maps4fs 2.1.1__py3-none-any.whl → 2.1.3__py3-none-any.whl

maps4fs/generator/component/background.py

@@ -21,6 +21,8 @@ from maps4fs.generator.component.dem import DEM
 from maps4fs.generator.component.texture import Texture
 from maps4fs.generator.settings import Parameters
 
+SEGMENT_LENGTH = 2
+
 
 class Background(MeshComponent, ImageComponent):
     """Component for creating 3D obj files based on DEM data around the map.
@@ -97,6 +99,10 @@ class Background(MeshComponent, ImageComponent):
         cutted_dem_path = self.save_map_dem(self.output_path)
         shutil.copyfile(self.output_path, self.not_substracted_path)
         self.save_map_dem(self.output_path, save_path=self.not_resized_path)
+
+        if self.map.background_settings.flatten_roads:
+            self.flatten_roads()
+
         if self.game.additional_dem_name is not None:
             self.make_copy(cutted_dem_path, self.game.additional_dem_name)
 
@@ -723,3 +729,94 @@ class Background(MeshComponent, ImageComponent):
         self.assets.water_mesh = elevated_save_path
 
         self.plane_from_np(elevated_water, elevated_save_path, include_zeros=False)
+
+    def flatten_roads(self) -> None:
+        """Flattens the roads in the DEM data by averaging the height values along the road polylines."""
+        if not self.not_resized_path or not os.path.isfile(self.not_resized_path):
+            self.logger.warning("No DEM data found for flattening roads.")
+            return
+
+        dem_image = cv2.imread(self.not_resized_path, cv2.IMREAD_UNCHANGED)
+        if dem_image is None:
+            self.logger.warning("Failed to read DEM data.")
+            return
+
+        roads_polylines = self.get_infolayer_data(Parameters.TEXTURES, Parameters.ROADS_POLYLINES)
+        if not roads_polylines:
+            self.logger.warning("No roads polylines found in textures info layer.")
+            return
+
+        self.logger.debug("Found %s roads polylines in textures info layer.", len(roads_polylines))
+
+        full_mask = np.zeros(dem_image.shape, dtype=np.uint8)
+
+        for road_polyline in tqdm(roads_polylines, desc="Flattening roads", unit="road"):
+            points = road_polyline.get("points")
+            width = road_polyline.get("width")
+            if not points or not width:
+                self.logger.warning("Skipping road with insufficient data: %s", road_polyline)
+                continue
+
+            try:
+                fitted_road = self.fit_object_into_bounds(
+                    linestring_points=points, angle=self.rotation
+                )
+            except ValueError as e:
+                self.logger.debug(
+                    "Road polyline could not be fitted into the map bounds with error: %s",
+                    e,
+                )
+                continue
+
+            polyline = shapely.LineString(fitted_road)
+
+            total_length = polyline.length
+            self.logger.debug("Total length of the road polyline: %s", total_length)
+
+            current_distance = 0
+            segments: list[shapely.LineString] = []
+            while current_distance < total_length:
+                start_point = polyline.interpolate(current_distance)
+                end_distance = min(current_distance + SEGMENT_LENGTH, total_length)
+                end_point = polyline.interpolate(end_distance)
+
+                # Create a small segment LineString
+                segment = shapely.LineString([start_point, end_point])
+                segments.append(segment)
+                current_distance += SEGMENT_LENGTH
+
+            self.logger.debug("Number of segments created: %s", len(segments))
+
+            road_polygons: list[shapely.Polygon] = []
+            for segment in segments:
+                polygon = segment.buffer(
+                    width * 2, resolution=4, cap_style="flat", join_style="mitre"
+                )
+                road_polygons.append(polygon)
+
+            for polygon in road_polygons:
+                polygon_points = polygon.exterior.coords
+                road_np = self.polygon_points_to_np(polygon_points)
+                mask = np.zeros(dem_image.shape, dtype=np.uint8)
+
+                try:
+                    cv2.fillPoly(mask, [road_np], 255)  # type: ignore
+                except Exception as e:
+                    self.logger.debug("Could not create mask for road with error: %s", e)
+                    continue
+
+                mean_value = cv2.mean(dem_image, mask=mask)[0]  # type: ignore
+                dem_image[mask == 255] = mean_value
+                full_mask[mask == 255] = 255
+
+        main_dem_path = self.game.dem_file_path(self.map_directory)
+        dem_image = self.blur_by_mask(dem_image, full_mask)
+        dem_image = self.blur_edges_by_mask(dem_image, full_mask)
+
+        output_size = dem_image.shape[0] + 1
+        resized_dem = cv2.resize(
+            dem_image, (output_size, output_size), interpolation=cv2.INTER_NEAREST
+        )
+
+        cv2.imwrite(main_dem_path, resized_dem)
+        self.logger.debug("Flattened roads saved to DEM file: %s", main_dem_path)

maps4fs/generator/component/base/component_image.py

@@ -175,3 +175,59 @@ class ImageComponent(Component):
         elif blur_radius % 2 == 0:
             blur_radius += 1
         return blur_radius
+
+    def blur_by_mask(self, data: np.ndarray, mask: np.ndarray, blur_radius: int = 3) -> np.ndarray:
+        """Blurs the provided image only where the mask is set.
+
+        Arguments:
+            data (np.ndarray): The image data to be blurred.
+            mask (np.ndarray): The mask where the blur should be applied.
+
+        Returns:
+            np.ndarray: The image with the blur applied according to the mask.
+        """
+        if data.shape[:2] != mask.shape[:2]:
+            raise ValueError("Data and mask must have the same dimensions.")
+
+        # Create a blurred version of the data
+        blurred_data = cv2.GaussianBlur(data, (blur_radius, blur_radius), sigmaX=3)
+
+        # Combine the blurred data with the original data using the mask
+        result = np.where(mask == 255, blurred_data, data)
+
+        return result
+
+    def blur_edges_by_mask(
+        self,
+        data: np.ndarray,
+        mask: np.ndarray,
+        bigger_kernel: int = 3,
+        smaller_kernel: int = 1,
+        iterations: int = 1,
+    ) -> np.ndarray:
+        """Blurs the edges of the edge region where changes were made by mask earlier.
+        Creates a slightly bigger mask, a slightly smaller mask, subtract them
+        and obtains the mask for the edges.
+        Then applies blur to the image data only where the mask is set.
+
+        Arguments:
+            data (np.ndarray): The image data to be blurred.
+            mask (np.ndarray): The mask where changes were made.
+            blur_radius (int): The radius of the blur.
+
+        Returns:
+            np.ndarray: The image with the edges blurred according to the mask.
+        """
+        if data.shape[:2] != mask.shape[:2]:
+            raise ValueError("Data and mask must have the same dimensions.")
+
+        bigger_mask = cv2.dilate(
+            mask, np.ones((bigger_kernel, bigger_kernel), np.uint8), iterations=iterations
+        )
+        smaller_mask = cv2.erode(
+            mask, np.ones((smaller_kernel, smaller_kernel), np.uint8), iterations=iterations
+        )
+
+        edge_mask = cv2.subtract(bigger_mask, smaller_mask)
+
+        return self.blur_by_mask(data, edge_mask)

maps4fs/generator/component/grle.py

@@ -11,8 +11,13 @@ from tqdm import tqdm
 
 from maps4fs.generator.component.base.component_image import ImageComponent
 from maps4fs.generator.component.base.component_xml import XMLComponent
+from maps4fs.generator.component.layer import Layer
 from maps4fs.generator.settings import Parameters
 
+# This value sums up the pixel value of the basic area type to convert it from "No Water" to "Near Water".
+# For example, if the basic area type is "city" (1), then the pixel value for "near water" will be 9.
+WATER_AREA_PIXEL_VALUE = 8
+
 
 def plant_to_pixel_value(plant_name: str) -> int | None:
     """Returns the pixel value representation of the plant.
