maps4fs 0.6.0__py3-none-any.whl

maps4fs/__init__.py

@@ -0,0 +1,4 @@
+# pylint: disable=missing-module-docstring
+from maps4fs.generator.game import Game
+from maps4fs.generator.map import Map
+from maps4fs.logger import Logger

maps4fs/generator/__init__.py

@@ -0,0 +1 @@
+# pylint: disable=missing-module-docstring

maps4fs/generator/component.py

@@ -0,0 +1,55 @@
+"""This module contains the base class for all map generation components."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from maps4fs.generator.game import Game
+
+
+# pylint: disable=R0801, R0903
+class Component:
+    """Base class for all map generation components.
+
+    Args:
+        coordinates (tuple[float, float]): The latitude and longitude of the center of the map.
+        distance (int): The distance from the center to the edge of the map.
+        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 __init__(
+        self,
+        game: Game,
+        coordinates: tuple[float, float],
+        distance: int,
+        map_directory: str,
+        logger: Any = None,
+        **kwargs,  # pylint: disable=W0613, R0913, R0917
+    ):
+        self.game = game
+        self.coordinates = coordinates
+        self.distance = distance
+        self.map_directory = map_directory
+        self.logger = logger
+        self.kwargs = kwargs
+
+        self.preprocess()
+
+    def preprocess(self) -> None:
+        """Prepares the component for processing. Must be implemented in the child class.
+
+        Raises:
+            NotImplementedError: If the method is not implemented in the child class.
+        """
+        raise NotImplementedError
+
+    def process(self) -> None:
+        """Launches the component processing. Must be implemented in the child class.
+
+        Raises:
+            NotImplementedError: If the method is not implemented in the child class.
+        """
+        raise NotImplementedError

maps4fs/generator/config.py

@@ -0,0 +1,44 @@
+"""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
+
+
+# pylint: disable=R0903
+class Config(Component):
+    """Component for map settings and configuration.
+
+    Args:
+        coordinates (tuple[float, float]): The latitude and longitude of the center of the map.
+        distance (int): The distance from the center to the edge of the map.
+        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:
+        self._map_xml_path = self.game.map_xml_path(self.map_directory)
+        self.logger.debug(f"Map XML path: {self._map_xml_path}")
+
+    def process(self):
+        self._set_map_size()
+
+    def _set_map_size(self):
+        """Edits map.xml file to set correct map size."""
+        if not os.path.isfile(self._map_xml_path):
+            self.logger.warning("Map XML file not found: %s.", self._map_xml_path)
+            return
+        tree = ET.parse(self._map_xml_path)
+        self.logger.debug("Map XML file loaded from: %s.", self._map_xml_path)
+        root = tree.getroot()
+        for map_elem in root.iter("map"):
+            width = height = str(self.distance * 2)
+            map_elem.set("width", width)
+            map_elem.set("height", height)
+            self.logger.debug("Map size set to %sx%s in Map XML file.", width, height)
+        tree.write(self._map_xml_path)
+        self.logger.debug("Map XML file saved to: %s.", self._map_xml_path)

maps4fs/generator/dem.py

