valetudo-map-parser 0.1.9b60__tar.gz → 0.1.9b62__tar.gz

{valetudo_map_parser-0.1.9b60 → valetudo_map_parser-0.1.9b62}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: valetudo-map-parser
-Version: 0.1.9b60
+Version: 0.1.9b62
 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.9b62/SCR/valetudo_map_parser/config/async_utils.py

@@ -0,0 +1,89 @@
+"""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 numpy import rot90
+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."""
+    await asyncio.sleep(0)
+    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)
+
+    @staticmethod
+    async def async_rot90(array: np.ndarray, k: int = 1) -> np.ndarray:
+        """Async array rotation."""
+        return await make_async(rot90, array, k)
+
+
+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)
+
+
+class AsyncParallel:
+    """Helper functions for parallel processing with asyncio.gather()."""
+
+    @staticmethod
+    async def parallel_data_preparation(*tasks):
+        """Execute multiple data preparation tasks in parallel."""
+        return await asyncio.gather(*tasks, return_exceptions=True)
+
+    @staticmethod
+    async def parallel_array_operations(base_array: np.ndarray, operations: list):
+        """Execute multiple array operations in parallel on copies of the base array."""
+
+        # Create tasks for parallel execution
+        tasks = []
+        for operation_func, *args in operations:
+            # Each operation works on a copy of the base array
+            array_copy = await AsyncNumPy.async_copy(base_array)
+            tasks.append(operation_func(array_copy, *args))
+
+        # Execute all operations in parallel
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+
+        # Filter out exceptions and return successful results
+        successful_results = [r for r in results if not isinstance(r, Exception)]
+        return successful_results

{valetudo_map_parser-0.1.9b60 → valetudo_map_parser-0.1.9b62}/SCR/valetudo_map_parser/config/auto_crop.py

@@ -9,6 +9,7 @@ import numpy as np
 from numpy import rot90
 from scipy import ndimage
 
+from .async_utils import AsyncNumPy, make_async
 from .types import Color, NumpyArray, TrimCropData, TrimsData
 from .utils import BaseHandler
 
@@ -364,7 +365,7 @@ class AutoCrop:
     ) -> NumpyArray:
         """Rotate the image and return the new array."""
         if rotate == 90:
-            rotated = rot90(trimmed)
+            rotated = await AsyncNumPy.async_rot90(trimmed)
             self.crop_area = [
                 self.trim_left,
                 self.trim_up,
@@ -372,10 +373,10 @@ class AutoCrop:
                 self.trim_down,
             ]
         elif rotate == 180:
-            rotated = rot90(trimmed, 2)
+            rotated = await AsyncNumPy.async_rot90(trimmed, 2)
             self.crop_area = self.auto_crop
         elif rotate == 270:
-            rotated = rot90(trimmed, 3)
+            rotated = await AsyncNumPy.async_rot90(trimmed, 3)
             self.crop_area = [
                 self.trim_left,
                 self.trim_up,

{valetudo_map_parser-0.1.9b60 → valetudo_map_parser-0.1.9b62}/SCR/valetudo_map_parser/config/drawable.py

@@ -12,6 +12,8 @@ from __future__ import annotations
 
 import logging
 import math
+import asyncio
+import inspect
 
 import numpy as np
 from PIL import ImageDraw, ImageFont
@@ -44,8 +46,12 @@ class Drawable:
         width: int, height: int, background_color: Color
     ) -> 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)
+        Background color is specified as an RGBA tuple.
+        Optimized: Uses np.empty + broadcast instead of np.full for better performance."""
+        # Use np.empty + broadcast instead of np.full (avoids double initialization)
+        img_array = np.empty((height, width, 4), dtype=np.uint8)
+        img_array[:] = background_color  # Broadcast color to all pixels efficiently
+        return img_array
 
     @staticmethod
     async def from_json_to_image(
@@ -152,6 +158,8 @@ class Drawable:
         It uses the rotation angle of the image to orient the flag.
         Includes color blending for better visual integration.
         """
+        await asyncio.sleep(0)  # Yield control
+
         # Check if coordinates are within bounds
         height, width = layer.shape[:2]
         x, y = center
