maps4fs 1.3.6__py3-none-any.whl → 1.3.9__py3-none-any.whl

maps4fs/__init__.py

@@ -6,6 +6,8 @@ from maps4fs.generator.map import (
     GRLESettings,
     I3DSettings,
     Map,
+    SettingsModel,
+    SplineSettings,
     TextureSettings,
 )
 from maps4fs.logger import Logger

maps4fs/generator/background.py

@@ -17,7 +17,6 @@ from maps4fs.generator.dem import DEM
 from maps4fs.generator.texture import Texture
 
 DEFAULT_DISTANCE = 2048
-RESIZE_FACTOR = 1 / 8
 FULL_NAME = "FULL"
 FULL_PREVIEW_NAME = "PREVIEW"
 ELEMENTS = [FULL_NAME, FULL_PREVIEW_NAME]
@@ -63,6 +62,7 @@ class Background(Component):
             os.path.join(self.background_directory, f"{name}.png") for name in ELEMENTS
         ]
         self.not_substracted_path = os.path.join(self.background_directory, "not_substracted.png")
+        self.not_resized_path = os.path.join(self.background_directory, "not_resized.png")
 
         dems = []
 
@@ -109,6 +109,7 @@ class Background(Component):
             dem.process()
             if not dem.is_preview:  # type: ignore
                 shutil.copyfile(dem.dem_path, self.not_substracted_path)
+                self.cutout(dem.dem_path, save_path=self.not_resized_path)
 
         if self.map.dem_settings.water_depth:
             self.subtraction()
@@ -198,11 +199,12 @@ class Background(Component):
             self.plane_from_np(dem_data, save_path, is_preview=dem.is_preview)  # type: ignore
 
     # pylint: disable=too-many-locals
-    def cutout(self, dem_path: str) -> str:
+    def cutout(self, dem_path: str, save_path: str | None = None) -> str:
         """Cuts out the center of the DEM (the actual map) and saves it as a separate file.
 
         Arguments:
             dem_path (str): The path to the DEM file.
+            save_path (str, optional): The path where the cutout DEM file will be saved.
 
         Returns:
             str -- The path to the cutout DEM file.
@@ -217,6 +219,11 @@ class Background(Component):
         y2 = center[1] + half_size
         dem_data = dem_data[x1:x2, y1:y2]
 
+        if save_path:
+            cv2.imwrite(save_path, dem_data)  # pylint: disable=no-member
+            self.logger.debug("Not resized DEM saved: %s", save_path)
+            return save_path
+
         output_size = self.map_size + 1
 
         main_dem_path = self.game.dem_file_path(self.map_directory)
@@ -252,11 +259,12 @@ class Background(Component):
             is_preview (bool, optional) -- If True, the preview mesh will be generated.
             include_zeros (bool, optional) -- If True, the mesh will include the zero height values.
         """
+        resize_factor = self.map.background_settings.resize_factor
         dem_data = cv2.resize(  # pylint: disable=no-member
-            dem_data, (0, 0), fx=RESIZE_FACTOR, fy=RESIZE_FACTOR
+            dem_data, (0, 0), fx=resize_factor, fy=resize_factor
         )
         self.logger.debug(
-            "DEM data resized to shape: %s with factor: %s", dem_data.shape, RESIZE_FACTOR
+            "DEM data resized to shape: %s with factor: %s", dem_data.shape, resize_factor
         )
 
         # Invert the height values.
@@ -322,7 +330,7 @@ class Background(Component):
                 else:
                     z_scaling_factor = 1 / 2**5
                 self.logger.debug("Z scaling factor: %s", z_scaling_factor)
-                mesh.apply_scale([1 / RESIZE_FACTOR, 1 / RESIZE_FACTOR, z_scaling_factor])
+                mesh.apply_scale([1 / resize_factor, 1 / resize_factor, z_scaling_factor])
 
         mesh.export(save_path)
         self.logger.debug("Obj file saved: %s", save_path)

maps4fs/generator/component.py

@@ -7,11 +7,11 @@ import os
 from copy import deepcopy
 from typing import TYPE_CHECKING, Any
 
-import cv2
+import cv2  # type: ignore
 import osmnx as ox  # type: ignore
 from pyproj import Transformer
 from shapely.affinity import rotate, translate  # type: ignore
-from shapely.geometry import Polygon, box  # type: ignore
+from shapely.geometry import LineString, Polygon, box  # type: ignore
 
 from maps4fs.generator.qgis import save_scripts
 
@@ -338,62 +338,79 @@ class Component:
         return cs_x, cs_y
 
     # pylint: disable=R0914
