maps4fs 1.0.9__py3-none-any.whl → 1.1.1__py3-none-any.whl

maps4fs/generator/background.py

@@ -15,87 +15,92 @@ from maps4fs.generator.dem import (
     DEFAULT_BLUR_RADIUS,
     DEFAULT_MULTIPLIER,
     DEFAULT_PLATEAU,
+    DEM,
 )
-from maps4fs.generator.path_steps import (
-    PATH_FULL_NAME,
-    PATH_FULL_PREVIEW_NAME,
-    get_steps,
-)
-from maps4fs.generator.tile import Tile
 
-RESIZE_FACTOR = 1 / 4
-FULL_RESIZE_FACTOR = 1 / 8
+DEFAULT_DISTANCE = 2048
+RESIZE_FACTOR = 1 / 8
+FULL_NAME = "FULL"
+FULL_PREVIEW_NAME = "PREVIEW"
+ELEMENTS = [FULL_NAME, FULL_PREVIEW_NAME]
 
 
 class Background(Component):
     """Component for creating 3D obj files based on DEM data around the map.
 
     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_height (int): The height of the map in pixels.
-        map_width (int): The width of the map in pixels.
+        map_size (int): The size of the map in pixels (it's a square).
+        rotated_map_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.
     """
 
+    # pylint: disable=R0801
     def preprocess(self) -> None:
-        """Prepares the component for processing. Registers the tiles around the map by moving
-        clockwise from North, then clockwise."""
-        self.tiles: list[Tile] = []
-        origin = self.coordinates
-
-        only_full_tiles = self.kwargs.get("only_full_tiles", True)
+        """Registers the DEMs for the background terrain."""
         self.light_version = self.kwargs.get("light_version", False)
+        self.stl_preview_path: str | None = None
 
