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

maps4fs/generator/background.py

@@ -3,8 +3,10 @@ around the map."""
 
 from __future__ import annotations
 
+import json
 import os
 import shutil
+from copy import deepcopy
 
 import cv2
 import numpy as np
@@ -17,6 +19,7 @@ from maps4fs.generator.dem import (
     DEFAULT_PLATEAU,
     DEM,
 )
+from maps4fs.generator.texture import Texture
 
 DEFAULT_DISTANCE = 2048
 RESIZE_FACTOR = 1 / 8
@@ -25,6 +28,7 @@ FULL_PREVIEW_NAME = "PREVIEW"
 ELEMENTS = [FULL_NAME, FULL_PREVIEW_NAME]
 
 
+# pylint: disable=R0902
 class Background(Component):
     """Component for creating 3D obj files based on DEM data around the map.
 
@@ -43,7 +47,9 @@ class Background(Component):
     def preprocess(self) -> None:
         """Registers the DEMs for the background terrain."""
         self.light_version = self.kwargs.get("light_version", False)
+        self.water_depth = self.kwargs.get("water_depth", 0)
         self.stl_preview_path: str | None = None
+        self.water_resources_path: str | None = None
 
         if self.rotation:
             self.logger.debug("Rotation is enabled: %s.", self.rotation)
@@ -51,21 +57,29 @@ class Background(Component):
         else:
             output_size_multiplier = 1
 
-        background_size = self.map_size + DEFAULT_DISTANCE * 2
-        rotated_size = int(background_size * output_size_multiplier)
+        self.background_size = self.map_size + DEFAULT_DISTANCE * 2
+        self.rotated_size = int(self.background_size * output_size_multiplier)
 
         self.background_directory = os.path.join(self.map_directory, "background")
+        self.water_directory = os.path.join(self.map_directory, "water")
         os.makedirs(self.background_directory, exist_ok=True)
+        os.makedirs(self.water_directory, exist_ok=True)
 
         autoprocesses = [self.kwargs.get("auto_process", False), False]
+        self.output_paths = [
+            os.path.join(self.background_directory, f"{name}.png") for name in ELEMENTS
+        ]
+        self.not_substracted_path = os.path.join(self.background_directory, "not_substracted.png")
+
         dems = []
 
-        for name, autoprocess in zip(ELEMENTS, autoprocesses):
+        for name, autoprocess, output_path in zip(ELEMENTS, autoprocesses, self.output_paths):
             dem = DEM(
                 self.game,
+                self.map,
                 self.coordinates,
-                background_size,
-                rotated_size,
+                self.background_size,
+                self.rotated_size,
                 self.rotation,
                 self.map_directory,
                 self.logger,
@@ -76,8 +90,8 @@ class Background(Component):
             )
             dem.preprocess()
             dem.is_preview = self.is_preview(name)  # type: ignore
-            dem.set_output_resolution((rotated_size, rotated_size))
-            dem.set_dem_path(os.path.join(self.background_directory, f"{name}.png"))
+            dem.set_output_resolution((self.rotated_size, self.rotated_size))
+            dem.set_dem_path(output_path)
             dems.append(dem)
 
         self.dems = dems
@@ -97,8 +111,17 @@ class Background(Component):
         """Launches the component processing. Iterates over all tiles and processes them
         as a result the DEM files will be saved, then based on them the obj files will be
         generated."""
+        self.create_background_textures()
+
         for dem in self.dems:
             dem.process()
+            if not dem.is_preview:  # type: ignore
+                shutil.copyfile(dem.dem_path, self.not_substracted_path)
+
+        if self.water_depth:
+            self.subtraction()
+
+        for dem in self.dems:
             if not dem.is_preview:  # type: ignore
                 cutted_dem_path = self.cutout(dem.dem_path)
                 if self.game.additional_dem_name is not None:
@@ -106,6 +129,7 @@ class Background(Component):
 
         if not self.light_version:
             self.generate_obj_files()
+            self.generate_water_resources_obj()
         else:
             self.logger.info("Light version is enabled, obj files will not be generated.")
 
@@ -222,13 +246,20 @@ class Background(Component):
         return main_dem_path
 
     # pylint: disable=too-many-locals
