maps4fs 2.8.9__py3-none-any.whl → 2.9.1__py3-none-any.whl

maps4fs/generator/component/background.py

@@ -19,6 +19,7 @@ from maps4fs.generator.component.base.component_image import ImageComponent
 from maps4fs.generator.component.base.component_mesh import MeshComponent
 from maps4fs.generator.component.dem import DEM
 from maps4fs.generator.component.texture import Texture
+from maps4fs.generator.monitor import monitor_performance
 from maps4fs.generator.settings import Parameters
 
 SEGMENT_LENGTH = 2
@@ -38,6 +39,7 @@ class Background(MeshComponent, ImageComponent):
             info, warning. If not provided, default logging will be used.
     """
 
+    @monitor_performance
     def preprocess(self) -> None:
         """Registers the DEMs for the background terrain."""
         self.stl_preview_path = os.path.join(self.previews_directory, "background_dem.stl")
@@ -76,6 +78,9 @@ class Background(MeshComponent, ImageComponent):
             self.background_directory, "not_substracted.png"
         )
         self.not_resized_path: str = os.path.join(self.background_directory, "not_resized.png")
+        self.not_resized_with_foundations_path: str = os.path.join(
+            self.background_directory, "not_resized_with_foundations.png"
+        )
 
         self.flatten_water_to: int | None = None
 
@@ -141,6 +146,7 @@ class Background(MeshComponent, ImageComponent):
                     "Mesh processing is disabled for the game, skipping water mesh processing."
                 )
 
+    @monitor_performance
     def create_foundations(self, dem_image: np.ndarray) -> np.ndarray:
         """Creates foundations for buildings based on the DEM data.
 
@@ -246,6 +252,7 @@ class Background(MeshComponent, ImageComponent):
         )
         self.create_qgis_scripts([qgis_layer, qgis_layer_with_margin])
 
+    @monitor_performance
     def generate_obj_files(self) -> None:
         """Iterates over all dems and generates 3D obj files based on DEM data.
         If at least one DEM file is missing, the generation will be stopped at all.
@@ -328,8 +335,9 @@ class Background(MeshComponent, ImageComponent):
                 return resolution
         return Parameters.MAXIMUM_BACKGROUND_TEXTURE_SIZE
 
+    @monitor_performance
     def decimate_background_mesh(self) -> None:
-        """ ""Decimates the background mesh based on the map size."""
+        """Decimates the background mesh based on the map size."""
         if not self.assets.background_mesh or not os.path.isfile(self.assets.background_mesh):
             self.logger.warning("Background mesh not found, cannot generate i3d background.")
             return
@@ -362,6 +370,7 @@ class Background(MeshComponent, ImageComponent):
 
         self.assets.decimated_background_mesh = decimated_save_path
 
+    @monitor_performance
     def texture_background_mesh(self) -> None:
         """Textures the background mesh using satellite imagery."""
         satellite_component = self.map.get_satellite_component()
@@ -427,6 +436,7 @@ class Background(MeshComponent, ImageComponent):
             self.logger.error("Could not texture background mesh: %s", e)
             return
 
+    @monitor_performance
     def convert_background_mesh_to_i3d(self) -> bool:
         """Converts the textured background mesh to i3d format.
 
@@ -498,6 +508,7 @@ class Background(MeshComponent, ImageComponent):
         with open(file_path, "w", encoding="utf-8") as f:
             f.write(content + "\n\n" + note)
 
