maps4fs 0.7.9__py3-none-any.whl → 0.8.3__py3-none-any.whl

maps4fs/generator/i3d.py

@@ -0,0 +1,89 @@
+"""This module contains the Config class for map settings and configuration."""
+
+from __future__ import annotations
+
+import os
+from xml.etree import ElementTree as ET
+
+from maps4fs.generator.component import Component
+
+DEFAULT_HEIGHT_SCALE = 2000
+DEFAULT_MAX_LOD_DISTANCE = 10000
+DEFAULT_MAX_LOD_OCCLUDER_DISTANCE = 10000
+
+
+# pylint: disable=R0903
+class I3d(Component):
+    """Component for map i3d file settings and configuration.
+
+    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.
+    """
+
+    _map_i3d_path: str | None = None
+
+    def preprocess(self) -> None:
+        """Gets the path to the map I3D file from the game instance and saves it to the instance
+        attribute. If the game does not support I3D files, the attribute is set to None."""
+        try:
+            self._map_i3d_path = self.game.i3d_file_path(self.map_directory)
+            self.logger.debug("Map I3D path: %s.", self._map_i3d_path)
+        except NotImplementedError:
+            self.logger.info("I3D file processing is not implemented for this game.")
+            self._map_i3d_path = None
+
+    def process(self) -> None:
+        """Updates the map I3D file with the default settings."""
+        self._update_i3d_file()
+
+    def _update_i3d_file(self) -> None:
+        """Updates the map I3D file with the default settings."""
+        if not self._map_i3d_path:
+            self.logger.info("I3D is not obtained, skipping the update.")
+            return
+        if not os.path.isfile(self._map_i3d_path):
+            self.logger.warning("I3D file not found: %s.", self._map_i3d_path)
+            return
+
+        tree = ET.parse(self._map_i3d_path)
+
+        self.logger.debug("Map I3D file loaded from: %s.", self._map_i3d_path)
+
+        root = tree.getroot()
+        for map_elem in root.iter("Scene"):
+            for terrain_elem in map_elem.iter("TerrainTransformGroup"):
+                terrain_elem.set("heightScale", str(DEFAULT_HEIGHT_SCALE))
+                self.logger.debug(
+                    "heightScale attribute set to %s in TerrainTransformGroup element.",
+                    DEFAULT_HEIGHT_SCALE,
+                )
+                terrain_elem.set("maxLODDistance", str(DEFAULT_MAX_LOD_DISTANCE))
+                self.logger.debug(
+                    "maxLODDistance attribute set to %s in TerrainTransformGroup element.",
+                    DEFAULT_MAX_LOD_DISTANCE,
+                )
+
+                terrain_elem.set("occMaxLODDistance", str(DEFAULT_MAX_LOD_OCCLUDER_DISTANCE))
+                self.logger.debug(
+                    "occMaxLODDistance attribute set to %s in TerrainTransformGroup element.",
+                    DEFAULT_MAX_LOD_OCCLUDER_DISTANCE,
+                )
+
+                self.logger.debug("TerrainTransformGroup element updated in I3D file.")
+
+        tree.write(self._map_i3d_path)
+        self.logger.debug("Map I3D file saved to: %s.", self._map_i3d_path)
+
+    def previews(self) -> list[str]:
+        """Returns a list of paths to the preview images (empty list).
+        The component does not generate any preview images so it returns an empty list.
+
+        Returns:
+            list[str]: An empty list.
+        """
+        return []

maps4fs/generator/map.py

@@ -1,11 +1,12 @@
 """This module contains Map class, which is used to generate map using all components."""
 
+from __future__ import annotations
+
 import os
 import shutil
-from typing import Any
-
-from tqdm import tqdm
+from typing import Any, Generator
 
+# from maps4fs.generator.background import Background
 from maps4fs.generator.component import Component
 from maps4fs.generator.game import Game
 from maps4fs.logger import Logger
@@ -47,6 +48,7 @@ class Map:
         self.logger.debug("Game was set to %s", game.code)
 
         self.kwargs = kwargs
+        self.logger.debug("Additional arguments: %s", kwargs)
 
         os.makedirs(self.map_directory, exist_ok=True)
         self.logger.debug("Map directory created: %s", self.map_directory)
@@ -57,31 +59,45 @@ class Map:
         except Exception as e:
             raise RuntimeError(f"Can not unpack map template due to error: {e}") from e
 
