maps4fs 0.9.93__py3-none-any.whl → 1.1.6__py3-none-any.whl

maps4fs/generator/texture.py

@@ -4,7 +4,8 @@ from __future__ import annotations
 
 import json
 import os
-import warnings
+import re
+from collections import defaultdict
 from typing import Any, Callable, Generator, Optional
 
 import cv2
@@ -36,11 +37,14 @@ class Texture(Component):
         """Class which represents a layer with textures and tags.
         It's using to obtain data from OSM using tags and make changes into corresponding textures.
 
-        Args:
+        Arguments:
             name (str): Name of the layer.
             tags (dict[str, str | list[str]]): Dictionary of tags to search for.
             width (int | None): Width of the polygon in meters (only for LineString).
             color (tuple[int, int, int]): Color of the layer in BGR format.
+            exclude_weight (bool): Flag to exclude weight from the texture.
+            priority (int | None): Priority of the layer.
+            info_layer (str | None): Name of the corresnponding info layer.
 
         Attributes:
             name (str): Name of the layer.
@@ -58,6 +62,7 @@ class Texture(Component):
             color: tuple[int, int, int] | list[int] | None = None,
             exclude_weight: bool = False,
             priority: int | None = None,
+            info_layer: str | None = None,
         ):
             self.name = name
             self.count = count
@@ -66,6 +71,7 @@ class Texture(Component):
             self.color = color if color else (255, 255, 255)
             self.exclude_weight = exclude_weight
             self.priority = priority
+            self.info_layer = info_layer
 
         def to_json(self) -> dict[str, str | list[str] | bool]:  # type: ignore
             """Returns dictionary with layer data.
@@ -80,6 +86,7 @@ class Texture(Component):
                 "color": list(self.color),
                 "exclude_weight": self.exclude_weight,
                 "priority": self.priority,
+                "info_layer": self.info_layer,
             }
 
             data = {k: v for k, v in data.items() if v is not None}
@@ -89,7 +96,7 @@ class Texture(Component):
         def from_json(cls, data: dict[str, str | list[str] | bool]) -> Texture.Layer:
             """Creates a new instance of the class from dictionary.
 
-            Args:
+            Arguments:
                 data (dict[str, str | list[str] | bool]): Dictionary with layer data.
 
             Returns:
@@ -110,7 +117,64 @@ class Texture(Component):
             weight_postfix = "_weight" if not self.exclude_weight else ""
             return os.path.join(weights_directory, f"{self.name}{idx}{weight_postfix}.png")
 
+        def path_preview(self, previews_directory: str) -> str:
+            """Returns path to the preview of the first texture of the layer.
+
+            Arguments:
+                previews_directory (str): Path to the directory with previews.
+
+            Returns:
+                str: Path to the preview.
+            """
+            return self.path(previews_directory).replace(".png", "_preview.png")
+
+        def get_preview_or_path(self, previews_directory: str) -> str:
+            """Returns path to the preview of the first texture of the layer if it exists,
+            otherwise returns path to the texture.
+
+            Arguments:
+                previews_directory (str): Path to the directory with previews.
+
+            Returns:
+                str: Path to the preview or texture.
+            """
+            preview_path = self.path_preview(previews_directory)
+            return preview_path if os.path.isfile(preview_path) else self.path(previews_directory)
+
+        def paths(self, weights_directory: str) -> list[str]:
+            """Returns a list of paths to the textures of the layer.
+            NOTE: Works only after the textures are generated, since it just lists the directory.
+
+            Arguments:
+                weights_directory (str): Path to the directory with weights.
+
+            Returns:
+                list[str]: List of paths to the textures.
+            """
+            weight_files = os.listdir(weights_directory)
+
+            # Inconsistent names are the name of textures that are not following the pattern
+            # of texture_name{idx}_weight.png.
+            inconsistent_names = ["forestRockRoot", "waterPuddle"]
+
+            if self.name in inconsistent_names:
+                return [
+                    os.path.join(weights_directory, weight_file)
+                    for weight_file in weight_files
+                    if weight_file.startswith(self.name)
+                ]
+
+            return [
+                os.path.join(weights_directory, weight_file)
+                for weight_file in weight_files
+                if re.match(rf"{self.name}\d{{2}}_weight.png", weight_file)
+            ]
+
     def preprocess(self) -> None:
+        self.light_version = self.kwargs.get("light_version", False)
+        self.fields_padding = self.kwargs.get("fields_padding", 0)
+        self.logger.debug("Light version: %s.", self.light_version)
+
         if not os.path.isfile(self.game.texture_schema):
             raise FileNotFoundError(f"Texture layers schema not found: {self.game.texture_schema}")
 
@@ -134,6 +198,9 @@ class Texture(Component):
         self.info_save_path = os.path.join(self.map_directory, "generation_info.json")
         self.logger.debug("Generation info save path: %s.", self.info_save_path)
 
+        self.info_layer_path = os.path.join(self.info_layers_directory, "textures.json")
+        self.logger.debug("Info layer path: %s.", self.info_layer_path)
+
     def get_base_layer(self) -> Layer | None:
         """Returns base layer.
 