+    @monitor_performance
     def convert_water_mesh_to_i3d(self) -> bool:
         """Converts the line-based water mesh to i3d format.
 
@@ -553,6 +564,10 @@ class Background(MeshComponent, ImageComponent):
 
         if self.map.dem_settings.add_foundations:
             dem_data = self.create_foundations(dem_data)
+            cv2.imwrite(self.not_resized_with_foundations_path, dem_data)
+            self.logger.debug(
+                "Not resized DEM with foundations saved: %s", self.not_resized_with_foundations_path
+            )
 
         output_size = self.scaled_size + 1
 
@@ -730,6 +745,7 @@ class Background(MeshComponent, ImageComponent):
         cv2.imwrite(colored_dem_path, dem_data_colored)
         return colored_dem_path
 
+    @monitor_performance
     def create_background_textures(self) -> None:
         """Creates background textures for the map."""
         layers_schema = self.map.texture_schema
@@ -782,6 +798,7 @@ class Background(MeshComponent, ImageComponent):
 
         cv2.imwrite(self.water_resources_path, background_image)
 
+    @monitor_performance
     def subtraction(self) -> None:
         """Subtracts the water depth from the DEM data where the water resources are located."""
         if not self.water_resources_path:
@@ -967,6 +984,7 @@ class Background(MeshComponent, ImageComponent):
         mesh = trimesh.Trimesh(vertices=vertices, faces=faces, process=False)
         return mesh
 
+    @monitor_performance
     def generate_water_resources_obj(self) -> None:
         """Generates 3D obj files based on water resources data."""
         self.logger.debug("Starting water resources generation...")
@@ -1033,13 +1051,24 @@ class Background(MeshComponent, ImageComponent):
 
         self.plane_from_np(elevated_water, elevated_save_path, include_zeros=False)
 
+    @monitor_performance
     def flatten_roads(self) -> None:
         """Flattens the roads in the DEM data by averaging the height values along the road polylines."""
-        if not self.not_resized_path or not os.path.isfile(self.not_resized_path):
+        supported_files = [self.not_resized_with_foundations_path, self.not_resized_path]
+
+        base_image_path = None
+        for supported_file in supported_files:
+            if not supported_file or not os.path.isfile(supported_file):
+                continue
+
+            base_image_path = supported_file
+            break
+
+        if not base_image_path:
             self.logger.warning("No DEM data found for flattening roads.")
             return
 
-        dem_image = cv2.imread(self.not_resized_path, cv2.IMREAD_UNCHANGED)
+        dem_image = cv2.imread(base_image_path, cv2.IMREAD_UNCHANGED)
         if dem_image is None:
             self.logger.warning("Failed to read DEM data.")
             return
@@ -1076,41 +1105,80 @@ class Background(MeshComponent, ImageComponent):
             total_length = polyline.length
             self.logger.debug("Total length of the road polyline: %s", total_length)
 
-            current_distance = 0
-            segments: list[shapely.LineString] = []
-            while current_distance < total_length:
-                start_point = polyline.interpolate(current_distance)
-                end_distance = min(current_distance + SEGMENT_LENGTH, total_length)
-                end_point = polyline.interpolate(end_distance)
+            # Step 1: Create complete road mask once
+            road_mask = np.zeros(dem_image.shape, dtype=np.uint8)
+            # OpenCV thickness is total width, not radius like Shapely buffer
+            # So we need width * 4 to match the old buffer(width * 2) behavior
+            line_thickness = int(width * 4)
+
+            # Get densely sampled points for smooth road
+            dense_sample_distance = min(SEGMENT_LENGTH, total_length / 100)  # At least 100 samples
+            num_dense_points = max(100, int(total_length / dense_sample_distance))
+            dense_distances = np.linspace(0, total_length, num_dense_points)
+            dense_points = [polyline.interpolate(d) for d in dense_distances]
+            dense_coords = np.array([(int(p.x), int(p.y)) for p in dense_points], dtype=np.int32)
+
+            # Draw entire road at once
+            if len(dense_coords) > 1:
+                cv2.polylines(road_mask, [dense_coords], False, 255, thickness=line_thickness)
+
+            # Step 2: Get all road pixels that need processing
+            road_pixels = np.where(road_mask == 255)
+            if len(road_pixels[0]) == 0:
+                continue
 
-                # Create a small segment LineString
-                segment = shapely.LineString([start_point, end_point])
-                segments.append(segment)
-                current_distance += SEGMENT_LENGTH
+            road_y, road_x = road_pixels
+            self.logger.debug("Processing %s road pixels", len(road_y))
+
+            # Step 3: Efficient distance-based smooth gradation
+            # Use much larger segments (10-20x SEGMENT_LENGTH) but interpolate between them
+            large_segment_length = SEGMENT_LENGTH * 15  # 30 units instead of 2
+            num_large_segments = max(1, int(np.ceil(total_length / large_segment_length)))
+            large_distances = np.linspace(0, total_length, num_large_segments + 1)
+
+            # Calculate elevation values at large segment points
+            segment_elevations = []
+            for dist in large_distances:
+                sample_point = polyline.interpolate(dist)
+                sample_x, sample_y = int(sample_point.x), int(sample_point.y)
+
+                # Sample elevation in small area around this point
+                sample_radius = max(5, line_thickness // 4)
+                y_min = max(0, sample_y - sample_radius)
+                y_max = min(dem_image.shape[0], sample_y + sample_radius)
+                x_min = max(0, sample_x - sample_radius)
+                x_max = min(dem_image.shape[1], sample_x + sample_radius)
+
+                if y_max > y_min and x_max > x_min:
+                    sample_elevation = np.mean(dem_image[y_min:y_max, x_min:x_max])  # type: ignore
+                else:
+                    sample_elevation = (
+                        dem_image[sample_y, sample_x]  # type: ignore
+                        if 0 <= sample_y < dem_image.shape[0] and 0 <= sample_x < dem_image.shape[1]
+                        else 0
+                    )
 
-            self.logger.debug("Number of segments created: %s", len(segments))
+                segment_elevations.append(sample_elevation)
 
-            road_polygons: list[shapely.Polygon] = []
-            for segment in segments:
-                polygon = segment.buffer(
-                    width * 2, resolution=4, cap_style="flat", join_style="mitre"
-                )
-                road_polygons.append(polygon)
-
-            for polygon in road_polygons:
-                polygon_points = polygon.exterior.coords
-                road_np = self.polygon_points_to_np(polygon_points)
-                mask = np.zeros(dem_image.shape, dtype=np.uint8)
-
-                try:
-                    cv2.fillPoly(mask, [road_np], 255)  # type: ignore
-                except Exception as e:
-                    self.logger.debug("Could not create mask for road with error: %s", e)
-                    continue
-
-                mean_value = cv2.mean(dem_image, mask=mask)[0]  # type: ignore
-                dem_image[mask == 255] = mean_value
-                full_mask[mask == 255] = 255
+            # Step 4: Interpolate elevations smoothly along entire road
+            road_distances_from_start = []
+            for i in range(len(road_y)):  # pylint: disable=consider-using-enumerate
+                px, py = road_x[i], road_y[i]
+                # Find closest point on polyline (approximation)
+                closest_point = polyline.interpolate(polyline.project(shapely.Point(px, py)))
+                distance_along_road = polyline.project(closest_point)
+                road_distances_from_start.append(distance_along_road)
+
+            road_distances_from_start = np.array(road_distances_from_start)  # type: ignore
+
+            # Interpolate elevation values based on distance along road
+            interpolated_elevations = np.interp(
+                road_distances_from_start, large_distances, segment_elevations
+            )
+
+            # Step 5: Apply interpolated elevations to road pixels
+            dem_image[road_y, road_x] = interpolated_elevations
+            full_mask[road_y, road_x] = 255
 
         main_dem_path = self.game.dem_file_path(self.map_directory)
         dem_image = self.blur_by_mask(dem_image, full_mask, blur_radius=5)

maps4fs/generator/component/base/component_mesh.py

@@ -1,5 +1,6 @@
 """Base class for all components that primarily used to work with meshes."""
 
+import logging
 import os
 import shutil
 import xml.etree.ElementTree as ET
@@ -15,6 +16,8 @@ from tqdm import tqdm
 from maps4fs.generator.component.base.component import Component
 from maps4fs.generator.settings import Parameters
 
+logger = logging.getLogger("maps4fs")
+
 
 class MeshComponent(Component):
     """Base class for all components that primarily used to work with meshes."""
@@ -595,19 +598,53 @@ class MeshComponent(Component):
         if has_uv:
             xml_vertices.set("uv0", "true")
 
-        # Write vertex data
-        for idx in tqdm(range(len(vertices)), desc="Writing vertices", unit="vertex"):
-            v = vertices[idx]
-            v_el = ET.SubElement(xml_vertices, "v")
-            v_el.set("p", f"{v[0]:.6f} {v[1]:.6f} {v[2]:.6f}")
+        # Pre-format ALL strings using vectorized operations
+        pos_strings = np.array([f"{v[0]:.6f} {v[1]:.6f} {v[2]:.6f}" for v in vertices])
+
+        normal_strings = None
+        if has_normals:
+            normal_strings = np.array(
+                [f"{n[0]:.6f} {n[1]:.6f} {n[2]:.6f}" for n in mesh.vertex_normals]
+            )
+
+        if normal_strings is None:
+            logger.warning("Normals are missing despite has_normals being True. Can't write i3d.")
+            return
+
+        uv_strings = None
+        if has_uv:
+            uv_strings = np.array([f"{uv[0]:.6f} {uv[1]:.6f}" for uv in mesh.visual.uv])
+
+        if uv_strings is None:
+            logger.warning("UV coordinates are missing despite has_uv being True. Can't write i3d.")
+            return
+
+        # Batch process vertices for memory efficiency
+        batch_size = 2000
+        vertex_elements = []
+
+        for batch_start in tqdm(
+            range(0, len(vertices), batch_size), desc="Writing vertices", unit="batch"
+        ):
+            batch_end = min(batch_start + batch_size, len(vertices))
+            batch_elements = []
+
+            for idx in range(batch_start, batch_end):
+                v_el = ET.Element("v")
+                v_el.set("p", pos_strings[idx])
+
+                if has_normals:
+                    v_el.set("n", normal_strings[idx])
+
+                if has_uv:
+                    v_el.set("t0", uv_strings[idx])
+
+                batch_elements.append(v_el)
 
-            if has_normals:
-                n = mesh.vertex_normals[idx]
-                v_el.set("n", f"{n[0]:.6f} {n[1]:.6f} {n[2]:.6f}")
+            vertex_elements.extend(batch_elements)
 
-            if has_uv:
-                uv = mesh.visual.uv[idx]
-                v_el.set("t0", f"{uv[0]:.6f} {uv[1]:.6f}")
+        # Add all vertex elements at once
+        xml_vertices.extend(vertex_elements)
 
         # Triangles block
         xml_tris = ET.SubElement(shape, "Triangles")

maps4fs/generator/component/config.py

@@ -10,6 +10,7 @@ import numpy as np
 import maps4fs.generator.utils as mfsutils
 from maps4fs.generator.component.base.component_image import ImageComponent
 from maps4fs.generator.component.base.component_xml import XMLComponent
+from maps4fs.generator.monitor import monitor_performance
 from maps4fs.generator.settings import Parameters
 
 # Defines coordinates for country block on the license plate texture.
@@ -120,6 +121,7 @@ class Config(XMLComponent, ImageComponent):
 
         self.create_qgis_scripts(layers)
 
+    @monitor_performance
     def _adjust_fog(self) -> None:
         """Adjusts the fog settings in the environment XML file based on the DEM and height scale."""
         self.logger.debug("Adjusting fog settings based on DEM and height scale...")
@@ -231,6 +233,7 @@ class Config(XMLComponent, ImageComponent):
 
         return dem_maximum_meter, dem_minimum_meter
 
+    @monitor_performance
     def _set_overview(self) -> None:
         """Generates and sets the overview image for the map."""
         try:
@@ -347,6 +350,7 @@ class Config(XMLComponent, ImageComponent):
             "HR",
         }
 
+    @monitor_performance
     def update_license_plates(self):
         """Updates license plates for the specified country."""
         try:
@@ -565,6 +569,7 @@ class Config(XMLComponent, ImageComponent):
         self.save_tree(tree, xml_path=i3d_path)
         self.logger.debug("Updated licensePlatesPL.i3d texture reference to: %s", filename)
 
+    @monitor_performance
     def _generate_license_plate_texture(
         self,
         license_plates_directory: str,

maps4fs/generator/component/dem.py

@@ -9,6 +9,7 @@ from pydtmdl import DTMProvider
 
 import maps4fs.generator.config as mfscfg
 from maps4fs.generator.component.base.component_image import ImageComponent
+from maps4fs.generator.monitor import monitor_performance
 
 
 # pylint: disable=R0903, R0902
@@ -115,6 +116,7 @@ class DEM(ImageComponent):
         except Exception as e:
             self.logger.warning("Failed to update DEM info: %s.", e)
 
+    @monitor_performance
     def process(self) -> None:
         """Reads DTM file, crops it to map size, normalizes and blurs it,
         saves to map directory."""
@@ -190,6 +192,7 @@ class DEM(ImageComponent):
         if self.rotation:
             self.rotate_dem()
 
+    @monitor_performance
     def normalize_data(self, data: np.ndarray, height_scale_value: int) -> np.ndarray:
         """Normalize DEM data to 16-bit unsigned integer range (0 to 65535).
 
