maps4fs 2.9.3__py3-none-any.whl → 2.9.32__py3-none-any.whl

maps4fs/generator/component/building.py

@@ -0,0 +1,570 @@
+"""Component for map buildings processing and generation."""
+
+import json
+import os
+from typing import NamedTuple
+from xml.etree import ElementTree as ET
+
+import cv2
+import numpy as np
+from tqdm import tqdm
+
+from maps4fs.generator.component.i3d import I3d
+from maps4fs.generator.settings import Parameters
+from maps4fs.generator.utils import get_region_by_coordinates
+
+BUILDINGS_STARTING_NODE_ID = 10000
+TOLERANCE_FACTOR = 0.3  # 30% size tolerance
+DEFAULT_HEIGHT = 200
+
+
+AREA_TYPES = {
+    "residential": 10,
+    "commercial": 20,
+    "industrial": 30,
+    "retail": 40,
+    "farmyard": 50,
+    "religious": 60,
+    "recreation": 70,
+}
+PIXEL_TYPES = {v: k for k, v in AREA_TYPES.items()}
+
+
+class BuildingEntry(NamedTuple):
+    """Data structure for a building entry in the buildings schema."""
+
+    file: str
+    name: str
+    width: float
+    depth: float
+    categories: list[str]
+    regions: list[str]
+    type: str | None = None
+
+
+class BuildingEntryCollection:
+    """Collection of building entries with efficient lookup capabilities."""
+
+    def __init__(self, building_entries: list[BuildingEntry], region: str):
+        """Initialize the collection with a list of building entries for a specific region.
+
+        Arguments:
+            building_entries (list[BuildingEntry]): List of building entries to manage
+            region (str): The region for this collection (filters entries to this region only)
+        """
+        self.region = region
+        # Filter entries to only include the specified region
+        self.entries = [entry for entry in building_entries if region in entry.regions]
+        # Create indices for faster lookup
+        self._create_indices()
+
+    def _create_indices(self) -> None:
+        """Create indexed dictionaries for faster lookups."""
+        self.by_category: dict[str, list[BuildingEntry]] = {}
+
+        for entry in self.entries:
+            # Index by each category (all entries are already filtered by region)
+            for category in entry.categories:
+                if category not in self.by_category:
+                    self.by_category[category] = []
+                self.by_category[category].append(entry)
+
+    def find_best_match(
+        self,
+        category: str,
+        width: float | None = None,
+        depth: float | None = None,
+        tolerance: float = 0.3,
+    ) -> BuildingEntry | None:
+        """Find the best matching building entry based on criteria.
+        All entries are already filtered by region during initialization.
+
+        Arguments:
+            category (str): Required building category
+            width (float | None): Desired width (optional)
+            depth (float | None): Desired depth (optional)
+            tolerance (float): Size tolerance factor (0.3 = 30% tolerance)
+
+        Returns:
+            BuildingEntry | None: Best matching entry or None if no suitable match found
+        """
+        # Start with buildings of the required category (already filtered by region)
+        candidates = self.by_category.get(category, [])
+        if not candidates:
+            return None
+
+        # Score each candidate
+        scored_candidates = []
+        for entry in candidates:
+            score = self._calculate_match_score(entry, category, width, depth, tolerance)
+            if score > 0:  # Only consider viable matches
+                scored_candidates.append((score, entry))
+
+        if not scored_candidates:
+            return None
+
+        # Return the highest scoring match
+        scored_candidates.sort(key=lambda x: x[0], reverse=True)
+        return scored_candidates[0][1]
+
+    def _calculate_match_score(
+        self,
+        entry: BuildingEntry,
+        category: str,
+        width: float | None,
+        depth: float | None,
+        tolerance: float,
+    ) -> float:
+        """Calculate a match score for a building entry.
+        Region is already matched during initialization.
+
+        Returns:
+            float: Match score (higher is better, 0 means no match)
+        """
+        score = 0.0
+
+        # Category match (required) - base score
+        if category in entry.categories:
+            score = 100.0
+        else:
+            return 0.0  # Category mismatch = no match
+
+        # Size matching (if dimensions are provided)
+        if width is not None and depth is not None:
+            # Calculate how well the dimensions match (considering both orientations)
+            size_score1 = self._calculate_size_match(
+                entry.width, entry.depth, width, depth, tolerance
+            )
+            size_score2 = self._calculate_size_match(
+                entry.width, entry.depth, depth, width, tolerance
+            )
+
+            # Use the better orientation
+            size_score = max(size_score1, size_score2)
+
+            if size_score > 0:
+                score += (
+                    size_score * 80.0
+                )  # Size match contributes up to 80 points (increased since no region bonus)
+            else:
+                return 0.0  # Size too different = no match
+
+        return score
+
+    def _calculate_size_match(
+        self,
+        entry_width: float,
+        entry_depth: float,
+        target_width: float,
+        target_depth: float,
+        tolerance: float,
+    ) -> float:
+        """Calculate how well building dimensions match target dimensions.
+
+        Returns:
+            float: Size match score between 0 and 1 (1 = perfect match)
+        """
+        width_ratio = min(entry_width, target_width) / max(entry_width, target_width)
+        depth_ratio = min(entry_depth, target_depth) / max(entry_depth, target_depth)
+
+        # Check if both dimensions are within tolerance
+        if width_ratio < (1 - tolerance) or depth_ratio < (1 - tolerance):
+            return 0.0
+
+        # Calculate combined size score (average of both dimension matches)
+        return (width_ratio + depth_ratio) / 2.0
+
+    def get_available_categories(self) -> list[str]:
+        """Get list of available building categories for this region."""
+        return list(self.by_category.keys())
+
+    def filter_by_category(self, category: str) -> list[BuildingEntry]:
+        """Get all buildings of a specific category (already filtered by region)."""
+        return self.by_category.get(category, [])
+
+
+def building_category_type_to_pixel(building_category: str) -> int | None:
+    """Returns the pixel value representation of the building category.
+    If not found, returns None.
+
+    Arguments:
+        building_category (str | None): The building category type as a string.
+
+    Returns:
+        int | None: pixel value of the building category, or None if not found.
+    """
+    return AREA_TYPES.get(building_category)
+
+
+def pixel_value_to_building_category_type(pixel_value: int) -> str:
+    """Returns the building category type representation of the pixel value.
+    If not found, returns "residential".
+
+    Arguments:
+        pixel_value (int | None): The pixel value to look up the building category for.
+
+    Returns:
+        str: building category of the pixel value, or "residential" if not found.
+    """
+    return PIXEL_TYPES.get(pixel_value, "residential")
+
+
+class Building(I3d):
+    """Component for map buildings processing and generation.
+
+    Arguments:
+        game (Game): The game instance for which the map is generated.
+        coordinates (tuple[float, float]): The latitude and longitude of the center of the map.
+        map_size (int): The size of the map in pixels.
+        map_rotated_size (int): The size of the map in pixels after rotation.
+        rotation (int): The rotation angle of the map.
+        map_directory (str): The directory where the map files are stored.
+        logger (Any, optional): The logger to use. Must have at least three basic methods: debug,
+            info, warning. If not provided, default logging will be used.
+    """
+
+    def preprocess(self) -> None:
+        """Preprocess and prepare buildings schema and buildings map image."""
+        try:
+            buildings_schema_path = self.game.buildings_schema
+        except ValueError as e:
+            self.logger.warning("The game does not support buildings schema: %s", e)
+            return
+
+        custom_buildings_schema = self.map.buildings_custom_schema
+        if not custom_buildings_schema:
+            if not os.path.isfile(buildings_schema_path):
+                self.logger.warning(
+                    "Buildings schema file not found at path: %s. Skipping buildings generation.",
+                    buildings_schema_path,
+                )
+                return
+
+            try:
+                with open(buildings_schema_path, "r", encoding="utf-8") as f:
+                    buildings_schema = json.load(f)
+
+                self.buildings_schema = buildings_schema
+
+            except Exception as e:
+                self.logger.warning(
+                    "Failed to load buildings schema from path: %s with error: %s. Skipping buildings generation.",
+                    buildings_schema_path,
+                    e,
+                )
+        else:
+            self.buildings_schema = custom_buildings_schema
+
+        self.logger.info(
+            "Buildings schema loaded successfully with %d objects.", len(self.buildings_schema)
+        )
+
+        self.xml_path = self.game.i3d_file_path(self.map_directory)
+
+        buildings_directory = os.path.join(self.map.map_directory, "buildings")
+        self.buildings_map_path = os.path.join(buildings_directory, "building_categories.png")
+        os.makedirs(buildings_directory, exist_ok=True)
+
+        texture_component = self.map.get_texture_component()
+        if not texture_component:
+            self.logger.warning("Texture component not found in the map.")
+            return
+
+        # Creating empty single-channel image for building categories.
+        buildings_map_image = np.zeros((self.map.size, self.map.size), dtype=np.uint8)
+
+        for layer in texture_component.get_building_category_layers():
+            self.logger.debug(
+                "Processing building category layer: %s (%s)",
+                layer.name,
+                layer.building_category,
+            )
+            pixel_value = building_category_type_to_pixel(layer.building_category)  # type: ignore
+            if pixel_value is None:
+                self.logger.warning(
+                    "Unknown building category '%s' for layer '%s'. Skipping.",
+                    layer.building_category,
+                    layer.name,
+                )
+                continue
+
+            layer_path = layer.path(self.game.weights_dir_path(self.map.map_directory))
+            if not layer_path or not os.path.isfile(layer_path):
+                self.logger.warning("Layer texture file not found: %s. Skipping.", layer_path)
+                continue
+
+            layer_image = cv2.imread(layer_path, cv2.IMREAD_UNCHANGED)
+            if layer_image is None:
+                self.logger.warning("Failed to read layer image: %s. Skipping.", layer_path)
+                continue
+
+            mask = layer_image > 0
+            buildings_map_image[mask] = pixel_value
+
+        # Save the buildings map image
+        cv2.imwrite(self.buildings_map_path, buildings_map_image)
+        self.logger.info("Building categories map saved to: %s", self.buildings_map_path)
+
+        building_entries = []
+        for building_entry in self.buildings_schema:
+            building = BuildingEntry(**building_entry)
+            building_entries.append(building)
+
+        region = get_region_by_coordinates(self.coordinates)
+
+        self.buildings_collection = BuildingEntryCollection(building_entries, region)
+        self.logger.info(
+            "Buildings collection created with %d buildings for region '%s'.",
+            len(self.buildings_collection.entries),
+            region,
+        )
+
+    # pylint: disable=too-many-return-statements
+    def process(self) -> None:
+        """Process and place buildings on the map based on the buildings map image and schema."""
+        if not hasattr(self, "buildings_map_path") or not os.path.isfile(self.buildings_map_path):
+            self.logger.warning(
+                "Buildings map path is not set or file does not exist. Skipping process step."
+            )
+            return
+
+        # Check if the collection contains any buildings.
+        if not self.buildings_collection.entries:
+            self.logger.warning(
+                "No buildings found in the collection. Buildings generation will be skipped.",
+            )
+            return
+
+        buildings_map_image = cv2.imread(self.buildings_map_path, cv2.IMREAD_UNCHANGED)
+        if buildings_map_image is None:
+            self.logger.warning("Failed to read buildings map image. Skipping process step.")
+            return
+
+        self.logger.debug("Buildings map categories file found, processing...")
+
+        buildings = self.get_infolayer_data(Parameters.TEXTURES, Parameters.BUILDINGS)
+        if not buildings:
+            self.logger.warning("Buildings data not found in textures info layer.")
+            return
+
+        self.logger.info("Found %d building entries to process.", len(buildings))
+
+        # Initialize tracking for XML modifications
+        tree = self.get_tree()
+        root = tree.getroot()
+
+        if root is None:
+            self.logger.warning("Failed to get root element from I3D XML tree.")
+            return
+
+        # Find the Scene element
+        scene_node = root.find(".//Scene")
+        if scene_node is None:
+            self.logger.warning("Scene element not found in I3D file.")
+            return
+
+        # Find or create the Files section
+        files_section = root.find("Files")
+        if files_section is None:
+            files_section = ET.SubElement(root, "Files")
+
+        # Find or create the buildings transform group in the scene
+        buildings_group = self._find_or_create_buildings_group(scene_node)
+
+        # Track used building files to avoid duplicates (file_path -> file_id mapping)
+        used_building_files = {}
+        file_id_counter = BUILDINGS_STARTING_NODE_ID
+        node_id_counter = BUILDINGS_STARTING_NODE_ID + 1000
+
+        not_resized_dem = self.get_not_resized_dem(with_foundations=True)
+        if not_resized_dem is None:
+            self.logger.warning("Not resized DEM not found.")
+            return
+
+        for building in tqdm(buildings, desc="Placing buildings", unit="building"):
+            try:
+                fitted_building = self.fit_object_into_bounds(
+                    polygon_points=building, angle=self.rotation
+                )
+            except ValueError as e:
+                self.logger.debug(
+                    "Building could not be fitted into the map bounds with error: %s",
+                    e,
+                )
+                continue
+
+            # 1. Identify the center point of the building polygon.
+            center_point = np.mean(fitted_building, axis=0).astype(int)
+            x, y = center_point
+            self.logger.debug("Center point of building polygon: %s", center_point)
+
+            pixel_value = buildings_map_image[y, x]
+            self.logger.debug("Pixel value at center point: %s", pixel_value)
+
+            category = pixel_value_to_building_category_type(pixel_value)
+            self.logger.debug("Building category at center point: %s", category)
+
+            # 2. Obtain building dimensions and rotation using minimum area bounding rectangle
+            polygon_np = self.polygon_points_to_np(fitted_building)
+            width, depth, rotation_angle = self._get_polygon_dimensions_and_rotation(polygon_np)
+            self.logger.debug(
+                "Building dimensions: width=%d, depth=%d, rotation=%d°",
+                width,
+                depth,
+                rotation_angle,
+            )
+
+            # 3. Find the best matching building from the collection (region already filtered)
+            best_match = self.buildings_collection.find_best_match(
+                category=category,
+                width=width,
+                depth=depth,
+                tolerance=TOLERANCE_FACTOR,
+            )
+
+            if best_match:
+                self.logger.debug(
+                    f"Best building match: {best_match.name} ({best_match.width}x{best_match.depth})"
+                )
+
+                # Get world coordinates
+                x_center, y_center = self.top_left_coordinates_to_center(center_point)
+                try:
+                    z = self.get_z_coordinate_from_dem(not_resized_dem, x, y)
+                except Exception as e:
+                    self.logger.warning(
+                        "Failed to get Z coordinate from DEM at (%d, %d) with error: %s. Using default height %d.",
+                        x,
+                        y,
+                        e,
+                        DEFAULT_HEIGHT,
+                    )
+                    z = DEFAULT_HEIGHT
+
+                # * Disabled for now, maybe re-enable later.
+                # Calculate scale factors to match the polygon size
+                # scale_width = width / best_match.width
+                # scale_depth = depth / best_match.depth
+
+                self.logger.debug(
+                    "World coordinates for building: x=%.3f, y=%.3f, z=%.3f",
+                    x_center,
+                    y_center,
+                    z,
+                )
+                # self.logger.debug(
+                #     "Scale factors: width=%.4f, depth=%.4f",
+                #     scale_width,
+                #     scale_depth,
+                # )
+
+                # Add building file to Files section if not already present
+                file_id = None
+                if best_match.file not in used_building_files:
+                    file_id = file_id_counter
+                    file_element = ET.SubElement(files_section, "File")
+                    file_element.set("fileId", str(file_id))
+                    file_element.set("filename", best_match.file)
+                    used_building_files[best_match.file] = file_id
+                    file_id_counter += 1
+                else:
+                    file_id = used_building_files[best_match.file]
+
+                # Create building instance in the buildings group
+                building_node = ET.SubElement(buildings_group, "ReferenceNode")
+                building_node.set("name", f"{best_match.name}_{node_id_counter}")
+                building_node.set("translation", f"{x_center:.3f} {z:.3f} {y_center:.3f}")
+                building_node.set("rotation", f"0 {rotation_angle:.3f} 0")
+                # building_node.set(
+                #     "scale", f"{scale_width:.4f} 1.0 {scale_depth:.4f}"
+                # )
+                building_node.set("referenceId", str(file_id))
+                building_node.set("nodeId", str(node_id_counter))
+
+                node_id_counter += 1
+
+            else:
+                self.logger.debug(
+                    f"No suitable building found for category '{category}' with dimensions {width:.2f}x{depth:.2f}"
+                )
+                continue
+
+        added_buildings_count = node_id_counter - (BUILDINGS_STARTING_NODE_ID + 1000)
+        self.logger.info("Total buildings placed: %d of %d", added_buildings_count, len(buildings))
+
+        # Save the modified XML tree
+        self.save_tree(tree)
+        self.logger.info("Buildings placement completed and saved to map.i3d")
+
+    def _get_polygon_dimensions_and_rotation(
+        self, polygon_points: np.ndarray
+    ) -> tuple[float, float, float]:
+        """Calculate width, depth, and rotation angle of a polygon using minimum area bounding rectangle.
+
+        Arguments:
+            polygon_points (np.ndarray): Array of polygon points with shape (n, 2)
+
+        Returns:
+            tuple[float, float, float]: width, depth, and rotation angle in degrees
+        """
+        # Convert to the format expected by cv2.minAreaRect (needs to be float32)
+        points = polygon_points.astype(np.float32)
+
+        # Find the minimum area bounding rectangle
+        rect = cv2.minAreaRect(points)
+
+        # rect contains: ((center_x, center_y), (width, height), angle)
+        (_, _), (width, height), angle = rect
+
+        # OpenCV's minAreaRect returns angle in range [-90, 0) for the longer side
+        # We need to convert this to a proper world rotation angle
+
+        # First, ensure width is the longer dimension
+        if width < height:
+            # Swap dimensions
+            width, height = height, width
+            # When we swap dimensions, we need to adjust the angle by 90 degrees
+            angle = angle + 90.0
+
+        # Convert OpenCV angle to world rotation angle
+        # OpenCV angle is measured from the horizontal axis, counter-clockwise
+        # But we want the angle in degrees for Y-axis rotation in 3D space
+        rotation_angle = -angle  # Negative because 3D rotation is clockwise positive
+
+        # Normalize to [0, 360) range
+        while rotation_angle < 0:
+            rotation_angle += 360
+        while rotation_angle >= 360:
+            rotation_angle -= 360
+
+        return width, height, rotation_angle
+
+    def _find_or_create_buildings_group(self, scene_node: ET.Element) -> ET.Element:
+        """Find or create the buildings transform group in the scene.
+
+        Arguments:
+            scene_node (ET.Element): The scene element of the XML tree
+
+        Returns:
+            ET.Element: The buildings transform group element
+        """
+        # Look for existing buildings group in the scene
+        for transform_group in scene_node.iter("TransformGroup"):
+            if transform_group.get("name") == "buildings":
+                return transform_group
+
+        # Create new buildings group if not found using the proper element creation method
+        buildings_group = self.create_element(
+            "TransformGroup",
+            {
+                "name": "buildings",
+                "translation": "0 0 0",
+                "nodeId": str(BUILDINGS_STARTING_NODE_ID),
+            },
+        )
+
+        scene_node.append(buildings_group)
+        return buildings_group
+
+    def info_sequence(self) -> dict[str, dict[str, str | float | int]]:
+        return {}

