maps4fs 0.7.8__py3-none-any.whl → 0.8.2__py3-none-any.whl

maps4fs/generator/component.py

@@ -15,6 +15,7 @@ class Component:
     """Base class for all map generation components.
 
     Args:
+        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.

maps4fs/generator/config.py

@@ -22,13 +22,15 @@ class Config(Component):
     """
 
     def preprocess(self) -> None:
+        """Gets the path to the map XML file and saves it to the instance variable."""
         self._map_xml_path = self.game.map_xml_path(self.map_directory)
         self.logger.debug("Map XML path: %s.", self._map_xml_path)
 
-    def process(self):
+    def process(self) -> None:
+        """Sets the map size in the map.xml file."""
         self._set_map_size()
 
-    def _set_map_size(self):
+    def _set_map_size(self) -> None:
         """Edits map.xml file to set correct map size."""
         if not os.path.isfile(self._map_xml_path):
             self.logger.warning("Map XML file not found: %s.", self._map_xml_path)

maps4fs/generator/dem.py

@@ -14,7 +14,7 @@ from maps4fs.generator.component import Component
 
 SRTM = "https://elevation-tiles-prod.s3.amazonaws.com/skadi/{latitude_band}/{tile_name}.hgt.gz"
 DEFAULT_MULTIPLIER = 1
-DEFAULT_BLUR_RADIUS = 21
+DEFAULT_BLUR_RADIUS = 35
 
 
 # pylint: disable=R0903
@@ -47,6 +47,8 @@ class DEM(Component):
             "DEM value multiplier is %s, blur radius is %s.", self.multiplier, self.blur_radius
         )
 
+        self.auto_process = self.kwargs.get("auto_process", False)
+
     # pylint: disable=no-member
     def process(self) -> None:
         """Reads SRTM file, crops it to map size, normalizes and blurs it,
@@ -105,15 +107,12 @@ class DEM(Component):
             resampled_data.min(),
         )
 
-        resampled_data = resampled_data * self.multiplier
-        self.logger.debug(
-            "DEM data multiplied by %s. Shape: %s, dtype: %s. Min: %s, max: %s.",
-            self.multiplier,
-            resampled_data.shape,
-            resampled_data.dtype,
-            resampled_data.min(),
-            resampled_data.max(),
-        )
+        if self.auto_process:
+            self.logger.debug("Auto processing is enabled, will normalize DEM data.")
+            resampled_data = self._normalize_dem(resampled_data)
+        else:
+            self.logger.debug("Auto processing is disabled, DEM data will not be normalized.")
+            resampled_data = resampled_data * self.multiplier
 
         self.logger.debug(
             "DEM data was resampled. Shape: %s, dtype: %s. Min: %s, max: %s.",
@@ -123,7 +122,9 @@ class DEM(Component):
             resampled_data.max(),
         )
 
-        resampled_data = cv2.GaussianBlur(resampled_data, (self.blur_radius, self.blur_radius), 0)
+        resampled_data = cv2.GaussianBlur(
+            resampled_data, (self.blur_radius, self.blur_radius), sigmaX=40, sigmaY=40
+        )
         self.logger.debug(
             "Gaussion blur applied to DEM data with kernel size %s.",
             self.blur_radius,
@@ -254,7 +255,7 @@ class DEM(Component):
 
         self.logger.debug("Creating colored preview of DEM data in %s.", colored_dem_path)
 
-        dem_data = cv2.imread(self._dem_path, cv2.IMREAD_UNCHANGED)
+        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.",
@@ -289,3 +290,42 @@ class DEM(Component):
         """
         self.logger.debug("Starting DEM previews generation.")
         return [self.grayscale_preview(), self.colored_preview()]
