maps4fs 2.8.9__py3-none-any.whl → 2.9.37__py3-none-any.whl

maps4fs/generator/component/texture.py

@@ -7,10 +7,10 @@ import os
 import shutil
 import warnings
 from collections import defaultdict
-from time import perf_counter
 from typing import Any, Callable, Generator, Optional
 
 import cv2
+import geopandas as gpd
 import numpy as np
 import osmnx as ox
 import pandas as pd
@@ -21,6 +21,7 @@ from tqdm import tqdm
 
 from maps4fs.generator.component.base.component_image import ImageComponent
 from maps4fs.generator.component.layer import Layer
+from maps4fs.generator.monitor import monitor_performance
 from maps4fs.generator.settings import Parameters
 
 
@@ -167,6 +168,14 @@ class Texture(ImageComponent):
         """
         return [layer for layer in self.layers if layer.indoor]
 
+    def get_building_category_layers(self) -> list[Layer]:
+        """Returns layers which have building category defined.
+
+        Returns:
+            list[Layer]: List of layers which have building category defined.
+        """
+        return [layer for layer in self.layers if layer.building_category is not None]
+
     def process(self) -> None:
         """Processes the data to generate textures."""
         self._prepare_weights()
@@ -186,6 +195,7 @@ class Texture(ImageComponent):
         for layer in self.layers:
             self.assets[layer.name] = layer.path(self._weights_dir)
 
+    @monitor_performance
     def add_borders(self) -> None:
         """Iterates over all the layers and picks the one which have the border propety defined.
         Borders are distance from the edge of the map on each side (top, right, bottom, left).
@@ -272,6 +282,7 @@ class Texture(ImageComponent):
                 return layer
         return None
 
+    @monitor_performance
     def merge_into(self) -> None:
         """Merges the content of layers into their target layers."""
         for layer in self.layers:
@@ -298,6 +309,7 @@ class Texture(ImageComponent):
                     cv2.imwrite(layer.path(self._weights_dir), np.zeros_like(layer_image))
                     self.logger.debug("Cleared layer %s.", layer.name)
 
+    @monitor_performance
     def rotate_textures(self) -> None:
         """Rotates textures of the layers which have tags."""
         if self.rotation:
@@ -320,6 +332,7 @@ class Texture(ImageComponent):
                         "Skipping rotation of layer %s because it has no tags.", layer.name
                     )
 
+    @monitor_performance
     def scale_textures(self) -> None:
         """Resizes all the textures to the map output size."""
         if not self.map.output_size:
@@ -364,6 +377,7 @@ class Texture(ImageComponent):
         ]
         return {attr: getattr(self, attr, None) for attr in useful_attributes}
 
+    @monitor_performance
     def _prepare_weights(self):
         self.logger.debug("Starting preparing weights from %s layers.", len(self.layers))
 
@@ -428,6 +442,7 @@ class Texture(ImageComponent):
             ),
         )
 
+    @monitor_performance
     def draw(self) -> None:
         """Iterates over layers and fills them with polygons from OSM data."""
         layers = self.layers_by_priority()
@@ -462,8 +477,11 @@ class Texture(ImageComponent):
             self._draw_layer(layer, info_layer_data, layer_image)  # type: ignore
             self._add_roads(layer, info_layer_data)
 
-            output_image = cv2.bitwise_and(layer_image, mask)  # type: ignore
-            cumulative_image = cv2.bitwise_or(cumulative_image, output_image)  # type: ignore
+            if not layer.external:
+                output_image = cv2.bitwise_and(layer_image, mask)  # type: ignore
+                cumulative_image = cv2.bitwise_or(cumulative_image, output_image)  # type: ignore
+            else:
+                output_image = layer_image  # type: ignore
 
             cv2.imwrite(layer_path, output_image)
             self.logger.debug("Texture %s saved.", layer_path)
@@ -543,9 +561,11 @@ class Texture(ImageComponent):
                     "points": linestring,
                     "tags": str(layer.tags),
                     "width": layer.width,
+                    "road_texture": layer.road_texture,
                 }
                 info_layer_data[f"{layer.info_layer}_polylines"].append(linestring_entry)  # type: ignore
 
+    @monitor_performance
     def dissolve(self) -> None:
         """Dissolves textures of the layers with tags into sublayers for them to look more
         natural in the game.
@@ -554,46 +574,52 @@ class Texture(ImageComponent):
         files of the corresponding layer and saves the changes to the files.
         """
         for layer in tqdm(self.layers, desc="Dissolving textures", unit="layer"):
