maps4fs 0.8.2__py3-none-any.whl → 0.8.4__py3-none-any.whl

maps4fs/generator/background.py

@@ -0,0 +1,281 @@
+"""This module contains the Background component, which generates 3D obj files based on DEM data
+around the map."""
+
+from __future__ import annotations
+
+import os
+
+import cv2
+import numpy as np
+import trimesh  # type: ignore
+
+from maps4fs.generator.component import Component
+from maps4fs.generator.path_steps import DEFAULT_DISTANCE, get_steps
+from maps4fs.generator.tile import Tile
+
+RESIZE_FACTOR = 1 / 4
+
+
+class Background(Component):
+    """Component for creating 3D obj files based on DEM data around the map.
+
+    Args:
+        coordinates (tuple[float, float]): The latitude and longitude of the center of the map.
+        map_height (int): The height of the map in pixels.
+        map_width (int): The width of the map in pixels.
+        map_directory (str): The directory where the map files are stored.
+        logger (Any, optional): The logger to use. Must have at least three basic methods: debug,
+            info, warning. If not provided, default logging will be used.
+    """
+
+    def preprocess(self) -> None:
+        """Prepares the component for processing. Registers the tiles around the map by moving
+        clockwise from North, then clockwise."""
+        self.tiles: list[Tile] = []
+        origin = self.coordinates
+
+        # Getting a list of 8 tiles around the map starting from the N(North) tile.
+        for path_step in get_steps(self.map_height, self.map_width):
+            # Getting the destination coordinates for the current tile.
+            tile_coordinates = path_step.get_destination(origin)
+
+            # Create a Tile component, which is needed to save the DEM image.
+            tile = Tile(
+                game=self.game,
+                coordinates=tile_coordinates,
+                map_height=path_step.size[1],
+                map_width=path_step.size[0],
+                map_directory=self.map_directory,
+                logger=self.logger,
+                tile_code=path_step.code,
+                auto_process=False,
+                blur_radius=self.kwargs.get("blur_radius"),
+                multiplier=1,
+            )
+
+            # Update the origin for the next tile.
+            origin = tile_coordinates
+            self.tiles.append(tile)
+            self.logger.debug(
+                "Registered tile: %s, coordinates: %s, size: %s",
+                tile.code,
+                tile_coordinates,
+                path_step.size,
+            )
+
+    def process(self) -> None:
+        """Launches the component processing. Iterates over all tiles and processes them
+        as a result the DEM files will be saved, then based on them the obj files will be
+        generated."""
+        for tile in self.tiles:
+            tile.process()
+
+        self.generate_obj_files()
+
+    def info_sequence(self) -> dict[str, dict[str, str | float | int]]:
+        """Returns a dictionary with information about the tiles around the map.
+        Adds the EPSG:3857 string to the data for convenient usage in QGIS.
+
+        Returns:
+            dict[str, dict[str, float | int]] -- A dictionary with information about the tiles.
+        """
+        data = {}
+        for tile in self.tiles:
+            north, south, east, west = tile.bbox
+            epsg3857_string = tile.get_epsg3857_string()
+
+            tile_entry = {
+                "center_latitude": tile.coordinates[0],
+                "center_longitude": tile.coordinates[1],
+                "epsg3857_string": epsg3857_string,
+                "height": tile.map_height,
+                "width": tile.map_width,
+                "north": north,
+                "south": south,
+                "east": east,
+                "west": west,
+            }
+            if tile.code is not None:
+                data[tile.code] = tile_entry
+
+        return data  # type: ignore
+
+    def generate_obj_files(self) -> None:
+        """Iterates over all tiles 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 tile in self.tiles:
+            # Read DEM data from the tile.
+            dem_path = tile.dem_path
+            if not os.path.isfile(dem_path):
+                self.logger.warning("DEM file not found, generation will be stopped: %s", dem_path)
+                return
+
+            self.logger.info("DEM file for tile %s found: %s", tile.code, dem_path)
+
+            base_directory = os.path.dirname(dem_path)
+            save_path = os.path.join(base_directory, f"{tile.code}.obj")
+            self.logger.debug("Generating obj file for tile %s in path: %s", tile.code, save_path)
+
+            dem_data = cv2.imread(tile.dem_path, cv2.IMREAD_UNCHANGED)  # pylint: disable=no-member
+            self.plane_from_np(dem_data, save_path)
+
+    # pylint: disable=too-many-locals
+    def plane_from_np(self, dem_data: np.ndarray, save_path: str) -> None:
+        """Generates a 3D obj file based on DEM data.
+
+        Arguments:
+            dem_data (np.ndarray) -- The DEM data as a numpy array.
+            save_path (str) -- The path where the obj file will be saved.
+        """
+        dem_data = cv2.resize(  # pylint: disable=no-member
+            dem_data, (0, 0), fx=RESIZE_FACTOR, fy=RESIZE_FACTOR
+        )
+        self.logger.debug(
+            "DEM data resized to shape: %s with factor: %s", dem_data.shape, RESIZE_FACTOR
+        )
+
+        rows, cols = dem_data.shape
+        x = np.linspace(0, cols - 1, cols)
+        y = np.linspace(0, rows - 1, rows)
+        x, y = np.meshgrid(x, y)
+        z = dem_data
+
+        vertices = np.column_stack([x.ravel(), y.ravel(), z.ravel()])
+        faces = []
+
+        for i in range(rows - 1):
+            for j in range(cols - 1):
+                top_left = i * cols + j
+                top_right = top_left + 1
+                bottom_left = top_left + cols
+                bottom_right = bottom_left + 1
+
+                # Invert the order of vertices to flip the normals
+                faces.append([top_left, bottom_right, bottom_left])
+                faces.append([top_left, top_right, bottom_right])
+
+        faces = np.array(faces)  # type: ignore
+        mesh = trimesh.Trimesh(vertices=vertices, faces=faces)
+
+        # Simplify the mesh to reduce the number of faces.
+        mesh = mesh.simplify_quadric_decimation(face_count=len(faces) // 10)
+        self.logger.debug("Mesh simplified to %s faces", len(mesh.faces))
+
+        mesh.export(save_path)
+        self.logger.info("Obj file saved: %s", save_path)
+
+    def previews(self) -> list[str]:
+        """Generates a preview by combining all tiles into one image.
+        NOTE: The map itself is not included in the preview, so it will be empty.
+
+        Returns:
+            list[str] -- A list of paths to the preview images."""
+
+        self.logger.info("Generating a preview image for the background DEM")
+
+        image_height = self.map_height + DEFAULT_DISTANCE * 2
+        image_width = self.map_width + DEFAULT_DISTANCE * 2
+        self.logger.debug("Full size of the preview image: %s x %s", image_width, image_height)
+
+        image = np.zeros((image_height, image_width), np.uint16)  # pylint: disable=no-member
+        self.logger.debug("Empty image created: %s", image.shape)
+
+        for tile in self.tiles:
+            # pylint: disable=no-member
+            tile_image = cv2.imread(tile.dem_path, cv2.IMREAD_UNCHANGED)
+
+            self.logger.debug(
+                "Tile %s image shape: %s, dtype: %s, max: %s, min: %s",
+                tile.code,
+                tile_image.shape,
+                tile_image.dtype,
+                tile_image.max(),
+                tile_image.min(),
+            )
+
+            tile_height, tile_width = tile_image.shape
+            self.logger.debug("Tile %s size: %s x %s", tile.code, tile_width, tile_height)
+
+            # Calculate the position based on the tile code
+            if tile.code == "N":
+                x = DEFAULT_DISTANCE
+                y = 0
+            elif tile.code == "NE":
+                x = self.map_width + DEFAULT_DISTANCE
+                y = 0
+            elif tile.code == "E":
+                x = self.map_width + DEFAULT_DISTANCE
+                y = DEFAULT_DISTANCE
+            elif tile.code == "SE":
+                x = self.map_width + DEFAULT_DISTANCE
+                y = self.map_height + DEFAULT_DISTANCE
+            elif tile.code == "S":
+                x = DEFAULT_DISTANCE
+                y = self.map_height + DEFAULT_DISTANCE
+            elif tile.code == "SW":
+                x = 0
+                y = self.map_height + DEFAULT_DISTANCE
+            elif tile.code == "W":
+                x = 0
+                y = DEFAULT_DISTANCE
+            elif tile.code == "NW":
+                x = 0
+                y = 0
+
+            # pylint: disable=possibly-used-before-assignment
+            x2 = x + tile_width
+            y2 = y + tile_height
+
+            self.logger.debug(
+                "Tile %s position. X from %s to %s, Y from %s to %s", tile.code, x, x2, y, y2
+            )
+
+            # pylint: disable=possibly-used-before-assignment
+            image[y:y2, x:x2] = tile_image
+
+        # Save image to the map directory.
+        preview_path = os.path.join(self.previews_directory, "background_dem.png")
+
+        # pylint: disable=no-member
+        image = cv2.normalize(image, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U)  # type: ignore
+        image = cv2.cvtColor(image, cv2.COLOR_GRAY2BGR)  # type: ignore
+        cv2.imwrite(preview_path, image)
+
+        return [preview_path]
+
+
+# Creates tiles around the map.
+# The one on corners 2048x2048, on sides and in the middle map_size x 2048.
+# So 2048 is a distance FROM the edge of the map, but the other size depends on the map size.
+# But for corner tiles it's always 2048.
+
+# In the beginning we have coordinates of the central point of the map and it's size.
+# We need to calculate the coordinates of central points all 8 tiles around the map.
+
+# Latitude is a vertical line, Longitude is a horizontal line.
+
+#                         2048
+#                     |         |
+# ____________________|_________|___
+# |         |         |         |
+# |    NW   |    N    |    NE   |    2048
+# |_________|_________|_________|___
+# |         |         |         |
+# |    W    |    C    |    E    |
+# |_________|_________|_________|
+# |         |         |         |
+# |    SW   |    S    |    SE   |
+# |_________|_________|_________|
+#
+# N = C map_height / 2 + 1024; N_width = map_width; N_height = 2048
+# NW = N - map_width / 2 - 1024; NW_width = 2048; NW_height = 2048
+# and so on...
+
+# lat, lon = 45.28565000315636, 20.237121355049904
+# dst = 1024
+
+# # N
+# destination = distance(meters=dst).destination((lat, lon), 0)
+# lat, lon = destination.latitude, destination.longitude
+# print(lat, lon)

maps4fs/generator/component.py

@@ -2,9 +2,13 @@
 
 from __future__ import annotations
 
+import json
+import os
+from copy import deepcopy
 from typing import TYPE_CHECKING, Any
 
 import osmnx as ox  # type: ignore
+from pyproj import Transformer
 
 if TYPE_CHECKING:
     from maps4fs.generator.game import Game
@@ -42,6 +46,8 @@ class Component:
         self.logger = logger
         self.kwargs = kwargs
 
+        os.makedirs(self.previews_directory, exist_ok=True)
+
         self.save_bbox()
         self.preprocess()
 
@@ -69,21 +75,94 @@ class Component:
         """
         raise NotImplementedError
 
