maps4fs 1.5.2__py3-none-any.whl → 1.5.6__py3-none-any.whl

maps4fs/__init__.py

@@ -1,11 +1,12 @@
 # pylint: disable=missing-module-docstring
+from maps4fs.generator.dtm import DTMProvider
 from maps4fs.generator.game import Game
-from maps4fs.generator.map import (
+from maps4fs.generator.map import Map
+from maps4fs.generator.settings import (
     BackgroundSettings,
     DEMSettings,
     GRLESettings,
     I3DSettings,
-    Map,
     SettingsModel,
     SplineSettings,
     TextureSettings,

maps4fs/generator/component.py

@@ -68,6 +68,7 @@ class Component:
         os.makedirs(self.previews_directory, exist_ok=True)
         os.makedirs(self.scripts_directory, exist_ok=True)
         os.makedirs(self.info_layers_directory, exist_ok=True)
+        os.makedirs(self.satellite_directory, exist_ok=True)
 
         self.save_bbox()
         self.preprocess()
@@ -123,6 +124,15 @@ class Component:
         """
         return os.path.join(self.map_directory, "scripts")
 
+    @property
+    def satellite_directory(self) -> str:
+        """The directory where the satellite images are stored.
+
+        Returns:
+            str: The directory where the satellite images are stored.
+        """
+        return os.path.join(self.map_directory, "satellite")
+
     @property
     def generation_info_path(self) -> str:
         """The path to the generation info JSON file.

maps4fs/generator/dem.py

@@ -1,19 +1,15 @@
 """This module contains DEM class for processing Digital Elevation Model data."""
 
-import gzip
-import math
 import os
-import shutil
 
 import cv2
 import numpy as np
-import rasterio  # type: ignore
-import requests
+
+# import rasterio  # type: ignore
 from pympler import asizeof  # type: ignore
 
 from maps4fs.generator.component import Component
-
-SRTM = "https://elevation-tiles-prod.s3.amazonaws.com/skadi/{latitude_band}/{tile_name}.hgt.gz"
+from maps4fs.generator.dtm import DTMProvider
 
 
 # pylint: disable=R0903, R0902
@@ -63,6 +59,14 @@ class DEM(Component):
 
         self.auto_process = self.map.dem_settings.auto_process
 
+        self.dtm_provider: DTMProvider = self.map.dtm_provider(  # type: ignore
+            coordinates=self.coordinates,
+            user_settings=self.map.dtm_provider_settings,
+            size=self.map_rotated_size,
+            directory=self.temp_dir,
+            logger=self.logger,
+        )
+
     @property
     def dem_path(self) -> str:
         """Returns path to the DEM file.
@@ -132,36 +136,29 @@ class DEM(Component):
     def process(self) -> None:
         """Reads SRTM file, crops it to map size, normalizes and blurs it,
         saves to map directory."""
-        north, south, east, west = self.bbox
 
         dem_output_resolution = self.output_resolution
         self.logger.debug("DEM output resolution: %s.", dem_output_resolution)
 
-        tile_path = self._srtm_tile()
-        if not tile_path:
-            self.logger.warning("Tile was not downloaded, DEM file will be filled with zeros.")
+        try:
+            data = self.dtm_provider.get_numpy()
+        except Exception as e:  # pylint: disable=W0718
+            self.logger.error("Failed to get DEM data from SRTM: %s.", e)
             self._save_empty_dem(dem_output_resolution)
             return
 
-        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 len(data.shape) != 2:
+            self.logger.error("DTM provider returned incorrect data: more than 1 channel.")
+            self._save_empty_dem(dem_output_resolution)
+            return
 
-        if not data.size > 0:
-            self.logger.warning("DEM data is empty, DEM file will be filled with zeros.")
+        if data.dtype not in ["int16", "uint16"]:
+            self.logger.error("DTM provider returned incorrect data type: %s.", data.dtype)
             self._save_empty_dem(dem_output_resolution)
             return
 
         self.logger.debug(
-            "DEM data was read from SRTM file. Shape: %s, dtype: %s. Min: %s, max: %s.",
+            "DEM data was retrieved from DTM provider. Shape: %s, dtype: %s. Min: %s, max: %s.",
             data.shape,
             data.dtype,
             data.min(),
@@ -276,81 +273,6 @@ class DEM(Component):
             output_width=output_width,
         )
 
-    def _tile_info(self, lat: float, lon: float) -> tuple[str, str]:
-        """Returns latitude band and tile name for SRTM tile from coordinates.
-
-        Arguments:
-            lat (float): Latitude.
-            lon (float): Longitude.
-
-        Returns:
-            tuple[str, str]: Latitude band and tile name.
-        """
-        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, tile_name
-
-    def _download_tile(self) -> str | None:
-        """Downloads SRTM tile from Amazon S3 using coordinates.
-
-        Returns:
-            str: Path to compressed tile or None if download failed.
-        """
-        latitude_band, tile_name = self._tile_info(*self.coordinates)
-        compressed_file_path = os.path.join(self.gz_dir, f"{tile_name}.hgt.gz")
-        url = SRTM.format(latitude_band=latitude_band, tile_name=tile_name)
-        self.logger.debug("Trying to get response from %s...", url)
-        response = requests.get(url, stream=True, timeout=10)
-
-        if response.status_code == 200:
-            self.logger.debug("Response received. Saving to %s...", compressed_file_path)
-            with open(compressed_file_path, "wb") as f:
-                for chunk in response.iter_content(chunk_size=8192):
-                    f.write(chunk)
-            self.logger.debug("Compressed tile successfully downloaded.")
-        else:
-            self.logger.error("Response was failed with status code %s.", response.status_code)
-            return None
-
-        return compressed_file_path
-
-    def _srtm_tile(self) -> str | None:
-        """Determines SRTM tile name from coordinates downloads it if necessary, and decompresses.
-
-        Returns:
-            str: Path to decompressed tile or None if download failed.
-        """
-        latitude_band, tile_name = self._tile_info(*self.coordinates)
-        self.logger.debug("SRTM tile name %s from latitude band %s.", tile_name, latitude_band)
-
-        decompressed_file_path = os.path.join(self.hgt_dir, f"{tile_name}.hgt")
-        if os.path.isfile(decompressed_file_path):
-            self.logger.debug(
-                "Decompressed tile already exists: %s, skipping download.",
-                decompressed_file_path,
-            )
-            return decompressed_file_path
-
-        compressed_file_path = self._download_tile()
-        if not compressed_file_path:
-            self.logger.error("Download from SRTM failed, DEM file will be filled with zeros.")
-            return None
-        with gzip.open(compressed_file_path, "rb") as f_in:
-            with open(decompressed_file_path, "wb") as f_out:
-                shutil.copyfileobj(f_in, f_out)
-        self.logger.debug("Tile decompressed to %s.", decompressed_file_path)
-        return decompressed_file_path
-
     def _save_empty_dem(self, dem_output_resolution: tuple[int, int]) -> None:
         """Saves empty DEM file filled with zeros."""
         dem_data = np.zeros(dem_output_resolution, dtype="uint16")

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/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

maps4fs/generator/settings.py

@@ -0,0 +1,152 @@
+"""This module contains settings models for all components."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel
+
+
+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 = False
+    generate_water: bool = False
+    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
+
+
+class SatelliteSettings(SettingsModel):
+    """Represents the advanced settings for satellite component.
+
+    Attributes:
+        download_images (bool): download satellite images.
+        margin (int): margin around the map.
+    """
+
+    download_images: bool = False
+    satellite_margin: int = 100
+    zoom_level: int = 14

{maps4fs-1.5.2.dist-info → maps4fs-1.5.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: maps4fs
-Version: 1.5.2
+Version: 1.5.6
 Summary: Generate map templates for Farming Simulator from real places.
 Author-email: iwatkot <iwatkot@gmail.com>
 License: MIT License
@@ -75,6 +75,8 @@ Requires-Dist: pydantic
 🌲 Automatically generates forests 🆕<br>
 🌊 Automatically generates water planes 🆕<br>
 📈 Automatically generates splines 🆕<br>
+🛰️ Automatically downloads high resolution satellite images 🆕<br>
+🏔️ Allows to use multiple DTM providers for elevation models 🆕<br>
 🌍 Based on real-world data from OpenStreetMap<br>
 🗺️ Supports [custom OSM maps](/docs/custom_osm.md)<br>
 🏞️ Generates height map using SRTM dataset<br>
@@ -511,10 +513,16 @@ You can also apply some advanced settings to the map generation process. Note th
 
 - Skip drains - if enabled, the tool will not generate the drains and ditches on the map. By default, it's set to False. Use this if you don't need the drains on the map.
 
-## Splines Advanced settings
+### Splines Advanced settings
 
 - Splines density - number of points, which will be added (interpolate) between each pair of existing points. The higher the value, the denser the spline will be. It can smooth the splines, but high values can in opposite make the splines look unnatural.
 
+### Satellite Advanced settings
+
+- Download images - if enabled, the tool will download the satellite images for the background terrain and the overview image. If you already have the images, you can turn it off.
+- Satellite margin - the margin around the map in meters. It's useful when you want to have some space around the map on the satellite images. By default, it's set to 100.
+- Zoom level - the zoom level of the satellite images. The higher the value, the more detailed the images will be. By default, it's set to 14 and this option is disabled on a public version of the app.
+
 ## Expert Settings
 The tool also supports the expert settings. Do not use them until you read the documentation and understand what they do. Here's the list of the expert settings:
 
@@ -555,3 +563,4 @@ But also, I want to thank the people who helped me with the project in some way,
 - [Tox3](https://github.com/Tox3) - for the manual tests of the app. 
 - [Lucandia](https://github.com/Lucandia) - for the awesome StreamLit [widget to preview STL files](https://github.com/Lucandia/streamlit_stl).
 - [H4rdB4se](https://github.com/H4rdB4se) - for investigating the issue with custom OSM files and finding a proper way to work with the files in JOSM.
+- [kbrandwijk](https://github.com/kbrandwijk) - for providing [awesome tool](https://github.com/Paint-a-Farm/satmap_downloader) to download the satellite images from the Google Maps and giving a permission to modify it and create a Python Package.

{maps4fs-1.5.2.dist-info → maps4fs-1.5.6.dist-info}/RECORD

@@ -1,21 +1,24 @@
-maps4fs/__init__.py,sha256=LMzzORK3Q3OjXmmRJ03CpS2SMP6zTwKNnUUei3P7s40,300
+maps4fs/__init__.py,sha256=EJzbqRrSGltSMUI-dHgONODxKt9YvP_ElwFmXV8M_MA,380
 maps4fs/logger.py,sha256=B-NEYpMjPAAqlV4VpfTi6nbBFnEABVtQOaYe6nMpidg,1489
 maps4fs/generator/__init__.py,sha256=zZMLEkGzb4z0xql650gOtGSvcgX58DnJ2yN3vC2daRk,43
 maps4fs/generator/background.py,sha256=ySABP9HLji8R0aXi1BwjUQtP2uDqZPkrlmugowa9Gkk,22836
-maps4fs/generator/component.py,sha256=58UQgdR-7KlWHTfwLesNNK76BTRsiVngRa6B64OKjhc,20065
+maps4fs/generator/component.py,sha256=RtXruvT4Fxfr7_xo9Bi-i3IIWcPd5QQOSpYJ_cNC49o,20408
 maps4fs/generator/config.py,sha256=0QmK052B8bxyHVhg3jzCORLfOBMMmqVfhhbqXKf6OMk,4383
-maps4fs/generator/dem.py,sha256=MZf3ZjawJ977TxqB1q9nNpvPZUNwfmm2EaJDtVU-eCU,15939
-maps4fs/generator/game.py,sha256=jjo7CTwHHSkRpeD_QgRXkhR_NxI09C4kMxz-nYOTM4A,7931
+maps4fs/generator/dem.py,sha256=aJva77k_00SKrqnRLF_BXr8eGR5flifrh72kSBq1saI,12621
+maps4fs/generator/dtm.py,sha256=5_1e-kQcZ7c1Xg3tvuTyumzfTAcUPmDkIyZd5VagyOk,10550
+maps4fs/generator/game.py,sha256=QHgVnyGYvEnfwGZ84-u-dpbCRr3UeVVqBbrwr5WG8dE,7992
 maps4fs/generator/grle.py,sha256=u8ZwSs313PIOkH_0B_O2tVTaZ-eYNkc30eKGtBxWzTM,17846
 maps4fs/generator/i3d.py,sha256=qeZYqfuhbhRPlSAuQHXaq6RmIO7314oMN68Ivebp1YQ,24786
-maps4fs/generator/map.py,sha256=jIdekpiymhHqKx4FaAwjtq3hMnRdKYo6TvJLX1fSD0k,12814
+maps4fs/generator/map.py,sha256=flU0b2TrVYLxj9o3v_YRvNz9YB3s4w6YFSv4Jka5ojM,9283
 maps4fs/generator/qgis.py,sha256=Es8hLuqN_KH8lDfnJE6He2rWYbAKJ3RGPn-o87S6CPI,6116
+maps4fs/generator/satellite.py,sha256=Qnb6XxmXKnHdHKVMb9mJ3vDGtGkDHCOv_81hrrXdx3k,3660
+maps4fs/generator/settings.py,sha256=gBMjXpz0hcUsCAw8MS_SsuFKHaI41RK6dclEEepsx2M,4575
 maps4fs/generator/texture.py,sha256=sErusfv1AqQfP-veMrZ921Tz8DnGEhfB4ucggMmKrD4,31231
 maps4fs/toolbox/__init__.py,sha256=zZMLEkGzb4z0xql650gOtGSvcgX58DnJ2yN3vC2daRk,43
 maps4fs/toolbox/background.py,sha256=9BXWNqs_n3HgqDiPztWylgYk_QM4YgBpe6_ZNQAWtSc,2154
 maps4fs/toolbox/dem.py,sha256=z9IPFNmYbjiigb3t02ZenI3Mo8odd19c5MZbjDEovTo,3525
-maps4fs-1.5.2.dist-info/LICENSE.md,sha256=pTKD_oUexcn-yccFCTrMeLkZy0ifLRa-VNcDLqLZaIw,10749
-maps4fs-1.5.2.dist-info/METADATA,sha256=Hj01MkOYD87umoXLB2iwwjcS2eGxuUdYGv4SyYWO9Xw,35026
-maps4fs-1.5.2.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-maps4fs-1.5.2.dist-info/top_level.txt,sha256=Ue9DSRlejRQRCaJueB0uLcKrWwsEq9zezfv5dI5mV1M,8
-maps4fs-1.5.2.dist-info/RECORD,,
+maps4fs-1.5.6.dist-info/LICENSE.md,sha256=pTKD_oUexcn-yccFCTrMeLkZy0ifLRa-VNcDLqLZaIw,10749
+maps4fs-1.5.6.dist-info/METADATA,sha256=0OuPPRh06Av71q90zEiVokNCHSh7QLCULKjcBNyLoYA,36012
+maps4fs-1.5.6.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+maps4fs-1.5.6.dist-info/top_level.txt,sha256=Ue9DSRlejRQRCaJueB0uLcKrWwsEq9zezfv5dI5mV1M,8
+maps4fs-1.5.6.dist-info/RECORD,,