valetudo-map-parser 0.1.9b53__py3-none-any.whl → 0.1.9b55__py3-none-any.whl

valetudo_map_parser/__init__.py

@@ -15,13 +15,14 @@ from .config.types import (
     TrimCropData,
     UserLanguageStore,
 )
-from .hypfer_rooms_handler import HypferRoomsHandler
 from .hypfer_handler import HypferMapImageHandler
 from .rand25_handler import ReImageHandler
+from .rooms_handler import RoomsHandler, RandRoomsHandler
 
 
 __all__ = [
-    "HypferRoomsHandler",
+    "RoomsHandler",
+    "RandRoomsHandler",
     "HypferMapImageHandler",
     "ReImageHandler",
     "RRMapParser",

valetudo_map_parser/config/auto_crop.py

@@ -125,7 +125,7 @@ class AutoCrop:
             if self.auto_crop:
                 self.auto_crop_offset()
         else:
-            self.handler.max_frames = 5
+            self.handler.max_frames = 1205
 
         # Fallback: Ensure auto_crop is valid
         if not self.auto_crop or any(v < 0 for v in self.auto_crop):
@@ -137,12 +137,32 @@ class AutoCrop:
     async def async_image_margins(
         self, image_array: NumpyArray, detect_colour: Color
     ) -> tuple[int, int, int, int]:
-        """Crop the image based on the auto crop area."""
-        nonzero_coords = np.column_stack(np.where(image_array != list(detect_colour)))
-        # Calculate the trim box based on the first and last occurrences
-        min_y, min_x, _ = NumpyArray.min(nonzero_coords, axis=0)
-        max_y, max_x, _ = NumpyArray.max(nonzero_coords, axis=0)
-        del nonzero_coords
+        """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
+        mask = ~np.all(image_array == list(detect_colour), axis=2)
+
+        # Use scipy.ndimage.find_objects to efficiently find the bounding box
+        # This returns a list of slice objects that define the bounding box
+        # Label the mask with a single label (1) and find its bounding box
+        labeled_mask = mask.astype(np.int8)  # Convert to int8 (smallest integer type)
+        objects = ndimage.find_objects(labeled_mask)
+
+        if not objects:  # No objects found
+            _LOGGER.warning(
+                "%s: No non-background pixels found in image", self.handler.file_name
+            )
+            # Return full image dimensions as fallback
+            return 0, 0, image_array.shape[1], image_array.shape[0]
+
+        # Extract the bounding box coordinates from the slice objects
+        y_slice, x_slice = objects[0]
+        min_y, max_y = y_slice.start, y_slice.stop - 1
+        min_x, max_x = x_slice.start, x_slice.stop - 1
+
         _LOGGER.debug(
             "%s: Found trims max and min values (y,x) (%s, %s) (%s, %s)...",
             self.handler.file_name,

valetudo_map_parser/config/color_utils.py

@@ -1,9 +1,9 @@
 """Utility functions for color operations in the map parser."""
 
-from typing import Tuple, Optional
+from typing import Optional, Tuple
 
 from .colors import ColorsManagement
-from .types import NumpyArray, Color
+from .types import Color, NumpyArray
 
 
 def get_blended_color(

valetudo_map_parser/config/colors.py

@@ -63,6 +63,7 @@ from .types import (
     Color,
 )
 
+
 color_transparent = (0, 0, 0, 0)
 color_charger = (0, 128, 0, 255)
 color_move = (238, 247, 255, 255)

valetudo_map_parser/config/drawable.py

@@ -10,15 +10,14 @@ Optimized with NumPy and SciPy for better performance.
 
 from __future__ import annotations
 
-
 import logging
 import math
 
 import numpy as np
 from PIL import ImageDraw, ImageFont
 
-from .colors import ColorsManagement
 from .color_utils import get_blended_color
+from .colors import ColorsManagement
 from .types import Color, NumpyArray, PilPNG, Point, Tuple, Union
 
 

valetudo_map_parser/config/drawable_elements.py

@@ -8,10 +8,12 @@ from __future__ import annotations
 
 from enum import IntEnum
 from typing import Dict, List, Tuple, Union
+
 import numpy as np
-from .types import LOGGER
 
 from .colors import DefaultColors, SupportedColor
+from .types import LOGGER
+
 
 # Type aliases
 Color = Tuple[int, int, int, int]  # RGBA color
@@ -170,13 +172,7 @@ class DrawingConfig:
 
     def is_enabled(self, element_code: DrawableElement) -> bool:
         """Check if an element is enabled for drawing."""
-        enabled = self._enabled_elements.get(element_code, False)
-        LOGGER.debug(
-            "Checking if element %s is enabled: %s",
-            element_code.name if hasattr(element_code, "name") else element_code,
-            enabled,
-        )
-        return enabled
+        return self._enabled_elements.get(element_code, False)
 
     def set_property(
         self, element_code: DrawableElement, property_name: str, value
@@ -238,10 +234,6 @@ class DrawingConfig:
                 self.set_property(room_element, "color", rgba)
                 self.set_property(room_element, "opacity", alpha / 255.0)
 
-                LOGGER.debug(
-                    "Updated room %d color to %s with alpha %s", room_id, rgb, alpha
-                )
-
         # Update other element colors
         for element, color_key in element_color_mapping.items():
             if color_key in device_info:
@@ -265,13 +257,6 @@ class DrawingConfig:
                 self.set_property(element, "color", rgba)
                 self.set_property(element, "opacity", alpha / 255.0)
 
-                LOGGER.debug(
-                    "Updated element %s color to %s with alpha %s",
-                    element.name,
-                    rgb,
-                    alpha,
-                )
-
         # Check for disabled elements using specific boolean flags
         # Map element disable flags to DrawableElement enum values
         element_disable_mapping = {

valetudo_map_parser/config/enhanced_drawable.py

@@ -13,12 +13,12 @@ from typing import Optional, Tuple
 
 import numpy as np
 
+from .colors import ColorsManagement
 from .drawable import Drawable
 from .drawable_elements import (
     DrawableElement,
     DrawingConfig,
 )
-from .colors import ColorsManagement
 
 
 # Type aliases

valetudo_map_parser/config/shared.py

@@ -88,6 +88,7 @@ class CameraShared:
         self.vac_json_id = None  # Vacuum json id
         self.margins = "100"  # Image margins
         self.obstacles_data = None  # Obstacles data
+        self.obstacles_pos = None  # Obstacles position
         self.offset_top = 0  # Image offset top
         self.offset_down = 0  # Image offset down
         self.offset_left = 0  # Image offset left
@@ -247,26 +248,6 @@ class CameraSharedManager:
             )
             instance.trims = TrimsData.from_dict(trim_data)
 
-            # Log disable_obstacles and disable_path settings
-            if "disable_obstacles" in device_info:
-                _LOGGER.info(
-                    "%s: device_info contains disable_obstacles: %s",
-                    instance.file_name,
-                    device_info["disable_obstacles"],
-                )
-            if "disable_path" in device_info:
-                _LOGGER.info(
-                    "%s: device_info contains disable_path: %s",
-                    instance.file_name,
-                    device_info["disable_path"],
-                )
-            if "disable_elements" in device_info:
-                _LOGGER.info(
-                    "%s: device_info contains disable_elements: %s",
-                    instance.file_name,
-                    device_info["disable_elements"],
-                )
-
         except TypeError as ex:
             _LOGGER.error("Shared data can't be initialized due to a TypeError! %s", ex)
         except AttributeError as ex:

valetudo_map_parser/config/types.py

@@ -8,7 +8,7 @@ import json
 import logging
 import threading
 from dataclasses import asdict, dataclass
-from typing import Any, Dict, Optional, Tuple, Union, TypedDict
+from typing import Any, Dict, Optional, Tuple, TypedDict, Union
 
 import numpy as np
 from PIL import Image
@@ -639,7 +639,3 @@ class TrimsData:
         self.trim_down = 0
         self.trim_right = 0
         return asdict(self)
-
-    def self_instance(self):
-        """Return self instance."""
-        return self.self_instance()

valetudo_map_parser/config/utils.py

@@ -550,58 +550,8 @@ def initialize_drawing_config(handler):
         hasattr(handler.shared, "device_info")
         and handler.shared.device_info is not None
     ):
-        LOGGER.info(
-            "%s: Initializing drawing config from device_info", handler.file_name
-        )
-        LOGGER.info(
-            "%s: device_info contains disable_obstacles: %s",
-            handler.file_name,
-            "disable_obstacles" in handler.shared.device_info,
-        )
-        LOGGER.info(
-            "%s: device_info contains disable_path: %s",
-            handler.file_name,
-            "disable_path" in handler.shared.device_info,
-        )
-        LOGGER.info(
-            "%s: device_info contains disable_elements: %s",
-            handler.file_name,
-            "disable_elements" in handler.shared.device_info,
-        )
-
-        if "disable_obstacles" in handler.shared.device_info:
-            LOGGER.info(
-                "%s: disable_obstacles value: %s",
-                handler.file_name,
-                handler.shared.device_info["disable_obstacles"],
-            )
-        if "disable_path" in handler.shared.device_info:
-            LOGGER.info(
-                "%s: disable_path value: %s",
-                handler.file_name,
-                handler.shared.device_info["disable_path"],
-            )
-        if "disable_elements" in handler.shared.device_info:
-            LOGGER.info(
-                "%s: disable_elements value: %s",
-                handler.file_name,
-                handler.shared.device_info["disable_elements"],
-            )
-
         drawing_config.update_from_device_info(handler.shared.device_info)
 
-        # Verify elements are disabled
-        LOGGER.info(
-            "%s: After initialization, PATH enabled: %s",
-            handler.file_name,
-            drawing_config.is_enabled(DrawableElement.PATH),
-        )
-        LOGGER.info(
-            "%s: After initialization, OBSTACLE enabled: %s",
-            handler.file_name,
-            drawing_config.is_enabled(DrawableElement.OBSTACLE),
-        )
-
     # Initialize both drawable systems for backward compatibility
     draw = Drawable()  # Legacy drawing utilities
     enhanced_draw = EnhancedDrawable(drawing_config)  # New enhanced drawing system
@@ -632,7 +582,7 @@ def blend_colors(base_color, overlay_color):
 
     # Avoid division by zero
     if a_out < 0.0001:
-        return (0, 0, 0, 0)
+        return [0, 0, 0, 0]
 
     # Calculate blended RGB components
     r_out = (r1 * a1 + r2 * a2 * (1 - a1)) / a_out

valetudo_map_parser/hypfer_draw.py

@@ -142,12 +142,6 @@ class ImageDraw:
                 room_element = getattr(DrawableElement, f"ROOM_{current_room_id}", None)
                 if room_element and hasattr(self.img_h.drawing_config, "is_enabled"):
                     draw_room = self.img_h.drawing_config.is_enabled(room_element)
-                    _LOGGER.debug(
-                        "%s: Room %d is %s",
-                        self.file_name,
-                        current_room_id,
-                        "enabled" if draw_room else "disabled",
-                    )
 
         # Get the room color
         room_color = self.img_h.shared.rooms_colors[room_id]
@@ -170,13 +164,6 @@ class ImageDraw:
         except IndexError as e:
             _LOGGER.warning("%s: Image Draw Error: %s", self.file_name, str(e))
 
-        _LOGGER.debug(
-            "%s Active Zones: %s and Room ID: %s",
-            self.file_name,
-            str(self.img_h.active_zones),
-            str(room_id),
-        )
-
         return img_np_array, room_id
 
     def _get_active_room_color(self, room_id, room_color, color_zone_clean):
@@ -316,6 +303,13 @@ class ImageDraw:
             await self.img_h.draw.async_draw_obstacles(
                 np_array, obstacle_positions, color_no_go
             )
+
+            # Update both obstacles_pos and obstacles_data
+            self.img_h.shared.obstacles_pos = obstacle_positions
+            # Only update obstacles_data if it's None or if the number of obstacles has changed
+            if (self.img_h.shared.obstacles_data is None or
+                len(self.img_h.shared.obstacles_data) != len(obstacle_positions)):
+                self.img_h.shared.obstacles_data = obstacle_positions
         return np_array
 
     async def async_draw_charger(

valetudo_map_parser/hypfer_handler.py

@@ -20,6 +20,7 @@ from .config.types import (
     CalibrationPoints,
     Colors,
     RoomsProperties,
+    RoomStore,
 )
 from .config.utils import (
     BaseHandler,
@@ -28,8 +29,8 @@ from .config.utils import (
     prepare_resize_params,
 )
 from .hypfer_draw import ImageDraw as ImDraw
-from .hypfer_rooms_handler import HypferRoomsHandler
 from .map_data import ImageData
+from .rooms_handler import RoomsHandler
 
 
 class HypferMapImageHandler(BaseHandler, AutoCrop):
@@ -57,7 +58,7 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
         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.
-        self.rooms_handler = HypferRoomsHandler(
+        self.rooms_handler = RoomsHandler(
             self.file_name, self.drawing_config
         )  # Room data handler
 
@@ -68,51 +69,24 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
 
     async def async_extract_room_properties(self, json_data) -> RoomsProperties:
         """Extract room properties from the JSON data."""
-
-        return await self.rooms_handler.async_extract_room_properties(json_data)
-        # room_properties = {}
-        # self.rooms_pos = []
-        # pixel_size = json_data.get("pixelSize", [])
-        #
-        # for layer in json_data.get("layers", []):
-        #     if layer["__class"] == "MapLayer":
-        #         meta_data = layer.get("metaData", {})
-        #         segment_id = meta_data.get("segmentId")
-        #         if segment_id is not None:
-        #             name = meta_data.get("name")
-        #             compressed_pixels = layer.get("compressedPixels", [])
-        #             pixels = self.data.sublist(compressed_pixels, 3)
-        #             # Calculate x and y min/max from compressed pixels
-        #             (
-        #                 x_min,
-        #                 y_min,
-        #                 x_max,
-        #                 y_max,
-        #             ) = await self.data.async_get_rooms_coordinates(pixels, pixel_size)
-        #             corners = self.get_corners(x_max, x_min, y_max, y_min)
-        #             room_id = str(segment_id)
-        #             self.rooms_pos.append(
-        #                 {
-        #                     "name": name,
-        #                     "corners": corners,
-        #                 }
-        #             )
-        #             room_properties[room_id] = {
-        #                 "number": segment_id,
-        #                 "outline": corners,
-        #                 "name": name,
-        #                 "x": ((x_min + x_max) // 2),
-        #                 "y": ((y_min + y_max) // 2),
-        #             }
-        # if room_properties:
-        #     rooms = RoomStore(self.file_name, room_properties)
-        #     LOGGER.debug(
-        #         "%s: Rooms data extracted! %s", self.file_name, rooms.get_rooms()
-        #     )
-        # else:
-        #     LOGGER.debug("%s: Rooms data not available!", self.file_name)
-        #     self.rooms_pos = None
-        # return room_properties
+        room_properties = await self.rooms_handler.async_extract_room_properties(
+            json_data
+        )
+        if room_properties:
+            rooms = RoomStore(self.file_name, room_properties)
+            LOGGER.debug(
+                "%s: Rooms data extracted! %s", self.file_name, rooms.get_rooms()
+            )
+            # Convert room_properties to the format expected by async_get_robot_in_room
+            self.rooms_pos = []
+            for room_id, room_data in room_properties.items():
+                self.rooms_pos.append(
+                    {"name": room_data["name"], "outline": room_data["outline"]}
+                )
+        else:
+            LOGGER.debug("%s: Rooms data not available!", self.file_name)
+            self.rooms_pos = None
+        return room_properties
 
     # noinspection PyUnresolvedReferences,PyUnboundLocalVariable
     async def async_get_image_from_json(
@@ -164,9 +138,6 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                     img_np_array = await self.draw.create_empty_image(
                         size_x, size_y, colors["background"]
                     )
-
-                    LOGGER.info("%s: Drawing map with color blending", self.file_name)
-
                     # Draw layers and segments if enabled
                     room_id = 0
                     # Keep track of disabled rooms to skip their walls later
@@ -218,25 +189,13 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                                     room_element = getattr(
                                         DrawableElement, f"ROOM_{current_room_id}", None
                                     )
-                                    if room_element:
-                                        # Log the room check for debugging
-                                        LOGGER.debug(
-                                            "%s: Checking if room %d is enabled: %s",
-                                            self.file_name,
-                                            current_room_id,
-                                            self.drawing_config.is_enabled(
-                                                room_element
-                                            ),
-                                        )
 
-                                        # Skip this room if it's disabled
-                                        if not self.drawing_config.is_enabled(
-                                            room_element
-                                        ):
-                                            room_id = (
-                                                room_id + 1
-                                            ) % 16  # Increment room_id even if we skip
-                                            continue
+                                    # Skip this room if it's disabled
+                                    if not self.drawing_config.is_enabled(room_element):
+                                        room_id = (
+                                            room_id + 1
+                                        ) % 16  # Increment room_id even if we skip
+                                        continue
 
                             # Check if this is a wall layer and if walls are enabled
                             is_wall_layer = layer_type == "wall"
@@ -244,22 +203,7 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                                 if not self.drawing_config.is_enabled(
                                     DrawableElement.WALL
                                 ):
-                                    LOGGER.info(
-                                        "%s: Skipping wall layer because WALL element is disabled",
-                                        self.file_name,
-                                    )
-                                    continue
-
-                                # Filter out walls for disabled rooms
-                                if disabled_rooms:
-                                    # Need to modify compressed_pixels_list to exclude walls of disabled rooms
-                                    # This requires knowledge of which walls belong to which rooms
-                                    # For now, we'll just log that we're drawing walls for all rooms
-                                    LOGGER.debug(
-                                        "%s: Drawing walls for all rooms (including disabled ones)",
-                                        self.file_name,
-                                    )
-                                    # In a real implementation, we would filter the walls here
+                                    pass
 
                             # Draw the layer
                             (
@@ -281,10 +225,6 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                                 room_element = getattr(
                                     DrawableElement, f"ROOM_{room_id}", None
                                 )
-                                if room_element:
-                                    # This is a simplification - in a real implementation we would
-                                    # need to identify the exact pixels that belong to this room
-                                    pass
 
                     # Draw the virtual walls if enabled
                     if self.drawing_config.is_enabled(DrawableElement.VIRTUAL_WALL):

valetudo_map_parser/rand25_handler.py

@@ -29,13 +29,14 @@ from .config.types import (
 )
 from .config.utils import (
     BaseHandler,
+    # async_extract_room_outline,
     initialize_drawing_config,
     manage_drawable_elements,
     prepare_resize_params,
-    async_extract_room_outline,
 )
 from .map_data import RandImageData
 from .reimg_draw import ImageDraw
+from .rooms_handler import RandRoomsHandler
 
 
 _LOGGER = logging.getLogger(__name__)
@@ -68,6 +69,7 @@ class ReImageHandler(BaseHandler, AutoCrop):
         self.active_zones = None  # Active zones
         self.file_name = self.shared.file_name  # File name
         self.imd = ImageDraw(self)  # Image Draw
+        self.rooms_handler = RandRoomsHandler(self.file_name, self.drawing_config)  # Room data handler
 
     async def extract_room_outline_from_map(self, room_id_int, pixels):
         """Extract the outline of a room using the pixel data and element map.
@@ -110,62 +112,45 @@ class ReImageHandler(BaseHandler, AutoCrop):
                 ) = await RandImageData.async_get_rrm_segments(
                     json_data, size_x, size_y, top, left, True
                 )