-    def get_bbox(self, project_utm: bool = False) -> tuple[int, int, int, int]:
+    @property
+    def previews_directory(self) -> str:
+        """The directory where the preview images are stored.
+
+        Returns:
+            str: The directory where the preview images are stored.
+        """
+        return os.path.join(self.map_directory, "previews")
+
+    @property
+    def generation_info_path(self) -> str:
+        """The path to the generation info JSON file.
+
+        Returns:
+            str: The path to the generation info JSON file.
+        """
+        return os.path.join(self.map_directory, "generation_info.json")
+
+    def info_sequence(self) -> dict[Any, Any]:
+        """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:
+            dict[Any, Any]: The information sequence for the component.
+        """
+        return {}
+
+    def commit_generation_info(self) -> None:
+        """Commits the generation info to the generation info JSON file."""
+        self.update_generation_info(self.info_sequence())
+
+    def update_generation_info(self, data: dict[Any, Any]) -> None:
+        """Updates the generation info with the provided data.
+        If the generation info file does not exist, it will be created.
+
+        Args:
+            data (dict[Any, Any]): The data to update the generation info with.
+        """
+        if os.path.isfile(self.generation_info_path):
+            with open(self.generation_info_path, "r", encoding="utf-8") as file:
+                generation_info = json.load(file)
+                self.logger.debug("Loaded generation info from %s", self.generation_info_path)
+        else:
+            self.logger.debug(
+                "Generation info file does not exist, creating a new one in %s",
+                self.generation_info_path,
+            )
+            generation_info = {}
+
+        updated_generation_info = deepcopy(generation_info)
+        updated_generation_info[self.__class__.__name__] = data
+
+        self.logger.debug("Updated generation info, now contains %s fields", len(data))
+
+        with open(self.generation_info_path, "w", encoding="utf-8") as file:
+            json.dump(updated_generation_info, file, indent=4)
+
+        self.logger.debug("Saved updated generation info to %s", self.generation_info_path)
+
+    def get_bbox(
+        self,
+        coordinates: tuple[float, float] | None = None,
+        distance: int | None = None,
+        project_utm: bool = False,
+    ) -> tuple[int, int, int, int]:
         """Calculates the bounding box of the map from the coordinates and the height and
         width of the map.
+        If coordinates and distance are not provided, the instance variables are used.
 
         Args:
+            coordinates (tuple[float, float], optional): The latitude and longitude of the center of
+                the map. Defaults to None.
+            distance (int, optional): The distance from the center of the map to the edge of the
+                map. Defaults to None.
             project_utm (bool, optional): Whether to project the bounding box to UTM.
 
         Returns:
             tuple[int, int, int, int]: The bounding box of the map.
         """
