maps4fs 1.1.9__py3-none-any.whl → 1.2.1__py3-none-any.whl

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/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/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/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
@@ -76,6 +85,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).
@@ -184,3 +198,192 @@ 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)
+        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/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/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.9.dist-info → maps4fs-1.2.1.dist-info}/METADATA

@@ -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.2.1.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=QNb1WAnTiGcFdCatu2XOWuLt2NwNBidkq6s8sY7bBgY,17245
+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.1.dist-info/LICENSE.md,sha256=pTKD_oUexcn-yccFCTrMeLkZy0ifLRa-VNcDLqLZaIw,10749
+maps4fs-1.2.1.dist-info/METADATA,sha256=43v3vGKA2z9uEd4r2M0wcebMv3fKEJESFbkUOshkZHU,29340
+maps4fs-1.2.1.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+maps4fs-1.2.1.dist-info/top_level.txt,sha256=Ue9DSRlejRQRCaJueB0uLcKrWwsEq9zezfv5dI5mV1M,8
+maps4fs-1.2.1.dist-info/RECORD,,

maps4fs-1.1.9.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=dnUkS1atEqqz_ryKkcfP_K9ZcwMHZVs97y-twZMpD44,15881
-maps4fs/generator/component.py,sha256=sihh2S35q0o38leEU-dpi0is6kYCuxXiWUISAtiQErM,17351
-maps4fs/generator/config.py,sha256=b7qY0luC-_WM_c72Ohtlf4FrB37X5cALInbestSdUsw,4382
-maps4fs/generator/dem.py,sha256=rc7ADzjvlZzStOqagsWW0Vrm9-X86aPpoR1RhBF_-OE,16025
-maps4fs/generator/game.py,sha256=2oA77i9lyNYOlhtOZft6KiPTxgGJbX1Gam1TosMNLis,7407
-maps4fs/generator/grle.py,sha256=IVbvzF_azItxLE_ZxaM_suQflEZjJuMgHmv1En51G7A,7592
-maps4fs/generator/i3d.py,sha256=SzjAxYacbBQ030N2sHh9c-dhWoG3iADJqCrHBox6vWI,12268
-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.9.dist-info/LICENSE.md,sha256=pTKD_oUexcn-yccFCTrMeLkZy0ifLRa-VNcDLqLZaIw,10749
-maps4fs-1.1.9.dist-info/METADATA,sha256=xA35Q8Wixg83CezYWalIaGqwv2YZvtjR9jDSuHGbAxc,28942
-maps4fs-1.1.9.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-maps4fs-1.1.9.dist-info/top_level.txt,sha256=Ue9DSRlejRQRCaJueB0uLcKrWwsEq9zezfv5dI5mV1M,8
-maps4fs-1.1.9.dist-info/RECORD,,