maps4fs 0.7.8__py3-none-any.whl

maps4fs/__init__.py

@@ -0,0 +1,4 @@
+# pylint: disable=missing-module-docstring
+from maps4fs.generator.game import Game
+from maps4fs.generator.map import Map
+from maps4fs.logger import Logger

maps4fs/generator/__init__.py

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

maps4fs/generator/component.py

@@ -0,0 +1,101 @@
+"""This module contains the base class for all map generation components."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+import osmnx as ox  # type: ignore
+
+if TYPE_CHECKING:
+    from maps4fs.generator.game import Game
+
+
+# pylint: disable=R0801, R0903, R0902
+class Component:
+    """Base class for all map generation components.
+
+    Args:
+        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.
+    """
+
+    def __init__(
+        self,
+        game: Game,
+        coordinates: tuple[float, float],
+        map_height: int,
+        map_width: int,
+        map_directory: str,
+        logger: Any = None,
+        **kwargs,  # pylint: disable=W0613, R0913, R0917
+    ):
+        self.game = game
+        self.coordinates = coordinates
+        self.map_height = map_height
+        self.map_width = map_width
+        self.map_directory = map_directory
+        self.logger = logger
+        self.kwargs = kwargs
+
+        self.save_bbox()
+        self.preprocess()
+
+    def preprocess(self) -> None:
+        """Prepares the component for processing. Must be implemented in the child class.
+
+        Raises:
+            NotImplementedError: If the method is not implemented in the child class.
+        """
+        raise NotImplementedError
+
+    def process(self) -> None:
+        """Launches the component processing. Must be implemented in the child class.
+
+        Raises:
+            NotImplementedError: If the method is not implemented in the child class.
+        """
+        raise NotImplementedError
+
+    def previews(self) -> list[str]:
+        """Returns a list of paths to the preview images. Must be implemented in the child class.
+
+        Raises:
+            NotImplementedError: If the method is not implemented in the child class.
+        """
+        raise NotImplementedError
+
+    def get_bbox(self, project_utm: bool = False) -> tuple[int, int, int, int]:
+        """Calculates the bounding box of the map from the coordinates and the height and
+        width of the map.
+
+        Args:
+            project_utm (bool, optional): Whether to project the bounding box to UTM.
+
+        Returns:
+            tuple[int, int, int, int]: The bounding box of the map.
+        """
+        north, south, _, _ = ox.utils_geo.bbox_from_point(
+            self.coordinates, dist=self.map_height / 2, project_utm=project_utm
+        )
+        _, _, east, west = ox.utils_geo.bbox_from_point(
+            self.coordinates, dist=self.map_width / 2, project_utm=project_utm
+        )
+        bbox = north, south, east, west
+        self.logger.debug(
+            "Calculated bounding box for component: %s: %s, project_utm: %s",
+            self.__class__.__name__,
+            bbox,
+            project_utm,
+        )
+        return bbox
+
+    def save_bbox(self) -> None:
+        """Saves the bounding box of the map to the component instance from the coordinates and the
+        height and width of the map.
+        """
+        self.bbox = self.get_bbox(project_utm=False)
+        self.logger.debug("Saved bounding box: %s", self.bbox)

maps4fs/generator/config.py

@@ -0,0 +1,55 @@
+"""This module contains the Config class for map settings and configuration."""
+
+from __future__ import annotations
+
+import os
+from xml.etree import ElementTree as ET
+
+from maps4fs.generator.component import Component
+
+
+# pylint: disable=R0903
+class Config(Component):
+    """Component for map settings and configuration.
+
+    Args:
+        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.
+    """
+
+    def preprocess(self) -> None:
+        self._map_xml_path = self.game.map_xml_path(self.map_directory)
+        self.logger.debug("Map XML path: %s.", self._map_xml_path)
+
+    def process(self):
+        self._set_map_size()
+
+    def _set_map_size(self):
+        """Edits map.xml file to set correct map size."""
+        if not os.path.isfile(self._map_xml_path):
+            self.logger.warning("Map XML file not found: %s.", self._map_xml_path)
+            return
+        tree = ET.parse(self._map_xml_path)
+        self.logger.debug("Map XML file loaded from: %s.", self._map_xml_path)
+        root = tree.getroot()
+        for map_elem in root.iter("map"):
+            map_elem.set("width", str(self.map_width))
+            map_elem.set("height", str(self.map_height))
+            self.logger.debug(
+                "Map size set to %sx%s in Map XML file.", self.map_width, self.map_height
+            )
+        tree.write(self._map_xml_path)
+        self.logger.debug("Map XML file saved to: %s.", self._map_xml_path)
+
+    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.
+
+        Returns:
+            list[str]: An empty list.
+        """
+        return []

