maps4fs 1.2.4__py3-none-any.whl → 1.5.0__py3-none-any.whl

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
 
 
@@ -43,28 +44,25 @@ class I3d(Component):
     def preprocess(self) -> None:
         """Gets the path to the map I3D file from the game instance and saves it to the instance
         attribute. If the game does not support I3D files, the attribute is set to None."""
-        self.auto_process = self.kwargs.get("auto_process", False)
-
         try:
             self._map_i3d_path = self.game.i3d_file_path(self.map_directory)
             self.logger.debug("Map I3D path: %s.", self._map_i3d_path)
         except NotImplementedError:
-            self.logger.info("I3D file processing is not implemented for this game.")
+            self.logger.warning("I3D file processing is not implemented for this game.")
             self._map_i3d_path = None
 
-        self.forest_density = self.kwargs.get("forest_density", DEFAULT_FOREST_DENSITY)
-        self.logger.info("Forest density: %s.", self.forest_density)
-
     def process(self) -> None:
         """Updates the map I3D file with the default settings."""
         self._update_i3d_file()
         self._add_fields()
-        self._add_forests()
+        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."""
         if not self._map_i3d_path:
-            self.logger.info("I3D is not obtained, skipping the update.")
+            self.logger.debug("I3D is not obtained, skipping the update.")
             return None
         if not os.path.isfile(self._map_i3d_path):
             self.logger.warning("I3D file not found: %s.", self._map_i3d_path)
@@ -84,7 +82,7 @@ class I3d(Component):
         root = tree.getroot()
         for map_elem in root.iter("Scene"):
             for terrain_elem in map_elem.iter("TerrainTransformGroup"):
-                if self.auto_process:
+                if self.map.dem_settings.auto_process:
                     terrain_elem.set("heightScale", str(DEFAULT_HEIGHT_SCALE))
                     self.logger.debug(
                         "heightScale attribute set to %s in TerrainTransformGroup element.",
@@ -122,7 +120,7 @@ class I3d(Component):
                 )
 
         tree.write(self._map_i3d_path)  # type: ignore
-        self.logger.info("Map I3D file saved to: %s.", self._map_i3d_path)
+        self.logger.debug("Map I3D file saved to: %s.", self._map_i3d_path)
 
     def previews(self) -> list[str]:
         """Returns a list of paths to the preview images (empty list).
@@ -133,6 +131,157 @@ 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
+            user_attributes_node = root.find(".//UserAttributes")
+            if user_attributes_node is None:
+                self.logger.warning("UserAttributes node not found in I3D file.")
+                return
+
+            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)
+
+                # Add UserAttributes to the shape node.
+                # <UserAttribute nodeId="5000">
+                # <Attribute name="maxSpeedScale" type="integer" value="1"/>
+                # <Attribute name="speedLimit" type="integer" value="100"/>
+                # </UserAttribute>
+
+                user_attribute_node = ET.Element("UserAttribute")
+                user_attribute_node.set("nodeId", str(node_id))
+
+                attributes = [
+                    ("maxSpeedScale", "integer", "1"),
+                    ("speedLimit", "integer", "100"),
+                ]
+
+                for name, attr_type, value in attributes:
+                    user_attribute_node.append(I3d.create_attribute_node(name, attr_type, value))
+
+                user_attributes_node.append(user_attribute_node)  # type: ignore
+
+                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."""
@@ -170,7 +319,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",
@@ -239,7 +390,7 @@ class I3d(Component):
                     field_id += 1
 
             tree.write(self._map_i3d_path)  # type: ignore
-            self.logger.info("Map I3D file saved to: %s.", self._map_i3d_path)
+            self.logger.debug("Map I3D file saved to: %s.", self._map_i3d_path)
 
     def get_name_indicator_node(self, node_id: int, field_id: int) -> tuple[ET.Element, int]:
         """Creates a name indicator node with given node ID and field ID.
@@ -332,24 +483,28 @@ class I3d(Component):
     # pylint: disable=R0911
     def _add_forests(self) -> None:
         """Adds forests to the map I3D file."""
