maps4fs 0.9.98__py3-none-any.whl → 1.0.3__py3-none-any.whl

maps4fs/generator/background.py

@@ -15,7 +15,7 @@ from maps4fs.generator.dem import (
     DEFAULT_MULTIPLIER,
     DEFAULT_PLATEAU,
 )
-from maps4fs.generator.path_steps import DEFAULT_DISTANCE, PATH_FULL_NAME, get_steps
+from maps4fs.generator.path_steps import PATH_FULL_NAME, get_steps
 from maps4fs.generator.tile import Tile
 
 RESIZE_FACTOR = 1 / 4
@@ -143,7 +143,7 @@ class Background(Component):
                 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)
+            self.logger.debug("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")
@@ -164,7 +164,6 @@ class Background(Component):
         if tile_code == PATH_FULL_NAME:
             resize_factor = FULL_RESIZE_FACTOR
             simplify_factor = FULL_SIMPLIFY_FACTOR
-            self.logger.info("Generating a full map obj file")
         else:
             resize_factor = RESIZE_FACTOR
             simplify_factor = SIMPLIFY_FACTOR
@@ -242,119 +241,21 @@ class Background(Component):
 
         self.stl_preview_path = preview_path  # pylint: disable=attribute-defined-outside-init
 
+    # pylint: disable=no-member
     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 the path to the image of full tile and the path to the STL preview file.
 
         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
-            if tile.code == PATH_FULL_NAME:
-                continue
-            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
+            list[str] -- A list of paths to the previews.
+        """
+        full_tile = next((tile for tile in self.tiles if tile.code == PATH_FULL_NAME), None)
+        if full_tile:
+            preview_path = os.path.join(self.previews_directory, "background_dem.png")
+            full_tile_image = cv2.imread(full_tile.dem_path, cv2.IMREAD_UNCHANGED)
+            full_tile_image = cv2.normalize(  # type: ignore
+                full_tile_image, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U
             )
-
-            # 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, self.stl_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)
+            full_tile_image = cv2.cvtColor(full_tile_image, cv2.COLOR_GRAY2BGR)
+            cv2.imwrite(preview_path, full_tile_image)
+            return [preview_path, self.stl_preview_path]
+        return [self.stl_preview_path]

maps4fs/generator/component.py

@@ -50,6 +50,7 @@ class Component:
 
         os.makedirs(self.previews_directory, exist_ok=True)
         os.makedirs(self.scripts_directory, exist_ok=True)
+        os.makedirs(self.info_layers_directory, exist_ok=True)
 
         self.save_bbox()
         self.preprocess()
@@ -87,6 +88,15 @@ class Component:
         """
         return os.path.join(self.map_directory, "previews")
 
+    @property
+    def info_layers_directory(self) -> str:
+        """The directory where the info layers are stored.
+
+        Returns:
+            str: The directory where the info layers are stored.
+        """
+        return os.path.join(self.map_directory, "info_layers")
+
     @property
     def scripts_directory(self) -> str:
         """The directory where the scripts are stored.
@@ -174,10 +184,10 @@ class Component:
         height_distance = height_distance or int(self.map_height / 2)
         width_distance = width_distance or int(self.map_width / 2)
 
-        north, south, _, _ = ox.utils_geo.bbox_from_point(
+        west, south, _, _ = ox.utils_geo.bbox_from_point(  # type: ignore
             coordinates, dist=height_distance, project_utm=project_utm
         )
-        _, _, east, west = ox.utils_geo.bbox_from_point(
+        _, _, east, north = ox.utils_geo.bbox_from_point(  # type: ignore
             coordinates, dist=width_distance, project_utm=project_utm
         )
         bbox = north, south, east, west

maps4fs/generator/config.py

@@ -36,7 +36,7 @@ class Config(Component):
             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)
+        self.logger.info("Map XML file loaded from: %s.", self._map_xml_path)
         root = tree.getroot()
         for map_elem in root.iter("map"):
             map_elem.set("width", str(self.map_width))

maps4fs/generator/dem.py

@@ -103,7 +103,7 @@ class DEM(Component):
         north, south, east, west = self.bbox
 
         dem_output_resolution = self.get_output_resolution()
-        self.logger.debug("DEM output resolution: %s.", dem_output_resolution)
+        self.logger.info("DEM output resolution: %s.", dem_output_resolution)
 
         tile_path = self._srtm_tile()
         if not tile_path:
@@ -223,7 +223,7 @@ class DEM(Component):
             )
 
         cv2.imwrite(self._dem_path, resampled_data)
-        self.logger.debug("DEM data was saved to %s.", self._dem_path)
+        self.logger.info("DEM data was saved to %s.", self._dem_path)
 
         if self.game.additional_dem_name is not None:
             self.make_copy(self.game.additional_dem_name)
@@ -239,7 +239,7 @@ class DEM(Component):
         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)
+        self.logger.info("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.
@@ -260,7 +260,7 @@ class DEM(Component):
         else:
             tile_name = f"{latitude_band}E{abs(tile_longitude):03d}"
 
-        self.logger.debug(
+        self.logger.info(
             "Detected tile name: %s for coordinates: lat %s, lon %s.", tile_name, lat, lon
         )
         return latitude_band, tile_name
@@ -319,7 +319,7 @@ class DEM(Component):
     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
+        cv2.imwrite(self._dem_path, dem_data)
         self.logger.warning("DEM data filled with zeros and saved to %s.", self._dem_path)
 
     def grayscale_preview(self) -> str:
@@ -329,7 +329,6 @@ class DEM(Component):
         Returns:
             str: Path to the preview image.
         """
