maps4fs 1.8.13__py3-none-any.whl → 1.8.15__py3-none-any.whl

maps4fs/generator/{background.py → component/background.py}

@@ -10,21 +10,15 @@ from copy import deepcopy
 
 import cv2
 import numpy as np
-import trimesh  # type: ignore
-from tqdm import tqdm
 
-from maps4fs.generator.component.base.component import Component
+from maps4fs.generator.component.base.component_image import ImageComponent
+from maps4fs.generator.component.base.component_mesh import MeshComponent
 from maps4fs.generator.dem import DEM
+from maps4fs.generator.settings import Parameters
 from maps4fs.generator.texture import Texture
 
-DEFAULT_DISTANCE = 2048
-FULL_NAME = "FULL"
-FULL_PREVIEW_NAME = "PREVIEW"
-ELEMENTS = [FULL_NAME, FULL_PREVIEW_NAME]
 
-
-# pylint: disable=R0902
-class Background(Component):
+class Background(MeshComponent, ImageComponent):
     """Component for creating 3D obj files based on DEM data around the map.
 
     Arguments:
@@ -38,11 +32,9 @@ class Background(Component):
             info, warning. If not provided, default logging will be used.
     """
 
-    # pylint: disable=R0801
     def preprocess(self) -> None:
         """Registers the DEMs for the background terrain."""
-        self.stl_preview_path: str | None = None
-        self.water_resources_path: str | None = None
+        self.stl_preview_path = os.path.join(self.previews_directory, "background_dem.stl")
 
         if self.rotation:
             self.logger.debug("Rotation is enabled: %s.", self.rotation)
@@ -50,7 +42,7 @@ class Background(Component):
         else:
             output_size_multiplier = 1
 
-        self.background_size = self.map_size + DEFAULT_DISTANCE * 2
+        self.background_size = self.map_size + Parameters.BACKGROUND_DISTANCE * 2
         self.rotated_size = int(self.background_size * output_size_multiplier)
 
         self.background_directory = os.path.join(self.map_directory, "background")
@@ -58,13 +50,17 @@ class Background(Component):
         os.makedirs(self.background_directory, exist_ok=True)
         os.makedirs(self.water_directory, exist_ok=True)
 
-        self.output_path = os.path.join(self.background_directory, f"{FULL_NAME}.png")
+        self.water_resources_path = os.path.join(self.water_directory, "water_resources.png")
+
+        self.output_path = os.path.join(self.background_directory, f"{Parameters.FULL}.png")
         if self.map.custom_background_path:
-            self.check_custom_background(self.map.custom_background_path)
+            self.validate_np_for_mesh(self.map.custom_background_path, self.map_size)
             shutil.copyfile(self.map.custom_background_path, self.output_path)
 