-            if not layer.tags:
-                self.logger.debug("Layer %s has no tags, there's nothing to dissolve.", layer.name)
-                continue
-            layer_path = layer.path(self._weights_dir)
-            layer_paths = layer.paths(self._weights_dir)
-
-            if len(layer_paths) < 2:
-                self.logger.debug("Layer %s has only one texture, skipping.", layer.name)
-                continue
-
-            self.logger.debug("Dissolving layer from %s to %s.", layer_path, layer_paths)
+            self.dissolve_layer(layer)
 
-            # Check if the image contains any non-zero values, otherwise continue.
-            layer_image = cv2.imread(layer_path, cv2.IMREAD_UNCHANGED)
+    def dissolve_layer(self, layer: Layer) -> None:
+        """Dissolves texture of the layer into sublayers."""
+        if not layer.tags:
+            self.logger.debug("Layer %s has no tags, there's nothing to dissolve.", layer.name)
+            return
+        layer_path = layer.path(self._weights_dir)
+        layer_paths = layer.paths(self._weights_dir)
 
-            if not np.any(layer_image):  # type: ignore
-                self.logger.debug(
-                    "Layer %s does not contain any non-zero values, skipping.", layer.name
-                )
-                continue
+        if len(layer_paths) < 2:
+            self.logger.debug("Layer %s has only one texture, skipping.", layer.name)
+            return
 
-            # Save the original image to use it for preview later, without combining the sublayers.
-            cv2.imwrite(layer.path_preview(self._weights_dir), layer_image.copy())  # type: ignore
+        self.logger.debug("Dissolving layer from %s to %s.", layer_path, layer_paths)
+        # Check if the image contains any non-zero values, otherwise continue.
+        layer_image = cv2.imread(layer_path, cv2.IMREAD_UNCHANGED)
+        if layer_image is None:
+            self.logger.debug("Layer %s image not found, skipping.", layer.name)
+            return
 
-            # Get the coordinates of non-zero values.
-            non_zero_coords = np.column_stack(np.where(layer_image > 0))  # type: ignore
+        # Get mask of non-zero pixels. If there are no non-zero pixels, skip the layer.
+        mask = layer_image > 0
+        if not np.any(mask):
+            self.logger.debug(
+                "Layer %s does not contain any non-zero values, skipping.", layer.name
+            )
+            return
+        # Save the original image to use it for preview later, without combining the sublayers.
+        cv2.imwrite(layer.path_preview(self._weights_dir), layer_image.copy())  # type: ignore
 
-            # Prepare sublayers.
-            sublayers = [np.zeros_like(layer_image) for _ in range(layer.count)]
+        # Create random assignment array for all pixels
+        random_assignment = np.random.randint(0, layer.count, size=layer_image.shape)
 
-            # Randomly assign non-zero values to sublayers.
-            for coord in non_zero_coords:
-                sublayers[np.random.randint(0, layer.count)][coord[0], coord[1]] = 255  # type: ignore
+        # Create sublayers using vectorized operations.
+        sublayers = []
+        for i in range(layer.count):
+            # Create sublayer: 255 where (mask is True AND random_assignment == i)
+            sublayer = np.where((mask) & (random_assignment == i), 255, 0).astype(np.uint8)
+            sublayers.append(sublayer)
 
-            # Save the sublayers.
-            for sublayer, sublayer_path in zip(sublayers, layer_paths):
-                cv2.imwrite(sublayer_path, sublayer)
-                self.logger.debug("Sublayer %s saved.", sublayer_path)
+        # Save sublayers
+        for sublayer, sublayer_path in zip(sublayers, layer_paths):
+            cv2.imwrite(sublayer_path, sublayer)
 
