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

valetudo_map_parser/config/room_outline.py

@@ -0,0 +1,148 @@
+"""
+Room Outline Extraction Utilities.
+Uses scipy for efficient room outline extraction.
+Version: 0.1.9
+"""
+
+from __future__ import annotations
+
+import numpy as np
+from scipy import ndimage
+
+from .types import LOGGER
+
+
+async def extract_room_outline_with_scipy(
+    room_mask, min_x, min_y, max_x, max_y, file_name=None, room_id=None
+):
+    """Extract a room outline using scipy for contour finding.
+
+    Args:
+        room_mask: Binary mask of the room (1 for room, 0 for non-room)
+        min_x, min_y, max_x, max_y: Bounding box coordinates
+        file_name: Optional file name for logging
+        room_id: Optional room ID for logging
+
+    Returns:
+        List of points forming the outline of the room
+    """
+    # If the mask is empty, return a rectangular outline
+    if np.sum(room_mask) == 0:
+        LOGGER.warning(
+            "%s: Empty room mask for room %s, using rectangular outline",
+            file_name or "RoomOutline",
+            str(room_id) if room_id is not None else "unknown",
+        )
+        return [(min_x, min_y), (max_x, min_y), (max_x, max_y), (min_x, max_y)]
+
+    # Use scipy to clean up the mask (remove noise, fill holes)
+    # Fill small holes
+    room_mask = ndimage.binary_fill_holes(room_mask).astype(np.uint8)
+
+    # Remove small objects
+    labeled_array, num_features = ndimage.label(room_mask)
+    if num_features > 1:
+        # Find the largest connected component
+        component_sizes = np.bincount(labeled_array.ravel())[1:]
+        largest_component = np.argmax(component_sizes) + 1
+        room_mask = (labeled_array == largest_component).astype(np.uint8)
+
+    # Find the boundary points by tracing the perimeter
+    boundary_points = []
+    height, width = room_mask.shape
+
+    # Scan horizontally (top and bottom edges)
+    for x in range(width):
+        # Top edge
+        for y in range(height):
+            if room_mask[y, x] == 1:
+                boundary_points.append((x + min_x, y + min_y))
+                break
+
+        # Bottom edge
+        for y in range(height - 1, -1, -1):
+            if room_mask[y, x] == 1:
+                boundary_points.append((x + min_x, y + min_y))
+                break
+
+    # Scan vertically (left and right edges)
+    for y in range(height):
+        # Left edge
+        for x in range(width):
+            if room_mask[y, x] == 1:
+                boundary_points.append((x + min_x, y + min_y))
+                break
+
+        # Right edge
+        for x in range(width - 1, -1, -1):
+            if room_mask[y, x] == 1:
+                boundary_points.append((x + min_x, y + min_y))
+                break
+
+    # Remove duplicates while preserving order
+    unique_points = []
+    for point in boundary_points:
+        if point not in unique_points:
+            unique_points.append(point)
+
+    # If we have too few points, return a simple rectangle
+    if len(unique_points) < 4:
+        LOGGER.warning(
+            "%s: Too few boundary points for room %s, using rectangular outline",
+            file_name or "RoomOutline",
+            str(room_id) if room_id is not None else "unknown",
+        )
+        return [(min_x, min_y), (max_x, min_y), (max_x, max_y), (min_x, max_y)]
+
+    # Simplify the outline by keeping only significant points
+    simplified = simplify_outline(unique_points, tolerance=5)
+
+    LOGGER.debug(
+        "%s: Extracted outline for room %s with %d points",
+        file_name or "RoomOutline",
+        str(room_id) if room_id is not None else "unknown",
+        len(simplified),
+    )
+
+    return simplified
+
+
+def simplify_outline(points, tolerance=5):
+    """Simplify an outline by removing points that don't contribute much to the shape."""
+    if len(points) <= 4:
+        return points
+
+    # Start with the first point
+    simplified = [points[0]]
+
+    # Process remaining points
+    for i in range(1, len(points) - 1):
+        # Get previous and next points
+        prev = simplified[-1]
+        current = points[i]
+        next_point = points[i + 1]
+
+        # Calculate vectors
+        v1 = (current[0] - prev[0], current[1] - prev[1])
+        v2 = (next_point[0] - current[0], next_point[1] - current[1])
+
+        # Calculate change in direction
+        dot_product = v1[0] * v2[0] + v1[1] * v2[1]
+        len_v1 = (v1[0] ** 2 + v1[1] ** 2) ** 0.5
+        len_v2 = (v2[0] ** 2 + v2[1] ** 2) ** 0.5
+
+        # Avoid division by zero
+        if len_v1 == 0 or len_v2 == 0:
+            continue
+
+        # Calculate cosine of angle between vectors
+        cos_angle = dot_product / (len_v1 * len_v2)
+
+        # If angle is significant or distance is large, keep the point
+        if abs(cos_angle) < 0.95 or len_v1 > tolerance or len_v2 > tolerance:
+            simplified.append(current)
+
+    # Add the last point
+    simplified.append(points[-1])
+
+    return simplified

valetudo_map_parser/config/shared.py

@@ -6,10 +6,13 @@ Version: v2024.12.0
 
 import asyncio
 import logging
+from typing import List
 
 from .types import (
     ATTR_CALIBRATION_POINTS,
+    ATTR_CAMERA_MODE,
     ATTR_MARGINS,
+    ATTR_OBSTACLES,
     ATTR_POINTS,
     ATTR_ROOMS,
     ATTR_ROTATE,
@@ -19,8 +22,6 @@ from .types import (
     ATTR_VACUUM_POSITION,
     ATTR_VACUUM_STATUS,
     ATTR_ZONES,
-    ATTR_CAMERA_MODE,
-    ATTR_OBSTACLES,
     CONF_ASPECT_RATIO,
     CONF_AUTO_ZOOM,
     CONF_OFFSET_BOTTOM,
@@ -35,8 +36,10 @@ from .types import (
     CONF_ZOOM_LOCK_RATIO,
     DEFAULT_VALUES,
     CameraModes,
+    Colors,
+    TrimsData,
 )
-from .types import Colors
+
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -85,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
@@ -99,8 +103,50 @@ class CameraShared:
         self.map_pred_points = None  # Predefined points data
         self.map_new_path = None  # New path data
         self.map_old_path = None  # Old path data
-        self.trim_crop_data = None
         self.user_language = None  # User language
+        self.trim_crop_data = None
+        self.trims = TrimsData.from_dict(DEFAULT_VALUES["trims_data"])  # Trims data
+        self.skip_room_ids: List[str] = []
+        self.device_info = None  # Store the device_info
+
+    @staticmethod
+    def _compose_obstacle_links(vacuum_host_ip: str, obstacles: list) -> list | None:
+        """
+        Compose JSON with obstacle details including the image link.
+        """
+        obstacle_links = []
+        if not obstacles or not vacuum_host_ip:
+            return None
+
+        for obstacle in obstacles:
+            # Extract obstacle details
+            label = obstacle.get("label", "")
+            points = obstacle.get("points", {})
+            image_id = obstacle.get("id", "None")
+
+            if label and points and image_id and vacuum_host_ip:
+                # Append formatted obstacle data
+                if image_id != "None":
+                    # Compose the link
+                    image_link = (
+                        f"http://{vacuum_host_ip}"
+                        f"/api/v2/robot/capabilities/ObstacleImagesCapability/img/{image_id}"
+                    )
+                    obstacle_links.append(
+                        {
+                            "point": points,
+                            "label": label,
+                            "link": image_link,
+                        }
+                    )
+                else:
+                    obstacle_links.append(
+                        {
+                            "point": points,
+                            "label": label,
+                        }
+                    )
+        return obstacle_links
 
     def update_user_colors(self, user_colors):
         """Update the user colors."""
@@ -118,6 +164,11 @@ class CameraShared:
         """Get the rooms colors."""
         return self.rooms_colors
 
+    def reset_trims(self) -> dict:
+        """Reset the trims."""
+        self.trims = TrimsData.from_dict(DEFAULT_VALUES["trims_data"])
+        return self.trims
+
     async def batch_update(self, **kwargs):
         """Batch update multiple attributes."""
         for key, value in kwargs.items():
@@ -137,7 +188,11 @@ class CameraShared:
             ATTR_VACUUM_JSON_ID: self.vac_json_id,
             ATTR_CALIBRATION_POINTS: self.attr_calibration_points,
         }
-        if self.obstacles_data:
+        if self.obstacles_pos and self.vacuum_ips:
+            _LOGGER.debug("Generating obstacle links from: %s", self.obstacles_pos)
+            self.obstacles_data =  self._compose_obstacle_links(
+                self.vacuum_ips, self.obstacles_pos
+            )
             attrs[ATTR_OBSTACLES] = self.obstacles_data
 
         if self.enable_snapshots:
@@ -167,6 +222,7 @@ class CameraSharedManager:
         self._lock = asyncio.Lock()
         self.file_name = file_name
         self.device_info = device_info
+        self.update_shared_data(device_info)
 
         # Automatically initialize shared data for the instance
         # self._init_shared_data(device_info)
@@ -176,6 +232,12 @@ class CameraSharedManager:
         instance = self.get_instance()  # Retrieve the correct instance
 
         try:
+            # Store the device_info in the instance
+            instance.device_info = device_info
+            _LOGGER.info(
+                "%s: Stored device_info in shared instance", instance.file_name
+            )
+
             instance.attr_calibration_points = None
 
             # Initialize shared data with defaults from DEFAULT_VALUES
@@ -218,11 +280,16 @@ class CameraSharedManager:
             instance.vacuum_status_position = device_info.get(
                 CONF_VAC_STAT_POS, DEFAULT_VALUES["vac_status_position"]
             )
-
             # If enable_snapshots, check for png in www.
             instance.enable_snapshots = device_info.get(
                 CONF_SNAPSHOTS_ENABLE, DEFAULT_VALUES["enable_www_snapshots"]
             )
+            # Ensure trims are updated correctly
+            trim_data = device_info.get("trims_data", DEFAULT_VALUES["trims_data"])
+            _LOGGER.debug(
+                "%s: Updating shared trims with: %s", instance.file_name, trim_data
+            )
+            instance.trims = TrimsData.from_dict(trim_data)
 
         except TypeError as ex:
             _LOGGER.error("Shared data can't be initialized due to a TypeError! %s", ex)

valetudo_map_parser/config/types.py

@@ -4,29 +4,27 @@ Version 0.0.1
 """
 
 import asyncio
-from dataclasses import dataclass
 import json
 import logging
-from typing import Any, Dict, Tuple, Union
+import threading
+from dataclasses import asdict, dataclass
+from typing import Any, Dict, Optional, Tuple, TypedDict, Union
 
-from PIL import Image
 import numpy as np
+from PIL import Image
+
 
 DEFAULT_ROOMS = 1
 
-MY_LOGGER = logging.getLogger(__name__)
+LOGGER = logging.getLogger(__package__)
 
-Color = Union[Tuple[int, int, int], Tuple[int, int, int, int]]
-Colors = Dict[str, Color]
-CalibrationPoints = list[dict[str, Any]]
-RobotPosition = dict[str, int | float]
-ChargerPosition = dict[str, Any]
-RoomsProperties = dict[str, dict[str, int | list[tuple[Any, Any]]]]
-ImageSize = dict[str, int | list[int]]
-JsonType = Any  # json.loads() return type is Any
-PilPNG = Image.Image
-NumpyArray = np.ndarray
-Point = Tuple[int, int]
+
+class RoomProperty(TypedDict):
+    number: int
+    outline: list[tuple[int, int]]
+    name: str
+    x: int
+    y: int
 
 
 # pylint: disable=no-member
@@ -73,43 +71,37 @@ class TrimCropData:
         )
 
 
-# pylint: disable=no-member
 class RoomStore:
-    """Store the room data for the vacuum."""
-
-    _instance = None
-    _lock = asyncio.Lock()
-
-    def __init__(self):
-        self.vacuums_data = {}
-
-    def __new__(cls):
-        if cls._instance is None:
-            cls._instance = super(RoomStore, cls).__new__(cls)
-            cls._instance.vacuums_data = {}
-        return cls._instance
-
-    async def async_set_rooms_data(self, vacuum_id: str, rooms_data: dict) -> None:
-        """Set the room data for the vacuum."""
-        async with self._lock:
-            self.vacuums_data[vacuum_id] = rooms_data
+    _instances: Dict[str, "RoomStore"] = {}
+    _lock = threading.Lock()
+
+    def __new__(cls, vacuum_id: str, rooms_data: Optional[dict] = None) -> "RoomStore":
+        with cls._lock:
+            if vacuum_id not in cls._instances:
+                instance = super(RoomStore, cls).__new__(cls)
+                instance.vacuum_id = vacuum_id
+                instance.vacuums_data = rooms_data or {}
+                cls._instances[vacuum_id] = instance
+            else:
+                if rooms_data is not None:
+                    cls._instances[vacuum_id].vacuums_data = rooms_data
+        return cls._instances[vacuum_id]
+
+    def get_rooms(self) -> dict:
+        return self.vacuums_data
+
+    def set_rooms(self, rooms_data: dict) -> None:
+        self.vacuums_data = rooms_data
+
+    def get_rooms_count(self) -> int:
+        if isinstance(self.vacuums_data, dict):
+            count = len(self.vacuums_data)
+            return count if count > 0 else DEFAULT_ROOMS
+        return DEFAULT_ROOMS
 
-    async def async_get_rooms_data(self, vacuum_id: str) -> dict:
-        """Get the room data for a vacuum."""
-        async with self._lock:
-            data = self.vacuums_data.get(vacuum_id, {})
-            if isinstance(data, str):
-                json_data = json.loads(data)
-                return json_data
-            return data
-
-    async def async_get_rooms_count(self, vacuum_id: str) -> int:
-        """Count the number of rooms for a vacuum."""
-        async with self._lock:
-            count = len(self.vacuums_data.get(vacuum_id, {}))
-            if count == 0:
-                return DEFAULT_ROOMS
-            return count
+    @classmethod
+    def get_all_instances(cls) -> Dict[str, "RoomStore"]:
+        return cls._instances
 
 
 # pylint: disable=no-member
@@ -202,8 +194,19 @@ class SnapshotStore:
             self.vacuum_json_data[vacuum_id] = json_data
 
 
+Color = Union[Tuple[int, int, int], Tuple[int, int, int, int]]
+Colors = Dict[str, Color]
+CalibrationPoints = list[dict[str, Any]]
+RobotPosition = dict[str, int | float]
+ChargerPosition = dict[str, Any]
+RoomsProperties = dict[str, RoomProperty]
+ImageSize = dict[str, int | list[int]]
+JsonType = Any  # json.loads() return type is Any
+PilPNG = Image.Image
+NumpyArray = np.ndarray
+Point = Tuple[int, int]
+
 CAMERA_STORAGE = "valetudo_camera"
-DEFAULT_ROOMS = 1  # 15 is the maximum number of rooms.
 ATTR_ROTATE = "rotate_image"
 ATTR_CROP = "crop_image"
 ATTR_MARGINS = "margins"
@@ -284,6 +287,7 @@ DEFAULT_VALUES = {
     "vac_status_position": True,
     "get_svg_file": False,
     "save_trims": True,
+    "trims_data": {"trim_left": 0, "trim_up": 0, "trim_right": 0, "trim_down": 0},
     "enable_www_snapshots": False,
     "color_charger": [255, 128, 0],
     "color_move": [238, 247, 255],
@@ -345,6 +349,7 @@ KEYS_TO_UPDATE = [
     "offset_bottom",
     "offset_left",
     "offset_right",
+    "trims_data",
     "auto_zoom",
     "zoom_lock_ratio",
     "show_vac_status",
@@ -588,3 +593,49 @@ class CameraModes:
     CAMERA_STANDBY = "camera_standby"
     CAMERA_OFF = False
     CAMERA_ON = True
+
+
+# noinspection PyTypeChecker
+@dataclass
+class TrimsData:
+    """Dataclass to store and manage trims data."""
+
+    floor: str = ""
+    trim_up: int = 0
+    trim_left: int = 0
+    trim_down: int = 0
+    trim_right: int = 0
+
+    @classmethod
+    def from_json(cls, json_data: str):
+        """Create a TrimsConfig instance from a JSON string."""
+        data = json.loads(json_data)
+        return cls(
+            floor=data.get("floor", ""),
+            trim_up=data.get("trim_up", 0),
+            trim_left=data.get("trim_left", 0),
+            trim_down=data.get("trim_down", 0),
+            trim_right=data.get("trim_right", 0),
+        )
+
+    def to_json(self) -> str:
+        """Convert TrimsConfig instance to a JSON string."""
+        return json.dumps(asdict(self))
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        """Initialize TrimData from a dictionary."""
+        return cls(**data)
+
+    def to_dict(self) -> dict:
+        """Convert TrimData to a dictionary."""
+        return asdict(self)
+
+    def clear(self) -> dict:
+        """Clear all the trims."""
+        self.floor = ""
+        self.trim_up = 0
+        self.trim_left = 0
+        self.trim_down = 0
+        self.trim_right = 0
+        return asdict(self)