@@ -209,6 +212,7 @@ class DEM(ImageComponent):
         )
         return normalized_data
 
+    @monitor_performance
     def determine_height_scale(self, data: np.ndarray) -> int:
         """Determine height scale value using ceiling.
 
@@ -261,6 +265,7 @@ class DEM(ImageComponent):
         )
         return data
 
+    @monitor_performance
     def apply_multiplier(self, data: np.ndarray) -> np.ndarray:
         """Apply multiplier to DEM data.
 
@@ -283,6 +288,7 @@ class DEM(ImageComponent):
         )
         return multiplied_data
 
+    @monitor_performance
     def resize_to_output(self, data: np.ndarray) -> np.ndarray:
         """Resize DEM data to the output resolution.
 
@@ -296,6 +302,7 @@ class DEM(ImageComponent):
 
         return resampled_data
 
+    @monitor_performance
     def rotate_dem(self) -> None:
         """Rotate DEM image."""
         self.logger.debug("Rotating DEM image by %s degrees.", self.rotation)

maps4fs/generator/component/grle.py

@@ -12,6 +12,7 @@ from tqdm import tqdm
 from maps4fs.generator.component.base.component_image import ImageComponent
 from maps4fs.generator.component.base.component_xml import XMLComponent
 from maps4fs.generator.component.layer import Layer
+from maps4fs.generator.monitor import monitor_performance
 from maps4fs.generator.settings import Parameters
 
 # This value sums up the pixel value of the basic area type to convert it from "No Water" to "Near Water".
@@ -98,6 +99,7 @@ class GRLE(ImageComponent, XMLComponent):
 
         return grle_schema
 
+    @monitor_performance
     def process(self) -> None:
         """Generates InfoLayer PNG files based on the GRLE schema."""
         grle_schema = self._read_grle_schema()
@@ -134,6 +136,7 @@ class GRLE(ImageComponent, XMLComponent):
             self._process_environment()
             self._process_indoor()
 
+    @monitor_performance
     def previews(self) -> list[str]:
         """Returns a list of paths to the preview images (empty list).
         The component does not generate any preview images so it returns an empty list.
@@ -173,6 +176,7 @@ class GRLE(ImageComponent, XMLComponent):
 
         return preview_paths
 