-            self.logger.debug("Dissolved layer %s.", layer.name)
+        self.logger.debug("Dissolved layer %s.", layer.name)
 
     def draw_base_layer(self, cumulative_image: np.ndarray) -> None:
         """Draws base layer and saves it into the png file.
@@ -789,37 +815,49 @@ class Texture(ImageComponent):
         is_fieds = info_layer == "fields"
 
         ox_settings.use_cache = self.map.texture_settings.use_cache
-        ox_settings.requests_timeout = 30
+        ox_settings.requests_timeout = 10
 
+        objects = self.fetch_osm_data(tags)
+        if objects is None or objects.empty:
+            self.logger.debug("No objects found for tags: %s.", tags)
+            return
+
+        self.logger.debug("Fetched %s elements for tags: %s.", len(objects), tags)
+
+        method = self.linestrings_generator if yield_linestrings else self.polygons_generator
+
+        yield from method(objects, width, is_fieds)
+
+    @monitor_performance
+    def fetch_osm_data(self, tags: dict[str, str | list[str] | bool]) -> gpd.GeoDataFrame | None:
+        """Fetches OSM data for given tags.
+
+        Arguments:
+            tags (dict[str, str | list[str] | bool]): Dictionary of tags to search for.
+
+        Returns:
+            gpd.GeoDataFrame | None: GeoDataFrame with OSM objects or None if no objects found.
+        """
         try:
             if self.map.custom_osm is not None:
                 with warnings.catch_warnings():
                     warnings.simplefilter("ignore", FutureWarning)
                     objects = ox.features_from_xml(self.map.custom_osm, tags=tags)
             else:
-                before_fetch = perf_counter()
                 objects = ox.features_from_bbox(bbox=self.new_bbox, tags=tags)
-                after_fetch = perf_counter()
-                fetched_in = after_fetch - before_fetch
-                self.logger.info(
-                    "Fetched OSMNX objects for tags: %s in %.2f seconds.", tags, fetched_in
-                )
         except Exception as e:
-            self.logger.debug("Error fetching objects for tags: %s. Error: %s.", tags, e)
-            return
-        self.logger.debug("Fetched %s elements for tags: %s.", len(objects), tags)
+            self.logger.warning("Error fetching objects for tags: %s. Error: %s.", tags, e)
+            return None
 
-        method = self.linestrings_generator if yield_linestrings else self.polygons_generator
-
-        yield from method(objects, width, is_fieds)
+        return objects
 
     def linestrings_generator(
-        self, objects: pd.core.frame.DataFrame, *args, **kwargs
+        self, objects: gpd.GeoDataFrame, *args, **kwargs
     ) -> Generator[list[tuple[int, int]], None, None]:
         """Generator which yields lists of point coordinates which represent LineStrings from OSM.
 
         Arguments:
-            objects (pd.core.frame.DataFrame): Dataframe with OSM objects.
+            objects (gpd.GeoDataFrame): GeoDataFrame with OSM objects.
 
         Yields:
             Generator[list[tuple[int, int]], None, None]: List of point coordinates.
@@ -865,6 +903,7 @@ class Texture(ImageComponent):
             polygon_np = self._to_np(polygon)
             yield polygon_np
 
+    @monitor_performance
     def previews(self) -> list[str]:
         """Invokes methods to generate previews. Returns list of paths to previews.
 

maps4fs/generator/config.py

@@ -40,7 +40,7 @@ logger.info(
 )
 
 TEMPLATES_STRUCTURE = {
-    "fs25": ["texture_schemas", "tree_schemas", "map_templates"],
+    "fs25": ["texture_schemas", "tree_schemas", "buildings_schemas", "map_templates"],
     "fs22": ["texture_schemas", "map_templates"],
 }
 
@@ -51,11 +51,19 @@ def ensure_templates():
     If MFS_TEMPLATES_DIR is empty or doesn't exist, clone the maps4fsdata
     repository and run the preparation script to populate it.
     """
-
     # Check if templates directory exists and has content
-    if os.path.exists(MFS_TEMPLATES_DIR) and os.listdir(MFS_TEMPLATES_DIR):
-        logger.info("Templates directory already exists and contains data: %s", MFS_TEMPLATES_DIR)
-        return
+    if os.path.exists(MFS_TEMPLATES_DIR):  # and os.listdir(MFS_TEMPLATES_DIR):
+        logger.info("Templates directory already exists: %s", MFS_TEMPLATES_DIR)
+
+        files = [
+            entry
+            for entry in os.listdir(MFS_TEMPLATES_DIR)
+            if os.path.isfile(os.path.join(MFS_TEMPLATES_DIR, entry))
+        ]
+
+        if files:
+            logger.info("Templates directory contains files and will not be modified.")
+            return
 
     logger.info("Templates directory is empty or missing, preparing data...")
 
@@ -82,15 +90,31 @@ def ensure_templates():
                 text=True,
             )
 
