valetudo-map-parser 0.1.9b59__tar.gz → 0.1.9b61__tar.gz

{valetudo_map_parser-0.1.9b59 → valetudo_map_parser-0.1.9b61}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: valetudo-map-parser
-Version: 0.1.9b59
+Version: 0.1.9b61
 Summary: A Python library to parse Valetudo map data returning a PIL Image object.
 License: Apache-2.0
 Author: Sandro Cantarella
@@ -12,6 +12,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: Pillow (>=10.3.0)
 Requires-Dist: numpy (>=1.26.4)
+Requires-Dist: pandas (>=2.3.0)
 Requires-Dist: scipy (>=1.12.0)
 Project-URL: Bug Tracker, https://github.com/sca075/Python-package-valetudo-map-parser/issues
 Project-URL: Changelog, https://github.com/sca075/Python-package-valetudo-map-parser/releases

valetudo_map_parser-0.1.9b61/SCR/valetudo_map_parser/config/async_utils.py

@@ -0,0 +1,55 @@
+"""Async utility functions for making NumPy and PIL operations truly async."""
+
+import asyncio
+import io
+from typing import Any, Callable
+
+import numpy as np
+from PIL import Image
+
+
+async def make_async(func: Callable, *args, **kwargs) -> Any:
+    """Convert a synchronous function to async by yielding control to the event loop."""
+    result = func(*args, **kwargs)
+    await asyncio.sleep(0)
+    return result
+
+
+class AsyncNumPy:
+    """Async wrappers for NumPy operations that yield control to the event loop."""
+
+    @staticmethod
+    async def async_copy(array: np.ndarray) -> np.ndarray:
+        """Async array copying."""
+        return await make_async(np.copy, array)
+
+    @staticmethod
+    async def async_full(shape: tuple, fill_value: Any, dtype: np.dtype = None) -> np.ndarray:
+        """Async array creation with fill value."""
+        return await make_async(np.full, shape, fill_value, dtype=dtype)
+
+
+class AsyncPIL:
+    """Async wrappers for PIL operations that yield control to the event loop."""
+
+    @staticmethod
+    async def async_fromarray(array: np.ndarray, mode: str = "RGBA") -> Image.Image:
+        """Async PIL Image creation from NumPy array."""
+        return await make_async(Image.fromarray, array, mode)
+
+    @staticmethod
+    async def async_resize(image: Image.Image, size: tuple, resample: int = None) -> Image.Image:
+        """Async image resizing."""
+        if resample is None:
+            resample = Image.LANCZOS
+        return await make_async(image.resize, size, resample)
+
+    @staticmethod
+    async def async_save_to_bytes(image: Image.Image, format_type: str = "WEBP", **kwargs) -> bytes:
+        """Async image saving to bytes."""
+        def save_to_bytes():
+            buffer = io.BytesIO()
+            image.save(buffer, format=format_type, **kwargs)
+            return buffer.getvalue()
+        
+        return await make_async(save_to_bytes)

{valetudo_map_parser-0.1.9b59 → valetudo_map_parser-0.1.9b61}/SCR/valetudo_map_parser/config/drawable.py

@@ -16,6 +16,7 @@ import math
 import numpy as np
 from PIL import ImageDraw, ImageFont
 
+from .async_utils import AsyncNumPy
 from .color_utils import get_blended_color
 from .colors import ColorsManagement
 from .types import Color, NumpyArray, PilPNG, Point, Tuple, Union
@@ -45,7 +46,7 @@ class Drawable:
     ) -> NumpyArray:
         """Create the empty background image NumPy array.
         Background color is specified as an RGBA tuple."""