-        # 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.", grayscale_dem_path)
@@ -346,8 +345,6 @@ class DEM(Component):
         Returns:
             list[str]: List with a single path to the DEM file
         """
-
-        # 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)
@@ -424,14 +421,18 @@ class DEM(Component):
 
         scaling_factor = self._get_scaling_factor(max_dev)
         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}."
+        self.logger.info(
+            "Maximum deviation: %s. Scaling factor: %s. Adjusted max height: %s.",
+            max_dev,
+            scaling_factor,
+            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()}."
+            "DEM data was normalized to %s - %s.",
+            normalized_data.min(),
+            normalized_data.max(),
         )
         return normalized_data

maps4fs/generator/game.py

@@ -38,7 +38,8 @@ class Game:
     _texture_schema: str | None = None
     _grle_schema: str | None = None
 
-    components = [Config, Texture, GRLE, DEM, I3d, Background]
+    # Order matters! Some components depend on others.
+    components = [Texture, I3d, DEM, Config, GRLE, Background]
 
     def __init__(self, map_template_path: str | None = None):
         if map_template_path:

maps4fs/generator/grle.py

@@ -61,7 +61,7 @@ class GRLE(Component):
                 info_layer_data = np.zeros((height, width), dtype=data_type)
                 print(info_layer_data.shape)
                 cv2.imwrite(file_path, info_layer_data)  # pylint: disable=no-member
-                self.logger.info("InfoLayer PNG file %s created.", file_path)
+                self.logger.debug("InfoLayer PNG file %s created.", file_path)
             else:
                 self.logger.warning("Invalid InfoLayer schema: %s.", info_layer)
 

maps4fs/generator/i3d.py

@@ -2,14 +2,18 @@
 
 from __future__ import annotations
 
+import json
 import os
 from xml.etree import ElementTree as ET
 
+from shapely.geometry import Polygon, box  # type: ignore
+
 from maps4fs.generator.component import Component
 
 DEFAULT_HEIGHT_SCALE = 2000
 DEFAULT_MAX_LOD_DISTANCE = 10000
 DEFAULT_MAX_LOD_OCCLUDER_DISTANCE = 10000
+NODE_ID_STARTING_VALUE = 500
 
 
 # pylint: disable=R0903
@@ -40,17 +44,25 @@ class I3d(Component):
     def process(self) -> None:
         """Updates the map I3D file with the default settings."""
         self._update_i3d_file()
+        self._add_fields()
 
-    def _update_i3d_file(self) -> None:
-        """Updates the map I3D file with the default settings."""
+    def _get_tree(self) -> ET.ElementTree | None:
+        """Returns the ElementTree instance of the map I3D file."""
         if not self._map_i3d_path:
             self.logger.info("I3D is not obtained, skipping the update.")
-            return
+            return None
         if not os.path.isfile(self._map_i3d_path):
             self.logger.warning("I3D file not found: %s.", self._map_i3d_path)
-            return
+            return None
 
-        tree = ET.parse(self._map_i3d_path)
+        return ET.parse(self._map_i3d_path)
+
+    def _update_i3d_file(self) -> None:
+        """Updates the map I3D file with the default settings."""
+
+        tree = self._get_tree()
+        if tree is None:
+            return
 
         self.logger.debug("Map I3D file loaded from: %s.", self._map_i3d_path)
 
@@ -76,8 +88,8 @@ class I3d(Component):
 
                 self.logger.debug("TerrainTransformGroup element updated in I3D file.")
 
-        tree.write(self._map_i3d_path)
-        self.logger.debug("Map I3D file saved to: %s.", self._map_i3d_path)
+        tree.write(self._map_i3d_path)  # type: ignore
+        self.logger.info("Map I3D file saved to: %s.", self._map_i3d_path)
 
     def previews(self) -> list[str]:
         """Returns a list of paths to the preview images (empty list).
