maps4fs 2.0.9__tar.gz → 2.1.1__tar.gz

{maps4fs-2.0.9 → maps4fs-2.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maps4fs
-Version: 2.0.9
+Version: 2.1.1
 Summary: Generate map templates for Farming Simulator from real places.
 Author-email: iwatkot <iwatkot@gmail.com>
 License: Apache License 2.0
@@ -650,6 +650,8 @@ You can also apply some advanced settings to the map generation process.<br>
 
 - Forest density - the density of the forest in meters. The lower the value, the lower the distance between the trees, which makes the forest denser. Note, that low values will lead to enormous number of trees, which may cause the Giants Editor to crash or lead to performance issues. By default, it's set to 10.
 
+- Tree limit - this value will be used to adjust the forest density value. For example, if it's possible to place 100000 trees from OSM data, and the forest density is set to 10, the expected number of trees on map will be 10000. At the same time, if you set the tree limit to 5000, the forest density will be adjusted to 20, which means that the distance between the trees will be doubled. This value is useful to prevent the Giants Editor from crashing due to too many trees on the map. By default, it's set to 0, which means that it's disabled and will use the forest density value as is. Note, that it will not lead to the exact number of trees, but will adjust the forest density value to fit the tree limit so the resulting number of trees will be more or less equal to the tree limit value.
+
 - Trees relative shift - represents the maximum possible shift of the tree from it's original position in percents of the forest density value. The higher the value, the more the trees will be shifted from their original positions. Warning: higher values can lead to overlapping trees.
 
 - 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.

{maps4fs-2.0.9 → maps4fs-2.1.1}/README.md

@@ -619,6 +619,8 @@ You can also apply some advanced settings to the map generation process.<br>
 
 - Forest density - the density of the forest in meters. The lower the value, the lower the distance between the trees, which makes the forest denser. Note, that low values will lead to enormous number of trees, which may cause the Giants Editor to crash or lead to performance issues. By default, it's set to 10.
 
+- Tree limit - this value will be used to adjust the forest density value. For example, if it's possible to place 100000 trees from OSM data, and the forest density is set to 10, the expected number of trees on map will be 10000. At the same time, if you set the tree limit to 5000, the forest density will be adjusted to 20, which means that the distance between the trees will be doubled. This value is useful to prevent the Giants Editor from crashing due to too many trees on the map. By default, it's set to 0, which means that it's disabled and will use the forest density value as is. Note, that it will not lead to the exact number of trees, but will adjust the forest density value to fit the tree limit so the resulting number of trees will be more or less equal to the tree limit value.
+
 - Trees relative shift - represents the maximum possible shift of the tree from it's original position in percents of the forest density value. The higher the value, the more the trees will be shifted from their original positions. Warning: higher values can lead to overlapping trees.
 
 - 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.

{maps4fs-2.0.9 → maps4fs-2.1.1}/maps4fs/generator/component/base/component_mesh.py

@@ -265,5 +265,5 @@ class MeshComponent(Component):
             trimesh.Trimesh: A new mesh with inverted faces.
         """
         mesh_copy = mesh.copy()
-        mesh_copy.faces = mesh_copy.faces[:, ::-1]
+        mesh_copy.faces = mesh_copy.faces[:, ::-1]  # type: ignore
         return mesh_copy

{maps4fs-2.0.9 → maps4fs-2.1.1}/maps4fs/generator/component/base/component_xml.py

@@ -4,6 +4,7 @@ import os
 from xml.etree import ElementTree as ET
 
 from maps4fs.generator.component.base.component import Component
+from maps4fs.generator.settings import Parameters
 
 
 class XMLComponent(Component):
@@ -57,6 +58,20 @@ class XMLComponent(Component):
 
         tree.write(xml_path, encoding="utf-8", xml_declaration=True)
 
+    def get_element_from_tree(self, path: str, xml_path: str | None = None) -> ET.Element | None:
+        """Finds an element in the XML tree by the path.
+
+        Arguments:
+            path (str): The path to the element.
+            xml_path (str, optional): The path to the XML file. Defaults to None.
+
+        Returns:
+            ET.Element | None: The found element or None if not found.
+        """
+        tree = self.get_tree(xml_path)
+        root = tree.getroot()
+        return root.find(path)  # type: ignore
+
     def get_and_update_element(self, root: ET.Element, path: str, data: dict[str, str]) -> None:
         """Finds the element by the path and updates it with the provided data.
 
@@ -106,3 +121,25 @@ class XMLComponent(Component):
         """
         element = ET.SubElement(parent, element_name)
         self.update_element(element, data)
+
+    def get_height_scale(self) -> int:
+        """Returns the height scale from the I3D file.
+
+        Returns:
+            int: The height scale value.
+
+        Raises:
+            ValueError: If the height scale element is not found in the I3D file.
+        """
+        height_scale_element = self.get_element_from_tree(
+            path=".//Scene/TerrainTransformGroup",
+            xml_path=self.game.i3d_file_path(self.map_directory),
+        )
+        if height_scale_element is None:
+            raise ValueError("Height scale element not found in the I3D file.")
+
+        height_scale = height_scale_element.get(Parameters.HEIGHT_SCALE)
+        if height_scale is None:
+            raise ValueError("Height scale not found in the I3D file.")
+
+        return int(height_scale)

maps4fs-2.1.1/maps4fs/generator/component/config.py

@@ -0,0 +1,215 @@
+"""This module contains the Config class for map settings and configuration."""
+
+from __future__ import annotations
+
+import os
+
+import cv2
+
+from maps4fs.generator.component.base.component_xml import XMLComponent
+
+
+# pylint: disable=R0903
+class Config(XMLComponent):
+    """Component for map settings and configuration.
+
+    Arguments:
+        game (Game): The game instance for which the map is generated.
+        coordinates (tuple[float, float]): The latitude and longitude of the center of the map.
+        map_size (int): The size of the map in pixels (it's a square).
+        map_rotated_size (int): The size of the map in pixels after rotation.
+        rotation (int): The rotation angle of the map.
+        map_directory (str): The directory where the map files are stored.
+        logger (Any, optional): The logger to use. Must have at least three basic methods: debug,
+            info, warning. If not provided, default logging will be used.
+    """
+
+    def preprocess(self) -> None:
+        """Gets the path to the map XML file and saves it to the instance variable."""
+        self.xml_path = self.game.map_xml_path(self.map_directory)
+        self.fog_parameters: dict[str, int] = {}
+
+    def process(self) -> None:
+        """Sets the map size in the map.xml file."""
+        self._set_map_size()
+
+        if self.game.fog_processing:
+            self._adjust_fog()
+
+    def _set_map_size(self) -> None:
+        """Edits map.xml file to set correct map size."""
+        tree = self.get_tree()
+        if not tree:
+            raise FileNotFoundError(f"Map XML file not found: {self.xml_path}")
+
+        root = tree.getroot()
+        data = {
+            "width": str(self.scaled_size),
+            "height": str(self.scaled_size),
+        }
+
+        for element in root.iter("map"):  # type: ignore
+            self.update_element(element, data)
+            break
+        self.save_tree(tree)
+
+    def info_sequence(self) -> dict[str, dict[str, str | float | int]]:
+        """Returns information about the component.
+        Overview section is needed to create the overview file (in-game map).
+
+        Returns:
+            dict[str, dict[str, str | float | int]]: Information about the component.
+        """
+        # The overview file is exactly 2X bigger than the map size, does not matter
+        # if the map is 2048x2048 or 4096x4096, the overview will be 4096x4096
+        # and the map will be in the center of the overview.
+        # That's why the distance is set to the map height not as a half of it.
+        bbox = self.get_bbox(distance=self.map_size)
+        south, west, north, east = bbox
+        epsg3857_string = self.get_epsg3857_string(bbox=bbox)
+        epsg3857_string_with_margin = self.get_epsg3857_string(bbox=bbox, add_margin=True)
+
+        self.qgis_sequence()
+
+        overview_data = {
+            "epsg3857_string": epsg3857_string,
+            "epsg3857_string_with_margin": epsg3857_string_with_margin,
+            "south": south,
+            "west": west,
+            "north": north,
+            "east": east,
+            "height": self.map_size * 2,
+            "width": self.map_size * 2,
+        }
+
+        data = {
+            "Overview": overview_data,
+        }
+        if self.fog_parameters:
+            data["Fog"] = self.fog_parameters  # type: ignore
+
+        return data  # type: ignore
+
+    def qgis_sequence(self) -> None:
+        """Generates QGIS scripts for creating bounding box layers and rasterizing them."""
+        bbox = self.get_bbox(distance=self.map_size)
+        espg3857_bbox = self.get_espg3857_bbox(bbox=bbox)
+        espg3857_bbox_with_margin = self.get_espg3857_bbox(bbox=bbox, add_margin=True)
+
+        qgis_layers = [("Overview_bbox", *espg3857_bbox)]
+        qgis_layers_with_margin = [("Overview_bbox_with_margin", *espg3857_bbox_with_margin)]
+
+        layers = qgis_layers + qgis_layers_with_margin
+
+        self.create_qgis_scripts(layers)
+
+    def _adjust_fog(self) -> None:
+        """Adjusts the fog settings in the environment XML file based on the DEM and height scale."""
+        self.logger.debug("Adjusting fog settings based on DEM and height scale...")
+        try:
+            environment_xml_path = self.game.get_environment_xml_path(self.map_directory)
+        except NotImplementedError:
+            self.logger.warning(
+                "Game does not support environment XML file, fog adjustment will not be applied."
+            )
+            return
+
+        if not environment_xml_path or not os.path.isfile(environment_xml_path):
+            self.logger.warning(
+                "Environment XML file not found, fog adjustment will not be applied."
+            )
+            return
+
+        self.logger.debug("Will work with environment XML file: %s", environment_xml_path)
+
+        dem_params = self._get_dem_meter_params()
+        if not dem_params:
+            return
+        maximum_height, minimum_height = dem_params
+
+        tree = self.get_tree(xml_path=environment_xml_path)
+        root = tree.getroot()
+
+        # Find the <latitude>40.6</latitude> element in the XML file.
+        latitude_element = root.find("./latitude")  # type: ignore
+        if latitude_element is not None:
+            map_latitude = round(self.map.coordinates[0], 1)
+            latitude_element.text = str(map_latitude)
+            self.logger.debug(
+                "Found latitude element and set it to: %s",
+                latitude_element.text,
+            )
+
+        # The XML file contains 4 <fog> entries in different sections of <weather> representing
+        # different seasons, such as <season name="spring">, <season name="summer">, etc.
+        # We need to find them all and adjust the parameters accordingly.
+        for season in root.findall(".//weather/season"):  # type: ignore
+            # Example of the <heightFog> element:
+            # <heightFog>
+            #     <groundLevelDensity min="0.05" max="0.2" />
+            #     <maxHeight min="420" max="600" />
+            # </heightFog>
+            # We need to adjust the maxheight min and max attributes.
+            max_height_element = season.find("./fog/heightFog/maxHeight")
+            data = {
+                "min": str(minimum_height),
+                "max": str(maximum_height),
+            }
+            self.update_element(max_height_element, data)  # type: ignore
+            self.logger.debug(
+                "Adjusted fog settings for season '%s': min=%s, max=%s",
+                season.get("name", "unknown"),
+                minimum_height,
+                maximum_height,
+            )
+
+        self.logger.debug("Fog adjusted and file will be saved to %s", environment_xml_path)
+        self.save_tree(tree, xml_path=environment_xml_path)
+
+        self.fog_parameters = {
+            "minimum_height": minimum_height,
+            "maximum_height": maximum_height,
+        }
+
+    def _get_dem_meter_params(self) -> tuple[int, int] | None:
+        """Reads the DEM file and returns the maximum and minimum height in meters.
+
+        Returns:
+            tuple[int, int] | None: Maximum and minimum height in meters or None if the DEM file
+                is not found or cannot be read.
+        """
+        self.logger.debug("Reading DEM meter parameters...")
+        dem_path = self.game.dem_file_path(self.map_directory)
+        if not dem_path or not os.path.isfile(dem_path):
+            self.logger.warning("DEM file not found, fog adjustment will not be applied.")
+            return None
+
+        dem_image = cv2.imread(dem_path, cv2.IMREAD_UNCHANGED)
+        if dem_image is None:
+            self.logger.warning("Failed to read DEM image, fog adjustment will not be applied.")
+            return None
+        dem_maximum_pixel = dem_image.max()
+        dem_minimum_pixel = dem_image.min()
+
+        self.logger.debug(
+            "DEM read successfully. Max pixel: %d, Min pixel: %d",
+            dem_maximum_pixel,
+            dem_minimum_pixel,
+        )
+
+        try:
+            height_scale = self.get_height_scale()
+        except ValueError as e:
+            self.logger.warning("Error getting height scale from I3D file: %s", e)
+            return None
+        self.logger.debug("Height scale from I3D file: %d", height_scale)
+
+        dem_maximum_meter = int(dem_maximum_pixel / height_scale)
+        dem_minimum_meter = int(dem_minimum_pixel / height_scale)
+        self.logger.debug(
+            "DEM maximum height in meters: %d, minimum height in meters: %d",
+            dem_maximum_meter,
+            dem_minimum_meter,
+        )
+
+        return dem_maximum_meter, dem_minimum_meter

{maps4fs-2.0.9 → maps4fs-2.1.1}/maps4fs/generator/component/i3d.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import json
 import os
 from random import choice, randint, uniform
-from typing import Generator
+from typing import Any, Generator
 from xml.etree import ElementTree as ET
 
 import cv2
@@ -48,6 +48,9 @@ class I3d(XMLComponent):
         attribute. If the game does not support I3D files, the attribute is set to None."""
         self.xml_path = self.game.i3d_file_path(self.map_directory)
 
+        self.forest_info: dict[str, Any] = {}
+        self.field_info: dict[str, Any] = {}
+
     def process(self) -> None:
         """Updates the map I3D file and creates splines in a separate I3D file."""
         self.update_height_scale()
@@ -83,7 +86,7 @@ class I3d(XMLComponent):
         root = tree.getroot()
         path = ".//Scene/TerrainTransformGroup"
 
-        data = {"heightScale": str(value)}
+        data = {Parameters.HEIGHT_SCALE: str(value)}
 
         self.get_and_update_element(root, path, data)  # type: ignore
         self.save_tree(tree)  # type: ignore
@@ -267,6 +270,8 @@ class I3d(XMLComponent):
 
         node_id = NODE_ID_STARTING_VALUE
         field_id = 1
+        added_fields = skipped_fields = 0
+        skipped_field_ids: list[int] = []
 
         for field in tqdm(fields, desc="Adding fields", unit="field"):
             try:
@@ -279,6 +284,7 @@ class I3d(XMLComponent):
                     field_id,
                     e,
                 )
+                skipped_fields += 1
                 continue
 
             field_ccs = [self.top_left_coordinates_to_center(point) for point in fitted_field]
@@ -297,6 +303,11 @@ class I3d(XMLComponent):
 
             node_id += 1
             field_id += 1
+            added_fields += 1
+
+        self.field_info["added_fields"] = added_fields
+        self.field_info["skipped_fields"] = skipped_fields
+        self.field_info["skipped_field_ids"] = skipped_field_ids
 
         self.save_tree(tree)
 
@@ -504,6 +515,8 @@ class I3d(XMLComponent):
 
         node_id = TREE_NODE_ID_STARTING_VALUE
 
+        tree_count = 0
+
         for forest_layer in forest_layers:
             weights_directory = self.game.weights_dir_path(self.map_directory)
             forest_image_path = forest_layer.get_preview_or_path(weights_directory)
@@ -542,12 +555,17 @@ 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  # type: ignore
-            ):
+
+            step = self.get_step_by_limit(
+                forest_image,  # type: ignore
+                self.map.i3d_settings.tree_limit,
+                self.map.i3d_settings.forest_density,
+            )
+
+            for x, y in self.non_empty_pixels(forest_image, step=step):  # type: ignore
                 shifted_x, shifted_y = self.randomize_coordinates(
                     (x, y),
-                    self.map.i3d_settings.forest_density,
+                    step,
                     self.map.i3d_settings.trees_relative_shift,
                 )
 
