maps4fs 0.7.8__py3-none-any.whl → 0.9.8__py3-none-any.whl

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.
+
+    Args:
+        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.
+
+    Args:
+        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.
+
+    Args:
+        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.
+
+    Args:
+        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.
+
+    Args:
+        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/texture.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import json
 import os
 import warnings
-from typing import Callable, Generator, Optional
+from typing import Any, Callable, Generator, Optional
 
 import cv2
 import numpy as np
@@ -57,6 +57,7 @@ class Texture(Component):
             width: int | None = None,
             color: tuple[int, int, int] | list[int] | None = None,
             exclude_weight: bool = False,
+            priority: int | None = None,
         ):
             self.name = name
             self.count = count
@@ -64,6 +65,7 @@ class Texture(Component):
             self.width = width
             self.color = color if color else (255, 255, 255)
             self.exclude_weight = exclude_weight
+            self.priority = priority
 
         def to_json(self) -> dict[str, str | list[str] | bool]:  # type: ignore
             """Returns dictionary with layer data.
@@ -77,6 +79,7 @@ class Texture(Component):
                 "width": self.width,
                 "color": list(self.color),
                 "exclude_weight": self.exclude_weight,
+                "priority": self.priority,
             }
 
             data = {k: v for k, v in data.items() if v is not None}
@@ -120,16 +123,32 @@ class Texture(Component):
         self.layers = [self.Layer.from_json(layer) for layer in layers_schema]
         self.logger.info("Loaded %s layers.", len(self.layers))
 
+        base_layer = self.get_base_layer()
+        if base_layer:
+            self.logger.info("Base layer found: %s.", base_layer.name)
+        else:
+            self.logger.warning("No base layer found.")
+
         self._weights_dir = self.game.weights_dir_path(self.map_directory)
         self.logger.debug("Weights directory: %s.", self._weights_dir)
         self.info_save_path = os.path.join(self.map_directory, "generation_info.json")
         self.logger.debug("Generation info save path: %s.", self.info_save_path)
 
+    def get_base_layer(self) -> Layer | None:
+        """Returns base layer.
+
+        Returns:
+            Layer | None: Base layer.
+        """
+        for layer in self.layers:
+            if layer.priority == 0:
+                return layer
+        return None
+
     def process(self):
         self._prepare_weights()
         self._read_parameters()
         self.draw()
-        self.info_sequence()
 
     # pylint: disable=W0201
     def _read_parameters(self) -> None:
@@ -148,31 +167,8 @@ class Texture(Component):
         self.logger.debug("Map minimum coordinates (XxY): %s x %s.", self.minimum_x, self.minimum_y)
         self.logger.debug("Map maximum coordinates (XxY): %s x %s.", self.maximum_x, self.maximum_y)
 
-        self.height = abs(north - south)
-        self.width = abs(east - west)
-        self.logger.info("Map dimensions (HxW): %s x %s.", self.height, self.width)
-
-        self.height_coef = self.height / self.map_height
-        self.width_coef = self.width / self.map_width
-        self.logger.debug("Map coefficients (HxW): %s x %s.", self.height_coef, self.width_coef)
-
-    def info_sequence(self) -> None:
-        """Saves generation info to JSON file "generation_info.json".
-
-        Info sequence contains following attributes:
-            - coordinates
-            - bbox
-            - map_height
-            - map_width
-            - minimum_x
-            - minimum_y
-            - maximum_x
-            - maximum_y
-            - height
-            - width
-            - height_coef
-            - width_coef
-        """
+    def info_sequence(self) -> dict[str, Any]:
+        """Returns the JSON representation of the generation info for textures."""
         useful_attributes = [
             "coordinates",
             "bbox",
@@ -182,16 +178,8 @@ class Texture(Component):
             "minimum_y",
             "maximum_x",
             "maximum_y",
-            "height",
-            "width",
-            "height_coef",
-            "width_coef",
         ]
-        info_sequence = {attr: getattr(self, attr, None) for attr in useful_attributes}
-
-        with open(self.info_save_path, "w") as f:  # pylint: disable=W1514
-            json.dump(info_sequence, f, indent=4)
-        self.logger.info("Generation info saved to %s.", self.info_save_path)
+        return {attr: getattr(self, attr, None) for attr in useful_attributes}
 
     def _prepare_weights(self):
         self.logger.debug("Starting preparing weights from %s layers.", len(self.layers))
@@ -239,22 +227,79 @@ class Texture(Component):
         """
         self._layers = layers
 
