maps4fs 1.8.171__py3-none-any.whl → 1.8.173__py3-none-any.whl

maps4fs/generator/component/background.py

@@ -235,24 +235,16 @@ class Background(MeshComponent, ImageComponent):
                 This setting is used for a Background Terrain, where the center part where the
                 playable area is will be cut out.
         """
-        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:
-            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
-        )
-
         mesh = self.mesh_from_np(
             dem_data,
             include_zeros=include_zeros,
             z_scaling_factor=self.get_z_scaling_factor(),
-            resize_factor=resize_factor,
+            resize_factor=self.map.background_settings.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,
+            remove_center=remove_center,
+            remove_size=self.map_size,
         )
 
         mesh.export(save_path)
@@ -414,10 +406,18 @@ class Background(MeshComponent, ImageComponent):
         water_resources_image = cv2.imread(self.water_resources_path, cv2.IMREAD_UNCHANGED)
         dem_image = cv2.imread(self.output_path, cv2.IMREAD_UNCHANGED)
 
+        # fall back to default value for height_scale 255, it is defined as float | None
+        # but it is always set at this point
+        z_scaling_factor: float = (
+            self.map.shared_settings.mesh_z_scaling_factor
+            if self.map.shared_settings.mesh_z_scaling_factor is not None
+            else 257
+        )
+
         dem_image = self.subtract_by_mask(
             dem_image,
             water_resources_image,
-            self.map.dem_settings.water_depth,
+            int(self.map.dem_settings.water_depth * z_scaling_factor),
         )
 
         # Save the modified dem_image back to the output path
@@ -432,6 +432,12 @@ class Background(MeshComponent, ImageComponent):
 
         # Single channeled 8 bit image, where the water have values of 255, and the rest 0.
         plane_water = cv2.imread(self.water_resources_path, cv2.IMREAD_UNCHANGED)
+
+        # Check if the image contains non-zero values.
+        if not np.any(plane_water):
+            self.logger.warning("Water resources image is empty, skipping water generation.")
+            return
+
         dilated_plane_water = cv2.dilate(
             plane_water.astype(np.uint8), np.ones((5, 5), np.uint8), iterations=5
         ).astype(np.uint8)

maps4fs/generator/component/base/component_mesh.py

@@ -53,10 +53,12 @@ class MeshComponent(Component):
         image: np.ndarray,
         include_zeros: bool,
         z_scaling_factor: float,
-        resize_factor: float,
+        resize_factor: int,
         apply_decimation: bool,
         decimation_percent: int,
         decimation_agression: int,
+        remove_center: bool,
+        remove_size: int,
     ) -> trimesh.Trimesh:
         """Generates a mesh from the given numpy array.
 
@@ -64,16 +66,21 @@ class MeshComponent(Component):
             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.
