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

maps4fs/generator/dtm.py

@@ -0,0 +1,333 @@
+"""This module contains the DTMProvider class and its subclasses. DTMProvider class is used to
+define different providers of digital terrain models (DTM) data. Each provider has its own URL
+and specific settings for downloading and processing the data."""
+
+from __future__ import annotations
+
+import gzip
+import math
+import os
+import shutil
+from typing import Type
+
+import numpy as np
+import osmnx as ox  # type: ignore
+import rasterio  # type: ignore
+import requests
+from pydantic import BaseModel
+
+from maps4fs.logger import Logger
+
+
+class DTMProviderSettings(BaseModel):
+    """Base class for DTM provider settings models."""
+
+
+class DTMProvider:
+    """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
+
+    _url: str | None = None
+
+    _author: str | None = None
+    _is_community: bool = False
+    _settings: Type[DTMProviderSettings] | None = None
+
+    _instructions: str | None = None
+
+    # pylint: disable=R0913, R0917
+    def __init__(
+        self,
+        coordinates: tuple[float, float],
+        user_settings: DTMProviderSettings | None,
+        size: int,
+        directory: str,
+        logger: Logger,
+    ):
+        self._coordinates = coordinates
+        self._user_settings = user_settings
+        self._size = size
+
+        if not self._code:
+            raise ValueError("Provider code must be defined.")
+        self._tile_directory = os.path.join(directory, self._code)
+        os.makedirs(self._tile_directory, exist_ok=True)
+
+        self.logger = logger
+
+    @property
+    def coordinates(self) -> tuple[float, float]:
+        """Coordinates of the center point of the DTM data.
+
+        Returns:
+            tuple: Latitude and longitude of the center point.
+        """
+        return self._coordinates
+
+    @property
+    def size(self) -> int:
+        """Size of the DTM data in meters.
+
+        Returns:
+            int: Size of the DTM data.
+        """
+        return self._size
+
+    @property
+    def url(self) -> str | None:
+        """URL of the provider."""
+        return self._url
+
+    def formatted_url(self, **kwargs) -> str:
+        """Formatted URL of the provider."""
+        if not self.url:
+            raise ValueError("URL must be defined.")
+        return self.url.format(**kwargs)
+
+    @classmethod
+    def author(cls) -> str | None:
+        """Author of the provider.
+
+        Returns:
+            str: Author of the provider.
+        """
+        return cls._author
+
+    @classmethod
+    def is_community(cls) -> bool:
+        """Is the provider a community-driven project.
+
+        Returns:
+            bool: True if the provider is a community-driven project, False otherwise.
+        """
+        return cls._is_community
+
+    @classmethod
+    def settings(cls) -> Type[DTMProviderSettings] | None:
+        """Settings model of the provider.
+
+        Returns:
+            Type[DTMProviderSettings]: Settings model of the provider.
+        """
+        return cls._settings
+
+    @classmethod
+    def instructions(cls) -> str | None:
+        """Instructions for using the provider.
+
+        Returns:
+            str: Instructions for using the provider.
+        """
+        return cls._instructions
+
+    @property
+    def user_settings(self) -> DTMProviderSettings | None:
+        """User settings of the provider.
+
+        Returns:
+            DTMProviderSettings: User settings of the provider.
+        """
+        return self._user_settings
+
+    @classmethod
+    def description(cls) -> str:
+        """Description of the provider.
+
+        Returns:
+            str: Provider description.
+        """
+        return f"{cls._icon} {cls._region} [{cls._resolution} m/px] {cls._name}"
+
+    @classmethod
+    def get_provider_by_code(cls, code: str) -> Type[DTMProvider] | None:
+        """Get a provider by its code.
+
+        Arguments:
+            code (str): Provider code.
+
+        Returns:
+            DTMProvider: Provider class or None if not found.
+        """
+        for provider in cls.__subclasses__():
+            if provider._code == code:  # pylint: disable=W0212
+                return provider
+        return None
+
+    @classmethod
+    def get_provider_descriptions(cls) -> dict[str, str]:
+        """Get descriptions of all providers, where keys are provider codes and
+        values are provider descriptions.
+
+        Returns:
+            dict: Provider descriptions.
+        """
+        providers = {}
+        for provider in cls.__subclasses__():
+            providers[provider._code] = provider.description()  # pylint: disable=W0212
+        return providers  # type: ignore
+
+    def download_tile(self, output_path: str, **kwargs) -> bool:
+        """Download a tile from the provider.
+
+        Arguments:
+            output_path (str): Path to save the downloaded tile.
+
+        Returns:
+            bool: True if the tile was downloaded successfully, False otherwise.
+        """
+        url = self.formatted_url(**kwargs)
+        response = requests.get(url, stream=True, timeout=10)
+        if response.status_code == 200:
+            with open(output_path, "wb") as file:
+                for chunk in response.iter_content(chunk_size=1024):
+                    file.write(chunk)
+            return True
+        return False
+
+    def get_or_download_tile(self, output_path: str, **kwargs) -> str | None:
+        """Get or download a tile from the provider.
+
+        Arguments:
+            output_path (str): Path to save the downloaded tile.
+
+        Returns:
+            str: Path to the downloaded tile or None if the tile not exists and was
+                not downloaded.
+        """
+        if not os.path.exists(output_path):
+            if not self.download_tile(output_path, **kwargs):
+                return None
+        return output_path
+
+    def get_tile_parameters(self, *args, **kwargs) -> dict:
+        """Get parameters for the tile, that will be used to format the URL.
+        Must be implemented in subclasses.
+
+        Returns:
+            dict: Tile parameters to format the URL.
+        """
+        raise NotImplementedError
+
+    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
+        windowed to the bounding box of ROI. It also must have only one channel.
+
+        Returns:
+            np.ndarray: Numpy array of the tile.
+        """
+        raise NotImplementedError
+
+    def get_bbox(self) -> tuple[float, float, float, float]:
+        """Get bounding box of the tile based on the center point and size.
+
+        Returns:
+            tuple: Bounding box of the tile (north, south, east, west).
+        """
+        west, south, east, north = ox.utils_geo.bbox_from_point(  # type: ignore
+            self.coordinates, dist=self.size // 2, project_utm=False
+        )
+        bbox = north, south, east, west
+        return bbox
+
+    def extract_roi(self, tile_path: str) -> np.ndarray:
+        """Extract region of interest (ROI) from the GeoTIFF file.
+
+        Arguments:
+            tile_path (str): Path to the GeoTIFF file.
+
+        Raises:
+            ValueError: If the tile does not contain any data.
+
+        Returns:
+            np.ndarray: Numpy array of the ROI.
+        """
+        north, south, east, west = self.get_bbox()
+        with rasterio.open(tile_path) as src:
+            self.logger.debug("Opened tile, shape: %s, dtype: %s.", src.shape, src.dtypes[0])
+            window = rasterio.windows.from_bounds(west, south, east, north, src.transform)
+            self.logger.debug(
+                "Window parameters. Column offset: %s, row offset: %s, width: %s, height: %s.",
+                window.col_off,
+                window.row_off,
+                window.width,
+                window.height,
+            )
+            data = src.read(1, window=window)
+        if not data.size > 0:
+            raise ValueError("No data in the tile.")
+
+        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.
+
+        Returns:
+            dict: Tile parameters.
+        """
+        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)

maps4fs/generator/game.py

@@ -10,6 +10,7 @@ from maps4fs.generator.background import Background
 from maps4fs.generator.config import Config
 from maps4fs.generator.grle import GRLE
 from maps4fs.generator.i3d import I3d
+from maps4fs.generator.satellite import Satellite
 from maps4fs.generator.texture import Texture
 
 working_directory = os.getcwd()
@@ -39,7 +40,7 @@ class Game:
     _tree_schema: str | None = None
 
     # Order matters! Some components depend on others.
-    components = [Texture, GRLE, Background, I3d, Config]
+    components = [Texture, GRLE, Background, I3d, Config, Satellite]
 
     def __init__(self, map_template_path: str | None = None):
         if map_template_path:

maps4fs/generator/i3d.py

@@ -81,20 +81,6 @@ class I3d(Component):
 
         root = tree.getroot()
         for map_elem in root.iter("Scene"):
-            for terrain_elem in map_elem.iter("TerrainTransformGroup"):
-                if self.map.dem_settings.auto_process:
-                    terrain_elem.set("heightScale", str(DEFAULT_HEIGHT_SCALE))
-                    self.logger.debug(
-                        "heightScale attribute set to %s in TerrainTransformGroup element.",
-                        DEFAULT_HEIGHT_SCALE,
-                    )
-                else:
-                    self.logger.debug(
-                        "Auto process is disabled, skipping the heightScale attribute update."
-                    )
-
-                self.logger.debug("TerrainTransformGroup element updated in I3D file.")
-
             sun_elem = map_elem.find(".//Light[@name='sun']")
 
             if sun_elem is not None:
@@ -111,6 +97,10 @@ 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:

maps4fs/generator/map.py

@@ -7,145 +7,21 @@ import os
 import shutil
 from typing import Any, Generator
 
-from pydantic import BaseModel
-
 from maps4fs.generator.component import Component
+from maps4fs.generator.dtm import DTMProvider, DTMProviderSettings
 from maps4fs.generator.game import Game
+from maps4fs.generator.settings import (
+    BackgroundSettings,
+    DEMSettings,
+    GRLESettings,
+    I3DSettings,
+    SatelliteSettings,
+    SplineSettings,
+    TextureSettings,
+)
 from maps4fs.logger import Logger
 
 
-class SettingsModel(BaseModel):
-    """Base class for settings models. It provides methods to convert settings to and from JSON."""
-
-    @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.
-
-        Returns:
-            dict[str, dict[str, Any]]: Dictionary with settings of the current class and its
-                subclasses.
-        """
-        all_settings = {}
-        for subclass in cls.__subclasses__():
-            all_settings[subclass.__name__] = subclass().model_dump()
-
-        return all_settings
-
-    @classmethod
-    def all_settings_from_json(cls, data: dict) -> dict[str, SettingsModel]:
-        """Create settings instances from JSON data.
-
-        Arguments:
-            data (dict): JSON data.
-
-        Returns:
-            dict[str, Type[SettingsModel]]: Dictionary with settings instances.
-        """
-        settings = {}
-        for subclass in cls.__subclasses__():
-            settings[subclass.__name__] = subclass(**data[subclass.__name__])
-
-        return settings
-
-    @classmethod
-    def all_settings(cls) -> list[SettingsModel]:
-        """Get all settings of the current class and its subclasses.
-
-        Returns:
-            list[SettingsModel]: List with settings of the current class and its subclasses.
-        """
-        settings = []
-        for subclass in cls.__subclasses__():
-            settings.append(subclass())
-
-        return settings
-
-
-class DEMSettings(SettingsModel):
-    """Represents the advanced settings for DEM component.
-
-    Attributes:
-        auto_process (bool): use the auto preset to change the multiplier.
-        multiplier (int): multiplier for the heightmap, every pixel will be multiplied by this
-            value.
-        blur_radius (int): radius of the blur filter.
-        plateau (int): plateau height, will be added to each pixel.
-        water_depth (int): water depth, will be subtracted from each pixel where the water
-            is present.
-    """
-
-    auto_process: bool = True
-    multiplier: int = 1
-    blur_radius: int = 35
-    plateau: int = 0
-    water_depth: int = 0
-
-
-class BackgroundSettings(SettingsModel):
-    """Represents the advanced settings for background component.
-
-    Attributes:
-        generate_background (bool): generate obj files for the background terrain.
-        generate_water (bool): generate obj files for the water.
-        resize_factor (int): resize factor for the background terrain and water.
-            It will be used as 1 / resize_factor of the original size.
-    """
-
-    generate_background: bool = True
-    generate_water: bool = True
-    resize_factor: int = 8
-
-
-class GRLESettings(SettingsModel):
-    """Represents the advanced settings for GRLE component.
-
-    Attributes:
-        farmland_margin (int): margin around the farmland.
-        random_plants (bool): generate random plants on the map or use the default one.
-        add_farmyards (bool): If True, regions of frarmyards will be added to the map
-            without corresponding fields.
-    """
-
-    farmland_margin: int = 0
-    random_plants: bool = True
-    add_farmyards: bool = False
-
-
-class I3DSettings(SettingsModel):
-    """Represents the advanced settings for I3D component.
-
-    Attributes:
-        forest_density (int): density of the forest (distance between trees).
-    """
-
-    forest_density: int = 10
-
-
-class TextureSettings(SettingsModel):
-    """Represents the advanced settings for texture component.
-
-    Attributes:
-        dissolve (bool): dissolve the texture into several images.
-        fields_padding (int): padding around the fields.
-        skip_drains (bool): skip drains generation.
-    """
-
-    dissolve: bool = False
-    fields_padding: int = 0
-    skip_drains: bool = False
-
-
-class SplineSettings(SettingsModel):
-    """Represents the advanced settings for spline component.
-
-    Attributes:
-        spline_density (int): the number of extra points that will be added between each two
-            existing points.
-    """
-
-    spline_density: int = 2
-
-
 # pylint: disable=R0913, R0902, R0914
 class Map:
     """Class used to generate map using all components.
@@ -161,6 +37,8 @@ class Map:
     def __init__(  # pylint: disable=R0917, R0915
         self,
         game: Game,
+        dtm_provider: DTMProvider,
+        dtm_provider_settings: DTMProviderSettings,
         coordinates: tuple[float, float],
         size: int,
         rotation: int,
@@ -173,6 +51,7 @@ class Map:
         i3d_settings: I3DSettings = I3DSettings(),
         texture_settings: TextureSettings = TextureSettings(),
         spline_settings: SplineSettings = SplineSettings(),
+        satellite_settings: SatelliteSettings = SatelliteSettings(),
         **kwargs,
     ):
         if not logger:
@@ -189,6 +68,8 @@ class Map:
         self.rotated_size = int(size * rotation_multiplier)
 
         self.game = game
+        self.dtm_provider = dtm_provider
+        self.dtm_provider_settings = dtm_provider_settings
         self.components: list[Component] = []
         self.coordinates = coordinates
         self.map_directory = map_directory
@@ -217,6 +98,7 @@ class Map:
         self.logger.info("Texture settings: %s", texture_settings)
         self.spline_settings = spline_settings
         self.logger.info("Spline settings: %s", spline_settings)
+        self.satellite_settings = satellite_settings
 
         os.makedirs(self.map_directory, exist_ok=True)
         self.logger.debug("Map directory created: %s", self.map_directory)
@@ -228,6 +110,7 @@ class Map:
             i3d_settings,
             texture_settings,
             spline_settings,
+            satellite_settings,
         ]
 
         settings_json = {}

maps4fs/generator/satellite.py

@@ -0,0 +1,92 @@
+"""This module contains the Satellite class for the maps4fs package to download satellite images
+for the map."""
+
+import os
+
+import cv2
+from pygmdl import save_image  # type: ignore
+
+from maps4fs.generator.background import DEFAULT_DISTANCE
+from maps4fs.generator.component import Component
+from maps4fs.generator.texture import PREVIEW_MAXIMUM_SIZE
+
+
+# pylint: disable=W0223
+class Satellite(Component):
+    """Component for to download satellite images for the map.
+
+    Arguments:
+        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_size (int): The size of the map in pixels.
+        map_rotated_size (int): The size of the map in pixels after rotation.
+        rotation (int): The rotation angle of the map.
+        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.
+    """
+
+    def preprocess(self) -> None:
+        """This component does not require any preprocessing."""
+        return
+
+    def process(self) -> None:
+        """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.")
+            return
+
+        margin = self.map.satellite_settings.satellite_margin
+        overview_size = (self.map_size + margin) * 2
+        overwiew_path = os.path.join(self.satellite_directory, "satellite_overview.png")
+
+        background_size = self.map_size + (DEFAULT_DISTANCE + margin) * 2
+        background_path = os.path.join(self.satellite_directory, "satellite_background.png")
+
+        sizes = [overview_size, background_size]
+        self.image_paths = [overwiew_path, background_path]  # pylint: disable=W0201
+
+        for size, path in zip(sizes, self.image_paths):
+            try:
+                lat, lon = self.coordinates
+                zoom = self.map.satellite_settings.zoom_level
+                save_image(
+                    lat,
+                    lon,
+                    size,
+                    output_path=path,
+                    rotation=self.rotation,
+                    zoom=zoom,
+                    from_center=True,
+                    logger=self.logger,
+                )
+            except Exception as e:  # pylint: disable=W0718
+                self.logger.error(f"Failed to download satellite image: {e}")
+                continue
+
+    # pylint: disable=no-member
+    def previews(self) -> list[str]:
+        """Returns the paths to the preview images.
+
+        Returns:
+            list[str]: List of paths to the preview images.
+        """
+        previews = []
+        for image_path in self.image_paths:
+            if not os.path.isfile(image_path):
+                self.logger.warning(f"File {image_path} does not exist.")
+                continue
+            image = cv2.imread(image_path)
+            if image is None:
+                self.logger.warning(f"Failed to read image from {image_path}")
+                continue
+
+            if image.shape[0] > PREVIEW_MAXIMUM_SIZE or image.shape[1] > PREVIEW_MAXIMUM_SIZE:
+                image = cv2.resize(image, (PREVIEW_MAXIMUM_SIZE, PREVIEW_MAXIMUM_SIZE))
+
+            preview_path = os.path.join(self.previews_directory, os.path.basename(image_path))
+            cv2.imwrite(preview_path, image)
+            previews.append(preview_path)
+
+        return previews