valetudo-map-parser 0.1.9b50__py3-none-any.whl → 0.1.9b52__py3-none-any.whl

valetudo_map_parser/config/enhanced_drawable.py

@@ -14,7 +14,11 @@ from typing import Optional, Tuple
 import numpy as np
 
 from .drawable import Drawable
-from .drawable_elements import DrawableElement, DrawingConfig
+from .drawable_elements import (
+    DrawableElement,
+    DrawingConfig,
+)
+from .colors import ColorsManagement
 
 
 # Type aliases
@@ -32,97 +36,13 @@ class EnhancedDrawable(Drawable):
         super().__init__()
         self.drawing_config = drawing_config or DrawingConfig()
 
-    @staticmethod
-    def blend_colors(base_color: Color, overlay_color: Color) -> Color:
-        """
-        Blend two RGBA colors, considering alpha channels.
-
-        Args:
-            base_color: The base RGBA color
-            overlay_color: The overlay RGBA color to blend on top
-
-        Returns:
-            The blended RGBA color
-        """
-        # Extract components
-        r1, g1, b1, a1 = base_color
-        r2, g2, b2, a2 = overlay_color
-
-        # Convert alpha to 0-1 range
-        a1 = a1 / 255.0
-        a2 = a2 / 255.0
-
-        # Calculate resulting alpha
-        a_out = a1 + a2 * (1 - a1)
-
-        # Avoid division by zero
-        if a_out < 0.0001:
-            return (0, 0, 0, 0)
-
-        # Calculate blended RGB components
-        r_out = (r1 * a1 + r2 * a2 * (1 - a1)) / a_out
-        g_out = (g1 * a1 + g2 * a2 * (1 - a1)) / a_out
-        b_out = (b1 * a1 + b2 * a2 * (1 - a1)) / a_out
-
-        # Convert back to 0-255 range and return as tuple
-        return (
-            int(max(0, min(255, int(r_out)))),
-            int(max(0, min(255, int(g_out)))),
-            int(max(0, min(255, int(b_out)))),
-            int(max(0, min(255, int(a_out * 255)))),
-        )
-
-    def blend_pixel(
-        self,
-        array: NumpyArray,
-        x: int,
-        y: int,
-        color: Color,
-        element: DrawableElement,
-        element_map: NumpyArray,
-    ) -> None:
-        """
-        Blend a pixel color with the existing color at the specified position.
-        Also updates the element map if the new element has higher z-index.
-
-        Args:
-            array: The image array to modify
-            x, y: Pixel coordinates
-            color: RGBA color to blend
-            element: The element being drawn
-            element_map: The element map to update
-        """
-        # Check bounds
-        if not (0 <= y < array.shape[0] and 0 <= x < array.shape[1]):
-            return
-
-        # Get current element at this position
-        current_element = element_map[y, x]
-
-        # Get z-indices for comparison
-        current_z = (
-            self.drawing_config.get_property(current_element, "z_index", 0)
-            if current_element
-            else 0
-        )
-        new_z = self.drawing_config.get_property(element, "z_index", 0)
-
-        # Get current color at this position
-        current_color = tuple(array[y, x])
-
-        # Blend colors
-        blended_color = self.blend_colors(current_color, color)
+    # Color blending methods have been moved to ColorsManagement class in colors.py
 
-        # Update pixel color
-        array[y, x] = blended_color
-
-        # Update element map if new element has higher z-index
-        if new_z >= current_z:
-            element_map[y, x] = element
+    # Pixel blending methods have been moved to ColorsManagement class in colors.py
 
     async def draw_map(
         self, map_data: dict, base_array: Optional[NumpyArray] = None
-    ) -> Tuple[NumpyArray, NumpyArray]:
+    ) -> NumpyArray:
         """
         Draw the map with selected elements.
 
@@ -131,7 +51,7 @@ class EnhancedDrawable(Drawable):
             base_array: Optional base array to draw on
 
         Returns:
-            Tuple of (image_array, element_map)
+            The image array with all elements drawn
         """
         # Get map dimensions
         size_x = map_data.get("size", {}).get("x", 1024)
@@ -144,81 +64,48 @@ class EnhancedDrawable(Drawable):
             )
             base_array = await self.create_empty_image(size_x, size_y, background_color)
 
