valetudo-map-parser 0.1.9b100__py3-none-any.whl → 0.1.10__py3-none-any.whl

valetudo_map_parser/config/rand256_parser.py

@@ -1,7 +1,7 @@
 """New Rand256 Map Parser - Based on Xiaomi/Roborock implementation with precise binary parsing."""
 
-import struct
 import math
+import struct
 from enum import Enum
 from typing import Any, Dict, List, Optional
 
@@ -24,6 +24,14 @@ class RRMapParser:
         VIRTUAL_WALLS = 10
         CURRENTLY_CLEANED_BLOCKS = 11
         FORBIDDEN_MOP_ZONES = 12
+        OBSTACLES = 13
+        IGNORED_OBSTACLES = 14
+        OBSTACLES_WITH_PHOTO = 15
+        IGNORED_OBSTACLES_WITH_PHOTO = 16
+        CARPET_MAP = 17
+        MOP_PATH = 18
+        NO_CARPET_AREAS = 19
+        DIGEST = 1024
 
     class Tools:
         """Tools for coordinate transformations."""
@@ -33,6 +41,7 @@ class RRMapParser:
 
     def __init__(self):
         """Initialize the parser."""
+        self.is_valid = False
         self.map_data: Dict[str, Any] = {}
 
     # Xiaomi/Roborock style byte extraction methods
@@ -67,6 +76,61 @@ class RRMapParser:
         value = RRMapParser._get_int32(data, address)
         return value if value < 0x80000000 else value - 0x100000000
 
+    @staticmethod
+    def _parse_carpet_map(data: bytes) -> set[int]:
+        carpet_map = set()
+
+        for i, v in enumerate(data):
+            if v:
+                carpet_map.add(i)
+        return carpet_map
+
+    @staticmethod
+    def _parse_area(header: bytes, data: bytes) -> list:
+        area_pairs = RRMapParser._get_int16(header, 0x08)
+        areas = []
+        for area_start in range(0, area_pairs * 16, 16):
+            x0 = RRMapParser._get_int16(data, area_start + 0)
+            y0 = RRMapParser._get_int16(data, area_start + 2)
+            x1 = RRMapParser._get_int16(data, area_start + 4)
+            y1 = RRMapParser._get_int16(data, area_start + 6)
+            x2 = RRMapParser._get_int16(data, area_start + 8)
+            y2 = RRMapParser._get_int16(data, area_start + 10)
+            x3 = RRMapParser._get_int16(data, area_start + 12)
+            y3 = RRMapParser._get_int16(data, area_start + 14)
+            areas.append(
+                [
+                    x0,
+                    RRMapParser.Tools.DIMENSION_MM - y0,
+                    x1,
+                    RRMapParser.Tools.DIMENSION_MM - y1,
+                    x2,
+                    RRMapParser.Tools.DIMENSION_MM - y2,
+                    x3,
+                    RRMapParser.Tools.DIMENSION_MM - y3,
+                ]
+            )
+        return areas
+
+    @staticmethod
+    def _parse_zones(data: bytes, header: bytes) -> list:
+        zone_pairs = RRMapParser._get_int16(header, 0x08)
+        zones = []
+        for zone_start in range(0, zone_pairs * 8, 8):
+            x0 = RRMapParser._get_int16(data, zone_start + 0)
+            y0 = RRMapParser._get_int16(data, zone_start + 2)
+            x1 = RRMapParser._get_int16(data, zone_start + 4)
+            y1 = RRMapParser._get_int16(data, zone_start + 6)
+            zones.append(
+                [
+                    x0,
+                    RRMapParser.Tools.DIMENSION_MM - y0,
+                    x1,
+                    RRMapParser.Tools.DIMENSION_MM - y1,
+                ]
+            )
+        return zones
+
     @staticmethod
     def _parse_object_position(block_data_length: int, data: bytes) -> Dict[str, Any]:
         """Parse object position using Xiaomi method."""
@@ -82,6 +146,38 @@ class RRMapParser:
                 angle = raw_angle
         return {"position": [x, y], "angle": angle}
 
