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

valetudo_map_parser/__init__.py

@@ -1,33 +1,40 @@
 """Valetudo map parser.
-Version: 0.1.8"""
+Version: 0.1.9"""
 
-from .hypfer_handler import HypferMapImageHandler
-from .rand25_handler import ReImageHandler
+from .config.colors import ColorsManagement
+from .config.drawable import Drawable
+from .config.drawable_elements import DrawableElement, DrawingConfig
+from .config.enhanced_drawable import EnhancedDrawable
 from .config.rand25_parser import RRMapParser
 from .config.shared import CameraShared, CameraSharedManager
-from .config.colors import ColorsManagment
-from .config.drawable import Drawable
 from .config.types import (
-    SnapshotStore,
-    UserLanguageStore,
-    RoomStore,
+    CameraModes,
     RoomsProperties,
+    RoomStore,
+    SnapshotStore,
     TrimCropData,
-    CameraModes,
+    UserLanguageStore,
 )
+from .hypfer_handler import HypferMapImageHandler
+from .rand25_handler import ReImageHandler
+from .rooms_handler import RoomsHandler, RandRoomsHandler
+
 
 __all__ = [
+    "RoomsHandler",
+    "RandRoomsHandler",
     "HypferMapImageHandler",
     "ReImageHandler",
     "RRMapParser",
     "CameraShared",
     "CameraSharedManager",
-    "ColorsManagment",
+    "ColorsManagement",
     "Drawable",
+    "DrawableElement",
+    "DrawingConfig",
+    "EnhancedDrawable",
     "SnapshotStore",
     "UserLanguageStore",
-    "UserLanguageStore",
-    "SnapshotStore",
     "RoomStore",
     "RoomsProperties",
     "TrimCropData",

valetudo_map_parser/config/auto_crop.py

@@ -8,7 +8,9 @@ import logging
 import numpy as np
 from numpy import rot90
 
-from .types import Color, NumpyArray, TrimCropData
+from .types import Color, NumpyArray, TrimCropData, TrimsData
+from .utils import BaseHandler
+
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -24,20 +26,39 @@ class TrimError(Exception):
 class AutoCrop:
     """Auto Crop Class for trimming and zooming images."""
 
-    def __init__(self, image_handler):
-        self.imh = image_handler
-        self.file_name = self.imh.file_name
-        # self.path_to_data = self.hass.config.path(
-        #     STORAGE_DIR, CAMERA_STORAGE, f"auto_crop_{self.file_name}.json"
-        # )
+    def __init__(self, handler: BaseHandler):
+        self.auto_crop = None  # auto crop data to be calculate once.
+        self.crop_area = None
+        self.handler = handler
+        trim_data = self.handler.shared.trims.to_dict()  # trims data
+        self.trim_up = trim_data.get("trim_up", 0)  # trim up
+        self.trim_down = trim_data.get("trim_down", 0)  # trim down
+        self.trim_left = trim_data.get("trim_left", 0)  # trim left
+        self.trim_right = trim_data.get("trim_right", 0)  # trim right
+        self.offset_top = self.handler.shared.offset_top  # offset top
+        self.offset_bottom = self.handler.shared.offset_down  # offset bottom
+        self.offset_left = self.handler.shared.offset_left  # offset left
+        self.offset_right = self.handler.shared.offset_right  # offset right
+
+    @staticmethod
+    def validate_crop_dimensions(shared):
+        """Ensure width and height are valid before processing cropping."""
+        if shared.image_ref_width <= 0 or shared.image_ref_height <= 0:
+            _LOGGER.warning(
+                "Auto-crop failed: Invalid dimensions (width=%s, height=%s). Using original image.",
+                shared.image_ref_width,
+                shared.image_ref_height,
+            )
+            return False
+        return True
 
     def check_trim(
         self, trimmed_height, trimmed_width, margin_size, image_array, file_name, rotate
     ):
         """Check if the trim is okay."""
         if trimmed_height <= margin_size or trimmed_width <= margin_size:
-            self.imh.crop_area = [0, 0, image_array.shape[1], image_array.shape[0]]
-            self.imh.img_size = (image_array.shape[1], image_array.shape[0])
+            self.crop_area = [0, 0, image_array.shape[1], image_array.shape[0]]
+            self.handler.img_size = (image_array.shape[1], image_array.shape[0])
             raise TrimError(
                 f"{file_name}: Trimming failed at rotation {rotate}.", image_array
             )
@@ -45,89 +66,106 @@ class AutoCrop:
     def _calculate_trimmed_dimensions(self):
         """Calculate and update the dimensions after trimming."""
         trimmed_width = max(
-            0,
-            (
-                (self.imh.trim_right - self.imh.offset_right)
-                - (self.imh.trim_left + self.imh.offset_left)
-            ),
+            1,  # Ensure at least 1px
+            (self.trim_right - self.offset_right) - (self.trim_left + self.offset_left),
         )
         trimmed_height = max(
-            0,
-            (
-                (self.imh.trim_down - self.imh.offset_bottom)
-                - (self.imh.trim_up + self.imh.offset_top)
-            ),
+            1,  # Ensure at least 1px
+            (self.trim_down - self.offset_bottom) - (self.trim_up + self.offset_top),
         )
+
         # Ensure shared reference dimensions are updated
-        if hasattr(self.imh.shared, "image_ref_height") and hasattr(
-            self.imh.shared, "image_ref_width"
+        if hasattr(self.handler.shared, "image_ref_height") and hasattr(
+            self.handler.shared, "image_ref_width"
         ):
-            self.imh.shared.image_ref_height = trimmed_height
-            self.imh.shared.image_ref_width = trimmed_width
+            self.handler.shared.image_ref_height = trimmed_height
+            self.handler.shared.image_ref_width = trimmed_width
         else:
             _LOGGER.warning(
                 "Shared attributes for image dimensions are not initialized."
             )
+
         return trimmed_width, trimmed_height
 
-    async def _async_auto_crop_data(self, tdata=None):
+    async def _async_auto_crop_data(self, tdata: TrimsData):  # , tdata=None
         """Load the auto crop data from the Camera config."""
-        # todo: implement this method but from config data
-        # if not self.imh.auto_crop:
-        #     trims_data = TrimCropData.from_dict(dict(tdata)).to_list()
-        #     (
-        #         self.imh.trim_left,
-        #         self.imh.trim_up,
-        #         self.imh.trim_right,
-        #         self.imh.trim_down,
-        #     ) = trims_data
-        #     self._calculate_trimmed_dimensions()
-        #     return trims_data
+        _LOGGER.debug("Auto Crop data: %s, %s", str(tdata), str(self.auto_crop))
+        if not self.auto_crop:
+            trims_data = TrimCropData.from_dict(dict(tdata.to_dict())).to_list()
+            (
+                self.trim_left,
+                self.trim_up,
+                self.trim_right,
+                self.trim_down,
+            ) = trims_data
+            _LOGGER.debug("Auto Crop trims data: %s", trims_data)
+            if trims_data != [0, 0, 0, 0]:
+                self._calculate_trimmed_dimensions()
+            else:
+                trims_data = None
+            return trims_data
         return None
 
     def auto_crop_offset(self):
         """Calculate the offset for the auto crop."""
-        if self.imh.auto_crop:
-            self.imh.auto_crop[0] += self.imh.offset_left
-            self.imh.auto_crop[1] += self.imh.offset_top
-            self.imh.auto_crop[2] -= self.imh.offset_right
-            self.imh.auto_crop[3] -= self.imh.offset_bottom
+        if self.auto_crop:
+            self.auto_crop[0] += self.offset_left
+            self.auto_crop[1] += self.offset_top
+            self.auto_crop[2] -= self.offset_right
+            self.auto_crop[3] -= self.offset_bottom
 
     async def _init_auto_crop(self):
         """Initialize the auto crop data."""
-        if not self.imh.auto_crop and self.imh.shared.vacuum_state == "docked":
-            self.imh.auto_crop = await self._async_auto_crop_data()
-            if self.imh.auto_crop:
+        _LOGGER.debug("Auto Crop Init data: %s", str(self.auto_crop))
+        _LOGGER.debug(
+            "Auto Crop Init trims data: %r", self.handler.shared.trims.to_dict()
+        )
+        if not self.auto_crop:  # and self.handler.shared.vacuum_state == "docked":
+            self.auto_crop = await self._async_auto_crop_data(self.handler.shared.trims)
+            if self.auto_crop:
                 self.auto_crop_offset()
         else:
-            self.imh.max_frames = 5
-        return self.imh.auto_crop
-
-    # async def _async_save_auto_crop_data(self):
-    #     """Save the auto crop data to the disk."""
-    #     try:
-    #         if not os.path.exists(self.path_to_data):
-    #             data = TrimCropData(
-    #                 self.imh.trim_left,
-    #                 self.imh.trim_up,
-    #                 self.imh.trim_right,
-    #                 self.imh.trim_down,
-    #             ).to_dict()
-    #     except Exception as e:
-    #         _LOGGER.error(f"Failed to save trim data due to an error: {e}")
+            self.handler.max_frames = 1205
+
+        # Fallback: Ensure auto_crop is valid
+        if not self.auto_crop or any(v < 0 for v in self.auto_crop):
+            _LOGGER.debug("Auto-crop data unavailable. Scanning full image.")
+            self.auto_crop = None
+
+        return self.auto_crop
 
     async def async_image_margins(
         self, image_array: NumpyArray, detect_colour: Color
     ) -> tuple[int, int, int, int]:
-        """Crop the image based on the auto crop area."""
-        nonzero_coords = np.column_stack(np.where(image_array != list(detect_colour)))
-        # Calculate the trim box based on the first and last occurrences
-        min_y, min_x, _ = NumpyArray.min(nonzero_coords, axis=0)
-        max_y, max_x, _ = NumpyArray.max(nonzero_coords, axis=0)
-        del nonzero_coords
+        """Crop the image based on the auto crop area using scipy.ndimage for better performance."""
+        # Import scipy.ndimage here to avoid import at module level
+        from scipy import ndimage
+
+        # Create a binary mask where True = non-background pixels
+        # This is much more memory efficient than storing coordinates
+        mask = ~np.all(image_array == list(detect_colour), axis=2)
+
+        # Use scipy.ndimage.find_objects to efficiently find the bounding box
+        # This returns a list of slice objects that define the bounding box
+        # Label the mask with a single label (1) and find its bounding box
+        labeled_mask = mask.astype(np.int8)  # Convert to int8 (smallest integer type)
+        objects = ndimage.find_objects(labeled_mask)
+
+        if not objects:  # No objects found
+            _LOGGER.warning(
+                "%s: No non-background pixels found in image", self.handler.file_name
+            )
+            # Return full image dimensions as fallback
+            return 0, 0, image_array.shape[1], image_array.shape[0]
+
+        # Extract the bounding box coordinates from the slice objects
+        y_slice, x_slice = objects[0]
+        min_y, max_y = y_slice.start, y_slice.stop - 1
+        min_x, max_x = x_slice.start, x_slice.stop - 1
+
         _LOGGER.debug(
             "%s: Found trims max and min values (y,x) (%s, %s) (%s, %s)...",
-            self.file_name,
+            self.handler.file_name,
             int(max_y),
             int(max_x),
             int(min_y),
@@ -142,38 +180,53 @@ class AutoCrop:
         zoom: bool = False,
         rand256: bool = False,
     ) -> NumpyArray:
-        """Check if the image need to be zoom."""
+        """Check if the image needs to be zoomed."""
 
         if (
             zoom
-            and self.imh.shared.vacuum_state == "cleaning"
-            and self.imh.shared.image_auto_zoom
+            and self.handler.shared.vacuum_state == "cleaning"
+            and self.handler.shared.image_auto_zoom
         ):
-            # Zoom the image based on the robot's position.
             _LOGGER.debug(
                 "%s: Zooming the image on room %s.",
-                self.file_name,
-                self.imh.robot_in_room["room"],
+                self.handler.file_name,
+                self.handler.robot_in_room["room"],
             )
+
             if rand256:
-                trim_left = round(self.imh.robot_in_room["right"] / 10) - margin_size
-                trim_right = round(self.imh.robot_in_room["left"] / 10) + margin_size
-                trim_up = round(self.imh.robot_in_room["down"] / 10) - margin_size
-                trim_down = round(self.imh.robot_in_room["up"] / 10) + margin_size
+                trim_left = (
+                    round(self.handler.robot_in_room["right"] / 10) - margin_size
+                )
+                trim_right = (
+                    round(self.handler.robot_in_room["left"] / 10) + margin_size
+                )
+                trim_up = round(self.handler.robot_in_room["down"] / 10) - margin_size
+                trim_down = round(self.handler.robot_in_room["up"] / 10) + margin_size
             else:
-                trim_left = self.imh.robot_in_room["left"] - margin_size
-                trim_right = self.imh.robot_in_room["right"] + margin_size
-                trim_up = self.imh.robot_in_room["up"] - margin_size
-                trim_down = self.imh.robot_in_room["down"] + margin_size
+                trim_left = self.handler.robot_in_room["left"] - margin_size
+                trim_right = self.handler.robot_in_room["right"] + margin_size
+                trim_up = self.handler.robot_in_room["up"] - margin_size
+                trim_down = self.handler.robot_in_room["down"] + margin_size
+
+            # Ensure valid trim values
             trim_left, trim_right = sorted([trim_left, trim_right])
             trim_up, trim_down = sorted([trim_up, trim_down])
+
+            # Prevent zero-sized images
+            if trim_right - trim_left < 1 or trim_down - trim_up < 1:
+                _LOGGER.warning(
+                    "Zooming resulted in an invalid crop area. Using full image."
+                )
+                return image_array  # Return original image
+
             trimmed = image_array[trim_up:trim_down, trim_left:trim_right]
+
         else:
-            # Apply the auto-calculated trims to the rotated image
             trimmed = image_array[
-                self.imh.auto_crop[1] : self.imh.auto_crop[3],
-                self.imh.auto_crop[0] : self.imh.auto_crop[2],
+                self.auto_crop[1] : self.auto_crop[3],
+                self.auto_crop[0] : self.auto_crop[2],
             ]
+
         return trimmed
 
     async def async_rotate_the_image(
@@ -182,26 +235,26 @@ class AutoCrop:
         """Rotate the image and return the new array."""
         if rotate == 90:
             rotated = rot90(trimmed)
-            self.imh.crop_area = [
-                self.imh.trim_left,
-                self.imh.trim_up,
-                self.imh.trim_right,
-                self.imh.trim_down,
+            self.crop_area = [
+                self.trim_left,
+                self.trim_up,
+                self.trim_right,
+                self.trim_down,
             ]
         elif rotate == 180:
             rotated = rot90(trimmed, 2)
-            self.imh.crop_area = self.imh.auto_crop
+            self.crop_area = self.auto_crop
         elif rotate == 270:
             rotated = rot90(trimmed, 3)
-            self.imh.crop_area = [
-                self.imh.trim_left,
-                self.imh.trim_up,
-                self.imh.trim_right,
-                self.imh.trim_down,
+            self.crop_area = [
+                self.trim_left,
+                self.trim_up,
+                self.trim_right,
+                self.trim_down,
             ]
         else:
             rotated = trimmed
-            self.imh.crop_area = self.imh.auto_crop
+            self.crop_area = self.auto_crop
         return rotated
 
     async def async_auto_trim_and_zoom_image(
@@ -217,18 +270,18 @@ class AutoCrop:
         Automatically crops and trims a numpy array and returns the processed image.
         """
         try:
-            await self._init_auto_crop()
-            if self.imh.auto_crop is None:
-                _LOGGER.debug("%s: Calculating auto trim box", self.file_name)
+            self.auto_crop = await self._init_auto_crop()
+            if (self.auto_crop is None) or (self.auto_crop == [0, 0, 0, 0]):
+                _LOGGER.debug("%s: Calculating auto trim box", self.handler.file_name)
                 # Find the coordinates of the first occurrence of a non-background color
                 min_y, min_x, max_x, max_y = await self.async_image_margins(
                     image_array, detect_colour
                 )
                 # Calculate and store the trims coordinates with margins
-                self.imh.trim_left = int(min_x) - margin_size
-                self.imh.trim_up = int(min_y) - margin_size
-                self.imh.trim_right = int(max_x) + margin_size
-                self.imh.trim_down = int(max_y) + margin_size
+                self.trim_left = int(min_x) - margin_size
+                self.trim_up = int(min_y) - margin_size
+                self.trim_right = int(max_x) + margin_size
+                self.trim_down = int(max_y) + margin_size
                 del min_y, min_x, max_x, max_y
 
                 # Calculate the dimensions after trimming using min/max values
@@ -241,23 +294,28 @@ class AutoCrop:
                         trimmed_width,
                         margin_size,
                         image_array,
