maps4fs 1.5.7__py3-none-any.whl → 1.6.91__py3-none-any.whl

maps4fs/generator/grle.py

@@ -10,13 +10,26 @@ import numpy as np
 from shapely.geometry import Polygon  # type: ignore
 
 from maps4fs.generator.component import Component
-from maps4fs.generator.texture import Texture
+from maps4fs.generator.texture import PREVIEW_MAXIMUM_SIZE, Texture
 
-ISLAND_SIZE_MIN = 10
-ISLAND_SIZE_MAX = 200
 ISLAND_DISTORTION = 0.3
-ISLAND_VERTEX_COUNT = 30
-ISLAND_ROUNDING_RADIUS = 15
+
+
+def plant_to_pixel_value(plant_name: str) -> int | None:
+    """Returns the pixel value representation of the plant.
+    If not found, returns None.
+
+    Arguments:
+        plant_name (str): name of the plant
+
+    Returns:
+        int | None: pixel value of the plant or None if not found.
+    """
+    plants = {
+        "smallDenseMix": 33,
+        "meadow": 131,
+    }
+    return plants.get(plant_name)
 
 
 # pylint: disable=W0223
@@ -39,6 +52,7 @@ class GRLE(Component):
     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.preview_paths: dict[str, str] = {}
 
         try:
             grle_schema_path = self.game.grle_schema
@@ -89,6 +103,7 @@ class GRLE(Component):
         else:
             self.logger.warning("Adding plants it's not supported for the %s.", self.game.code)
 
+    # pylint: disable=no-member
     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.