+
+    @staticmethod
+    def _parse_walls(data: bytes, header: bytes) -> list:
+        wall_pairs = RRMapParser._get_int16(header, 0x08)
+        walls = []
+        for wall_start in range(0, wall_pairs * 8, 8):
+            x0 = RRMapParser._get_int16(data, wall_start + 0)
+            y0 = RRMapParser._get_int16(data, wall_start + 2)
+            x1 = RRMapParser._get_int16(data, wall_start + 4)
+            y1 = RRMapParser._get_int16(data, wall_start + 6)
+            walls.append([x0, RRMapParser.Tools.DIMENSION_MM - y0, x1, RRMapParser.Tools.DIMENSION_MM - y1])
+        return walls
+
+    @staticmethod
+    def _parse_walls(data: bytes, header: bytes) -> list:
+        wall_pairs = RRMapParser._get_int16(header, 0x08)
+        walls = []
+        for wall_start in range(0, wall_pairs * 8, 8):
+            x0 = RRMapParser._get_int16(data, wall_start + 0)
+            y0 = RRMapParser._get_int16(data, wall_start + 2)
+            x1 = RRMapParser._get_int16(data, wall_start + 4)
+            y1 = RRMapParser._get_int16(data, wall_start + 6)
+            walls.append(
+                [
+                    x0,
+                    RRMapParser.Tools.DIMENSION_MM - y0,
+                    x1,
+                    RRMapParser.Tools.DIMENSION_MM - y1,
+                ]
+            )
+        return walls
+
     @staticmethod
     def _parse_path_block(buf: bytes, offset: int, length: int) -> Dict[str, Any]:
         """Parse path block using EXACT same method as working parser."""
@@ -127,59 +223,69 @@ class RRMapParser:
             return {}
 
     def parse_blocks(self, raw: bytes, pixels: bool = True) -> Dict[int, Any]:
-        """Parse all blocks using Xiaomi method."""
         blocks = {}
         map_header_length = self._get_int16(raw, 0x02)
         block_start_position = map_header_length
-
         while block_start_position < len(raw):
             try:
-                # Parse block header using Xiaomi method
                 block_header_length = self._get_int16(raw, block_start_position + 0x02)
                 header = self._get_bytes(raw, block_start_position, block_header_length)
                 block_type = self._get_int16(header, 0x00)
                 block_data_length = self._get_int32(header, 0x04)
                 block_data_start = block_start_position + block_header_length
                 data = self._get_bytes(raw, block_data_start, block_data_length)
+                match block_type:
+                    case self.Types.DIGEST.value:
+                        self.is_valid = True
+                    case (
+                        self.Types.ROBOT_POSITION.value
+                        | self.Types.CHARGER_LOCATION.value
+                    ):
+                        blocks[block_type] = self._parse_object_position(
+                            block_data_length, data
+                        )
+                    case self.Types.PATH.value | self.Types.GOTO_PREDICTED_PATH.value:
+                        blocks[block_type] = self._parse_path_block(
+                            raw, block_start_position, block_data_length
+                        )
+                    case self.Types.CURRENTLY_CLEANED_ZONES.value:
+                        blocks[block_type] = {"zones": self._parse_zones(data, header)}
+                    case self.Types.FORBIDDEN_ZONES.value:
+                        blocks[block_type] = {
+                            "forbidden_zones": self._parse_area(header, data)
+                        }
+                    case self.Types.FORBIDDEN_MOP_ZONES.value:
+                        blocks[block_type] = {
+                            "forbidden_mop_zones": self._parse_area(header, data)
+                        }
+                    case self.Types.GOTO_TARGET.value:
+                        blocks[block_type] = {"position": self._parse_goto_target(data)}
+                    case self.Types.VIRTUAL_WALLS.value:
+                        blocks[block_type] = {
+                            "virtual_walls": self._parse_walls(data, header)
+                        }
+                    case self.Types.CARPET_MAP.value:
+                        data = RRMapParser._get_bytes(
+                            raw, block_data_start, block_data_length
+                        )
+                        blocks[block_type] = {
+                            "carpet_map": self._parse_carpet_map(data)
+                        }
+                    case self.Types.IMAGE.value:
+                        header_length = self._get_int8(header, 2)
+                        blocks[block_type] = self._parse_image_block(
+                            raw,
+                            block_start_position,
+                            block_data_length,
+                            header_length,
+                            pixels,
+                        )
 
