maps4fs 1.8.0__py3-none-any.whl

maps4fs/generator/map.py

@@ -0,0 +1,275 @@
+"""This module contains Map class, which is used to generate map using all components."""
+
+from __future__ import annotations
+
+import json
+import os
+import shutil
+from typing import Any, Generator
+
+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
+
+
+# pylint: disable=R0913, R0902, R0914
+class Map:
+    """Class used to generate map using all components.
+
+    Arguments:
+        game (Type[Game]): Game for which the map is generated.
+        coordinates (tuple[float, float]): Coordinates of the center of the map.
+        size (int): Height and width of the map in pixels (it's a square).
+        map_directory (str): Path to the directory where map files will be stored.
+        logger (Any): Logger instance
+    """
+
+    def __init__(  # pylint: disable=R0917, R0915
+        self,
+        game: Game,
+        dtm_provider: DTMProvider,
+        dtm_provider_settings: DTMProviderSettings,
+        coordinates: tuple[float, float],
+        size: int,
+        rotation: int,
+        map_directory: str,
+        logger: Any = None,
+        custom_osm: str | None = None,
+        dem_settings: DEMSettings = DEMSettings(),
+        background_settings: BackgroundSettings = BackgroundSettings(),
+        grle_settings: GRLESettings = GRLESettings(),
+        i3d_settings: I3DSettings = I3DSettings(),
+        texture_settings: TextureSettings = TextureSettings(),
+        spline_settings: SplineSettings = SplineSettings(),
+        satellite_settings: SatelliteSettings = SatelliteSettings(),
+        **kwargs,
+    ):
+        if not logger:
+            logger = Logger(to_stdout=True, to_file=False)
+        self.logger = logger
+        self.size = size
+
+        if rotation:
+            rotation_multiplier = 1.5
+        else:
+            rotation_multiplier = 1
+
+        self.rotation = rotation
+        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
+
+        self.logger.info("Game was set to %s", game.code)
+
+        self.custom_osm = custom_osm
+        self.logger.info("Custom OSM file: %s", custom_osm)
+
+        # Make a copy of a custom osm file to the map directory, so it will be
+        # included in the output archive.
+        if custom_osm:
+            copy_path = os.path.join(self.map_directory, "custom_osm.osm")
+            shutil.copyfile(custom_osm, copy_path)
+            self.logger.debug("Custom OSM file copied to %s", copy_path)
+
+        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
+        self.logger.info("GRLE settings: %s", grle_settings)
+        self.i3d_settings = i3d_settings
+        self.logger.info("I3D settings: %s", i3d_settings)
+        self.texture_settings = texture_settings
+        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)
+
+        settings = [
+            dem_settings,
+            background_settings,
+            grle_settings,
+            i3d_settings,
+            texture_settings,
+            spline_settings,
+            satellite_settings,
+        ]
+
+        settings_json = {}
+
+        for setting in settings:
+            settings_json[setting.__class__.__name__] = setting.model_dump()
+
+        save_path = os.path.join(self.map_directory, "generation_settings.json")
+
+        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")
+            with open(save_path, "w", encoding="utf-8") as file:
+                json.dump(self.texture_custom_schema, file, indent=4)
+            self.logger.debug("Texture custom schema saved to %s", save_path)
+
+        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)
+        except Exception as e:
+            raise RuntimeError(f"Can not unpack map template due to error: {e}") from e
+
+    def generate(self) -> Generator[str, None, None]:
+        """Launch map generation using all components. Yield component names during the process.
+
+        Yields:
+            Generator[str, None, None]: Component names.
+        """
+        self.logger.info(
+            "Starting map generation. Game code: %s. Coordinates: %s, size: %s. Rotation: %s.",
+            self.game.code,
+            self.coordinates,
+            self.size,
+            self.rotation,
+        )
+
+        for game_component in self.game.components:
+            component = game_component(
+                self.game,
+                self,
+                self.coordinates,
+                self.size,
+                self.rotated_size,
+                self.rotation,
+                self.map_directory,
+                self.logger,
+                texture_custom_schema=self.texture_custom_schema,
+                tree_custom_schema=self.tree_custom_schema,
+            )
+            self.components.append(component)
+
+            yield component.__class__.__name__
+
+            try:
+                component.process()
+            except Exception as e:  # pylint: disable=W0718
+                self.logger.error(
+                    "Error processing component %s: %s",
+                    component.__class__.__name__,
+                    e,
+                )
+                raise e
+
+            try:
+                component.commit_generation_info()
+            except Exception as e:  # pylint: disable=W0718
+                self.logger.error(
+                    "Error committing generation info for component %s: %s",
+                    component.__class__.__name__,
+                    e,
+                )
+                raise e
+
+        self.logger.info(
+            "Map generation completed. Game code: %s. Coordinates: %s, size: %s. Rotation: %s.",
+            self.game.code,
+            self.coordinates,
+            self.size,
+            self.rotation,
+        )
+
+    def get_component(self, component_name: str) -> Component | None:
+        """Get component by name.
+
+        Arguments:
+            component_name (str): Name of the component.
+
+        Returns:
+            Component | None: Component instance or None if not found.
+        """
+        for component in self.components:
+            if component.__class__.__name__ == component_name:
+                return component
+        return None
+
+    def previews(self) -> list[str]:
+        """Get list of preview images.
+
+        Returns:
+            list[str]: List of preview images.
+        """
+        previews = []
+        for component in self.components:
+            try:
+                previews.extend(component.previews())
+            except Exception as e:  # pylint: disable=W0718
+                self.logger.error(
+                    "Error getting previews for component %s: %s",
+                    component.__class__.__name__,
+                    e,
+                )
+        return previews
+
+    def pack(self, archive_path: str, remove_source: bool = True) -> str:
+        """Pack map directory to zip archive.
+
+        Arguments:
+            archive_path (str): Path to the archive.
+            remove_source (bool, optional): Remove source directory after packing.
+
+        Returns:
+            str: Path to the archive.
+        """
+        archive_path = shutil.make_archive(archive_path, "zip", self.map_directory)
+        self.logger.debug("Map packed to %s.zip", archive_path)
+        if remove_source:
+            try:
+                shutil.rmtree(self.map_directory)
+                self.logger.debug("Map directory removed: %s", self.map_directory)
+            except Exception as e:  # pylint: disable=W0718
+                self.logger.debug("Error removing map directory %s: %s", self.map_directory, e)
+        return archive_path