+
             dest_json = destinations
-            room_data = dict(dest_json).get("rooms", [])
             zones_data = dict(dest_json).get("zones", [])
             points_data = dict(dest_json).get("spots", [])
-            room_id_to_data = {room["id"]: room for room in room_data}
+
+            # Use the RandRoomsHandler to extract room properties
+            room_properties = await self.rooms_handler.async_extract_room_properties(
+                json_data, dest_json
+            )
+
+            # Update self.rooms_pos from room_properties for compatibility with other methods
             self.rooms_pos = []
-            room_properties = {}
-            if self.outlines:
-                for id_x, room_id in enumerate(unsorted_id):
-                    if room_id in room_id_to_data:
-                        room_info = room_id_to_data[room_id]
-                        name = room_info.get("name")
-                        # Calculate x and y min/max from outlines
-                        x_min = self.outlines[id_x][0][0]
-                        x_max = self.outlines[id_x][1][0]
-                        y_min = self.outlines[id_x][0][1]
-                        y_max = self.outlines[id_x][1][1]
-                        corners = self.get_corners(x_max, x_min, y_max, y_min)
-                        # rand256 vacuums accept int(room_id) or str(name)
-                        # the card will soon support int(room_id) but the camera will send name
-                        # this avoids the manual change of the values in the card.
-                        self.rooms_pos.append(
-                            {
-                                "name": name,
-                                "corners": corners,
-                            }
-                        )
-                        room_properties[int(room_id)] = {
-                            "number": int(room_id),
-                            "outline": corners,
-                            "name": name,
-                            "x": (x_min + x_max) // 2,
-                            "y": (y_min + y_max) // 2,
-                        }
-                # get the zones and points data
-                zone_properties = await self.async_zone_propriety(zones_data)
-                # get the points data
-                point_properties = await self.async_points_propriety(points_data)
-                if room_properties or zone_properties:
-                    extracted_data = [
-                        f"{len(room_properties)} Rooms" if room_properties else None,
-                        f"{len(zone_properties)} Zones" if zone_properties else None,
-                    ]
-                    extracted_data = ", ".join(filter(None, extracted_data))
-                    _LOGGER.debug("Extracted data: %s", extracted_data)
-                else:
-                    self.rooms_pos = None
-                    _LOGGER.debug(
-                        "%s: Rooms and Zones data not available!", self.file_name
-                    )
-                rooms = RoomStore(self.file_name, room_properties)
-                _LOGGER.debug("Rooms Data: %s", rooms.get_rooms())
-                return room_properties, zone_properties, point_properties
+            for room_id, props in room_properties.items():
+                self.rooms_pos.append({
+                    "name": props["name"],
+                    "corners": props["outline"],  # Use the enhanced outline
+                })
+
+            # get the zones and points data
+            zone_properties = await self.async_zone_propriety(zones_data)
+            # get the points data
+            point_properties = await self.async_points_propriety(points_data)
+
+            if room_properties or zone_properties:
+                extracted_data = [
+                    f"{len(room_properties)} Rooms" if room_properties else None,
+                    f"{len(zone_properties)} Zones" if zone_properties else None,
+                ]
+                extracted_data = ", ".join(filter(None, extracted_data))
+                _LOGGER.debug("Extracted data: %s", extracted_data)
             else:
-                _LOGGER.debug("%s: No outlines available", self.file_name)
-                return None, None, None
+                self.rooms_pos = None
+                _LOGGER.debug(
+                    "%s: Rooms and Zones data not available!", self.file_name
+                )
+
+            rooms = RoomStore(self.file_name, room_properties)
+            _LOGGER.debug("Rooms Data: %s", rooms.get_rooms())
+            return room_properties, zone_properties, point_properties
         except (RuntimeError, ValueError) as e:
             _LOGGER.debug(
                 "No rooms Data or Error in extract_room_properties: %s",

valetudo_map_parser/rooms_handler.py

@@ -0,0 +1,470 @@
+"""
+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
+
+import time
+from typing import Any, Dict, List, Optional, Tuple
+
+import numpy as np
+from scipy.ndimage import binary_dilation, binary_erosion
+from scipy.spatial import ConvexHull
+
+from .config.drawable_elements import DrawableElement, DrawingConfig
+from .config.types import LOGGER, RoomsProperties
+
+from .map_data import RandImageData, ImageData
+
+class RoomsHandler:
+    """
+    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)]
+
+    @staticmethod
+    def convex_hull_outline(mask: np.ndarray) -> list[tuple[int, int]]:
+        y_indices, x_indices = np.where(mask > 0)
+        if len(x_indices) == 0 or len(y_indices) == 0:
+            return []
+
+        points = np.column_stack((x_indices, y_indices))
+        if len(points) < 3:
+            return [(int(x), int(y)) for x, y in points]
+
+        hull = ConvexHull(points)
+        # Convert numpy.int64 values to regular Python integers
+        hull_points = [
+            (int(points[vertex][0]), int(points[vertex][1])) for vertex in hull.vertices
+        ]
+        if hull_points[0] != hull_points[-1]:
+            hull_points.append(hull_points[0])
+        return hull_points
+
+    async def _process_room_layer(
+        self, layer: Dict[str, Any], width: int, height: int, pixel_size: int
+    ) -> Tuple[Optional[str], Optional[Dict[str, Any]]]:
+        """Process a single room layer and extract its outline.
+
+        Args:
+            layer: The layer data from the JSON
+            width: The width of the map
+            height: The height of the map
+            pixel_size: The size of each pixel
+
+        Returns:
+            Tuple of (room_id, room_data) or (None, None) if processing failed
+        """
+        meta_data = layer.get("metaData", {})
+        segment_id = meta_data.get("segmentId")
+        name = meta_data.get("name", "Room {}".format(segment_id))
+        compressed_pixels = layer.get("compressedPixels", [])
+        pixels = self.sublist(compressed_pixels, 3)
+
+        # Check if this room is enabled in the drawing configuration
+        if self.drawing_config is not None:
+            # Convert segment_id to room element (ROOM_1 to ROOM_15)
+            try:
+                # Segment IDs might not be sequential, so we need to map them to room elements
+                # We'll use a simple approach: if segment_id is an integer, use it directly
+                room_element_id = int(segment_id)
+                if 1 <= room_element_id <= 15:
+                    room_element = getattr(
+                        DrawableElement, f"ROOM_{room_element_id}", None
+                    )
+                    if room_element:
+                        is_enabled = self.drawing_config.is_enabled(room_element)
+                        if not is_enabled:
+                            # Skip this room if it's disabled
+                            LOGGER.debug("Skipping disabled room %s", segment_id)
+                            return None, None
+            except (ValueError, TypeError):
+                # If segment_id is not a valid integer, we can't map it to a room element
+                # In this case, we'll include the room (fail open)
+                LOGGER.debug(
+                    "Could not convert segment_id %s to room element", segment_id
+                )
+
+        # Optimization: Create a smaller mask for just the room area
+        if not pixels:
+            # Skip if no pixels
+            return None, None
+
+        # Convert to numpy arrays for vectorized operations
+        pixel_data = np.array(pixels)
+
+        if pixel_data.size == 0:
+            return None, None
+
+        # Find the actual bounds of the room to create a smaller mask
+        # Add padding to ensure we don't lose edge details
+        padding = 10  # Add padding pixels around the room
+        min_x = max(0, int(np.min(pixel_data[:, 0])) - padding)
+        max_x = min(
+            width, int(np.max(pixel_data[:, 0]) + np.max(pixel_data[:, 2])) + padding
+        )
+        min_y = max(0, int(np.min(pixel_data[:, 1])) - padding)
+        max_y = min(height, int(np.max(pixel_data[:, 1]) + 1) + padding)
+
+        # Create a smaller mask for just the room area (much faster)
+        local_width = max_x - min_x
+        local_height = max_y - min_y
+
+        # Skip if dimensions are invalid
+        if local_width <= 0 or local_height <= 0:
+            return None, None
+
+        # Create a smaller mask
+        local_mask = np.zeros((local_height, local_width), dtype=np.uint8)
+
+        # Fill the mask efficiently
+        for x, y, length in pixel_data:
+            x, y, length = int(x), int(y), int(length)
+            # Adjust coordinates to local mask
+            local_x = x - min_x
+            local_y = y - min_y
+
+            # Ensure we're within bounds
+            if 0 <= local_y < local_height and 0 <= local_x < local_width:
+                # Calculate the end point, clamping to mask width
+                end_x = min(local_x + length, local_width)
+                if end_x > local_x:  # Only process if there's a valid segment
+                    local_mask[local_y, local_x:end_x] = 1
+
+        # Apply morphological operations
+        struct_elem = np.ones((3, 3), dtype=np.uint8)
+        eroded = binary_erosion(local_mask, structure=struct_elem, iterations=1)
+        mask = binary_dilation(eroded, structure=struct_elem, iterations=1).astype(
+            np.uint8
+        )
+
+        # Extract contour from the mask
+        outline = self.convex_hull_outline(mask)
+        if not outline:
+            return None, None
+
+        # Adjust coordinates back to global space
+        outline = [(x + min_x, y + min_y) for (x, y) in outline]
+
+        # Use coordinates as-is without flipping Y coordinates
+        xs, ys = zip(*outline)
+        x_min, x_max = min(xs), max(xs)
+        y_min, y_max = min(ys), max(ys)
+
+        room_id = str(segment_id)
+
+        # Scale coordinates by pixel_size and convert to regular Python integers
+        scaled_outline = [
+            (int(x * pixel_size), int(y * pixel_size)) for x, y in outline
+        ]
+        room_data = {
+            "number": segment_id,
+            "outline": scaled_outline,
+            "name": name,
+            "x": int(((x_min + x_max) * pixel_size) // 2),
+            "y": int(((y_min + y_max) * pixel_size) // 2),
+        }
+
+        return room_id, room_data
+
+    async def async_extract_room_properties(self, json_data) -> RoomsProperties:
+        """Extract room properties from the JSON data.
+
+        This method processes all room layers in the JSON data and extracts their outlines.
+        It respects the drawing configuration, skipping rooms that are disabled.
+
+        Args:
+            json_data: The JSON data from the vacuum
+
+        Returns:
+            Dictionary of room properties
+        """
+        start_total = time.time()
+        room_properties = {}
+        pixel_size = json_data.get("pixelSize", 5)
+        height = json_data["size"]["y"]
+        width = json_data["size"]["x"]
+
+        for layer in json_data.get("layers", []):
+            if layer.get("__class") == "MapLayer" and layer.get("type") == "segment":
+                room_id, room_data = await self._process_room_layer(
+                    layer, width, height, pixel_size
+                )
+                if room_id is not None and room_data is not None:
+                    room_properties[room_id] = room_data
+
+        # Log timing information
+        total_time = time.time() - start_total
+        LOGGER.debug("Room extraction Total time: %.3fs", total_time)
+        return room_properties
+
+class RandRoomsHandler:
+    """
+    Handler for extracting and managing room data from Rand25 vacuum maps.
+
+    This class provides methods to:
+    - Extract room outlines using the Convex Hull algorithm
+    - Process room properties from JSON data and destinations JSON
+    - 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 RandRoomsHandler.
+
+        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
+        self.segment_data = None  # Segment data
+        self.outlines = None  # Outlines data
+
+    @staticmethod
+    def sublist(data: list, chunk_size: int) -> list:
+        """Split a list into chunks of specified size."""
+        return [data[i : i + chunk_size] for i in range(0, len(data), chunk_size)]
+
+    @staticmethod
+    def convex_hull_outline(points: List[Tuple[int, int]]) -> List[Tuple[int, int]]:
+        """
+        Generate a convex hull outline from a set of points.
+
+        Args:
+            points: List of (x, y) coordinate tuples
+
+        Returns:
+            List of (x, y) tuples forming the convex hull outline
+        """
+        if len(points) == 0:
+            return []
+
+        # Convert to numpy array for processing
+        points_array = np.array(points)
+
+        if len(points) < 3:
+            # Not enough points for a convex hull, return the points as is
+            return [(int(x), int(y)) for x, y in points_array]
+
+        try:
+            # Calculate the convex hull
+            hull = ConvexHull(points_array)
+
+            # Extract the vertices in order
+            hull_points = [
+                (int(points_array[vertex][0]), int(points_array[vertex][1]))
+                for vertex in hull.vertices
+            ]
+
+            # Close the polygon by adding the first point at the end
+            if hull_points[0] != hull_points[-1]:
+                hull_points.append(hull_points[0])
+
+            return hull_points
+
+        except Exception as e:
+            LOGGER.warning(f"Error calculating convex hull: {e}")
+
+            # Fallback to bounding box if convex hull fails
+            x_min, y_min = np.min(points_array, axis=0)
+            x_max, y_max = np.max(points_array, axis=0)
+
+            return [
+                (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
+            ]
+
+    async def _process_segment_data(
+        self, segment_data: List, segment_id: int, pixel_size: int
+    ) -> Tuple[Optional[str], Optional[Dict[str, Any]]]:
+        """
+        Process a single segment and extract its outline.
+
+        Args:
+            segment_data: The segment pixel data
+            segment_id: The ID of the segment
+            pixel_size: The size of each pixel
+
+        Returns:
+            Tuple of (room_id, room_data) or (None, None) if processing failed
+        """
+        # Check if this room is enabled in the drawing configuration
+        if self.drawing_config is not None:
+            try:
+                # Convert segment_id to room element (ROOM_1 to ROOM_15)
+                room_element_id = int(segment_id)
+                if 1 <= room_element_id <= 15:
+                    room_element = getattr(
+                        DrawableElement, f"ROOM_{room_element_id}", None
+                    )
+                    if room_element:
+                        is_enabled = self.drawing_config.is_enabled(room_element)
+                        if not is_enabled:
+                            # Skip this room if it's disabled
+                            LOGGER.debug("Skipping disabled room %s", segment_id)
+                            return None, None
+            except (ValueError, TypeError):
+                # If segment_id is not a valid integer, we can't map it to a room element
+                # In this case, we'll include the room (fail open)
+                LOGGER.debug(
+                    "Could not convert segment_id %s to room element", segment_id
+                )
+
+        # Skip if no pixels
+        if not segment_data:
+            return None, None
+
+        # Extract points from segment data
+        points = []
+        for x, y, _ in segment_data:
+            points.append((int(x), int(y)))
+
+        if not points:
+            return None, None
+
+        # Use convex hull to get the outline
+        outline = self.convex_hull_outline(points)
+        if not outline:
+            return None, None
+
+        # Calculate bounding box for 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 = [
+            (int(x * pixel_size), int(y * pixel_size)) for x, y in outline
+        ]
+
+        room_id = str(segment_id)
+        room_data = {
+            "number": segment_id,
+            "outline": scaled_outline,
+            "name": f"Room {segment_id}",  # Default name, will be updated from destinations
+            "x": int(((x_min + x_max) * pixel_size) // 2),
+            "y": int(((y_min + y_max) * pixel_size) // 2),
+        }
+
+        return room_id, room_data
+
+    async def async_extract_room_properties(
+        self, json_data: Dict[str, Any], destinations: Dict[str, Any]
+    ) -> RoomsProperties:
+        """
+        Extract room properties from the JSON data and destinations.
+
+        Args:
+            json_data: The JSON data from the vacuum
+            destinations: The destinations JSON containing room names and IDs
+
+        Returns:
+            Dictionary of room properties
+        """
+        start_total = time.time()
+        room_properties = {}
+
+        # Get basic map information
+        unsorted_id = RandImageData.get_rrm_segments_ids(json_data)
+        size_x, size_y = RandImageData.get_rrm_image_size(json_data)
+        top, left = RandImageData.get_rrm_image_position(json_data)
+        pixel_size = 50  # Rand25 vacuums use a larger pixel size to match the original implementation
+
+        # Get segment data and outlines if not already available
+        if not self.segment_data or not self.outlines:
+            (
+                self.segment_data,
+                self.outlines,
+            ) = await RandImageData.async_get_rrm_segments(
+                json_data, size_x, size_y, top, left, True
+            )
+
+        # Process destinations JSON to get room names
+        dest_json = destinations
+        room_data = dest_json.get("rooms", [])
+        room_id_to_data = {room["id"]: room for room in room_data}
+
+        # Process each segment
+        if unsorted_id and self.segment_data and self.outlines:
+            for idx, segment_id in enumerate(unsorted_id):
+                # Extract points from segment data
+                points = []
+                for x, y, _ in self.segment_data[idx]:
+                    points.append((int(x), int(y)))
+
+                if not points:
+                    continue
+
+                # Use convex hull to get the outline
+                outline = self.convex_hull_outline(points)
+                if not outline:
+                    continue
+
+                # Scale coordinates by pixel_size
+                scaled_outline = [
+                    (int(x * pixel_size), int(y * pixel_size)) for x, y in outline
+                ]
+
+                # Calculate center point
+                xs, ys = zip(*outline)
+                x_min, x_max = min(xs), max(xs)
+                y_min, y_max = min(ys), max(ys)
+                center_x = int(((x_min + x_max) * pixel_size) // 2)
+                center_y = int(((y_min + y_max) * pixel_size) // 2)
+
+                # Create room data
+                room_id = str(segment_id)
+                room_data = {
+                    "number": segment_id,
+                    "outline": scaled_outline,
+                    "name": f"Room {segment_id}",  # Default name, will be updated from destinations
+                    "x": center_x,
+                    "y": center_y,
+                }
+
+                # Update room name from destinations if available
+                if segment_id in room_id_to_data:
+                    room_info = room_id_to_data[segment_id]
+                    room_data["name"] = room_info.get("name", room_data["name"])
+
+                room_properties[room_id] = room_data
+
+        # Log timing information
+        total_time = time.time() - start_total
+        LOGGER.debug("Room extraction Total time: %.3fs", total_time)
+
+        return room_properties

{valetudo_map_parser-0.1.9b53.dist-info → valetudo_map_parser-0.1.9b55.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: valetudo-map-parser
-Version: 0.1.9b53
+Version: 0.1.9b55
 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.9b55.dist-info/RECORD

@@ -0,0 +1,27 @@
+valetudo_map_parser/__init__.py,sha256=Fz-gtKf_OlZcDQqVfGlBwIWi5DJAiRucMbBMdQ2tX_U,1060
+valetudo_map_parser/config/__init__.py,sha256=DQ9plV3ZF_K25Dp5ZQHPDoG-40dQoJNdNi-dfNeR3Zc,48
+valetudo_map_parser/config/auto_crop.py,sha256=6xt_wJQqphddWhlrr7MNUkodCi8ZYdRk42qvAaxlYCM,13546
+valetudo_map_parser/config/color_utils.py,sha256=nXD6WeNmdFdoMxPDW-JFpjnxJSaZR1jX-ouNfrx6zvE,4502
+valetudo_map_parser/config/colors.py,sha256=DG-oPQoN5gsnwDbEsuFr8a0hRCxmbFHObWa4_5pr-70,29910
+valetudo_map_parser/config/drawable.py,sha256=2MeVHXqZuVuJk3eerMJYGwo25rVetHx3xB_vxecEFOQ,34168
+valetudo_map_parser/config/drawable_elements.py,sha256=o-5oiXmfqPwNQLzKIhkEcZD_A47rIU9E0CqKgWipxgc,11516
+valetudo_map_parser/config/enhanced_drawable.py,sha256=QlGxlUMVgECUXPtFwIslyjubWxQuhIixsRymWV3lEvk,12586
+valetudo_map_parser/config/optimized_element_map.py,sha256=52BCnkvVv9bre52LeVIfT8nhnEIpc0TuWTv1xcNu0Rk,15744
+valetudo_map_parser/config/rand25_parser.py,sha256=kIayyqVZBfQfAMkiArzqrrj9vqZB3pkgT0Y5ufrQmGA,16448
+valetudo_map_parser/config/room_outline.py,sha256=D20D-yeyKnlmVbW9lI7bsPtQGn2XkcWow6YNOEPnWVg,4800
+valetudo_map_parser/config/shared.py,sha256=Vr4bicL7aJoRQbwbXyjEpiWhfzZ-cakLlfRqL3LBhpM,10475
+valetudo_map_parser/config/types.py,sha256=TaRKoo7G7WIUw7ljOz2Vn5oYzKaLyQH-7Eb8ZYql8Ls,17464
+valetudo_map_parser/config/utils.py,sha256=CFuuiS5IufEu9aeaZwi7xa1jEF1z6yDZB0mcyVX79Xo,29261
+valetudo_map_parser/hypfer_draw.py,sha256=bwNTYopTJFY0nElrHquQrSfGHgN_-6t5E-8xBxDsRXA,26660
+valetudo_map_parser/hypfer_handler.py,sha256=wvkZt6MsUF0gkHZDAwiUgOOawkdvakRzYBV3NtjxuJQ,19938
+valetudo_map_parser/hypfer_rooms_handler.py,sha256=NkpOA6Gdq-2D3lLAxvtNuuWMvPXHxeMY2TO5RZLSHlU,22652
+valetudo_map_parser/map_data.py,sha256=zQKE8EzWxR0r0qyfD1QQq51T1wFrpcIeXtnpm92-LXQ,17743
+valetudo_map_parser/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+valetudo_map_parser/rand25_handler.py,sha256=VOBzx0AY61AggOkiX-P4c73MrPrQBGfsDQTEbVL1wCQ,18855
+valetudo_map_parser/reimg_draw.py,sha256=1q8LkNTPHEA9Tsapc_JnVw51kpPYNhaBU-KmHkefCQY,12507
+valetudo_map_parser/rooms_handler.py,sha256=YP8OLotBH-RXluv398l7TTT2zIBHJp91b8THWxl3NdI,17794
+valetudo_map_parser-0.1.9b55.dist-info/LICENSE,sha256=Lh-qBbuRV0-jiCIBhfV7NgdwFxQFOXH3BKOzK865hRs,10480
+valetudo_map_parser-0.1.9b55.dist-info/METADATA,sha256=Af2KutWU3EHPE8F1HNCWWKlIGKqr9bz1nTbC1-d3ZCo,3321
+valetudo_map_parser-0.1.9b55.dist-info/NOTICE.txt,sha256=5lTOuWiU9aiEnJ2go8sc7lTJ7ntMBx0g0GFnNrswCY4,2533
+valetudo_map_parser-0.1.9b55.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+valetudo_map_parser-0.1.9b55.dist-info/RECORD,,

valetudo_map_parser-0.1.9b53.dist-info/RECORD

@@ -1,26 +0,0 @@
-valetudo_map_parser/__init__.py,sha256=cewtLadNSOg3X2Ts2SuG8mTJqo0ncsFRg_sQ4VkM4ow,1037
-valetudo_map_parser/config/__init__.py,sha256=DQ9plV3ZF_K25Dp5ZQHPDoG-40dQoJNdNi-dfNeR3Zc,48
-valetudo_map_parser/config/auto_crop.py,sha256=6OvRsWzXMXBaSEvgwpaaisNdozDKiDyTmPjknFxoUMc,12624
-valetudo_map_parser/config/color_utils.py,sha256=D4NXRhuPdQ7UDKM3vLNYR0HnACl9AB75EnfCp5tGliI,4502
-valetudo_map_parser/config/colors.py,sha256=LE7sl4Qy0TkxbkjgB3dotYIfXqhc-fllkFQxexVvUvg,29909
-valetudo_map_parser/config/drawable.py,sha256=qenuxD1-Vvyus9o8alJFYRqL54aO3pakMqPSYNGvpe8,34169
-valetudo_map_parser/config/drawable_elements.py,sha256=bkEwdbx1upt9vaPaqE_VR1rtwRsaiH-IVKc3mHNa8IY,12065
-valetudo_map_parser/config/enhanced_drawable.py,sha256=6yGoOq_dLf2VCghO_URSyGfLAshFyzS3iEPeHw1PeDo,12586
-valetudo_map_parser/config/optimized_element_map.py,sha256=52BCnkvVv9bre52LeVIfT8nhnEIpc0TuWTv1xcNu0Rk,15744
-valetudo_map_parser/config/rand25_parser.py,sha256=kIayyqVZBfQfAMkiArzqrrj9vqZB3pkgT0Y5ufrQmGA,16448
-valetudo_map_parser/config/room_outline.py,sha256=D20D-yeyKnlmVbW9lI7bsPtQGn2XkcWow6YNOEPnWVg,4800
-valetudo_map_parser/config/shared.py,sha256=GIEMF-M6BVA6SFBrql7chV7TciWNMLJ8geqwHB0NrW8,11253
-valetudo_map_parser/config/types.py,sha256=e-eZSwbPm3m5JfCDaKhnUFspmcRFSv74huxegkSBDXM,17566
-valetudo_map_parser/config/utils.py,sha256=RsMjpjVqNbkI502yhLiRaB0GjCADqmRRcz-TkC6zklQ,31073
-valetudo_map_parser/hypfer_draw.py,sha256=P8CrKysLaBb63ZArfqxN2Og6JCU6sPHPFHOte5noCGg,26654
-valetudo_map_parser/hypfer_handler.py,sha256=WYFrp-q5wBsy0cTcVQUCXXVGTtW30z2W2dYvjKz2el8,23292
-valetudo_map_parser/hypfer_rooms_handler.py,sha256=NkpOA6Gdq-2D3lLAxvtNuuWMvPXHxeMY2TO5RZLSHlU,22652
-valetudo_map_parser/map_data.py,sha256=zQKE8EzWxR0r0qyfD1QQq51T1wFrpcIeXtnpm92-LXQ,17743
-valetudo_map_parser/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-valetudo_map_parser/rand25_handler.py,sha256=eLFX_gmGLaWQwvp8hVj8CgcNOfLsYNIdE1OLRcQy_yM,19988
-valetudo_map_parser/reimg_draw.py,sha256=1q8LkNTPHEA9Tsapc_JnVw51kpPYNhaBU-KmHkefCQY,12507
-valetudo_map_parser-0.1.9b53.dist-info/LICENSE,sha256=Lh-qBbuRV0-jiCIBhfV7NgdwFxQFOXH3BKOzK865hRs,10480
-valetudo_map_parser-0.1.9b53.dist-info/METADATA,sha256=i8nDujD2s2Qs62WwEv-3AIO23XJTvxvSZXY5QcswEtc,3321
-valetudo_map_parser-0.1.9b53.dist-info/NOTICE.txt,sha256=5lTOuWiU9aiEnJ2go8sc7lTJ7ntMBx0g0GFnNrswCY4,2533
-valetudo_map_parser-0.1.9b53.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-valetudo_map_parser-0.1.9b53.dist-info/RECORD,,