@@ -149,6 +216,31 @@ class Texture(Component):
         self._prepare_weights()
         self._read_parameters()
         self.draw()
+        self.rotate_textures()
+
+    def rotate_textures(self) -> None:
+        """Rotates textures of the layers which have tags."""
+        if self.rotation:
+            # Iterate over the layers which have tags and rotate them.
+            for layer in self.layers:
+                if layer.tags:
+                    self.logger.debug("Rotating layer %s.", layer.name)
+                    layer_paths = layer.paths(self._weights_dir)
+                    layer_paths += [layer.path_preview(self._weights_dir)]
+                    for layer_path in layer_paths:
+                        if os.path.isfile(layer_path):
+                            self.rotate_image(
+                                layer_path,
+                                self.rotation,
+                                output_height=self.map_size,
+                                output_width=self.map_size,
+                            )
+                        else:
+                            self.logger.warning("Layer path %s not found.", layer_path)
+                else:
+                    self.logger.debug(
+                        "Skipping rotation of layer %s because it has no tags.", layer.name
+                    )
 
     # pylint: disable=W0201
     def _read_parameters(self) -> None:
@@ -186,16 +278,16 @@ class Texture(Component):
 
         for layer in self.layers:
             self._generate_weights(layer)
-        self.logger.debug("Prepared weights for %s layers.", len(self.layers))
+        self.logger.info("Prepared weights for %s layers.", len(self.layers))
 
     def _generate_weights(self, layer: Layer) -> None:
         """Generates weight files for textures. Each file is a numpy array of zeros and
             dtype uint8 (0-255).
 
-        Args:
+        Arguments:
             layer (Layer): Layer with textures and tags.
         """
-        size = (self.map_height, self.map_width)
+        size = (self.map_rotated_size, self.map_rotated_size)
         postfix = "_weight.png" if not layer.exclude_weight else ".png"
         if layer.count == 0:
             filepaths = [os.path.join(self._weights_dir, layer.name + postfix)]
@@ -222,7 +314,7 @@ class Texture(Component):
     def layers(self, layers: list[Layer]) -> None:
         """Sets list of layers with textures and tags.
 
-        Args:
+        Arguments:
             layers (list[Layer]): List of layers.
         """
         self._layers = layers
@@ -253,6 +345,10 @@ class Texture(Component):
 
         cumulative_image = None
 
+        # Dictionary to store info layer data.
+        # Key is a layer.info_layer, value is a list of polygon points as tuples (x, y).
+        info_layer_data = defaultdict(list)
+
         for layer in layers:
             if not layer.tags:
                 self.logger.debug("Layer %s has no tags, there's nothing to draw.", layer.name)
@@ -273,6 +369,8 @@ class Texture(Component):
             mask = cv2.bitwise_not(cumulative_image)
 
             for polygon in self.polygons(layer.tags, layer.width):  # type: ignore
+                if layer.info_layer:
+                    info_layer_data[layer.info_layer].append(self.np_to_polygon_points(polygon))
                 cv2.fillPoly(layer_image, [polygon], color=255)  # type: ignore
 
             output_image = cv2.bitwise_and(layer_image, mask)