+            resize_factor (int): 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.
+            remove_center (bool): Whether to remove the center from the mesh.
+            remove_size (int): The size of the center to remove.
 
         Returns:
             trimesh.Trimesh: The generated mesh.
         """
+        output_x_size, _ = image.shape
         image = image.max() - image
 
+        image = image[::resize_factor, ::resize_factor]
+
         rows, cols = image.shape
         x = np.linspace(0, cols - 1, cols)
         y = np.linspace(0, rows - 1, rows)
@@ -106,15 +113,7 @@ class MeshComponent(Component):
 
         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])
+        mesh = MeshComponent.rotate_mesh(mesh)
 
         if apply_decimation:
             percent = decimation_percent / 100
@@ -122,4 +121,122 @@ class MeshComponent(Component):
                 percent=percent, aggression=decimation_agression
             )
 
+        try:
+            if not mesh.is_watertight:
+                mesh = MeshComponent.fix_mesh(mesh)
+        except Exception:
+            pass
+
+        mesh = MeshComponent.mesh_to_output_size(
+            mesh,
+            resize_factor,
+            z_scaling_factor,
+            output_x_size,
+            skip_resize_to_expected_size=not include_zeros,
+        )
+
+        if remove_center:
+            mesh = MeshComponent.remove_center_from_mesh(mesh, remove_size)
+
         return mesh
+
+    @staticmethod
+    def rotate_mesh(mesh: trimesh.Trimesh) -> trimesh.Trimesh:
+        """Rotates the given mesh by 180 degrees around the Y-axis and Z-axis.
+
+        Arguments:
+            mesh (trimesh.Trimesh): The mesh to rotate.
+
+        Returns:
+            trimesh.Trimesh: The rotated mesh.
+        """
+        mesh_copy = mesh.copy()
+
+        rotation_matrices = [
+            trimesh.transformations.rotation_matrix(np.pi, [0, 1, 0]),
+            trimesh.transformations.rotation_matrix(np.pi, [0, 0, 1]),
+        ]
+
+        for rotation_matrix in tqdm(rotation_matrices, desc="Rotating mesh", unit="rotation"):
+            mesh_copy.apply_transform(rotation_matrix)
+
+        return mesh_copy
+
+    @staticmethod
+    def fix_mesh(mesh: trimesh.Trimesh) -> trimesh.Trimesh:
+        """Fixes the given mesh by filling holes, fixing normals, fixing winding, fixing inversion,
+        fixing broken faces, and stitching.
+
+        Arguments:
+            mesh (trimesh.Trimesh): The mesh to fix.
+
+        Returns:
+            trimesh.Trimesh: The fixed mesh.
+        """
+        mesh_copy = mesh.copy()
+
+        fix_methods = [
+            trimesh.repair.fill_holes,
+            trimesh.repair.fix_normals,
+            trimesh.repair.fix_winding,
+            trimesh.repair.fix_inversion,
+            trimesh.repair.broken_faces,
+            trimesh.repair.stitch,
+        ]
+
+        for method in tqdm(fix_methods, desc="Fixing mesh", unit="method"):
+            method(mesh_copy)  # type: ignore
+
+        return mesh_copy
+
+    @staticmethod
+    def mesh_to_output_size(
+        mesh: trimesh.Trimesh,
+        resize_factor: int,
+        z_scaling_factor: float,
+        expected_size: int,
+        skip_resize_to_expected_size: bool = False,
+    ) -> trimesh.Trimesh:
+        """Resizes the given mesh to the expected size.
+
+        Arguments:
+            mesh (trimesh.Trimesh): The mesh to resize.
+            resize_factor (int): The resizing factor.
+            z_scaling_factor (float): The scaling factor for the Z-axis.
+            expected_size (int): The expected size.
+            skip_resize_to_expected_size (bool): Whether to skip resizing to the expected size.
+
+        Returns:
+            trimesh.Trimesh: The resized mesh.
+        """
+        mesh_copy = mesh.copy()
+
+        mesh_copy.apply_scale([resize_factor / 1, resize_factor / 1, z_scaling_factor])
+
+        if not skip_resize_to_expected_size:
+            x_size, y_size, _ = mesh_copy.extents
+            x_resize_factor = expected_size / x_size
+            y_resize_factor = expected_size / y_size
+
+            mesh_copy.apply_scale([x_resize_factor, y_resize_factor, 1])
+        return mesh_copy
+
+    @staticmethod
+    def remove_center_from_mesh(mesh: trimesh.Trimesh, remove_size: int) -> trimesh.Trimesh:
+        """Removes the center from the given mesh.
+
+        Arguments:
+            mesh (trimesh.Trimesh): The mesh to remove the center from.
+            remove_size (int): The size of the center to remove.
+
+        Returns:
+            trimesh.Trimesh: The mesh with the center removed.
+        """
+        mesh_copy = mesh.copy()
+
+        _, _, z_size = mesh_copy.extents
+
+        cube_mesh = trimesh.creation.box([remove_size, remove_size, z_size * 4])
+        cube_mesh.apply_translation(mesh_copy.centroid - cube_mesh.centroid)
+
+        return trimesh.boolean.difference([mesh_copy, cube_mesh], check_volume=False)

maps4fs/generator/dem.py

@@ -1,6 +1,6 @@
 """This module contains DEM class for processing Digital Elevation Model data."""
 
-import os
+import math
 from typing import Any
 
 import cv2
@@ -31,10 +31,6 @@ class DEM(Component):
     def preprocess(self) -> None:
         self._dem_path = self.game.dem_file_path(self.map_directory)
         self.temp_dir = "temp"
-        self.hgt_dir = os.path.join(self.temp_dir, "hgt")
-        self.gz_dir = os.path.join(self.temp_dir, "gz")
-        os.makedirs(self.hgt_dir, exist_ok=True)
-        os.makedirs(self.gz_dir, exist_ok=True)
 
         self.logger.debug("Map size: %s x %s.", self.map_size, self.map_size)
         self.logger.debug(
@@ -116,24 +112,8 @@ class DEM(Component):
         )
         return dem_size, dem_size
 
-    def to_ground(self, data: np.ndarray) -> np.ndarray:
-        """Receives the signed 16-bit integer array and converts it to the ground level.
-        If the min value is negative, it will become zero value and the rest of the values
-        will be shifted accordingly.
-        """
-        # For examlem, min value was -50, it will become 0 and for all values we'll +50.
-
-        if data.min() < 0:
-            self.logger.debug("Array contains negative values, will be shifted to the ground.")
-            data = data + abs(data.min())
-
-        self.logger.debug(
-            "Array was shifted to the ground. Min: %s, max: %s.", data.min(), data.max()
-        )
-        return data
-
     def process(self) -> None:
-        """Reads SRTM file, crops it to map size, normalizes and blurs it,
+        """Reads DTM file, crops it to map size, normalizes and blurs it,
         saves to map directory."""
 
         dem_output_resolution = self.output_resolution
@@ -142,7 +122,7 @@ class DEM(Component):
         try:
             data = self.dtm_provider.get_numpy()
         except Exception as e:  # pylint: disable=W0718
-            self.logger.error("Failed to get DEM data from SRTM: %s.", e)
+            self.logger.error("Failed to get DEM data from DTM provider: %s.", e)
             self._save_empty_dem(dem_output_resolution)
             return
 
@@ -151,7 +131,7 @@ class DEM(Component):
             self._save_empty_dem(dem_output_resolution)
             return
 
-        if data.dtype not in ["int16", "uint16"]:
+        if data.dtype not in ["int16", "uint16", "float", "float32"]:
             self.logger.error("DTM provider returned incorrect data type: %s.", data.dtype)
             self._save_empty_dem(dem_output_resolution)
             return