-    def generate(self) -> None:
-        """Launch map generation using all components."""
-        with tqdm(total=len(self.game.components), desc="Generating map...") as pbar:
-            for game_component in self.game.components:
-                component = game_component(
-                    self.game,
-                    self.coordinates,
-                    self.height,
-                    self.width,
-                    self.map_directory,
-                    self.logger,
-                    **self.kwargs,
+    def generate(self) -> Generator[str, None, None]:
+        """Launch map generation using all components. Yield component names during the process.
+
+        Yields:
+            Generator[str, None, None]: Component names.
+        """
+        for game_component in self.game.components:
+            component = game_component(
+                self.game,
+                self.coordinates,
+                self.height,
+                self.width,
+                self.map_directory,
+                self.logger,
+                **self.kwargs,
+            )
+
+            yield component.__class__.__name__
+
+            try:
+                component.process()
+            except Exception as e:  # pylint: disable=W0718
+                self.logger.error(
+                    "Error processing component %s: %s",
+                    component.__class__.__name__,
+                    e,
+                )
+                raise e
+
+            try:
+                component.commit_generation_info()
+            except Exception as e:  # pylint: disable=W0718
+                self.logger.error(
+                    "Error committing generation info for component %s: %s",
+                    component.__class__.__name__,
+                    e,
                 )
-                try:
-                    component.process()
-                except Exception as e:  # pylint: disable=W0718
-                    self.logger.error(
-                        "Error processing component %s: %s",
-                        component.__class__.__name__,
-                        e,
-                    )
-                    raise e
-                self.components.append(component)
-
-                pbar.update(1)
+                raise e
+            self.components.append(component)
 
     def previews(self) -> list[str]:
         """Get list of preview images.

maps4fs/generator/path_steps.py

@@ -0,0 +1,72 @@
+"""This module contains functions and clas for generating path steps."""
+
+from typing import NamedTuple
+
+from geopy.distance import distance  # type: ignore
+
+DEFAULT_DISTANCE = 2048
+
+
+class PathStep(NamedTuple):
+    """Represents parameters of one step in the path.
+
+    Attributes:
+        code {str} -- Tile code (N, NE, E, SE, S, SW, W, NW).
+        angle {int} -- Angle in degrees (for example 0 for North, 90 for East).
+        distance {int} -- Distance in meters from previous step.
+        size {tuple[int, int]} -- Size of the tile in pixels (width, height).
+    """
+
+    code: str
+    angle: int
+    distance: int
+    size: tuple[int, int]
+
+    def get_destination(self, origin: tuple[float, float]) -> tuple[float, float]:
+        """Calculate destination coordinates based on origin and step parameters.
+
+        Arguments:
+            origin {tuple[float, float]} -- Origin coordinates (latitude, longitude)
+
+        Returns:
+            tuple[float, float] -- Destination coordinates (latitude, longitude)
+        """
+        destination = distance(meters=self.distance).destination(origin, self.angle)
+        return destination.latitude, destination.longitude
+
+
+def get_steps(map_height: int, map_width: int) -> list[PathStep]:
+    """Return a list of PathStep objects for each tile, which represent a step in the path.
+    Moving from the center of the map to North, then clockwise.
+
+    Arguments:
+        map_height {int} -- Height of the map in pixels
+        map_width {int} -- Width of the map in pixels
+
+    Returns:
+        list[PathStep] -- List of PathStep objects
+    """
+    # Move clockwise from N and calculate coordinates and sizes for each tile.
+    half_width = int(map_width / 2)
+    half_height = int(map_height / 2)
+
+    half_default_distance = int(DEFAULT_DISTANCE / 2)
+
+    return [
+        PathStep("N", 0, half_height + half_default_distance, (map_width, DEFAULT_DISTANCE)),
+        PathStep(
+            "NE", 90, half_width + half_default_distance, (DEFAULT_DISTANCE, DEFAULT_DISTANCE)
+        ),
+        PathStep("E", 180, half_height + half_default_distance, (DEFAULT_DISTANCE, map_height)),
+        PathStep(
+            "SE", 180, half_height + half_default_distance, (DEFAULT_DISTANCE, DEFAULT_DISTANCE)
+        ),
+        PathStep("S", 270, half_width + half_default_distance, (map_width, DEFAULT_DISTANCE)),
+        PathStep(
+            "SW", 270, half_width + half_default_distance, (DEFAULT_DISTANCE, DEFAULT_DISTANCE)
+        ),
+        PathStep("W", 0, half_height + half_default_distance, (DEFAULT_DISTANCE, map_height)),
+        PathStep(
+            "NW", 0, half_height + half_default_distance, (DEFAULT_DISTANCE, DEFAULT_DISTANCE)
+        ),
+    ]

maps4fs/generator/texture.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import json
 import os
 import warnings
-from typing import Callable, Generator, Optional
+from typing import Any, Callable, Generator, Optional
 
 import cv2
 import numpy as np
@@ -57,6 +57,7 @@ class Texture(Component):
             width: int | None = None,
             color: tuple[int, int, int] | list[int] | None = None,
             exclude_weight: bool = False,
+            priority: int | None = None,
         ):
             self.name = name
             self.count = count
@@ -64,6 +65,7 @@ class Texture(Component):
             self.width = width
             self.color = color if color else (255, 255, 255)
             self.exclude_weight = exclude_weight
+            self.priority = priority
 
         def to_json(self) -> dict[str, str | list[str] | bool]:  # type: ignore
             """Returns dictionary with layer data.
@@ -77,6 +79,7 @@ class Texture(Component):
                 "width": self.width,
                 "color": list(self.color),
                 "exclude_weight": self.exclude_weight,
+                "priority": self.priority,
             }
 
             data = {k: v for k, v in data.items() if v is not None}