+    @monitor_performance
     def overlay_fields(self, farmlands_np: np.ndarray) -> np.ndarray | None:
         """Overlay fields on the farmlands preview image.
 
@@ -200,6 +204,7 @@ class GRLE(ImageComponent, XMLComponent):
         # use fields_np as base layer and overlay farmlands_np on top of it with 50% alpha blending.
         return cv2.addWeighted(fields_np, 0.5, farmlands_np, 0.5, 0)
 
+    @monitor_performance
     def _add_farmlands(self) -> None:
         """Adds farmlands to the InfoLayer PNG file."""
         farmlands = []
@@ -297,6 +302,7 @@ class GRLE(ImageComponent, XMLComponent):
 
         self.preview_paths["farmlands"] = info_layer_farmlands_path
 
+    @monitor_performance
     def _add_plants(self) -> None:
         """Adds plants to the InfoLayer PNG file."""
         grass_layer = self.map.get_texture_layer(by_usage="grass")
@@ -399,6 +405,7 @@ class GRLE(ImageComponent, XMLComponent):
 
         self.logger.debug("Updated density map for fruits saved in %s.", density_map_fruit_path)
 
+    @monitor_performance
     def create_island_of_plants(self, image: np.ndarray, count: int) -> np.ndarray:
         """Create an island of plants in the image.
 
@@ -495,6 +502,7 @@ class GRLE(ImageComponent, XMLComponent):
         image_np[:, -1] = 0  # Right side
         return image_np
 
+    @monitor_performance
     def _process_environment(self) -> None:
         info_layer_environment_path = self.game.get_environment_path(self.map_directory)
         if not info_layer_environment_path or not os.path.isfile(info_layer_environment_path):
@@ -554,6 +562,7 @@ class GRLE(ImageComponent, XMLComponent):
         self.logger.debug("Environment InfoLayer PNG file saved: %s.", info_layer_environment_path)
         self.preview_paths["environment"] = info_layer_environment_path
 
+    @monitor_performance
     def get_resized_weight(
         self, layer: Layer, resize_to: int, dilations: int = 3
     ) -> np.ndarray | None:

maps4fs/generator/component/i3d.py

@@ -13,6 +13,7 @@ import numpy as np
 from tqdm import tqdm
 
 from maps4fs.generator.component.base.component_xml import XMLComponent
+from maps4fs.generator.monitor import monitor_performance
 from maps4fs.generator.settings import Parameters
 
 NODE_ID_STARTING_VALUE = 2000
@@ -112,6 +113,7 @@ class I3d(XMLComponent):
 
         self.save_tree(tree)
 
+    @monitor_performance
     def _add_splines(self) -> None:
         """Adds splines to the map I3D file."""
         splines_i3d_path = self.game.splines_file_path(self.map_directory)
@@ -240,6 +242,7 @@ class I3d(XMLComponent):
 
         self.assets.splines = splines_i3d_path
 
+    @monitor_performance
     def _add_fields(self) -> None:
         """Adds fields to the map I3D file."""
         tree = self.get_tree()
@@ -498,6 +501,7 @@ class I3d(XMLComponent):
 
         return choice(trees_by_leaf_type)
 
+    @monitor_performance
     def _add_forests(self) -> None:
         """Adds forests to the map I3D file."""
         tree_schema = self._read_tree_schema()

maps4fs/generator/component/satellite.py

@@ -9,6 +9,7 @@ from pygmdl import save_image
 
 import maps4fs.generator.config as mfscfg
 from maps4fs.generator.component.base.component_image import ImageComponent
+from maps4fs.generator.monitor import monitor_performance
 from maps4fs.generator.settings import Parameters
 
 
@@ -49,6 +50,7 @@ class Satellite(ImageComponent):
             info, warning. If not provided, default logging will be used.
     """
 
+    @monitor_performance
     def process(self) -> None:
         """Downloads the satellite images for the map."""
         self.image_paths = []
@@ -126,6 +128,7 @@ class Satellite(ImageComponent):
 
         return tasks
 
+    @monitor_performance
     def previews(self) -> list[str]:
         """Returns the paths to the preview images.
 

maps4fs/generator/component/texture.py

@@ -7,10 +7,10 @@ import os
 import shutil
 import warnings
 from collections import defaultdict
-from time import perf_counter
 from typing import Any, Callable, Generator, Optional
 
 import cv2
+import geopandas as gpd
 import numpy as np
 import osmnx as ox
 import pandas as pd
@@ -21,6 +21,7 @@ from tqdm import tqdm
 
 from maps4fs.generator.component.base.component_image import ImageComponent
 from maps4fs.generator.component.layer import Layer
+from maps4fs.generator.monitor import monitor_performance
 from maps4fs.generator.settings import Parameters
 
 
@@ -186,6 +187,7 @@ class Texture(ImageComponent):
         for layer in self.layers:
             self.assets[layer.name] = layer.path(self._weights_dir)
 
+    @monitor_performance
     def add_borders(self) -> None:
         """Iterates over all the layers and picks the one which have the border propety defined.
         Borders are distance from the edge of the map on each side (top, right, bottom, left).
@@ -272,6 +274,7 @@ class Texture(ImageComponent):
                 return layer
         return None
 
+    @monitor_performance
     def merge_into(self) -> None:
         """Merges the content of layers into their target layers."""
         for layer in self.layers:
@@ -298,6 +301,7 @@ class Texture(ImageComponent):
                     cv2.imwrite(layer.path(self._weights_dir), np.zeros_like(layer_image))
                     self.logger.debug("Cleared layer %s.", layer.name)
 
+    @monitor_performance
     def rotate_textures(self) -> None:
         """Rotates textures of the layers which have tags."""
         if self.rotation:
@@ -320,6 +324,7 @@ class Texture(ImageComponent):
                         "Skipping rotation of layer %s because it has no tags.", layer.name
                     )
 
+    @monitor_performance
     def scale_textures(self) -> None:
         """Resizes all the textures to the map output size."""
         if not self.map.output_size:
@@ -364,6 +369,7 @@ class Texture(ImageComponent):
         ]
         return {attr: getattr(self, attr, None) for attr in useful_attributes}
 
+    @monitor_performance
     def _prepare_weights(self):
         self.logger.debug("Starting preparing weights from %s layers.", len(self.layers))
 
@@ -428,6 +434,7 @@ class Texture(ImageComponent):
             ),
         )
 
+    @monitor_performance
     def draw(self) -> None:
         """Iterates over layers and fills them with polygons from OSM data."""
         layers = self.layers_by_priority()
@@ -546,6 +553,7 @@ class Texture(ImageComponent):
                 }
                 info_layer_data[f"{layer.info_layer}_polylines"].append(linestring_entry)  # type: ignore
 
+    @monitor_performance
     def dissolve(self) -> None:
         """Dissolves textures of the layers with tags into sublayers for them to look more
         natural in the game.