@@ -164,93 +144,158 @@ class DEM(Component):
             data.max(),
         )
 
-        data = self.to_ground(data)
+        # 1. Resize DEM data to the output resolution.
+        resampled_data = self.resize_to_output(data)
 
-        resampled_data = cv2.resize(
-            data, dem_output_resolution, interpolation=cv2.INTER_LINEAR
-        ).astype("uint16")
+        # 2. Apply multiplier (-10 to 120.4 becomes -20 to 240.8)
+        resampled_data = self.apply_multiplier(resampled_data)
 
-        size_of_resampled_data = asizeof.asizeof(resampled_data) / 1024 / 1024
-        self.logger.debug("Size of resampled data: %s MB.", size_of_resampled_data)
+        # 3. Raise terrain, and optionally lower to plateau level+water depth
+        # e.g. -20 to 240.8m becomes 20 to 280.8m
+        resampled_data = self.raise_or_lower(resampled_data)
+
+        # 4. Determine actual height scale value using ceiling
+        # e.g. 255 becomes 280.8+10 = 291
+        height_scale_value = self.determine_height_scale(resampled_data)
+
+        # 5. Normalize DEM data to 16-bit unsigned integer range (0 to 65535)
+        # e.g. multiply by 65535/291, clip and return as uint16
+        resampled_data = self.normalize_data(resampled_data, height_scale_value)
+
+        # 6. Blur DEM data.
+        resampled_data = self.apply_blur(resampled_data)
+
+        cv2.imwrite(self._dem_path, resampled_data)
+        self.logger.debug("DEM data was saved to %s.", self._dem_path)
+
+        if self.rotation:
+            self.rotate_dem()
 
+    def normalize_data(self, data: np.ndarray, height_scale_value: int) -> np.ndarray:
+        """Normalize DEM data to 16-bit unsigned integer range (0 to 65535).
+
+        Arguments:
+            data (np.ndarray): DEM data.
+            height_scale_value (int): Height scale value.
+
+        Returns:
+            np.ndarray: Normalized DEM data.
+        """
+        normalized_data = np.clip((data / height_scale_value) * 65535, 0, 65535).astype(np.uint16)
         self.logger.debug(
-            "Maximum value in resampled data: %s, minimum value: %s. Data type: %s.",
-            resampled_data.max(),
-            resampled_data.min(),
-            resampled_data.dtype,
+            "DEM data was normalized and clipped to 16-bit unsigned integer range. "
+            "Min: %s, max: %s.",
+            normalized_data.min(),
+            normalized_data.max(),
         )
+        return normalized_data
+
+    def determine_height_scale(self, data: np.ndarray) -> int:
+        """Determine height scale value using ceiling.
+
+        Arguments:
+            data (np.ndarray): DEM data.
+
+        Returns:
+            int: Height scale value.
+        """
+        height_scale = self.map.dem_settings.minimum_height_scale
+        adjusted_height_scale = math.ceil(
+            max(height_scale, data.max() + self.map.dem_settings.ceiling)
+        )
+
+        self.map.shared_settings.height_scale_value = adjusted_height_scale  # type: ignore
+        self.map.shared_settings.mesh_z_scaling_factor = 65535 / adjusted_height_scale
+        self.map.shared_settings.height_scale_multiplier = adjusted_height_scale / 255
+        self.map.shared_settings.change_height_scale = True  # type: ignore
+
+        self.logger.debug("Height scale value is %s.", adjusted_height_scale)
+        return adjusted_height_scale
+
+    def raise_or_lower(self, data: np.ndarray) -> np.ndarray:
+        """Raise or lower terrain to the level of plateau+water depth."""
+
+        if not self.map.dem_settings.adjust_terrain_to_ground_level:
+            return data
+
+        desired_ground_level = self.map.dem_settings.plateau + self.map.dem_settings.water_depth
+        current_ground_level = data.min()
 
-        if self.multiplier != 1:
-            resampled_data = resampled_data * self.multiplier
-
-            self.logger.debug(
-                "DEM data was multiplied by %s. Min: %s, max: %s. Data type: %s.",
-                self.multiplier,
-                resampled_data.min(),
-                resampled_data.max(),
-                resampled_data.dtype,
-            )
-
-            size_of_resampled_data = asizeof.asizeof(resampled_data) / 1024 / 1024
-            self.logger.debug("Size of resampled data: %s MB.", size_of_resampled_data)
-
-            # Clip values to 16-bit unsigned integer range.
-            resampled_data = np.clip(resampled_data, 0, 65535)
-            resampled_data = resampled_data.astype("uint16")
-            self.logger.debug(
-                "DEM data was multiplied by %s and clipped to 16-bit unsigned integer range. "
-                "Min: %s, max: %s.",
-                self.multiplier,
-                resampled_data.min(),
-                resampled_data.max(),
-            )
+        data = data + (desired_ground_level - current_ground_level)
 
         self.logger.debug(
-            "DEM data was resampled. Shape: %s, dtype: %s. Min: %s, max: %s.",
-            resampled_data.shape,
-            resampled_data.dtype,
-            resampled_data.min(),
-            resampled_data.max(),
+            "Array was shifted to the ground level %s. Min: %s, max: %s.",
+            desired_ground_level,
+            data.min(),
+            data.max(),
         )
