maps4fs 0.9.97__py3-none-any.whl → 0.9.99__py3-none-any.whl

maps4fs/generator/component.py

@@ -50,6 +50,7 @@ class Component:
 
         os.makedirs(self.previews_directory, exist_ok=True)
         os.makedirs(self.scripts_directory, exist_ok=True)
+        os.makedirs(self.info_layers_directory, exist_ok=True)
 
         self.save_bbox()
         self.preprocess()
@@ -87,6 +88,15 @@ class Component:
         """
         return os.path.join(self.map_directory, "previews")
 
+    @property
+    def info_layers_directory(self) -> str:
+        """The directory where the info layers are stored.
+
+        Returns:
+            str: The directory where the info layers are stored.
+        """
+        return os.path.join(self.map_directory, "info_layers")
+
     @property
     def scripts_directory(self) -> str:
         """The directory where the scripts are stored.

maps4fs/generator/game.py

@@ -38,7 +38,8 @@ class Game:
     _texture_schema: str | None = None
     _grle_schema: str | None = None
 
-    components = [Config, Texture, GRLE, DEM, I3d, Background]
+    # Order matters! Some components depend on others.
+    components = [Texture, I3d, DEM, Config, GRLE, Background]
 
     def __init__(self, map_template_path: str | None = None):
         if map_template_path:

maps4fs/generator/grle.py

@@ -57,15 +57,6 @@ class GRLE(Component):
                 width = int(self.map_width * info_layer["width_multiplier"])
                 data_type = info_layer["data_type"]
 
-                self.logger.debug(
-                    "Creating InfoLayer PNG file %s with dimensions %sx%s, %s channels, "
-                    "and data type %s.",
-                    file_path,
-                    height,
-                    width,
-                    data_type,
-                )
-
                 # Create the InfoLayer PNG file with zeros.
                 info_layer_data = np.zeros((height, width), dtype=data_type)
                 print(info_layer_data.shape)

maps4fs/generator/i3d.py

@@ -2,14 +2,18 @@
 
 from __future__ import annotations
 
+import json
 import os
 from xml.etree import ElementTree as ET
 
+from shapely.geometry import Polygon, box  # type: ignore
+
 from maps4fs.generator.component import Component
 
 DEFAULT_HEIGHT_SCALE = 2000
 DEFAULT_MAX_LOD_DISTANCE = 10000
 DEFAULT_MAX_LOD_OCCLUDER_DISTANCE = 10000
+NODE_ID_STARTING_VALUE = 500
 
 
 # pylint: disable=R0903
@@ -40,17 +44,25 @@ class I3d(Component):
     def process(self) -> None:
         """Updates the map I3D file with the default settings."""
         self._update_i3d_file()
+        self._add_fields()
 
-    def _update_i3d_file(self) -> None:
-        """Updates the map I3D file with the default settings."""
+    def _get_tree(self) -> ET.ElementTree | None:
+        """Returns the ElementTree instance of the map I3D file."""
         if not self._map_i3d_path:
             self.logger.info("I3D is not obtained, skipping the update.")
-            return
+            return None
         if not os.path.isfile(self._map_i3d_path):
             self.logger.warning("I3D file not found: %s.", self._map_i3d_path)
-            return
+            return None
+
+        return ET.parse(self._map_i3d_path)
 
-        tree = ET.parse(self._map_i3d_path)
+    def _update_i3d_file(self) -> None:
+        """Updates the map I3D file with the default settings."""
+
+        tree = self._get_tree()
+        if tree is None:
+            return
 
         self.logger.debug("Map I3D file loaded from: %s.", self._map_i3d_path)
 
@@ -76,7 +88,7 @@ class I3d(Component):
 
                 self.logger.debug("TerrainTransformGroup element updated in I3D file.")
 