maps4fs/generator/qgis.py

@@ -0,0 +1,196 @@
+"""This module contains templates for generating QGIS scripts."""
+
+import os
+
+BBOX_TEMPLATE = """
+layers = [
+    {layers}
+]
+for layer in layers:
+    name = "Bounding_Box_" + layer[0]
+    north, south, east, west = layer[1:]
+
+    # Create a rectangle geometry from the bounding box.
+    rect = QgsRectangle(north, east, south, west)
+
+    # Create a new memory layer to hold the bounding box.
+    layer = QgsVectorLayer("Polygon?crs=EPSG:3857", name, "memory")
+    provider = layer.dataProvider()
+
+    # Add the rectangle as a feature to the layer.
+    feature = QgsFeature()
+    feature.setGeometry(QgsGeometry.fromRect(rect))
+    provider.addFeatures([feature])
+
+    # Add the layer to the map.
+    QgsProject.instance().addMapLayer(layer)
+
+    # Set the fill opacity.
+    symbol = layer.renderer().symbol()
+    symbol_layer = symbol.symbolLayer(0)
+
+    # Set the stroke color and width.
+    symbol_layer.setStrokeColor(QColor(0, 255, 0))
+    symbol_layer.setStrokeWidth(0.2)
+    symbol_layer.setFillColor(QColor(0, 0, 255, 0))
+    layer.triggerRepaint()
+"""
+
+POINT_TEMPLATE = """
+layers = [
+    {layers}
+]
+for layer in layers:
+    name = "Points_" + layer[0]
+    north, south, east, west = layer[1:]
+
+    top_left = QgsPointXY(north, west)
+    top_right = QgsPointXY(north, east)
+    bottom_right = QgsPointXY(south, east)
+    bottom_left = QgsPointXY(south, west)
+
+    points = [top_left, top_right, bottom_right, bottom_left, top_left]
+
+    # Create a new layer
+    layer = QgsVectorLayer('Point?crs=EPSG:3857', name, 'memory')
+    provider = layer.dataProvider()
+
+    # Add fields
+    provider.addAttributes([QgsField("id", QVariant.Int)])
+    layer.updateFields()
+
+    # Create and add features for each point
+    for i, point in enumerate(points):
+        feature = QgsFeature()
+        feature.setGeometry(QgsGeometry.fromPointXY(point))
+        feature.setAttributes([i + 1])
+        provider.addFeature(feature)
+
+    layer.updateExtents()
+
+    # Add the layer to the project
+    QgsProject.instance().addMapLayer(layer)
+"""
+
+RASTERIZE_TEMPLATE = """
+import processing
+
+############################################################
+####### ADD THE DIRECTORY FOR THE FILES TO SAVE HERE #######
+############################################################
+############### IT MUST END WITH A SLASH (/) ###############
+############################################################
+
+SAVE_DIR = "C:/Users/iwatk/OneDrive/Desktop/"
+
+############################################################
+
+layers = [
+    {layers}
+]
+
+for layer in layers:
+    name = layer[0]
+    north, south, east, west = layer[1:]
+
+    epsg3857_string = str(north) + "," + str(south) + "," + str(east) + "," + str(west) + " [EPSG:3857]"
+    file_path = SAVE_DIR + name + ".tif"
+
+    processing.run(
+        "native:rasterize",
+        {{
+            "EXTENT": epsg3857_string,
+            "EXTENT_BUFFER": 0,
+            "TILE_SIZE": 64,
+            "MAP_UNITS_PER_PIXEL": 1,
+            "MAKE_BACKGROUND_TRANSPARENT": False,
+            "MAP_THEME": None,
+            "LAYERS": None,
+            "OUTPUT": file_path,
+        }},
+)
+"""
+
+
+def _get_template(layers: list[tuple[str, float, float, float, float]], template: str) -> str:
+    """Returns a template for creating layers in QGIS.
+
+    Arguments:
+        layers (list[tuple[str, float, float, float, float]]): A list of tuples containing the
+            layer name and the bounding box coordinates.
+        template (str): The template for creating layers in QGIS.
+
+    Returns:
+        str: The template for creating layers in QGIS.
+    """
+    return template.format(
+        layers=",\n    ".join(
+            [
+                f'("{name}", {north}, {south}, {east}, {west})'
+                for name, north, south, east, west in layers
+            ]
+        )
+    )
+
+
+def get_bbox_template(layers: list[tuple[str, float, float, float, float]]) -> str:
+    """Returns a template for creating bounding box layers in QGIS.
+
+    Arguments:
+        layers (list[tuple[str, float, float, float, float]]): A list of tuples containing the
+            layer name and the bounding box coordinates.
+
+    Returns:
+        str: The template for creating bounding box layers in QGIS.
+    """
+    return _get_template(layers, BBOX_TEMPLATE)
+
+
+def get_point_template(layers: list[tuple[str, float, float, float, float]]) -> str:
+    """Returns a template for creating point layers in QGIS.
+
+    Arguments:
+        layers (list[tuple[str, float, float, float, float]]): A list of tuples containing the
+            layer name and the bounding box coordinates.
+
+    Returns:
+        str: The template for creating point layers in QGIS.
+    """
+    return _get_template(layers, POINT_TEMPLATE)
+
+
+def get_rasterize_template(layers: list[tuple[str, float, float, float, float]]) -> str:
+    """Returns a template for rasterizing bounding box layers in QGIS.
+
+    Arguments:
+        layers (list[tuple[str, float, float, float, float]]): A list of tuples containing the
+            layer name and the bounding box coordinates.
+
+    Returns:
+        str: The template for rasterizing bounding box layers in QGIS.
+    """
+    return _get_template(layers, RASTERIZE_TEMPLATE)
+
+
+def save_scripts(
+    layers: list[tuple[str, float, float, float, float]], file_prefix: str, save_directory: str
+) -> None:
+    """Saves QGIS scripts for creating bounding box, point, and raster layers.
+
+    Arguments:
+        layers (list[tuple[str, float, float, float, float]]): A list of tuples containing the
+            layer name and the bounding box coordinates.
+        save_dir (str): The directory to save the scripts.
+    """
+    script_files = [
+        (f"{file_prefix}_bbox.py", get_bbox_template),
+        (f"{file_prefix}_rasterize.py", get_rasterize_template),
+        (f"{file_prefix}_point.py", get_point_template),
+    ]
+
+    for script_file, process_function in script_files:
+        script_path = os.path.join(save_directory, script_file)
+        script_content = process_function(layers)  # type: ignore
+
+        with open(script_path, "w", encoding="utf-8") as file:
+            file.write(script_content)

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