+
+    def _get_scaling_factor(self, maximum_deviation: int) -> float:
+        ESTIMATED_MAXIMUM_DEVIATION = 1000  # pylint: disable=C0103
+        scaling_factor = maximum_deviation / ESTIMATED_MAXIMUM_DEVIATION
+        return scaling_factor if scaling_factor < 1 else 1
+
+    def _normalize_dem(self, data: np.ndarray) -> np.ndarray:
+        """Normalize DEM data to 16-bit unsigned integer using max height from settings.
+        Args:
+            data (np.ndarray): DEM data from SRTM file after cropping.
+        Returns:
+            np.ndarray: Normalized DEM data.
+        """
+        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
+        self.logger.debug(
+            "Maximum deviation: %s with maximum at %s and minimum at %s.",
+            max_dev,
+            max_height,
+            min_height,
+        )
+
+        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}."
+        )
+        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()}."
+        )
+        return normalized_data

maps4fs/generator/game.py

@@ -8,6 +8,7 @@ import os
 
 from maps4fs.generator.config import Config
 from maps4fs.generator.dem import DEM
+from maps4fs.generator.i3d import I3d
 from maps4fs.generator.texture import Texture
 
 working_directory = os.getcwd()
@@ -34,7 +35,7 @@ class Game:
     _map_template_path: str | None = None
     _texture_schema: str | None = None
 
-    components = [Config, Texture, DEM]
+    components = [Config, Texture, DEM, I3d]
 
     def __init__(self, map_template_path: str | None = None):
         if map_template_path:
@@ -113,6 +114,16 @@ class Game:
             str: The path to the weights directory."""
         raise NotImplementedError
 
+    def i3d_file_path(self, map_directory: str) -> str:
+        """Returns the path to the i3d file.
+
+        Arguments:
+            map_directory (str): The path to the map directory.
+
+        Returns:
+            str: The path to the i3d file."""
+        raise NotImplementedError
+
     @property
     def additional_dem_name(self) -> str | None:
         """Returns the name of the additional DEM file.
@@ -122,6 +133,7 @@ class Game:
         return self._additional_dem_name
 
 
+# pylint: disable=W0223
 class FS22(Game):
     """Class used to define the game version FS22."""
 
@@ -189,3 +201,13 @@ class FS25(Game):
         Returns:
             str: The path to the weights directory."""
         return os.path.join(map_directory, "mapUS", "data")
+
+    def i3d_file_path(self, map_directory: str) -> str:
+        """Returns the path to the i3d file.
+
+        Arguments:
+            map_directory (str): The path to the map directory.
+
+        Returns:
+            str: The path to the i3d file."""
+        return os.path.join(map_directory, "mapUS", "mapUS.i3d")

maps4fs/generator/i3d.py

@@ -0,0 +1,89 @@
+"""This module contains the Config class for map settings and configuration."""
+
+from __future__ import annotations
+
+import os
+from xml.etree import ElementTree as ET
+
+from maps4fs.generator.component import Component
+
+DEFAULT_HEIGHT_SCALE = 2000
+DEFAULT_MAX_LOD_DISTANCE = 10000
+DEFAULT_MAX_LOD_OCCLUDER_DISTANCE = 10000
+
+
+# pylint: disable=R0903
+class I3d(Component):
+    """Component for map i3d file settings and configuration.
+
+    Args:
+        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_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.
+    """
+
+    _map_i3d_path: 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."""
+        try:
+            self._map_i3d_path = self.game.i3d_file_path(self.map_directory)
+            self.logger.debug("Map I3D path: %s.", self._map_i3d_path)
+        except NotImplementedError:
+            self.logger.info("I3D file processing is not implemented for this game.")
+            self._map_i3d_path = None
+
+    def process(self) -> None:
+        """Updates the map I3D file with the default settings."""
+        self._update_i3d_file()
+
+    def _update_i3d_file(self) -> None:
+        """Updates the map I3D file with the default settings."""
+        if not self._map_i3d_path:
+            self.logger.info("I3D is not obtained, skipping the update.")
+            return
+        if not os.path.isfile(self._map_i3d_path):
+            self.logger.warning("I3D file not found: %s.", self._map_i3d_path)
+            return
+
+        tree = ET.parse(self._map_i3d_path)
+
+        self.logger.debug("Map I3D file loaded from: %s.", self._map_i3d_path)
+
+        root = tree.getroot()
+        for map_elem in root.iter("Scene"):
+            for terrain_elem in map_elem.iter("TerrainTransformGroup"):
+                terrain_elem.set("heightScale", str(DEFAULT_HEIGHT_SCALE))
+                self.logger.debug(
+                    "heightScale attribute set to %s in TerrainTransformGroup element.",
+                    DEFAULT_HEIGHT_SCALE,
+                )
+                terrain_elem.set("maxLODDistance", str(DEFAULT_MAX_LOD_DISTANCE))
+                self.logger.debug(
+                    "maxLODDistance attribute set to %s in TerrainTransformGroup element.",
+                    DEFAULT_MAX_LOD_DISTANCE,
+                )
+
+                terrain_elem.set("occMaxLODDistance", str(DEFAULT_MAX_LOD_OCCLUDER_DISTANCE))
+                self.logger.debug(
+                    "occMaxLODDistance attribute set to %s in TerrainTransformGroup element.",
+                    DEFAULT_MAX_LOD_OCCLUDER_DISTANCE,
+                )
+
+                self.logger.debug("TerrainTransformGroup element updated in I3D file.")
+
+        tree.write(self._map_i3d_path)
+        self.logger.debug("Map I3D file saved to: %s.", self._map_i3d_path)
+
+    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 []

