valetudo-map-parser 0.1.9b28__tar.gz → 0.1.9b30__tar.gz

{valetudo_map_parser-0.1.9b28 → valetudo_map_parser-0.1.9b30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: valetudo-map-parser
-Version: 0.1.9b28
+Version: 0.1.9b30
 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.9b28 → valetudo_map_parser-0.1.9b30}/SCR/valetudo_map_parser/config/auto_crop.py

@@ -9,6 +9,7 @@ import numpy as np
 from numpy import rot90
 
 from .types import Color, NumpyArray, TrimCropData, TrimsData
+from .utils import BaseHandler
 
 
 _LOGGER = logging.getLogger(__name__)
@@ -25,16 +26,30 @@ 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
+    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
+        _LOGGER.debug("Trim Data: %s", str(trim_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)
+            _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
 
@@ -43,8 +58,8 @@ class AutoCrop:
     ):
         """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
             )
@@ -52,62 +67,65 @@ 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: TrimsData = None):  # , tdata=None
+    async def _async_auto_crop_data(self, tdata: TrimsData):  # , tdata=None
         """Load the auto crop data from the Camera config."""
-        if not self.imh.auto_crop:
+        if not self.auto_crop:
             trims_data = TrimCropData.from_dict(dict(tdata.to_dict())).to_list()
             (
-                self.imh.trim_left,
-                self.imh.trim_up,
-                self.imh.trim_right,
-                self.imh.trim_down,
+                self.trim_left,
+                self.trim_up,
+                self.trim_right,
+                self.trim_down,
             ) = trims_data
             self._calculate_trimmed_dimensions()
             return trims_data
+        _LOGGER.debug("No Crop data found in the Camera config.")
         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(self.imh.shared.trims)
-            if self.imh.auto_crop:
+        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
+            self.handler.max_frames = 5
+
+        # 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
@@ -120,7 +138,7 @@ class AutoCrop:
         del nonzero_coords
         _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),
@@ -135,38 +153,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(
@@ -175,26 +208,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(
@@ -210,18 +243,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:
+                _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
@@ -234,20 +267,20 @@ 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":
+                # if self.handler.shared.vacuum_state == "docked":
                 #     await (
                 #         self._async_save_auto_crop_data()
                 #     )  # Save the crop data to the disk
@@ -261,19 +294,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-0.1.9b30/SCR/valetudo_map_parser/config/colors_man.py

@@ -0,0 +1,249 @@
+"""
+Colors RGBA
+Version: v2025.02.0
+"""
+
+import logging
+
+from .types import (
+    ALPHA_BACKGROUND,
+    ALPHA_CHARGER,
+    ALPHA_GO_TO,
+    ALPHA_MOVE,
+    ALPHA_NO_GO,
+    ALPHA_ROBOT,
+    ALPHA_ROOM_0,
+    ALPHA_ROOM_1,
+    ALPHA_ROOM_2,
+    ALPHA_ROOM_3,
+    ALPHA_ROOM_4,
+    ALPHA_ROOM_5,
+    ALPHA_ROOM_6,
+    ALPHA_ROOM_7,
+    ALPHA_ROOM_8,
+    ALPHA_ROOM_9,
+    ALPHA_ROOM_10,
+    ALPHA_ROOM_11,
+    ALPHA_ROOM_12,
+    ALPHA_ROOM_13,
+    ALPHA_ROOM_14,
+    ALPHA_ROOM_15,
+    ALPHA_TEXT,
+    ALPHA_WALL,
+    ALPHA_ZONE_CLEAN,
+    COLOR_BACKGROUND,
+    COLOR_CHARGER,
+    COLOR_GO_TO,
+    COLOR_MOVE,
+    COLOR_NO_GO,
+    COLOR_ROBOT,
+    COLOR_ROOM_0,
+    COLOR_ROOM_1,
+    COLOR_ROOM_2,
+    COLOR_ROOM_3,
+    COLOR_ROOM_4,
+    COLOR_ROOM_5,
+    COLOR_ROOM_6,
+    COLOR_ROOM_7,
+    COLOR_ROOM_8,
+    COLOR_ROOM_9,
+    COLOR_ROOM_10,
+    COLOR_ROOM_11,
+    COLOR_ROOM_12,
+    COLOR_ROOM_13,
+    COLOR_ROOM_14,
+    COLOR_ROOM_15,
+    COLOR_TEXT,
+    COLOR_WALL,
+    COLOR_ZONE_CLEAN,
+)
+
+
+color_transparent = (0, 0, 0, 0)
+color_charger = (0, 128, 0, 255)
+color_move = (238, 247, 255, 255)
+color_robot = (255, 255, 204, 255)
+color_no_go = (255, 0, 0, 255)
+color_go_to = (0, 255, 0, 255)
+color_background = (0, 125, 255, 255)
+color_zone_clean = (255, 255, 255, 25)
+color_wall = (255, 255, 0, 255)
+color_text = (255, 255, 255, 255)
+color_grey = (125, 125, 125, 255)
+color_black = (0, 0, 0, 255)
+color_room_0 = (135, 206, 250, 255)
+color_room_1 = (176, 226, 255, 255)
+color_room_2 = (164, 211, 238, 255)
+color_room_3 = (141, 182, 205, 255)
+color_room_4 = (96, 123, 139, 255)
+color_room_5 = (224, 255, 255, 255)
+color_room_6 = (209, 238, 238, 255)
+color_room_7 = (180, 205, 205, 255)
+color_room_8 = (122, 139, 139, 255)
+color_room_9 = (175, 238, 238, 255)
+color_room_10 = (84, 153, 199, 255)
+color_room_11 = (133, 193, 233, 255)
+color_room_12 = (245, 176, 65, 255)
+color_room_13 = (82, 190, 128, 255)
+color_room_14 = (72, 201, 176, 255)
+color_room_15 = (165, 105, 18, 255)
+
+rooms_color = [
+    color_room_0,
+    color_room_1,
+    color_room_2,
+    color_room_3,
+    color_room_4,
+    color_room_5,
+    color_room_6,
+    color_room_7,
+    color_room_8,
+    color_room_9,
+    color_room_10,
+    color_room_11,
+    color_room_12,
+    color_room_13,
+    color_room_14,
+    color_room_15,
+]
+
+base_colors_array = [
+    color_wall,
+    color_zone_clean,
+    color_robot,
+    color_background,
+    color_move,
+    color_charger,
+    color_no_go,
+    color_go_to,
+    color_text,
+]
+
+color_array = [
+    base_colors_array[0],  # color_wall
+    base_colors_array[6],  # color_no_go
+    base_colors_array[7],  # color_go_to
+    color_black,
+    base_colors_array[2],  # color_robot
+    base_colors_array[5],  # color_charger
+    color_text,
+    base_colors_array[4],  # color_move
+    base_colors_array[3],  # color_background
+    base_colors_array[1],  # color_zone_clean
+    color_transparent,
+    rooms_color,
+]
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class ColorsManagment:
+    """Class to manage the colors.
+    Imports and updates the colors from the user configuration."""
+
+    def __init__(self, shared_var):
+        self.shared_var = shared_var
+
+    @staticmethod
+    def add_alpha_to_rgb(alpha_channels, rgb_colors):
+        """
+        Add alpha channel to RGB colors using corresponding alpha channels.
+
+        Args:
+            alpha_channels (List[Optional[float]]): List of alpha channel values (0.0-255.0).
+            rgb_colors (List[Tuple[int, int, int]]): List of RGB colors.
+
+        Returns:
+            List[Tuple[int, int, int, int]]: List of RGBA colors with alpha channel added.
+        """
+        if len(alpha_channels) != len(rgb_colors):
+            _LOGGER.error("Input lists must have the same length.")
+            return []
+
+        result = []
+        for alpha, rgb in zip(alpha_channels, rgb_colors):
+            try:
+                alpha_int = int(alpha)
+                if alpha_int < 0:
+                    alpha_int = 0
+                elif alpha_int > 255:
+                    alpha_int = 255
+
+                if rgb is None:
+                    result.append((0, 0, 0, alpha_int))
+                else:
+                    result.append((rgb[0], rgb[1], rgb[2], alpha_int))
+            except (ValueError, TypeError):
+                result.append(None)
+
+        return result
+
+    def set_initial_colours(self, device_info: dict) -> None:
+        """Set the initial colours for the map."""
+        try:
+            user_colors = [
+                device_info.get(COLOR_WALL, color_wall),
+                device_info.get(COLOR_ZONE_CLEAN, color_zone_clean),
+                device_info.get(COLOR_ROBOT, color_robot),
+                device_info.get(COLOR_BACKGROUND, color_background),
+                device_info.get(COLOR_MOVE, color_move),
+                device_info.get(COLOR_CHARGER, color_charger),
+                device_info.get(COLOR_NO_GO, color_no_go),
+                device_info.get(COLOR_GO_TO, color_go_to),
+                device_info.get(COLOR_TEXT, color_text),
+            ]
+            user_alpha = [
+                device_info.get(ALPHA_WALL, 255),
+                device_info.get(ALPHA_ZONE_CLEAN, 255),
+                device_info.get(ALPHA_ROBOT, 255),
+                device_info.get(ALPHA_BACKGROUND, 255),
+                device_info.get(ALPHA_MOVE, 255),
+                device_info.get(ALPHA_CHARGER, 255),
+                device_info.get(ALPHA_NO_GO, 255),
+                device_info.get(ALPHA_GO_TO, 255),
+                device_info.get(ALPHA_TEXT, 255),
+            ]
+            rooms_colors = [
+                device_info.get(COLOR_ROOM_0, color_room_0),
+                device_info.get(COLOR_ROOM_1, color_room_1),
+                device_info.get(COLOR_ROOM_2, color_room_2),
+                device_info.get(COLOR_ROOM_3, color_room_3),
+                device_info.get(COLOR_ROOM_4, color_room_4),
+                device_info.get(COLOR_ROOM_5, color_room_5),
+                device_info.get(COLOR_ROOM_6, color_room_6),
+                device_info.get(COLOR_ROOM_7, color_room_7),
+                device_info.get(COLOR_ROOM_8, color_room_8),
+                device_info.get(COLOR_ROOM_9, color_room_9),
+                device_info.get(COLOR_ROOM_10, color_room_10),
+                device_info.get(COLOR_ROOM_11, color_room_11),
+                device_info.get(COLOR_ROOM_12, color_room_12),
+                device_info.get(COLOR_ROOM_13, color_room_13),
+                device_info.get(COLOR_ROOM_14, color_room_14),
+                device_info.get(COLOR_ROOM_15, color_room_15),
+            ]
+            rooms_alpha = [
+                device_info.get(ALPHA_ROOM_0, 255),
+                device_info.get(ALPHA_ROOM_1, 255),
+                device_info.get(ALPHA_ROOM_2, 255),
+                device_info.get(ALPHA_ROOM_3, 255),
+                device_info.get(ALPHA_ROOM_4, 255),
+                device_info.get(ALPHA_ROOM_5, 255),
+                device_info.get(ALPHA_ROOM_6, 255),
+                device_info.get(ALPHA_ROOM_7, 255),
+                device_info.get(ALPHA_ROOM_8, 255),
+                device_info.get(ALPHA_ROOM_9, 255),
+                device_info.get(ALPHA_ROOM_10, 255),
+                device_info.get(ALPHA_ROOM_11, 255),
+                device_info.get(ALPHA_ROOM_12, 255),
+                device_info.get(ALPHA_ROOM_13, 255),
+                device_info.get(ALPHA_ROOM_14, 255),
+                device_info.get(ALPHA_ROOM_15, 255),
+            ]
+            self.shared_var.update_user_colors(
+                self.add_alpha_to_rgb(user_alpha, user_colors)
+            )
+            self.shared_var.update_rooms_colors(
+                self.add_alpha_to_rgb(rooms_alpha, rooms_colors)
+            )
+        except (ValueError, IndexError, UnboundLocalError) as e:
+            _LOGGER.error("Error while populating colors: %s", e)

{valetudo_map_parser-0.1.9b28 → valetudo_map_parser-0.1.9b30}/SCR/valetudo_map_parser/config/types.py

@@ -6,7 +6,7 @@ Version 0.0.1
 import asyncio
 import json
 import logging
-from dataclasses import dataclass, asdict
+from dataclasses import asdict, dataclass
 from typing import Any, Dict, Tuple, Union
 
 import numpy as np

{valetudo_map_parser-0.1.9b28 → valetudo_map_parser-0.1.9b30}/SCR/valetudo_map_parser/config/utils.py

@@ -489,7 +489,11 @@ async def async_resize_image(params: ResizeParams):
         if wsf == 0 or hsf == 0 or params.width <= 0 or params.height <= 0:
             _LOGGER.warning(
                 "Invalid aspect ratio parameters: width=%s, height=%s, wsf=%s, hsf=%s. Returning original image.",
-                params.width, params.height, wsf, hsf)
+                params.width,
+                params.height,
+                wsf,
+                hsf,
+            )
             return params.pil_img  # Return original image if invalid
 
         new_aspect_ratio = wsf / hsf

{valetudo_map_parser-0.1.9b28 → valetudo_map_parser-0.1.9b30}/SCR/valetudo_map_parser/hypfer_handler.py

@@ -24,17 +24,16 @@ from .map_data import ImageData
 _LOGGER = logging.getLogger(__name__)
 
 
-class HypferMapImageHandler(BaseHandler):
+class HypferMapImageHandler(BaseHandler, AutoCrop):
     """Map Image Handler Class.
     This class is used to handle the image data and the drawing of the map."""
 
     def __init__(self, shared_data: CameraShared):
         """Initialize the Map Image Handler."""
         BaseHandler.__init__(self)
+        AutoCrop.__init__(self, BaseHandler)
         self.shared = shared_data  # camera shared data
-        self.auto_crop = None  # auto crop data to be calculate once.
         self.calibration_data = None  # camera shared data.
-        self.crop_area = None  # module shared for calibration data.
         self.data = ImageData  # imported Image Data Module.
         self.draw = Drawable  # imported Drawing utilities
         self.go_to = None  # vacuum go to data
@@ -42,18 +41,7 @@ class HypferMapImageHandler(BaseHandler):
         self.img_base_layer = None  # numpy array store the map base layer.
         self.active_zones = None  # vacuum active zones.
         self.svg_wait = False  # SVG image creation wait.
-        trim_data = self.shared.trims.to_dict()  # trims data
-        _LOGGER.debug("Trim Data: %s", str(trim_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.shared.offset_top  # offset top
-        self.offset_bottom = self.shared.offset_down  # offset bottom
-        self.offset_left = self.shared.offset_left  # offset left
-        self.offset_right = self.shared.offset_right  # offset right
-        self.imd = ImDraw(self)
-        self.ac = AutoCrop(self)
+        self.imd = ImDraw(self)  # Image Draw class.
         self.color_grey = (128, 128, 128, 255)
         self.file_name = self.shared.file_name  # file name of the vacuum.
 
@@ -233,7 +221,7 @@ class HypferMapImageHandler(BaseHandler):
                         robot_state=self.shared.vacuum_state,
                     )
                 # Resize the image
-                img_np_array = await self.ac.async_auto_trim_and_zoom_image(
+                img_np_array = await self.async_auto_trim_and_zoom_image(
                     img_np_array,
                     colors["background"],
                     int(self.shared.margins),

{valetudo_map_parser-0.1.9b28 → valetudo_map_parser-0.1.9b30}/SCR/valetudo_map_parser/rand25_handler.py

@@ -33,38 +33,27 @@ _LOGGER = logging.getLogger(__name__)
 
 
 # noinspection PyTypeChecker
-class ReImageHandler(BaseHandler):
+class ReImageHandler(BaseHandler, AutoCrop):
     """
     Image Handler for Valetudo Re Vacuums.
     """
 
-    def __init__(self, camera_shared):
+    def __init__(self, shared_data):
         BaseHandler.__init__(self)
+        AutoCrop.__init__(self, BaseHandler)
         self.auto_crop = None  # Auto crop flag
         self.segment_data = None  # Segment data
         self.outlines = None  # Outlines data
         self.calibration_data = None  # Calibration data
-        self.crop_area = None  # Crop area
         self.data = RandImageData  # Image Data
         self.go_to = None  # Go to position data
         self.img_base_layer = None  # Base image layer
-        self.img_rotate = camera_shared.image_rotate  # Image rotation
+        self.img_rotate = shared_data.image_rotate  # Image rotation
         self.room_propriety = None  # Room propriety data
-        self.shared = camera_shared  # Shared data
+        self.shared = shared_data  # Shared data
         self.active_zones = None  # Active zones
-        trim_data = self.shared.trims.to_dict()  # trims data
-        _LOGGER.debug("Trim Data: %s", trim_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.file_name = self.shared.file_name  # File name
-        self.offset_top = self.shared.offset_top  # offset top
-        self.offset_bottom = self.shared.offset_down  # offset bottom
-        self.offset_left = self.shared.offset_left  # offset left
-        self.offset_right = self.shared.offset_right  # offset right
         self.imd = ImageDraw(self)  # Image Draw
-        self.crop = AutoCrop(self)
 
     async def extract_room_properties(
         self, json_data: JsonType, destinations: JsonType
@@ -248,7 +237,7 @@ class ReImageHandler(BaseHandler):
         img_np_array = await self.imd.async_draw_robot_on_map(
             img_np_array, robot_position, robot_position_angle, colors["robot"]
         )
-        img_np_array = await self.crop.async_auto_trim_and_zoom_image(
+        img_np_array = await self.async_auto_trim_and_zoom_image(
             img_np_array,
             detect_colour=colors["background"],
             margin_size=int(self.shared.margins),
@@ -260,7 +249,9 @@ class ReImageHandler(BaseHandler):
 
     async def _finalize_image(self, pil_img):
         if not self.shared.image_ref_width or not self.shared.image_ref_height:
-            _LOGGER.warning("Image finalization failed: Invalid image dimensions. Returning original image.")
+            _LOGGER.warning(
+                "Image finalization failed: Invalid image dimensions. Returning original image."
+            )
             return pil_img
         if self.check_zoom_and_aspect_ratio():
             resize_params = prepare_resize_params(self, pil_img, True)

{valetudo_map_parser-0.1.9b28 → valetudo_map_parser-0.1.9b30}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "valetudo-map-parser"
-version = "0.1.9.b28"
+version = "0.1.9.b30"
 description = "A Python library to parse Valetudo map data returning a PIL Image object."
 authors = ["Sandro Cantarella <gsca075@gmail.com>"]
 license = "Apache-2.0"