maps4fs 1.1.9__tar.gz → 1.2.1__tar.gz

{maps4fs-1.1.9 → maps4fs-1.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: maps4fs
-Version: 1.1.9
+Version: 1.2.1
 Summary: Generate map templates for Farming Simulator from real places.
 Author-email: iwatkot <iwatkot@gmail.com>
 License: MIT License
@@ -68,6 +68,8 @@ Requires-Dist: pympler
 🔄 Support map rotation 🆕<br>
 🌾 Automatically generates fields 🆕<br>
 🌽 Automatically generates farmlands 🆕<br>
+🌿 Automatically generates decorative foliage 🆕<br>
+🌲 Automatically generates forests 🆕<br>
 🌍 Based on real-world data from OpenStreetMap<br>
 🏞️ Generates height map using SRTM dataset<br>
 📦 Provides a ready-to-use map template for the Giants Editor<br>
@@ -84,6 +86,10 @@ Requires-Dist: pympler
 🛰️ Realistic background terrain with satellite images.<br><br>
 <img src="https://github.com/user-attachments/assets/6e3c0e99-2cce-46ac-82db-5cb60bba7a30"><br>
 📐 Perfectly aligned background terrain.<br><br>
+<img src="https://github.com/user-attachments/assets/5764b2ec-e626-426f-9f5d-beb12ba95133"><br>
+🌿 Automatically generates decorative foliage.<br><br>
+<img src="https://github.com/user-attachments/assets/27a5e541-a9f5-4504-b8d2-64aae9fb3e52"><br>
+🌲 Automatically generates forests.<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>

{maps4fs-1.1.9 → maps4fs-1.2.1}/README.md

@@ -43,6 +43,8 @@
 🔄 Support map rotation 🆕<br>
 🌾 Automatically generates fields 🆕<br>
 🌽 Automatically generates farmlands 🆕<br>
+🌿 Automatically generates decorative foliage 🆕<br>
+🌲 Automatically generates forests 🆕<br>
 🌍 Based on real-world data from OpenStreetMap<br>
 🏞️ Generates height map using SRTM dataset<br>
 📦 Provides a ready-to-use map template for the Giants Editor<br>
@@ -59,6 +61,10 @@
 🛰️ Realistic background terrain with satellite images.<br><br>
 <img src="https://github.com/user-attachments/assets/6e3c0e99-2cce-46ac-82db-5cb60bba7a30"><br>
 📐 Perfectly aligned background terrain.<br><br>
+<img src="https://github.com/user-attachments/assets/5764b2ec-e626-426f-9f5d-beb12ba95133"><br>
+🌿 Automatically generates decorative foliage.<br><br>
+<img src="https://github.com/user-attachments/assets/27a5e541-a9f5-4504-b8d2-64aae9fb3e52"><br>
+🌲 Automatically generates forests.<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>

{maps4fs-1.1.9 → maps4fs-1.2.1}/maps4fs/generator/background.py

@@ -63,6 +63,7 @@ class Background(Component):
         for name, autoprocess in zip(ELEMENTS, autoprocesses):
             dem = DEM(
                 self.game,
+                self.map,
                 self.coordinates,
                 background_size,
                 rotated_size,

{maps4fs-1.1.9 → maps4fs-1.2.1}/maps4fs/generator/component.py

@@ -17,6 +17,7 @@ from maps4fs.generator.qgis import save_scripts
 
 if TYPE_CHECKING:
     from maps4fs.generator.game import Game
+    from maps4fs.generator.map import Map
 
 
 # pylint: disable=R0801, R0903, R0902, R0904
@@ -25,6 +26,7 @@ class Component:
 
     Arguments:
         game (Game): The game instance for which the map is generated.
+        map (Map): The map instance for which the component 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.
         map_rotated_size (int): The size of the map in pixels after rotation.
@@ -37,6 +39,7 @@ class Component:
     def __init__(
         self,
         game: Game,
+        map: Map,  # pylint: disable=W0622
         coordinates: tuple[float, float],
         map_size: int,
         map_rotated_size: int,
@@ -46,6 +49,7 @@ class Component:
         **kwargs,  # pylint: disable=W0613, R0913, R0917
     ):
         self.game = game
+        self.map = map
         self.coordinates = coordinates
         self.map_size = map_size
         self.map_rotated_size = map_rotated_size

{maps4fs-1.1.9 → maps4fs-1.2.1}/maps4fs/generator/game.py

@@ -36,6 +36,7 @@ class Game:
     _map_template_path: str | None = None
     _texture_schema: str | None = None
     _grle_schema: str | None = None
+    _tree_schema: str | None = None
 
     # Order matters! Some components depend on others.
     components = [Texture, I3d, GRLE, Background, Config]
@@ -109,6 +110,19 @@ class Game:
             raise ValueError("GRLE layers schema path not set.")
         return self._grle_schema
 
+    @property
+    def tree_schema(self) -> str:
+        """Returns the path to the tree layers schema file.
+
+        Raises:
+            ValueError: If the tree layers schema path is not set.
+
+        Returns:
+            str: The path to the tree layers schema file."""
+        if not self._tree_schema:
+            raise ValueError("Tree layers schema path not set.")
+        return self._tree_schema
+
     def dem_file_path(self, map_directory: str) -> str:
         """Returns the path to the DEM file.
 
@@ -187,6 +201,7 @@ class FS25(Game):
     _map_template_path = os.path.join(working_directory, "data", "fs25-map-template.zip")
     _texture_schema = os.path.join(working_directory, "data", "fs25-texture-schema.json")
     _grle_schema = os.path.join(working_directory, "data", "fs25-grle-schema.json")
+    _tree_schema = os.path.join(working_directory, "data", "fs25-tree-schema.json")
 
     def dem_file_path(self, map_directory: str) -> str:
         """Returns the path to the DEM file.

maps4fs-1.2.1/maps4fs/generator/grle.py

@@ -0,0 +1,389 @@
+"""This module contains the GRLE class for generating InfoLayer PNG files based on GRLE schema."""
+
+import json
+import os
+from random import choice, randint
+from xml.etree import ElementTree as ET
+
+import cv2
+import numpy as np
+from shapely.geometry import Polygon  # type: ignore
+
+from maps4fs.generator.component import Component
+from maps4fs.generator.texture import Texture
+
+ISLAND_SIZE_MIN = 10
+ISLAND_SIZE_MAX = 200
+ISLAND_DISTORTION = 0.3
+ISLAND_VERTEX_COUNT = 30
+ISLAND_ROUNDING_RADIUS = 15
+
+
+# pylint: disable=W0223
+class GRLE(Component):
+    """Component for to generate InfoLayer PNG files based on GRLE schema.
+
+    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.
+        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.
+    """
+
+    _grle_schema: dict[str, float | int | str] | None = None
+
+    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.farmland_margin = self.kwargs.get("farmland_margin", 0)
+
+        try:
+            grle_schema_path = self.game.grle_schema
+        except ValueError:
+            self.logger.info("GRLE schema processing is not implemented for this game.")
+            return
+
+        try:
+            with open(grle_schema_path, "r", encoding="utf-8") as file:
+                self._grle_schema = json.load(file)
+            self.logger.debug("GRLE schema loaded from: %s.", grle_schema_path)
+        except (json.JSONDecodeError, FileNotFoundError) as error:
+            self.logger.error("Error loading GRLE schema from %s: %s.", grle_schema_path, error)
+            self._grle_schema = None
+
+    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.")
+            return
+
+        for info_layer in self._grle_schema:
+            if isinstance(info_layer, dict):
+                file_path = os.path.join(
+                    self.game.weights_dir_path(self.map_directory), info_layer["name"]
+                )
+
+                height = int(self.map_size * info_layer["height_multiplier"])
+                width = int(self.map_size * info_layer["width_multiplier"])
+                channels = info_layer["channels"]
+                data_type = info_layer["data_type"]
+
+                # Create the InfoLayer PNG file with zeros.
+                if channels == 1:
+                    info_layer_data = np.zeros((height, width), dtype=data_type)
+                else:
+                    info_layer_data = np.zeros((height, width, channels), dtype=data_type)
+                self.logger.debug("Shape of %s: %s.", info_layer["name"], info_layer_data.shape)
+                cv2.imwrite(file_path, info_layer_data)  # pylint: disable=no-member
+                self.logger.debug("InfoLayer PNG file %s created.", file_path)
+            else:
+                self.logger.warning("Invalid InfoLayer schema: %s.", info_layer)
+
+        self._add_farmlands()
+        if self.game.code == "FS25":
+            self.logger.info("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)
+
+    def previews(self) -> list[str]:
+        """Returns a list of paths to the preview images (empty list).
+        The component does not generate any preview images so it returns an empty list.
+
+        Returns:
+            list[str]: An empty list.
+        """
+        return []
+
+    # pylint: disable=R0801, R0914
+    def _add_farmlands(self) -> None:
+        """Adds farmlands to the InfoLayer PNG file."""
+
+        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)
+
+        fields: list[list[tuple[int, int]]] | None = textures_info_layer.get("fields")
+        if not fields:
+            self.logger.warning("Fields data not found in textures info layer.")
+            return
+
+        self.logger.info("Found %s fields in textures info layer.", len(fields))
+
+        info_layer_farmlands_path = os.path.join(
+            self.game.weights_dir_path(self.map_directory), "infoLayer_farmlands.png"
+        )
+
+        self.logger.info(
+            "Adding farmlands to the InfoLayer PNG file: %s.", info_layer_farmlands_path
+        )
+
+        if not os.path.isfile(info_layer_farmlands_path):
+            self.logger.warning("InfoLayer PNG file %s not found.", info_layer_farmlands_path)
+            return
+
+        # pylint: disable=no-member
+        image = cv2.imread(info_layer_farmlands_path, cv2.IMREAD_UNCHANGED)
+        farmlands_xml_path = os.path.join(self.map_directory, "map/config/farmlands.xml")
+        if not os.path.isfile(farmlands_xml_path):
+            self.logger.warning("Farmlands XML file %s not found.", farmlands_xml_path)
+            return
+
+        tree = ET.parse(farmlands_xml_path)
+        farmlands_xml = tree.find("farmlands")
+
+        # Not using enumerate because in case of the error, we do not increment
+        # the farmland_id. So as a result we do not have a gap in the farmland IDs.
+        farmland_id = 1
+
+        for field in fields:
+            try:
+                fitted_field = self.fit_polygon_into_bounds(
+                    field, self.farmland_margin, angle=self.rotation
+                )
+            except ValueError as e:
+                self.logger.warning(
+                    "Farmland %s could not be fitted into the map bounds with error: %s",
+                    farmland_id,
+                    e,
+                )
+                continue
+
+            self.logger.debug("Fitted field %s contains %s points.", farmland_id, len(fitted_field))
+
+            field_np = np.array(fitted_field, np.int32)
+            field_np = field_np.reshape((-1, 1, 2))
+
+            self.logger.debug(
+                "Created a numpy array and reshaped it. Number of points: %s", len(field_np)
+            )
+
+            # Infolayer image is 1/2 of the size of the map image, that's why we need to divide
+            # the coordinates by 2.
+            field_np = field_np // 2
+            self.logger.debug("Divided the coordinates by 2.")
+
+            # pylint: disable=no-member
+            try:
+                cv2.fillPoly(image, [field_np], farmland_id)  # type: ignore
+            except Exception as e:  # pylint: disable=W0718
+                self.logger.warning(
+                    "Farmland %s could not be added to the InfoLayer PNG file with error: %s",
+                    farmland_id,
+                    e,
+                )
+                continue
+
+            # Add the field to the farmlands XML.
+            farmland = ET.SubElement(farmlands_xml, "farmland")  # type: ignore
+            farmland.set("id", str(farmland_id))
+            farmland.set("priceScale", "1")
+            farmland.set("npcName", "FORESTER")
+
+            farmland_id += 1
+
+        tree.write(farmlands_xml_path)
+
+        self.logger.info("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(
+            "Farmlands added to the InfoLayer PNG file: %s.", info_layer_farmlands_path
+        )
+
+    # pylint: disable=R0915
+    def _add_plants(self) -> None:
+        """Adds plants to the InfoLayer PNG file."""
+        # 1. Get the path to the densityMap_fruits.png.
+        # 2. Get the path to the base layer (grass).
+        # 3. Detect non-zero areas in the base layer (it's where the plants will be placed).
+        texture_component: Texture | None = self.map.get_component("Texture")  # type: ignore
+        if not texture_component:
+            self.logger.warning("Texture component not found in the map.")
+            return
+
+        grass_layer = texture_component.get_layer_by_usage("grass")
+        if not grass_layer:
+            self.logger.warning("Grass layer not found in the texture component.")
+            return
+
+        weights_directory = self.game.weights_dir_path(self.map_directory)
+        grass_image_path = grass_layer.get_preview_or_path(weights_directory)
+        self.logger.debug("Grass image path: %s.", grass_image_path)
+
+        forest_layer = texture_component.get_layer_by_usage("forest")
+        forest_image = None
+        if forest_layer:
+            forest_image_path = forest_layer.get_preview_or_path(weights_directory)
+            self.logger.debug("Forest image path: %s.", forest_image_path)
+            if forest_image_path:
+                # pylint: disable=no-member
+                forest_image = cv2.imread(forest_image_path, cv2.IMREAD_UNCHANGED)
+
+        if not grass_image_path or not os.path.isfile(grass_image_path):
+            self.logger.warning("Base image not found in %s.", grass_image_path)
+            return
+
+        density_map_fruit_path = os.path.join(
+            self.game.weights_dir_path(self.map_directory), "densityMap_fruits.png"
+        )
+
+        self.logger.debug("Density map for fruits path: %s.", density_map_fruit_path)
+
+        if not os.path.isfile(density_map_fruit_path):
+            self.logger.warning("Density map for fruits not found in %s.", density_map_fruit_path)
+            return
+
+        # Single channeled 8-bit image, where non-zero values (255) are where the grass is.
+        grass_image = cv2.imread(  # pylint: disable=no-member
+            grass_image_path, cv2.IMREAD_UNCHANGED  # pylint: disable=no-member
+        )
+
+        # Density map of the fruits is 2X size of the base image, so we need to resize it.
+        # We'll resize the base image to make it bigger, so we can compare the values.
+        grass_image = cv2.resize(  # pylint: disable=no-member
+            grass_image,
+            (grass_image.shape[1] * 2, grass_image.shape[0] * 2),
+            interpolation=cv2.INTER_NEAREST,  # pylint: disable=no-member
+        )
+        if forest_image is not None:
+            forest_image = cv2.resize(  # pylint: disable=no-member
+                forest_image,
+                (forest_image.shape[1] * 2, forest_image.shape[0] * 2),
+                interpolation=cv2.INTER_NEAREST,  # pylint: disable=no-member
+            )
+
+            # Add non zero values from the forest image to the grass image.
+            grass_image[forest_image != 0] = 255
+
+        # B and G channels remain the same (zeros), while we change the R channel.
+        possible_R_values = [33, 65, 97, 129, 161, 193, 225]  # pylint: disable=C0103
+
+        # 1st approach: Change the non zero values in the base image to 33 (for debug).
+        # And use the base image as R channel in the density map.
+
+        # pylint: disable=no-member
+        def create_island_of_plants(image: np.ndarray, count: int) -> np.ndarray:
+            """Create an island of plants in the image.
+
+            Arguments:
+                image (np.ndarray): The image where the island of plants will be created.
+                count (int): The number of islands of plants to create.
+
+            Returns:
+                np.ndarray: The image with the islands of plants.
+            """
+            for _ in range(count):
+                # Randomly choose the value for the island.
+                plant_value = choice(possible_R_values)
+                # Randomly choose the size of the island.
+                island_size = randint(ISLAND_SIZE_MIN, ISLAND_SIZE_MAX)
+                # Randomly choose the position of the island.
+                # x = np.random.randint(0, image.shape[1] - island_size)
+                # y = np.random.randint(0, image.shape[0] - island_size)
+                x = randint(0, image.shape[1] - island_size)
+                y = randint(0, image.shape[0] - island_size)
+
+                # Randomly choose the shape of the island.
+                # shapes = ["circle", "ellipse", "polygon"]
+                # shape = choice(shapes)
+
+                try:
+                    polygon_points = get_rounded_polygon(
+                        num_vertices=ISLAND_VERTEX_COUNT,
+                        center=(x + island_size // 2, y + island_size // 2),
+                        radius=island_size // 2,
+                        rounding_radius=ISLAND_ROUNDING_RADIUS,
+                    )
+                    if not polygon_points:
+                        continue
+
+                    nodes = np.array(polygon_points, np.int32)  # type: ignore
+                    cv2.fillPoly(image, [nodes], plant_value)  # type: ignore
+                except Exception:  # pylint: disable=W0703
+                    continue
+
+            return image
+
+        def get_rounded_polygon(
+            num_vertices: int, center: tuple[int, int], radius: int, rounding_radius: int
+        ) -> list[tuple[int, int]] | None:
+            """Get a randomly rounded polygon.
+
+            Arguments:
+                num_vertices (int): The number of vertices of the polygon.
+                center (tuple[int, int]): The center of the polygon.
+                radius (int): The radius of the polygon.
+                rounding_radius (int): The rounding radius of the polygon.
+
+            Returns:
+                list[tuple[int, int]] | None: The rounded polygon.
+            """
+            angle_offset = np.pi / num_vertices
+            angles = np.linspace(0, 2 * np.pi, num_vertices, endpoint=False) + angle_offset
+            random_angles = angles + np.random.uniform(
+                -ISLAND_DISTORTION, ISLAND_DISTORTION, num_vertices
+            )  # Add randomness to angles
+            random_radii = radius + np.random.uniform(
+                -radius * ISLAND_DISTORTION, radius * ISLAND_DISTORTION, num_vertices
+            )  # Add randomness to radii
+
+            points = [
+                (center[0] + np.cos(a) * r, center[1] + np.sin(a) * r)
+                for a, r in zip(random_angles, random_radii)
+            ]
+            polygon = Polygon(points)
+            buffered_polygon = polygon.buffer(rounding_radius, resolution=16)
+            rounded_polygon = list(buffered_polygon.exterior.coords)
+            if not rounded_polygon:
+                return None
+            return rounded_polygon
+
+        grass_image_copy = grass_image.copy()
+        if forest_image is not None:
+            # Add the forest layer to the base image, to merge the masks.
+            grass_image_copy[forest_image != 0] = 33
+        # Set all the non-zero values to 33.
+        grass_image_copy[grass_image != 0] = 33
+
+        # 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)
+        grass_image_copy = create_island_of_plants(grass_image_copy, island_count)
+        self.logger.debug("Islands of plants added to the base image.")
+
+        # Sligtly reduce the size of the grass_image, that we'll use as mask.
+        kernel = np.ones((3, 3), np.uint8)
+        grass_image = cv2.erode(grass_image, kernel, iterations=1)
+
+        # Remove the values where the base image has zeros.
+        grass_image_copy[grass_image == 0] = 0
+        self.logger.debug("Removed the values where the base image has zeros.")
+
+        # Value of 33 represents the base grass plant.
+        # After painting it with base grass, we'll create multiple islands of different plants.
+        # On the final step, we'll remove all the values which in pixels
+        # where zerons in the original base image (so we don't paint grass where it should not be).
+
+        # Three channeled 8-bit image, where non-zero values are the
+        # different types of plants (only in the R channel).
+        density_map_fruits = cv2.imread(density_map_fruit_path, cv2.IMREAD_UNCHANGED)
+        self.logger.debug("Density map for fruits loaded, shape: %s.", density_map_fruits.shape)
+
+        # Put the updated base image as the B channel in the density map.
+        density_map_fruits[:, :, 0] = grass_image_copy
+        self.logger.debug("Updated base image added as the B channel in the density map.")
+
+        # Save the updated density map.
+        # Ensure that order of channels is correct because CV2 uses BGR and we need RGB.
+        density_map_fruits = cv2.cvtColor(density_map_fruits, cv2.COLOR_BGR2RGB)
+        cv2.imwrite(density_map_fruit_path, density_map_fruits)
+        self.logger.info("Updated density map for fruits saved in %s.", density_map_fruit_path)

{maps4fs-1.1.9 → maps4fs-1.2.1}/maps4fs/generator/i3d.py

@@ -4,15 +4,23 @@ from __future__ import annotations
 
 import json
 import os
+from random import choice, randint, uniform
+from typing import Generator
 from xml.etree import ElementTree as ET
 
+import cv2
+import numpy as np
+
 from maps4fs.generator.component import Component
+from maps4fs.generator.texture import Texture
 
 DEFAULT_HEIGHT_SCALE = 2000
 DISPLACEMENT_LAYER_SIZE_FOR_BIG_MAPS = 32768
 DEFAULT_MAX_LOD_DISTANCE = 10000
 DEFAULT_MAX_LOD_OCCLUDER_DISTANCE = 10000
-NODE_ID_STARTING_VALUE = 500
+NODE_ID_STARTING_VALUE = 2000
+TREE_NODE_ID_STARTING_VALUE = 4000
+DEFAULT_FOREST_DENSITY = 10
 
 
 # pylint: disable=R0903
@@ -44,10 +52,14 @@ class I3d(Component):
             self.logger.info("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()
 
     def _get_tree(self) -> ET.ElementTree | None:
         """Returns the ElementTree instance of the map I3D file."""
@@ -85,6 +97,21 @@ class I3d(Component):
 
                 self.logger.debug("TerrainTransformGroup element updated in I3D file.")
 
+            sun_elem = map_elem.find(".//Light[@name='sun']")
+
+            if sun_elem is not None:
+                self.logger.debug("Sun element found in I3D file.")
+
+                distance = self.map_size // 2
+
+                sun_elem.set("lastShadowMapSplitBboxMin", f"-{distance},-128,-{distance}")
+                sun_elem.set("lastShadowMapSplitBboxMax", f"{distance},148,{distance}")
+
+                self.logger.debug(
+                    "Sun BBOX updated with half of the map size: %s.",
+                    distance,
+                )
+
         if self.map_size > 4096:
             displacement_layer = terrain_elem.find(".//DisplacementLayer")  # pylint: disable=W0631
 
@@ -301,3 +328,138 @@ class I3d(Component):
         attribute_node.set("type", attr_type)
         attribute_node.set("value", value)
         return attribute_node
+
+    # 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
+
+        texture_component: Texture | None = self.map.get_component("Texture")  # type: ignore
+        if not texture_component:
+            self.logger.warning("Texture component not found.")
+            return
+
+        forest_layer = texture_component.get_layer_by_usage("forest")
+
+        if not forest_layer:
+            self.logger.warning("Forest layer not found.")
+            return
+
+        weights_directory = self.game.weights_dir_path(self.map_directory)
+        forest_image_path = forest_layer.get_preview_or_path(weights_directory)
+
+        if not forest_image_path or not os.path.isfile(forest_image_path):
+            self.logger.warning("Forest image not found.")
+            return
+
+        tree = self._get_tree()
+        if tree is None:
+            return
+
+        # Find the <Scene> element in the I3D file.
+        root = tree.getroot()
+        scene_node = root.find(".//Scene")
+        if scene_node is None:
+            self.logger.warning("Scene element not found in I3D file.")
+            return
+
+        self.logger.debug("Scene element found in I3D file, starting to add forests.")
+
+        node_id = TREE_NODE_ID_STARTING_VALUE
+
+        # Create <TransformGroup name="trees" translation="0 400 0" nodeId="{node_id}"> element.
+        trees_node = ET.Element("TransformGroup")
+        trees_node.set("name", "trees")
+        trees_node.set("translation", "0 400 0")
+        trees_node.set("nodeId", str(node_id))
+        node_id += 1
+
+        # pylint: disable=no-member
+        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):
+            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
+
+            random_tree = choice(tree_schema)
+            tree_name = random_tree["name"]
+            tree_id = random_tree["reference_id"]
+
+            reference_node = ET.Element("ReferenceNode")
+            reference_node.set("name", tree_name)  # type: ignore
+            reference_node.set("translation", f"{xcs} 0 {ycs}")
+            reference_node.set("rotation", f"0 {rotation} 0")
+            reference_node.set("referenceId", str(tree_id))
+            reference_node.set("nodeId", str(node_id))
+
+            trees_node.append(reference_node)
+            tree_count += 1
+
+        scene_node.append(trees_node)
+        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)
+
+    @staticmethod
+    def randomize_coordinates(coordinates: tuple[int, int], density: int) -> tuple[float, float]:
+        """Randomizes the coordinates of the point with the given density.
+
+        Arguments:
+            coordinates (tuple[int, int]): The coordinates of the point.
+            density (int): The density of the randomization.
+
+        Returns:
+            tuple[float, float]: The randomized coordinates of the point.
+        """
+        MAXIMUM_RELATIVE_SHIFT = 0.2  # pylint: disable=C0103
+        shift_range = density * MAXIMUM_RELATIVE_SHIFT
+
+        x_shift = uniform(-shift_range, shift_range)
+        y_shift = uniform(-shift_range, shift_range)
+
+        x, y = coordinates
+        x += x_shift  # type: ignore
+        y += y_shift  # type: ignore
+
+        return x, y
+
+    @staticmethod
+    def non_empty_pixels(
+        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).
+
+        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.
+
+        Yields:
+            tuple[int, int]: The coordinates of non-empty pixels.
+        """
+        for y, row in enumerate(image[::step]):
+            for x, value in enumerate(row[::step]):
+                if value > 0:
+                    yield x * step, y * step

{maps4fs-1.1.9 → maps4fs-1.2.1}/maps4fs/generator/map.py

@@ -74,6 +74,7 @@ class Map:
         for game_component in self.game.components:
             component = game_component(
                 self.game,
+                self,
                 self.coordinates,
                 self.size,
                 self.rotated_size,
@@ -82,6 +83,7 @@ class Map:
                 self.logger,
                 **self.kwargs,
             )
+            self.components.append(component)
 
             yield component.__class__.__name__
 
@@ -104,7 +106,20 @@ class Map:
                     e,
                 )
                 raise e
-            self.components.append(component)
+
+    def get_component(self, component_name: str) -> Component | None:
+        """Get component by name.
+
+        Arguments:
+            component_name (str): Name of the component.
+
+        Returns:
+            Component | None: Component instance or None if not found.
+        """
+        for component in self.components:
+            if component.__class__.__name__ == component_name:
+                return component
+        return None
 
     def previews(self) -> list[str]:
         """Get list of preview images.

{maps4fs-1.1.9 → maps4fs-1.2.1}/maps4fs/generator/texture.py

@@ -63,6 +63,7 @@ class Texture(Component):
             exclude_weight: bool = False,
             priority: int | None = None,
             info_layer: str | None = None,
+            usage: str | None = None,
         ):
             self.name = name
             self.count = count
@@ -72,6 +73,7 @@ class Texture(Component):
             self.exclude_weight = exclude_weight
             self.priority = priority
             self.info_layer = info_layer
+            self.usage = usage
 
         def to_json(self) -> dict[str, str | list[str] | bool]:  # type: ignore
             """Returns dictionary with layer data.
@@ -87,6 +89,7 @@ class Texture(Component):
                 "exclude_weight": self.exclude_weight,
                 "priority": self.priority,
                 "info_layer": self.info_layer,
+                "usage": self.usage,
             }
 
             data = {k: v for k, v in data.items() if v is not None}
@@ -117,29 +120,29 @@ class Texture(Component):
             weight_postfix = "_weight" if not self.exclude_weight else ""
             return os.path.join(weights_directory, f"{self.name}{idx}{weight_postfix}.png")
 
-        def path_preview(self, previews_directory: str) -> str:
+        def path_preview(self, weights_directory: str) -> str:
             """Returns path to the preview of the first texture of the layer.
 
             Arguments:
-                previews_directory (str): Path to the directory with previews.
+                weights_directory (str): Path to the directory with weights.
 
             Returns:
                 str: Path to the preview.
             """
-            return self.path(previews_directory).replace(".png", "_preview.png")
+            return self.path(weights_directory).replace(".png", "_preview.png")
 
-        def get_preview_or_path(self, previews_directory: str) -> str:
+        def get_preview_or_path(self, weights_directory: str) -> str:
             """Returns path to the preview of the first texture of the layer if it exists,
             otherwise returns path to the texture.
 
             Arguments:
-                previews_directory (str): Path to the directory with previews.
+                weights_directory (str): Path to the directory with weights.
 
             Returns:
                 str: Path to the preview or texture.
             """
-            preview_path = self.path_preview(previews_directory)
-            return preview_path if os.path.isfile(preview_path) else self.path(previews_directory)
+            preview_path = self.path_preview(weights_directory)
+            return preview_path if os.path.isfile(preview_path) else self.path(weights_directory)
 
         def paths(self, weights_directory: str) -> list[str]:
             """Returns a list of paths to the textures of the layer.
@@ -212,6 +215,20 @@ class Texture(Component):
                 return layer
         return None
 
+    def get_layer_by_usage(self, usage: str) -> Layer | None:
+        """Returns layer by usage.
+
+        Arguments:
+            usage (str): Usage of the layer.
+
+        Returns:
+            Layer | None: Layer.
+        """
+        for layer in self.layers:
+            if layer.usage == usage:
+                return layer
+        return None
+
     def process(self):
         self._prepare_weights()
         self._read_parameters()
@@ -287,7 +304,10 @@ class Texture(Component):
         Arguments:
             layer (Layer): Layer with textures and tags.
         """
-        size = (self.map_rotated_size, self.map_rotated_size)
+        if layer.tags is None:
+            size = (self.map_size, self.map_size)
+        else:
+            size = (self.map_rotated_size, self.map_rotated_size)
         postfix = "_weight.png" if not layer.exclude_weight else ".png"
         if layer.count == 0:
             filepaths = [os.path.join(self._weights_dir, layer.name + postfix)]

{maps4fs-1.1.9 → maps4fs-1.2.1}/maps4fs.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: maps4fs
-Version: 1.1.9
+Version: 1.2.1
 Summary: Generate map templates for Farming Simulator from real places.
 Author-email: iwatkot <iwatkot@gmail.com>
 License: MIT License
@@ -68,6 +68,8 @@ Requires-Dist: pympler
 🔄 Support map rotation 🆕<br>
 🌾 Automatically generates fields 🆕<br>
 🌽 Automatically generates farmlands 🆕<br>
+🌿 Automatically generates decorative foliage 🆕<br>
+🌲 Automatically generates forests 🆕<br>
 🌍 Based on real-world data from OpenStreetMap<br>
 🏞️ Generates height map using SRTM dataset<br>
 📦 Provides a ready-to-use map template for the Giants Editor<br>
@@ -84,6 +86,10 @@ Requires-Dist: pympler
 🛰️ Realistic background terrain with satellite images.<br><br>
 <img src="https://github.com/user-attachments/assets/6e3c0e99-2cce-46ac-82db-5cb60bba7a30"><br>
 📐 Perfectly aligned background terrain.<br><br>
+<img src="https://github.com/user-attachments/assets/5764b2ec-e626-426f-9f5d-beb12ba95133"><br>
+🌿 Automatically generates decorative foliage.<br><br>
+<img src="https://github.com/user-attachments/assets/27a5e541-a9f5-4504-b8d2-64aae9fb3e52"><br>
+🌲 Automatically generates forests.<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>

{maps4fs-1.1.9 → maps4fs-1.2.1}/pyproject.toml

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

maps4fs-1.1.9/maps4fs/generator/grle.py

@@ -1,186 +0,0 @@
-"""This module contains the GRLE class for generating InfoLayer PNG files based on GRLE schema."""
-
-import json
-import os
-from xml.etree import ElementTree as ET
-
-import cv2
-import numpy as np
-
-from maps4fs.generator.component import Component
-
-
-# pylint: disable=W0223
-class GRLE(Component):
-    """Component for to generate InfoLayer PNG files based on GRLE schema.
-
-    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.
-        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.
-    """
-
-    _grle_schema: dict[str, float | int | str] | None = None
-
-    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.farmland_margin = self.kwargs.get("farmland_margin", 0)
-
-        try:
-            grle_schema_path = self.game.grle_schema
-        except ValueError:
-            self.logger.info("GRLE schema processing is not implemented for this game.")
-            return
-
-        try:
-            with open(grle_schema_path, "r", encoding="utf-8") as file:
-                self._grle_schema = json.load(file)
-            self.logger.debug("GRLE schema loaded from: %s.", grle_schema_path)
-        except (json.JSONDecodeError, FileNotFoundError) as error:
-            self.logger.error("Error loading GRLE schema from %s: %s.", grle_schema_path, error)
-            self._grle_schema = None
-
-    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.")
-            return
-
-        for info_layer in self._grle_schema:
-            if isinstance(info_layer, dict):
-                file_path = os.path.join(
-                    self.game.weights_dir_path(self.map_directory), info_layer["name"]
-                )
-
-                height = int(self.map_size * info_layer["height_multiplier"])
-                width = int(self.map_size * info_layer["width_multiplier"])
-                channels = info_layer["channels"]
-                data_type = info_layer["data_type"]
-
-                # Create the InfoLayer PNG file with zeros.
-                if channels == 1:
-                    info_layer_data = np.zeros((height, width), dtype=data_type)
-                else:
-                    info_layer_data = np.zeros((height, width, channels), dtype=data_type)
-                self.logger.debug("Shape of %s: %s.", info_layer["name"], info_layer_data.shape)
-                cv2.imwrite(file_path, info_layer_data)  # pylint: disable=no-member
-                self.logger.debug("InfoLayer PNG file %s created.", file_path)
-            else:
-                self.logger.warning("Invalid InfoLayer schema: %s.", info_layer)
-
-        self._add_farmlands()
-
-    def previews(self) -> list[str]:
-        """Returns a list of paths to the preview images (empty list).
-        The component does not generate any preview images so it returns an empty list.
-
-        Returns:
-            list[str]: An empty list.
-        """
-        return []
-
-    # pylint: disable=R0801, R0914
-    def _add_farmlands(self) -> None:
-        """Adds farmlands to the InfoLayer PNG file."""
-
-        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)
-
-        fields: list[list[tuple[int, int]]] | None = textures_info_layer.get("fields")
-        if not fields:
-            self.logger.warning("Fields data not found in textures info layer.")
-            return
-
-        self.logger.info("Found %s fields in textures info layer.", len(fields))
-
-        info_layer_farmlands_path = os.path.join(
-            self.game.weights_dir_path(self.map_directory), "infoLayer_farmlands.png"
-        )
-
-        self.logger.info(
-            "Adding farmlands to the InfoLayer PNG file: %s.", info_layer_farmlands_path
-        )
-
-        if not os.path.isfile(info_layer_farmlands_path):
-            self.logger.warning("InfoLayer PNG file %s not found.", info_layer_farmlands_path)
-            return
-
-        # pylint: disable=no-member
-        image = cv2.imread(info_layer_farmlands_path, cv2.IMREAD_UNCHANGED)
-        farmlands_xml_path = os.path.join(self.map_directory, "map/config/farmlands.xml")
-        if not os.path.isfile(farmlands_xml_path):
-            self.logger.warning("Farmlands XML file %s not found.", farmlands_xml_path)
-            return
-
-        tree = ET.parse(farmlands_xml_path)
-        farmlands_xml = tree.find("farmlands")
-
-        # Not using enumerate because in case of the error, we do not increment
-        # the farmland_id. So as a result we do not have a gap in the farmland IDs.
-        farmland_id = 1
-
-        for field in fields:
-            try:
-                fitted_field = self.fit_polygon_into_bounds(
-                    field, self.farmland_margin, angle=self.rotation
-                )
-            except ValueError as e:
-                self.logger.warning(
-                    "Farmland %s could not be fitted into the map bounds with error: %s",
-                    farmland_id,
-                    e,
-                )
-                continue
-
-            self.logger.debug("Fitted field %s contains %s points.", farmland_id, len(fitted_field))
-
-            field_np = np.array(fitted_field, np.int32)
-            field_np = field_np.reshape((-1, 1, 2))
-
-            self.logger.debug(
-                "Created a numpy array and reshaped it. Number of points: %s", len(field_np)
-            )
-
-            # Infolayer image is 1/2 of the size of the map image, that's why we need to divide
-            # the coordinates by 2.
-            field_np = field_np // 2
-            self.logger.debug("Divided the coordinates by 2.")
-
-            # pylint: disable=no-member
-            try:
-                cv2.fillPoly(image, [field_np], farmland_id)  # type: ignore
-            except Exception as e:  # pylint: disable=W0718
-                self.logger.warning(
-                    "Farmland %s could not be added to the InfoLayer PNG file with error: %s",
-                    farmland_id,
-                    e,
-                )
-                continue
-
-            # Add the field to the farmlands XML.
-            farmland = ET.SubElement(farmlands_xml, "farmland")  # type: ignore
-            farmland.set("id", str(farmland_id))
-            farmland.set("priceScale", "1")
-            farmland.set("npcName", "FORESTER")
-
-            farmland_id += 1
-
-        tree.write(farmlands_xml_path)
-
-        self.logger.info("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(
-            "Farmlands added to the InfoLayer PNG file: %s.", info_layer_farmlands_path
-        )