maps4fs/generator/map.py

@@ -47,6 +47,7 @@ class Map:
         self.logger.debug("Game was set to %s", game.code)
 
         self.kwargs = kwargs
+        self.logger.debug("Additional arguments: %s", kwargs)
 
         os.makedirs(self.map_directory, exist_ok=True)
         self.logger.debug("Map directory created: %s", self.map_directory)

maps4fs/generator/texture.py

@@ -57,6 +57,7 @@ class Texture(Component):
             width: int | None = None,
             color: tuple[int, int, int] | list[int] | None = None,
             exclude_weight: bool = False,
+            priority: int | None = None,
         ):
             self.name = name
             self.count = count
@@ -64,6 +65,7 @@ class Texture(Component):
             self.width = width
             self.color = color if color else (255, 255, 255)
             self.exclude_weight = exclude_weight
+            self.priority = priority
 
         def to_json(self) -> dict[str, str | list[str] | bool]:  # type: ignore
             """Returns dictionary with layer data.
@@ -77,6 +79,7 @@ class Texture(Component):
                 "width": self.width,
                 "color": list(self.color),
                 "exclude_weight": self.exclude_weight,
+                "priority": self.priority,
             }
 
             data = {k: v for k, v in data.items() if v is not None}
@@ -120,11 +123,28 @@ class Texture(Component):
         self.layers = [self.Layer.from_json(layer) for layer in layers_schema]
         self.logger.info("Loaded %s layers.", len(self.layers))
 
+        base_layer = self.get_base_layer()
+        if base_layer:
+            self.logger.info("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.info_save_path = os.path.join(self.map_directory, "generation_info.json")
         self.logger.debug("Generation info save path: %s.", self.info_save_path)
 
+    def get_base_layer(self) -> Layer | None:
+        """Returns base layer.
+
+        Returns:
+            Layer | None: Base layer.
+        """
+        for layer in self.layers:
+            if layer.priority == 0:
+                return layer
+        return None
+
     def process(self):
         self._prepare_weights()
         self._read_parameters()
@@ -239,22 +259,79 @@ class Texture(Component):
         """
         self._layers = layers
 