-                        self.file_name,
+                        self.handler.file_name,
                         rotate,
                     )
                 except TrimError as e:
                     return e.image
 
                 # Store Crop area of the original image_array we will use from the next frame.
-                self.imh.auto_crop = TrimCropData(
-                    self.imh.trim_left,
-                    self.imh.trim_up,
-                    self.imh.trim_right,
-                    self.imh.trim_down,
+                self.auto_crop = TrimCropData(
+                    self.trim_left,
+                    self.trim_up,
+                    self.trim_right,
+                    self.trim_down,
                 ).to_list()
-                # if self.imh.shared.vacuum_state == "docked":
-                #     await (
-                #         self._async_save_auto_crop_data()
-                #     )  # Save the crop data to the disk
+                # Update the trims data in the shared instance
+                self.handler.shared.trims = TrimsData.from_dict(
+                    {
+                        "trim_left": self.trim_left,
+                        "trim_up": self.trim_up,
+                        "trim_right": self.trim_right,
+                        "trim_down": self.trim_down,
+                    }
+                )
                 self.auto_crop_offset()
             # If it is needed to zoom the image.
             trimmed = await self.async_check_if_zoom_is_on(
@@ -268,19 +326,19 @@ class AutoCrop:
             rotated = await self.async_rotate_the_image(trimmed, rotate)
             del trimmed  # Free memory.
             _LOGGER.debug(
-                "%s: Auto Trim Box data: %s", self.file_name, self.imh.crop_area
+                "%s: Auto Trim Box data: %s", self.handler.file_name, self.crop_area
             )
-            self.imh.crop_img_size = [rotated.shape[1], rotated.shape[0]]
+            self.handler.crop_img_size = [rotated.shape[1], rotated.shape[0]]
             _LOGGER.debug(
                 "%s: Auto Trimmed image size: %s",
-                self.file_name,
-                self.imh.crop_img_size,
+                self.handler.file_name,
+                self.handler.crop_img_size,
             )
 
         except RuntimeError as e:
             _LOGGER.warning(
                 "%s: Error %s during auto trim and zoom.",
-                self.file_name,
+                self.handler.file_name,
                 e,
                 exc_info=True,
             )

valetudo_map_parser/config/color_utils.py

@@ -0,0 +1,105 @@
+"""Utility functions for color operations in the map parser."""
+
+from typing import Optional, Tuple
+
+from .colors import ColorsManagement
+from .types import Color, NumpyArray
+
+
+def get_blended_color(
+    x0: int,
+    y0: int,
+    x1: int,
+    y1: int,
+    arr: Optional[NumpyArray],
+    color: Color,
+) -> Color:
+    """
+    Get a blended color for a pixel based on the current element map and the new element to draw.
+
+    This function:
+    1. Gets the background colors at the start and end points (with offset to avoid sampling already drawn pixels)
+    2. Directly blends the foreground color with the background using straight alpha
+    3. Returns the average of the two blended colors
+
+    Returns:
+        Blended RGBA color to use for drawing
+    """
+    # Extract foreground color components
+    fg_r, fg_g, fg_b, fg_a = color
+    fg_alpha = fg_a / 255.0  # Convert to 0-1 range
+
+    # Fast path for fully opaque or transparent foreground
+    if fg_a == 255:
+        return color
+    if fg_a == 0:
+        # Sample background at midpoint
+        mid_x, mid_y = (x0 + x1) // 2, (y0 + y1) // 2
+        if 0 <= mid_y < arr.shape[0] and 0 <= mid_x < arr.shape[1]:
+            return tuple(arr[mid_y, mid_x])
+        return (0, 0, 0, 0)  # Default if out of bounds
+
+    # Calculate direction vector for offset sampling
+    dx = x1 - x0
+    dy = y1 - y0
+    length = max(1, (dx**2 + dy**2) ** 0.5)  # Avoid division by zero
+    offset = 5  # 5-pixel offset to avoid sampling already drawn pixels
+
+    # Calculate offset coordinates for start point (move away from the line)
+    offset_x0 = int(x0 - (offset * dx / length))
+    offset_y0 = int(y0 - (offset * dy / length))
+
+    # Calculate offset coordinates for end point (move away from the line)
+    offset_x1 = int(x1 + (offset * dx / length))
+    offset_y1 = int(y1 + (offset * dy / length))
+
+    # Sample background at offset start point
+    if 0 <= offset_y0 < arr.shape[0] and 0 <= offset_x0 < arr.shape[1]:
+        bg_color_start = arr[offset_y0, offset_x0]
+        # Direct straight alpha blending
+        start_r = int(fg_r * fg_alpha + bg_color_start[0] * (1 - fg_alpha))
+        start_g = int(fg_g * fg_alpha + bg_color_start[1] * (1 - fg_alpha))
+        start_b = int(fg_b * fg_alpha + bg_color_start[2] * (1 - fg_alpha))
+        start_a = int(fg_a + bg_color_start[3] * (1 - fg_alpha))
+        start_blended_color = (start_r, start_g, start_b, start_a)
+    else:
+        # If offset point is out of bounds, try original point
+        if 0 <= y0 < arr.shape[0] and 0 <= x0 < arr.shape[1]:
+            bg_color_start = arr[y0, x0]
+            start_r = int(fg_r * fg_alpha + bg_color_start[0] * (1 - fg_alpha))
+            start_g = int(fg_g * fg_alpha + bg_color_start[1] * (1 - fg_alpha))
+            start_b = int(fg_b * fg_alpha + bg_color_start[2] * (1 - fg_alpha))
+            start_a = int(fg_a + bg_color_start[3] * (1 - fg_alpha))
+            start_blended_color = (start_r, start_g, start_b, start_a)
+        else:
+            start_blended_color = color
+
+    # Sample background at offset end point
+    if 0 <= offset_y1 < arr.shape[0] and 0 <= offset_x1 < arr.shape[1]:
+        bg_color_end = arr[offset_y1, offset_x1]
+        # Direct straight alpha blending
+        end_r = int(fg_r * fg_alpha + bg_color_end[0] * (1 - fg_alpha))
+        end_g = int(fg_g * fg_alpha + bg_color_end[1] * (1 - fg_alpha))
+        end_b = int(fg_b * fg_alpha + bg_color_end[2] * (1 - fg_alpha))
+        end_a = int(fg_a + bg_color_end[3] * (1 - fg_alpha))
+        end_blended_color = (end_r, end_g, end_b, end_a)
+    else:
+        # If offset point is out of bounds, try original point
+        if 0 <= y1 < arr.shape[0] and 0 <= x1 < arr.shape[1]:
+            bg_color_end = arr[y1, x1]
+            end_r = int(fg_r * fg_alpha + bg_color_end[0] * (1 - fg_alpha))
+            end_g = int(fg_g * fg_alpha + bg_color_end[1] * (1 - fg_alpha))
+            end_b = int(fg_b * fg_alpha + bg_color_end[2] * (1 - fg_alpha))
+            end_a = int(fg_a + bg_color_end[3] * (1 - fg_alpha))
+            end_blended_color = (end_r, end_g, end_b, end_a)
+        else:
+            end_blended_color = color
+
+    # Use the average of the two blended colors
+    blended_color = (
+        (start_blended_color[0] + end_blended_color[0]) // 2,
+        (start_blended_color[1] + end_blended_color[1]) // 2,
+        (start_blended_color[2] + end_blended_color[2]) // 2,
+        (start_blended_color[3] + end_blended_color[3]) // 2,
+    )
+    return blended_color