@@ -280,16 +378,76 @@ class Texture(Component):
             cumulative_image = cv2.bitwise_or(cumulative_image, output_image)
 
             cv2.imwrite(layer_path, output_image)
-            self.logger.debug("Texture %s saved.", layer_path)
+            self.logger.info("Texture %s saved.", layer_path)
+
+        # Save info layer data.
+        with open(self.info_layer_path, "w", encoding="utf-8") as f:
+            json.dump(info_layer_data, f, ensure_ascii=False, indent=4)
 
         if cumulative_image is not None:
             self.draw_base_layer(cumulative_image)
 
+        if not self.light_version:
+            self.dissolve()
+        else:
+            self.logger.debug("Skipping dissolve in light version of the map.")
+
+    def dissolve(self) -> None:
+        """Dissolves textures of the layers with tags into sublayers for them to look more
+        natural in the game.
+        Iterates over all layers with tags and reads the first texture, checks if the file
+        contains any non-zero values (255), splits those non-values between different weight
+        files of the corresponding layer and saves the changes to the files.
+        """
+        for layer in self.layers:
+            if not layer.tags:
+                self.logger.debug("Layer %s has no tags, there's nothing to dissolve.", layer.name)
+                continue
+            layer_path = layer.path(self._weights_dir)
+            layer_paths = layer.paths(self._weights_dir)
+
+            if len(layer_paths) < 2:
+                self.logger.debug("Layer %s has only one texture, skipping.", layer.name)
+                continue
+
+            self.logger.debug("Dissolving layer from %s to %s.", layer_path, layer_paths)
+
+            # Check if the image contains any non-zero values, otherwise continue.
+            layer_image = cv2.imread(layer_path, cv2.IMREAD_UNCHANGED)
+
+            if not np.any(layer_image):
+                self.logger.debug(
+                    "Layer %s does not contain any non-zero values, skipping.", layer.name
+                )
+                continue
+
+            # Save the original image to use it for preview later, without combining the sublayers.
+            cv2.imwrite(layer.path_preview(self._weights_dir), layer_image.copy())
+
+            # Get the coordinates of non-zero values.
+            non_zero_coords = np.column_stack(np.where(layer_image > 0))
+
+            # Prepare sublayers.
+            sublayers = [np.zeros_like(layer_image) for _ in range(layer.count)]
+
+            # Randomly assign non-zero values to sublayers.
+            for coord in non_zero_coords:
+                sublayers[np.random.randint(0, layer.count)][coord[0], coord[1]] = 255
+
+            # Save the sublayers.
+            for sublayer, sublayer_path in zip(sublayers, layer_paths):
+                cv2.imwrite(sublayer_path, sublayer)
+                self.logger.debug("Sublayer %s saved.", sublayer_path)
+
+            self.logger.info("Dissolved layer %s.", layer.name)
+
+        self.logger.info("Dissolving finished.")
+
     def draw_base_layer(self, cumulative_image: np.ndarray) -> None:
         """Draws base layer and saves it into the png file.
         Base layer is the last layer to be drawn, it fills the remaining area of the map.
 
-        Args:
+        Arguments:
             cumulative_image (np.ndarray): Cumulative image with all layers.
         """
         base_layer = self.get_base_layer()
@@ -298,37 +456,50 @@ class Texture(Component):
             self.logger.debug("Drawing base layer %s.", layer_path)
             img = cv2.bitwise_not(cumulative_image)
             cv2.imwrite(layer_path, img)
-            self.logger.debug("Base texture %s saved.", layer_path)
+            self.logger.info("Base texture %s saved.", layer_path)
 
     def get_relative_x(self, x: float) -> int:
         """Converts UTM X coordinate to relative X coordinate in map image.
 
-        Args:
+        Arguments:
             x (float): UTM X coordinate.
 
         Returns:
             int: Relative X coordinate in map image.
         """
-        return int(self.map_width * (x - self.minimum_x) / (self.maximum_x - self.minimum_x))
+        return int(self.map_rotated_size * (x - self.minimum_x) / (self.maximum_x - self.minimum_x))
 
     def get_relative_y(self, y: float) -> int:
         """Converts UTM Y coordinate to relative Y coordinate in map image.
 
-        Args:
+        Arguments:
             y (float): UTM Y coordinate.
 
         Returns:
             int: Relative Y coordinate in map image.
         """