@@ -31,6 +36,27 @@ def plant_to_pixel_value(plant_name: str) -> int | None:
     return plants.get(plant_name)
 
 
+def area_type_to_pixel_value(area_type: str) -> int | None:
+    """Returns the pixel value representation of the area type.
+    If not found, returns None.
+
+    Arguments:
+        area_type (str): name of the area type
+
+    Returns:
+        int | None: pixel value of the area type or None if not found.
+    """
+    area_types = {
+        "open_land": 0,
+        "city": 1,
+        "village": 2,
+        "harbor": 3,
+        "industrial": 4,
+        "open_water": 5,
+    }
+    return area_types.get(area_type)
+
+
 class GRLE(ImageComponent, XMLComponent):
     """Component for to generate InfoLayer PNG files based on GRLE schema.
 
@@ -104,6 +130,9 @@ class GRLE(ImageComponent, XMLComponent):
         self._add_farmlands()
         if self.game.plants_processing and self.map.grle_settings.add_grass:
             self._add_plants()
+        if self.game.environment_processing:
+            self._process_environment()
+            self._process_indoor()
 
     def previews(self) -> list[str]:
         """Returns a list of paths to the preview images (empty list).
@@ -130,6 +159,9 @@ class GRLE(ImageComponent, XMLComponent):
             cv2.imwrite(save_path, image_colored)
             preview_paths.append(save_path)
 