@@ -96,7 +111,57 @@ class GRLE(Component):
         Returns:
             list[str]: An empty list.
         """
-        return []
+        preview_paths = []
+        for preview_name, preview_path in self.preview_paths.items():
+            save_path = os.path.join(self.previews_directory, f"{preview_name}.png")
+            # Resize the preview image to the maximum size allowed for previews.
+            image = cv2.imread(preview_path, cv2.IMREAD_GRAYSCALE)
+            if image.shape[0] > PREVIEW_MAXIMUM_SIZE or image.shape[1] > PREVIEW_MAXIMUM_SIZE:
+                image = cv2.resize(image, (PREVIEW_MAXIMUM_SIZE, PREVIEW_MAXIMUM_SIZE))
+            image_normalized = np.empty_like(image)
+            cv2.normalize(image, image_normalized, 0, 255, cv2.NORM_MINMAX)
+            image_colored = cv2.applyColorMap(image_normalized, cv2.COLORMAP_JET)
+            cv2.imwrite(save_path, image_colored)
+            preview_paths.append(save_path)
+
+            with_fields_save_path = os.path.join(
+                self.previews_directory, f"{preview_name}_with_fields.png"
+            )
+            image_with_fields = self.overlay_fields(image_colored)
+            if image_with_fields is None:
+                continue
+            cv2.imwrite(with_fields_save_path, image_with_fields)  # pylint: disable=no-member
+            preview_paths.append(with_fields_save_path)
+
+        return preview_paths
+
+    def overlay_fields(self, farmlands_np: np.ndarray) -> np.ndarray | None:
+        """Overlay fields on the farmlands preview image.
+
+        Arguments:
+            farmlands_np (np.ndarray): The farmlands preview image.
+
+        Returns:
+            np.ndarray | None: The farmlands preview image with fields overlayed on top of it.
+        """
+        texture_component: Texture | None = self.map.get_component("Texture")  # type: ignore
+        if not texture_component:
+            self.logger.warning("Texture component not found in the map.")
+            return None
+
+        fields_layer = texture_component.get_layer_by_usage("field")
+        fields_layer_path = fields_layer.get_preview_or_path(  # type: ignore
+            self.game.weights_dir_path(self.map_directory)
+        )
+        if not fields_layer_path or not os.path.isfile(fields_layer_path):
+            self.logger.warning("Fields layer not found in the texture component.")
+            return None
+        fields_np = cv2.imread(fields_layer_path)
+        # Resize fields_np to the same size as farmlands_np.
+        fields_np = cv2.resize(fields_np, (farmlands_np.shape[1], farmlands_np.shape[0]))
+
+        # 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)
 
     # pylint: disable=R0801, R0914
     def _add_farmlands(self) -> None:
@@ -114,12 +179,12 @@ class GRLE(Component):
             self.logger.warning("Fields data not found in textures info layer.")
             return
 
-        self.logger.info("Found %s fields in textures info layer.", len(fields))
+        self.logger.debug("Found %s fields in textures info layer.", len(fields))
 
         farmyards: list[list[tuple[int, int]]] | None = textures_info_layer.get("farmyards")
         if farmyards and self.map.grle_settings.add_farmyards:
             fields.extend(farmyards)
-            self.logger.info("Found %s farmyards in textures info layer.", len(farmyards))
+            self.logger.debug("Found %s farmyards in textures info layer.", len(farmyards))
 
         info_layer_farmlands_path = os.path.join(
             self.game.weights_dir_path(self.map_directory), "infoLayer_farmlands.png"
@@ -155,7 +220,7 @@ class GRLE(Component):
                     angle=self.rotation,
                 )
             except ValueError as e:
-                self.logger.warning(
+                self.logger.debug(
                     "Farmland %s could not be fitted into the map bounds with error: %s",
                     farmland_id,
                     e,
@@ -180,7 +245,7 @@ class GRLE(Component):
             try:
                 cv2.fillPoly(image, [field_np], farmland_id)  # type: ignore
             except Exception as e:  # pylint: disable=W0718
-                self.logger.warning(
+                self.logger.debug(
                     "Farmland %s could not be added to the InfoLayer PNG file with error: %s",
                     farmland_id,
                     e,
@@ -204,6 +269,8 @@ class GRLE(Component):
             "Farmlands added to the InfoLayer PNG file: %s.", info_layer_farmlands_path
         )
 
+        self.preview_paths["farmlands"] = info_layer_farmlands_path  # type: ignore
+
     # pylint: disable=R0915
     def _add_plants(self) -> None:
         """Adds plants to the InfoLayer PNG file."""
@@ -270,10 +337,13 @@ class GRLE(Component):
             grass_image[forest_image != 0] = 255
 
         # B and G channels remain the same (zeros), while we change the R channel.
-        possible_R_values = [33, 65, 97, 129, 161, 193, 225]  # pylint: disable=C0103
+        possible_R_values = [65, 97, 129, 161, 193, 225]  # pylint: disable=C0103
 
-        # 1st approach: Change the non zero values in the base image to 33 (for debug).
-        # And use the base image as R channel in the density map.
+        base_layer_pixel_value = plant_to_pixel_value(
+            self.map.grle_settings.base_grass  # type:ignore
+        )
+        if not base_layer_pixel_value:
+            base_layer_pixel_value = 131
 
         # pylint: disable=no-member
         def create_island_of_plants(image: np.ndarray, count: int) -> np.ndarray:
@@ -290,23 +360,20 @@ class GRLE(Component):
                 # Randomly choose the value for the island.
                 plant_value = choice(possible_R_values)
                 # Randomly choose the size of the island.
-                island_size = randint(ISLAND_SIZE_MIN, ISLAND_SIZE_MAX)
+                island_size = randint(
+                    self.map.grle_settings.plants_island_minimum_size,  # type:ignore
+                    self.map.grle_settings.plants_island_maximum_size,  # type:ignore
+                )
                 # Randomly choose the position of the island.
-                # x = np.random.randint(0, image.shape[1] - island_size)
-                # y = np.random.randint(0, image.shape[0] - island_size)
                 x = randint(0, image.shape[1] - island_size)
                 y = randint(0, image.shape[0] - island_size)
 
-                # Randomly choose the shape of the island.
-                # shapes = ["circle", "ellipse", "polygon"]
-                # shape = choice(shapes)
-
                 try:
                     polygon_points = get_rounded_polygon(
-                        num_vertices=ISLAND_VERTEX_COUNT,
+                        num_vertices=self.map.grle_settings.plants_island_vertex_count,
                         center=(x + island_size // 2, y + island_size // 2),
                         radius=island_size // 2,
-                        rounding_radius=ISLAND_ROUNDING_RADIUS,
+                        rounding_radius=self.map.grle_settings.plants_island_rounding_radius,
                     )
                     if not polygon_points:
                         continue
@@ -355,16 +422,16 @@ class GRLE(Component):
         grass_image_copy = grass_image.copy()
         if forest_image is not None:
             # Add the forest layer to the base image, to merge the masks.
-            grass_image_copy[forest_image != 0] = 33
-        # Set all the non-zero values to 33.
-        grass_image_copy[grass_image != 0] = 33
+            grass_image_copy[forest_image != 0] = base_layer_pixel_value
+
+        grass_image_copy[grass_image != 0] = base_layer_pixel_value
 
         # Add islands of plants to the base image.
-        island_count = self.map_size
+        island_count = int(self.map_size * self.map.grle_settings.plants_island_percent // 100)
         self.logger.debug("Adding %s islands of plants to the base image.", island_count)
         if self.map.grle_settings.random_plants:
             grass_image_copy = create_island_of_plants(grass_image_copy, island_count)
-        self.logger.debug("Islands of plants added to the base image.")
+            self.logger.info("Added %s islands of plants to the base image.", island_count)
 
         # Sligtly reduce the size of the grass_image, that we'll use as mask.
         kernel = np.ones((3, 3), np.uint8)
@@ -380,7 +447,6 @@ class GRLE(Component):
         grass_image_copy[:, 0] = 0  # Left side
         grass_image_copy[:, -1] = 0  # Right side
 
-        # Value of 33 represents the base grass plant.
         # After painting it with base grass, we'll create multiple islands of different plants.
         # On the final step, we'll remove all the values which in pixels
         # where zerons in the original base image (so we don't paint grass where it should not be).

maps4fs/generator/i3d.py

@@ -14,14 +14,10 @@ import numpy as np
 from maps4fs.generator.component import Component
 from maps4fs.generator.texture import Texture
 
-DEFAULT_HEIGHT_SCALE = 2000
 DISPLACEMENT_LAYER_SIZE_FOR_BIG_MAPS = 32768
-DEFAULT_MAX_LOD_DISTANCE = 10000
-DEFAULT_MAX_LOD_OCCLUDER_DISTANCE = 10000
 NODE_ID_STARTING_VALUE = 2000
 SPLINES_NODE_ID_STARTING_VALUE = 5000
 TREE_NODE_ID_STARTING_VALUE = 10000
-DEFAULT_FOREST_DENSITY = 10
 
 
 # pylint: disable=R0903
@@ -81,6 +77,20 @@ class I3d(Component):
 
         root = tree.getroot()
         for map_elem in root.iter("Scene"):
+            for terrain_elem in map_elem.iter("TerrainTransformGroup"):
+                if self.map.shared_settings.change_height_scale:
+                    suggested_height_scale = self.map.shared_settings.height_scale_value
+                    if suggested_height_scale is not None and suggested_height_scale > 255:
+                        new_height_scale = int(
+                            self.map.shared_settings.height_scale_value  # type: ignore
+                        )
+                        terrain_elem.set("heightScale", str(new_height_scale))
+                        self.logger.info(
+                            "heightScale attribute set to %s in TerrainTransformGroup element.",
+                            new_height_scale,
+                        )
+
+                self.logger.debug("TerrainTransformGroup element updated in I3D file.")
             sun_elem = map_elem.find(".//Light[@name='sun']")
 
             if sun_elem is not None:
@@ -97,10 +107,6 @@ class I3d(Component):
                 )
 
         if self.map_size > 4096:
-            terrain_elem = root.find(".//TerrainTransformGroup")
-            if terrain_elem is None:
-                self.logger.warning("TerrainTransformGroup element not found in I3D file.")
-                return
             displacement_layer = terrain_elem.find(".//DisplacementLayer")  # pylint: disable=W0631
 
             if displacement_layer is not None:
@@ -146,7 +152,7 @@ class I3d(Component):
             self.logger.warning("Roads polylines data not found in textures info layer.")
             return
 
-        self.logger.info("Found %s roads polylines in textures info layer.", len(roads_polylines))
+        self.logger.debug("Found %s roads polylines in textures info layer.", len(roads_polylines))
         self.logger.debug("Starging to add roads polylines to the I3D file.")
 
         root = tree.getroot()
@@ -188,7 +194,7 @@ class I3d(Component):
                         linestring_points=road, angle=self.rotation
                     )
                 except ValueError as e:
-                    self.logger.warning(
+                    self.logger.debug(
                         "Road %s could not be fitted into the map bounds with error: %s",
                         road_id,
                         e,
@@ -239,7 +245,7 @@ class I3d(Component):
                     y = max(0, min(y, dem_y_size - 1))
 
                     z = not_resized_dem[y, x]
-                    z /= 32  # Yes, it's a magic number here.
+                    z *= self.get_z_scaling_factor()  # type: ignore
 
                     cv_node = ET.Element("cv")
                     cv_node.set("c", f"{cx}, {z}, {cy}")
@@ -291,7 +297,7 @@ class I3d(Component):
             self.logger.warning("Fields data not found in textures info layer.")
             return
 
-        self.logger.info("Found %s fields in textures info layer.", len(fields))
+        self.logger.debug("Found %s fields in textures info layer.", len(fields))
         self.logger.debug("Starging to add fields to the I3D file.")
 
         root = tree.getroot()
@@ -313,7 +319,7 @@ class I3d(Component):
                             polygon_points=field, angle=self.rotation
                         )
                     except ValueError as e:
-                        self.logger.warning(
+                        self.logger.debug(
                             "Field %s could not be fitted into the map bounds with error: %s",
                             field_id,
                             e,
@@ -327,7 +333,7 @@ class I3d(Component):
                     try:
                         cx, cy = self.get_polygon_center(field_ccs)
                     except Exception as e:  # pylint: disable=W0718
-                        self.logger.warning(
+                        self.logger.debug(
                             "Field %s could not be fitted into the map bounds.", field_id
                         )
                         self.logger.debug("Error: %s", e)

maps4fs/generator/map.py

@@ -8,7 +8,7 @@ import shutil
 from typing import Any, Generator
 
 from maps4fs.generator.component import Component
-from maps4fs.generator.dtm import DTMProvider, DTMProviderSettings
+from maps4fs.generator.dtm.dtm import DTMProvider, DTMProviderSettings
 from maps4fs.generator.game import Game
 from maps4fs.generator.settings import (
     BackgroundSettings,
@@ -16,6 +16,7 @@ from maps4fs.generator.settings import (
     GRLESettings,
     I3DSettings,
     SatelliteSettings,
+    SharedSettings,
     SplineSettings,
     TextureSettings,
 )
@@ -88,6 +89,17 @@ class Map:
 
         self.dem_settings = dem_settings
         self.logger.info("DEM settings: %s", dem_settings)
+        if self.dem_settings.water_depth > 0:
+            # Make sure that the plateau value is >= water_depth
+            self.dem_settings.plateau = max(
+                self.dem_settings.plateau, self.dem_settings.water_depth
+            )
+            self.logger.info(
+                "Plateau value was set to %s to be >= water_depth value %s",
+                self.dem_settings.plateau,
+                self.dem_settings.water_depth,
+            )
+
         self.background_settings = background_settings
         self.logger.info("Background settings: %s", background_settings)
         self.grle_settings = grle_settings
@@ -123,6 +135,8 @@ class Map:
         with open(save_path, "w", encoding="utf-8") as file:
             json.dump(settings_json, file, indent=4)
 
+        self.shared_settings = SharedSettings()
+
         self.texture_custom_schema = kwargs.get("texture_custom_schema", None)
         if self.texture_custom_schema:
             save_path = os.path.join(self.map_directory, "texture_custom_schema.json")
@@ -132,11 +146,17 @@ class Map:
 
         self.tree_custom_schema = kwargs.get("tree_custom_schema", None)
         if self.tree_custom_schema:
+            self.logger.info("Custom tree schema contains %s trees", len(self.tree_custom_schema))
             save_path = os.path.join(self.map_directory, "tree_custom_schema.json")
             with open(save_path, "w", encoding="utf-8") as file:
                 json.dump(self.tree_custom_schema, file, indent=4)
             self.logger.debug("Tree custom schema saved to %s", save_path)
 
+        self.custom_background_path = kwargs.get("custom_background_path", None)
+        if self.custom_background_path:
+            save_path = os.path.join(self.map_directory, "custom_background.png")
+            shutil.copyfile(self.custom_background_path, save_path)
+
         try:
             shutil.unpack_archive(game.template_path, self.map_directory)
             self.logger.debug("Map template unpacked to %s", self.map_directory)
@@ -245,7 +265,7 @@ class Map:
             str: Path to the archive.
         """
         archive_path = shutil.make_archive(archive_path, "zip", self.map_directory)