@@ -323,7 +331,12 @@ class Drawable:
         Join the coordinates creating a continuous line (path).
         Optimized with vectorized operations for better performance.
         """
-        for coord in coords:
+
+        # Handle case where arr might be a coroutine (shouldn't happen but let's be safe)
+        if inspect.iscoroutine(arr):
+            arr = await arr
+
+        for i, coord in enumerate(coords):
             x0, y0 = coord[0]
             try:
                 x1, y1 = coord[1]
@@ -340,6 +353,10 @@ class Drawable:
             # Use the optimized line drawing method
             arr = Drawable._line(arr, x0, y0, x1, y1, blended_color, width)
 
+            # Yield control every 100 operations to prevent blocking
+            if i % 100 == 0:
+                await asyncio.sleep(0)
+
         return arr
 
     @staticmethod
@@ -484,56 +501,120 @@ class Drawable:
     async def zones(layers: NumpyArray, coordinates, color: Color) -> NumpyArray:
         """
         Draw the zones on the input layer with color blending.
-        Optimized with NumPy vectorized operations for better performance.
+        Optimized with parallel processing for better performance.
         """
+        await asyncio.sleep(0)  # Yield control
+
         dot_radius = 1  # Number of pixels for the dot
         dot_spacing = 4  # Space between dots
 
-        for zone in coordinates:
-            points = zone["points"]
-            min_x = max(0, min(points[::2]))
-            max_x = min(layers.shape[1] - 1, max(points[::2]))
-            min_y = max(0, min(points[1::2]))
-            max_y = min(layers.shape[0] - 1, max(points[1::2]))
+        # Process zones in parallel if there are multiple zones
+        if len(coordinates) > 1:
+            # Create tasks for parallel zone processing
+            zone_tasks = []
+            for zone in coordinates:
+                zone_tasks.append(Drawable._process_single_zone(layers.copy(), zone, color, dot_radius, dot_spacing))
+
+            # Execute all zone processing tasks in parallel
+            zone_results = await asyncio.gather(*zone_tasks, return_exceptions=True)
+
+            # Merge results back into the main layer
+            for result in zone_results:
+                if not isinstance(result, Exception):
+                    # Simple overlay - pixels that are different from original get updated
+                    mask = result != layers
+                    layers[mask] = result[mask]
+        else:
+            # Single zone - process directly
+            for zone in coordinates:
+                points = zone["points"]
+                min_x = max(0, min(points[::2]))
+                max_x = min(layers.shape[1] - 1, max(points[::2]))
+                min_y = max(0, min(points[1::2]))
+                max_y = min(layers.shape[0] - 1, max(points[1::2]))
+
+                # Skip if zone is outside the image
+                if min_x >= max_x or min_y >= max_y:
+                    continue
+
+                # Sample a point from the zone to get the background color
+                # Use the center of the zone for sampling
+                sample_x = (min_x + max_x) // 2
+                sample_y = (min_y + max_y) // 2
 
-            # Skip if zone is outside the image
-            if min_x >= max_x or min_y >= max_y:
-                continue
+                # Blend the color with the background color at the sample point
+                if 0 <= sample_y < layers.shape[0] and 0 <= sample_x < layers.shape[1]:
+                    blended_color = ColorsManagement.sample_and_blend_color(
+                        layers, sample_x, sample_y, color
+                    )
+                else:
+                    blended_color = color
 
-            # Sample a point from the zone to get the background color
-            # Use the center of the zone for sampling
-            sample_x = (min_x + max_x) // 2
-            sample_y = (min_y + max_y) // 2
+                # Create a grid of dot centers
+                x_centers = np.arange(min_x, max_x, dot_spacing)
+                y_centers = np.arange(min_y, max_y, dot_spacing)
 
-            # Blend the color with the background color at the sample point
-            if 0 <= sample_y < layers.shape[0] and 0 <= sample_x < layers.shape[1]:
-                blended_color = ColorsManagement.sample_and_blend_color(
-                    layers, sample_x, sample_y, color
-                )
-            else:
-                blended_color = color
+                # Draw dots at each grid point
+                for y in y_centers:
+                    for x in x_centers:
+                        # Create a small mask for the dot
+                        y_min = max(0, y - dot_radius)
+                        y_max = min(layers.shape[0], y + dot_radius + 1)
+                        x_min = max(0, x - dot_radius)
+                        x_max = min(layers.shape[1], x + dot_radius + 1)
 
-            # Create a grid of dot centers
-            x_centers = np.arange(min_x, max_x, dot_spacing)
-            y_centers = np.arange(min_y, max_y, dot_spacing)
+                        # Create coordinate arrays for the dot
+                        y_indices, x_indices = np.ogrid[y_min:y_max, x_min:x_max]
 
-            # Draw dots at each grid point
-            for y in y_centers:
-                for x in x_centers:
-                    # Create a small mask for the dot
+                        # Create a circular mask
+                        mask = (y_indices - y) ** 2 + (x_indices - x) ** 2 <= dot_radius**2
+
+                        # Apply the color to the masked region
+                        layers[y_min:y_max, x_min:x_max][mask] = blended_color
+
+        return layers
+
+    @staticmethod
+    async def _process_single_zone(layers: NumpyArray, zone, color: Color, dot_radius: int, dot_spacing: int) -> NumpyArray:
+        """Process a single zone for parallel execution."""
+        await asyncio.sleep(0)  # Yield control
+
+        points = zone["points"]
+        min_x = max(0, min(points[::2]))
+        max_x = min(layers.shape[1] - 1, max(points[::2]))
+        min_y = max(0, min(points[1::2]))
+        max_y = min(layers.shape[0] - 1, max(points[1::2]))
+
+        # Skip if zone is outside the image
+        if min_x >= max_x or min_y >= max_y:
+            return layers
+
+        # Sample a point from the zone to get the background color
+        sample_x = (min_x + max_x) // 2
+        sample_y = (min_y + max_y) // 2
+
+        # Blend the color with the background color at the sample point
+        if 0 <= sample_y < layers.shape[0] and 0 <= sample_x < layers.shape[1]:
+            blended_color = ColorsManagement.sample_and_blend_color(
+                layers, sample_x, sample_y, color
+            )
+        else:
+            blended_color = color
+
+        # Create a dotted pattern within the zone
+        for y in range(min_y, max_y + 1, dot_spacing):
+            for x in range(min_x, max_x + 1, dot_spacing):
+                if Drawable.point_inside(x, y, points):
+                    # Draw a small filled circle (dot) using vectorized operations
                     y_min = max(0, y - dot_radius)
                     y_max = min(layers.shape[0], y + dot_radius + 1)
                     x_min = max(0, x - dot_radius)
                     x_max = min(layers.shape[1], x + dot_radius + 1)
 
-                    # Create coordinate arrays for the dot
-                    y_indices, x_indices = np.ogrid[y_min:y_max, x_min:x_max]
-
-                    # Create a circular mask
-                    mask = (y_indices - y) ** 2 + (x_indices - x) ** 2 <= dot_radius**2
-
-                    # Apply the color to the masked region
-                    layers[y_min:y_max, x_min:x_max][mask] = blended_color
+                    if y_min < y_max and x_min < x_max:
+                        y_indices, x_indices = np.ogrid[y_min:y_max, x_min:x_max]
+                        mask = (y_indices - y) ** 2 + (x_indices - x) ** 2 <= dot_radius**2
+                        layers[y_min:y_max, x_min:x_max][mask] = blended_color
 
         return layers
 

{valetudo_map_parser-0.1.9b60 → valetudo_map_parser-0.1.9b62}/SCR/valetudo_map_parser/config/shared.py

@@ -18,6 +18,7 @@ from .types import (
     ATTR_ROTATE,
     ATTR_SNAPSHOT,
     ATTR_VACUUM_BATTERY,
+    ATTR_VACUUM_CHARGING,
     ATTR_VACUUM_JSON_ID,
     ATTR_VACUUM_POSITION,
     ATTR_VACUUM_STATUS,
@@ -60,7 +61,7 @@ class CameraShared:
         self.last_image = None  # Last image received
         self.current_image = None  # Current image
         self.binary_image = None  # Current image in binary format
-        self.image_format = "WebP"  # Image format
+        self.image_format = "image/pil"  # Image format
         self.image_size = None  # Image size
         self.image_auto_zoom: bool = False  # Auto zoom image
         self.image_zoom_lock_ratio: bool = True  # Zoom lock ratio
@@ -112,6 +113,12 @@ class CameraShared:
         self.skip_room_ids: List[str] = []
         self.device_info = None  # Store the device_info
 
+
+
+    def _state_charging(self) -> bool:
+        """Check if the vacuum is charging."""
+        return self.vacuum_state == "charging"
+
     @staticmethod
     def _compose_obstacle_links(vacuum_host_ip: str, obstacles: list) -> list | None:
         """
