maps4fs 0.7.8__py3-none-any.whl

maps4fs/generator/map.py

@@ -0,0 +1,115 @@
+"""This module contains Map class, which is used to generate map using all components."""
+
+import os
+import shutil
+from typing import Any
+
+from tqdm import tqdm
+
+from maps4fs.generator.component import Component
+from maps4fs.generator.game import Game
+from maps4fs.logger import Logger
+
+
+# pylint: disable=R0913, R0902
+class Map:
+    """Class used to generate map using all components.
+
+    Args:
+        game (Type[Game]): Game for which the map is generated.
+        coordinates (tuple[float, float]): Coordinates of the center of the map.
+        height (int): Height of the map in pixels.
+        width (int): Width of the map in pixels.
+        map_directory (str): Path to the directory where map files will be stored.
+        logger (Any): Logger instance
+    """
+
+    def __init__(  # pylint: disable=R0917
+        self,
+        game: Game,
+        coordinates: tuple[float, float],
+        height: int,
+        width: int,
+        map_directory: str,
+        logger: Any = None,
+        **kwargs,
+    ):
+        self.game = game
+        self.components: list[Component] = []
+        self.coordinates = coordinates
+        self.height = height
+        self.width = width
+        self.map_directory = map_directory
+
+        if not logger:
+            logger = Logger(__name__, to_stdout=True, to_file=False)
+        self.logger = logger
+        self.logger.debug("Game was set to %s", game.code)
+
+        self.kwargs = kwargs
+
+        os.makedirs(self.map_directory, exist_ok=True)
+        self.logger.debug("Map directory created: %s", self.map_directory)
+
+        try:
+            shutil.unpack_archive(game.template_path, self.map_directory)
+            self.logger.info("Map template unpacked to %s", self.map_directory)
+        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,
+                )
+                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)
+
+    def previews(self) -> list[str]:
+        """Get list of preview images.
+
+        Returns:
+            list[str]: List of preview images.
+        """
+        previews = []
+        for component in self.components:
+            try:
+                previews.extend(component.previews())
+            except Exception as e:  # pylint: disable=W0718
+                self.logger.error(
+                    "Error getting previews for component %s: %s",
+                    component.__class__.__name__,
+                    e,
+                )
+        return previews
+
+    def pack(self, archive_name: str) -> str:
+        """Pack map directory to zip archive.
+
+        Args:
+            archive_name (str): Name of the archive.
+
+        Returns:
+            str: Path to the archive.
+        """
+        archive_path = shutil.make_archive(archive_name, "zip", self.map_directory)
+        self.logger.info("Map packed to %s.zip", archive_name)
+        return archive_path

maps4fs/generator/texture.py