@@ -87,3 +99,260 @@ class I3d(Component):
             list[str]: An empty list.
         """
         return []
+
+    # pylint: disable=R0914, R0915
+    def _add_fields(self) -> None:
+        """Adds fields to the map I3D file."""
+        tree = self._get_tree()
+        if tree is None:
+            return
+
+        textures_info_layer_path = os.path.join(self.info_layers_directory, "textures.json")
+        if not os.path.isfile(textures_info_layer_path):
+            self.logger.warning("Textures info layer not found: %s.", textures_info_layer_path)
+            return
+
+        with open(textures_info_layer_path, "r", encoding="utf-8") as textures_info_layer_file:
+            textures_info_layer = json.load(textures_info_layer_file)
+
+        fields: list[tuple[int, int]] | None = textures_info_layer.get("fields")
+        if not fields:
+            self.logger.warning("Fields data not found in textures info layer.")
+            return
+
+        self.logger.info("Found %s fields in textures info layer.", len(fields))
+
+        root = tree.getroot()
+        gameplay_node = root.find(".//TransformGroup[@name='gameplay']")
+        if gameplay_node is not None:
+            fields_node = gameplay_node.find(".//TransformGroup[@name='fields']")
+            user_attributes_node = root.find(".//UserAttributes")
+
+            if fields_node is not None:
+                node_id = NODE_ID_STARTING_VALUE
+
+                for field_id, field in enumerate(fields, start=1):
+                    # Convert the top-left coordinates to the center coordinates system.
+                    try:
+                        fitted_field = self.fit_polygon_into_bounds(field)  # type: ignore
+                    except ValueError as e:
+                        self.logger.warning(
+                            "Field %s could not be fitted into the map bounds.", field_id
+                        )
+                        self.logger.debug("Error: %s", e)
+                        continue
+                    field_ccs = [
+                        self.top_left_coordinates_to_center(point) for point in fitted_field
+                    ]
+
+                    # Creating the main field node.
+                    field_node = ET.Element("TransformGroup")
+                    field_node.set("name", f"field{field_id}")
+                    cx, cy = self.get_polygon_center(field_ccs)
+                    field_node.set("translation", f"{cx} 0 {cy}")
+                    field_node.set("nodeId", str(node_id))
+
+                    # Adding UserAttributes to the field node.
+                    user_attribute_node = self.create_user_attribute_node(node_id)
+                    user_attributes_node.append(user_attribute_node)  # type: ignore
+
+                    node_id += 1
+
+                    # Creating the polygon points node, which contains the points of the field.
+                    polygon_points_node = ET.Element("TransformGroup")
+                    polygon_points_node.set("name", "polygonPoints")
+                    polygon_points_node.set("nodeId", str(node_id))
+                    node_id += 1
+
+                    for point_id, point in enumerate(field_ccs, start=1):
+                        rx, ry = self.absolute_to_relative(point, (cx, cy))
+
+                        node_id += 1
+                        point_node = ET.Element("TransformGroup")
+                        point_node.set("name", f"point{point_id}")
+                        point_node.set("translation", f"{rx} 0 {ry}")
+                        point_node.set("nodeId", str(node_id))
+
+                        polygon_points_node.append(point_node)
+
+                    field_node.append(polygon_points_node)
+
+                    # Adding the name indicator node to the field node.
+                    name_indicator_node, node_id = self.get_name_indicator_node(node_id, field_id)
+                    field_node.append(name_indicator_node)
+
+                    # Adding the teleport indicator node to the field node.
+                    teleport_indicator_node, node_id = self.get_teleport_indicator_node(node_id)
+                    field_node.append(teleport_indicator_node)
+
+                    # Adding the field node to the fields node.
+                    fields_node.append(field_node)
+                    self.logger.debug("Field %s added to the I3D file.", field_id)
+
+                    node_id += 1
+
+            tree.write(self._map_i3d_path)  # type: ignore
+            self.logger.info("Map I3D file saved to: %s.", self._map_i3d_path)
+
+    def get_name_indicator_node(self, node_id: int, field_id: int) -> tuple[ET.Element, int]:
+        """Creates a name indicator node with given node ID and field ID.
+
+        Arguments:
+            node_id (int): The node ID of the name indicator node.
+            field_id (int): The ID of the field.
+
+        Returns:
+            tuple[ET.Element, int]: The name indicator node and the updated node ID.
+        """
+        node_id += 1
+        name_indicator_node = ET.Element("TransformGroup")
+        name_indicator_node.set("name", "nameIndicator")
+        name_indicator_node.set("nodeId", str(node_id))
+
+        node_id += 1
+        note_node = ET.Element("Note")
+        note_node.set("name", "Note")
+        note_node.set("nodeId", str(node_id))
+        note_node.set("text", f"field{field_id}
0.00 ha")
+        note_node.set("color", "4278190080")
+        note_node.set("fixedSize", "true")
+
+        name_indicator_node.append(note_node)
+
+        return name_indicator_node, node_id
+
+    def get_teleport_indicator_node(self, node_id: int) -> tuple[ET.Element, int]:
+        """Creates a teleport indicator node with given node ID.
+
+        Arguments:
+            node_id (int): The node ID of the teleport indicator node.
+
+        Returns:
+            tuple[ET.Element, int]: The teleport indicator node and the updated node ID.
+        """
+        node_id += 1
+        teleport_indicator_node = ET.Element("TransformGroup")
+        teleport_indicator_node.set("name", "teleportIndicator")
+        teleport_indicator_node.set("nodeId", str(node_id))
+
+        return teleport_indicator_node, node_id
+
+    def get_polygon_center(self, polygon_points: list[tuple[int, int]]) -> tuple[int, int]:
+        """Calculates the center of a polygon defined by a list of points.
+
+        Arguments:
+            polygon_points (list[tuple[int, int]]): The points of the polygon.
+
+        Returns:
+            tuple[int, int]: The center of the polygon.
+        """
+        polygon = Polygon(polygon_points)
+        center = polygon.centroid
+        return int(center.x), int(center.y)
+
+    def absolute_to_relative(
+        self, point: tuple[int, int], center: tuple[int, int]
+    ) -> tuple[int, int]:
+        """Converts a pair of absolute coordinates to relative coordinates.
+
+        Arguments:
+            point (tuple[int, int]): The absolute coordinates.
+            center (tuple[int, int]): The center coordinates.
+
+        Returns:
+            tuple[int, int]: The relative coordinates.
+        """
+        cx, cy = center
+        x, y = point
+        return x - cx, y - cy
+
+    def top_left_coordinates_to_center(self, top_left: tuple[int, int]) -> tuple[int, int]:
+        """Converts a pair of coordinates from the top-left system to the center system.
+        In top-left system, the origin (0, 0) is in the top-left corner of the map, while in the
+        center system, the origin is in the center of the map.
+
+        Arguments:
+            top_left (tuple[int, int]): The coordinates in the top-left system.
+
+        Returns:
+            tuple[int, int]: The coordinates in the center system.
+        """
+        x, y = top_left
+        cs_x = x - self.map_width // 2
+        cs_y = y - self.map_height // 2
+
+        return cs_x, cs_y
+
+    def fit_polygon_into_bounds(
+        self, polygon_points: list[tuple[int, int]]
+    ) -> list[tuple[int, int]]:
+        """Fits a polygon into the bounds of the map.
+
+        Arguments:
+            polygon_points (list[tuple[int, int]]): The points of the polygon.
+
+        Returns:
+            list[tuple[int, int]]: The points of the polygon fitted into the map bounds.
+        """
+        min_x = min_y = 0
+        max_x, max_y = self.map_width, self.map_height
+
+        # Create a polygon from the given points
+        polygon = Polygon(polygon_points)
+
+        # Create a bounding box for the map bounds
+        bounds = box(min_x, min_y, max_x, max_y)
+
+        # Intersect the polygon with the bounds to fit it within the map
+        fitted_polygon = polygon.intersection(bounds)
+
+        if not isinstance(fitted_polygon, Polygon):
+            raise ValueError("The fitted polygon is not a valid polygon.")
+
+        # Return the fitted polygon points
+        return list(fitted_polygon.exterior.coords)
+
+    @staticmethod
+    def create_user_attribute_node(node_id: int) -> ET.Element:
+        """Creates an XML user attribute node with given node ID.
+
+        Arguments:
+            node_id (int): The node ID of the user attribute node.
+
+        Returns:
+            ET.Element: The created user attribute node.
+        """
+        user_attribute_node = ET.Element("UserAttribute")
+        user_attribute_node.set("nodeId", str(node_id))
+
+        attributes = [
+            ("angle", "integer", "0"),
+            ("missionAllowed", "boolean", "true"),
+            ("missionOnlyGrass", "boolean", "false"),
+            ("nameIndicatorIndex", "string", "1"),
+            ("polygonIndex", "string", "0"),
+            ("teleportIndicatorIndex", "string", "2"),
+        ]
+
+        for name, attr_type, value in attributes:
+            user_attribute_node.append(I3d.create_attribute_node(name, attr_type, value))
+
+        return user_attribute_node
+
+    @staticmethod
+    def create_attribute_node(name: str, attr_type: str, value: str) -> ET.Element:
+        """Creates an XML attribute node with given name, type, and value.
+
+        Arguments:
+            name (str): The name of the attribute.
+            attr_type (str): The type of the attribute.
+            value (str): The value of the attribute.
+
+        Returns:
+            ET.Element: The created attribute node.
+        """
+        attribute_node = ET.Element("Attribute")
+        attribute_node.set("name", name)
+        attribute_node.set("type", attr_type)
+        attribute_node.set("value", value)
+        return attribute_node

maps4fs/generator/map.py

@@ -44,17 +44,17 @@ class Map:
         if not logger:
             logger = Logger(to_stdout=True, to_file=False)
         self.logger = logger
-        self.logger.debug("Game was set to %s", game.code)
+        self.logger.info("Game was set to %s", game.code)
 
         self.kwargs = kwargs
-        self.logger.debug("Additional arguments: %s", kwargs)
+        self.logger.info("Additional arguments: %s", kwargs)
 
         os.makedirs(self.map_directory, exist_ok=True)
         self.logger.debug("Map directory created: %s", self.map_directory)
 
         try:
             shutil.unpack_archive(game.template_path, self.map_directory)
-            self.logger.info("Map template unpacked to %s", self.map_directory)
+            self.logger.debug("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
 

maps4fs/generator/texture.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import json
 import os
-import warnings
+from collections import defaultdict
 from typing import Any, Callable, Generator, Optional
 
 import cv2
@@ -41,6 +41,9 @@ class Texture(Component):
             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.
+            exclude_weight (bool): Flag to exclude weight from the texture.
+            priority (int | None): Priority of the layer.
+            info_layer (str | None): Name of the corresnponding info layer.
 
         Attributes:
             name (str): Name of the layer.
@@ -58,6 +61,7 @@ class Texture(Component):
             color: tuple[int, int, int] | list[int] | None = None,
             exclude_weight: bool = False,
             priority: int | None = None,
+            info_layer: str | None = None,
         ):
             self.name = name
             self.count = count
@@ -66,6 +70,7 @@ class Texture(Component):
             self.color = color if color else (255, 255, 255)
             self.exclude_weight = exclude_weight
             self.priority = priority
+            self.info_layer = info_layer
 
         def to_json(self) -> dict[str, str | list[str] | bool]:  # type: ignore
             """Returns dictionary with layer data.