-        return int(self.map_height * (1 - (y - self.minimum_y) / (self.maximum_y - self.minimum_y)))
+        return int(
+            self.map_rotated_size * (1 - (y - self.minimum_y) / (self.maximum_y - self.minimum_y))
+        )
+
+    def np_to_polygon_points(self, np_array: np.ndarray) -> list[tuple[int, int]]:
+        """Converts numpy array of polygon points to list of tuples.
+
+        Arguments:
+            np_array (np.ndarray): Numpy array of polygon points.
+
+        Returns:
+            list[tuple[int, int]]: List of tuples.
+        """
+        return [(int(x), int(y)) for x, y in np_array.reshape(-1, 2)]
 
     # pylint: disable=W0613
     def _to_np(self, geometry: shapely.geometry.polygon.Polygon, *args) -> np.ndarray:
         """Converts Polygon geometry to numpy array of polygon points.
 
-        Args:
+        Arguments:
             geometry (shapely.geometry.polygon.Polygon): Polygon geometry.
-            *args: Additional arguments:
+            *Arguments: Additional arguments:
                 - width (int | None): Width of the polygon in meters.
 
         Returns:
@@ -340,15 +511,17 @@ class Texture(Component):
         pairs = list(zip(xs, ys))
         return np.array(pairs, dtype=np.int32).reshape((-1, 1, 2))
 
-    def _to_polygon(self, obj: pd.core.series.Series, width: int | None) -> np.ndarray | None:
+    def _to_polygon(
+        self, obj: pd.core.series.Series, width: int | None
+    ) -> shapely.geometry.polygon.Polygon:
         """Converts OSM object to numpy array of polygon points.
 
-        Args:
+        Arguments:
             obj (pd.core.series.Series): OSM object.
             width (int | None): Width of the polygon in meters.
 
         Returns:
-            np.ndarray | None: Numpy array of polygon points.
+            shapely.geometry.polygon.Polygon: Polygon geometry.
         """
         geometry = obj["geometry"]
         geometry_type = geometry.geom_type
@@ -362,32 +535,45 @@ class Texture(Component):
         self,
         geometry: shapely.geometry.linestring.LineString | shapely.geometry.point.Point,
         width: int | None,
-    ) -> np.ndarray:
+    ) -> shapely.geometry.polygon.Polygon:
         """Converts LineString or Point geometry to numpy array of polygon points.
 
-        Args:
+        Arguments:
             geometry (shapely.geometry.linestring.LineString | shapely.geometry.point.Point):
                 LineString or Point geometry.
             width (int | None): Width of the polygon in meters.
 
         Returns:
-            np.ndarray: Numpy array of polygon points.
+            shapely.geometry.polygon.Polygon: Polygon geometry.
         """
         polygon = geometry.buffer(width)
-        return self._to_np(polygon)
+        return polygon
+
+    def _skip(
+        self, geometry: shapely.geometry.polygon.Polygon, *args, **kwargs
+    ) -> shapely.geometry.polygon.Polygon:
+        """Returns the same geometry.
+
+        Arguments:
+            geometry (shapely.geometry.polygon.Polygon): Polygon geometry.
+
+        Returns:
+            shapely.geometry.polygon.Polygon: Polygon geometry.
+        """
+        return geometry
 
     def _converters(
         self, geom_type: str
     ) -> Optional[Callable[[BaseGeometry, Optional[int]], np.ndarray]]:
         """Returns a converter function for a given geometry type.
 
-        Args:
+        Arguments:
             geom_type (str): Geometry type.
 
         Returns:
             Callable[[shapely.geometry, int | None], np.ndarray]: Converter function.
         """
-        converters = {"Polygon": self._to_np, "LineString": self._sequence, "Point": self._sequence}
+        converters = {"Polygon": self._skip, "LineString": self._sequence, "Point": self._sequence}
         return converters.get(geom_type)  # type: ignore
 
     def polygons(
@@ -395,29 +581,38 @@ class Texture(Component):
     ) -> Generator[np.ndarray, None, None]:
         """Generator which yields numpy arrays of polygons from OSM data.
 
-        Args:
+        Arguments:
             tags (dict[str, str | list[str]]): Dictionary of tags to search for.
             width (int | None): Width of the polygon in meters (only for LineString).
 
         Yields:
             Generator[np.ndarray, None, None]: Numpy array of polygon points.
         """
+        is_fieds = "farmland" in tags.values()
         try:
-            with warnings.catch_warnings():
-                warnings.simplefilter("ignore", DeprecationWarning)
-                objects = ox.features_from_bbox(bbox=self.bbox, tags=tags)
+            objects = ox.features_from_bbox(bbox=self.new_bbox, tags=tags)
         except Exception as e:  # pylint: disable=W0718
             self.logger.warning("Error fetching objects for tags: %s.", tags)
             self.logger.warning(e)
             return
-        objects_utm = ox.project_gdf(objects, to_latlong=False)
+        objects_utm = ox.projection.project_gdf(objects, to_latlong=False)
         self.logger.debug("Fetched %s elements for tags: %s.", len(objects_utm), tags)
 
         for _, obj in objects_utm.iterrows():
             polygon = self._to_polygon(obj, width)
             if polygon is None:
                 continue
-            yield polygon
+
+            if is_fieds and self.fields_padding > 0:
+                padded_polygon = polygon.buffer(-self.fields_padding)
+
+                if not isinstance(padded_polygon, shapely.geometry.polygon.Polygon):
+                    self.logger.warning("The padding value is too high, field will not padded.")
+                else:
+                    polygon = padded_polygon
+
+            polygon_np = self._to_np(polygon)
+            yield polygon_np
 
     def previews(self) -> list[str]:
         """Invokes methods to generate previews. Returns list of paths to previews.
