maps4fs 1.8.0__py3-none-any.whl

maps4fs/generator/dtm/niedersachsen.py

@@ -0,0 +1,39 @@
+"""This module contains provider of Niedersachsen data."""
+
+from maps4fs.generator.dtm.base.wms import WMSProvider
+from maps4fs.generator.dtm.dtm import DTMProvider
+
+
+# pylint: disable=R0801
+class NiedersachsenProvider(WMSProvider, DTMProvider):
+    """Provider of Niedersachsen data."""
+
+    _code = "niedersachsen"
+    _name = "Lower Saxony DGM1"
+    _region = "DE"
+    _icon = "🇩🇪󠁥󠁢󠁹󠁿"
+    _resolution = 1
+    _author = "[kbrandwijk](https://github.com/kbrandwijk)"
+    _is_community = True
+    _instructions = (
+        "Warning: The Niedersachsen DGM1 data is provided as 8-bit Cloud Optimized GeoTIFF "
+        "(whole meters only). You will need to use blur ('Blur Radius' under 'DEM Settings') "
+        "to smooth the data."
+    )
+    _is_base = False
+    _extents = (54.148101, 51.153098, 11.754046, 6.505772)
+
+    _url = "https://opendata.lgln.niedersachsen.de/doorman/noauth/dgm_wms"
+    _source_crs = "EPSG:25832"
+    _tile_size = 2000
+    _wms_version = "1.3.0"
+
+    def get_wms_parameters(self, tile):
+        return {
+            "layers": ["ni_dgm1_grau"],
+            "srs": "EPSG:25832",
+            "bbox": (tile[1], tile[0], tile[3], tile[2]),
+            "size": (2000, 2000),
+            "format": "image/tiff",
+            "transparent": False,
+        }

maps4fs/generator/dtm/nrw.py

@@ -0,0 +1,30 @@
+"""This module contains provider of NRW data."""
+
+from maps4fs.generator.dtm.base.wcs import WCSProvider
+from maps4fs.generator.dtm.dtm import DTMProvider
+
+
+class NRWProvider(WCSProvider, DTMProvider):
+    """Provider of NRW data."""
+
+    _code = "NRW"
+    _name = "North Rhine-Westphalia DGM1"
+    _region = "DE"
+    _icon = "🇩🇪󠁥󠁢󠁹󠁿"
+    _resolution = 1
+    _author = "[kbrandwijk](https://github.com/kbrandwijk)"
+    _is_community = True
+    _is_base = False
+    _extents = (52.6008271, 50.1506045, 9.5315425, 5.8923538)
+
+    _url = "https://www.wcs.nrw.de/geobasis/wcs_nw_dgm"
+    _wcs_version = "2.0.1"
+    _source_crs = "EPSG:25832"
+    _tile_size = 1000
+
+    def get_wcs_parameters(self, tile: tuple[float, float, float, float]) -> dict:
+        return {
+            "identifier": ["nw_dgm"],
+            "subsets": [("y", str(tile[0]), str(tile[2])), ("x", str(tile[1]), str(tile[3]))],
+            "format": "image/tiff",
+        }

maps4fs/generator/dtm/srtm.py

