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

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

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

@@ -17,11 +17,12 @@ from .config.types import (
 )
 from .hypfer_handler import HypferMapImageHandler
 from .rand25_handler import ReImageHandler
-from .rooms_handler import RoomsHandler
+from .rooms_handler import RoomsHandler, RandRoomsHandler
 
 
 __all__ = [
     "RoomsHandler",
+    "RandRoomsHandler",
     "HypferMapImageHandler",
     "ReImageHandler",
     "RRMapParser",

{valetudo_map_parser-0.1.9b54 → valetudo_map_parser-0.1.9b56}/SCR/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

{valetudo_map_parser-0.1.9b54 → valetudo_map_parser-0.1.9b56}/SCR/valetudo_map_parser/hypfer_draw.py

@@ -303,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-0.1.9b54 → valetudo_map_parser-0.1.9b56}/SCR/valetudo_map_parser/rand25_handler.py

@@ -29,13 +29,13 @@ from .config.types import (
 )
 from .config.utils import (
     BaseHandler,
-    async_extract_room_outline,
     initialize_drawing_config,
     manage_drawable_elements,
     prepare_resize_params,
 )
 from .map_data import RandImageData
 from .reimg_draw import ImageDraw
+from .rooms_handler import RandRoomsHandler
 
 
 _LOGGER = logging.getLogger(__name__)