@@ -80,6 +85,7 @@ class Texture(Component):
                 "color": list(self.color),
                 "exclude_weight": self.exclude_weight,
                 "priority": self.priority,
+                "info_layer": self.info_layer,
             }
 
             data = {k: v for k, v in data.items() if v is not None}
@@ -178,6 +184,9 @@ class Texture(Component):
         self.info_save_path = os.path.join(self.map_directory, "generation_info.json")
         self.logger.debug("Generation info save path: %s.", self.info_save_path)
 
+        self.info_layer_path = os.path.join(self.info_layers_directory, "textures.json")
+        self.logger.debug("Info layer path: %s.", self.info_layer_path)
+
     def get_base_layer(self) -> Layer | None:
         """Returns base layer.
 
@@ -230,7 +239,7 @@ class Texture(Component):
 
         for layer in self.layers:
             self._generate_weights(layer)
-        self.logger.debug("Prepared weights for %s layers.", len(self.layers))
+        self.logger.info("Prepared weights for %s layers.", len(self.layers))
 
     def _generate_weights(self, layer: Layer) -> None:
         """Generates weight files for textures. Each file is a numpy array of zeros and
@@ -297,6 +306,10 @@ class Texture(Component):
 
         cumulative_image = None
 
+        # Dictionary to store info layer data.
+        # Key is a layer.info_layer, value is a list of polygon points as tuples (x, y).
+        info_layer_data = defaultdict(list)
+
         for layer in layers:
             if not layer.tags:
                 self.logger.debug("Layer %s has no tags, there's nothing to draw.", layer.name)