+        return data
 
-        if self.blur_radius > 0:
-            resampled_data = cv2.GaussianBlur(
-                resampled_data, (self.blur_radius, self.blur_radius), sigmaX=40, sigmaY=40
-            )
-            self.logger.debug(
-                "Gaussion blur applied to DEM data with kernel size %s.",
-                self.blur_radius,
-            )
+    def apply_multiplier(self, data: np.ndarray) -> np.ndarray:
+        """Apply multiplier to DEM data.
+
+        Arguments:
+            data (np.ndarray): DEM data.
 
+        Returns:
+            np.ndarray: Multiplied DEM data.
+        """
+        if not self.multiplier != 1:
+            return data
+
+        multiplied_data = data * self.multiplier
         self.logger.debug(
-            "DEM data was blurred. Shape: %s, dtype: %s. Min: %s, max: %s.",
-            resampled_data.shape,
-            resampled_data.dtype,
-            resampled_data.min(),
-            resampled_data.max(),
+            "DEM data was multiplied by %s. Min: %s, max: %s.",
+            self.multiplier,
+            multiplied_data.min(),
+            multiplied_data.max(),
         )
+        return multiplied_data
 
-        if self.map.dem_settings.plateau:
-            # Plateau is a flat area with a constant height.
-            # So we just add this value to each pixel of the DEM.
-            # And also need to ensure that there will be no values with height greater than
-            # it's allowed in 16-bit unsigned integer.
+    def resize_to_output(self, data: np.ndarray) -> np.ndarray:
+        """Resize DEM data to the output resolution.
 
-            resampled_data += self.map.dem_settings.plateau
-            resampled_data = np.clip(resampled_data, 0, 65535)
+        Arguments:
+            data (np.ndarray): DEM data.
 
-            self.logger.debug(
-                "Plateau with height %s was added to DEM data. Min: %s, max: %s.",
-                self.map.dem_settings.plateau,
-                resampled_data.min(),
-                resampled_data.max(),
-            )
+        Returns:
+            np.ndarray: Resized DEM data.
+        """
+        resampled_data = cv2.resize(data, self.output_resolution, interpolation=cv2.INTER_LINEAR)
 
-        cv2.imwrite(self._dem_path, resampled_data)
-        self.logger.debug("DEM data was saved to %s.", self._dem_path)
+        size_of_resampled_data = asizeof.asizeof(resampled_data) / 1024 / 1024
+        self.logger.debug("Size of resampled data: %s MB.", size_of_resampled_data)
 
-        if self.rotation:
-            self.rotate_dem()
+        return resampled_data
+
+    def apply_blur(self, data: np.ndarray) -> np.ndarray:
+        """Apply blur to DEM data.
+
+        Arguments:
+            data (np.ndarray): DEM data.
+
+        Returns:
+            np.ndarray: Blurred DEM data.
+        """
+        if self.blur_radius == 0:
+            return data
+
+        self.logger.debug(
+            "Applying Gaussion blur to DEM data with kernel size %s.",
+            self.blur_radius,
+        )
+
+        blurred_data = cv2.GaussianBlur(
+            data, (self.blur_radius, self.blur_radius), sigmaX=10, sigmaY=10
+        )
+        self.logger.debug(
+            "DEM data was blurred. Shape: %s, dtype: %s. Min: %s, max: %s.",
+            blurred_data.shape,
+            blurred_data.dtype,
+            blurred_data.min(),
+            blurred_data.max(),
+        )
+        return blurred_data
 
     def rotate_dem(self) -> None:
         """Rotate DEM image."""

maps4fs/generator/dtm/dtm.py

@@ -29,9 +29,6 @@ if TYPE_CHECKING:
 class DTMProviderSettings(BaseModel):
     """Base class for DTM provider settings models."""
 
-    easy_mode: bool = True
-    power_factor: int = 0
-
 
 # pylint: disable=too-many-public-methods, too-many-instance-attributes
 class DTMProvider(ABC):
@@ -56,20 +53,7 @@ class DTMProvider(ABC):
 
     _instructions: str | None = None
 