@@ -68,38 +68,13 @@ 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
-
-    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.
-
-        Args:
-            room_id_int: The room ID as an integer
-            pixels: List of pixel coordinates in the format [[x, y, z], ...]
-
-        Returns:
-            List of points forming the outline of the room
-        """
-        # Calculate x and y min/max from compressed pixels for rectangular fallback
-        x_values = []
-        y_values = []
-        for x, y, _ in pixels:
-            x_values.append(x)
-            y_values.append(y)
-
-        if not x_values or not y_values:
-            return []
-
-        min_x, max_x = min(x_values), max(x_values)
-        min_y, max_y = min(y_values), max(y_values)
-
-        # Always return a rectangular outline since element_map is removed
-        return [(min_x, min_y), (max_x, min_y), (max_x, max_y), (min_x, max_y)]
+        self.rooms_handler = RandRoomsHandler(self.file_name, self.drawing_config)  # Room data handler
 
     async def extract_room_properties(
         self, json_data: JsonType, destinations: JsonType
     ) -> RoomsProperties:
         """Extract the room properties."""
-        unsorted_id = RandImageData.get_rrm_segments_ids(json_data)
+        # 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)
         try:
@@ -110,62 +85,44 @@ 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, room_data in room_properties.items():
+                self.rooms_pos.append(
+                    {"name": room_data["name"], "outline": room_data["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",
@@ -368,79 +325,189 @@ class ReImageHandler(BaseHandler, AutoCrop):
                 _LOGGER.debug("Got Rooms Attributes.")
         return self.room_propriety
 
+    @staticmethod
+    def point_in_polygon(x: int, y: int, polygon: list) -> bool:
+        """
+        Check if a point is inside a polygon using ray casting algorithm.
+        Enhanced version with better handling of edge cases.
+
+        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
+        """
+        # Ensure we have a valid polygon with at least 3 points
+        if len(polygon) < 3:
+            return False
+
+        # Make sure the polygon is closed (last point equals first point)
+        if polygon[0] != polygon[-1]:
+            polygon = polygon + [polygon[0]]
+
+        # Use winding number algorithm for better accuracy
+        wn = 0  # Winding number counter
+
+        # Loop through all edges of the polygon
+        for i in range(len(polygon) - 1):  # Last vertex is first vertex
+            p1x, p1y = polygon[i]
+            p2x, p2y = polygon[i + 1]
+
+            # Test if a point is left/right/on the edge defined by two vertices
+            if p1y <= y:  # Start y <= P.y
+                if p2y > y:  # End y > P.y (upward crossing)
+                    # Point left of edge
+                    if ((p2x - p1x) * (y - p1y) - (x - p1x) * (p2y - p1y)) > 0:
+                        wn += 1  # Valid up intersect
+            else:  # Start y > P.y
+                if p2y <= y:  # End y <= P.y (downward crossing)
+                    # Point right of edge
+                    if ((p2x - p1x) * (y - p1y) - (x - p1x) * (p2y - p1y)) < 0:
+                        wn -= 1  # Valid down intersect
+
+        # If winding number is not 0, the point is inside the polygon
+        return wn != 0
+
     async def async_get_robot_in_room(
         self, robot_x: int, robot_y: int, angle: float
     ) -> RobotPosition:
         """Get the robot position and return in what room is."""
+        # First check if we already have a cached room and if the robot is still in it
+        if self.robot_in_room:
+            # If we have outline data, use point_in_polygon for accurate detection
+            if "outline" in self.robot_in_room:
+                outline = self.robot_in_room["outline"]
+                if self.point_in_polygon(int(robot_x), int(robot_y), outline):
+                    temp = {
+                        "x": robot_x,
+                        "y": robot_y,
+                        "angle": angle,
+                        "in_room": self.robot_in_room["room"],
+                    }
+                    # Handle active zones
+                    self.active_zones = self.shared.rand256_active_zone
+                    self.zooming = False
+                    if self.active_zones and (
+                        self.robot_in_room["id"]
+                        in range(len(self.active_zones))
+                    ):
+                        self.zooming = bool(
+                            self.active_zones[self.robot_in_room["id"]]
+                        )
+                    else:
+                        self.zooming = False
+                    return temp
+            # Fallback to bounding box check if no outline data
+            elif all(
+                k in self.robot_in_room for k in ["left", "right", "up", "down"]
+            ):
+                if (
+                    (self.robot_in_room["right"] <= int(robot_x) <= self.robot_in_room["left"])
+                    and (self.robot_in_room["up"] <= int(robot_y) <= self.robot_in_room["down"])
+                ):
+                    temp = {
+                        "x": robot_x,
+                        "y": robot_y,
+                        "angle": angle,
+                        "in_room": self.robot_in_room["room"],
+                    }
+                    # Handle active zones
+                    self.active_zones = self.shared.rand256_active_zone
+                    self.zooming = False
+                    if self.active_zones and (
+                        self.robot_in_room["id"]
+                        in range(len(self.active_zones))
+                    ):
+                        self.zooming = bool(
+                            self.active_zones[self.robot_in_room["id"]]
+                        )
+                    else:
+                        self.zooming = False
+                    return temp
 
-        def _check_robot_position(x: int, y: int) -> bool:
-            # Check if the robot coordinates are inside the room's corners
-            return (
-                self.robot_in_room["left"] >= x >= self.robot_in_room["right"]
-                and self.robot_in_room["up"] >= y >= self.robot_in_room["down"]
-            )
+        # If we don't have a cached room or the robot is not in it, search all rooms
+        last_room = None
+        room_count = 0
+        if self.robot_in_room:
+            last_room = self.robot_in_room
 
-        # If the robot coordinates are inside the room's
-        if self.robot_in_room and _check_robot_position(robot_x, robot_y):
+        # Check if the robot is far outside the normal map boundaries
+        # This helps prevent false positives for points very far from any room
+        map_boundary = 50000  # Typical map size is around 25000-30000 units for Rand25
+        if abs(robot_x) > map_boundary or abs(robot_y) > map_boundary:
+            _LOGGER.debug(
+                "%s robot position (%s, %s) is far outside map boundaries.",
+                self.file_name,
+                robot_x,
+                robot_y,
+            )
+            self.robot_in_room = last_room
+            self.zooming = False
             temp = {
                 "x": robot_x,
                 "y": robot_y,
                 "angle": angle,
-                "in_room": self.robot_in_room["room"],
+                "in_room": last_room["room"] if last_room else "unknown",
             }
-            self.active_zones = self.shared.rand256_active_zone
-            self.zooming = False
-            if self.active_zones and (
-                (self.robot_in_room["id"]) in range(len(self.active_zones))
-            ):  # issue #100 Index out of range
-                self.zooming = bool(self.active_zones[self.robot_in_room["id"]])
             return temp
-        # else we need to search and use the async method
-        _LOGGER.debug("%s Changed room.. searching..", self.file_name)
-        room_count = -1
-        last_room = None
 
-        # If no rooms data is available, return a default position
+        # Search through all rooms to find which one contains the robot
         if not self.rooms_pos:
-            _LOGGER.debug("%s: No rooms data available", self.file_name)
-            return {"x": robot_x, "y": robot_y, "angle": angle, "in_room": "unknown"}
+            _LOGGER.debug(
+                "%s: No rooms data available for robot position detection.",
+                self.file_name,
+            )
+            self.robot_in_room = last_room
+            self.zooming = False
+            temp = {
+                "x": robot_x,
+                "y": robot_y,
+                "angle": angle,
+                "in_room": last_room["room"] if last_room else "unknown",
+            }
+            return temp
 
-        # If rooms data is available, search for the room
-        if self.robot_in_room:
-            last_room = self.robot_in_room
+        _LOGGER.debug("%s: Searching for robot in rooms...", self.file_name)
         for room in self.rooms_pos:
-            corners = room["corners"]
+            # Check if the room has an outline (polygon points)
+            if "outline" in room:
+                outline = room["outline"]
+                # Use point_in_polygon for accurate detection with complex shapes
+                if self.point_in_polygon(int(robot_x), int(robot_y), outline):
+                    # Robot is in this room
+                    self.robot_in_room = {
+                        "id": room_count,
+                        "room": str(room["name"]),
+                        "outline": outline,
+                    }
+                    temp = {
+                        "x": robot_x,
+                        "y": robot_y,
+                        "angle": angle,
+                        "in_room": self.robot_in_room["room"],
+                    }
+                    _LOGGER.debug(
+                        "%s is in %s room (polygon detection).",
+                        self.file_name,
+                        self.robot_in_room["room"],
+                    )
+                    return temp
             room_count += 1
-            self.robot_in_room = {
-                "id": room_count,
-                "left": corners[0][0],
-                "right": corners[2][0],
-                "up": corners[0][1],
-                "down": corners[2][1],
-                "room": room["name"],
-            }
-            # Check if the robot coordinates are inside the room's corners
-            if _check_robot_position(robot_x, robot_y):
-                temp = {
-                    "x": robot_x,
-                    "y": robot_y,
-                    "angle": angle,
-                    "in_room": self.robot_in_room["room"],
-                }
-                _LOGGER.debug("%s is in %s", self.file_name, self.robot_in_room["room"])
-                del room, corners, robot_x, robot_y  # free memory.
-                return temp
-        # After checking all rooms and not finding a match
+
+        # Robot not found in any room
         _LOGGER.debug(
-            "%s: Not located within Camera Rooms coordinates.", self.file_name
+            "%s not located within any room coordinates.",
+            self.file_name,
         )
-        self.zooming = False
         self.robot_in_room = last_room
+        self.zooming = False
         temp = {
             "x": robot_x,
             "y": robot_y,
             "angle": angle,
-            "in_room": self.robot_in_room["room"] if self.robot_in_room else "unknown",
+            "in_room": last_room["room"] if last_room else "unknown",
         }
         return temp
 

valetudo_map_parser-0.1.9b56/SCR/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.9b54 → valetudo_map_parser-0.1.9b56}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "valetudo-map-parser"
-version = "0.1.9b54"
+version = "0.1.9b56"
 description = "A Python library to parse Valetudo map data returning a PIL Image object."
 authors = ["Sandro Cantarella <gsca075@gmail.com>"]
 license = "Apache-2.0"

valetudo_map_parser-0.1.9b54/SCR/valetudo_map_parser/rooms_handler.py

@@ -1,225 +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
-
-import time
-from typing import Any, Dict, 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
-
-
-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