-        # Create a 2D map for element identification
-        element_map = np.zeros(
-            (base_array.shape[0], base_array.shape[1]), dtype=np.int32
-        )
-
         # Draw elements in order of z-index
         for element in self.drawing_config.get_drawing_order():
             if element == DrawableElement.FLOOR:
-                base_array, element_map = await self._draw_floor(
-                    map_data, base_array, element_map
-                )
+                base_array = await self._draw_floor(map_data, base_array)
             elif element == DrawableElement.WALL:
-                base_array, element_map = await self._draw_walls(
-                    map_data, base_array, element_map
-                )
+                base_array = await self._draw_walls(map_data, base_array)
             elif element == DrawableElement.ROBOT:
-                base_array, element_map = await self._draw_robot(
-                    map_data, base_array, element_map
-                )
+                base_array = await self._draw_robot(map_data, base_array)
             elif element == DrawableElement.CHARGER:
-                base_array, element_map = await self._draw_charger(
-                    map_data, base_array, element_map
-                )
+                base_array = await self._draw_charger(map_data, base_array)
             elif element == DrawableElement.VIRTUAL_WALL:
-                base_array, element_map = await self._draw_virtual_walls(
-                    map_data, base_array, element_map
-                )
+                base_array = await self._draw_virtual_walls(map_data, base_array)
             elif element == DrawableElement.RESTRICTED_AREA:
-                base_array, element_map = await self._draw_restricted_areas(
-                    map_data, base_array, element_map
-                )
+                base_array = await self._draw_restricted_areas(map_data, base_array)
             elif element == DrawableElement.NO_MOP_AREA:
-                base_array, element_map = await self._draw_no_mop_areas(
-                    map_data, base_array, element_map
-                )
+                base_array = await self._draw_no_mop_areas(map_data, base_array)
             elif element == DrawableElement.PATH:
-                base_array, element_map = await self._draw_path(
-                    map_data, base_array, element_map
-                )
+                base_array = await self._draw_path(map_data, base_array)
             elif element == DrawableElement.PREDICTED_PATH:
-                base_array, element_map = await self._draw_predicted_path(
-                    map_data, base_array, element_map
-                )
+                base_array = await self._draw_predicted_path(map_data, base_array)
             elif element == DrawableElement.GO_TO_TARGET:
-                base_array, element_map = await self._draw_go_to_target(
-                    map_data, base_array, element_map
-                )
+                base_array = await self._draw_go_to_target(map_data, base_array)
             elif DrawableElement.ROOM_1 <= element <= DrawableElement.ROOM_15:
                 room_id = element - DrawableElement.ROOM_1 + 1
-                base_array, element_map = await self._draw_room(
-                    map_data, room_id, base_array, element_map
-                )
+                base_array = await self._draw_room(map_data, room_id, base_array)
 
-        return base_array, element_map
+        return base_array
 
-    async def _draw_floor(
-        self, map_data: dict, array: NumpyArray, element_map: NumpyArray
-    ) -> Tuple[NumpyArray, NumpyArray]:
+    async def _draw_floor(self, map_data: dict, array: NumpyArray) -> NumpyArray:
         """Draw the floor layer."""
         if not self.drawing_config.is_enabled(DrawableElement.FLOOR):
-            return array, element_map
+            return array
 
         # Implementation depends on the map data format
         # This is a placeholder - actual implementation would use map_data to draw floor
-        # For now, we'll just mark the entire map as floor in the element map
-        element_map[:] = DrawableElement.FLOOR
 
-        return array, element_map
+        return array
 
-    async def _draw_walls(
-        self, map_data: dict, array: NumpyArray, element_map: NumpyArray
-    ) -> Tuple[NumpyArray, NumpyArray]:
+    async def _draw_walls(self, map_data: dict, array: NumpyArray) -> NumpyArray:
         """Draw the walls."""
         if not self.drawing_config.is_enabled(DrawableElement.WALL):
