maps4fs 1.1.0__py3-none-any.whl → 1.2.3__py3-none-any.whl

maps4fs/generator/background.py

@@ -43,6 +43,7 @@ class Background(Component):
     def preprocess(self) -> None:
         """Registers the DEMs for the background terrain."""
         self.light_version = self.kwargs.get("light_version", False)
+        self.stl_preview_path: str | None = None
 
         if self.rotation:
             self.logger.debug("Rotation is enabled: %s.", self.rotation)
@@ -62,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,
@@ -335,7 +337,8 @@ class Background(Component):
                 cv2.imwrite(background_dem_preview_path, background_dem_preview_image)
                 preview_paths.append(background_dem_preview_path)
 
-        preview_paths.append(self.stl_preview_path)
+        if self.stl_preview_path:
+            preview_paths.append(self.stl_preview_path)
 
         return preview_paths
 

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
@@ -356,6 +360,7 @@ class Component:
             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.")
 
         if margin:
             polygon = polygon.buffer(margin, join_style="mitre")
@@ -367,12 +372,16 @@ class Component:
 
         # Intersect the polygon with the bounds to fit it within the map
         fitted_polygon = polygon.intersection(bounds)
+        self.logger.debug("Fitted the polygon into the bounds: %s", bounds)
 
         if not isinstance(fitted_polygon, Polygon):
             raise ValueError("The fitted polygon is not a valid polygon.")
 
         # Return the fitted polygon points
-        return list(fitted_polygon.exterior.coords)
+        as_list = list(fitted_polygon.exterior.coords)
+        if not as_list:
+            raise ValueError("The fitted polygon has no points.")
+        return as_list
 
     def get_infolayer_path(self, layer_name: str) -> str | None:
         """Returns the path to the info layer file.

maps4fs/generator/game.py

@@ -31,11 +31,12 @@ class Game:
     """
 
     code: str | None = None
-    dem_multipliyer: int = 1
+    dem_multipliyer: int = 2
     _additional_dem_name: str | None = None
     _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/generator/grle.py

@@ -2,12 +2,21 @@
 
 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
@@ -32,6 +41,7 @@ class GRLE(Component):
         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
@@ -76,6 +86,11 @@ class GRLE(Component):
                 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).
@@ -108,6 +123,10 @@ class GRLE(Component):
             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
@@ -139,12 +158,19 @@ class GRLE(Component):
                 )
                 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:
@@ -173,3 +199,199 @@ class GRLE(Component):
         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)
+        if self.randomize_plants:
+            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.")
+
+        # Set zeros on all sides of the image
+        grass_image_copy[0, :] = 0  # Top side
+        grass_image_copy[-1, :] = 0  # Bottom side
+        grass_image_copy[:, 0] = 0  # Left side
+        grass_image_copy[:, -1] = 0  # Right side
+
+        # 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/generator/i3d.py