+            if preview_name != "farmlands":
+                continue
+
             with_fields_save_path = os.path.join(
                 self.previews_directory, f"{preview_name}_with_fields.png"
             )
@@ -462,3 +494,149 @@ class GRLE(ImageComponent, XMLComponent):
         image_np[:, 0] = 0  # Left side
         image_np[:, -1] = 0  # Right side
         return image_np
+
+    def _process_environment(self) -> None:
+        info_layer_environment_path = self.game.get_environment_path(self.map_directory)
+        if not info_layer_environment_path or not os.path.isfile(info_layer_environment_path):
+            self.logger.warning(
+                "Environment InfoLayer PNG file not found in %s.", info_layer_environment_path
+            )
+            return
+
+        self.logger.debug(
+            "Processing environment InfoLayer PNG file: %s.", info_layer_environment_path
+        )
+
+        environment_image = cv2.imread(info_layer_environment_path, cv2.IMREAD_UNCHANGED)
+        if environment_image is None:
+            self.logger.error("Failed to read the environment InfoLayer PNG file.")
+            return
+
+        self.logger.debug(
+            "Environment InfoLayer PNG file loaded, shape: %s.", environment_image.shape
+        )
+
+        environment_size = int(environment_image.shape[0])
+
+        # 1. Get the texture layers that contain "area_type" property.
+        # 2. Read the corresponding weight image (not the dissolved ones!).
+        # 3. Resize it to match the environment image size (probably 1/4 of the texture size).
+        # 4. Dilate the texture mask to make it little bit bigger.
+        # 5. Set the corresponding pixel values of the environment image to the pixel value of the area type.
+        # 6. Get the texture layer that "area_water" is True.
+        # 7. Same as resize, dilate, etc.
+        # 8. Sum the current pixel value with the WATER_AREA_PIXEL_VALUE.
+
+        texture_component = self.map.get_texture_component()
+        if not texture_component:
+            self.logger.warning("Texture component not found in the map.")
+            return
+
+        for layer in texture_component.get_area_type_layers():
+            pixel_value = area_type_to_pixel_value(layer.area_type)  # type: ignore
+            weight_image = self.get_resized_weight(layer, environment_size)  # type: ignore
+            if weight_image is None:
+                self.logger.warning("Weight image for area type layer not found in %s.", layer.name)
+                continue
+            environment_image[weight_image > 0] = pixel_value  # type: ignore
+
+        for layer in texture_component.get_water_area_layers():
+            pixel_value = WATER_AREA_PIXEL_VALUE
+            weight_image = self.get_resized_weight(layer, environment_size)
+            if weight_image is None:
+                self.logger.warning(
+                    "Weight image for water area layer not found in %s.", layer.name
+                )
+                continue
+            environment_image[weight_image > 0] += pixel_value  # type: ignore
+
+        cv2.imwrite(info_layer_environment_path, environment_image)
+        self.logger.debug("Environment InfoLayer PNG file saved: %s.", info_layer_environment_path)
+        self.preview_paths["environment"] = info_layer_environment_path
+
+    def get_resized_weight(
+        self, layer: Layer, resize_to: int, dilations: int = 3
+    ) -> np.ndarray | None:
+        """Get the resized weight image for a given layer.
+
+        Arguments:
+            layer (Layer): The layer for which to get the weight image.
+            resize_to (int): The size to which the weight image should be resized.
+            dilations (int): The number of dilations to apply to the weight image.
+
+        Returns:
+            np.ndarray | None: The resized and dilated weight image, or None if the image could not be loaded.
+        """
+        weight_image_path = layer.get_preview_or_path(
+            self.game.weights_dir_path(self.map_directory)
+        )
+        self.logger.debug("Weight image path for area type layer: %s.", weight_image_path)
+
+        if not weight_image_path or not os.path.isfile(weight_image_path):
+            self.logger.warning(
+                "Weight image for area type layer not found in %s.", weight_image_path
+            )
+            return None
+
+        weight_image = cv2.imread(weight_image_path, cv2.IMREAD_UNCHANGED)
+        if weight_image is None:
+            self.logger.error("Failed to read the weight image for area type layer.")
+            return None
+
+        self.logger.debug("Weight image for area type layer loaded, shape: %s.", weight_image.shape)
+
+        # Resize the weight image to match the environment image size.
+        weight_image = cv2.resize(
+            weight_image,
+            (resize_to, resize_to),
+            interpolation=cv2.INTER_NEAREST,
+        )
+
+        self.logger.debug(
+            "Resized weight image for area type layer, new shape: %s.", weight_image.shape
+        )
+
+        if dilations <= 0:
+            return weight_image
+
+        dilated_weight_image = cv2.dilate(
+            weight_image.astype(np.uint8), np.ones((dilations, dilations), np.uint8), iterations=dilations  # type: ignore
+        )
+
+        return dilated_weight_image
+
+    def _process_indoor(self) -> None:
+        """Processes the indoor layers."""
+        info_layer_indoor_path = self.game.get_indoor_mask_path(self.map_directory)
+        if not info_layer_indoor_path or not os.path.isfile(info_layer_indoor_path):
+            self.logger.warning(
+                "Indoor InfoLayer PNG file not found in %s.", info_layer_indoor_path
+            )
+            return
+
+        indoor_mask_image = cv2.imread(info_layer_indoor_path, cv2.IMREAD_UNCHANGED)
+        if indoor_mask_image is None:
+            self.logger.warning(
+                "Failed to read the indoor InfoLayer PNG file %s.", info_layer_indoor_path
+            )
+            return
+
+        indoor_mask_size = int(indoor_mask_image.shape[0])
+        self.logger.debug("Indoor InfoLayer PNG file loaded, shape: %s.", indoor_mask_image.shape)
+
+        texture_component = self.map.get_texture_component()
+        if not texture_component:
+            self.logger.warning("Texture component not found in the map.")
+            return
+
+        for layer in texture_component.get_indoor_layers():
+            weight_image = self.get_resized_weight(layer, indoor_mask_size, dilations=0)
+            if weight_image is None:
+                self.logger.warning("Weight image for indoor layer not found in %s.", layer.name)
+                continue
+
+            indoor_mask_image[weight_image > 0] = 1
+
+        cv2.imwrite(info_layer_indoor_path, indoor_mask_image)
+        self.logger.debug("Indoor InfoLayer PNG file saved: %s.", info_layer_indoor_path)
+        self.preview_paths["indoor"] = info_layer_indoor_path