@@ -0,0 +1,434 @@
+"""Module with Texture class for generating textures for the map using OSM data."""
+
+from __future__ import annotations
+
+import json
+import os
+import warnings
+from typing import Callable, Generator, Optional
+
+import cv2
+import numpy as np
+import osmnx as ox  # type: ignore
+import pandas as pd
+import shapely.geometry  # type: ignore
+from shapely.geometry.base import BaseGeometry  # type: ignore
+
+from maps4fs.generator.component import Component
+
+PREVIEW_MAXIMUM_SIZE = 2048
+
+
+# pylint: disable=R0902
+class Texture(Component):
+    """Class which generates textures for the map using OSM data.
+
+    Attributes:
+        weights_dir (str): Path to the directory with weights.
+        name (str): Name of the texture.
+        tags (dict[str, str | list[str] | bool]): Dictionary of tags to search for.
+        width (int | None): Width of the polygon in meters (only for LineString).
+        color (tuple[int, int, int]): Color of the layer in BGR format.
+    """
+
+    # pylint: disable=R0903
+    class Layer:
+        """Class which represents a layer with textures and tags.
+        It's using to obtain data from OSM using tags and make changes into corresponding textures.
+
+        Args:
+            name (str): Name of the layer.
+            tags (dict[str, str | list[str]]): Dictionary of tags to search for.
+            width (int | None): Width of the polygon in meters (only for LineString).
+            color (tuple[int, int, int]): Color of the layer in BGR format.
+
+        Attributes:
+            name (str): Name of the layer.
+            tags (dict[str, str | list[str]]): Dictionary of tags to search for.
+            width (int | None): Width of the polygon in meters (only for LineString).
+        """
+
+        # pylint: disable=R0913
+        def __init__(  # pylint: disable=R0917
+            self,
+            name: str,
+            count: int,
+            tags: dict[str, str | list[str] | bool] | None = None,
+            width: int | None = None,
+            color: tuple[int, int, int] | list[int] | None = None,
+            exclude_weight: bool = False,
+        ):
+            self.name = name
+            self.count = count
+            self.tags = tags
+            self.width = width
+            self.color = color if color else (255, 255, 255)
+            self.exclude_weight = exclude_weight
+
+        def to_json(self) -> dict[str, str | list[str] | bool]:  # type: ignore
+            """Returns dictionary with layer data.
+
+            Returns:
+                dict: Dictionary with layer data."""
+            data = {
+                "name": self.name,
+                "count": self.count,
+                "tags": self.tags,
+                "width": self.width,
+                "color": list(self.color),
+                "exclude_weight": self.exclude_weight,
+            }
+
+            data = {k: v for k, v in data.items() if v is not None}
+            return data  # type: ignore
+
+        @classmethod
+        def from_json(cls, data: dict[str, str | list[str] | bool]) -> Texture.Layer:
+            """Creates a new instance of the class from dictionary.
+
+            Args:
+                data (dict[str, str | list[str] | bool]): Dictionary with layer data.
+
+            Returns:
+                Layer: New instance of the class.
+            """
+            return cls(**data)  # type: ignore
+
+        def path(self, weights_directory: str) -> str:
+            """Returns path to the first texture of the layer.
+
+            Arguments:
+                weights_directory (str): Path to the directory with weights.
+
+            Returns:
+                str: Path to the texture.
+            """
+            idx = "01" if self.count > 0 else ""
+            weight_postfix = "_weight" if not self.exclude_weight else ""
+            return os.path.join(weights_directory, f"{self.name}{idx}{weight_postfix}.png")
+
+    def preprocess(self) -> None:
+        if not os.path.isfile(self.game.texture_schema):
+            raise FileNotFoundError(f"Texture layers schema not found: {self.game.texture_schema}")
+
+        try:
+            with open(self.game.texture_schema, "r", encoding="utf-8") as f:
+                layers_schema = json.load(f)
+        except json.JSONDecodeError as e:
+            raise ValueError(f"Error loading texture layers schema: {e}") from e
+
+        self.layers = [self.Layer.from_json(layer) for layer in layers_schema]
+        self.logger.info("Loaded %s layers.", len(self.layers))
+
+        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 process(self):
+        self._prepare_weights()
+        self._read_parameters()
+        self.draw()
+        self.info_sequence()
+
+    # pylint: disable=W0201
+    def _read_parameters(self) -> None:
+        """Reads map parameters from OSM data, such as:
+        - minimum and maximum coordinates in UTM format
+        - map dimensions in meters
+        - map coefficients (meters per pixel)
+        """
+        north, south, east, west = self.get_bbox(project_utm=True)
+
+        # Parameters of the map in UTM format (meters).
+        self.minimum_x = min(west, east)
+        self.minimum_y = min(south, north)
+        self.maximum_x = max(west, east)
+        self.maximum_y = max(south, north)
+        self.logger.debug("Map minimum coordinates (XxY): %s x %s.", self.minimum_x, self.minimum_y)
+        self.logger.debug("Map maximum coordinates (XxY): %s x %s.", self.maximum_x, self.maximum_y)
+
+        self.height = abs(north - south)
+        self.width = abs(east - west)
+        self.logger.info("Map dimensions (HxW): %s x %s.", self.height, self.width)
+
+        self.height_coef = self.height / self.map_height
+        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
+        """
+        useful_attributes = [
+            "coordinates",
+            "bbox",
+            "map_height",
+            "map_width",
+            "minimum_x",
+            "minimum_y",
+            "maximum_x",
+            "maximum_y",
+            "height",
+            "width",
+            "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)
+
+    def _prepare_weights(self):
+        self.logger.debug("Starting preparing weights from %s layers.", len(self.layers))
+
+        for layer in self.layers:
+            self._generate_weights(layer)
+        self.logger.debug("Prepared weights for %s layers.", len(self.layers))
+
+    def _generate_weights(self, layer: Layer) -> None:
+        """Generates weight files for textures. Each file is a numpy array of zeros and
+            dtype uint8 (0-255).
+
+        Args:
+            layer (Layer): Layer with textures and tags.
+        """
+        size = (self.map_height, self.map_width)
+        postfix = "_weight.png" if not layer.exclude_weight else ".png"
+        if layer.count == 0:
+            filepaths = [os.path.join(self._weights_dir, layer.name + postfix)]
+        else:
+            filepaths = [
+                os.path.join(self._weights_dir, layer.name + str(i).zfill(2) + postfix)
+                for i in range(1, layer.count + 1)
+            ]
+
+        for filepath in filepaths:
+            img = np.zeros(size, dtype=np.uint8)
+            cv2.imwrite(filepath, img)  # pylint: disable=no-member
+
+    @property
+    def layers(self) -> list[Layer]:
+        """Returns list of layers with textures and tags from textures.json.
+
+        Returns:
+            list[Layer]: List of layers.
+        """
+        return self._layers
+
+    @layers.setter
+    def layers(self, layers: list[Layer]) -> None:
+        """Sets list of layers with textures and tags.
+
+        Args:
+            layers (list[Layer]): List of layers.
+        """
+        self._layers = layers
+
+    # pylint: disable=no-member
+    def draw(self) -> None:
+        """Iterates over layers and fills them with polygons from OSM data."""
+        for layer in self.layers:
+            if not layer.tags:
+                self.logger.debug("Layer %s has no tags, there's nothing to draw.", layer.name)
+                continue
+            layer_path = layer.path(self._weights_dir)
+            self.logger.debug("Drawing layer %s.", layer_path)
+
+            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)
+            self.logger.debug("Texture %s saved.", layer_path)
+
+    def get_relative_x(self, x: float) -> int:
+        """Converts UTM X coordinate to relative X coordinate in map image.
+
+        Args:
+            x (float): UTM X coordinate.
+
+        Returns:
+            int: Relative X coordinate in map image.
+        """
+        raw_x = x - self.minimum_x
+        return int(raw_x * self.height_coef)
+
+    def get_relative_y(self, y: float) -> int:
+        """Converts UTM Y coordinate to relative Y coordinate in map image.
+
+        Args:
+            y (float): UTM Y coordinate.
+
+        Returns:
+            int: Relative Y coordinate in map image.
+        """
+        raw_y = y - self.minimum_y
+        return self.height - int(raw_y * self.width_coef)
+
+    # pylint: disable=W0613
+    def _to_np(self, geometry: shapely.geometry.polygon.Polygon, *args) -> np.ndarray:
+        """Converts Polygon geometry to numpy array of polygon points.
+
+        Args:
+            geometry (shapely.geometry.polygon.Polygon): Polygon geometry.
+            *args: Additional arguments:
+                - width (int | None): Width of the polygon in meters.
+
+        Returns:
+            np.ndarray: Numpy array of polygon points.
+        """
+        xs, ys = geometry.exterior.coords.xy
+        xs = [int(self.get_relative_x(x)) for x in xs.tolist()]
+        ys = [int(self.get_relative_y(y)) for y in ys.tolist()]
+        pairs = list(zip(xs, ys))
+        return np.array(pairs, dtype=np.int32).reshape((-1, 1, 2))
+
+    def _to_polygon(self, obj: pd.core.series.Series, width: int | None) -> np.ndarray | None:
+        """Converts OSM object to numpy array of polygon points.
+
+        Args:
+            obj (pd.core.series.Series): OSM object.
+            width (int | None): Width of the polygon in meters.
+
+        Returns:
+            np.ndarray | None: Numpy array of polygon points.
+        """
+        geometry = obj["geometry"]
+        geometry_type = geometry.geom_type
+        converter = self._converters(geometry_type)
+        if not converter:
+            self.logger.warning("Geometry type %s not supported.", geometry_type)
+            return None
+        return converter(geometry, width)
+
+    def _sequence(
+        self,
+        geometry: shapely.geometry.linestring.LineString | shapely.geometry.point.Point,
+        width: int | None,
+    ) -> np.ndarray:
+        """Converts LineString or Point geometry to numpy array of polygon points.
+
+        Args:
+            geometry (shapely.geometry.linestring.LineString | shapely.geometry.point.Point):
+                LineString or Point geometry.
+            width (int | None): Width of the polygon in meters.
+
+        Returns:
+            np.ndarray: Numpy array of polygon points.
+        """
+        polygon = geometry.buffer(width)
+        return self._to_np(polygon)
+
+    def _converters(
+        self, geom_type: str
+    ) -> Optional[Callable[[BaseGeometry, Optional[int]], np.ndarray]]:
+        """Returns a converter function for a given geometry type.
+
+        Args:
+            geom_type (str): Geometry type.
+
+        Returns:
+            Callable[[shapely.geometry, int | None], np.ndarray]: Converter function.
+        """
+        converters = {"Polygon": self._to_np, "LineString": self._sequence, "Point": self._sequence}
+        return converters.get(geom_type)  # type: ignore
+
+    def polygons(
+        self, tags: dict[str, str | list[str] | bool], width: int | None
+    ) -> Generator[np.ndarray, None, None]:
+        """Generator which yields numpy arrays of polygons from OSM data.
+
+        Args:
+            tags (dict[str, str | list[str]]): Dictionary of tags to search for.
+            width (int | None): Width of the polygon in meters (only for LineString).
+
+        Yields:
+            Generator[np.ndarray, None, None]: Numpy array of polygon points.
+        """
+        try:
+            with warnings.catch_warnings():
+                warnings.simplefilter("ignore", DeprecationWarning)
+                objects = ox.features_from_bbox(bbox=self.bbox, tags=tags)
+        except Exception as e:  # pylint: disable=W0718
+            self.logger.warning("Error fetching objects for tags: %s.", tags)
+            self.logger.warning(e)
+            return
+        objects_utm = ox.project_gdf(objects, to_latlong=False)
+        self.logger.debug("Fetched %s elements for tags: %s.", len(objects_utm), tags)
+
+        for _, obj in objects_utm.iterrows():
+            polygon = self._to_polygon(obj, width)
+            if polygon is None:
+                continue
+            yield polygon
+
+    def previews(self) -> list[str]:
+        """Invokes methods to generate previews. Returns list of paths to previews.
+
+        Returns:
+            list[str]: List of paths to previews.
+        """
+        preview_paths = []
+        preview_paths.append(self._osm_preview())
+        return preview_paths
+
+    # pylint: disable=no-member
+    def _osm_preview(self) -> str:
+        """Merges layers into one image and saves it into the png file.
+
+        Returns:
+            str: Path to the preview.
+        """
+        scaling_factor = min(
+            PREVIEW_MAXIMUM_SIZE / self.map_width, PREVIEW_MAXIMUM_SIZE / self.map_height
+        )
+
+        preview_size = (
+            int(self.map_width * scaling_factor),
+            int(self.map_height * scaling_factor),
+        )
+        self.logger.debug(
+            "Scaling factor: %s. Preview size: %s.",
+            scaling_factor,
+            preview_size,
+        )
+
+        active_layers = [layer for layer in self.layers if layer.tags is not None]
+        self.logger.debug("Following layers have tag textures: %s.", len(active_layers))
+
+        images = [
+            cv2.resize(
+                cv2.imread(layer.path(self._weights_dir), cv2.IMREAD_UNCHANGED), preview_size
+            )
+            for layer in active_layers
+        ]
+        colors = [layer.color for layer in active_layers]
+        color_images = []
+        for img, color in zip(images, colors):
+            color_img = np.zeros((img.shape[0], img.shape[1], 3), dtype=np.uint8)
+            color_img[img > 0] = color
+            color_images.append(color_img)
+        merged = np.sum(color_images, axis=0, dtype=np.uint8)
+        self.logger.debug(
+            "Merged layers into one image. Shape: %s, dtype: %s.",
+            merged.shape,
+            merged.dtype,
+        )
+        preview_path = os.path.join(self.map_directory, "preview_osm.png")
+        cv2.imwrite(preview_path, merged)  # pylint: disable=no-member
+        self.logger.info("Preview saved to %s.", preview_path)
+        return preview_path

maps4fs/logger.py

@@ -0,0 +1,46 @@
+"""This module contains the Logger class for logging to the file and stdout."""
+
+import logging
+import os
+import sys
+from datetime import datetime
+from typing import Literal
+
+log_directory = os.path.join(os.getcwd(), "logs")
+os.makedirs(log_directory, exist_ok=True)
+
+
+class Logger(logging.Logger):
+    """Handles logging to the file and stroudt with timestamps."""
+
+    def __init__(
+        self,
+        name: str,
+        level: Literal["DEBUG", "INFO", "WARNING", "ERROR"] = "ERROR",
+        to_stdout: bool = True,
+        to_file: bool = True,
+    ):
+        super().__init__(name)
+        self.setLevel(level)
+        self.stdout_handler = logging.StreamHandler(sys.stdout)
+        self.file_handler = logging.FileHandler(
+            filename=self.log_file(), mode="a", encoding="utf-8"
+        )
+        formatter = "%(name)s | %(levelname)s | %(asctime)s | %(message)s"
+        self.fmt = formatter
+        self.stdout_handler.setFormatter(logging.Formatter(formatter))
+        self.file_handler.setFormatter(logging.Formatter(formatter))
+        if to_stdout:
+            self.addHandler(self.stdout_handler)
+        if to_file:
+            self.addHandler(self.file_handler)
+
+    def log_file(self) -> str:
+        """Returns the path to the log file.
+
+        Returns:
+            str: The path to the log file.
+        """
+        today = datetime.now().strftime("%Y-%m-%d")
+        log_file = os.path.join(log_directory, f"{today}.txt")
+        return log_file

maps4fs-0.7.8.dist-info/LICENSE.md

@@ -0,0 +1,21 @@
+# MIT License
+
+Copyright © [2024] [iwatkot]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.