maps4fs 0.7.9__py3-none-any.whl → 0.8.3__py3-none-any.whl

maps4fs/generator/background.py

@@ -0,0 +1,292 @@
+"""This module contains the Background component, which generates 3D obj files based on DEM data
+around the map."""
+
+from __future__ import annotations
+
+import os
+
+import cv2
+import numpy as np
+import trimesh  # type: ignore
+from pyproj import Transformer
+
+from maps4fs.generator.component import Component
+from maps4fs.generator.path_steps import DEFAULT_DISTANCE, get_steps
+from maps4fs.generator.tile import Tile
+
+RESIZE_FACTOR = 1 / 4
+
+
+class Background(Component):
+    """Component for creating 3D obj files based on DEM data around the map.
+
+    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:
+        """Prepares the component for processing. Registers the tiles around the map by moving
+        clockwise from North, then clockwise."""
+        self.tiles: list[Tile] = []
+        origin = self.coordinates
+
+        # Getting a list of 8 tiles around the map starting from the N(North) tile.
+        for path_step in get_steps(self.map_height, self.map_width):
+            # Getting the destination coordinates for the current tile.
+            tile_coordinates = path_step.get_destination(origin)
+
+            # Create a Tile component, which is needed to save the DEM image.
+            tile = Tile(
+                game=self.game,
+                coordinates=tile_coordinates,
+                map_height=path_step.size[1],
+                map_width=path_step.size[0],
+                map_directory=self.map_directory,
+                logger=self.logger,
+                tile_code=path_step.code,
+                auto_process=False,
+                blur_radius=self.kwargs.get("blur_radius"),
+                multiplier=1,
+            )
+
+            # Update the origin for the next tile.
+            origin = tile_coordinates
+            self.tiles.append(tile)
+            self.logger.debug(
+                "Registered tile: %s, coordinates: %s, size: %s",
+                tile.code,
+                tile_coordinates,
+                path_step.size,
+            )
+
+    def process(self) -> None:
+        """Launches the component processing. Iterates over all tiles and processes them
+        as a result the DEM files will be saved, then based on them the obj files will be
+        generated."""
+        for tile in self.tiles:
+            tile.process()
+
+        self.generate_obj_files()
+
+    def info_sequence(self) -> dict[str, dict[str, str | float | int]]:
+        """Returns a dictionary with information about the tiles around the map.
+        Adds the EPSG:3857 string to the data for convenient usage in QGIS.
+
+        Returns:
+            dict[str, dict[str, float | int]] -- A dictionary with information about the tiles.
+        """
+        data = {}
+        for tile in self.tiles:
+            north, south, east, west = tile.bbox
+
+            # The default CMS in library is EPSG:4326.
+            # It needed to be converted to EPSG:3857 for convinient usage in QGIS.
+
+            transformer = Transformer.from_crs("epsg:4326", "epsg:3857")
+            epsg3857_north, epsg3857_west = transformer.transform(north, west)
+            epsg3857_south, epsg3857_east = transformer.transform(south, east)
+
+            epsg3857_string = (
+                f"{epsg3857_north},{epsg3857_south},{epsg3857_east},{epsg3857_west} [EPSG:3857]"
+            )
+
+            tile_entry = {
+                "center_latitude": tile.coordinates[0],
+                "center_longitude": tile.coordinates[1],
+                "epsg3857_string": epsg3857_string,
+                "height": tile.map_height,
+                "width": tile.map_width,
+                "north": north,
+                "south": south,
+                "east": east,
+                "west": west,
+            }
+            if tile.code is not None:
+                data[tile.code] = tile_entry
+
+        return data  # type: ignore
+
+    def generate_obj_files(self) -> None:
+        """Iterates over all tiles and generates 3D obj files based on DEM data.
+        If at least one DEM file is missing, the generation will be stopped at all.
+        """
+        for tile in self.tiles:
+            # Read DEM data from the tile.
+            dem_path = tile.dem_path
+            if not os.path.isfile(dem_path):
+                self.logger.warning("DEM file not found, generation will be stopped: %s", dem_path)
+                return
+
+            self.logger.info("DEM file for tile %s found: %s", tile.code, dem_path)
+
+            base_directory = os.path.dirname(dem_path)
+            save_path = os.path.join(base_directory, f"{tile.code}.obj")
+            self.logger.debug("Generating obj file for tile %s in path: %s", tile.code, save_path)
+
+            dem_data = cv2.imread(tile.dem_path, cv2.IMREAD_UNCHANGED)  # pylint: disable=no-member
+            self.plane_from_np(dem_data, save_path)
+
+    # pylint: disable=too-many-locals
+    def plane_from_np(self, dem_data: np.ndarray, save_path: str) -> None:
+        """Generates a 3D obj file based on DEM data.
+
+        Arguments:
+            dem_data (np.ndarray) -- The DEM data as a numpy array.
+            save_path (str) -- The path where the obj file will be saved.
+        """
+        dem_data = cv2.resize(  # pylint: disable=no-member
+            dem_data, (0, 0), fx=RESIZE_FACTOR, fy=RESIZE_FACTOR
+        )
+        self.logger.debug(
+            "DEM data resized to shape: %s with factor: %s", dem_data.shape, RESIZE_FACTOR
+        )
+
+        rows, cols = dem_data.shape
+        x = np.linspace(0, cols - 1, cols)
+        y = np.linspace(0, rows - 1, rows)
+        x, y = np.meshgrid(x, y)
+        z = dem_data
+
+        vertices = np.column_stack([x.ravel(), y.ravel(), z.ravel()])
+        faces = []
+
+        for i in range(rows - 1):
+            for j in range(cols - 1):
+                top_left = i * cols + j
+                top_right = top_left + 1
+                bottom_left = top_left + cols
+                bottom_right = bottom_left + 1
+
+                # Invert the order of vertices to flip the normals
+                faces.append([top_left, bottom_right, bottom_left])
+                faces.append([top_left, top_right, bottom_right])
+
+        faces = np.array(faces)  # type: ignore
+        mesh = trimesh.Trimesh(vertices=vertices, faces=faces)
+
+        # Simplify the mesh to reduce the number of faces.
+        mesh = mesh.simplify_quadric_decimation(face_count=len(faces) // 10)
+        self.logger.debug("Mesh simplified to %s faces", len(mesh.faces))
+
+        mesh.export(save_path)
+        self.logger.info("Obj file saved: %s", save_path)
+
+    def previews(self) -> list[str]:
+        """Generates a preview by combining all tiles into one image.
+        NOTE: The map itself is not included in the preview, so it will be empty.
+
+        Returns:
+            list[str] -- A list of paths to the preview images."""
+
+        self.logger.info("Generating a preview image for the background DEM")
+
+        image_height = self.map_height + DEFAULT_DISTANCE * 2
+        image_width = self.map_width + DEFAULT_DISTANCE * 2
+        self.logger.debug("Full size of the preview image: %s x %s", image_width, image_height)
+
+        image = np.zeros((image_height, image_width), np.uint16)  # pylint: disable=no-member
+        self.logger.debug("Empty image created: %s", image.shape)
+
+        for tile in self.tiles:
+            # pylint: disable=no-member
+            tile_image = cv2.imread(tile.dem_path, cv2.IMREAD_UNCHANGED)
+
+            self.logger.debug(
+                "Tile %s image shape: %s, dtype: %s, max: %s, min: %s",
+                tile.code,
+                tile_image.shape,
+                tile_image.dtype,
+                tile_image.max(),
+                tile_image.min(),
+            )
+
+            tile_height, tile_width = tile_image.shape
+            self.logger.debug("Tile %s size: %s x %s", tile.code, tile_width, tile_height)
+
+            # Calculate the position based on the tile code
+            if tile.code == "N":
+                x = DEFAULT_DISTANCE
+                y = 0
+            elif tile.code == "NE":
+                x = self.map_width + DEFAULT_DISTANCE
+                y = 0
+            elif tile.code == "E":
+                x = self.map_width + DEFAULT_DISTANCE
+                y = DEFAULT_DISTANCE
+            elif tile.code == "SE":
+                x = self.map_width + DEFAULT_DISTANCE
+                y = self.map_height + DEFAULT_DISTANCE
+            elif tile.code == "S":
+                x = DEFAULT_DISTANCE
+                y = self.map_height + DEFAULT_DISTANCE
+            elif tile.code == "SW":
+                x = 0
+                y = self.map_height + DEFAULT_DISTANCE
+            elif tile.code == "W":
+                x = 0
+                y = DEFAULT_DISTANCE
+            elif tile.code == "NW":
+                x = 0
+                y = 0
+
+            # pylint: disable=possibly-used-before-assignment
+            x2 = x + tile_width
+            y2 = y + tile_height
+
+            self.logger.debug(
+                "Tile %s position. X from %s to %s, Y from %s to %s", tile.code, x, x2, y, y2
+            )
+
+            # pylint: disable=possibly-used-before-assignment
+            image[y:y2, x:x2] = tile_image
+
+        # Save image to the map directory.
+        preview_path = os.path.join(self.previews_directory, "background_dem.png")
+
+        # pylint: disable=no-member
+        image = cv2.normalize(image, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U)  # type: ignore
+        image = cv2.cvtColor(image, cv2.COLOR_GRAY2BGR)  # type: ignore
+        cv2.imwrite(preview_path, image)
+
+        return [preview_path]
+
+
+# Creates tiles around the map.
+# The one on corners 2048x2048, on sides and in the middle map_size x 2048.
+# So 2048 is a distance FROM the edge of the map, but the other size depends on the map size.
+# But for corner tiles it's always 2048.
+
+# In the beginning we have coordinates of the central point of the map and it's size.
+# We need to calculate the coordinates of central points all 8 tiles around the map.
+
+# Latitude is a vertical line, Longitude is a horizontal line.
+
+#                         2048
+#                     |         |
+# ____________________|_________|___
+# |         |         |         |
+# |    NW   |    N    |    NE   |    2048
+# |_________|_________|_________|___
+# |         |         |         |
+# |    W    |    C    |    E    |
+# |_________|_________|_________|
+# |         |         |         |
+# |    SW   |    S    |    SE   |
+# |_________|_________|_________|
+#
+# N = C map_height / 2 + 1024; N_width = map_width; N_height = 2048
+# NW = N - map_width / 2 - 1024; NW_width = 2048; NW_height = 2048
+# and so on...
+
+# lat, lon = 45.28565000315636, 20.237121355049904
+# dst = 1024
+
+# # N
+# destination = distance(meters=dst).destination((lat, lon), 0)
+# lat, lon = destination.latitude, destination.longitude
+# print(lat, lon)

maps4fs/generator/component.py

@@ -2,6 +2,9 @@
 
 from __future__ import annotations
 
+import json
+import os
+from copy import deepcopy
 from typing import TYPE_CHECKING, Any
 
 import osmnx as ox  # type: ignore
@@ -15,6 +18,7 @@ class Component:
     """Base class for all map generation components.
 
     Args:
+        game (Game): The game instance for which the map is generated.
         coordinates (tuple[float, float]): The latitude and longitude of the center of the map.
         map_height (int): The height of the map in pixels.
         map_width (int): The width of the map in pixels.
@@ -41,6 +45,8 @@ class Component:
         self.logger = logger
         self.kwargs = kwargs
 
+        os.makedirs(self.previews_directory, exist_ok=True)
+
         self.save_bbox()
         self.preprocess()
 
@@ -68,6 +74,66 @@ class Component:
         """
         raise NotImplementedError
 
+    @property
+    def previews_directory(self) -> str:
+        """The directory where the preview images are stored.
+
+        Returns:
+            str: The directory where the preview images are stored.
+        """
+        return os.path.join(self.map_directory, "previews")
+
+    @property
+    def generation_info_path(self) -> str:
+        """The path to the generation info JSON file.
+
+        Returns:
+            str: The path to the generation info JSON file.
+        """
+        return os.path.join(self.map_directory, "generation_info.json")
+
+    def info_sequence(self) -> dict[Any, Any]:
+        """Returns the information sequence for the component. Must be implemented in the child
+        class. If the component does not have an information sequence, an empty dictionary must be
+        returned.
+
+        Returns:
+            dict[Any, Any]: The information sequence for the component.
+        """
+        return {}
+
+    def commit_generation_info(self) -> None:
+        """Commits the generation info to the generation info JSON file."""
+        self.update_generation_info(self.info_sequence())
+
+    def update_generation_info(self, data: dict[Any, Any]) -> None:
+        """Updates the generation info with the provided data.
+        If the generation info file does not exist, it will be created.
+
+        Args:
+            data (dict[Any, Any]): The data to update the generation info with.
+        """
+        if os.path.isfile(self.generation_info_path):
+            with open(self.generation_info_path, "r", encoding="utf-8") as file:
+                generation_info = json.load(file)
+                self.logger.debug("Loaded generation info from %s", self.generation_info_path)
+        else:
+            self.logger.debug(
+                "Generation info file does not exist, creating a new one in %s",
+                self.generation_info_path,
+            )
+            generation_info = {}
+
+        updated_generation_info = deepcopy(generation_info)
+        updated_generation_info[self.__class__.__name__] = data
+
+        self.logger.debug("Updated generation info, now contains %s fields", len(data))
+
+        with open(self.generation_info_path, "w", encoding="utf-8") as file:
+            json.dump(updated_generation_info, file, indent=4)
+
+        self.logger.debug("Saved updated generation info to %s", self.generation_info_path)
+
     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.

maps4fs/generator/config.py

@@ -22,13 +22,15 @@ class Config(Component):
     """
 
     def preprocess(self) -> None:
+        """Gets the path to the map XML file and saves it to the instance variable."""
         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):
+    def process(self) -> None:
+        """Sets the map size in the map.xml file."""
         self._set_map_size()
 
-    def _set_map_size(self):
+    def _set_map_size(self) -> None:
         """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)

maps4fs/generator/dem.py

@@ -14,12 +14,12 @@ 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
+DEFAULT_BLUR_RADIUS = 35
 
 
 # pylint: disable=R0903
 class DEM(Component):
-    """Component for map settings and configuration.
+    """Component for processing Digital Elevation Model data.
 
     Args:
         coordinates (tuple[float, float]): The latitude and longitude of the center of the map.
@@ -40,19 +40,33 @@ class DEM(Component):
 
         self.multiplier = self.kwargs.get("multiplier", DEFAULT_MULTIPLIER)
         blur_radius = self.kwargs.get("blur_radius", DEFAULT_BLUR_RADIUS)
-        if blur_radius % 2 == 0:
+        if blur_radius is None or blur_radius <= 0:
+            # We'll disable blur if the radius is 0 or negative.
+            blur_radius = 0
+        elif 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
+        self.auto_process = self.kwargs.get("auto_process", False)
+
+    @property
+    def dem_path(self) -> str:
+        """Returns path to the DEM file.
 
