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

maps4fs/__init__.py

@@ -1,4 +1,13 @@
 # pylint: disable=missing-module-docstring
 from maps4fs.generator.game import Game
-from maps4fs.generator.map import Map
+from maps4fs.generator.map import (
+    BackgroundSettings,
+    DEMSettings,
+    GRLESettings,
+    I3DSettings,
+    Map,
+    SettingsModel,
+    SplineSettings,
+    TextureSettings,
+)
 from maps4fs.logger import Logger

maps4fs/generator/background.py

@@ -13,16 +13,10 @@ import numpy as np
 import trimesh  # type: ignore
 
 from maps4fs.generator.component import Component
-from maps4fs.generator.dem import (
-    DEFAULT_BLUR_RADIUS,
-    DEFAULT_MULTIPLIER,
-    DEFAULT_PLATEAU,
-    DEM,
-)
+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]
@@ -46,8 +40,6 @@ class Background(Component):
     # pylint: disable=R0801
     def preprocess(self) -> None:
         """Registers the DEMs for the background terrain."""
-        self.light_version = self.kwargs.get("light_version", False)
-        self.water_depth = self.kwargs.get("water_depth", 0)
         self.stl_preview_path: str | None = None
         self.water_resources_path: str | None = None
 
@@ -65,11 +57,12 @@ class Background(Component):
         os.makedirs(self.background_directory, exist_ok=True)
         os.makedirs(self.water_directory, exist_ok=True)
 
-        autoprocesses = [self.kwargs.get("auto_process", False), False]
+        autoprocesses = [self.map.dem_settings.auto_process, False]
         self.output_paths = [
             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 = []
 
@@ -83,13 +76,12 @@ class Background(Component):
                 self.rotation,
                 self.map_directory,
                 self.logger,
-                auto_process=autoprocess,
-                blur_radius=self.kwargs.get("blur_radius", DEFAULT_BLUR_RADIUS),
-                multiplier=self.kwargs.get("multiplier", DEFAULT_MULTIPLIER),
-                plateau=self.kwargs.get("plateau", DEFAULT_PLATEAU),
             )
             dem.preprocess()
             dem.is_preview = self.is_preview(name)  # type: ignore
+            if dem.is_preview:  # type: ignore
+                dem.multiplier = 1
+            dem.auto_process = autoprocess
             dem.set_output_resolution((self.rotated_size, self.rotated_size))
             dem.set_dem_path(output_path)
             dems.append(dem)
@@ -117,8 +109,9 @@ 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.water_depth:
+        if self.map.dem_settings.water_depth:
             self.subtraction()
 
         for dem in self.dems:
@@ -127,11 +120,10 @@ class Background(Component):
                 if self.game.additional_dem_name is not None:
                     self.make_copy(cutted_dem_path, self.game.additional_dem_name)
 
-        if not self.light_version:
+        if self.map.background_settings.generate_background:
             self.generate_obj_files()
+        if self.map.background_settings.generate_water:
             self.generate_water_resources_obj()
-        else:
-            self.logger.info("Light version is enabled, obj files will not be generated.")
 
     def make_copy(self, dem_path: str, dem_name: str) -> None:
         """Copies DEM data to additional DEM file.
@@ -145,7 +137,7 @@ class Background(Component):
         additional_dem_path = os.path.join(dem_directory, dem_name)
 
         shutil.copyfile(dem_path, additional_dem_path)
-        self.logger.info("Additional DEM data was copied to %s.", additional_dem_path)
+        self.logger.debug("Additional DEM data was copied to %s.", additional_dem_path)
 
     def info_sequence(self) -> dict[str, str | float | int]:
         """Returns a dictionary with information about the background terrain.
@@ -207,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.
@@ -226,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)
@@ -261,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 = 1 / 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.
@@ -325,13 +324,13 @@ class Background(Component):
             self.mesh_to_stl(mesh)
         else:
             if not include_zeros:
-                multiplier = self.kwargs.get("multiplier", DEFAULT_MULTIPLIER)
+                multiplier = self.map.dem_settings.multiplier
                 if multiplier != 1:
                     z_scaling_factor = 1 / multiplier
                 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)
@@ -347,7 +346,7 @@ class Background(Component):
         preview_path = os.path.join(self.previews_directory, "background_dem.stl")
         mesh.export(preview_path)
 
-        self.logger.info("STL file saved: %s", preview_path)
+        self.logger.debug("STL file saved: %s", preview_path)
 
         self.stl_preview_path = preview_path  # pylint: disable=attribute-defined-outside-init
 