maps4fs/generator/dem.py

@@ -0,0 +1,291 @@
+"""This module contains DEM class for processing Digital Elevation Model data."""
+
+import gzip
+import math
+import os
+import shutil
+
+import cv2
+import numpy as np
+import rasterio  # type: ignore
+import requests
+
+from maps4fs.generator.component import Component
+
+SRTM = "https://elevation-tiles-prod.s3.amazonaws.com/skadi/{latitude_band}/{tile_name}.hgt.gz"
+DEFAULT_MULTIPLIER = 1
+DEFAULT_BLUR_RADIUS = 21
+
+
+# pylint: disable=R0903
+class DEM(Component):
+    """Component for map settings and configuration.
+
+    Args:
+        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.
+    """
+
+    def preprocess(self) -> None:
+        self._dem_path = self.game.dem_file_path(self.map_directory)
+        self.temp_dir = "temp"
+        self.hgt_dir = os.path.join(self.temp_dir, "hgt")
+        self.gz_dir = os.path.join(self.temp_dir, "gz")
+        os.makedirs(self.hgt_dir, exist_ok=True)
+        os.makedirs(self.gz_dir, exist_ok=True)
+
+        self.multiplier = self.kwargs.get("multiplier", DEFAULT_MULTIPLIER)
+        blur_radius = self.kwargs.get("blur_radius", DEFAULT_BLUR_RADIUS)
+        if blur_radius % 2 == 0:
+            blur_radius += 1
+        self.blur_radius = blur_radius
+        self.logger.debug(
+            "DEM value multiplier is %s, blur radius is %s.", self.multiplier, self.blur_radius
+        )
+
+    # pylint: disable=no-member
+    def process(self) -> None:
+        """Reads SRTM file, crops it to map size, normalizes and blurs it,
+        saves to map directory."""
+        north, south, east, west = self.bbox
+
+        dem_height = int((self.map_height / 2) * self.game.dem_multipliyer + 1)
+        dem_width = int((self.map_width / 2) * self.game.dem_multipliyer + 1)
+        self.logger.debug(
+            "DEM size multiplier is %s, DEM height is %s, DEM width is %s.",
+            self.game.dem_multipliyer,
+            dem_height,
+            dem_width,
+        )
+        dem_output_resolution = (dem_width, dem_height)
+        self.logger.debug("DEM output resolution: %s.", dem_output_resolution)
+
+        tile_path = self._srtm_tile()
+        if not tile_path:
+            self.logger.warning("Tile was not downloaded, DEM file will be filled with zeros.")
+            self._save_empty_dem(dem_output_resolution)
+            return
+
+        with rasterio.open(tile_path) as src:
+            self.logger.debug("Opened tile, shape: %s, dtype: %s.", src.shape, src.dtypes[0])
+            window = rasterio.windows.from_bounds(west, south, east, north, src.transform)
+            self.logger.debug(
+                "Window parameters. Column offset: %s, row offset: %s, width: %s, height: %s.",
+                window.col_off,
+                window.row_off,
+                window.width,
+                window.height,
+            )
+            data = src.read(1, window=window)
+
+        if not data.size > 0:
+            self.logger.warning("DEM data is empty, DEM file will be filled with zeros.")
+            self._save_empty_dem(dem_output_resolution)
+            return
+
+        self.logger.debug(
+            "DEM data was read from SRTM file. Shape: %s, dtype: %s. Min: %s, max: %s.",
+            data.shape,
+            data.dtype,
+            data.min(),
+            data.max(),
+        )
+
+        resampled_data = cv2.resize(
+            data, dem_output_resolution, interpolation=cv2.INTER_LINEAR
+        ).astype("uint16")
+
+        self.logger.debug(
+            "Maximum value in resampled data: %s, minimum value: %s.",
+            resampled_data.max(),
+            resampled_data.min(),
+        )
+
+        resampled_data = resampled_data * self.multiplier
+        self.logger.debug(
+            "DEM data multiplied by %s. Shape: %s, dtype: %s. Min: %s, max: %s.",
+            self.multiplier,
+            resampled_data.shape,
+            resampled_data.dtype,
+            resampled_data.min(),
+            resampled_data.max(),
+        )
+
+        self.logger.debug(
+            "DEM data was resampled. Shape: %s, dtype: %s. Min: %s, max: %s.",
+            resampled_data.shape,
+            resampled_data.dtype,
+            resampled_data.min(),
+            resampled_data.max(),
+        )
+
+        resampled_data = cv2.GaussianBlur(resampled_data, (self.blur_radius, self.blur_radius), 0)
+        self.logger.debug(
+            "Gaussion blur applied to DEM data with kernel size %s.",
+            self.blur_radius,
+        )
+        self.logger.debug(
+            "DEM data was blurred. Shape: %s, dtype: %s. Min: %s, max: %s.",
+            resampled_data.shape,
+            resampled_data.dtype,
+            resampled_data.min(),
+            resampled_data.max(),
+        )
+
+        cv2.imwrite(self._dem_path, resampled_data)
+        self.logger.debug("DEM data was saved to %s.", self._dem_path)
+
+        if self.game.additional_dem_name is not None:
+            dem_directory = os.path.dirname(self._dem_path)
+            additional_dem_path = os.path.join(dem_directory, self.game.additional_dem_name)
+            shutil.copyfile(self._dem_path, additional_dem_path)
+            self.logger.debug("Additional DEM data was copied to %s.", additional_dem_path)
+
+    def _tile_info(self, lat: float, lon: float) -> tuple[str, str]:
+        """Returns latitude band and tile name for SRTM tile from coordinates.
+
+        Args:
+            lat (float): Latitude.
+            lon (float): Longitude.
+
+        Returns:
+            tuple[str, str]: Latitude band and tile name.
+        """
+        tile_latitude = math.floor(lat)
+        tile_longitude = math.floor(lon)
+
+        latitude_band = f"N{abs(tile_latitude):02d}" if lat >= 0 else f"S{abs(tile_latitude):02d}"
+        if lon < 0:
+            tile_name = f"{latitude_band}W{abs(tile_longitude):03d}"
+        else:
+            tile_name = f"{latitude_band}E{abs(tile_longitude):03d}"
+
+        self.logger.debug(
+            "Detected tile name: %s for coordinates: lat %s, lon %s.", tile_name, lat, lon
+        )
+        return latitude_band, tile_name
+
+    def _download_tile(self) -> str | None:
+        """Downloads SRTM tile from Amazon S3 using coordinates.
+
+        Returns:
+            str: Path to compressed tile or None if download failed.
+        """
+        latitude_band, tile_name = self._tile_info(*self.coordinates)
+        compressed_file_path = os.path.join(self.gz_dir, f"{tile_name}.hgt.gz")
+        url = SRTM.format(latitude_band=latitude_band, tile_name=tile_name)
+        self.logger.debug("Trying to get response from %s...", url)
+        response = requests.get(url, stream=True, timeout=10)
+
+        if response.status_code == 200:
+            self.logger.debug("Response received. Saving to %s...", compressed_file_path)
+            with open(compressed_file_path, "wb") as f:
+                for chunk in response.iter_content(chunk_size=8192):
+                    f.write(chunk)
+            self.logger.debug("Compressed tile successfully downloaded.")
+        else:
+            self.logger.error("Response was failed with status code %s.", response.status_code)
+            return None
+
+        return compressed_file_path
+
+    def _srtm_tile(self) -> str | None:
+        """Determines SRTM tile name from coordinates downloads it if necessary, and decompresses.
+
+        Returns:
+            str: Path to decompressed tile or None if download failed.
+        """
+        latitude_band, tile_name = self._tile_info(*self.coordinates)
+        self.logger.debug("SRTM tile name %s from latitude band %s.", tile_name, latitude_band)
+
+        decompressed_file_path = os.path.join(self.hgt_dir, f"{tile_name}.hgt")
+        if os.path.isfile(decompressed_file_path):
+            self.logger.info(
+                "Decompressed tile already exists: %s, skipping download.",
+                decompressed_file_path,
+            )
+            return decompressed_file_path
+
+        compressed_file_path = self._download_tile()
+        if not compressed_file_path:
+            self.logger.error("Download from SRTM failed, DEM file will be filled with zeros.")
+            return None
+        with gzip.open(compressed_file_path, "rb") as f_in:
+            with open(decompressed_file_path, "wb") as f_out:
+                shutil.copyfileobj(f_in, f_out)
+        self.logger.debug("Tile decompressed to %s.", decompressed_file_path)
+        return decompressed_file_path
+
+    def _save_empty_dem(self, dem_output_resolution: tuple[int, int]) -> None:
+        """Saves empty DEM file filled with zeros."""
+        dem_data = np.zeros(dem_output_resolution, dtype="uint16")
+        cv2.imwrite(self._dem_path, dem_data)  # pylint: disable=no-member
+        self.logger.warning("DEM data filled with zeros and saved to %s.", self._dem_path)
+
+    def grayscale_preview(self) -> str:
+        """Converts DEM image to grayscale RGB image and saves it to the map directory.
+        Returns path to the preview image.
+
+        Returns:
+            str: Path to the preview image.
+        """
+        rgb_dem_path = self._dem_path.replace(".png", "_grayscale.png")
+
+        self.logger.debug("Creating grayscale preview of DEM data in %s.", rgb_dem_path)
+
+        dem_data = cv2.imread(self._dem_path, cv2.IMREAD_GRAYSCALE)
+        dem_data_rgb = cv2.cvtColor(dem_data, cv2.COLOR_GRAY2RGB)
+        cv2.imwrite(rgb_dem_path, dem_data_rgb)
+        return rgb_dem_path
+
+    def colored_preview(self) -> str:
+        """Converts DEM image to colored RGB image and saves it to the map directory.
+        Returns path to the preview image.
+
+        Returns:
+            list[str]: List with a single path to the DEM file
+        """
+
+        colored_dem_path = self._dem_path.replace(".png", "_colored.png")
+
+        self.logger.debug("Creating colored preview of DEM data in %s.", colored_dem_path)
+
+        dem_data = cv2.imread(self._dem_path, cv2.IMREAD_UNCHANGED)
+
+        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
+
+    def previews(self) -> list[str]:
+        """Get list of preview images.
+
+        Returns:
+            list[str]: List of preview images.
+        """
+        self.logger.debug("Starting DEM previews generation.")
+        return [self.grayscale_preview(), self.colored_preview()]

