valetudo-map-parser 0.1.4__py3-none-any.whl → 0.1.6__py3-none-any.whl

valetudo_map_parser/__init__.py

@@ -1,8 +1,9 @@
 """Valetudo map parser.
-   Version: 0.1.4"""
-
+Version: 0.1.6"""
 
 from .hypfer_handler import HypferMapImageHandler
+from .rand25_handler import ReImageHandler
+from .config.rand25_parser import RRMapParser
 from .config.shared import CameraShared, CameraSharedManager
 from .config.colors import ColorsManagment
 from .config.drawable import Drawable
@@ -17,6 +18,7 @@ from .config.types import (
 
 __all__ = [
     "HypferMapImageHandler",
+    "ReImageHandler",
     "CameraShared",
     "CameraSharedManager",
     "ColorsManagment",

valetudo_map_parser/config/auto_crop.py

@@ -71,18 +71,18 @@ class AutoCrop:
         return trimmed_width, trimmed_height
 
     async def _async_auto_crop_data(self, tdata=None):
-        """Load the auto crop data from the disk."""
-
-        if not self.imh.auto_crop:
-            trims_data = TrimCropData.from_dict(dict(tdata)).to_list()
-            (
-                self.imh.trim_left,
-                self.imh.trim_up,
-                self.imh.trim_right,
-                self.imh.trim_down,
-            ) = trims_data
-            self._calculate_trimmed_dimensions()
-            return trims_data
+        """Load the auto crop data from the Camera config."""
+        # todo: implement this method but from config data
+        # if not self.imh.auto_crop:
+        #     trims_data = TrimCropData.from_dict(dict(tdata)).to_list()
+        #     (
+        #         self.imh.trim_left,
+        #         self.imh.trim_up,
+        #         self.imh.trim_right,
+        #         self.imh.trim_down,
+        #     ) = trims_data
+        #     self._calculate_trimmed_dimensions()
+        #     return trims_data
         return None
 
     def auto_crop_offset(self):

valetudo_map_parser/config/rand25_parser.py

@@ -0,0 +1,398 @@
+"""
+Version: v2024.08.2
+- This parser is the python version of @rand256 valetudo_mapper.
+- This class is extracting the vacuum binary map_data.
+- Additional functions are to get in our image_handler the images datas.
+"""
+
+from enum import Enum
+import math
+import struct
+from typing import Dict, List, Optional, Callable, TypeVar, Any
+
+_CallableT = TypeVar("_CallableT", bound=Callable[..., Any])
+
+
+def callback(func: _CallableT) -> _CallableT:
+    """Annotation to mark method as safe to call from within the event loop."""
+    setattr(func, "_hass_callback", True)  # Attach a custom attribute to the function
+    return func  # Return the function without modifying its behavior
+
+
+# noinspection PyTypeChecker
+class RRMapParser:
+    """Parse the map data from the Rand256 vacuum."""
+
+    def __init__(self):
+        self.map_data = None
+
+    class Tools:
+        """Tools for the RRMapParser."""
+
+        DIMENSION_PIXELS = 1024
+        DIMENSION_MM = 50 * 1024
+
+    class Types(Enum):
+        """Types of blocks in the RRMapParser."""
+
+        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
+        DIGEST = 1024
+
+    @staticmethod
+    def parse_block(
+        buf: bytes,
+        offset: int,
+        result: Optional[Dict[int, Any]] = None,
+        pixels: bool = False,
+    ) -> Dict[int, Any]:
+        """Parse a block of data from the map data."""
+        result = result or {}
+        if len(buf) <= offset:
+            return result
+
+        type_ = struct.unpack("<H", buf[offset : offset + 2])[0]
+        hlength = struct.unpack("<H", buf[offset + 2 : offset + 4])[0]
+        length = struct.unpack("<I", buf[offset + 4 : offset + 8])[0]
+
+        if type_ in (
+            RRMapParser.Types.ROBOT_POSITION.value,
+            RRMapParser.Types.CHARGER_LOCATION.value,
+        ):
+            result[type_] = {
+                "position": [
+                    int.from_bytes(buf[offset + 8 : offset + 10], byteorder="little"),
+                    int.from_bytes(buf[offset + 12 : offset + 14], byteorder="little"),
+                ],
+                "angle": (
+                    struct.unpack("<i", buf[offset + 16 : offset + 20])[0]
+                    if length >= 12
+                    else 0
+                ),
+            }
+        elif type_ == RRMapParser.Types.IMAGE.value:
+            RRMapParser._parse_image_block(buf, offset, length, hlength, result, pixels)
+        elif type_ in (
+            RRMapParser.Types.PATH.value,
+            RRMapParser.Types.GOTO_PATH.value,
+            RRMapParser.Types.GOTO_PREDICTED_PATH.value,
+        ):
+            result[type_] = RRMapParser._parse_path_block(buf, offset, length)
+        elif type_ == RRMapParser.Types.GOTO_TARGET.value:
+            result[type_] = {
+                "position": [
+                    struct.unpack("<H", buf[offset + 8 : offset + 10])[0],
+                    struct.unpack("<H", buf[offset + 10 : offset + 12])[0],
+                ]
+            }
+        elif type_ == RRMapParser.Types.CURRENTLY_CLEANED_ZONES.value:
+            result[type_] = RRMapParser._parse_cleaned_zones(buf, offset, length)
+        elif type_ in (
+            RRMapParser.Types.FORBIDDEN_ZONES.value,
+            RRMapParser.Types.FORBIDDEN_MOP_ZONES.value,
+            RRMapParser.Types.VIRTUAL_WALLS.value,
+        ):
+            result[type_] = RRMapParser._parse_forbidden_zones(buf, offset, length)
+        return RRMapParser.parse_block(buf, offset + length + hlength, result, pixels)
+
+    @staticmethod
+    def _parse_image_block(
+        buf: bytes,
+        offset: int,
+        length: int,
+        hlength: int,
+        result: Dict[int, Any],
+        pixels: bool,
+    ) -> None:
+        """Parse the image block of the map data."""
+        g3offset = 4 if hlength > 24 else 0
+        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": {}},
+        }
+        parameters["position"]["top"] = (
+            RRMapParser.Tools.DIMENSION_PIXELS
+            - parameters["position"]["top"]
+            - parameters["dimensions"]["height"]
+        )
+        if (
+            parameters["dimensions"]["height"] > 0
+            and parameters["dimensions"]["width"] > 0
+        ):
+            for i in range(length):
+                segment_type = (
+                    struct.unpack(
+                        "<B",
+                        buf[offset + 24 + g3offset + i : offset + 25 + g3offset + i],
+                    )[0]
+                    & 0x07
+                )
+                if segment_type == 0:
+                    continue
+                elif segment_type == 1 and pixels:
+                    parameters["pixels"]["walls"].append(i)
+                else:
+                    s = (
+                        struct.unpack(
+                            "<B",
+                            buf[
+                                offset + 24 + g3offset + i : offset + 25 + g3offset + i
+                            ],
+                        )[0]
+                        >> 3
+                    )
+                    if s == 0 and pixels:
+                        parameters["pixels"]["floor"].append(i)
+                    elif s != 0:
+                        if s not in parameters["segments"]["id"]:
+                            parameters["segments"]["id"].append(s)
+                            parameters["segments"]["pixels_seg_" + str(s)] = []
+                        if pixels:
+                            parameters["segments"]["pixels_seg_" + str(s)].append(i)
+        result[RRMapParser.Types.IMAGE.value] = parameters
+
+    @staticmethod
+    def _parse_path_block(buf: bytes, offset: int, length: int) -> Dict[str, Any]:
+        """Parse a path block of the map data."""
+        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_cleaned_zones(buf: bytes, offset: int, length: int) -> List[List[int]]:
+        """Parse the cleaned zones block of the map data."""
+        zone_count = struct.unpack("<I", buf[offset + 8 : offset + 12])[0]
+        return (
+            [
+                [
+                    struct.unpack("<H", buf[offset + 12 + i : offset + 14 + i])[0],
+                    struct.unpack("<H", buf[offset + 14 + i : offset + 16 + i])[0],
+                    struct.unpack("<H", buf[offset + 16 + i : offset + 18 + i])[0],
+                    struct.unpack("<H", buf[offset + 18 + i : offset + 20 + i])[0],
+                ]
+                for i in range(0, length, 8)
+            ]
+            if zone_count > 0
+            else []
+        )
+
+    @staticmethod
+    def _parse_forbidden_zones(buf: bytes, offset: int, length: int) -> List[List[int]]:
+        """Parse the forbidden zones block of the map data."""
+        zone_count = struct.unpack("<I", buf[offset + 8 : offset + 12])[0]
+        return (
+            [
+                [
+                    struct.unpack("<H", buf[offset + 12 + i : offset + 14 + i])[0],
+                    struct.unpack("<H", buf[offset + 14 + i : offset + 16 + i])[0],
+                    struct.unpack("<H", buf[offset + 16 + i : offset + 18 + i])[0],
+                    struct.unpack("<H", buf[offset + 18 + i : offset + 20 + i])[0],
+                    struct.unpack("<H", buf[offset + 20 + i : offset + 22 + i])[0],
+                    struct.unpack("<H", buf[offset + 22 + i : offset + 24 + i])[0],
+                    struct.unpack("<H", buf[offset + 24 + i : offset + 26 + i])[0],
+                    struct.unpack("<H", buf[offset + 26 + i : offset + 28 + i])[0],
+                ]
+                for i in range(0, length, 16)
+            ]
+            if zone_count > 0
+            else []
+        )
+
+    @callback
+    def parse(self, map_buf: bytes) -> Dict[str, Any]:
+        """Parse the map data."""
+        if map_buf[0:2] == b"rr":
+            return {
+                "header_length": struct.unpack("<H", map_buf[2:4])[0],
+                "data_length": struct.unpack("<H", map_buf[4:6])[0],
+                "version": {
+                    "major": struct.unpack("<H", map_buf[8:10])[0],
+                    "minor": struct.unpack("<H", map_buf[10:12])[0],
+                },
+                "map_index": struct.unpack("<H", map_buf[12:14])[0],
+                "map_sequence": struct.unpack("<H", map_buf[16:18])[0],
+            }
+        return {}
+
+    @callback
+    def parse_rrm_data(
+        self, map_buf: bytes, pixels: bool = False
+    ) -> Optional[Dict[str, Any]]:
+        """Parse the complete map data."""
+        if not self.parse(map_buf).get("map_index"):
+            return None
+
+        parsed_map_data = {}
+        blocks = self.parse_block(map_buf, 0x14, None, pixels)
+
+        if RRMapParser.Types.IMAGE.value in blocks:
+            parsed_map_data["image"] = blocks[RRMapParser.Types.IMAGE.value]
+            for item in [
+                {"type": RRMapParser.Types.PATH.value, "path": "path"},
+                {
+                    "type": RRMapParser.Types.GOTO_PREDICTED_PATH.value,
+                    "path": "goto_predicted_path",
+                },
+            ]:
+                if item["type"] in blocks:
+                    parsed_map_data[item["path"]] = blocks[item["type"]]
+                    parsed_map_data[item["path"]]["points"] = [
+                        [point[0], RRMapParser.Tools.DIMENSION_MM - point[1]]
+                        for point in parsed_map_data[item["path"]]["points"]
+                    ]
+                    if len(parsed_map_data[item["path"]]["points"]) >= 2:
+                        parsed_map_data[item["path"]]["current_angle"] = math.degrees(
+                            math.atan2(
+                                parsed_map_data[item["path"]]["points"][-1][1]
+                                - parsed_map_data[item["path"]]["points"][-2][1],
+                                parsed_map_data[item["path"]]["points"][-1][0]
+                                - parsed_map_data[item["path"]]["points"][-2][0],
+                            )
+                        )
+        if RRMapParser.Types.CHARGER_LOCATION.value in blocks:
+            charger = blocks[RRMapParser.Types.CHARGER_LOCATION.value]["position"]
+            # Assume no transformation needed here
+            parsed_map_data["charger"] = charger
+
+        if RRMapParser.Types.ROBOT_POSITION.value in blocks:
+            robot = blocks[RRMapParser.Types.ROBOT_POSITION.value]["position"]
+            rob_angle = blocks[RRMapParser.Types.ROBOT_POSITION.value]["angle"]
+            # Assume no transformation needed here
+            parsed_map_data["robot"] = robot
+            parsed_map_data["robot_angle"] = rob_angle
+
+        if RRMapParser.Types.GOTO_TARGET.value in blocks:
+            parsed_map_data["goto_target"] = blocks[
+                RRMapParser.Types.GOTO_TARGET.value
+            ]["position"]
+            # Assume no transformation needed here
+
+        if RRMapParser.Types.CURRENTLY_CLEANED_ZONES.value in blocks:
+            parsed_map_data["currently_cleaned_zones"] = blocks[
+                RRMapParser.Types.CURRENTLY_CLEANED_ZONES.value
+            ]
+            parsed_map_data["currently_cleaned_zones"] = [
+                [
+                    zone[0],
+                    RRMapParser.Tools.DIMENSION_MM - zone[1],
+                    zone[2],
+                    RRMapParser.Tools.DIMENSION_MM - zone[3],
+                ]
+                for zone in parsed_map_data["currently_cleaned_zones"]
+            ]
+
+        if RRMapParser.Types.FORBIDDEN_ZONES.value in blocks:
+            parsed_map_data["forbidden_zones"] = blocks[
+                RRMapParser.Types.FORBIDDEN_ZONES.value
+            ]
+            parsed_map_data["forbidden_zones"] = [
+                [
+                    zone[0],
+                    RRMapParser.Tools.DIMENSION_MM - zone[1],
+                    zone[2],
+                    RRMapParser.Tools.DIMENSION_MM - zone[3],
+                    zone[4],
+                    RRMapParser.Tools.DIMENSION_MM - zone[5],
+                    zone[6],
+                    RRMapParser.Tools.DIMENSION_MM - zone[7],
+                ]
+                for zone in parsed_map_data["forbidden_zones"]
+            ]
+
+        if RRMapParser.Types.VIRTUAL_WALLS.value in blocks:
+            parsed_map_data["virtual_walls"] = blocks[
+                RRMapParser.Types.VIRTUAL_WALLS.value
+            ]
+            parsed_map_data["virtual_walls"] = [
+                [
+                    wall[0],
+                    RRMapParser.Tools.DIMENSION_MM - wall[1],
+                    wall[2],
+                    RRMapParser.Tools.DIMENSION_MM - wall[3],
+                ]
+                for wall in parsed_map_data["virtual_walls"]
+            ]
+
+        if RRMapParser.Types.CURRENTLY_CLEANED_BLOCKS.value in blocks:
+            parsed_map_data["currently_cleaned_blocks"] = blocks[
+                RRMapParser.Types.CURRENTLY_CLEANED_BLOCKS.value
+            ]
+
+        if RRMapParser.Types.FORBIDDEN_MOP_ZONES.value in blocks:
+            parsed_map_data["forbidden_mop_zones"] = blocks[
+                RRMapParser.Types.FORBIDDEN_MOP_ZONES.value
+            ]
+            parsed_map_data["forbidden_mop_zones"] = [
+                [
+                    zone[0],
+                    RRMapParser.Tools.DIMENSION_MM - zone[1],
+                    zone[2],
+                    RRMapParser.Tools.DIMENSION_MM - zone[3],
+                    zone[4],
+                    RRMapParser.Tools.DIMENSION_MM - zone[5],
+                    zone[6],
+                    RRMapParser.Tools.DIMENSION_MM - zone[7],
+                ]
+                for zone in parsed_map_data["forbidden_mop_zones"]
+            ]
+
+        return parsed_map_data
+
+    def parse_data(
+        self, payload: Optional[bytes] = None, pixels: bool = False
+    ) -> Optional[Dict[str, Any]]:
+        """Get the map data from MQTT and return the json."""
+        if payload:
+            self.map_data = self.parse(payload)
+            self.map_data.update(self.parse_rrm_data(payload, pixels) or {})
+        return self.map_data
+
+    def get_image(self) -> Dict[str, Any]:
+        """Get the image data from the map data."""
+        return self.map_data.get("image", {})
+
+    @staticmethod
+    def get_int32(data: bytes, address: int) -> int:
+        """Get a 32-bit integer from the data."""
+        return struct.unpack_from("<i", data, address)[0]

valetudo_map_parser/hypfer_handler.py

@@ -66,10 +66,10 @@ class HypferMapImageHandler:
         self.max_frames = 1024
         self.zooming = False  # zooming the image.
         self.svg_wait = False  # SVG image creation wait.
-        self.trim_down = None  # memory stored trims calculated once.
-        self.trim_left = None  # memory stored trims calculated once.
-        self.trim_right = None  # memory stored trims calculated once.
-        self.trim_up = None  # memory stored trims calculated once.
+        self.trim_down = 0  # memory stored trims calculated once.
+        self.trim_left = 0  # memory stored trims calculated once.
+        self.trim_right = 0  # memory stored trims calculated once.
+        self.trim_up = 0  # memory stored trims calculated once.
         self.offset_top = self.shared.offset_top  # offset top
         self.offset_bottom = self.shared.offset_down  # offset bottom
         self.offset_left = self.shared.offset_left  # offset left

valetudo_map_parser/map_data.py

@@ -3,12 +3,11 @@ Collections of Json and List routines
 ImageData is part of the Image_Handler
 used functions to search data in the json
 provided for the creation of the new camera frame
-Version: v2024.08.0
+Version: v0.1.6
 """
 
 from __future__ import annotations
 
-from typing import Any
 import numpy as np
 
 from .config.types import (
@@ -186,7 +185,7 @@ class ImageData:
             if rand:
                 x, y, _ = entry  # Extract x and y coordinates
                 max_x = max(max_x, x)  # Update max x coordinate
-                max_y = max(max_y, y)  # Update max y coordinate
+                max_y = max(max_y, y + pixel_size)  # Update max y coordinate
                 min_x = min(min_x, x)  # Update min x coordinate
                 min_y = min(min_y, y)  # Update min y coordinate
             else:
@@ -227,7 +226,7 @@ class ImageData:
         compressed_pixels = []
 
         tot_pixels = 0
-        current_x, current_y, count = None, None, 0  # pylint: disable=unused-variable
+        current_x, current_y, count = None, None, 0
         for index in pixel_data:
             x = (index % image_width) + image_left
             y = ((image_height - 1) - (index // image_width)) + image_top