@@ -485,8 +484,7 @@ class Background(Component):
             rotation=self.rotation,
             map_directory=self.map_directory,
             logger=self.logger,
-            light_version=self.light_version,
-            custom_schema=background_layers,
+            texture_custom_schema=background_layers,  # type: ignore
         )
 
         self.background_texture.preprocess()
@@ -509,7 +507,7 @@ class Background(Component):
 
         background_save_path = os.path.join(self.water_directory, "water_resources.png")
         cv2.imwrite(background_save_path, background_image)
-        self.logger.info("Background texture saved: %s", background_save_path)
+        self.logger.debug("Background texture saved: %s", background_save_path)
         self.water_resources_path = background_save_path  # pylint: disable=W0201
 
     def subtraction(self) -> None:
@@ -534,7 +532,7 @@ class Background(Component):
 
             # Create a mask where water_resources_image is 255 (or not 0)
             # Subtract water_depth from dem_image where mask is True
-            dem_image[mask] = dem_image[mask] - self.water_depth
+            dem_image[mask] = dem_image[mask] - self.map.dem_settings.water_depth
 
             # Save the modified dem_image back to the output path
             cv2.imwrite(output_path, dem_image)

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
 
@@ -20,7 +20,7 @@ if TYPE_CHECKING:
     from maps4fs.generator.map import Map
 
 
-# pylint: disable=R0801, R0903, R0902, R0904
+# pylint: disable=R0801, R0903, R0902, R0904, R0913, R0917
 class Component:
     """Base class for all map generation components.
 
@@ -46,7 +46,7 @@ class Component:
         rotation: int,
         map_directory: str,
         logger: Any = None,
-        **kwargs,  # pylint: disable=W0613, R0913, R0917
+        **kwargs: dict[str, Any],
     ):
         self.game = game
         self.map = map
@@ -58,6 +58,13 @@ class Component:
         self.logger = logger
         self.kwargs = kwargs
 
+        self.logger.info(
+            "Component %s initialized. Map size: %s, map rotated size: %s",  # type: ignore
+            self.__class__.__name__,
+            self.map_size,
+            self.map_rotated_size,
+        )
+
         os.makedirs(self.previews_directory, exist_ok=True)
         os.makedirs(self.scripts_directory, exist_ok=True)
         os.makedirs(self.info_layers_directory, exist_ok=True)
@@ -331,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:
@@ -469,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/config.py

@@ -38,7 +38,7 @@ class Config(Component):
             self.logger.warning("Map XML file not found: %s.", self._map_xml_path)
             return
         tree = ET.parse(self._map_xml_path)
-        self.logger.info("Map XML file loaded from: %s.", self._map_xml_path)
+        self.logger.debug("Map XML file loaded from: %s.", self._map_xml_path)
         root = tree.getroot()
         for map_elem in root.iter("map"):
             map_elem.set("width", str(self.map_size))

maps4fs/generator/dem.py

@@ -14,9 +14,6 @@ from pympler import asizeof  # type: ignore
 from maps4fs.generator.component import Component
 
 SRTM = "https://elevation-tiles-prod.s3.amazonaws.com/skadi/{latitude_band}/{tile_name}.hgt.gz"
-DEFAULT_MULTIPLIER = 1
-DEFAULT_BLUR_RADIUS = 35
-DEFAULT_PLATEAU = 0
 
 
 # pylint: disable=R0903, R0902
@@ -50,20 +47,21 @@ class DEM(Component):
         self.output_resolution = self.get_output_resolution()
         self.logger.debug("Output resolution for DEM data: %s.", self.output_resolution)
 
-        self.multiplier = self.kwargs.get("multiplier", DEFAULT_MULTIPLIER)
-        blur_radius = self.kwargs.get("blur_radius", DEFAULT_BLUR_RADIUS)
+        blur_radius = self.map.dem_settings.blur_radius
         if blur_radius is None or blur_radius <= 0:
             # We'll disable blur if the radius is 0 or negative.
             blur_radius = 0
         elif blur_radius % 2 == 0:
             blur_radius += 1
         self.blur_radius = blur_radius
+        self.multiplier = self.map.dem_settings.multiplier
         self.logger.debug(
-            "DEM value multiplier is %s, blur radius is %s.", self.multiplier, self.blur_radius
+            "DEM value multiplier is %s, blur radius is %s.",
+            self.multiplier,
+            self.blur_radius,
         )
 
-        self.auto_process = self.kwargs.get("auto_process", False)
-        self.plateau = self.kwargs.get("plateau", False)
+        self.auto_process = self.map.dem_settings.auto_process
 
     @property
     def dem_path(self) -> str:
@@ -240,24 +238,24 @@ class DEM(Component):
             resampled_data.max(),
         )
 
-        if self.plateau:
+        if self.map.dem_settings.plateau:
             # Plateau is a flat area with a constant height.
             # So we just add this value to each pixel of the DEM.
             # And also need to ensure that there will be no values with height greater than
             # it's allowed in 16-bit unsigned integer.
 
-            resampled_data += self.plateau
+            resampled_data += self.map.dem_settings.plateau
             resampled_data = np.clip(resampled_data, 0, 65535)
 
             self.logger.debug(
                 "Plateau with height %s was added to DEM data. Min: %s, max: %s.",
-                self.plateau,
+                self.map.dem_settings.plateau,
                 resampled_data.min(),
                 resampled_data.max(),
             )
 
         cv2.imwrite(self._dem_path, resampled_data)
-        self.logger.info("DEM data was saved to %s.", self._dem_path)
+        self.logger.debug("DEM data was saved to %s.", self._dem_path)
 
         if self.rotation:
             self.rotate_dem()
@@ -403,7 +401,7 @@ class DEM(Component):
 
         scaling_factor = self._get_scaling_factor(max_dev)
         adjusted_max_height = int(65535 * scaling_factor)
-        self.logger.info(
+        self.logger.debug(
             "Maximum deviation: %s. Scaling factor: %s. Adjusted max height: %s.",
             max_dev,
             scaling_factor,

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

@@ -40,13 +40,10 @@ class GRLE(Component):
         """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.farmland_margin = self.kwargs.get("farmland_margin", 0)