maps4fs/generator/game.py

@@ -0,0 +1,191 @@
+"""This module contains the Game class and its subclasses. Game class is used to define
+different versions of the game for which the map is generated. Each game has its own map
+template file and specific settings for map generation."""
+
+from __future__ import annotations
+
+import os
+
+from maps4fs.generator.config import Config
+from maps4fs.generator.dem import DEM
+from maps4fs.generator.texture import Texture
+
+working_directory = os.getcwd()
+
+
+class Game:
+    """Class used to define different versions of the game for which the map is generated.
+
+    Arguments:
+        map_template_path (str, optional): Path to the map template file. Defaults to None.
+
+    Attributes and Properties:
+        code (str): The code of the game.
+        components (list[Type[Component]]): List of components used for map generation.
+        map_template_path (str): Path to the map template file.
+
+    Public Methods:
+        from_code(cls, code: str) -> Game: Returns the game instance based on the game code.
+    """
+
+    code: str | None = None
+    dem_multipliyer: int = 1
+    _additional_dem_name: str | None = None
+    _map_template_path: str | None = None
+    _texture_schema: str | None = None
+
+    components = [Config, Texture, DEM]
+
+    def __init__(self, map_template_path: str | None = None):
+        if map_template_path:
+            self._map_template_path = map_template_path
+
+    def map_xml_path(self, map_directory: str) -> str:
+        """Returns the path to the map.xml file.
+
+        Arguments:
+            map_directory (str): The path to the map directory.
+
+        Returns:
+            str: The path to the map.xml file.
+        """
+        return os.path.join(map_directory, "maps", "map", "map.xml")
+
+    @classmethod
+    def from_code(cls, code: str) -> Game:
+        """Returns the game instance based on the game code.
+
+        Arguments:
+            code (str): The code of the game.
+
+        Returns:
+            Game: The game instance.
+        """
+        for game in cls.__subclasses__():
+            if game.code and game.code.lower() == code.lower():
+                return game()
+        raise ValueError(f"Game with code {code} not found.")
+
+    @property
+    def template_path(self) -> str:
+        """Returns the path to the map template file.
+
+        Raises:
+            ValueError: If the map template path is not set.
+
+        Returns:
+            str: The path to the map template file."""
+        if not self._map_template_path:
+            raise ValueError("Map template path not set.")
+        return self._map_template_path
+
+    @property
+    def texture_schema(self) -> str:
+        """Returns the path to the texture layers schema file.
+
+        Raises:
+            ValueError: If the texture layers schema path is not set.
+
+        Returns:
+            str: The path to the texture layers schema file."""
+        if not self._texture_schema:
+            raise ValueError("Texture layers schema path not set.")
+        return self._texture_schema
+
+    def dem_file_path(self, map_directory: str) -> str:
+        """Returns the path to the DEM file.
+
+        Arguments:
+            map_directory (str): The path to the map directory.
+
+        Returns:
+            str: The path to the DEM file.
+        """
+        raise NotImplementedError
+
+    def weights_dir_path(self, map_directory: str) -> str:
+        """Returns the path to the weights directory.
+
+        Arguments:
+            map_directory (str): The path to the map directory.
+
+        Returns:
+            str: The path to the weights directory."""
+        raise NotImplementedError
+
+    @property
+    def additional_dem_name(self) -> str | None:
+        """Returns the name of the additional DEM file.
+
+        Returns:
+            str | None: The name of the additional DEM file."""
+        return self._additional_dem_name
+
+
+class FS22(Game):
+    """Class used to define the game version FS22."""
+
+    code = "FS22"
+    _map_template_path = os.path.join(working_directory, "data", "fs22-map-template.zip")
+    _texture_schema = os.path.join(working_directory, "data", "fs22-texture-schema.json")
+
+    def dem_file_path(self, map_directory: str) -> str:
+        """Returns the path to the DEM file.
+
+        Arguments:
+            map_directory (str): The path to the map directory.
+
+        Returns:
+            str: The path to the DEM file."""
+        return os.path.join(map_directory, "maps", "map", "data", "map_dem.png")
+
+    def weights_dir_path(self, map_directory: str) -> str:
+        """Returns the path to the weights directory.
+
+        Arguments:
+            map_directory (str): The path to the map directory.
+
+        Returns:
+            str: The path to the weights directory."""
+        return os.path.join(map_directory, "maps", "map", "data")
+
+
+class FS25(Game):
+    """Class used to define the game version FS25."""
+
+    code = "FS25"
+    dem_multipliyer: int = 2
+    _additional_dem_name = "unprocessedHeightMap.png"
+    _map_template_path = os.path.join(working_directory, "data", "fs25-map-template.zip")
+    _texture_schema = os.path.join(working_directory, "data", "fs25-texture-schema.json")
+
+    def dem_file_path(self, map_directory: str) -> str:
+        """Returns the path to the DEM file.
+
+        Arguments:
+            map_directory (str): The path to the map directory.
+
+        Returns:
+            str: The path to the DEM file."""
+        return os.path.join(map_directory, "mapUS", "data", "dem.png")
+
+    def map_xml_path(self, map_directory: str) -> str:
+        """Returns the path to the map.xml file.
+
+        Arguments:
+            map_directory (str): The path to the map directory.
+
+        Returns:
+            str: The path to the map.xml file.
+        """
+        return os.path.join(map_directory, "mapUS", "mapUS.xml")
+
+    def weights_dir_path(self, map_directory: str) -> str:
+        """Returns the path to the weights directory.
+
+        Arguments:
+            map_directory (str): The path to the map directory.
+
+        Returns:
+            str: The path to the weights directory."""
+        return os.path.join(map_directory, "mapUS", "data")