-        return np.full((height, width, 4), background_color, dtype=np.uint8)
+        return await AsyncNumPy.async_full((height, width, 4), background_color, dtype=np.uint8)
 
     @staticmethod
     async def from_json_to_image(

{valetudo_map_parser-0.1.9b59 → valetudo_map_parser-0.1.9b61}/SCR/valetudo_map_parser/hypfer_handler.py

@@ -11,6 +11,7 @@ import json
 
 from PIL import Image
 
+from .config.async_utils import AsyncNumPy, AsyncPIL
 from .config.auto_crop import AutoCrop
 from .config.drawable_elements import DrawableElement
 from .config.shared import CameraShared
@@ -371,7 +372,7 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
             # Handle resizing if needed, then return based on format preference
             if self.check_zoom_and_aspect_ratio():
                 # Convert to PIL for resizing
-                pil_img = Image.fromarray(img_np_array, mode="RGBA")
+                pil_img = await AsyncPIL.async_fromarray(img_np_array, mode="RGBA")
                 del img_np_array
                 resize_params = prepare_resize_params(self, pil_img, False)
                 resized_image = await self.async_resize_images(resize_params)
@@ -394,7 +395,7 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                     return webp_bytes
                 else:
                     # Convert to PIL Image (original behavior)
-                    pil_img = Image.fromarray(img_np_array, mode="RGBA")
+                    pil_img = await AsyncPIL.async_fromarray(img_np_array, mode="RGBA")
                     del img_np_array
                     LOGGER.debug("%s: Frame Completed.", self.file_name)
                     return pil_img
@@ -474,4 +475,4 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
     @staticmethod
     async def async_copy_array(original_array):
         """Copy the array."""
-        return original_array.copy()
+        return await AsyncNumPy.async_copy(original_array)

{valetudo_map_parser-0.1.9b59 → valetudo_map_parser-0.1.9b61}/SCR/valetudo_map_parser/map_data.py

@@ -9,7 +9,7 @@ Version: v0.1.6
 from __future__ import annotations
 
 import numpy as np
-
+import pandas as pd
 from .config.types import ImageSize, JsonType
 
 
@@ -18,65 +18,48 @@ class ImageData:
 
     @staticmethod
     def sublist(lst, n):
-        """Sub lists of specific n number of elements"""
-        return [lst[i : i + n] for i in range(0, len(lst), n)]
+        """Split a list into n chunks of specified size."""
+        return [lst[i: i + n] for i in range(0, len(lst), n)]
 
     @staticmethod
     def sublist_join(lst, n):
-        """Join the lists in a unique list of n elements"""
+        """Join the lists in a unique list of n elements."""
         arr = np.array(lst)
         num_windows = len(lst) - n + 1
-        result = [arr[i : i + n].tolist() for i in range(num_windows)]
+        result = [arr[i: i + n].tolist() for i in range(num_windows)]
         return result
 
-    # The below functions are basically the same ech one
-    # of them is allowing filtering and putting together in a
-    # list the specific Layers, Paths, Zones and Pints in the
-    # Vacuums Json in parallel.
-
     @staticmethod
     def get_obstacles(entity_dict: dict) -> list:
         """Get the obstacles positions from the entity data."""
-        try:
-            obstacle_data = entity_dict.get("obstacle")
-        except KeyError:
-            return []
+        obstacles = entity_dict.get("obstacle", [])
         obstacle_positions = []
-        if obstacle_data:
-            for obstacle in obstacle_data:
-                label = obstacle.get("metaData", {}).get("label")
-                points = obstacle.get("points", [])
-                image_id = obstacle.get("metaData", {}).get("id")
-
-                if label and points:
-                    obstacle_pos = {
-                        "label": label,
-                        "points": {"x": points[0], "y": points[1]},
-                        "id": image_id,
-                    }
-                    obstacle_positions.append(obstacle_pos)
-            return obstacle_positions
-        return []
-
-    @staticmethod
-    def find_layers(
-        json_obj: JsonType, layer_dict: dict, active_list: list
-    ) -> tuple[dict, list]:
+        for obstacle in obstacles:
+            label = obstacle.get("metaData", {}).get("label")
+            points = obstacle.get("points", [])
+            image_id = obstacle.get("metaData", {}).get("id")
+            if label and points:
+                obstacle_positions.append({
+                    "label": label,
+                    "points": {"x": points[0], "y": points[1]},
+                    "id": image_id,
+                })
+        return obstacle_positions
+
+    @staticmethod
+    def find_layers(json_obj: JsonType, layer_dict: dict, active_list: list) -> tuple[dict, list]:
         """Find the layers in the json object."""
         layer_dict = {} if layer_dict is None else layer_dict
         active_list = [] if active_list is None else active_list
         if isinstance(json_obj, dict):
-            if "__class" in json_obj and json_obj["__class"] == "MapLayer":
+            if json_obj.get("__class") == "MapLayer":
                 layer_type = json_obj.get("type")
                 active_type = json_obj.get("metaData")
                 if layer_type:
-                    if layer_type not in layer_dict:
-                        layer_dict[layer_type] = []
-                    layer_dict[layer_type].append(json_obj.get("compressedPixels", []))
+                    layer_dict.setdefault(layer_type, []).append(json_obj.get("compressedPixels", []))
                 if layer_type == "segment":
-                    active_list.append(int(active_type["active"]))
-
-            for value in json_obj.items():
+                    active_list.append(int(active_type.get("active", 0)))
+            for value in json_obj.values():
                 ImageData.find_layers(value, layer_dict, active_list)
         elif isinstance(json_obj, list):
             for item in json_obj:
@@ -86,8 +69,7 @@ class ImageData:
     @staticmethod
     def find_points_entities(json_obj: JsonType, entity_dict: dict = None) -> dict:
         """Find the points entities in the json object."""
-        if entity_dict is None:
-            entity_dict = {}
+        entity_dict = {} if entity_dict is None else entity_dict
         if isinstance(json_obj, dict):
             if json_obj.get("__class") == "PointMapEntity":
                 entity_type = json_obj.get("type")
@@ -103,9 +85,7 @@ class ImageData:
     @staticmethod
     def find_paths_entities(json_obj: JsonType, entity_dict: dict = None) -> dict:
         """Find the paths entities in the json object."""
-
-        if entity_dict is None:
-            entity_dict = {}
+        entity_dict = {} if entity_dict is None else entity_dict
         if isinstance(json_obj, dict):
             if json_obj.get("__class") == "PathMapEntity":
                 entity_type = json_obj.get("type")
@@ -121,8 +101,7 @@ class ImageData:
     @staticmethod
     def find_zone_entities(json_obj: JsonType, entity_dict: dict = None) -> dict:
         """Find the zone entities in the json object."""
-        if entity_dict is None:
-            entity_dict = {}
+        entity_dict = {} if entity_dict is None else entity_dict
         if isinstance(json_obj, dict):
             if json_obj.get("__class") == "PolygonMapEntity":
                 entity_type = json_obj.get("type")
@@ -138,59 +117,41 @@ class ImageData:
     @staticmethod
     def find_virtual_walls(json_obj: JsonType) -> list:
         """Find the virtual walls in the json object."""
-        virtual_walls = []
+        walls = []
 
-        def find_virtual_walls_recursive(obj):
-            """Find the virtual walls in the json object recursively."""
+        def _recursive(obj):
             if isinstance(obj, dict):
-                if obj.get("__class") == "LineMapEntity":
-                    entity_type = obj.get("type")
-                    if entity_type == "virtual_wall":
-                        virtual_walls.append(obj["points"])
+                if obj.get("__class") == "LineMapEntity" and obj.get("type") == "virtual_wall":
+                    walls.append(obj["points"])
                 for value in obj.values():
-                    find_virtual_walls_recursive(value)
+                    _recursive(value)
             elif isinstance(obj, list):
                 for item in obj:
-                    find_virtual_walls_recursive(item)
+                    _recursive(item)
 
-        find_virtual_walls_recursive(json_obj)
-        return virtual_walls
+        _recursive(json_obj)
+        return walls
 
     @staticmethod
-    async def async_get_rooms_coordinates(
-        pixels: list, pixel_size: int = 5, rand: bool = False
-    ) -> tuple:
-        """
-        Extract the room coordinates from the vacuum pixels data.
-        piexels: dict: The pixels data format [[x,y,z], [x1,y1,z1], [xn,yn,zn]].
-        pixel_size: int: The size of the pixel in mm (optional).
-        rand: bool: Return the coordinates in a rand256 format (optional).
-        """
-        # Initialize variables to store max and min coordinates
-        max_x, max_y = pixels[0][0], pixels[0][1]
-        min_x, min_y = pixels[0][0], pixels[0][1]
-        # Iterate through the data list to find max and min coordinates
-        for entry in pixels:
-            if rand:
-                x, y, _ = entry  # Extract x and y coordinates
-                max_x = max(max_x, x)  # Update max x coordinate
-                max_y = max(max_y, y + pixel_size)  # Update max y coordinate
-                min_x = min(min_x, x)  # Update min x coordinate
-                min_y = min(min_y, y)  # Update min y coordinate
-            else:
-                x, y, z = entry  # Extract x and y coordinates
-                max_x = max(max_x, x + z)  # Update max x coordinate
-                max_y = max(max_y, y + pixel_size)  # Update max y coordinate
-                min_x = min(min_x, x)  # Update min x coordinate
-                min_y = min(min_y, y)  # Update min y coordinate
+    async def async_get_rooms_coordinates(pixels: list, pixel_size: int = 5, rand: bool = False) -> tuple:
+        """Extract the room coordinates from the vacuum pixels data."""
+        df = pd.DataFrame(pixels, columns=["x", "y", "length"])
+        if rand:
+            df["x_end"] = df["x"]
+            df["y_end"] = df["y"] + pixel_size
+        else:
+            df["x_end"] = df["x"] + df["length"]
+            df["y_end"] = df["y"] + pixel_size
+
+        min_x, max_x = df["x"].min(), df["x_end"].max()
+        min_y, max_y = df["y"].min(), df["y_end"].max()
+
         if rand:
             return (
-                (((max_x * pixel_size) * 10), ((max_y * pixel_size) * 10)),
-                (
-                    ((min_x * pixel_size) * 10),
-                    ((min_y * pixel_size) * 10),
-                ),
+                ((max_x * pixel_size) * 10, (max_y * pixel_size) * 10),
+                ((min_x * pixel_size) * 10, (min_y * pixel_size) * 10),
             )
+
         return (
             min_x * pixel_size,
             min_y * pixel_size,
@@ -308,8 +269,17 @@ class RandImageData:
         Return the calculated angle and original angle.
         """
         angle_c = round(json_data.get("robot_angle", 0))
-        angle = (360 - angle_c + 95) if angle_c < 0 else (180 - angle_c - 85)
-        return angle % 360, json_data.get("robot_angle", 0)
+        # Convert negative values: -10 -> 350, -180 -> 359, but keep positive: 24 -> 24
+        if angle_c < 0:
+            if angle_c == -180:
+                angle = 359  # -180 becomes 359 (avoiding 360)
+            else:
+                angle = 360 + angle_c  # -10 -> 350, -90 -> 270
+        else:
+            angle = angle_c
+
+        angle = (angle + 90) % 360
+        return angle, json_data.get("robot_angle", 0)
 
     @staticmethod
     def get_rrm_goto_target(json_data: JsonType) -> list or None:

{valetudo_map_parser-0.1.9b59 → valetudo_map_parser-0.1.9b61}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "valetudo-map-parser"
-version = "0.1.9b59"
+version = "0.1.9b61"
 description = "A Python library to parse Valetudo map data returning a PIL Image object."
 authors = ["Sandro Cantarella <gsca075@gmail.com>"]
 license = "Apache-2.0"
@@ -18,6 +18,7 @@ python = ">=3.12"
 numpy = ">=1.26.4"
 Pillow = ">=10.3.0"
 scipy = ">=1.12.0"
+pandas = ">=2.3.0"
 
 [tool.poetry.group.dev.dependencies]
 ruff = "*"