valetudo-map-parser 0.1.2__tar.gz → 0.1.3__tar.gz

{valetudo_map_parser-0.1.2 → valetudo_map_parser-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: valetudo-map-parser
-Version: 0.1.2
+Version: 0.1.3
 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.3/SCR/valetudo_map_parser/__init__.py

@@ -0,0 +1,2 @@
+"""Valetudo map parser.
+Version: 0.1.0"""

valetudo_map_parser-0.1.3/SCR/valetudo_map_parser/config/__init__.py

@@ -0,0 +1 @@
+"""Configuration module for the SCR package."""

valetudo_map_parser-0.1.3/SCR/valetudo_map_parser/config/auto_crop.py

@@ -0,0 +1,288 @@
+"""Auto Crop Class for trimming and zooming images.
+Version: 2024.10.0"""
+
+from __future__ import annotations
+
+import logging
+
+import numpy as np
+from numpy import rot90
+
+from .types import Color, NumpyArray, TrimCropData
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class TrimError(Exception):
+    """Exception raised for errors in the trim process."""
+
+    def __init__(self, message, image):
+        super().__init__(message)
+        self.image = image
+
+
+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 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])
+            raise TrimError(
+                f"{file_name}: Trimming failed at rotation {rotate}.", image_array
+            )
+
+    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)
+            ),
+        )
+        trimmed_height = max(
+            0,
+            (
+                (self.imh.trim_down - self.imh.offset_bottom)
+                - (self.imh.trim_up + self.imh.offset_top)
+            ),
+        )
+        # Ensure shared reference dimensions are updated
+        if hasattr(self.imh.shared, "image_ref_height") and hasattr(
+            self.imh.shared, "image_ref_width"
+        ):
+            self.imh.shared.image_ref_height = trimmed_height
+            self.imh.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):
+        """Load the auto crop data from the disk."""
+
+        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
+        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
+
+    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:
+                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}")
+
+    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
+        _LOGGER.debug(
+            "%s: Found trims max and min values (y,x) (%s, %s) (%s, %s)...",
+            self.file_name,
+            int(max_y),
+            int(max_x),
+            int(min_y),
+            int(min_x),
+        )
+        return min_y, min_x, max_x, max_y
+
+    async def async_check_if_zoom_is_on(
+        self,
+        image_array: NumpyArray,
+        margin_size: int = 100,
+        zoom: bool = False,
+        rand256: bool = False,
+    ) -> NumpyArray:
+        """Check if the image need to be zoom."""
+
+        if (
+            zoom
+            and self.imh.shared.vacuum_state == "cleaning"
+            and self.imh.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"],
+            )
+            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
+            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, trim_right = sorted([trim_left, trim_right])
+            trim_up, trim_down = sorted([trim_up, trim_down])
+            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],
+            ]
+        return trimmed
+
+    async def async_rotate_the_image(
+        self, trimmed: NumpyArray, rotate: int
+    ) -> NumpyArray:
+        """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,
+            ]
+        elif rotate == 180:
+            rotated = rot90(trimmed, 2)
+            self.imh.crop_area = self.imh.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,
+            ]
+        else:
+            rotated = trimmed
+            self.imh.crop_area = self.imh.auto_crop
+        return rotated
+
+    async def async_auto_trim_and_zoom_image(
+        self,
+        image_array: NumpyArray,
+        detect_colour: Color = (93, 109, 126, 255),
+        margin_size: int = 0,
+        rotate: int = 0,
+        zoom: bool = False,
+        rand256: bool = False,
+    ):
+        """
+        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)
+                # 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
+                del min_y, min_x, max_x, max_y
+
+                # Calculate the dimensions after trimming using min/max values
+                trimmed_width, trimmed_height = self._calculate_trimmed_dimensions()
+
+                # Test if the trims are okay or not
+                try:
+                    self.check_trim(
+                        trimmed_height,
+                        trimmed_width,
+                        margin_size,
+                        image_array,
+                        self.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,
+                ).to_list()
+                # if self.imh.shared.vacuum_state == "docked":
+                #     await (
+                #         self._async_save_auto_crop_data()
+                #     )  # Save the crop data to the disk
+                self.auto_crop_offset()
+            # If it is needed to zoom the image.
+            trimmed = await self.async_check_if_zoom_is_on(
+                image_array, margin_size, zoom, rand256
+            )
+            del image_array  # Free memory.
+            # Rotate the cropped image based on the given angle
+            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
+            )
+            self.imh.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,
+            )
+
+        except RuntimeError as e:
+            _LOGGER.warning(
+                "%s: Error %s during auto trim and zoom.",
+                self.file_name,
+                e,
+                exc_info=True,
+            )
+            return None
+        return rotated

