maps4fs 2.8.9__py3-none-any.whl → 2.9.37__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,12 @@ 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.not_resized_with_flattened_roads_path: str = os.path.join(
+            self.background_directory, "not_resized_with_flattened_roads.png"
+        )
 
         self.flatten_water_to: int | None = None
 
@@ -141,6 +149,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 +255,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 +338,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 +373,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 +439,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 +511,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 +567,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 +748,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 +801,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:
@@ -806,6 +826,10 @@ class Background(MeshComponent, ImageComponent):
 
         if self.map.background_settings.flatten_water:
             try:
+                # Check if there are any water pixels (255) in the water resources image.
+                if not np.any(water_resources_image == 255):
+                    self.logger.warning("No water pixels found in water resources image.")
+                    return
                 mask = water_resources_image == 255
                 flatten_to = int(np.mean(dem_image[mask]) - subtract_by)  # type: ignore
                 self.flatten_water_to = flatten_to  # type: ignore
@@ -845,13 +869,14 @@ class Background(MeshComponent, ImageComponent):
         """
         self.logger.debug("Starting line-based water generation...")
         water_polygons = self.get_infolayer_data(Parameters.BACKGROUND, Parameters.WATER)
-        self.logger.debug(
-            "Found %s water polygons in background info layer.", len(water_polygons)  # type: ignore
-        )
         if not water_polygons:
             self.logger.warning("No water polygons found in background info layer.")
             return
 
+        self.logger.debug(
+            "Found %s water polygons in background info layer.", len(water_polygons)  # type: ignore
+        )
+
         polygons: list[shapely.Polygon] = []
         for polygon_points in water_polygons:
             if not polygon_points or len(polygon_points) < 2:
@@ -967,6 +992,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 +1059,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,46 +1113,92 @@ 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)
+            # 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)
 
-            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)
+            road_distances_from_start = np.array(road_distances_from_start)  # type: ignore
 
-                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
+            # Interpolate elevation values based on distance along road
+            interpolated_elevations = np.interp(
+                road_distances_from_start, large_distances, segment_elevations
+            )
 
-                mean_value = cv2.mean(dem_image, mask=mask)[0]  # type: ignore
-                dem_image[mask == 255] = mean_value
-                full_mask[mask == 255] = 255
+            # 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)
         dem_image = self.blur_edges_by_mask(dem_image, full_mask)
 
+        # Save the not resized DEM with flattened roads.
+        cv2.imwrite(self.not_resized_with_flattened_roads_path, dem_image)
+        self.logger.debug(
+            "Not resized DEM with flattened roads saved to: %s",
+            self.not_resized_with_flattened_roads_path,
+        )
+
         output_size = dem_image.shape[0] + 1
         resized_dem = cv2.resize(
             dem_image, (output_size, output_size), interpolation=cv2.INTER_NEAREST

maps4fs/generator/component/base/component_mesh.py

@@ -595,19 +595,45 @@ 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}")
-
-            if has_normals:
-                n = mesh.vertex_normals[idx]
-                v_el.set("n", f"{n[0]:.6f} {n[1]:.6f} {n[2]:.6f}")
-
-            if has_uv:
-                uv = mesh.visual.uv[idx]
-                v_el.set("t0", f"{uv[0]:.6f} {uv[1]:.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]
+            )
+
+        uv_strings = None
+        if has_uv:
+            uv_strings = np.array([f"{uv[0]:.6f} {uv[1]:.6f}" for uv in mesh.visual.uv])
+
+        # 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])  # type: ignore
+
+                if has_uv:
+                    v_el.set("t0", uv_strings[idx])  # type: ignore
+
+                batch_elements.append(v_el)
+
+            vertex_elements.extend(batch_elements)
+
+        # Add all vertex elements at once
+        xml_vertices.extend(vertex_elements)
 
         # Triangles block
         xml_tris = ET.SubElement(shape, "Triangles")