-        self.logger.info("Map packed to %s.zip", archive_path)
+        self.logger.debug("Map packed to %s.zip", archive_path)
         if remove_source:
             try:
                 shutil.rmtree(self.map_directory)

maps4fs/generator/satellite.py

@@ -34,7 +34,7 @@ class Satellite(Component):
         """Downloads the satellite images for the map."""
         self.image_paths = []  # pylint: disable=W0201
         if not self.map.satellite_settings.download_images:
-            self.logger.info("Satellite images download is disabled.")
+            self.logger.debug("Satellite images download is disabled.")
             return
 
         margin = self.map.satellite_settings.satellite_margin

maps4fs/generator/settings.py

@@ -4,12 +4,29 @@ from __future__ import annotations
 
 from typing import Any
 
-from pydantic import BaseModel
+from pydantic import BaseModel, ConfigDict
+
+
+class SharedSettings(BaseModel):
+    """Represents the shared settings for all components."""
+
+    mesh_z_scaling_factor: float | None = None
+    height_scale_multiplier: float | None = None
+    height_scale_value: float | None = None
+    change_height_scale: bool = False
+
+    model_config = ConfigDict(
+        frozen=False,
+    )
 
 
 class SettingsModel(BaseModel):
     """Base class for settings models. It provides methods to convert settings to and from JSON."""
 