@@ -0,0 +1,127 @@
+"""This module contains provider of Shuttle Radar Topography Mission (SRTM) 30m data."""
+
+# Author: https://github.com/iwatkot
+
+import gzip
+import math
+import os
+import shutil
+
+import requests
+
+from maps4fs.generator.dtm.dtm import DTMProvider, DTMProviderSettings
+
+
+class SRTM30ProviderSettings(DTMProviderSettings):
+    """Settings for SRTM 30m provider."""
+
+
+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)"
+
+    _extents = (60, -65, 180, -180)
+
+    _settings = SRTM30ProviderSettings
+
+    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)
+        self.data_info: dict[str, int | str | float] | None = None  # type: ignore
+
+    def download_tiles(self):
+        """Download SRTM tiles."""
+        north, south, east, west = self.get_bbox()
+
+        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")
+
+            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)
+            tiles.append(decompressed_tile_path)
+
+        return list(set(tiles))
+
+    # region provider specific helpers
+    def download_tile(self, output_path: str, **kwargs) -> bool:
+        """Download a tile from the provider.
+
+        Arguments:
+            output_path (str): Path to save the downloaded tile.
+
+        Returns:
+            bool: True if the tile was downloaded successfully, False otherwise.
+        """
+        url = self.formatted_url(**kwargs)
+        response = requests.get(url, stream=True, timeout=10)
+        if response.status_code == 200:
+            with open(output_path, "wb") as file:
+                for chunk in response.iter_content(chunk_size=1024):
+                    file.write(chunk)
+            return True
+        return False
+
+    def get_or_download_tile(self, output_path: str, **kwargs) -> str | None:
+        """Get or download a tile from the provider.
+
+        Arguments:
+            output_path (str): Path to save the downloaded tile.
+
+        Returns:
+            str: Path to the downloaded tile or None if the tile not exists and was
+                not downloaded.
+        """
+        if not os.path.exists(output_path):
+            if not self.download_tile(output_path, **kwargs):
+                return None
+        return output_path
+
+    def get_tile_parameters(self, *args) -> 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}
+
+    # endregion

maps4fs/generator/dtm/usgs.py

@@ -0,0 +1,87 @@
+"""This module contains provider of USGS data."""
+
+import os
+from datetime import datetime
+
+import numpy as np
+import requests
+
+from maps4fs.generator.dtm.dtm import DTMProvider, DTMProviderSettings
+
+
+class USGSProviderSettings(DTMProviderSettings):
+    """Settings for the USGS provider."""
+
+    dataset: tuple | str = (
+        "Digital Elevation Model (DEM) 1 meter",
+        "Alaska IFSAR 5 meter DEM",
+        "National Elevation Dataset (NED) 1/9 arc-second",
+        "National Elevation Dataset (NED) 1/3 arc-second",
+        "National Elevation Dataset (NED) 1 arc-second",
+        "National Elevation Dataset (NED) Alaska 2 arc-second",
+        "Original Product Resolution (OPR) Digital Elevation Model (DEM)",
+    )
+
+
+class USGSProvider(DTMProvider):
+    """Provider of USGS."""
+
+    _code = "USGS"
+    _name = "USGS"
+    _region = "USA"
+    _icon = "🇺🇸"
+    _resolution = "variable"
+    _data: np.ndarray | None = None
+    _settings = USGSProviderSettings
+    _author = "[ZenJakey](https://github.com/ZenJakey)"
+    _contributors = "[kbrandwijk](https://github.com/kbrandwijk)"
+    _is_community = True
+    _instructions = None
+    _extents = (50.0, 17.0, -64.0, -162.0)
+
+    _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, self.shared_tiff_path)
+        return all_tif_files
+
+    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"&datasets={self.user_settings.dataset}"  # type: ignore
+                + f"&bbox={west},{north},{east},{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

maps4fs/generator/dtm/utils.py

@@ -0,0 +1,61 @@
+"""Utility functions for the DTM generator."""
+
+import numpy as np
+from pyproj import Transformer
+
+
+def tile_bbox(
+    bbox: tuple[float, float, float, float], tile_size: float
+) -> 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 if east > west else -tile_size)
+    y_coords = np.arange(north, south, tile_size if south > north else -tile_size)
+    x_coords = np.append(x_coords, east).astype(x_coords.dtype)
+    y_coords = np.append(y_coords, south).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, dtype=float
+    )
+
+    return [tuple(tile[i].item() for i in range(4)) for tile in tiles]
+
+
+def transform_bbox(
+    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
+
+    # EPSG:4326 is lat, lon, so xx is lat and yy is lon
+    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)
+    north = min(bottom_left_x, top_left_x)
+    south = max(bottom_right_x, top_right_x)
+
+    return north, south, east, west