-        try:
-            tree_schema_path = self.game.tree_schema
-        except ValueError:
-            self.logger.warning("Tree schema path not set for the Game %s.", self.game.code)
-            return
-
-        if not os.path.isfile(tree_schema_path):
-            self.logger.warning("Tree schema file was not found: %s.", tree_schema_path)
-            return
-
-        try:
-            with open(tree_schema_path, "r", encoding="utf-8") as tree_schema_file:
-                tree_schema: list[dict[str, str | int]] = json.load(tree_schema_file)
-        except json.JSONDecodeError as e:
-            self.logger.warning(
-                "Could not load tree schema from %s with error: %s", tree_schema_path, e
-            )
-            return
+        custom_schema = self.kwargs.get("tree_custom_schema")
+        if custom_schema:
+            tree_schema = custom_schema
+        else:
+            try:
+                tree_schema_path = self.game.tree_schema
+            except ValueError:
+                self.logger.warning("Tree schema path not set for the Game %s.", self.game.code)
+                return
+
+            if not os.path.isfile(tree_schema_path):
+                self.logger.warning("Tree schema file was not found: %s.", tree_schema_path)
+                return
+
+            try:
+                with open(tree_schema_path, "r", encoding="utf-8") as tree_schema_file:
+                    tree_schema = json.load(tree_schema_file)  # type: ignore
+            except json.JSONDecodeError as e:
+                self.logger.warning(
+                    "Could not load tree schema from %s with error: %s", tree_schema_path, e
+                )
+                return
 
         texture_component: Texture | None = self.map.get_component("Texture")  # type: ignore
         if not texture_component:
@@ -395,14 +550,16 @@ class I3d(Component):
         forest_image = cv2.imread(forest_image_path, cv2.IMREAD_UNCHANGED)
 
         tree_count = 0
-        for x, y in self.non_empty_pixels(forest_image, step=self.forest_density):
+        for x, y in self.non_empty_pixels(forest_image, step=self.map.i3d_settings.forest_density):
             xcs, ycs = self.top_left_coordinates_to_center((x, y))
             node_id += 1
 
             rotation = randint(-180, 180)
-            xcs, ycs = self.randomize_coordinates((xcs, ycs), self.forest_density)  # type: ignore
+            xcs, ycs = self.randomize_coordinates(  # type: ignore
+                (xcs, ycs), self.map.i3d_settings.forest_density
+            )
 
-            random_tree = choice(tree_schema)
+            random_tree = choice(tree_schema)  # type: ignore
             tree_name = random_tree["name"]
             tree_id = random_tree["reference_id"]
 
@@ -420,7 +577,7 @@ class I3d(Component):
         self.logger.info("Added %s trees to the I3D file.", tree_count)
 
         tree.write(self._map_i3d_path)  # type: ignore
-        self.logger.info("Map I3D file saved to: %s.", self._map_i3d_path)
+        self.logger.debug("Map I3D file saved to: %s.", self._map_i3d_path)
 
     @staticmethod
     def randomize_coordinates(coordinates: tuple[int, int], density: int) -> tuple[float, float]:

maps4fs/generator/map.py

@@ -2,16 +2,151 @@
 
 from __future__ import annotations
 
+import json
 import os
 import shutil
 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
 
 
-# pylint: disable=R0913, R0902
+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
+
+    @classmethod
+    def all_settings(cls) -> list[SettingsModel]:
+        """Get all settings of the current class and its subclasses.
+
+        Returns:
+            list[SettingsModel]: List with settings of the current class and its subclasses.
+        """
+        settings = []
+        for subclass in cls.__subclasses__():
+            settings.append(subclass())
+
+        return settings
+
+
+class DEMSettings(SettingsModel):
+    """Represents the advanced settings for DEM component.
+
+    Attributes:
+        auto_process (bool): use the auto preset to change the multiplier.
+        multiplier (int): multiplier for the heightmap, every pixel will be multiplied by this
+            value.
+        blur_radius (int): radius of the blur filter.
+        plateau (int): plateau height, will be added to each pixel.
+        water_depth (int): water depth, will be subtracted from each pixel where the water
+            is present.
+    """
+
+    auto_process: bool = True
+    multiplier: int = 1
+    blur_radius: int = 35
+    plateau: int = 0
+    water_depth: int = 0
+
+
+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 (int): resize factor for the background terrain and water.
+            It will be used as 1 / resize_factor of the original size.
+    """
+
+    generate_background: bool = True
+    generate_water: bool = True
+    resize_factor: int = 8
+
+
+class GRLESettings(SettingsModel):
+    """Represents the advanced settings for GRLE component.
+
+    Attributes:
+        farmland_margin (int): margin around the farmland.
+        random_plants (bool): generate random plants on the map or use the default one.
+        add_farmyards (bool): If True, regions of frarmyards will be added to the map
+            without corresponding fields.
+    """
+
+    farmland_margin: int = 0
+    random_plants: bool = True
+    add_farmyards: bool = False
+
+
+class I3DSettings(SettingsModel):
+    """Represents the advanced settings for I3D component.
+
+    Attributes:
+        forest_density (int): density of the forest (distance between trees).
+    """
+
+    forest_density: int = 10
+
+
+class TextureSettings(SettingsModel):
+    """Represents the advanced settings for texture component.
+
+    Attributes:
+        dissolve (bool): dissolve the texture into several images.
+        fields_padding (int): padding around the fields.
+        skip_drains (bool): skip drains generation.
+    """
+
+    dissolve: bool = False
+    fields_padding: int = 0
+    skip_drains: bool = False
+
+
+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 = 2
+
+
+# pylint: disable=R0913, R0902, R0914
 class Map:
     """Class used to generate map using all components.
 
