refactor(rendering): shapes rendering rewrote

Author: danila-schelkov

system/bytestream.py

@@ -1,5 +1,5 @@
 import io
-from typing import Literal, Optional
+from typing import Literal
 
 
 class Reader(io.BytesIO):
@@ -68,7 +68,7 @@ def write_uint32(self, integer: int):
     def write_int32(self, integer: int):
         self.write_int(integer, 4, True)
 
-    def write_string(self, string: Optional["str"] = None):
+    def write_string(self, string: str | None = None):
         if string is None:
             self.write_byte(255)
             return

system/lib/__init__.py

@@ -195,9 +195,9 @@ def refill_menu():
         Menu.Item(
             name=locale.clear_directories,
             description=locale.clean_dirs_description,
-            handler=lambda: clear_directories()
-            if Console.question(locale.clear_qu)
-            else -1,
+            handler=lambda: (
+                clear_directories() if Console.question(locale.clear_qu) else -1
+            ),
         )
     )
     other.add(

system/lib/features/cut_sprites.py

@@ -67,9 +67,9 @@ def render_objects(swf: SupercellSWF, output_folder: Path):
             region = shape.regions[region_index]
 
             swf.xcod_writer.write_ubyte(region.texture_index)
-            swf.xcod_writer.write_ubyte(region.get_points_count())
+            swf.xcod_writer.write_ubyte(region.get_point_count())
 
-            for i in range(region.get_points_count()):
+            for i in range(region.get_point_count()):
                 swf.xcod_writer.write_uint16(int(region.get_u(i)))
                 swf.xcod_writer.write_uint16(int(region.get_v(i)))
             swf.xcod_writer.write_ubyte(1 if region.is_mirrored else 0)

system/lib/features/place_sprites.py

@@ -1,12 +1,11 @@
 import os
 from pathlib import Path
-from typing import List
 
-from PIL import Image, ImageDraw
+from PIL import Image
 
 from system.lib import Console
-from system.lib.helper import get_sides, get_size
-from system.lib.images import get_format_by_pixel_type
+from system.lib.images import create_filled_polygon_image, get_format_by_pixel_type
+from system.lib.math.polygon import get_rect
 from system.lib.xcod import FileInfo
 from system.localization import locale
 
@@ -15,7 +14,7 @@
 
 def place_sprites(
     file_info: FileInfo, folder: Path, overwrite: bool = False
-) -> List[Image.Image]:
+) -> list[Image.Image]:
     files_to_overwrite = os.listdir(folder / ("overwrite" if overwrite else ""))
     texture_files = os.listdir(folder / "textures")
 
@@ -40,46 +39,40 @@ def place_sprites(
         )
 
         for region_index, region_info in enumerate(shape_info.regions):
-            texture_size = (
-                sheets[region_info.texture_id].width,
-                sheets[region_info.texture_id].height,
-            )
+            texture_width = sheets[region_info.texture_id].width
+            texture_height = sheets[region_info.texture_id].height
 
             filename = f"shape_{shape_info.id}_{region_index}.png"
             if filename not in files_to_overwrite:
                 continue
 
-            img_mask = Image.new("L", texture_size, 0)
-            ImageDraw.Draw(img_mask).polygon(region_info.points, fill=MASK_COLOR)
-            bbox = img_mask.getbbox()
-
-            if not bbox:
-                min_x = min(i[0] for i in region_info.points)
-                min_y = min(i[1] for i in region_info.points)
-                max_x = max(i[0] for i in region_info.points)
-                max_y = max(i[1] for i in region_info.points)
+            rect = get_rect(region_info.points)
 
-                if max_y - min_y != 0:
-                    for _y in range(max_y - min_y):
-                        img_mask.putpixel((max_x - 1, min_y + _y - 1), MASK_COLOR)
+            img_mask = create_filled_polygon_image(
+                "L", texture_width, texture_height, region_info.points, MASK_COLOR
+            )
 