+    def layers_by_priority(self) -> list[Layer]:
+        """Returns list of layers sorted by priority: None priority layers are first,
+        then layers are sorted by priority (descending).
+
+        Returns:
+            list[Layer]: List of layers sorted by priority.
+        """
+        return sorted(
+            self.layers,
+            key=lambda _layer: (
+                _layer.priority is not None,
+                -_layer.priority if _layer.priority is not None else float("inf"),
+            ),
+        )
+
     # pylint: disable=no-member
     def draw(self) -> None:
         """Iterates over layers and fills them with polygons from OSM data."""
-        for layer in self.layers:
+        layers = self.layers_by_priority()
+
+        self.logger.debug(
+            "Sorted layers by priority: %s.", [(layer.name, layer.priority) for layer in layers]
+        )
+
+        cumulative_image = None
+
+        for layer in layers:
             if not layer.tags:
                 self.logger.debug("Layer %s has no tags, there's nothing to draw.", layer.name)
                 continue
+            if layer.priority == 0:
+                self.logger.debug(
+                    "Found base layer %s. Postponing that to be the last layer drawn.", layer.name
+                )
+                continue
             layer_path = layer.path(self._weights_dir)
             self.logger.debug("Drawing layer %s.", layer_path)
+            layer_image = cv2.imread(layer_path, cv2.IMREAD_UNCHANGED)
+
+            if cumulative_image is None:
+                self.logger.debug("First layer, creating new cumulative image.")
+                cumulative_image = layer_image
+
+            mask = cv2.bitwise_not(cumulative_image)
 
-            img = cv2.imread(layer_path, cv2.IMREAD_UNCHANGED)
             for polygon in self.polygons(layer.tags, layer.width):  # type: ignore
-                cv2.fillPoly(img, [polygon], color=255)  # type: ignore
-            cv2.imwrite(layer_path, img)
+                cv2.fillPoly(layer_image, [polygon], color=255)  # type: ignore
+
+            output_image = cv2.bitwise_and(layer_image, mask)
+
+            cumulative_image = cv2.bitwise_or(cumulative_image, output_image)
+
+            cv2.imwrite(layer_path, output_image)
             self.logger.debug("Texture %s saved.", layer_path)
 
+        if cumulative_image is not None:
+            self.draw_base_layer(cumulative_image)
+
+    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:
+            cumulative_image (np.ndarray): Cumulative image with all layers.
+        """
+        base_layer = self.get_base_layer()
+        if base_layer is not None:
+            layer_path = base_layer.path(self._weights_dir)
+            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)
+
     def get_relative_x(self, x: float) -> int:
         """Converts UTM X coordinate to relative X coordinate in map image.
 