@@ -120,16 +123,32 @@ class Texture(Component):
         self.layers = [self.Layer.from_json(layer) for layer in layers_schema]
         self.logger.info("Loaded %s layers.", len(self.layers))
 
+        base_layer = self.get_base_layer()
+        if base_layer:
+            self.logger.info("Base layer found: %s.", base_layer.name)
+        else:
+            self.logger.warning("No base layer found.")
+
         self._weights_dir = self.game.weights_dir_path(self.map_directory)
         self.logger.debug("Weights directory: %s.", self._weights_dir)
         self.info_save_path = os.path.join(self.map_directory, "generation_info.json")
         self.logger.debug("Generation info save path: %s.", self.info_save_path)
 
+    def get_base_layer(self) -> Layer | None:
+        """Returns base layer.
+
+        Returns:
+            Layer | None: Base layer.
+        """
+        for layer in self.layers:
+            if layer.priority == 0:
+                return layer
+        return None
+
     def process(self):
         self._prepare_weights()
         self._read_parameters()
         self.draw()
-        self.info_sequence()
 
     # pylint: disable=W0201
     def _read_parameters(self) -> None:
@@ -156,23 +175,8 @@ class Texture(Component):
         self.width_coef = self.width / self.map_width
         self.logger.debug("Map coefficients (HxW): %s x %s.", self.height_coef, self.width_coef)
 
-    def info_sequence(self) -> None:
-        """Saves generation info to JSON file "generation_info.json".
-
-        Info sequence contains following attributes:
-            - coordinates
-            - bbox
-            - map_height
-            - map_width
-            - minimum_x
-            - minimum_y
-            - maximum_x
-            - maximum_y
-            - height
-            - width
-            - height_coef
-            - width_coef
-        """
+    def info_sequence(self) -> dict[str, Any]:
+        """Returns the JSON representation of the generation info for textures."""
         useful_attributes = [
             "coordinates",
             "bbox",
@@ -187,11 +191,7 @@ class Texture(Component):
             "height_coef",
             "width_coef",
         ]
-        info_sequence = {attr: getattr(self, attr, None) for attr in useful_attributes}
-
-        with open(self.info_save_path, "w") as f:  # pylint: disable=W1514
-            json.dump(info_sequence, f, indent=4)
-        self.logger.info("Generation info saved to %s.", self.info_save_path)
+        return {attr: getattr(self, attr, None) for attr in useful_attributes}
 
     def _prepare_weights(self):
         self.logger.debug("Starting preparing weights from %s layers.", len(self.layers))