@@ -4,14 +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
@@ -43,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."""
@@ -84,6 +97,30 @@ 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
+
+            if displacement_layer is not None:
+                displacement_layer.set("size", str(DISPLACEMENT_LAYER_SIZE_FOR_BIG_MAPS))
+                self.logger.debug(
+                    "Map size is greater than 4096, DisplacementLayer size set to %s.",
+                )
+
         tree.write(self._map_i3d_path)  # type: ignore
         self.logger.info("Map I3D file saved to: %s.", self._map_i3d_path)
 
@@ -116,6 +153,7 @@ class I3d(Component):
             return
 
         self.logger.info("Found %s fields in textures info layer.", len(fields))
+        self.logger.debug("Starging to add fields to the I3D file.")
 
         root = tree.getroot()
         gameplay_node = root.find(".//TransformGroup[@name='gameplay']")
@@ -290,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/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/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.0.dist-info → maps4fs-1.2.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: maps4fs
-Version: 1.1.0
+Version: 1.2.3
 Summary: Generate map templates for Farming Simulator from real places.
 Author-email: iwatkot <iwatkot@gmail.com>
 License: MIT License
@@ -35,6 +35,7 @@ Requires-Dist: pympler
   <a href="#How-To-Run">How-To-Run</a><br>
   <a href="docs/FAQ.md">FAQ</a> •
   <a href="docs/map_structure.md">Map Structure</a> •
+  <a href="docs/tips_and_hints.md">Tips and Hints</a> •
   <a href="#Modder-Toolbox">Modder Toolbox</a><br>
   <a href="#Supported-objects">Supported objects</a> •
   <a href="#Generation-info">Generation info</a> •
@@ -42,9 +43,10 @@ Requires-Dist: pympler
   <a href="#Background-terrain">Background terrain</a> •
   <a href="#Overview-image">Overview image</a><br>
   <a href="#DDS-conversion">DDS conversion</a> •
-  <a href="#For-advanced-users">For advanced users</a> •
+  <a href="#Advanced-settings">Advanced settings</a> •
   <a href="#Resources">Resources</a> •
-  <a href="#Bugs-and-feature-requests">Bugs and feature requests</a>
+  <a href="#Bugs-and-feature-requests">Bugs and feature requests</a><br>
+  <a href="#Special-thanks">Special thanks</a>
 </p>
 
 
@@ -66,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>
@@ -78,17 +82,20 @@ Requires-Dist: pympler
 <p align="center">
 <img src="https://github.com/user-attachments/assets/cf8f5752-9c69-4018-bead-290f59ba6976"><br>
 🌎 Detailed terrain based on real-world data.<br><br>
-<img src="https://github.com/user-attachments/assets/7f238ab4-9ff4-4c6e-ba07-5796be012baa"><br>
-🛰️ Realistic background terrain objects with satellite images.<br><br>
+<img src="https://github.com/user-attachments/assets/dc40d0bb-c20b-411c-8833-9925d0389452"><br>
+🛰️ 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>
 🌾 Field generation with one click.<br><br>
 <img width="480" src="https://github.com/user-attachments/assets/4d1fa879-5d60-438b-a84e-16883bcef0ec"><br>
 🌽 Automatic farmlands generation based on the fields.<br><br>
-<img src="https://github.com/user-attachments/assets/cce45575-c917-4a1b-bdc0-6368e32ccdff"><br>
-📏 Almost any possible map sizes.
-</p>
 
 📹 A complete step-by-step video tutorial is here!  
 <a href="https://www.youtube.com/watch?v=Nl_aqXJ5nAk" target="_blank"><img src="https://github.com/user-attachments/assets/4845e030-0e73-47ab-a5a3-430308913060"/></a>
@@ -111,7 +118,7 @@ So, jump to [Docker version](#option-2-docker-version) to launch the tool with o
 ### 😎 For advanced users
 **Option 2:** Run the Docker version in your browser. Launch the following command in your terminal:
 ```bash
-docker run -d -p 8501:8501 iwatkot/maps4fs
+docker run -d -p 8501:8501 --name maps4fs iwatkot/maps4fs
 ```
 And open [http://localhost:8501](http://localhost:8501) in your browser.<br>
 If you don't know how to use Docker, navigate to the [Docker version](#option-2-docker-version), it's really simple.<br>
@@ -174,7 +181,7 @@ You can launch the project with minimalistic UI in your browser using Docker. Fo
 1. Install [Docker](https://docs.docker.com/get-docker/) for your OS.
 2. Run the following command in your terminal:
 ```bash
-docker run -d -p 8501:8501 iwatkot/maps4fs
+docker run -d -p 8501:8501 --name maps4fs iwatkot/maps4fs
 ```
 3. Open your browser and go to [http://localhost:8501](http://localhost:8501).
 4. Fill in the required fields and click on the `Generate` button.
@@ -452,7 +459,7 @@ List of the important DDS files:
 - `preview.dds` - 2048x2048 pixels, the preview image of the map on the loading screen,
 - `mapsUS/overview.dds` - 4096x4096 pixels, the overview image of the map (in-game map)
 
-## For advanced users
+## Advanced settings
 The tool supports the custom size of the map. To use this feature select `Custom` in the `Map size` dropdown and enter the desired size. The tool will generate a map with the size you entered.<br>
 
 ⛔️ Do not use this feature, if you don't know what you're doing. In most cases, the Giants Editor will just crash on opening the file, because you need to enter specific values for the map size.<br><br>
@@ -477,6 +484,12 @@ You can also apply some advanced settings to the map generation process. Note th
 
 - Farmlands margin - this value (in meters) will be applied to each farmland, making it bigger. You can use the value to adjust how much the farmland should be bigger than the actual field. By default, it's set to 3.
 
+### Vegetation Advanced settings
+
+- 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.
+
+- Random plants - when adding decorative foliage, enabling this option will add different species of plants to the map. If unchecked only basic grass (smallDenseMix) will be added. Defaults to True.
+
 ## Resources
 In this section, you'll find a list of the resources that you need to create a map for the Farming Simulator.<br>
 To create a basic map, you only need the Giants Editor. But if you want to create a background terrain - the world around the map, so it won't look like it's floating in the void - you also need Blender and the Blender Exporter Plugins. To create realistic textures for the background terrain, the QGIS is required to obtain high-resolution satellite images.<br>
@@ -491,3 +504,13 @@ To create a basic map, you only need the Giants Editor. But if you want to creat
 ## Bugs and feature requests
 ➡️ Please, before creating an issue or asking some questions, check the [FAQ](docs/FAQ.md) section.<br>
 If you find a bug or have an idea for a new feature, please create an issue [here](https://github.com/iwatkot/maps4fs/issues) or contact me directly on [Telegram](https://t.me/iwatkot) or on Discord: `iwatkot`.
+
+## Special thanks
+
+Of course, first of all, thanks to the direct [contributors](https://github.com/iwatkot/maps4fs/graphs/contributors) of the project.  
+
+But also, I want to thank the people who helped me with the project in some way, even if they didn't contribute directly. Here's the list of them:
+
+- [Ka5tis](https://github.com/Ka5tis) - for investigating the issue with a "spiky terrain" and finding a solution - changing the `DisplacementLayer` size to a higher value.
+- [Kalderone](https://www.youtube.com/@Kalderone_FS22) - for useful feedback, suggestions, expert advice on the map-making process and highlihting some important settings in the Giants Editor.
+- [OneSunnySunday](https://www.artstation.com/onesunnysunday) - for expert advice on Blender, help in processing background terrain, and compiling detailed tutorials on how to prepare the OBJ files for use in Giants Editor.

maps4fs-1.2.3.dist-info/RECORD

@@ -0,0 +1,21 @@
+maps4fs/__init__.py,sha256=da4jmND2Ths9AffnkAKgzLHNkvKFOc_l21gJisPXqWY,155
+maps4fs/logger.py,sha256=B-NEYpMjPAAqlV4VpfTi6nbBFnEABVtQOaYe6nMpidg,1489
+maps4fs/generator/__init__.py,sha256=zZMLEkGzb4z0xql650gOtGSvcgX58DnJ2yN3vC2daRk,43
+maps4fs/generator/background.py,sha256=fLWk7FSNL08gk3skHfi0iVchnKrYjnLLKAT1g_7sRzc,15907
+maps4fs/generator/component.py,sha256=_d9rHmGh348KOMrLWR8rRDVsbZ2xwJQwZGIGvMIYXPM,17533
+maps4fs/generator/config.py,sha256=b7qY0luC-_WM_c72Ohtlf4FrB37X5cALInbestSdUsw,4382
+maps4fs/generator/dem.py,sha256=rc7ADzjvlZzStOqagsWW0Vrm9-X86aPpoR1RhBF_-OE,16025
+maps4fs/generator/game.py,sha256=ZQeYzPzPB3CG41avdhNCyTZpHEeedqNBuAbNevTZuXg,7931
+maps4fs/generator/grle.py,sha256=3hcr5e2YLXemFi-_x2cLHWbMVb06591k0PZxaBVovH8,17600
+maps4fs/generator/i3d.py,sha256=oK5pKjzvT-gydma5Q6CcDYTVODGxK7MIGajLrAV9JkU,18370
+maps4fs/generator/map.py,sha256=lA1MNAcMwsDtsYxbwwm7DjwP3zraHKnri_xnLUu30j0,5326
+maps4fs/generator/qgis.py,sha256=Es8hLuqN_KH8lDfnJE6He2rWYbAKJ3RGPn-o87S6CPI,6116
+maps4fs/generator/texture.py,sha256=MSkM-rH_836l8zgq1WVcYJeYrUofWBpC8OKJglSmGGQ,26558
+maps4fs/toolbox/__init__.py,sha256=zZMLEkGzb4z0xql650gOtGSvcgX58DnJ2yN3vC2daRk,43
+maps4fs/toolbox/background.py,sha256=9BXWNqs_n3HgqDiPztWylgYk_QM4YgBpe6_ZNQAWtSc,2154
+maps4fs/toolbox/dem.py,sha256=z9IPFNmYbjiigb3t02ZenI3Mo8odd19c5MZbjDEovTo,3525
+maps4fs-1.2.3.dist-info/LICENSE.md,sha256=pTKD_oUexcn-yccFCTrMeLkZy0ifLRa-VNcDLqLZaIw,10749
+maps4fs-1.2.3.dist-info/METADATA,sha256=F3YcAPR8CA5160fvsWtnxEq3CtObEpiAG5B1DS6iSkg,29885
+maps4fs-1.2.3.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+maps4fs-1.2.3.dist-info/top_level.txt,sha256=Ue9DSRlejRQRCaJueB0uLcKrWwsEq9zezfv5dI5mV1M,8
+maps4fs-1.2.3.dist-info/RECORD,,

maps4fs-1.1.0.dist-info/RECORD

@@ -1,21 +0,0 @@
-maps4fs/__init__.py,sha256=da4jmND2Ths9AffnkAKgzLHNkvKFOc_l21gJisPXqWY,155
-maps4fs/logger.py,sha256=B-NEYpMjPAAqlV4VpfTi6nbBFnEABVtQOaYe6nMpidg,1489
-maps4fs/generator/__init__.py,sha256=zZMLEkGzb4z0xql650gOtGSvcgX58DnJ2yN3vC2daRk,43
-maps4fs/generator/background.py,sha256=wBFIT38GH3_JRWHnXjPXLr4k1KN_Cyag9LdIS3n3lts,15794
-maps4fs/generator/component.py,sha256=iYQgw2l_rvVpZ-VIhoZELdAe8rPVBwCVKwRsYejDCb0,17094
-maps4fs/generator/config.py,sha256=b7qY0luC-_WM_c72Ohtlf4FrB37X5cALInbestSdUsw,4382
-maps4fs/generator/dem.py,sha256=rc7ADzjvlZzStOqagsWW0Vrm9-X86aPpoR1RhBF_-OE,16025
-maps4fs/generator/game.py,sha256=H4msVHoDlJD5_9KoRvr3lCv2ZbLqJPqPDCEAEIDaCB4,7407
-maps4fs/generator/grle.py,sha256=HFOH07RZfkCkIpSj2VSMoBUjhmYDVCFWQQYd4tn6O5o,7162
-maps4fs/generator/i3d.py,sha256=GcGyawpE70yVjH9WdgpbNXESZoHYHmCKncl7pp5G1zo,11741
-maps4fs/generator/map.py,sha256=7UqLjDZgoY6M0ZxX5Q4Rjee2UGWZ64a3tGyr8B24UO0,4863
-maps4fs/generator/qgis.py,sha256=Es8hLuqN_KH8lDfnJE6He2rWYbAKJ3RGPn-o87S6CPI,6116
-maps4fs/generator/texture.py,sha256=uSt563KomSVUndl25IgEIi0YuhBQbnhPIoQKa-4A3_E,26016
-maps4fs/toolbox/__init__.py,sha256=zZMLEkGzb4z0xql650gOtGSvcgX58DnJ2yN3vC2daRk,43
-maps4fs/toolbox/background.py,sha256=9BXWNqs_n3HgqDiPztWylgYk_QM4YgBpe6_ZNQAWtSc,2154
-maps4fs/toolbox/dem.py,sha256=z9IPFNmYbjiigb3t02ZenI3Mo8odd19c5MZbjDEovTo,3525
-maps4fs-1.1.0.dist-info/LICENSE.md,sha256=pTKD_oUexcn-yccFCTrMeLkZy0ifLRa-VNcDLqLZaIw,10749
-maps4fs-1.1.0.dist-info/METADATA,sha256=DECQI5vTzd9ppdZZNkC-uRchalBX-bQakSIqrKjPkPQ,27907
-maps4fs-1.1.0.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-maps4fs-1.1.0.dist-info/top_level.txt,sha256=Ue9DSRlejRQRCaJueB0uLcKrWwsEq9zezfv5dI5mV1M,8
-maps4fs-1.1.0.dist-info/RECORD,,