@@ -23,7 +158,7 @@ class Map:
         logger (Any): Logger instance
     """
 
-    def __init__(  # pylint: disable=R0917
+    def __init__(  # pylint: disable=R0917, R0915
         self,
         game: Game,
         coordinates: tuple[float, float],
@@ -31,6 +166,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:
@@ -53,12 +195,65 @@ class Map:
 
         self.logger.info("Game was set to %s", game.code)
 
-        self.kwargs = kwargs
-        self.logger.info("Additional arguments: %s", kwargs)
+        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
+        self.logger.info("Background settings: %s", background_settings)
+        self.grle_settings = grle_settings
+        self.logger.info("GRLE settings: %s", grle_settings)
+        self.i3d_settings = i3d_settings
+        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)
 
+        settings = [
+            dem_settings,
+            background_settings,
+            grle_settings,
+            i3d_settings,
+            texture_settings,
+            spline_settings,
+        ]
+
+        settings_json = {}
+
+        for setting in settings:
+            settings_json[setting.__class__.__name__] = setting.model_dump()
+
+        save_path = os.path.join(self.map_directory, "generation_settings.json")
+
+        with open(save_path, "w", encoding="utf-8") as file:
+            json.dump(settings_json, file, indent=4)
+
+        self.texture_custom_schema = kwargs.get("texture_custom_schema", None)
+        if self.texture_custom_schema:
+            save_path = os.path.join(self.map_directory, "texture_custom_schema.json")
+            with open(save_path, "w", encoding="utf-8") as file:
+                json.dump(self.texture_custom_schema, file, indent=4)
+            self.logger.debug("Texture custom schema saved to %s", save_path)
+
+        self.tree_custom_schema = kwargs.get("tree_custom_schema", None)
+        if self.tree_custom_schema:
+            save_path = os.path.join(self.map_directory, "tree_custom_schema.json")
+            with open(save_path, "w", encoding="utf-8") as file:
+                json.dump(self.tree_custom_schema, file, indent=4)
+            self.logger.debug("Tree custom schema saved to %s", save_path)
+
         try:
             shutil.unpack_archive(game.template_path, self.map_directory)
             self.logger.debug("Map template unpacked to %s", self.map_directory)
@@ -71,6 +266,14 @@ class Map:
         Yields:
             Generator[str, None, None]: Component names.
         """
+        self.logger.info(
+            "Starting map generation. Game code: %s. Coordinates: %s, size: %s. Rotation: %s.",
+            self.game.code,
+            self.coordinates,
+            self.size,
+            self.rotation,
+        )
+
         for game_component in self.game.components:
             component = game_component(
                 self.game,
@@ -81,7 +284,8 @@ class Map:
                 self.rotation,
                 self.map_directory,
                 self.logger,
-                **self.kwargs,
+                texture_custom_schema=self.texture_custom_schema,
+                tree_custom_schema=self.tree_custom_schema,
             )
             self.components.append(component)
 
@@ -107,6 +311,14 @@ class Map:
                 )
                 raise e
 
+        self.logger.info(
+            "Map generation completed. Game code: %s. Coordinates: %s, size: %s. Rotation: %s.",
+            self.game.code,
+            self.coordinates,
+            self.size,
+            self.rotation,
+        )
+
     def get_component(self, component_name: str) -> Component | None:
         """Get component by name.
 
@@ -154,7 +366,7 @@ class Map:
         if remove_source:
             try:
                 shutil.rmtree(self.map_directory)
-                self.logger.info("Map directory removed: %s", self.map_directory)
+                self.logger.debug("Map directory removed: %s", self.map_directory)
             except Exception as e:  # pylint: disable=W0718
-                self.logger.error("Error removing map directory %s: %s", self.map_directory, e)
+                self.logger.debug("Error removing map directory %s: %s", self.map_directory, e)
         return archive_path