@@ -573,9 +591,16 @@ class I3d(XMLComponent):
                 }
                 trees_node.append(self.create_element("ReferenceNode", data))
 
+                tree_count += 1
+
             scene_node.append(trees_node)
             self.save_tree(tree)
 
+        self.forest_info["tree_count"] = tree_count
+        self.forest_info["tree_limit"] = self.map.i3d_settings.tree_limit
+        self.forest_info["initial_step"] = self.map.i3d_settings.forest_density
+        self.forest_info["actual_step"] = step
+
         self.assets.forests = self.xml_path
 
     @staticmethod
@@ -606,19 +631,61 @@ class I3d(XMLComponent):
         image: np.ndarray, step: int = 1
     ) -> Generator[tuple[int, int], None, None]:
         """Receives numpy array, which represents single-channeled image of uint8 type.
-        Yield coordinates of non-empty pixels (pixels with value greater than 0).
+        Yield coordinates of non-empty pixels (pixels with value greater than 0), sampling about 1/step of them.
 
         Arguments:
             image (np.ndarray): The image to get non-empty pixels from.
-            step (int, optional): The step to iterate through the image. Defaults to 1.
+            step (int, optional): The step to sample non-empty pixels. Defaults to 1.
 
         Yields:
             tuple[int, int]: The coordinates of non-empty pixels.
         """