-        tree.write(self._map_i3d_path)
+        tree.write(self._map_i3d_path)  # type: ignore
         self.logger.debug("Map I3D file saved to: %s.", self._map_i3d_path)
 
     def previews(self) -> list[str]:
@@ -87,3 +99,262 @@ class I3d(Component):
             list[str]: An empty list.
         """
         return []
+
+    # pylint: disable=R0914, R0915
+    def _add_fields(self) -> None:
+        """Adds fields to the map I3D file."""
+        tree = self._get_tree()
+        if tree is None:
+            return
+
+        textures_info_layer_path = os.path.join(self.info_layers_directory, "textures.json")
+        if not os.path.isfile(textures_info_layer_path):
+            self.logger.warning("Textures info layer not found: %s.", textures_info_layer_path)
+            return
+
+        with open(textures_info_layer_path, "r", encoding="utf-8") as textures_info_layer_file:
+            textures_info_layer = json.load(textures_info_layer_file)
+
+        fields: list[tuple[int, int]] | None = textures_info_layer.get("fields")
+        if not fields:
+            self.logger.warning("Fields data not found in textures info layer.")
+            return
+
+        self.logger.debug("Found %s fields in textures info layer.", len(fields))
+
+        root = tree.getroot()
+        gameplay_node = root.find(".//TransformGroup[@name='gameplay']")
+        if gameplay_node is not None:
+            self.logger.debug("Found the gameplay node.")
+
+            fields_node = gameplay_node.find(".//TransformGroup[@name='fields']")
+            user_attributes_node = root.find(".//UserAttributes")
+
+            if fields_node is not None:
+                node_id = NODE_ID_STARTING_VALUE
+
+                for field_id, field in enumerate(fields, start=1):
+                    # Convert the top-left coordinates to the center coordinates system.
+                    try:
+                        fitted_field = self.fit_polygon_into_bounds(field)  # type: ignore
+                    except ValueError as e:
+                        self.logger.warning(
+                            "Field %s could not be fitted into the map bounds.", field_id
+                        )
+                        self.logger.debug("Error: %s", e)
+                        continue
+                    field_ccs = [
+                        self.top_left_coordinates_to_center(point) for point in fitted_field
+                    ]
+
+                    # Creating the main field node.
+                    field_node = ET.Element("TransformGroup")
+                    field_node.set("name", f"field{field_id}")
+                    cx, cy = self.get_polygon_center(field_ccs)
+                    field_node.set("translation", f"{cx} 0 {cy}")
+                    field_node.set("nodeId", str(node_id))
+
+                    # Adding UserAttributes to the field node.
+                    user_attribute_node = self.create_user_attribute_node(node_id)
+                    user_attributes_node.append(user_attribute_node)  # type: ignore
+
+                    node_id += 1
+
+                    # Creating the polygon points node, which contains the points of the field.
+                    polygon_points_node = ET.Element("TransformGroup")
+                    polygon_points_node.set("name", "polygonPoints")
+                    polygon_points_node.set("nodeId", str(node_id))
+                    node_id += 1
+
+                    for point_id, point in enumerate(field_ccs, start=1):
+                        rx, ry = self.absolute_to_relative(point, (cx, cy))
+
+                        node_id += 1
+                        point_node = ET.Element("TransformGroup")
+                        point_node.set("name", f"point{point_id}")
+                        point_node.set("translation", f"{rx} 0 {ry}")
+                        point_node.set("nodeId", str(node_id))
+
+                        polygon_points_node.append(point_node)
+
+                    field_node.append(polygon_points_node)
+
+                    # Adding the name indicator node to the field node.
+                    name_indicator_node, node_id = self.get_name_indicator_node(node_id, field_id)
+                    field_node.append(name_indicator_node)
+
+                    # Adding the teleport indicator node to the field node.
+                    teleport_indicator_node, node_id = self.get_teleport_indicator_node(node_id)
+                    field_node.append(teleport_indicator_node)
+
+                    # Adding the field node to the fields node.
+                    fields_node.append(field_node)
+                    self.logger.debug("Field %s added to the I3D file.", field_id)
+
+                    node_id += 1
+
+            tree.write(self._map_i3d_path)  # type: ignore
+            self.logger.debug("Map I3D file saved to: %s.", self._map_i3d_path)
+
+    def get_name_indicator_node(self, node_id: int, field_id: int) -> tuple[ET.Element, int]:
+        """Creates a name indicator node with given node ID and field ID.
+
+        Arguments:
+            node_id (int): The node ID of the name indicator node.
+            field_id (int): The ID of the field.
+
+        Returns:
+            tuple[ET.Element, int]: The name indicator node and the updated node ID.
+        """
+        node_id += 1
+        name_indicator_node = ET.Element("TransformGroup")
+        name_indicator_node.set("name", "nameIndicator")
+        name_indicator_node.set("nodeId", str(node_id))
+
+        node_id += 1
+        note_node = ET.Element("Note")
+        note_node.set("name", "Note")
+        note_node.set("nodeId", str(node_id))
+        note_node.set("text", f"field{field_id}
0.00 ha")
+        note_node.set("color", "4278190080")
+        note_node.set("fixedSize", "true")
+
+        name_indicator_node.append(note_node)
+
+        return name_indicator_node, node_id
+
+    def get_teleport_indicator_node(self, node_id: int) -> tuple[ET.Element, int]:
+        """Creates a teleport indicator node with given node ID.
+
+        Arguments:
+            node_id (int): The node ID of the teleport indicator node.
+
+        Returns:
+            tuple[ET.Element, int]: The teleport indicator node and the updated node ID.
+        """
+        node_id += 1
+        teleport_indicator_node = ET.Element("TransformGroup")
+        teleport_indicator_node.set("name", "teleportIndicator")
+        teleport_indicator_node.set("nodeId", str(node_id))
+
+        return teleport_indicator_node, node_id
+
+    def get_polygon_center(self, polygon_points: list[tuple[int, int]]) -> tuple[int, int]:
+        """Calculates the center of a polygon defined by a list of points.
+
+        Arguments:
+            polygon_points (list[tuple[int, int]]): The points of the polygon.
+
+        Returns:
+            tuple[int, int]: The center of the polygon.
+        """
+        polygon = Polygon(polygon_points)
+        center = polygon.centroid
+        return int(center.x), int(center.y)
+
+    def absolute_to_relative(
+        self, point: tuple[int, int], center: tuple[int, int]
+    ) -> tuple[int, int]:
+        """Converts a pair of absolute coordinates to relative coordinates.
+
+        Arguments:
+            point (tuple[int, int]): The absolute coordinates.
+            center (tuple[int, int]): The center coordinates.
+
+        Returns:
+            tuple[int, int]: The relative coordinates.
+        """
+        cx, cy = center
+        x, y = point
+        return x - cx, y - cy
+
+    def top_left_coordinates_to_center(self, top_left: tuple[int, int]) -> tuple[int, int]:
+        """Converts a pair of coordinates from the top-left system to the center system.
+        In top-left system, the origin (0, 0) is in the top-left corner of the map, while in the
+        center system, the origin is in the center of the map.
+
+        Arguments:
+            top_left (tuple[int, int]): The coordinates in the top-left system.
+
+        Returns:
+            tuple[int, int]: The coordinates in the center system.
+        """
+        x, y = top_left
+        cs_x = x - self.map_width // 2
+        cs_y = y - self.map_height // 2
+
+        return cs_x, cs_y
+
+    def fit_polygon_into_bounds(
+        self, polygon_points: list[tuple[int, int]]
+    ) -> list[tuple[int, int]]:
+        """Fits a polygon into the bounds of the map.
+
+        Arguments:
+            polygon_points (list[tuple[int, int]]): The points of the polygon.
+
+        Returns:
+            list[tuple[int, int]]: The points of the polygon fitted into the map bounds.
+        """
+        min_x = min_y = 0
+        max_x, max_y = self.map_width, self.map_height
+
+        # Create a polygon from the given points
+        polygon = Polygon(polygon_points)
+
+        # Create a bounding box for the map bounds
+        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)
+
+        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)
+
+    @staticmethod
+    def create_user_attribute_node(node_id: int) -> ET.Element:
+        """Creates an XML user attribute node with given node ID.
+
+        Arguments:
+            node_id (int): The node ID of the user attribute node.
+
+        Returns:
+            ET.Element: The created user attribute node.
+        """
+        user_attribute_node = ET.Element("UserAttribute")
+        user_attribute_node.set("nodeId", str(node_id))
+
+        attributes = [
+            ("angle", "integer", "0"),
+            ("missionAllowed", "boolean", "true"),
+            ("missionOnlyGrass", "boolean", "false"),
+            ("nameIndicatorIndex", "string", "1"),
+            ("polygonIndex", "string", "0"),
+            ("teleportIndicatorIndex", "string", "2"),
+        ]
+
+        for name, attr_type, value in attributes:
+            user_attribute_node.append(I3d.create_attribute_node(name, attr_type, value))
+
+        return user_attribute_node
+
+    @staticmethod
+    def create_attribute_node(name: str, attr_type: str, value: str) -> ET.Element:
+        """Creates an XML attribute node with given name, type, and value.
+
+        Arguments:
+            name (str): The name of the attribute.
+            attr_type (str): The type of the attribute.
+            value (str): The value of the attribute.
+
+        Returns:
+            ET.Element: The created attribute node.
+        """
+        attribute_node = ET.Element("Attribute")
+        attribute_node.set("name", name)
+        attribute_node.set("type", attr_type)
+        attribute_node.set("value", value)
+        return attribute_node

maps4fs/generator/texture.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import json
 import os
 import warnings
+from collections import defaultdict
 from typing import Any, Callable, Generator, Optional
 
 import cv2
@@ -41,6 +42,9 @@ class Texture(Component):
             tags (dict[str, str | list[str]]): Dictionary of tags to search for.
             width (int | None): Width of the polygon in meters (only for LineString).
             color (tuple[int, int, int]): Color of the layer in BGR format.
+            exclude_weight (bool): Flag to exclude weight from the texture.
+            priority (int | None): Priority of the layer.
+            info_layer (str | None): Name of the corresnponding info layer.
 
         Attributes:
             name (str): Name of the layer.
@@ -58,6 +62,7 @@ class Texture(Component):
             color: tuple[int, int, int] | list[int] | None = None,
             exclude_weight: bool = False,
             priority: int | None = None,
+            info_layer: str | None = None,
         ):
             self.name = name
             self.count = count
@@ -66,6 +71,7 @@ class Texture(Component):
             self.color = color if color else (255, 255, 255)
             self.exclude_weight = exclude_weight
             self.priority = priority
+            self.info_layer = info_layer
 
         def to_json(self) -> dict[str, str | list[str] | bool]:  # type: ignore
             """Returns dictionary with layer data.
