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

maps4fs/generator/map.py

@@ -1,10 +1,10 @@
 """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.component import Component
 from maps4fs.generator.game import Game
@@ -58,31 +58,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
@@ -149,7 +149,6 @@ class Texture(Component):
         self._prepare_weights()
         self._read_parameters()
         self.draw()
-        self.info_sequence()
 
     # pylint: disable=W0201
     def _read_parameters(self) -> None:
@@ -176,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",
@@ -207,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))
@@ -505,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