maps4fs 0.6.0__tar.gz

maps4fs-0.6.0/LICENSE.md

@@ -0,0 +1,21 @@
+# MIT License
+
+Copyright © [2024] [iwatkot]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

maps4fs-0.6.0/PKG-INFO

@@ -0,0 +1,147 @@
+Metadata-Version: 2.1
+Name: maps4fs
+Version: 0.6.0
+Summary: Generate map templates for Farming Simulator from real places.
+Author-email: iwatkot <iwatkot@gmail.com>
+License: MIT License
+Project-URL: Homepage, https://github.com/iwatkot/maps4fs
+Project-URL: Repository, https://github.com/iwatkot/maps4fs
+Keywords: farmingsimulator,fs,farmingsimulator22,farmingsimulator25,fs22,fs25
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: requests>=2.0.0
+Requires-Dist: httpx>=0.20.0
+
+<div align="center" markdown>
+<img src="https://github.com/iwatkot/maps4fs/assets/118521851/ffd7f0a3-e317-4c3f-911f-2c2fb736fbfa">
+
+<p align="center">
+  <a href="#Quick-Start">Quick Start</a> •
+  <a href="#Overview">Overview</a> • 
+  <a href="#How-To-Run">How-To-Run</a> • 
+  <a href="#Features">Features</a> • 
+  <a href="#Supported-objects">Supported objects</a> • 
+  <a href="Settings">Settings</a> • 
+  <a href="#Bugs-and-feature-requests">Bugs and feature requests</a>
+</p>
+
+
+[![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/iwatkot/maps4fs)](https://github.com/iwatkot/maps4fs/releases)
+[![Docker Pulls](https://img.shields.io/docker/pulls/iwatkot/maps4fs)](https://hub.docker.com/repository/docker/iwatkot/maps4fs/general)
+[![GitHub issues](https://img.shields.io/github/issues/iwatkot/maps4fs)](https://github.com/iwatkot/maps4fs/issues)
+[![Maintainability](https://api.codeclimate.com/v1/badges/b922fd0a7188d37e61de/maintainability)](https://codeclimate.com/github/iwatkot/maps4fs/maintainability)<br>
+[![Checked with mypy](https://www.mypy-lang.org/static/mypy_badge.svg)](https://mypy-lang.org/)
+[![Build Status](https://github.com/iwatkot/maps4fs/actions/workflows/checks.yml/badge.svg)](https://github.com/iwatkot/maps4fs/actions)
+[![Test Coverage](https://api.codeclimate.com/v1/badges/b922fd0a7188d37e61de/test_coverage)](https://codeclimate.com/github/iwatkot/maps4fs/test_coverage)
+[![GitHub Repo stars](https://img.shields.io/github/stars/iwatkot/maps4fs)](https://github.com/iwatkot/maps4fs/stargazers)
+
+</div>
+
+### Supported Games
+
+✅ Farming Simulator 22<br>
+🔃 Farming Simulator 25 (changes in the library are ready, waiting for the Giants to release the Giants Editor v10)<br>
+
+## Quick Start
+For those, who don't want to read anything, here you go:<br>
+**Option 1:** launch the [@maps4fs](https://t.me/maps4fsbot) Telegram bot and generate a map template in a few clicks.<br>
+**Option 2:** run the Docker version in your browser. Launch the following command in your terminal:
+```bash
+docker run -d -p 8501:8501 iwatkot/maps4fs
+```
+And open [http://localhost:8501](http://localhost:8501) in your browser.<br>
+If you don't know how to use Docker, navigate to the [Docker version](#option-2-docker-version), it's really simple.<br>
+
+## Overview
+The core idea is coming from the awesome [maps4cim](https://github.com/klamann/maps4cim) project.<br>
+
+The main goal of this project is to generate map templates, based on real-world data, for the Farming Simulator. It's important to mention that **templates are not maps**. They are just a starting point for creating a map. This tool just uses built-in textures to highlight different types of terrain and buildings with correct shapes and scales and to generate a height map. The rest of the work is up to you. So if you thought that you could just run this tool and get a playable map, then I'm sorry to disappoint you. But if you are a map maker, then this tool will save you a lot of time.<br>
+So, if you're new to map making, here's a quick overview of the process:
+1. Generate a map template using this tool.
+2. Download the Giants Editor.
+3. Open the map template in the Giants Editor.
+4. Now you can start creating your map (adding roads, fields, buildings, etc.).
+
+## How-To-Run
+
+You'll find detailed instructions on how to run the project below. But if you prefer video tutorials, here's one for you:
+<a href="https://www.youtube.com/watch?v=ujwWKHVKsw8" target="_blank"><img src="https://github.com/user-attachments/assets/6dbbbc71-d04f-40b2-9fba-81e5e4857407"/></a>
+<i>Video tutorial: How to generate a Farming Simulator 22 map from real-world data.</i>
+
+### Option 1: Telegram bot
+**🗺️ Supported map sizes:** 2x2, 4x4 km.<br>
+🟢 Recommended for all users, you don't need to install anything.<br>
+Using Telegram bot [@maps4fs](https://t.me/maps4fsbot).<br>
+Note: due to CPU and RAM limitations of the hosting, only 2x2 and 4x4 km maps are available. If you need bigger maps, use the [Docker version](#option-2-docker-version).<br>
+
+![Telegram bot](https://github.com/iwatkot/maps4fs/assets/118521851/ede69fe8-1a34-4ede-908f-52c9dc355ae4)
+<br>
+
+Using it is easy and doesn't require any guides. Enjoy!
+
+### Option 2: Docker version
+**🗺️ Supported map sizes:** 2x2, 4x4, 8x8, 16x16 km.<br>
+🟢 Recommended for users who need bigger maps, very simple installation.<br>
+You can launch the project with minimalistic UI in your browser using Docker. Follow these steps:
+
+1. Install [Docker](https://docs.docker.com/get-docker/) for your OS.
+2. Run the following command in your terminal:
+```bash
+docker run -d -p 8501:8501 iwatkot/maps4fs
+```
+3. Open your browser and go to [http://localhost:8501](http://localhost:8501).
+4. Fill in the required fields and click on the `Generate` button.
+5. When the map is generated click on the `Download` button to get the map.
+
+![WebUI](https://github.com/user-attachments/assets/b80c458b-29ea-4790-a640-8fa3b5550610)
+
+## Settings
+Advanced settings are available in the tool's UI under the **Advanced Settings** tab. Here's the list of them:
+- `max_height` - the maximum height of the map. The default value is 400. Select smaller values for plain-like maps and bigger values for mountainous maps. You may need to experiment with this value to get the desired result.
+- `blur_seed` - the seed for the blur algorithm. The default value is 5, which means 5 meters. The bigger the value, the smoother the map will be. The smaller the value, the more detailed the map will be. Keep in mind that for some regions, where terrain is bumpy, disabling the blur algorithm may lead to a very rough map. So, I recommend leaving this value as it is.
+
+## Features
+- Allows to enter a location by lat and lon (e.g. from Google Maps).
+- Allows to select a size of the map (2x2, 4x4, 8x8 km, 16x16 km).
+- Generates a map template (check the list of supported objects in [this section](#supported-objects)).
+- Generates a height map.
+
+## Supported objects
+The project is based on the [OpenStreetMap](https://www.openstreetmap.org/) data. So, refer to [this page](https://wiki.openstreetmap.org/wiki/Map_Features) to understand the list below.
+- "building": True
+- "highway": ["motorway", "trunk", "primary"]
+- "highway": ["secondary", "tertiary", "road"]
+- "highway": ["unclassified", "residential", "track"]
+- "natural": "grassland"
+- "landuse": "farmland"
+- "natural": ["water"]
+- "waterway": True
+- "natural": ["wood", "tree_row"]
+
+The list will be updated as the project develops.
+
+## Info sequence
+The script will also generate the `generation_info.json` file in the `output` folder. It contains the following keys: <br>
+`"coordinates"` - the coordinates of the map center which you entered,<br>
+`"bbox"` - the bounding box of the map in lat and lon,<br>
+`"distance"` - the size of the map in meters,<br>
+`"minimum_x"` - the minimum x coordinate of the map (UTM projection),<br>
+`"minimum_y"` - the minimum y coordinate of the map (UTM projection),<br>
+`"maximum_x"` - the maximum x coordinate of the map (UTM projection),<br>
+`"maximum_y"` - the maximum y coordinate of the map (UTM projection),<br>
+`"height"` - the height of the map in meters (it won't be equal to the distance since the Earth is not flat, sorry flat-earthers),<br>
+`"width"` - the width of the map in meters,<br>
+`"height_coef"` - since we need a texture of exact size, the height of the map is multiplied by this coefficient,<br>
+`"width_coef"` - same as above but for the width,<br>
+`"tile_name"` - the name of the SRTM tile which was used to generate the height map, e.g. "N52E013"<br>
+
+You can use this information to adjust some other sources of data to the map, e.g. textures, height maps, etc.
+
+## Bugs and feature requests
+If you find a bug or have an idea for a new feature, please create an issue [here](https://github.com/iwatkot/maps4fs/issues) or contact me directly on [Telegram](https://t.me/iwatkot).<br>
+ℹ️ Please, don't bother me if the Telegram bot is down. As I said before this is related to the hosting limitations, if you want you can always run the tool locally or support the project by donating, so maybe I'll be able to afford better hosting.

maps4fs-0.6.0/README.md

@@ -0,0 +1,128 @@
+<div align="center" markdown>
+<img src="https://github.com/iwatkot/maps4fs/assets/118521851/ffd7f0a3-e317-4c3f-911f-2c2fb736fbfa">
+
+<p align="center">
+  <a href="#Quick-Start">Quick Start</a> •
+  <a href="#Overview">Overview</a> • 
+  <a href="#How-To-Run">How-To-Run</a> • 
+  <a href="#Features">Features</a> • 
+  <a href="#Supported-objects">Supported objects</a> • 
+  <a href="Settings">Settings</a> • 
+  <a href="#Bugs-and-feature-requests">Bugs and feature requests</a>
+</p>
+
+
+[![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/iwatkot/maps4fs)](https://github.com/iwatkot/maps4fs/releases)
+[![Docker Pulls](https://img.shields.io/docker/pulls/iwatkot/maps4fs)](https://hub.docker.com/repository/docker/iwatkot/maps4fs/general)
+[![GitHub issues](https://img.shields.io/github/issues/iwatkot/maps4fs)](https://github.com/iwatkot/maps4fs/issues)
+[![Maintainability](https://api.codeclimate.com/v1/badges/b922fd0a7188d37e61de/maintainability)](https://codeclimate.com/github/iwatkot/maps4fs/maintainability)<br>
+[![Checked with mypy](https://www.mypy-lang.org/static/mypy_badge.svg)](https://mypy-lang.org/)
+[![Build Status](https://github.com/iwatkot/maps4fs/actions/workflows/checks.yml/badge.svg)](https://github.com/iwatkot/maps4fs/actions)
+[![Test Coverage](https://api.codeclimate.com/v1/badges/b922fd0a7188d37e61de/test_coverage)](https://codeclimate.com/github/iwatkot/maps4fs/test_coverage)
+[![GitHub Repo stars](https://img.shields.io/github/stars/iwatkot/maps4fs)](https://github.com/iwatkot/maps4fs/stargazers)
+
+</div>
+
+### Supported Games
+
+✅ Farming Simulator 22<br>
+🔃 Farming Simulator 25 (changes in the library are ready, waiting for the Giants to release the Giants Editor v10)<br>
+
+## Quick Start
+For those, who don't want to read anything, here you go:<br>
+**Option 1:** launch the [@maps4fs](https://t.me/maps4fsbot) Telegram bot and generate a map template in a few clicks.<br>
+**Option 2:** run the Docker version in your browser. Launch the following command in your terminal:
+```bash
+docker run -d -p 8501:8501 iwatkot/maps4fs
+```
+And open [http://localhost:8501](http://localhost:8501) in your browser.<br>
+If you don't know how to use Docker, navigate to the [Docker version](#option-2-docker-version), it's really simple.<br>
+
+## Overview
+The core idea is coming from the awesome [maps4cim](https://github.com/klamann/maps4cim) project.<br>
+
+The main goal of this project is to generate map templates, based on real-world data, for the Farming Simulator. It's important to mention that **templates are not maps**. They are just a starting point for creating a map. This tool just uses built-in textures to highlight different types of terrain and buildings with correct shapes and scales and to generate a height map. The rest of the work is up to you. So if you thought that you could just run this tool and get a playable map, then I'm sorry to disappoint you. But if you are a map maker, then this tool will save you a lot of time.<br>
+So, if you're new to map making, here's a quick overview of the process:
+1. Generate a map template using this tool.
+2. Download the Giants Editor.
+3. Open the map template in the Giants Editor.
+4. Now you can start creating your map (adding roads, fields, buildings, etc.).
+
+## How-To-Run
+
+You'll find detailed instructions on how to run the project below. But if you prefer video tutorials, here's one for you:
+<a href="https://www.youtube.com/watch?v=ujwWKHVKsw8" target="_blank"><img src="https://github.com/user-attachments/assets/6dbbbc71-d04f-40b2-9fba-81e5e4857407"/></a>
+<i>Video tutorial: How to generate a Farming Simulator 22 map from real-world data.</i>
+
+### Option 1: Telegram bot
+**🗺️ Supported map sizes:** 2x2, 4x4 km.<br>
+🟢 Recommended for all users, you don't need to install anything.<br>
+Using Telegram bot [@maps4fs](https://t.me/maps4fsbot).<br>
+Note: due to CPU and RAM limitations of the hosting, only 2x2 and 4x4 km maps are available. If you need bigger maps, use the [Docker version](#option-2-docker-version).<br>
+
+![Telegram bot](https://github.com/iwatkot/maps4fs/assets/118521851/ede69fe8-1a34-4ede-908f-52c9dc355ae4)
+<br>
+
+Using it is easy and doesn't require any guides. Enjoy!
+
+### Option 2: Docker version
+**🗺️ Supported map sizes:** 2x2, 4x4, 8x8, 16x16 km.<br>
+🟢 Recommended for users who need bigger maps, very simple installation.<br>
+You can launch the project with minimalistic UI in your browser using Docker. Follow these steps:
+
+1. Install [Docker](https://docs.docker.com/get-docker/) for your OS.
+2. Run the following command in your terminal:
+```bash
+docker run -d -p 8501:8501 iwatkot/maps4fs
+```
+3. Open your browser and go to [http://localhost:8501](http://localhost:8501).
+4. Fill in the required fields and click on the `Generate` button.
+5. When the map is generated click on the `Download` button to get the map.
+
+![WebUI](https://github.com/user-attachments/assets/b80c458b-29ea-4790-a640-8fa3b5550610)
+
+## Settings
+Advanced settings are available in the tool's UI under the **Advanced Settings** tab. Here's the list of them:
+- `max_height` - the maximum height of the map. The default value is 400. Select smaller values for plain-like maps and bigger values for mountainous maps. You may need to experiment with this value to get the desired result.
+- `blur_seed` - the seed for the blur algorithm. The default value is 5, which means 5 meters. The bigger the value, the smoother the map will be. The smaller the value, the more detailed the map will be. Keep in mind that for some regions, where terrain is bumpy, disabling the blur algorithm may lead to a very rough map. So, I recommend leaving this value as it is.
+
+## Features
+- Allows to enter a location by lat and lon (e.g. from Google Maps).
+- Allows to select a size of the map (2x2, 4x4, 8x8 km, 16x16 km).
+- Generates a map template (check the list of supported objects in [this section](#supported-objects)).
+- Generates a height map.
+
+## Supported objects
+The project is based on the [OpenStreetMap](https://www.openstreetmap.org/) data. So, refer to [this page](https://wiki.openstreetmap.org/wiki/Map_Features) to understand the list below.
+- "building": True
+- "highway": ["motorway", "trunk", "primary"]
+- "highway": ["secondary", "tertiary", "road"]
+- "highway": ["unclassified", "residential", "track"]
+- "natural": "grassland"
+- "landuse": "farmland"
+- "natural": ["water"]
+- "waterway": True
+- "natural": ["wood", "tree_row"]
+
+The list will be updated as the project develops.
+
+## Info sequence
+The script will also generate the `generation_info.json` file in the `output` folder. It contains the following keys: <br>
+`"coordinates"` - the coordinates of the map center which you entered,<br>
+`"bbox"` - the bounding box of the map in lat and lon,<br>
+`"distance"` - the size of the map in meters,<br>
+`"minimum_x"` - the minimum x coordinate of the map (UTM projection),<br>
+`"minimum_y"` - the minimum y coordinate of the map (UTM projection),<br>
+`"maximum_x"` - the maximum x coordinate of the map (UTM projection),<br>
+`"maximum_y"` - the maximum y coordinate of the map (UTM projection),<br>
+`"height"` - the height of the map in meters (it won't be equal to the distance since the Earth is not flat, sorry flat-earthers),<br>
+`"width"` - the width of the map in meters,<br>
+`"height_coef"` - since we need a texture of exact size, the height of the map is multiplied by this coefficient,<br>
+`"width_coef"` - same as above but for the width,<br>
+`"tile_name"` - the name of the SRTM tile which was used to generate the height map, e.g. "N52E013"<br>
+
+You can use this information to adjust some other sources of data to the map, e.g. textures, height maps, etc.
+
+## Bugs and feature requests
+If you find a bug or have an idea for a new feature, please create an issue [here](https://github.com/iwatkot/maps4fs/issues) or contact me directly on [Telegram](https://t.me/iwatkot).<br>
+ℹ️ Please, don't bother me if the Telegram bot is down. As I said before this is related to the hosting limitations, if you want you can always run the tool locally or support the project by donating, so maybe I'll be able to afford better hosting.

maps4fs-0.6.0/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-0.6.0/maps4fs/generator/__init__.py

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

maps4fs-0.6.0/maps4fs/generator/component.py

@@ -0,0 +1,55 @@
+"""This module contains the base class for all map generation components."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from maps4fs.generator.game import Game
+
+
+# pylint: disable=R0801, R0903
+class Component:
+    """Base class for all map generation components.
+
+    Args:
+        coordinates (tuple[float, float]): The latitude and longitude of the center of the map.
+        distance (int): The distance from the center to the edge of the map.
+        map_directory (str): The directory where the map files are stored.
+        logger (Any, optional): The logger to use. Must have at least three basic methods: debug,
+            info, warning. If not provided, default logging will be used.
+    """
+
+    def __init__(
+        self,
+        game: Game,
+        coordinates: tuple[float, float],
+        distance: int,
+        map_directory: str,
+        logger: Any = None,
+        **kwargs,  # pylint: disable=W0613, R0913, R0917
+    ):
+        self.game = game
+        self.coordinates = coordinates
+        self.distance = distance
+        self.map_directory = map_directory
+        self.logger = logger
+        self.kwargs = kwargs
+
+        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

maps4fs-0.6.0/maps4fs/generator/config.py

@@ -0,0 +1,44 @@
+"""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.
+        distance (int): The distance from the center to the edge of the map.
+        map_directory (str): The directory where the map files are stored.
+        logger (Any, optional): The logger to use. Must have at least three basic methods: debug,
+            info, warning. If not provided, default logging will be used.
+    """
+
+    def preprocess(self) -> None:
+        self._map_xml_path = self.game.map_xml_path(self.map_directory)
+        self.logger.debug(f"Map XML path: {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"):
+            width = height = str(self.distance * 2)
+            map_elem.set("width", width)
+            map_elem.set("height", height)
+            self.logger.debug("Map size set to %sx%s in Map XML file.", width, height)
+        tree.write(self._map_xml_path)
+        self.logger.debug("Map XML file saved to: %s.", self._map_xml_path)

maps4fs-0.6.0/maps4fs/generator/dem.py

@@ -0,0 +1,207 @@
+"""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 osmnx as ox  # type: ignore
+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"
+
+
+# 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.
+        distance (int): The distance from the center to the edge of the map.
+        map_directory (str): The directory where the map files are stored.
+        logger (Any, optional): The logger to use. Must have at least three basic methods: debug,
+            info, warning. If not provided, default logging will be used.
+    """
+
+    def preprocess(self) -> None:
+        self._blur_seed: int = self.kwargs.get("blur_seed") or 5
+        self._max_height: int = self.kwargs.get("max_height") or 200
+
+        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)
+
+    # 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 = ox.utils_geo.bbox_from_point(  # pylint: disable=W0632
+            self.coordinates, dist=self.distance
+        )
+        self.logger.debug(
+            f"Processing DEM. North: {north}, south: {south}, east: {east}, west: {west}."
+        )
+
+        dem_output_size = self.distance * self.game.dem_multipliyer + 1
+        self.logger.debug(
+            "DEM multiplier is %s, DEM output size is %s.",
+            self.game.dem_multipliyer,
+            dem_output_size,
+        )
+        dem_output_resolution = (dem_output_size, dem_output_size)
+        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(
+            f"DEM data was read from SRTM file. Shape: {data.shape}, dtype: {data.dtype}. "
+            f"Min: {data.min()}, max: {data.max()}."
+        )
+
+        normalized_data = self._normalize_dem(data)
+
+        resampled_data = cv2.resize(
+            normalized_data, dem_output_resolution, interpolation=cv2.INTER_LINEAR
+        )
+        self.logger.debug(
+            f"DEM data was resampled. Shape: {resampled_data.shape}, "
+            f"dtype: {resampled_data.dtype}. "
+            f"Min: {resampled_data.min()}, max: {resampled_data.max()}."
+        )
+
+        blurred_data = cv2.GaussianBlur(resampled_data, (self._blur_seed, self._blur_seed), 0)
+        cv2.imwrite(self._dem_path, blurred_data)
+        self.logger.debug("DEM data was saved to %s.", self._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(
+                f"Decompressed tile already exists: {decompressed_file_path}, skipping download."
+            )
+            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 _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.
+        """
+        max_dev = data.max() - data.min()
+        scaling_factor = max_dev / self._max_height if max_dev < self._max_height else 1
+        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