maps4fs 2.8.9__py3-none-any.whl → 2.9.37__py3-none-any.whl

maps4fs/generator/component/config.py

@@ -10,6 +10,7 @@ import numpy as np
 import maps4fs.generator.utils as mfsutils
 from maps4fs.generator.component.base.component_image import ImageComponent
 from maps4fs.generator.component.base.component_xml import XMLComponent
+from maps4fs.generator.monitor import monitor_performance
 from maps4fs.generator.settings import Parameters
 
 # Defines coordinates for country block on the license plate texture.
@@ -120,6 +121,7 @@ class Config(XMLComponent, ImageComponent):
 
         self.create_qgis_scripts(layers)
 
+    @monitor_performance
     def _adjust_fog(self) -> None:
         """Adjusts the fog settings in the environment XML file based on the DEM and height scale."""
         self.logger.debug("Adjusting fog settings based on DEM and height scale...")
@@ -231,6 +233,7 @@ class Config(XMLComponent, ImageComponent):
 
         return dem_maximum_meter, dem_minimum_meter
 
+    @monitor_performance
     def _set_overview(self) -> None:
         """Generates and sets the overview image for the map."""
         try:
@@ -347,6 +350,7 @@ class Config(XMLComponent, ImageComponent):
             "HR",
         }
 
+    @monitor_performance
     def update_license_plates(self):
         """Updates license plates for the specified country."""
         try:
@@ -565,6 +569,7 @@ class Config(XMLComponent, ImageComponent):
         self.save_tree(tree, xml_path=i3d_path)
         self.logger.debug("Updated licensePlatesPL.i3d texture reference to: %s", filename)
 
+    @monitor_performance
     def _generate_license_plate_texture(
         self,
         license_plates_directory: str,

maps4fs/generator/component/dem.py

@@ -9,6 +9,7 @@ from pydtmdl import DTMProvider
 
 import maps4fs.generator.config as mfscfg
 from maps4fs.generator.component.base.component_image import ImageComponent
+from maps4fs.generator.monitor import monitor_performance
 
 
 # pylint: disable=R0903, R0902
@@ -115,6 +116,7 @@ class DEM(ImageComponent):
         except Exception as e:
             self.logger.warning("Failed to update DEM info: %s.", e)
 
+    @monitor_performance
     def process(self) -> None:
         """Reads DTM file, crops it to map size, normalizes and blurs it,
         saves to map directory."""
@@ -190,6 +192,7 @@ class DEM(ImageComponent):
         if self.rotation:
             self.rotate_dem()
 
+    @monitor_performance
     def normalize_data(self, data: np.ndarray, height_scale_value: int) -> np.ndarray:
         """Normalize DEM data to 16-bit unsigned integer range (0 to 65535).
 
@@ -209,6 +212,7 @@ class DEM(ImageComponent):
         )
         return normalized_data
 
+    @monitor_performance
     def determine_height_scale(self, data: np.ndarray) -> int:
         """Determine height scale value using ceiling.
 
@@ -261,6 +265,7 @@ class DEM(ImageComponent):
         )
         return data
 
+    @monitor_performance
     def apply_multiplier(self, data: np.ndarray) -> np.ndarray:
         """Apply multiplier to DEM data.
 
@@ -283,6 +288,7 @@ class DEM(ImageComponent):
         )
         return multiplied_data
 
+    @monitor_performance
     def resize_to_output(self, data: np.ndarray) -> np.ndarray:
         """Resize DEM data to the output resolution.
 
@@ -296,6 +302,7 @@ class DEM(ImageComponent):
 
         return resampled_data
 
+    @monitor_performance
     def rotate_dem(self) -> None:
         """Rotate DEM image."""
         self.logger.debug("Rotating DEM image by %s degrees.", self.rotation)

maps4fs/generator/component/grle.py

@@ -12,6 +12,7 @@ from tqdm import tqdm
 from maps4fs.generator.component.base.component_image import ImageComponent
 from maps4fs.generator.component.base.component_xml import XMLComponent
 from maps4fs.generator.component.layer import Layer