maps4fs/generator/component/layer.py

@@ -46,6 +46,9 @@ class Layer:
         border: int | None = None,
         precise_tags: dict[str, str | list[str] | bool] | None = None,
         precise_usage: str | None = None,
+        area_type: str | None = None,
+        area_water: bool = False,
+        indoor: bool = False,
     ):
         self.name = name
         self.count = count
@@ -62,6 +65,9 @@ class Layer:
         self.border = border
         self.precise_tags = precise_tags
         self.precise_usage = precise_usage
+        self.area_type = area_type
+        self.area_water = area_water
+        self.indoor = indoor
 
     def to_json(self) -> dict[str, str | list[str] | bool]:  # type: ignore
         """Returns dictionary with layer data.
@@ -84,6 +90,9 @@ class Layer:
             "border": self.border,
             "precise_tags": self.precise_tags,
             "precise_usage": self.precise_usage,
+            "area_type": self.area_type,
+            "area_water": self.area_water,
+            "indoor": self.indoor,
         }
 
         data = {k: v for k, v in data.items() if v is not None}

maps4fs/generator/component/texture.py

@@ -137,6 +137,36 @@ class Texture(ImageComponent):
         """
         return [layer for layer in self.layers if layer.usage == usage]
 
+    def get_area_type_layers(self, area_type: str | None = None) -> list[Layer]:
+        """Returns layers by area type. If area_type is None, returns all layers
+        with area_type set (not None).
+
+        Arguments:
+            area_type (str | None): Area type of the layer.
+
+        Returns:
+            list[Layer]: List of layers.
+        """
+        if area_type is None:
+            return [layer for layer in self.layers if layer.area_type is not None]
+        return [layer for layer in self.layers if layer.area_type == area_type]
+
+    def get_water_area_layers(self) -> list[Layer]:
+        """Returns layers which are water areas.
+
+        Returns:
+            list[Layer]: List of layers which are water areas.
+        """
+        return [layer for layer in self.layers if layer.area_water]
+
+    def get_indoor_layers(self) -> list[Layer]:
+        """Returns layers which are indoor areas.
+
+        Returns:
+            list[Layer]: List of layers which are indoor areas.
+        """
+        return [layer for layer in self.layers if layer.indoor]
+
     def process(self) -> None:
         """Processes the data to generate textures."""
         self._prepare_weights()

