maps4fs 0.9.8__py3-none-any.whl → 1.1.0__py3-none-any.whl

maps4fs/generator/component.py

@@ -7,8 +7,11 @@ import os
 from copy import deepcopy
 from typing import TYPE_CHECKING, Any
 
+import cv2
 import osmnx as ox  # type: ignore
 from pyproj import Transformer
+from shapely.affinity import rotate, translate  # type: ignore
+from shapely.geometry import Polygon, box  # type: ignore
 
 from maps4fs.generator.qgis import save_scripts
 
@@ -16,15 +19,16 @@ if TYPE_CHECKING:
     from maps4fs.generator.game import Game
 
 
-# pylint: disable=R0801, R0903, R0902
+# pylint: disable=R0801, R0903, R0902, R0904
 class Component:
     """Base class for all map generation components.
 
-    Args:
+    Arguments:
         game (Game): The game instance for which the map is generated.
         coordinates (tuple[float, float]): The latitude and longitude of the center of the map.
-        map_height (int): The height of the map in pixels.
-        map_width (int): The width of the map in pixels.
+        map_size (int): The size of the map in pixels.
+        map_rotated_size (int): The size of the map in pixels after rotation.
+        rotation (int): The rotation angle of the map.
         map_directory (str): The directory where the map files are stored.
         logger (Any, optional): The logger to use. Must have at least three basic methods: debug,
             info, warning. If not provided, default logging will be used.
@@ -34,22 +38,25 @@ class Component:
         self,
         game: Game,
         coordinates: tuple[float, float],
-        map_height: int,
-        map_width: int,
+        map_size: int,
+        map_rotated_size: int,
+        rotation: int,
         map_directory: str,
         logger: Any = None,
         **kwargs,  # pylint: disable=W0613, R0913, R0917
     ):
         self.game = game
         self.coordinates = coordinates
-        self.map_height = map_height
-        self.map_width = map_width
+        self.map_size = map_size
+        self.map_rotated_size = map_rotated_size
+        self.rotation = rotation
         self.map_directory = map_directory
         self.logger = logger
         self.kwargs = kwargs
 
         os.makedirs(self.previews_directory, exist_ok=True)
         os.makedirs(self.scripts_directory, exist_ok=True)
+        os.makedirs(self.info_layers_directory, exist_ok=True)
 
         self.save_bbox()
         self.preprocess()
@@ -87,6 +94,15 @@ class Component:
         """
         return os.path.join(self.map_directory, "previews")
 
+    @property
+    def info_layers_directory(self) -> str:
+        """The directory where the info layers are stored.
+
+        Returns:
+            str: The directory where the info layers are stored.
+        """
+        return os.path.join(self.map_directory, "info_layers")
+
     @property
     def scripts_directory(self) -> str:
         """The directory where the scripts are stored.
@@ -123,7 +139,7 @@ class Component:
         """Updates the generation info with the provided data.
         If the generation info file does not exist, it will be created.
 
-        Args:
+        Arguments:
             data (dict[Any, Any]): The data to update the generation info with.
         """
         if os.path.isfile(self.generation_info_path):
@@ -150,45 +166,37 @@ class Component:
     def get_bbox(
         self,
         coordinates: tuple[float, float] | None = None,
-        height_distance: int | None = None,
-        width_distance: int | None = None,
+        distance: int | None = None,
         project_utm: bool = False,
     ) -> tuple[int, int, int, int]:
         """Calculates the bounding box of the map from the coordinates and the height and
         width of the map.
         If coordinates and distance are not provided, the instance variables are used.
 
