valetudo-map-parser 0.1.9b56__py3-none-any.whl → 0.1.9b58__py3-none-any.whl

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/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/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/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,

valetudo_map_parser/hypfer_handler.py

@@ -21,11 +21,13 @@ from .config.types import (
     Colors,
     RoomsProperties,
     RoomStore,
+    WebPBytes,
 )
 from .config.utils import (
     BaseHandler,
     initialize_drawing_config,
     manage_drawable_elements,
+    numpy_to_webp_bytes,
     prepare_resize_params,
 )
 from .hypfer_draw import ImageDraw as ImDraw
@@ -81,7 +83,11 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
             self.rooms_pos = []
             for room_id, room_data in room_properties.items():
                 self.rooms_pos.append(
-                    {"name": room_data["name"], "outline": room_data["outline"]}
+                    {
+                        "id": room_id,
+                        "name": room_data["name"],
+                        "outline": room_data["outline"],
+                    }
                 )
         else:
             LOGGER.debug("%s: Rooms data not available!", self.file_name)
@@ -92,12 +98,14 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
     async def async_get_image_from_json(
         self,
         m_json: json | None,
-    ) -> Image.Image | None:
+        return_webp: bool = False,
+    ) -> WebPBytes | Image.Image | None:
         """Get the image from the JSON data.
         It uses the ImageDraw class to draw some of the elements of the image.
         The robot itself will be drawn in this function as per some of the values are needed for other tasks.
         @param m_json: The JSON data to use to draw the image.
-        @return Image.Image: The image to display.
+        @param return_webp: If True, return WebP bytes; if False, return PIL Image (default).
+        @return WebPBytes | Image.Image: WebP bytes or PIL Image depending on return_webp parameter.
         """
         # Initialize the colors.
         colors: Colors = {
@@ -131,6 +139,8 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                 # Get the pixels size and layers from the JSON data
                 pixel_size = int(m_json["pixelSize"])
                 layers, active = self.data.find_layers(m_json["layers"], {}, [])
+                # Populate active_zones from the JSON data
+                self.active_zones = active
                 new_frame_hash = await self.calculate_array_hash(layers, active)
                 if self.frame_number == 0:
                     self.img_hash = new_frame_hash
@@ -240,20 +250,30 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
 
                     # Draw obstacles if enabled
                     if self.drawing_config.is_enabled(DrawableElement.OBSTACLE):
-                        img_np_array = await self.imd.async_draw_obstacle(
-                            img_np_array, entity_dict, colors["no_go"]
-                        )
+                        self.shared.obstacles_pos = self.data.get_obstacles(entity_dict)
+                        if self.shared.obstacles_pos:
+                            img_np_array = await self.imd.async_draw_obstacle(
+                                img_np_array, self.shared.obstacles_pos, colors["no_go"]
+                            )
                     # Robot and rooms position
                     if (room_id > 0) and not self.room_propriety:
                         self.room_propriety = await self.async_extract_room_properties(
                             self.json_data
                         )
-                        if self.rooms_pos and robot_position and robot_position_angle:
-                            self.robot_pos = await self.imd.async_get_robot_in_room(
-                                robot_x=(robot_position[0]),
-                                robot_y=(robot_position[1]),
-                                angle=robot_position_angle,
-                            )
+
+                    # Ensure room data is available for robot room detection (even if not extracted above)
+                    if not self.rooms_pos and not self.room_propriety:
+                        self.room_propriety = await self.async_extract_room_properties(
+                            self.json_data
+                        )
+
+                    # Always check robot position for zooming (moved outside the condition)
+                    if self.rooms_pos and robot_position and robot_position_angle:
+                        self.robot_pos = await self.imd.async_get_robot_in_room(
+                            robot_x=(robot_position[0]),
+                            robot_y=(robot_position[1]),
+                            angle=robot_position_angle,
+                        )
                     LOGGER.info("%s: Completed base Layers", self.file_name)
                     # Copy the new array in base layer.
                     self.img_base_layer = await self.async_copy_array(img_np_array)
@@ -332,6 +352,9 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                             robot_position,
                             DrawableElement.ROBOT,
                         )