maps4fs/generator/game.py

@@ -40,6 +40,7 @@ class Game:
     _tree_schema: str | None = None
     _i3d_processing: bool = True
     _plants_processing: bool = True
+    _environment_processing: bool = True
     _fog_processing: bool = True
     _dissolve: bool = True
 
@@ -180,6 +181,28 @@ class Game:
         weights_dir = self.weights_dir_path(map_directory)
         return os.path.join(weights_dir, "infoLayer_farmlands.png")
 
+    def get_environment_path(self, map_directory: str) -> str:
+        """Returns the path to the environment file.
+
+        Arguments:
+            map_directory (str): The path to the map directory.
+
+        Returns:
+            str: The path to the environment file."""
+        weights_dir = self.weights_dir_path(map_directory)
+        return os.path.join(weights_dir, "infoLayer_environment.png")
+
+    def get_indoor_mask_path(self, map_directory: str) -> str:
+        """Returns the path to the indoor mask file.
+
+        Arguments:
+            map_directory (str): The path to the map directory.
+
+        Returns:
+            str: The path to the indoor mask file."""
+        weights_dir = self.weights_dir_path(map_directory)
+        return os.path.join(weights_dir, "infoLayer_indoorMask.png")
+
     def get_farmlands_xml_path(self, map_directory: str) -> str:
         """Returns the path to the farmlands xml file.
 
@@ -218,6 +241,14 @@ class Game:
             bool: True if the i3d file should be processed, False otherwise."""
         return self._i3d_processing
 