@@ -317,6 +330,8 @@ class Texture(Component):
             mask = cv2.bitwise_not(cumulative_image)
 
             for polygon in self.polygons(layer.tags, layer.width):  # type: ignore
+                if layer.info_layer:
+                    info_layer_data[layer.info_layer].append(self.np_to_polygon_points(polygon))
                 cv2.fillPoly(layer_image, [polygon], color=255)  # type: ignore
 
             output_image = cv2.bitwise_and(layer_image, mask)
@@ -324,7 +339,11 @@ class Texture(Component):
             cumulative_image = cv2.bitwise_or(cumulative_image, output_image)
 
             cv2.imwrite(layer_path, output_image)
-            self.logger.debug("Texture %s saved.", layer_path)
+            self.logger.info("Texture %s saved.", layer_path)
+
+        # Save info layer data.
+        with open(self.info_layer_path, "w", encoding="utf-8") as f:
+            json.dump(info_layer_data, f, ensure_ascii=False, indent=4)
 
         if cumulative_image is not None:
             self.draw_base_layer(cumulative_image)
@@ -332,7 +351,7 @@ class Texture(Component):
         if not self.light_version:
             self.dissolve()
         else:
-            self.logger.info("Skipping dissolve in light version of the map.")
+            self.logger.debug("Skipping dissolve in light version of the map.")
 
     def dissolve(self) -> None:
         """Dissolves textures of the layers with tags into sublayers for them to look more
@@ -404,7 +423,7 @@ class Texture(Component):
             self.logger.debug("Drawing base layer %s.", layer_path)
             img = cv2.bitwise_not(cumulative_image)
             cv2.imwrite(layer_path, img)
-            self.logger.debug("Base texture %s saved.", layer_path)
+            self.logger.info("Base texture %s saved.", layer_path)
 
     def get_relative_x(self, x: float) -> int:
         """Converts UTM X coordinate to relative X coordinate in map image.
@@ -428,6 +447,17 @@ class Texture(Component):
         """
         return int(self.map_height * (1 - (y - self.minimum_y) / (self.maximum_y - self.minimum_y)))
 
+    def np_to_polygon_points(self, np_array: np.ndarray) -> list[tuple[int, int]]:
+        """Converts numpy array of polygon points to list of tuples.
+
+        Arguments:
+            np_array (np.ndarray): Numpy array of polygon points.
+
+        Returns:
+            list[tuple[int, int]]: List of tuples.
+        """
+        return [(int(x), int(y)) for x, y in np_array.reshape(-1, 2)]
+
     # pylint: disable=W0613
     def _to_np(self, geometry: shapely.geometry.polygon.Polygon, *args) -> np.ndarray:
         """Converts Polygon geometry to numpy array of polygon points.
@@ -509,14 +539,12 @@ class Texture(Component):
             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)
+            objects = ox.features_from_bbox(bbox=self.new_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)
+        objects_utm = ox.projection.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():
@@ -579,6 +607,7 @@ class Texture(Component):
             merged.dtype,
         )
         preview_path = os.path.join(self.previews_directory, "textures_osm.png")
-        cv2.imwrite(preview_path, merged)  # pylint: disable=no-member
+
+        cv2.imwrite(preview_path, merged)  # type: ignore
         self.logger.info("Preview saved to %s.", preview_path)
         return preview_path

maps4fs/generator/tile.py

@@ -36,10 +36,10 @@ class Tile(DEM):
 
         self.logger.debug("Generating tile for code %s", self.code)
 
-        tiles_directory = os.path.join(self.map_directory, "objects", "tiles")
-        os.makedirs(tiles_directory, exist_ok=True)
+        background_directory = os.path.join(self.map_directory, "background")
+        os.makedirs(background_directory, exist_ok=True)
 
-        self._dem_path = os.path.join(tiles_directory, f"{self.code}.png")
+        self._dem_path = os.path.join(background_directory, f"{self.code}.png")
         self.logger.debug("DEM path for tile %s is %s", self.code, self._dem_path)
 
     def get_output_resolution(self) -> tuple[int, int]:

maps4fs/toolbox/background.py