-        Args:
-            coordinates (tuple[float, float], optional): The latitude and longitude of the center of
-                the map. Defaults to None.
-            height_distance (int, optional): The distance from the center of the map to the edge of
-                the map in the north-south direction. Defaults to None.
-            width_distance (int, optional): The distance from the center of the map to the edge of
-                the map in the east-west direction. Defaults to None.
+        Arguments:
+            coordinates (tuple[float, float], optional): The latitude and longitude of the center
+                of the map. Defaults to None.
+            distance (int, optional): The distance from the center of the map to the edge of the
+                map in all directions. Defaults to None.
             project_utm (bool, optional): Whether to project the bounding box to UTM.
 
         Returns:
             tuple[int, int, int, int]: The bounding box of the map.
         """
         coordinates = coordinates or self.coordinates
-        height_distance = height_distance or int(self.map_height / 2)
-        width_distance = width_distance or int(self.map_width / 2)
+        distance = distance or int(self.map_rotated_size / 2)
 
-        north, south, _, _ = ox.utils_geo.bbox_from_point(
-            coordinates, dist=height_distance, project_utm=project_utm
-        )
-        _, _, east, west = ox.utils_geo.bbox_from_point(
-            coordinates, dist=width_distance, project_utm=project_utm
+        west, south, east, north = ox.utils_geo.bbox_from_point(  # type: ignore
+            coordinates, dist=distance, project_utm=project_utm
         )
+
         bbox = north, south, east, west
         self.logger.debug(
-            "Calculated bounding box for component: %s: %s, project_utm: %s, "
-            "height_distance: %s, width_distance: %s",
+            "Calculated bounding box for component: %s: %s, project_utm: %s, distance: %s",
             self.__class__.__name__,
             bbox,
             project_utm,
-            height_distance,
-            width_distance,
+            distance,
         )
         return bbox
 
@@ -219,7 +227,7 @@ class Component:
         """Converts the bounding box to EPSG:3857.
         If the bounding box is not provided, the instance variable is used.
 
-        Args:
+        Arguments:
             bbox (tuple[float, float, float, float], optional): The bounding box to convert.
             add_margin (bool, optional): Whether to add a margin to the bounding box.
 
@@ -247,7 +255,7 @@ class Component:
         """Converts the bounding box to EPSG:3857 string.
         If the bounding box is not provided, the instance variable is used.
 
-        Args:
+        Arguments:
             bbox (tuple[float, float, float, float], optional): The bounding box to convert.
             add_margin (bool, optional): Whether to add a margin to the bounding box.
 
@@ -265,9 +273,184 @@ class Component:
         bounding box coordinates in EPSG:3857.
         For filenames, the class name is used as a prefix.
 
-        Args:
+        Arguments:
             qgis_layers (list[tuple[str, float, float, float, float]]): The list of layers to
                 create scripts for.
         """
         class_name = self.__class__.__name__.lower()
         save_scripts(qgis_layers, class_name, self.scripts_directory)