-        self.randomize_plants = self.kwargs.get("randomize_plants", True)
-
         try:
             grle_schema_path = self.game.grle_schema
         except ValueError:
-            self.logger.info("GRLE schema processing is not implemented for this game.")
+            self.logger.warning("GRLE schema processing is not implemented for this game.")
             return
 
         try:
@@ -60,7 +57,7 @@ class GRLE(Component):
     def process(self) -> None:
         """Generates InfoLayer PNG files based on the GRLE schema."""
         if not self._grle_schema:
-            self.logger.info("GRLE schema is not obtained, skipping the processing.")
+            self.logger.debug("GRLE schema is not obtained, skipping the processing.")
             return
 
         for info_layer in self._grle_schema:
@@ -87,7 +84,7 @@ class GRLE(Component):
 
         self._add_farmlands()
         if self.game.code == "FS25":
-            self.logger.info("Game is %s, plants will be added.", self.game.code)
+            self.logger.debug("Game is %s, plants will be added.", self.game.code)
             self._add_plants()
         else:
             self.logger.warning("Adding plants it's not supported for the %s.", self.game.code)
@@ -123,7 +120,7 @@ class GRLE(Component):
             self.game.weights_dir_path(self.map_directory), "infoLayer_farmlands.png"
         )
 
-        self.logger.info(
+        self.logger.debug(
             "Adding farmlands to the InfoLayer PNG file: %s.", info_layer_farmlands_path
         )
 
@@ -147,8 +144,10 @@ class GRLE(Component):
 
         for field in fields:
             try:
-                fitted_field = self.fit_polygon_into_bounds(
-                    field, self.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(
@@ -193,10 +192,10 @@ class GRLE(Component):
 
         tree.write(farmlands_xml_path)
 
-        self.logger.info("Farmlands added to the farmlands XML file: %s.", farmlands_xml_path)
+        self.logger.debug("Farmlands added to the farmlands XML file: %s.", farmlands_xml_path)
 
         cv2.imwrite(info_layer_farmlands_path, image)  # pylint: disable=no-member
-        self.logger.info(
+        self.logger.debug(
             "Farmlands added to the InfoLayer PNG file: %s.", info_layer_farmlands_path
         )
 
@@ -357,8 +356,8 @@ class GRLE(Component):
 
         # Add islands of plants to the base image.
         island_count = self.map_size
-        self.logger.info("Adding %s islands of plants to the base image.", island_count)
-        if self.randomize_plants:
+        self.logger.debug("Adding %s islands of plants to the base image.", island_count)
+        if self.map.grle_settings.random_plants:
             grass_image_copy = create_island_of_plants(grass_image_copy, island_count)
         self.logger.debug("Islands of plants added to the base image.")
 
@@ -394,4 +393,4 @@ class GRLE(Component):
         # 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)
         cv2.imwrite(density_map_fruit_path, density_map_fruits)
-        self.logger.info("Updated density map for fruits saved in %s.", density_map_fruit_path)
+        self.logger.debug("Updated density map for fruits saved in %s.", density_map_fruit_path)