+from maps4fs.generator.monitor import monitor_performance
 from maps4fs.generator.settings import Parameters
 
 # This value sums up the pixel value of the basic area type to convert it from "No Water" to "Near Water".
@@ -98,6 +99,7 @@ class GRLE(ImageComponent, XMLComponent):
 
         return grle_schema
 
+    @monitor_performance
     def process(self) -> None:
         """Generates InfoLayer PNG files based on the GRLE schema."""
         grle_schema = self._read_grle_schema()
@@ -134,6 +136,7 @@ class GRLE(ImageComponent, XMLComponent):
             self._process_environment()
             self._process_indoor()
 
+    @monitor_performance
     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.
@@ -173,6 +176,7 @@ class GRLE(ImageComponent, XMLComponent):
 
         return preview_paths
 
+    @monitor_performance
     def overlay_fields(self, farmlands_np: np.ndarray) -> np.ndarray | None:
         """Overlay fields on the farmlands preview image.
 
@@ -200,6 +204,7 @@ class GRLE(ImageComponent, XMLComponent):
         # use fields_np as base layer and overlay farmlands_np on top of it with 50% alpha blending.
         return cv2.addWeighted(fields_np, 0.5, farmlands_np, 0.5, 0)
 
+    @monitor_performance
     def _add_farmlands(self) -> None:
         """Adds farmlands to the InfoLayer PNG file."""
         farmlands = []
@@ -297,6 +302,7 @@ class GRLE(ImageComponent, XMLComponent):
 
         self.preview_paths["farmlands"] = info_layer_farmlands_path
 
+    @monitor_performance
     def _add_plants(self) -> None:
         """Adds plants to the InfoLayer PNG file."""
         grass_layer = self.map.get_texture_layer(by_usage="grass")
@@ -399,6 +405,7 @@ class GRLE(ImageComponent, XMLComponent):
 
         self.logger.debug("Updated density map for fruits saved in %s.", density_map_fruit_path)
 
+    @monitor_performance
     def create_island_of_plants(self, image: np.ndarray, count: int) -> np.ndarray:
         """Create an island of plants in the image.
 
@@ -495,6 +502,7 @@ class GRLE(ImageComponent, XMLComponent):
         image_np[:, -1] = 0  # Right side
         return image_np
 
+    @monitor_performance
     def _process_environment(self) -> None:
         info_layer_environment_path = self.game.get_environment_path(self.map_directory)
         if not info_layer_environment_path or not os.path.isfile(info_layer_environment_path):
@@ -534,6 +542,17 @@ class GRLE(ImageComponent, XMLComponent):
 
         for layer in texture_component.get_area_type_layers():
             pixel_value = area_type_to_pixel_value(layer.area_type)  # type: ignore
+            # * Not enabled for now.
+            # * If the layer is invisible, we need to draw the mask from the info layer.
+            # if layer.invisible:
+            #     self.logger.debug("Processing invisible area type layer: %s.", layer.name)
+            #     if layer.info_layer:
+            #         self.logger.debug("Info layer available: %s.", layer.info_layer)
+            #         weight_image = self.draw_invisible_layer_mask(layer, environment_size)
+            #     else:
+            #         self.logger.debug("No info layer available for layer: %s.", layer.name)
+            #         continue
+            # else:
             weight_image = self.get_resized_weight(layer, environment_size)  # type: ignore
             if weight_image is None:
                 self.logger.warning("Weight image for area type layer not found in %s.", layer.name)
@@ -554,6 +573,53 @@ class GRLE(ImageComponent, XMLComponent):
         self.logger.debug("Environment InfoLayer PNG file saved: %s.", info_layer_environment_path)
         self.preview_paths["environment"] = info_layer_environment_path
 
