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

maps4fs/__init__.py

@@ -1,5 +1,7 @@
 # pylint: disable=missing-module-docstring
-from maps4fs.generator.dtm import DTMProvider
+from maps4fs.generator.dtm.dtm import DTMProvider
+from maps4fs.generator.dtm.srtm import SRTM30Provider
+from maps4fs.generator.dtm.usgs import USGSProvider
 from maps4fs.generator.game import Game
 from maps4fs.generator.map import Map
 from maps4fs.generator.settings import (

maps4fs/generator/background.py

@@ -58,6 +58,10 @@ class Background(Component):
         os.makedirs(self.water_directory, exist_ok=True)
 
         self.output_path = os.path.join(self.background_directory, f"{FULL_NAME}.png")
+        if self.map.custom_background_path:
+            self.check_custom_background(self.map.custom_background_path)
+            shutil.copyfile(self.map.custom_background_path, self.output_path)
+
         self.not_substracted_path = os.path.join(self.background_directory, "not_substracted.png")
         self.not_resized_path = os.path.join(self.background_directory, "not_resized.png")
 
@@ -75,6 +79,28 @@ class Background(Component):
         self.dem.set_output_resolution((self.rotated_size, self.rotated_size))
         self.dem.set_dem_path(self.output_path)
 
+    def check_custom_background(self, image_path: str) -> None:
+        """Checks if the custom background image meets the requirements.
+
+        Arguments:
+            image_path (str): The path to the custom background image.
+
+        Raises:
+            ValueError: If the custom background image does not meet the requirements.
+        """
+        image = cv2.imread(image_path, cv2.IMREAD_UNCHANGED)  # pylint: disable=no-member
+        if image.shape[0] != image.shape[1]:
+            raise ValueError("The custom background image must be a square.")
+
+        if image.shape[0] != self.map_size + DEFAULT_DISTANCE * 2:
+            raise ValueError("The custom background image must have the size of the map + 4096.")
+
+        if len(image.shape) != 2:
+            raise ValueError("The custom background image must be a grayscale image.")
+
+        if image.dtype != np.uint16:
+            raise ValueError("The custom background image must be a 16-bit grayscale image.")
+
     def is_preview(self, name: str) -> bool:
         """Checks if the DEM is a preview.
 
@@ -91,7 +117,9 @@ class Background(Component):
         as a result the DEM files will be saved, then based on them the obj files will be
         generated."""
         self.create_background_textures()
-        self.dem.process()
+
+        if not self.map.custom_background_path:
+            self.dem.process()
 
         shutil.copyfile(self.dem.dem_path, self.not_substracted_path)
         self.cutout(self.dem.dem_path, save_path=self.not_resized_path)
@@ -148,6 +176,9 @@ class Background(Component):
             "east": east,
             "west": west,
         }
+
+        dem_info_sequence = self.dem.info_sequence()
+        data["DEM"] = dem_info_sequence
         return data  # type: ignore
 
     def qgis_sequence(self) -> None:
@@ -176,7 +207,13 @@ class Background(Component):
         self.logger.debug("Generating obj file in path: %s", save_path)
 
         dem_data = cv2.imread(self.dem.dem_path, cv2.IMREAD_UNCHANGED)  # pylint: disable=no-member
-        self.plane_from_np(dem_data, save_path)  # type: ignore
+        self.plane_from_np(
+            dem_data,
+            save_path,
+            create_preview=True,
+            remove_center=self.map.background_settings.remove_center,
+            include_zeros=False,
+        )  # type: ignore
 
     # pylint: disable=too-many-locals
     def cutout(self, dem_path: str, save_path: str | None = None) -> str:
@@ -219,16 +256,37 @@ class Background(Component):
         )
 
         cv2.imwrite(main_dem_path, resized_dem_data)  # pylint: disable=no-member
-        self.logger.info("DEM cutout saved: %s", main_dem_path)
+        self.logger.debug("DEM cutout saved: %s", main_dem_path)
 
         return main_dem_path
 