-    _base_instructions = (
-        "ℹ️ Using **Easy mode** is recommended, as it automatically adjusts the values in the "
-        "image, so the terrain elevation in Giants Editor will match real world "
-        "elevation in meters.  \n"
-        "ℹ️ If the terrain height difference in the real world is bigger than 255 meters, "
-        "the [Height scale](https://github.com/iwatkot/maps4fs/blob/main/docs/dem.md#height-scale)"
-        " parameter in the **map.i3d** file will be automatically adjusted.  \n"
-        "⚡ If the **Easy mode** option is disabled, you will probably get completely flat "
-        "terrain, unless you adjust the DEM Multiplier Setting or the Height scale parameter in "
-        "the Giants Editor.  \n"
-        "💡 You can use the **Power factor** setting to make the difference between heights "
-        "bigger. Be extremely careful with this setting, and use only low values, otherwise your "
-        "terrain may be completely broken.  \n"
-    )
+    _base_instructions = None
 
     # pylint: disable=R0913, R0917
     def __init__(
@@ -304,64 +288,8 @@ class DTMProvider(ABC):
         # extract region of interest from the tile
         data = self.extract_roi(tile)
 
-        # process elevation data to be compatible with the game
-        data = self.process_elevation(data)
-
         return data
 
-    def process_elevation(self, data: np.ndarray) -> np.ndarray:
-        """Process elevation data.
-
-        Arguments:
-            data (np.ndarray): Elevation data.
-
-        Returns:
-            np.ndarray: Processed elevation data.
-        """
-        self.data_info = {}
-        self.add_numpy_params(data, "original")
-
-        data = self.ground_height_data(data)
-        self.add_numpy_params(data, "grounded")
-
-        original_deviation = int(self.data_info["original_deviation"])
-        in_game_maximum_height = 65535 // 255
-        if original_deviation > in_game_maximum_height:
-            suggested_height_scale_multiplier = (
-                original_deviation / in_game_maximum_height  # type: ignore
-            )
-            suggested_height_scale_value = int(255 * suggested_height_scale_multiplier)
-        else:
-            suggested_height_scale_multiplier = 1
-            suggested_height_scale_value = 255
-
-        self.data_info["suggested_height_scale_multiplier"] = suggested_height_scale_multiplier
-        self.data_info["suggested_height_scale_value"] = suggested_height_scale_value
-
-        self.map.shared_settings.height_scale_multiplier = (  # type: ignore
-            suggested_height_scale_multiplier
-        )
-        self.map.shared_settings.height_scale_value = suggested_height_scale_value  # type: ignore
-
-        if self.user_settings.easy_mode:  # type: ignore
-            try:
-                data = self.normalize_dem(data)
-                self.add_numpy_params(data, "normalized")
-
-                normalized_deviation = self.data_info["normalized_deviation"]
-                z_scaling_factor = normalized_deviation / original_deviation  # type: ignore
-                self.data_info["z_scaling_factor"] = z_scaling_factor
-
-                self.map.shared_settings.mesh_z_scaling_factor = z_scaling_factor  # type: ignore
-                self.map.shared_settings.change_height_scale = True  # type: ignore
-
-            except Exception as e:  # pylint: disable=W0718
-                self.logger.error(
-                    "Failed to normalize DEM data. Error: %s. Using original data.", e
-                )
-
-        return data.astype(np.uint16)
-
     def info_sequence(self) -> dict[str, int | str | float] | None:
         """Returns the information sequence for the component. Must be implemented in the child
         class. If the component does not have an information sequence, an empty dictionary must be
@@ -414,6 +342,7 @@ class DTMProvider(ABC):
             desc="Downloading tiles",
             unit="tile",
             initial=len(tif_files),
+            total=len(urls),
         ):
             try:
                 file_name = os.path.basename(url)
@@ -570,84 +499,4 @@ class DTMProvider(ABC):
 
         return data
 
-    def normalize_dem(self, data: np.ndarray) -> np.ndarray:
-        """Normalize DEM data to 16-bit unsigned integer using max height from settings.
-
-        Arguments:
-            data (np.ndarray): DEM data from SRTM file after cropping.
-
-        Returns:
-            np.ndarray: Normalized DEM data.
-        """
-        maximum_height = int(data.max())
-        minimum_height = int(data.min())
-        deviation = maximum_height - minimum_height
-        self.logger.debug(
-            "Maximum height: %s. Minimum height: %s. Deviation: %s.",
-            maximum_height,
-            minimum_height,
-            deviation,
-        )
-        self.logger.debug("Number of unique values in original DEM data: %s.", np.unique(data).size)
-
-        adjusted_maximum_height = maximum_height * 255
-        adjusted_maximum_height = min(adjusted_maximum_height, 65535)
-        scaling_factor = adjusted_maximum_height / maximum_height
-        self.logger.debug(
-            "Adjusted maximum height: %s. Scaling factor: %s.",
-            adjusted_maximum_height,
-            scaling_factor,
-        )
-
-        if self.user_settings.power_factor:  # type: ignore
-            power_factor = 1 + self.user_settings.power_factor / 10  # type: ignore
-            self.logger.debug(
-                "Applying power factor: %s to the DEM data.",
-                power_factor,
-            )
-            data = np.power(data, power_factor)
-
-        normalized_data = np.round(data * scaling_factor).astype(np.uint16)
-        self.logger.debug(
-            "Normalized data maximum height: %s. Minimum height: %s. Number of unique values: %s.",
-            normalized_data.max(),
-            normalized_data.min(),
-            np.unique(normalized_data).size,
-        )
-        return normalized_data
-
-    @staticmethod
-    def ground_height_data(data: np.ndarray, add_one: bool = True) -> np.ndarray:
-        """Shift the data to ground level (0 meter).
-        Optionally add one meter to the data to leave some room
-        for the water level and pit modifications.
-
-        Arguments:
-            data (np.ndarray): DEM data after cropping.
-            add_one (bool): Add one meter to the data
-
-        Returns:
-            np.ndarray: Unsigned DEM data.
-        """
-        data = data - data.min()
-        if add_one:
-            data = data + 1
-        return data
-
-    def add_numpy_params(
-        self,
-        data: np.ndarray,
-        prefix: str,
-    ) -> None:
-        """Add numpy array parameters to the data_info dictionary.
-
-        Arguments:
-            data (np.ndarray): Numpy array of the tile.
-            prefix (str): Prefix for the parameters.
-        """
-        self.data_info[f"{prefix}_minimum_height"] = int(data.min())  # type: ignore
-        self.data_info[f"{prefix}_maximum_height"] = int(data.max())  # type: ignore
-        self.data_info[f"{prefix}_deviation"] = int(data.max() - data.min())  # type: ignore
-        self.data_info[f"{prefix}_unique_values"] = int(np.unique(data).size)  # type: ignore
-
     # endregion

maps4fs/generator/dtm/srtm.py

@@ -31,6 +31,8 @@ class SRTM30Provider(DTMProvider):
 
     _settings = SRTM30ProviderSettings
 
+    _instructions = "ℹ️ Recommended settings:  \nDEM Settings -> Blur Radius: **35**"
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.hgt_directory = os.path.join(self._tile_directory, "hgt")

maps4fs/generator/settings.py

@@ -102,18 +102,22 @@ class DEMSettings(SettingsModel):
     """Represents the advanced settings for DEM component.
 
     Attributes:
-        multiplier (int): multiplier for the heightmap, every pixel will be multiplied by this
-            value.
+        adjust_terrain_to_ground_level (bool): adjust terrain to ground level or not.
+        multiplier (int): multiplier for the heightmap.
         blur_radius (int): radius of the blur filter.
-        plateau (int): plateau height, will be added to each pixel.
-        water_depth (int): water depth, will be subtracted from each pixel where the water
-            is present.
+        minimum_height_scale (int): minimum height scale for the i3d.
+        plateau (int): plateau height.
+        ceiling (int): ceiling height.
+        water_depth (int): water depth.
     """
 
+    adjust_terrain_to_ground_level: bool = True
     multiplier: int = 1
-    blur_radius: int = 35
+    minimum_height_scale: int = 255
     plateau: int = 0
+    ceiling: int = 0
     water_depth: int = 0
+    blur_radius: int = 3
 
 
 class BackgroundSettings(SettingsModel):
@@ -129,7 +133,7 @@ class BackgroundSettings(SettingsModel):
     generate_background: bool = False
     generate_water: bool = False
     resize_factor: int = 8
-    remove_center: bool = False
+    remove_center: bool = True
     apply_decimation: bool = False
     decimation_percent: int = 25
     decimation_agression: int = 3

{maps4fs-1.8.171.dist-info → maps4fs-1.8.173.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: maps4fs
-Version: 1.8.171
+Version: 1.8.173
 Summary: Generate map templates for Farming Simulator from real places.
 Author-email: iwatkot <iwatkot@gmail.com>
 License: MIT License
@@ -562,13 +562,17 @@ You can also apply some advanced settings to the map generation process.<br>
 
 ### DEM Advanced settings
 
-- Multiplier: the height of the map is multiplied by this value. So the DEM map is just a 16-bit grayscale image, which means that the maximum available value there is 65535, while the actual difference between the deepest and the highest point on Earth is about 20 km. Just note that this setting mostly does not matter, because you can always adjust it in the Giants Editor, learn more about the DEM file and the heightScale parameter in [docs](docs/dem.md). To match the in-game heights with SRTM Data provider, the recommended value is 255 (if easy mode is disabled), but depending on the place, you will need to play with both multiplier and the height scale in Giants Editor to find the best values.
+- Adjust terrain to ground level: Enabling this setting (default) will raise or lower the terrain so that it's lowest point is at ground level (taking into account the plateau and water depth settings).
 
-- Blur radius: the radius of the Gaussian blur filter applied to the DEM map. By default, it's set to 21. This filter just makes the DEM map smoother, so the height transitions will be more natural. You can set it to 1 to disable the filter, but it will result in a Minecraft-like map.
+- Multiplier: DEM multiplier can be used to make the terrain more pronounced. By default the DEM file will be exact copy of the real terrain. If you want to make it more steep, you can increase this value. The recommended value of the multiplier is 1.
 
-- Plateau: this value will be added to each pixel of the DEM image, making it "higher". It's useful when you want to add some negative heights on the map, that appear to be in a "low" place. By default, it's set to 0.
+- Minimum height scale: This value is used as the heightScale in your map i3d. It will automatically be set higher if the elevation in your map (plus plateau, ceiling and water depth) is higher than this value.
 
-- Water depth: this value will be subtracted from each pixel of the DEM image, where water resources are located. Pay attention that it's not in meters, instead it in the pixel value of DEM, which is 16 bit image with possible values from 0 to 65535. When this value is set, the same value will be added to the plateau setting to avoid negative heights.
+- Plateau: DEM plateau value (in meters) is used to make the whole map higher or lower. This value will be added to each pixel of the DEM image, making it higher. It can be useful if you're working on a plain area and need to add some negative height (to make rivers, for example).
+
+- Ceiling: DEM ceiling value (in meters) is used to add padding in the DEM above the highest elevation in your map area. It can be useful if you plan to manually add some height to the map by sculpting the terrain in GE.
+
+- Water depth: Water depth value (in meters) will be subtracted from the DEM image, making the water deeper. The pixel value used for this is calculated based on the heightScale value for your map.
 
 ### Background terrain Advanced settings
 
@@ -578,7 +582,7 @@ You can also apply some advanced settings to the map generation process.<br>
 
 - Resize factor - the factor by which the background terrain will be resized. It will be used as 1 / resize_factor while generating the models. Which means that the larger the value the more the terrain will be resized. The lowest value is 1, in this case background terrain will not be resized. Note, than low values will lead to long processing and enormous size of the obj files.
 
-- Remove center - if enabled, the playable region (map terrain) will be removed from the background terrain. Note, that it will require low resize factors, to avoid gaps between the map and the background terrain.
+- Remove center - if enabled, the playable region (map terrain) will be removed from the background terrain. By default, it's set to True.
 
 - Apply decimation - if enabled, the mesh will be simplified to reduce the number of faces.
 
@@ -703,4 +707,3 @@ But also, I want to thank the people who helped me with the project in some way,
 - [kbrandwijk](https://github.com/kbrandwijk) - for providing [awesome tool](https://github.com/Paint-a-Farm/satmap_downloader) to download the satellite images from the Google Maps and giving a permission to modify it and create a Python Package.
 - [Maaslandmods](https://github.com/Maaslandmods) - for the awesome idea to edit the tree schema in UI, images and code snippets on how to do it.
 - [StrauntMaunt](https://gitlab.com/StrauntMaunt) - for developing procedural generation scripts, providing with the required updates for maps4fs and preparing the docs on how to use procedural generation.
-

{maps4fs-1.8.171.dist-info → maps4fs-1.8.173.dist-info}/RECORD

@@ -1,27 +1,27 @@
 maps4fs/__init__.py,sha256=iq4GcHoQ-by-BK6CzDOfVcdDww6osyi9Wv6pKXub68U,1307
 maps4fs/logger.py,sha256=B-NEYpMjPAAqlV4VpfTi6nbBFnEABVtQOaYe6nMpidg,1489
 maps4fs/generator/__init__.py,sha256=zZMLEkGzb4z0xql650gOtGSvcgX58DnJ2yN3vC2daRk,43
-maps4fs/generator/dem.py,sha256=RsIaL3LabYnZzow2fzmccsnzBo0m1YjcVVxUkJJGJMU,10735
+maps4fs/generator/dem.py,sha256=oLN02bWNax73HzFsseRBOV47Azl_1L7qdrzuxHh4i_c,11886
 maps4fs/generator/game.py,sha256=YwtdzqwcBJm1FHtc1ehDd3WbfTTW_gBvxK-pzfU48zs,11015
 maps4fs/generator/map.py,sha256=c5GMhr5iTRdXvTXoBKyVYa2V1tocR3ZCc7D_hpU21k8,11523
 maps4fs/generator/qgis.py,sha256=Es8hLuqN_KH8lDfnJE6He2rWYbAKJ3RGPn-o87S6CPI,6116
 maps4fs/generator/satellite.py,sha256=t33EfaxWTCjcKYnqoppSlFdQQSekiBe7UFmLgTVhFQI,3650
-maps4fs/generator/settings.py,sha256=psZC3k95roptV6-YQMDz9ofoKw5dBNc1TZ66DEECmSc,6134
+maps4fs/generator/settings.py,sha256=cFlN-gK8QcySqyPtcGm-2fLnxQnlmC3Y9kQufJxwI3Y,6270
 maps4fs/generator/texture.py,sha256=_IfqIuxH4934VJXKtdABHa6ToPWk3T0xknvlu-rZ5Uc,36570
 maps4fs/generator/component/__init__.py,sha256=zZMLEkGzb4z0xql650gOtGSvcgX58DnJ2yN3vC2daRk,43
-maps4fs/generator/component/background.py,sha256=pN1iMXm5Xg87OWh4XFml4bVIrueTJMdwVJvS3YWm0x0,18588
+maps4fs/generator/component/background.py,sha256=cBBp-ULrJzuNG9wfE_MaxzAn_mR24neqtL7WjxXEb3I,18749
 maps4fs/generator/component/config.py,sha256=RitKgFDZPzjA1fi8GcEi1na75qqaueUvpcITHjBvCXc,3674
 maps4fs/generator/component/grle.py,sha256=aKMjVJNuKHJJ2gsXaH00bz10kWaIbbZXU_JbP-ZAGw4,18990
 maps4fs/generator/component/i3d.py,sha256=3x38yL-kSJ8ylBwICBb6wPYzRSky4gVj8XCk2jzYSeo,19861
 maps4fs/generator/component/base/__init__.py,sha256=zZMLEkGzb4z0xql650gOtGSvcgX58DnJ2yN3vC2daRk,43
 maps4fs/generator/component/base/component.py,sha256=U3XJae0GUvHN08psv2j24Y4PBAAytSkSK3AmD-VjjXE,21404
 maps4fs/generator/component/base/component_image.py,sha256=vuiiJqsrKZgYsnK8Qa5yL2Pejqa6nJSTtXNAcBPL29c,3099
-maps4fs/generator/component/base/component_mesh.py,sha256=-9kmMX5KUULAIScygcrzmq8Cg643hiZ2IfSZOKiFfRs,4634
+maps4fs/generator/component/base/component_mesh.py,sha256=jtsEQZkqiCkycYpueq1M1eqgxdShL_bHaJT6Upu8PLI,8412
 maps4fs/generator/component/base/component_xml.py,sha256=6OO1dKoceO1ACk7-k1oGtnkfNud8ZN3u3ZNjdNMpTqw,3967
 maps4fs/generator/dtm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 maps4fs/generator/dtm/bavaria.py,sha256=7njrEvSCYAC8ZVyvS-_84iXHhWA0oHKrEqSzxdnZuGs,4293
 maps4fs/generator/dtm/canada.py,sha256=lYONwm6aNX5cjVggR3AiZZF9dlCDAWg0M8RMaObog8s,1288
-maps4fs/generator/dtm/dtm.py,sha256=Bu6-wHH2MXxLmfSEz_LYjfRdXmzsvnTBs18qHgdta0E,23191
+maps4fs/generator/dtm/dtm.py,sha256=L824mwmd_cNTujwWBsRg7RZLq9KEXf0-xIzKx8M3y1Q,16872
 maps4fs/generator/dtm/england.py,sha256=YyCYwnNUJuBeeMNUozfKIj_yNjHpGeuH1Mz0NiAJL-U,1122
 maps4fs/generator/dtm/finland.py,sha256=Chi3-3sanLIYpipjtPpTu9tqnL3DYcnygSDCPm1s24c,1753
 maps4fs/generator/dtm/flanders.py,sha256=81pKkrM40SeOe1LSlcsTNXSmUNpofC4D454DG6WFSyA,1037
@@ -33,7 +33,7 @@ maps4fs/generator/dtm/norway.py,sha256=kSsNZGEqb3IQ3a82UCJ_Iw_0wqdCgEvuRJ4JpEK7Q
 maps4fs/generator/dtm/nrw.py,sha256=1zMa10O0NdQbiTwOa7XXGrx3NhdHUqRXI4yBn_Scb2M,958
 maps4fs/generator/dtm/scotland.py,sha256=Od4dDMuCM_iteewjGBbmZXJ26S0bDwrhRhXeV4HyyOA,4803
 maps4fs/generator/dtm/spain.py,sha256=HxN0MvrtRqqeTmhl47q60-1DGaMDb2wq6neMcDlDCl8,1005
-maps4fs/generator/dtm/srtm.py,sha256=abggmxrR1rC22llkJ6kFle9MYLqP-raMc76O9qm6qag,4411
+maps4fs/generator/dtm/srtm.py,sha256=ob6AUuEn3G3G9kdqTA2VhT335N65RRBJsqAfHuw0gA8,4502
 maps4fs/generator/dtm/usgs.py,sha256=1XzLP5GJbe6xcqzkOrEBUtR2SPw7gm6rl1nw5YXmBP8,3253
 maps4fs/generator/dtm/utils.py,sha256=I-wUSA_J85Xbt8sZCZAVKHSIcrMj5Ng-0adtPVhVmk0,2315
 maps4fs/generator/dtm/base/wcs.py,sha256=UfkLNHqsYTr2ytjyZjWDocq2hFC_qyFCvl-_tnz6gHM,2510
@@ -42,8 +42,8 @@ maps4fs/toolbox/__init__.py,sha256=zZMLEkGzb4z0xql650gOtGSvcgX58DnJ2yN3vC2daRk,4
 maps4fs/toolbox/background.py,sha256=RclEqxEWLbMxuEkkegQP8jybzugwQ1_R3rdfDe0s21U,2104
 maps4fs/toolbox/custom_osm.py,sha256=X6ZlPqiOhNjkmdD_qVroIfdOl9Rb90cDwVSLDVYgx80,1892
 maps4fs/toolbox/dem.py,sha256=z9IPFNmYbjiigb3t02ZenI3Mo8odd19c5MZbjDEovTo,3525
-maps4fs-1.8.171.dist-info/LICENSE.md,sha256=pTKD_oUexcn-yccFCTrMeLkZy0ifLRa-VNcDLqLZaIw,10749
-maps4fs-1.8.171.dist-info/METADATA,sha256=-tS0TohOL4AcCk2sVK_XYAXWvKndrwtczFPm888wUic,43208
-maps4fs-1.8.171.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-maps4fs-1.8.171.dist-info/top_level.txt,sha256=Ue9DSRlejRQRCaJueB0uLcKrWwsEq9zezfv5dI5mV1M,8
-maps4fs-1.8.171.dist-info/RECORD,,
+maps4fs-1.8.173.dist-info/LICENSE.md,sha256=pTKD_oUexcn-yccFCTrMeLkZy0ifLRa-VNcDLqLZaIw,10749
+maps4fs-1.8.173.dist-info/METADATA,sha256=juPm5cwfn3XLlaUemJjP43yHQbW-9NYEljrHscMlGN4,42937
+maps4fs-1.8.173.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+maps4fs-1.8.173.dist-info/top_level.txt,sha256=Ue9DSRlejRQRCaJueB0uLcKrWwsEq9zezfv5dI5mV1M,8
+maps4fs-1.8.173.dist-info/RECORD,,