maps4fs 0.9.2__py3-none-any.whl → 0.9.4__py3-none-any.whl

maps4fs/generator/background.py

@@ -10,10 +10,14 @@ import numpy as np
 import trimesh  # type: ignore
 
 from maps4fs.generator.component import Component
-from maps4fs.generator.path_steps import DEFAULT_DISTANCE, get_steps
+from maps4fs.generator.path_steps import DEFAULT_DISTANCE, PATH_FULL_NAME, get_steps
 from maps4fs.generator.tile import Tile
+from maps4fs.logger import timeit
 
 RESIZE_FACTOR = 1 / 4
+SIMPLIFY_FACTOR = 10
+FULL_RESIZE_FACTOR = 1 / 4
+FULL_SIMPLIFY_FACTOR = 20
 
 
 class Background(Component):
@@ -37,7 +41,12 @@ class Background(Component):
         # 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)
+            if path_step.angle is None:
+                # For the case when generating the overview map, which has the same
+                # center as the main map.
+                tile_coordinates = self.coordinates
+            else:
+                tile_coordinates = path_step.get_destination(origin)
 
             # Create a Tile component, which is needed to save the DEM image.
             tile = Tile(
@@ -86,11 +95,13 @@ class Background(Component):
         for tile in self.tiles:
             north, south, east, west = tile.bbox
             epsg3857_string = tile.get_epsg3857_string()
+            epsg3857_string_with_margin = tile.get_epsg3857_string(add_margin=True)
 
             tile_entry = {
                 "center_latitude": tile.coordinates[0],
                 "center_longitude": tile.coordinates[1],
                 "epsg3857_string": epsg3857_string,
+                "epsg3857_string_with_margin": epsg3857_string_with_margin,
                 "height": tile.map_height,
                 "width": tile.map_width,
                 "north": north,
@@ -106,10 +117,16 @@ class Background(Component):
     def qgis_sequence(self) -> None:
         """Generates QGIS scripts for creating bounding box layers and rasterizing them."""
         qgis_layers = [
-            (f"Background_bbox_{tile.code}", *tile.get_espg3857_bbox()) for tile in self.tiles
+            (f"Background_{tile.code}", *tile.get_espg3857_bbox()) for tile in self.tiles
         ]
+        qgis_layers_with_margin = [
+            (f"Background_{tile.code}_margin", *tile.get_espg3857_bbox(add_margin=True))
+            for tile in self.tiles
+        ]
+
+        layers = qgis_layers + qgis_layers_with_margin
 
-        self.create_qgis_scripts(qgis_layers)  # type: ignore
+        self.create_qgis_scripts(layers)
 
     def generate_obj_files(self) -> None:
         """Iterates over all tiles and generates 3D obj files based on DEM data.
@@ -129,29 +146,49 @@ class Background(Component):
             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)
+            self.plane_from_np(tile.code, dem_data, save_path)
 
     # pylint: disable=too-many-locals
-    def plane_from_np(self, dem_data: np.ndarray, save_path: str) -> None:
+    @timeit
+    def plane_from_np(self, tile_code: str, dem_data: np.ndarray, save_path: str) -> None:
         """Generates a 3D obj file based on DEM data.
 
         Arguments:
+            tile_code (str) -- The code of the tile.
             dem_data (np.ndarray) -- The DEM data as a numpy array.
             save_path (str) -- The path where the obj file will be saved.
         """
+        if tile_code == PATH_FULL_NAME:
+            resize_factor = FULL_RESIZE_FACTOR
+            simplify_factor = FULL_SIMPLIFY_FACTOR
+            self.logger.info("Generating a full map obj file")
+        else:
+            resize_factor = RESIZE_FACTOR
+            simplify_factor = SIMPLIFY_FACTOR
         dem_data = cv2.resize(  # pylint: disable=no-member
-            dem_data, (0, 0), fx=RESIZE_FACTOR, fy=RESIZE_FACTOR
+            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
+            "DEM data resized to shape: %s with factor: %s", dem_data.shape, resize_factor
         )
 
+        # Invert the height values.
+        dem_data = dem_data.max() - dem_data
+
         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
 
+        self.logger.info(
+            "Starting to generate a mesh for tile %s with shape: %s x %s. "
+            "This may take a while...",
+            tile_code,
+            cols,
+            rows,
+        )
+
         vertices = np.column_stack([x.ravel(), y.ravel(), z.ravel()])
         faces = []
 
@@ -162,15 +199,22 @@ class Background(Component):
                 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.append([top_left, bottom_left, bottom_right])
+                faces.append([top_left, bottom_right, top_right])
 
         faces = np.array(faces)  # type: ignore
         mesh = trimesh.Trimesh(vertices=vertices, faces=faces)
 
+        # Apply rotation: 180 degrees around Y-axis and Z-axis
+        rotation_matrix_y = trimesh.transformations.rotation_matrix(np.pi, [0, 1, 0])
+        rotation_matrix_z = trimesh.transformations.rotation_matrix(np.pi, [0, 0, 1])
+        mesh.apply_transform(rotation_matrix_y)
+        mesh.apply_transform(rotation_matrix_z)
+
+        self.logger.info("Mesh generated with %s faces, will be simplified", len(mesh.faces))
+
         # Simplify the mesh to reduce the number of faces.
-        mesh = mesh.simplify_quadric_decimation(face_count=len(faces) // 10)
+        mesh = mesh.simplify_quadric_decimation(face_count=len(faces) // simplify_factor)
         self.logger.debug("Mesh simplified to %s faces", len(mesh.faces))
 
         mesh.export(save_path)

maps4fs/generator/component.py

@@ -10,7 +10,7 @@ from typing import TYPE_CHECKING, Any
 import osmnx as ox  # type: ignore
 from pyproj import Transformer
 
-from maps4fs.generator.qgis import get_bbox_template, get_rasterize_template
+from maps4fs.generator.qgis import save_scripts
 
 if TYPE_CHECKING:
     from maps4fs.generator.game import Game
@@ -214,16 +214,17 @@ class Component:
         return west, south, east, north
 
     def get_espg3857_bbox(
-        self, bbox: tuple[int, int, int, int] | None = None
-    ) -> tuple[int, int, int, int]:
+        self, bbox: tuple[float, float, float, float] | None = None, add_margin: bool = False
+    ) -> tuple[float, float, float, float]:
         """Converts the bounding box to EPSG:3857.
         If the bounding box is not provided, the instance variable is used.
 
         Args:
-            bbox (tuple[int, int, int, int], optional): The bounding box to convert.
+            bbox (tuple[float, float, float, float], optional): The bounding box to convert.
+            add_margin (bool, optional): Whether to add a margin to the bounding box.
 
         Returns:
-            tuple[int, int, int, int]: The bounding box in EPSG:3857.
+            tuple[float, float, float, float]: The bounding box in EPSG:3857.
         """
         bbox = bbox or self.bbox
         north, south, east, west = bbox
@@ -231,19 +232,29 @@ class Component:
         epsg3857_north, epsg3857_west = transformer.transform(north, west)
         epsg3857_south, epsg3857_east = transformer.transform(south, east)
 
+        if add_margin:
+            MARGIN = 500  # pylint: disable=C0103
+            epsg3857_north = int(epsg3857_north - MARGIN)
+            epsg3857_south = int(epsg3857_south + MARGIN)
+            epsg3857_east = int(epsg3857_east - MARGIN)
+            epsg3857_west = int(epsg3857_west + MARGIN)
+
         return epsg3857_north, epsg3857_south, epsg3857_east, epsg3857_west
 
-    def get_epsg3857_string(self, bbox: tuple[int, int, int, int] | None = None) -> str:
+    def get_epsg3857_string(
+        self, bbox: tuple[float, float, float, float] | None = None, add_margin: bool = False
+    ) -> str:
         """Converts the bounding box to EPSG:3857 string.
         If the bounding box is not provided, the instance variable is used.
 
         Args:
-            bbox (tuple[int, int, int, int], optional): The bounding box to convert.
+            bbox (tuple[float, float, float, float], optional): The bounding box to convert.
+            add_margin (bool, optional): Whether to add a margin to the bounding box.
 
         Returns:
             str: The bounding box in EPSG:3857 string.
         """
-        north, south, east, west = self.get_espg3857_bbox(bbox)
+        north, south, east, west = self.get_espg3857_bbox(bbox, add_margin=add_margin)
         return f"{north},{south},{east},{west} [EPSG:3857]"
 
     def create_qgis_scripts(
@@ -259,17 +270,4 @@ class Component:
                 create scripts for.
         """
         class_name = self.__class__.__name__.lower()
-
-        script_files = [
-            (f"{class_name}_bbox.py", get_bbox_template),
-            (f"{class_name}_rasterize.py", get_rasterize_template),
-        ]
-
-        for script_file, process_function in script_files:
-            script_path = os.path.join(self.scripts_directory, script_file)
-            script_content = process_function(qgis_layers)  # type: ignore
-
-            with open(script_path, "w", encoding="utf-8") as file:
-                file.write(script_content)
-
-            self.logger.info("QGIS script saved: %s", script_path)
+        save_scripts(qgis_layers, class_name, self.scripts_directory)

maps4fs/generator/config.py

@@ -70,11 +70,13 @@ class Config(Component):
         bbox = self.get_bbox(height_distance=self.map_height, width_distance=self.map_width)
         south, west, north, east = bbox
         epsg3857_string = self.get_epsg3857_string(bbox=bbox)
+        epsg3857_string_with_margin = self.get_epsg3857_string(bbox=bbox, add_margin=True)
 
         self.qgis_sequence()
 
         overview_data = {
             "epsg3857_string": epsg3857_string,
+            "epsg3857_string_with_margin": epsg3857_string_with_margin,
             "south": south,
             "west": west,
             "north": north,
@@ -93,7 +95,11 @@ class Config(Component):
         """Generates QGIS scripts for creating bounding box layers and rasterizing them."""
         bbox = self.get_bbox(height_distance=self.map_height, width_distance=self.map_width)
         espg3857_bbox = self.get_espg3857_bbox(bbox=bbox)
+        espg3857_bbox_with_margin = self.get_espg3857_bbox(bbox=bbox, add_margin=True)
 
         qgis_layers = [("Overview_bbox", *espg3857_bbox)]
+        qgis_layers_with_margin = [("Overview_bbox_with_margin", *espg3857_bbox_with_margin)]
 
-        self.create_qgis_scripts(qgis_layers)  # type: ignore
+        layers = qgis_layers + qgis_layers_with_margin
+
+        self.create_qgis_scripts(layers)

maps4fs/generator/map.py

@@ -42,7 +42,7 @@ class Map:
         self.map_directory = map_directory
 
         if not logger:
-            logger = Logger(__name__, to_stdout=True, to_file=False)
+            logger = Logger(to_stdout=True, to_file=False)
         self.logger = logger
         self.logger.debug("Game was set to %s", game.code)
 

maps4fs/generator/path_steps.py

@@ -5,6 +5,7 @@ from typing import NamedTuple
 from geopy.distance import distance  # type: ignore
 
 DEFAULT_DISTANCE = 2048
+PATH_FULL_NAME = "FULL"
 
 
 class PathStep(NamedTuple):
@@ -13,13 +14,17 @@ class PathStep(NamedTuple):
     Attributes:
         code {str} -- Tile code (N, NE, E, SE, S, SW, W, NW).
         angle {int} -- Angle in degrees (for example 0 for North, 90 for East).
+            If None, the step is a full map with a center at the same coordinates as the
+            map itself.
         distance {int} -- Distance in meters from previous step.
+            If None, the step is a full map with a center at the same coordinates as the
+            map itself.
         size {tuple[int, int]} -- Size of the tile in pixels (width, height).
     """
 
     code: str
-    angle: int
-    distance: int
+    angle: int | None
+    distance: int | None
     size: tuple[int, int]
 
     def get_destination(self, origin: tuple[float, float]) -> tuple[float, float]:
@@ -69,4 +74,10 @@ def get_steps(map_height: int, map_width: int) -> list[PathStep]:
         PathStep(
             "NW", 0, half_height + half_default_distance, (DEFAULT_DISTANCE, DEFAULT_DISTANCE)
         ),
+        PathStep(
+            PATH_FULL_NAME,
+            None,
+            None,
+            (map_width + DEFAULT_DISTANCE * 2, map_height + DEFAULT_DISTANCE * 2),
+        ),
     ]

maps4fs/generator/qgis.py

@@ -1,11 +1,13 @@
 """This module contains templates for generating QGIS scripts."""
 
+import os
+
 BBOX_TEMPLATE = """
 layers = [
     {layers}
 ]
 for layer in layers:
-    name = layer[0]
+    name = "Bounding_Box_" + layer[0]
     north, south, east, west = layer[1:]
 
     # Create a rectangle geometry from the bounding box.
@@ -34,6 +36,42 @@ for layer in layers:
     layer.triggerRepaint()
 """
 
+POINT_TEMPLATE = """
+layers = [
+    {layers}
+]
+for layer in layers:
+    name = "Points_" + layer[0]
+    north, south, east, west = layer[1:]
+
+    top_left = QgsPointXY(north, west)
+    top_right = QgsPointXY(north, east)
+    bottom_right = QgsPointXY(south, east)
+    bottom_left = QgsPointXY(south, west)
+
+    points = [top_left, top_right, bottom_right, bottom_left, top_left]
+
+    # Create a new layer
+    layer = QgsVectorLayer('Point?crs=EPSG:4326', name, 'memory')
+    provider = layer.dataProvider()
+
+    # Add fields
+    provider.addAttributes([QgsField("id", QVariant.Int)])
+    layer.updateFields()
+
+    # Create and add features for each point
+    for i, point in enumerate(points):
+        feature = QgsFeature()
+        feature.setGeometry(QgsGeometry.fromPointXY(point))
+        feature.setAttributes([i + 1])
+        provider.addFeature(feature)
+
+    layer.updateExtents()
+
+    # Add the layer to the project
+    QgsProject.instance().addMapLayer(layer)
+"""
+
 RASTERIZE_TEMPLATE = """
 import processing
 
@@ -74,17 +112,18 @@ for layer in layers:
 """
 
 
-def get_bbox_template(layers: list[tuple[str, float, float, float, float]]) -> str:
-    """Returns a template for creating bounding box layers in QGIS.
+def _get_template(layers: list[tuple[str, float, float, float, float]], template: str) -> str:
+    """Returns a template for creating layers in QGIS.
 
     Args:
         layers (list[tuple[str, float, float, float, float]]): A list of tuples containing the
             layer name and the bounding box coordinates.
+        template (str): The template for creating layers in QGIS.
 
     Returns:
-        str: The template for creating bounding box layers in QGIS.
+        str: The template for creating layers in QGIS.
     """
-    return BBOX_TEMPLATE.format(
+    return template.format(
         layers=",\n    ".join(
             [
                 f'("{name}", {north}, {south}, {east}, {west})'
@@ -94,6 +133,32 @@ def get_bbox_template(layers: list[tuple[str, float, float, float, float]]) -> s
     )
 
 
+def get_bbox_template(layers: list[tuple[str, float, float, float, float]]) -> str:
+    """Returns a template for creating bounding box layers in QGIS.
+
+    Args:
+        layers (list[tuple[str, float, float, float, float]]): A list of tuples containing the
+            layer name and the bounding box coordinates.
+
+    Returns:
+        str: The template for creating bounding box layers in QGIS.
+    """
+    return _get_template(layers, BBOX_TEMPLATE)
+
+
+def get_point_template(layers: list[tuple[str, float, float, float, float]]) -> str:
+    """Returns a template for creating point layers in QGIS.
+
+    Args:
+        layers (list[tuple[str, float, float, float, float]]): A list of tuples containing the
+            layer name and the bounding box coordinates.
+
+    Returns:
+        str: The template for creating point layers in QGIS.
+    """
+    return _get_template(layers, POINT_TEMPLATE)
+
+
 def get_rasterize_template(layers: list[tuple[str, float, float, float, float]]) -> str:
     """Returns a template for rasterizing bounding box layers in QGIS.
 
@@ -104,11 +169,28 @@ def get_rasterize_template(layers: list[tuple[str, float, float, float, float]])
     Returns:
         str: The template for rasterizing bounding box layers in QGIS.
     """
-    return RASTERIZE_TEMPLATE.format(
-        layers=",\n    ".join(
-            [
-                f'("{name}", {north}, {south}, {east}, {west})'
-                for name, north, south, east, west in layers
-            ]
-        )
-    )
+    return _get_template(layers, RASTERIZE_TEMPLATE)
+
+
+def save_scripts(
+    layers: list[tuple[str, float, float, float, float]], file_prefix: str, save_directory: str
+) -> None:
+    """Saves QGIS scripts for creating bounding box, point, and raster layers.
+
+    Args:
+        layers (list[tuple[str, float, float, float, float]]): A list of tuples containing the
+            layer name and the bounding box coordinates.
+        save_dir (str): The directory to save the scripts.
+    """
+    script_files = [
+        (f"{file_prefix}_bbox.py", get_bbox_template),
+        (f"{file_prefix}_rasterize.py", get_rasterize_template),
+        (f"{file_prefix}_point.py", get_point_template),
+    ]
+
+    for script_file, process_function in script_files:
+        script_path = os.path.join(save_directory, script_file)
+        script_content = process_function(layers)  # type: ignore
+
+        with open(script_path, "w", encoding="utf-8") as file:
+            file.write(script_content)

maps4fs/logger.py

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

{maps4fs-0.9.2.dist-info → maps4fs-0.9.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: maps4fs
-Version: 0.9.2
+Version: 0.9.4
 Summary: Generate map templates for Farming Simulator from real places.
 Author-email: iwatkot <iwatkot@gmail.com>
 License: MIT License
@@ -23,7 +23,9 @@ Requires-Dist: imageio
 Requires-Dist: tifffile
 
 <div align="center" markdown>
-<img src="https://github.com/iwatkot/maps4fs/assets/118521851/ffd7f0a3-e317-4c3f-911f-2c2fb736fbfa">
+<a href="https://discord.gg/Sj5QKKyE42">
+<img src="https://github.com/user-attachments/assets/37043333-d6ef-4ca3-9f3c-81323d9d0b71">
+</a>
 
 <p align="center">
   <a href="#Quick-Start">Quick Start</a> •
@@ -41,6 +43,7 @@ Requires-Dist: tifffile
 </p>
 
 
+[![Join Discord](https://img.shields.io/badge/join-discord-blue)](https://discord.gg/Sj5QKKyE42)
 [![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/iwatkot/maps4fs)](https://github.com/iwatkot/maps4fs/releases)
 [![PyPI - Version](https://img.shields.io/pypi/v/maps4fs)](https://pypi.org/project/maps4fs)
 [![Docker Pulls](https://img.shields.io/docker/pulls/iwatkot/maps4fs)](https://hub.docker.com/repository/docker/iwatkot/maps4fs/general)
@@ -360,6 +363,12 @@ Let's have a closer look at the fields:
 ## Background terrain
 The tool now supports the generation of the background terrain. If you don't know what it is, here's a brief explanation. The background terrain is the world around the map. It's important to create it, because if you don't, the map will look like it's floating in the void. The background terrain is a simple plane which can (and should) be texture to look fine.<br>
 So, the tool generates the background terrain in the form of the 8 tiles, which surround the map. The tiles are named as the cardinal points, e.g. "N", "NE", "E" and so on. All those tiles will be saved in the `objects/tiles` directory with corresponding names: `N.obj`, `NE.obj`, `E.obj` and so on.<br>
+If you don't want to work with separate tiles, the tool also generates the `FULL.obj` file, which includes everything around the map and the map itself. It may be a convinient approach to work with one file, one texture and then just cut the map from it.<br>
+
+![Complete background terrain in Blender](https://github.com/user-attachments/assets/7266b8f1-bfa2-4c14-a740-1c84b1030a66)
+
+➡️ *No matter which approach you choose, you still need to adjust the background terrain to connect it to the map without any gaps. But with a sinlge file it's much easier to do.*
+
 If you're willing to create a background terrain, you will need: Blender, the Blender Exporter Plugins and the QGIS. You'll find the download links in the [Resources](#resources) section.<br>
 
 If you're afraid of this task, please don't be. It's really simple and I've prepaired detailed step-by-step instructions for you, you'll find them in the separate README files. Here are the steps you need to follow:

maps4fs-0.9.4.dist-info/RECORD

@@ -0,0 +1,19 @@
+maps4fs/__init__.py,sha256=da4jmND2Ths9AffnkAKgzLHNkvKFOc_l21gJisPXqWY,155
+maps4fs/logger.py,sha256=8oZzAKJllilYrVp452LX0zx-dNFwpS6UngbTrI6KfwA,2148
+maps4fs/generator/__init__.py,sha256=zZMLEkGzb4z0xql650gOtGSvcgX58DnJ2yN3vC2daRk,43
+maps4fs/generator/background.py,sha256=6mN2xRg5XEqsLaXPUqdNGgDR1Ats60fBK93WlDeB8EI,13002
+maps4fs/generator/component.py,sha256=ZEDjChPnvqAsgnBu2f2YBOlwGOlfax4VaAYBcJerLIQ,10684
+maps4fs/generator/config.py,sha256=ZO5BWDU-S3p0-ndKDSFa8Oin3YcYy0iH8B4lqEA_07Q,4275
+maps4fs/generator/dem.py,sha256=p7THncPUdYWtNR2HrTXe0bCuJ8psUV8rRpYPJkzL2gA,15220
+maps4fs/generator/game.py,sha256=94HjPNOyy6XSSOnBp-uxrkBglKyC-X3ULIrrucfdlKw,6825
+maps4fs/generator/i3d.py,sha256=UuQiQRusPQ2f6PvGKxJ_UZeXsx3uG15efmy8Ysnm3F8,3597
+maps4fs/generator/map.py,sha256=v8OOLmhAkgqq64tQgEDbV6DmbgOVm3NXJBDDy0nJf60,4226
+maps4fs/generator/path_steps.py,sha256=yeN6hmOD8O2LMozUf4HcQMIy8WJ5sHF5pGQT_s2FfOw,3147
+maps4fs/generator/qgis.py,sha256=vhV-EwZKK-p1qEV-2H_yckuktx8ezlCMnmJJfUt1HGI,6091
+maps4fs/generator/texture.py,sha256=CwaXZfAG4e3D3YR7yVR2MC677EHpbUWTboCS3G6jkhk,17723
+maps4fs/generator/tile.py,sha256=3vmfjQiPiiUZKPuIo5tg2rOKkgcP1NRVkMGK-Vo10-A,2138
+maps4fs-0.9.4.dist-info/LICENSE.md,sha256=-JY0v7p3dwXze61EbYiK7YEJ2aKrjaFZ8y2xYEOrmRY,1068
+maps4fs-0.9.4.dist-info/METADATA,sha256=WVUjB4PmrCnuWZNIVurx3_1XPqS2oBEwWdVaU22uX2Y,24130
+maps4fs-0.9.4.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+maps4fs-0.9.4.dist-info/top_level.txt,sha256=Ue9DSRlejRQRCaJueB0uLcKrWwsEq9zezfv5dI5mV1M,8
+maps4fs-0.9.4.dist-info/RECORD,,

maps4fs-0.9.2.dist-info/RECORD

@@ -1,19 +0,0 @@
-maps4fs/__init__.py,sha256=da4jmND2Ths9AffnkAKgzLHNkvKFOc_l21gJisPXqWY,155
-maps4fs/logger.py,sha256=CneeHxQywjNUJXqQrUUSeiDxu95FfrfyK_Si1v0gMZ8,1477
-maps4fs/generator/__init__.py,sha256=zZMLEkGzb4z0xql650gOtGSvcgX58DnJ2yN3vC2daRk,43
-maps4fs/generator/background.py,sha256=2BUgn12t-FgijPTY7hvwTaYQrVzYdnZqhoz76KSBcKs,11216
-maps4fs/generator/component.py,sha256=tLjjbrFn3v4CrUrUOgH9s8NuJhmQcBs74ShefkNg1VE,10584
-maps4fs/generator/config.py,sha256=JL7leQv8C06JQOXIbgQ-jve2re7cNsx8vKa8dfbnxPM,3896
-maps4fs/generator/dem.py,sha256=p7THncPUdYWtNR2HrTXe0bCuJ8psUV8rRpYPJkzL2gA,15220
-maps4fs/generator/game.py,sha256=94HjPNOyy6XSSOnBp-uxrkBglKyC-X3ULIrrucfdlKw,6825
-maps4fs/generator/i3d.py,sha256=UuQiQRusPQ2f6PvGKxJ_UZeXsx3uG15efmy8Ysnm3F8,3597
-maps4fs/generator/map.py,sha256=BS8ylTCRlHRmbImg73wnHMpBB2ODckVyVZq5KJhCMfM,4236
-maps4fs/generator/path_steps.py,sha256=rKslIiG9mriCVL9_0i8Oet2p0DITrpBWi0pECpvuyUM,2707
-maps4fs/generator/qgis.py,sha256=k19miPEFyOdu_ogBFHmFVfYQ-IgF38ufJZ5DM5NSHBQ,3400
-maps4fs/generator/texture.py,sha256=CwaXZfAG4e3D3YR7yVR2MC677EHpbUWTboCS3G6jkhk,17723
-maps4fs/generator/tile.py,sha256=3vmfjQiPiiUZKPuIo5tg2rOKkgcP1NRVkMGK-Vo10-A,2138
-maps4fs-0.9.2.dist-info/LICENSE.md,sha256=-JY0v7p3dwXze61EbYiK7YEJ2aKrjaFZ8y2xYEOrmRY,1068
-maps4fs-0.9.2.dist-info/METADATA,sha256=J9SVncLGsj5Le0QQu-mfSyrsQJc0EkO7tdDs1HFd8vQ,23427
-maps4fs-0.9.2.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-maps4fs-0.9.2.dist-info/top_level.txt,sha256=Ue9DSRlejRQRCaJueB0uLcKrWwsEq9zezfv5dI5mV1M,8
-maps4fs-0.9.2.dist-info/RECORD,,