-    def plane_from_np(self, dem_data: np.ndarray, save_path: str, is_preview: bool = False) -> None:
+    def plane_from_np(
+        self,
+        dem_data: np.ndarray,
+        save_path: str,
+        is_preview: bool = False,
+        include_zeros: bool = True,
+    ) -> None:
         """Generates a 3D obj file based on DEM data.
 
         Arguments:
             dem_data (np.ndarray) -- The DEM data as a numpy array.
             save_path (str) -- The path where the obj file will be saved.
             is_preview (bool, optional) -- If True, the preview mesh will be generated.
+            include_zeros (bool, optional) -- If True, the mesh will include the zero height values.
         """
         dem_data = cv2.resize(  # pylint: disable=no-member
             dem_data, (0, 0), fx=RESIZE_FACTOR, fy=RESIZE_FACTOR
@@ -246,6 +277,9 @@ class Background(Component):
         x, y = np.meshgrid(x, y)
         z = dem_data
 
+        ground = z.max()
+        self.logger.debug("Ground level: %s", ground)
+
         self.logger.debug(
             "Starting to generate a mesh for with shape: %s x %s. This may take a while...",
             cols,
@@ -255,6 +289,8 @@ class Background(Component):
         vertices = np.column_stack([x.ravel(), y.ravel(), z.ravel()])
         faces = []
 
+        skipped = 0
+
         for i in range(rows - 1):
             for j in range(cols - 1):
                 top_left = i * cols + j
@@ -262,9 +298,15 @@ class Background(Component):
                 bottom_left = top_left + cols
                 bottom_right = bottom_left + 1
 
+                if ground in [z[i, j], z[i, j + 1], z[i + 1, j], z[i + 1, j + 1]]:
+                    skipped += 1
+                    continue
+
                 faces.append([top_left, bottom_left, bottom_right])
                 faces.append([top_left, bottom_right, top_right])
 
+        self.logger.debug("Skipped faces: %s", skipped)
+
         faces = np.array(faces)  # type: ignore
         mesh = trimesh.Trimesh(vertices=vertices, faces=faces)
 
@@ -282,13 +324,14 @@ class Background(Component):
             mesh.apply_scale([0.5, 0.5, 0.5])
             self.mesh_to_stl(mesh)
         else:
-            multiplier = self.kwargs.get("multiplier", DEFAULT_MULTIPLIER)
-            if multiplier != 1:
-                z_scaling_factor = 1 / multiplier
-            else:
-                z_scaling_factor = 1 / 2**5
-            self.logger.debug("Z scaling factor: %s", z_scaling_factor)
-            mesh.apply_scale([1 / RESIZE_FACTOR, 1 / RESIZE_FACTOR, z_scaling_factor])
+            if not include_zeros:
+                multiplier = self.kwargs.get("multiplier", DEFAULT_MULTIPLIER)
+                if multiplier != 1:
+                    z_scaling_factor = 1 / multiplier
+                else:
+                    z_scaling_factor = 1 / 2**5
+                self.logger.debug("Z scaling factor: %s", z_scaling_factor)
+                mesh.apply_scale([1 / RESIZE_FACTOR, 1 / RESIZE_FACTOR, z_scaling_factor])
 
         mesh.export(save_path)
         self.logger.debug("Obj file saved: %s", save_path)
@@ -412,3 +455,123 @@ class Background(Component):
 
         cv2.imwrite(colored_dem_path, dem_data_colored)
         return colored_dem_path
+
+    def create_background_textures(self) -> None:
+        """Creates background textures for the map."""
+        if not os.path.isfile(self.game.texture_schema):
+            self.logger.warning("Texture schema file not found: %s", self.game.texture_schema)
+            return
+
+        with open(self.game.texture_schema, "r", encoding="utf-8") as f:
+            layers_schema = json.load(f)
+
+        background_layers = []
+        for layer in layers_schema:
+            if layer.get("background") is True:
+                layer_copy = deepcopy(layer)
+                layer_copy["count"] = 1
+                layer_copy["name"] = f"{layer['name']}_background"
+                background_layers.append(layer_copy)
+
+        if not background_layers:
+            return
+
+        self.background_texture = Texture(  # pylint: disable=W0201
+            self.game,
+            self.map,
+            self.coordinates,
+            self.background_size,
+            self.rotated_size,
+            rotation=self.rotation,
+            map_directory=self.map_directory,
+            logger=self.logger,
+            light_version=self.light_version,
+            custom_schema=background_layers,
+        )
+
+        self.background_texture.preprocess()
+        self.background_texture.process()
+
+        processed_layers = self.background_texture.get_background_layers()
+        weights_directory = self.game.weights_dir_path(self.map_directory)
+        background_paths = [layer.path(weights_directory) for layer in processed_layers]
+        self.logger.debug("Found %s background textures.", len(background_paths))
+
+        if not background_paths:
+            self.logger.warning("No background textures found.")
+            return
+
+        # Merge all images into one.
+        background_image = np.zeros((self.background_size, self.background_size), dtype=np.uint8)
+        for path in background_paths:
+            layer = cv2.imread(path, cv2.IMREAD_GRAYSCALE)
+            background_image = cv2.add(background_image, layer)  # type: ignore
+
+        background_save_path = os.path.join(self.water_directory, "water_resources.png")
+        cv2.imwrite(background_save_path, background_image)
+        self.logger.info("Background texture saved: %s", background_save_path)
+        self.water_resources_path = background_save_path  # pylint: disable=W0201
+
+    def subtraction(self) -> None:
+        """Subtracts the water depth from the DEM data where the water resources are located."""
+        if not self.water_resources_path:
+            self.logger.warning("Water resources texture not found.")
+            return
+
+        # Single channeled 8 bit image, where the water have values of 255, and the rest 0.
+        water_resources_image = cv2.imread(self.water_resources_path, cv2.IMREAD_UNCHANGED)
+        mask = water_resources_image == 255
+
+        # Make mask a little bit smaller (1 pixel).
+        mask = cv2.erode(mask.astype(np.uint8), np.ones((3, 3), np.uint8), iterations=1).astype(
+            bool
+        )
+
+        for output_path in self.output_paths:
+            if FULL_PREVIEW_NAME in output_path:
+                continue
+            dem_image = cv2.imread(output_path, cv2.IMREAD_UNCHANGED)
+
+            # Create a mask where water_resources_image is 255 (or not 0)
+            # Subtract water_depth from dem_image where mask is True
+            dem_image[mask] = dem_image[mask] - self.water_depth
+
+            # Save the modified dem_image back to the output path
+            cv2.imwrite(output_path, dem_image)
+            self.logger.debug("Water depth subtracted from DEM data: %s", output_path)
+
+    def generate_water_resources_obj(self) -> None:
+        """Generates 3D obj files based on water resources data."""
+        if not self.water_resources_path:
+            self.logger.warning("Water resources texture not found.")
+            return
+
+        # Single channeled 8 bit image, where the water have values of 255, and the rest 0.
+        plane_water = cv2.imread(self.water_resources_path, cv2.IMREAD_UNCHANGED)
+        dilated_plane_water = cv2.dilate(
+            plane_water.astype(np.uint8), np.ones((5, 5), np.uint8), iterations=5
+        ).astype(np.uint8)
+        plane_save_path = os.path.join(self.water_directory, "plane_water.obj")
+        self.plane_from_np(
+            dilated_plane_water, plane_save_path, is_preview=False, include_zeros=False
+        )
+
+        # Single channeled 16 bit DEM image of terrain.
+        background_dem = cv2.imread(self.not_substracted_path, cv2.IMREAD_UNCHANGED)
+
+        # Remove all the values from the background dem where the plane_water is 0.
+        background_dem[plane_water == 0] = 0
+
+        # Dilate the background dem to make the water more smooth.
+        elevated_water = cv2.dilate(background_dem, np.ones((3, 3), np.uint16), iterations=10)
+
+        # Use the background dem as a mask to prevent the original values from being overwritten.
+        mask = background_dem > 0
+
+        # Combine the dilated background dem with non-dilated background dem.
+        elevated_water = np.where(mask, background_dem, elevated_water)
+        elevated_save_path = os.path.join(self.water_directory, "elevated_water.obj")
+
+        self.plane_from_np(
+            elevated_water, elevated_save_path, is_preview=False, include_zeros=False
+        )

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
@@ -326,6 +330,7 @@ class Component:
 
         return cs_x, cs_y
 
+    # pylint: disable=R0914
     def fit_polygon_into_bounds(
         self, polygon_points: list[tuple[int, int]], margin: int = 0, angle: int = 0
     ) -> list[tuple[int, int]]:
@@ -367,8 +372,13 @@ class Component:
         bounds = box(min_x, min_y, max_x, max_y)
 
         # 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)
+        try:
+            fitted_polygon = polygon.intersection(bounds)
+            self.logger.debug("Fitted the polygon into the bounds: %s", bounds)
+        except Exception as e:
+            raise ValueError(  # pylint: disable=W0707
+                f"Could not fit the polygon into the bounds: {e}"
+            )
 
         if not isinstance(fitted_polygon, Polygon):
             raise ValueError("The fitted polygon is not a valid polygon.")

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
@@ -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).
@@ -184,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,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,8 @@ class Texture(Component):
             exclude_weight: bool = False,
             priority: int | None = None,
             info_layer: str | None = None,
+            usage: str | None = None,
+            background: bool = False,
         ):
             self.name = name
             self.count = count
