maps4fs 1.5.0__py3-none-any.whl → 1.6.91__py3-none-any.whl

maps4fs/generator/grle.py

@@ -10,13 +10,26 @@ import numpy as np
 from shapely.geometry import Polygon  # type: ignore
 
 from maps4fs.generator.component import Component
-from maps4fs.generator.texture import Texture
+from maps4fs.generator.texture import PREVIEW_MAXIMUM_SIZE, Texture
 
-ISLAND_SIZE_MIN = 10
-ISLAND_SIZE_MAX = 200
 ISLAND_DISTORTION = 0.3
-ISLAND_VERTEX_COUNT = 30
-ISLAND_ROUNDING_RADIUS = 15
+
+
+def plant_to_pixel_value(plant_name: str) -> int | None:
+    """Returns the pixel value representation of the plant.
+    If not found, returns None.
+
+    Arguments:
+        plant_name (str): name of the plant
+
+    Returns:
+        int | None: pixel value of the plant or None if not found.
+    """
+    plants = {
+        "smallDenseMix": 33,
+        "meadow": 131,
+    }
+    return plants.get(plant_name)
 
 
 # pylint: disable=W0223
@@ -39,6 +52,7 @@ class GRLE(Component):
     def preprocess(self) -> None:
         """Gets the path to the map I3D file from the game instance and saves it to the instance
         attribute. If the game does not support I3D files, the attribute is set to None."""
+        self.preview_paths: dict[str, str] = {}
 
         try:
             grle_schema_path = self.game.grle_schema
@@ -89,6 +103,7 @@ class GRLE(Component):
         else:
             self.logger.warning("Adding plants it's not supported for the %s.", self.game.code)
 
+    # pylint: disable=no-member
     def previews(self) -> list[str]:
         """Returns a list of paths to the preview images (empty list).
         The component does not generate any preview images so it returns an empty list.
@@ -96,7 +111,57 @@ class GRLE(Component):
         Returns:
             list[str]: An empty list.
         """
-        return []
+        preview_paths = []
+        for preview_name, preview_path in self.preview_paths.items():
+            save_path = os.path.join(self.previews_directory, f"{preview_name}.png")
+            # Resize the preview image to the maximum size allowed for previews.
+            image = cv2.imread(preview_path, cv2.IMREAD_GRAYSCALE)
+            if image.shape[0] > PREVIEW_MAXIMUM_SIZE or image.shape[1] > PREVIEW_MAXIMUM_SIZE:
+                image = cv2.resize(image, (PREVIEW_MAXIMUM_SIZE, PREVIEW_MAXIMUM_SIZE))
+            image_normalized = np.empty_like(image)
+            cv2.normalize(image, image_normalized, 0, 255, cv2.NORM_MINMAX)
+            image_colored = cv2.applyColorMap(image_normalized, cv2.COLORMAP_JET)
+            cv2.imwrite(save_path, image_colored)
+            preview_paths.append(save_path)
+
+            with_fields_save_path = os.path.join(
+                self.previews_directory, f"{preview_name}_with_fields.png"
+            )
+            image_with_fields = self.overlay_fields(image_colored)
+            if image_with_fields is None:
+                continue
+            cv2.imwrite(with_fields_save_path, image_with_fields)  # pylint: disable=no-member
+            preview_paths.append(with_fields_save_path)
+
+        return preview_paths
+
+    def overlay_fields(self, farmlands_np: np.ndarray) -> np.ndarray | None:
+        """Overlay fields on the farmlands preview image.
+
+        Arguments:
+            farmlands_np (np.ndarray): The farmlands preview image.
+
+        Returns:
+            np.ndarray | None: The farmlands preview image with fields overlayed on top of it.
+        """
+        texture_component: Texture | None = self.map.get_component("Texture")  # type: ignore
+        if not texture_component:
+            self.logger.warning("Texture component not found in the map.")
+            return None
+
+        fields_layer = texture_component.get_layer_by_usage("field")
+        fields_layer_path = fields_layer.get_preview_or_path(  # type: ignore
+            self.game.weights_dir_path(self.map_directory)
+        )
+        if not fields_layer_path or not os.path.isfile(fields_layer_path):
+            self.logger.warning("Fields layer not found in the texture component.")
+            return None
+        fields_np = cv2.imread(fields_layer_path)
+        # Resize fields_np to the same size as farmlands_np.
+        fields_np = cv2.resize(fields_np, (farmlands_np.shape[1], farmlands_np.shape[0]))
+
+        # use fields_np as base layer and overlay farmlands_np on top of it with 50% alpha blending.
+        return cv2.addWeighted(fields_np, 0.5, farmlands_np, 0.5, 0)
 
     # pylint: disable=R0801, R0914
     def _add_farmlands(self) -> None:
@@ -114,12 +179,12 @@ class GRLE(Component):
             self.logger.warning("Fields data not found in textures info layer.")
             return
 
-        self.logger.info("Found %s fields in textures info layer.", len(fields))
+        self.logger.debug("Found %s fields in textures info layer.", len(fields))
 
         farmyards: list[list[tuple[int, int]]] | None = textures_info_layer.get("farmyards")
         if farmyards and self.map.grle_settings.add_farmyards:
             fields.extend(farmyards)
-            self.logger.info("Found %s farmyards in textures info layer.", len(farmyards))
+            self.logger.debug("Found %s farmyards in textures info layer.", len(farmyards))
 
         info_layer_farmlands_path = os.path.join(
             self.game.weights_dir_path(self.map_directory), "infoLayer_farmlands.png"
@@ -155,7 +220,7 @@ class GRLE(Component):
                     angle=self.rotation,
                 )
             except ValueError as e:
-                self.logger.warning(
+                self.logger.debug(
                     "Farmland %s could not be fitted into the map bounds with error: %s",
                     farmland_id,
                     e,
@@ -180,7 +245,7 @@ class GRLE(Component):
             try:
                 cv2.fillPoly(image, [field_np], farmland_id)  # type: ignore
             except Exception as e:  # pylint: disable=W0718
-                self.logger.warning(
+                self.logger.debug(
                     "Farmland %s could not be added to the InfoLayer PNG file with error: %s",
                     farmland_id,
                     e,
@@ -204,6 +269,8 @@ class GRLE(Component):
             "Farmlands added to the InfoLayer PNG file: %s.", info_layer_farmlands_path
         )
 
+        self.preview_paths["farmlands"] = info_layer_farmlands_path  # type: ignore
+
     # pylint: disable=R0915
     def _add_plants(self) -> None:
         """Adds plants to the InfoLayer PNG file."""
@@ -270,10 +337,13 @@ class GRLE(Component):
             grass_image[forest_image != 0] = 255
 
         # B and G channels remain the same (zeros), while we change the R channel.
-        possible_R_values = [33, 65, 97, 129, 161, 193, 225]  # pylint: disable=C0103
+        possible_R_values = [65, 97, 129, 161, 193, 225]  # pylint: disable=C0103
 
-        # 1st approach: Change the non zero values in the base image to 33 (for debug).
-        # And use the base image as R channel in the density map.
+        base_layer_pixel_value = plant_to_pixel_value(
+            self.map.grle_settings.base_grass  # type:ignore
+        )
+        if not base_layer_pixel_value:
+            base_layer_pixel_value = 131
 
         # pylint: disable=no-member
         def create_island_of_plants(image: np.ndarray, count: int) -> np.ndarray:
@@ -290,23 +360,20 @@ class GRLE(Component):
                 # Randomly choose the value for the island.
                 plant_value = choice(possible_R_values)
                 # Randomly choose the size of the island.
-                island_size = randint(ISLAND_SIZE_MIN, ISLAND_SIZE_MAX)
+                island_size = randint(
+                    self.map.grle_settings.plants_island_minimum_size,  # type:ignore
+                    self.map.grle_settings.plants_island_maximum_size,  # type:ignore
+                )
                 # Randomly choose the position of the island.
-                # x = np.random.randint(0, image.shape[1] - island_size)
-                # y = np.random.randint(0, image.shape[0] - island_size)
                 x = randint(0, image.shape[1] - island_size)
                 y = randint(0, image.shape[0] - island_size)
 
-                # Randomly choose the shape of the island.
-                # shapes = ["circle", "ellipse", "polygon"]
-                # shape = choice(shapes)
-
                 try:
                     polygon_points = get_rounded_polygon(
-                        num_vertices=ISLAND_VERTEX_COUNT,
+                        num_vertices=self.map.grle_settings.plants_island_vertex_count,
                         center=(x + island_size // 2, y + island_size // 2),
                         radius=island_size // 2,
-                        rounding_radius=ISLAND_ROUNDING_RADIUS,
+                        rounding_radius=self.map.grle_settings.plants_island_rounding_radius,
                     )
                     if not polygon_points:
                         continue
@@ -355,16 +422,16 @@ class GRLE(Component):
         grass_image_copy = grass_image.copy()
         if forest_image is not None:
             # Add the forest layer to the base image, to merge the masks.
-            grass_image_copy[forest_image != 0] = 33
-        # Set all the non-zero values to 33.
-        grass_image_copy[grass_image != 0] = 33
+            grass_image_copy[forest_image != 0] = base_layer_pixel_value
+
+        grass_image_copy[grass_image != 0] = base_layer_pixel_value
 
         # Add islands of plants to the base image.
-        island_count = self.map_size
+        island_count = int(self.map_size * self.map.grle_settings.plants_island_percent // 100)
         self.logger.debug("Adding %s islands of plants to the base image.", island_count)
         if self.map.grle_settings.random_plants:
             grass_image_copy = create_island_of_plants(grass_image_copy, island_count)
-        self.logger.debug("Islands of plants added to the base image.")
+            self.logger.info("Added %s islands of plants to the base image.", island_count)
 
         # Sligtly reduce the size of the grass_image, that we'll use as mask.
         kernel = np.ones((3, 3), np.uint8)
@@ -380,7 +447,6 @@ class GRLE(Component):
         grass_image_copy[:, 0] = 0  # Left side
         grass_image_copy[:, -1] = 0  # Right side
 
-        # Value of 33 represents the base grass plant.
         # After painting it with base grass, we'll create multiple islands of different plants.
         # On the final step, we'll remove all the values which in pixels
         # where zerons in the original base image (so we don't paint grass where it should not be).

maps4fs/generator/i3d.py

@@ -14,14 +14,10 @@ import numpy as np
 from maps4fs.generator.component import Component
 from maps4fs.generator.texture import Texture
 
-DEFAULT_HEIGHT_SCALE = 2000
 DISPLACEMENT_LAYER_SIZE_FOR_BIG_MAPS = 32768
-DEFAULT_MAX_LOD_DISTANCE = 10000
-DEFAULT_MAX_LOD_OCCLUDER_DISTANCE = 10000
 NODE_ID_STARTING_VALUE = 2000
 SPLINES_NODE_ID_STARTING_VALUE = 5000
 TREE_NODE_ID_STARTING_VALUE = 10000
-DEFAULT_FOREST_DENSITY = 10
 
 
 # pylint: disable=R0903
@@ -82,19 +78,19 @@ class I3d(Component):
         root = tree.getroot()
         for map_elem in root.iter("Scene"):
             for terrain_elem in map_elem.iter("TerrainTransformGroup"):
-                if self.map.dem_settings.auto_process:
-                    terrain_elem.set("heightScale", str(DEFAULT_HEIGHT_SCALE))
-                    self.logger.debug(
-                        "heightScale attribute set to %s in TerrainTransformGroup element.",
-                        DEFAULT_HEIGHT_SCALE,
-                    )
-                else:
-                    self.logger.debug(
-                        "Auto process is disabled, skipping the heightScale attribute update."
-                    )
+                if self.map.shared_settings.change_height_scale:
+                    suggested_height_scale = self.map.shared_settings.height_scale_value
+                    if suggested_height_scale is not None and suggested_height_scale > 255:
+                        new_height_scale = int(
+                            self.map.shared_settings.height_scale_value  # type: ignore
+                        )
+                        terrain_elem.set("heightScale", str(new_height_scale))
+                        self.logger.info(
+                            "heightScale attribute set to %s in TerrainTransformGroup element.",
+                            new_height_scale,
+                        )
 
                 self.logger.debug("TerrainTransformGroup element updated in I3D file.")
-
             sun_elem = map_elem.find(".//Light[@name='sun']")
 
             if sun_elem is not None:
@@ -156,7 +152,7 @@ class I3d(Component):
             self.logger.warning("Roads polylines data not found in textures info layer.")
             return
 
-        self.logger.info("Found %s roads polylines in textures info layer.", len(roads_polylines))
+        self.logger.debug("Found %s roads polylines in textures info layer.", len(roads_polylines))
         self.logger.debug("Starging to add roads polylines to the I3D file.")
 
         root = tree.getroot()
@@ -198,7 +194,7 @@ class I3d(Component):
                         linestring_points=road, angle=self.rotation
                     )
                 except ValueError as e:
-                    self.logger.warning(
+                    self.logger.debug(
                         "Road %s could not be fitted into the map bounds with error: %s",
                         road_id,
                         e,
@@ -249,7 +245,7 @@ class I3d(Component):
                     y = max(0, min(y, dem_y_size - 1))
 
                     z = not_resized_dem[y, x]
-                    z /= 32  # Yes, it's a magic number here.
+                    z *= self.get_z_scaling_factor()  # type: ignore
 
                     cv_node = ET.Element("cv")
                     cv_node.set("c", f"{cx}, {z}, {cy}")
@@ -301,7 +297,7 @@ class I3d(Component):
             self.logger.warning("Fields data not found in textures info layer.")
             return
 
-        self.logger.info("Found %s fields in textures info layer.", len(fields))
+        self.logger.debug("Found %s fields in textures info layer.", len(fields))
         self.logger.debug("Starging to add fields to the I3D file.")
 
         root = tree.getroot()
@@ -323,7 +319,7 @@ class I3d(Component):
                             polygon_points=field, angle=self.rotation
                         )
                     except ValueError as e:
-                        self.logger.warning(
+                        self.logger.debug(
                             "Field %s could not be fitted into the map bounds with error: %s",
                             field_id,
                             e,
@@ -337,7 +333,7 @@ class I3d(Component):
                     try:
                         cx, cy = self.get_polygon_center(field_ccs)
                     except Exception as e:  # pylint: disable=W0718
-                        self.logger.warning(
+                        self.logger.debug(
                             "Field %s could not be fitted into the map bounds.", field_id
                         )
                         self.logger.debug("Error: %s", e)

maps4fs/generator/map.py

@@ -7,145 +7,22 @@ import os
 import shutil
 from typing import Any, Generator
 
-from pydantic import BaseModel
-
 from maps4fs.generator.component import Component
+from maps4fs.generator.dtm.dtm import DTMProvider, DTMProviderSettings
 from maps4fs.generator.game import Game
+from maps4fs.generator.settings import (
+    BackgroundSettings,
+    DEMSettings,
+    GRLESettings,
+    I3DSettings,
+    SatelliteSettings,
+    SharedSettings,
+    SplineSettings,
+    TextureSettings,
+)
 from maps4fs.logger import Logger
 
 
-class SettingsModel(BaseModel):
-    """Base class for settings models. It provides methods to convert settings to and from JSON."""
-
-    @classmethod
-    def all_settings_to_json(cls) -> dict[str, dict[str, Any]]:
-        """Get all settings of the current class and its subclasses as a dictionary.
-
-        Returns:
-            dict[str, dict[str, Any]]: Dictionary with settings of the current class and its
-                subclasses.
-        """
-        all_settings = {}
-        for subclass in cls.__subclasses__():
-            all_settings[subclass.__name__] = subclass().model_dump()
-
-        return all_settings
-
-    @classmethod
-    def all_settings_from_json(cls, data: dict) -> dict[str, SettingsModel]:
-        """Create settings instances from JSON data.
-
-        Arguments:
-            data (dict): JSON data.
-
-        Returns:
-            dict[str, Type[SettingsModel]]: Dictionary with settings instances.
-        """
-        settings = {}
-        for subclass in cls.__subclasses__():
-            settings[subclass.__name__] = subclass(**data[subclass.__name__])
-
-        return settings
-
-    @classmethod
-    def all_settings(cls) -> list[SettingsModel]:
-        """Get all settings of the current class and its subclasses.
-
-        Returns:
-            list[SettingsModel]: List with settings of the current class and its subclasses.
-        """
-        settings = []
-        for subclass in cls.__subclasses__():
-            settings.append(subclass())
-
-        return settings
-
-
-class DEMSettings(SettingsModel):
-    """Represents the advanced settings for DEM component.
-
-    Attributes:
-        auto_process (bool): use the auto preset to change the multiplier.
-        multiplier (int): multiplier for the heightmap, every pixel will be multiplied by this
-            value.
-        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.
-    """
-
-    auto_process: bool = True
-    multiplier: int = 1
-    blur_radius: int = 35
-    plateau: int = 0
-    water_depth: int = 0
-
-
-class BackgroundSettings(SettingsModel):
-    """Represents the advanced settings for background component.
-
-    Attributes:
-        generate_background (bool): generate obj files for the background terrain.
-        generate_water (bool): generate obj files for the water.
-        resize_factor (int): resize factor for the background terrain and water.
-            It will be used as 1 / resize_factor of the original size.
-    """
-
-    generate_background: bool = True
-    generate_water: bool = True
-    resize_factor: int = 8
-
-
-class GRLESettings(SettingsModel):
-    """Represents the advanced settings for GRLE component.
-
-    Attributes:
-        farmland_margin (int): margin around the farmland.
-        random_plants (bool): generate random plants on the map or use the default one.
-        add_farmyards (bool): If True, regions of frarmyards will be added to the map
-            without corresponding fields.
-    """
-
-    farmland_margin: int = 0
-    random_plants: bool = True
-    add_farmyards: bool = False
-
-
-class I3DSettings(SettingsModel):
-    """Represents the advanced settings for I3D component.
-
-    Attributes:
-        forest_density (int): density of the forest (distance between trees).
-    """
-
-    forest_density: int = 10
-
-
-class TextureSettings(SettingsModel):
-    """Represents the advanced settings for texture component.
-
-    Attributes:
-        dissolve (bool): dissolve the texture into several images.
-        fields_padding (int): padding around the fields.
-        skip_drains (bool): skip drains generation.
-    """
-
-    dissolve: bool = False
-    fields_padding: int = 0
-    skip_drains: bool = False
-
-
-class SplineSettings(SettingsModel):
-    """Represents the advanced settings for spline component.
-
-    Attributes:
-        spline_density (int): the number of extra points that will be added between each two
-            existing points.
-    """
-
-    spline_density: int = 2
-
-
 # pylint: disable=R0913, R0902, R0914
 class Map:
     """Class used to generate map using all components.
@@ -161,6 +38,8 @@ class Map:
     def __init__(  # pylint: disable=R0917, R0915
         self,
         game: Game,
+        dtm_provider: DTMProvider,
+        dtm_provider_settings: DTMProviderSettings,
         coordinates: tuple[float, float],
         size: int,
         rotation: int,
@@ -173,6 +52,7 @@ class Map:
         i3d_settings: I3DSettings = I3DSettings(),
         texture_settings: TextureSettings = TextureSettings(),
         spline_settings: SplineSettings = SplineSettings(),
+        satellite_settings: SatelliteSettings = SatelliteSettings(),
         **kwargs,
     ):
         if not logger:
@@ -189,6 +69,8 @@ class Map:
         self.rotated_size = int(size * rotation_multiplier)
 
         self.game = game
+        self.dtm_provider = dtm_provider
+        self.dtm_provider_settings = dtm_provider_settings
         self.components: list[Component] = []
         self.coordinates = coordinates
         self.map_directory = map_directory
@@ -207,6 +89,17 @@ class Map:
 
         self.dem_settings = dem_settings
         self.logger.info("DEM settings: %s", dem_settings)
+        if self.dem_settings.water_depth > 0:
+            # Make sure that the plateau value is >= water_depth
+            self.dem_settings.plateau = max(
+                self.dem_settings.plateau, self.dem_settings.water_depth
+            )
+            self.logger.info(
+                "Plateau value was set to %s to be >= water_depth value %s",
+                self.dem_settings.plateau,
+                self.dem_settings.water_depth,
+            )
+
         self.background_settings = background_settings
         self.logger.info("Background settings: %s", background_settings)
         self.grle_settings = grle_settings
@@ -217,6 +110,7 @@ class Map:
         self.logger.info("Texture settings: %s", texture_settings)
         self.spline_settings = spline_settings
         self.logger.info("Spline settings: %s", spline_settings)
+        self.satellite_settings = satellite_settings
 
         os.makedirs(self.map_directory, exist_ok=True)
         self.logger.debug("Map directory created: %s", self.map_directory)
@@ -228,6 +122,7 @@ class Map:
             i3d_settings,
             texture_settings,
             spline_settings,
+            satellite_settings,
         ]
 
         settings_json = {}
@@ -240,6 +135,8 @@ class Map:
         with open(save_path, "w", encoding="utf-8") as file:
             json.dump(settings_json, file, indent=4)
 
+        self.shared_settings = SharedSettings()
+
         self.texture_custom_schema = kwargs.get("texture_custom_schema", None)
         if self.texture_custom_schema:
             save_path = os.path.join(self.map_directory, "texture_custom_schema.json")
@@ -249,11 +146,17 @@ class Map:
 
         self.tree_custom_schema = kwargs.get("tree_custom_schema", None)
         if self.tree_custom_schema:
+            self.logger.info("Custom tree schema contains %s trees", len(self.tree_custom_schema))
             save_path = os.path.join(self.map_directory, "tree_custom_schema.json")
             with open(save_path, "w", encoding="utf-8") as file:
                 json.dump(self.tree_custom_schema, file, indent=4)
             self.logger.debug("Tree custom schema saved to %s", save_path)
 
+        self.custom_background_path = kwargs.get("custom_background_path", None)
+        if self.custom_background_path:
+            save_path = os.path.join(self.map_directory, "custom_background.png")
+            shutil.copyfile(self.custom_background_path, save_path)
+
         try:
             shutil.unpack_archive(game.template_path, self.map_directory)
             self.logger.debug("Map template unpacked to %s", self.map_directory)
@@ -362,7 +265,7 @@ class Map:
             str: Path to the archive.
         """
         archive_path = shutil.make_archive(archive_path, "zip", self.map_directory)
-        self.logger.info("Map packed to %s.zip", archive_path)
+        self.logger.debug("Map packed to %s.zip", archive_path)
         if remove_source:
             try:
                 shutil.rmtree(self.map_directory)

maps4fs/generator/satellite.py

@@ -0,0 +1,92 @@
+"""This module contains the Satellite class for the maps4fs package to download satellite images
+for the map."""
+
+import os
+
+import cv2
+from pygmdl import save_image  # type: ignore
+
+from maps4fs.generator.background import DEFAULT_DISTANCE
+from maps4fs.generator.component import Component
+from maps4fs.generator.texture import PREVIEW_MAXIMUM_SIZE
+
+
+# pylint: disable=W0223
+class Satellite(Component):
+    """Component for to download satellite images for 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_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:
+        """This component does not require any preprocessing."""
+        return
+
+    def process(self) -> None:
+        """Downloads the satellite images for the map."""
+        self.image_paths = []  # pylint: disable=W0201
+        if not self.map.satellite_settings.download_images:
+            self.logger.debug("Satellite images download is disabled.")
+            return
+
+        margin = self.map.satellite_settings.satellite_margin
+        overview_size = (self.map_size + margin) * 2
+        overwiew_path = os.path.join(self.satellite_directory, "satellite_overview.png")
+
+        background_size = self.map_size + (DEFAULT_DISTANCE + margin) * 2
+        background_path = os.path.join(self.satellite_directory, "satellite_background.png")
+
+        sizes = [overview_size, background_size]
+        self.image_paths = [overwiew_path, background_path]  # pylint: disable=W0201
+
+        for size, path in zip(sizes, self.image_paths):
+            try:
+                lat, lon = self.coordinates
+                zoom = self.map.satellite_settings.zoom_level
+                save_image(
+                    lat,
+                    lon,
+                    size,
+                    output_path=path,
+                    rotation=self.rotation,
+                    zoom=zoom,
+                    from_center=True,
+                    logger=self.logger,
+                )
+            except Exception as e:  # pylint: disable=W0718
+                self.logger.error(f"Failed to download satellite image: {e}")
+                continue
+
+    # pylint: disable=no-member
+    def previews(self) -> list[str]:
+        """Returns the paths to the preview images.
+
+        Returns:
+            list[str]: List of paths to the preview images.
+        """
+        previews = []
+        for image_path in self.image_paths:
+            if not os.path.isfile(image_path):
+                self.logger.warning(f"File {image_path} does not exist.")
+                continue
+            image = cv2.imread(image_path)
+            if image is None:
+                self.logger.warning(f"Failed to read image from {image_path}")
+                continue
+
+            if image.shape[0] > PREVIEW_MAXIMUM_SIZE or image.shape[1] > PREVIEW_MAXIMUM_SIZE:
+                image = cv2.resize(image, (PREVIEW_MAXIMUM_SIZE, PREVIEW_MAXIMUM_SIZE))
+
+            preview_path = os.path.join(self.previews_directory, os.path.basename(image_path))
+            cv2.imwrite(preview_path, image)
+            previews.append(preview_path)
+
+        return previews