+        coordinates = coordinates or self.coordinates
+        distance = distance or int(self.map_height / 2)
+
         north, south, _, _ = ox.utils_geo.bbox_from_point(
-            self.coordinates, dist=self.map_height / 2, project_utm=project_utm
+            coordinates, dist=distance, project_utm=project_utm
         )
         _, _, east, west = ox.utils_geo.bbox_from_point(
-            self.coordinates, dist=self.map_width / 2, project_utm=project_utm
+            coordinates, dist=distance, project_utm=project_utm
         )
         bbox = north, south, east, west
         self.logger.debug(
@@ -100,3 +179,21 @@ class Component:
         """
         self.bbox = self.get_bbox(project_utm=False)
         self.logger.debug("Saved bounding box: %s", self.bbox)
+
+    def get_epsg3857_string(self, bbox: tuple[int, int, int, int] | None = None) -> str:
+        """Converts the bounding box to EPSG:3857 string.
+        If the bounding box is not provided, the instance variable is used.
+
+        Args:
+            bbox (tuple[int, int, int, int], optional): The bounding box to convert.
+
+        Returns:
+            str: The bounding box in EPSG:3857 string.
+        """
+        bbox = bbox or self.bbox
+        north, south, east, west = bbox
+        transformer = Transformer.from_crs("epsg:4326", "epsg:3857")
+        epsg3857_north, epsg3857_west = transformer.transform(north, west)
+        epsg3857_south, epsg3857_east = transformer.transform(south, east)
+
+        return f"{epsg3857_north},{epsg3857_south},{epsg3857_east},{epsg3857_west} [EPSG:3857]"

maps4fs/generator/config.py

@@ -55,3 +55,34 @@ class Config(Component):
             list[str]: An empty list.
         """
         return []
+
+    def info_sequence(self) -> dict[str, dict[str, str | float | int]]:
+        """Returns information about the component.
+        Overview section is needed to create the overview file (in-game map).
+
+        Returns:
+            dict[str, dict[str, str | float | int]]: Information about the component.
+        """
+        # The overview file is exactly 2X bigger than the map size, does not matter
+        # if the map is 2048x2048 or 4096x4096, the overview will be 4096x4096
+        # and the map will be in the center of the overview.
+        # That's why the distance is set to the map height not as a half of it.
+        bbox = self.get_bbox(distance=self.map_height)
+        south, west, north, east = bbox
+        epsg3857_string = self.get_epsg3857_string(bbox=bbox)
+
+        overview_data = {
+            "epsg3857_string": epsg3857_string,
+            "south": south,
+            "west": west,
+            "north": north,
+            "east": east,
+            "height": self.map_height * 2,
+            "width": self.map_width * 2,
+        }
+
+        data = {
+            "Overview": overview_data,
+        }
+
+        return data  # type: ignore

maps4fs/generator/dem.py

@@ -19,7 +19,7 @@ DEFAULT_BLUR_RADIUS = 35
 
 # pylint: disable=R0903
 class DEM(Component):
-    """Component for map settings and configuration.
+    """Component for processing Digital Elevation Model data.
 
     Args:
         coordinates (tuple[float, float]): The latitude and longitude of the center of the map.
@@ -40,7 +40,10 @@ class DEM(Component):
 
         self.multiplier = self.kwargs.get("multiplier", DEFAULT_MULTIPLIER)
         blur_radius = self.kwargs.get("blur_radius", DEFAULT_BLUR_RADIUS)
-        if blur_radius % 2 == 0:
+        if blur_radius is None or blur_radius <= 0:
+            # We'll disable blur if the radius is 0 or negative.
+            blur_radius = 0
+        elif blur_radius % 2 == 0:
             blur_radius += 1
         self.blur_radius = blur_radius
         self.logger.debug(
@@ -49,12 +52,21 @@ class DEM(Component):
 
         self.auto_process = self.kwargs.get("auto_process", False)
 
-    # pylint: disable=no-member
-    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
+    @property
+    def dem_path(self) -> str:
+        """Returns path to the DEM file.
+
+        Returns:
+            str: Path to the DEM file.
+        """
+        return self._dem_path
+
+    def get_output_resolution(self) -> tuple[int, int]:
+        """Get output resolution for DEM data.
 
+        Returns:
+            tuple[int, int]: Output resolution for DEM data.
+        """
         dem_height = int((self.map_height / 2) * self.game.dem_multipliyer + 1)
         dem_width = int((self.map_width / 2) * self.game.dem_multipliyer + 1)
         self.logger.debug(
@@ -63,7 +75,15 @@ class DEM(Component):
             dem_height,
             dem_width,
         )
-        dem_output_resolution = (dem_width, dem_height)
+        return dem_width, dem_height
+
+    # pylint: disable=no-member
+    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.get_output_resolution()
         self.logger.debug("DEM output resolution: %s.", dem_output_resolution)
 
         tile_path = self._srtm_tile()
@@ -122,13 +142,15 @@ class DEM(Component):
             resampled_data.max(),
         )
 
-        resampled_data = cv2.GaussianBlur(
-            resampled_data, (self.blur_radius, self.blur_radius), sigmaX=40, sigmaY=40
-        )
-        self.logger.debug(
-            "Gaussion blur applied to DEM data with kernel size %s.",
-            self.blur_radius,
-        )
+        if self.blur_radius > 0:
+            resampled_data = cv2.GaussianBlur(
+                resampled_data, (self.blur_radius, self.blur_radius), sigmaX=40, sigmaY=40
+            )
+            self.logger.debug(
+                "Gaussion blur applied to DEM data with kernel size %s.",
+                self.blur_radius,
+            )
+
         self.logger.debug(
             "DEM data was blurred. Shape: %s, dtype: %s. Min: %s, max: %s.",
             resampled_data.shape,
@@ -141,10 +163,20 @@ class DEM(Component):
         self.logger.debug("DEM data was saved to %s.", self._dem_path)
 
         if self.game.additional_dem_name is not None:
-            dem_directory = os.path.dirname(self._dem_path)
-            additional_dem_path = os.path.join(dem_directory, self.game.additional_dem_name)
-            shutil.copyfile(self._dem_path, additional_dem_path)
-            self.logger.debug("Additional DEM data was copied to %s.", additional_dem_path)
+            self.make_copy(self.game.additional_dem_name)
+
+    def make_copy(self, dem_name: str) -> None:
+        """Copies DEM data to additional DEM file.
+
+        Args:
+            dem_name (str): Name of the additional DEM file.
+        """
+        dem_directory = os.path.dirname(self._dem_path)
+
+        additional_dem_path = os.path.join(dem_directory, dem_name)
+
+        shutil.copyfile(self._dem_path, additional_dem_path)
+        self.logger.debug("Additional DEM data was copied to %s.", additional_dem_path)
 
     def _tile_info(self, lat: float, lon: float) -> tuple[str, str]:
         """Returns latitude band and tile name for SRTM tile from coordinates.
@@ -234,14 +266,15 @@ class DEM(Component):
         Returns:
             str: Path to the preview image.
         """
-        rgb_dem_path = self._dem_path.replace(".png", "_grayscale.png")
+        # rgb_dem_path = self._dem_path.replace(".png", "_grayscale.png")
+        grayscale_dem_path = os.path.join(self.previews_directory, "dem_grayscale.png")
 
-        self.logger.debug("Creating grayscale preview of DEM data in %s.", rgb_dem_path)
+        self.logger.debug("Creating grayscale preview of DEM data in %s.", grayscale_dem_path)
 
         dem_data = cv2.imread(self._dem_path, cv2.IMREAD_GRAYSCALE)
         dem_data_rgb = cv2.cvtColor(dem_data, cv2.COLOR_GRAY2RGB)
-        cv2.imwrite(rgb_dem_path, dem_data_rgb)
-        return rgb_dem_path
+        cv2.imwrite(grayscale_dem_path, dem_data_rgb)
+        return grayscale_dem_path
 
     def colored_preview(self) -> str:
         """Converts DEM image to colored RGB image and saves it to the map directory.
@@ -251,7 +284,8 @@ class DEM(Component):
             list[str]: List with a single path to the DEM file
         """
 
-        colored_dem_path = self._dem_path.replace(".png", "_colored.png")
+        # colored_dem_path = self._dem_path.replace(".png", "_colored.png")
+        colored_dem_path = os.path.join(self.previews_directory, "dem_colored.png")
 
         self.logger.debug("Creating colored preview of DEM data in %s.", colored_dem_path)
 
@@ -292,6 +326,15 @@ class DEM(Component):
         return [self.grayscale_preview(), self.colored_preview()]
 
     def _get_scaling_factor(self, maximum_deviation: int) -> float:
+        """Calculate scaling factor for DEM data normalization.
+        NOTE: Needs reconsideration for the implementation.
+
+        Args:
+            maximum_deviation (int): Maximum deviation in DEM data.
+
+        Returns:
+            float: Scaling factor for DEM data normalization.
+        """
         ESTIMATED_MAXIMUM_DEVIATION = 1000  # pylint: disable=C0103
         scaling_factor = maximum_deviation / ESTIMATED_MAXIMUM_DEVIATION
         return scaling_factor if scaling_factor < 1 else 1

maps4fs/generator/game.py

@@ -6,6 +6,7 @@ from __future__ import annotations
 
 import os
 
+from maps4fs.generator.background import Background
 from maps4fs.generator.config import Config
 from maps4fs.generator.dem import DEM
 from maps4fs.generator.i3d import I3d
@@ -35,7 +36,7 @@ class Game:
     _map_template_path: str | None = None
     _texture_schema: str | None = None
 
-    components = [Config, Texture, DEM, I3d]
+    components = [Config, Texture, DEM, I3d, Background]
 
     def __init__(self, map_template_path: str | None = None):
         if map_template_path: