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

maps4fs/generator/dem.py

@@ -23,10 +23,12 @@ DEFAULT_PLATEAU = 0
 class DEM(Component):
     """Component for processing Digital Elevation Model data.
 
-    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.
@@ -40,6 +42,14 @@ class DEM(Component):
         os.makedirs(self.hgt_dir, exist_ok=True)
         os.makedirs(self.gz_dir, exist_ok=True)
 
+        self.logger.debug("Map size: %s x %s.", self.map_size, self.map_size)
+        self.logger.debug(
+            "Map rotated size: %s x %s.", self.map_rotated_size, self.map_rotated_size
+        )
+
+        self.output_resolution = self.get_output_resolution()
+        self.logger.debug("Output resolution for DEM data: %s.", self.output_resolution)
+
         self.multiplier = self.kwargs.get("multiplier", DEFAULT_MULTIPLIER)
         blur_radius = self.kwargs.get("blur_radius", DEFAULT_BLUR_RADIUS)
         if blur_radius is None or blur_radius <= 0:
@@ -64,21 +74,45 @@ class DEM(Component):
         """
         return self._dem_path
 
-    def get_output_resolution(self) -> tuple[int, int]:
+    # pylint: disable=W0201
+    def set_dem_path(self, dem_path: str) -> None:
+        """Set path to the DEM file.
+
+        Arguments:
+            dem_path (str): Path to the DEM file.
+        """
+        self._dem_path = dem_path
+
+    # pylint: disable=W0201
+    def set_output_resolution(self, output_resolution: tuple[int, int]) -> None:
+        """Set output resolution for DEM data (width, height).
+
+        Arguments:
+            output_resolution (tuple[int, int]): Output resolution for DEM data.
+        """
+        self.output_resolution = output_resolution
+
+    def get_output_resolution(self, use_original: bool = False) -> tuple[int, int]:
         """Get output resolution for DEM data.
 
+        Arguments:
+            use_original (bool, optional): If True, will use original map size. Defaults to False.
+
         Returns:
             tuple[int, int]: Output resolution for DEM data.
         """
-        dem_height = int((self.map_height / 2) * self.game.dem_multipliyer + 1)
-        dem_width = int((self.map_width / 2) * self.game.dem_multipliyer + 1)
+        map_size = self.map_size if use_original else self.map_rotated_size
+
+        dem_size = int((map_size / 2) * self.game.dem_multipliyer)
+
         self.logger.debug(
-            "DEM size multiplier is %s, DEM height is %s, DEM width is %s.",
+            "DEM size multiplier is %s, DEM size: %sx%s, use original: %s.",
             self.game.dem_multipliyer,
-            dem_height,
-            dem_width,
+            dem_size,
+            dem_size,
+            use_original,
         )
-        return dem_width, dem_height
+        return dem_size, dem_size
 
     def to_ground(self, data: np.ndarray) -> np.ndarray:
         """Receives the signed 16-bit integer array and converts it to the ground level.
@@ -102,7 +136,7 @@ class DEM(Component):
         saves to map directory."""
         north, south, east, west = self.bbox
 
-        dem_output_resolution = self.get_output_resolution()
+        dem_output_resolution = self.output_resolution
         self.logger.debug("DEM output resolution: %s.", dem_output_resolution)
 
         tile_path = self._srtm_tile()
@@ -223,28 +257,31 @@ class DEM(Component):
             )
 
         cv2.imwrite(self._dem_path, resampled_data)
-        self.logger.debug("DEM data was saved to %s.", self._dem_path)
+        self.logger.info("DEM data was saved to %s.", self._dem_path)
 
-        if self.game.additional_dem_name is not None:
-            self.make_copy(self.game.additional_dem_name)
+        if self.rotation:
+            self.rotate_dem()
 