+        Returns:
+            str: Path to the DEM file.
+        """
+        return self._dem_path
+
+    def get_output_resolution(self) -> tuple[int, int]:
+        """Get output resolution for DEM data.
+
+        Returns:
+            tuple[int, int]: Output resolution for DEM data.
+        """
         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(
@@ -61,7 +75,15 @@ class DEM(Component):
             dem_height,
             dem_width,
         )
-        dem_output_resolution = (dem_width, dem_height)
+        return dem_width, dem_height
+
+    # 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_output_resolution = self.get_output_resolution()
         self.logger.debug("DEM output resolution: %s.", dem_output_resolution)
 
         tile_path = self._srtm_tile()
@@ -105,15 +127,12 @@ class DEM(Component):
             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(),
-        )
+        if self.auto_process:
+            self.logger.debug("Auto processing is enabled, will normalize DEM data.")
+            resampled_data = self._normalize_dem(resampled_data)
+        else:
+            self.logger.debug("Auto processing is disabled, DEM data will not be normalized.")
+            resampled_data = resampled_data * self.multiplier
 
         self.logger.debug(
             "DEM data was resampled. Shape: %s, dtype: %s. Min: %s, max: %s.",
@@ -123,11 +142,15 @@ class DEM(Component):
             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,
-        )
+        if self.blur_radius > 0:
+            resampled_data = cv2.GaussianBlur(
+                resampled_data, (self.blur_radius, self.blur_radius), sigmaX=40, sigmaY=40
+            )
+            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,
@@ -140,10 +163,20 @@ class DEM(Component):
         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)
+            self.make_copy(self.game.additional_dem_name)
+
+    def make_copy(self, dem_name: str) -> None:
+        """Copies DEM data to additional DEM file.
+
+        Args:
+            dem_name (str): Name of the additional DEM file.
+        """
+        dem_directory = os.path.dirname(self._dem_path)
+
+        additional_dem_path = os.path.join(dem_directory, 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.
@@ -233,14 +266,15 @@ class DEM(Component):
         Returns:
             str: Path to the preview image.
         """
-        rgb_dem_path = self._dem_path.replace(".png", "_grayscale.png")
+        # rgb_dem_path = self._dem_path.replace(".png", "_grayscale.png")
+        grayscale_dem_path = os.path.join(self.previews_directory, "dem_grayscale.png")
 