-    # pylint: disable=too-many-locals
+    def remove_center(self, dem_data: np.ndarray, resize_factor: float) -> np.ndarray:
+        """Removes the center part of the DEM data.
+
+        Arguments:
+            dem_data (np.ndarray) -- The DEM data as a numpy array.
+            resize_factor (float) -- The resize factor of the DEM data.
+
+        Returns:
+            np.ndarray -- The DEM data with the center part removed.
+        """
+        center = (dem_data.shape[0] // 2, dem_data.shape[1] // 2)
+        half_size = int(self.map_size // 2 * resize_factor)
+        x1 = center[0] - half_size
+        x2 = center[0] + half_size
+        y1 = center[1] - half_size
+        y2 = center[1] + half_size
+        dem_data[x1:x2, y1:y2] = 0
+        return dem_data
+
+    # pylint: disable=R0913, R0917, R0915
     def plane_from_np(
         self,
         dem_data: np.ndarray,
         save_path: str,
         include_zeros: bool = True,
+        create_preview: bool = False,
+        remove_center: bool = False,
     ) -> None:
         """Generates a 3D obj file based on DEM data.
 
@@ -236,11 +294,18 @@ class Background(Component):
             dem_data (np.ndarray) -- The DEM data as a numpy array.
             save_path (str) -- The path where the obj file will be saved.
             include_zeros (bool, optional) -- If True, the mesh will include the zero height values.
+            create_preview (bool, optional) -- If True, a simplified mesh will be saved as an STL.
+            remove_center (bool, optional) -- If True, the center of the mesh will be removed.
+                This setting is used for a Background Terrain, where the center part where the
+                playable area is will be cut out.
         """
         resize_factor = 1 / self.map.background_settings.resize_factor
         dem_data = cv2.resize(  # pylint: disable=no-member
             dem_data, (0, 0), fx=resize_factor, fy=resize_factor
         )
+        if remove_center:
+            dem_data = self.remove_center(dem_data, resize_factor)
+            self.logger.debug("Center removed from DEM data.")
         self.logger.debug(
             "DEM data resized to shape: %s with factor: %s", dem_data.shape, resize_factor
         )
@@ -275,7 +340,10 @@ class Background(Component):
                 bottom_left = top_left + cols
                 bottom_right = bottom_left + 1
 
-                if ground in [z[i, j], z[i, j + 1], z[i + 1, j], z[i + 1, j + 1]]:
+                if (
+                    ground in [z[i, j], z[i, j + 1], z[i + 1, j], z[i + 1, j + 1]]
+                    and not include_zeros
+                ):
                     skipped += 1
                     continue
 
@@ -294,16 +362,32 @@ class Background(Component):
         mesh.apply_transform(rotation_matrix_z)
 
         # if not include_zeros:
-        z_scaling_factor = 1 / self.map.dem_settings.multiplier
+        z_scaling_factor = self.get_z_scaling_factor()
         self.logger.debug("Z scaling factor: %s", z_scaling_factor)
         mesh.apply_scale([1 / resize_factor, 1 / resize_factor, z_scaling_factor])
 
+        old_faces = len(mesh.faces)
+        self.logger.debug("Mesh generated with %s faces.", old_faces)
+
+        if self.map.background_settings.apply_decimation:
+            percent = self.map.background_settings.decimation_percent / 100
+            mesh = mesh.simplify_quadric_decimation(
+                percent=percent, aggression=self.map.background_settings.decimation_agression
+            )
+
+            new_faces = len(mesh.faces)
+            decimation_percent = (old_faces - new_faces) / old_faces * 100
+
+            self.logger.debug(
+                "Mesh simplified to %s faces. Decimation percent: %s", new_faces, decimation_percent
+            )
+
         mesh.export(save_path)
         self.logger.debug("Obj file saved: %s", save_path)
 
-        if include_zeros:
+        if create_preview:
             # Simplify the preview mesh to reduce the size of the file.
-            mesh = mesh.simplify_quadric_decimation(face_count=len(mesh.faces) // 2**7)
+            # mesh = mesh.simplify_quadric_decimation(face_count=len(mesh.faces) // 2**7)
 
             # Apply scale to make the preview mesh smaller in the UI.
             mesh.apply_scale([0.5, 0.5, 0.5])

maps4fs/generator/component.py

@@ -58,7 +58,7 @@ class Component:
         self.logger = logger
         self.kwargs = kwargs
 
-        self.logger.info(
+        self.logger.debug(
             "Component %s initialized. Map size: %s, map rotated size: %s",  # type: ignore
             self.__class__.__name__,
             self.map_size,
@@ -188,8 +188,7 @@ class Component:
         self,
         coordinates: tuple[float, float] | None = None,
         distance: int | None = None,
-        project_utm: bool = False,
-    ) -> tuple[int, int, int, int]:
+    ) -> tuple[float, float, float, float]:
         """Calculates the bounding box of the map from the coordinates and the height and
         width of the map.
         If coordinates and distance are not provided, the instance variables are used.
@@ -199,24 +198,23 @@ class Component:
                 of the map. Defaults to None.
             distance (int, optional): The distance from the center of the map to the edge of the
                 map in all directions. Defaults to None.
-            project_utm (bool, optional): Whether to project the bounding box to UTM.
 
         Returns:
-            tuple[int, int, int, int]: The bounding box of the map.
+            tuple[float, float, float, float]: The bounding box of the map.
         """
         coordinates = coordinates or self.coordinates
         distance = distance or int(self.map_rotated_size / 2)
 
         west, south, east, north = ox.utils_geo.bbox_from_point(  # type: ignore
-            coordinates, dist=distance, project_utm=project_utm
+            coordinates,
+            dist=distance,
         )
 
         bbox = north, south, east, west
         self.logger.debug(
-            "Calculated bounding box for component: %s: %s, project_utm: %s, distance: %s",
+            "Calculated bounding box for component: %s: %s, distance: %s",
             self.__class__.__name__,
             bbox,
-            project_utm,
             distance,
         )
         return bbox
@@ -225,7 +223,7 @@ class Component:
         """Saves the bounding box of the map to the component instance from the coordinates and the
         height and width of the map.
         """
-        self.bbox = self.get_bbox(project_utm=False)
+        self.bbox = self.get_bbox()
         self.logger.debug("Saved bounding box: %s", self.bbox)
 
     @property
@@ -535,3 +533,19 @@ class Component:
         interpolated_polyline.append(polyline[-1])
 
         return interpolated_polyline
+
+    def get_z_scaling_factor(self) -> float:
+        """Calculates the scaling factor for the Z axis based on the map settings.
+
+        Returns:
+            float -- The scaling factor for the Z axis.
+        """
+
+        scaling_factor = 1 / self.map.dem_settings.multiplier
+
+        if self.map.shared_settings.height_scale_multiplier:
+            scaling_factor *= self.map.shared_settings.height_scale_multiplier
+        if self.map.shared_settings.mesh_z_scaling_factor:
+            scaling_factor *= 1 / self.map.shared_settings.mesh_z_scaling_factor
+
+        return scaling_factor

maps4fs/generator/dem.py

@@ -1,6 +1,7 @@
 """This module contains DEM class for processing Digital Elevation Model data."""
 
 import os
+from typing import Any
 
 import cv2
 import numpy as np
@@ -9,7 +10,7 @@ import numpy as np
 from pympler import asizeof  # type: ignore
 
 from maps4fs.generator.component import Component
-from maps4fs.generator.dtm import DTMProvider
+from maps4fs.generator.dtm.dtm import DTMProvider
 
 
 # pylint: disable=R0903, R0902
@@ -63,6 +64,7 @@ class DEM(Component):
             size=self.map_rotated_size,
             directory=self.temp_dir,
             logger=self.logger,
+            map=self.map,
         )
 
     @property
@@ -281,54 +283,15 @@ class DEM(Component):
         """
         return []
 
-    def _get_scaling_factor(self, maximum_deviation: int) -> float:
-        """Calculate scaling factor for DEM data normalization.
-        NOTE: Needs reconsideration for the implementation.
+    def info_sequence(self) -> dict[Any, Any] | None:  # type: ignore
+        """Returns the information sequence for the component. Must be implemented in the child
+        class. If the component does not have an information sequence, an empty dictionary must be
+        returned.
 
-        Arguments:
-            maximum_deviation (int): Maximum deviation in DEM data.
-
-        Returns:
-            float: Scaling factor for DEM data normalization.
-        """
-        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.
-        Arguments:
-            data (np.ndarray): DEM data from SRTM file after cropping.
         Returns:
-            np.ndarray: Normalized DEM data.
+            dict[Any, Any]: The information sequence for the 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()
-        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,
-            max_height,
-            min_height,
-        )
-
-        scaling_factor = self._get_scaling_factor(max_dev)
-        adjusted_max_height = int(65535 * scaling_factor)
-        self.logger.debug(
-            "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(
-            "DEM data was normalized to %s - %s.",
-            normalized_data.min(),
-            normalized_data.max(),
-        )
-        return normalized_data
+        provider_info_sequence = self.dtm_provider.info_sequence()
+        if provider_info_sequence is None:
+            return {}
+        return provider_info_sequence

maps4fs/generator/{dtm.py → dtm/dtm.py}

@@ -4,11 +4,9 @@ and specific settings for downloading and processing the data."""
 
 from __future__ import annotations
 
-import gzip
-import math
+from abc import ABC, abstractmethod
 import os
-import shutil
-from typing import Type
+from typing import TYPE_CHECKING, Type
 
 import numpy as np
 import osmnx as ox  # type: ignore
@@ -18,24 +16,30 @@ from pydantic import BaseModel
 
 from maps4fs.logger import Logger
 
+if TYPE_CHECKING:
+    from maps4fs.generator.map import Map
+
 
 class DTMProviderSettings(BaseModel):
     """Base class for DTM provider settings models."""
 
 
-class DTMProvider:
+# pylint: disable=too-many-public-methods
+class DTMProvider(ABC):
     """Base class for DTM providers."""
 
     _code: str | None = None
     _name: str | None = None
     _region: str | None = None
     _icon: str | None = None
-    _resolution: float | None = None
+    _resolution: float | str | None = None
 
     _url: str | None = None
 
     _author: str | None = None
+    _contributors: str | None = None
     _is_community: bool = False
+    _is_base: bool = False
     _settings: Type[DTMProviderSettings] | None = None
 
     _instructions: str | None = None
@@ -48,6 +52,7 @@ class DTMProvider:
         size: int,
         directory: str,
         logger: Logger,
+        map: Map | None = None,  # pylint: disable=W0622
     ):
         self._coordinates = coordinates
         self._user_settings = user_settings
@@ -59,6 +64,27 @@ class DTMProvider:
         os.makedirs(self._tile_directory, exist_ok=True)
 
         self.logger = logger
+        self.map = map
+
+        self._data_info: dict[str, int | str | float] | None = None
+
+    @property
+    def data_info(self) -> dict[str, int | str | float] | None:
+        """Information about the DTM data.
+
+        Returns:
+            dict: Information about the DTM data.
+        """
+        return self._data_info
+
+    @data_info.setter
+    def data_info(self, value: dict[str, int | str | float] | None) -> None:
+        """Set information about the DTM data.
+
+        Arguments:
+            value (dict): Information about the DTM data.
+        """
+        self._data_info = value
 
     @property
     def coordinates(self) -> tuple[float, float]:
@@ -98,6 +124,24 @@ class DTMProvider:
         """
         return cls._author
 
+    @classmethod
+    def contributors(cls) -> str | None:
+        """Contributors of the provider.
+
+        Returns:
+            str: Contributors of the provider.
+        """
+        return cls._contributors
+
+    @classmethod
+    def is_base(cls) -> bool:
+        """Is the provider a base provider.
+
+        Returns:
+            bool: True if the provider is a base provider, False otherwise.
+        """
+        return cls._is_base
+
     @classmethod
     def is_community(cls) -> bool:
         """Is the provider a community-driven project.
@@ -168,7 +212,8 @@ class DTMProvider:
         """
         providers = {}
         for provider in cls.__subclasses__():
-            providers[provider._code] = provider.description()  # pylint: disable=W0212
+            if not provider.is_base():
+                providers[provider._code] = provider.description()  # pylint: disable=W0212
         return providers  # type: ignore
 
     def download_tile(self, output_path: str, **kwargs) -> bool:
@@ -213,6 +258,7 @@ class DTMProvider:
         """
         raise NotImplementedError
 
+    @abstractmethod
     def get_numpy(self) -> np.ndarray:
         """Get numpy array of the tile.
         Resulting array must be 16 bit (signed or unsigned) integer and it should be already
@@ -264,70 +310,12 @@ class DTMProvider:
 
         return data
 
-
-class SRTM30Provider(DTMProvider):
-    """Provider of Shuttle Radar Topography Mission (SRTM) 30m data."""
-
-    _code = "srtm30"
-    _name = "SRTM 30 m"
-    _region = "Global"
-    _icon = "🌎"
-    _resolution = 30.0
-
-    _url = "https://elevation-tiles-prod.s3.amazonaws.com/skadi/{latitude_band}/{tile_name}.hgt.gz"
-
-    _author = "[iwatkot](https://github.com/iwatkot)"
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.hgt_directory = os.path.join(self._tile_directory, "hgt")
-        self.gz_directory = os.path.join(self._tile_directory, "gz")
-        os.makedirs(self.hgt_directory, exist_ok=True)
-        os.makedirs(self.gz_directory, exist_ok=True)
-
-    def get_tile_parameters(self, *args, **kwargs) -> dict[str, str]:
-        """Returns latitude band and tile name for SRTM tile from coordinates.
-
-        Arguments:
-            lat (float): Latitude.
-            lon (float): Longitude.
+    def info_sequence(self) -> dict[str, int | str | float] | None:
+        """Returns the information sequence for the component. Must be implemented in the child
+        class. If the component does not have an information sequence, an empty dictionary must be
+        returned.
 
         Returns:
-            dict: Tile parameters.
+            dict[str, int | str | float] | None: Information sequence for the component.
         """
-        lat, lon = args
-
-        tile_latitude = math.floor(lat)
-        tile_longitude = math.floor(lon)
-
-        latitude_band = f"N{abs(tile_latitude):02d}" if lat >= 0 else f"S{abs(tile_latitude):02d}"
-        if lon < 0:
-            tile_name = f"{latitude_band}W{abs(tile_longitude):03d}"
-        else:
-            tile_name = f"{latitude_band}E{abs(tile_longitude):03d}"
-
-        self.logger.debug(
-            "Detected tile name: %s for coordinates: lat %s, lon %s.", tile_name, lat, lon
-        )
-        return {"latitude_band": latitude_band, "tile_name": tile_name}
-
-    def get_numpy(self) -> np.ndarray:
-        """Get numpy array of the tile.
-
-        Returns:
-            np.ndarray: Numpy array of the tile.
-        """
-        tile_parameters = self.get_tile_parameters(*self.coordinates)
-        tile_name = tile_parameters["tile_name"]
-        decompressed_tile_path = os.path.join(self.hgt_directory, f"{tile_name}.hgt")
-
-        if not os.path.isfile(decompressed_tile_path):
-            compressed_tile_path = os.path.join(self.gz_directory, f"{tile_name}.hgt.gz")
-            if not self.get_or_download_tile(compressed_tile_path, **tile_parameters):
-                raise FileNotFoundError(f"Tile {tile_name} not found.")
-
-            with gzip.open(compressed_tile_path, "rb") as f_in:
-                with open(decompressed_tile_path, "wb") as f_out:
-                    shutil.copyfileobj(f_in, f_out)
-
-        return self.extract_roi(decompressed_tile_path)
+        return self.data_info