-                # Parse different block types
-                if block_type == self.Types.ROBOT_POSITION.value:
-                    blocks[block_type] = self._parse_object_position(
-                        block_data_length, data
-                    )
-                elif block_type == self.Types.CHARGER_LOCATION.value:
-                    blocks[block_type] = self._parse_object_position(
-                        block_data_length, data
-                    )
-                elif block_type == self.Types.PATH.value:
-                    blocks[block_type] = self._parse_path_block(
-                        raw, block_start_position, block_data_length
-                    )
-                elif block_type == self.Types.GOTO_PREDICTED_PATH.value:
-                    blocks[block_type] = self._parse_path_block(
-                        raw, block_start_position, block_data_length
-                    )
-                elif block_type == self.Types.GOTO_TARGET.value:
-                    blocks[block_type] = {"position": self._parse_goto_target(data)}
-                elif block_type == self.Types.IMAGE.value:
-                    # Get header length for Gen1/Gen3 detection
-                    header_length = self._get_int8(header, 2)
-                    blocks[block_type] = self._parse_image_block(
-                        raw,
-                        block_start_position,
-                        block_data_length,
-                        header_length,
-                        pixels,
-                    )
-
-                # Move to next block using Xiaomi method
                 block_start_position = (
                     block_start_position + block_data_length + self._get_int8(header, 2)
                 )
-
             except (struct.error, IndexError):
                 break
-
         return blocks
 
     def _parse_image_block(
@@ -365,8 +471,32 @@ class RRMapParser:
                 ]
 
             # Add missing fields to match expected JSON format
-            parsed_map_data["forbidden_zones"] = []
-            parsed_map_data["virtual_walls"] = []
+            parsed_map_data["currently_cleaned_zones"] = (
+                blocks[self.Types.CURRENTLY_CLEANED_ZONES.value]["zones"]
+                if self.Types.CURRENTLY_CLEANED_ZONES.value in blocks
+                else []
+            )
+            parsed_map_data["forbidden_zones"] = (
+                blocks[self.Types.FORBIDDEN_ZONES.value]["forbidden_zones"]
+                if self.Types.FORBIDDEN_ZONES.value in blocks
+                else []
+            )
+            parsed_map_data["forbidden_mop_zones"] = (
+                blocks[self.Types.FORBIDDEN_MOP_ZONES.value]["forbidden_mop_zones"]
+                if self.Types.FORBIDDEN_MOP_ZONES.value in blocks
+                else []
+            )
+            parsed_map_data["virtual_walls"] = (
+                blocks[self.Types.VIRTUAL_WALLS.value]["virtual_walls"]
+                if self.Types.VIRTUAL_WALLS.value in blocks
+                else []
+            )
+            parsed_map_data["carpet_areas"] = (
+                blocks[self.Types.CARPET_MAP.value]["carpet_map"]
+                if self.Types.CARPET_MAP.value in blocks
+                else []
+            )
+            parsed_map_data["is_valid"] = self.is_valid
 
             return parsed_map_data
 
@@ -388,8 +518,3 @@ class RRMapParser:
             except (struct.error, IndexError, ValueError):
                 return None
         return self.map_data
-
-    @staticmethod
-    def get_int32(data: bytes, address: int) -> int:
-        """Get a 32-bit integer from the data - kept for compatibility."""
-        return struct.unpack_from("<i", data, address)[0]

valetudo_map_parser/config/shared.py

@@ -1,23 +1,25 @@
 """
 Class Camera Shared.
 Keep the data between the modules.
-Version: v0.1.9
+Version: v0.1.12
 """
 
 import asyncio
 import logging
 from typing import List