+    def layers_by_priority(self) -> list[Layer]:
+        """Returns list of layers sorted by priority: None priority layers are first,
+        then layers are sorted by priority (descending).
+
+        Returns:
+            list[Layer]: List of layers sorted by priority.
+        """
+        return sorted(
+            self.layers,
+            key=lambda _layer: (
+                _layer.priority is not None,
+                -_layer.priority if _layer.priority is not None else float("inf"),
+            ),
+        )
+
     # pylint: disable=no-member
     def draw(self) -> None:
         """Iterates over layers and fills them with polygons from OSM data."""
-        for layer in self.layers:
+        layers = self.layers_by_priority()
+
+        self.logger.debug(
+            "Sorted layers by priority: %s.", [(layer.name, layer.priority) for layer in layers]
+        )
+
+        cumulative_image = None
+
+        for layer in layers:
             if not layer.tags:
                 self.logger.debug("Layer %s has no tags, there's nothing to draw.", layer.name)
                 continue
+            if layer.priority == 0:
+                self.logger.debug(
+                    "Found base layer %s. Postponing that to be the last layer drawn.", layer.name
+                )
+                continue
             layer_path = layer.path(self._weights_dir)
             self.logger.debug("Drawing layer %s.", layer_path)
+            layer_image = cv2.imread(layer_path, cv2.IMREAD_UNCHANGED)
+
+            if cumulative_image is None:
+                self.logger.debug("First layer, creating new cumulative image.")
+                cumulative_image = layer_image
+
+            mask = cv2.bitwise_not(cumulative_image)
 
-            img = cv2.imread(layer_path, cv2.IMREAD_UNCHANGED)
             for polygon in self.polygons(layer.tags, layer.width):  # type: ignore
-                cv2.fillPoly(img, [polygon], color=255)  # type: ignore
-            cv2.imwrite(layer_path, img)
+                cv2.fillPoly(layer_image, [polygon], color=255)  # type: ignore
+
+            output_image = cv2.bitwise_and(layer_image, mask)
+
+            cumulative_image = cv2.bitwise_or(cumulative_image, output_image)
+
+            cv2.imwrite(layer_path, output_image)
             self.logger.debug("Texture %s saved.", layer_path)
 
+        if cumulative_image is not None:
+            self.draw_base_layer(cumulative_image)
+
+    def draw_base_layer(self, cumulative_image: np.ndarray) -> None:
+        """Draws base layer and saves it into the png file.
+        Base layer is the last layer to be drawn, it fills the remaining area of the map.
+
+        Args:
+            cumulative_image (np.ndarray): Cumulative image with all layers.
+        """
+        base_layer = self.get_base_layer()
+        if base_layer is not None:
+            layer_path = base_layer.path(self._weights_dir)
+            self.logger.debug("Drawing base layer %s.", layer_path)
+            img = cv2.bitwise_not(cumulative_image)
+            cv2.imwrite(layer_path, img)
+            self.logger.debug("Base texture %s saved.", layer_path)
+
     def get_relative_x(self, x: float) -> int:
         """Converts UTM X coordinate to relative X coordinate in map image.
 
@@ -264,8 +309,7 @@ class Texture(Component):
         Returns:
             int: Relative X coordinate in map image.
         """
-        raw_x = x - self.minimum_x
-        return int(raw_x * self.height_coef)
+        return int(self.map_width * (x - self.minimum_x) / (self.maximum_x - self.minimum_x))
 
     def get_relative_y(self, y: float) -> int:
         """Converts UTM Y coordinate to relative Y coordinate in map image.
@@ -276,8 +320,7 @@ class Texture(Component):
         Returns:
             int: Relative Y coordinate in map image.
         """