@@ -0,0 +1,63 @@
+"""This module contains functions to work with the background terrain of the map."""
+
+import cv2
+import numpy as np
+import trimesh  # type: ignore
+
+
+# pylint: disable=R0801, R0914
+def plane_from_np(
+    dem_data: np.ndarray,
+    resize_factor: float,
+    simplify_factor: int,
+    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.
+        resize_factor (float) -- The factor by which the DEM data will be resized. Bigger values
+            will result in a bigger mesh.
+        simplify_factor (int) -- The factor by which the mesh will be simplified. Bigger values
+            will result in a simpler mesh.
+        save_path (str) -- The path to save the obj file.
+    """
+    dem_data = cv2.resize(  # pylint: disable=no-member
+        dem_data, (0, 0), fx=resize_factor, fy=resize_factor
+    )
+
+    # Invert the height values.
+    dem_data = dem_data.max() - dem_data
+
+    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
+
+            faces.append([top_left, bottom_left, bottom_right])
+            faces.append([top_left, bottom_right, top_right])
+
+    faces = np.array(faces)  # type: ignore
+    mesh = trimesh.Trimesh(vertices=vertices, faces=faces)
+
+    # Apply rotation: 180 degrees around Y-axis and Z-axis
+    rotation_matrix_y = trimesh.transformations.rotation_matrix(np.pi, [0, 1, 0])
+    rotation_matrix_z = trimesh.transformations.rotation_matrix(np.pi, [0, 0, 1])
+    mesh.apply_transform(rotation_matrix_y)
+    mesh.apply_transform(rotation_matrix_z)
+
+    # Simplify the mesh to reduce the number of faces.
+    mesh = mesh.simplify_quadric_decimation(face_count=len(faces) // simplify_factor)
+
+    mesh.export(save_path)

{maps4fs-0.9.98.dist-info → maps4fs-1.0.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: maps4fs
-Version: 0.9.98
+Version: 1.0.3
 Summary: Generate map templates for Farming Simulator from real places.
 Author-email: iwatkot <iwatkot@gmail.com>
 License: MIT License
@@ -14,7 +14,7 @@ Classifier: Operating System :: OS Independent
 Description-Content-Type: text/markdown
 License-File: LICENSE.md
 Requires-Dist: opencv-python
-Requires-Dist: osmnx<2.0.0
+Requires-Dist: osmnx>=2.0.0
 Requires-Dist: rasterio
 Requires-Dist: folium
 Requires-Dist: geopy
@@ -31,8 +31,10 @@ Requires-Dist: pympler
 <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="#Step-by-step">Create a map in 10 steps</a> •
+  <a href="#How-To-Run">How-To-Run</a><br>
   <a href="docs/FAQ.md">FAQ</a> •
+  <a href="docs/map_structure.md">Map Structure</a> •
   <a href="#Modder-Toolbox">Modder Toolbox</a><br>
   <a href="#Supported-objects">Supported objects</a> •
   <a href="#Generation-info">Generation info</a> •
@@ -68,6 +70,7 @@ Requires-Dist: pympler
 🔷 Generates *.obj files for background terrain based on the real-world height map<br>
 📄 Generates scripts to download high-resolution satellite images from [QGIS](https://qgis.org/download/) in one click<br>
 🧰 Modder Toolbox to help you with various of tasks 🆕<br>
+🌾 Automatically generates fields 🆕<br>
 
 <p align="center">
 <img src="https://github.com/user-attachments/assets/cf8f5752-9c69-4018-bead-290f59ba6976"><br>
@@ -76,6 +79,8 @@ Requires-Dist: pympler
 🛰️ Realistic background terrain objects with satellite images.<br><br>
 <img src="https://github.com/user-attachments/assets/80e5923c-22c7-4dc0-8906-680902511f3a"><br>
 🗒️ True-to-life blueprints for fast and precise modding.<br><br>
+<img width="480" src="https://github.com/user-attachments/assets/1a8802d2-6a3b-4bfa-af2b-7c09478e199b"><br>
+🌾 Field generation with one click.<br><br>
 <img src="https://github.com/user-attachments/assets/cce45575-c917-4a1b-bdc0-6368e32ccdff"><br>
 📏 Almost any possible map sizes.
 </p>
@@ -84,6 +89,13 @@ Requires-Dist: pympler
 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>
 ### 🚜 For most users
 **Option 1:** open the [maps4fs](https://maps4fs.streamlit.app) on StreamLit and generate a map template in a few clicks.<br>
+<i>Note, that StreamLit community hosting has some limitations, such as:  <br>
+1. Maximum map size is 4096x4096 meters.  <br>
+2. Advanced settings are disabled.  <br>
+3. Texure dissolving is disabled (they will look worse).  </i><br>
+
+If you run the application locally, you won't have any of these limitations and will be able to generate maps of any size with any settings you want and nice looking textures.<br>
+So, jump to [Docker version](#option-2-docker-version) to launch the tool with one command and get the full experience.<br>
 
 ![Basic WebUI](https://github.com/user-attachments/assets/52f499cc-f28a-4da3-abef-0e818abe8dbe)
 
@@ -126,6 +138,9 @@ Parameters:
 - coordinates: 45.15, 19.71
 - size: 16 x 16 km
 
+## Step by step
+Don't know where to start? Don't worry, just follow this [step-by-step guide](docs/step_by_step.md) to create your first map in 10 simple steps.<br>
+
 ## 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:
@@ -133,14 +148,22 @@ You'll find detailed instructions on how to run the project below. But if you pr
 <i>Video tutorial: How to generate a Farming Simulator 22 map from real-world data.</i>
 
 ### Option 1: StreamLit
-🟢 Recommended for all users, you don't need to install anything.<br>
+🟢 Recommended for all users.
+🛠️ Don't need to install anything.  
+🗺️ Supported map sizes: 2x2, 4x4 km.  
+⚙️ Advanced settings: disabled.  
+🖼️ Texture dissolving: disabled.  
 Using the [StreamLit](https://maps4fs.streamlit.app) version of the tool is the easiest way to generate a map template. Just open the link and follow the instructions.
 Note: due to CPU and RAM limitations of the hosting, the generation may take some time. If you need faster processing, use the [Docker version](#option-2-docker-version).<br>
 
 Using it is easy and doesn't require any guides. Enjoy!
 
 ### Option 2: Docker version
-🟠 Recommended for users who want faster processing, very simple installation.<br>
+🟠 Recommended for users who want bigger maps, fast generation, nice looking textures and advanced settings.  
+🛠️ Launch with one single command.  
+🗺️ Supported map sizes: 2x2, 4x4, 8x8, 16x16 km and any custom size.  
+⚙️ Advanced settings: enabled.   
+🖼️ Texture dissolving: enabled.  
 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.
@@ -153,7 +176,10 @@ docker run -d -p 8501:8501 iwatkot/maps4fs
 5. When the map is generated click on the `Download` button to get the map.
 
 ### Option 3: Python package
-🔴 Recommended for developers.<br>
+🔴 Recommended for developers.  
+🗺️ Supported map sizes: 2x2, 4x4, 8x8, 16x16 km and any custom size.  
+⚙️ Advanced settings: enabled.   
+🖼️ Texture dissolving: enabled.  
 You can use the Python package to generate maps. Follow these steps:
 
 1. Install the package from PyPI:
@@ -202,12 +228,15 @@ The map will be saved in the `map_directory` directory.
 ## Modder Toolbox
 The tool now has a Modder Toolbox, which is a set of tools to help you with various tasks. You can open the toolbox by switching to the `🧰 Modder Toolbox` tab in the StreamLit app.<br>
 
-![Modder Toolbox](https://github.com/user-attachments/assets/18f169e9-1a5b-474c-b488-6becfffadcea)
+![Modder Toolbox](https://github.com/user-attachments/assets/dffb252f-f5c0-4021-9d45-31e5bccc0d9b)
 
 ### Tool categories
 Tools are divided into categories, which are listed below.
 #### Textures and DEM
-- **GeoTIFF windowing** - allows you to upload your GeoTIFF file and select the region of interest to extract it from the image.
+- **GeoTIFF windowing** - allows you to upload your GeoTIFF file and select the region of interest to extract it from the image. It's useful when you have high-resolution DEM data and want to create the height map using it.
+
+#### Background terrain
+- **Convert image to obj model** - allows you to convert the image to the obj model. You can use this tool to create the background terrain for your map. It can be extremely useful if you have access to the sources of high-resolution DEM data and want to create the background terrain using it.
 
 ## 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.
@@ -376,7 +405,7 @@ Let's have a closer look at the fields:
 
 ## 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>
+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 `background` directory with corresponding names: `N.obj`, `NE.obj`, `E.obj` and so on.<br>
 If you don't want to work with separate tiles, the tool also generates the `FULL.obj` file, which includes everything around the map and the map itself. It may be a convinient approach to work with one file, one texture and then just cut the map from it.<br>
 
 ![Complete background terrain in Blender](https://github.com/user-attachments/assets/7266b8f1-bfa2-4c14-a740-1c84b1030a66)

maps4fs-1.0.3.dist-info/RECORD

@@ -0,0 +1,23 @@
+maps4fs/__init__.py,sha256=da4jmND2Ths9AffnkAKgzLHNkvKFOc_l21gJisPXqWY,155
+maps4fs/logger.py,sha256=B-NEYpMjPAAqlV4VpfTi6nbBFnEABVtQOaYe6nMpidg,1489
+maps4fs/generator/__init__.py,sha256=zZMLEkGzb4z0xql650gOtGSvcgX58DnJ2yN3vC2daRk,43
+maps4fs/generator/background.py,sha256=n4GnDhER6yt8pgG1F3Ztwg9tpjCl0UVmryGx5n4Bvbc,10455
+maps4fs/generator/component.py,sha256=swOocaEOP3XtZgHfgDJ0ROALWoLgCJwMq8ubl0d2WrI,11085
+maps4fs/generator/config.py,sha256=kspXIT2o-_28EU0RQsROHCjkgQdqQnvreAKP5QAC5Ws,4279
+maps4fs/generator/dem.py,sha256=bSO1sGpstrDu4PpFxfu8F471tKFLw6gSZ0KlV6kcZnA,17036
+maps4fs/generator/game.py,sha256=3Y65K-XQDKxfMRSrjsmE8qX0tQSd0aDzMUT6yGIhzXg,7450
+maps4fs/generator/grle.py,sha256=oZNBA_F0zhJzDIDDI8m4e2XHycC_5z2kZRnAiPcYURE,3135
+maps4fs/generator/i3d.py,sha256=1z1SuFCg2lmfJl10CuhWstflm44hjL6ldQ7nwbMndZc,14219
+maps4fs/generator/map.py,sha256=gDZUZ2wimoeA8mHVOCnZvrIBeK7b99OIWFd_LjruqBc,4677
+maps4fs/generator/path_steps.py,sha256=yeN6hmOD8O2LMozUf4HcQMIy8WJ5sHF5pGQT_s2FfOw,3147
+maps4fs/generator/qgis.py,sha256=Es8hLuqN_KH8lDfnJE6He2rWYbAKJ3RGPn-o87S6CPI,6116
+maps4fs/generator/texture.py,sha256=BZjJIHwGEQMoRULAhvTPyKx8k7jlot5voVk82_TsXgg,23668
+maps4fs/generator/tile.py,sha256=_UZ-iHGPghUfpYcG0OboquNczpZ1FaCVYpBgNLd72eo,2160
+maps4fs/toolbox/__init__.py,sha256=zZMLEkGzb4z0xql650gOtGSvcgX58DnJ2yN3vC2daRk,43
+maps4fs/toolbox/background.py,sha256=9BXWNqs_n3HgqDiPztWylgYk_QM4YgBpe6_ZNQAWtSc,2154
+maps4fs/toolbox/dem.py,sha256=z9IPFNmYbjiigb3t02ZenI3Mo8odd19c5MZbjDEovTo,3525
+maps4fs-1.0.3.dist-info/LICENSE.md,sha256=pTKD_oUexcn-yccFCTrMeLkZy0ifLRa-VNcDLqLZaIw,10749
+maps4fs-1.0.3.dist-info/METADATA,sha256=GhFrgp-oYPbsE3wx-2DiikIfM8YbrxApckYDsxRwO70,27123
+maps4fs-1.0.3.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+maps4fs-1.0.3.dist-info/top_level.txt,sha256=Ue9DSRlejRQRCaJueB0uLcKrWwsEq9zezfv5dI5mV1M,8
+maps4fs-1.0.3.dist-info/RECORD,,

maps4fs-0.9.98.dist-info/RECORD

@@ -1,22 +0,0 @@
-maps4fs/__init__.py,sha256=da4jmND2Ths9AffnkAKgzLHNkvKFOc_l21gJisPXqWY,155
-maps4fs/logger.py,sha256=B-NEYpMjPAAqlV4VpfTi6nbBFnEABVtQOaYe6nMpidg,1489
-maps4fs/generator/__init__.py,sha256=zZMLEkGzb4z0xql650gOtGSvcgX58DnJ2yN3vC2daRk,43
-maps4fs/generator/background.py,sha256=h6zyqMc51eOD8_Jbe8eP9DJFy27-XItzIOVEThQKFdk,14011
-maps4fs/generator/component.py,sha256=ibfl2V_niXqWaFO05aaV25JbPBaupUpKBOLxKQq0Fv4,10714
-maps4fs/generator/config.py,sha256=qomeSaHNgSYvRyPbGkyDjgAxU1jUMND8wESuy9uXcV4,4280
-maps4fs/generator/dem.py,sha256=aU0syr7pu81hd6oVn1rjQoDsDAYJro-58i1STTUz3jw,17167
-maps4fs/generator/game.py,sha256=hvVsU4l43kHYM9oZ6WBFhDiI8U3gJxzSeavAvXyh0DI,7395
-maps4fs/generator/grle.py,sha256=kyFiGu-2aXrLVB_8GeXlGvG5ULwlSVuqU1yfpt_0br4,3134
-maps4fs/generator/i3d.py,sha256=CSdVDQJOybeu6DQhxTxImEOSsbbXSNqAN8sunNuicM0,3602
-maps4fs/generator/map.py,sha256=1EJfq5928xbV7v9vBBuoC3VpD5gC1SMDBTQ7geH6yaA,4678
-maps4fs/generator/path_steps.py,sha256=yeN6hmOD8O2LMozUf4HcQMIy8WJ5sHF5pGQT_s2FfOw,3147
-maps4fs/generator/qgis.py,sha256=Es8hLuqN_KH8lDfnJE6He2rWYbAKJ3RGPn-o87S6CPI,6116
-maps4fs/generator/texture.py,sha256=9qBlL3udozp5ATg9N48naRjTQPWe_eOPgs28hG4U13g,22381
-maps4fs/generator/tile.py,sha256=6zUpDidPcPRTGzQvYSNw-0Pj-if2WiakU2qb-40vyOk,2151
-maps4fs/toolbox/__init__.py,sha256=zZMLEkGzb4z0xql650gOtGSvcgX58DnJ2yN3vC2daRk,43
-maps4fs/toolbox/dem.py,sha256=z9IPFNmYbjiigb3t02ZenI3Mo8odd19c5MZbjDEovTo,3525
-maps4fs-0.9.98.dist-info/LICENSE.md,sha256=pTKD_oUexcn-yccFCTrMeLkZy0ifLRa-VNcDLqLZaIw,10749
-maps4fs-0.9.98.dist-info/METADATA,sha256=O0p9Zjx6_gFZHTtBurPZkMmsVcqzOUpK4uQUGfPmH_M,25194
-maps4fs-0.9.98.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-maps4fs-0.9.98.dist-info/top_level.txt,sha256=Ue9DSRlejRQRCaJueB0uLcKrWwsEq9zezfv5dI5mV1M,8
-maps4fs-0.9.98.dist-info/RECORD,,