-        for y, row in enumerate(image[::step]):
-            for x, value in enumerate(row[::step]):
+        count = 0
+        for y, row in enumerate(image):
+            for x, value in enumerate(row):
                 if value > 0:
-                    yield x * step, y * step
+                    if count % step == 0:
+                        yield x, y
+                    count += 1
+
+    @staticmethod
+    def non_empty_pixels_count(image: np.ndarray) -> int:
+        """Counts the number of non-empty pixels in the image.
+
+        Arguments:
+            image (np.ndarray): The image to count non-empty pixels in.
+
+        Returns:
+            int: The number of non-empty pixels in the image.
+        """
+        result = np.count_nonzero(image > 0)
+        return result
+
+    def get_step_by_limit(
+        self, image: np.ndarray, limit: int, current_step: int | None = None
+    ) -> int:
+        """Calculates the step size for iterating through the image based on the limit based
+        on the number of non-empty pixels in the image.
+
+        Arguments:
+            image (np.ndarray): The image to calculate the step size for.
+            limit (int): The maximum number of non-empty pixels to process.
+            current_step (int | None, optional): The current step size. If provided, the method
+                will return the maximum of the recommended step and the current step.
+
+        Returns:
+            int: The recommended step size for iterating through the image.
+        """
+        available_tree_count = self.non_empty_pixels_count(image)
+        self.forest_info["available_tree_count"] = available_tree_count
+        if limit <= 0 or available_tree_count <= limit:
+            recommended_step = 1
+        else:
+            recommended_step = int(available_tree_count / limit)
+
+        self.forest_info["step_by_limit"] = recommended_step
+
+        return recommended_step if not current_step else max(recommended_step, current_step)
 
     def get_not_resized_dem(self) -> np.ndarray | None:
         """Reads the not resized DEM image from the background component.
@@ -638,3 +705,16 @@ class I3d(XMLComponent):
         not_resized_dem = cv2.imread(background_component.not_resized_path, cv2.IMREAD_UNCHANGED)
 
         return not_resized_dem
+
+    def info_sequence(self) -> dict[str, dict[str, str | float | int]]:
+        """Returns information about the component.
+
+        Returns:
+            dict[str, dict[str, str | float | int]]: Information about the component.
+        """
+        data = {
+            "Forests": self.forest_info,
+            "Fields": self.field_info,
+        }
+
+        return data

{maps4fs-2.0.9 → maps4fs-2.1.1}/maps4fs/generator/game.py

@@ -40,6 +40,7 @@ class Game:
     _tree_schema: str | None = None
     _i3d_processing: bool = True
     _plants_processing: bool = True
+    _fog_processing: bool = True
     _dissolve: bool = True
 
     # Order matters! Some components depend on others.
@@ -189,6 +190,16 @@ class Game:
             str: The path to the farmlands xml file."""
         raise NotImplementedError
 