valetudo_map_parser-0.1.3/SCR/valetudo_map_parser/config/colors.py

@@ -0,0 +1,178 @@
+"""Colors for the maps Elements."""
+
+from __future__ import annotations
+
+from enum import StrEnum
+from typing import List, Dict, Tuple
+import logging
+
+_LOGGER = logging.getLogger(__name__)
+
+Color = Tuple[int, int, int, int]  # RGBA color definition
+
+
+class SupportedColor(StrEnum):
+    """Color of a supported map element."""
+
+    CHARGER = "color_charger"
+    PATH = "color_move"
+    PREDICTED_PATH = "color_predicted_move"
+    WALLS = "color_wall"
+    ROBOT = "color_robot"
+    GO_TO = "color_go_to"
+    NO_GO = "color_no_go"
+    ZONE_CLEAN = "color_zone_clean"
+    MAP_BACKGROUND = "color_background"
+    TEXT = "color_text"
+    TRANSPARENT = "color_transparent"
+    COLOR_ROOM_PREFIX = "color_room_"
+
+    @staticmethod
+    def room_key(index: int) -> str:
+        return f"{SupportedColor.COLOR_ROOM_PREFIX}{index}"
+
+
+class DefaultColors:
+    """Container that simplifies retrieving default RGB and RGBA colors."""
+
+    COLORS_RGB: Dict[str, Tuple[int, int, int]] = {
+        SupportedColor.CHARGER: (255, 128, 0),
+        SupportedColor.PATH: (238, 247, 255),
+        SupportedColor.PREDICTED_PATH: (93, 109, 126),
+        SupportedColor.WALLS: (255, 255, 0),
+        SupportedColor.ROBOT: (255, 255, 204),
+        SupportedColor.GO_TO: (0, 255, 0),
+        SupportedColor.NO_GO: (255, 0, 0),
+        SupportedColor.ZONE_CLEAN: (255, 255, 255),
+        SupportedColor.MAP_BACKGROUND: (0, 125, 255),
+        SupportedColor.TEXT: (0, 0, 0),
+        SupportedColor.TRANSPARENT: (0, 0, 0),
+    }
+
+    DEFAULT_ROOM_COLORS: Dict[str, Tuple[int, int, int]] = {
+        SupportedColor.room_key(i): color
+        for i, color in enumerate(
+            [
+                (135, 206, 250),
+                (176, 226, 255),
+                (165, 105, 18),
+                (164, 211, 238),
+                (141, 182, 205),
+                (96, 123, 139),
+                (224, 255, 255),
+                (209, 238, 238),
+                (180, 205, 205),
+                (122, 139, 139),
+                (175, 238, 238),
+                (84, 153, 199),
+                (133, 193, 233),
+                (245, 176, 65),
+                (82, 190, 128),
+                (72, 201, 176),
+            ]
+        )
+    }
+
+    DEFAULT_ALPHA: Dict[str, float] = {
+        f"alpha_{key}": 255.0 for key in COLORS_RGB.keys()
+    }
+    DEFAULT_ALPHA.update({f"alpha_room_{i}": 255.0 for i in range(16)})
+
+    @classmethod
+    def get_rgba(cls, key: str, alpha: float) -> Color:
+        rgb = cls.COLORS_RGB.get(key, (0, 0, 0))
+        r, g, b = rgb  # Explicitly unpack the RGB values
+        return r, g, b, int(alpha)
+
+
+class ColorsManagment:
+    """Manages user-defined and default colors for map elements."""
+
+    def __init__(self, device_info: dict) -> None:
+        """
+        Initialize ColorsManagment with optional device_info from Home Assistant.
+        :param device_info: Dictionary containing user-defined RGB colors and alpha values.
+        """
+        self.user_colors = self.initialize_user_colors(device_info)
+        self.rooms_colors = self.initialize_rooms_colors(device_info)
+
+    def initialize_user_colors(self, device_info: dict) -> List[Color]:
+        """
+        Initialize user-defined colors with defaults as fallback.
+        :param device_info: Dictionary containing user-defined colors.
+        :return: List of RGBA colors for map elements.
+        """
+        colors = []
+        for key in SupportedColor:
+            if key.startswith(SupportedColor.COLOR_ROOM_PREFIX):
+                continue  # Skip room colors for user_colors
+            rgb = device_info.get(key, DefaultColors.COLORS_RGB.get(key))
+            alpha = device_info.get(
+                f"alpha_{key}", DefaultColors.DEFAULT_ALPHA.get(f"alpha_{key}")
+            )
+            colors.append(self.add_alpha_to_color(rgb, alpha))
+        return colors
+
+    def initialize_rooms_colors(self, device_info: dict) -> List[Color]:
+        """
+        Initialize room colors with defaults as fallback.
+        :param device_info: Dictionary containing user-defined room colors.
+        :return: List of RGBA colors for rooms.
+        """
+        colors = []
+        for i in range(16):
+            rgb = device_info.get(
+                SupportedColor.room_key(i),
+                DefaultColors.DEFAULT_ROOM_COLORS.get(SupportedColor.room_key(i)),
+            )
+            alpha = device_info.get(
+                f"alpha_room_{i}", DefaultColors.DEFAULT_ALPHA.get(f"alpha_room_{i}")
+            )
+            colors.append(self.add_alpha_to_color(rgb, alpha))
+        return colors
+
+    @staticmethod
+    def add_alpha_to_color(rgb: Tuple[int, int, int], alpha: float) -> Color:
+        """
+        Convert RGB to RGBA by appending the alpha value.
+        :param rgb: RGB values.
+        :param alpha: Alpha value (0.0 to 255.0).
+        :return: RGBA color.
+        """
+        return (*rgb, int(alpha)) if rgb else (0, 0, 0, int(alpha))
+
+    def get_user_colors(self) -> List[Color]:
+        """Return the list of RGBA colors for user-defined map elements."""
+        return self.user_colors
+
+    def get_rooms_colors(self) -> List[Color]:
+        """Return the list of RGBA colors for rooms."""
+        return self.rooms_colors
+
+    def get_colour(self, supported_color: SupportedColor) -> Color:
+        """
+        Retrieve the color for a specific map element, prioritizing user-defined values.
+
+        :param supported_color: The SupportedColor key for the desired color.
+        :return: The RGBA color for the given map element.
+        """
+        # Handle room-specific colors
+        if supported_color.startswith("color_room_"):
+            room_index = int(supported_color.split("_")[-1])
+            try:
+                return self.rooms_colors[room_index]
+            except (IndexError, KeyError):
+                _LOGGER.warning("Room index %s not found, using default.", room_index)
+                r, g, b = DefaultColors.DEFAULT_ROOM_COLORS[f"color_room_{room_index}"]
+                a = DefaultColors.DEFAULT_ALPHA[f"alpha_room_{room_index}"]
+                return r, g, b, int(a)
+
+        # Handle general map element colors
+        try:
+            index = list(SupportedColor).index(supported_color)
+            return self.user_colors[index]
+        except (IndexError, KeyError, ValueError):
+            _LOGGER.warning(
+                "Color for %s not found. Returning default.", supported_color
+            )
+            return DefaultColors.get_rgba(supported_color, 255)  # Transparent fallback