@@ -554,46 +562,52 @@ class Texture(ImageComponent):
         files of the corresponding layer and saves the changes to the files.
         """
         for layer in tqdm(self.layers, desc="Dissolving textures", unit="layer"):
-            if not layer.tags:
-                self.logger.debug("Layer %s has no tags, there's nothing to dissolve.", layer.name)
-                continue
-            layer_path = layer.path(self._weights_dir)
-            layer_paths = layer.paths(self._weights_dir)
-
-            if len(layer_paths) < 2:
-                self.logger.debug("Layer %s has only one texture, skipping.", layer.name)
-                continue
+            self.dissolve_layer(layer)
 
-            self.logger.debug("Dissolving layer from %s to %s.", layer_path, layer_paths)
-
-            # Check if the image contains any non-zero values, otherwise continue.
-            layer_image = cv2.imread(layer_path, cv2.IMREAD_UNCHANGED)
+    def dissolve_layer(self, layer: Layer) -> None:
+        """Dissolves texture of the layer into sublayers."""
+        if not layer.tags:
+            self.logger.debug("Layer %s has no tags, there's nothing to dissolve.", layer.name)
+            return
+        layer_path = layer.path(self._weights_dir)
+        layer_paths = layer.paths(self._weights_dir)
 
-            if not np.any(layer_image):  # type: ignore
-                self.logger.debug(
-                    "Layer %s does not contain any non-zero values, skipping.", layer.name
-                )
-                continue
+        if len(layer_paths) < 2:
+            self.logger.debug("Layer %s has only one texture, skipping.", layer.name)
+            return
 
-            # Save the original image to use it for preview later, without combining the sublayers.
-            cv2.imwrite(layer.path_preview(self._weights_dir), layer_image.copy())  # type: ignore
+        self.logger.debug("Dissolving layer from %s to %s.", layer_path, layer_paths)
+        # Check if the image contains any non-zero values, otherwise continue.
+        layer_image = cv2.imread(layer_path, cv2.IMREAD_UNCHANGED)
+        if layer_image is None:
+            self.logger.debug("Layer %s image not found, skipping.", layer.name)
+            return
 
-            # Get the coordinates of non-zero values.
-            non_zero_coords = np.column_stack(np.where(layer_image > 0))  # type: ignore
+        # Get mask of non-zero pixels. If there are no non-zero pixels, skip the layer.
+        mask = layer_image > 0
+        if not np.any(mask):
+            self.logger.debug(
+                "Layer %s does not contain any non-zero values, skipping.", layer.name
+            )
+            return
+        # Save the original image to use it for preview later, without combining the sublayers.
+        cv2.imwrite(layer.path_preview(self._weights_dir), layer_image.copy())  # type: ignore
 
-            # Prepare sublayers.
-            sublayers = [np.zeros_like(layer_image) for _ in range(layer.count)]
+        # Create random assignment array for all pixels
+        random_assignment = np.random.randint(0, layer.count, size=layer_image.shape)
 
-            # Randomly assign non-zero values to sublayers.
-            for coord in non_zero_coords:
-                sublayers[np.random.randint(0, layer.count)][coord[0], coord[1]] = 255  # type: ignore
+        # Create sublayers using vectorized operations.
+        sublayers = []
+        for i in range(layer.count):
+            # Create sublayer: 255 where (mask is True AND random_assignment == i)
+            sublayer = np.where((mask) & (random_assignment == i), 255, 0).astype(np.uint8)
+            sublayers.append(sublayer)
 
-            # Save the sublayers.
-            for sublayer, sublayer_path in zip(sublayers, layer_paths):
-                cv2.imwrite(sublayer_path, sublayer)
-                self.logger.debug("Sublayer %s saved.", sublayer_path)
+        # Save sublayers
+        for sublayer, sublayer_path in zip(sublayers, layer_paths):
+            cv2.imwrite(sublayer_path, sublayer)
 
-            self.logger.debug("Dissolved layer %s.", layer.name)
+        self.logger.debug("Dissolved layer %s.", layer.name)
 
     def draw_base_layer(self, cumulative_image: np.ndarray) -> None:
         """Draws base layer and saves it into the png file.
@@ -791,35 +805,47 @@ class Texture(ImageComponent):
         ox_settings.use_cache = self.map.texture_settings.use_cache
         ox_settings.requests_timeout = 30
 
+        objects = self.fetch_osm_data(tags)
+        if objects is None or objects.empty:
+            self.logger.debug("No objects found for tags: %s.", tags)
+            return
+
+        self.logger.debug("Fetched %s elements for tags: %s.", len(objects), tags)
+
+        method = self.linestrings_generator if yield_linestrings else self.polygons_generator
+
+        yield from method(objects, width, is_fieds)
+
+    @monitor_performance
+    def fetch_osm_data(self, tags: dict[str, str | list[str] | bool]) -> gpd.GeoDataFrame | None:
+        """Fetches OSM data for given tags.
+
+        Arguments:
+            tags (dict[str, str | list[str] | bool]): Dictionary of tags to search for.
+
+        Returns:
+            gpd.GeoDataFrame | None: GeoDataFrame with OSM objects or None if no objects found.
+        """
         try:
             if self.map.custom_osm is not None:
                 with warnings.catch_warnings():
                     warnings.simplefilter("ignore", FutureWarning)
                     objects = ox.features_from_xml(self.map.custom_osm, tags=tags)
             else:
-                before_fetch = perf_counter()
                 objects = ox.features_from_bbox(bbox=self.new_bbox, tags=tags)
-                after_fetch = perf_counter()
-                fetched_in = after_fetch - before_fetch
-                self.logger.info(
-                    "Fetched OSMNX objects for tags: %s in %.2f seconds.", tags, fetched_in
-                )
         except Exception as e:
             self.logger.debug("Error fetching objects for tags: %s. Error: %s.", tags, e)
-            return
-        self.logger.debug("Fetched %s elements for tags: %s.", len(objects), tags)
-
-        method = self.linestrings_generator if yield_linestrings else self.polygons_generator
+            return None
 