@@ -80,6 +86,7 @@ class Texture(Component):
                 "color": list(self.color),
                 "exclude_weight": self.exclude_weight,
                 "priority": self.priority,
+                "info_layer": self.info_layer,
             }
 
             data = {k: v for k, v in data.items() if v is not None}
@@ -178,6 +185,9 @@ class Texture(Component):
         self.info_save_path = os.path.join(self.map_directory, "generation_info.json")
         self.logger.debug("Generation info save path: %s.", self.info_save_path)
 
+        self.info_layer_path = os.path.join(self.info_layers_directory, "textures.json")
+        self.logger.debug("Info layer path: %s.", self.info_layer_path)
+
     def get_base_layer(self) -> Layer | None:
         """Returns base layer.
 
@@ -297,6 +307,10 @@ class Texture(Component):
 
         cumulative_image = None
 
+        # Dictionary to store info layer data.
+        # Key is a layer.info_layer, value is a list of polygon points as tuples (x, y).
+        info_layer_data = defaultdict(list)
+
         for layer in layers:
             if not layer.tags:
                 self.logger.debug("Layer %s has no tags, there's nothing to draw.", layer.name)
@@ -317,6 +331,8 @@ class Texture(Component):
             mask = cv2.bitwise_not(cumulative_image)
 
             for polygon in self.polygons(layer.tags, layer.width):  # type: ignore
+                if layer.info_layer:
+                    info_layer_data[layer.info_layer].append(self.np_to_polygon_points(polygon))
                 cv2.fillPoly(layer_image, [polygon], color=255)  # type: ignore
 
             output_image = cv2.bitwise_and(layer_image, mask)
@@ -326,6 +342,10 @@ class Texture(Component):
             cv2.imwrite(layer_path, output_image)
             self.logger.debug("Texture %s saved.", layer_path)
 
+        # Save info layer data.
+        with open(self.info_layer_path, "w", encoding="utf-8") as f:
+            json.dump(info_layer_data, f, ensure_ascii=False, indent=4)
+
         if cumulative_image is not None:
             self.draw_base_layer(cumulative_image)
 
@@ -428,6 +448,17 @@ class Texture(Component):
         """
         return int(self.map_height * (1 - (y - self.minimum_y) / (self.maximum_y - self.minimum_y)))
 