-            # Make the preparation script executable
-            prep_script = os.path.join(clone_dir, "prepare_data.sh")
+            if os.name == "nt":
+                logger.info("Detected Windows OS, running PowerShell preparation script...")
+                prep_script = os.path.join(clone_dir, "prepare_data.ps1")
+                for_subprocess = [
+                    "powershell",
+                    "-ExecutionPolicy",
+                    "Bypass",
+                    "-File",
+                    "prepare_data.ps1",
+                ]
+            else:
+                logger.info("Detected non-Windows OS, running bash preparation script...")
+                prep_script = os.path.join(clone_dir, "prepare_data.sh")
+                for_subprocess = ["./prepare_data.sh"]
+
             if os.path.exists(prep_script):
-                os.chmod(prep_script, 0o755)
+                try:
+                    os.chmod(prep_script, 0o755)
+                except Exception as e:
+                    logger.warning("Could not set execute permissions on script: %s", str(e))
 
                 logger.info("Running data preparation script...")
                 # Run the preparation script from the cloned directory
                 subprocess.run(
-                    ["./prepare_data.sh"], cwd=clone_dir, check=True, capture_output=True, text=True
+                    for_subprocess, cwd=clone_dir, check=True, capture_output=True, text=True
                 )
 
                 # Copy the generated data directory to templates directory
@@ -140,6 +164,27 @@ def ensure_template_subdirs() -> None:
     logger.info("Templates directory is ready at: %s", MFS_TEMPLATES_DIR)
 
 
+def reload_templates() -> None:
+    """Reload templates by removing existing files and re-preparing them.
+    Does not affect nested directories containing user data.
+    If needed, the files should be removed manually.
+    """
+    logger.info("Reloading templates...")
+    # Remove files from the templates directory.
+    # But do not remove nested directories, because they contain user data.
+    # Only remove files in the top-level templates directory.
+    for item in os.listdir(MFS_TEMPLATES_DIR):
+        item_path = os.path.join(MFS_TEMPLATES_DIR, item)
+        if os.path.isfile(item_path):
+            try:
+                os.remove(item_path)
+            except Exception as e:
+                logger.warning("Could not remove file %s: %s", item_path, str(e))
+    ensure_templates()
+    ensure_template_subdirs()
+    logger.info("Templates reloaded successfully.")
+
+
 ensure_templates()
 ensure_template_subdirs()
 
@@ -160,8 +205,31 @@ SAT_CACHE_DIR = os.path.join(MFS_CACHE_DIR, "sat")
 
 osmnx_cache = os.path.join(MFS_CACHE_DIR, "osmnx")
 osmnx_data = os.path.join(MFS_CACHE_DIR, "odata")
-os.makedirs(osmnx_cache, exist_ok=True)
-os.makedirs(osmnx_data, exist_ok=True)
+
+CACHE_DIRS = [DTM_CACHE_DIR, SAT_CACHE_DIR, osmnx_cache, osmnx_data]
+
+
+def create_cache_dirs() -> None:
+    """Create cache directories if they do not exist."""
+    logger.info("Ensuring cache directories exist...")
+    for cache_dir in CACHE_DIRS:
+        os.makedirs(cache_dir, exist_ok=True)
+        logger.debug("Cache directory ensured: %s", cache_dir)
+    logger.info("All cache directories are ready.")
+
+
+def clean_cache() -> None:
+    """Clean all cache directories by removing and recreating them."""
+    logger.info("Cleaning cache directories...")
+    for cache_dir in CACHE_DIRS:
+        if os.path.exists(cache_dir):
+            shutil.rmtree(cache_dir)
+            logger.debug("Removed cache directory: %s", cache_dir)
+    create_cache_dirs()
+    logger.info("Cache directories cleaned and recreated.")
+
+
+create_cache_dirs()
 
 
 ox_settings.cache_folder = osmnx_cache

maps4fs/generator/game.py