-        yield from method(objects, width, is_fieds)
+        return objects
 
     def linestrings_generator(
-        self, objects: pd.core.frame.DataFrame, *args, **kwargs
+        self, objects: gpd.GeoDataFrame, *args, **kwargs
     ) -> Generator[list[tuple[int, int]], None, None]:
         """Generator which yields lists of point coordinates which represent LineStrings from OSM.
 
         Arguments:
-            objects (pd.core.frame.DataFrame): Dataframe with OSM objects.
+            objects (gpd.GeoDataFrame): GeoDataFrame with OSM objects.
 
         Yields:
             Generator[list[tuple[int, int]], None, None]: List of point coordinates.
@@ -865,6 +891,7 @@ class Texture(ImageComponent):
             polygon_np = self._to_np(polygon)
             yield polygon_np
 
+    @monitor_performance
     def previews(self) -> list[str]:
         """Invokes methods to generate previews. Returns list of paths to previews.
 

maps4fs/generator/map.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import json
 import os
 import shutil
+from time import perf_counter
 from typing import Any, Generator
 
 from pydtmdl import DTMProvider
@@ -14,8 +15,13 @@ import maps4fs.generator.config as mfscfg
 import maps4fs.generator.utils as mfsutils
 from maps4fs.generator.component import Background, Component, Layer, Satellite, Texture
 from maps4fs.generator.game import Game
+from maps4fs.generator.monitor import PerformanceMonitor, performance_session
 from maps4fs.generator.settings import GenerationSettings, MainSettings, SharedSettings
-from maps4fs.generator.statistics import send_advanced_settings, send_main_settings
+from maps4fs.generator.statistics import (
+    send_advanced_settings,
+    send_main_settings,
+    send_performance_report,
+)
 from maps4fs.logger import Logger
 
 
@@ -203,51 +209,76 @@ class Map:
         Yields:
             Generator[str, None, None]: Component names.
         """
-        self.logger.debug(
-            "Starting map generation. Game code: %s. Coordinates: %s, size: %s. Rotation: %s.",
-            self.game.code,
-            self.coordinates,
-            self.size,
-            self.rotation,
-        )
-        for game_component in self.game.components:
-            component = game_component(
-                self.game,
-                self,
+        with performance_session() as session_id:
+            self.logger.info(
+                "Starting map generation. Game code: %s. Coordinates: %s, size: %s. Rotation: %s.",
+                self.game.code,
                 self.coordinates,
                 self.size,
-                self.rotated_size,
                 self.rotation,
-                self.map_directory,
-                self.logger,
-                texture_custom_schema=self.texture_custom_schema,  # type: ignore
-                tree_custom_schema=self.tree_custom_schema,  # type: ignore
             )
-            self.components.append(component)
-
-            yield component.__class__.__name__
-
-            try:
-                component.process()
-                component.commit_generation_info()
-            except Exception as e:
-                self.logger.error(
-                    "Error processing or committing generation info for component %s: %s",
-                    component.__class__.__name__,
-                    e,
+            generation_start = perf_counter()
+
+            for game_component in self.game.components:
+                component = game_component(
+                    self.game,
+                    self,
+                    self.coordinates,
+                    self.size,
+                    self.rotated_size,
+                    self.rotation,
+                    self.map_directory,
+                    self.logger,
+                    texture_custom_schema=self.texture_custom_schema,  # type: ignore
+                    tree_custom_schema=self.tree_custom_schema,  # type: ignore
                 )
-                self._update_main_settings({"error": str(e)})
-                raise e
+                self.components.append(component)
+
+                yield component.__class__.__name__
+
+                try:
+                    component_start = perf_counter()
+                    component.process()
+                    component_finish = perf_counter()
+                    self.logger.info(
+                        "Component %s processed in %.2f seconds.",
+                        component.__class__.__name__,
+                        component_finish - component_start,
+                    )
+                    component.commit_generation_info()
+                except Exception as e:
+                    self.logger.error(
+                        "Error processing or committing generation info for component %s: %s",
+                        component.__class__.__name__,
+                        e,
+                    )
+                    self._update_main_settings({"error": str(e)})
+                    raise e
+
+            generation_finish = perf_counter()
+            self.logger.info(
+                "Map generation completed in %.2f seconds.",
+                generation_finish - generation_start,
+            )
 
-        self._update_main_settings({"completed": True})
+            self._update_main_settings({"completed": True})
 
-        self.logger.debug(
-            "Map generation completed. Game code: %s. Coordinates: %s, size: %s. Rotation: %s.",
-            self.game.code,
-            self.coordinates,
-            self.size,
-            self.rotation,
-        )
+            self.logger.info(
+                "Map generation completed. Game code: %s. Coordinates: %s, size: %s. Rotation: %s.",
+                self.game.code,
+                self.coordinates,
+                self.size,
+                self.rotation,
+            )
+
+        session_json = PerformanceMonitor().get_session_json(session_id)
+        if session_json:
+            report_filename = "performance_report.json"
+            with open(
+                os.path.join(self.map_directory, report_filename), "w", encoding="utf-8"
+            ) as file:
+                json.dump(session_json, file, indent=4)
+            send_performance_report(session_json)
 
     def _update_main_settings(self, data: dict[str, Any]) -> None:
         """Update main settings with provided data.

maps4fs/generator/monitor.py

@@ -0,0 +1,118 @@
+"""Module for performance monitoring during map generation."""
+
+import functools
+import threading
+import uuid
+from collections import defaultdict
+from contextlib import contextmanager
+from time import perf_counter
+from typing import Callable, Generator
+
+from maps4fs.generator.utils import Singleton
+from maps4fs.logger import Logger
+
+logger = Logger(name="MAPS4FS_MONITOR")
+
+_local = threading.local()
+
+
+def get_current_session() -> str | None:
+    """Get the current session name from thread-local storage."""
+    return getattr(_local, "current_session", None)
+
+
+@contextmanager
+def performance_session(session_id: str | None = None) -> Generator[str, None, None]:
+    """Context manager for performance monitoring session.
+
+    Arguments:
+        session_id (str, optional): Custom session ID. If None, generates UUID.
+    """
+    if session_id is None:
+        session_id = str(uuid.uuid4())
+
+    _local.current_session = session_id
+
+    try:
+        yield session_id
+    finally:
+        _local.current_session = None
+
+
+class PerformanceMonitor(metaclass=Singleton):
+    """Singleton class for monitoring performance metrics."""
+
+    def __init__(self) -> None:
+        self.sessions: dict[str, dict[str, dict[str, float]]] = defaultdict(
+            lambda: defaultdict(lambda: defaultdict(float))
+        )
+
+    def add_record(self, session: str, component: str, function: str, time_taken: float) -> None:
+        """Add a performance record.
+
+        Arguments:
+            session (str): The session name.
+            component (str): The component/class name.
+            function (str): The function/method name.
+            time_taken (float): Time taken in seconds.
+        """
+        self.sessions[session][component][function] += time_taken
+
+    def get_session_json(self, session: str) -> dict[str, dict[str, float]]:
+        """Get performance data for a session in JSON-serializable format.
+
+        Arguments:
+            session (str): The session name.
+
+        Returns:
+            dict[str, dict[str, float]]: Performance data.
+        """
+        return self.sessions.get(session, {})
+
+
+def monitor_performance(func: Callable) -> Callable:
+    """Decorator to monitor performance of methods/functions.
+
+    Arguments:
+        func (callable) -- The function to be monitored.
+
+    Returns:
+        callable -- The wrapped function with performance monitoring.
+    """
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        if args and hasattr(args[0], "__class__"):
+            class_name = args[0].__class__.__name__
+        elif args and hasattr(args[0], "__name__"):
+            class_name = args[0].__name__
+        elif "." in func.__qualname__:
+            class_name = func.__qualname__.split(".")[0]
+        else:
+            class_name = None
+
+        function_name = func.__name__
+
+        start = perf_counter()
+        result = func(*args, **kwargs)
+        end = perf_counter()
+        time_taken = round(end - start, 5)
+
+        session_name = get_current_session()
+
+        try:
+            if session_name and time_taken > 0.001 and class_name:
+                PerformanceMonitor().add_record(session_name, class_name, function_name, time_taken)
+                logger.info(
+                    "[PERFORMANCE] %s | %s | %s | %s",
+                    session_name,
+                    class_name,
+                    function_name,
+                    time_taken,
+                )
+        except Exception:
+            pass
+
+        return result
+
+    return wrapper