@@ -436,13 +631,11 @@ class Texture(Component):
         Returns:
             str: Path to the preview.
         """
-        scaling_factor = min(
-            PREVIEW_MAXIMUM_SIZE / self.map_width, PREVIEW_MAXIMUM_SIZE / self.map_height
-        )
+        scaling_factor = PREVIEW_MAXIMUM_SIZE / self.map_size
 
         preview_size = (
-            int(self.map_width * scaling_factor),
-            int(self.map_height * scaling_factor),
+            int(self.map_size * scaling_factor),
+            int(self.map_size * scaling_factor),
         )
         self.logger.debug(
             "Scaling factor: %s. Preview size: %s.",
@@ -455,7 +648,8 @@ class Texture(Component):
 
         images = [
             cv2.resize(
-                cv2.imread(layer.path(self._weights_dir), cv2.IMREAD_UNCHANGED), preview_size
+                cv2.imread(layer.get_preview_or_path(self._weights_dir), cv2.IMREAD_UNCHANGED),
+                preview_size,
             )
             for layer in active_layers
         ]
@@ -472,6 +666,7 @@ class Texture(Component):
             merged.dtype,
         )
         preview_path = os.path.join(self.previews_directory, "textures_osm.png")
-        cv2.imwrite(preview_path, merged)  # pylint: disable=no-member
+
+        cv2.imwrite(preview_path, merged)  # type: ignore
         self.logger.info("Preview saved to %s.", preview_path)
         return preview_path

maps4fs/logger.py

@@ -4,9 +4,7 @@ import logging
 import os
 import sys
 from datetime import datetime
-from logging import getLogger
-from time import perf_counter
-from typing import Any, Callable, Literal
+from typing import Literal
 
 LOGGER_NAME = "maps4fs"
 log_directory = os.path.join(os.getcwd(), "logs")
@@ -46,25 +44,3 @@ class Logger(logging.Logger):
         today = datetime.now().strftime("%Y-%m-%d")
         log_file = os.path.join(log_directory, f"{today}.txt")
         return log_file
-
-
-def timeit(func: Callable[..., Any]) -> Callable[..., Any]:
-    """Decorator to log the time taken by a function to execute.
-
-    Args:
-        func (function): The function to be timed.
-
-    Returns:
-        function: The timed function.
-    """
-
-    def timed(*args, **kwargs):
-        logger = getLogger("maps4fs")
-        start = perf_counter()
-        result = func(*args, **kwargs)
-        end = perf_counter()
-        if logger is not None:
-            logger.info("Function %s took %s seconds to execute", func.__name__, end - start)
-        return result
-
-    return timed

maps4fs/toolbox/background.py

@@ -0,0 +1,63 @@
+"""This module contains functions to work with the background terrain of the map."""
+
+import cv2
+import numpy as np
+import trimesh  # type: ignore
+
+
+# pylint: disable=R0801, R0914
+def plane_from_np(
+    dem_data: np.ndarray,
+    resize_factor: float,
+    simplify_factor: int,
+    save_path: str,
+) -> None:
+    """Generates a 3D obj file based on DEM data.
+
+    Arguments:
+        dem_data (np.ndarray) -- The DEM data as a numpy array.
+        resize_factor (float) -- The factor by which the DEM data will be resized. Bigger values
+            will result in a bigger mesh.
+        simplify_factor (int) -- The factor by which the mesh will be simplified. Bigger values
+            will result in a simpler mesh.
+        save_path (str) -- The path to save the obj file.
+    """
+    dem_data = cv2.resize(  # pylint: disable=no-member
+        dem_data, (0, 0), fx=resize_factor, fy=resize_factor
+    )
+
+    # Invert the height values.
+    dem_data = dem_data.max() - dem_data
+
+    rows, cols = dem_data.shape
+    x = np.linspace(0, cols - 1, cols)
+    y = np.linspace(0, rows - 1, rows)
+    x, y = np.meshgrid(x, y)
+    z = dem_data
+
+    vertices = np.column_stack([x.ravel(), y.ravel(), z.ravel()])
+    faces = []
+
+    for i in range(rows - 1):
+        for j in range(cols - 1):
+            top_left = i * cols + j
+            top_right = top_left + 1
+            bottom_left = top_left + cols
+            bottom_right = bottom_left + 1
+
+            faces.append([top_left, bottom_left, bottom_right])
+            faces.append([top_left, bottom_right, top_right])
+
+    faces = np.array(faces)  # type: ignore
+    mesh = trimesh.Trimesh(vertices=vertices, faces=faces)
+
+    # Apply rotation: 180 degrees around Y-axis and Z-axis
+    rotation_matrix_y = trimesh.transformations.rotation_matrix(np.pi, [0, 1, 0])
+    rotation_matrix_z = trimesh.transformations.rotation_matrix(np.pi, [0, 0, 1])
+    mesh.apply_transform(rotation_matrix_y)
+    mesh.apply_transform(rotation_matrix_z)
+
+    # Simplify the mesh to reduce the number of faces.
+    mesh = mesh.simplify_quadric_decimation(face_count=len(faces) // simplify_factor)
+
+    mesh.export(save_path)

maps4fs/toolbox/dem.py

@@ -11,7 +11,7 @@ from rasterio.windows import from_bounds  # type: ignore
 def read_geo_tiff(file_path: str) -> DatasetReader:
     """Read a GeoTIFF file and return the DatasetReader object.
 
-    Args:
+    Arguments:
         file_path (str): The path to the GeoTIFF file.
 
     Raises:
@@ -43,7 +43,7 @@ def get_geo_tiff_bbox(
 ) -> tuple[float, float, float, float]:
     """Return the bounding box of a GeoTIFF file in the destination CRS.
 
-    Args:
+    Arguments:
         src (DatasetReader): The DatasetReader object for the GeoTIFF file.
         dst_crs (str, optional): The destination CRS. Defaults to "EPSG:4326".
 
@@ -65,7 +65,7 @@ def get_geo_tiff_bbox(
 def extract_roi(file_path: str, bbox: tuple[float, float, float, float]) -> str:
     """Extract a region of interest (ROI) from a GeoTIFF file and save it as a new file.
 
-    Args:
+    Arguments:
         file_path (str): The path to the GeoTIFF file.
         bbox (tuple[float, float, float, float]): The bounding box of the region of interest
             as (north, south, east, west).