@@ -239,22 +239,79 @@ class Texture(Component):
         """
         self._layers = layers
 
+    def layers_by_priority(self) -> list[Layer]:
+        """Returns list of layers sorted by priority: None priority layers are first,
+        then layers are sorted by priority (descending).
+
+        Returns:
+            list[Layer]: List of layers sorted by priority.
+        """
+        return sorted(
+            self.layers,
+            key=lambda _layer: (
+                _layer.priority is not None,
+                -_layer.priority if _layer.priority is not None else float("inf"),
+            ),
+        )
+
     # pylint: disable=no-member
     def draw(self) -> None:
         """Iterates over layers and fills them with polygons from OSM data."""
-        for layer in self.layers:
+        layers = self.layers_by_priority()
+
+        self.logger.debug(
+            "Sorted layers by priority: %s.", [(layer.name, layer.priority) for layer in layers]
+        )
+
+        cumulative_image = None
+
+        for layer in layers:
             if not layer.tags:
                 self.logger.debug("Layer %s has no tags, there's nothing to draw.", layer.name)
                 continue
+            if layer.priority == 0:
+                self.logger.debug(
+                    "Found base layer %s. Postponing that to be the last layer drawn.", layer.name
+                )
+                continue
             layer_path = layer.path(self._weights_dir)
             self.logger.debug("Drawing layer %s.", layer_path)
+            layer_image = cv2.imread(layer_path, cv2.IMREAD_UNCHANGED)
+
+            if cumulative_image is None:
+                self.logger.debug("First layer, creating new cumulative image.")
+                cumulative_image = layer_image
+
+            mask = cv2.bitwise_not(cumulative_image)
 
-            img = cv2.imread(layer_path, cv2.IMREAD_UNCHANGED)
             for polygon in self.polygons(layer.tags, layer.width):  # type: ignore
-                cv2.fillPoly(img, [polygon], color=255)  # type: ignore
-            cv2.imwrite(layer_path, img)
+                cv2.fillPoly(layer_image, [polygon], color=255)  # type: ignore
+
+            output_image = cv2.bitwise_and(layer_image, mask)
+
+            cumulative_image = cv2.bitwise_or(cumulative_image, output_image)
+
+            cv2.imwrite(layer_path, output_image)
             self.logger.debug("Texture %s saved.", layer_path)
 
+        if cumulative_image is not None:
+            self.draw_base_layer(cumulative_image)
+
+    def draw_base_layer(self, cumulative_image: np.ndarray) -> None:
+        """Draws base layer and saves it into the png file.
+        Base layer is the last layer to be drawn, it fills the remaining area of the map.
+
+        Args:
+            cumulative_image (np.ndarray): Cumulative image with all layers.
+        """
+        base_layer = self.get_base_layer()
+        if base_layer is not None:
+            layer_path = base_layer.path(self._weights_dir)
+            self.logger.debug("Drawing base layer %s.", layer_path)
+            img = cv2.bitwise_not(cumulative_image)
+            cv2.imwrite(layer_path, img)
+            self.logger.debug("Base texture %s saved.", layer_path)
+
     def get_relative_x(self, x: float) -> int:
         """Converts UTM X coordinate to relative X coordinate in map image.
 
@@ -428,7 +485,7 @@ class Texture(Component):
             merged.shape,
             merged.dtype,
         )
-        preview_path = os.path.join(self.map_directory, "preview_osm.png")
+        preview_path = os.path.join(self.previews_directory, "textures_osm.png")
         cv2.imwrite(preview_path, merged)  # pylint: disable=no-member
         self.logger.info("Preview saved to %s.", preview_path)
         return preview_path

maps4fs/generator/tile.py

@@ -0,0 +1,55 @@
+"""This module contains the Tile component, which is used to generate a tile of DEM data around
+the map."""
+
+import os
+
+from maps4fs.generator.dem import DEM
+
+
+class Tile(DEM):
+    """Component for creating a tile of DEM data around the map.
+
+    Arguments:
+        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.
+
+    Keyword Arguments:
+        tile_code (str): The code of the tile (N, NE, E, SE, S, SW, W, NW).
+
+    Public Methods:
+        get_output_resolution: Return the resolution of the output image.
+        process: Launch the component processing.
+        make_copy: Override the method to prevent copying the tile.
+    """
+
+    def preprocess(self) -> None:
+        """Prepares the component for processing. Reads the tile code from the kwargs and sets the
+        DEM path for the tile."""
+        super().preprocess()
+        self.code = self.kwargs.get("tile_code")
+        if not self.code:
+            raise ValueError("Tile code was not provided")
+
+        self.logger.debug(f"Generating tile {self.code}")
+
+        tiles_directory = os.path.join(self.map_directory, "objects", "tiles")
+        os.makedirs(tiles_directory, exist_ok=True)
+
+        self._dem_path = os.path.join(tiles_directory, f"{self.code}.png")
+        self.logger.debug(f"DEM path for tile {self.code} is {self._dem_path}")
+
+    def get_output_resolution(self) -> tuple[int, int]:
+        """Return the resolution of the output image.
+
+        Returns:
+            tuple[int, int]: The width and height of the output image.
+        """
+        return self.map_width, self.map_height
+
+    def make_copy(self, *args, **kwargs) -> None:
+        """Override the method to prevent copying the tile."""
+        pass  # pylint: disable=unnecessary-pass