valetudo-map-parser 0.1.8__py3-none-any.whl → 0.1.9a2__py3-none-any.whl

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.9a2.dist-info/METADATA

@@ -0,0 +1,93 @@
+Metadata-Version: 2.3
+Name: valetudo-map-parser
+Version: 0.1.9a2
+Summary: A Python library to parse Valetudo map data returning a PIL Image object.
+License: Apache-2.0
+Author: Sandro Cantarella
+Author-email: gsca075@gmail.com
+Requires-Python: >=3.12
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: Pillow (>=10.3.0)
+Requires-Dist: numpy (>=1.26.4)
+Requires-Dist: scipy (>=1.12.0)
+Project-URL: Bug Tracker, https://github.com/sca075/Python-package-valetudo-map-parser/issues
+Project-URL: Changelog, https://github.com/sca075/Python-package-valetudo-map-parser/releases
+Project-URL: Homepage, https://github.com/sca075/Python-package-valetudo-map-parser
+Project-URL: Repository, https://github.com/sca075/Python-package-valetudo-map-parser
+Description-Content-Type: text/markdown
+
+# Python-package-valetudo-map-parser
+
+---
+### What is it:
+❗This is an _unofficial_ project and is not created, maintained, or in any sense linked to [valetudo.cloud](https://valetudo.cloud)
+
+A Python library that converts Valetudo vacuum JSON map data into PIL (Python Imaging Library) images. This package is primarily developed for and used in the [MQTT Vacuum Camera](https://github.com/sca075/mqtt_vacuum_camera) project.
+
+---
+
+### Features:
+- Processes map data from Valetudo-compatible robot vacuums
+- Supports both Hypfer and Rand256 vacuum data formats
+- Renders comprehensive map visualizations including:
+  - Walls and obstacles
+  - Robot position and cleaning path
+  - Room segments and boundaries
+  - Cleaning zones
+  - Virtual restrictions
+  - LiDAR data
+- Provides auto-cropping and dynamic zooming
+- Supports image rotation and aspect ratio management
+- Enables custom color schemes
+- Handles multilingual labels
+- Implements thread-safe data sharing
+
+### Installation:
+```bash
+pip install valetudo_map_parser
+```
+
+### Requirements:
+- Python 3.12 or higher
+- Dependencies:
+  - Pillow (PIL) for image processing
+  - NumPy for array operations
+
+### Usage:
+The library is configured using a dictionary format. See our [sample code](https://github.com/sca075/Python-package-valetudo-map-parser/blob/main/tests/test.py) for implementation examples.
+
+Key functionalities:
+- Decodes raw data from Rand256 format
+- Processes JSON data from compatible vacuums
+- Returns Pillow PNG images
+- Provides calibration and room property extraction
+- Supports asynchronous operations
+
+### Development Status:
+Current version: 0.1.9.b41
+- Full functionality available in versions >= 0.1.9
+- Actively maintained and enhanced
+- Uses Poetry for dependency management
+- Implements comprehensive testing
+- Enforces code quality through ruff, isort, and pylint
+
+### Contributing:
+Contributions are welcome! You can help by:
+- Submitting code improvements
+- Enhancing documentation
+- Reporting issues
+- Suggesting new features
+
+### Disclaimer:
+This project is provided "as is" without warranty of any kind. Users assume all risks associated with its use.
+
+### License:
+Apache-2.0
+
+---
+For more information about Valetudo, visit [valetudo.cloud](https://valetudo.cloud)
+Integration with Home Assistant: [MQTT Vacuum Camera](https://github.com/sca075/mqtt_vacuum_camera)
+

valetudo_map_parser-0.1.9a2.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=Yd0MlAH6DaAfqxrUw1NW2uHxYoLe9IwKxyFowQ6VJWg,12133
+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=L1eM8dDLNsi4SOUt9499v9jLbQa1MwDKPfMYHcUEsXQ,26722
+valetudo_map_parser/hypfer_handler.py,sha256=f7y5It8tr__FCadojQsk_FPuMgsnjyUST1scXLZ1tws,20108
+valetudo_map_parser/hypfer_rooms_handler.py,sha256=NkpOA6Gdq-2D3lLAxvtNuuWMvPXHxeMY2TO5RZLSHlU,22652
+valetudo_map_parser/map_data.py,sha256=3CG3l_fWeEwWCT5j9nfnqPuClU01m7exwuYWV3K9jIk,18618
+valetudo_map_parser/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+valetudo_map_parser/rand25_handler.py,sha256=EKf7dhBtLKt_lEFi3hiJwSL0wgX0ZmvWlNMPxS8TDQE,22875
+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.9a2.dist-info/LICENSE,sha256=Lh-qBbuRV0-jiCIBhfV7NgdwFxQFOXH3BKOzK865hRs,10480
+valetudo_map_parser-0.1.9a2.dist-info/METADATA,sha256=DZkyXziGLLJ2QK6P29Unz2P8tBWHVbJNUYe072gg5yU,3320
+valetudo_map_parser-0.1.9a2.dist-info/NOTICE.txt,sha256=5lTOuWiU9aiEnJ2go8sc7lTJ7ntMBx0g0GFnNrswCY4,2533
+valetudo_map_parser-0.1.9a2.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+valetudo_map_parser-0.1.9a2.dist-info/RECORD,,

{valetudo_map_parser-0.1.8.dist-info → valetudo_map_parser-0.1.9a2.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.0.0
+Generator: poetry-core 2.1.3
 Root-Is-Purelib: true
 Tag: py3-none-any