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

maps4fs/__init__.py

@@ -1,11 +1,12 @@
 # pylint: disable=missing-module-docstring
+from maps4fs.generator.dtm import DTMProvider
 from maps4fs.generator.game import Game
-from maps4fs.generator.map import (
+from maps4fs.generator.map import Map
+from maps4fs.generator.settings import (
     BackgroundSettings,
     DEMSettings,
     GRLESettings,
     I3DSettings,
-    Map,
     SettingsModel,
     SplineSettings,
     TextureSettings,

maps4fs/generator/background.py

@@ -57,36 +57,23 @@ class Background(Component):
         os.makedirs(self.background_directory, exist_ok=True)
         os.makedirs(self.water_directory, exist_ok=True)
 
-        autoprocesses = [self.map.dem_settings.auto_process, False]
-        self.output_paths = [
-            os.path.join(self.background_directory, f"{name}.png") for name in ELEMENTS
-        ]
+        self.output_path = os.path.join(self.background_directory, f"{FULL_NAME}.png")
         self.not_substracted_path = os.path.join(self.background_directory, "not_substracted.png")
         self.not_resized_path = os.path.join(self.background_directory, "not_resized.png")
 
-        dems = []
-
-        for name, autoprocess, output_path in zip(ELEMENTS, autoprocesses, self.output_paths):
-            dem = DEM(
-                self.game,
-                self.map,
-                self.coordinates,
-                self.background_size,
-                self.rotated_size,
-                self.rotation,
-                self.map_directory,
-                self.logger,
-            )
-            dem.preprocess()
-            dem.is_preview = self.is_preview(name)  # type: ignore
-            if dem.is_preview:  # type: ignore
-                dem.multiplier = 1
-            dem.auto_process = autoprocess
-            dem.set_output_resolution((self.rotated_size, self.rotated_size))
-            dem.set_dem_path(output_path)
-            dems.append(dem)
-
-        self.dems = dems
+        self.dem = DEM(
+            self.game,
+            self.map,
+            self.coordinates,
+            self.background_size,
+            self.rotated_size,
+            self.rotation,
+            self.map_directory,
+            self.logger,
+        )
+        self.dem.preprocess()
+        self.dem.set_output_resolution((self.rotated_size, self.rotated_size))
+        self.dem.set_dem_path(self.output_path)
 
     def is_preview(self, name: str) -> bool:
         """Checks if the DEM is a preview.
@@ -104,21 +91,17 @@ class Background(Component):
         as a result the DEM files will be saved, then based on them the obj files will be
         generated."""
         self.create_background_textures()
+        self.dem.process()
 
-        for dem in self.dems:
-            dem.process()
-            if not dem.is_preview:  # type: ignore
-                shutil.copyfile(dem.dem_path, self.not_substracted_path)
-                self.cutout(dem.dem_path, save_path=self.not_resized_path)
+        shutil.copyfile(self.dem.dem_path, self.not_substracted_path)
+        self.cutout(self.dem.dem_path, save_path=self.not_resized_path)
 
         if self.map.dem_settings.water_depth:
             self.subtraction()
 
-        for dem in self.dems:
-            if not dem.is_preview:  # type: ignore
-                cutted_dem_path = self.cutout(dem.dem_path)
-                if self.game.additional_dem_name is not None:
-                    self.make_copy(cutted_dem_path, self.game.additional_dem_name)
+        cutted_dem_path = self.cutout(self.dem.dem_path)
+        if self.game.additional_dem_name is not None:
+            self.make_copy(cutted_dem_path, self.game.additional_dem_name)
 
         if self.map.background_settings.generate_background:
             self.generate_obj_files()
@@ -149,19 +132,17 @@ class Background(Component):
         """
         self.qgis_sequence()
 
-        dem = self.dems[0]
-
-        north, south, east, west = dem.bbox
-        epsg3857_string = dem.get_epsg3857_string()
-        epsg3857_string_with_margin = dem.get_epsg3857_string(add_margin=True)
+        north, south, east, west = self.dem.bbox
+        epsg3857_string = self.dem.get_epsg3857_string()
+        epsg3857_string_with_margin = self.dem.get_epsg3857_string(add_margin=True)
 
         data = {
-            "center_latitude": dem.coordinates[0],
-            "center_longitude": dem.coordinates[1],
+            "center_latitude": self.dem.coordinates[0],
+            "center_longitude": self.dem.coordinates[1],
             "epsg3857_string": epsg3857_string,
             "epsg3857_string_with_margin": epsg3857_string_with_margin,
-            "height": dem.map_size,
-            "width": dem.map_size,
+            "height": self.dem.map_size,
+            "width": self.dem.map_size,
             "north": north,
             "south": south,
             "east": east,
@@ -171,10 +152,10 @@ class Background(Component):
 
     def qgis_sequence(self) -> None:
         """Generates QGIS scripts for creating bounding box layers and rasterizing them."""
-        qgis_layer = (f"Background_{FULL_NAME}", *self.dems[0].get_espg3857_bbox())
+        qgis_layer = (f"Background_{FULL_NAME}", *self.dem.get_espg3857_bbox())
         qgis_layer_with_margin = (
             f"Background_{FULL_NAME}_margin",
-            *self.dems[0].get_espg3857_bbox(add_margin=True),
+            *self.dem.get_espg3857_bbox(add_margin=True),
         )
         self.create_qgis_scripts([qgis_layer, qgis_layer_with_margin])
 
@@ -182,21 +163,20 @@ class Background(Component):
         """Iterates over all dems and generates 3D obj files based on DEM data.
         If at least one DEM file is missing, the generation will be stopped at all.
         """
-        for dem in self.dems:
-            if not os.path.isfile(dem.dem_path):
-                self.logger.warning(
-                    "DEM file not found, generation will be stopped: %s", dem.dem_path
-                )
-                return
+        if not os.path.isfile(self.dem.dem_path):
+            self.logger.warning(
+                "DEM file not found, generation will be stopped: %s", self.dem.dem_path
+            )
+            return
 
-            self.logger.debug("DEM file for found: %s", dem.dem_path)
+        self.logger.debug("DEM file for found: %s", self.dem.dem_path)
 
-            filename = os.path.splitext(os.path.basename(dem.dem_path))[0]
-            save_path = os.path.join(self.background_directory, f"{filename}.obj")
-            self.logger.debug("Generating obj file in path: %s", save_path)
+        filename = os.path.splitext(os.path.basename(self.dem.dem_path))[0]
+        save_path = os.path.join(self.background_directory, f"{filename}.obj")
+        self.logger.debug("Generating obj file in path: %s", save_path)
 
-            dem_data = cv2.imread(dem.dem_path, cv2.IMREAD_UNCHANGED)  # pylint: disable=no-member
-            self.plane_from_np(dem_data, save_path, is_preview=dem.is_preview)  # type: ignore
+        dem_data = cv2.imread(self.dem.dem_path, cv2.IMREAD_UNCHANGED)  # pylint: disable=no-member
+        self.plane_from_np(dem_data, save_path)  # type: ignore
 
     # pylint: disable=too-many-locals
     def cutout(self, dem_path: str, save_path: str | None = None) -> str:
@@ -248,7 +228,6 @@ class Background(Component):
         self,
         dem_data: np.ndarray,
         save_path: str,
-        is_preview: bool = False,
         include_zeros: bool = True,
     ) -> None:
         """Generates a 3D obj file based on DEM data.
@@ -256,7 +235,6 @@ class Background(Component):
         Arguments:
             dem_data (np.ndarray) -- The DEM data as a numpy array.
             save_path (str) -- The path where the obj file will be saved.
-            is_preview (bool, optional) -- If True, the preview mesh will be generated.
             include_zeros (bool, optional) -- If True, the mesh will include the zero height values.
         """
         resize_factor = 1 / self.map.background_settings.resize_factor
@@ -315,25 +293,21 @@ class Background(Component):
         mesh.apply_transform(rotation_matrix_y)
         mesh.apply_transform(rotation_matrix_z)
 
-        if is_preview:
+        # if not include_zeros:
+        z_scaling_factor = 1 / self.map.dem_settings.multiplier
+        self.logger.debug("Z scaling factor: %s", z_scaling_factor)
+        mesh.apply_scale([1 / resize_factor, 1 / resize_factor, z_scaling_factor])
+
+        mesh.export(save_path)
+        self.logger.debug("Obj file saved: %s", save_path)
+
+        if include_zeros:
             # Simplify the preview mesh to reduce the size of the file.
             mesh = mesh.simplify_quadric_decimation(face_count=len(mesh.faces) // 2**7)
 
             # Apply scale to make the preview mesh smaller in the UI.
             mesh.apply_scale([0.5, 0.5, 0.5])
             self.mesh_to_stl(mesh)
-        else:
-            if not include_zeros:
-                multiplier = self.map.dem_settings.multiplier
-                if multiplier != 1:
-                    z_scaling_factor = 1 / multiplier
-                else:
-                    z_scaling_factor = 1 / 2**5
-                self.logger.debug("Z scaling factor: %s", z_scaling_factor)
-                mesh.apply_scale([1 / resize_factor, 1 / resize_factor, z_scaling_factor])
-
-        mesh.export(save_path)
-        self.logger.debug("Obj file saved: %s", save_path)
 
     def mesh_to_stl(self, mesh: trimesh.Trimesh) -> None:
         """Converts the mesh to an STL file and saves it in the previews directory.
@@ -358,25 +332,22 @@ class Background(Component):
             list[str] -- A list of paths to the previews.
         """
         preview_paths = self.dem_previews(self.game.dem_file_path(self.map_directory))
-        for dem in self.dems:
-            if dem.is_preview:  # type: ignore
-                background_dem_preview_path = os.path.join(
-                    self.previews_directory, "background_dem.png"
-                )
-                background_dem_preview_image = cv2.imread(dem.dem_path, cv2.IMREAD_UNCHANGED)
-
-                background_dem_preview_image = cv2.resize(
-                    background_dem_preview_image, (0, 0), fx=1 / 4, fy=1 / 4
-                )
-                background_dem_preview_image = cv2.normalize(  # type: ignore
-                    background_dem_preview_image, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U
-                )
-                background_dem_preview_image = cv2.cvtColor(
-                    background_dem_preview_image, cv2.COLOR_GRAY2BGR
-                )
-
-                cv2.imwrite(background_dem_preview_path, background_dem_preview_image)
-                preview_paths.append(background_dem_preview_path)
+
+        background_dem_preview_path = os.path.join(self.previews_directory, "background_dem.png")
+        background_dem_preview_image = cv2.imread(self.dem.dem_path, cv2.IMREAD_UNCHANGED)
+
+        background_dem_preview_image = cv2.resize(
+            background_dem_preview_image, (0, 0), fx=1 / 4, fy=1 / 4
+        )
+        background_dem_preview_image = cv2.normalize(  # type: ignore
+            background_dem_preview_image, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U
+        )
+        background_dem_preview_image = cv2.cvtColor(
+            background_dem_preview_image, cv2.COLOR_GRAY2BGR
+        )
+
+        cv2.imwrite(background_dem_preview_path, background_dem_preview_image)
+        preview_paths.append(background_dem_preview_path)
 
         if self.stl_preview_path:
             preview_paths.append(self.stl_preview_path)
@@ -525,18 +496,15 @@ class Background(Component):
             bool
         )
 
-        for output_path in self.output_paths:
-            if FULL_PREVIEW_NAME in output_path:
-                continue
-            dem_image = cv2.imread(output_path, cv2.IMREAD_UNCHANGED)
+        dem_image = cv2.imread(self.output_path, cv2.IMREAD_UNCHANGED)
 
-            # Create a mask where water_resources_image is 255 (or not 0)
-            # Subtract water_depth from dem_image where mask is True
-            dem_image[mask] = dem_image[mask] - self.map.dem_settings.water_depth
+        # Create a mask where water_resources_image is 255 (or not 0)
+        # Subtract water_depth from dem_image where mask is True
+        dem_image[mask] = dem_image[mask] - self.map.dem_settings.water_depth
 
-            # Save the modified dem_image back to the output path
-            cv2.imwrite(output_path, dem_image)
-            self.logger.debug("Water depth subtracted from DEM data: %s", output_path)
+        # Save the modified dem_image back to the output path
+        cv2.imwrite(self.output_path, dem_image)
+        self.logger.debug("Water depth subtracted from DEM data: %s", self.output_path)
 
     def generate_water_resources_obj(self) -> None:
         """Generates 3D obj files based on water resources data."""
@@ -550,9 +518,7 @@ class Background(Component):
             plane_water.astype(np.uint8), np.ones((5, 5), np.uint8), iterations=5
         ).astype(np.uint8)
         plane_save_path = os.path.join(self.water_directory, "plane_water.obj")
-        self.plane_from_np(
-            dilated_plane_water, plane_save_path, is_preview=False, include_zeros=False
-        )
+        self.plane_from_np(dilated_plane_water, plane_save_path, include_zeros=False)
 
         # Single channeled 16 bit DEM image of terrain.
         background_dem = cv2.imread(self.not_substracted_path, cv2.IMREAD_UNCHANGED)
@@ -570,6 +536,4 @@ class Background(Component):
         elevated_water = np.where(mask, background_dem, elevated_water)
         elevated_save_path = os.path.join(self.water_directory, "elevated_water.obj")
 
-        self.plane_from_np(
-            elevated_water, elevated_save_path, is_preview=False, include_zeros=False
-        )
+        self.plane_from_np(elevated_water, elevated_save_path, include_zeros=False)

maps4fs/generator/component.py

@@ -68,6 +68,7 @@ class Component:
         os.makedirs(self.previews_directory, exist_ok=True)
         os.makedirs(self.scripts_directory, exist_ok=True)
         os.makedirs(self.info_layers_directory, exist_ok=True)
+        os.makedirs(self.satellite_directory, exist_ok=True)
 
         self.save_bbox()
         self.preprocess()
@@ -123,6 +124,15 @@ class Component:
         """
         return os.path.join(self.map_directory, "scripts")
 
+    @property
+    def satellite_directory(self) -> str:
+        """The directory where the satellite images are stored.
+
+        Returns:
+            str: The directory where the satellite images are stored.
+        """
+        return os.path.join(self.map_directory, "satellite")
+
     @property
     def generation_info_path(self) -> str:
         """The path to the generation info JSON file.

maps4fs/generator/dem.py

@@ -1,19 +1,15 @@
 """This module contains DEM class for processing Digital Elevation Model data."""
 
-import gzip
-import math
 import os
-import shutil
 
 import cv2
 import numpy as np
-import rasterio  # type: ignore
-import requests
+
+# import rasterio  # type: ignore
 from pympler import asizeof  # type: ignore
 
 from maps4fs.generator.component import Component
-
-SRTM = "https://elevation-tiles-prod.s3.amazonaws.com/skadi/{latitude_band}/{tile_name}.hgt.gz"
+from maps4fs.generator.dtm import DTMProvider
 
 
 # pylint: disable=R0903, R0902
@@ -61,7 +57,13 @@ class DEM(Component):
             self.blur_radius,
         )
 
-        self.auto_process = self.map.dem_settings.auto_process
+        self.dtm_provider: DTMProvider = self.map.dtm_provider(  # type: ignore
+            coordinates=self.coordinates,
+            user_settings=self.map.dtm_provider_settings,
+            size=self.map_rotated_size,
+            directory=self.temp_dir,
+            logger=self.logger,
+        )
 
     @property
     def dem_path(self) -> str:
@@ -132,36 +134,29 @@ class DEM(Component):
     def process(self) -> None:
         """Reads SRTM file, crops it to map size, normalizes and blurs it,
         saves to map directory."""
-        north, south, east, west = self.bbox
 
         dem_output_resolution = self.output_resolution
         self.logger.debug("DEM output resolution: %s.", dem_output_resolution)
 
-        tile_path = self._srtm_tile()
-        if not tile_path:
-            self.logger.warning("Tile was not downloaded, DEM file will be filled with zeros.")
+        try:
+            data = self.dtm_provider.get_numpy()
+        except Exception as e:  # pylint: disable=W0718
+            self.logger.error("Failed to get DEM data from SRTM: %s.", e)
             self._save_empty_dem(dem_output_resolution)
             return
 
-        with rasterio.open(tile_path) as src:
-            self.logger.debug("Opened tile, shape: %s, dtype: %s.", src.shape, src.dtypes[0])
-            window = rasterio.windows.from_bounds(west, south, east, north, src.transform)
-            self.logger.debug(
-                "Window parameters. Column offset: %s, row offset: %s, width: %s, height: %s.",
-                window.col_off,
-                window.row_off,
-                window.width,
-                window.height,
-            )
-            data = src.read(1, window=window)
+        if len(data.shape) != 2:
+            self.logger.error("DTM provider returned incorrect data: more than 1 channel.")
+            self._save_empty_dem(dem_output_resolution)
+            return
 
-        if not data.size > 0:
-            self.logger.warning("DEM data is empty, DEM file will be filled with zeros.")
+        if data.dtype not in ["int16", "uint16"]:
+            self.logger.error("DTM provider returned incorrect data type: %s.", data.dtype)
             self._save_empty_dem(dem_output_resolution)
             return
 
         self.logger.debug(
-            "DEM data was read from SRTM file. Shape: %s, dtype: %s. Min: %s, max: %s.",
+            "DEM data was retrieved from DTM provider. Shape: %s, dtype: %s. Min: %s, max: %s.",
             data.shape,
             data.dtype,
             data.min(),
@@ -184,11 +179,7 @@ class DEM(Component):
             resampled_data.dtype,
         )
 
-        if self.auto_process:
-            self.logger.debug("Auto processing is enabled, will normalize DEM data.")
-            resampled_data = self._normalize_dem(resampled_data)
-        else:
-            self.logger.debug("Auto processing is disabled, DEM data will not be normalized.")
+        if self.multiplier != 1:
             resampled_data = resampled_data * self.multiplier
 
             self.logger.debug(
@@ -276,81 +267,6 @@ class DEM(Component):
             output_width=output_width,
         )
 
-    def _tile_info(self, lat: float, lon: float) -> tuple[str, str]:
-        """Returns latitude band and tile name for SRTM tile from coordinates.
-
-        Arguments:
-            lat (float): Latitude.
-            lon (float): Longitude.
-
-        Returns:
-            tuple[str, str]: Latitude band and tile name.
-        """
-        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, tile_name
-
-    def _download_tile(self) -> str | None:
-        """Downloads SRTM tile from Amazon S3 using coordinates.
-
-        Returns:
-            str: Path to compressed tile or None if download failed.
-        """
-        latitude_band, tile_name = self._tile_info(*self.coordinates)
-        compressed_file_path = os.path.join(self.gz_dir, f"{tile_name}.hgt.gz")
-        url = SRTM.format(latitude_band=latitude_band, tile_name=tile_name)
-        self.logger.debug("Trying to get response from %s...", url)
-        response = requests.get(url, stream=True, timeout=10)
-
-        if response.status_code == 200:
-            self.logger.debug("Response received. Saving to %s...", compressed_file_path)
-            with open(compressed_file_path, "wb") as f:
-                for chunk in response.iter_content(chunk_size=8192):
-                    f.write(chunk)
-            self.logger.debug("Compressed tile successfully downloaded.")
-        else:
-            self.logger.error("Response was failed with status code %s.", response.status_code)
-            return None
-
-        return compressed_file_path
-
-    def _srtm_tile(self) -> str | None:
-        """Determines SRTM tile name from coordinates downloads it if necessary, and decompresses.
-
-        Returns:
-            str: Path to decompressed tile or None if download failed.
-        """
-        latitude_band, tile_name = self._tile_info(*self.coordinates)
-        self.logger.debug("SRTM tile name %s from latitude band %s.", tile_name, latitude_band)
-
-        decompressed_file_path = os.path.join(self.hgt_dir, f"{tile_name}.hgt")
-        if os.path.isfile(decompressed_file_path):
-            self.logger.debug(
-                "Decompressed tile already exists: %s, skipping download.",
-                decompressed_file_path,
-            )
-            return decompressed_file_path
-
-        compressed_file_path = self._download_tile()
-        if not compressed_file_path:
-            self.logger.error("Download from SRTM failed, DEM file will be filled with zeros.")
-            return None
-        with gzip.open(compressed_file_path, "rb") as f_in:
-            with open(decompressed_file_path, "wb") as f_out:
-                shutil.copyfileobj(f_in, f_out)
-        self.logger.debug("Tile decompressed to %s.", decompressed_file_path)
-        return decompressed_file_path
-
     def _save_empty_dem(self, dem_output_resolution: tuple[int, int]) -> None:
         """Saves empty DEM file filled with zeros."""
         dem_data = np.zeros(dem_output_resolution, dtype="uint16")