maps4fs 1.7.2__py3-none-any.whl → 1.7.4__py3-none-any.whl

maps4fs/__init__.py

@@ -2,6 +2,7 @@
 from maps4fs.generator.dtm.dtm import DTMProvider
 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 (

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/toolbox/custom_osm.py

@@ -0,0 +1,67 @@
+"""This module contains functions to work with custom OSM files."""
+
+import json
+from xml.etree import ElementTree as ET
+
+import osmnx as ox
+from osmnx._errors import InsufficientResponseError
+
+from maps4fs.generator.game import FS25
+
+
+def check_osm_file(file_path: str) -> bool:
+    """Tries to read the OSM file using OSMnx and returns True if the file is valid,
+    False otherwise.
+
+    Arguments:
+        file_path (str): Path to the OSM file.
+
+    Returns:
+        bool: True if the file is valid, False otherwise.
+    """
+    with open(FS25().texture_schema, encoding="utf-8") as f:
+        schema = json.load(f)
+
+    tags = []
+    for element in schema:
+        element_tags = element.get("tags")
+        if element_tags:
+            tags.append(element_tags)
+
+    for tag in tags:
+        try:
+            ox.features_from_xml(file_path, tags=tag)
+        except InsufficientResponseError:
+            continue
+        except Exception:  # pylint: disable=W0718
+            return False
+    return True
+
+
+def fix_osm_file(input_file_path: str, output_file_path: str) -> tuple[bool, int]:
+    """Fixes the OSM file by removing all the <relation> nodes and all the nodes with
+    action='delete'.
+
+    Arguments:
+        input_file_path (str): Path to the input OSM file.
+        output_file_path (str): Path to the output OSM file.
+
+    Returns:
+        tuple[bool, int]: A tuple containing the result of the check_osm_file function
+            and the number of fixed errors.
+    """
+    broken_entries = ["relation", ".//*[@action='delete']"]
+
+    tree = ET.parse(input_file_path)
+    root = tree.getroot()
+
+    fixed_errors = 0
+    for entry in broken_entries:
+        for element in root.findall(entry):
+            root.remove(element)
+            fixed_errors += 1
+
+    tree.write(output_file_path)
+    result = check_osm_file(output_file_path)
+
+    return result, fixed_errors

{maps4fs-1.7.2.dist-info → maps4fs-1.7.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: maps4fs
-Version: 1.7.2
+Version: 1.7.4
 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> •
@@ -293,6 +292,9 @@ Tools are divided into categories, which are listed below.
 - **Texture Schema Editor** - allows you to view all the supported textures and edit their parameters, such as priority, OSM tags and so on. After editing, you should click the Show updated schema button and copy the JSON schema to the clipboard. Then you can use it in the Expert settings to generate the map with the updated textures.
 
 #### For Textures and DEM
+
+- **Fix custom OSM file** - this tool fixes the most common errors in the custom OSM file, but it can not guarantee that the file will be fixed completely if some non-common errors are present.
+
 - **GeoTIFF windowing** - allows you to upload your GeoTIFF file and select the region of interest to extract it from the image. It's useful when you have high-resolution DEM data and want to create a height map using it.
 
 #### For Background terrain

{maps4fs-1.7.2.dist-info → maps4fs-1.7.4.dist-info}/RECORD

@@ -1,4 +1,4 @@
-maps4fs/__init__.py,sha256=rUpfzsaHxFEf4wS1f1TtmIIcTs8Ub-X_KE9zdiQVt5A,559
+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
@@ -14,14 +14,16 @@ maps4fs/generator/satellite.py,sha256=_7RcuNmR1mjxEJWMDsjnzKUIqWxnGUn50XtjB7HmSP
 maps4fs/generator/settings.py,sha256=9vbXISQrE-aDY7ATpvZ7LVJMqjfwa3-gNl-huI8XLO0,5666
 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/custom_osm.py,sha256=X6ZlPqiOhNjkmdD_qVroIfdOl9Rb90cDwVSLDVYgx80,1892
 maps4fs/toolbox/dem.py,sha256=z9IPFNmYbjiigb3t02ZenI3Mo8odd19c5MZbjDEovTo,3525
-maps4fs-1.7.2.dist-info/LICENSE.md,sha256=pTKD_oUexcn-yccFCTrMeLkZy0ifLRa-VNcDLqLZaIw,10749
-maps4fs-1.7.2.dist-info/METADATA,sha256=t_t_Ybmh8QDgytrnMqmUBTtWGVhnyn6_rPNpTDYq2k4,40298
-maps4fs-1.7.2.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-maps4fs-1.7.2.dist-info/top_level.txt,sha256=Ue9DSRlejRQRCaJueB0uLcKrWwsEq9zezfv5dI5mV1M,8
-maps4fs-1.7.2.dist-info/RECORD,,
+maps4fs-1.7.4.dist-info/LICENSE.md,sha256=pTKD_oUexcn-yccFCTrMeLkZy0ifLRa-VNcDLqLZaIw,10749
+maps4fs-1.7.4.dist-info/METADATA,sha256=RqMBGBQBs4zhyn8fnpnNwXl6Fm_zhPBaNuxo1-TVQUg,40436
+maps4fs-1.7.4.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+maps4fs-1.7.4.dist-info/top_level.txt,sha256=Ue9DSRlejRQRCaJueB0uLcKrWwsEq9zezfv5dI5mV1M,8
+maps4fs-1.7.4.dist-info/RECORD,,