@@ -186,6 +193,7 @@ class CameraShared:
         attrs = {
             ATTR_CAMERA_MODE: self.camera_mode,
             ATTR_VACUUM_BATTERY: f"{self.vacuum_battery}%",
+            ATTR_VACUUM_CHARGING: self._state_charging(),
             ATTR_VACUUM_POSITION: self.current_room,
             ATTR_VACUUM_STATUS: self.vacuum_state,
             ATTR_VACUUM_JSON_ID: self.vac_json_id,

{valetudo_map_parser-0.1.9b60 → valetudo_map_parser-0.1.9b62}/SCR/valetudo_map_parser/config/types.py

@@ -568,7 +568,8 @@ ALPHA_ROOM_15 = "alpha_room_15"
 
 """ Constants for the attribute keys """
 ATTR_FRIENDLY_NAME = "friendly_name"
-ATTR_VACUUM_BATTERY = "vacuum_battery"
+ATTR_VACUUM_BATTERY = "battery"
+ATTR_VACUUM_CHARGING = "charging"
 ATTR_VACUUM_POSITION = "vacuum_position"
 ATTR_VACUUM_TOPIC = "vacuum_topic"
 ATTR_VACUUM_STATUS = "vacuum_status"

{valetudo_map_parser-0.1.9b60 → valetudo_map_parser-0.1.9b62}/SCR/valetudo_map_parser/hypfer_draw.py

@@ -6,10 +6,11 @@ Version: 2024.07.2
 
 from __future__ import annotations
 
+import asyncio
 import logging
 
 from .config.drawable_elements import DrawableElement
-from .config.types import Color, JsonType, NumpyArray, RobotPosition
+from .config.types import Color, JsonType, NumpyArray, RobotPosition, RoomStore
 
 
 _LOGGER = logging.getLogger(__name__)
@@ -92,7 +93,7 @@ class ImageDraw:
         pixel_size,
         disabled_rooms=None,
     ):
