maps4fs 2.0.6__tar.gz → 2.0.8__tar.gz

{maps4fs-2.0.6 → maps4fs-2.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maps4fs
-Version: 2.0.6
+Version: 2.0.8
 Summary: Generate map templates for Farming Simulator from real places.
 Author-email: iwatkot <iwatkot@gmail.com>
 License: Apache License 2.0

{maps4fs-2.0.6 → maps4fs-2.0.8}/maps4fs/generator/component/background.py

@@ -10,6 +10,8 @@ from typing import Any
 
 import cv2
 import numpy as np
+import shapely
+import trimesh
 from tqdm import tqdm
 from trimesh import Trimesh
 
@@ -144,7 +146,7 @@ class Background(MeshComponent, ImageComponent):
                 self.logger.debug("Could not create mask for building with error: %s", e)
                 continue
 
-            mean_value = cv2.mean(dem_image, mask=mask)[0]
+            mean_value = cv2.mean(dem_image, mask=mask)[0]  # type: ignore
             mean_value = np.round(mean_value).astype(dem_image.dtype)
             self.logger.debug("Mean value of the building area: %s", mean_value)
 
@@ -231,13 +233,13 @@ class Background(MeshComponent, ImageComponent):
         if self.map.output_size is not None:
             scaled_background_size = int(self.background_size * self.map.size_scale)
             dem_data = cv2.resize(
-                dem_data,
+                dem_data,  # type: ignore
                 (scaled_background_size, scaled_background_size),
                 interpolation=cv2.INTER_NEAREST,
             )
 
         self.plane_from_np(
-            dem_data,
+            dem_data,  # type: ignore
             save_path,
             create_preview=True,
             remove_center=self.map.background_settings.remove_center,
@@ -255,7 +257,7 @@ class Background(MeshComponent, ImageComponent):
         """
         dem_data = cv2.imread(dem_path, cv2.IMREAD_UNCHANGED)
         half_size = self.map_size // 2
-        dem_data = self.cut_out_np(dem_data, half_size, return_cutout=True)
+        dem_data = self.cut_out_np(dem_data, half_size, return_cutout=True)  # type: ignore
 
         if save_path:
             cv2.imwrite(save_path, dem_data)
@@ -362,7 +364,7 @@ class Background(MeshComponent, ImageComponent):
         background_dem_preview_image = cv2.imread(self.output_path, cv2.IMREAD_UNCHANGED)
 
         background_dem_preview_image = cv2.resize(
-            background_dem_preview_image, (0, 0), fx=1 / 4, fy=1 / 4
+            background_dem_preview_image, (0, 0), fx=1 / 4, fy=1 / 4  # type: ignore
         )
         background_dem_preview_image = cv2.normalize(
             background_dem_preview_image,
@@ -411,7 +413,7 @@ class Background(MeshComponent, ImageComponent):
         self.logger.debug("Creating grayscale preview of DEM data in %s.", grayscale_dem_path)
 
         dem_data = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)
-        dem_data_rgb = cv2.cvtColor(dem_data, cv2.COLOR_GRAY2RGB)
+        dem_data_rgb = cv2.cvtColor(dem_data, cv2.COLOR_GRAY2RGB)  # type: ignore
         cv2.imwrite(grayscale_dem_path, dem_data_rgb)
         return grayscale_dem_path
 
@@ -435,7 +437,7 @@ class Background(MeshComponent, ImageComponent):
         dem_data_normalized = np.empty_like(dem_data)
 
         # Normalize the DEM data to the range [0, 255]
-        cv2.normalize(dem_data, dem_data_normalized, 0, 255, cv2.NORM_MINMAX)
+        cv2.normalize(dem_data, dem_data_normalized, 0, 255, cv2.NORM_MINMAX)  # type: ignore
         dem_data_colored = cv2.applyColorMap(dem_data_normalized, cv2.COLORMAP_JET)
 
         cv2.imwrite(colored_dem_path, dem_data_colored)
@@ -470,6 +472,7 @@ class Background(MeshComponent, ImageComponent):
             logger=self.logger,
             texture_custom_schema=background_layers,  # type: ignore
             skip_scaling=True,  # type: ignore
+            info_layer_path=os.path.join(self.info_layers_directory, "background.json"),  # type: ignore
         )
 
         self.background_texture.preprocess()
@@ -513,8 +516,8 @@ class Background(MeshComponent, ImageComponent):
         )
 
         dem_image = self.subtract_by_mask(
-            dem_image,
-            water_resources_image,
+            dem_image,  # type: ignore
+            water_resources_image,  # type: ignore
             int(self.map.dem_settings.water_depth * z_scaling_factor),
         )
 
@@ -534,8 +537,135 @@ class Background(MeshComponent, ImageComponent):
 
         return blur_power
 
+    def generate_linebased_water(self) -> None:
+        """Generates water resources based on line-based polylines from the background info layer.
+        It creates polygons from the polylines, fits them into the map bounds, and generates a mesh.
+        """
+        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
+
+        polygons: list[shapely.Polygon] = []
+        for polygon_points in water_polygons:
+            if not polygon_points or len(polygon_points) < 2:
+                self.logger.warning("Skipping polygon with insufficient points...")
+                continue
+
+            polygon = shapely.Polygon(polygon_points)
+
+            if polygon.is_empty or not polygon.is_valid:
+                self.logger.warning("Skipping empty or invalid polygon...")
+                continue
+
+            # Make Polygon a little bit bigger to hide under the terrain when creating water planes.
+            polygon = polygon.buffer(Parameters.WATER_ADD_WIDTH, resolution=4)
+
+            polygons.append(polygon)
+
+        fitted_polygons = []
+        for polygon in polygons:
+            try:
+                fitted_polygon_points = self.fit_object_into_bounds(
+                    polygon_points=polygon.exterior.coords,
+                    angle=self.rotation,
+                    canvas_size=self.background_size,
+                )
+                fitted_polygon = shapely.Polygon(fitted_polygon_points)
+                fitted_polygons.append(fitted_polygon)
+            except Exception as e:
+                self.logger.warning(
+                    "Could not fit polygon into bounds with error: %s, polygon: %s", e, polygon
+                )
+                continue
+
+        if not fitted_polygons:
+            self.logger.warning("No valid water polygons created from polylines.")
+            return
+
+        # Create a mesh from the 3D polygons
+        mesh = self.mesh_from_3d_polygons(fitted_polygons)
+        if mesh is None:
+            self.logger.warning("No mesh could be created from the water polygons.")
+            return
+        self.logger.debug("Created mesh from %s water polygons.", len(fitted_polygons))
+
+        mesh = self.rotate_mesh(mesh)
+        mesh = self.invert_faces(mesh)
+
+        line_based_save_path = os.path.join(self.water_directory, "line_based_water.obj")
+        mesh.export(line_based_save_path)
+        self.logger.debug("Line-based water mesh saved to %s", line_based_save_path)
+
+    def mesh_from_3d_polygons(self, polygons: list[shapely.Polygon]) -> Trimesh | None:
+        """Create a simple mesh from a list of 3D shapely Polygons.
+        Each polygon must be flat (all Z the same or nearly the same for each polygon).
+        Returns a single Trimesh mesh.
+
+        Arguments:
+            polygons (list[shapely.Polygon]): List of 3D shapely Polygons to create the mesh from.
+
+        Returns:
+            Trimesh: A single Trimesh object containing the mesh created from the polygons.
+        """
+
+        all_vertices = []
+        all_faces = []
+        vertex_offset = 0
+
+        not_resized_dem = cv2.imread(self.not_resized_path, cv2.IMREAD_UNCHANGED)
+
+        for polygon in polygons:
+            # Get exterior 3D coordinates
+            exterior_coords = np.array(polygon.exterior.coords)
+            # Project to 2D for triangulation
+            exterior_2d = exterior_coords[:, :2]
+            poly_2d = shapely.geometry.Polygon(
+                exterior_2d, [np.array(ring.coords)[:, :2] for ring in polygon.interiors]
+            )
+
+            # Triangulate in 2D
+            vertices_2d, faces = trimesh.creation.triangulate_polygon(poly_2d)
+            # tris.vertices is 2D, tris.faces are indices
+
+            # Map 2D triangulated vertices back to 3D by matching to original 3D coords
+            vertices_3d = []
+            for v in vertices_2d:
+                # Find closest original 2D point to get Z
+                dists = np.linalg.norm(exterior_2d - v[:2], axis=1)
+                idx = np.argmin(dists)
+                # z = exterior_coords[idx, 2]
+                z = self.get_z_coordinate_from_dem(
+                    not_resized_dem, exterior_coords[idx, 0], exterior_coords[idx, 1]  # type: ignore
+                )
+                vertices_3d.append([v[0], v[1], z])
+            vertices_3d = np.array(vertices_3d)  # type: ignore
+
+            faces = faces + vertex_offset
+            all_vertices.append(vertices_3d)
+            all_faces.append(faces)
+            vertex_offset += len(vertices_3d)
+
+        if not all_vertices:
+            return None
+
+        vertices = np.vstack(all_vertices)
+        faces = np.vstack(all_faces)
+        mesh = trimesh.Trimesh(vertices=vertices, faces=faces, process=False)
+        return mesh
+
     def generate_water_resources_obj(self) -> None:
         """Generates 3D obj files based on water resources data."""
+        self.logger.debug("Starting water resources generation...")
+        try:
+            self.generate_linebased_water()
+        except Exception as e:
+            self.logger.error("Error during line-based water generation: %s", e)
+
         if not os.path.isfile(self.water_resources_path):
             self.logger.warning("Water resources texture not found.")
             return
@@ -544,12 +674,12 @@ class Background(MeshComponent, ImageComponent):
         plane_water = cv2.imread(self.water_resources_path, cv2.IMREAD_UNCHANGED)
 
         # Check if the image contains non-zero values.
-        if not np.any(plane_water):
+        if not np.any(plane_water):  # type: ignore
             self.logger.debug("Water resources image is empty, skipping water generation.")
             return
 
         dilated_plane_water = cv2.dilate(
-            plane_water.astype(np.uint8), np.ones((5, 5), np.uint8), iterations=5
+            plane_water.astype(np.uint8), np.ones((5, 5), np.uint8), iterations=5  # type: ignore
         ).astype(np.uint8)
         plane_save_path = os.path.join(self.water_directory, "plane_water.obj")
         self.plane_from_np(dilated_plane_water, plane_save_path, include_zeros=False)
@@ -560,12 +690,12 @@ class Background(MeshComponent, ImageComponent):
         if self.map.output_size is not None:
             scaled_background_size = int(self.background_size * self.map.size_scale)
             plane_water = cv2.resize(
-                plane_water,
+                plane_water,  # type: ignore
                 (scaled_background_size, scaled_background_size),
                 interpolation=cv2.INTER_NEAREST,
             )
             background_dem = cv2.resize(
-                background_dem,
+                background_dem,  # type: ignore
                 (scaled_background_size, scaled_background_size),
                 interpolation=cv2.INTER_NEAREST,
             )
@@ -574,20 +704,20 @@ class Background(MeshComponent, ImageComponent):
             # Apply Gaussian blur to the background dem.
             blur_power = self._get_blur_power()
             background_dem = cv2.GaussianBlur(
-                background_dem, (blur_power, blur_power), sigmaX=blur_power, sigmaY=blur_power
+                background_dem, (blur_power, blur_power), sigmaX=blur_power, sigmaY=blur_power  # type: ignore
             )
 
         # Remove all the values from the background dem where the plane_water is 0.
-        background_dem[plane_water == 0] = 0
+        background_dem[plane_water == 0] = 0  # type: ignore
 
         # Dilate the background dem to make the water more smooth.
-        elevated_water = cv2.dilate(background_dem, np.ones((3, 3), np.uint16), iterations=10)
+        elevated_water = cv2.dilate(background_dem, np.ones((3, 3), np.uint16), iterations=10)  # type: ignore
 
         # Use the background dem as a mask to prevent the original values from being overwritten.
-        mask = background_dem > 0
+        mask = background_dem > 0  # type: ignore
 
         # Combine the dilated background dem with non-dilated background dem.
-        elevated_water = np.where(mask, background_dem, elevated_water)
+        elevated_water = np.where(mask, background_dem, elevated_water)  # type: ignore
         elevated_save_path = os.path.join(self.water_directory, "elevated_water.obj")
 
         self.assets.water_mesh = elevated_save_path

{maps4fs-2.0.6 → maps4fs-2.0.8}/maps4fs/generator/component/base/component.py

@@ -8,6 +8,7 @@ from copy import deepcopy
 from typing import TYPE_CHECKING, Any
 
 import cv2
+import numpy as np
 import osmnx as ox
 from pyproj import Transformer
 from shapely.affinity import rotate, translate
@@ -363,6 +364,7 @@ class Component:
         margin: int = 0,
         angle: int = 0,
         border: int = 0,
+        canvas_size: int | None = None,
     ) -> list[tuple[int, int]]:
         """Fits a polygon into the bounds of the map.
 
@@ -379,8 +381,10 @@ class Component:
         if polygon_points is None and linestring_points is None:
             raise ValueError("Either polygon or linestring points must be provided.")
 
+        limit = canvas_size or self.scaled_size
+
         min_x = min_y = 0 + border
-        max_x = max_y = self.scaled_size - border
+        max_x = max_y = limit - border
 
         object_type = Polygon if polygon_points else LineString
 
@@ -586,3 +590,24 @@ class Component:
             int: The output size of the map or the map size.
         """
         return self.map_size if self.map.output_size is None else self.map.output_size
+
+    def get_z_coordinate_from_dem(self, not_resized_dem: np.ndarray, x: int, y: int) -> float:
+        """Gets the Z coordinate from the DEM image for the given coordinates.
+
+        Arguments:
+            not_resized_dem (np.ndarray): The not resized DEM image.
+            x (int): The x coordinate.
+            y (int): The y coordinate.
+
+        Returns:
+            float: The Z coordinate.
+        """
+        dem_x_size, dem_y_size = not_resized_dem.shape
+
+        x = int(max(0, min(x, dem_x_size - 1)))
+        y = int(max(0, min(y, dem_y_size - 1)))
+
+        z = not_resized_dem[y, x]
+        z *= self.get_z_scaling_factor(ignore_height_scale_multiplier=True)
+
+        return z

{maps4fs-2.0.6 → maps4fs-2.0.8}/maps4fs/generator/component/base/component_mesh.py

@@ -252,3 +252,18 @@ class MeshComponent(Component):
         distance = int(round(x_size) / 2)
         mesh_copy.apply_translation([-distance, distance, 0])
         return mesh_copy
+
+    @staticmethod
+    def invert_faces(mesh: trimesh.Trimesh) -> trimesh.Trimesh:
+        """
+        Inverts the faces (normals) of the mesh by reversing the order of indices in each face.
+
+        Arguments:
+            mesh (trimesh.Trimesh): The mesh whose faces are to be inverted.
+
+        Returns:
+            trimesh.Trimesh: A new mesh with inverted faces.
+        """
+        mesh_copy = mesh.copy()
+        mesh_copy.faces = mesh_copy.faces[:, ::-1]
+        return mesh_copy

{maps4fs-2.0.6 → maps4fs-2.0.8}/maps4fs/generator/component/grle.py

@@ -118,14 +118,14 @@ class GRLE(ImageComponent, XMLComponent):
             # Resize the preview image to the maximum size allowed for previews.
             image = cv2.imread(preview_path, cv2.IMREAD_GRAYSCALE)
             if (
-                image.shape[0] > Parameters.PREVIEW_MAXIMUM_SIZE
-                or image.shape[1] > Parameters.PREVIEW_MAXIMUM_SIZE
+                image.shape[0] > Parameters.PREVIEW_MAXIMUM_SIZE  # type: ignore
+                or image.shape[1] > Parameters.PREVIEW_MAXIMUM_SIZE  # type: ignore
             ):
                 image = cv2.resize(
-                    image, (Parameters.PREVIEW_MAXIMUM_SIZE, Parameters.PREVIEW_MAXIMUM_SIZE)
+                    image, (Parameters.PREVIEW_MAXIMUM_SIZE, Parameters.PREVIEW_MAXIMUM_SIZE)  # type: ignore
                 )
             image_normalized = np.empty_like(image)
-            cv2.normalize(image, image_normalized, 0, 255, cv2.NORM_MINMAX)
+            cv2.normalize(image, image_normalized, 0, 255, cv2.NORM_MINMAX)  # type: ignore
             image_colored = cv2.applyColorMap(image_normalized, cv2.COLORMAP_JET)
             cv2.imwrite(save_path, image_colored)
             preview_paths.append(save_path)
@@ -163,7 +163,7 @@ class GRLE(ImageComponent, XMLComponent):
             return None
         fields_np = cv2.imread(fields_layer_path)
         # Resize fields_np to the same size as farmlands_np.
-        fields_np = cv2.resize(fields_np, (farmlands_np.shape[1], farmlands_np.shape[0]))
+        fields_np = cv2.resize(fields_np, (farmlands_np.shape[1], farmlands_np.shape[0]))  # type: ignore
 
         # 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)
@@ -235,7 +235,7 @@ class GRLE(ImageComponent, XMLComponent):
                 break
 
             try:
-                cv2.fillPoly(image, [farmland_np], (float(farmland_id),))
+                cv2.fillPoly(image, [farmland_np], (float(farmland_id),))  # type: ignore
             except Exception as e:
                 self.logger.debug(
                     "Farmland %s could not be added to the InfoLayer PNG file with error: %s",
@@ -257,9 +257,9 @@ class GRLE(ImageComponent, XMLComponent):
 
         # Replace all the zero values on the info layer image with 255.
         if self.map.grle_settings.fill_empty_farmlands:
-            image[image == 0] = 255
+            image[image == 0] = 255  # type: ignore
 
-        cv2.imwrite(info_layer_farmlands_path, image)
+        cv2.imwrite(info_layer_farmlands_path, image)  # type: ignore
 
         self.assets.farmlands = info_layer_farmlands_path
 
@@ -303,8 +303,8 @@ class GRLE(ImageComponent, XMLComponent):
         # Density map of the fruits is 2X size of the base image, so we need to resize it.
         # We'll resize the base image to make it bigger, so we can compare the values.
         grass_image = cv2.resize(
-            grass_image,
-            (grass_image.shape[1] * 2, grass_image.shape[0] * 2),
+            grass_image,  # type: ignore
+            (grass_image.shape[1] * 2, grass_image.shape[0] * 2),  # type: ignore
             interpolation=cv2.INTER_NEAREST,
         )
         if forest_image is not None:
@@ -352,15 +352,15 @@ class GRLE(ImageComponent, XMLComponent):
         # Three channeled 8-bit image, where non-zero values are the
         # different types of plants (only in the R channel).
         density_map_fruits = cv2.imread(density_map_fruit_path, cv2.IMREAD_UNCHANGED)
-        self.logger.debug("Density map for fruits loaded, shape: %s.", density_map_fruits.shape)
+        self.logger.debug("Density map for fruits loaded, shape: %s.", density_map_fruits.shape)  # type: ignore
 
         # Put the updated base image as the B channel in the density map.
-        density_map_fruits[:, :, 0] = grass_image_copy
+        density_map_fruits[:, :, 0] = grass_image_copy  # type: ignore
         self.logger.debug("Updated base image added as the B channel in the density map.")
 
         # Save the updated density map.
         # Ensure that order of channels is correct because CV2 uses BGR and we need RGB.
-        density_map_fruits = cv2.cvtColor(density_map_fruits, cv2.COLOR_BGR2RGB)
+        density_map_fruits = cv2.cvtColor(density_map_fruits, cv2.COLOR_BGR2RGB)  # type: ignore
         cv2.imwrite(density_map_fruit_path, density_map_fruits)
 
         self.assets.plants = density_map_fruit_path

{maps4fs-2.0.6 → maps4fs-2.0.8}/maps4fs/generator/component/i3d.py

@@ -543,7 +543,7 @@ class I3d(XMLComponent):
 
             forest_image = cv2.imread(forest_image_path, cv2.IMREAD_UNCHANGED)
             for x, y in self.non_empty_pixels(
-                forest_image, step=self.map.i3d_settings.forest_density
+                forest_image, step=self.map.i3d_settings.forest_density  # type: ignore
             ):
                 shifted_x, shifted_y = self.randomize_coordinates(
                     (x, y),
@@ -638,24 +638,3 @@ class I3d(XMLComponent):
         not_resized_dem = cv2.imread(background_component.not_resized_path, cv2.IMREAD_UNCHANGED)
 
         return not_resized_dem
-
-    def get_z_coordinate_from_dem(self, not_resized_dem: np.ndarray, x: int, y: int) -> float:
-        """Gets the Z coordinate from the DEM image for the given coordinates.
-
-        Arguments:
-            not_resized_dem (np.ndarray): The not resized DEM image.
-            x (int): The x coordinate.
-            y (int): The y coordinate.
-
-        Returns:
-            float: The Z coordinate.
-        """
-        dem_x_size, dem_y_size = not_resized_dem.shape
-
-        x = int(max(0, min(x, dem_x_size - 1)))
-        y = int(max(0, min(y, dem_y_size - 1)))
-
-        z = not_resized_dem[y, x]
-        z *= self.get_z_scaling_factor(ignore_height_scale_multiplier=True)
-
-        return z

{maps4fs-2.0.6 → maps4fs-2.0.8}/maps4fs/generator/component/texture.py

@@ -44,7 +44,10 @@ class Texture(ImageComponent):
         os.makedirs(self.procedural_dir, exist_ok=True)
 
         self.info_save_path = os.path.join(self.map_directory, "generation_info.json")
-        self.info_layer_path = os.path.join(self.info_layers_directory, "textures.json")
+        if not self.kwargs.get("info_layer_path"):
+            self.info_layer_path = os.path.join(self.info_layers_directory, "textures.json")
+        else:
+            self.info_layer_path = self.kwargs["info_layer_path"]  # type: ignore
 
     def read_layers(self, layers_schema: list[dict[str, Any]]) -> None:
         """Reads layers from the schema.
@@ -174,9 +177,9 @@ class Texture(ImageComponent):
             if not border:
                 continue
 
-            self.transfer_border(layer_image, base_layer_image, border)
+            self.transfer_border(layer_image, base_layer_image, border)  # type: ignore
 
-            cv2.imwrite(layer.path(self._weights_dir), layer_image)
+            cv2.imwrite(layer.path(self._weights_dir), layer_image)  # type: ignore
             self.logger.debug("Borders added to layer %s.", layer.name)
 
         if base_layer_image is not None:
@@ -261,7 +264,7 @@ class Texture(ImageComponent):
                     self.logger.debug("Scaling layer %s.", layer_path)
                     img = cv2.imread(layer_path, cv2.IMREAD_UNCHANGED)
                     img = cv2.resize(
-                        img,
+                        img,  # type: ignore
                         (self.map.output_size, self.map.output_size),
                         interpolation=cv2.INTER_NEAREST,
                     )
@@ -384,12 +387,12 @@ class Texture(ImageComponent):
                 self.logger.debug("First layer, creating new cumulative image.")
                 cumulative_image = layer_image
 
-            mask = cv2.bitwise_not(cumulative_image)
-            self._draw_layer(layer, info_layer_data, layer_image)
+            mask = cv2.bitwise_not(cumulative_image)  # type: ignore
+            self._draw_layer(layer, info_layer_data, layer_image)  # type: ignore
             self._add_roads(layer, info_layer_data)
 
-            output_image = cv2.bitwise_and(layer_image, mask)
-            cumulative_image = cv2.bitwise_or(cumulative_image, output_image)
+            output_image = cv2.bitwise_and(layer_image, mask)  # type: ignore
+            cumulative_image = cv2.bitwise_or(cumulative_image, output_image)  # type: ignore
 
             cv2.imwrite(layer_path, output_image)
             self.logger.debug("Texture %s saved.", layer_path)
@@ -452,7 +455,11 @@ class Texture(ImageComponent):
             layer (Layer): Layer with textures and tags.
             info_layer_data (dict[list[list[int]]]): Dictionary to store info layer data.
         """
-        if layer.info_layer == "roads":
+        linestring_infolayers = ["roads"]
+        if self.kwargs.get("info_layer_path", None):
+            linestring_infolayers.append("water")
+
+        if layer.info_layer in linestring_infolayers:
             for linestring in self.objects_generator(
                 layer.tags, layer.width, layer.info_layer, yield_linestrings=True
             ):
@@ -464,6 +471,7 @@ class Texture(ImageComponent):
                 linestring_entry = {
                     "points": linestring,
                     "tags": str(layer.tags),
+                    "width": layer.width,
                 }
                 info_layer_data[f"{layer.info_layer}_polylines"].append(linestring_entry)  # type: ignore
 
@@ -490,17 +498,17 @@ class Texture(ImageComponent):
             # Check if the image contains any non-zero values, otherwise continue.
             layer_image = cv2.imread(layer_path, cv2.IMREAD_UNCHANGED)
 
-            if not np.any(layer_image):
+            if not np.any(layer_image):  # type: ignore
                 self.logger.debug(
                     "Layer %s does not contain any non-zero values, skipping.", layer.name
                 )
                 continue
 
             # 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())
+            cv2.imwrite(layer.path_preview(self._weights_dir), layer_image.copy())  # type: ignore
 
             # Get the coordinates of non-zero values.
-            non_zero_coords = np.column_stack(np.where(layer_image > 0))
+            non_zero_coords = np.column_stack(np.where(layer_image > 0))  # type: ignore
 
             # Prepare sublayers.
             sublayers = [np.zeros_like(layer_image) for _ in range(layer.count)]
@@ -817,7 +825,7 @@ class Texture(ImageComponent):
 
         images = [
             cv2.resize(
-                cv2.imread(layer.get_preview_or_path(self._weights_dir), cv2.IMREAD_UNCHANGED),
+                cv2.imread(layer.get_preview_or_path(self._weights_dir), cv2.IMREAD_UNCHANGED),  # type: ignore
                 preview_size,
             )
             for layer in active_layers

{maps4fs-2.0.6 → maps4fs-2.0.8}/maps4fs/generator/map.py

@@ -445,6 +445,7 @@ def fix_osm_file(input_file_path: str, output_file_path: str | None = None) -> t
             and the number of fixed errors.
     """
     broken_entries = ["relation", ".//*[@action='delete']"]
+    output_file_path = output_file_path or input_file_path
 
     tree = ET.parse(input_file_path)
     root = tree.getroot()

{maps4fs-2.0.6 → maps4fs-2.0.8}/maps4fs/generator/settings.py

@@ -15,8 +15,11 @@ class Parameters:
     FIELDS = "fields"
     BUILDINGS = "buildings"
     TEXTURES = "textures"
+    BACKGROUND = "background"
     FOREST = "forest"
     ROADS_POLYLINES = "roads_polylines"
+    WATER_POLYLINES = "water_polylines"
+    WATER = "water"
     FARMYARDS = "farmyards"
 
     PREVIEW_MAXIMUM_SIZE = 2048
@@ -35,6 +38,8 @@ class Parameters:
     PLANTS_ISLAND_VERTEX_COUNT = 30
     PLANTS_ISLAND_ROUNDING_RADIUS = 15
 
+    WATER_ADD_WIDTH = 2
+
 
 class SharedSettings(BaseModel):
     """Represents the shared settings for all components."""

{maps4fs-2.0.6 → maps4fs-2.0.8}/maps4fs.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maps4fs
-Version: 2.0.6
+Version: 2.0.8
 Summary: Generate map templates for Farming Simulator from real places.
 Author-email: iwatkot <iwatkot@gmail.com>
 License: Apache License 2.0

{maps4fs-2.0.6 → maps4fs-2.0.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "maps4fs"
-version = "2.0.6"
+version = "2.0.8"
 description = "Generate map templates for Farming Simulator from real places."
 authors = [{name = "iwatkot", email = "iwatkot@gmail.com"}]
 license = {text = "Apache License 2.0"}