valetudo-map-parser 0.1.10rc6__py3-none-any.whl → 0.1.10rc7__py3-none-any.whl

valetudo_map_parser/config/rand256_parser.py

@@ -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,19 @@ 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_path_block(buf: bytes, offset: int, length: int) -> Dict[str, Any]:
         """Parse path block using EXACT same method as working parser."""
@@ -127,59 +204,45 @@ 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)
-
-                # 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)
-                )
-
+                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)
+
+                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 +428,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 +475,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

@@ -12,12 +12,13 @@ from PIL import Image
 from .types import (
     ATTR_CALIBRATION_POINTS,
     ATTR_CAMERA_MODE,
+    ATTR_CONTENT_TYPE,
     ATTR_MARGINS,
     ATTR_OBSTACLES,
     ATTR_POINTS,
     ATTR_ROOMS,
     ATTR_ROTATE,
-    ATTR_SNAPSHOT,
+    ATTR_IMAGE_LAST_UPDATED,
     ATTR_VACUUM_BATTERY,
     ATTR_VACUUM_CHARGING,
     ATTR_VACUUM_JSON_ID,
@@ -179,12 +180,14 @@ 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_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:
@@ -193,8 +196,6 @@ class CameraShared:
             )
             attrs[ATTR_OBSTACLES] = self.obstacles_data
 