+    # def draw_invisible_layer_mask(self, layer: Layer, resize_to: int) -> np.ndarray:
+    #     """Draw the mask for the invisible layer.
+
+    #     Arguments:
+    #         layer (Layer): The layer for which to draw the mask.
+    #         resize_to (int): The size to which the mask should be resized.
+
+    #     Returns:
+    #         np.ndarray: The resized mask.
+    #     """
+    #     mask = np.zeros((self.map.size, self.map.size), dtype=np.uint8)
+    #     polygons = self.get_infolayer_data(Parameters.TEXTURES, layer.info_layer)
+    #     self.logger.debug("Found %d polygons in info layer %s.", len(polygons), layer.info_layer)
+
+    #     for polygon in polygons:
+    #         try:
+    #             fitted_polygon = self.fit_object_into_bounds(
+    #                 polygon_points=polygon,
+    #                 # margin=self.map.grle_settings.farmland_margin,
+    #                 angle=self.rotation,
+    #             )
+    #         except ValueError as e:
+    #             self.logger.debug(
+    #                 "Polygon could not be fitted into the map bounds with error: %s",
+    #                 e,
+    #             )
+    #             continue
+    #         polygon_np = self.polygon_points_to_np(fitted_polygon)
+
+    #         try:
+    #             cv2.fillPoly(mask, [polygon_np], (float(255),))  # type: ignore
+    #         except Exception as e:
+    #             self.logger.debug(
+    #                 "Polygon could not be added to the mask with error: %s",
+    #                 e,
+    #             )
+    #             continue
+
+    #     resized_mask = cv2.resize(
+    #         mask,
+    #         (resize_to, resize_to),
+    #         interpolation=cv2.INTER_NEAREST,
+    #     )
+
+    #     return resized_mask
+
+    @monitor_performance
     def get_resized_weight(
         self, layer: Layer, resize_to: int, dilations: int = 3
     ) -> np.ndarray | None:

maps4fs/generator/component/i3d.py

@@ -12,12 +12,14 @@ import cv2
 import numpy as np
 from tqdm import tqdm
 
+from maps4fs.generator.component.base.component_image import ImageComponent
 from maps4fs.generator.component.base.component_xml import XMLComponent
+from maps4fs.generator.monitor import monitor_performance
 from maps4fs.generator.settings import Parameters
 
 NODE_ID_STARTING_VALUE = 2000
 SPLINES_NODE_ID_STARTING_VALUE = 5000