{maps4fs-0.7.8.dist-info → maps4fs-0.8.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: maps4fs
-Version: 0.7.8
+Version: 0.8.2
 Summary: Generate map templates for Farming Simulator from real places.
 Author-email: iwatkot <iwatkot@gmail.com>
 License: MIT License
@@ -17,6 +17,7 @@ Requires-Dist: opencv-python
 Requires-Dist: osmnx<2.0.0
 Requires-Dist: rasterio
 Requires-Dist: tqdm
+Requires-Dist: folium
 
 <div align="center" markdown>
 <img src="https://github.com/iwatkot/maps4fs/assets/118521851/ffd7f0a3-e317-4c3f-911f-2c2fb736fbfa">

maps4fs-0.8.2.dist-info/RECORD

@@ -0,0 +1,15 @@
+maps4fs/__init__.py,sha256=da4jmND2Ths9AffnkAKgzLHNkvKFOc_l21gJisPXqWY,155
+maps4fs/logger.py,sha256=CneeHxQywjNUJXqQrUUSeiDxu95FfrfyK_Si1v0gMZ8,1477
+maps4fs/generator/__init__.py,sha256=zZMLEkGzb4z0xql650gOtGSvcgX58DnJ2yN3vC2daRk,43
+maps4fs/generator/component.py,sha256=CL3DNuvKAd44pynLfir_JLnBC0c9Kr233_BbSHQng6Q,3534
+maps4fs/generator/config.py,sha256=ln_XGUdiPnc4zzhMVEueZRf-FGljeHtCHUnJ6FRlE4w,2264
+maps4fs/generator/dem.py,sha256=L91hOxoXnn2LtpaH7fVA6Ke2i7JNfFk_KGMsVWHVNps,13169
+maps4fs/generator/game.py,sha256=mN9VeN4nk-e43oFujIC5GOGAQOYATKrmeIb1kLHuwtI,6773
+maps4fs/generator/i3d.py,sha256=UuQiQRusPQ2f6PvGKxJ_UZeXsx3uG15efmy8Ysnm3F8,3597
+maps4fs/generator/map.py,sha256=xYbSyGrcEB9CRJhVf8iTRCKLK6BvnewtlKO_Ut--Oik,3858
+maps4fs/generator/texture.py,sha256=uH09vnYSTklv2VxV6ys0DM_f8KXHmxQr9l6flwVguLU,18726
+maps4fs-0.8.2.dist-info/LICENSE.md,sha256=-JY0v7p3dwXze61EbYiK7YEJ2aKrjaFZ8y2xYEOrmRY,1068
+maps4fs-0.8.2.dist-info/METADATA,sha256=Ombva3jSyqSsTuzspfzp24DESv1G8lqRWLTuTN0L81w,11866
+maps4fs-0.8.2.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+maps4fs-0.8.2.dist-info/top_level.txt,sha256=Ue9DSRlejRQRCaJueB0uLcKrWwsEq9zezfv5dI5mV1M,8
+maps4fs-0.8.2.dist-info/RECORD,,

maps4fs-0.7.8.dist-info/RECORD

@@ -1,14 +0,0 @@
-maps4fs/__init__.py,sha256=da4jmND2Ths9AffnkAKgzLHNkvKFOc_l21gJisPXqWY,155
-maps4fs/logger.py,sha256=CneeHxQywjNUJXqQrUUSeiDxu95FfrfyK_Si1v0gMZ8,1477
-maps4fs/generator/__init__.py,sha256=zZMLEkGzb4z0xql650gOtGSvcgX58DnJ2yN3vC2daRk,43
-maps4fs/generator/component.py,sha256=BU_HNNyKXuEBohQJRTlXmNdSNrjolwX-ZzqqSSuzTrE,3463
-maps4fs/generator/config.py,sha256=luDYXkKjgOM4-Mft4mHDPP6v-DVIUyWZAMAsCKyvaoY,2108
-maps4fs/generator/dem.py,sha256=nVDDtDqj_rEOO2oPviBf4cUbqCnYmZbjDqypINzMLrs,11414
-maps4fs/generator/game.py,sha256=dfbLyu1yqbHkBWmJu1uANCX-84vkdlvqR6hA6JCiIsE,6107
-maps4fs/generator/map.py,sha256=zLIFAjjz-Y7u_FG-UjYoGiqBreLwuverkYY8Er9L_Qg,3796
-maps4fs/generator/texture.py,sha256=cEXQOLJ5Iq_Nb0C9OmU-9PR-E_5cgM1Q62kG49G3VNg,16019
-maps4fs-0.7.8.dist-info/LICENSE.md,sha256=-JY0v7p3dwXze61EbYiK7YEJ2aKrjaFZ8y2xYEOrmRY,1068
-maps4fs-0.7.8.dist-info/METADATA,sha256=D8NKpG80a8SOHQqnDagfQGCnWhYvdBgo10JivZTjZdA,11844
-maps4fs-0.7.8.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-maps4fs-0.7.8.dist-info/top_level.txt,sha256=Ue9DSRlejRQRCaJueB0uLcKrWwsEq9zezfv5dI5mV1M,8
-maps4fs-0.7.8.dist-info/RECORD,,