valetudo-map-parser 0.1.9b56__tar.gz → 0.1.9b58__tar.gz

{valetudo_map_parser-0.1.9b56 → valetudo_map_parser-0.1.9b58}/PKG-INFO

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

@@ -0,0 +1,395 @@
+"""New Rand256 Map Parser - Based on Xiaomi/Roborock implementation with precise binary parsing."""
+
+import struct
+import math
+from enum import Enum
+from typing import Any, Dict, List, Optional
+
+
+class RRMapParser:
+    """New Rand256 Map Parser using Xiaomi/Roborock approach for precise data extraction."""
+
+    class Types(Enum):
+        """Map data block types."""
+
+        CHARGER_LOCATION = 1
+        IMAGE = 2
+        PATH = 3
+        GOTO_PATH = 4
+        GOTO_PREDICTED_PATH = 5
+        CURRENTLY_CLEANED_ZONES = 6
+        GOTO_TARGET = 7
+        ROBOT_POSITION = 8
+        FORBIDDEN_ZONES = 9
+        VIRTUAL_WALLS = 10
+        CURRENTLY_CLEANED_BLOCKS = 11
+        FORBIDDEN_MOP_ZONES = 12
+
+    class Tools:
+        """Tools for coordinate transformations."""
+
+        DIMENSION_PIXELS = 1024
+        DIMENSION_MM = 50 * 1024
+
+    def __init__(self):
+        """Initialize the parser."""
+        self.map_data: Dict[str, Any] = {}
+
+    # Xiaomi/Roborock style byte extraction methods
+    @staticmethod
+    def _get_bytes(data: bytes, start_index: int, size: int) -> bytes:
+        """Extract bytes from data."""
+        return data[start_index : start_index + size]
+
+    @staticmethod
+    def _get_int8(data: bytes, address: int) -> int:
+        """Get an 8-bit integer from data using Xiaomi method."""
+        return data[address] & 0xFF
+
+    @staticmethod
+    def _get_int16(data: bytes, address: int) -> int:
+        """Get a 16-bit little-endian integer using Xiaomi method."""
+        return ((data[address + 0] << 0) & 0xFF) | ((data[address + 1] << 8) & 0xFFFF)
+
+    @staticmethod
+    def _get_int32(data: bytes, address: int) -> int:
+        """Get a 32-bit little-endian integer using Xiaomi method."""
+        return (
+            ((data[address + 0] << 0) & 0xFF)
+            | ((data[address + 1] << 8) & 0xFFFF)
+            | ((data[address + 2] << 16) & 0xFFFFFF)
+            | ((data[address + 3] << 24) & 0xFFFFFFFF)
+        )
+
+    @staticmethod
+    def _get_int32_signed(data: bytes, address: int) -> int:
+        """Get a 32-bit signed integer."""
+        value = RRMapParser._get_int32(data, address)
+        return value if value < 0x80000000 else value - 0x100000000
+
+    @staticmethod
+    def _parse_object_position(block_data_length: int, data: bytes) -> Dict[str, Any]:
+        """Parse object position using Xiaomi method."""
+        x = RRMapParser._get_int32(data, 0x00)
+        y = RRMapParser._get_int32(data, 0x04)
+        angle = 0
+        if block_data_length > 8:
+            raw_angle = RRMapParser._get_int32(data, 0x08)
+            # Apply Xiaomi angle normalization
+            if raw_angle > 0xFF:
+                angle = (raw_angle & 0xFF) - 256
+            else:
+                angle = raw_angle
+        return {"position": [x, y], "angle": angle}
+
+    @staticmethod
+    def _parse_path_block(buf: bytes, offset: int, length: int) -> Dict[str, Any]:
+        """Parse path block using EXACT same method as working parser."""
+        points = [
+            [
+                struct.unpack("<H", buf[offset + 20 + i : offset + 22 + i])[0],
+                struct.unpack("<H", buf[offset + 22 + i : offset + 24 + i])[0],
+            ]
+            for i in range(0, length, 4)
+        ]
+        return {
+            "current_angle": struct.unpack("<I", buf[offset + 16 : offset + 20])[0],
+            "points": points,
+        }
+
+    @staticmethod
+    def _parse_goto_target(data: bytes) -> List[int]:
+        """Parse goto target using Xiaomi method."""
+        try:
+            x = RRMapParser._get_int16(data, 0x00)
+            y = RRMapParser._get_int16(data, 0x02)
+            return [x, y]
+        except (struct.error, IndexError):
+            return [0, 0]
+
+    def parse(self, map_buf: bytes) -> Dict[str, Any]:
+        """Parse the map header data using Xiaomi method."""
+        if len(map_buf) < 18 or map_buf[0:2] != b"rr":
+            return {}
+
+        try:
+            return {
+                "header_length": self._get_int16(map_buf, 0x02),
+                "data_length": self._get_int16(map_buf, 0x04),
+                "version": {
+                    "major": self._get_int16(map_buf, 0x08),
+                    "minor": self._get_int16(map_buf, 0x0A),
+                },
+                "map_index": self._get_int32(map_buf, 0x0C),
+                "map_sequence": self._get_int32(map_buf, 0x10),
+            }
+        except (struct.error, IndexError):
+            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)
+
+                # 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(
+        self, buf: bytes, offset: int, length: int, hlength: int, pixels: bool = True
+    ) -> Dict[str, Any]:
+        """Parse image block using EXACT logic from working parser."""
+        try:
+            # CRITICAL: Gen1 vs Gen3 detection like working parser
+            g3offset = 4 if hlength > 24 else 0
+
+            # Use EXACT same structure as working parser
+            parameters = {
+                "segments": {
+                    "count": (
+                        struct.unpack("<i", buf[offset + 8 : offset + 12])[0]
+                        if g3offset
+                        else 0
+                    ),
+                    "id": [],
+                },
+                "position": {
+                    "top": struct.unpack(
+                        "<i", buf[offset + 8 + g3offset : offset + 12 + g3offset]
+                    )[0],
+                    "left": struct.unpack(
+                        "<i", buf[offset + 12 + g3offset : offset + 16 + g3offset]
+                    )[0],
+                },
+                "dimensions": {
+                    "height": struct.unpack(
+                        "<i", buf[offset + 16 + g3offset : offset + 20 + g3offset]
+                    )[0],
+                    "width": struct.unpack(
+                        "<i", buf[offset + 20 + g3offset : offset + 24 + g3offset]
+                    )[0],
+                },
+                "pixels": {"floor": [], "walls": [], "segments": {}},
+            }
+
+            # Apply EXACT working parser coordinate transformation
+            parameters["position"]["top"] = (
+                self.Tools.DIMENSION_PIXELS
+                - parameters["position"]["top"]
+                - parameters["dimensions"]["height"]
+            )
+
+            # Extract pixels using optimized sequential processing
+            if (
+                parameters["dimensions"]["height"] > 0
+                and parameters["dimensions"]["width"] > 0
+            ):
+                # Process data sequentially - segments are organized as blocks
+                current_segments = {}
+
+                for i in range(length):
+                    pixel_byte = struct.unpack(
+                        "<B",
+                        buf[offset + 24 + g3offset + i : offset + 25 + g3offset + i],
+                    )[0]
+
+                    segment_type = pixel_byte & 0x07
+                    if segment_type == 0:
+                        continue
+
+                    if segment_type == 1 and pixels:
+                        # Wall pixel
+                        parameters["pixels"]["walls"].append(i)
+                    else:
+                        # Floor or room segment
+                        segment_id = pixel_byte >> 3
+                        if segment_id == 0 and pixels:
+                            # Floor pixel
+                            parameters["pixels"]["floor"].append(i)
+                        elif segment_id != 0:
+                            # Room segment - segments are sequential blocks
+                            if segment_id not in current_segments:
+                                parameters["segments"]["id"].append(segment_id)
+                                parameters["segments"][
+                                    "pixels_seg_" + str(segment_id)
+                                ] = []
+                                current_segments[segment_id] = True
+
+                            if pixels:
+                                parameters["segments"][
+                                    "pixels_seg_" + str(segment_id)
+                                ].append(i)
+
+            parameters["segments"]["count"] = len(parameters["segments"]["id"])
+            return parameters
+
+        except (struct.error, IndexError):
+            return {
+                "segments": {"count": 0, "id": []},
+                "position": {"top": 0, "left": 0},
+                "dimensions": {"height": 0, "width": 0},
+                "pixels": {"floor": [], "walls": [], "segments": {}},
+            }
+
+    def parse_rrm_data(
+        self, map_buf: bytes, pixels: bool = False
+    ) -> Optional[Dict[str, Any]]:
+        """Parse the complete map data and return in your JSON format."""
+        if not self.parse(map_buf).get("map_index"):
+            return None
+
+        try:
+            parsed_map_data = {}
+            blocks = self.parse_blocks(map_buf, pixels)
+
+            # Parse robot position
+            if self.Types.ROBOT_POSITION.value in blocks:
+                robot_data = blocks[self.Types.ROBOT_POSITION.value]
+                parsed_map_data["robot"] = robot_data["position"]
+
+            # Parse path data with coordinate transformation FIRST
+            transformed_path_points = []
+            if self.Types.PATH.value in blocks:
+                path_data = blocks[self.Types.PATH.value].copy()
+                # Apply coordinate transformation like current parser
+                transformed_path_points = [
+                    [point[0], self.Tools.DIMENSION_MM - point[1]]
+                    for point in path_data["points"]
+                ]
+                path_data["points"] = transformed_path_points
+
+                # Calculate current angle from transformed points
+                if len(transformed_path_points) >= 2:
+                    last_point = transformed_path_points[-1]
+                    second_last = transformed_path_points[-2]
+                    dx = last_point[0] - second_last[0]
+                    dy = last_point[1] - second_last[1]
+                    if dx != 0 or dy != 0:
+                        angle_rad = math.atan2(dy, dx)
+                        path_data["current_angle"] = math.degrees(angle_rad)
+                parsed_map_data["path"] = path_data
+
+            # Get robot angle from TRANSFORMED path data (like current implementation)
+            robot_angle = 0
+            if len(transformed_path_points) >= 2:
+                last_point = transformed_path_points[-1]
+                second_last = transformed_path_points[-2]
+                dx = last_point[0] - second_last[0]
+                dy = last_point[1] - second_last[1]
+                if dx != 0 or dy != 0:
+                    angle_rad = math.atan2(dy, dx)
+                    robot_angle = int(math.degrees(angle_rad))
+
+            parsed_map_data["robot_angle"] = robot_angle
+
+            # Parse charger position
+            if self.Types.CHARGER_LOCATION.value in blocks:
+                charger_data = blocks[self.Types.CHARGER_LOCATION.value]
+                parsed_map_data["charger"] = charger_data["position"]
+
+            # Parse image data
+            if self.Types.IMAGE.value in blocks:
+                parsed_map_data["image"] = blocks[self.Types.IMAGE.value]
+
+            # Parse goto predicted path
+            if self.Types.GOTO_PREDICTED_PATH.value in blocks:
+                goto_path_data = blocks[self.Types.GOTO_PREDICTED_PATH.value].copy()
+                # Apply coordinate transformation
+                goto_path_data["points"] = [
+                    [point[0], self.Tools.DIMENSION_MM - point[1]]
+                    for point in goto_path_data["points"]
+                ]
+                # Calculate current angle from transformed points (like working parser)
+                if len(goto_path_data["points"]) >= 2:
+                    points = goto_path_data["points"]
+                    last_point = points[-1]
+                    second_last = points[-2]
+                    dx = last_point[0] - second_last[0]
+                    dy = last_point[1] - second_last[1]
+                    if dx != 0 or dy != 0:
+                        angle_rad = math.atan2(dy, dx)
+                        goto_path_data["current_angle"] = math.degrees(angle_rad)
+                parsed_map_data["goto_predicted_path"] = goto_path_data
+
+            # Parse goto target
+            if self.Types.GOTO_TARGET.value in blocks:
+                parsed_map_data["goto_target"] = blocks[self.Types.GOTO_TARGET.value][
+                    "position"
+                ]
+
+            # Add missing fields to match expected JSON format
+            parsed_map_data["forbidden_zones"] = []
+            parsed_map_data["virtual_walls"] = []
+
+            return parsed_map_data
+
+        except (struct.error, IndexError, ValueError):
+            return None
+
+    def parse_data(
+        self, payload: Optional[bytes] = None, pixels: bool = False
+    ) -> Optional[Dict[str, Any]]:
+        """Get the map data from MQTT and return dictionary like old parsers."""
+        if payload:
+            try:
+                self.map_data = self.parse(payload)
+                parsed_data = self.parse_rrm_data(payload, pixels)
+                if parsed_data:
+                    self.map_data.update(parsed_data)
+                # Return dictionary directly - faster!
+                return self.map_data
+            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]