valetudo-map-parser 0.1.9b67__py3-none-any.whl → 0.1.9b69__py3-none-any.whl

valetudo_map_parser/config/async_utils.py

@@ -23,7 +23,9 @@ class AsyncNumPy:
         return await make_async(np.copy, array)
 
     @staticmethod
-    async def async_full(shape: tuple, fill_value: Any, dtype: np.dtype = None) -> np.ndarray:
+    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)
 
@@ -42,20 +44,25 @@ class AsyncPIL:
         return await make_async(Image.fromarray, array, mode)
 
     @staticmethod
-    async def async_resize(image: Image.Image, size: tuple, resample: int = None) -> Image.Image:
+    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 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/config/drawable.py

@@ -14,7 +14,6 @@ import logging
 import math
 import asyncio
 import inspect
-import threading
 
 import numpy as np
 from PIL import ImageDraw, ImageFont
@@ -27,72 +26,6 @@ from .types import Color, NumpyArray, PilPNG, Point, Tuple, Union
 _LOGGER = logging.getLogger(__name__)
 
 
-class ImageArrayPool:
-    """Thread-safe memory pool for reusing image arrays to reduce allocation overhead."""
-
-    def __init__(self, max_arrays_per_size: int = 3):
-        self._pools = {}  # {(width, height): [array1, array2, ...]}
-        self._lock = threading.Lock()
-        self._max_arrays_per_size = max_arrays_per_size
-
-    def get_array(self, width: int, height: int, background_color: Color) -> NumpyArray:
-        """Get a reusable array or create a new one if none available."""
-        key = (width, height)
-
-        with self._lock:
-            if key in self._pools and self._pools[key]:
-                # Reuse existing array
-                array = self._pools[key].pop()
-                _LOGGER.debug("Reused array from pool for size %dx%d", width, height)
-            else:
-                # Create new array
-                array = np.empty((height, width, 4), dtype=np.uint8)
-                _LOGGER.debug("Created new array for size %dx%d", width, height)
-
-        # Fill with background color (outside lock for better performance)
-        array[:] = background_color
-        return array
-
-    def return_array(self, array: NumpyArray) -> None:
-        """Return an array to the pool for reuse."""
-        if array is None:
-            return
-
-        height, width = array.shape[:2]
-        key = (width, height)
-
-        with self._lock:
-            if key not in self._pools:
-                self._pools[key] = []
-
-            # Only keep up to max_arrays_per_size arrays per size
-            if len(self._pools[key]) < self._max_arrays_per_size:
-                self._pools[key].append(array)
-                _LOGGER.debug("Returned array to pool for size %dx%d (pool size: %d)",
-                             width, height, len(self._pools[key]))
-            else:
-                _LOGGER.debug("Pool full for size %dx%d, discarding array", width, height)
-
-    def clear_pool(self) -> None:
-        """Clear all arrays from the pool."""
-        with self._lock:
-            total_arrays = sum(len(arrays) for arrays in self._pools.values())
-            self._pools.clear()
-            _LOGGER.debug("Cleared image array pool (%d arrays freed)", total_arrays)
-
-    def get_pool_stats(self) -> dict:
-        """Get statistics about the current pool state."""
-        with self._lock:
-            stats = {}
-            for (width, height), arrays in self._pools.items():
-                stats[f"{width}x{height}"] = len(arrays)
-            return stats
-
-
-# Global shared pool instance for both Hypfer and Rand256 handlers
-_image_pool = ImageArrayPool()
-
-
 class Drawable:
     """
     Collection of drawing utility functions for the image handlers.
@@ -112,27 +45,13 @@ class Drawable:
     async def create_empty_image(
         width: int, height: int, background_color: Color
     ) -> NumpyArray:
-        """Create the empty background image NumPy array using memory pool for better performance.
+        """Create the empty background image NumPy array.
         Background color is specified as an RGBA tuple.
-        Optimized: Uses shared memory pool to reuse arrays and reduce allocation overhead."""
-        # Get array from shared pool (reuses memory when possible)
-        return _image_pool.get_array(width, height, background_color)
-
-    @staticmethod
-    def return_image_to_pool(image_array: NumpyArray) -> None:
-        """Return an image array to the memory pool for reuse.
-        Call this when you're done with an image array to enable memory reuse."""
-        _image_pool.return_array(image_array)
-
-    @staticmethod
-    def get_pool_stats() -> dict:
-        """Get statistics about the current memory pool state."""
-        return _image_pool.get_pool_stats()
-
-    @staticmethod
-    def clear_image_pool() -> None:
-        """Clear all arrays from the memory pool."""
-        _image_pool.clear_pool()
+        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(
@@ -392,6 +311,79 @@ class Drawable:
 
         return layer
 
+    @staticmethod
+    def draw_lines_batch(
+        layer: NumpyArray,
+        line_segments: list,
+        color: Color,
+        width: int = 3,
+    ) -> NumpyArray:
+        """
+        Draw multiple line segments with batch processing for better performance.
+
+        Args:
+            layer: The numpy array to draw on
+            line_segments: List of tuples [(x1, y1, x2, y2), ...]
+            color: Color to draw with
+            width: Width of the lines
+        """
+        if not line_segments:
+            return layer
+
+        # Pre-calculate blended color once for the entire batch
+        # Use the first line segment for color sampling
+        x1, y1, x2, y2 = line_segments[0]
+        blended_color = get_blended_color(x1, y1, x2, y2, layer, color)
+
+        # Fast path for fully opaque colors - skip individual blending
+        if color[3] == 255:
+            blended_color = color
+
+        # Process all line segments with the same blended color
+        for x1, y1, x2, y2 in line_segments:
+            # Ensure coordinates are integers
+            x1, y1, x2, y2 = int(x1), int(y1), int(x2), int(y2)
+
+            # Calculate line length
+            length = max(abs(x2 - x1), abs(y2 - y1))
+            if length == 0:  # Handle case of a single point
+                # Draw a dot with the specified width
+                for i in range(-width // 2, (width + 1) // 2):
+                    for j in range(-width // 2, (width + 1) // 2):
+                        if (
+                            0 <= x1 + i < layer.shape[1]
+                            and 0 <= y1 + j < layer.shape[0]
+                        ):
+                            layer[y1 + j, x1 + i] = blended_color
+                continue
+
+            # Create parametric points along the line
+            t = np.linspace(0, 1, length + 1)  # Reduced from length * 2 to length + 1
+            x_coords = np.round(x1 * (1 - t) + x2 * t).astype(int)
+            y_coords = np.round(y1 * (1 - t) + y2 * t).astype(int)
+
+            # Draw the line with the specified width
+            if width == 1:
+                # Fast path for width=1
+                for x, y in zip(x_coords, y_coords):
+                    if 0 <= x < layer.shape[1] and 0 <= y < layer.shape[0]:
+                        layer[y, x] = blended_color
+            else:
+                # For thicker lines, draw a rectangle at each point
+                half_width = width // 2
+                for x, y in zip(x_coords, y_coords):
+                    for i in range(-half_width, half_width + 1):
+                        for j in range(-half_width, half_width + 1):
+                            if (
+                                i * i + j * j
+                                <= half_width * half_width  # Make it round
+                                and 0 <= x + i < layer.shape[1]
+                                and 0 <= y + j < layer.shape[0]
+                            ):
+                                layer[y + j, x + i] = blended_color
+
+        return layer
+
     @staticmethod
     async def draw_virtual_walls(
         layer: NumpyArray, virtual_walls, color: Color
@@ -410,14 +402,16 @@ class Drawable:
     async def lines(arr: NumpyArray, coords, width: int, color: Color) -> NumpyArray:
         """
         Join the coordinates creating a continuous line (path).
-        Optimized with vectorized operations for better performance.
+        Optimized with batch processing for better performance.
         """
 
         # 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):
+        # Collect all line segments for batch processing
+        line_segments = []
+        for coord in coords:
             x0, y0 = coord[0]
             try:
                 x1, y1 = coord[1]
@@ -428,15 +422,16 @@ class Drawable:
             if x0 == x1 and y0 == y1:
                 continue
 
-            # Get blended color for this line segment
-            blended_color = get_blended_color(x0, y0, x1, y1, arr, color)
+            line_segments.append((x0, y0, x1, y1))
 
-            # Use the optimized line drawing method
-            arr = Drawable._line(arr, x0, y0, x1, y1, blended_color, width)
+        # Process all line segments in batches
+        batch_size = 100  # Process 100 lines at a time
+        for i in range(0, len(line_segments), batch_size):
+            batch = line_segments[i : i + batch_size]
+            arr = Drawable.draw_lines_batch(arr, batch, color, width)
 
-            # Yield control every 100 operations to prevent blocking
-            if i % 100 == 0:
-                await asyncio.sleep(0)
+            # Yield control between batches to prevent blocking
+            await asyncio.sleep(0)
 
         return arr
 
@@ -594,7 +589,11 @@ class Drawable:
             # 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))
+                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)
@@ -648,7 +647,9 @@ class Drawable:
                         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
+                        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
@@ -656,7 +657,9 @@ class Drawable:
         return layers
 
     @staticmethod
-    async def _process_single_zone(layers: NumpyArray, zone, color: Color, dot_radius: int, dot_spacing: int) -> NumpyArray:
+    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
 
@@ -694,7 +697,9 @@ class Drawable:
 
                     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
+                        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/config/shared.py

@@ -1,12 +1,13 @@
 """
 Class Camera Shared.
 Keep the data between the modules.
-Version: v2024.12.0
+Version: v0.1.9
 """
 
 import asyncio
 import logging
 from typing import List
+from PIL import Image
 
 from .types import (
     ATTR_CALIBRATION_POINTS,
@@ -39,6 +40,7 @@ from .types import (
     CameraModes,
     Colors,
     TrimsData,
+    PilPNG,
 )
 
 
@@ -58,9 +60,13 @@ class CameraShared:
         self.rand256_active_zone: list = []  # Active zone for rand256
         self.is_rand: bool = False  # MQTT rand data
         self._new_mqtt_message = False  # New MQTT message
-        self.last_image = None  # Last image received
-        self.current_image = None  # Current image
-        self.binary_image = None  # Current image in binary format
+        # Initialize last_image with default gray image (250x150 minimum)
+        self.last_image = Image.new(
+            "RGBA", (250, 150), (128, 128, 128, 255)
+        )  # Gray default image
+        self.new_image: PilPNG | None = None  # New image received
+        self.binary_image: bytes | None = None  # Current image in binary format
+        self.image_last_updated: float = 0.0  # Last image update time
         self.image_format = "image/pil"  # Image format
         self.image_size = None  # Image size
         self.image_auto_zoom: bool = False  # Auto zoom image
@@ -113,9 +119,7 @@ class CameraShared:
         self.skip_room_ids: List[str] = []
         self.device_info = None  # Store the device_info
 
-
-
-    def _state_charging(self) -> bool:
+    def vacuum_bat_charged(self) -> bool:
         """Check if the vacuum is charging."""
         return (self.vacuum_state == "docked") and (int(self.vacuum_battery) < 100)
 
@@ -193,7 +197,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_CHARGING: self.vacuum_bat_charged,
             ATTR_VACUUM_POSITION: self.current_room,
             ATTR_VACUUM_STATUS: self.vacuum_state,
             ATTR_VACUUM_JSON_ID: self.vac_json_id,
@@ -228,12 +232,13 @@ class CameraShared:
 class CameraSharedManager:
     """Camera Shared Manager class."""
 
-    def __init__(self, file_name, device_info):
+    def __init__(self, file_name: str, device_info: dict = None):
         self._instances = {}
         self._lock = asyncio.Lock()
         self.file_name = file_name
-        self.device_info = device_info
-        self.update_shared_data(device_info)
+        if device_info:
+            self.device_info = device_info
+            self.update_shared_data(device_info)
 
         # Automatically initialize shared data for the instance
         # self._init_shared_data(device_info)

valetudo_map_parser/config/utils.py

@@ -1,5 +1,6 @@
 """Utility code for the valetudo map parser."""
 
+import datetime
 import hashlib
 import json
 from dataclasses import dataclass
@@ -10,7 +11,7 @@ import numpy as np
 from PIL import Image, ImageOps
 
 from .drawable import Drawable
-from .drawable_elements import DrawableElement, DrawingConfig
+from .drawable_elements import DrawingConfig
 from .enhanced_drawable import EnhancedDrawable
 from .types import (
     LOGGER,
@@ -79,6 +80,107 @@ class BaseHandler:
         """Return the robot position."""
         return self.robot_pos
 
+    async def async_get_image(
+        self,
+        m_json: dict | None,
+        destinations: list | None = None,
+        bytes_format: bool = False,
+    ) -> PilPNG | None:
+        """
+        Unified async function to get PIL image from JSON data for both Hypfer and Rand256 handlers.
+
+        This function:
+        1. Calls the appropriate async_get_image_from_json method
+        2. Stores the processed data in shared.new_image
+        3. Backs up previous data to shared.last_image
+        4. Updates shared.image_last_updated with current datetime
+
+        @param m_json: The JSON data to use to draw the image
+        @param destinations: MQTT destinations for labels (used by Rand256)
+        @param bytes_format: If True, also convert to PNG bytes and store in shared.binary_image
+        @return: PIL Image or None
+        """
+        try:
+            # Backup current image to last_image before processing new one
+            if hasattr(self.shared, "new_image") and self.shared.new_image is not None:
+                self.shared.last_image = self.shared.new_image
+
+            # Call the appropriate handler method based on handler type
+            if hasattr(self, "get_image_from_rrm"):
+                # This is a Rand256 handler
+                new_image = await self.get_image_from_rrm(
+                    m_json=m_json,
+                    destinations=destinations,
+                    return_webp=False,  # Always return PIL Image
+                )
+            elif hasattr(self, "async_get_image_from_json"):
+                # This is a Hypfer handler
+                new_image = await self.async_get_image_from_json(
+                    m_json=m_json,
+                    return_webp=False,  # Always return PIL Image
+                )
+            else:
+                LOGGER.warning(
+                    "%s: Handler type not recognized for async_get_image",
+                    self.file_name,
+                )
+                return (
+                    self.shared.last_image
+                    if hasattr(self.shared, "last_image")
+                    else None
+                )
+
+            # Store the new image in shared data
+            if new_image is not None:
+                self.shared.new_image = new_image
+
+                # Convert to binary (PNG bytes) if requested
+                if bytes_format:
+                    try:
+                        png_buffer = io.BytesIO()
+                        new_image.save(png_buffer, format="PNG")
+                        self.shared.binary_image = png_buffer.getvalue()
+                        png_buffer.close()
+                        LOGGER.debug(
+                            "%s: Binary image conversion completed", self.file_name
+                        )
+                    except Exception as e:
+                        LOGGER.warning(
+                            "%s: Failed to convert image to binary: %s",
+                            self.file_name,
+                            str(e),
+                        )
+                        self.shared.binary_image = None
+                else:
+                    self.shared.binary_image = None
+
+                # Update the timestamp with current datetime
+                self.shared.image_last_updated = datetime.datetime.now().timestamp()
+                LOGGER.debug(
+                    "%s: Image processed and stored in shared data", self.file_name
+                )
+                return new_image
+            else:
+                LOGGER.warning(
+                    "%s: Failed to generate image from JSON data", self.file_name
+                )
+                return (
+                    self.shared.last_image
+                    if hasattr(self.shared, "last_image")
+                    else None
+                )
+
+        except Exception as e:
+            LOGGER.error(
+                "%s: Error in async_get_image: %s",
+                self.file_name,
+                str(e),
+                exc_info=True,
+            )
+            return (
+                self.shared.last_image if hasattr(self.shared, "last_image") else None
+            )
+
     def get_charger_position(self) -> ChargerPosition | None:
         """Return the charger position."""
         return self.charger_pos

valetudo_map_parser/hypfer_draw.py

@@ -337,39 +337,30 @@ class ImageDraw:
             _LOGGER.info("%s: Got zones.", self.file_name)
 
         if zone_clean:
-            # Prepare zone drawing tasks for parallel execution
-            zone_tasks = []
+            # Process zones sequentially to avoid memory-intensive array copies
+            # This is more memory-efficient than parallel processing with copies
 
             # Active zones
             zones_active = zone_clean.get("active_zone")
             if zones_active:
-                zone_tasks.append(
-                    self.img_h.draw.zones(np_array.copy(), zones_active, color_zone_clean)
+                np_array = await self.img_h.draw.zones(
+                    np_array, zones_active, color_zone_clean
                 )
 
             # No-go zones
             no_go_zones = zone_clean.get("no_go_area")
             if no_go_zones:
-                zone_tasks.append(
-                    self.img_h.draw.zones(np_array.copy(), no_go_zones, color_no_go)
+                np_array = await self.img_h.draw.zones(
+                    np_array, no_go_zones, color_no_go
                 )
 
             # No-mop zones
             no_mop_zones = zone_clean.get("no_mop_area")
             if no_mop_zones:
-                zone_tasks.append(
-                    self.img_h.draw.zones(np_array.copy(), no_mop_zones, color_no_go)
+                np_array = await self.img_h.draw.zones(
+                    np_array, 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(
@@ -439,7 +430,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:
-
             segment_id = str(self.img_h.robot_in_room["id"])
             room_store = RoomStore(self.file_name)
             room_keys = list(room_store.get_rooms().keys())
@@ -615,7 +605,6 @@ class ImageDraw:
 
                     # Handle active zones - Map segment ID to active_zones position
                     if self.img_h.active_zones:
-
                         segment_id = str(self.img_h.robot_in_room["id"])
                         room_store = RoomStore(self.file_name)
                         room_keys = list(room_store.get_rooms().keys())

valetudo_map_parser/hypfer_handler.py

@@ -8,11 +8,10 @@ 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.async_utils import AsyncNumPy, AsyncPIL
 from .config.auto_crop import AutoCrop
 from .config.drawable_elements import DrawableElement
 from .config.shared import CameraShared
@@ -25,6 +24,7 @@ from .config.types import (
     RoomsProperties,
     RoomStore,
     WebPBytes,
+    JsonType,
 )
 from .config.utils import (
     BaseHandler,
@@ -100,7 +100,7 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
     # noinspection PyUnresolvedReferences,PyUnboundLocalVariable
     async def async_get_image_from_json(
         self,
-        m_json: json | None,
+        m_json: JsonType | None,
         return_webp: bool = False,
     ) -> WebPBytes | Image.Image | None:
         """Get the image from the JSON data.
@@ -232,13 +232,6 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                                 disabled_rooms if layer_type == "wall" else None,
                             )
 
-                            # Update element map for this layer
-                            if is_room_layer and 0 < room_id <= 15:
-                                # Mark the room in the element map
-                                room_element = getattr(
-                                    DrawableElement, f"ROOM_{room_id}", None
-                                )
-
                     # Draw the virtual walls if enabled
                     if self.drawing_config.is_enabled(DrawableElement.VIRTUAL_WALL):
                         img_np_array = await self.imd.async_draw_virtual_walls(
@@ -308,14 +301,16 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
 
                 # 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)
+                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
+                # Await all data preparation tasks if any were created
                 if data_tasks:
-                    prepared_data = await AsyncParallel.parallel_data_preparation(*data_tasks)
+                    await asyncio.gather(*data_tasks)
 
                 # Process drawing operations sequentially (since they modify the same array)
                 # Draw zones if enabled
@@ -390,9 +385,7 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
             if self.check_zoom_and_aspect_ratio():
                 # Convert to PIL for resizing
                 pil_img = await AsyncPIL.async_fromarray(img_np_array, mode="RGBA")
-                # Return array to pool for reuse instead of just deleting
-                from .config.drawable import Drawable
-                Drawable.return_image_to_pool(img_np_array)
+                del img_np_array
                 resize_params = prepare_resize_params(self, pil_img, False)
                 resized_image = await self.async_resize_images(resize_params)
 
@@ -407,17 +400,13 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                 if return_webp:
                     # Convert directly from NumPy to WebP for better performance
                     webp_bytes = await numpy_to_webp_bytes(img_np_array)
-                    # Return array to pool for reuse instead of just deleting
-                    from .config.drawable import Drawable
-                    Drawable.return_image_to_pool(img_np_array)
+                    del img_np_array
                     LOGGER.debug("%s: Frame Completed.", self.file_name)
                     return webp_bytes
                 else:
                     # Convert to PIL Image (original behavior)
                     pil_img = await AsyncPIL.async_fromarray(img_np_array, mode="RGBA")
-                    # Return array to pool for reuse instead of just deleting
-                    from .config.drawable import Drawable
-                    Drawable.return_image_to_pool(img_np_array)
+                    del img_np_array
                     LOGGER.debug("%s: Frame Completed.", self.file_name)
                     return pil_img
         except (RuntimeError, RuntimeWarning) as e:
@@ -506,7 +495,8 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
         except (ValueError, KeyError):
             return None
 
-    async def _prepare_goto_data(self, entity_dict):
+    @staticmethod
+    async def _prepare_goto_data(entity_dict):
         """Prepare go-to flag data for parallel processing."""
         await asyncio.sleep(0)  # Yield control
         # Extract go-to target data from entity_dict
@@ -516,6 +506,6 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
         """Prepare path data for parallel processing."""
         await asyncio.sleep(0)  # Yield control
         try:
-            return self.data.find_path_entities(m_json)
+            return self.data.find_paths_entities(m_json)
         except (ValueError, KeyError):
             return None

valetudo_map_parser/map_data.py

@@ -19,14 +19,14 @@ class ImageData:
     @staticmethod
     def sublist(lst, n):
         """Split a list into n chunks of specified size."""
-        return [lst[i: i + n] for i in range(0, len(lst), n)]
+        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."""
         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
 
     @staticmethod
@@ -39,15 +39,19 @@ class ImageData:
             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,
-                })
+                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]:
+    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
@@ -56,7 +60,9 @@ class ImageData:
                 layer_type = json_obj.get("type")
                 active_type = json_obj.get("metaData")
                 if layer_type:
-                    layer_dict.setdefault(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.get("active", 0)))
             for value in json_obj.values():
@@ -121,7 +127,10 @@ class ImageData:
 
         def _recursive(obj):
             if isinstance(obj, dict):
-                if obj.get("__class") == "LineMapEntity" and obj.get("type") == "virtual_wall":
+                if (
+                    obj.get("__class") == "LineMapEntity"
+                    and obj.get("type") == "virtual_wall"
+                ):
                     walls.append(obj["points"])
                 for value in obj.values():
                     _recursive(value)
@@ -133,7 +142,9 @@ class ImageData:
         return walls
 
     @staticmethod
-    async def async_get_rooms_coordinates(pixels: list, pixel_size: int = 5, rand: bool = False) -> tuple:
+    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:

valetudo_map_parser/rand256_handler.py

@@ -7,15 +7,13 @@ Version: 0.1.9.a6
 
 from __future__ import annotations
 
-import asyncio
 import logging
 import uuid
 from typing import Any
 
 import numpy as np
-from PIL import Image
 
-from .config.async_utils import AsyncNumPy, AsyncPIL, AsyncParallel
+from .config.async_utils import AsyncNumPy, AsyncPIL
 from .config.auto_crop import AutoCrop
 from .config.drawable_elements import DrawableElement
 from .config.types import (
@@ -147,7 +145,7 @@ class ReImageHandler(BaseHandler, AutoCrop):
         m_json: JsonType,  # json data
         destinations: None = None,  # MQTT destinations for labels
         return_webp: bool = False,
-    ) -> WebPBytes | Image.Image | None:
+    ) -> WebPBytes | PilPNG | None:
         """Generate Images from the json data.
         @param m_json: The JSON data to use to draw the image.
         @param destinations: MQTT destinations for labels (unused).
@@ -168,14 +166,6 @@ class ReImageHandler(BaseHandler, AutoCrop):
                 self.json_id = str(uuid.uuid4())  # image id
                 _LOGGER.info("Vacuum Data ID: %s", self.json_id)
 
-                # Prepare parallel data extraction tasks
-                data_tasks = []
-                data_tasks.append(self._prepare_zone_data(m_json))
-                data_tasks.append(self._prepare_path_data(m_json))
-
-                # Execute data preparation tasks in parallel
-                zone_data, path_data = await asyncio.gather(*data_tasks, return_exceptions=True)
-
                 (
                     img_np_array,
                     robot_position,
@@ -202,16 +192,12 @@ class ReImageHandler(BaseHandler, AutoCrop):
                 if return_webp:
                     # Convert directly to WebP bytes for better performance
                     webp_bytes = await numpy_to_webp_bytes(img_np_array)
-                    # Return array to pool for reuse instead of just deleting
-                    from .config.drawable import Drawable
-                    Drawable.return_image_to_pool(img_np_array)
+                    del img_np_array  # free memory
                     return webp_bytes
                 else:
                     # Convert to PIL Image using async utilities
                     pil_img = await AsyncPIL.async_fromarray(img_np_array, mode="RGBA")
-                    # Return array to pool for reuse instead of just deleting
-                    from .config.drawable import Drawable
-                    Drawable.return_image_to_pool(img_np_array)
+                    del img_np_array  # free memory
                     return await self._finalize_image(pil_img)
 
         except (RuntimeError, RuntimeWarning) as e:
@@ -311,11 +297,6 @@ class ReImageHandler(BaseHandler, AutoCrop):
                     original_rooms_pos = self.rooms_pos
                     self.rooms_pos = temp_rooms_pos
 
-                    # Perform robot room detection to check active zones
-                    robot_room_result = await self.async_get_robot_in_room(
-                        robot_position[0], robot_position[1], robot_position_angle
-                    )
-
                     # Restore original rooms_pos
                     self.rooms_pos = original_rooms_pos
 
@@ -691,21 +672,3 @@ class ReImageHandler(BaseHandler, AutoCrop):
     async def async_copy_array(self, original_array):
         """Copy the array using async utilities."""
         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_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.9b67.dist-info → valetudo_map_parser-0.1.9b69.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: valetudo-map-parser
-Version: 0.1.9b67
+Version: 0.1.9b69
 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.9b67.dist-info → valetudo_map_parser-0.1.9b69.dist-info}/RECORD

@@ -1,27 +1,27 @@
 valetudo_map_parser/__init__.py,sha256=XO_eJwFDyU7hXJ4tAa2zY-n-SM2_kmIGMWDKY3GcauY,1163
 valetudo_map_parser/config/__init__.py,sha256=DQ9plV3ZF_K25Dp5ZQHPDoG-40dQoJNdNi-dfNeR3Zc,48
-valetudo_map_parser/config/async_utils.py,sha256=r96x4rVis2y57KSnWfVxraSGi0cOz0fsOg-njRIggfs,3169
+valetudo_map_parser/config/async_utils.py,sha256=e1j9uTtg4dhPVWvB2_XgqaH4aeSjRAPz-puRMbGoOs8,3204
 valetudo_map_parser/config/auto_crop.py,sha256=Aes7vfv4z8ihYvGaH5Nryj6Y9mHDerZLIeyvePjf9aQ,19259
 valetudo_map_parser/config/color_utils.py,sha256=nXD6WeNmdFdoMxPDW-JFpjnxJSaZR1jX-ouNfrx6zvE,4502
 valetudo_map_parser/config/colors.py,sha256=DG-oPQoN5gsnwDbEsuFr8a0hRCxmbFHObWa4_5pr-70,29910
-valetudo_map_parser/config/drawable.py,sha256=d9hdEjmlXnbnEKgy2RiKVGiUlU8pbWF14MfNlVpDgcw,40947
+valetudo_map_parser/config/drawable.py,sha256=nAOoPQmNz6LJ4-WN7WF5iHTYEAzT43YVnTpiqzjNva0,41180
 valetudo_map_parser/config/drawable_elements.py,sha256=o-5oiXmfqPwNQLzKIhkEcZD_A47rIU9E0CqKgWipxgc,11516
 valetudo_map_parser/config/enhanced_drawable.py,sha256=QlGxlUMVgECUXPtFwIslyjubWxQuhIixsRymWV3lEvk,12586
 valetudo_map_parser/config/optimized_element_map.py,sha256=52BCnkvVv9bre52LeVIfT8nhnEIpc0TuWTv1xcNu0Rk,15744
 valetudo_map_parser/config/rand256_parser.py,sha256=LU3y7XvRRQxVen9iwom0dOaDnJJvhZdg97NqOYRZFas,16279
-valetudo_map_parser/config/shared.py,sha256=J_66BuhgqRJUjXKBwKh8qih1iyiTq9ZiaZwduIROYmE,12560
+valetudo_map_parser/config/shared.py,sha256=98CgGDY0tbc5BSg2TIHbGcDFZZ2acgIYnoPjAwENmBU,12885
 valetudo_map_parser/config/types.py,sha256=saL7pULKAdTRQ_ShR2arT8IV472e9MBC_SohTthlGp8,17567
-valetudo_map_parser/config/utils.py,sha256=fnzzNywE0Z1qw968hUa_yGslq3YhOP7daFj21miuhjI,31354
-valetudo_map_parser/hypfer_draw.py,sha256=ZK_WybvukHd8nNk2mq5icrOu1Ue3SVCIC6_Hc9bTg0Q,29396
-valetudo_map_parser/hypfer_handler.py,sha256=X-okVYDeHRWfwx08XIvqimoI-mghqekTe3GlyzV62gA,24214
+valetudo_map_parser/config/utils.py,sha256=lRLvQbqCQ44knnIJr-UAlkEOO1d14mFCmHKDor989VE,35468
+valetudo_map_parser/hypfer_draw.py,sha256=vlrfBSDpHNnjh0dRA1BE5_4MsKMMWS_O1QErrd-VRKE,28995
+valetudo_map_parser/hypfer_handler.py,sha256=U452BEi3kmU0O27aNN7BY42J_zrpjhDuebpqxwGxe50,23366
 valetudo_map_parser/hypfer_rooms_handler.py,sha256=NkpOA6Gdq-2D3lLAxvtNuuWMvPXHxeMY2TO5RZLSHlU,22652
-valetudo_map_parser/map_data.py,sha256=Op0LTCakcTJ1Q0rxQhl6BpgSby_6nJenCQS2Y2FHtRk,17243
+valetudo_map_parser/map_data.py,sha256=Flq5t9QQQiD5ylObIniHhPP1VB7VhNoMcMeJrOey3Go,17433
 valetudo_map_parser/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-valetudo_map_parser/rand256_handler.py,sha256=vrfoX7RM8NFhpbzrc2BSLEA8VGx4B_sXBG_uAZSO8W0,29216
+valetudo_map_parser/rand256_handler.py,sha256=daaSQ5ktMUYMnYxJkjS75UdBchpXVZ58HIomwHBFivs,27651
 valetudo_map_parser/reimg_draw.py,sha256=1q8LkNTPHEA9Tsapc_JnVw51kpPYNhaBU-KmHkefCQY,12507
 valetudo_map_parser/rooms_handler.py,sha256=ovqQtAjauAqwUNPR0aX27P2zhheQmqfaFhDE3_AwYWk,17821
-valetudo_map_parser-0.1.9b67.dist-info/LICENSE,sha256=Lh-qBbuRV0-jiCIBhfV7NgdwFxQFOXH3BKOzK865hRs,10480
-valetudo_map_parser-0.1.9b67.dist-info/METADATA,sha256=0ItPS5MJeqacL3gkVvxoL9T9jvRJi5o9rFmNwByD7cA,3353
-valetudo_map_parser-0.1.9b67.dist-info/NOTICE.txt,sha256=5lTOuWiU9aiEnJ2go8sc7lTJ7ntMBx0g0GFnNrswCY4,2533
-valetudo_map_parser-0.1.9b67.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-valetudo_map_parser-0.1.9b67.dist-info/RECORD,,
+valetudo_map_parser-0.1.9b69.dist-info/LICENSE,sha256=Lh-qBbuRV0-jiCIBhfV7NgdwFxQFOXH3BKOzK865hRs,10480
+valetudo_map_parser-0.1.9b69.dist-info/METADATA,sha256=Ex2vOq_SjHDzJqk5dNNL78hXqOnkhz9Y7anOUC-XsmE,3353
+valetudo_map_parser-0.1.9b69.dist-info/NOTICE.txt,sha256=5lTOuWiU9aiEnJ2go8sc7lTJ7ntMBx0g0GFnNrswCY4,2533
+valetudo_map_parser-0.1.9b69.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+valetudo_map_parser-0.1.9b69.dist-info/RECORD,,