-    def make_copy(self, dem_name: str) -> None:
-        """Copies DEM data to additional DEM file.
+    def rotate_dem(self) -> None:
+        """Rotate DEM image."""
+        self.logger.debug("Rotating DEM image by %s degrees.", self.rotation)
+        output_width, output_height = self.get_output_resolution(use_original=True)
 
-        Args:
-            dem_name (str): Name of the additional DEM file.
-        """
-        dem_directory = os.path.dirname(self._dem_path)
-
-        additional_dem_path = os.path.join(dem_directory, dem_name)
+        self.logger.debug(
+            "Output resolution for rotated DEM: %s x %s.", output_width, output_height
+        )
 
-        shutil.copyfile(self._dem_path, additional_dem_path)
-        self.logger.debug("Additional DEM data was copied to %s.", additional_dem_path)
+        self.rotate_image(
+            self._dem_path,
+            self.rotation,
+            output_height=output_height,
+            output_width=output_width,
+        )
 
     def _tile_info(self, lat: float, lon: float) -> tuple[str, str]:
         """Returns latitude band and tile name for SRTM tile from coordinates.
 
-        Args:
+        Arguments:
             lat (float): Latitude.
             lon (float): Longitude.
 
@@ -300,7 +337,7 @@ class DEM(Component):
 
         decompressed_file_path = os.path.join(self.hgt_dir, f"{tile_name}.hgt")
         if os.path.isfile(decompressed_file_path):
-            self.logger.info(
+            self.logger.debug(
                 "Decompressed tile already exists: %s, skipping download.",
                 decompressed_file_path,
             )
@@ -319,80 +356,22 @@ class DEM(Component):
     def _save_empty_dem(self, dem_output_resolution: tuple[int, int]) -> None:
         """Saves empty DEM file filled with zeros."""
         dem_data = np.zeros(dem_output_resolution, dtype="uint16")
-        cv2.imwrite(self._dem_path, dem_data)  # pylint: disable=no-member
+        cv2.imwrite(self._dem_path, dem_data)
         self.logger.warning("DEM data filled with zeros and saved to %s.", self._dem_path)
 
-    def grayscale_preview(self) -> str:
-        """Converts DEM image to grayscale RGB image and saves it to the map directory.
-        Returns path to the preview image.
-
-        Returns:
-            str: Path to the preview image.
-        """
-        # rgb_dem_path = self._dem_path.replace(".png", "_grayscale.png")
-        grayscale_dem_path = os.path.join(self.previews_directory, "dem_grayscale.png")
-
-        self.logger.debug("Creating grayscale preview of DEM data in %s.", grayscale_dem_path)
-
-        dem_data = cv2.imread(self._dem_path, cv2.IMREAD_GRAYSCALE)
-        dem_data_rgb = cv2.cvtColor(dem_data, cv2.COLOR_GRAY2RGB)
-        cv2.imwrite(grayscale_dem_path, dem_data_rgb)
-        return grayscale_dem_path
-
-    def colored_preview(self) -> str:
-        """Converts DEM image to colored RGB image and saves it to the map directory.
-        Returns path to the preview image.
+    def previews(self) -> list:
+        """This component does not have previews, returns empty list.
 
         Returns:
-            list[str]: List with a single path to the DEM file
+            list: Empty list.
         """