+    model_config = ConfigDict(
+        frozen=False,
+    )
+
     @classmethod
     def all_settings_to_json(cls) -> dict[str, dict[str, Any]]:
         """Get all settings of the current class and its subclasses as a dictionary.
@@ -25,18 +42,28 @@ class SettingsModel(BaseModel):
         return all_settings
 
     @classmethod
-    def all_settings_from_json(cls, data: dict) -> dict[str, SettingsModel]:
+    def all_settings_from_json(
+        cls, data: dict, flattening: bool = True
+    ) -> dict[str, SettingsModel]:
         """Create settings instances from JSON data.
 
         Arguments:
             data (dict): JSON data.
+            flattening (bool): if set to True will flattet iterables to use the first element
+                of it.
 
         Returns:
             dict[str, Type[SettingsModel]]: Dictionary with settings instances.
         """
         settings = {}
         for subclass in cls.__subclasses__():
-            settings[subclass.__name__] = subclass(**data[subclass.__name__])
+            subclass_data = data[subclass.__name__]
+            if flattening:
+                for key, value in subclass_data.items():
+                    if isinstance(value, (list, tuple)):
+                        subclass_data[key] = value[0]
+
+            settings[subclass.__name__] = subclass(**subclass_data)
 
         return settings
 
@@ -85,6 +112,10 @@ class BackgroundSettings(SettingsModel):
     generate_background: bool = False
     generate_water: bool = False
     resize_factor: int = 8
+    remove_center: bool = False
+    apply_decimation: bool = False
+    decimation_percent: int = 25
+    decimation_agression: int = 3
 
 
 class GRLESettings(SettingsModel):
@@ -100,6 +131,12 @@ class GRLESettings(SettingsModel):
     farmland_margin: int = 0
     random_plants: bool = True
     add_farmyards: bool = False
+    base_grass: tuple | str = ("smallDenseMix", "meadow")
+    plants_island_minimum_size: int = 10
+    plants_island_maximum_size: int = 200
+    plants_island_vertex_count: int = 30
+    plants_island_rounding_radius: int = 15
+    plants_island_percent: int = 100
 
 
 class I3DSettings(SettingsModel):

maps4fs/generator/texture.py

@@ -5,6 +5,8 @@ from __future__ import annotations
 import json
 import os
 import re
+import shutil
+import warnings
 from collections import defaultdict
 from typing import Any, Callable, Generator, Optional
 
@@ -69,6 +71,7 @@ class Texture(Component):
             usage: str | None = None,
             background: bool = False,
             invisible: bool = False,
+            procedural: list[str] | None = None,
         ):
             self.name = name
             self.count = count
@@ -81,6 +84,7 @@ class Texture(Component):
             self.usage = usage
             self.background = background
             self.invisible = invisible
+            self.procedural = procedural
 
         def to_json(self) -> dict[str, str | list[str] | bool]:  # type: ignore
             """Returns dictionary with layer data.