-    def fit_polygon_into_bounds(
-        self, polygon_points: list[tuple[int, int]], margin: int = 0, angle: int = 0
+    def fit_object_into_bounds(
+        self,
+        polygon_points: list[tuple[int, int]] | None = None,
+        linestring_points: list[tuple[int, int]] | None = None,
+        margin: int = 0,
+        angle: int = 0,
     ) -> list[tuple[int, int]]:
         """Fits a polygon into the bounds of the map.
 
         Arguments:
             polygon_points (list[tuple[int, int]]): The points of the polygon.
+            linestring_points (list[tuple[int, int]]): The points of the linestring.
             margin (int, optional): The margin to add to the polygon. Defaults to 0.
             angle (int, optional): The angle to rotate the polygon by. Defaults to 0.
 
         Returns:
             list[tuple[int, int]]: The points of the polygon fitted into the map bounds.
         """
+        if polygon_points is None and linestring_points is None:
+            raise ValueError("Either polygon or linestring points must be provided.")
+
         min_x = min_y = 0
         max_x = max_y = self.map_size
 
-        polygon = Polygon(polygon_points)
+        object_type = Polygon if polygon_points else LineString
+
+        # polygon = Polygon(polygon_points)
+        osm_object = object_type(polygon_points or linestring_points)
 
         if angle:
             center_x = center_y = self.map_rotated_size // 2
             self.logger.debug(
-                "Rotating the polygon by %s degrees with center at %sx%s",
+                "Rotating the osm_object by %s degrees with center at %sx%s",
                 angle,
                 center_x,
                 center_y,
             )
-            polygon = rotate(polygon, -angle, origin=(center_x, center_y))
+            osm_object = rotate(osm_object, -angle, origin=(center_x, center_y))
             offset = (self.map_size / 2) - (self.map_rotated_size / 2)
-            self.logger.debug("Translating the polygon by %s", offset)
-            polygon = translate(polygon, xoff=offset, yoff=offset)
-            self.logger.debug("Rotated and translated polygon.")
+            self.logger.debug("Translating the osm_object by %s", offset)
+            osm_object = translate(osm_object, xoff=offset, yoff=offset)
+            self.logger.debug("Rotated and translated the osm_object.")
 
-        if margin:
-            polygon = polygon.buffer(margin, join_style="mitre")
-            if polygon.is_empty:
-                raise ValueError("The polygon is empty after adding the margin.")
+        if margin and object_type is Polygon:
+            osm_object = osm_object.buffer(margin, join_style="mitre")
+            if osm_object.is_empty:
+                raise ValueError("The osm_object is empty after adding the margin.")
 
         # Create a bounding box for the map bounds
         bounds = box(min_x, min_y, max_x, max_y)
 
-        # Intersect the polygon with the bounds to fit it within the map
+        # Intersect the osm_object with the bounds to fit it within the map
         try:
-            fitted_polygon = polygon.intersection(bounds)
-            self.logger.debug("Fitted the polygon into the bounds: %s", bounds)
+            fitted_osm_object = osm_object.intersection(bounds)
+            self.logger.debug("Fitted the osm_object into the bounds: %s", bounds)
         except Exception as e:
             raise ValueError(  # pylint: disable=W0707
-                f"Could not fit the polygon into the bounds: {e}"
+                f"Could not fit the osm_object into the bounds: {e}"
             )
 
-        if not isinstance(fitted_polygon, Polygon):
-            raise ValueError("The fitted polygon is not a valid polygon.")
+        if not isinstance(fitted_osm_object, object_type):
+            raise ValueError("The fitted osm_object is not valid (probably splitted into parts).")
 
         # Return the fitted polygon points
-        as_list = list(fitted_polygon.exterior.coords)
+        if object_type is Polygon:
+            as_list = list(fitted_osm_object.exterior.coords)
+        elif object_type is LineString:
+            as_list = list(fitted_osm_object.coords)
+        else:
+            raise ValueError("The object type is not supported.")
+
         if not as_list:
-            raise ValueError("The fitted polygon has no points.")
+            raise ValueError("The fitted osm_object has no points.")
         return as_list
 
     def get_infolayer_path(self, layer_name: str) -> str | None:
@@ -476,3 +493,35 @@ class Component:
         self.logger.debug("Shape of the cropped image: %s", cropped.shape)
 
         cv2.imwrite(output_path, cropped)
+
+    @staticmethod
+    def interpolate_points(
+        polyline: list[tuple[int, int]], num_points: int = 4
+    ) -> list[tuple[int, int]]:
+        """Receives a list of tuples, which represents a polyline. Add additional points
+        between the existing points to make the polyline smoother.
+
+        Arguments:
+            polyline (list[tuple[int, int]]): The list of points to interpolate.
+            num_points (int): The number of additional points to add between each pair of points.
+
+        Returns:
+            list[tuple[int, int]]: The list of points with additional points.
+        """
+        if not polyline or num_points < 1:
+            return polyline
+
+        interpolated_polyline = []
+        for i in range(len(polyline) - 1):
+            p1 = polyline[i]
+            p2 = polyline[i + 1]
+            interpolated_polyline.append(p1)
+            for j in range(1, num_points + 1):
+                new_point = (
+                    p1[0] + (p2[0] - p1[0]) * j / (num_points + 1),
+                    p1[1] + (p2[1] - p1[1]) * j / (num_points + 1),
+                )
+                interpolated_polyline.append((int(new_point[0]), int(new_point[1])))
+        interpolated_polyline.append(polyline[-1])
+
+        return interpolated_polyline

maps4fs/generator/game.py

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

maps4fs/generator/grle.py

@@ -144,8 +144,10 @@ class GRLE(Component):
 
         for field in fields:
             try:
-                fitted_field = self.fit_polygon_into_bounds(
-                    field, self.map.grle_settings.farmland_margin, angle=self.rotation
+                fitted_field = self.fit_object_into_bounds(
+                    polygon_points=field,
+                    margin=self.map.grle_settings.farmland_margin,
+                    angle=self.rotation,
                 )
             except ValueError as e:
                 self.logger.warning(

maps4fs/generator/i3d.py

@@ -19,7 +19,8 @@ DISPLACEMENT_LAYER_SIZE_FOR_BIG_MAPS = 32768
 DEFAULT_MAX_LOD_DISTANCE = 10000
 DEFAULT_MAX_LOD_OCCLUDER_DISTANCE = 10000
 NODE_ID_STARTING_VALUE = 2000
-TREE_NODE_ID_STARTING_VALUE = 4000
+SPLINES_NODE_ID_STARTING_VALUE = 5000
+TREE_NODE_ID_STARTING_VALUE = 10000
 DEFAULT_FOREST_DENSITY = 10
 
 
@@ -56,6 +57,7 @@ class I3d(Component):
         self._add_fields()
         if self.game.code == "FS25":
             self._add_forests()
+            self._add_splines()
 
     def _get_tree(self) -> ET.ElementTree | None:
         """Returns the ElementTree instance of the map I3D file."""
@@ -129,6 +131,134 @@ class I3d(Component):
         """
         return []
 
+    # pylint: disable=R0914, R0915
+    def _add_splines(self) -> None:
+        """Adds splines to the map I3D file."""
+        splines_i3d_path = os.path.join(self.map_directory, "map", "splines.i3d")
+        if not os.path.isfile(splines_i3d_path):
+            self.logger.warning("Splines I3D file not found: %s.", splines_i3d_path)
+            return
+
+        tree = ET.parse(splines_i3d_path)
+
+        textures_info_layer_path = self.get_infolayer_path("textures")
+        if not textures_info_layer_path:
+            return
+
+        with open(textures_info_layer_path, "r", encoding="utf-8") as textures_info_layer_file:
+            textures_info_layer = json.load(textures_info_layer_file)
+
+        roads_polylines: list[list[tuple[int, int]]] | None = textures_info_layer.get(
+            "roads_polylines"
+        )
+
+        if not roads_polylines:
+            self.logger.warning("Roads polylines data not found in textures info layer.")
+            return
+
+        self.logger.info("Found %s roads polylines in textures info layer.", len(roads_polylines))
+        self.logger.debug("Starging to add roads polylines to the I3D file.")
+
+        root = tree.getroot()
+        # Find <Shapes> element in the I3D file.
+        shapes_node = root.find(".//Shapes")
+        # Find <Scene> element in the I3D file.
+        scene_node = root.find(".//Scene")
+
+        # Read the not resized DEM to obtain Z values for spline points.
+        background_component = self.map.get_component("Background")
+        if not background_component:
+            self.logger.warning("Background component not found.")
+            return
+
+        # pylint: disable=no-member
+        not_resized_dem = cv2.imread(
+            background_component.not_resized_path, cv2.IMREAD_UNCHANGED  # type: ignore
+        )
+        self.logger.debug(
+            "Not resized DEM loaded from: %s. Shape: %s.",
+            background_component.not_resized_path,  # type: ignore
+            not_resized_dem.shape,
+        )
+        dem_x_size, dem_y_size = not_resized_dem.shape
+
+        if shapes_node is not None and scene_node is not None:
+            node_id = SPLINES_NODE_ID_STARTING_VALUE
+
+            for road_id, road in enumerate(roads_polylines, start=1):
+                # Add to scene node
+                # <Shape name="spline01_CSV" translation="0 0 0" nodeId="11" shapeId="11"/>
+
+                try:
+                    fitted_road = self.fit_object_into_bounds(
+                        linestring_points=road, angle=self.rotation
+                    )
+                except ValueError as e:
+                    self.logger.warning(
+                        "Road %s could not be fitted into the map bounds with error: %s",
+                        road_id,
+                        e,
+                    )
+                    continue
+
+                self.logger.debug("Road %s has %s points.", road_id, len(fitted_road))
+                fitted_road = self.interpolate_points(
+                    fitted_road, num_points=self.map.spline_settings.spline_density
+                )
+                self.logger.debug(
+                    "Road %s has %s points after interpolation.", road_id, len(fitted_road)
+                )
+
+                spline_name = f"spline{road_id}"
+
+                shape_node = ET.Element("Shape")
+                shape_node.set("name", spline_name)
+                shape_node.set("translation", "0 0 0")
+                shape_node.set("nodeId", str(node_id))
+                shape_node.set("shapeId", str(node_id))
+
+                scene_node.append(shape_node)
+
+                road_ccs = [self.top_left_coordinates_to_center(point) for point in fitted_road]
+
+                # Add to shapes node
+                # <NurbsCurve name="spline01_CSV" shapeId="11" degree="3" form="open">
+
+                nurbs_curve_node = ET.Element("NurbsCurve")
+                nurbs_curve_node.set("name", spline_name)
+                nurbs_curve_node.set("shapeId", str(node_id))
+                nurbs_curve_node.set("degree", "3")
+                nurbs_curve_node.set("form", "open")
+
+                # Now for each point in the road add the following entry to nurbs_curve_node
+                # <cv c="-224.548401, 427.297546, -2047.570312" />
+                # The second coordinate (Z) will be 0 at the moment.
+
+                for point_ccs, point in zip(road_ccs, fitted_road):
+                    cx, cy = point_ccs
+                    x, y = point
+
+                    x = int(x)
+                    y = int(y)
+
+                    x = max(0, min(x, dem_x_size - 1))
+                    y = max(0, min(y, dem_y_size - 1))
+
+                    z = not_resized_dem[y, x]
+                    z /= 32  # Yes, it's a magic number here.
+
+                    cv_node = ET.Element("cv")
+                    cv_node.set("c", f"{cx}, {z}, {cy}")
+
+                    nurbs_curve_node.append(cv_node)
+
+                shapes_node.append(nurbs_curve_node)
+
+                node_id += 1
+
+            tree.write(splines_i3d_path)  # type: ignore
+            self.logger.debug("Splines I3D file saved to: %s.", splines_i3d_path)
+
     # pylint: disable=R0914, R0915
     def _add_fields(self) -> None:
         """Adds fields to the map I3D file."""
@@ -166,7 +296,9 @@ class I3d(Component):
 
                 for field in fields:
                     try:
-                        fitted_field = self.fit_polygon_into_bounds(field, angle=self.rotation)
+                        fitted_field = self.fit_object_into_bounds(
+                            polygon_points=field, angle=self.rotation
+                        )
                     except ValueError as e:
                         self.logger.warning(
                             "Field %s could not be fitted into the map bounds with error: %s",

maps4fs/generator/map.py

@@ -4,14 +4,50 @@ from __future__ import annotations
 
 import os
 import shutil
-from typing import Any, Generator, NamedTuple
+from typing import Any, Generator
+
+from pydantic import BaseModel
 
 from maps4fs.generator.component import Component
 from maps4fs.generator.game import Game
 from maps4fs.logger import Logger
 
 
-class DEMSettings(NamedTuple):
+class SettingsModel(BaseModel):
+    """Base class for settings models. It provides methods to convert settings to and from JSON."""
+
+    @classmethod
+    def all_settings_to_json(cls) -> dict[str, dict[str, Any]]:
+        """Get all settings of the current class and its subclasses as a dictionary.
+
+        Returns:
+            dict[str, dict[str, Any]]: Dictionary with settings of the current class and its
+                subclasses.
+        """
+        all_settings = {}
+        for subclass in cls.__subclasses__():
+            all_settings[subclass.__name__] = subclass().model_dump()
+
+        return all_settings
+
+    @classmethod
+    def all_settings_from_json(cls, data: dict) -> dict[str, SettingsModel]:
+        """Create settings instances from JSON data.
+
+        Arguments:
+            data (dict): JSON data.
+
+        Returns:
+            dict[str, Type[SettingsModel]]: Dictionary with settings instances.
+        """
+        settings = {}
+        for subclass in cls.__subclasses__():
+            settings[subclass.__name__] = subclass(**data[subclass.__name__])
+
+        return settings
+
+
+class DEMSettings(SettingsModel):
     """Represents the advanced settings for DEM component.
 
     Attributes:
@@ -31,19 +67,21 @@ class DEMSettings(NamedTuple):
     water_depth: int = 0
 
 
-class BackgroundSettings(NamedTuple):
+class BackgroundSettings(SettingsModel):
     """Represents the advanced settings for background component.
 
     Attributes:
         generate_background (bool): generate obj files for the background terrain.
         generate_water (bool): generate obj files for the water.
+        resize_factor (float): resize factor for the background and water.
     """
 
     generate_background: bool = True
     generate_water: bool = True
+    resize_factor: float = 1 / 8
 
 
-class GRLESettings(NamedTuple):
+class GRLESettings(SettingsModel):
     """Represents the advanced settings for GRLE component.
 
     Attributes:
@@ -55,7 +93,7 @@ class GRLESettings(NamedTuple):
     random_plants: bool = True
 
 
-class I3DSettings(NamedTuple):
+class I3DSettings(SettingsModel):
     """Represents the advanced settings for I3D component.
 
     Attributes:
@@ -65,7 +103,7 @@ class I3DSettings(NamedTuple):
     forest_density: int = 10
 
 
-class TextureSettings(NamedTuple):
+class TextureSettings(SettingsModel):
     """Represents the advanced settings for texture component.
 
     Attributes:
@@ -79,7 +117,18 @@ class TextureSettings(NamedTuple):
     skip_drains: bool = False
 
 
-# pylint: disable=R0913, R0902
+class SplineSettings(SettingsModel):
+    """Represents the advanced settings for spline component.
+
+    Attributes:
+        spline_density (int): the number of extra points that will be added between each two
+            existing points.
+    """
+
+    spline_density: int = 4
+
+
+# pylint: disable=R0913, R0902, R0914
 class Map:
     """Class used to generate map using all components.
 
@@ -99,11 +148,13 @@ class Map:
         rotation: int,
         map_directory: str,
         logger: Any = None,
+        custom_osm: str | None = None,
         dem_settings: DEMSettings = DEMSettings(),
         background_settings: BackgroundSettings = BackgroundSettings(),
         grle_settings: GRLESettings = GRLESettings(),
         i3d_settings: I3DSettings = I3DSettings(),
         texture_settings: TextureSettings = TextureSettings(),
+        spline_settings: SplineSettings = SplineSettings(),
         **kwargs,
     ):
         if not logger:
@@ -126,6 +177,16 @@ class Map:
 
         self.logger.info("Game was set to %s", game.code)
 
+        self.custom_osm = custom_osm
+        self.logger.info("Custom OSM file: %s", custom_osm)
+
+        # Make a copy of a custom osm file to the map directory, so it will be
+        # included in the output archive.
+        if custom_osm:
+            copy_path = os.path.join(self.map_directory, "custom_osm.osm")
+            shutil.copyfile(custom_osm, copy_path)
+            self.logger.debug("Custom OSM file copied to %s", copy_path)
+
         self.dem_settings = dem_settings
         self.logger.info("DEM settings: %s", dem_settings)
         self.background_settings = background_settings
@@ -136,6 +197,8 @@ class Map:
         self.logger.info("I3D settings: %s", i3d_settings)
         self.texture_settings = texture_settings
         self.logger.info("Texture settings: %s", texture_settings)
+        self.spline_settings = spline_settings
+        self.logger.info("Spline settings: %s", spline_settings)
 
         os.makedirs(self.map_directory, exist_ok=True)
         self.logger.debug("Map directory created: %s", self.map_directory)

maps4fs/generator/texture.py

@@ -372,7 +372,7 @@ class Texture(Component):
             ),
         )
 