-
-        # colored_dem_path = self._dem_path.replace(".png", "_colored.png")
-        colored_dem_path = os.path.join(self.previews_directory, "dem_colored.png")
-
-        self.logger.debug("Creating colored preview of DEM data in %s.", colored_dem_path)
-
-        dem_data = cv2.imread(self._dem_path, cv2.IMREAD_GRAYSCALE)
-
-        self.logger.debug(
-            "DEM data before normalization. Shape: %s, dtype: %s. Min: %s, max: %s.",
-            dem_data.shape,
-            dem_data.dtype,
-            dem_data.min(),
-            dem_data.max(),
-        )
-
-        # Create an empty array with the same shape and type as dem_data.
-        dem_data_normalized = np.empty_like(dem_data)
-
-        # Normalize the DEM data to the range [0, 255]
-        cv2.normalize(dem_data, dem_data_normalized, 0, 255, cv2.NORM_MINMAX)
-        self.logger.debug(
-            "DEM data after normalization. Shape: %s, dtype: %s. Min: %s, max: %s.",
-            dem_data_normalized.shape,
-            dem_data_normalized.dtype,
-            dem_data_normalized.min(),
-            dem_data_normalized.max(),
-        )
-        dem_data_colored = cv2.applyColorMap(dem_data_normalized, cv2.COLORMAP_JET)
-
-        cv2.imwrite(colored_dem_path, dem_data_colored)
-        return colored_dem_path
-
-    def previews(self) -> list[str]:
-        """Get list of preview images.
-
-        Returns:
-            list[str]: List of preview images.
-        """
-        self.logger.debug("Starting DEM previews generation.")
-        return [self.grayscale_preview(), self.colored_preview()]
+        return []
 
     def _get_scaling_factor(self, maximum_deviation: int) -> float:
         """Calculate scaling factor for DEM data normalization.
         NOTE: Needs reconsideration for the implementation.
 
-        Args:
+        Arguments:
             maximum_deviation (int): Maximum deviation in DEM data.
 
         Returns:
@@ -404,7 +383,7 @@ class DEM(Component):
 
     def _normalize_dem(self, data: np.ndarray) -> np.ndarray:
         """Normalize DEM data to 16-bit unsigned integer using max height from settings.
-        Args:
+        Arguments:
             data (np.ndarray): DEM data from SRTM file after cropping.
         Returns:
             np.ndarray: Normalized DEM data.
@@ -412,9 +391,9 @@ class DEM(Component):
         self.logger.debug("Starting DEM data normalization.")
         # Calculate the difference between the maximum and minimum values in the DEM data.
 