+    def get_environment_xml_path(self, map_directory: str) -> str:
+        """Returns the path to the environment xml file.
+
+        Arguments:
+            map_directory (str): The path to the map directory.
+
+        Returns:
+            str: The path to the environment xml file."""
+        raise NotImplementedError
+
     def i3d_file_path(self, map_directory: str) -> str:
         """Returns the path to the i3d file.
 
@@ -207,6 +218,14 @@ class Game:
             bool: True if the i3d file should be processed, False otherwise."""
         return self._i3d_processing
 
+    @property
+    def fog_processing(self) -> bool:
+        """Returns whether the fog should be processed.
+
+        Returns:
+            bool: True if the fog should be processed, False otherwise."""
+        return self._fog_processing
+
     @property
     def plants_processing(self) -> bool:
         """Returns whether the plants should be processed.
@@ -250,6 +269,7 @@ class FS22(Game):
     _map_template_path = os.path.join(working_directory, "data", "fs22-map-template.zip")
     _texture_schema = os.path.join(working_directory, "data", "fs22-texture-schema.json")
     _i3d_processing = False
+    _fog_processing = False
     _plants_processing = False
     _dissolve = False
 
@@ -345,3 +365,13 @@ class FS25(Game):
         Returns:
             str: The path to the farmlands xml file."""
         return os.path.join(map_directory, "map", "config", "farmlands.xml")