@@ -5,12 +5,15 @@ template file and specific settings for map generation."""
 from __future__ import annotations
 
 import os
+from typing import Callable
 
 import maps4fs.generator.config as mfscfg
 from maps4fs.generator.component.background import Background
+from maps4fs.generator.component.building import Building
 from maps4fs.generator.component.config import Config
 from maps4fs.generator.component.grle import GRLE
 from maps4fs.generator.component.i3d import I3d
+from maps4fs.generator.component.road import Road
 from maps4fs.generator.component.satellite import Satellite
 from maps4fs.generator.component.texture import Texture
 
@@ -37,6 +40,7 @@ class Game:
     _texture_schema_file: str | None = None
     _grle_schema_file: str | None = None
     _tree_schema_file: str | None = None
+    _buildings_schema_file: str | None = None
     _i3d_processing: bool = True
     _plants_processing: bool = True
     _environment_processing: bool = True
@@ -45,7 +49,7 @@ class Game:
     _mesh_processing: bool = True
 
     # Order matters! Some components depend on others.
-    components = [Satellite, Texture, Background, GRLE, I3d, Config]
+    components = [Satellite, Texture, Background, GRLE, I3d, Config, Road, Building]
 
     def __init__(self, map_template_path: str | None = None):
         if map_template_path:
@@ -72,6 +76,11 @@ class Game:
         else:
             self._tree_schema = os.path.join(mfscfg.MFS_TEMPLATES_DIR, self._tree_schema_file)  # type: ignore
 
+        if not self._buildings_schema_file:
+            self._buildings_schema_file = None
+        else:
+            self._buildings_schema_file = os.path.join(mfscfg.MFS_TEMPLATES_DIR, self._buildings_schema_file)  # type: ignore
+
     def set_components_by_names(self, component_names: list[str]) -> None:
         """Sets the components used for map generation by their names.
 
@@ -159,6 +168,19 @@ class Game:
             raise ValueError("Tree layers schema path not set.")
         return self._tree_schema
 
+    @property
+    def buildings_schema(self) -> str:
+        """Returns the path to the buildings layers schema file.
+
+        Raises:
+            ValueError: If the buildings layers schema path is not set.
+
+        Returns:
+            str: The path to the buildings layers schema file."""
+        if not self._buildings_schema_file:
+            raise ValueError("Buildings layers schema path not set.")
+        return self._buildings_schema_file
+
     def dem_file_path(self, map_directory: str) -> str:
         """Returns the path to the DEM file.
 
@@ -166,8 +188,7 @@ class Game:
             map_directory (str): The path to the map directory.
 
         Returns:
-            str: The path to the DEM file.
-        """
+            str: The path to the DEM file."""
         raise NotImplementedError
 
     def weights_dir_path(self, map_directory: str) -> str:
@@ -341,6 +362,45 @@ class Game:
             bool: True if the mesh should be processed, False otherwise."""
         return self._mesh_processing
 
+    def validate_template(self, map_directory: str) -> None:
+        """Validates that all required files exist in the map template directory.
+
+        Arguments:
+            map_directory (str): The path to the map directory.
+
+        Raises:
+            FileNotFoundError: If any required files are missing from the template.
+        """
+        all_files = []
+        for root, _, files in os.walk(map_directory):
+            for file in files:
+                all_files.append(os.path.join(root, file))
+
+        missing_files = []
+        for func in self.required_file_methods():
+            try:
+                required_filepath = func(map_directory)
+            except NotImplementedError:
+                continue
+            if required_filepath not in all_files:
+                missing_files.append(required_filepath)
+        if missing_files:
+            raise FileNotFoundError(f"The following files are not found: {missing_files}.")
+
+    def required_file_methods(self) -> list[Callable[[str], str]]:
+        """Returns a list of methods that return paths to required files for map generation.
+
+        Returns:
+            list[Callable[[str], str]]: List of methods that take a map directory path
+                and return file paths that are required for the map template.
+        """
+        return [
+            self.map_xml_path,
+            self.i3d_file_path,
+            self.get_environment_xml_path,
+            self.get_farmlands_xml_path,
+        ]
+
 
 class FS22(Game):
     """Class used to define the game version FS22."""
@@ -396,6 +456,7 @@ class FS25(Game):
     _texture_schema_file = "fs25-texture-schema.json"
     _grle_schema_file = "fs25-grle-schema.json"
     _tree_schema_file = "fs25-tree-schema.json"