+                # Synchronize zooming state from ImageDraw to handler before auto-crop
+                self.zooming = self.imd.img_h.zooming
+
                 # Resize the image
                 img_np_array = await self.async_auto_trim_and_zoom_image(
                     img_np_array,
@@ -345,16 +368,43 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                 LOGGER.warning("%s: Image array is None.", self.file_name)
                 return None
 
-            # Convert the numpy array to a PIL image
-            pil_img = Image.fromarray(img_np_array, mode="RGBA")
-            del img_np_array
-            # reduce the image size if the zoomed image is bigger then the original.
+            # Handle resizing if needed, then return based on format preference
             if self.check_zoom_and_aspect_ratio():
+                # Convert to PIL for resizing
+                pil_img = Image.fromarray(img_np_array, mode="RGBA")
+                del img_np_array
                 resize_params = prepare_resize_params(self, pil_img, False)
                 resized_image = await self.async_resize_images(resize_params)
-                return resized_image
-            LOGGER.debug("%s: Frame Completed.", self.file_name)
-            return pil_img
+
+                # 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,
+                        quality=90,
+                        lossless=False
+                    )
+                    return webp_bytes
+                else:
+                    return resized_image
+            else:
+                # Return WebP bytes or PIL Image based on parameter
+                if return_webp:
+                    # Convert directly from NumPy to WebP for better performance
+                    webp_bytes = await numpy_to_webp_bytes(
+                        img_np_array,
+                        quality=90,
+                        lossless=False
+                    )
+                    del img_np_array
+                    LOGGER.debug("%s: Frame Completed.", self.file_name)
+                    return webp_bytes
+                else:
+                    # Convert to PIL Image (original behavior)
+                    pil_img = Image.fromarray(img_np_array, mode="RGBA")
+                    del img_np_array
+                    LOGGER.debug("%s: Frame Completed.", self.file_name)
+                    return pil_img
         except (RuntimeError, RuntimeWarning) as e:
             LOGGER.warning(
                 "%s: Error %s during image creation.",

valetudo_map_parser/map_data.py

@@ -10,7 +10,7 @@ from __future__ import annotations
 
 import numpy as np
 
-from .config.types import Colors, ImageSize, JsonType, NumpyArray
+from .config.types import ImageSize, JsonType
 
 
 class ImageData:
@@ -34,6 +34,30 @@ class ImageData:
     # list the specific Layers, Paths, Zones and Pints in the
     # Vacuums Json in parallel.
 
+    @staticmethod
+    def get_obstacles(entity_dict: dict) -> list:
+        """Get the obstacles positions from the entity data."""
+        try:
+            obstacle_data = entity_dict.get("obstacle")
+        except KeyError:
+            return []
+        obstacle_positions = []
+        if obstacle_data:
+            for obstacle in obstacle_data:
+                label = obstacle.get("metaData", {}).get("label")
+                points = obstacle.get("points", [])
+                image_id = obstacle.get("metaData", {}).get("id")
+
+                if label and points:
+                    obstacle_pos = {
+                        "label": label,
+                        "points": {"x": points[0], "y": points[1]},
+                        "id": image_id,
+                    }
+                    obstacle_positions.append(obstacle_pos)
+            return obstacle_positions
+        return []
+
     @staticmethod
     def find_layers(
         json_obj: JsonType, layer_dict: dict, active_list: list
@@ -284,7 +308,7 @@ class RandImageData:
         Return the calculated angle and original angle.
         """
         angle_c = round(json_data.get("robot_angle", 0))
-        angle = (360 - angle_c + 80) if angle_c < 0 else (180 - angle_c - 80)
+        angle = (360 - angle_c + 95) if angle_c < 0 else (180 - angle_c - 85)
         return angle % 360, json_data.get("robot_angle", 0)
 
     @staticmethod