+
+    def get_environment_xml_path(self, map_directory: str) -> str:
+        """Returns the path to the environment xml file.
+
+        Arguments:
+            map_directory (str): The path to the map directory.
+
+        Returns:
+            str: The path to the environment xml file."""
+        return os.path.join(map_directory, "map", "config", "environment.xml")

{maps4fs-2.0.9 → maps4fs-2.1.1}/maps4fs/generator/settings.py

@@ -40,6 +40,8 @@ class Parameters:
 
     WATER_ADD_WIDTH = 2
 
+    HEIGHT_SCALE = "heightScale"
+
 
 class SharedSettings(BaseModel):
     """Represents the shared settings for all components."""
@@ -201,6 +203,7 @@ class I3DSettings(SettingsModel):
     Attributes:
         add_trees (bool): add trees to the map.
         forest_density (int): density of the forest (distance between trees).
+        tree_limit (int): maximum number of trees to be added to the map.
         trees_relative_shift (int): relative shift of the trees.
         spline_density (int): the number of extra points that will be added between each two
             existing points.
@@ -210,6 +213,7 @@ class I3DSettings(SettingsModel):
 
     add_trees: bool = True
     forest_density: int = 10
+    tree_limit: int = 0
     trees_relative_shift: int = 20
 
     spline_density: int = 2