maps4fs/generator/game.py

@@ -0,0 +1,247 @@
+"""This module contains the Game class and its subclasses. Game class is used to define
+different versions of the game for which the map is generated. Each game has its own map
+template file and specific settings for map generation."""
+
+from __future__ import annotations
+
+import os
+
+from maps4fs.generator.background import Background
+from maps4fs.generator.config import Config
+from maps4fs.generator.grle import GRLE
+from maps4fs.generator.i3d import I3d
+from maps4fs.generator.satellite import Satellite
+from maps4fs.generator.texture import Texture
+
+working_directory = os.getcwd()
+
+
+class Game:
+    """Class used to define different versions of the game for which the map is generated.
+
+    Arguments:
+        map_template_path (str, optional): Path to the map template file. Defaults to None.
+
+    Attributes and Properties:
+        code (str): The code of the game.
+        components (list[Type[Component]]): List of components used for map generation.
+        map_template_path (str): Path to the map template file.
+
+    Public Methods:
+        from_code(cls, code: str) -> Game: Returns the game instance based on the game code.
+    """
+
+    code: str | None = None
+    dem_multipliyer: int = 2
+    _additional_dem_name: str | None = None
+    _map_template_path: str | None = None
+    _texture_schema: str | None = None
+    _grle_schema: str | None = None
+    _tree_schema: str | None = None
+
+    # Order matters! Some components depend on others.
+    components = [Texture, Background, GRLE, I3d, Config, Satellite]
+
+    def __init__(self, map_template_path: str | None = None):
+        if map_template_path:
+            self._map_template_path = map_template_path
+
+    def map_xml_path(self, map_directory: str) -> str:
+        """Returns the path to the map.xml file.
+
+        Arguments:
+            map_directory (str): The path to the map directory.
+
+        Returns:
+            str: The path to the map.xml file.
+        """
+        return os.path.join(map_directory, "maps", "map", "map.xml")
+
+    @classmethod
+    def from_code(cls, code: str, map_template_path: str | None = None) -> Game:
+        """Returns the game instance based on the game code.
+
+        Arguments:
+            code (str): The code of the game.
+            map_template_path (str, optional): Path to the map template file. Defaults to None.
+
+        Returns:
+            Game: The game instance.
+        """
+        for game in cls.__subclasses__():
+            if game.code and game.code.lower() == code.lower():
+                return game(map_template_path)
+        raise ValueError(f"Game with code {code} not found.")
+
+    @property
+    def template_path(self) -> str:
+        """Returns the path to the map template file.
+
+        Raises:
+            ValueError: If the map template path is not set.
+
+        Returns:
+            str: The path to the map template file."""
+        if not self._map_template_path:
+            raise ValueError("Map template path not set.")
+        return self._map_template_path
+
+    @property
+    def texture_schema(self) -> str:
+        """Returns the path to the texture layers schema file.
+
+        Raises:
+            ValueError: If the texture layers schema path is not set.
+
+        Returns:
+            str: The path to the texture layers schema file."""
+        if not self._texture_schema:
+            raise ValueError("Texture layers schema path not set.")
+        return self._texture_schema
+
+    @property
+    def grle_schema(self) -> str:
+        """Returns the path to the GRLE layers schema file.
+
+        Raises:
+            ValueError: If the GRLE layers schema path is not set.
+
+        Returns:
+            str: The path to the GRLE layers schema file."""
+        if not self._grle_schema:
+            raise ValueError("GRLE layers schema path not set.")
+        return self._grle_schema
+
+    @property
+    def tree_schema(self) -> str:
+        """Returns the path to the tree layers schema file.
+
+        Raises:
+            ValueError: If the tree layers schema path is not set.
+
+        Returns:
+            str: The path to the tree layers schema file."""
+        if not self._tree_schema:
+            raise ValueError("Tree layers schema path not set.")
+        return self._tree_schema
+
+    def dem_file_path(self, map_directory: str) -> str:
+        """Returns the path to the DEM file.
+
+        Arguments:
+            map_directory (str): The path to the map directory.
+
+        Returns:
+            str: The path to the DEM file.
+        """
+        raise NotImplementedError
+
+    def weights_dir_path(self, map_directory: str) -> str:
+        """Returns the path to the weights directory.
+
+        Arguments:
+            map_directory (str): The path to the map directory.
+
+        Returns:
+            str: The path to the weights directory."""
+        raise NotImplementedError
+
+    def i3d_file_path(self, map_directory: str) -> str:
+        """Returns the path to the i3d file.
+
+        Arguments:
+            map_directory (str): The path to the map directory.
+
+        Returns:
+            str: The path to the i3d file."""
+        raise NotImplementedError
+
+    @property
+    def additional_dem_name(self) -> str | None:
+        """Returns the name of the additional DEM file.
+
+        Returns:
+            str | None: The name of the additional DEM file."""
+        return self._additional_dem_name
+
+
+# pylint: disable=W0223
+class FS22(Game):
+    """Class used to define the game version FS22."""
+
+    code = "FS22"
+    _map_template_path = os.path.join(working_directory, "data", "fs22-map-template.zip")
+    _texture_schema = os.path.join(working_directory, "data", "fs22-texture-schema.json")
+
+    def dem_file_path(self, map_directory: str) -> str:
+        """Returns the path to the DEM file.
+
+        Arguments:
+            map_directory (str): The path to the map directory.
+
+        Returns:
+            str: The path to the DEM file."""
+        return os.path.join(map_directory, "maps", "map", "data", "map_dem.png")
+
+    def weights_dir_path(self, map_directory: str) -> str:
+        """Returns the path to the weights directory.
+
+        Arguments:
+            map_directory (str): The path to the map directory.
+
+        Returns:
+            str: The path to the weights directory."""
+        return os.path.join(map_directory, "maps", "map", "data")
+
+
+class FS25(Game):
+    """Class used to define the game version FS25."""
+
+    code = "FS25"
+    dem_multipliyer: int = 2
+    _additional_dem_name = "unprocessedHeightMap.png"
+    _map_template_path = os.path.join(working_directory, "data", "fs25-map-template.zip")
+    _texture_schema = os.path.join(working_directory, "data", "fs25-texture-schema.json")
+    _grle_schema = os.path.join(working_directory, "data", "fs25-grle-schema.json")
+    _tree_schema = os.path.join(working_directory, "data", "fs25-tree-schema.json")
+
+    def dem_file_path(self, map_directory: str) -> str:
+        """Returns the path to the DEM file.
+
+        Arguments:
+            map_directory (str): The path to the map directory.
+
+        Returns:
+            str: The path to the DEM file."""
+        return os.path.join(map_directory, "map", "data", "dem.png")
+
+    def map_xml_path(self, map_directory: str) -> str:
+        """Returns the path to the map.xml file.
+
+        Arguments:
+            map_directory (str): The path to the map directory.
+
+        Returns:
+            str: The path to the map.xml file.
+        """
+        return os.path.join(map_directory, "map", "map.xml")
+
+    def weights_dir_path(self, map_directory: str) -> str:
+        """Returns the path to the weights directory.
+
+        Arguments:
+            map_directory (str): The path to the map directory.
+
+        Returns:
+            str: The path to the weights directory."""
+        return os.path.join(map_directory, "map", "data")
+
+    def i3d_file_path(self, map_directory: str) -> str:
+        """Returns the path to the i3d file.
+
+        Arguments:
+            map_directory (str): The path to the map directory.
+
+        Returns:
+            str: The path to the i3d file."""
+        return os.path.join(map_directory, "map", "map.i3d")