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

maps4fs/generator/background.py

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

maps4fs/generator/component.py

@@ -2,6 +2,9 @@
 
 from __future__ import annotations
 
+import json
+import os
+from copy import deepcopy
 from typing import TYPE_CHECKING, Any
 
 import osmnx as ox  # type: ignore
@@ -42,6 +45,8 @@ class Component:
         self.logger = logger
         self.kwargs = kwargs
 
+        os.makedirs(self.previews_directory, exist_ok=True)
+
         self.save_bbox()
         self.preprocess()
 
@@ -69,6 +74,66 @@ class Component:
         """
         raise NotImplementedError
 
+    @property
+    def previews_directory(self) -> str:
+        """The directory where the preview images are stored.
+
+        Returns:
+            str: The directory where the preview images are stored.
+        """
+        return os.path.join(self.map_directory, "previews")
+
+    @property
+    def generation_info_path(self) -> str:
+        """The path to the generation info JSON file.
+
+        Returns:
+            str: The path to the generation info JSON file.
+        """
+        return os.path.join(self.map_directory, "generation_info.json")
+
+    def info_sequence(self) -> dict[Any, Any]:
+        """Returns the information sequence for the component. Must be implemented in the child
+        class. If the component does not have an information sequence, an empty dictionary must be
+        returned.
+
+        Returns:
+            dict[Any, Any]: The information sequence for the component.
+        """
+        return {}
+
+    def commit_generation_info(self) -> None:
+        """Commits the generation info to the generation info JSON file."""
+        self.update_generation_info(self.info_sequence())
+
+    def update_generation_info(self, data: dict[Any, Any]) -> None:
+        """Updates the generation info with the provided data.
+        If the generation info file does not exist, it will be created.
+
+        Args:
+            data (dict[Any, Any]): The data to update the generation info with.
+        """
+        if os.path.isfile(self.generation_info_path):
+            with open(self.generation_info_path, "r", encoding="utf-8") as file:
+                generation_info = json.load(file)
+                self.logger.debug("Loaded generation info from %s", self.generation_info_path)
+        else:
+            self.logger.debug(
+                "Generation info file does not exist, creating a new one in %s",
+                self.generation_info_path,
+            )
+            generation_info = {}
+
+        updated_generation_info = deepcopy(generation_info)
+        updated_generation_info[self.__class__.__name__] = data
+
+        self.logger.debug("Updated generation info, now contains %s fields", len(data))
+
+        with open(self.generation_info_path, "w", encoding="utf-8") as file:
+            json.dump(updated_generation_info, file, indent=4)
+
+        self.logger.debug("Saved updated generation info to %s", self.generation_info_path)
+
     def get_bbox(self, project_utm: bool = False) -> tuple[int, int, int, int]:
         """Calculates the bounding box of the map from the coordinates and the height and
         width of the map.

maps4fs/generator/dem.py

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

maps4fs/generator/game.py

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

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
@@ -58,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
@@ -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