-    # pylint: disable=no-member
+    # pylint: disable=no-member, R0912
     def draw(self) -> None:
         """Iterates over layers and fills them with polygons from OSM data."""
         layers = self.layers_by_priority()
@@ -409,11 +409,23 @@ class Texture(Component):
 
             mask = cv2.bitwise_not(cumulative_image)
 
-            for polygon in self.polygons(layer.tags, layer.width, layer.info_layer):  # type: ignore
+            for polygon in self.objects_generator(  # type: ignore
+                layer.tags, layer.width, layer.info_layer
+            ):
                 if layer.info_layer:
-                    info_layer_data[layer.info_layer].append(self.np_to_polygon_points(polygon))
+                    info_layer_data[layer.info_layer].append(
+                        self.np_to_polygon_points(polygon)  # type: ignore
+                    )
                 cv2.fillPoly(layer_image, [polygon], color=255)  # type: ignore
 
+            if layer.info_layer == "roads":
+                for linestring in self.objects_generator(
+                    layer.tags, layer.width, layer.info_layer, yield_linestrings=True
+                ):
+                    info_layer_data[f"{layer.info_layer}_polylines"].append(
+                        linestring  # type: ignore
+                    )
+
             output_image = cv2.bitwise_and(layer_image, mask)
 
             cumulative_image = cv2.bitwise_or(cumulative_image, output_image)