{maps4fs-2.0.9 → maps4fs-2.1.1}/maps4fs.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maps4fs
-Version: 2.0.9
+Version: 2.1.1
 Summary: Generate map templates for Farming Simulator from real places.
 Author-email: iwatkot <iwatkot@gmail.com>
 License: Apache License 2.0
@@ -650,6 +650,8 @@ You can also apply some advanced settings to the map generation process.<br>
 
 - Forest density - the density of the forest in meters. The lower the value, the lower the distance between the trees, which makes the forest denser. Note, that low values will lead to enormous number of trees, which may cause the Giants Editor to crash or lead to performance issues. By default, it's set to 10.
 
+- Tree limit - this value will be used to adjust the forest density value. For example, if it's possible to place 100000 trees from OSM data, and the forest density is set to 10, the expected number of trees on map will be 10000. At the same time, if you set the tree limit to 5000, the forest density will be adjusted to 20, which means that the distance between the trees will be doubled. This value is useful to prevent the Giants Editor from crashing due to too many trees on the map. By default, it's set to 0, which means that it's disabled and will use the forest density value as is. Note, that it will not lead to the exact number of trees, but will adjust the forest density value to fit the tree limit so the resulting number of trees will be more or less equal to the tree limit value.
+
 - Trees relative shift - represents the maximum possible shift of the tree from it's original position in percents of the forest density value. The higher the value, the more the trees will be shifted from their original positions. Warning: higher values can lead to overlapping trees.
 
 - 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.

