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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: valetudo-map-parser
-Version: 0.1.9b61
+Version: 0.1.9b63
 Summary: A Python library to parse Valetudo map data returning a PIL Image object.
 License: Apache-2.0
 Author: Sandro Cantarella

{valetudo_map_parser-0.1.9b61 → valetudo_map_parser-0.1.9b63}/SCR/valetudo_map_parser/config/async_utils.py

@@ -5,11 +5,13 @@ 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
@@ -28,6 +30,11 @@ class AsyncNumPy:
         """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."""
@@ -53,3 +60,30 @@ class AsyncPIL:
             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.9b61 → valetudo_map_parser-0.1.9b63}/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.9b61 → valetudo_map_parser-0.1.9b63}/SCR/valetudo_map_parser/config/drawable.py

@@ -12,11 +12,12 @@ from __future__ import annotations
 
 import logging
 import math
+import asyncio
+import inspect
 
 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,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 await AsyncNumPy.async_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(
@@ -153,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
@@ -324,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]
@@ -341,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
@@ -485,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.9b61 → valetudo_map_parser-0.1.9b63}/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 == "docked") and (self.vacuum_battery < 100)
+
     @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.9b61 → valetudo_map_parser-0.1.9b63}/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.9b61 → valetudo_map_parser-0.1.9b63}/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.9b61 → valetudo_map_parser-0.1.9b63}/SCR/valetudo_map_parser/hypfer_handler.py

@@ -7,14 +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
+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,
@@ -292,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
@@ -308,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
                     )
@@ -379,8 +396,6 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
 
                 # 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:
@@ -476,3 +491,25 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
     async def async_copy_array(original_array):
         """Copy the array."""
         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.9b61 → valetudo_map_parser-0.1.9b63}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "valetudo-map-parser"
-version = "0.1.9b61"
+version = "0.1.9b63"
 description = "A Python library to parse Valetudo map data returning a PIL Image object."
 authors = ["Sandro Cantarella <gsca075@gmail.com>"]
 license = "Apache-2.0"