-                elif max_x - min_x != 0:
-                    for _x in range(max_x - min_x):
-                        img_mask.putpixel((min_x + _x - 1, max_y - 1), MASK_COLOR)
+            if rect.width + rect.height <= 2:
+                if rect.height != 0:
+                    for _y in range(int(rect.height)):
+                        img_mask.putpixel(
+                            (int(rect.right - 1), int(rect.top + _y - 1)), MASK_COLOR
+                        )
+                elif rect.width != 0:
+                    for _x in range(int(rect.width)):
+                        img_mask.putpixel(
+                            (int(rect.left + _x - 1), int(rect.bottom - 1)), MASK_COLOR
+                        )
                 else:
-                    img_mask.putpixel((max_x - 1, max_y - 1), MASK_COLOR)
-
-            left, top, right, bottom = get_sides(region_info.points)
-            if left == right:
-                right += 1
-            if top == bottom:
-                bottom += 1
-
-            width, height = get_size(left, top, right, bottom)
-            left = int(left)
-            top = int(top)
+                    img_mask.putpixel(
+                        (int(rect.right - 1), int(rect.bottom - 1)), MASK_COLOR
+                    )
 
-            bbox = int(left), int(top), int(right), int(bottom)
+            x = int(rect.left)
+            y = int(rect.top)
+            width = int(rect.width)
+            height = int(rect.height)
+            bbox = int(rect.left), int(rect.top), int(rect.right), int(rect.bottom)
 
             tmp_region = Image.open(
                 f'{folder}{"/overwrite" if overwrite else ""}/{filename}'
@@ -90,9 +83,9 @@ def place_sprites(
             tmp_region = tmp_region.resize((width, height), Image.Resampling.LANCZOS)
 
             sheets[region_info.texture_id].paste(
-                Image.new("RGBA", (width, height)), (left, top), img_mask.crop(bbox)
+                Image.new("RGBA", (width, height)), (x, y), img_mask.crop(bbox)
             )
-            sheets[region_info.texture_id].paste(tmp_region, (left, top), tmp_region)
+            sheets[region_info.texture_id].paste(tmp_region, (x, y), tmp_region)
     print()
 
     return sheets

system/lib/features/sc/__init__.py

@@ -1,6 +1,5 @@
 import struct
 from pathlib import Path
-from typing import List
 
 from loguru import logger
 from PIL import Image
@@ -16,7 +15,7 @@
 def compile_sc(
     output_folder: Path,
     file_info: FileInfo,
-    sheets: List[Image.Image],
+    sheets: list[Image.Image],
 ):
     sc = Writer()
 

system/lib/helper.py

@@ -1,10 +1,12 @@
 import math
 
 import PIL.PyAccess
-from PIL import Image
+from PIL import Image, ImageDraw
 
 from system.bytestream import Reader, Writer
 from system.lib.console import Console
+from system.lib.math.point import Point
+from system.lib.matrices import Matrix2x3
 from system.lib.pixel_utils import (
     get_channel_count_by_pixel_type,
     get_read_function,
@@ -17,7 +19,6 @@
 
 def load_image_from_buffer(img: Image.Image) -> None:
     width, height = img.size
-    # noinspection PyTypeChecker
     img_loaded: PIL.PyAccess.PyAccess = img.load()  # type: ignore
 
     with open("pixel_buffer", "rb") as pixel_buffer:
@@ -198,13 +199,13 @@ def transform_image(image, scale_x, scale_y, angle, x, y):
 
     return image.transform(
         (translated_w, translated_h),
-        Image.AFFINE,
+        Image.Transform.AFFINE,
         (a, b, c, d, e, f),
-        resample=Image.BILINEAR,
+        resample=Image.Resampling.BILINEAR,
     )
 
 
-def translate_image(image, x, y):
+def translate_image(image, x: float, y: float) -> Image.Image:
     w, h = image.size
 
     translated_w = int(math.ceil(w + math.fabs(x)))
@@ -216,23 +217,29 @@ def translate_image(image, x, y):
 
     return image.transform(
         (translated_w, translated_h),
-        Image.AFFINE,
+        Image.Transform.AFFINE,
         (1, 0, -x, 0, 1, -y),
-        resample=Image.BILINEAR,
+        resample=Image.Resampling.BILINEAR,
     )
 
 
-def transform_image_by_matrix(image, matrix: list or tuple):
-    scale_x, rotation_x, x = matrix[:3]
-    rotation_y, scale_y, y = matrix[3:]
-    return transform_image(
-        image, scale_x, scale_y, math.atan2(rotation_x, rotation_y), x, y
+def transform_image_by_matrix(image: Image.Image, matrix: Matrix2x3):
+    new_width = matrix.apply_x(image.width, image.height)
+    new_height = matrix.apply_y(image.width, image.height)
+
+    return image.transform(
+        (new_width, new_height),
+        Image.Transform.AFFINE,
+        (matrix.a, matrix.b, matrix.x, matrix.c, matrix.d, matrix.y),
+        resample=Image.Resampling.BILINEAR,
     )
 
 
-if __name__ == "__main__":
-    transform_image_by_matrix(
-        Image.open("../../test_0.png"),
-        [1.0458984375, 0.0, -127.65, 0.0, 1.0458984375, -700.0],
-    ).show()
-    input()
+def create_filled_polygon_image(
+    mode: str, width: int, height: int, polygon: list[Point], color: int
+) -> Image.Image:
+    mask_image = Image.new(mode, (width, height), 0)
+    drawable_image = ImageDraw.Draw(mask_image)
+    drawable_image.polygon([point.as_tuple() for point in polygon], fill=color)
+
+    return mask_image

system/lib/images.py

@@ -1,6 +1,3 @@
-from typing import Tuple
-
-
 class Point:
     def __init__(self, x: float = 0, y: float = 0):
         self.x: float = x
@@ -26,13 +23,7 @@ def __neg__(self):
         return self
 
     def __repr__(self):
-        return str(self.position)
+        return str(self.as_tuple())
 
-    @property
-    def position(self) -> Tuple[float, float]:
+    def as_tuple(self) -> tuple[float, float]:
         return self.x, self.y
-
-    @position.setter
-    def position(self, value: Tuple[float, float]):
-        self.x = value[0]
-        self.y = value[1]

system/lib/math/__init__.py

@@ -0,0 +1,76 @@
+from math import atan2, degrees
+from typing import TypeAlias
+
+from system.lib.math.point import Point
+from system.lib.math.rect import Rect
+
+Polygon: TypeAlias = list[Point]
+
+
+def is_clockwise(polygon: Polygon) -> bool:
+    """Returns true if polygon points order is clockwise, otherwise false.
+
+    :param polygon:
+    :return:
+    """
+    points_sum = 0
+    for i in range(len(polygon)):
+        p1 = polygon[i]
+        p2 = polygon[(i + 1) % len(polygon)]
+
+        points_sum += (p2.x - p1.x) * (p1.y + p2.y)
+    return points_sum > 0
+
+
+def compare_polygons(
+    polygon1: Polygon,
+    polygon2: Polygon,
+    round_to_nearest: bool = False,
+) -> tuple[int, bool]:
+    """Calculates rotation and if polygon is mirrored.
+
+    :param polygon1: shape polygon
+    :param polygon2: sheet polygon
+    :param round_to_nearest: should round to a multiple of 90
+    :return: rotation degrees, is polygon mirrored
+    """
+
+    is_uv_clockwise = is_clockwise(polygon2)
+    is_xy_clockwise = is_clockwise(polygon1)
+
+    mirroring = not (is_uv_clockwise == is_xy_clockwise)
+
+    dx = polygon1[1].x - polygon1[0].x
+    dy = polygon1[1].y - polygon1[0].y
+    du = polygon2[1].x - polygon2[0].x
+    dv = polygon2[1].y - polygon2[0].y
+
+    angle_xy = degrees(atan2(dy, dx)) % 360
+    angle_uv = degrees(atan2(dv, du)) % 360
+
+    angle = angle_xy - angle_uv
+
+    if mirroring:
+        angle -= 180
+
+    angle = (angle + 360) % 360
+
+    if round_to_nearest:
+        angle = round(angle / 90) * 90
+
+    return int(angle), mirroring
+
+
+def get_rect(polygon: list[Point]) -> Rect:
+    """Calculates polygon bounds and returns rect.
+
+    :param polygon: polygon points
+    :return: Rect object
+    """
+
+    rect = Rect(left=100000, top=100000, right=-100000, bottom=-100000)
+
+    for point in polygon:
+        rect.add_point(point.x, point.y)
+
+    return rect