-TREE_NODE_ID_STARTING_VALUE = 10000
+TREE_NODE_ID_STARTING_VALUE = 30000
 
 FIELDS_ATTRIBUTES = [
     ("angle", "integer", "0"),
@@ -29,7 +31,7 @@ FIELDS_ATTRIBUTES = [
 ]
 
 
-class I3d(XMLComponent):
+class I3d(XMLComponent, ImageComponent):
     """Component for map i3d file settings and configuration.
 
     Arguments:
@@ -112,6 +114,7 @@ class I3d(XMLComponent):
 
         self.save_tree(tree)
 
+    @monitor_performance
     def _add_splines(self) -> None:
         """Adds splines to the map I3D file."""
         splines_i3d_path = self.game.splines_file_path(self.map_directory)
@@ -240,6 +243,7 @@ class I3d(XMLComponent):
 
         self.assets.splines = splines_i3d_path
 
+    @monitor_performance
     def _add_fields(self) -> None:
         """Adds fields to the map I3D file."""
         tree = self.get_tree()
@@ -498,6 +502,7 @@ class I3d(XMLComponent):
 
         return choice(trees_by_leaf_type)
 
+    @monitor_performance
     def _add_forests(self) -> None:
         """Adds forests to the map I3D file."""
         tree_schema = self._read_tree_schema()
@@ -686,9 +691,13 @@ class I3d(XMLComponent):
 
         return recommended_step if not current_step else max(recommended_step, current_step)
 
-    def get_not_resized_dem(self) -> np.ndarray | None:
+    def get_not_resized_dem(self, with_foundations: bool = False) -> np.ndarray | None:
         """Reads the not resized DEM image from the background component.
 
+        Arguments:
+            with_foundations (bool, optional): Whether to get the DEM with foundations.
+                Defaults to False.
+
         Returns:
             np.ndarray | None: The not resized DEM image or None if the image could not be read.
         """
@@ -697,11 +706,60 @@ class I3d(XMLComponent):
             self.logger.warning("Background component not found.")
             return None
 
-        if not background_component.not_resized_path:
+        dem_path = (
+            background_component.not_resized_with_foundations_path
+            if with_foundations
+            else background_component.not_resized_path
+        )
+
+        if not dem_path or not os.path.isfile(dem_path):
             self.logger.warning("Not resized DEM path not found.")
             return None
 
-        not_resized_dem = cv2.imread(background_component.not_resized_path, cv2.IMREAD_UNCHANGED)
+        not_resized_dem = cv2.imread(dem_path, cv2.IMREAD_UNCHANGED)
+
+        return not_resized_dem
+
+    def get_not_resized_dem_with_foundations(
+        self, allow_fallback: bool = False
+    ) -> np.ndarray | None:
+        """Gets the not resized DEM with foundations. If the DEM with foundations is not found
+        and allow_fallback is True, the method returns the not resized DEM without foundations.
+
+        Arguments:
+            allow_fallback (bool, optional): Whether to allow fallback to DEM without
+                foundations. Defaults to False.
+
+        Returns:
+            np.ndarray | None: The not resized DEM image or None if the image could not be read.
+        """
+        dem_with_foundations = self.get_not_resized_dem(with_foundations=True)
+
+        if dem_with_foundations is not None:
+            return dem_with_foundations
+        self.logger.warning("Not resized DEM with foundations not found.")
+        if allow_fallback:
+            return self.get_not_resized_dem(with_foundations=False)
+        return None
+
+    def get_not_resized_dem_with_flattened_roads(self) -> np.ndarray | None:
+        """Gets the not resized DEM with flattened roads.
+
+        Returns:
+            np.ndarray | None: The not resized DEM image or None if the image could not be read.
+        """
+        background_component = self.map.get_background_component()
+        if not background_component:
+            self.logger.warning("Background component not found.")
+            return None
+
+        dem_path = background_component.not_resized_with_flattened_roads_path
+
+        if not dem_path or not os.path.isfile(dem_path):
+            self.logger.warning("Not resized DEM with flattened roads path not found.")
+            return None
+
+        not_resized_dem = cv2.imread(dem_path, cv2.IMREAD_UNCHANGED)
 
         return not_resized_dem
 

maps4fs/generator/component/layer.py

@@ -21,6 +21,16 @@ class Layer:
         usage (str | None): Usage of the layer.
         background (bool): Flag to determine if the layer is a background.
         invisible (bool): Flag to determine if the layer is invisible.
+        procedural (list[str] | None): List of procedural textures to apply.
+        border (int | None): Border size in pixels.
+        precise_tags (dict[str, str | list[str]] | None): Dictionary of precise tags to search for.
+        precise_usage (str | None): Precise usage of the layer.
+        area_type (str | None): Type of the area (e.g., residential, commercial).
+        area_water (bool): Flag to determine if the area is water.
+        indoor (bool): Flag to determine if the layer is indoor.
+        merge_into (str | None): Name of the layer to merge into.
+        building_category (str | None): Category of the building.
+        external (bool): External layers not being used by the game directly.
 
     Attributes:
         name (str): Name of the layer.
@@ -50,6 +60,9 @@ class Layer:
         area_water: bool = False,
         indoor: bool = False,
         merge_into: str | None = None,
+        building_category: str | None = None,
+        external: bool = False,
+        road_texture: str | None = None,
     ):
         self.name = name
         self.count = count
@@ -70,6 +83,9 @@ class Layer:
         self.area_water = area_water
         self.indoor = indoor
         self.merge_into = merge_into
+        self.building_category = building_category
+        self.external = external
+        self.road_texture = road_texture
 
     def to_json(self) -> dict[str, str | list[str] | bool]:  # type: ignore
         """Returns dictionary with layer data.
@@ -96,6 +112,9 @@ class Layer:
             "area_water": self.area_water,
             "indoor": self.indoor,
             "merge_into": self.merge_into,
+            "building_category": self.building_category,
+            "external": self.external,
+            "road_texture": self.road_texture,
         }
 
         data = {k: v for k, v in data.items() if v is not None}