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

maps4fs/generator/component/grle.py

@@ -542,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)
@@ -562,6 +573,52 @@ 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

maps4fs/generator/component/i3d.py

@@ -12,13 +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"),
@@ -30,7 +31,7 @@ FIELDS_ATTRIBUTES = [
 ]
 
 
-class I3d(XMLComponent):
+class I3d(XMLComponent, ImageComponent):
     """Component for map i3d file settings and configuration.
 
     Arguments:
@@ -690,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.
         """
@@ -701,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}