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

maps4fs/__init__.py

@@ -1,7 +1,8 @@
 # pylint: disable=missing-module-docstring
 from maps4fs.generator.dtm.dtm import DTMProvider
-from maps4fs.generator.dtm.srtm import SRTM30Provider
-from maps4fs.generator.dtm.usgs import USGSProvider
+from maps4fs.generator.dtm.srtm import SRTM30Provider, SRTM30ProviderSettings
+from maps4fs.generator.dtm.usgs import USGSProvider, USGSProviderSettings
+from maps4fs.generator.dtm.nrw import NRWProvider, NRWProviderSettings
 from maps4fs.generator.game import Game
 from maps4fs.generator.map import Map
 from maps4fs.generator.settings import (
@@ -9,6 +10,7 @@ from maps4fs.generator.settings import (
     DEMSettings,
     GRLESettings,
     I3DSettings,
+    SatelliteSettings,
     SettingsModel,
     SplineSettings,
     TextureSettings,

maps4fs/generator/dtm/dtm.py

@@ -11,7 +11,10 @@ from typing import TYPE_CHECKING, Type
 import numpy as np
 import osmnx as ox  # type: ignore
 import rasterio  # type: ignore
-import requests
+from rasterio.warp import calculate_default_transform, reproject
+from rasterio.enums import Resampling
+from rasterio.merge import merge
+
 from pydantic import BaseModel
 
 from maps4fs.logger import Logger
@@ -23,8 +26,11 @@ if TYPE_CHECKING:
 class DTMProviderSettings(BaseModel):
     """Base class for DTM provider settings models."""
 
+    easy_mode: bool = True
+    power_factor: int = 0
+
 
-# pylint: disable=too-many-public-methods
+# pylint: disable=too-many-public-methods, too-many-instance-attributes
 class DTMProvider(ABC):
     """Base class for DTM providers."""
 
@@ -44,6 +50,21 @@ class DTMProvider(ABC):
 
     _instructions: str | None = None
 
+    _base_instructions = (
+        "ℹ️ Using **Easy mode** is recommended, as it automatically adjusts the values in the "
+        "image, so the terrain elevation in Giants Editor will match real world "
+        "elevation in meters.  \n"
+        "ℹ️ If the terrain height difference in the real world is bigger than 255 meters, "
+        "the [Height scale](https://github.com/iwatkot/maps4fs/blob/main/docs/dem.md#height-scale)"
+        " parameter in the **map.i3d** file will be automatically adjusted.  \n"
+        "⚡ If the **Easy mode** option is disabled, you will probably get completely flat "
+        "terrain, unless you adjust the DEM Multiplier Setting or the Height scale parameter in "
+        "the Giants Editor.  \n"
+        "💡 You can use the **Power factor** setting to make the difference between heights "
+        "bigger. Be extremely careful with this setting, and use only low values, otherwise your "
+        "terrain may be completely broken.  \n"
+    )
+
     # pylint: disable=R0913, R0917
     def __init__(
         self,
@@ -169,6 +190,15 @@ class DTMProvider(ABC):
         """
         return cls._instructions
 
+    @classmethod
+    def base_instructions(cls) -> str | None:
+        """Instructions for using any provider.
+
+        Returns:
+            str: Instructions for using any provider.
+        """
+        return cls._base_instructions
+
     @property
     def user_settings(self) -> DTMProviderSettings | None:
         """User settings of the provider.
@@ -212,63 +242,116 @@ class DTMProvider(ABC):
         """
         providers = {}
         for provider in cls.__subclasses__():
-            if not provider.is_base():
-                providers[provider._code] = provider.description()  # pylint: disable=W0212
+            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.
+    @abstractmethod
+    def download_tiles(self) -> list[str]:
+        """Download tiles from the provider.
 
         Returns:
-            bool: True if the tile was downloaded successfully, False otherwise.
+            list: List of paths to the downloaded tiles.
         """
-        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.
+        raise NotImplementedError
 
-        Arguments:
-            output_path (str): Path to save the downloaded tile.
+    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:
-            str: Path to the downloaded tile or None if the tile not exists and was
-                not downloaded.
+            np.ndarray: Numpy array of the tile.
         """
-        if not os.path.exists(output_path):
-            if not self.download_tile(output_path, **kwargs):
-                return None
-        return output_path
+        # download tiles using DTM provider implementation
+        tiles = self.download_tiles()
+        self.logger.debug(f"Downloaded {len(tiles)} DEM tiles")
+
+        # merge tiles if necessary
+        if len(tiles) > 1:
+            self.logger.debug("Multiple tiles downloaded. Merging tiles")
+            tile, _ = self.merge_geotiff(tiles)
+        else:
+            tile = tiles[0]
+
+        # determine CRS of the resulting tile and reproject if necessary
+        with rasterio.open(tile) as src:
+            crs = src.crs
+        if crs != "EPSG:4326":
+            self.logger.debug(f"Reprojecting GeoTIFF from {crs} to EPSG:4326...")
+            tile = self.reproject_geotiff(tile)
+
+        # extract region of interest from the tile
+        data = self.extract_roi(tile)
+
+        # process elevation data to be compatible with the game
+        data = self.process_elevation(data)
 
-    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.
+        return data
+
+    def process_elevation(self, data: np.ndarray) -> np.ndarray:
+        """Process elevation data.
+
+        Arguments:
+            data (np.ndarray): Elevation data.
 
         Returns:
-            dict: Tile parameters to format the URL.
+            np.ndarray: Processed elevation data.
         """
-        raise NotImplementedError
+        self.data_info = {}
+        self.add_numpy_params(data, "original")
 
-    @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
-        windowed to the bounding box of ROI. It also must have only one channel.
+        data = self.signed_to_unsigned(data)
+        self.add_numpy_params(data, "grounded")
+
+        original_deviation = int(self.data_info["original_deviation"])
+        in_game_maximum_height = 65535 // 255
+        if original_deviation > in_game_maximum_height:
+            suggested_height_scale_multiplier = (
+                original_deviation / in_game_maximum_height  # type: ignore
+            )
+            suggested_height_scale_value = int(255 * suggested_height_scale_multiplier)
+        else:
+            suggested_height_scale_multiplier = 1
+            suggested_height_scale_value = 255
+
+        self.data_info["suggested_height_scale_multiplier"] = suggested_height_scale_multiplier
+        self.data_info["suggested_height_scale_value"] = suggested_height_scale_value
+
+        self.map.shared_settings.height_scale_multiplier = (  # type: ignore
+            suggested_height_scale_multiplier
+        )
+        self.map.shared_settings.height_scale_value = suggested_height_scale_value  # type: ignore
+
+        if self.user_settings.easy_mode:  # type: ignore
+            try:
+                data = self.normalize_dem(data)
+                self.add_numpy_params(data, "normalized")
+
+                normalized_deviation = self.data_info["normalized_deviation"]
+                z_scaling_factor = normalized_deviation / original_deviation  # type: ignore
+                self.data_info["z_scaling_factor"] = z_scaling_factor
+
+                self.map.shared_settings.mesh_z_scaling_factor = z_scaling_factor  # type: ignore
+                self.map.shared_settings.change_height_scale = True  # type: ignore
+
+            except Exception as e:  # pylint: disable=W0718
+                self.logger.error(
+                    "Failed to normalize DEM data. Error: %s. Using original data.", e
+                )
+
+        return data
+
+    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:
-            np.ndarray: Numpy array of the tile.
+            dict[str, int | str | float] | None: Information sequence for the component.
         """
-        raise NotImplementedError
+        return self.data_info
 
+    # region helpers
     def get_bbox(self) -> tuple[float, float, float, float]:
         """Get bounding box of the tile based on the center point and size.
 
@@ -281,6 +364,83 @@ class DTMProvider(ABC):
         bbox = north, south, east, west
         return bbox
 
+    def reproject_geotiff(self, input_tiff: str) -> str:
+        """Reproject a GeoTIFF file to a new coordinate reference system (CRS).
+
+        Arguments:
+            input_tiff (str): Path to the input GeoTIFF file.
+            target_crs (str): Target CRS (e.g., EPSG:4326 for CRS:84).
+
+        Returns:
+            str: Path to the reprojected GeoTIFF file.
+        """
+        output_tiff = os.path.join(self._tile_directory, "merged.tif")
+
+        # Open the source GeoTIFF
+        self.logger.debug("Reprojecting GeoTIFF to %s CRS...", "EPSG:4326")
+        with rasterio.open(input_tiff) as src:
+            # Get the transform, width, and height of the target CRS
+            transform, width, height = calculate_default_transform(
+                src.crs, "EPSG:4326", src.width, src.height, *src.bounds
+            )
+
+            # Update the metadata for the target GeoTIFF
+            kwargs = src.meta.copy()
+            kwargs.update(
+                {"crs": "EPSG:4326", "transform": transform, "width": width, "height": height}
+            )
+
+            # Open the destination GeoTIFF file and reproject
+            with rasterio.open(output_tiff, "w", **kwargs) as dst:
+                for i in range(1, src.count + 1):  # Iterate over all raster bands
+                    reproject(
+                        source=rasterio.band(src, i),
+                        destination=rasterio.band(dst, i),
+                        src_transform=src.transform,
+                        src_crs=src.crs,
+                        dst_transform=transform,
+                        dst_crs="EPSG:4326",
+                        resampling=Resampling.nearest,  # Choose resampling method
+                    )
+
+        self.logger.debug("Reprojected GeoTIFF saved to %s", output_tiff)
+        return output_tiff
+
+    def merge_geotiff(self, input_files: list[str]) -> tuple[str, str]:
+        """Merge multiple GeoTIFF files into a single GeoTIFF file.
+
+        Arguments:
+            input_files (list): List of input GeoTIFF files to merge.
+            output_file (str): Path to save the merged GeoTIFF file.
+        """
+        output_file = os.path.join(self._tile_directory, "merged.tif")
+        # Open all input GeoTIFF files as datasets
+        self.logger.debug("Merging tiff files...")
+        datasets = [rasterio.open(file) for file in input_files]
+
+        # Merge datasets
+        crs = datasets[0].crs
+        mosaic, out_transform = merge(datasets, nodata=0)
+
+        # Get metadata from the first file and update it for the output
+        out_meta = datasets[0].meta.copy()
+        out_meta.update(
+            {
+                "driver": "GTiff",
+                "height": mosaic.shape[1],
+                "width": mosaic.shape[2],
+                "transform": out_transform,
+                "count": mosaic.shape[0],  # Number of bands
+            }
+        )
+
+        # Write merged GeoTIFF to the output file
+        with rasterio.open(output_file, "w", **out_meta) as dest:
+            dest.write(mosaic)
+
+        self.logger.debug("GeoTIFF images merged successfully into %s", output_file)
+        return output_file, crs
+
     def extract_roi(self, tile_path: str) -> np.ndarray:
         """Extract region of interest (ROI) from the GeoTIFF file.
 
@@ -304,18 +464,86 @@ class DTMProvider(ABC):
                 window.width,
                 window.height,
             )
-            data = src.read(1, window=window)
+            data = src.read(1, window=window, masked=True)
         if not data.size > 0:
             raise ValueError("No data in the tile.")
 
         return data
 
-    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.
+    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:
-            dict[str, int | str | float] | None: Information sequence for the component.
+            np.ndarray: Normalized DEM data.
         """
-        return self.data_info
+        maximum_height = int(data.max())
+        minimum_height = int(data.min())
+        deviation = maximum_height - minimum_height
+        self.logger.debug(
+            "Maximum height: %s. Minimum height: %s. Deviation: %s.",
+            maximum_height,
+            minimum_height,
+            deviation,
+        )
+        self.logger.debug("Number of unique values in original DEM data: %s.", np.unique(data).size)
+
+        adjusted_maximum_height = maximum_height * 255
+        adjusted_maximum_height = min(adjusted_maximum_height, 65535)
+        scaling_factor = adjusted_maximum_height / maximum_height
+        self.logger.debug(
+            "Adjusted maximum height: %s. Scaling factor: %s.",
+            adjusted_maximum_height,
+            scaling_factor,
+        )
+
+        if self.user_settings.power_factor:  # type: ignore
+            power_factor = 1 + self.user_settings.power_factor / 10  # type: ignore
+            self.logger.debug(
+                "Applying power factor: %s to the DEM data.",
+                power_factor,
+            )
+            data = np.power(data, power_factor).astype(np.uint16)
+
+        normalized_data = np.round(data * scaling_factor).astype(np.uint16)
+        self.logger.debug(
+            "Normalized data maximum height: %s. Minimum height: %s. Number of unique values: %s.",
+            normalized_data.max(),
+            normalized_data.min(),
+            np.unique(normalized_data).size,
+        )
+        return normalized_data
+
+    def signed_to_unsigned(self, data: np.ndarray, add_one: bool = True) -> np.ndarray:
+        """Convert signed 16-bit integer to unsigned 16-bit integer.
+
+        Arguments:
+            data (np.ndarray): DEM data from SRTM file after cropping.
+
+        Returns:
+            np.ndarray: Unsigned DEM data.
+        """
+        data = data - data.min()
+        if add_one:
+            data = data + 1
+        return data.astype(np.uint16)
+
+    def add_numpy_params(
+        self,
+        data: np.ndarray,
+        prefix: str,
+    ) -> None:
+        """Add numpy array parameters to the data_info dictionary.
+
+        Arguments:
+            data (np.ndarray): Numpy array of the tile.
+            prefix (str): Prefix for the parameters.
+        """
+        self.data_info[f"{prefix}_minimum_height"] = int(data.min())  # type: ignore
+        self.data_info[f"{prefix}_maximum_height"] = int(data.max())  # type: ignore
+        self.data_info[f"{prefix}_deviation"] = int(data.max() - data.min())  # type: ignore
+        self.data_info[f"{prefix}_unique_values"] = int(np.unique(data).size)  # type: ignore
+
+    # endregion

maps4fs/generator/dtm/nrw.py

@@ -0,0 +1,127 @@
+"""This module contains provider of USGS data."""
+
+import os
+
+import numpy as np
+from owslib.wcs import WebCoverageService
+from owslib.util import Authentication
+from pyproj import Transformer
+
+from maps4fs.generator.dtm.dtm import DTMProvider, DTMProviderSettings
+
+
+class NRWProviderSettings(DTMProviderSettings):
+    """Settings for the USGS provider."""
+
+
+# pylint: disable=too-many-locals
+class NRWProvider(DTMProvider):
+    """Generic provider of WCS sources."""
+
+    _code = "NRW"
+    _name = "North Rhine-Westphalia DGM1"
+    _region = "DE"
+    _icon = "🇩🇪󠁥󠁢󠁹󠁿"
+    _resolution = 1
+    _data: np.ndarray | None = None
+    _settings = NRWProviderSettings
+    _author = "[kbrandwijk](https://github.com/kbrandwijk)"
+    _is_community = True
+    _instructions = None
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.shared_tiff_path = os.path.join(self._tile_directory, "shared")
+        os.makedirs(self.shared_tiff_path, exist_ok=True)
+
+    def download_tiles(self) -> list[str]:
+        bbox = self.get_bbox()
+        bbox = self.transform_bbox(bbox, "EPSG:25832")
+
+        tiles = self.tile_bbox(bbox, 1000)
+
+        all_tif_files = self.download_all_tiles(tiles)
+        return all_tif_files
+
+    def tile_bbox(
+            self,
+            bbox: tuple[float, float, float, float],
+            tile_size: int) -> list[tuple[float, float, float, float]]:
+        """Tile the bounding box into smaller bounding boxes of a specified size.
+
+        Arguments:
+            bbox (tuple): Bounding box to tile (north, south, east, west).
+            tile_size (int): Size of the tiles in meters.
+
+        Returns:
+            list: List of smaller bounding boxes (north, south, east, west).
+        """
+        north, south, east, west = bbox
+        x_coords = np.arange(west, east, tile_size)
+        y_coords = np.arange(south, north, tile_size)
+        x_coords = np.append(x_coords, east).astype(x_coords.dtype)
+        y_coords = np.append(y_coords, north).astype(y_coords.dtype)
+
+        x_min, y_min = np.meshgrid(x_coords[:-1], y_coords[:-1], indexing="ij")
+        x_max, y_max = np.meshgrid(x_coords[1:], y_coords[1:], indexing="ij")
+
+        tiles = np.stack([x_min.ravel(), y_min.ravel(), x_max.ravel(), y_max.ravel()], axis=1)
+
+        return tiles
+
+    def download_all_tiles(self, tiles: list[tuple[float, float, float, float]]) -> list[str]:
+        """Download tiles from the NRW provider.
+
+        Arguments:
+            tiles (list): List of tiles to download.
+
+        Returns:
+            list: List of paths to the downloaded GeoTIFF files.
+        """
+        all_tif_files = []
+        wcs = WebCoverageService(
+            'https://www.wcs.nrw.de/geobasis/wcs_nw_dgm',
+            auth=Authentication(verify=False),
+            timeout=600)
+        for tile in tiles:
+            file_name = '_'.join(map(str, tile)) + '.tif'
+            file_path = os.path.join(self.shared_tiff_path, file_name)
+
+            if not os.path.exists(file_path):
+                output = wcs.getCoverage(
+                    identifier=['nw_dgm'],
+                    subsets=[('y', str(tile[0]), str(tile[2])), ('x', str(tile[1]), str(tile[3]))],
+                    format='image/tiff'
+                )
+                with open(file_path, 'wb') as f:
+                    f.write(output.read())
+
+            all_tif_files.append(file_path)
+        return all_tif_files
+
+    def transform_bbox(
+            self,
+            bbox: tuple[float, float, float, float],
+            to_crs: str) -> tuple[float, float, float, float]:
+        """Transform the bounding box to a different coordinate reference system (CRS).
+
+        Arguments:
+            bbox (tuple): Bounding box to transform (north, south, east, west).
+            to_crs (str): Target CRS (e.g., EPSG:4326 for CRS:84).
+
+        Returns:
+            tuple: Transformed bounding box (north, south, east, west).
+        """
+        transformer = Transformer.from_crs("epsg:4326", to_crs)
+        north, south, east, west = bbox
+        bottom_left_x, bottom_left_y = transformer.transform(xx=south, yy=west)
+        top_left_x, top_left_y = transformer.transform(xx=north, yy=west)
+        top_right_x, top_right_y = transformer.transform(xx=north, yy=east)
+        bottom_right_x, bottom_right_y = transformer.transform(xx=south, yy=east)
+
+        west = min(bottom_left_y, bottom_right_y)
+        east = max(top_left_y, top_right_y)
+        south = min(bottom_left_x, top_left_x)
+        north = max(bottom_right_x, top_right_x)
+
+        return north, south, east, west

maps4fs/generator/dtm/srtm.py

@@ -7,7 +7,7 @@ import math
 import os
 import shutil
 
-import numpy as np
+import requests
 
 from maps4fs.generator.dtm.dtm import DTMProvider, DTMProviderSettings
 
@@ -15,9 +15,6 @@ from maps4fs.generator.dtm.dtm import DTMProvider, DTMProviderSettings
 class SRTM30ProviderSettings(DTMProviderSettings):
     """Settings for SRTM 30m provider."""
 
-    easy_mode: bool = True
-    power_factor: int = 0
-
 
 class SRTM30Provider(DTMProvider):
     """Provider of Shuttle Radar Topography Mission (SRTM) 30m data."""
@@ -32,22 +29,6 @@ class SRTM30Provider(DTMProvider):
 
     _author = "[iwatkot](https://github.com/iwatkot)"
 
-    _instructions = (
-        "ℹ️ If you don't know how to work with DEM data, it is recommended to use the "
-        "**Easy mode** option. It will automatically change the values in the image, so the "
-        "terrain will be visible in the Giants Editor. If you're an experienced modder, it's "
-        "recommended to disable this option and work with the DEM data in a usual way.  \n"
-        "ℹ️ If the terrain height difference in the real world is bigger than 255 meters, "
-        "the [Height scale](https://github.com/iwatkot/maps4fs/blob/main/docs/dem.md#height-scale)"
-        " parameter in the **map.i3d** file will be changed automatically.  \n"
-        "⚡ If the **Easy mode** option is disabled, you will probably get completely flat "
-        "terrain, unless you adjust the DEM Multiplier Setting or the Height scale parameter in "
-        "the Giants Editor.  \n"
-        "💡 You can use the **Power factor** setting to make the difference between heights "
-        "bigger. Be extremely careful with this setting, and use only low values, otherwise your "
-        "terrain may be completely broken.  \n"
-    )
-
     _settings = SRTM30ProviderSettings
 
     def __init__(self, *args, **kwargs):
@@ -58,169 +39,86 @@ class SRTM30Provider(DTMProvider):
         os.makedirs(self.gz_directory, exist_ok=True)
         self.data_info: dict[str, int | str | float] | None = None  # type: ignore
 
-    def get_tile_parameters(self, *args, **kwargs) -> dict[str, str]:
-        """Returns latitude band and tile name for SRTM tile from coordinates.
+    def download_tiles(self):
+        """Download SRTM tiles."""
+        north, south, east, west = self.get_bbox()
 
-        Arguments:
-            lat (float): Latitude.
-            lon (float): Longitude.
+        tiles = []
+        # Look at each corner of the bbox in case the bbox spans across multiple tiles
+        for pair in [(north, east), (south, west), (south, east), (north, west)]:
+            tile_parameters = self.get_tile_parameters(*pair)
+            tile_name = tile_parameters["tile_name"]
+            decompressed_tile_path = os.path.join(self.hgt_directory, f"{tile_name}.hgt")
 
-        Returns:
-            dict: Tile parameters.
-        """
-        lat, lon = args
+            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.")
 
-        tile_latitude = math.floor(lat)
-        tile_longitude = math.floor(lon)
+                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)
+            tiles.append(decompressed_tile_path)
 
-        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}"
+        return tiles
 
-        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}
+    # region provider specific helpers
+    def download_tile(self, output_path: str, **kwargs) -> bool:
+        """Download a tile from the provider.
 
-    def get_numpy(self) -> np.ndarray:
-        """Get numpy array of the tile.
+        Arguments:
+            output_path (str): Path to save the downloaded 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)
-
-        data = self.extract_roi(decompressed_tile_path)
-
-        self.data_info = {}
-        self.add_numpy_params(data, "original")
-
-        data = self.signed_to_unsigned(data)
-        self.add_numpy_params(data, "grounded")
-
-        original_deviation = int(self.data_info["original_deviation"])
-        in_game_maximum_height = 65535 // 255
-        if original_deviation > in_game_maximum_height:
-            suggested_height_scale_multiplier = (
-                original_deviation / in_game_maximum_height  # type: ignore
-            )
-            suggested_height_scale_value = int(255 * suggested_height_scale_multiplier)
-        else:
-            suggested_height_scale_multiplier = 1
-            suggested_height_scale_value = 255
-
-        self.data_info["suggested_height_scale_multiplier"] = suggested_height_scale_multiplier
-        self.data_info["suggested_height_scale_value"] = suggested_height_scale_value
-
-        self.map.shared_settings.height_scale_multiplier = (  # type: ignore
-            suggested_height_scale_multiplier
-        )
-        self.map.shared_settings.height_scale_value = suggested_height_scale_value  # type: ignore
-
-        if self.user_settings.easy_mode:  # type: ignore
-            try:
-                data = self.normalize_dem(data)
-                self.add_numpy_params(data, "normalized")
-
-                normalized_deviation = self.data_info["normalized_deviation"]
-                z_scaling_factor = normalized_deviation / original_deviation  # type: ignore
-                self.data_info["z_scaling_factor"] = z_scaling_factor
-
-                self.map.shared_settings.mesh_z_scaling_factor = z_scaling_factor  # type: ignore
-                self.map.shared_settings.change_height_scale = True  # type: ignore
-
-            except Exception as e:  # pylint: disable=W0718
-                self.logger.error(
-                    "Failed to normalize DEM data. Error: %s. Using original data.", e
-                )
-
-        return data
-
-    def add_numpy_params(
-        self,
-        data: np.ndarray,
-        prefix: str,
-    ) -> None:
-        """Add numpy array parameters to the data_info dictionary.
-
-        Arguments:
-            data (np.ndarray): Numpy array of the tile.
-            prefix (str): Prefix for the parameters.
+            bool: True if the tile was downloaded successfully, False otherwise.
         """