-        raw_y = y - self.minimum_y
-        return self.height - int(raw_y * self.width_coef)
+        return int(self.map_height * (1 - (y - self.minimum_y) / (self.maximum_y - self.minimum_y)))
 
     # pylint: disable=W0613
     def _to_np(self, geometry: shapely.geometry.polygon.Polygon, *args) -> np.ndarray:
@@ -428,7 +471,7 @@ class Texture(Component):
             merged.shape,
             merged.dtype,
         )
-        preview_path = os.path.join(self.map_directory, "preview_osm.png")
+        preview_path = os.path.join(self.previews_directory, "textures_osm.png")
         cv2.imwrite(preview_path, merged)  # pylint: disable=no-member
         self.logger.info("Preview saved to %s.", preview_path)
         return preview_path

maps4fs/generator/tile.py

@@ -0,0 +1,55 @@
+"""This module contains the Tile component, which is used to generate a tile of DEM data around
+the map."""
+
+import os
+
+from maps4fs.generator.dem import DEM
+
+
+class Tile(DEM):
+    """Component for creating a tile of DEM data around the map.
+
+    Arguments:
+        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_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.
+
+    Keyword Arguments:
+        tile_code (str): The code of the tile (N, NE, E, SE, S, SW, W, NW).
+
+    Public Methods:
+        get_output_resolution: Return the resolution of the output image.
+        process: Launch the component processing.
+        make_copy: Override the method to prevent copying the tile.
+    """
+
+    def preprocess(self) -> None:
+        """Prepares the component for processing. Reads the tile code from the kwargs and sets the
+        DEM path for the tile."""
+        super().preprocess()
+        self.code = self.kwargs.get("tile_code")
+        if not self.code:
+            raise ValueError("Tile code was not provided")
+
+        self.logger.debug(f"Generating tile {self.code}")
+
+        tiles_directory = os.path.join(self.map_directory, "objects", "tiles")
+        os.makedirs(tiles_directory, exist_ok=True)
+
+        self._dem_path = os.path.join(tiles_directory, f"{self.code}.png")
+        self.logger.debug(f"DEM path for tile {self.code} is {self._dem_path}")
+
+    def get_output_resolution(self) -> tuple[int, int]:
+        """Return the resolution of the output image.
+
+        Returns:
+            tuple[int, int]: The width and height of the output image.
+        """
+        return self.map_width, self.map_height
+
+    def make_copy(self, *args, **kwargs) -> None:
+        """Override the method to prevent copying the tile."""
+        pass  # pylint: disable=unnecessary-pass

maps4fs/logger.py

@@ -4,8 +4,11 @@ import logging
 import os
 import sys
 from datetime import datetime
-from typing import Literal
+from logging import getLogger
+from time import perf_counter
+from typing import Any, Callable, Literal
 
+LOGGER_NAME = "maps4fs"
 log_directory = os.path.join(os.getcwd(), "logs")
 os.makedirs(log_directory, exist_ok=True)
 
@@ -15,12 +18,11 @@ class Logger(logging.Logger):
 
     def __init__(
         self,
-        name: str,
         level: Literal["DEBUG", "INFO", "WARNING", "ERROR"] = "ERROR",
         to_stdout: bool = True,
         to_file: bool = True,
     ):