maps4fs/generator/statistics.py

@@ -80,3 +80,13 @@ def send_survey(data: dict[str, Any]) -> None:
     """
     endpoint = f"{STATS_HOST}/receive_survey"
     post(endpoint, data)
+
+
+def send_performance_report(data: dict[str, Any]) -> None:
+    """Send performance report to the statistics server.
+
+    Arguments:
+        data (dict[str, Any]): The performance report data to send.
+    """
+    endpoint = f"{STATS_HOST}/receive_performance_report"
+    post(endpoint, data)

maps4fs/generator/utils.py

@@ -158,3 +158,14 @@ def dump_json(filename: str, directory: str, data: dict[Any, Any] | Any | None)
     save_path = os.path.join(directory, filename)
     with open(save_path, "w", encoding="utf-8") as file:
         json.dump(data, file, indent=4)
+
+
+class Singleton(type):
+    """A metaclass for creating singleton classes."""
+
+    _instances: dict[Any, Any] = {}
+
+    def __call__(cls, *args, **kwargs):
+        if cls not in cls._instances:
+            cls._instances[cls] = super().__call__(*args, **kwargs)
+        return cls._instances[cls]

maps4fs/logger.py

@@ -14,8 +14,9 @@ class Logger(logging.Logger):
         self,
         level: Literal["DEBUG", "INFO", "WARNING", "ERROR"] = "INFO",
         to_stdout: bool = True,
+        **kwargs,
     ):
-        super().__init__(LOGGER_NAME)
+        super().__init__(kwargs.pop("name", LOGGER_NAME))
         self.setLevel(level)
         self.stdout_handler = logging.StreamHandler(sys.stdout)
         formatter = "%(name)s | %(levelname)s | %(asctime)s | %(message)s"

{maps4fs-2.8.9.dist-info → maps4fs-2.9.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maps4fs
-Version: 2.8.9
+Version: 2.9.1
 Summary: Generate map templates for Farming Simulator from real places.
 Author-email: iwatkot <iwatkot@gmail.com>
 License: GNU Affero General Public License v3.0

maps4fs-2.9.1.dist-info/RECORD

@@ -0,0 +1,30 @@
+maps4fs/__init__.py,sha256=5ixsCA5vgcIV0OrF9EJBm91Mmc_KfMiDRM-QyifMAvo,386
+maps4fs/logger.py,sha256=aZAa9glzgvH6ySVDLelSPTwHfWZtpGK5YBl-ufNUsPg,801
+maps4fs/generator/__init__.py,sha256=zZMLEkGzb4z0xql650gOtGSvcgX58DnJ2yN3vC2daRk,43
+maps4fs/generator/config.py,sha256=dHJLBt-Ua5rMMvUujAa3cuPSYvDA7tgfY7Z8tpvT_zo,7176
+maps4fs/generator/game.py,sha256=_LNiH__7FeSGsPKsuvAGiktt5GcJQVqcQYtsFZNWGyM,16106
+maps4fs/generator/map.py,sha256=ak74FNSDQXPqaB0gOaZqVo8Sy0fvf_3iXHg6FJkHPpA,15888
+maps4fs/generator/monitor.py,sha256=IqNZ6vLlw3vS1dHQ3RPFcGHkKwRfPOPVFy2IR2-wWsE,3523
+maps4fs/generator/qgis.py,sha256=Es8hLuqN_KH8lDfnJE6He2rWYbAKJ3RGPn-o87S6CPI,6116
+maps4fs/generator/settings.py,sha256=_QJL4ikQYLFOIB1zWqXjYvyLfoh3cr2RYb2IzsunMJg,13405
+maps4fs/generator/statistics.py,sha256=ol0MTiehcCbQFfyYA7cKU-M4_cjiLCktnGbid4GYABU,2641
+maps4fs/generator/utils.py,sha256=FOkJZrBifGLfEd33noL6AqfV_oW5cM-GQjXHNxzIKv4,5132
+maps4fs/generator/component/__init__.py,sha256=s01yVVVi8R2xxNvflu2D6wTd9I_g73AMM2x7vAC7GX4,490
+maps4fs/generator/component/background.py,sha256=c2bjK3DkQXvA6Gtb_hUM9m-7fIVgp2BxJp09c4ZY3_A,49434
+maps4fs/generator/component/config.py,sha256=tI2RQaGIqBgJIi9KjYfMZZ8AWg_YVUm6KKsBHGV241g,31285
+maps4fs/generator/component/dem.py,sha256=vMVJtU2jAS-2lfB9JsqodZsrUvY1h5xr3Dh5qk6txwk,11895
+maps4fs/generator/component/grle.py,sha256=uOd0dP-TeS85SZ87wafVj7AQv8L5VSdg2O0pDrtm_p0,27500
+maps4fs/generator/component/i3d.py,sha256=t6Y9JPXvKJ91wTBg_-noIsxDPk1OSdY9EwM5ZtgOl9Q,26771
+maps4fs/generator/component/layer.py,sha256=bdy1XGOODyPqYUM3b_wEY2H9Piz-AaHsCDecl-qRHiM,6627
+maps4fs/generator/component/satellite.py,sha256=1bPqd8JqAPqU0tEI9m-iuljMW9hXqlaCIxvq7kdpMY0,5219
+maps4fs/generator/component/texture.py,sha256=FF2x6F2d5MRD3mls_m7z0JpnfmQVyoUkThJpXt1PMPM,38087
+maps4fs/generator/component/base/__init__.py,sha256=zZMLEkGzb4z0xql650gOtGSvcgX58DnJ2yN3vC2daRk,43
+maps4fs/generator/component/base/component.py,sha256=-7H3donrH19f0_rivNyI3fgLsiZkntXfGywEx4tOnM4,23924
+maps4fs/generator/component/base/component_image.py,sha256=GXFkEFARNRkWkDiGSjvU4WX6f_8s6R1t2ZYqZflv1jk,9626
+maps4fs/generator/component/base/component_mesh.py,sha256=UgtycniJ1anN81R9188D9xewGOFR22nA2TW9mmBGZlU,25878
+maps4fs/generator/component/base/component_xml.py,sha256=MT-VhU2dEckLFxAgmxg6V3gnv11di_94Qq6atfpOLdc,5342
+maps4fs-2.9.1.dist-info/licenses/LICENSE.md,sha256=Ptw8AkqJ60c4tRts6yuqGP_8B0dxwOGmJsp6YJ8dKqM,34328
+maps4fs-2.9.1.dist-info/METADATA,sha256=sHHN63IF4C9aZplKg50vjhx5jkSwIhI8c49vPeJeGF4,10042
+maps4fs-2.9.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+maps4fs-2.9.1.dist-info/top_level.txt,sha256=Ue9DSRlejRQRCaJueB0uLcKrWwsEq9zezfv5dI5mV1M,8
+maps4fs-2.9.1.dist-info/RECORD,,

maps4fs-2.8.9.dist-info/RECORD

@@ -1,29 +0,0 @@
-maps4fs/__init__.py,sha256=5ixsCA5vgcIV0OrF9EJBm91Mmc_KfMiDRM-QyifMAvo,386
-maps4fs/logger.py,sha256=6sem0aFKQqtVjQ_yNu9iGcc-hqzLQUhfxco05K6nqow,763
-maps4fs/generator/__init__.py,sha256=zZMLEkGzb4z0xql650gOtGSvcgX58DnJ2yN3vC2daRk,43
-maps4fs/generator/config.py,sha256=dHJLBt-Ua5rMMvUujAa3cuPSYvDA7tgfY7Z8tpvT_zo,7176
-maps4fs/generator/game.py,sha256=_LNiH__7FeSGsPKsuvAGiktt5GcJQVqcQYtsFZNWGyM,16106
-maps4fs/generator/map.py,sha256=ZZRU8x0feGbgeJgxc0D3N-mfiasyFXxj6gbGyl-WRzE,14528
-maps4fs/generator/qgis.py,sha256=Es8hLuqN_KH8lDfnJE6He2rWYbAKJ3RGPn-o87S6CPI,6116
-maps4fs/generator/settings.py,sha256=_QJL4ikQYLFOIB1zWqXjYvyLfoh3cr2RYb2IzsunMJg,13405
-maps4fs/generator/statistics.py,sha256=ciklaj_giopr2ShYE1_Xy9sJop9qWLmb_IZ-qgAq2b8,2348
-maps4fs/generator/utils.py,sha256=ugdQ8C22NeiZLIlldLoEKCc7ioOefz4W-8qF2eOy9qU,4834
-maps4fs/generator/component/__init__.py,sha256=s01yVVVi8R2xxNvflu2D6wTd9I_g73AMM2x7vAC7GX4,490
-maps4fs/generator/component/background.py,sha256=tFWdYASUUZsJ8QiQrxxba-6aMECD3hvpd0pMm_UdrH8,46151
-maps4fs/generator/component/config.py,sha256=OPDhQyALt6h8r70SU26qPcS1NwlfhuM97Q_LfjPJFKs,31127
-maps4fs/generator/component/dem.py,sha256=FPqcXmFQg5MPaGuy4g5kxzvY1wbhozeCf-aNMCj5eaU,11687
-maps4fs/generator/component/grle.py,sha256=0PC1K829wjD4y4d9qfIbnU29ebjflIPBbwIZx8FXwc8,27242
-maps4fs/generator/component/i3d.py,sha256=RvpiW9skkZ6McyahC-AeIdPuSQjpXiFs1l0xOioJAu4,26638
-maps4fs/generator/component/layer.py,sha256=bdy1XGOODyPqYUM3b_wEY2H9Piz-AaHsCDecl-qRHiM,6627
-maps4fs/generator/component/satellite.py,sha256=JeQg4CGDSFir937ugbj30yliw6wftwfM9rCEc0uDcwc,5111
-maps4fs/generator/component/texture.py,sha256=AjN1RsnVLtL7F13B_va6psKTTPc_0JCEznjT5mb1vKo,37309
-maps4fs/generator/component/base/__init__.py,sha256=zZMLEkGzb4z0xql650gOtGSvcgX58DnJ2yN3vC2daRk,43
-maps4fs/generator/component/base/component.py,sha256=-7H3donrH19f0_rivNyI3fgLsiZkntXfGywEx4tOnM4,23924
-maps4fs/generator/component/base/component_image.py,sha256=GXFkEFARNRkWkDiGSjvU4WX6f_8s6R1t2ZYqZflv1jk,9626
-maps4fs/generator/component/base/component_mesh.py,sha256=S5M_SU-FZz17-LgzTIM935ms1Vc4O06UQNTEN4e0INU,24729
-maps4fs/generator/component/base/component_xml.py,sha256=MT-VhU2dEckLFxAgmxg6V3gnv11di_94Qq6atfpOLdc,5342
-maps4fs-2.8.9.dist-info/licenses/LICENSE.md,sha256=Ptw8AkqJ60c4tRts6yuqGP_8B0dxwOGmJsp6YJ8dKqM,34328
-maps4fs-2.8.9.dist-info/METADATA,sha256=c5om5AlUIKRcE13_Tu54VHdCwxEeK6S5y12up1CCvPQ,10042
-maps4fs-2.8.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-maps4fs-2.8.9.dist-info/top_level.txt,sha256=Ue9DSRlejRQRCaJueB0uLcKrWwsEq9zezfv5dI5mV1M,8
-maps4fs-2.8.9.dist-info/RECORD,,