+    _buildings_schema_file = "fs25-buildings-schema.json"
 
     def dem_file_path(self, map_directory: str) -> str:
         """Returns the path to the DEM file.

maps4fs/generator/map.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import json
 import os
 import shutil
+from time import perf_counter
 from typing import Any, Generator
 
 from pydtmdl import DTMProvider
@@ -14,8 +15,13 @@ import maps4fs.generator.config as mfscfg
 import maps4fs.generator.utils as mfsutils
 from maps4fs.generator.component import Background, Component, Layer, Satellite, Texture
 from maps4fs.generator.game import Game
+from maps4fs.generator.monitor import PerformanceMonitor, performance_session
 from maps4fs.generator.settings import GenerationSettings, MainSettings, SharedSettings
-from maps4fs.generator.statistics import send_advanced_settings, send_main_settings
+from maps4fs.generator.statistics import (
+    send_advanced_settings,
+    send_main_settings,
+    send_performance_report,
+)
 from maps4fs.logger import Logger
 
 
@@ -99,6 +105,7 @@ class Map:
         self.i3d_settings = generation_settings.i3d_settings
         self.texture_settings = generation_settings.texture_settings
         self.satellite_settings = generation_settings.satellite_settings
+        self.building_settings = generation_settings.building_settings
         self.process_settings()
 
         self.logger = logger if logger else Logger()
@@ -117,11 +124,13 @@ class Map:
         os.makedirs(self.map_directory, exist_ok=True)
         self.texture_custom_schema = kwargs.get("texture_custom_schema", None)
         self.tree_custom_schema = kwargs.get("tree_custom_schema", None)
+        self.buildings_custom_schema = kwargs.get("buildings_custom_schema", None)
 
         json_data = {
             "generation_settings.json": generation_settings_json,
             "texture_custom_schema.json": self.texture_custom_schema,
             "tree_custom_schema.json": self.tree_custom_schema,
+            "buildings_custom_schema.json": self.buildings_custom_schema,
         }
 
         for filename, data in json_data.items():
@@ -203,51 +212,76 @@ class Map:
         Yields:
             Generator[str, None, None]: Component names.
         """
-        self.logger.debug(
-            "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,
+        with performance_session() as session_id:
+            self.logger.info(
+                "Starting map generation. Game code: %s. Coordinates: %s, size: %s. Rotation: %s.",
+                self.game.code,
                 self.coordinates,
                 self.size,
-                self.rotated_size,
                 self.rotation,
-                self.map_directory,
-                self.logger,
-                texture_custom_schema=self.texture_custom_schema,  # type: ignore
-                tree_custom_schema=self.tree_custom_schema,  # type: ignore
             )
-            self.components.append(component)
-
-            yield component.__class__.__name__
-
-            try:
-                component.process()
-                component.commit_generation_info()
-            except Exception as e:
-                self.logger.error(
-                    "Error processing or committing generation info for component %s: %s",
-                    component.__class__.__name__,
-                    e,
+            generation_start = perf_counter()
+
+            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,  # type: ignore
+                    tree_custom_schema=self.tree_custom_schema,  # type: ignore
                 )
-                self._update_main_settings({"error": str(e)})
-                raise e
+                self.components.append(component)
+
+                yield component.__class__.__name__
+
+                try:
+                    component_start = perf_counter()
+                    component.process()
+                    component_finish = perf_counter()
+                    self.logger.info(
+                        "Component %s processed in %.2f seconds.",
+                        component.__class__.__name__,
+                        component_finish - component_start,
+                    )
+                    component.commit_generation_info()
+                except Exception as e:
+                    self.logger.error(
+                        "Error processing or committing generation info for component %s: %s",
+                        component.__class__.__name__,
+                        e,
+                    )
+                    self._update_main_settings({"error": str(e)})
+                    raise e
+
+            generation_finish = perf_counter()
+            self.logger.info(
+                "Map generation completed in %.2f seconds.",
+                generation_finish - generation_start,
+            )
 
-        self._update_main_settings({"completed": True})
+            self._update_main_settings({"completed": True})
 
-        self.logger.debug(
-            "Map generation completed. Game code: %s. Coordinates: %s, size: %s. Rotation: %s.",
-            self.game.code,
-            self.coordinates,
-            self.size,
-            self.rotation,
-        )
+            self.logger.info(
+                "Map generation completed. Game code: %s. Coordinates: %s, size: %s. Rotation: %s.",
+                self.game.code,
+                self.coordinates,
+                self.size,
+                self.rotation,
+            )
+
+        session_json = PerformanceMonitor().get_session_json(session_id)
+        if session_json:
+            report_filename = "performance_report.json"
+            with open(
+                os.path.join(self.map_directory, report_filename), "w", encoding="utf-8"
+            ) as file:
+                json.dump(session_json, file, indent=4)
+            send_performance_report(session_json)
 
     def _update_main_settings(self, data: dict[str, Any]) -> None:
         """Update main settings with provided data.