@@ -422,8 +434,16 @@ class Texture(Component):
             self.logger.debug("Texture %s saved.", layer_path)
 
         # Save info layer data.
+        if os.path.isfile(self.info_layer_path):
+            self.logger.debug(
+                "File %s already exists, will update to avoid overwriting.", self.info_layer_path
+            )
+            with open(self.info_layer_path, "r", encoding="utf-8") as f:
+                info_layer_data.update(json.load(f))
+
         with open(self.info_layer_path, "w", encoding="utf-8") as f:
             json.dump(info_layer_data, f, ensure_ascii=False, indent=4)
+            self.logger.debug("Info layer data saved to %s.", self.info_layer_path)
 
         if cumulative_image is not None:
             self.draw_base_layer(cumulative_image)
@@ -617,31 +637,73 @@ class Texture(Component):
         converters = {"Polygon": self._skip, "LineString": self._sequence, "Point": self._sequence}
         return converters.get(geom_type)  # type: ignore
 
-    def polygons(
+    def objects_generator(
         self,
         tags: dict[str, str | list[str] | bool],
         width: int | None,
         info_layer: str | None = None,
-    ) -> Generator[np.ndarray, None, None]:
+        yield_linestrings: bool = False,
+    ) -> Generator[np.ndarray, None, None] | Generator[list[tuple[int, int]], None, None]:
         """Generator which yields numpy arrays of polygons from OSM data.
 
         Arguments:
             tags (dict[str, str | list[str]]): Dictionary of tags to search for.
             width (int | None): Width of the polygon in meters (only for LineString).
             info_layer (str | None): Name of the corresponding info layer.
+            yield_linestrings (bool): Flag to determine if the LineStrings should be yielded.
 
         Yields:
-            Generator[np.ndarray, None, None]: Numpy array of polygon points.
+            Generator[np.ndarray, None, None] | Generator[list[tuple[int, int]], None, None]:
+                Numpy array of polygon points or list of point coordinates.
         """
         is_fieds = info_layer == "fields"
         try:
-            objects = ox.features_from_bbox(bbox=self.new_bbox, tags=tags)
-        except Exception:  # pylint: disable=W0718
-            self.logger.debug("Error fetching objects for tags: %s.", tags)
+            if self.map.custom_osm is not None:
+                objects = ox.features_from_xml(self.map.custom_osm, tags=tags)
+            else:
+                objects = ox.features_from_bbox(bbox=self.new_bbox, tags=tags)
+        except Exception as e:  # pylint: disable=W0718
+            self.logger.debug("Error fetching objects for tags: %s. Error: %s.", tags, e)
             return
         objects_utm = ox.projection.project_gdf(objects, to_latlong=False)
         self.logger.debug("Fetched %s elements for tags: %s.", len(objects_utm), tags)
 
+        method = self.linestrings_generator if yield_linestrings else self.polygons_generator
+
+        yield from method(objects_utm, width, is_fieds)
+
+    def linestrings_generator(
+        self, objects_utm: pd.core.frame.DataFrame, *args, **kwargs
+    ) -> Generator[list[tuple[int, int]], None, None]:
+        """Generator which yields lists of point coordinates which represent LineStrings from OSM.
+
+        Arguments:
+            objects_utm (pd.core.frame.DataFrame): Dataframe with OSM objects in UTM format.
+
+        Yields:
+            Generator[list[tuple[int, int]], None, None]: List of point coordinates.
+        """
+        for _, obj in objects_utm.iterrows():
+            geometry = obj["geometry"]
+            if isinstance(geometry, shapely.geometry.linestring.LineString):
+                points = [
+                    (self.get_relative_x(x), self.get_relative_y(y)) for x, y in geometry.coords
+                ]
+                yield points
+
+    def polygons_generator(
+        self, objects_utm: pd.core.frame.DataFrame, width: int | None, is_fieds: bool
+    ) -> Generator[np.ndarray, None, None]:
+        """Generator which yields numpy arrays of polygons from OSM data.
+
+        Arguments:
+            objects_utm (pd.core.frame.DataFrame): Dataframe with OSM objects in UTM format.
+            width (int | None): Width of the polygon in meters (only for LineString).
+            is_fieds (bool): Flag to determine if the fields should be padded.
+
+        Yields:
+            Generator[np.ndarray, None, None]: Numpy array of polygon points.
+        """
         for _, obj in objects_utm.iterrows():
             polygon = self._to_polygon(obj, width)
             if polygon is None:

