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

maps4fs/generator/dtm/nrw.py

@@ -0,0 +1,127 @@
+"""This module contains provider of NRW 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 NRW 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