-        self.data_info[f"{prefix}_minimum_height"] = int(data.min())  # type: ignore
-        self.data_info[f"{prefix}_maximum_height"] = int(data.max())  # type: ignore
-        self.data_info[f"{prefix}_deviation"] = int(data.max() - data.min())  # type: ignore
-        self.data_info[f"{prefix}_unique_values"] = int(np.unique(data).size)  # type: ignore
-
-    def signed_to_unsigned(self, data: np.ndarray, add_one: bool = True) -> np.ndarray:
-        """Convert signed 16-bit integer to unsigned 16-bit integer.
+        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:
-            data (np.ndarray): DEM data from SRTM file after cropping.
+            output_path (str): Path to save the downloaded tile.
 
         Returns:
-            np.ndarray: Unsigned DEM data.
+            str: Path to the downloaded tile or None if the tile not exists and was
+                not downloaded.
         """
-        data = data - data.min()
-        if add_one:
-            data = data + 1
-        return data.astype(np.uint16)
+        if not os.path.exists(output_path):
+            if not self.download_tile(output_path, **kwargs):
+                return None
+        return output_path
 
-    def normalize_dem(self, data: np.ndarray) -> np.ndarray:
-        """Normalize DEM data to 16-bit unsigned integer using max height from settings.
+    def get_tile_parameters(self, *args) -> dict[str, str]:
+        """Returns latitude band and tile name for SRTM tile from coordinates.
 
         Arguments:
-            data (np.ndarray): DEM data from SRTM file after cropping.
+            lat (float): Latitude.
+            lon (float): Longitude.
 
         Returns:
-            np.ndarray: Normalized DEM data.
+            dict: Tile parameters.
         """
-        maximum_height = int(data.max())
-        minimum_height = int(data.min())
-        deviation = maximum_height - minimum_height
-        self.logger.debug(
-            "Maximum height: %s. Minimum height: %s. Deviation: %s.",
-            maximum_height,
-            minimum_height,
-            deviation,
-        )
-        self.logger.debug("Number of unique values in original DEM data: %s.", np.unique(data).size)
+        lat, lon = args
 
-        adjusted_maximum_height = maximum_height * 255
-        adjusted_maximum_height = min(adjusted_maximum_height, 65535)
-        scaling_factor = adjusted_maximum_height / maximum_height
-        self.logger.debug(
-            "Adjusted maximum height: %s. Scaling factor: %s.",
-            adjusted_maximum_height,
-            scaling_factor,
-        )
+        tile_latitude = math.floor(lat)
+        tile_longitude = math.floor(lon)
 
-        if self.user_settings.power_factor:  # type: ignore
-            power_factor = 1 + self.user_settings.power_factor / 10  # type: ignore
-            self.logger.debug(
-                "Applying power factor: %s to the DEM data.",
-                power_factor,
-            )
-            data = np.power(data, power_factor).astype(np.uint16)
+        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}"
 
-        normalized_data = np.round(data * scaling_factor).astype(np.uint16)
         self.logger.debug(
-            "Normalized data maximum height: %s. Minimum height: %s. Number of unique values: %s.",
-            normalized_data.max(),
-            normalized_data.min(),
-            np.unique(normalized_data).size,
+            "Detected tile name: %s for coordinates: lat %s, lon %s.", tile_name, lat, lon
         )
-        return normalized_data
+        return {"latitude_band": latitude_band, "tile_name": tile_name}
+    # endregion

maps4fs/generator/dtm/usgs.py

@@ -5,12 +5,7 @@ from datetime import datetime
 from zipfile import ZipFile
 
 import numpy as np
-import rasterio
 import requests
-from rasterio.enums import Resampling
-from rasterio.merge import merge
-from rasterio.warp import calculate_default_transform, reproject
-from rasterio.windows import from_bounds
 
 from maps4fs.generator.dtm.dtm import DTMProvider, DTMProviderSettings
 
@@ -18,7 +13,6 @@ from maps4fs.generator.dtm.dtm import DTMProvider, DTMProviderSettings
 class USGSProviderSettings(DTMProviderSettings):
     """Settings for the USGS provider."""
 
-    max_local_elevation: int = 255
     dataset: tuple | str = (
         'Digital Elevation Model (DEM) 1 meter',
         'Alaska IFSAR 5 meter DEM',
@@ -43,17 +37,18 @@ class USGSProvider(DTMProvider):
     _author = "[ZenJakey](https://github.com/ZenJakey)"
     _contributors = "[kbrandwijk](https://github.com/kbrandwijk)"
     _is_community = True
-    _instructions = (
-        "ℹ️ Set the max local elevation to approx the local max elevation for your area in"
-        " meters. This will allow you to use heightScale 255 in GE with minimal tweaking."
-        " Setting this value too low can cause a flat map!"
-    )
+    _instructions = None
 
     _url = (
         "https://tnmaccess.nationalmap.gov/api/v1/products?prodFormats=GeoTIFF,IMG"
 
     )
 
+    def download_tiles(self):
+        download_urls = self.get_download_urls()
+        all_tif_files = self.download_tif_files(download_urls)
+        return all_tif_files
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
@@ -138,214 +133,3 @@ class USGSProvider(DTMProvider):
                     tif_files.append(file_path)
 
         return tif_files
-
-    def merge_geotiff(self, input_files: list[str], output_file: str) -> None:
-        """Merge multiple GeoTIFF files into a single GeoTIFF file.
-
-        Arguments:
-            input_files (list): List of input GeoTIFF files to merge.
-            output_file (str): Path to save the merged GeoTIFF file.
-        """
-        # Open all input GeoTIFF files as datasets
-        self.logger.debug("Merging tiff files...")
-        datasets = [rasterio.open(file) for file in input_files]
-
-        # Merge datasets
-        mosaic, out_transform = merge(datasets, nodata=0)
-
-        # Get metadata from the first file and update it for the output
-        out_meta = datasets[0].meta.copy()
-        out_meta.update(
-            {
-                "driver": "GTiff",
-                "height": mosaic.shape[1],
-                "width": mosaic.shape[2],
-                "transform": out_transform,
-                "count": mosaic.shape[0],  # Number of bands
-            }
-        )
-
-        # Write merged GeoTIFF to the output file
-        with rasterio.open(output_file, "w", **out_meta) as dest:
-            dest.write(mosaic)
-
-        self.logger.debug("GeoTIFF images merged successfully into %s", output_file)
-
-    def reproject_geotiff(self, input_tiff: str, output_tiff: str, target_crs: str) -> None:
-        """Reproject a GeoTIFF file to a new coordinate reference system (CRS).
-
-        Arguments:
-            input_tiff (str): Path to the input GeoTIFF file.
-            output_tiff (str): Path to save the reprojected GeoTIFF file.
-            target_crs (str): Target CRS (e.g., EPSG:4326 for CRS:84).
-        """
-        # Open the source GeoTIFF
-        self.logger.debug("Reprojecting GeoTIFF to %s CRS...", target_crs)
-        with rasterio.open(input_tiff) as src:
-            # Get the transform, width, and height of the target CRS
-            transform, width, height = calculate_default_transform(
-                src.crs, target_crs, src.width, src.height, *src.bounds
-            )
-
-            # Update the metadata for the target GeoTIFF
-            kwargs = src.meta.copy()
-            kwargs.update(
-                {"crs": target_crs, "transform": transform, "width": width, "height": height}
-            )
-
-            # Open the destination GeoTIFF file and reproject
-            with rasterio.open(output_tiff, "w", **kwargs) as dst:
-                for i in range(1, src.count + 1):  # Iterate over all raster bands
-                    reproject(
-                        source=rasterio.band(src, i),
-                        destination=rasterio.band(dst, i),
-                        src_transform=src.transform,
-                        src_crs=src.crs,
-                        dst_transform=transform,
-                        dst_crs=target_crs,
-                        resampling=Resampling.nearest,  # Choose resampling method
-                    )
-        self.logger.debug("Reprojected GeoTIFF saved to %s", output_tiff)
-
-    def extract_roi(self, input_tiff: str) -> np.ndarray:  # pylint: disable=W0237
-        """
-        Crop a GeoTIFF based on given geographic bounding box and save to a new file.
-
-        Arguments:
-            input_tiff (str): Path to the input GeoTIFF file.
-
-        Returns:
-            np.ndarray: Numpy array of the cropped GeoTIFF.
-        """
-        self.logger.debug("Extracting ROI...")
-        # Open the input GeoTIFF
-        with rasterio.open(input_tiff) as src:
-
-            # Create a rasterio window from the bounding box
-            (north, south, east, west) = self.get_bbox()
-            window = from_bounds(west, south, east, north, transform=src.transform)
-
-            data = src.read(1, window=window)
-            self.logger.debug("Extracted ROI")
-            return data
-
-    # pylint: disable=R0914, R0917, R0913
-    def convert_geotiff_to_geotiff(
-        self,
-        input_tiff: str,
-        output_tiff: str,
-        min_height: float,
-        max_height: float,
-        target_crs: str,
-    ) -> None:
-        """
-        Convert a GeoTIFF to a scaled GeoTIFF with UInt16 values using a specific coordinate
-        system and output size.
-
-        Arguments:
-            input_tiff (str): Path to the input GeoTIFF file.
-            output_tiff (str): Path to save the output GeoTIFF file.
-            min_height (float): Minimum terrain height (input range).
-            max_height (float): Maximum terrain height (input range).
-            target_crs (str): Target CRS (e.g., EPSG:4326 for CRS:84).
-        """
-        # Open the input GeoTIFF file
-        self.logger.debug("Converting to uint16")
-        with rasterio.open(input_tiff) as src:
-            # Ensure the input CRS matches the target CRS (reprojection may be required)
-            if str(src.crs) != str(target_crs):
-                raise ValueError(
-                    f"The GeoTIFF CRS is {src.crs}, but the target CRS is {target_crs}. "
-                    "Reprojection may be required."
-                )
-
-            # Read the data from the first band
-            data = src.read(1)  # Assuming the input GeoTIFF has only a single band
-
-            # Identify the input file's NoData value
-            input_nodata = src.nodata
-            if input_nodata is None:
-                input_nodata = -999999.0  # Default fallback if no NoData value is defined
-            nodata_value = 0
-            # Replace NoData values (e.g., -999999.0) with the new NoData value
-            # (e.g., 65535 for UInt16)
-            data[data == input_nodata] = nodata_value
-
-            # Scale the data to the 0–65535 range (UInt16), avoiding NoData areas
-            scaled_data = np.clip(
-                (data - min_height) * (65535 / (max_height - min_height)), 0, 65535
-            ).astype(np.uint16)
-            scaled_data[data == nodata_value] = (
-                nodata_value  # Preserve NoData value in the scaled array
-            )
-
-            # Compute the proper transform to ensure consistency
-            # Get the original transform, width, and height
-            transform = src.transform
-            width = src.width
-            height = src.height
-            left, bottom, right, top = src.bounds
-
-            # Adjust the transform matrix to make sure bounds and transform align correctly
-            transform = rasterio.transform.from_bounds(left, bottom, right, top, width, height)
-
-            # Prepare metadata for the output GeoTIFF
-            metadata = src.meta.copy()
-            metadata.update(
-                {
-                    "dtype": rasterio.uint16,  # Update dtype for uint16
-                    "crs": target_crs,  # Update CRS if needed
-                    "nodata": nodata_value,  # Set the new NoData value
-                    "transform": transform,  # Use the updated, consistent transform
-                }
-            )
-
-        # Write the scaled data to the output GeoTIFF
-        with rasterio.open(output_tiff, "w", **metadata) as dst:
-            dst.write(scaled_data, 1)  # Write the first band
-
-        self.logger.debug(
-            "GeoTIFF successfully converted and saved to %s, with nodata value: %s.",
-            output_tiff,
-            nodata_value,
-        )
-
-    def generate_data(self) -> np.ndarray:
-        """Generate data from the USGS 1m provider.
-
-        Returns:
-            np.ndarray: Numpy array of the data.
-        """
-        download_urls = self.get_download_urls()
-        all_tif_files = self.download_tif_files(download_urls)
-        self.merge_geotiff(all_tif_files, os.path.join(self.output_path, "merged.tif"))
-        self.reproject_geotiff(
-            os.path.join(self.output_path, "merged.tif"),
-            os.path.join(self.output_path, "reprojected.tif"),
-            "EPSG:4326",
-        )
-        self.convert_geotiff_to_geotiff(
-            os.path.join(self.output_path, "reprojected.tif"),
-            os.path.join(self.output_path, "translated.tif"),
-            min_height=0,
-            max_height=self.user_settings.max_local_elevation,  # type: ignore
-            target_crs="EPSG:4326",
-        )
-        return self.extract_roi(os.path.join(self.output_path, "translated.tif"))
-
-    def get_numpy(self) -> np.ndarray:
-        """Get numpy array of the tile.
-
-        Returns:
-            np.ndarray: Numpy array of the tile.
-        """
-        if not self.user_settings:
-            raise ValueError("user_settings is 'none'")
-        if self.user_settings.max_local_elevation <= 0:  # type: ignore
-            raise ValueError(
-                "Entered 'max_local_elevation' value is unable to be used. "
-                "Use a value greater than 0."
-            )
-        if not self._data:
-            self._data = self.generate_data()
-        return self._data

maps4fs/generator/texture.py

@@ -466,7 +466,11 @@ class Texture(Component):
                         self.np_to_polygon_points(polygon)  # type: ignore
                     )
                 if not layer.invisible:
-                    cv2.fillPoly(layer_image, [polygon], color=255)  # type: ignore
+                    try:
+                        cv2.fillPoly(layer_image, [polygon], color=255)  # type: ignore
+                    except Exception as e:  # pylint: disable=W0718
+                        self.logger.warning("Error drawing polygon: %s.", repr(e))
+                        continue
 
             if layer.info_layer == "roads":
                 for linestring in self.objects_generator(

{maps4fs-1.7.1.dist-info → maps4fs-1.7.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: maps4fs
-Version: 1.7.1
+Version: 1.7.3
 Summary: Generate map templates for Farming Simulator from real places.
 Author-email: iwatkot <iwatkot@gmail.com>
 License: MIT License
@@ -36,7 +36,6 @@ Requires-Dist: pydantic
   <a href="#How-To-Run">How-To-Run</a><br>
   <a href="docs/FAQ.md">FAQ</a> •
   <a href="docs/map_structure.md">Map Structure</a> •
-  <a href="docs/tips_and_hints.md">Tips and Hints</a> •
   <a href="#Modder-Toolbox">Modder Toolbox</a><br>
   <a href="#Supported-objects">Supported objects</a> •
   <a href="#Generation-info">Generation info</a> •
@@ -141,7 +140,7 @@ Check out the [Docker FAQ](docs/FAQ_docker.md) if you have any questions.<br>
 ```bash
 pip install maps4fs
 ```
-And refer to the [Python package](#option-3-python-package) section to learn how to use it.<br>
+And refer to the [Python package or run from the source](#option-3-python-package-or-source-code) section to learn how to use it.<br>
 
 ## Overview
 The core idea is coming from the awesome [maps4cim](https://github.com/klamann/maps4cim) project.<br>
@@ -201,7 +200,7 @@ docker run -d -p 8501:8501 --name maps4fs iwatkot/maps4fs
 4. Fill in the required fields and click on the `Generate` button.
 5. When the map is generated click on the `Download` button to get the map.
 
-### Option 3: Python package
+### Option 3: Python package or source code
 🔴 Recommended for developers.  
 🗺️ Supported map sizes: 2x2, 4x4, 8x8, 16x16 km and any custom size.  
 ⚙️ Advanced settings: enabled.   
@@ -212,11 +211,50 @@ You can use the Python package to generate maps. Follow these steps:
 ```bash
 pip install maps4fs
 ```
+
+Or clone the repository and install the package from the source code:
+```bash
+git clone https://github.com/iwatkot/maps4fs.git
+cd maps4fs
+dev/create_venv.ps1 # for Windows
+sh dev/create_venv.sh # for Linux
+
+# Activate the virtual environment.
+./venv/scripts/activate # for Windows
+source venv/bin/activate # for Linux
+
+# Edit the demo.py file to set the parameters.
+python demo.py
+```
+
+
 2. Import the Game class and create an instance of it:
 ```python
 import maps4fs as mfs
 
-game = mfs.Game.from_code("FS25")
+game_code = "fs25"
+game = mfs.Game.from_code(game_code)
+
+dtm_provider = mfs.SRTM30Provider
+dtm_provider_settings = mfs.SRTM30ProviderSettings(easy_mode=True, power_factor=0)
+
+lat, lon = 45.28, 20.23
+coordinates = (lat, lon)
+size = 2048
+rotation = 25
+
+map_directory = "map_directory"
+os.makedirs(map_directory, exist_ok=True)
+
+mp = mfs.Map(
+    game,
+    dtm_provider,
+    dtm_provider_settings,
+    coordinates,
+    size,
+    rotation,
+    map_directory,
+)
 ```
 In this case, the library will use the default templates, which should be present in the `data` directory, which should be placed in the current working directory.<br>
 Structure example:<br>
@@ -229,28 +267,17 @@ Structure example:<br>
 
 So it's recommended to download the `data` directory from the repository and place it in the root of your project.<br>
 
-3. Create an instance of the Map class:
-```python
-import maps4fs as mfs
-
-map = mfs.Map(
-  game,
-  (52.5200, 13.4050),  # Latitude and longitude of the map center.
-  height=1024,  # The height of the map in meters.
-  width=1024,  # The width of the map in meters.
-  map_directory="path/to/your/map/directory",  # The directory where the map will be saved.
-)
-```
-
-4. Generate the map:
+3. Launch the generation process.  
 The `generate` method returns a generator, which yields the active component of the map. You can use it to track the progress of the generation process.
 ```python
-for active_component in map.generate():
-    print(active_component)
+for component_name in mp.generate():
+    print(f"Generating {component_name}...")
 ```
 
 The map will be saved in the `map_directory` directory.
 
+➡️ Check out the [demo.py](demo.py) file for a complete example.
+
 ## Modder Toolbox
 The tool now has a Modder Toolbox, which is a set of tools to help you with various tasks. You can open the toolbox by switching to the `🧰 Modder Toolbox` tab in the StreamLit app.<br>
 

{maps4fs-1.7.1.dist-info → maps4fs-1.7.3.dist-info}/RECORD

@@ -1,4 +1,4 @@
-maps4fs/__init__.py,sha256=LrWSsyWaU28Dzcs7sRycywO_LvM-j34UvtafyBhvdx4,490
+maps4fs/__init__.py,sha256=TXqX7Ks_Kqt2fiXRt5zdVSLUHxP4cT_p7jgutYFdbo8,630
 maps4fs/logger.py,sha256=B-NEYpMjPAAqlV4VpfTi6nbBFnEABVtQOaYe6nMpidg,1489
 maps4fs/generator/__init__.py,sha256=zZMLEkGzb4z0xql650gOtGSvcgX58DnJ2yN3vC2daRk,43
 maps4fs/generator/background.py,sha256=tV4UXvtkNN-OSvv6ujp4jFWRU1xGBgEvSakVGZ1H4nc,24877
@@ -12,16 +12,17 @@ maps4fs/generator/map.py,sha256=a50KQEr1XZKjS_WKXywGwh4OC3gyjY6M8FTc0eNcxpg,1018
 maps4fs/generator/qgis.py,sha256=Es8hLuqN_KH8lDfnJE6He2rWYbAKJ3RGPn-o87S6CPI,6116
 maps4fs/generator/satellite.py,sha256=_7RcuNmR1mjxEJWMDsjnzKUIqWxnGUn50XtjB7HmSPg,3661
 maps4fs/generator/settings.py,sha256=9vbXISQrE-aDY7ATpvZ7LVJMqjfwa3-gNl-huI8XLO0,5666
-maps4fs/generator/texture.py,sha256=tDC9lIx2qn8d09Gu6PW_Lbq7EK7s1N4l25p50v92xl8,33548
+maps4fs/generator/texture.py,sha256=P4AJjedG98SFxrw4hBenw7_OgtkcI0TpE63fEffJ2eE,33761
 maps4fs/generator/dtm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-maps4fs/generator/dtm/dtm.py,sha256=nCQKQygARLxaz4HkREQQd0Yb03oKOf1Iav5_VoZsFWI,9819
-maps4fs/generator/dtm/srtm.py,sha256=2-pX6bWrJX6gr8IM7ueX6mm_PW7_UQ58MtdzDHae2OQ,9030
-maps4fs/generator/dtm/usgs.py,sha256=hwVjoSNTNRU6hwnfwJ2d3rOdtOjadCmx2QESA2REn6s,14493
+maps4fs/generator/dtm/dtm.py,sha256=T2h7eP5kQEWTGllI8ZxcGCDW4czZSoPBgOUS8a7_Ym8,19105
+maps4fs/generator/dtm/nrw.py,sha256=lJYZBZB4n5egUlX2iA7AhLmMIRKB7i_LVxCTohWsSmw,4612
+maps4fs/generator/dtm/srtm.py,sha256=RsvVa7ErajPwXoetG7mO_rldji9GR97HFaazH-PkdHw,4399
+maps4fs/generator/dtm/usgs.py,sha256=fWFR_kO_uLVjAJAL43YFvBaHwsXWI-00jMlp23Ue7Wo,5450
 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.7.1.dist-info/LICENSE.md,sha256=pTKD_oUexcn-yccFCTrMeLkZy0ifLRa-VNcDLqLZaIw,10749
-maps4fs-1.7.1.dist-info/METADATA,sha256=QMIGgmKUnYvtc-Ln_rxPm7WeF8Q9L82Eo_aY2g2Uc8c,39697
-maps4fs-1.7.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-maps4fs-1.7.1.dist-info/top_level.txt,sha256=Ue9DSRlejRQRCaJueB0uLcKrWwsEq9zezfv5dI5mV1M,8
-maps4fs-1.7.1.dist-info/RECORD,,
+maps4fs-1.7.3.dist-info/LICENSE.md,sha256=pTKD_oUexcn-yccFCTrMeLkZy0ifLRa-VNcDLqLZaIw,10749
+maps4fs-1.7.3.dist-info/METADATA,sha256=3oaI3MI_V8Vf-qZi3r3bS1Qn-Y806sDHE7g1JqV9YDI,40240
+maps4fs-1.7.3.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+maps4fs-1.7.3.dist-info/top_level.txt,sha256=Ue9DSRlejRQRCaJueB0uLcKrWwsEq9zezfv5dI5mV1M,8
+maps4fs-1.7.3.dist-info/RECORD,,