-        self.not_substracted_path = os.path.join(self.background_directory, "not_substracted.png")
-        self.not_resized_path = os.path.join(self.background_directory, "not_resized.png")
+        self.not_substracted_path: str = os.path.join(
+            self.background_directory, "not_substracted.png"
+        )
+        self.not_resized_path: str = os.path.join(self.background_directory, "not_resized.png")
 
         self.dem = DEM(
             self.game,
@@ -80,39 +76,6 @@ class Background(Component):
         self.dem.set_output_resolution((self.rotated_size, self.rotated_size))
         self.dem.set_dem_path(self.output_path)
 
-    def check_custom_background(self, image_path: str) -> None:
-        """Checks if the custom background image meets the requirements.
-
-        Arguments:
-            image_path (str): The path to the custom background image.
-
-        Raises:
-            ValueError: If the custom background image does not meet the requirements.
-        """
-        image = cv2.imread(image_path, cv2.IMREAD_UNCHANGED)
-        if image.shape[0] != image.shape[1]:
-            raise ValueError("The custom background image must be a square.")
-
-        if image.shape[0] != self.map_size + DEFAULT_DISTANCE * 2:
-            raise ValueError("The custom background image must have the size of the map + 4096.")
-
-        if len(image.shape) != 2:
-            raise ValueError("The custom background image must be a grayscale image.")
-
-        if image.dtype != np.uint16:
-            raise ValueError("The custom background image must be a 16-bit grayscale image.")
-
-    def is_preview(self, name: str) -> bool:
-        """Checks if the DEM is a preview.
-
-        Arguments:
-            name (str): The name of the DEM.
-
-        Returns:
-            bool: True if the DEM is a preview, False otherwise.
-        """
-        return name == FULL_PREVIEW_NAME
-
     def process(self) -> None:
         """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
@@ -123,12 +86,12 @@ class Background(Component):
             self.dem.process()
 
         shutil.copyfile(self.dem.dem_path, self.not_substracted_path)
-        self.cutout(self.dem.dem_path, save_path=self.not_resized_path)
+        self.save_map_dem(self.dem.dem_path, save_path=self.not_resized_path)
 
         if self.map.dem_settings.water_depth:
             self.subtraction()
 
-        cutted_dem_path = self.cutout(self.dem.dem_path)
+        cutted_dem_path = self.save_map_dem(self.dem.dem_path)
         if self.game.additional_dem_name is not None:
             self.make_copy(cutted_dem_path, self.game.additional_dem_name)
 
@@ -184,9 +147,9 @@ class Background(Component):
 
     def qgis_sequence(self) -> None:
         """Generates QGIS scripts for creating bounding box layers and rasterizing them."""
-        qgis_layer = (f"Background_{FULL_NAME}", *self.dem.get_espg3857_bbox())
+        qgis_layer = (f"Background_{Parameters.FULL}", *self.dem.get_espg3857_bbox())
         qgis_layer_with_margin = (
-            f"Background_{FULL_NAME}_margin",
+            f"Background_{Parameters.FULL}_margin",
             *self.dem.get_espg3857_bbox(add_margin=True),
         )
         self.create_qgis_scripts([qgis_layer, qgis_layer_with_margin])
@@ -214,10 +177,9 @@ class Background(Component):
             create_preview=True,
             remove_center=self.map.background_settings.remove_center,
             include_zeros=False,
-        )  # type: ignore
+        )
 
-    # pylint: disable=too-many-locals
-    def cutout(self, dem_path: str, save_path: str | None = None) -> str:
+    def save_map_dem(self, dem_path: str, save_path: str | None = None) -> str:
         """Cuts out the center of the DEM (the actual map) and saves it as a separate file.
 
         Arguments:
@@ -228,14 +190,8 @@ class Background(Component):
             str -- The path to the cutout DEM file.
         """
         dem_data = cv2.imread(dem_path, cv2.IMREAD_UNCHANGED)
-
-        center = (dem_data.shape[0] // 2, dem_data.shape[1] // 2)
         half_size = self.map_size // 2
-        x1 = center[0] - half_size
-        x2 = center[0] + half_size
-        y1 = center[1] - half_size
-        y2 = center[1] + half_size
-        dem_data = dem_data[x1:x2, y1:y2]
+        dem_data = self.cut_out_np(dem_data, half_size, return_cutout=True)
 
         if save_path:
             cv2.imwrite(save_path, dem_data)
@@ -260,26 +216,6 @@ class Background(Component):
 
         return main_dem_path
 
-    def remove_center(self, dem_data: np.ndarray, resize_factor: float) -> np.ndarray:
-        """Removes the center part of the DEM data.
-
-        Arguments:
-            dem_data (np.ndarray) -- The DEM data as a numpy array.
-            resize_factor (float) -- The resize factor of the DEM data.
-
-        Returns:
-            np.ndarray -- The DEM data with the center part removed.
-        """
-        center = (dem_data.shape[0] // 2, dem_data.shape[1] // 2)
-        half_size = int(self.map_size // 2 * resize_factor)
-        x1 = center[0] - half_size
-        x2 = center[0] + half_size
-        y1 = center[1] - half_size
-        y2 = center[1] + half_size
-        dem_data[x1:x2, y1:y2] = 0
-        return dem_data
-
-    # pylint: disable=R0913, R0917, R0915
     def plane_from_np(
         self,
         dem_data: np.ndarray,
@@ -302,110 +238,29 @@ class Background(Component):
         resize_factor = 1 / self.map.background_settings.resize_factor
         dem_data = cv2.resize(dem_data, (0, 0), fx=resize_factor, fy=resize_factor)
         if remove_center:
-            dem_data = self.remove_center(dem_data, resize_factor)
+            half_size = int(self.map_size // 2 * resize_factor)
+            dem_data = self.cut_out_np(dem_data, half_size, set_zeros=True)
             self.logger.debug("Center removed from DEM data.")
         self.logger.debug(
             "DEM data resized to shape: %s with factor: %s", dem_data.shape, resize_factor
         )
 
-        # Invert the height values.
-        dem_data = dem_data.max() - dem_data
-
-        rows, cols = dem_data.shape
-        x = np.linspace(0, cols - 1, cols)
-        y = np.linspace(0, rows - 1, rows)
-        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,
-            rows,
+        mesh = self.mesh_from_np(
+            dem_data,
+            include_zeros=include_zeros,
+            z_scaling_factor=self.get_z_scaling_factor(),
+            resize_factor=resize_factor,
+            apply_decimation=self.map.background_settings.apply_decimation,
+            decimation_percent=self.map.background_settings.decimation_percent,
+            decimation_agression=self.map.background_settings.decimation_agression,
         )
 
-        vertices = np.column_stack([x.ravel(), y.ravel(), z.ravel()])
-        faces = []
-
-        skipped = 0
-
-        for i in tqdm(range(rows - 1), desc="Generating mesh", unit="row"):
-            for j in range(cols - 1):
-                top_left = i * cols + j
-                top_right = top_left + 1
-                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]]
-                    and not include_zeros
-                ):
-                    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)
-
-        # Apply rotation: 180 degrees around Y-axis and Z-axis
-        rotation_matrix_y = trimesh.transformations.rotation_matrix(np.pi, [0, 1, 0])
-        rotation_matrix_z = trimesh.transformations.rotation_matrix(np.pi, [0, 0, 1])
-        mesh.apply_transform(rotation_matrix_y)
-        mesh.apply_transform(rotation_matrix_z)
-
-        # if not include_zeros:
-        z_scaling_factor = self.get_z_scaling_factor()
-        self.logger.debug("Z scaling factor: %s", z_scaling_factor)
-        mesh.apply_scale([1 / resize_factor, 1 / resize_factor, z_scaling_factor])
-
-        old_faces = len(mesh.faces)
-        self.logger.debug("Mesh generated with %s faces.", old_faces)
-
-        if self.map.background_settings.apply_decimation:
-            percent = self.map.background_settings.decimation_percent / 100
-            mesh = mesh.simplify_quadric_decimation(
-                percent=percent, aggression=self.map.background_settings.decimation_agression
-            )
-
-            new_faces = len(mesh.faces)
-            decimation_percent = (old_faces - new_faces) / old_faces * 100
-
-            self.logger.debug(
-                "Mesh simplified to %s faces. Decimation percent: %s", new_faces, decimation_percent
-            )
-
         mesh.export(save_path)
         self.logger.debug("Obj file saved: %s", save_path)
 
         if create_preview:
-            # Simplify the preview mesh to reduce the size of the file.
-            # mesh = mesh.simplify_quadric_decimation(face_count=len(mesh.faces) // 2**7)
-
-            # Apply scale to make the preview mesh smaller in the UI.
             mesh.apply_scale([0.5, 0.5, 0.5])
-            self.mesh_to_stl(mesh)
-
-    def mesh_to_stl(self, mesh: trimesh.Trimesh) -> None:
-        """Converts the mesh to an STL file and saves it in the previews directory.
-        Uses powerful simplification to reduce the size of the file since it will be used
-        only for the preview.
-
-        Arguments:
-            mesh (trimesh.Trimesh) -- The mesh to convert to an STL file.
-        """
-        mesh = mesh.simplify_quadric_decimation(face_count=len(mesh.faces) // 2**6)
-        preview_path = os.path.join(self.previews_directory, "background_dem.stl")
-        mesh.export(preview_path)
-
-        self.logger.debug("STL file saved: %s", preview_path)
-
-        self.stl_preview_path = preview_path  # pylint: disable=attribute-defined-outside-init
+            self.mesh_to_stl(mesh, save_path=self.stl_preview_path)
 
     def previews(self) -> list[str]:
         """Returns the path to the image previews paths and the path to the STL preview file.
@@ -421,8 +276,13 @@ class Background(Component):
         background_dem_preview_image = cv2.resize(
             background_dem_preview_image, (0, 0), fx=1 / 4, fy=1 / 4
         )
-        background_dem_preview_image = cv2.normalize(  # type: ignore
-            background_dem_preview_image, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U
+        background_dem_preview_image = cv2.normalize(
+            background_dem_preview_image,
+            dst=np.empty_like(background_dem_preview_image),
+            alpha=0,
+            beta=255,
+            norm_type=cv2.NORM_MINMAX,
+            dtype=cv2.CV_8U,
         )
         background_dem_preview_image = cv2.cvtColor(
             background_dem_preview_image, cv2.COLOR_GRAY2BGR
@@ -431,7 +291,7 @@ class Background(Component):
         cv2.imwrite(background_dem_preview_path, background_dem_preview_image)
         preview_paths.append(background_dem_preview_path)
 
-        if self.stl_preview_path:
+        if os.path.isfile(self.stl_preview_path):
             preview_paths.append(self.stl_preview_path)
 
         return preview_paths
@@ -483,26 +343,11 @@ class Background(Component):
 
         dem_data = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)
 
-        self.logger.debug(
-            "DEM data before normalization. Shape: %s, dtype: %s. Min: %s, max: %s.",
-            dem_data.shape,
-            dem_data.dtype,
-            dem_data.min(),
-            dem_data.max(),
-        )
-
         # Create an empty array with the same shape and type as dem_data.
         dem_data_normalized = np.empty_like(dem_data)
 
         # Normalize the DEM data to the range [0, 255]
         cv2.normalize(dem_data, dem_data_normalized, 0, 255, cv2.NORM_MINMAX)
-        self.logger.debug(
-            "DEM data after normalization. Shape: %s, dtype: %s. Min: %s, max: %s.",
-            dem_data_normalized.shape,
-            dem_data_normalized.dtype,
-            dem_data_normalized.min(),
-            dem_data_normalized.max(),
-        )
         dem_data_colored = cv2.applyColorMap(dem_data_normalized, cv2.COLORMAP_JET)
 
         cv2.imwrite(colored_dem_path, dem_data_colored)
@@ -528,7 +373,7 @@ class Background(Component):
         if not background_layers:
             return
 
-        self.background_texture = Texture(  # pylint: disable=W0201
+        self.background_texture = Texture(
             self.game,
             self.map,
             self.coordinates,
@@ -555,13 +400,10 @@ class Background(Component):
         # 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_layer = cv2.imread(path, cv2.IMREAD_GRAYSCALE)
+            background_image = cv2.add(background_image, background_layer)  # type: ignore
 
-        background_save_path = os.path.join(self.water_directory, "water_resources.png")
-        cv2.imwrite(background_save_path, background_image)
-        self.logger.debug("Background texture saved: %s", background_save_path)
-        self.water_resources_path = background_save_path  # pylint: disable=W0201
+        cv2.imwrite(self.water_resources_path, background_image)
 
     def subtraction(self) -> None:
         """Subtracts the water depth from the DEM data where the water resources are located."""
@@ -569,20 +411,14 @@ class Background(Component):
             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
-        )
-
         dem_image = cv2.imread(self.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.map.dem_settings.water_depth
+        dem_image = self.subtract_by_mask(
+            dem_image,
+            water_resources_image,
+            self.map.dem_settings.water_depth,
+        )
 
         # Save the modified dem_image back to the output path
         cv2.imwrite(self.output_path, dem_image)
@@ -590,7 +426,7 @@ class Background(Component):
 
     def generate_water_resources_obj(self) -> None:
         """Generates 3D obj files based on water resources data."""
-        if not self.water_resources_path:
+        if not os.path.isfile(self.water_resources_path):
             self.logger.warning("Water resources texture not found.")
             return
 

maps4fs/generator/component/base/component_image.py

@@ -0,0 +1,90 @@
+"""Base class for all components that primarily used to work with images."""
+
+import cv2
+import numpy as np
+
+from maps4fs.generator.component.base.component import Component
+
+
+class ImageComponent(Component):
+    """Base class for all components that primarily used to work with images."""
+
+    @staticmethod
+    def polygon_points_to_np(
+        polygon_points: list[tuple[int, int]], divide: int | None = None
+    ) -> np.ndarray:
+        """Converts the polygon points to a NumPy array.
+
+        Arguments:
+            polygon_points (list[tuple[int, int]]): The polygon points.
+            divide (int, optional): The number to divide the points by. Defaults to None.
+
+        Returns:
+            np.array: The NumPy array of the polygon points.
+        """
+        array = np.array(polygon_points, dtype=np.int32).reshape((-1, 1, 2))
+        if divide:
+            return array // divide
+        return array
+
+    @staticmethod
+    def cut_out_np(
+        image: np.ndarray, half_size: int, set_zeros: bool = False, return_cutout: bool = False
+    ) -> np.ndarray:
+        """Cuts out a square from the center of the image.
+
+        Arguments:
+            image (np.ndarray): The image.
+            half_size (int): The half size of the square.
+            set_zeros (bool, optional): Whether to set the cutout to zeros. Defaults to False.
+            return_cutout (bool, optional): Whether to return the cutout. Defaults to False.
+
+        Returns:
+            np.ndarray: The image with the cutout or the cutout itself.
+        """
+        center = (image.shape[0] // 2, image.shape[1] // 2)
+        x1 = center[0] - half_size
+        x2 = center[0] + half_size
+        y1 = center[1] - half_size
+        y2 = center[1] + half_size
+
+        if return_cutout:
+            return image[x1:x2, y1:y2]
+
+        if set_zeros:
+            image[x1:x2, y1:y2] = 0
+
+        return image
+
+    @staticmethod
+    def subtract_by_mask(
+        image: np.ndarray,
+        image_mask: np.ndarray,
+        subtract_by: int,
+        mask_by: int = 255,
+        erode_kernel: int | None = 3,
+        erode_iter: int | None = 1,
+    ) -> np.ndarray:
+        """Subtracts a value from the image where the mask is equal to the mask by value.
+
+        Arguments:
+            image (np.ndarray): The image.
+            image_mask (np.ndarray): The mask.
+            subtract_by (int): The value to subtract by.
+            mask_by (int, optional): The value to mask by. Defaults to 255.
+            erode_kernel (int, optional): The kernel size for the erosion. Defaults to 3.
+            erode_iter (int, optional): The number of iterations for the erosion. Defaults to 1.
+
+        Returns:
+            np.ndarray: The image with the subtracted value.
+        """
+        mask = image_mask == mask_by
+        if erode_kernel and erode_iter:
+            mask = cv2.erode(
+                mask.astype(np.uint8),
+                np.ones((erode_kernel, erode_kernel), np.uint8),
+                iterations=erode_iter,
+            ).astype(bool)
+
+        image[mask] = image[mask] - subtract_by
+        return image

maps4fs/generator/component/base/component_mesh.py

@@ -0,0 +1,125 @@
+"""Base class for all components that primarily used to work with meshes."""
+
+import cv2
+import numpy as np
+import trimesh
+from tqdm import tqdm
+
+from maps4fs.generator.component.base.component import Component
+from maps4fs.generator.settings import Parameters
+
+
+class MeshComponent(Component):
+    """Base class for all components that primarily used to work with meshes."""
+
+    @staticmethod
+    def validate_np_for_mesh(image_path: str, map_size: int) -> None:
+        """Checks if the given image is a valid for mesh generation.
+
+        Arguments:
+            image_path (str): The path to the custom background image.
+            map_size (int): The size of the map.
+
+        Raises:
+            ValueError: If the custom background image does not meet the requirements.
+        """
+        image = cv2.imread(image_path, cv2.IMREAD_UNCHANGED)
+        if image.shape[0] != image.shape[1]:
+            raise ValueError("The custom background image must be a square.")
+
+        if image.shape[0] != map_size + Parameters.BACKGROUND_DISTANCE * 2:
+            raise ValueError("The custom background image must have the size of the map + 4096.")
+
+        if len(image.shape) != 2:
+            raise ValueError("The custom background image must be a grayscale image.")
+
+        if image.dtype != np.uint16:
+            raise ValueError("The custom background image must be a 16-bit grayscale image.")
+
+    @staticmethod
+    def mesh_to_stl(mesh: trimesh.Trimesh, save_path: str) -> None:
+        """Converts the mesh to an STL file and saves it in the previews directory.
+        Uses powerful simplification to reduce the size of the file since it will be used
+        only for the preview.
+
+        Arguments:
+            mesh (trimesh.Trimesh) -- The mesh to convert to an STL file.
+        """
+        mesh = mesh.simplify_quadric_decimation(face_count=len(mesh.faces) // 2**6)
+        mesh.export(save_path)
+
+    @staticmethod
+    def mesh_from_np(
+        image: np.ndarray,
+        include_zeros: bool,
+        z_scaling_factor: float,
+        resize_factor: float,
+        apply_decimation: bool,
+        decimation_percent: int,
+        decimation_agression: int,
+    ) -> trimesh.Trimesh:
+        """Generates a mesh from the given numpy array.
+
+        Arguments:
+            image (np.ndarray): The numpy array to generate the mesh from.
+            include_zeros (bool): Whether to include zero values in the mesh.
+            z_scaling_factor (float): The scaling factor for the Z-axis.
+            resize_factor (float): The resizing factor.
+            apply_decimation (bool): Whether to apply decimation to the mesh.
+            decimation_percent (int): The percent of the decimation.
+            decimation_agression (int): The agression of the decimation.
+
+        Returns:
+            trimesh.Trimesh: The generated mesh.
+        """
+        image = image.max() - image
+
+        rows, cols = image.shape
+        x = np.linspace(0, cols - 1, cols)
+        y = np.linspace(0, rows - 1, rows)
+        x, y = np.meshgrid(x, y)
+        z = image
+
+        ground = z.max()
+
+        vertices = np.column_stack([x.ravel(), y.ravel(), z.ravel()])
+        faces = []
+
+        skipped = 0
+
+        for i in tqdm(range(rows - 1), desc="Generating mesh", unit="row"):
+            for j in range(cols - 1):
+                top_left = i * cols + j
+                top_right = top_left + 1
+                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]]
+                    and not include_zeros
+                ):
+                    skipped += 1
+                    continue
+
+                faces.append([top_left, bottom_left, bottom_right])
+                faces.append([top_left, bottom_right, top_right])
+
+        faces_np = np.array(faces)
+        mesh = trimesh.Trimesh(vertices=vertices, faces=faces_np)
+
+        # Apply rotation: 180 degrees around Y-axis and Z-axis
+        rotation_matrix_y = trimesh.transformations.rotation_matrix(np.pi, [0, 1, 0])
+        rotation_matrix_z = trimesh.transformations.rotation_matrix(np.pi, [0, 0, 1])
+        mesh.apply_transform(rotation_matrix_y)
+        mesh.apply_transform(rotation_matrix_z)
+
+        # if not include_zeros:
+        mesh.apply_scale([1 / resize_factor, 1 / resize_factor, z_scaling_factor])
+
+        if apply_decimation:
+            percent = decimation_percent / 100
+            mesh = mesh.simplify_quadric_decimation(
+                percent=percent, aggression=decimation_agression
+            )
+
+        return mesh

maps4fs/generator/component/base/component_xml.py

@@ -93,3 +93,16 @@ class XMLComponent(Component):
         for key, value in data.items():
             element.set(key, value)
         return element
+
+    def create_subelement(
+        self, parent: ET.Element, element_name: str, data: dict[str, str]
+    ) -> None:
+        """Creates a subelement under the parent element with the provided data.
+
+        Arguments:
+            parent (ET.Element): The parent element.
+            element_name (str): The name of the subelement.
+            data (dict[str, str]): The data to set the subelement attributes to.
+        """
+        element = ET.SubElement(parent, element_name)
+        self.update_element(element, data)