-        max_height = data.max()  # 1800
-        min_height = data.min()  # 1700
-        max_dev = max_height - min_height  # 100
+        max_height = data.max()
+        min_height = data.min()
+        max_dev = max_height - min_height
         self.logger.debug(
             "Maximum deviation: %s with maximum at %s and minimum at %s.",
             max_dev,
@@ -424,14 +403,18 @@ class DEM(Component):
 
         scaling_factor = self._get_scaling_factor(max_dev)
         adjusted_max_height = int(65535 * scaling_factor)
-        self.logger.debug(
-            f"Maximum deviation: {max_dev}. Scaling factor: {scaling_factor}. "
-            f"Adjusted max height: {adjusted_max_height}."
+        self.logger.info(
+            "Maximum deviation: %s. Scaling factor: %s. Adjusted max height: %s.",
+            max_dev,
+            scaling_factor,
+            adjusted_max_height,
         )
         normalized_data = (
             (data - data.min()) / (data.max() - data.min()) * adjusted_max_height
         ).astype("uint16")
         self.logger.debug(
-            f"DEM data was normalized to {normalized_data.min()} - {normalized_data.max()}."
+            "DEM data was normalized to %s - %s.",
+            normalized_data.min(),
+            normalized_data.max(),
         )
         return normalized_data

maps4fs/generator/game.py

@@ -8,7 +8,7 @@ import os
 
 from maps4fs.generator.background import Background
 from maps4fs.generator.config import Config
-from maps4fs.generator.dem import DEM
+from maps4fs.generator.grle import GRLE
 from maps4fs.generator.i3d import I3d
 from maps4fs.generator.texture import Texture
 
@@ -31,12 +31,14 @@ class Game:
     """
 
     code: str | None = None
-    dem_multipliyer: int = 1
+    dem_multipliyer: int = 2
     _additional_dem_name: str | None = None
     _map_template_path: str | None = None
     _texture_schema: str | None = None
+    _grle_schema: str | None = None
 
-    components = [Config, Texture, DEM, I3d, Background]
+    # Order matters! Some components depend on others.
+    components = [Texture, I3d, GRLE, Background, Config]
 
     def __init__(self, map_template_path: str | None = None):
         if map_template_path:
@@ -94,6 +96,19 @@ class Game:
             raise ValueError("Texture layers schema path not set.")
         return self._texture_schema
 
+    @property
+    def grle_schema(self) -> str:
+        """Returns the path to the GRLE layers schema file.
+
+        Raises:
+            ValueError: If the GRLE layers schema path is not set.
+
+        Returns:
+            str: The path to the GRLE layers schema file."""
+        if not self._grle_schema:
+            raise ValueError("GRLE layers schema path not set.")
+        return self._grle_schema
+
     def dem_file_path(self, map_directory: str) -> str:
         """Returns the path to the DEM file.
 
@@ -171,6 +186,7 @@ class FS25(Game):
     _additional_dem_name = "unprocessedHeightMap.png"
     _map_template_path = os.path.join(working_directory, "data", "fs25-map-template.zip")
     _texture_schema = os.path.join(working_directory, "data", "fs25-texture-schema.json")
+    _grle_schema = os.path.join(working_directory, "data", "fs25-grle-schema.json")
 
     def dem_file_path(self, map_directory: str) -> str:
         """Returns the path to the DEM file.

maps4fs/generator/grle.py

@@ -0,0 +1,186 @@
+"""This module contains the GRLE class for generating InfoLayer PNG files based on GRLE schema."""
+
+import json
+import os
+from xml.etree import ElementTree as ET
+
+import cv2
+import numpy as np
+
+from maps4fs.generator.component import Component
+
+
+# pylint: disable=W0223
+class GRLE(Component):
+    """Component for to generate InfoLayer PNG files based on GRLE schema.
+
+    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_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.
+    """
+
+    _grle_schema: dict[str, float | int | str] | None = None
+
+    def preprocess(self) -> None:
+        """Gets the path to the map I3D file from the game instance and saves it to the instance
+        attribute. If the game does not support I3D files, the attribute is set to None."""
+
+        self.farmland_margin = self.kwargs.get("farmland_margin", 0)
+
+        try:
+            grle_schema_path = self.game.grle_schema
+        except ValueError:
+            self.logger.info("GRLE schema processing is not implemented for this game.")
+            return
+
+        try:
+            with open(grle_schema_path, "r", encoding="utf-8") as file:
+                self._grle_schema = json.load(file)
+            self.logger.debug("GRLE schema loaded from: %s.", grle_schema_path)
+        except (json.JSONDecodeError, FileNotFoundError) as error:
+            self.logger.error("Error loading GRLE schema from %s: %s.", grle_schema_path, error)
+            self._grle_schema = None
+
+    def process(self) -> None:
+        """Generates InfoLayer PNG files based on the GRLE schema."""
+        if not self._grle_schema:
+            self.logger.info("GRLE schema is not obtained, skipping the processing.")
+            return
+
+        for info_layer in self._grle_schema:
+            if isinstance(info_layer, dict):
+                file_path = os.path.join(
+                    self.game.weights_dir_path(self.map_directory), info_layer["name"]
+                )
+
+                height = int(self.map_size * info_layer["height_multiplier"])
+                width = int(self.map_size * info_layer["width_multiplier"])
+                channels = info_layer["channels"]
+                data_type = info_layer["data_type"]
+
+                # Create the InfoLayer PNG file with zeros.
+                if channels == 1:
+                    info_layer_data = np.zeros((height, width), dtype=data_type)
+                else:
+                    info_layer_data = np.zeros((height, width, channels), dtype=data_type)
+                self.logger.debug("Shape of %s: %s.", info_layer["name"], info_layer_data.shape)
+                cv2.imwrite(file_path, info_layer_data)  # pylint: disable=no-member
+                self.logger.debug("InfoLayer PNG file %s created.", file_path)
+            else:
+                self.logger.warning("Invalid InfoLayer schema: %s.", info_layer)
+
+        self._add_farmlands()
+
+    def previews(self) -> list[str]:
+        """Returns a list of paths to the preview images (empty list).
+        The component does not generate any preview images so it returns an empty list.
+
+        Returns:
+            list[str]: An empty list.
+        """
+        return []
+
+    # pylint: disable=R0801, R0914
+    def _add_farmlands(self) -> None:
+        """Adds farmlands to the InfoLayer PNG file."""
+
+        textures_info_layer_path = self.get_infolayer_path("textures")
+        if not textures_info_layer_path:
+            return
+
+        with open(textures_info_layer_path, "r", encoding="utf-8") as textures_info_layer_file:
+            textures_info_layer = json.load(textures_info_layer_file)
+
+        fields: list[list[tuple[int, int]]] | None = textures_info_layer.get("fields")
+        if not fields:
+            self.logger.warning("Fields data not found in textures info layer.")
+            return
+
+        self.logger.info("Found %s fields in textures info layer.", len(fields))
+
+        info_layer_farmlands_path = os.path.join(
+            self.game.weights_dir_path(self.map_directory), "infoLayer_farmlands.png"
+        )
+
+        self.logger.info(
+            "Adding farmlands to the InfoLayer PNG file: %s.", info_layer_farmlands_path
+        )
+
+        if not os.path.isfile(info_layer_farmlands_path):
+            self.logger.warning("InfoLayer PNG file %s not found.", info_layer_farmlands_path)
+            return
+
+        # pylint: disable=no-member
+        image = cv2.imread(info_layer_farmlands_path, cv2.IMREAD_UNCHANGED)
+        farmlands_xml_path = os.path.join(self.map_directory, "map/config/farmlands.xml")
+        if not os.path.isfile(farmlands_xml_path):
+            self.logger.warning("Farmlands XML file %s not found.", farmlands_xml_path)
+            return
+
+        tree = ET.parse(farmlands_xml_path)
+        farmlands_xml = tree.find("farmlands")
+
+        # Not using enumerate because in case of the error, we do not increment
+        # the farmland_id. So as a result we do not have a gap in the farmland IDs.
+        farmland_id = 1
+
+        for field in fields:
+            try:
+                fitted_field = self.fit_polygon_into_bounds(
+                    field, self.farmland_margin, angle=self.rotation
+                )
+            except ValueError as e:
+                self.logger.warning(
+                    "Farmland %s could not be fitted into the map bounds with error: %s",
+                    farmland_id,
+                    e,
+                )
+                continue
+
+            self.logger.debug("Fitted field %s contains %s points.", farmland_id, len(fitted_field))
+
+            field_np = np.array(fitted_field, np.int32)
+            field_np = field_np.reshape((-1, 1, 2))
+
+            self.logger.debug(
+                "Created a numpy array and reshaped it. Number of points: %s", len(field_np)
+            )
+
+            # Infolayer image is 1/2 of the size of the map image, that's why we need to divide
+            # the coordinates by 2.
+            field_np = field_np // 2
+            self.logger.debug("Divided the coordinates by 2.")
+
+            # pylint: disable=no-member
+            try:
+                cv2.fillPoly(image, [field_np], farmland_id)  # type: ignore
+            except Exception as e:  # pylint: disable=W0718
+                self.logger.warning(
+                    "Farmland %s could not be added to the InfoLayer PNG file with error: %s",
+                    farmland_id,
+                    e,
+                )
+                continue
+
+            # Add the field to the farmlands XML.
+            farmland = ET.SubElement(farmlands_xml, "farmland")  # type: ignore
+            farmland.set("id", str(farmland_id))
+            farmland.set("priceScale", "1")
+            farmland.set("npcName", "FORESTER")
+
+            farmland_id += 1
+
+        tree.write(farmlands_xml_path)
+
+        self.logger.info("Farmlands added to the farmlands XML file: %s.", farmlands_xml_path)
+
+        cv2.imwrite(info_layer_farmlands_path, image)  # pylint: disable=no-member
+        self.logger.info(
+            "Farmlands added to the InfoLayer PNG file: %s.", info_layer_farmlands_path
+        )