{maps4fs-0.8.2.dist-info → maps4fs-0.8.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: maps4fs
-Version: 0.8.2
+Version: 0.8.3
 Summary: Generate map templates for Farming Simulator from real places.
 Author-email: iwatkot <iwatkot@gmail.com>
 License: MIT License
@@ -16,8 +16,9 @@ License-File: LICENSE.md
 Requires-Dist: opencv-python
 Requires-Dist: osmnx<2.0.0
 Requires-Dist: rasterio
-Requires-Dist: tqdm
 Requires-Dist: folium
+Requires-Dist: geopy
+Requires-Dist: trimesh
 
 <div align="center" markdown>
 <img src="https://github.com/iwatkot/maps4fs/assets/118521851/ffd7f0a3-e317-4c3f-911f-2c2fb736fbfa">
@@ -25,9 +26,13 @@ Requires-Dist: folium
 <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="#Supported-objects">Supported objects</a> • 
-  <a href="#For-advanced-users">For advanced users</a> • 
+  <a href="#How-To-Run">How-To-Run</a><br>
+  <a href="#Supported-objects">Supported objects</a> •
+  <a href="#Generation-info">Generation info</a> •
+  <a href="#Texture-schema">Texture schema</a> •
+  <a href="Background-terrain">Background terrain</a><br>
+  <a href="#For-advanced-users">For advanced users</a> •
+  <a jref="#Resources">Resources</a> •
   <a href="#Bugs-and-feature-requests">Bugs and feature requests</a>
 </p>
 
@@ -37,6 +42,7 @@ Requires-Dist: folium
 [![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>
+[![PyPI - Downloads](https://img.shields.io/pypi/dm/maps4fs)](https://pypi.org/project/maps4fs)
 [![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)
@@ -49,6 +55,8 @@ Requires-Dist: folium
 🏞️ Generates height using SRTM dataset<br>
 📦 Provides a ready-to-use map template for the Giants Editor<br>
 🚜 Supports Farming Simulator 22 and 25<br>
+🔷 Generates *.obj files for background terrain based on the real-world height map 🆕<br>
+📄 Generates commands to obtain high-resolution satellite images from [QGIS](https://qgis.org/download/) 🆕<br>
 
 ## Quick Start
 There are several ways to use the tool. You obviously need the **first one**, but you can choose any of the others depending on your needs.<br>
@@ -120,7 +128,7 @@ docker run -d -p 8501:8501 iwatkot/maps4fs
 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/581e1206-2abd-4b3c-ad31-80554ad92d99)
+![Basic WebUI](https://github.com/user-attachments/assets/14620044-9e92-47ae-8531-d61460740f58)
 
 ### Option 3: Python package
 🔴 Recommended for developers.<br>
@@ -161,8 +169,10 @@ map = mfs.Map(
 ```
 
 4. Generate the map:
+The `generate` method returns a generator, which yields the active component of the map. You can use it to track the progress of the generation process.
 ```python
-map.generate()
+for active_component in map.generate():
+    print(active_component)
 ```
 
 The map will be saved in the `map_directory` directory.
@@ -182,30 +192,157 @@ The project is based on the [OpenStreetMap](https://www.openstreetmap.org/) data
 
 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>
-`"map_height"` - the height of the map in meters (this one is from the user input, e.g. 2048 and so on),<br>
-`"map_width"` - the width of the map in meters (same as above),<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 parameters above since the Earth is not flat, sorry flat-earthers),<br>
-`"width"` - the width of the map in meters (same as above),<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.
+## Generation info
+The script will generate the `generation_info.json` file in the `output` folder. It splitted to the different sections, which represents the components of the map generator. You may need this information to use some other tools and services to obtain additional data for your map.<br>
+
+List of components:
+- `Config` - this component handles the `map.xml` file, where the basic description of the map is stored.
+- `Texture` -  this component describes the textures, that were used to generate the map.
+- `DEM` - this component describes the Digital Elevation Model (the one which creates terrain on your map), which was used to generate the height map and related to the `dem.png` file.
+- `I3d` - this component describes the i3d file, where some specific attributes properties and path to the files are stored.
+- `Background` - this component describes the 8 tiles, that surround the map.
+
+Below you'll find descriptions of the components and the fields that they contain.<br>
+ℹ️ If there's no information about the component, it means that at the moment it does not store any data in the `generation_info.json` file.
+
+### Texture
+
+Example of the `Texture` component:
+```json
+"Texture": {
+    "coordinates": [
+        45.28571409289627,
+        20.237433441210115
+    ],
+    "bbox": [
+        45.29492313313172,
+        45.27650505266082,
+        20.250522423471406,
+        20.224344458948824
+    ],
+    "map_height": 2048,
+    "map_width": 2048,
+    "minimum_x": 439161.2439774908,
+    "minimum_y": 5013940.540089059,
+    "maximum_x": 441233.5397821935,
+    "maximum_y": 5016006.074349126,
+    "height": 2065.5342600671574,
+    "width": 2072.295804702677,
+    "height_coef": 1.0085616504234167,
+    "width_coef": 1.011863185889979
+},
+```
+
+And here's the list of the fields:
+
+- `"coordinates"` - the coordinates of the map center which you entered,<br>
+- `"bbox"` - the bounding box of the map in lat and lon,<br>
+- `"map_height"` - the height of the map in meters (this one is from the user input, e.g. 2048 and so on),<br>
+- `"map_width"` - the width of the map in meters (same as above),<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 parameters above since the Earth is not flat, sorry flat-earthers),<br>
+- `"width"` - the width of the map in meters (same as above),<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>
+
+### Background
+
+The background component consist of the 8 tiles, each one represents the tile, that surrounds the map. The tiles are named as the cardinal points, e.g. "N", "NE", "E" and so on.<br>
+Example of the `Background` component:
+
+```json
+"Background": {
+"N": {
+    "center_latitude": 45.30414170952092,
+    "center_longitude": 20.237433441210115,
+    "epsg3857_string": "2251363.25324853,2254278.318028022,5668072.719985372,5670987.784803056 [EPSG:3857]",
+    "height": 2048,
+    "width": 2048,
+    "north": 45.31335074975637,
+    "south": 45.29493266928547,
+    "east": 20.250526677438195,
+    "west": 20.224340204982035
+},
+}
+```
+
+And here's the list of the fields:
+- `"center_latitude"` - the latitude of the center of the tile,<br>
+- `"center_longitude"` - the longitude of the center of the tile,<br>
+- `"epsg3857_string"` - the string representation of the bounding box in the EPSG:3857 projection, it's required to obtain the satellite images in the QGIS,<br>
+- `"height"` - the height of the tile in meters,<br>
+- `"width"` - the width of the tile in meters,<br>
+- `"north"` - the northern border of the tile,<br>
+- `"south"` - the southern border of the tile,<br>
+- `"east"` - the eastern border of the tile,<br>
+- `"west"` - the western border of the tile,<br>
+
+## Texture schema
+maps4fs uses a simple JSON file to define the texture schema. For each of supported games this file has unique entries, but the structure is the same. Here's an example of the schema for Farming Simulator 25:
+
+```json
+[
+    {
+    "name": "forestRockRoots",
+    "count": 2,
+    "exclude_weight": true
+  },
+  {
+    "name": "grass",
+    "count": 2,
+    "tags": { "natural": "grassland" },
+    "color": [34, 255, 34],
+    "priority": 0
+  },
+  {
+    "name": "grassClovers",
+    "count": 2
+  },
+  {
+    "name": "grassCut",
+    "count": 2
+  },
+  {
+    "name": "grassDirtPatchy",
+    "count": 2,
+    "tags": { "natural": ["wood", "tree_row"] },
+    "width": 2,
+    "color": [0, 252, 124]
+  }
+]
+```
+Let's have a closer look at the fields:
+- `name` - the name of the texture. Just the way the file will be named.
+- `count` - the number of textures of this type. For example, for the **dirtMedium** texture there will be two textures: **dirtMedium01_weight.png** and **dirtMedium02_weight.png**.
+ℹ️ There's one texture that have count `0`, it's the waterPuddle texture from FS22, which not present in FS25.
+- `tags` - the tags from the OpenStreetMap data. Refer to the section [Supported objects](#supported-objects) to see the list of supported tags. If there are no tags, the texture file will be generated empty and no objects will be placed on it.
+- `width` - the width of the texture in meters. Some of the objects from OSM (roads, for example) are lines, not areas. So, to draw them correctly, the tool needs to know the width of the line.
+- `color` - the color of the texture. It's used only in the preview images and have no effect on the map itself. But remember that previews are crucial for the map making process, so it's better to set the color to something that represents the texture.
+- `priority` - the priority of the texture for overlapping. Textures with higher priorities will be drawn over the textures with lower priorities.
+ℹ️ The texture with 0 priority considers the base layer, which means that all empty areas will be filled with this texture.
+- `exclude_weight` - this only used for the forestRockRoots texture from FS25. It's just means that this texture has no `weight` postfix, that's all.
+
+## Background terrain
+The tool now supports the generation of the background terrain. If you don't know what it is, here's a brief explanation. The background terrain is the world around the map. It's important to create it, because if you don't, the map will look like it's floating in the void. The background terrain is a simple plane which can (and should) be texture to look fine.<br>
+So, the tool generates the background terrain in the form of the 8 tiles, which surround the map. The tiles are named as the cardinal points, e.g. "N", "NE", "E" and so on. All those tiles will be saved in the `objects/tiles` directory with corresponding names: `N.obj`, `NE.obj`, `E.obj` and so on.<br>
+If you're willing to create a background terrain, you will need: Blender, the Blender Exporter Plugins and the QGIS. You'll find the download links in the [Resources](#resources) section.<br>
+
+If you're afraid of this task, please don't be. It's really simple and I've prepaired detailed step-by-step instructions for you, you'll find them in the separate README files. Here are the steps you need to follow:
+
+1. [Download high-resolution satellite images](README_satellite_images.md).
+2. [Prepare the i3d files](README_i3d.md).
+3. [Import the i3d files to Giants Editor](README_giants_editor.md).
 
 ## For advanced users
 The tool supports the custom size of the map. To use this feature select `Custom` in the `Map size` dropdown and enter the desired size. The tool will generate a map with the size you entered.<br>
 
 ⛔️ Do not use this feature, if you don't know what you're doing. In most cases the Giants Editor will just crash on opening the file, because you need to enter a specific values for the map size.<br><br>
 
-![Advanced settings and custom size](https://github.com/user-attachments/assets/327b6065-09ed-41d0-86a8-7d904025707c)
+![Advanced settings](https://github.com/user-attachments/assets/0446cdf2-f093-49ba-ba8f-9bef18a58b47)
 
 You can also apply some advanced settings to the map generation process. Note that they're ADVANCED, so you don't need to use them if you're not sure what they do.<br>
 
@@ -215,5 +352,14 @@ Here's the list of the advanced settings:
 
 - DEM Blur radius: the radius of the Gaussian blur filter applied to the DEM map. By default, it's set to 21. This filter just makes the DEM map smoother, so the height transitions will be more natural. You can set it to 1 to disable the filter, but it will result as a Minecraft-like map.
 
+## Resources
+In this section you'll find a list of the resources that you need to create a map for the Farming Simulator.<br>
+To create a basic map, you only need the Giants Editor. But if you want to create a background terrain - the world around the map, so it won't look like it's floating in the void - you also need Blender and the Blender Exporter Plugins. To create realistic textures for the background terrain, the QGIS is required to obtain high-resolution satellite images.<br>
+
+1. [Giants Editor](https://gdn.giants-software.com/downloads.php) - the official tool for creating maps for the Farming Simulator.
+2. [Blender](https://www.blender.org/download/) - the open-source 3D modeling software that you can use to create models for the Farming Simulator.
+3. [Blender Exporter Plugins](https://gdn.giants-software.com/downloads.php) - the official plugins for exporting models from Blender to i3d format (the format used in the Farming Simulator).
+4. [QGIS](https://qgis.org/download/) - the open-source GIS software that you can use to obtain high-resolution satellite images for your map.
+
 ## 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>

maps4fs-0.8.3.dist-info/RECORD

@@ -0,0 +1,18 @@
+maps4fs/__init__.py,sha256=da4jmND2Ths9AffnkAKgzLHNkvKFOc_l21gJisPXqWY,155
+maps4fs/logger.py,sha256=CneeHxQywjNUJXqQrUUSeiDxu95FfrfyK_Si1v0gMZ8,1477
+maps4fs/generator/__init__.py,sha256=zZMLEkGzb4z0xql650gOtGSvcgX58DnJ2yN3vC2daRk,43
+maps4fs/generator/background.py,sha256=KsErhYERWXzMedGLg1H7wO94OXyaqw_XQYnotKNTStE,11267
+maps4fs/generator/component.py,sha256=w5hUttO8m5bXcujLxB0pZjf25hxMnMPP4yPikQyoOkQ,6010
+maps4fs/generator/config.py,sha256=ln_XGUdiPnc4zzhMVEueZRf-FGljeHtCHUnJ6FRlE4w,2264
+maps4fs/generator/dem.py,sha256=FsYcaf0IQSYykKdbkHxAN5-Rc_PZZEBJfdZA2Z-b8AU,14514
+maps4fs/generator/game.py,sha256=yry1tJYQi-tNLHlEY85Vz71KN_o2PVjxrAc4HDNB_Sg,6837
+maps4fs/generator/i3d.py,sha256=UuQiQRusPQ2f6PvGKxJ_UZeXsx3uG15efmy8Ysnm3F8,3597
+maps4fs/generator/map.py,sha256=2MXOIQxj7mDxhp76uh7EXqLP-v3T4TbiKQdx6my7GFc,4290
+maps4fs/generator/path_steps.py,sha256=rKslIiG9mriCVL9_0i8Oet2p0DITrpBWi0pECpvuyUM,2707
+maps4fs/generator/texture.py,sha256=0gkohGmamZbmqc9VpPqt8pli_x9w9SnUh2JjYGaiI3I,18170
+maps4fs/generator/tile.py,sha256=3vmfjQiPiiUZKPuIo5tg2rOKkgcP1NRVkMGK-Vo10-A,2138
+maps4fs-0.8.3.dist-info/LICENSE.md,sha256=-JY0v7p3dwXze61EbYiK7YEJ2aKrjaFZ8y2xYEOrmRY,1068
+maps4fs-0.8.3.dist-info/METADATA,sha256=UbKREWFL9CnOpTHk1I76Q-4S5DEGOGbWoNro-qREB9c,20081
+maps4fs-0.8.3.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+maps4fs-0.8.3.dist-info/top_level.txt,sha256=Ue9DSRlejRQRCaJueB0uLcKrWwsEq9zezfv5dI5mV1M,8
+maps4fs-0.8.3.dist-info/RECORD,,

maps4fs-0.8.2.dist-info/RECORD

@@ -1,15 +0,0 @@
-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=CL3DNuvKAd44pynLfir_JLnBC0c9Kr233_BbSHQng6Q,3534
-maps4fs/generator/config.py,sha256=ln_XGUdiPnc4zzhMVEueZRf-FGljeHtCHUnJ6FRlE4w,2264
-maps4fs/generator/dem.py,sha256=L91hOxoXnn2LtpaH7fVA6Ke2i7JNfFk_KGMsVWHVNps,13169
-maps4fs/generator/game.py,sha256=mN9VeN4nk-e43oFujIC5GOGAQOYATKrmeIb1kLHuwtI,6773
-maps4fs/generator/i3d.py,sha256=UuQiQRusPQ2f6PvGKxJ_UZeXsx3uG15efmy8Ysnm3F8,3597
-maps4fs/generator/map.py,sha256=xYbSyGrcEB9CRJhVf8iTRCKLK6BvnewtlKO_Ut--Oik,3858
-maps4fs/generator/texture.py,sha256=uH09vnYSTklv2VxV6ys0DM_f8KXHmxQr9l6flwVguLU,18726
-maps4fs-0.8.2.dist-info/LICENSE.md,sha256=-JY0v7p3dwXze61EbYiK7YEJ2aKrjaFZ8y2xYEOrmRY,1068
-maps4fs-0.8.2.dist-info/METADATA,sha256=Ombva3jSyqSsTuzspfzp24DESv1G8lqRWLTuTN0L81w,11866
-maps4fs-0.8.2.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-maps4fs-0.8.2.dist-info/top_level.txt,sha256=Ue9DSRlejRQRCaJueB0uLcKrWwsEq9zezfv5dI5mV1M,8
-maps4fs-0.8.2.dist-info/RECORD,,