{maps4fs-2.0.9 → maps4fs-2.1.1}/pyproject.toml

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

maps4fs-2.0.9/maps4fs/generator/component/config.py

@@ -1,94 +0,0 @@
-"""This module contains the Config class for map settings and configuration."""
-
-from __future__ import annotations
-
-from maps4fs.generator.component.base.component_xml import XMLComponent
-
-
-# pylint: disable=R0903
-class Config(XMLComponent):
-    """Component for map settings and configuration.
-
-    Arguments:
-        game (Game): The game instance for which the map is generated.
-        coordinates (tuple[float, float]): The latitude and longitude of the center of the map.
-        map_size (int): The size of the map in pixels (it's a square).
-        map_rotated_size (int): The size of the map in pixels after rotation.
-        rotation (int): The rotation angle of the map.
-        map_directory (str): The directory where the map files are stored.
-        logger (Any, optional): The logger to use. Must have at least three basic methods: debug,
-            info, warning. If not provided, default logging will be used.
-    """
-
-    def preprocess(self) -> None:
-        """Gets the path to the map XML file and saves it to the instance variable."""
-        self.xml_path = self.game.map_xml_path(self.map_directory)
-
-    def process(self) -> None:
-        """Sets the map size in the map.xml file."""
-        self._set_map_size()
-
-    def _set_map_size(self) -> None:
-        """Edits map.xml file to set correct map size."""
-        tree = self.get_tree()
-        if not tree:
-            raise FileNotFoundError(f"Map XML file not found: {self.xml_path}")
-
-        root = tree.getroot()
-        data = {
-            "width": str(self.scaled_size),
-            "height": str(self.scaled_size),
-        }
-
-        for element in root.iter("map"):  # type: ignore
-            self.update_element(element, data)
-            break
-        self.save_tree(tree)
-
-    def info_sequence(self) -> dict[str, dict[str, str | float | int]]:
-        """Returns information about the component.
-        Overview section is needed to create the overview file (in-game map).
-
-        Returns:
-            dict[str, dict[str, str | float | int]]: Information about the component.
-        """
-        # The overview file is exactly 2X bigger than the map size, does not matter
-        # if the map is 2048x2048 or 4096x4096, the overview will be 4096x4096
-        # and the map will be in the center of the overview.
-        # That's why the distance is set to the map height not as a half of it.
-        bbox = self.get_bbox(distance=self.map_size)
-        south, west, north, east = bbox
-        epsg3857_string = self.get_epsg3857_string(bbox=bbox)
-        epsg3857_string_with_margin = self.get_epsg3857_string(bbox=bbox, add_margin=True)
-
-        self.qgis_sequence()
-
-        overview_data = {
-            "epsg3857_string": epsg3857_string,
-            "epsg3857_string_with_margin": epsg3857_string_with_margin,
-            "south": south,
-            "west": west,
-            "north": north,
-            "east": east,
-            "height": self.map_size * 2,
-            "width": self.map_size * 2,
-        }
-
-        data = {
-            "Overview": overview_data,
-        }
-
-        return data  # type: ignore
-
-    def qgis_sequence(self) -> None:
-        """Generates QGIS scripts for creating bounding box layers and rasterizing them."""
-        bbox = self.get_bbox(distance=self.map_size)
-        espg3857_bbox = self.get_espg3857_bbox(bbox=bbox)
-        espg3857_bbox_with_margin = self.get_espg3857_bbox(bbox=bbox, add_margin=True)
-
-        qgis_layers = [("Overview_bbox", *espg3857_bbox)]
-        qgis_layers_with_margin = [("Overview_bbox_with_margin", *espg3857_bbox_with_margin)]
-
-        layers = qgis_layers + qgis_layers_with_margin
-
-        self.create_qgis_scripts(layers)