@@ -0,0 +1,207 @@
+"""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 osmnx as ox  # type: ignore
+import rasterio  # type: ignore
+import requests
+
+from maps4fs.generator.component import Component
+
+SRTM = "https://elevation-tiles-prod.s3.amazonaws.com/skadi/{latitude_band}/{tile_name}.hgt.gz"
+
+
+# pylint: disable=R0903
+class DEM(Component):
+    """Component for map settings and configuration.
+
+    Args:
+        coordinates (tuple[float, float]): The latitude and longitude of the center of the map.
+        distance (int): The distance from the center to the edge of the map.
+        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:
+        self._blur_seed: int = self.kwargs.get("blur_seed") or 5
+        self._max_height: int = self.kwargs.get("max_height") or 200
+
+        self._dem_path = self.game.dem_file_path(self.map_directory)
+        self.temp_dir = "temp"
+        self.hgt_dir = os.path.join(self.temp_dir, "hgt")
+        self.gz_dir = os.path.join(self.temp_dir, "gz")
+        os.makedirs(self.hgt_dir, exist_ok=True)
+        os.makedirs(self.gz_dir, exist_ok=True)
+
+    # 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 = ox.utils_geo.bbox_from_point(  # pylint: disable=W0632
+            self.coordinates, dist=self.distance
+        )
+        self.logger.debug(
+            f"Processing DEM. North: {north}, south: {south}, east: {east}, west: {west}."
+        )
+
+        dem_output_size = self.distance * self.game.dem_multipliyer + 1
+        self.logger.debug(
+            "DEM multiplier is %s, DEM output size is %s.",
+            self.game.dem_multipliyer,
+            dem_output_size,
+        )
+        dem_output_resolution = (dem_output_size, dem_output_size)
+        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.")
+            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 not data.size > 0:
+            self.logger.warning("DEM data is empty, DEM file will be filled with zeros.")
+            self._save_empty_dem(dem_output_resolution)
+            return
+
+        self.logger.debug(
+            f"DEM data was read from SRTM file. Shape: {data.shape}, dtype: {data.dtype}. "
+            f"Min: {data.min()}, max: {data.max()}."
+        )
+
+        normalized_data = self._normalize_dem(data)
+
+        resampled_data = cv2.resize(
+            normalized_data, dem_output_resolution, interpolation=cv2.INTER_LINEAR
+        )
+        self.logger.debug(
+            f"DEM data was resampled. Shape: {resampled_data.shape}, "
+            f"dtype: {resampled_data.dtype}. "
+            f"Min: {resampled_data.min()}, max: {resampled_data.max()}."
+        )
+
+        blurred_data = cv2.GaussianBlur(resampled_data, (self._blur_seed, self._blur_seed), 0)
+        cv2.imwrite(self._dem_path, blurred_data)
+        self.logger.debug("DEM data was saved to %s.", self._dem_path)
+
+    def _tile_info(self, lat: float, lon: float) -> tuple[str, str]:
+        """Returns latitude band and tile name for SRTM tile from coordinates.
+
+        Args:
+            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.info(
+                f"Decompressed tile already exists: {decompressed_file_path}, skipping download."
+            )
+            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")
+        cv2.imwrite(self._dem_path, dem_data)  # pylint: disable=no-member
+        self.logger.warning("DEM data filled with zeros and saved to %s.", self._dem_path)
+
+    def _normalize_dem(self, data: np.ndarray) -> np.ndarray:
+        """Normalize DEM data to 16-bit unsigned integer using max height from settings.
+
+        Args:
+            data (np.ndarray): DEM data from SRTM file after cropping.
+
+        Returns:
+            np.ndarray: Normalized DEM data.
+        """
+        max_dev = data.max() - data.min()
+        scaling_factor = max_dev / self._max_height if max_dev < self._max_height else 1
+        adjusted_max_height = int(65535 * scaling_factor)
+        self.logger.debug(
+            f"Maximum deviation: {max_dev}. Scaling factor: {scaling_factor}. "
+            f"Adjusted max height: {adjusted_max_height}."
+        )
+        normalized_data = (
+            (data - data.min()) / (data.max() - data.min()) * adjusted_max_height
+        ).astype("uint16")
+        self.logger.debug(
+            f"DEM data was normalized to {normalized_data.min()} - {normalized_data.max()}."
+        )
+        return normalized_data

maps4fs/generator/game.py

@@ -0,0 +1,140 @@
+"""This module contains the Game class and its subclasses. Game class is used to define
+different versions of the game for which the map is generated. Each game has its own map
+template file and specific settings for map generation."""
+
+from __future__ import annotations
+
+import os
+
+from maps4fs.generator.config import Config
+from maps4fs.generator.dem import DEM
+from maps4fs.generator.texture import Texture
+
+working_directory = os.getcwd()
+
+
+class Game:
+    """Class used to define different versions of the game for which the map is generated.
+
+    Arguments:
+        map_template_path (str, optional): Path to the map template file. Defaults to None.
+
+    Attributes and Properties:
+        code (str): The code of the game.
+        components (list[Type[Component]]): List of components used for map generation.
+        map_template_path (str): Path to the map template file.
+
+    Public Methods:
+        from_code(cls, code: str) -> Game: Returns the game instance based on the game code.
+    """
+
+    code: str | None = None
+    dem_multipliyer: int = 1
+    _map_template_path: str | None = None
+    _texture_schema: str | None = None
+
+    components = [Config, Texture, DEM]
+
+    def __init__(self, map_template_path: str | None = None):
+        if map_template_path:
+            self._map_template_path = map_template_path
+
+    def map_xml_path(self, map_directory: str) -> str:
+        """Returns the path to the map.xml file.
+
+        Arguments:
+            map_directory (str): The path to the map directory.
+
+        Returns:
+            str: The path to the map.xml file.
+        """
+        return os.path.join(map_directory, "maps", "map", "map.xml")
+
+    @classmethod
+    def from_code(cls, code: str) -> Game:
+        """Returns the game instance based on the game code.
+
+        Arguments:
+            code (str): The code of the game.
+
+        Returns:
+            Game: The game instance.
+        """
+        for game in cls.__subclasses__():
+            if game.code and game.code.lower() == code.lower():
+                return game()
+        raise ValueError(f"Game with code {code} not found.")
+
+    @property
+    def template_path(self) -> str:
+        """Returns the path to the map template file.
+
+        Raises:
+            ValueError: If the map template path is not set.
+
+        Returns:
+            str: The path to the map template file."""
+        if not self._map_template_path:
+            raise ValueError("Map template path not set.")
+        return self._map_template_path
+
+    @property
+    def texture_schema(self) -> str:
+        """Returns the path to the texture layers schema file.
+
+        Raises:
+            ValueError: If the texture layers schema path is not set.
+
+        Returns:
+            str: The path to the texture layers schema file."""
+        if not self._texture_schema:
+            raise ValueError("Texture layers schema path not set.")
+        return self._texture_schema
+
+    def dem_file_path(self, map_directory: str) -> str:
+        """Returns the path to the DEM file.
+
+        Arguments:
+            map_directory (str): The path to the map directory.
+
+        Returns:
+            str: The path to the DEM file.
+        """
+        raise NotImplementedError
+
+
+class FS22(Game):
+    """Class used to define the game version FS22."""
+
+    code = "FS22"
+    _map_template_path = os.path.join(working_directory, "data", "fs22-map-template.zip")
+    _texture_schema = os.path.join(working_directory, "data", "fs22-texture-schema.json")
+
+    def dem_file_path(self, map_directory: str) -> str:
+        """Returns the path to the DEM file.
+
+        Arguments:
+            map_directory (str): The path to the map directory.
+
+        Returns:
+            str: The path to the DEM file."""
+        return os.path.join(map_directory, "maps", "map", "data", "map_dem.png")
+
+
+class FS25(Game):
+    """Class used to define the game version FS25."""
+
+    code = "FS25"
+    dem_multipliyer: int = 2
+    _map_template_path = os.path.join(working_directory, "data", "fs25-map-template.zip")
+    _texture_schema = os.path.join(working_directory, "data", "fs25-texture-schema.json")
+
+    def dem_file_path(self, map_directory: str) -> str:
+        """Returns the path to the DEM file.
+
+        Arguments:
+            map_directory (str): The path to the map directory.
+
+        Returns:
+            str: The path to the DEM file."""
+        return os.path.join(map_directory, "maps", "map", "data", "dem.png")

maps4fs/generator/map.py

@@ -0,0 +1,110 @@
+"""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.game import Game
+from maps4fs.logger import Logger
+
+
+# pylint: disable=R0913
+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.
+        distance (int): Distance from the center of the map.
+        map_directory (str): Path to the directory where map files will be stored.
+        blur_seed (int): Seed used for blur effect.
+        max_height (int): Maximum height of the map.
+        logger (Any): Logger instance
+    """
+
+    def __init__(  # pylint: disable=R0917
+        self,
+        game: Game,
+        coordinates: tuple[float, float],
+        distance: int,
+        map_directory: str,
+        blur_seed: int,
+        max_height: int,
+        logger: Any = None,
+    ):
+        self.game = game
+        self.coordinates = coordinates
+        self.distance = distance
+        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)
+
+        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
+
+        # Blur seed should be positive and odd.
+        if blur_seed <= 0:
+            raise ValueError("Blur seed should be positive.")
+        if blur_seed % 2 == 0:
+            blur_seed += 1
+
+        self.blur_seed = blur_seed
+        self.max_height = max_height
+
+    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.distance,
+                    self.map_directory,
+                    self.logger,
+                    blur_seed=self.blur_seed,
+                    max_height=self.max_height,
+                )
+                try:
+                    component.process()
+                except Exception as e:  # pylint: disable=W0718
+                    self.logger.error(
+                        "Error processing component %s: %s",
+                        component.__class__.__name__,
+                        e,
+                    )
+                    raise e
+                setattr(self, game_component.__name__.lower(), component)
+
+                pbar.update(1)
+
+    def previews(self) -> list[str]:
+        """Get list of preview images.
+
+        Returns:
+            list[str]: List of preview images.
+        """
+        return self.texture.previews()  # type: ignore # pylint: disable=no-member
+
+    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,535 @@
+"""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
+
+# region constants
+# texture = {
+#     "name": "concrete",
+#     "count": 4,
+#     "tags": {"building": True},
+#     "width": 8,
+#     "color": (130, 130, 130),
+# }
+
+# textures = [
+#     {
+#         "name": "animalMud",
+#         "count": 4,
+#     },
+#     {
+#         "name": "asphalt",
+#         "count": 4,
+#         "tags": {"highway": ["motorway", "trunk", "primary"]},
+#         "width": 8,
+#         "color": (70, 70, 70),
+#     },
+#     {
+#         "name": "cobbleStone",
+#         "count": 4,
+#     },
+#     {
+#         "name": "concrete",
+#         "count": 4,
+#         "tags": {"building": True},
+#         "width": 8,
+#         "color": (130, 130, 130),
+#     },
+#     {
+#         "name": "concreteRubble",
+#         "count": 4,
+#     },
+#     {
+#         "name": "concreteTiles",
+#         "count": 4,
+#     },
+#     {
+#         "name": "dirt",
+#         "count": 4,
+#     },
+#     {
+#         "name": "dirtDark",
+#         "count": 2,
+#         "tags": {"highway": ["unclassified", "residential", "track"]},
+#         "width": 2,
+#         "color": (33, 67, 101),
+#     },
+#     {
+#         "name": "forestGround",
+#         "count": 4,
+#         "tags": {"landuse": "farmland"},
+#         "color": (47, 107, 85),
+#     },
+#     {
+#         "name": "forestGroundLeaves",
+#         "count": 4,
+#     },
+#     {
+#         "name": "grass",
+#         "count": 4,
+#         "tags": {"natural": "grassland"},
+#         "color": (34, 255, 34),
+#     },
+#     {
+#         "name": "grassDirt",
+#         "count": 4,
+#         "tags": {"natural": ["wood", "tree_row"]},
+#         "width": 2,
+#         "color": (0, 252, 124),
+#     },
+#     {
+#         "name": "gravel",
+#         "count": 4,
+#         "tags": {"highway": ["secondary", "tertiary", "road"]},
+#         "width": 4,
+#         "color": (140, 180, 210),
+#     },
+#     {
+#         "name": "groundBricks",
+#         "count": 4,
+#     },
+#     {
+#         "name": "mountainRock",
+#         "count": 4,
+#     },
+#     {
+#         "name": "mountainRockDark",
+#         "count": 4,
+#     },
+#     {
+#         "name": "riverMud",
+#         "count": 4,
+#     },
+#     {
+#         "name": "waterPuddle",
+#         "count": 0,
+#         "tags": {"natural": "water", "waterway": True},
+#         "width": 10,
+#         "color": (255, 20, 20),
+#     },
+# ]
+
+# TEXTURES = {
+# ?     "animalMud": 4,
+# ?     "asphalt": 4,
+# ?     "cobbleStone": 4,
+# ?     "concrete": 4,
+#     "concreteRubble": 4,
+#     "concreteTiles": 4,
+#     "dirt": 4,
+#     "dirtDark": 2,
+#     "forestGround": 4,
+#     "forestGroundLeaves": 4,
+#     "grass": 4,
+#     "grassDirt": 4,
+#     "gravel": 4,
+#     "groundBricks": 4,
+#     "mountainRock": 4,
+#     "mountainRockDark": 4,
+#     "riverMud": 4,
+#     "waterPuddle": 0,
+# }
+# endregion
+
+
+# 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,
+        ):
+            self.name = name
+            self.count = count
+            self.tags = tags
+            self.width = width
+            self.color = color if color else (255, 255, 255)
+
+        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),
+            }
+
+            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.
+            """
+            if self.name == "waterPuddle":
+                return os.path.join(weights_directory, "waterPuddle_weight.png")
+            return os.path.join(weights_directory, f"{self.name}01_weight.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 = os.path.join(self.map_directory, "maps", "map", "data")
+        self._bbox = ox.utils_geo.bbox_from_point(self.coordinates, dist=self.distance)
+        self.info_save_path = os.path.join(self.map_directory, "generation_info.json")
+
+    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 = ox.utils_geo.bbox_from_point(  # pylint: disable=W0632
+            self.coordinates, dist=self.distance, 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.distance * 2)
+        self.width_coef = self.width / (self.distance * 2)
+        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
+            - distance
+            - minimum_x
+            - minimum_y
+            - maximum_x
+            - maximum_y
+            - height
+            - width
+            - height_coef
+            - width_coef
+        """
+        useful_attributes = [
+            "coordinates",
+            "bbox",
+            "distance",
+            "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.name, layer.count)
+        self.logger.debug("Prepared weights for %s layers.", len(self.layers))
+
+    def _generate_weights(self, texture_name: str, layer_numbers: int) -> None:
+        """Generates weight files for textures. Each file is a numpy array of zeros and
+            dtype uint8 (0-255).
+
+        Args:
+            texture_name (str): Name of the texture.
+            layer_numbers (int): Number of layers in the texture.
+        """
+        size = self.distance * 2
+        postfix = "_weight.png"
+        if layer_numbers == 0:
+            filepaths = [os.path.join(self._weights_dir, texture_name + postfix)]
+        else:
+            filepaths = [
+                os.path.join(self._weights_dir, texture_name + str(i).zfill(2) + postfix)
+                for i in range(1, layer_numbers + 1)
+            ]
+
+        for filepath in filepaths:
+            img = np.zeros((size, 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:
+            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.
+        """
+        preview_size = (2048, 2048)
+        images = [
+            cv2.resize(
+                cv2.imread(layer.path(self._weights_dir), cv2.IMREAD_UNCHANGED), preview_size
+            )
+            for layer in self.layers
+        ]
+        colors = [layer.color for layer in self.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(
+            f"Merged layers into one image. Shape: {merged.shape}, dtype: {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.6.0.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.

maps4fs-0.6.0.dist-info/METADATA

@@ -0,0 +1,147 @@
+Metadata-Version: 2.1
+Name: maps4fs
+Version: 0.6.0
+Summary: Generate map templates for Farming Simulator from real places.
+Author-email: iwatkot <iwatkot@gmail.com>
+License: MIT License
+Project-URL: Homepage, https://github.com/iwatkot/maps4fs
+Project-URL: Repository, https://github.com/iwatkot/maps4fs
+Keywords: farmingsimulator,fs,farmingsimulator22,farmingsimulator25,fs22,fs25
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: requests>=2.0.0
+Requires-Dist: httpx>=0.20.0
+
+<div align="center" markdown>
+<img src="https://github.com/iwatkot/maps4fs/assets/118521851/ffd7f0a3-e317-4c3f-911f-2c2fb736fbfa">
+
+<p align="center">
+  <a href="#Quick-Start">Quick Start</a> •
+  <a href="#Overview">Overview</a> • 
+  <a href="#How-To-Run">How-To-Run</a> • 
+  <a href="#Features">Features</a> • 
+  <a href="#Supported-objects">Supported objects</a> • 
+  <a href="Settings">Settings</a> • 
+  <a href="#Bugs-and-feature-requests">Bugs and feature requests</a>
+</p>
+
+
+[![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/iwatkot/maps4fs)](https://github.com/iwatkot/maps4fs/releases)
+[![Docker Pulls](https://img.shields.io/docker/pulls/iwatkot/maps4fs)](https://hub.docker.com/repository/docker/iwatkot/maps4fs/general)
+[![GitHub issues](https://img.shields.io/github/issues/iwatkot/maps4fs)](https://github.com/iwatkot/maps4fs/issues)
+[![Maintainability](https://api.codeclimate.com/v1/badges/b922fd0a7188d37e61de/maintainability)](https://codeclimate.com/github/iwatkot/maps4fs/maintainability)<br>
+[![Checked with mypy](https://www.mypy-lang.org/static/mypy_badge.svg)](https://mypy-lang.org/)
+[![Build Status](https://github.com/iwatkot/maps4fs/actions/workflows/checks.yml/badge.svg)](https://github.com/iwatkot/maps4fs/actions)
+[![Test Coverage](https://api.codeclimate.com/v1/badges/b922fd0a7188d37e61de/test_coverage)](https://codeclimate.com/github/iwatkot/maps4fs/test_coverage)
+[![GitHub Repo stars](https://img.shields.io/github/stars/iwatkot/maps4fs)](https://github.com/iwatkot/maps4fs/stargazers)
+
+</div>
+
+### Supported Games
+
+✅ Farming Simulator 22<br>
+🔃 Farming Simulator 25 (changes in the library are ready, waiting for the Giants to release the Giants Editor v10)<br>
+
+## Quick Start
+For those, who don't want to read anything, here you go:<br>
+**Option 1:** launch the [@maps4fs](https://t.me/maps4fsbot) Telegram bot and generate a map template in a few clicks.<br>
+**Option 2:** run the Docker version in your browser. Launch the following command in your terminal:
+```bash
+docker run -d -p 8501:8501 iwatkot/maps4fs
+```
+And open [http://localhost:8501](http://localhost:8501) in your browser.<br>
+If you don't know how to use Docker, navigate to the [Docker version](#option-2-docker-version), it's really simple.<br>
+
+## Overview
+The core idea is coming from the awesome [maps4cim](https://github.com/klamann/maps4cim) project.<br>
+
+The main goal of this project is to generate map templates, based on real-world data, for the Farming Simulator. It's important to mention that **templates are not maps**. They are just a starting point for creating a map. This tool just uses built-in textures to highlight different types of terrain and buildings with correct shapes and scales and to generate a height map. The rest of the work is up to you. So if you thought that you could just run this tool and get a playable map, then I'm sorry to disappoint you. But if you are a map maker, then this tool will save you a lot of time.<br>
+So, if you're new to map making, here's a quick overview of the process:
+1. Generate a map template using this tool.
+2. Download the Giants Editor.
+3. Open the map template in the Giants Editor.
+4. Now you can start creating your map (adding roads, fields, buildings, etc.).
+
+## How-To-Run
+
+You'll find detailed instructions on how to run the project below. But if you prefer video tutorials, here's one for you:
+<a href="https://www.youtube.com/watch?v=ujwWKHVKsw8" target="_blank"><img src="https://github.com/user-attachments/assets/6dbbbc71-d04f-40b2-9fba-81e5e4857407"/></a>
+<i>Video tutorial: How to generate a Farming Simulator 22 map from real-world data.</i>
+
+### Option 1: Telegram bot
+**🗺️ Supported map sizes:** 2x2, 4x4 km.<br>
+🟢 Recommended for all users, you don't need to install anything.<br>
+Using Telegram bot [@maps4fs](https://t.me/maps4fsbot).<br>
+Note: due to CPU and RAM limitations of the hosting, only 2x2 and 4x4 km maps are available. If you need bigger maps, use the [Docker version](#option-2-docker-version).<br>
+
+![Telegram bot](https://github.com/iwatkot/maps4fs/assets/118521851/ede69fe8-1a34-4ede-908f-52c9dc355ae4)
+<br>
+
+Using it is easy and doesn't require any guides. Enjoy!
+
+### Option 2: Docker version
+**🗺️ Supported map sizes:** 2x2, 4x4, 8x8, 16x16 km.<br>
+🟢 Recommended for users who need bigger maps, very simple installation.<br>
+You can launch the project with minimalistic UI in your browser using Docker. Follow these steps:
+
+1. Install [Docker](https://docs.docker.com/get-docker/) for your OS.
+2. Run the following command in your terminal:
+```bash
+docker run -d -p 8501:8501 iwatkot/maps4fs
+```
+3. Open your browser and go to [http://localhost:8501](http://localhost:8501).
+4. Fill in the required fields and click on the `Generate` button.
+5. When the map is generated click on the `Download` button to get the map.
+
+![WebUI](https://github.com/user-attachments/assets/b80c458b-29ea-4790-a640-8fa3b5550610)
+
+## Settings
+Advanced settings are available in the tool's UI under the **Advanced Settings** tab. Here's the list of them:
+- `max_height` - the maximum height of the map. The default value is 400. Select smaller values for plain-like maps and bigger values for mountainous maps. You may need to experiment with this value to get the desired result.
+- `blur_seed` - the seed for the blur algorithm. The default value is 5, which means 5 meters. The bigger the value, the smoother the map will be. The smaller the value, the more detailed the map will be. Keep in mind that for some regions, where terrain is bumpy, disabling the blur algorithm may lead to a very rough map. So, I recommend leaving this value as it is.
+
+## Features
+- Allows to enter a location by lat and lon (e.g. from Google Maps).
+- Allows to select a size of the map (2x2, 4x4, 8x8 km, 16x16 km).
+- Generates a map template (check the list of supported objects in [this section](#supported-objects)).
+- Generates a height map.
+
+## Supported objects
+The project is based on the [OpenStreetMap](https://www.openstreetmap.org/) data. So, refer to [this page](https://wiki.openstreetmap.org/wiki/Map_Features) to understand the list below.
+- "building": True
+- "highway": ["motorway", "trunk", "primary"]
+- "highway": ["secondary", "tertiary", "road"]
+- "highway": ["unclassified", "residential", "track"]
+- "natural": "grassland"
+- "landuse": "farmland"
+- "natural": ["water"]
+- "waterway": True
+- "natural": ["wood", "tree_row"]
+
+The list will be updated as the project develops.
+
+## Info sequence
+The script will also generate the `generation_info.json` file in the `output` folder. It contains the following keys: <br>
+`"coordinates"` - the coordinates of the map center which you entered,<br>
+`"bbox"` - the bounding box of the map in lat and lon,<br>
+`"distance"` - the size of the map in meters,<br>
+`"minimum_x"` - the minimum x coordinate of the map (UTM projection),<br>
+`"minimum_y"` - the minimum y coordinate of the map (UTM projection),<br>
+`"maximum_x"` - the maximum x coordinate of the map (UTM projection),<br>
+`"maximum_y"` - the maximum y coordinate of the map (UTM projection),<br>
+`"height"` - the height of the map in meters (it won't be equal to the distance since the Earth is not flat, sorry flat-earthers),<br>
+`"width"` - the width of the map in meters,<br>
+`"height_coef"` - since we need a texture of exact size, the height of the map is multiplied by this coefficient,<br>
+`"width_coef"` - same as above but for the width,<br>
+`"tile_name"` - the name of the SRTM tile which was used to generate the height map, e.g. "N52E013"<br>
+
+You can use this information to adjust some other sources of data to the map, e.g. textures, height maps, etc.
+
+## Bugs and feature requests
+If you find a bug or have an idea for a new feature, please create an issue [here](https://github.com/iwatkot/maps4fs/issues) or contact me directly on [Telegram](https://t.me/iwatkot).<br>
+ℹ️ Please, don't bother me if the Telegram bot is down. As I said before this is related to the hosting limitations, if you want you can always run the tool locally or support the project by donating, so maybe I'll be able to afford better hosting.

maps4fs-0.6.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+maps4fs/__init__.py,sha256=da4jmND2Ths9AffnkAKgzLHNkvKFOc_l21gJisPXqWY,155
+maps4fs/logger.py,sha256=CneeHxQywjNUJXqQrUUSeiDxu95FfrfyK_Si1v0gMZ8,1477
+maps4fs/generator/__init__.py,sha256=zZMLEkGzb4z0xql650gOtGSvcgX58DnJ2yN3vC2daRk,43
+maps4fs/generator/component.py,sha256=UmR6Gbs-uDld7897q_9hOOzqBXaIYD8svmw_a3IgC5g,1761
+maps4fs/generator/config.py,sha256=3X9E6luYh0dBlYcGvE4Exzp-ShAMCFjGB_8SK3qPBtM,1760
+maps4fs/generator/dem.py,sha256=_1d_TPMOGBgl2-R_CRMbKumzxCbQyb-hcpqsElhYbQ4,8546
+maps4fs/generator/game.py,sha256=IyXjNEC5epJmDdqjsrl4wKL85T1F23km73pUkBiuDWU,4468
+maps4fs/generator/map.py,sha256=Y7ERUB6ivxJilDAjE9UD0-vl0SKtzj6J2f8QPXM6i48,3712
+maps4fs/generator/texture.py,sha256=BUDDYIASk7lhYhJpEjZUTccKUI1GIfJIcPRgIgiUHAE,17938
+maps4fs-0.6.0.dist-info/LICENSE.md,sha256=-JY0v7p3dwXze61EbYiK7YEJ2aKrjaFZ8y2xYEOrmRY,1068
+maps4fs-0.6.0.dist-info/METADATA,sha256=4C_CBjobE8SIELoDlqjpcXEMMWZIMbf9YmM_VyBEp-Y,8937
+maps4fs-0.6.0.dist-info/WHEEL,sha256=a7TGlA-5DaHMRrarXjVbQagU3Man_dCnGIWMJr5kRWo,91
+maps4fs-0.6.0.dist-info/top_level.txt,sha256=Ue9DSRlejRQRCaJueB0uLcKrWwsEq9zezfv5dI5mV1M,8
+maps4fs-0.6.0.dist-info/RECORD,,

maps4fs-0.6.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.4.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

maps4fs-0.6.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+maps4fs