@@ -99,6 +103,7 @@ class Texture(Component):
                 "usage": self.usage,
                 "background": self.background,
                 "invisible": self.invisible,
+                "procedural": self.procedural,
             }
 
             data = {k: v for k, v in data.items() if v is not None}
@@ -187,7 +192,7 @@ class Texture(Component):
         custom_schema = self.kwargs.get("texture_custom_schema")
         if custom_schema:
             layers_schema = custom_schema  # type: ignore
-            self.logger.info("Custom schema loaded with %s layers.", len(layers_schema))
+            self.logger.debug("Custom schema loaded with %s layers.", len(layers_schema))
         else:
             if not os.path.isfile(self.game.texture_schema):
                 raise FileNotFoundError(
@@ -202,18 +207,20 @@ class Texture(Component):
 
         try:
             self.layers = [self.Layer.from_json(layer) for layer in layers_schema]  # type: ignore
-            self.logger.info("Loaded %s layers.", len(self.layers))
+            self.logger.debug("Loaded %s layers.", len(self.layers))
         except Exception as e:  # pylint: disable=W0703
             raise ValueError(f"Error loading texture layers: {e}") from e
 
         base_layer = self.get_base_layer()
         if base_layer:
             self.logger.debug("Base layer found: %s.", base_layer.name)
-        else:
-            self.logger.warning("No base layer found.")
 
         self._weights_dir = self.game.weights_dir_path(self.map_directory)
         self.logger.debug("Weights directory: %s.", self._weights_dir)
+        self.procedural_dir = os.path.join(self._weights_dir, "masks")
+        os.makedirs(self.procedural_dir, exist_ok=True)
+        self.logger.debug("Procedural directory: %s.", self.procedural_dir)
+
         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)
 