+
+    def get_polygon_center(self, polygon_points: list[tuple[int, int]]) -> tuple[int, int]:
+        """Calculates the center of a polygon defined by a list of points.
+
+        Arguments:
+            polygon_points (list[tuple[int, int]]): The points of the polygon.
+
+        Returns:
+            tuple[int, int]: The center of the polygon.
+        """
+        polygon = Polygon(polygon_points)
+        center = polygon.centroid
+        return int(center.x), int(center.y)
+
+    def absolute_to_relative(
+        self, point: tuple[int, int], center: tuple[int, int]
+    ) -> tuple[int, int]:
+        """Converts a pair of absolute coordinates to relative coordinates.
+
+        Arguments:
+            point (tuple[int, int]): The absolute coordinates.
+            center (tuple[int, int]): The center coordinates.
+
+        Returns:
+            tuple[int, int]: The relative coordinates.
+        """
+        cx, cy = center
+        x, y = point
+        return x - cx, y - cy
+
+    def top_left_coordinates_to_center(self, top_left: tuple[int, int]) -> tuple[int, int]:
+        """Converts a pair of coordinates from the top-left system to the center system.
+        In top-left system, the origin (0, 0) is in the top-left corner of the map, while in the
+        center system, the origin is in the center of the map.
+
+        Arguments:
+            top_left (tuple[int, int]): The coordinates in the top-left system.
+
+        Returns:
+            tuple[int, int]: The coordinates in the center system.
+        """
+        x, y = top_left
+        cs_x = x - self.map_size // 2
+        cs_y = y - self.map_size // 2
+
+        return cs_x, cs_y
+
+    def fit_polygon_into_bounds(
+        self, polygon_points: list[tuple[int, int]], margin: int = 0, angle: int = 0
+    ) -> list[tuple[int, int]]:
+        """Fits a polygon into the bounds of the map.
+
+        Arguments:
+            polygon_points (list[tuple[int, int]]): The points of the polygon.
+            margin (int, optional): The margin to add to the polygon. Defaults to 0.
+            angle (int, optional): The angle to rotate the polygon by. Defaults to 0.
+
+        Returns:
+            list[tuple[int, int]]: The points of the polygon fitted into the map bounds.
+        """
+        min_x = min_y = 0
+        max_x = max_y = self.map_size
+
+        polygon = Polygon(polygon_points)
+
+        if angle:
+            center_x = center_y = self.map_rotated_size // 2
+            self.logger.debug(
+                "Rotating the polygon by %s degrees with center at %sx%s",
+                angle,
+                center_x,
+                center_y,
+            )
+            polygon = rotate(polygon, -angle, origin=(center_x, center_y))
+            offset = (self.map_size / 2) - (self.map_rotated_size / 2)
+            self.logger.debug("Translating the polygon by %s", offset)
+            polygon = translate(polygon, xoff=offset, yoff=offset)
+
+        if margin:
+            polygon = polygon.buffer(margin, join_style="mitre")
+            if polygon.is_empty:
+                raise ValueError("The polygon is empty after adding the margin.")
+
+        # Create a bounding box for the map bounds
+        bounds = box(min_x, min_y, max_x, max_y)
+
+        # Intersect the polygon with the bounds to fit it within the map
+        fitted_polygon = polygon.intersection(bounds)
+
+        if not isinstance(fitted_polygon, Polygon):
+            raise ValueError("The fitted polygon is not a valid polygon.")
+
+        # Return the fitted polygon points
+        return list(fitted_polygon.exterior.coords)
+
+    def get_infolayer_path(self, layer_name: str) -> str | None:
+        """Returns the path to the info layer file.
+
+        Arguments:
+            layer_name (str): The name of the layer.
+
+        Returns:
+            str | None: The path to the info layer file or None if the layer does not exist.
+        """
+        info_layer_path = os.path.join(self.info_layers_directory, f"{layer_name}.json")
+        if not os.path.isfile(info_layer_path):
+            self.logger.warning("Info layer %s does not exist", info_layer_path)
+            return None
+        return info_layer_path
+
+    # pylint: disable=R0913, R0917, R0914
+    def rotate_image(
+        self,
+        image_path: str,
+        angle: int,
+        output_height: int,
+        output_width: int,
+        output_path: str | None = None,
+    ) -> None:
+        """Rotates an image by a given angle around its center and cuts out the center to match
+        the output size.
+
+        Arguments:
+            image_path (str): The path to the image to rotate.
+            angle (int): The angle to rotate the image by.
+            output_height (int): The height of the output image.
+            output_width (int): The width of the output image.
+        """
+        if not os.path.isfile(image_path):
+            self.logger.warning("Image %s does not exist", image_path)
+            return
+
+        # pylint: disable=no-member
+        image = cv2.imread(image_path, cv2.IMREAD_UNCHANGED)
+        if image is None:
+            self.logger.warning("Image %s could not be read", image_path)
+            return
+
+        self.logger.debug("Read image from %s with shape: %s", image_path, image.shape)
+
+        if not output_path:
+            output_path = image_path
+
+        height, width = image.shape[:2]
+        center = (width // 2, height // 2)
+
+        self.logger.debug(
+            "Rotating the image... Angle: %s, center: %s, height: %s, width: %s",
+            angle,
+            center,
+            height,
+            width,
+        )
+
+        rotation_matrix = cv2.getRotationMatrix2D(center, angle, 1.0)
+        rotated = cv2.warpAffine(image, rotation_matrix, (width, height))
+
+        start_x = center[0] - output_width // 2
+        start_y = center[1] - output_height // 2
+        end_x = start_x + output_width
+        end_y = start_y + output_height
+
+        self.logger.debug(
+            "Cropping the rotated image: start_x: %s, start_y: %s, end_x: %s, end_y: %s",
+            start_x,
+            start_y,
+            end_x,
+            end_y,
+        )
+
+        cropped = rotated[start_y:end_y, start_x:end_x]
+
+        self.logger.debug("Shape of the cropped image: %s", cropped.shape)
+
+        cv2.imwrite(output_path, cropped)

maps4fs/generator/config.py

@@ -12,10 +12,12 @@ from maps4fs.generator.component import Component
 class Config(Component):
     """Component for map settings and configuration.
 
-    Args:
+    Arguments:
+        game (Game): The game instance for which the map is generated.
         coordinates (tuple[float, float]): The latitude and longitude of the center of the map.
-        map_height (int): The height of the map in pixels.
-        map_width (int): The width of the map in pixels.
+        map_size (int): The size of the map in pixels (it's a square).
+        map_rotated_size (int): The size of the map in pixels after rotation.
+        rotation (int): The rotation angle of the map.
         map_directory (str): The directory where the map files are stored.
         logger (Any, optional): The logger to use. Must have at least three basic methods: debug,
             info, warning. If not provided, default logging will be used.
@@ -36,13 +38,15 @@ class Config(Component):
             self.logger.warning("Map XML file not found: %s.", self._map_xml_path)
             return
         tree = ET.parse(self._map_xml_path)
-        self.logger.debug("Map XML file loaded from: %s.", self._map_xml_path)
+        self.logger.info("Map XML file loaded from: %s.", self._map_xml_path)
         root = tree.getroot()
         for map_elem in root.iter("map"):
-            map_elem.set("width", str(self.map_width))
-            map_elem.set("height", str(self.map_height))
+            map_elem.set("width", str(self.map_size))
+            map_elem.set("height", str(self.map_size))
             self.logger.debug(
-                "Map size set to %sx%s in Map XML file.", self.map_width, self.map_height
+                "Map size set to %sx%s in Map XML file.",
+                self.map_size,
+                self.map_size,
             )
         tree.write(self._map_xml_path)
         self.logger.debug("Map XML file saved to: %s.", self._map_xml_path)
@@ -67,7 +71,7 @@ class Config(Component):
         # if the map is 2048x2048 or 4096x4096, the overview will be 4096x4096
         # and the map will be in the center of the overview.
         # That's why the distance is set to the map height not as a half of it.
-        bbox = self.get_bbox(height_distance=self.map_height, width_distance=self.map_width)
+        bbox = self.get_bbox(distance=self.map_size)
         south, west, north, east = bbox
         epsg3857_string = self.get_epsg3857_string(bbox=bbox)
         epsg3857_string_with_margin = self.get_epsg3857_string(bbox=bbox, add_margin=True)
@@ -81,8 +85,8 @@ class Config(Component):
             "west": west,
             "north": north,
             "east": east,
-            "height": self.map_height * 2,
-            "width": self.map_width * 2,
+            "height": self.map_size * 2,
+            "width": self.map_size * 2,
         }
 
         data = {
@@ -93,7 +97,7 @@ class Config(Component):
 
     def qgis_sequence(self) -> None:
         """Generates QGIS scripts for creating bounding box layers and rasterizing them."""
-        bbox = self.get_bbox(height_distance=self.map_height, width_distance=self.map_width)
+        bbox = self.get_bbox(distance=self.map_size)
         espg3857_bbox = self.get_espg3857_bbox(bbox=bbox)
         espg3857_bbox_with_margin = self.get_espg3857_bbox(bbox=bbox, add_margin=True)