-        self.logger.debug("Creating grayscale preview of DEM data in %s.", rgb_dem_path)
+        self.logger.debug("Creating grayscale preview of DEM data in %s.", grayscale_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
+        cv2.imwrite(grayscale_dem_path, dem_data_rgb)
+        return grayscale_dem_path
 
     def colored_preview(self) -> str:
         """Converts DEM image to colored RGB image and saves it to the map directory.
@@ -250,7 +284,8 @@ class DEM(Component):
             list[str]: List with a single path to the DEM file
         """
 
-        colored_dem_path = self._dem_path.replace(".png", "_colored.png")
+        # colored_dem_path = self._dem_path.replace(".png", "_colored.png")
+        colored_dem_path = os.path.join(self.previews_directory, "dem_colored.png")
 
         self.logger.debug("Creating colored preview of DEM data in %s.", colored_dem_path)
 
@@ -289,3 +324,51 @@ class DEM(Component):
         """
         self.logger.debug("Starting DEM previews generation.")
         return [self.grayscale_preview(), self.colored_preview()]
+
+    def _get_scaling_factor(self, maximum_deviation: int) -> float:
+        """Calculate scaling factor for DEM data normalization.
+        NOTE: Needs reconsideration for the implementation.
+
+        Args:
+            maximum_deviation (int): Maximum deviation in DEM data.
+
+        Returns:
+            float: Scaling factor for DEM data normalization.
+        """
+        ESTIMATED_MAXIMUM_DEVIATION = 1000  # pylint: disable=C0103
+        scaling_factor = maximum_deviation / ESTIMATED_MAXIMUM_DEVIATION
+        return scaling_factor if scaling_factor < 1 else 1
+
+    def _normalize_dem(self, data: np.ndarray) -> np.ndarray:
+        """Normalize DEM data to 16-bit unsigned integer using max height from settings.
+        Args:
+            data (np.ndarray): DEM data from SRTM file after cropping.
+        Returns:
+            np.ndarray: Normalized DEM data.
+        """
+        self.logger.debug("Starting DEM data normalization.")
+        # Calculate the difference between the maximum and minimum values in the DEM data.
+
+        max_height = data.max()  # 1800
+        min_height = data.min()  # 1700
+        max_dev = max_height - min_height  # 100
+        self.logger.debug(
+            "Maximum deviation: %s with maximum at %s and minimum at %s.",
+            max_dev,
+            max_height,
+            min_height,
+        )
+
+        scaling_factor = self._get_scaling_factor(max_dev)
+        adjusted_max_height = int(65535 * scaling_factor)
+        self.logger.debug(
+            f"Maximum deviation: {max_dev}. Scaling factor: {scaling_factor}. "
+            f"Adjusted max height: {adjusted_max_height}."
+        )
+        normalized_data = (
+            (data - data.min()) / (data.max() - data.min()) * adjusted_max_height
+        ).astype("uint16")
+        self.logger.debug(
+            f"DEM data was normalized to {normalized_data.min()} - {normalized_data.max()}."
+        )
+        return normalized_data

maps4fs/generator/game.py

@@ -6,8 +6,10 @@ from __future__ import annotations
 
 import os
 
+from maps4fs.generator.background import Background
 from maps4fs.generator.config import Config
 from maps4fs.generator.dem import DEM
+from maps4fs.generator.i3d import I3d
 from maps4fs.generator.texture import Texture
 
 working_directory = os.getcwd()
@@ -34,7 +36,7 @@ class Game:
     _map_template_path: str | None = None
     _texture_schema: str | None = None
 
-    components = [Config, Texture, DEM]
+    components = [Config, Texture, DEM, I3d, Background]
 
     def __init__(self, map_template_path: str | None = None):
         if map_template_path:
@@ -113,6 +115,16 @@ class Game:
             str: The path to the weights directory."""
         raise NotImplementedError
 
+    def i3d_file_path(self, map_directory: str) -> str:
+        """Returns the path to the i3d file.
+
+        Arguments:
+            map_directory (str): The path to the map directory.
+
+        Returns:
+            str: The path to the i3d file."""
+        raise NotImplementedError
+
     @property
     def additional_dem_name(self) -> str | None:
         """Returns the name of the additional DEM file.
@@ -122,6 +134,7 @@ class Game:
         return self._additional_dem_name
 
 
+# pylint: disable=W0223
 class FS22(Game):
     """Class used to define the game version FS22."""
 
@@ -189,3 +202,13 @@ class FS25(Game):
         Returns:
             str: The path to the weights directory."""
         return os.path.join(map_directory, "mapUS", "data")
+
+    def i3d_file_path(self, map_directory: str) -> str:
+        """Returns the path to the i3d file.
+
+        Arguments:
+            map_directory (str): The path to the map directory.
+
+        Returns:
+            str: The path to the i3d file."""
+        return os.path.join(map_directory, "mapUS", "mapUS.i3d")