+
 from PIL import Image
 
 from .types import (
     ATTR_CALIBRATION_POINTS,
     ATTR_CAMERA_MODE,
+    ATTR_CONTENT_TYPE,
+    ATTR_IMAGE_LAST_UPDATED,
     ATTR_MARGINS,
     ATTR_OBSTACLES,
     ATTR_POINTS,
     ATTR_ROOMS,
     ATTR_ROTATE,
-    ATTR_SNAPSHOT,
     ATTR_VACUUM_BATTERY,
     ATTR_VACUUM_CHARGING,
     ATTR_VACUUM_JSON_ID,
@@ -39,8 +41,8 @@ from .types import (
     DEFAULT_VALUES,
     CameraModes,
     Colors,
-    TrimsData,
     PilPNG,
+    TrimsData,
 )
 
 
@@ -54,70 +56,68 @@ class CameraShared:
     """
 
     def __init__(self, file_name):
-        self.camera_mode: str = CameraModes.MAP_VIEW  # Camera mode
-        self.frame_number: int = 0  # camera Frame number
-        self.destinations: list = []  # MQTT rand destinations
-        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
-        # 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
-        self.image_zoom_lock_ratio: bool = True  # Zoom lock ratio
-        self.image_ref_height: int = 0  # Image reference height
-        self.image_ref_width: int = 0  # Image reference width
-        self.image_aspect_ratio: str = "None"  # Change Image aspect ratio
-        self.image_grab = True  # Grab image from MQTT
-        self.image_rotate: int = 0  # Rotate image
-        self.drawing_limit: float = 0.0  # Drawing CPU limit
-        self.current_room = None  # Current room of rhe vacuum
-        self.user_colors = Colors  # User base colors
-        self.rooms_colors = Colors  # Rooms colors
-        self.vacuum_battery = 0  # Vacuum battery state
-        self.vacuum_bat_charged: bool = True  # Vacuum charged and ready
-        self.vacuum_connection = None  # Vacuum connection state
-        self.vacuum_state = None  # Vacuum state
-        self.charger_position = None  # Vacuum Charger position
-        self.show_vacuum_state = None  # Show vacuum state on the map
+        self.camera_mode: str = CameraModes.MAP_VIEW
+        self.frame_number: int = 0
+        self.destinations: list = []
+        self.rand256_active_zone: list = []
+        self.rand256_zone_coordinates: list = []
+        self.is_rand: bool = False
+        self._new_mqtt_message = False
+        self.last_image = Image.new("RGBA", (250, 150), (128, 128, 128, 255))
+        self.new_image: PilPNG | None = None
+        self.binary_image: bytes | None = None
+        self.image_last_updated: float = 0.0
+        self.image_format = "image/pil"
+        self.image_size = None
+        self.robot_size = None
+        self.image_auto_zoom: bool = False
+        self.image_zoom_lock_ratio: bool = True
+        self.image_ref_height: int = 0
+        self.image_ref_width: int = 0
+        self.image_aspect_ratio: str = "None"
+        self.image_grab = True
+        self.image_rotate: int = 0
+        self.drawing_limit: float = 0.0
+        self.current_room = None
+        self.user_colors = Colors
+        self.rooms_colors = Colors
+        self.vacuum_battery = 0
+        self.vacuum_connection = False
+        self.vacuum_state = None
+        self.charger_position = None
+        self.show_vacuum_state = None
         self.vacuum_status_font: str = (
-            "custom_components/mqtt_vacuum_camera/utils/fonts/FiraSans.ttf"  # Font
+            "custom_components/mqtt_vacuum_camera/utils/fonts/FiraSans.ttf"
         )
-        self.vacuum_status_size: int = 50  # Vacuum status size
-        self.vacuum_status_position: bool = True  # Vacuum status text image top
-        self.snapshot_take = False  # Take snapshot
-        self.vacuum_error = None  # Vacuum error
-        self.vacuum_api = None  # Vacuum API
-        self.vacuum_ips = None  # Vacuum IPs
-        self.vac_json_id = None  # Vacuum json id
-        self.margins = "100"  # Image margins
-        self.obstacles_data = None  # Obstacles data
-        self.obstacles_pos = None  # Obstacles position
-        self.offset_top = 0  # Image offset top
-        self.offset_down = 0  # Image offset down
-        self.offset_left = 0  # Image offset left
-        self.offset_right = 0  # Image offset right
-        self.export_svg = False  # Export SVG
-        self.svg_path = None  # SVG Export path
-        self.enable_snapshots = False  # Enable snapshots
-        self.file_name = file_name  # vacuum friendly name as File name
-        self.attr_calibration_points = None  # Calibration points of the image
-        self.map_rooms = None  # Rooms data from the vacuum
-        self.map_pred_zones = None  # Predefined zones data
-        self.map_pred_points = None  # Predefined points data
-        self.map_new_path = None  # New path data
-        self.map_old_path = None  # Old path data
-        self.user_language = None  # User language
+        self.vacuum_status_size: int = 50
+        self.vacuum_status_position: bool = True
+        self.snapshot_take = False
+        self.vacuum_error = None
+        self.vacuum_api = None
+        self.vacuum_ips = None
+        self.vac_json_id = None
+        self.margins = "100"
+        self.obstacles_data = None
+        self.obstacles_pos = None
+        self.offset_top = 0
+        self.offset_down = 0
+        self.offset_left = 0
+        self.offset_right = 0
+        self.export_svg = False
+        self.svg_path = None
+        self.enable_snapshots = False
+        self.file_name = file_name
+        self.attr_calibration_points = None
+        self.map_rooms = None
+        self.map_pred_zones = None
+        self.map_pred_points = None
+        self.map_new_path = None
+        self.map_old_path = None
+        self.user_language = None
         self.trim_crop_data = None
-        self.trims = TrimsData.from_dict(DEFAULT_VALUES["trims_data"])  # Trims data
+        self.trims = TrimsData.from_dict(DEFAULT_VALUES["trims_data"])
         self.skip_room_ids: List[str] = []
-        self.device_info = None  # Store the device_info
+        self.device_info = None
 
     def vacuum_bat_charged(self) -> bool:
         """Check if the vacuum is charging."""
@@ -125,49 +125,35 @@ class CameraShared:
 
     @staticmethod
     def _compose_obstacle_links(vacuum_host_ip: str, obstacles: list) -> list | None:
-        """
-        Compose JSON with obstacle details including the image link.
-        """
+        """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,
-                        }
+                        {"point": points, "label": label, "link": image_link}
                     )
                 else:
-                    obstacle_links.append(
-                        {
-                            "point": points,
-                            "label": label,
-                        }
-                    )
+                    obstacle_links.append({"point": points, "label": label})
         return obstacle_links
 
     def update_user_colors(self, user_colors):
-        """Update the user colors."""
+        """Update user colors palette"""
         self.user_colors = user_colors
 
     def get_user_colors(self):
-        """Get the user colors."""
+        """Return user colors"""
         return self.user_colors
 
     def update_rooms_colors(self, user_colors):
@@ -175,7 +161,7 @@ class CameraShared:
         self.rooms_colors = user_colors
 
     def get_rooms_colors(self):
-        """Get the rooms colors."""
+        """Return rooms colors"""
         return self.rooms_colors
 
     def reset_trims(self) -> dict:
@@ -184,7 +170,7 @@ class CameraShared:
         return self.trims
 
     async def batch_update(self, **kwargs):
-        """Batch update multiple attributes."""
+        """Update the data of Shared in Batch"""
         for key, value in kwargs.items():
             setattr(self, key, value)
 
@@ -195,39 +181,44 @@ class CameraShared:
     def generate_attributes(self) -> dict:
         """Generate and return the shared attribute's dictionary."""
         attrs = {
+            ATTR_IMAGE_LAST_UPDATED: self.image_last_updated,
+            ATTR_CONTENT_TYPE: self.image_format,
+            ATTR_VACUUM_JSON_ID: self.vac_json_id,
             ATTR_CAMERA_MODE: self.camera_mode,
+            ATTR_VACUUM_STATUS: self.vacuum_state,
             ATTR_VACUUM_BATTERY: f"{self.vacuum_battery}%",
-            ATTR_VACUUM_CHARGING: self.vacuum_bat_charged,
+            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,
             ATTR_CALIBRATION_POINTS: self.attr_calibration_points,
         }
         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:
-            attrs[ATTR_SNAPSHOT] = self.snapshot_take
-        else:
-            attrs[ATTR_SNAPSHOT] = False
-
-        # Add dynamic shared attributes if they are available
         shared_attrs = {
             ATTR_ROOMS: self.map_rooms,
             ATTR_ZONES: self.map_pred_zones,
             ATTR_POINTS: self.map_pred_points,
         }
-
         for key, value in shared_attrs.items():
             if value is not None:
                 attrs[key] = value
 
         return attrs
 
+    def to_dict(self) -> dict:
+        """Return a dictionary with image and attributes data."""
+        return {
+            "image": {
+                "binary": self.binary_image,
+                "pil_image": self.new_image,
+                "size": self.new_image.size if self.new_image else (10, 10),
+            },
+            "attributes": self.generate_attributes(),
+        }
+
 
 class CameraSharedManager:
     """Camera Shared Manager class."""
@@ -302,19 +293,30 @@ class CameraSharedManager:
             )
             # Ensure trims are updated correctly
             trim_data = device_info.get("trims_data", DEFAULT_VALUES["trims_data"])
-            _LOGGER.debug(
-                "%s: Updating shared trims with: %s", instance.file_name, trim_data
-            )
             instance.trims = TrimsData.from_dict(trim_data)
+            # Robot size
+            robot_size = device_info.get("robot_size", 25)
+            try:
+                robot_size = int(robot_size)
+            except (ValueError, TypeError):
+                robot_size = 25
+            # Clamp robot_size to [8, 25]
+            if robot_size < 8:
+                robot_size = 8
+            elif robot_size > 25:
+                robot_size = 25
+            instance.robot_size = robot_size
 
         except TypeError as ex:
-            _LOGGER.error("Shared data can't be initialized due to a TypeError! %s", ex)
+            _LOGGER.warning(
+                "Shared data can't be initialized due to a TypeError! %s", ex
+            )
         except AttributeError as ex:
-            _LOGGER.error(
+            _LOGGER.warning(
                 "Shared data can't be initialized due to an AttributeError! %s", ex
             )
         except RuntimeError as ex:
-            _LOGGER.error(
+            _LOGGER.warning(
                 "An unexpected error occurred while initializing shared data %s:", ex
             )