-        # Getting a list of 8 tiles around the map starting from the N(North) tile.
-        for path_step in get_steps(self.map_height, self.map_width, only_full_tiles):
-            # Getting the destination coordinates for the current tile.
-            if path_step.angle is None:
-                # For the case when generating the overview map, which has the same
-                # center as the main map.
-                tile_coordinates = self.coordinates
-            else:
-                tile_coordinates = path_step.get_destination(origin)
-
-            if path_step.code == PATH_FULL_PREVIEW_NAME:
-                auto_process = False
-            else:
-                auto_process = self.kwargs.get("auto_process", False)
-
-            # Create a Tile component, which is needed to save the DEM image.
-            tile = Tile(
-                game=self.game,
-                coordinates=tile_coordinates,
-                map_height=path_step.size[1],
-                map_width=path_step.size[0],
-                map_directory=self.map_directory,
-                logger=self.logger,
-                tile_code=path_step.code,
-                auto_process=auto_process,
+        if self.rotation:
+            self.logger.debug("Rotation is enabled: %s.", self.rotation)
+            output_size_multiplier = 1.5
+        else:
+            output_size_multiplier = 1
+
+        background_size = self.map_size + DEFAULT_DISTANCE * 2
+        rotated_size = int(background_size * output_size_multiplier)
+
+        self.background_directory = os.path.join(self.map_directory, "background")
+        os.makedirs(self.background_directory, exist_ok=True)
+
+        autoprocesses = [self.kwargs.get("auto_process", False), False]
+        dems = []
+
+        for name, autoprocess in zip(ELEMENTS, autoprocesses):
+            dem = DEM(
+                self.game,
+                self.coordinates,
+                background_size,
+                rotated_size,
+                self.rotation,
+                self.map_directory,
+                self.logger,
+                auto_process=autoprocess,
                 blur_radius=self.kwargs.get("blur_radius", DEFAULT_BLUR_RADIUS),
                 multiplier=self.kwargs.get("multiplier", DEFAULT_MULTIPLIER),
                 plateau=self.kwargs.get("plateau", DEFAULT_PLATEAU),
             )
+            dem.preprocess()
+            dem.is_preview = self.is_preview(name)  # type: ignore
+            dem.set_output_resolution((rotated_size, rotated_size))
+            dem.set_dem_path(os.path.join(self.background_directory, f"{name}.png"))
+            dems.append(dem)
 
-            # Update the origin for the next tile.
-            origin = tile_coordinates
-            self.tiles.append(tile)
-            self.logger.debug(
-                "Registered tile: %s, coordinates: %s, size: %s",
-                tile.code,
-                tile_coordinates,
-                path_step.size,
-            )
+        self.dems = dems
+
+    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
         generated."""
-        for tile in self.tiles:
-            tile.process()
-            if tile.code == PATH_FULL_NAME:
-                cutted_dem_path = self.cutout(tile.dem_path)
+        for dem in self.dems:
+            dem.process()
+            if not dem.is_preview:  # type: ignore
+                cutted_dem_path = self.cutout(dem.dem_path)
                 if self.game.additional_dem_name is not None:
                     self.make_copy(cutted_dem_path, self.game.additional_dem_name)
 
@@ -118,71 +123,64 @@ class Background(Component):
         shutil.copyfile(dem_path, additional_dem_path)
         self.logger.info("Additional DEM data was copied to %s.", additional_dem_path)
 
-    def info_sequence(self) -> dict[str, dict[str, str | float | int]]:
-        """Returns a dictionary with information about the tiles around the map.
+    def info_sequence(self) -> dict[str, str | float | int]:
+        """Returns a dictionary with information about the background terrain.
         Adds the EPSG:3857 string to the data for convenient usage in QGIS.
 
         Returns:
-            dict[str, dict[str, float | int]] -- A dictionary with information about the tiles.
+            dict[str, str, float | int] -- A dictionary with information about the background
+                terrain.
         """
-        data = {}
         self.qgis_sequence()
 
-        for tile in self.tiles:
-            north, south, east, west = tile.bbox
-            epsg3857_string = tile.get_epsg3857_string()
-            epsg3857_string_with_margin = tile.get_epsg3857_string(add_margin=True)
-
-            tile_entry = {
-                "center_latitude": tile.coordinates[0],
-                "center_longitude": tile.coordinates[1],
-                "epsg3857_string": epsg3857_string,
-                "epsg3857_string_with_margin": epsg3857_string_with_margin,
-                "height": tile.map_height,
-                "width": tile.map_width,
-                "north": north,
-                "south": south,
-                "east": east,
-                "west": west,
-            }
-            if tile.code is not None:
-                data[tile.code] = tile_entry
-
+        dem = self.dems[0]
+
+        north, south, east, west = dem.bbox
+        epsg3857_string = dem.get_epsg3857_string()
+        epsg3857_string_with_margin = dem.get_epsg3857_string(add_margin=True)
+
+        data = {
+            "center_latitude": dem.coordinates[0],
+            "center_longitude": dem.coordinates[1],
+            "epsg3857_string": epsg3857_string,
+            "epsg3857_string_with_margin": epsg3857_string_with_margin,
+            "height": dem.map_size,
+            "width": dem.map_size,
+            "north": north,
+            "south": south,
+            "east": east,
+            "west": west,
+        }
         return data  # type: ignore
 
     def qgis_sequence(self) -> None:
         """Generates QGIS scripts for creating bounding box layers and rasterizing them."""
-        qgis_layers = [
-            (f"Background_{tile.code}", *tile.get_espg3857_bbox()) for tile in self.tiles
-        ]
-        qgis_layers_with_margin = [
-            (f"Background_{tile.code}_margin", *tile.get_espg3857_bbox(add_margin=True))
-            for tile in self.tiles
-        ]
-
-        layers = qgis_layers + qgis_layers_with_margin
-
-        self.create_qgis_scripts(layers)
+        qgis_layer = (f"Background_{FULL_NAME}", *self.dems[0].get_espg3857_bbox())
+        qgis_layer_with_margin = (
+            f"Background_{FULL_NAME}_margin",
+            *self.dems[0].get_espg3857_bbox(add_margin=True),
+        )
+        self.create_qgis_scripts([qgis_layer, qgis_layer_with_margin])
 
     def generate_obj_files(self) -> None:
-        """Iterates over all tiles and generates 3D obj files based on DEM data.
+        """Iterates over all dems and generates 3D obj files based on DEM data.
         If at least one DEM file is missing, the generation will be stopped at all.
         """
-        for tile in self.tiles:
-            # Read DEM data from the tile.
-            dem_path = tile.dem_path
-            if not os.path.isfile(dem_path):
-                self.logger.warning("DEM file not found, generation will be stopped: %s", dem_path)
+        for dem in self.dems:
+            if not os.path.isfile(dem.dem_path):
+                self.logger.warning(
+                    "DEM file not found, generation will be stopped: %s", dem.dem_path
+                )
                 return
 
-            self.logger.debug("DEM file for tile %s found: %s", tile.code, dem_path)
+            self.logger.debug("DEM file for found: %s", dem.dem_path)
 
-            base_directory = os.path.dirname(dem_path)
-            save_path = os.path.join(base_directory, f"{tile.code}.obj")
-            self.logger.debug("Generating obj file for tile %s in path: %s", tile.code, save_path)
+            filename = os.path.splitext(os.path.basename(dem.dem_path))[0]
+            save_path = os.path.join(self.background_directory, f"{filename}.obj")
+            self.logger.debug("Generating obj file in path: %s", save_path)
 
-            dem_data = cv2.imread(tile.dem_path, cv2.IMREAD_UNCHANGED)  # pylint: disable=no-member
-            self.plane_from_np(tile.code, dem_data, save_path)  # type: ignore
+            dem_data = cv2.imread(dem.dem_path, cv2.IMREAD_UNCHANGED)  # pylint: disable=no-member
+            self.plane_from_np(dem_data, save_path, is_preview=dem.is_preview)  # type: ignore
 
     # pylint: disable=too-many-locals
     def cutout(self, dem_path: str) -> str:
@@ -197,17 +195,16 @@ class Background(Component):
         dem_data = cv2.imread(dem_path, cv2.IMREAD_UNCHANGED)  # pylint: disable=no-member
 
         center = (dem_data.shape[0] // 2, dem_data.shape[1] // 2)
-        half_size = self.map_height // 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]
 
-        output_size = self.map_height + 1
+        output_size = self.map_size + 1
 
         main_dem_path = self.game.dem_file_path(self.map_directory)
-        dem_directory = os.path.dirname(main_dem_path)
 
         try:
             os.remove(main_dem_path)
@@ -219,46 +216,25 @@ class Background(Component):
             dem_data, (output_size, output_size), interpolation=cv2.INTER_LINEAR
         )
 
-        # Giant Editor contains a bug for large maps, where the DEM should not match
-        # the UnitsPerPixel value. For example, for map 8192x8192, without bug
-        # the DEM image should be 8193x8193, but it does not work, so we need to
-        # resize the DEM to 4097x4097.
-        if self.map_height > 4096:
-            correct_dem_path = os.path.join(dem_directory, "correct_dem.png")
-            save_path = correct_dem_path
-
-            output_size = self.map_height // 2 + 1
-            bugged_dem_data = cv2.resize(
-                dem_data, (output_size, output_size), interpolation=cv2.INTER_LINEAR
-            )
-            # pylint: disable=no-member
-            cv2.imwrite(main_dem_path, bugged_dem_data)
-        else:
-            save_path = main_dem_path
-
-        cv2.imwrite(save_path, resized_dem_data)  # pylint: disable=no-member
-        self.logger.info("DEM cutout saved: %s", save_path)
+        cv2.imwrite(main_dem_path, resized_dem_data)  # pylint: disable=no-member
+        self.logger.info("DEM cutout saved: %s", main_dem_path)
 
-        return save_path
+        return main_dem_path
 
     # pylint: disable=too-many-locals
-    def plane_from_np(self, tile_code: str, dem_data: np.ndarray, save_path: str) -> None:
+    def plane_from_np(self, dem_data: np.ndarray, save_path: str, is_preview: bool = False) -> None:
         """Generates a 3D obj file based on DEM data.
 
         Arguments:
-            tile_code (str) -- The code of the tile.
             dem_data (np.ndarray) -- The DEM data as a numpy array.
             save_path (str) -- The path where the obj file will be saved.
+            is_preview (bool, optional) -- If True, the preview mesh will be generated.
         """
-        if tile_code == PATH_FULL_NAME:
-            resize_factor = FULL_RESIZE_FACTOR
-        else:
-            resize_factor = RESIZE_FACTOR
         dem_data = cv2.resize(  # pylint: disable=no-member
-            dem_data, (0, 0), fx=resize_factor, fy=resize_factor
+            dem_data, (0, 0), fx=RESIZE_FACTOR, fy=RESIZE_FACTOR
         )
         self.logger.debug(
-            "DEM data resized to shape: %s with factor: %s", dem_data.shape, resize_factor
+            "DEM data resized to shape: %s with factor: %s", dem_data.shape, RESIZE_FACTOR
         )
 
         # Invert the height values.
@@ -271,9 +247,7 @@ class Background(Component):
         z = dem_data
 
         self.logger.debug(
-            "Starting to generate a mesh for tile %s with shape: %s x %s. "
-            "This may take a while...",
-            tile_code,
+            "Starting to generate a mesh for with shape: %s x %s. This may take a while...",
             cols,
             rows,
         )
@@ -300,7 +274,7 @@ class Background(Component):
         mesh.apply_transform(rotation_matrix_y)
         mesh.apply_transform(rotation_matrix_z)
 
-        if tile_code == PATH_FULL_PREVIEW_NAME:
+        if is_preview:
             # Simplify the preview mesh to reduce the size of the file.
             mesh = mesh.simplify_quadric_decimation(face_count=len(mesh.faces) // 2**7)
 
@@ -314,7 +288,7 @@ class Background(Component):
             else:
                 z_scaling_factor = 1 / 2**5
             self.logger.debug("Z scaling factor: %s", z_scaling_factor)
-            mesh.apply_scale([1 / resize_factor, 1 / resize_factor, z_scaling_factor])
+            mesh.apply_scale([1 / RESIZE_FACTOR, 1 / RESIZE_FACTOR, z_scaling_factor])
 
         mesh.export(save_path)
         self.logger.debug("Obj file saved: %s", save_path)
@@ -336,19 +310,105 @@ class Background(Component):
 
     # pylint: disable=no-member
     def previews(self) -> list[str]:
-        """Returns the path to the image of full tile and the path to the STL preview file.
+        """Returns the path to the image previews paths and the path to the STL preview file.
 
         Returns:
             list[str] -- A list of paths to the previews.
         """
-        full_tile = next((tile for tile in self.tiles if tile.code == PATH_FULL_NAME), None)
-        if full_tile:
-            preview_path = os.path.join(self.previews_directory, "background_dem.png")
-            full_tile_image = cv2.imread(full_tile.dem_path, cv2.IMREAD_UNCHANGED)
-            full_tile_image = cv2.normalize(  # type: ignore
-                full_tile_image, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U
-            )
-            full_tile_image = cv2.cvtColor(full_tile_image, cv2.COLOR_GRAY2BGR)
-            cv2.imwrite(preview_path, full_tile_image)
-            return [preview_path, self.stl_preview_path]
-        return [self.stl_preview_path]
+        preview_paths = self.dem_previews(self.game.dem_file_path(self.map_directory))
+        for dem in self.dems:
+            if dem.is_preview:  # type: ignore
+                background_dem_preview_path = os.path.join(
+                    self.previews_directory, "background_dem.png"
+                )
+                background_dem_preview_image = cv2.imread(dem.dem_path, cv2.IMREAD_UNCHANGED)
+
+                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.cvtColor(
+                    background_dem_preview_image, cv2.COLOR_GRAY2BGR
+                )
+
+                cv2.imwrite(background_dem_preview_path, background_dem_preview_image)
+                preview_paths.append(background_dem_preview_path)
+
+        if self.stl_preview_path:
+            preview_paths.append(self.stl_preview_path)
+
+        return preview_paths
+
+    def dem_previews(self, image_path: str) -> list[str]:
+        """Get list of preview images.
+
+        Arguments:
+            image_path (str): Path to the DEM file.
+
+        Returns:
+            list[str]: List of preview images.
+        """
+        self.logger.debug("Starting DEM previews generation.")
+        return [self.grayscale_preview(image_path), self.colored_preview(image_path)]
+
+    def grayscale_preview(self, image_path: str) -> str:
+        """Converts DEM image to grayscale RGB image and saves it to the map directory.
+        Returns path to the preview image.
+
+        Arguments:
+            image_path (str): Path to the DEM file.
+
+        Returns:
+            str: Path to the preview image.
+        """
+        grayscale_dem_path = os.path.join(self.previews_directory, "dem_grayscale.png")
+
+        self.logger.debug("Creating grayscale preview of DEM data in %s.", grayscale_dem_path)
+
+        dem_data = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)
+        dem_data_rgb = cv2.cvtColor(dem_data, cv2.COLOR_GRAY2RGB)
+        cv2.imwrite(grayscale_dem_path, dem_data_rgb)
+        return grayscale_dem_path
+
+    def colored_preview(self, image_path: str) -> str:
+        """Converts DEM image to colored RGB image and saves it to the map directory.
+        Returns path to the preview image.
+
+        Arguments:
+            image_path (str): Path to the DEM file.
+
+        Returns:
+            list[str]: List with a single path to the DEM file
+        """
+        colored_dem_path = os.path.join(self.previews_directory, "dem_colored.png")
+
+        self.logger.debug("Creating colored preview of DEM data in %s.", colored_dem_path)
+
+        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)
+        return colored_dem_path