maps4fs/generator/component/grle.py

@@ -542,6 +542,17 @@ class GRLE(ImageComponent, XMLComponent):
 
         for layer in texture_component.get_area_type_layers():
             pixel_value = area_type_to_pixel_value(layer.area_type)  # type: ignore
+            # * Not enabled for now.
+            # * If the layer is invisible, we need to draw the mask from the info layer.
+            # if layer.invisible:
+            #     self.logger.debug("Processing invisible area type layer: %s.", layer.name)
+            #     if layer.info_layer:
+            #         self.logger.debug("Info layer available: %s.", layer.info_layer)
+            #         weight_image = self.draw_invisible_layer_mask(layer, environment_size)
+            #     else:
+            #         self.logger.debug("No info layer available for layer: %s.", layer.name)
+            #         continue
+            # else:
             weight_image = self.get_resized_weight(layer, environment_size)  # type: ignore
             if weight_image is None:
                 self.logger.warning("Weight image for area type layer not found in %s.", layer.name)
@@ -562,6 +573,52 @@ class GRLE(ImageComponent, XMLComponent):
         self.logger.debug("Environment InfoLayer PNG file saved: %s.", info_layer_environment_path)
         self.preview_paths["environment"] = info_layer_environment_path
 
+    # def draw_invisible_layer_mask(self, layer: Layer, resize_to: int) -> np.ndarray:
+    #     """Draw the mask for the invisible layer.
+
+    #     Arguments:
+    #         layer (Layer): The layer for which to draw the mask.
+    #         resize_to (int): The size to which the mask should be resized.
+
+    #     Returns:
+    #         np.ndarray: The resized mask.
+    #     """
+    #     mask = np.zeros((self.map.size, self.map.size), dtype=np.uint8)
+    #     polygons = self.get_infolayer_data(Parameters.TEXTURES, layer.info_layer)
+    #     self.logger.debug("Found %d polygons in info layer %s.", len(polygons), layer.info_layer)
+
+    #     for polygon in polygons:
+    #         try:
+    #             fitted_polygon = self.fit_object_into_bounds(
+    #                 polygon_points=polygon,
+    #                 # margin=self.map.grle_settings.farmland_margin,
+    #                 angle=self.rotation,
+    #             )
+    #         except ValueError as e:
+    #             self.logger.debug(
+    #                 "Polygon could not be fitted into the map bounds with error: %s",
+    #                 e,
+    #             )
+    #             continue
+    #         polygon_np = self.polygon_points_to_np(fitted_polygon)
+
+    #         try:
+    #             cv2.fillPoly(mask, [polygon_np], (float(255),))  # type: ignore
+    #         except Exception as e:
+    #             self.logger.debug(
+    #                 "Polygon could not be added to the mask with error: %s",
+    #                 e,
+    #             )
+    #             continue
+
+    #     resized_mask = cv2.resize(
+    #         mask,
+    #         (resize_to, resize_to),
+    #         interpolation=cv2.INTER_NEAREST,
+    #     )
+
+    #     return resized_mask
+
     @monitor_performance
     def get_resized_weight(
         self, layer: Layer, resize_to: int, dilations: int = 3

maps4fs/generator/component/i3d.py

@@ -12,13 +12,14 @@ import cv2
 import numpy as np
 from tqdm import tqdm
 
+from maps4fs.generator.component.base.component_image import ImageComponent
 from maps4fs.generator.component.base.component_xml import XMLComponent
 from maps4fs.generator.monitor import monitor_performance
 from maps4fs.generator.settings import Parameters
 
 NODE_ID_STARTING_VALUE = 2000
 SPLINES_NODE_ID_STARTING_VALUE = 5000
-TREE_NODE_ID_STARTING_VALUE = 10000
+TREE_NODE_ID_STARTING_VALUE = 30000
 
 FIELDS_ATTRIBUTES = [
     ("angle", "integer", "0"),
@@ -30,7 +31,7 @@ FIELDS_ATTRIBUTES = [
 ]
 
 
-class I3d(XMLComponent):
+class I3d(XMLComponent, ImageComponent):
     """Component for map i3d file settings and configuration.
 
     Arguments:
@@ -690,9 +691,13 @@ class I3d(XMLComponent):
 
         return recommended_step if not current_step else max(recommended_step, current_step)
 
-    def get_not_resized_dem(self) -> np.ndarray | None:
+    def get_not_resized_dem(self, with_foundations: bool = False) -> np.ndarray | None:
         """Reads the not resized DEM image from the background component.
 
+        Arguments:
+            with_foundations (bool, optional): Whether to get the DEM with foundations.
+                Defaults to False.
+
         Returns:
             np.ndarray | None: The not resized DEM image or None if the image could not be read.
         """
@@ -701,11 +706,17 @@ class I3d(XMLComponent):
             self.logger.warning("Background component not found.")
             return None
 
-        if not background_component.not_resized_path:
+        dem_path = (
+            background_component.not_resized_with_foundations_path
+            if with_foundations
+            else background_component.not_resized_path
+        )
+
+        if not dem_path:
             self.logger.warning("Not resized DEM path not found.")
             return None
 
-        not_resized_dem = cv2.imread(background_component.not_resized_path, cv2.IMREAD_UNCHANGED)
+        not_resized_dem = cv2.imread(dem_path, cv2.IMREAD_UNCHANGED)
 
         return not_resized_dem
 

maps4fs/generator/component/layer.py

@@ -21,6 +21,16 @@ class Layer:
         usage (str | None): Usage of the layer.
         background (bool): Flag to determine if the layer is a background.
         invisible (bool): Flag to determine if the layer is invisible.
+        procedural (list[str] | None): List of procedural textures to apply.
+        border (int | None): Border size in pixels.
+        precise_tags (dict[str, str | list[str]] | None): Dictionary of precise tags to search for.
+        precise_usage (str | None): Precise usage of the layer.
+        area_type (str | None): Type of the area (e.g., residential, commercial).
+        area_water (bool): Flag to determine if the area is water.
+        indoor (bool): Flag to determine if the layer is indoor.
+        merge_into (str | None): Name of the layer to merge into.
+        building_category (str | None): Category of the building.
+        external (bool): External layers not being used by the game directly.
 
     Attributes:
         name (str): Name of the layer.
@@ -50,6 +60,8 @@ class Layer:
         area_water: bool = False,
         indoor: bool = False,
         merge_into: str | None = None,
+        building_category: str | None = None,
+        external: bool = False,
     ):
         self.name = name
         self.count = count
@@ -70,6 +82,8 @@ class Layer:
         self.area_water = area_water
         self.indoor = indoor
         self.merge_into = merge_into
+        self.building_category = building_category
+        self.external = external
 
     def to_json(self) -> dict[str, str | list[str] | bool]:  # type: ignore
         """Returns dictionary with layer data.
@@ -96,6 +110,8 @@ class Layer:
             "area_water": self.area_water,
             "indoor": self.indoor,
             "merge_into": self.merge_into,
+            "building_category": self.building_category,
+            "external": self.external,
         }
 
         data = {k: v for k, v in data.items() if v is not None}

maps4fs/generator/component/texture.py

@@ -168,6 +168,14 @@ class Texture(ImageComponent):
         """
         return [layer for layer in self.layers if layer.indoor]
 
+    def get_building_category_layers(self) -> list[Layer]:
+        """Returns layers which have building category defined.
+
+        Returns:
+            list[Layer]: List of layers which have building category defined.
+        """
+        return [layer for layer in self.layers if layer.building_category is not None]
+
     def process(self) -> None:
         """Processes the data to generate textures."""
         self._prepare_weights()
@@ -469,8 +477,11 @@ class Texture(ImageComponent):
             self._draw_layer(layer, info_layer_data, layer_image)  # type: ignore
             self._add_roads(layer, info_layer_data)
 
-            output_image = cv2.bitwise_and(layer_image, mask)  # type: ignore
-            cumulative_image = cv2.bitwise_or(cumulative_image, output_image)  # type: ignore
+            if not layer.external:
+                output_image = cv2.bitwise_and(layer_image, mask)  # type: ignore
+                cumulative_image = cv2.bitwise_or(cumulative_image, output_image)  # type: ignore
+            else:
+                output_image = layer_image  # type: ignore
 
             cv2.imwrite(layer_path, output_image)
             self.logger.debug("Texture %s saved.", layer_path)

maps4fs/generator/config.py

@@ -40,7 +40,7 @@ logger.info(
 )
 
 TEMPLATES_STRUCTURE = {
-    "fs25": ["texture_schemas", "tree_schemas", "map_templates"],
+    "fs25": ["texture_schemas", "tree_schemas", "buildings_schemas", "map_templates"],
     "fs22": ["texture_schemas", "map_templates"],
 }
 
@@ -82,15 +82,31 @@ def ensure_templates():
                 text=True,
             )
 
-            # Make the preparation script executable
-            prep_script = os.path.join(clone_dir, "prepare_data.sh")
+            if os.name == "nt":
+                logger.info("Detected Windows OS, running PowerShell preparation script...")
+                prep_script = os.path.join(clone_dir, "prepare_data.ps1")
+                for_subprocess = [
+                    "powershell",
+                    "-ExecutionPolicy",
+                    "Bypass",
+                    "-File",
+                    "prepare_data.ps1",
+                ]
+            else:
+                logger.info("Detected non-Windows OS, running bash preparation script...")
+                prep_script = os.path.join(clone_dir, "prepare_data.sh")
+                for_subprocess = ["./prepare_data.sh"]
+
             if os.path.exists(prep_script):
-                os.chmod(prep_script, 0o755)
+                try:
+                    os.chmod(prep_script, 0o755)
+                except Exception as e:
+                    logger.warning("Could not set execute permissions on script: %s", str(e))
 
                 logger.info("Running data preparation script...")
                 # Run the preparation script from the cloned directory
                 subprocess.run(
-                    ["./prepare_data.sh"], cwd=clone_dir, check=True, capture_output=True, text=True
+                    for_subprocess, cwd=clone_dir, check=True, capture_output=True, text=True
                 )
 
                 # Copy the generated data directory to templates directory

maps4fs/generator/game.py

@@ -5,9 +5,11 @@ template file and specific settings for map generation."""
 from __future__ import annotations
 
 import os
+from typing import Callable
 
 import maps4fs.generator.config as mfscfg
 from maps4fs.generator.component.background import Background
+from maps4fs.generator.component.building import Building
 from maps4fs.generator.component.config import Config
 from maps4fs.generator.component.grle import GRLE
 from maps4fs.generator.component.i3d import I3d
@@ -37,6 +39,7 @@ class Game:
     _texture_schema_file: str | None = None
     _grle_schema_file: str | None = None
     _tree_schema_file: str | None = None
+    _buildings_schema_file: str | None = None
     _i3d_processing: bool = True
     _plants_processing: bool = True
     _environment_processing: bool = True
@@ -45,7 +48,7 @@ class Game:
     _mesh_processing: bool = True
 
     # Order matters! Some components depend on others.
-    components = [Satellite, Texture, Background, GRLE, I3d, Config]
+    components = [Satellite, Texture, Background, GRLE, I3d, Config, Building]
 
     def __init__(self, map_template_path: str | None = None):
         if map_template_path:
@@ -72,6 +75,11 @@ class Game:
         else:
             self._tree_schema = os.path.join(mfscfg.MFS_TEMPLATES_DIR, self._tree_schema_file)  # type: ignore
 
+        if not self._buildings_schema_file:
+            self._buildings_schema_file = None
+        else:
+            self._buildings_schema_file = os.path.join(mfscfg.MFS_TEMPLATES_DIR, self._buildings_schema_file)  # type: ignore
+
     def set_components_by_names(self, component_names: list[str]) -> None:
         """Sets the components used for map generation by their names.
 
@@ -159,6 +167,19 @@ class Game:
             raise ValueError("Tree layers schema path not set.")
         return self._tree_schema
 
+    @property
+    def buildings_schema(self) -> str:
+        """Returns the path to the buildings layers schema file.
+
+        Raises:
+            ValueError: If the buildings layers schema path is not set.
+
+        Returns:
+            str: The path to the buildings layers schema file."""
+        if not self._buildings_schema_file:
+            raise ValueError("Buildings layers schema path not set.")
+        return self._buildings_schema_file
+
     def dem_file_path(self, map_directory: str) -> str:
         """Returns the path to the DEM file.
 
@@ -166,8 +187,7 @@ class Game:
             map_directory (str): The path to the map directory.
 
         Returns:
-            str: The path to the DEM file.
-        """
+            str: The path to the DEM file."""
         raise NotImplementedError
 
     def weights_dir_path(self, map_directory: str) -> str:
@@ -341,6 +361,45 @@ class Game:
             bool: True if the mesh should be processed, False otherwise."""
         return self._mesh_processing
 
+    def validate_template(self, map_directory: str) -> None:
+        """Validates that all required files exist in the map template directory.
+
+        Arguments:
+            map_directory (str): The path to the map directory.
+
+        Raises:
+            FileNotFoundError: If any required files are missing from the template.
+        """
+        all_files = []
+        for root, _, files in os.walk(map_directory):
+            for file in files:
+                all_files.append(os.path.join(root, file))
+
+        missing_files = []
+        for func in self.required_file_methods():
+            try:
+                required_filepath = func(map_directory)
+            except NotImplementedError:
+                continue
+            if required_filepath not in all_files:
+                missing_files.append(required_filepath)
+        if missing_files:
+            raise FileNotFoundError(f"The following files are not found: {missing_files}.")
+
+    def required_file_methods(self) -> list[Callable[[str], str]]:
+        """Returns a list of methods that return paths to required files for map generation.
+
+        Returns:
+            list[Callable[[str], str]]: List of methods that take a map directory path
+                and return file paths that are required for the map template.
+        """
+        return [
+            self.map_xml_path,
+            self.i3d_file_path,
+            self.get_environment_xml_path,
+            self.get_farmlands_xml_path,
+        ]
+
 
 class FS22(Game):
     """Class used to define the game version FS22."""
@@ -396,6 +455,7 @@ class FS25(Game):
     _texture_schema_file = "fs25-texture-schema.json"
     _grle_schema_file = "fs25-grle-schema.json"
     _tree_schema_file = "fs25-tree-schema.json"
+    _buildings_schema_file = "fs25-buildings-schema.json"
 
     def dem_file_path(self, map_directory: str) -> str:
         """Returns the path to the DEM file.

maps4fs/generator/map.py

@@ -123,11 +123,13 @@ class Map:
         os.makedirs(self.map_directory, exist_ok=True)
         self.texture_custom_schema = kwargs.get("texture_custom_schema", None)
         self.tree_custom_schema = kwargs.get("tree_custom_schema", None)
+        self.buildings_custom_schema = kwargs.get("buildings_custom_schema", None)
 
         json_data = {
             "generation_settings.json": generation_settings_json,
             "texture_custom_schema.json": self.texture_custom_schema,
             "tree_custom_schema.json": self.tree_custom_schema,
+            "buildings_custom_schema.json": self.buildings_custom_schema,
         }
 
         for filename, data in json_data.items():

maps4fs/generator/utils.py

@@ -4,7 +4,7 @@ import json
 import os
 import shutil
 from datetime import datetime
-from typing import Any
+from typing import Any, Literal
 from xml.etree import ElementTree as ET
 
 import osmnx as ox
@@ -122,6 +122,20 @@ def get_country_by_coordinates(coordinates: tuple[float, float]) -> str:
     return "Unknown"
 
 
+def get_region_by_coordinates(coordinates: tuple[float, float]) -> Literal["EU", "US"]:
+    """Get region (EU or US) by coordinates.
+
+    Arguments:
+        coordinates (tuple[float, float]): Latitude and longitude.
+
+    Returns:
+        Literal["EU", "US"]: Region code.
+    """
+    country = get_country_by_coordinates(coordinates)
+    # If country is not US, assume EU for simplicity.
+    return "US" if country == "United States" else "EU"
+
+
 def get_timestamp() -> str:
     """Get current underscore-separated timestamp.
 

{maps4fs-2.9.3.dist-info → maps4fs-2.9.32.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maps4fs
-Version: 2.9.3
+Version: 2.9.32
 Summary: Generate map templates for Farming Simulator from real places.
 Author-email: iwatkot <iwatkot@gmail.com>
 License: GNU Affero General Public License v3.0
@@ -76,6 +76,7 @@ Dynamic: license-file
 🚜 **Farming Simulator 22 & 25** - Generate maps for both game versions<br>
 🗺️ **Flexible Map Sizes** - 2x2, 4x4, 8x8, 16x16 km + custom sizes<br>
 ✂️ **Map Scaling & Rotation** - Perfect positioning and sizing control<br>
+🏘️ **Adding buildings** - Automatic building placement system<br>
 
 🌍 **Real-World Foundation** - Built from OpenStreetMap and satellite data<br>
 🏞️ **Accurate Terrain** - SRTM elevation data with custom DTM support<br>
@@ -86,6 +87,7 @@ Dynamic: license-file
 🌲 **Natural Forests** - Tree placement with customizable density<br>
 🌊 **Water Systems** - Rivers, lakes, and water planes<br>
 🌿 **Decorative Foliage** - Realistic vegetation and grass areas<br>
+🏘️ **Intelligent Building Placement** - Automatic building placement in appropriate areas<br>
 
 🚧 **Complete Spline Networks** - Roads and infrastructure<br>
 🔷 **Background Terrain** - 3D *.obj files for surrounding landscape<br>

{maps4fs-2.9.3.dist-info → maps4fs-2.9.32.dist-info}/RECORD

@@ -1,30 +1,31 @@
 maps4fs/__init__.py,sha256=5ixsCA5vgcIV0OrF9EJBm91Mmc_KfMiDRM-QyifMAvo,386
 maps4fs/logger.py,sha256=aZAa9glzgvH6ySVDLelSPTwHfWZtpGK5YBl-ufNUsPg,801
 maps4fs/generator/__init__.py,sha256=zZMLEkGzb4z0xql650gOtGSvcgX58DnJ2yN3vC2daRk,43
-maps4fs/generator/config.py,sha256=dHJLBt-Ua5rMMvUujAa3cuPSYvDA7tgfY7Z8tpvT_zo,7176
-maps4fs/generator/game.py,sha256=_LNiH__7FeSGsPKsuvAGiktt5GcJQVqcQYtsFZNWGyM,16106
-maps4fs/generator/map.py,sha256=ak74FNSDQXPqaB0gOaZqVo8Sy0fvf_3iXHg6FJkHPpA,15888
+maps4fs/generator/config.py,sha256=_s5pLpATVF-hwpcVquDUOhochD1RghPJczwyKepXtrc,7889
+maps4fs/generator/game.py,sha256=bflRv0lxJ9-wkRvauh0k0RzIgF7zVWguygqQLcC7U-s,18457
+maps4fs/generator/map.py,sha256=9F3PaoK63sbhNONvHN46k62-ZFMBQy5qvu9T193gwWs,16045
 maps4fs/generator/monitor.py,sha256=Yrc7rClpmJK53SRzrOYZNBlwJmb5l6TkW-laFbyBEno,3524
 maps4fs/generator/qgis.py,sha256=Es8hLuqN_KH8lDfnJE6He2rWYbAKJ3RGPn-o87S6CPI,6116
 maps4fs/generator/settings.py,sha256=_QJL4ikQYLFOIB1zWqXjYvyLfoh3cr2RYb2IzsunMJg,13405
 maps4fs/generator/statistics.py,sha256=ol0MTiehcCbQFfyYA7cKU-M4_cjiLCktnGbid4GYABU,2641
-maps4fs/generator/utils.py,sha256=FOkJZrBifGLfEd33noL6AqfV_oW5cM-GQjXHNxzIKv4,5132
+maps4fs/generator/utils.py,sha256=qaHmS5I30OhDwd213bbctlplQQlX-qkHugyszXGmh0U,5587
 maps4fs/generator/component/__init__.py,sha256=s01yVVVi8R2xxNvflu2D6wTd9I_g73AMM2x7vAC7GX4,490
 maps4fs/generator/component/background.py,sha256=c2bjK3DkQXvA6Gtb_hUM9m-7fIVgp2BxJp09c4ZY3_A,49434
+maps4fs/generator/component/building.py,sha256=Ru3AAFMPN2X_ePwM3Yoe-KDkuJySRERpvvvSxU1lJvc,22233
 maps4fs/generator/component/config.py,sha256=tI2RQaGIqBgJIi9KjYfMZZ8AWg_YVUm6KKsBHGV241g,31285
 maps4fs/generator/component/dem.py,sha256=vMVJtU2jAS-2lfB9JsqodZsrUvY1h5xr3Dh5qk6txwk,11895
-maps4fs/generator/component/grle.py,sha256=uOd0dP-TeS85SZ87wafVj7AQv8L5VSdg2O0pDrtm_p0,27500
-maps4fs/generator/component/i3d.py,sha256=t6Y9JPXvKJ91wTBg_-noIsxDPk1OSdY9EwM5ZtgOl9Q,26771
-maps4fs/generator/component/layer.py,sha256=bdy1XGOODyPqYUM3b_wEY2H9Piz-AaHsCDecl-qRHiM,6627
+maps4fs/generator/component/grle.py,sha256=FAcGmG7yq0icOElRoO4QMsVisZMsNrLhfNSWvGKnOHg,29899
+maps4fs/generator/component/i3d.py,sha256=qB18jQWfWjlTiaZ4fHd16vv359hN2YHRLzGTZuJnbbU,27166
+maps4fs/generator/component/layer.py,sha256=-MHnIXyJ7Xth9wOcjJCX-XkXBIYYv23lRRGbQ0XlHdU,7602
 maps4fs/generator/component/satellite.py,sha256=1bPqd8JqAPqU0tEI9m-iuljMW9hXqlaCIxvq7kdpMY0,5219
-maps4fs/generator/component/texture.py,sha256=FF2x6F2d5MRD3mls_m7z0JpnfmQVyoUkThJpXt1PMPM,38087
+maps4fs/generator/component/texture.py,sha256=pmX8KE96dJAwzhnOe_ed-1In6sOLXs8-qdJ0aPc-ePM,38526
 maps4fs/generator/component/base/__init__.py,sha256=zZMLEkGzb4z0xql650gOtGSvcgX58DnJ2yN3vC2daRk,43
 maps4fs/generator/component/base/component.py,sha256=-7H3donrH19f0_rivNyI3fgLsiZkntXfGywEx4tOnM4,23924
 maps4fs/generator/component/base/component_image.py,sha256=GXFkEFARNRkWkDiGSjvU4WX6f_8s6R1t2ZYqZflv1jk,9626
 maps4fs/generator/component/base/component_mesh.py,sha256=2wGe_-wAZVRljMKzzVJ8jdzIETWg7LjxGj8A3inH5eI,25550
 maps4fs/generator/component/base/component_xml.py,sha256=MT-VhU2dEckLFxAgmxg6V3gnv11di_94Qq6atfpOLdc,5342
-maps4fs-2.9.3.dist-info/licenses/LICENSE.md,sha256=Ptw8AkqJ60c4tRts6yuqGP_8B0dxwOGmJsp6YJ8dKqM,34328
-maps4fs-2.9.3.dist-info/METADATA,sha256=ytA78FbbbRnbDGRMyD6qz0K3I9egsVsRdMkp49qL0-w,10042
-maps4fs-2.9.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-maps4fs-2.9.3.dist-info/top_level.txt,sha256=Ue9DSRlejRQRCaJueB0uLcKrWwsEq9zezfv5dI5mV1M,8
-maps4fs-2.9.3.dist-info/RECORD,,
+maps4fs-2.9.32.dist-info/licenses/LICENSE.md,sha256=Ptw8AkqJ60c4tRts6yuqGP_8B0dxwOGmJsp6YJ8dKqM,34328
+maps4fs-2.9.32.dist-info/METADATA,sha256=4X4Nut1e-f0FRrwMLVvJy1LZwUxhs4JH6C1KAleQ4Yk,10213
+maps4fs-2.9.32.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+maps4fs-2.9.32.dist-info/top_level.txt,sha256=Ue9DSRlejRQRCaJueB0uLcKrWwsEq9zezfv5dI5mV1M,8
+maps4fs-2.9.32.dist-info/RECORD,,