-        attrs[ATTR_SNAPSHOT] = self.snapshot_take if self.enable_snapshots else False
-
         shared_attrs = {
             ATTR_ROOMS: self.map_rooms,
             ATTR_ZONES: self.map_pred_zones,
@@ -211,10 +212,8 @@ class CameraShared:
         return {
             "image": {
                 "binary": self.binary_image,
-                "pil_image_size": self.new_image.size,
-                "size": self.new_image.size if self.new_image else None,
-                "format": self.image_format,
-                "updated": self.image_last_updated,
+                "pil_image": self.new_image,
+                "size": self.new_image.size if self.new_image else (10, 10),
             },
             "attributes": self.generate_attributes(),
         }

valetudo_map_parser/config/types.py

@@ -18,23 +18,29 @@ DEFAULT_ROOMS = 1
 
 LOGGER = logging.getLogger(__package__)
 
+
 class Spot(TypedDict):
     name: str
     coordinates: List[int]  # [x, y]
 
+
 class Zone(TypedDict):
     name: str
     coordinates: List[List[int]]  # [[x1, y1, x2, y2, repeats], ...]
 
+
 class Room(TypedDict):
     name: str
     id: int
 
+
+# list[dict[str, str | list[int]]] | list[dict[str, str | list[list[int]]]] | list[dict[str, str | int]] | int]'
 class Destinations(TypedDict, total=False):
     spots: NotRequired[Optional[List[Spot]]]
     zones: NotRequired[Optional[List[Zone]]]
     rooms: NotRequired[Optional[List[Room]]]
-    updated: NotRequired[Optional[int]]
+    updated: NotRequired[Optional[float]]
+
 
 class RoomProperty(TypedDict):
     number: int
@@ -227,9 +233,11 @@ NumpyArray = np.ndarray
 Point = Tuple[int, int]
 
 CAMERA_STORAGE = "valetudo_camera"
+ATTR_IMAGE_LAST_UPDATED = "image_last_updated"
 ATTR_ROTATE = "rotate_image"
 ATTR_CROP = "crop_image"
 ATTR_MARGINS = "margins"
+ATTR_CONTENT_TYPE = "content_type"
 CONF_OFFSET_TOP = "offset_top"
 CONF_OFFSET_BOTTOM = "offset_bottom"
 CONF_OFFSET_LEFT = "offset_left"

valetudo_map_parser/config/utils.py

@@ -23,7 +23,7 @@ from .types import (
     NumpyArray,
     PilPNG,
     RobotPosition,
-    Destinations
+    Destinations,
 )
 from ..map_data import HyperMapData
 from .async_utils import AsyncNumPy
@@ -197,26 +197,27 @@ class BaseHandler:
         """Update the shared data with the latest information."""
 
         if hasattr(self, "get_rooms_attributes") and (
-                self.shared.map_rooms is None and destinations is not None
+            self.shared.map_rooms is None and destinations is not None
         ):
-            (
-                self.shared.map_rooms,
-                self.shared.map_pred_zones,
-                self.shared.map_pred_points,
-            ) = await self.get_rooms_attributes(destinations)
+            (self.shared.map_rooms,) = await self.get_rooms_attributes(destinations)
             if self.shared.map_rooms:
                 LOGGER.debug("%s: Rand256 attributes rooms updated", self.file_name)
 
         if hasattr(self, "async_get_rooms_attributes") and (
-                self.shared.map_rooms is None
+            self.shared.map_rooms is None
         ):
             if self.shared.map_rooms is None:
                 self.shared.map_rooms = await self.async_get_rooms_attributes()
                 if self.shared.map_rooms:
                     LOGGER.debug("%s: Hyper attributes rooms updated", self.file_name)
 
-        if hasattr(self, "get_calibration_data") and self.shared.attr_calibration_points is None:
-            self.shared.attr_calibration_points = self.get_calibration_data(self.shared.image_rotate)
+        if (
+            hasattr(self, "get_calibration_data")
+            and self.shared.attr_calibration_points is None
+        ):
+            self.shared.attr_calibration_points = self.get_calibration_data(
+                self.shared.image_rotate
+            )
 
         if not self.shared.image_size:
             self.shared.image_size = self.get_img_size()
@@ -228,14 +229,19 @@ class BaseHandler:
 
         self.shared.current_room = self.get_robot_position()
 
-    def prepare_resize_params(self, pil_img: PilPNG, rand: bool=False) -> ResizeParams:
+    def prepare_resize_params(
+        self, pil_img: PilPNG, rand: bool = False
+    ) -> ResizeParams:
         """Prepare resize parameters for image resizing."""
         if self.shared.image_rotate in [0, 180]:
             width, height = pil_img.size
         else:
             height, width = pil_img.size
-        LOGGER.debug("Shared PIL image size: %s x %s", self.shared.image_ref_width,
-                     self.shared.image_ref_height)
+        LOGGER.debug(
+            "Shared PIL image size: %s x %s",
+            self.shared.image_ref_width,
+            self.shared.image_ref_height,
+        )
         return ResizeParams(
             pil_img=pil_img,
             width=width,

valetudo_map_parser/hypfer_handler.py

@@ -14,7 +14,6 @@ from PIL import Image
 
 from .config.async_utils import AsyncPIL
 
-# from .config.auto_crop import AutoCrop
 from mvcrender.autocrop import AutoCrop
 from .config.drawable_elements import DrawableElement
 from .config.shared import CameraShared
@@ -60,7 +59,6 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
             None  # persistent working buffer to avoid per-frame allocations
         )
         self.active_zones = []  # vacuum active zones.
-        self.svg_wait = False  # SVG image creation wait.
         self.imd = ImDraw(self)  # Image Draw class.
         self.color_grey = (128, 128, 128, 255)
         self.file_name = self.shared.file_name  # file name of the vacuum.
@@ -362,7 +360,7 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                 self.zooming = self.imd.img_h.zooming
 
                 # Resize the image
-                img_np_array = self.async_auto_trim_and_zoom_image(
+                img_np_array = self.auto_trim_and_zoom_image(
                     img_np_array,
                     colors["background"],
                     int(self.shared.margins),

valetudo_map_parser/map_data.py

@@ -539,16 +539,17 @@ class RandImageData:
         return None
 
     @staticmethod
-    def get_rrm_currently_cleaned_zones(json_data: JsonType) -> dict:
+    def get_rrm_currently_cleaned_zones(json_data: JsonType) -> list[dict[str, Any]]:
         """Get the currently cleaned zones from the json."""
         re_zones = json_data.get("currently_cleaned_zones", [])
         formatted_zones = RandImageData._rrm_valetudo_format_zone(re_zones)
         return formatted_zones
 
     @staticmethod
-    def get_rrm_forbidden_zones(json_data: JsonType) -> dict:
+    def get_rrm_forbidden_zones(json_data: JsonType) -> list[dict[str, Any]]:
         """Get the forbidden zones from the json."""
         re_zones = json_data.get("forbidden_zones", [])
+        re_zones.extend(json_data.get("forbidden_mop_zones", []))
         formatted_zones = RandImageData._rrm_valetudo_format_zone(re_zones)
         return formatted_zones
 

valetudo_map_parser/rand256_handler.py

@@ -7,7 +7,6 @@ Version: 0.1.9.a6
 
 from __future__ import annotations
 
-import logging
 import uuid
 from typing import Any
 
@@ -15,7 +14,6 @@ import numpy as np
 
 from .config.async_utils import AsyncPIL
 
-# from .config.auto_crop import AutoCrop
 from mvcrender.autocrop import AutoCrop
 from .config.drawable_elements import DrawableElement
 from .config.types import (
@@ -28,6 +26,7 @@ from .config.types import (
     RobotPosition,
     RoomsProperties,
     RoomStore,
+    LOGGER,
 )
 from .config.utils import (
     BaseHandler,
@@ -39,9 +38,6 @@ from .reimg_draw import ImageDraw
 from .rooms_handler import RandRoomsHandler
 
 
-_LOGGER = logging.getLogger(__name__)
-
-
 # noinspection PyTypeChecker
 class ReImageHandler(BaseHandler, AutoCrop):
     """
@@ -112,17 +108,17 @@ class ReImageHandler(BaseHandler, AutoCrop):
             self.shared.map_rooms = room_ids
 
             # get the zones and points data
-            zone_properties = await self.async_zone_propriety(zones_data)
+            self.shared.map_pred_zones = await self.async_zone_propriety(zones_data)
             # get the points data
-            point_properties = await self.async_points_propriety(points_data)
+            self.shared.map_pred_points = await self.async_points_propriety(points_data)
 
-            if not (room_properties or zone_properties):
+            if not (room_properties or self.shared.map_pred_zones):
                 self.rooms_pos = None
 
             rooms = RoomStore(self.file_name, room_properties)
-            return room_properties, zone_properties, point_properties
+            return room_properties
         except (RuntimeError, ValueError) as e:
-            _LOGGER.warning(
+            LOGGER.warning(
                 "No rooms Data or Error in extract_room_properties: %s",
                 e,
                 exc_info=True,
@@ -146,12 +142,12 @@ class ReImageHandler(BaseHandler, AutoCrop):
 
         try:
             if (m_json is not None) and (not isinstance(m_json, tuple)):
-                _LOGGER.info("%s: Composing the image for the camera.", self.file_name)
+                LOGGER.info("%s: Composing the image for the camera.", self.file_name)
                 self.json_data = m_json
                 size_x, size_y = self.data.get_rrm_image_size(m_json)
                 self.img_size = DEFAULT_IMAGE_SIZE
                 self.json_id = str(uuid.uuid4())  # image id
-                _LOGGER.info("Vacuum Data ID: %s", self.json_id)
+                LOGGER.info("Vacuum Data ID: %s", self.json_id)
 
                 (
                     img_np_array,
@@ -178,7 +174,7 @@ class ReImageHandler(BaseHandler, AutoCrop):
                 return await self._finalize_image(pil_img)
 
         except (RuntimeError, RuntimeWarning) as e:
-            _LOGGER.warning(
+            LOGGER.warning(
                 "%s: Runtime Error %s during image creation.",
                 self.file_name,
                 str(e),
@@ -214,7 +210,7 @@ class ReImageHandler(BaseHandler, AutoCrop):
                     colors["background"],
                     DEFAULT_PIXEL_SIZE,
                 )
-                _LOGGER.info("%s: Completed base Layers", self.file_name)
+                LOGGER.info("%s: Completed base Layers", self.file_name)
 
                 # Update element map for rooms
                 if 0 < room_id <= 15:
@@ -350,7 +346,7 @@ class ReImageHandler(BaseHandler, AutoCrop):
             else:
                 self.zooming = False
 
-        img_np_array = self.async_auto_trim_and_zoom_image(
+        img_np_array = self.auto_trim_and_zoom_image(
             img_np_array,
             detect_colour=colors["background"],
             margin_size=int(self.shared.margins),
@@ -362,7 +358,7 @@ class ReImageHandler(BaseHandler, AutoCrop):
 
     async def _finalize_image(self, pil_img):
         if not self.shared.image_ref_width or not self.shared.image_ref_height:
-            _LOGGER.warning(
+            LOGGER.warning(
                 "Image finalization failed: Invalid image dimensions. Returning original image."
             )
             return pil_img
@@ -515,7 +511,7 @@ class ReImageHandler(BaseHandler, AutoCrop):
         """Return the map calibration data."""
         if not self.calibration_data and self.crop_img_size:
             self.calibration_data = []
-            _LOGGER.info(
+            LOGGER.info(
                 "%s: Getting Calibrations points %s",
                 self.file_name,
                 str(self.crop_area),

valetudo_map_parser/reimg_draw.py

@@ -6,17 +6,12 @@ Version: 0.1.9.b42
 
 from __future__ import annotations
 
-import logging
-
 from .config.drawable import Drawable
 from .config.drawable_elements import DrawableElement
-from .config.types import Color, JsonType, NumpyArray
+from .config.types import Color, JsonType, NumpyArray, LOGGER
 from .map_data import ImageData, RandImageData
 
 
-_LOGGER = logging.getLogger(__name__)
-
-
 class ImageDraw:
     """Class to handle the image creation."""
 
@@ -48,7 +43,7 @@ class ImageDraw:
                     )
             return np_array
         except KeyError as e:
-            _LOGGER.warning(
+            LOGGER.warning(
                 "%s: Error in extraction of go-to target: %s",
                 self.file_name,
                 e,
@@ -70,7 +65,7 @@ class ImageDraw:
                 )
         except ValueError as e:
             self.img_h.segment_data = None
-            _LOGGER.info("%s: No segments data found: %s", self.file_name, e)
+            LOGGER.info("%s: No segments data found: %s", self.file_name, e)
 
     async def async_draw_base_layer(
         self,
@@ -87,13 +82,13 @@ class ImageDraw:
         walls_data = self.data.get_rrm_walls(m_json)
         floor_data = self.data.get_rrm_floor(m_json)
 
-        _LOGGER.info("%s: Empty image with background color", self.file_name)
+        LOGGER.info("%s: Empty image with background color", self.file_name)
         img_np_array = await self.draw.create_empty_image(
             self.img_h.img_size["x"], self.img_h.img_size["y"], color_background
         )
         room_id = 0
         if self.img_h.frame_number == 0:
-            _LOGGER.info("%s: Overlapping Layers", self.file_name)
+            LOGGER.info("%s: Overlapping Layers", self.file_name)
 
             # checking if there are segments too (sorted pixels in the raw data).
             await self.async_segment_data(m_json, size_x, size_y, pos_top, pos_left)
@@ -148,10 +143,10 @@ class ImageDraw:
         room_id = 0
         rooms_list = [color_wall]
         if not segment_data:
-            _LOGGER.info("%s: No segments data found.", self.file_name)
+            LOGGER.info("%s: No segments data found.", self.file_name)
             return room_id, img_np_array
 
-        _LOGGER.info("%s: Drawing segments.", self.file_name)
+        LOGGER.info("%s: Drawing segments.", self.file_name)
         for pixels in segment_data:
             room_color = self.img_h.shared.rooms_colors[room_id]
             rooms_list.append(room_color)
@@ -211,7 +206,7 @@ class ImageDraw:
                 self.data.get_rrm_charger_position(m_json)
             )
         except KeyError as e:
-            _LOGGER.warning("%s: No charger position found: %s", self.file_name, e)
+            LOGGER.warning("%s: No charger position found: %s", self.file_name, e)
         else:
             if charger_pos:
                 charger_pos_dictionary = {
@@ -238,7 +233,7 @@ class ImageDraw:
             zone_clean = None
 
         if zone_clean:
-            _LOGGER.info("%s: Got zones.", self.file_name)
+            LOGGER.info("%s: Got zones.", self.file_name)
             return await self.draw.zones(np_array, zone_clean, color_zone_clean)
         return np_array
 
@@ -252,7 +247,7 @@ class ImageDraw:
             virtual_walls = None
 
         if virtual_walls:
-            _LOGGER.info("%s: Got virtual walls.", self.file_name)
+            LOGGER.info("%s: Got virtual walls.", self.file_name)
             np_array = await self.draw.draw_virtual_walls(
                 np_array, virtual_walls, color_no_go
             )
@@ -280,7 +275,7 @@ class ImageDraw:
                 self.data.rrm_valetudo_path_array(path_pixel["points"]), 2
             )
         except KeyError as e:
-            _LOGGER.warning(
+            LOGGER.warning(
                 "%s: Error extracting paths data: %s", self.file_name, str(e)
             )
         finally:
@@ -297,7 +292,7 @@ class ImageDraw:
         except (ValueError, KeyError):
             entity_dict = None
         else:
-            _LOGGER.info("%s: Got the points in the json.", self.file_name)
+            LOGGER.info("%s: Got the points in the json.", self.file_name)
         return entity_dict
 
     async def async_get_robot_position(self, m_json: JsonType) -> tuple | None:
@@ -310,7 +305,7 @@ class ImageDraw:
             robot_pos = self.data.rrm_coordinates_to_valetudo(robot_pos_data)
             angle = self.data.get_rrm_robot_angle(m_json)
         except (ValueError, KeyError):
-            _LOGGER.warning("%s No robot position found.", self.file_name)
+            LOGGER.warning("%s No robot position found.", self.file_name)
             return None, None, None
         finally:
             robot_position_angle = round(angle[0], 0)

{valetudo_map_parser-0.1.10rc6.dist-info → valetudo_map_parser-0.1.10rc7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: valetudo-map-parser
-Version: 0.1.10rc6
+Version: 0.1.10rc7
 Summary: A Python library to parse Valetudo map data returning a PIL Image object.
 License: Apache-2.0
 License-File: LICENSE
@@ -13,7 +13,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: Pillow (>=10.3.0)
-Requires-Dist: mvcrender (>=0.0.2)
+Requires-Dist: mvcrender (>=0.0.4)
 Requires-Dist: numpy (>=1.26.4)
 Requires-Dist: scipy (>=1.12.0)
 Project-URL: Bug Tracker, https://github.com/sca075/Python-package-valetudo-map-parser/issues

{valetudo_map_parser-0.1.10rc6.dist-info → valetudo_map_parser-0.1.10rc7.dist-info}/RECORD

@@ -15,22 +15,21 @@ valetudo_map_parser/config/fonts/NotoKufiArabic-VF.ttf,sha256=NaIy40eLx7d3ts0kue
 valetudo_map_parser/config/fonts/NotoSansCJKhk-VF.ttf,sha256=xIXXLKCJzmWoPEg8HdvxeRgotMjjxF6l6ugGP-IWRJU,36135040
 valetudo_map_parser/config/fonts/NotoSansKhojki.ttf,sha256=XJWzSmpN-Ql6jTfTvFojP_JkCHOztQvixQc1_7hPWrc,107388
 valetudo_map_parser/config/optimized_element_map.py,sha256=52BCnkvVv9bre52LeVIfT8nhnEIpc0TuWTv1xcNu0Rk,15744
-valetudo_map_parser/config/rand256_parser.py,sha256=LU3y7XvRRQxVen9iwom0dOaDnJJvhZdg97NqOYRZFas,16279
-valetudo_map_parser/config/shared.py,sha256=dp_KOhwfLx16-C8c8tdWjYllUrfAhNtQqP7i2ziNEaI,11834
+valetudo_map_parser/config/rand256_parser.py,sha256=jsUiuShrNY3UpgfdEMgmTJjH6fj-lC-0y2TdIt43aG0,20161
+valetudo_map_parser/config/shared.py,sha256=58R6kaYl7RF0ESTIKarVy8pB1jo4LUlPHTb27_ubZFo,11789
 valetudo_map_parser/config/status_text/status_text.py,sha256=PaynYW11vXH_vhDxhZrR9j-xeDrCxbB6YQQtN-kcaxQ,4052
 valetudo_map_parser/config/status_text/translations.py,sha256=mmPbJkl_2A59w49wnesQf3ocXqwZxBsrqNX-yt5FSCQ,9132
-valetudo_map_parser/config/types.py,sha256=tT5gTgH_HSl011UWfmXIcIQd1yZDAtDPHiZXUX0D6q0,17865
-valetudo_map_parser/config/utils.py,sha256=EzpW6WDTFadIDXyyCVTTTwWTGE1z4h8i3YAnpZ7_xCw,38676
+valetudo_map_parser/config/types.py,sha256=vSJjEsosbx9ZaM_JEuqhdzFIHnf97bfzDBMvx_V3U0s,18067
+valetudo_map_parser/config/utils.py,sha256=sk6Vy3_QpJhX9Hvb6S36Womyu0n8bfxWejfuNEaEM-I,38658
 valetudo_map_parser/hypfer_draw.py,sha256=4zajujSOvtpRI_GMlmlioM3mDo19MvuOP861LhZmVlw,22495
-valetudo_map_parser/hypfer_handler.py,sha256=50G6WrSJ0x8h6qzb6AOlgOdpSYUFCbMw3gxX44MckoI,20582
-valetudo_map_parser/hypfer_rooms_handler.py,sha256=NkpOA6Gdq-2D3lLAxvtNuuWMvPXHxeMY2TO5RZLSHlU,22652
-valetudo_map_parser/map_data.py,sha256=3xsaR-a3-qX3voXERJdxur9LUCZkfdme-5da04Sy_pw,27257
+valetudo_map_parser/hypfer_handler.py,sha256=8g2zitibQkgVh-crqDO41kp1DQzZaMMixUdFqgPjfis,20477
+valetudo_map_parser/map_data.py,sha256=OSscuvlYpAZ9q7pfjzIjh98UvT0PV8zjPk5eUEwmLb8,27355
 valetudo_map_parser/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-valetudo_map_parser/rand256_handler.py,sha256=tWTxWef-FTIs4XaEy7W-m88ABQYC8xPZUZFrBBCE2Rk,21603
-valetudo_map_parser/reimg_draw.py,sha256=a93UPwcVl5y9mXMY5DsNWD4_pXzm1QhC_n_WOokhEAE,12534
+valetudo_map_parser/rand256_handler.py,sha256=jpbvhNr2tm6Gp1Xs7yMMLwjCN1dOnNUtED7MrjnH4Os,21504
+valetudo_map_parser/reimg_draw.py,sha256=tDQGMDTYprgPZjETxws3rzgVfpPxm_K-armzYFyGzGw,12474
 valetudo_map_parser/rooms_handler.py,sha256=tE8BrXcdL0SeFAYsdFvjR3NVDfDi2RPKnXw9jD1e5k8,17494
-valetudo_map_parser-0.1.10rc6.dist-info/METADATA,sha256=eMz1nSvJb1DuKK8LVQlh2tjouOXHUpY3coDKq8-QZ2w,3404
-valetudo_map_parser-0.1.10rc6.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-valetudo_map_parser-0.1.10rc6.dist-info/licenses/LICENSE,sha256=Lh-qBbuRV0-jiCIBhfV7NgdwFxQFOXH3BKOzK865hRs,10480
-valetudo_map_parser-0.1.10rc6.dist-info/licenses/NOTICE.txt,sha256=5lTOuWiU9aiEnJ2go8sc7lTJ7ntMBx0g0GFnNrswCY4,2533
-valetudo_map_parser-0.1.10rc6.dist-info/RECORD,,
+valetudo_map_parser-0.1.10rc7.dist-info/METADATA,sha256=NPYlwO902_zvejWWjfzzjOkTVyn_CoquAG9zs1cRG0E,3404
+valetudo_map_parser-0.1.10rc7.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+valetudo_map_parser-0.1.10rc7.dist-info/licenses/LICENSE,sha256=Lh-qBbuRV0-jiCIBhfV7NgdwFxQFOXH3BKOzK865hRs,10480
+valetudo_map_parser-0.1.10rc7.dist-info/licenses/NOTICE.txt,sha256=5lTOuWiU9aiEnJ2go8sc7lTJ7ntMBx0g0GFnNrswCY4,2533
+valetudo_map_parser-0.1.10rc7.dist-info/RECORD,,

valetudo_map_parser/hypfer_rooms_handler.py

@@ -1,599 +0,0 @@
-"""
-Hipfer Rooms Handler Module.
-Handles room data extraction and processing for Valetudo Hipfer vacuum maps.
-Provides async methods for room outline extraction and properties management.
-Version: 0.1.9
-"""
-
-from __future__ import annotations
-
-from math import sqrt
-from typing import Any, Dict, Optional, List, Tuple
-
-import numpy as np
-
-from .config.drawable_elements import DrawableElement, DrawingConfig
-from .config.types import LOGGER, RoomsProperties, RoomStore
-
-
-class HypferRoomsHandler:
-    """
-    Handler for extracting and managing room data from Hipfer vacuum maps.
-
-    This class provides methods to:
-    - Extract room outlines using the Ramer-Douglas-Peucker algorithm
-    - Process room properties from JSON data
-    - Generate room masks and extract contours
-
-    All methods are async for better integration with the rest of the codebase.
-    """
-
-    def __init__(self, vacuum_id: str, drawing_config: Optional[DrawingConfig] = None):
-        """
-        Initialize the HipferRoomsHandler.
-
-        Args:
-            vacuum_id: Identifier for the vacuum
-            drawing_config: Configuration for which elements to draw (optional)
-        """
-        self.vacuum_id = vacuum_id
-        self.drawing_config = drawing_config
-        self.current_json_data = None  # Will store the current JSON data being processed
-
-    @staticmethod
-    def sublist(data: list, chunk_size: int) -> list:
-        return [data[i : i + chunk_size] for i in range(0, len(data), chunk_size)]
-
-    # Cache for RDP results
-    _rdp_cache = {}
-
-    @staticmethod
-    def perpendicular_distance(
-        point: tuple[int, int], line_start: tuple[int, int], line_end: tuple[int, int]
-    ) -> float:
-        """Calculate the perpendicular distance from a point to a line.
-        Optimized for performance.
-        """
-        # Fast path for point-to-point distance
-        if line_start == line_end:
-            dx = point[0] - line_start[0]
-            dy = point[1] - line_start[1]
-            return sqrt(dx*dx + dy*dy)
-
-        x, y = point
-        x1, y1 = line_start
-        x2, y2 = line_end
-
-        # Precompute differences for efficiency
-        dx = x2 - x1
-        dy = y2 - y1
-
-        # Calculate the line length squared (avoid sqrt until needed)
-        line_length_sq = dx*dx + dy*dy
-        if line_length_sq == 0:
-            return 0
-
-        # Calculate the distance from the point to the line
-        # Using the formula: |cross_product| / |line_vector|
-        # This is more efficient than the original formula
-        cross_product = abs(dy * x - dx * y + x2 * y1 - y2 * x1)
-        return cross_product / sqrt(line_length_sq)
-
-    async def rdp(
-        self, points: List[Tuple[int, int]], epsilon: float
-    ) -> List[Tuple[int, int]]:
-        """Ramer-Douglas-Peucker algorithm for simplifying a curve.
-        Optimized with caching and better performance.
-        """
-        # Create a hashable key for caching
-        # Convert points to a tuple for hashing
-        points_tuple = tuple(points)
-        cache_key = (points_tuple, epsilon)
-
-        # Check cache first
-        if cache_key in self._rdp_cache:
-            return self._rdp_cache[cache_key]
-
-        # Base case
-        if len(points) <= 2:
-            return points
-
-        # For very small point sets, process directly without recursion
-        if len(points) <= 5:
-            # Find the point with the maximum distance
-            dmax = 0
-            index = 0
-            for i in range(1, len(points) - 1):
-                d = self.perpendicular_distance(points[i], points[0], points[-1])
-                if d > dmax:
-                    index = i
-                    dmax = d
-
-            # If max distance is greater than epsilon, keep the point
-            if dmax > epsilon:
-                result = [points[0]] + [points[index]] + [points[-1]]
-            else:
-                result = [points[0], points[-1]]
-
-            # Cache and return
-            self._rdp_cache[cache_key] = result
-            return result
-
-        # For larger point sets, use numpy for faster distance calculation
-        if len(points) > 20:
-            # Convert to numpy arrays for vectorized operations
-            points_array = np.array(points)
-            start = points_array[0]
-            end = points_array[-1]
-
-            # Calculate perpendicular distances in one vectorized operation
-            line_vector = end - start
-            line_length = np.linalg.norm(line_vector)
-
-            if line_length == 0:
-                # If start and end are the same, use direct distance
-                distances = np.linalg.norm(points_array[1:-1] - start, axis=1)
-            else:
-                # Normalize line vector
-                line_vector = line_vector / line_length
-                # Calculate perpendicular distances using vector operations
-                vectors_to_points = points_array[1:-1] - start
-                # Project vectors onto line vector
-                projections = np.dot(vectors_to_points, line_vector)
-                # Calculate projected points on line
-                projected_points = start + np.outer(projections, line_vector)
-                # Calculate distances from points to their projections
-                distances = np.linalg.norm(points_array[1:-1] - projected_points, axis=1)
-
-            # Find the point with maximum distance
-            if len(distances) > 0:
-                max_idx = np.argmax(distances)
-                dmax = distances[max_idx]
-                index = max_idx + 1  # +1 because we skipped the first point
-            else:
-                dmax = 0
-                index = 0
-        else:
-            # For medium-sized point sets, use the original algorithm
-            dmax = 0
-            index = 0
-            for i in range(1, len(points) - 1):
-                d = self.perpendicular_distance(points[i], points[0], points[-1])
-                if d > dmax:
-                    index = i
-                    dmax = d
-
-        # If max distance is greater than epsilon, recursively simplify
-        if dmax > epsilon:
-            # Recursive call
-            first_segment = await self.rdp(points[: index + 1], epsilon)
-            second_segment = await self.rdp(points[index:], epsilon)
-
-            # Build the result list (avoiding duplicating the common point)
-            result = first_segment[:-1] + second_segment
-        else:
-            result = [points[0], points[-1]]
-
-        # Limit cache size
-        if len(self._rdp_cache) > 100:  # Keep only 100 most recent items
-            try:
-                self._rdp_cache.pop(next(iter(self._rdp_cache)))
-            except (StopIteration, KeyError):
-                pass
-
-        # Cache the result
-        self._rdp_cache[cache_key] = result
-        return result
-
-    # Cache for corner results
-    _corners_cache = {}
-
-    async def async_get_corners(
-        self, mask: np.ndarray, epsilon_factor: float = 0.05
-    ) -> List[Tuple[int, int]]:
-        """
-        Get the corners of a room shape as a list of (x, y) tuples.
-        Uses contour detection and Douglas-Peucker algorithm to simplify the contour.
-        Optimized with caching and faster calculations.
-
-        Args:
-            mask: Binary mask of the room (1 for room, 0 for background)
-            epsilon_factor: Controls the level of simplification (higher = fewer points)
-
-        Returns:
-            List of (x, y) tuples representing the corners of the room
-        """
-        # Create a hash of the mask and epsilon factor for caching
-        mask_hash = hash((mask.tobytes(), epsilon_factor))
-
-        # Check if we have a cached result
-        if mask_hash in self._corners_cache:
-            return self._corners_cache[mask_hash]
-
-        # Fast path for empty masks
-        if not np.any(mask):
-            return []
-
-        # Find contours in the mask - this uses our optimized method with caching
-        contour = await self.async_moore_neighbor_trace(mask)
-
-        if not contour:
-            # Fallback to bounding box if contour detection fails
-            y_indices, x_indices = np.where(mask > 0)
-            if len(x_indices) == 0 or len(y_indices) == 0:
-                return []
-
-            x_min, x_max = np.min(x_indices), np.max(x_indices)
-            y_min, y_max = np.min(y_indices), np.max(y_indices)
-
-            result = [
-                (x_min, y_min),  # Top-left
-                (x_max, y_min),  # Top-right
-                (x_max, y_max),  # Bottom-right
-                (x_min, y_max),  # Bottom-left
-                (x_min, y_min),  # Back to top-left to close the polygon
-            ]
-
-            # Cache the result
-            self._corners_cache[mask_hash] = result
-            return result
-
-        # For small contours (less than 10 points), skip simplification
-        if len(contour) <= 10:
-            # Ensure the contour is closed
-            if contour[0] != contour[-1]:
-                contour.append(contour[0])
-
-            # Cache and return
-            self._corners_cache[mask_hash] = contour
-            return contour
-
-        # For larger contours, calculate perimeter more efficiently using numpy
-        points = np.array(contour)
-        # Calculate differences between consecutive points
-        diffs = np.diff(points, axis=0)
-        # Calculate squared distances
-        squared_dists = np.sum(diffs**2, axis=1)
-        # Calculate perimeter as sum of distances
-        perimeter = np.sum(np.sqrt(squared_dists))
-
-        # Apply Douglas-Peucker algorithm to simplify the contour
-        epsilon = epsilon_factor * perimeter
-        simplified_contour = await self.rdp(contour, epsilon=epsilon)
-
-        # Ensure the contour has at least 3 points to form a polygon
-        if len(simplified_contour) < 3:
-            # Fallback to bounding box
-            y_indices, x_indices = np.where(mask > 0)
-            x_min, x_max = int(np.min(x_indices)), int(np.max(x_indices))
-            y_min, y_max = int(np.min(y_indices)), int(np.max(y_indices))
-
-            LOGGER.debug(
-                f"{self.vacuum_id}: Too few points in contour, using bounding box"
-            )
-            result = [
-                (x_min, y_min),  # Top-left
-                (x_max, y_min),  # Top-right
-                (x_max, y_max),  # Bottom-right
-                (x_min, y_max),  # Bottom-left
-                (x_min, y_min),  # Back to top-left to close the polygon
-            ]
-
-            # Cache the result
-            self._corners_cache[mask_hash] = result
-            return result
-
-        # Ensure the contour is closed
-        if simplified_contour[0] != simplified_contour[-1]:
-            simplified_contour.append(simplified_contour[0])
-
-        # Limit cache size
-        if len(self._corners_cache) > 50:  # Keep only 50 most recent items
-            try:
-                self._corners_cache.pop(next(iter(self._corners_cache)))
-            except (StopIteration, KeyError):
-                pass
-
-        # Cache the result
-        self._corners_cache[mask_hash] = simplified_contour
-        return simplified_contour
-
-    # Cache for labeled arrays to avoid redundant calculations
-    _label_cache = {}
-    _hull_cache = {}
-
-    @staticmethod
-    async def async_moore_neighbor_trace(mask: np.ndarray) -> List[Tuple[int, int]]:
-        """
-        Trace the contour of a binary mask using an optimized approach.
-        Uses caching and simplified algorithms for better performance.
-
-        Args:
-            mask: Binary mask of the room (1 for room, 0 for background)
-
-        Returns:
-            List of (x, y) tuples representing the contour
-        """
-        # Create a hash of the mask for caching
-        mask_hash = hash(mask.tobytes())
-
-        # Check if we have a cached result
-        if mask_hash in HypferRoomsHandler._hull_cache:
-            return HypferRoomsHandler._hull_cache[mask_hash]
-
-        # Fast path for empty masks
-        if not np.any(mask):
-            return []
-
-        # Find bounding box of non-zero elements (much faster than full labeling for simple cases)
-        y_indices, x_indices = np.where(mask > 0)
-        if len(x_indices) == 0 or len(y_indices) == 0:
-            return []
-
-        # For very small rooms (less than 100 pixels), just use bounding box
-        if len(x_indices) < 100:
-            x_min, x_max = np.min(x_indices), np.max(x_indices)
-            y_min, y_max = np.min(y_indices), np.max(y_indices)
-
-            # Create a simple rectangle
-            hull_vertices = [
-                (int(x_min), int(y_min)),  # Top-left
-                (int(x_max), int(y_min)),  # Top-right
-                (int(x_max), int(y_max)),  # Bottom-right
-                (int(x_min), int(y_max)),  # Bottom-left
-                (int(x_min), int(y_min)),  # Back to top-left to close the polygon
-            ]
-
-            # Cache and return the result
-            HypferRoomsHandler._hull_cache[mask_hash] = hull_vertices
-            return hull_vertices
-
-        # For larger rooms, use convex hull but with optimizations
-        try:
-            # Import here to avoid overhead for small rooms
-            from scipy import ndimage
-            from scipy.spatial import ConvexHull
-
-            # Use cached labeled array if available
-            if mask_hash in HypferRoomsHandler._label_cache:
-                labeled_array = HypferRoomsHandler._label_cache[mask_hash]
-            else:
-                # Find connected components - this is expensive
-                labeled_array, _ = ndimage.label(mask)
-                # Cache the result for future use
-                HypferRoomsHandler._label_cache[mask_hash] = labeled_array
-
-                # Limit cache size to prevent memory issues
-                if len(HypferRoomsHandler._label_cache) > 50:  # Keep only 50 most recent items
-                    # Remove oldest item (first key)
-                    try:
-                        HypferRoomsHandler._label_cache.pop(next(iter(HypferRoomsHandler._label_cache)))
-                    except (StopIteration, KeyError):
-                        # Handle edge case of empty cache
-                        pass
-
-            # Create a mask with all components
-            all_components_mask = (labeled_array > 0)
-
-            # Sample points instead of using all points for large masks
-            # This significantly reduces computation time for ConvexHull
-            if len(x_indices) > 1000:
-                # Sample every 10th point for very large rooms
-                step = 10
-            elif len(x_indices) > 500:
-                # Sample every 5th point for medium-sized rooms
-                step = 5
-            else:
-                # Use all points for smaller rooms
-                step = 1
-
-            # Sample points using the step size
-            sampled_y = y_indices[::step]
-            sampled_x = x_indices[::step]
-
-            # Create a list of points
-            points = np.column_stack((sampled_x, sampled_y))
-
-            # Compute the convex hull
-            hull = ConvexHull(points)
-
-            # Extract the vertices of the convex hull
-            hull_vertices = [(int(points[v, 0]), int(points[v, 1])) for v in hull.vertices]
-
-            # Ensure the hull is closed
-            if hull_vertices[0] != hull_vertices[-1]:
-                hull_vertices.append(hull_vertices[0])
-
-            # Cache and return the result
-            HypferRoomsHandler._hull_cache[mask_hash] = hull_vertices
-
-            # Limit hull cache size
-            if len(HypferRoomsHandler._hull_cache) > 50:
-                try:
-                    HypferRoomsHandler._hull_cache.pop(next(iter(HypferRoomsHandler._hull_cache)))
-                except (StopIteration, KeyError):
-                    pass
-
-            return hull_vertices
-
-        except Exception as e:
-            LOGGER.warning(f"Failed to compute convex hull: {e}. Falling back to bounding box.")
-
-            # Fallback to bounding box if convex hull fails
-            x_min, x_max = np.min(x_indices), np.max(x_indices)
-            y_min, y_max = np.min(y_indices), np.max(y_indices)
-
-            # Create a simple rectangle
-            hull_vertices = [
-                (int(x_min), int(y_min)),  # Top-left
-                (int(x_max), int(y_min)),  # Top-right
-                (int(x_max), int(y_max)),  # Bottom-right
-                (int(x_min), int(y_max)),  # Bottom-left
-                (int(x_min), int(y_min)),  # Back to top-left to close the polygon
-            ]
-
-            # Cache and return the result
-            HypferRoomsHandler._hull_cache[mask_hash] = hull_vertices
-            return hull_vertices
-
-
-
-    async def async_extract_room_properties(
-        self, json_data: Dict[str, Any]
-    ) -> RoomsProperties:
-        """
-        Extract room properties from the JSON data.
-
-        Args:
-            json_data: JSON data from the vacuum
-
-        Returns:
-            Dictionary of room properties
-        """
-        room_properties = {}
-        pixel_size = json_data.get("pixelSize", 5)
-        height = json_data["size"]["y"]
-        width = json_data["size"]["x"]
-        vacuum_id = self.vacuum_id
-        room_id_counter = 0
-
-        # Store the JSON data for reference in other methods
-        self.current_json_data = json_data
-
-        for layer in json_data.get("layers", []):
-            if layer.get("__class") == "MapLayer" and layer.get("type") == "segment":
-                meta_data = layer.get("metaData", {})
-                segment_id = meta_data.get("segmentId")
-                name = meta_data.get("name", f"Room {segment_id}")
-
-                # Check if this room is disabled in the drawing configuration
-                # The room_id_counter is 0-based, but DrawableElement.ROOM_X is 1-based
-                current_room_id = room_id_counter + 1
-                room_id_counter = (
-                    room_id_counter + 1
-                ) % 16  # Cycle room_id back to 0 after 15
-
-                if 1 <= current_room_id <= 15 and self.drawing_config is not None:
-                    room_element = getattr(
-                        DrawableElement, f"ROOM_{current_room_id}", None
-                    )
-                    if room_element and not self.drawing_config.is_enabled(
-                        room_element
-                    ):
-                        LOGGER.debug(
-                            "%s: Room %d is disabled and will be skipped",
-                            self.vacuum_id,
-                            current_room_id,
-                        )
-                        continue
-
-                compressed_pixels = layer.get("compressedPixels", [])
-                pixels = self.sublist(compressed_pixels, 3)
-
-                # Create a binary mask for the room
-                if not pixels:
-                    LOGGER.warning(f"Skipping segment {segment_id}: no pixels found")
-                    continue
-
-                mask = np.zeros((height, width), dtype=np.uint8)
-                for x, y, length in pixels:
-                    if 0 <= y < height and 0 <= x < width and x + length <= width:
-                        mask[y, x : x + length] = 1
-
-                # Find the room outline using the improved get_corners function
-                # Adjust epsilon_factor to control the level of simplification (higher = fewer points)
-                outline = await self.async_get_corners(mask, epsilon_factor=0.05)
-
-                if not outline:
-                    LOGGER.warning(
-                        f"Skipping segment {segment_id}: failed to generate outline"
-                    )
-                    continue
-
-                # Calculate the center of the room
-                xs, ys = zip(*outline)
-                x_min, x_max = min(xs), max(xs)
-                y_min, y_max = min(ys), max(ys)
-
-                # Scale coordinates by pixel_size
-                scaled_outline = [(x * pixel_size, y * pixel_size) for x, y in outline]
-
-                room_id = str(segment_id)
-                room_properties[room_id] = {
-                    "number": segment_id,
-                    "outline": scaled_outline,  # Already includes the closing point
-                    "name": name,
-                    "x": ((x_min + x_max) * pixel_size) // 2,
-                    "y": ((y_min + y_max) * pixel_size) // 2,
-                }
-
-        RoomStore(vacuum_id, room_properties)
-        return room_properties
-
-    async def get_room_at_position(
-        self, x: int, y: int, room_properties: Optional[RoomsProperties] = None
-    ) -> Optional[Dict[str, Any]]:
-        """
-        Get the room at a specific position.
-
-        Args:
-            x: X coordinate
-            y: Y coordinate
-            room_properties: Room properties dictionary (optional)
-
-        Returns:
-            Room data dictionary or None if no room at position
-        """
-        if room_properties is None:
-            room_store = RoomStore(self.vacuum_id)
-            room_properties = room_store.get_rooms()
-
-        if not room_properties:
-            return None
-
-        for room_id, room_data in room_properties.items():
-            outline = room_data.get("outline", [])
-            if not outline or len(outline) < 3:
-                continue
-
-            # Check if point is inside the polygon
-            if self.point_in_polygon(x, y, outline):
-                return {
-                    "id": room_id,
-                    "name": room_data.get("name", f"Room {room_id}"),
-                    "x": room_data.get("x", 0),
-                    "y": room_data.get("y", 0),
-                }
-
-        return None
-
-    @staticmethod
-    def point_in_polygon(x: int, y: int, polygon: List[Tuple[int, int]]) -> bool:
-        """
-        Check if a point is inside a polygon using ray casting algorithm.
-
-        Args:
-            x: X coordinate of the point
-            y: Y coordinate of the point
-            polygon: List of (x, y) tuples forming the polygon
-
-        Returns:
-            True if the point is inside the polygon, False otherwise
-        """
-        n = len(polygon)
-        inside = False
-
-        p1x, p1y = polygon[0]
-        xinters = None  # Initialize with default value
-        for i in range(1, n + 1):
-            p2x, p2y = polygon[i % n]
-            if y > min(p1y, p2y):
-                if y <= max(p1y, p2y):
-                    if x <= max(p1x, p2x):
-                        if p1y != p2y:
-                            xinters = (y - p1y) * (p2x - p1x) / (p2y - p1y) + p1x
-                        if p1x == p2x or x <= xinters:
-                            inside = not inside
-            p1x, p1y = p2x, p2y
-
-        return inside