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

maps4fs/__init__.py

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

maps4fs/generator/dem.py

@@ -9,7 +9,7 @@ import numpy as np
 from pympler import asizeof  # type: ignore
 
 from maps4fs.generator.component import Component
-from maps4fs.generator.dtm import DTMProvider
+from maps4fs.generator.dtm.dtm import DTMProvider
 
 
 # pylint: disable=R0903, R0902
@@ -280,55 +280,3 @@ class DEM(Component):
             list: Empty list.
         """
         return []
-
-    def _get_scaling_factor(self, maximum_deviation: int) -> float:
-        """Calculate scaling factor for DEM data normalization.
-        NOTE: Needs reconsideration for the implementation.
-
-        Arguments:
-            maximum_deviation (int): Maximum deviation in DEM data.
-
-        Returns:
-            float: Scaling factor for DEM data normalization.
-        """
-        ESTIMATED_MAXIMUM_DEVIATION = 1000  # pylint: disable=C0103
-        scaling_factor = maximum_deviation / ESTIMATED_MAXIMUM_DEVIATION
-        return scaling_factor if scaling_factor < 1 else 1
-
-    def _normalize_dem(self, data: np.ndarray) -> np.ndarray:
-        """Normalize DEM data to 16-bit unsigned integer using max height from settings.
-        Arguments:
-            data (np.ndarray): DEM data from SRTM file after cropping.
-        Returns:
-            np.ndarray: Normalized DEM data.
-        """
-        self.logger.debug("Starting DEM data normalization.")
-        # Calculate the difference between the maximum and minimum values in the DEM data.
-
-        max_height = data.max()
-        min_height = data.min()
-        max_dev = max_height - min_height
-        self.logger.debug(
-            "Maximum deviation: %s with maximum at %s and minimum at %s.",
-            max_dev,
-            max_height,
-            min_height,
-        )
-
-        scaling_factor = self._get_scaling_factor(max_dev)
-        adjusted_max_height = int(65535 * scaling_factor)
-        self.logger.debug(
-            "Maximum deviation: %s. Scaling factor: %s. Adjusted max height: %s.",
-            max_dev,
-            scaling_factor,
-            adjusted_max_height,
-        )
-        normalized_data = (
-            (data - data.min()) / (data.max() - data.min()) * adjusted_max_height
-        ).astype("uint16")
-        self.logger.debug(
-            "DEM data was normalized to %s - %s.",
-            normalized_data.min(),
-            normalized_data.max(),
-        )
-        return normalized_data

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

@@ -4,10 +4,7 @@ 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
@@ -263,71 +260,3 @@ class DTMProvider:
             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/dtm/srtm.py

@@ -0,0 +1,86 @@
+"""This module contains provider of Shuttle Radar Topography Mission (SRTM) 30m data."""
+
+import gzip
+import math
+import os
+import shutil
+
+import numpy as np
+
+from maps4fs.generator.dtm.dtm import DTMProvider
+
+
+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)"
+
+    _instructions = (
+        "ℹ️ If you're a rookie in the Giants Editor check the **Apply the default multiplier** "
+        "checkbox. Otherwise, you can change the multiplier value in the DEM Settings. "
+        "If you will not apply the default multiplier and not change the value in the DEM "
+        "Settings, you'll have the DEM image with the original values as on Earth, which can "
+        "not be seen by eye and will lead to completely flat terrain. "
+    )
+
+    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/dtm/usgs.py

@@ -0,0 +1,323 @@
+"""This module contains provider of USGS 1m data."""
+
+import os
+from datetime import datetime
+
+import numpy as np
+import rasterio  # type: ignore
+import requests
+from rasterio._warp import Resampling  # type: ignore # pylint: disable=E0611
+from rasterio.merge import merge  # type: ignore
+from rasterio.warp import calculate_default_transform, reproject  # type: ignore
+from rasterio.windows import from_bounds  # type: ignore
+
+from maps4fs.generator.dtm.dtm import DTMProvider, DTMProviderSettings
+
+
+class USGS1mProviderSettings(DTMProviderSettings):
+    """Settings for the USGS 1m provider."""
+
+    max_local_elevation: int = 255
+
+
+# pylint: disable=W0223
+class USGS1mProvider(DTMProvider):
+    """Provider of USGS."""
+
+    _code = "USGS1m"
+    _name = "USGS 1m"
+    _region = "USA"
+    _icon = "🇺🇸"
+    _resolution = 1
+    _data: np.ndarray | None = None
+    _settings = USGS1mProviderSettings
+    _author = "[ZenJakey](https://github.com/ZenJakey)"
+    _is_community = True
+
+    _url = (
+        "https://tnmaccess.nationalmap.gov/api/v1/products?prodFormats=GeoTIFF,IMG&prodExtents="
+        "10000 x 10000 meter&datasets=Digital Elevation Model (DEM) 1 meter&polygon="
+    )
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+        self.shared_tiff_path = os.path.join(self._tile_directory, "shared")
+        os.makedirs(self.shared_tiff_path, exist_ok=True)
+        self.output_path = os.path.join(self._tile_directory, f"timestamp_{timestamp}")
+        os.makedirs(self.output_path, exist_ok=True)
+
+    def get_download_urls(self) -> list[str]:
+        """Get download URLs of the GeoTIFF files from the USGS API.
+
+        Returns:
+            list: List of download URLs.
+        """
+        urls = []
+        try:
+            # Make the GET request
+            (north, south, east, west) = self.get_bbox()
+            response = requests.get(  # pylint: disable=W3101
+                self.url  # type: ignore
+                + f"{west} {south},{east} {south},{east} {north},{west} {north},{west} {south}&="
+            )
+            self.logger.debug("Getting file locations from USGS...")
+
+            # Check if the request was successful (HTTP status code 200)
+            if response.status_code == 200:
+                # Parse the JSON response
+                json_data = response.json()
+                items = json_data["items"]
+                for item in items:
+                    urls.append(item["downloadURL"])
+                self.download_tif_files(urls)
+            else:
+                self.logger.error("Failed to get data. HTTP Status Code: %s", response.status_code)
+        except requests.exceptions.RequestException as e:
+            self.logger.error("Failed to get data. Error: %s", e)
+        self.logger.debug("Received %s urls", len(urls))
+        return urls
+
+    def download_tif_files(self, urls: list[str]) -> list[str]:
+        """Download GeoTIFF files from the given URLs.
+
+        Arguments:
+            urls (list): List of URLs to download GeoTIFF files from.
+
+        Returns:
+            list: List of paths to the downloaded GeoTIFF files.
+        """
+        tif_files = []
+        for url in urls:
+            file_name = os.path.basename(url)
+            self.logger.debug("Retrieving TIFF: %s", file_name)
+            file_path = os.path.join(self.shared_tiff_path, file_name)
+            if not os.path.exists(file_path):
+                try:
+                    # Send a GET request to the file URL
+                    response = requests.get(url, stream=True)  # pylint: disable=W3101
+                    response.raise_for_status()  # Raise an error for HTTP status codes 4xx/5xx
+
+                    # Write the content of the response to the file
+                    with open(file_path, "wb") as file:
+                        for chunk in response.iter_content(chunk_size=8192):  # Download in chunks
+                            file.write(chunk)
+                    self.logger.info("File downloaded successfully: %s", file_path)
+                except requests.exceptions.RequestException as e:
+                    self.logger.error("Failed to download file: %s", e)
+            else:
+                self.logger.debug("File already exists: %s", file_name)
+
+            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)
+
+        # 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/map.py

@@ -8,7 +8,7 @@ import shutil
 from typing import Any, Generator
 
 from maps4fs.generator.component import Component
-from maps4fs.generator.dtm import DTMProvider, DTMProviderSettings
+from maps4fs.generator.dtm.dtm import DTMProvider, DTMProviderSettings
 from maps4fs.generator.game import Game
 from maps4fs.generator.settings import (
     BackgroundSettings,

maps4fs/generator/texture.py

@@ -305,8 +305,7 @@ class Texture(Component):
         useful_attributes = [
             "coordinates",
             "bbox",
-            "map_height",
-            "map_width",
+            "map_size",
             "rotation",
             "minimum_x",
             "minimum_y",

{maps4fs-1.5.7.dist-info → maps4fs-1.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: maps4fs
-Version: 1.5.7
+Version: 1.6.0
 Summary: Generate map templates for Farming Simulator from real places.
 Author-email: iwatkot <iwatkot@gmail.com>
 License: MIT License
@@ -48,6 +48,7 @@ Requires-Dist: pydantic
   <a href="#Expert-settings">Expert settings</a> •
   <a href="#Resources">Resources</a> •
   <a href="#Bugs-and-feature-requests">Bugs and feature requests</a><br>
+  <a href="#DTM-Providers">DTM Providers</a> •
   <a href="#Special-thanks">Special thanks</a>
 </p>
 
@@ -69,6 +70,7 @@ Requires-Dist: pydantic
 
 🗺️ Supports 2x2, 4x4, 8x8, 16x16 and any custom size maps<br>
 🔄 Support map rotation 🆕<br>
+🌐 Supports custom [DTM Providers](#DTM-Providers) 🆕<br>
 🌾 Automatically generates fields 🆕<br>
 🌽 Automatically generates farmlands 🆕<br>
 🌿 Automatically generates decorative foliage 🆕<br>
@@ -547,6 +549,15 @@ To create a basic map, you only need the Giants Editor. But if you want to creat
 ➡️ Please, before creating an issue or asking some questions, check the [FAQ](docs/FAQ.md) section.<br>
 If you find a bug or have an idea for a new feature, please create an issue [here](https://github.com/iwatkot/maps4fs/issues) or contact me directly on [Telegram](https://t.me/iwatkot) or on Discord: `iwatkot`.
 
+## DTM Providers
+
+The generator supports adding the own DTM providers, please refer to the [DTM Providers](docs/dtm_providers.md) section to learn how to add the custom DTM provider.
+
+### Supported DTM providers
+
+- [SRTM 30m](https://dwtkns.com/srtm30m/) - the 30 meters resolution DEM data from the SRTM mission for the whole world.
+- [USGS 1m](https://portal.opentopography.org/raster?opentopoID=OTNED.012021.4269.3) - the 1-meter resolution DEM data from the USGS for the USA. Developed by [ZenJakey](https://github.com/ZenJakey).
+
 ## Special thanks
 
 Of course, first of all, thanks to the direct [contributors](https://github.com/iwatkot/maps4fs/graphs/contributors) of the project.  

{maps4fs-1.5.7.dist-info → maps4fs-1.6.0.dist-info}/RECORD

@@ -1,24 +1,27 @@
-maps4fs/__init__.py,sha256=EJzbqRrSGltSMUI-dHgONODxKt9YvP_ElwFmXV8M_MA,380
+maps4fs/__init__.py,sha256=WbT36EzJ_74GN0RUUrLIYECdSdtRiZaxKl17KUt7pjA,492
 maps4fs/logger.py,sha256=B-NEYpMjPAAqlV4VpfTi6nbBFnEABVtQOaYe6nMpidg,1489
 maps4fs/generator/__init__.py,sha256=zZMLEkGzb4z0xql650gOtGSvcgX58DnJ2yN3vC2daRk,43
 maps4fs/generator/background.py,sha256=moTsEJM-hZgHQQiBjFVTWBKgPMqxup-58EErh4bq_dE,21342
 maps4fs/generator/component.py,sha256=RtXruvT4Fxfr7_xo9Bi-i3IIWcPd5QQOSpYJ_cNC49o,20408
 maps4fs/generator/config.py,sha256=0QmK052B8bxyHVhg3jzCORLfOBMMmqVfhhbqXKf6OMk,4383
-maps4fs/generator/dem.py,sha256=shyehXYXXog9ZTdi_8Y1WAnmhsL4-YAIZ3EpmGy8qeA,12300
-maps4fs/generator/dtm.py,sha256=5_1e-kQcZ7c1Xg3tvuTyumzfTAcUPmDkIyZd5VagyOk,10550
+maps4fs/generator/dem.py,sha256=gXmHRckXf9-3fNwEhZ8jk89oMn6eElghIQ1kUa0rcuk,10328
 maps4fs/generator/game.py,sha256=QHgVnyGYvEnfwGZ84-u-dpbCRr3UeVVqBbrwr5WG8dE,7992
 maps4fs/generator/grle.py,sha256=u8ZwSs313PIOkH_0B_O2tVTaZ-eYNkc30eKGtBxWzTM,17846
 maps4fs/generator/i3d.py,sha256=FLVlj0g90IXRuaRARD1HTnufsLpuaa5kHKdiME-LUZY,24329
-maps4fs/generator/map.py,sha256=flU0b2TrVYLxj9o3v_YRvNz9YB3s4w6YFSv4Jka5ojM,9283
+maps4fs/generator/map.py,sha256=-iUFGqe11Df-oUrxhcnJzRZ0o6NZKRQ_blTq1h1Wezg,9287
 maps4fs/generator/qgis.py,sha256=Es8hLuqN_KH8lDfnJE6He2rWYbAKJ3RGPn-o87S6CPI,6116
 maps4fs/generator/satellite.py,sha256=Qnb6XxmXKnHdHKVMb9mJ3vDGtGkDHCOv_81hrrXdx3k,3660
 maps4fs/generator/settings.py,sha256=NWuK76ICr8gURQnzePat4JH9w-iACbQEKQebqu51gBE,4470
-maps4fs/generator/texture.py,sha256=sErusfv1AqQfP-veMrZ921Tz8DnGEhfB4ucggMmKrD4,31231
+maps4fs/generator/texture.py,sha256=7Z6Ci7urMvqk3-Jp9K2AKH2KlD1smEQS2qoc8Qzn8Uw,31204
+maps4fs/generator/dtm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+maps4fs/generator/dtm/dtm.py,sha256=THQ3RWVL9ut7A4omS8hEog-oQSSwYV0JcDMe0Iiw4fY,8009
+maps4fs/generator/dtm/srtm.py,sha256=x78VjI4onXxPx5CLrzpwEgFOA_E9f9zhouPdKC2YnBE,3190
+maps4fs/generator/dtm/usgs.py,sha256=U0kDog1UAa1lWiK4Pe3nnhXnnplOS4HZde1yqYqCiDw,13123
 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.7.dist-info/LICENSE.md,sha256=pTKD_oUexcn-yccFCTrMeLkZy0ifLRa-VNcDLqLZaIw,10749
-maps4fs-1.5.7.dist-info/METADATA,sha256=pIrqQEpHgaljNNzjl297anHnHS2jMruuNeBKyX9iGME,35585
-maps4fs-1.5.7.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-maps4fs-1.5.7.dist-info/top_level.txt,sha256=Ue9DSRlejRQRCaJueB0uLcKrWwsEq9zezfv5dI5mV1M,8
-maps4fs-1.5.7.dist-info/RECORD,,
+maps4fs-1.6.0.dist-info/LICENSE.md,sha256=pTKD_oUexcn-yccFCTrMeLkZy0ifLRa-VNcDLqLZaIw,10749
+maps4fs-1.6.0.dist-info/METADATA,sha256=36OOMtK0RoswMn9iyTDeJFuNeIVlhcmrDknK4Xe8HE4,36231
+maps4fs-1.6.0.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+maps4fs-1.6.0.dist-info/top_level.txt,sha256=Ue9DSRlejRQRCaJueB0uLcKrWwsEq9zezfv5dI5mV1M,8
+maps4fs-1.6.0.dist-info/RECORD,,