{maps4fs-1.3.6.dist-info → maps4fs-1.3.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: maps4fs
-Version: 1.3.6
+Version: 1.3.9
 Summary: Generate map templates for Farming Simulator from real places.
 Author-email: iwatkot <iwatkot@gmail.com>
 License: MIT License
@@ -22,6 +22,7 @@ Requires-Dist: trimesh
 Requires-Dist: imageio
 Requires-Dist: tifffile
 Requires-Dist: pympler
+Requires-Dist: pydantic
 
 <div align="center" markdown>
 <a href="https://discord.gg/Sj5QKKyE42">
@@ -71,7 +72,9 @@ Requires-Dist: pympler
 🌿 Automatically generates decorative foliage 🆕<br>
 🌲 Automatically generates forests 🆕<br>
 🌊 Automatically generates water planes 🆕<br>
+📈 Automatically generates splines 🆕<br>
 🌍 Based on real-world data from OpenStreetMap<br>
+🗺️ Supports [custom OSM maps](/docs/custom_osm.md)<br>
 🏞️ Generates height map using SRTM dataset<br>
 📦 Provides a ready-to-use map template for the Giants Editor<br>
 🚜 Supports Farming Simulator 22 and 25<br>
@@ -93,6 +96,8 @@ Requires-Dist: pympler
 🌲 Automatically generates forests.<br><br>
 <img src="https://github.com/user-attachments/assets/cce7d4e0-cba2-4dd2-b22d-03137fb2e860"><br>
 🌊 Automatically generates water planes.<br><br>
+<img src="https://github.com/user-attachments/assets/0b05b511-a595-48e7-a353-8298081314a4"><br>
+📈 Automatically generates splines.<br><br>
 <img src="https://github.com/user-attachments/assets/80e5923c-22c7-4dc0-8906-680902511f3a"><br>
 🗒️ True-to-life blueprints for fast and precise modding.<br><br>
 <img width="480" src="https://github.com/user-attachments/assets/1a8802d2-6a3b-4bfa-af2b-7c09478e199b"><br>
@@ -501,6 +506,12 @@ You can also apply some advanced settings to the map generation process. Note th
 
 - Generate water - if enabled, the water planes obj files will be generated. You can turn it off if you already have those files or don't need them. By default, it's set to True.
 
+- Resize factor - the factor by which the background terrain will be resized. In UI it sets as an integer number (default 8), will be converted to 1/8 (0.125). In expert mode use the float number. The higher the value, the smaller the background terrain will be. Warning: higher terrain will result long processing time and enormous file size.
+
+## Splines Advanced settings
+
+- Splines density - number of points, which will be added (interpolate) between each pair of existing points. The higher the value, the denser the spline will be. It can smooth the splines, but high values can in opposite make the splines look unnatural.
+
 ## Resources
 In this section, you'll find a list of the resources that you need to create a map for the Farming Simulator.<br>
 To create a basic map, you only need the Giants Editor. But if you want to create a background terrain - the world around the map, so it won't look like it's floating in the void - you also need Blender and the Blender Exporter Plugins. To create realistic textures for the background terrain, the QGIS is required to obtain high-resolution satellite images.<br>
@@ -528,3 +539,4 @@ But also, I want to thank the people who helped me with the project in some way,
 - [BFernaesds](https://github.com/BFernaesds) - for the manual tests of the app.
 - [gamerdesigns](https://github.com/gamerdesigns) - for the manual tests of the app. 
 - [Tox3](https://github.com/Tox3) - for the manual tests of the app. 
+- [Lucandia](https://github.com/Lucandia) - for the awesome StreamLit [widget to preview STL files](https://github.com/Lucandia/streamlit_stl).

maps4fs-1.3.9.dist-info/RECORD

@@ -0,0 +1,21 @@
+maps4fs/__init__.py,sha256=LMzzORK3Q3OjXmmRJ03CpS2SMP6zTwKNnUUei3P7s40,300
+maps4fs/logger.py,sha256=B-NEYpMjPAAqlV4VpfTi6nbBFnEABVtQOaYe6nMpidg,1489
+maps4fs/generator/__init__.py,sha256=zZMLEkGzb4z0xql650gOtGSvcgX58DnJ2yN3vC2daRk,43
+maps4fs/generator/background.py,sha256=-fQsrJogSZitxQ4tTDN4xLgaNrOVsXFS1bFfPkpktFE,22832
+maps4fs/generator/component.py,sha256=58UQgdR-7KlWHTfwLesNNK76BTRsiVngRa6B64OKjhc,20065
+maps4fs/generator/config.py,sha256=0QmK052B8bxyHVhg3jzCORLfOBMMmqVfhhbqXKf6OMk,4383
+maps4fs/generator/dem.py,sha256=MZf3ZjawJ977TxqB1q9nNpvPZUNwfmm2EaJDtVU-eCU,15939
+maps4fs/generator/game.py,sha256=jjo7CTwHHSkRpeD_QgRXkhR_NxI09C4kMxz-nYOTM4A,7931
+maps4fs/generator/grle.py,sha256=onhZovvRtireDfw7wEOL0CZmOmoVzRPY-R4TlvbOUMI,17561
+maps4fs/generator/i3d.py,sha256=vbH7G0kDOGC6gbNDE-QYxMnKOMJ-vCGYdaKhWwci4ZU,23748
+maps4fs/generator/map.py,sha256=bs3V5-E9hF77I_v8yanL--6oc5MgTcfrdTQrIAziqq8,10964
+maps4fs/generator/qgis.py,sha256=Es8hLuqN_KH8lDfnJE6He2rWYbAKJ3RGPn-o87S6CPI,6116
+maps4fs/generator/texture.py,sha256=fZN0soGWk8-f3GuQWiwJ2yQTsmL9fLWVlgqeLI6ePi4,30648
+maps4fs/toolbox/__init__.py,sha256=zZMLEkGzb4z0xql650gOtGSvcgX58DnJ2yN3vC2daRk,43
+maps4fs/toolbox/background.py,sha256=9BXWNqs_n3HgqDiPztWylgYk_QM4YgBpe6_ZNQAWtSc,2154
+maps4fs/toolbox/dem.py,sha256=z9IPFNmYbjiigb3t02ZenI3Mo8odd19c5MZbjDEovTo,3525
+maps4fs-1.3.9.dist-info/LICENSE.md,sha256=pTKD_oUexcn-yccFCTrMeLkZy0ifLRa-VNcDLqLZaIw,10749
+maps4fs-1.3.9.dist-info/METADATA,sha256=XWb_csNJp4zcnR8O85o0A2v4bi9VNFB-tcxYDGGgM-k,32129
+maps4fs-1.3.9.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+maps4fs-1.3.9.dist-info/top_level.txt,sha256=Ue9DSRlejRQRCaJueB0uLcKrWwsEq9zezfv5dI5mV1M,8
+maps4fs-1.3.9.dist-info/RECORD,,

maps4fs-1.3.6.dist-info/RECORD

@@ -1,21 +0,0 @@
-maps4fs/__init__.py,sha256=MlM_vkLH_22xoBwhoRD52JDECCmeAJ8gBQr7RMQZmis,261
-maps4fs/logger.py,sha256=B-NEYpMjPAAqlV4VpfTi6nbBFnEABVtQOaYe6nMpidg,1489
-maps4fs/generator/__init__.py,sha256=zZMLEkGzb4z0xql650gOtGSvcgX58DnJ2yN3vC2daRk,43
-maps4fs/generator/background.py,sha256=KFoO6GKaNrJDUoMrDyeroZG63Cv9aGkMgHaa0QYEpiU,22306
-maps4fs/generator/component.py,sha256=XN-3Zx0bujugpuRk3YB-pYNwUHREdyt_cLxPd7pr57g,17967
-maps4fs/generator/config.py,sha256=0QmK052B8bxyHVhg3jzCORLfOBMMmqVfhhbqXKf6OMk,4383
-maps4fs/generator/dem.py,sha256=MZf3ZjawJ977TxqB1q9nNpvPZUNwfmm2EaJDtVU-eCU,15939
-maps4fs/generator/game.py,sha256=ZQeYzPzPB3CG41avdhNCyTZpHEeedqNBuAbNevTZuXg,7931
-maps4fs/generator/grle.py,sha256=xKIpyhYsZol-IXcBULbX7wWZ1n83BWTZqaf8FLodchE,17499
-maps4fs/generator/i3d.py,sha256=bW7FLAISFKCPUmad7ANz1loWI07oEZlEQOEL_tv0YmQ,18483
-maps4fs/generator/map.py,sha256=a-nwDsKq6u9RLB2htueXtJtdDZbocpj_KxGhBw5AoEI,8776
-maps4fs/generator/qgis.py,sha256=Es8hLuqN_KH8lDfnJE6He2rWYbAKJ3RGPn-o87S6CPI,6116
-maps4fs/generator/texture.py,sha256=tNhv-_AOrv4Wf7knbrN9LZBkvApgsrGffGPAzZScr7g,27745
-maps4fs/toolbox/__init__.py,sha256=zZMLEkGzb4z0xql650gOtGSvcgX58DnJ2yN3vC2daRk,43
-maps4fs/toolbox/background.py,sha256=9BXWNqs_n3HgqDiPztWylgYk_QM4YgBpe6_ZNQAWtSc,2154
-maps4fs/toolbox/dem.py,sha256=z9IPFNmYbjiigb3t02ZenI3Mo8odd19c5MZbjDEovTo,3525
-maps4fs-1.3.6.dist-info/LICENSE.md,sha256=pTKD_oUexcn-yccFCTrMeLkZy0ifLRa-VNcDLqLZaIw,10749
-maps4fs-1.3.6.dist-info/METADATA,sha256=pczjM5FWcRCAJiNtW3JRwl0SeNYEAlQUwc1V2UWyjtY,31082
-maps4fs-1.3.6.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-maps4fs-1.3.6.dist-info/top_level.txt,sha256=Ue9DSRlejRQRCaJueB0uLcKrWwsEq9zezfv5dI5mV1M,8
-maps4fs-1.3.6.dist-info/RECORD,,