+    @property
+    def environment_processing(self) -> bool:
+        """Returns whether the environment should be processed.
+
+        Returns:
+            bool: True if the environment should be processed, False otherwise."""
+        return self._environment_processing
+
     @property
     def fog_processing(self) -> bool:
         """Returns whether the fog should be processed.
@@ -269,6 +300,7 @@ class FS22(Game):
     _map_template_path = os.path.join(working_directory, "data", "fs22-map-template.zip")
     _texture_schema = os.path.join(working_directory, "data", "fs22-texture-schema.json")
     _i3d_processing = False
+    _environment_processing = False
     _fog_processing = False
     _plants_processing = False
     _dissolve = False

maps4fs/generator/settings.py

@@ -163,12 +163,14 @@ class BackgroundSettings(SettingsModel):
         water_blurriness (int): blurriness of the water.
         remove_center (bool): remove the center of the background terrain.
             It will be used to remove the center of the map where the player starts.
+        flatten_roads (bool): if True, roads will be flattened in the DEM data.
     """
 
     generate_background: bool = False
     generate_water: bool = False
     water_blurriness: int = 20
     remove_center: bool = True
+    flatten_roads: bool = False
 
 
 class GRLESettings(SettingsModel):

{maps4fs-2.1.1.dist-info → maps4fs-2.1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maps4fs
-Version: 2.1.1
+Version: 2.1.3
 Summary: Generate map templates for Farming Simulator from real places.
 Author-email: iwatkot <iwatkot@gmail.com>
 License: Apache License 2.0
@@ -546,6 +546,9 @@ Let's have a closer look at the fields:
 - `border` - this value defines the border between the texture and the edge of the map. It's used to prevent the texture from being drawn on the edge of the map. The value is in pixels.
 - `precise_tags` - can be used for more specific tags, for example instead of `"natural": "wood"` you can use `"leaf_type": "broadleaved"` to draw only broadleaved trees.
 - `precise_usage` - the same as `usage`, but being used with `precise_tags`.
+- `area_type` - one of the supported by Giants Editor area types, such as: "open_land", "city", "village", "harbor", "industrial", "open_water". It will be reflected in the environment info layer file.  
+- `area_water` - whenever this field is set to true, the area will be considered as water, and it will be changed in the environment info layer file.
+- `indoor` - whenever this field is set to true, the area will be considered as indoor, and it will be reflected in the indoorMask info layer.
 