@@ -253,11 +260,56 @@ class Texture(Component):
                 return layer
         return None
 
-    def process(self):
+    def process(self) -> None:
+        """Processes the data to generate textures."""
         self._prepare_weights()
         self._read_parameters()
         self.draw()
         self.rotate_textures()
+        self.copy_procedural()
+
+    def copy_procedural(self) -> None:
+        """Copies some of the textures to use them as mask for procedural generation.
+        Creates an empty blockmask if it does not exist."""
+        blockmask_path = os.path.join(self.procedural_dir, "BLOCKMASK.png")
+        if not os.path.isfile(blockmask_path):
+            self.logger.debug("BLOCKMASK.png not found, creating an empty file.")
+            img = np.zeros((self.map_size, self.map_size), dtype=np.uint8)
+            cv2.imwrite(blockmask_path, img)  # pylint: disable=no-member
+
+        pg_layers_by_type = defaultdict(list)
+        for layer in self.layers:
+            if layer.procedural:
+                # Get path to the original file.
+                texture_path = layer.get_preview_or_path(self._weights_dir)
+                for procedural_layer_name in layer.procedural:
+                    pg_layers_by_type[procedural_layer_name].append(texture_path)
+
+        if not pg_layers_by_type:
+            self.logger.debug("No procedural layers found.")
+            return
+
+        for procedural_layer_name, texture_paths in pg_layers_by_type.items():
+            procedural_save_path = os.path.join(self.procedural_dir, f"{procedural_layer_name}.png")
+            if len(texture_paths) > 1:
+                # If there are more than one texture, merge them.
+                merged_texture = np.zeros((self.map_size, self.map_size), dtype=np.uint8)
+                for texture_path in texture_paths:
+                    # pylint: disable=E1101
+                    texture = cv2.imread(texture_path, cv2.IMREAD_UNCHANGED)
+                    merged_texture[texture == 255] = 255
+                cv2.imwrite(procedural_save_path, merged_texture)  # pylint: disable=no-member
+                self.logger.debug(
+                    "Procedural file %s merged from %s textures.",
+                    procedural_save_path,
+                    len(texture_paths),
+                )
+            elif len(texture_paths) == 1:
+                # Otherwise, copy the texture.
+                shutil.copyfile(texture_paths[0], procedural_save_path)
+                self.logger.debug(
+                    "Procedural file %s copied from %s.", procedural_save_path, texture_paths[0]
+                )
 
     def rotate_textures(self) -> None:
         """Rotates textures of the layers which have tags."""