@@ -72,6 +74,8 @@ class Texture(Component):
             self.exclude_weight = exclude_weight
             self.priority = priority
             self.info_layer = info_layer
+            self.usage = usage
+            self.background = background
 
         def to_json(self) -> dict[str, str | list[str] | bool]:  # type: ignore
             """Returns dictionary with layer data.
@@ -87,6 +91,8 @@ class Texture(Component):
                 "exclude_weight": self.exclude_weight,
                 "priority": self.priority,
                 "info_layer": self.info_layer,
+                "usage": self.usage,
+                "background": self.background,
             }
 
             data = {k: v for k, v in data.items() if v is not None}
@@ -117,29 +123,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.
@@ -175,17 +181,30 @@ class Texture(Component):
         self.fields_padding = self.kwargs.get("fields_padding", 0)
         self.logger.debug("Light version: %s.", self.light_version)
 
-        if not os.path.isfile(self.game.texture_schema):
-            raise FileNotFoundError(f"Texture layers schema not found: {self.game.texture_schema}")
+        self.custom_schema: list[dict[str, str | dict[str, str] | int]] | None = self.kwargs.get(
+            "custom_schema"
+        )
 
-        try:
-            with open(self.game.texture_schema, "r", encoding="utf-8") as f:
-                layers_schema = json.load(f)
-        except json.JSONDecodeError as e:
-            raise ValueError(f"Error loading texture layers schema: {e}") from e
+        if self.custom_schema:
+            layers_schema = self.custom_schema
+            self.logger.info("Custom schema loaded with %s layers.", len(layers_schema))
+        else:
+            if not os.path.isfile(self.game.texture_schema):
+                raise FileNotFoundError(
+                    f"Texture layers schema not found: {self.game.texture_schema}"
+                )
 
-        self.layers = [self.Layer.from_json(layer) for layer in layers_schema]
-        self.logger.info("Loaded %s layers.", len(self.layers))
+            try:
+                with open(self.game.texture_schema, "r", encoding="utf-8") as f:
+                    layers_schema = json.load(f)
+            except json.JSONDecodeError as e:
+                raise ValueError(f"Error loading texture layers schema: {e}") from e
+
+        try:
+            self.layers = [self.Layer.from_json(layer) for layer in layers_schema]
+            self.logger.info("Loaded %s layers.", len(self.layers))
+        except Exception as e:  # pylint: disable=W0703
+            raise ValueError(f"Error loading texture layers: {e}") from e
 
         base_layer = self.get_base_layer()
         if base_layer:
@@ -212,6 +231,28 @@ class Texture(Component):
                 return layer
         return None
 
+    def get_background_layers(self) -> list[Layer]:
+        """Returns list of background layers.
+
+        Returns:
+            list[Layer]: List of background layers.
+        """
+        return [layer for layer in self.layers if layer.background]
+
+    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 +328,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.6.dist-info → maps4fs-1.2.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: maps4fs
-Version: 1.1.6
+Version: 1.2.4
 Summary: Generate map templates for Farming Simulator from real places.
 Author-email: iwatkot <iwatkot@gmail.com>
 License: MIT License
@@ -43,7 +43,7 @@ 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><br>
   <a href="#Special-thanks">Special thanks</a>
@@ -68,6 +68,9 @@ Requires-Dist: pympler
 🔄 Support map rotation 🆕<br>
 🌾 Automatically generates fields 🆕<br>
 🌽 Automatically generates farmlands 🆕<br>
+🌿 Automatically generates decorative foliage 🆕<br>
+🌲 Automatically generates forests 🆕<br>
+🌊 Automatically generates water planes 🆕<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 +87,12 @@ 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/cce7d4e0-cba2-4dd2-b22d-03137fb2e860"><br>
+🌊 Automatically generates water planes.<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>
@@ -95,6 +104,9 @@ Requires-Dist: pympler
 <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>
 <p align="center"><i>How to Generate a Map for Farming Simulator 25 and 22 from a real place using maps4FS.</i></p>
 
+![Map example](https://github.com/user-attachments/assets/c46a3581-dd17-462f-b815-e36d4f724947)
+<p align="center"><i>Map example generated with maps4fs.</i></p>
+
 ## Quick Start
 There are several ways to use the tool. You obviously need the **first one**, but you can choose any of the others depending on your needs.<br>
 ### 🚜 For most users
@@ -453,7 +465,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>
@@ -470,6 +482,8 @@ You can also apply some advanced settings to the map generation process. Note th
 
 - Plateau height: this value will be added to each pixel of the DEM image, making it "higher". It's useful when you want to add some negative heights on the map, that appear to be in a "low" place. By default, it's set to 0.
 
+- Water depth: this value will be subtracted from each pixel of the DEM image, where water resources are located. Pay attention that it's not in meters, instead it in the pixel value of DEM, which is 16 bit image with possible values from 0 to 65535. When this value is set, the same value will be added to the plateau setting to avoid negative heights.
+
 ### Texture Advanced settings
 
 - Fields padding - this value (in meters) will be applied to each field, making it smaller. It's useful when the fields are too close to each other and you want to make them smaller. By default, it's set to 0.
@@ -478,6 +492,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>

maps4fs-1.2.4.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=21xB-xn2A6QGdX9UVWqvzoW-L6JWPAZOqCcIhR8nxKU,22689
+maps4fs/generator/component.py,sha256=SeI1xfwo9I4lrkcOcHyjxMffHsG8OXc80-mNsR2zpPw,17748
+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=vgiwJNIl14JABhNOBGh_W8SBkAUNQN3TjNJayR76va0,27468
+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.4.dist-info/LICENSE.md,sha256=pTKD_oUexcn-yccFCTrMeLkZy0ifLRa-VNcDLqLZaIw,10749
+maps4fs-1.2.4.dist-info/METADATA,sha256=cR3704tYCx9AaL8NW5cLrkMijvDNyWdxT7CpCaTv9NE,30600
+maps4fs-1.2.4.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+maps4fs-1.2.4.dist-info/top_level.txt,sha256=Ue9DSRlejRQRCaJueB0uLcKrWwsEq9zezfv5dI5mV1M,8
+maps4fs-1.2.4.dist-info/RECORD,,

maps4fs-1.1.6.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.6.dist-info/LICENSE.md,sha256=pTKD_oUexcn-yccFCTrMeLkZy0ifLRa-VNcDLqLZaIw,10749
-maps4fs-1.1.6.dist-info/METADATA,sha256=W5x23vIOjkx-xxq4L0VIWVIA9pCgOniTQvbFqiTUVFs,28942
-maps4fs-1.1.6.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-maps4fs-1.1.6.dist-info/top_level.txt,sha256=Ue9DSRlejRQRCaJueB0uLcKrWwsEq9zezfv5dI5mV1M,8
-maps4fs-1.1.6.dist-info/RECORD,,