-            return array, element_map
+            return array
 
         # Get wall color from drawing config
         wall_color = self.drawing_config.get_property(
@@ -240,17 +127,19 @@ class EnhancedDrawable(Drawable):
 
         # Draw wall pixels with color blending
         for x, y in wall_pixels:
-            # Use blend_pixel to properly blend colors and update element map
-            self.blend_pixel(array, x, y, wall_color, DrawableElement.WALL, element_map)
+            # Use sample_and_blend_color from ColorsManagement
+            blended_color = ColorsManagement.sample_and_blend_color(
+                array, x, y, wall_color
+            )
+            if 0 <= y < array.shape[0] and 0 <= x < array.shape[1]:
+                array[y, x] = blended_color
 
-        return array, element_map
+        return array
 
-    async def _draw_robot(
-        self, map_data: dict, array: NumpyArray, element_map: NumpyArray
-    ) -> Tuple[NumpyArray, NumpyArray]:
+    async def _draw_robot(self, map_data: dict, array: NumpyArray) -> NumpyArray:
         """Draw the robot."""
         if not self.drawing_config.is_enabled(DrawableElement.ROBOT):
-            return array, element_map
+            return array
 
         # Get robot color from drawing config
         robot_color = self.drawing_config.get_property(
@@ -271,23 +160,18 @@ class EnhancedDrawable(Drawable):
                 for dx in range(-radius, radius + 1):
                     if dx * dx + dy * dy <= radius * radius:
                         map_x, map_y = int(x + dx), int(y + dy)
-                        # Use blend_pixel to properly blend colors and update element map
-                        self.blend_pixel(
-                            array,
-                            map_x,
-                            map_y,
-                            robot_color,
-                            DrawableElement.ROBOT,
-                            element_map,
+                        # Use sample_and_blend_color from ColorsManagement
+                        blended_color = ColorsManagement.sample_and_blend_color(
+                            array, map_x, map_y, robot_color
                         )
-        return array, element_map
+                        if 0 <= map_y < array.shape[0] and 0 <= map_x < array.shape[1]:
+                            array[map_y, map_x] = blended_color
+        return array
 
-    async def _draw_charger(
-        self, map_data: dict, array: NumpyArray, element_map: NumpyArray
-    ) -> Tuple[NumpyArray, NumpyArray]:
+    async def _draw_charger(self, map_data: dict, array: NumpyArray) -> NumpyArray:
         """Draw the charger."""
         if not self.drawing_config.is_enabled(DrawableElement.CHARGER):
-            return array, element_map
+            return array
 
         # Get charger color from drawing config
         charger_color = self.drawing_config.get_property(
@@ -297,14 +181,14 @@ class EnhancedDrawable(Drawable):
         # Implementation depends on the map data format
         # This would extract charger data from map_data and draw it
 
-        return array, element_map
+        return array
 
     async def _draw_virtual_walls(
-        self, map_data: dict, array: NumpyArray, element_map: NumpyArray
-    ) -> Tuple[NumpyArray, NumpyArray]:
+        self, map_data: dict, array: NumpyArray
+    ) -> NumpyArray:
         """Draw virtual walls."""
         if not self.drawing_config.is_enabled(DrawableElement.VIRTUAL_WALL):
-            return array, element_map
+            return array
 
         # Get virtual wall color from drawing config
         wall_color = self.drawing_config.get_property(
@@ -314,14 +198,14 @@ class EnhancedDrawable(Drawable):
         # Implementation depends on the map data format
         # This would extract virtual wall data from map_data and draw it
 
-        return array, element_map
+        return array
 
     async def _draw_restricted_areas(
-        self, map_data: dict, array: NumpyArray, element_map: NumpyArray
-    ) -> Tuple[NumpyArray, NumpyArray]:
+        self, map_data: dict, array: NumpyArray
+    ) -> NumpyArray:
         """Draw restricted areas."""
         if not self.drawing_config.is_enabled(DrawableElement.RESTRICTED_AREA):
-            return array, element_map
+            return array
 
         # Get restricted area color from drawing config
         area_color = self.drawing_config.get_property(
@@ -331,14 +215,12 @@ class EnhancedDrawable(Drawable):
         # Implementation depends on the map data format
         # This would extract restricted area data from map_data and draw it
 
-        return array, element_map
+        return array
 
-    async def _draw_no_mop_areas(
-        self, map_data: dict, array: NumpyArray, element_map: NumpyArray
-    ) -> Tuple[NumpyArray, NumpyArray]:
+    async def _draw_no_mop_areas(self, map_data: dict, array: NumpyArray) -> NumpyArray:
         """Draw no-mop areas."""
         if not self.drawing_config.is_enabled(DrawableElement.NO_MOP_AREA):
-            return array, element_map
+            return array
 
         # Get no-mop area color from drawing config
         area_color = self.drawing_config.get_property(
@@ -348,14 +230,12 @@ class EnhancedDrawable(Drawable):
         # Implementation depends on the map data format
         # This would extract no-mop area data from map_data and draw it
 
-        return array, element_map
+        return array
 
-    async def _draw_path(
-        self, map_data: dict, array: NumpyArray, element_map: NumpyArray
-    ) -> Tuple[NumpyArray, NumpyArray]:
+    async def _draw_path(self, map_data: dict, array: NumpyArray) -> NumpyArray:
         """Draw the robot's path."""
         if not self.drawing_config.is_enabled(DrawableElement.PATH):
-            return array, element_map
+            return array
 
         # Get path color from drawing config
         path_color = self.drawing_config.get_property(
@@ -365,14 +245,14 @@ class EnhancedDrawable(Drawable):
         # Implementation depends on the map data format
         # This would extract path data from map_data and draw it
 
-        return array, element_map
+        return array
 
     async def _draw_predicted_path(
-        self, map_data: dict, array: NumpyArray, element_map: NumpyArray
-    ) -> Tuple[NumpyArray, NumpyArray]:
+        self, map_data: dict, array: NumpyArray
+    ) -> NumpyArray:
         """Draw the predicted path."""
         if not self.drawing_config.is_enabled(DrawableElement.PREDICTED_PATH):
-            return array, element_map
+            return array
 
         # Get predicted path color from drawing config
         path_color = self.drawing_config.get_property(
@@ -382,14 +262,12 @@ class EnhancedDrawable(Drawable):
         # Implementation depends on the map data format
         # This would extract predicted path data from map_data and draw it
 
-        return array, element_map
+        return array
 
-    async def _draw_go_to_target(
-        self, map_data: dict, array: NumpyArray, element_map: NumpyArray
-    ) -> Tuple[NumpyArray, NumpyArray]:
+    async def _draw_go_to_target(self, map_data: dict, array: NumpyArray) -> NumpyArray:
         """Draw the go-to target."""
         if not self.drawing_config.is_enabled(DrawableElement.GO_TO_TARGET):
-            return array, element_map
+            return array
 
         # Get go-to target color from drawing config
         target_color = self.drawing_config.get_property(
@@ -399,15 +277,15 @@ class EnhancedDrawable(Drawable):
         # Implementation depends on the map data format
         # This would extract go-to target data from map_data and draw it
 
-        return array, element_map
+        return array
 
     async def _draw_room(
-        self, map_data: dict, room_id: int, array: NumpyArray, element_map: NumpyArray
-    ) -> Tuple[NumpyArray, NumpyArray]:
+        self, map_data: dict, room_id: int, array: NumpyArray
+    ) -> NumpyArray:
         """Draw a specific room."""
         element = getattr(DrawableElement, f"ROOM_{room_id}")
         if not self.drawing_config.is_enabled(element):
-            return array, element_map
+            return array
 
         # Get room color from drawing config
         room_color = self.drawing_config.get_property(
@@ -436,7 +314,11 @@ class EnhancedDrawable(Drawable):
 
         # Draw room pixels with color blending
         for x, y in room_pixels:
-            # Use blend_pixel to properly blend colors and update element map
-            self.blend_pixel(array, x, y, room_color, element, element_map)
+            # Use sample_and_blend_color from ColorsManagement
+            blended_color = ColorsManagement.sample_and_blend_color(
+                array, x, y, room_color
+            )
+            if 0 <= y < array.shape[0] and 0 <= x < array.shape[1]:
+                array[y, x] = blended_color
 
-        return array, element_map
+        return array

valetudo_map_parser/config/shared.py

@@ -107,7 +107,6 @@ class CameraShared:
         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
-        self.element_map = None  # Map of element codes
 
     def update_user_colors(self, user_colors):
         """Update the user colors."""

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
+from typing import Any, Dict, Optional, Tuple, Union, TypedDict
 
 import numpy as np
 from PIL import Image
@@ -19,17 +19,12 @@ DEFAULT_ROOMS = 1
 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
@@ -77,21 +72,9 @@ class TrimCropData:
 
 
 class RoomStore:
-    """
-    Singleton RoomStore per vacuum_id.
-
-    This class stores room data (a dictionary) for each vacuum.
-    Calling RoomStore(vacuum_id, rooms_data) creates a new instance for that vacuum_id if it doesn't exist,
-    or returns the existing one (optionally updating the data if rooms_data is provided).
-    """
-
     _instances: Dict[str, "RoomStore"] = {}
     _lock = threading.Lock()
 
-    # Declare instance attributes for static analysis tools like Pylint
-    vacuum_id: str
-    vacuums_data: dict
-
     def __new__(cls, vacuum_id: str, rooms_data: Optional[dict] = None) -> "RoomStore":
         with cls._lock:
             if vacuum_id not in cls._instances:
@@ -100,25 +83,17 @@ class RoomStore:
                 instance.vacuums_data = rooms_data or {}
                 cls._instances[vacuum_id] = instance
             else:
-                # Update the instance's data if new rooms_data is provided.
                 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 the stored rooms data."""
         return self.vacuums_data
 
     def set_rooms(self, rooms_data: dict) -> None:
-        """Update the stored rooms data."""
         self.vacuums_data = rooms_data
 
     def get_rooms_count(self) -> int:
-        """
-        Return the number of rooms stored for this vacuum.
-        This is simply the number of keys in the vacuums_data dictionary.
-        If no data is stored, return the default number of rooms.
-        """
         if isinstance(self.vacuums_data, dict):
             count = len(self.vacuums_data)
             return count if count > 0 else DEFAULT_ROOMS
@@ -126,7 +101,6 @@ class RoomStore:
 
     @classmethod
     def get_all_instances(cls) -> Dict[str, "RoomStore"]:
-        """Return all active RoomStore instances (useful for debugging)."""
         return cls._instances
 
 
@@ -220,6 +194,18 @@ 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"
 ATTR_ROTATE = "rotate_image"
 ATTR_CROP = "crop_image"

valetudo_map_parser/config/utils.py

@@ -696,73 +696,6 @@ def blend_pixel(array, x, y, color, element, element_map=None, drawing_config=No
     array[y, x] = blended_color
 
 
-def get_element_at_position(element_map, x, y):
-    """
-    Get the element code at a specific position in the element map.
-
-    Args:
-        element_map: The element map array
-        x: X coordinate
-        y: Y coordinate
-
-    Returns:
-        Element code or None if out of bounds
-    """
-    if element_map is not None:
-        if 0 <= y < element_map.shape[0] and 0 <= x < element_map.shape[1]:
-            return element_map[y, x]
-    return None
-
-
-def get_room_at_position(element_map, x, y, room_base=101):
-    """
-    Get the room ID at a specific position, or None if not a room.
-
-    Args:
-        element_map: The element map array
-        x: X coordinate
-        y: Y coordinate
-        room_base: Base value for room elements (default: 101 for DrawableElement.ROOM_1)
-
-    Returns:
-        Room ID (1-15) or None if not a room
-    """
-    element = get_element_at_position(element_map, x, y)
-    if element is not None and room_base <= element <= room_base + 14:  # 15 rooms max
-        return element - room_base + 1
-    return None
-
-
-def update_element_map_with_robot(
-    element_map, robot_position, robot_element=3, robot_radius=25
-):
-    """
-    Update the element map with the robot position.
-
-    Args:
-        element_map: The element map to update
-        robot_position: Tuple of (x, y) coordinates for the robot
-        robot_element: Element code for the robot (default: 3 for DrawableElement.ROBOT)
-        robot_radius: Radius of the robot in pixels
-
-    Returns:
-        None
-    """
-    if element_map is None or robot_position is None:
-        return
-
-    # Update element map for robot position
-    for dy in range(-robot_radius, robot_radius + 1):
-        for dx in range(-robot_radius, robot_radius + 1):
-            if dx * dx + dy * dy <= robot_radius * robot_radius:
-                rx, ry = (
-                    int(robot_position[0] + dx),
-                    int(robot_position[1] + dy),
-                )
-                if 0 <= ry < element_map.shape[0] and 0 <= rx < element_map.shape[1]:
-                    element_map[ry, rx] = robot_element
-
-
 def manage_drawable_elements(
     handler,
     action,