+    def np_to_polygon_points(self, np_array: np.ndarray) -> list[tuple[int, int]]:
+        """Converts numpy array of polygon points to list of tuples.
+
+        Arguments:
+            np_array (np.ndarray): Numpy array of polygon points.
+
+        Returns:
+            list[tuple[int, int]]: List of tuples.
+        """
+        return [(int(x), int(y)) for x, y in np_array.reshape(-1, 2)]
+
     # pylint: disable=W0613
     def _to_np(self, geometry: shapely.geometry.polygon.Polygon, *args) -> np.ndarray:
         """Converts Polygon geometry to numpy array of polygon points.

{maps4fs-0.9.97.dist-info → maps4fs-0.9.99.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: maps4fs
-Version: 0.9.97
+Version: 0.9.99
 Summary: Generate map templates for Farming Simulator from real places.
 Author-email: iwatkot <iwatkot@gmail.com>
 License: MIT License
@@ -68,6 +68,7 @@ Requires-Dist: pympler
 🔷 Generates *.obj files for background terrain based on the real-world height map<br>
 📄 Generates scripts to download high-resolution satellite images from [QGIS](https://qgis.org/download/) in one click<br>
 🧰 Modder Toolbox to help you with various of tasks 🆕<br>
+🌾 Automatically generates fields 🆕<br>
 
 <p align="center">
 <img src="https://github.com/user-attachments/assets/cf8f5752-9c69-4018-bead-290f59ba6976"><br>
@@ -76,6 +77,8 @@ Requires-Dist: pympler
 🛰️ Realistic background terrain objects with satellite images.<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 src="https://github.com/user-attachments/assets/cce45575-c917-4a1b-bdc0-6368e32ccdff"><br>
 📏 Almost any possible map sizes.
 </p>

{maps4fs-0.9.97.dist-info → maps4fs-0.9.99.dist-info}/RECORD

@@ -2,21 +2,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=h6zyqMc51eOD8_Jbe8eP9DJFy27-XItzIOVEThQKFdk,14011
-maps4fs/generator/component.py,sha256=ibfl2V_niXqWaFO05aaV25JbPBaupUpKBOLxKQq0Fv4,10714
+maps4fs/generator/component.py,sha256=gtb_p_cHfRgOQwCLCxmQPNObuipqvmGaGAct7KUxAtI,11053
 maps4fs/generator/config.py,sha256=qomeSaHNgSYvRyPbGkyDjgAxU1jUMND8wESuy9uXcV4,4280
 maps4fs/generator/dem.py,sha256=aU0syr7pu81hd6oVn1rjQoDsDAYJro-58i1STTUz3jw,17167
-maps4fs/generator/game.py,sha256=hvVsU4l43kHYM9oZ6WBFhDiI8U3gJxzSeavAvXyh0DI,7395
-maps4fs/generator/grle.py,sha256=TM9I1ge1_hfepdLq485TbHozm2OBr6HWNrkmixAigI0,3436
-maps4fs/generator/i3d.py,sha256=CSdVDQJOybeu6DQhxTxImEOSsbbXSNqAN8sunNuicM0,3602
+maps4fs/generator/game.py,sha256=3Y65K-XQDKxfMRSrjsmE8qX0tQSd0aDzMUT6yGIhzXg,7450
+maps4fs/generator/grle.py,sha256=kyFiGu-2aXrLVB_8GeXlGvG5ULwlSVuqU1yfpt_0br4,3134
+maps4fs/generator/i3d.py,sha256=nlmI8SdzzKMOGQRvoZp7Pxo6lzm1jneoYNoL24v84zw,14281
 maps4fs/generator/map.py,sha256=1EJfq5928xbV7v9vBBuoC3VpD5gC1SMDBTQ7geH6yaA,4678
 maps4fs/generator/path_steps.py,sha256=yeN6hmOD8O2LMozUf4HcQMIy8WJ5sHF5pGQT_s2FfOw,3147
 maps4fs/generator/qgis.py,sha256=Es8hLuqN_KH8lDfnJE6He2rWYbAKJ3RGPn-o87S6CPI,6116
-maps4fs/generator/texture.py,sha256=9qBlL3udozp5ATg9N48naRjTQPWe_eOPgs28hG4U13g,22381
+maps4fs/generator/texture.py,sha256=uSuqJyZom861_BO-3aUqU8_OkroExmN25PsRBjdddkw,23799
 maps4fs/generator/tile.py,sha256=6zUpDidPcPRTGzQvYSNw-0Pj-if2WiakU2qb-40vyOk,2151
 maps4fs/toolbox/__init__.py,sha256=zZMLEkGzb4z0xql650gOtGSvcgX58DnJ2yN3vC2daRk,43
 maps4fs/toolbox/dem.py,sha256=z9IPFNmYbjiigb3t02ZenI3Mo8odd19c5MZbjDEovTo,3525
-maps4fs-0.9.97.dist-info/LICENSE.md,sha256=pTKD_oUexcn-yccFCTrMeLkZy0ifLRa-VNcDLqLZaIw,10749
-maps4fs-0.9.97.dist-info/METADATA,sha256=s4WH0mc0o_KT-TTA4PdgsYLTMEwr8LnlrvXqxVdWUZo,25194
-maps4fs-0.9.97.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-maps4fs-0.9.97.dist-info/top_level.txt,sha256=Ue9DSRlejRQRCaJueB0uLcKrWwsEq9zezfv5dI5mV1M,8
-maps4fs-0.9.97.dist-info/RECORD,,
+maps4fs-0.9.99.dist-info/LICENSE.md,sha256=pTKD_oUexcn-yccFCTrMeLkZy0ifLRa-VNcDLqLZaIw,10749
+maps4fs-0.9.99.dist-info/METADATA,sha256=e23P4VVbfJ9L9OvW0k1j9ppNIRDGAMUBW623o1n9-zM,25393
+maps4fs-0.9.99.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+maps4fs-0.9.99.dist-info/top_level.txt,sha256=Ue9DSRlejRQRCaJueB0uLcKrWwsEq9zezfv5dI5mV1M,8
+maps4fs-0.9.99.dist-info/RECORD,,