 ## Background terrain
 

{maps4fs-2.1.1.dist-info → maps4fs-2.1.3.dist-info}/RECORD

@@ -1,27 +1,27 @@
 maps4fs/__init__.py,sha256=Fy521EmVAWnhu6OvOInc97yrtJotFzcV0YfRB2b9O4s,314
 maps4fs/logger.py,sha256=WDfR14hxqy8b6xtwL6YIu2LGzFO1sbt0LxMgfsDTOkA,865
 maps4fs/generator/__init__.py,sha256=zZMLEkGzb4z0xql650gOtGSvcgX58DnJ2yN3vC2daRk,43
-maps4fs/generator/game.py,sha256=Nl8xqEwW-E04l2D3e9ff7kkzPcolr1ndnXxQJlLMBDM,12627
+maps4fs/generator/game.py,sha256=Qqeh1rg0RFghhu9uhBMn_XKXYkTkg7fsjY1xO2eIZRw,13777
 maps4fs/generator/map.py,sha256=x_NjUwKkDnh2cC61QpTfX88mFHAkQG1sxVwZckoV0mE,16357
 maps4fs/generator/qgis.py,sha256=Es8hLuqN_KH8lDfnJE6He2rWYbAKJ3RGPn-o87S6CPI,6116
-maps4fs/generator/settings.py,sha256=OXgCjpmcqvTENRcKKYcEhES3GD3KPpvrbeJDv8g25yY,7676
+maps4fs/generator/settings.py,sha256=bjEhn1918lxSsIRgmOXVpYWS3E4y72eqx2Ty7f99JKE,7788
 maps4fs/generator/statistics.py,sha256=aynS3zbAtiwnU_YLKHPTiiaKW98_suvQUhy1SGBA6mc,2448
 maps4fs/generator/component/__init__.py,sha256=s01yVVVi8R2xxNvflu2D6wTd9I_g73AMM2x7vAC7GX4,490
-maps4fs/generator/component/background.py,sha256=wqTgndTfRIGlLMpMXqJMw_6eVdH1JtMei46ZIXlT9X4,29480
+maps4fs/generator/component/background.py,sha256=0fTmghJZzmZMqleTmFc5C6A53eZm7nhMpLYmkELAHmQ,33507
 maps4fs/generator/component/config.py,sha256=uL76h9UwyhZKZmbxz0mBmWtEPN6qYay4epTEqqtej60,8601
 maps4fs/generator/component/dem.py,sha256=SH_2Zu5O4dhWtZeOkCwzDF4RU04XhTdpGFYaRYJkdjc,11905
-maps4fs/generator/component/grle.py,sha256=8K32pC_ar9CR6p0EhCe2X--wEoIxFzJCPcN9ydHQ1LE,19747
+maps4fs/generator/component/grle.py,sha256=3BKGlR0q0t0NvmqeT81WieS6MIc_UlMQjIDDZiqTiws,27243
 maps4fs/generator/component/i3d.py,sha256=L-QAbr3Z7Ye5N0BeS_qvY9bqYxYs0eVnRCGWp77etrE,26693
-maps4fs/generator/component/layer.py,sha256=-br4gAGcGeBNb3ldch9XFEK0lhXqb1IbArhFB5Owu54,6186
+maps4fs/generator/component/layer.py,sha256=U_DzJTn1m_yGOtwuvbXxr7oL7YHHBGBcK37lyJNnZDk,6508
 maps4fs/generator/component/satellite.py,sha256=OsxoNOCgkUtRzL7Geuqubsf6uoKXAIN8jQvrJ7IFeAI,4958
-maps4fs/generator/component/texture.py,sha256=krtvOS0hH8BTzfxd2jsTo3bIJYRkIVbaz6FGhWY8L1o,33921
+maps4fs/generator/component/texture.py,sha256=bpHBwUksEbwPQrdQ8K94m_MIKXnWYnUMvP987JVabAA,34987
 maps4fs/generator/component/base/__init__.py,sha256=zZMLEkGzb4z0xql650gOtGSvcgX58DnJ2yN3vC2daRk,43
 maps4fs/generator/component/base/component.py,sha256=Vgmdsn1ZC37EwWi4Va4uYVt0RnFLiARTtZ-R5GTSrrM,22877
-maps4fs/generator/component/base/component_image.py,sha256=2NYJgCU8deHl7O2FYFYk38WKZVJygFoc2gjBXwH6vjM,5970
+maps4fs/generator/component/base/component_image.py,sha256=n_tHyq8J1zWnb1_8O6fhNNd_4Wfj2VU2QqSAEzJXf60,8119
 maps4fs/generator/component/base/component_mesh.py,sha256=_thzgjJDroMn-9SBsBmAWizcSsnV9U5445SD18Tx1kc,9090
 maps4fs/generator/component/base/component_xml.py,sha256=MT-VhU2dEckLFxAgmxg6V3gnv11di_94Qq6atfpOLdc,5342
-maps4fs-2.1.1.dist-info/licenses/LICENSE.md,sha256=pTKD_oUexcn-yccFCTrMeLkZy0ifLRa-VNcDLqLZaIw,10749
-maps4fs-2.1.1.dist-info/METADATA,sha256=uHY1Ap5uahWTaFPIAOulIBz754lJ7Ga4S4RJ6ZOAUpI,44934
-maps4fs-2.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-maps4fs-2.1.1.dist-info/top_level.txt,sha256=Ue9DSRlejRQRCaJueB0uLcKrWwsEq9zezfv5dI5mV1M,8
-maps4fs-2.1.1.dist-info/RECORD,,
+maps4fs-2.1.3.dist-info/licenses/LICENSE.md,sha256=pTKD_oUexcn-yccFCTrMeLkZy0ifLRa-VNcDLqLZaIw,10749
+maps4fs-2.1.3.dist-info/METADATA,sha256=qJ4vDMMwhoupUdurZjg1aROKauLLhWLx9845zyynngY,45431
+maps4fs-2.1.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+maps4fs-2.1.3.dist-info/top_level.txt,sha256=Ue9DSRlejRQRCaJueB0uLcKrWwsEq9zezfv5dI5mV1M,8
+maps4fs-2.1.3.dist-info/RECORD,,