valetudo-map-parser 0.1.9b55__tar.gz → 0.1.9b57__tar.gz

{valetudo_map_parser-0.1.9b55 → valetudo_map_parser-0.1.9b57}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: valetudo-map-parser
-Version: 0.1.9b55
+Version: 0.1.9b57
 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.9b55 → valetudo_map_parser-0.1.9b57}/SCR/valetudo_map_parser/__init__.py

@@ -5,7 +5,8 @@ from .config.colors import ColorsManagement
 from .config.drawable import Drawable
 from .config.drawable_elements import DrawableElement, DrawingConfig
 from .config.enhanced_drawable import EnhancedDrawable
-from .config.rand25_parser import RRMapParser
+from .config.utils import webp_bytes_to_pil
+from .config.rand256_parser import RRMapParser
 from .config.shared import CameraShared, CameraSharedManager
 from .config.types import (
     CameraModes,
@@ -14,9 +15,10 @@ from .config.types import (
     SnapshotStore,
     TrimCropData,
     UserLanguageStore,
+    WebPBytes,
 )
 from .hypfer_handler import HypferMapImageHandler
-from .rand25_handler import ReImageHandler
+from .rand256_handler import ReImageHandler
 from .rooms_handler import RoomsHandler, RandRoomsHandler
 
 
@@ -39,4 +41,6 @@ __all__ = [
     "RoomsProperties",
     "TrimCropData",
     "CameraModes",
+    "WebPBytes",
+    "webp_bytes_to_pil",
 ]

{valetudo_map_parser-0.1.9b55 → valetudo_map_parser-0.1.9b57}/SCR/valetudo_map_parser/config/auto_crop.py

@@ -7,6 +7,7 @@ import logging
 
 import numpy as np
 from numpy import rot90
+from scipy import ndimage
 
 from .types import Color, NumpyArray, TrimCropData, TrimsData
 from .utils import BaseHandler
@@ -89,7 +90,7 @@ class AutoCrop:
 
     async def _async_auto_crop_data(self, tdata: TrimsData):  # , tdata=None
         """Load the auto crop data from the Camera config."""
-        _LOGGER.debug("Auto Crop data: %s, %s", str(tdata), str(self.auto_crop))
+        _LOGGER.debug("Auto Crop init data: %s, %s", str(tdata), str(self.auto_crop))
         if not self.auto_crop:
             trims_data = TrimCropData.from_dict(dict(tdata.to_dict())).to_list()
             (
@@ -139,7 +140,6 @@ class AutoCrop:
     ) -> tuple[int, int, int, int]:
         """Crop the image based on the auto crop area using scipy.ndimage for better performance."""
         # Import scipy.ndimage here to avoid import at module level
-        from scipy import ndimage
 
         # Create a binary mask where True = non-background pixels
         # This is much more memory efficient than storing coordinates
@@ -173,6 +173,87 @@ class AutoCrop:
         )
         return min_y, min_x, max_x, max_y
 
+    async def async_get_room_bounding_box(
+        self, room_name: str, rand256: bool = False
+    ) -> tuple[int, int, int, int] | None:
+        """Calculate bounding box coordinates from room outline for zoom functionality.
+
+        Args:
+            room_name: Name of the room to get bounding box for
+            rand256: Whether this is for a rand256 vacuum (applies /10 scaling)
+
+        Returns:
+            Tuple of (left, right, up, down) coordinates or None if room not found
+        """
+        try:
+            # For Hypfer vacuums, check room_propriety first, then rooms_pos
+            if hasattr(self.handler, "room_propriety") and self.handler.room_propriety:
+                # Handle different room_propriety formats
+                room_data_dict = None
+
+                if isinstance(self.handler.room_propriety, dict):
+                    # Hypfer handler: room_propriety is a dictionary
+                    room_data_dict = self.handler.room_propriety
+                elif (
+                    isinstance(self.handler.room_propriety, tuple)
+                    and len(self.handler.room_propriety) >= 1
+                ):
+                    # Rand256 handler: room_propriety is a tuple (room_properties, zone_properties, point_properties)
+                    room_data_dict = self.handler.room_propriety[0]
+
+                if room_data_dict and isinstance(room_data_dict, dict):
+                    for room_id, room_data in room_data_dict.items():
+                        if room_data.get("name") == room_name:
+                            outline = room_data.get("outline", [])
+                            if outline:
+                                xs, ys = zip(*outline)
+                                left, right = min(xs), max(xs)
+                                up, down = min(ys), max(ys)
+
+                                if rand256:
+                                    # Apply scaling for rand256 vacuums
+                                    left = round(left / 10)
+                                    right = round(right / 10)
+                                    up = round(up / 10)
+                                    down = round(down / 10)
+
+                                return left, right, up, down
+
+            # Fallback: check rooms_pos (used by both Hypfer and Rand256)
+            if hasattr(self.handler, "rooms_pos") and self.handler.rooms_pos:
+                for room in self.handler.rooms_pos:
+                    if room.get("name") == room_name:
+                        outline = room.get("outline", [])
+                        if outline:
+                            xs, ys = zip(*outline)
+                            left, right = min(xs), max(xs)
+                            up, down = min(ys), max(ys)
+
+                            if rand256:
+                                # Apply scaling for rand256 vacuums
+                                left = round(left / 10)
+                                right = round(right / 10)
+                                up = round(up / 10)
+                                down = round(down / 10)
+
+                            return left, right, up, down
+
+            _LOGGER.warning(
+                "%s: Room '%s' not found for zoom bounding box calculation",
+                self.handler.file_name,
+                room_name,
+            )
+            return None
+
+        except Exception as e:
+            _LOGGER.error(
+                "%s: Error calculating room bounding box for '%s': %s",
+                self.handler.file_name,
+                room_name,
+                e,
+            )
+            return None
+
     async def async_check_if_zoom_is_on(
         self,
         image_array: NumpyArray,
@@ -187,27 +268,76 @@ class AutoCrop:
             and self.handler.shared.vacuum_state == "cleaning"
             and self.handler.shared.image_auto_zoom
         ):