@@ -276,8 +328,6 @@ class Texture(Component):
                                 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
@@ -305,8 +355,7 @@ class Texture(Component):
         useful_attributes = [
             "coordinates",
             "bbox",
-            "map_height",
-            "map_width",
+            "map_size",
             "rotation",
             "minimum_x",
             "minimum_y",
@@ -510,7 +559,7 @@ class Texture(Component):
                 cv2.imwrite(sublayer_path, sublayer)
                 self.logger.debug("Sublayer %s saved.", sublayer_path)
 
-            self.logger.info("Dissolved layer %s.", layer.name)
+            self.logger.debug("Dissolved layer %s.", layer.name)
 
     def draw_base_layer(self, cumulative_image: np.ndarray) -> None:
         """Draws base layer and saves it into the png file.
@@ -596,7 +645,7 @@ class Texture(Component):
         geometry_type = geometry.geom_type
         converter = self._converters(geometry_type)
         if not converter:
-            self.logger.warning("Geometry type %s not supported.", geometry_type)
+            self.logger.debug("Geometry type %s not supported.", geometry_type)
             return None
         return converter(geometry, width)
 
@@ -667,7 +716,9 @@ class Texture(Component):
         is_fieds = info_layer == "fields"
         try:
             if self.map.custom_osm is not None:
-                objects = ox.features_from_xml(self.map.custom_osm, tags=tags)
+                with warnings.catch_warnings():
+                    warnings.simplefilter("ignore", FutureWarning)
+                    objects = ox.features_from_xml(self.map.custom_osm, tags=tags)
             else:
                 objects = ox.features_from_bbox(bbox=self.new_bbox, tags=tags)
         except Exception as e:  # pylint: disable=W0718
@@ -726,6 +777,8 @@ class Texture(Component):
 
                 if not isinstance(padded_polygon, shapely.geometry.polygon.Polygon):
                     self.logger.warning("The padding value is too high, field will not padded.")
+                elif not list(padded_polygon.exterior.coords):
+                    self.logger.warning("The padding value is too high, field will not padded.")
                 else:
                     polygon = padded_polygon