maps4fs 2.9.0__tar.gz → 2.9.1__tar.gz

{maps4fs-2.9.0 → maps4fs-2.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maps4fs
-Version: 2.9.0
+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.0 → maps4fs-2.9.1}/maps4fs/generator/component/background.py

@@ -78,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
 
@@ -561,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
 
@@ -1047,11 +1054,21 @@ class Background(MeshComponent, ImageComponent):
     @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
@@ -1088,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-2.9.0 → maps4fs-2.9.1}/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-2.9.0 → maps4fs-2.9.1}/maps4fs/generator/component/texture.py

@@ -562,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.logger.debug("Dissolving layer from %s to %s.", layer_path, layer_paths)
+            self.dissolve_layer(layer)
 
-            # 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.

{maps4fs-2.9.0 → maps4fs-2.9.1}/maps4fs/generator/monitor.py

@@ -9,6 +9,9 @@ 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()
 
@@ -100,6 +103,13 @@ def monitor_performance(func: Callable) -> Callable:
         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
 

{maps4fs-2.9.0 → maps4fs-2.9.1}/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.9.0 → maps4fs-2.9.1}/maps4fs.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maps4fs
-Version: 2.9.0
+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.0 → maps4fs-2.9.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "maps4fs"
-version = "2.9.0"
+version = "2.9.1"
 description = "Generate map templates for Farming Simulator from real places."
 authors = [{name = "iwatkot", email = "iwatkot@gmail.com"}]
 license = {text = "GNU Affero General Public License v3.0"}