-            _LOGGER.debug(
-                "%s: Zooming the image on room %s.",
-                self.handler.file_name,
-                self.handler.robot_in_room["room"],
+            # Get the current room name from robot_pos (not robot_in_room)
+            current_room = (
+                self.handler.robot_pos.get("in_room")
+                if self.handler.robot_pos
+                else None
             )
+            _LOGGER.info(f"Current room: {current_room}")
+
+            if not current_room:
+                # For Rand256 handler, try to zoom based on robot position even without room data
+                if (
+                    rand256
+                    and hasattr(self.handler, "robot_position")
+                    and self.handler.robot_position
+                ):
+                    robot_x, robot_y = (
+                        self.handler.robot_position[0],
+                        self.handler.robot_position[1],
+                    )
 
-            if rand256:
-                trim_left = (
-                    round(self.handler.robot_in_room["right"] / 10) - margin_size
-                )
-                trim_right = (
-                    round(self.handler.robot_in_room["left"] / 10) + margin_size
-                )
-                trim_up = round(self.handler.robot_in_room["down"] / 10) - margin_size
-                trim_down = round(self.handler.robot_in_room["up"] / 10) + margin_size
-            else:
-                trim_left = self.handler.robot_in_room["left"] - margin_size
-                trim_right = self.handler.robot_in_room["right"] + margin_size
-                trim_up = self.handler.robot_in_room["up"] - margin_size
-                trim_down = self.handler.robot_in_room["down"] + margin_size
+                    # Create a zoom area around the robot position (e.g., 800x800 pixels for better view)
+                    zoom_size = 800
+                    trim_left = max(0, int(robot_x - zoom_size // 2))
+                    trim_right = min(
+                        image_array.shape[1], int(robot_x + zoom_size // 2)
+                    )
+                    trim_up = max(0, int(robot_y - zoom_size // 2))
+                    trim_down = min(image_array.shape[0], int(robot_y + zoom_size // 2))
 
+                    _LOGGER.info(
+                        "%s: Zooming to robot position area (%d, %d) with size %dx%d",
+                        self.handler.file_name,
+                        robot_x,
+                        robot_y,
+                        trim_right - trim_left,
+                        trim_down - trim_up,
+                    )
+
+                    return image_array[trim_up:trim_down, trim_left:trim_right]
+                else:
+                    _LOGGER.warning(
+                        "%s: No room information available for zoom. Using full image.",
+                        self.handler.file_name,
+                    )
+                    return image_array[
+                        self.auto_crop[1] : self.auto_crop[3],
+                        self.auto_crop[0] : self.auto_crop[2],
+                    ]
+
+            # Calculate bounding box from room outline
+            bounding_box = await self.async_get_room_bounding_box(current_room, rand256)
+
+            if not bounding_box:
+                _LOGGER.warning(
+                    "%s: Could not calculate bounding box for room '%s'. Using full image.",
+                    self.handler.file_name,
+                    current_room,
+                )
+                return image_array[
+                    self.auto_crop[1] : self.auto_crop[3],
+                    self.auto_crop[0] : self.auto_crop[2],
+                ]
+
+            left, right, up, down = bounding_box
+
+            # Apply margins
+            trim_left = left - margin_size
+            trim_right = right + margin_size
+            trim_up = up - margin_size
+            trim_down = down + margin_size
             # Ensure valid trim values
             trim_left, trim_right = sorted([trim_left, trim_right])
             trim_up, trim_down = sorted([trim_up, trim_down])

{valetudo_map_parser-0.1.9b55 → valetudo_map_parser-0.1.9b57}/SCR/valetudo_map_parser/config/shared.py

@@ -58,6 +58,9 @@ class CameraShared:
         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
+        self.image_format = "WebP"  # 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
@@ -109,6 +112,45 @@ class CameraShared:
         self.skip_room_ids: List[str] = []
         self.device_info = None  # Store the device_info
 
+    @staticmethod
+    def _compose_obstacle_links(vacuum_host_ip: str, obstacles: list) -> list | None:
+        """
+        Compose JSON with obstacle details including the image link.
+        """
+        obstacle_links = []
+        if not obstacles or not vacuum_host_ip:
+            return None
+
+        for obstacle in obstacles:
+            # Extract obstacle details
+            label = obstacle.get("label", "")
+            points = obstacle.get("points", {})
+            image_id = obstacle.get("id", "None")
+
+            if label and points and image_id and vacuum_host_ip:
+                # Append formatted obstacle data
+                if image_id != "None":
+                    # Compose the link
+                    image_link = (
+                        f"http://{vacuum_host_ip}"
+                        f"/api/v2/robot/capabilities/ObstacleImagesCapability/img/{image_id}"
+                    )
+                    obstacle_links.append(
+                        {
+                            "point": points,
+                            "label": label,
+                            "link": image_link,
+                        }
+                    )
+                else:
+                    obstacle_links.append(
+                        {
+                            "point": points,
+                            "label": label,
+                        }
+                    )
+        return obstacle_links
+
     def update_user_colors(self, user_colors):
         """Update the user colors."""
         self.user_colors = user_colors
@@ -149,7 +191,11 @@ class CameraShared:
             ATTR_VACUUM_JSON_ID: self.vac_json_id,
             ATTR_CALIBRATION_POINTS: self.attr_calibration_points,
         }
-        if self.obstacles_data:
+        if self.obstacles_pos and self.vacuum_ips:
+            _LOGGER.debug("Generating obstacle links from: %s", self.obstacles_pos)
+            self.obstacles_data = self._compose_obstacle_links(
+                self.vacuum_ips, self.obstacles_pos
+            )
             attrs[ATTR_OBSTACLES] = self.obstacles_data
 
         if self.enable_snapshots:

{valetudo_map_parser-0.1.9b55 → valetudo_map_parser-0.1.9b57}/SCR/valetudo_map_parser/config/types.py

@@ -202,7 +202,8 @@ ChargerPosition = dict[str, Any]
 RoomsProperties = dict[str, RoomProperty]
 ImageSize = dict[str, int | list[int]]
 JsonType = Any  # json.loads() return type is Any
-PilPNG = Image.Image
+PilPNG = Image.Image  # Keep for backward compatibility
+WebPBytes = bytes  # WebP image as bytes
 NumpyArray = np.ndarray
 Point = Tuple[int, int]
 

{valetudo_map_parser-0.1.9b55 → valetudo_map_parser-0.1.9b57}/SCR/valetudo_map_parser/config/utils.py

@@ -4,14 +4,15 @@ import hashlib
 import json
 from dataclasses import dataclass
 from typing import Callable, List, Optional
+import io
 
 import numpy as np
-from PIL import ImageOps
+from PIL import Image, ImageOps
 
 from .drawable import Drawable
 from .drawable_elements import DrawableElement, DrawingConfig
 from .enhanced_drawable import EnhancedDrawable
-from .types import LOGGER, ChargerPosition, ImageSize, NumpyArray, PilPNG, RobotPosition
+from .types import LOGGER, ChargerPosition, ImageSize, NumpyArray, PilPNG, RobotPosition, WebPBytes
 
 
 @dataclass
@@ -839,3 +840,91 @@ async def async_extract_room_outline(
             str(e),
         )
         return rect_outline
+
+
+async def numpy_to_webp_bytes(
+    img_np_array: np.ndarray,
+    quality: int = 85,
+    lossless: bool = False
+) -> bytes:
+    """
+    Convert NumPy array directly to WebP bytes.
+
+    Args:
+        img_np_array: RGBA NumPy array
+        quality: WebP quality (0-100, ignored if lossless=True)
+        lossless: Use lossless WebP compression
+
+    Returns:
+        WebP image as bytes
+    """
+    # Convert NumPy array to PIL Image
+    pil_img = Image.fromarray(img_np_array, mode="RGBA")
+
+    # Create bytes buffer
+    webp_buffer = io.BytesIO()
+
+    # Save as WebP
+    pil_img.save(
+        webp_buffer,
+        format='WEBP',
+        quality=quality,
+        lossless=lossless,
+        method=6  # Best compression method
+    )
+
+    # Get bytes and cleanup
+    webp_bytes = webp_buffer.getvalue()
+    webp_buffer.close()
+
+    return webp_bytes
+
+
+async def pil_to_webp_bytes(
+    pil_img: Image.Image,
+    quality: int = 85,
+    lossless: bool = False
+) -> bytes:
+    """
+    Convert PIL Image to WebP bytes.
+
+    Args:
+        pil_img: PIL Image object
+        quality: WebP quality (0-100, ignored if lossless=True)
+        lossless: Use lossless WebP compression
+
+    Returns:
+        WebP image as bytes
+    """
+    # Create bytes buffer
+    webp_buffer = io.BytesIO()
+
+    # Save as WebP
+    pil_img.save(
+        webp_buffer,
+        format='WEBP',
+        quality=quality,
+        lossless=lossless,
+        method=6  # Best compression method
+    )
+
+    # Get bytes and cleanup
+    webp_bytes = webp_buffer.getvalue()
+    webp_buffer.close()
+
+    return webp_bytes
+
+
+def webp_bytes_to_pil(webp_bytes: bytes) -> Image.Image:
+    """
+    Convert WebP bytes back to PIL Image for display or further processing.
+
+    Args:
+        webp_bytes: WebP image as bytes
+
+    Returns:
+        PIL Image object
+    """
+    webp_buffer = io.BytesIO(webp_bytes)
+    pil_img = Image.open(webp_buffer)
+    return pil_img

{valetudo_map_parser-0.1.9b55 → valetudo_map_parser-0.1.9b57}/SCR/valetudo_map_parser/hypfer_draw.py

@@ -276,40 +276,13 @@ class ImageDraw:
         return img_np_array
 
     async def async_draw_obstacle(
-        self, np_array: NumpyArray, entity_dict: dict, color_no_go: Color
+        self, np_array: NumpyArray, obstacle_positions: list[dict], color_no_go: Color
     ) -> NumpyArray:
-        """Get the obstacle positions from the entity data."""
-        try:
-            obstacle_data = entity_dict.get("obstacle")
-        except KeyError:
-            _LOGGER.info("%s No obstacle found.", self.file_name)
-            return np_array
-        obstacle_positions = []
-        if obstacle_data:
-            for obstacle in obstacle_data:
-                label = obstacle.get("metaData", {}).get("label")
-                points = obstacle.get("points", [])
-
-                if label and points:
-                    obstacle_pos = {
-                        "label": label,
-                        "points": {"x": points[0], "y": points[1]},
-                    }
-                    obstacle_positions.append(obstacle_pos)
-
-        # List of dictionaries containing label and points for each obstacle
-        # and draw obstacles on the map
+        """Draw the obstacle positions from the entity data."""
         if obstacle_positions:
             await self.img_h.draw.async_draw_obstacles(
                 np_array, obstacle_positions, color_no_go
             )
-
-            # Update both obstacles_pos and obstacles_data
-            self.img_h.shared.obstacles_pos = obstacle_positions
-            # Only update obstacles_data if it's None or if the number of obstacles has changed
-            if (self.img_h.shared.obstacles_data is None or
-                len(self.img_h.shared.obstacles_data) != len(obstacle_positions)):
-                self.img_h.shared.obstacles_data = obstacle_positions
         return np_array
 
     async def async_draw_charger(
@@ -453,6 +426,50 @@ class ImageDraw:
         _LOGGER.info("%s: Got the points in the json.", self.file_name)
         return entity_dict
 
+    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)
+            room_keys = list(room_store.get_rooms().keys())
+
+            _LOGGER.debug(
+                "%s: Active zones debug - segment_id: %s, room_keys: %s, active_zones: %s",
+                self.file_name,
+                segment_id,
+                room_keys,
+                self.img_h.active_zones,
+            )
+
+            if segment_id in room_keys:
+                position = room_keys.index(segment_id)
+                _LOGGER.debug(
+                    "%s: Segment ID %s found at position %s, active_zones[%s] = %s",
+                    self.file_name,
+                    segment_id,
+                    position,
+                    position,
+                    self.img_h.active_zones[position]
+                    if position < len(self.img_h.active_zones)
+                    else "OUT_OF_BOUNDS",
+                )
+                if position < len(self.img_h.active_zones):
+                    self.img_h.zooming = bool(self.img_h.active_zones[position])
+                else:
+                    self.img_h.zooming = False
+            else:
+                _LOGGER.warning(
+                    "%s: Segment ID %s not found in room_keys %s",
+                    self.file_name,
+                    segment_id,
+                    room_keys,
+                )
+                self.img_h.zooming = False
+        else:
+            self.img_h.zooming = False
+
     @staticmethod
     def point_in_polygon(x: int, y: int, polygon: list) -> bool:
         """
@@ -501,15 +518,7 @@ class ImageDraw:
                         "in_room": self.img_h.robot_in_room["room"],
                     }
                     # Handle active zones
-                    if self.img_h.active_zones and (
-                        self.img_h.robot_in_room["id"]
-                        in range(len(self.img_h.active_zones))
-                    ):
-                        self.img_h.zooming = bool(
-                            self.img_h.active_zones[self.img_h.robot_in_room["id"]]
-                        )
-                    else:
-                        self.img_h.zooming = False
+                    self._check_active_zone_and_set_zooming()
                     return temp
             # Fallback to bounding box check if no outline data
             elif all(
@@ -529,15 +538,7 @@ class ImageDraw:
                         "in_room": self.img_h.robot_in_room["room"],
                     }
                     # Handle active zones
-                    if self.img_h.active_zones and (
-                        self.img_h.robot_in_room["id"]
-                        in range(len(self.img_h.active_zones))
-                    ):
-                        self.img_h.zooming = bool(
-                            self.img_h.active_zones[self.img_h.robot_in_room["id"]]
-                        )
-                    else:
-                        self.img_h.zooming = False
+                    self._check_active_zone_and_set_zooming()
                     return temp
 
         # If we don't have a cached room or the robot is not in it, search all rooms
@@ -590,7 +591,9 @@ class ImageDraw:
                 if self.point_in_polygon(int(robot_x), int(robot_y), outline):
                     # Robot is in this room
                     self.img_h.robot_in_room = {
-                        "id": room_count,
+                        "id": room.get(
+                            "id", room_count
+                        ),  # Use actual segment ID if available
                         "room": str(room["name"]),
                         "outline": outline,
                     }
@@ -600,6 +603,52 @@ class ImageDraw:
                         "angle": angle,
                         "in_room": self.img_h.robot_in_room["room"],
                     }
+
+                    # 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)
+                        room_keys = list(room_store.get_rooms().keys())
+
+                        _LOGGER.debug(
+                            "%s: Active zones debug - segment_id: %s, room_keys: %s, active_zones: %s",
+                            self.file_name,
+                            segment_id,
+                            room_keys,
+                            self.img_h.active_zones,
+                        )
+
+                        if segment_id in room_keys:
+                            position = room_keys.index(segment_id)
+                            _LOGGER.debug(
+                                "%s: Segment ID %s found at position %s, active_zones[%s] = %s",
+                                self.file_name,
+                                segment_id,
+                                position,
+                                position,
+                                self.img_h.active_zones[position]
+                                if position < len(self.img_h.active_zones)
+                                else "OUT_OF_BOUNDS",
+                            )
+                            if position < len(self.img_h.active_zones):
+                                self.img_h.zooming = bool(
+                                    self.img_h.active_zones[position]
+                                )
+                            else:
+                                self.img_h.zooming = False
+                        else:
+                            _LOGGER.warning(
+                                "%s: Segment ID %s not found in room_keys %s",
+                                self.file_name,
+                                segment_id,
+                                room_keys,
+                            )
+                            self.img_h.zooming = False
+                    else:
+                        self.img_h.zooming = False
+
                     _LOGGER.debug(
                         "%s is in %s room (polygon detection).",
                         self.file_name,
@@ -611,7 +660,9 @@ class ImageDraw:
                 corners = room["corners"]
                 # Create a bounding box from the corners
                 self.img_h.robot_in_room = {
-                    "id": room_count,
+                    "id": room.get(
+                        "id", room_count
+                    ),  # Use actual segment ID if available
                     "left": int(corners[0][0]),
                     "right": int(corners[2][0]),
                     "up": int(corners[0][1]),
@@ -632,6 +683,10 @@ class ImageDraw:
                         "angle": angle,
                         "in_room": self.img_h.robot_in_room["room"],
                     }
+
+                    # Handle active zones
+                    self._check_active_zone_and_set_zooming()
+
                     _LOGGER.debug(
                         "%s is in %s room (bounding box detection).",
                         self.file_name,