-        """Draw the base layer of the map.
+        """Draw the base layer of the map with parallel processing for rooms.
 
         Args:
             img_np_array: The image array to draw on
@@ -108,6 +109,7 @@ class ImageDraw:
         """
         room_id = 0
 
+        # Sequential processing for rooms/segments (dependencies require this)
         for compressed_pixels in compressed_pixels_list:
             pixels = self.img_h.data.sublist(compressed_pixels, 3)
 
@@ -325,41 +327,49 @@ class ImageDraw:
         color_zone_clean: Color,
         color_no_go: Color,
     ) -> NumpyArray:
-        """Get the zone clean from the JSON data."""
+        """Get the zone clean from the JSON data with parallel processing."""
+
         try:
             zone_clean = self.img_h.data.find_zone_entities(m_json)
         except (ValueError, KeyError):
             zone_clean = None
         else:
             _LOGGER.info("%s: Got zones.", self.file_name)
+
         if zone_clean:
-            try:
-                zones_active = zone_clean.get("active_zone")
-            except KeyError:
-                zones_active = None
+            # Prepare zone drawing tasks for parallel execution
+            zone_tasks = []
+
+            # Active zones
+            zones_active = zone_clean.get("active_zone")
             if zones_active:
-                np_array = await self.img_h.draw.zones(
-                    np_array, zones_active, color_zone_clean
+                zone_tasks.append(
+                    self.img_h.draw.zones(np_array.copy(), zones_active, color_zone_clean)
                 )
-            try:
-                no_go_zones = zone_clean.get("no_go_area")
-            except KeyError:
-                no_go_zones = None
 
+            # No-go zones
+            no_go_zones = zone_clean.get("no_go_area")
             if no_go_zones:
-                np_array = await self.img_h.draw.zones(
-                    np_array, no_go_zones, color_no_go
+                zone_tasks.append(
+                    self.img_h.draw.zones(np_array.copy(), no_go_zones, color_no_go)
                 )
 
-            try:
-                no_mop_zones = zone_clean.get("no_mop_area")
-            except KeyError:
-                no_mop_zones = None
-
+            # No-mop zones
+            no_mop_zones = zone_clean.get("no_mop_area")
             if no_mop_zones:
-                np_array = await self.img_h.draw.zones(
-                    np_array, no_mop_zones, color_no_go
+                zone_tasks.append(
+                    self.img_h.draw.zones(np_array.copy(), no_mop_zones, color_no_go)
                 )
+
+            # Execute all zone drawing tasks in parallel
+            if zone_tasks:
+                zone_results = await asyncio.gather(*zone_tasks)
+                # Merge results back into the main array
+                for result in zone_results:
+                    # Simple overlay - in practice you might want more sophisticated blending
+                    mask = result != np_array
+                    np_array[mask] = result[mask]
+
         return np_array
 
     async def async_draw_virtual_walls(
@@ -429,7 +439,6 @@ class ImageDraw:
     def _check_active_zone_and_set_zooming(self) -> None:
         """Helper function to check active zones and set zooming state."""
         if self.img_h.active_zones and self.img_h.robot_in_room:
-            from .config.types import RoomStore
 
             segment_id = str(self.img_h.robot_in_room["id"])
             room_store = RoomStore(self.file_name)
@@ -606,7 +615,6 @@ class ImageDraw:
 
                     # Handle active zones - Map segment ID to active_zones position
                     if self.img_h.active_zones:
-                        from .config.types import RoomStore
 
                         segment_id = str(self.img_h.robot_in_room["id"])
                         room_store = RoomStore(self.file_name)

{valetudo_map_parser-0.1.9b60 → valetudo_map_parser-0.1.9b62}/SCR/valetudo_map_parser/hypfer_handler.py

@@ -7,13 +7,16 @@ Version: 0.1.9
 
 from __future__ import annotations
 
+import asyncio
 import json
 
 from PIL import Image
 
+from .config.async_utils import AsyncNumPy, AsyncPIL, AsyncParallel
 from .config.auto_crop import AutoCrop
 from .config.drawable_elements import DrawableElement
 from .config.shared import CameraShared
+from .config.utils import pil_to_webp_bytes
 from .config.types import (
     COLORS,
     LOGGER,
@@ -291,14 +294,34 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                 )
                 # Copy the base layer to the new image.
                 img_np_array = await self.async_copy_array(self.img_base_layer)
-                # All below will be drawn at each frame.
-                # Draw zones if any and if enabled
+
+                # Prepare parallel data extraction tasks
+                data_tasks = []
+
+                # Prepare zone data extraction
+                if self.drawing_config.is_enabled(DrawableElement.RESTRICTED_AREA):
+                    data_tasks.append(self._prepare_zone_data(m_json))
+
+                # Prepare go_to flag data extraction
+                if self.drawing_config.is_enabled(DrawableElement.GO_TO_TARGET):
+                    data_tasks.append(self._prepare_goto_data(entity_dict))
+
+                # Prepare path data extraction
+                path_enabled = self.drawing_config.is_enabled(DrawableElement.PATH)
+                LOGGER.info("%s: PATH element enabled: %s", self.file_name, path_enabled)
+                if path_enabled:
+                    LOGGER.info("%s: Drawing path", self.file_name)
+                    data_tasks.append(self._prepare_path_data(m_json))
+
+                # Execute data preparation in parallel if we have tasks
+                if data_tasks:
+                    prepared_data = await AsyncParallel.parallel_data_preparation(*data_tasks)
+
+                # Process drawing operations sequentially (since they modify the same array)
+                # Draw zones if enabled
                 if self.drawing_config.is_enabled(DrawableElement.RESTRICTED_AREA):
                     img_np_array = await self.imd.async_draw_zones(
-                        m_json,
-                        img_np_array,
-                        colors["zone_clean"],
-                        colors["no_go"],
+                        m_json, img_np_array, colors["zone_clean"], colors["no_go"]
                     )
 
                 # Draw the go_to target flag if enabled
@@ -307,13 +330,8 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                         img_np_array, entity_dict, colors["go_to"]
                     )
 
-                # Draw path prediction and paths if enabled
-                path_enabled = self.drawing_config.is_enabled(DrawableElement.PATH)
-                LOGGER.info(
-                    "%s: PATH element enabled: %s", self.file_name, path_enabled
-                )
+                # Draw paths if enabled
                 if path_enabled:
-                    LOGGER.info("%s: Drawing path", self.file_name)
                     img_np_array = await self.imd.async_draw_paths(
                         img_np_array, m_json, colors["move"], self.color_grey
                     )
@@ -371,15 +389,13 @@ 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)
 
                 # Return WebP bytes or PIL Image based on parameter
                 if return_webp:
-                    from .config.utils import pil_to_webp_bytes
-
                     webp_bytes = await pil_to_webp_bytes(resized_image)
                     return webp_bytes
                 else:
@@ -394,7 +410,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 +490,26 @@ 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)
+
+    async def _prepare_zone_data(self, m_json):
+        """Prepare zone data for parallel processing."""
+        await asyncio.sleep(0)  # Yield control
+        try:
+            return self.data.find_zone_entities(m_json)
+        except (ValueError, KeyError):
+            return None
+
+    async def _prepare_goto_data(self, entity_dict):
+        """Prepare go-to flag data for parallel processing."""
+        await asyncio.sleep(0)  # Yield control
+        # Extract go-to target data from entity_dict
+        return entity_dict.get("go_to_target", None)
+
+    async def _prepare_path_data(self, m_json):
+        """Prepare path data for parallel processing."""
+        await asyncio.sleep(0)  # Yield control
+        try:
+            return self.data.find_path_entities(m_json)
+        except (ValueError, KeyError):
+            return None

{valetudo_map_parser-0.1.9b60 → valetudo_map_parser-0.1.9b62}/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,

{valetudo_map_parser-0.1.9b60 → valetudo_map_parser-0.1.9b62}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "valetudo-map-parser"
-version = "0.1.9b60"
+version = "0.1.9b62"
 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 = "*"