-        super().__init__(name)
+        super().__init__(LOGGER_NAME)
         self.setLevel(level)
         self.stdout_handler = logging.StreamHandler(sys.stdout)
         self.file_handler = logging.FileHandler(
@@ -44,3 +46,25 @@ class Logger(logging.Logger):
         today = datetime.now().strftime("%Y-%m-%d")
         log_file = os.path.join(log_directory, f"{today}.txt")
         return log_file
+
+
+def timeit(func: Callable[..., Any]) -> Callable[..., Any]:
+    """Decorator to log the time taken by a function to execute.
+
+    Args:
+        func (function): The function to be timed.
+
+    Returns:
+        function: The timed function.
+    """
+
+    def timed(*args, **kwargs):
+        logger = getLogger("maps4fs")
+        start = perf_counter()
+        result = func(*args, **kwargs)
+        end = perf_counter()
+        if logger is not None:
+            logger.info("Function %s took %s seconds to execute", func.__name__, end - start)
+        return result
+
+    return timed

maps4fs/toolbox/__init__.py

@@ -0,0 +1 @@
+# pylint: disable=missing-module-docstring

maps4fs/toolbox/dem.py

@@ -0,0 +1,112 @@
+"""This module contains functions for working with Digital Elevation Models (DEMs)."""
+
+import os
+
+import rasterio  # type: ignore
+from pyproj import Transformer
+from rasterio.io import DatasetReader  # type: ignore
+from rasterio.windows import from_bounds  # type: ignore
+
+
+def read_geo_tiff(file_path: str) -> DatasetReader:
+    """Read a GeoTIFF file and return the DatasetReader object.
+
+    Args:
+        file_path (str): The path to the GeoTIFF file.
+
+    Raises:
+        FileNotFoundError: If the file is not found.
+        RuntimeError: If there is an error reading the file.
+
+    Returns:
+        DatasetReader: The DatasetReader object for the GeoTIFF file.
+    """
+    if not os.path.isfile(file_path):
+        raise FileNotFoundError(f"File not found: {file_path}")
+
+    try:
+        src = rasterio.open(file_path)
+    except Exception as e:
+        raise RuntimeError(f"Error reading file: {file_path}") from e
+
+    if not src.bounds or not src.crs:
+        raise RuntimeError(
+            f"Can not read bounds or CRS from file: {file_path}. "
+            f"Bounds: {src.bounds}, CRS: {src.crs}"
+        )
+
+    return src
+
+
+def get_geo_tiff_bbox(
+    src: DatasetReader, dst_crs: str | None = "EPSG:4326"
+) -> tuple[float, float, float, float]:
+    """Return the bounding box of a GeoTIFF file in the destination CRS.
+
+    Args:
+        src (DatasetReader): The DatasetReader object for the GeoTIFF file.
+        dst_crs (str, optional): The destination CRS. Defaults to "EPSG:4326".
+
+    Returns:
+        tuple[float, float, float, float]: The bounding box in the destination CRS
+            as (north, south, east, west).
+    """
+    left, bottom, right, top = src.bounds
+
+    transformer = Transformer.from_crs(src.crs, dst_crs, always_xy=True)
+
+    east, north = transformer.transform(left, top)
+    west, south = transformer.transform(right, bottom)
+
+    return north, south, east, west
+
+
+# pylint: disable=R0914
+def extract_roi(file_path: str, bbox: tuple[float, float, float, float]) -> str:
+    """Extract a region of interest (ROI) from a GeoTIFF file and save it as a new file.
+
+    Args:
+        file_path (str): The path to the GeoTIFF file.
+        bbox (tuple[float, float, float, float]): The bounding box of the region of interest
+            as (north, south, east, west).
+
+    Raises:
+        RuntimeError: If there is no data in the selected region.
+
+    Returns:
+        str: The path to the new GeoTIFF file containing the extracted ROI.
+    """
+    with rasterio.open(file_path) as src:
+        transformer = Transformer.from_crs("EPSG:4326", src.crs, always_xy=True)
+        north, south, east, west = bbox
+
+        left, bottom = transformer.transform(west, south)
+        right, top = transformer.transform(east, north)
+
+        window = from_bounds(left, bottom, right, top, src.transform)
+        data = src.read(window=window)
+
+    if not data.size > 0:
+        raise RuntimeError("No data in the selected region.")
+
+    base_name = os.path.basename(file_path).split(".")[0]
+    dir_name = os.path.dirname(file_path)
+
+    output_name = f"{base_name}_{north}_{south}_{east}_{west}.tif"
+
+    output_path = os.path.join(dir_name, output_name)
+
+    with rasterio.open(
+        output_path,
+        "w",
+        driver="GTiff",
+        height=data.shape[1],
+        width=data.shape[2],
+        count=data.shape[0],
+        dtype=data.dtype,
+        crs=src.crs,
+        transform=src.window_transform(window),
+    ) as dst:
+        dst.write(data)
+
+    return output_path