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

valetudo_map_parser/__init__.py

@@ -15,13 +15,13 @@ from .config.types import (
     TrimCropData,
     UserLanguageStore,
 )
-from .hypfer_rooms_handler import HypferRoomsHandler
 from .hypfer_handler import HypferMapImageHandler
 from .rand25_handler import ReImageHandler
+from .rooms_handler import RoomsHandler
 
 
 __all__ = [
-    "HypferRoomsHandler",
+    "RoomsHandler",
     "HypferMapImageHandler",
     "ReImageHandler",
     "RRMapParser",

valetudo_map_parser/config/auto_crop.py

@@ -125,7 +125,7 @@ class AutoCrop:
             if self.auto_crop:
                 self.auto_crop_offset()
         else:
-            self.handler.max_frames = 5
+            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):
@@ -137,12 +137,32 @@ class AutoCrop:
     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.handler.file_name,

valetudo_map_parser/config/color_utils.py

@@ -1,9 +1,9 @@
 """Utility functions for color operations in the map parser."""
 
-from typing import Tuple, Optional
+from typing import Optional, Tuple
 
 from .colors import ColorsManagement
-from .types import NumpyArray, Color
+from .types import Color, NumpyArray
 
 
 def get_blended_color(

valetudo_map_parser/config/colors.py

@@ -63,6 +63,7 @@ from .types import (
     Color,
 )
 
+
 color_transparent = (0, 0, 0, 0)
 color_charger = (0, 128, 0, 255)
 color_move = (238, 247, 255, 255)
@@ -492,10 +493,20 @@ class ColorsManagement:
                 background = tuple(map(int, array[y, x]))
 
                 # Update cache (with simple LRU-like behavior)
-                if len(cache) >= ColorsManagement._cache_size:
-                    # Remove a random entry if cache is full
-                    cache.pop(next(iter(cache)))
-                cache[cache_key] = background
+                try:
+                    if len(cache) >= ColorsManagement._cache_size:
+                        # Remove a random entry if cache is full
+                        if cache:  # Make sure cache is not empty
+                            cache.pop(next(iter(cache)))
+                        else:
+                            # If cache is somehow empty but len reported >= _cache_size
+                            # This is an edge case that shouldn't happen but we handle it
+                            pass
+                    cache[cache_key] = background
+                except KeyError:
+                    # If we encounter a KeyError, reset the cache
+                    # This is a rare edge case that might happen in concurrent access
+                    ColorsManagement._bg_color_cache = {cache_key: background}
 
             except (IndexError, ValueError):
                 return foreground

valetudo_map_parser/config/drawable.py

@@ -10,15 +10,14 @@ Optimized with NumPy and SciPy for better performance.
 
 from __future__ import annotations
 
-
 import logging
 import math
 
 import numpy as np
 from PIL import ImageDraw, ImageFont
 
-from .colors import ColorsManagement
 from .color_utils import get_blended_color
+from .colors import ColorsManagement
 from .types import Color, NumpyArray, PilPNG, Point, Tuple, Union
 
 
@@ -57,9 +56,6 @@ class Drawable:
         # Extract alpha from color
         alpha = color[3] if len(color) == 4 else 255
 
-        # For debugging
-        _LOGGER.debug("Drawing with color %s and alpha %s", color, alpha)
-
         # Create the full color with alpha
         full_color = color if len(color) == 4 else (*color, 255)
 

valetudo_map_parser/config/drawable_elements.py

@@ -8,10 +8,12 @@ from __future__ import annotations
 
 from enum import IntEnum
 from typing import Dict, List, Tuple, Union
+
 import numpy as np
-from .types import LOGGER
 
 from .colors import DefaultColors, SupportedColor
+from .types import LOGGER
+
 
 # Type aliases
 Color = Tuple[int, int, int, int]  # RGBA color
@@ -170,13 +172,7 @@ class DrawingConfig:
 
     def is_enabled(self, element_code: DrawableElement) -> bool:
         """Check if an element is enabled for drawing."""
-        enabled = self._enabled_elements.get(element_code, False)
-        LOGGER.debug(
-            "Checking if element %s is enabled: %s",
-            element_code.name if hasattr(element_code, "name") else element_code,
-            enabled,
-        )
-        return enabled
+        return self._enabled_elements.get(element_code, False)
 
     def set_property(
         self, element_code: DrawableElement, property_name: str, value
@@ -238,10 +234,6 @@ class DrawingConfig:
                 self.set_property(room_element, "color", rgba)
                 self.set_property(room_element, "opacity", alpha / 255.0)
 
-                LOGGER.debug(
-                    "Updated room %d color to %s with alpha %s", room_id, rgb, alpha
-                )
-
         # Update other element colors
         for element, color_key in element_color_mapping.items():
             if color_key in device_info:
@@ -265,13 +257,6 @@ class DrawingConfig:
                 self.set_property(element, "color", rgba)
                 self.set_property(element, "opacity", alpha / 255.0)
 
-                LOGGER.debug(
-                    "Updated element %s color to %s with alpha %s",
-                    element.name,
-                    rgb,
-                    alpha,
-                )
-
         # Check for disabled elements using specific boolean flags
         # Map element disable flags to DrawableElement enum values
         element_disable_mapping = {

valetudo_map_parser/config/enhanced_drawable.py

@@ -13,12 +13,12 @@ from typing import Optional, Tuple
 
 import numpy as np
 
+from .colors import ColorsManagement
 from .drawable import Drawable
 from .drawable_elements import (
     DrawableElement,
     DrawingConfig,
 )
-from .colors import ColorsManagement
 
 
 # Type aliases

valetudo_map_parser/config/shared.py

@@ -247,26 +247,6 @@ class CameraSharedManager:
             )
             instance.trims = TrimsData.from_dict(trim_data)
 
-            # Log disable_obstacles and disable_path settings
-            if "disable_obstacles" in device_info:
-                _LOGGER.info(
-                    "%s: device_info contains disable_obstacles: %s",
-                    instance.file_name,
-                    device_info["disable_obstacles"],
-                )
-            if "disable_path" in device_info:
-                _LOGGER.info(
-                    "%s: device_info contains disable_path: %s",
-                    instance.file_name,
-                    device_info["disable_path"],
-                )
-            if "disable_elements" in device_info:
-                _LOGGER.info(
-                    "%s: device_info contains disable_elements: %s",
-                    instance.file_name,
-                    device_info["disable_elements"],
-                )
-
         except TypeError as ex:
             _LOGGER.error("Shared data can't be initialized due to a TypeError! %s", ex)
         except AttributeError as ex:

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, TypedDict
+from typing import Any, Dict, Optional, Tuple, TypedDict, Union
 
 import numpy as np
 from PIL import Image
@@ -639,7 +639,3 @@ class TrimsData:
         self.trim_down = 0
         self.trim_right = 0
         return asdict(self)
-
-    def self_instance(self):
-        """Return self instance."""
-        return self.self_instance()

valetudo_map_parser/config/utils.py

@@ -550,58 +550,8 @@ def initialize_drawing_config(handler):
         hasattr(handler.shared, "device_info")
         and handler.shared.device_info is not None
     ):
-        LOGGER.info(
-            "%s: Initializing drawing config from device_info", handler.file_name
-        )
-        LOGGER.info(
-            "%s: device_info contains disable_obstacles: %s",
-            handler.file_name,
-            "disable_obstacles" in handler.shared.device_info,
-        )
-        LOGGER.info(
-            "%s: device_info contains disable_path: %s",
-            handler.file_name,
-            "disable_path" in handler.shared.device_info,
-        )
-        LOGGER.info(
-            "%s: device_info contains disable_elements: %s",
-            handler.file_name,
-            "disable_elements" in handler.shared.device_info,
-        )
-
-        if "disable_obstacles" in handler.shared.device_info:
-            LOGGER.info(
-                "%s: disable_obstacles value: %s",
-                handler.file_name,
-                handler.shared.device_info["disable_obstacles"],
-            )
-        if "disable_path" in handler.shared.device_info:
-            LOGGER.info(
-                "%s: disable_path value: %s",
-                handler.file_name,
-                handler.shared.device_info["disable_path"],
-            )
-        if "disable_elements" in handler.shared.device_info:
-            LOGGER.info(
-                "%s: disable_elements value: %s",
-                handler.file_name,
-                handler.shared.device_info["disable_elements"],
-            )
-
         drawing_config.update_from_device_info(handler.shared.device_info)
 
-        # Verify elements are disabled
-        LOGGER.info(
-            "%s: After initialization, PATH enabled: %s",
-            handler.file_name,
-            drawing_config.is_enabled(DrawableElement.PATH),
-        )
-        LOGGER.info(
-            "%s: After initialization, OBSTACLE enabled: %s",
-            handler.file_name,
-            drawing_config.is_enabled(DrawableElement.OBSTACLE),
-        )
-
     # Initialize both drawable systems for backward compatibility
     draw = Drawable()  # Legacy drawing utilities
     enhanced_draw = EnhancedDrawable(drawing_config)  # New enhanced drawing system
@@ -632,7 +582,7 @@ def blend_colors(base_color, overlay_color):
 
     # Avoid division by zero
     if a_out < 0.0001:
-        return (0, 0, 0, 0)
+        return [0, 0, 0, 0]
 
     # Calculate blended RGB components
     r_out = (r1 * a1 + r2 * a2 * (1 - a1)) / a_out

valetudo_map_parser/hypfer_draw.py

@@ -142,12 +142,6 @@ class ImageDraw:
                 room_element = getattr(DrawableElement, f"ROOM_{current_room_id}", None)
                 if room_element and hasattr(self.img_h.drawing_config, "is_enabled"):
                     draw_room = self.img_h.drawing_config.is_enabled(room_element)
-                    _LOGGER.debug(
-                        "%s: Room %d is %s",
-                        self.file_name,
-                        current_room_id,
-                        "enabled" if draw_room else "disabled",
-                    )
 
         # Get the room color
         room_color = self.img_h.shared.rooms_colors[room_id]
@@ -170,13 +164,6 @@ class ImageDraw:
         except IndexError as e:
             _LOGGER.warning("%s: Image Draw Error: %s", self.file_name, str(e))
 
-        _LOGGER.debug(
-            "%s Active Zones: %s and Room ID: %s",
-            self.file_name,
-            str(self.img_h.active_zones),
-            str(room_id),
-        )
-
         return img_np_array, room_id
 
     def _get_active_room_color(self, room_id, room_color, color_zone_clean):

valetudo_map_parser/hypfer_handler.py

@@ -20,6 +20,7 @@ from .config.types import (
     CalibrationPoints,
     Colors,
     RoomsProperties,
+    RoomStore,
 )
 from .config.utils import (
     BaseHandler,
@@ -28,8 +29,8 @@ from .config.utils import (
     prepare_resize_params,
 )
 from .hypfer_draw import ImageDraw as ImDraw
-from .hypfer_rooms_handler import HypferRoomsHandler
 from .map_data import ImageData
+from .rooms_handler import RoomsHandler
 
 
 class HypferMapImageHandler(BaseHandler, AutoCrop):
@@ -57,7 +58,7 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
         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.
-        self.rooms_handler = HypferRoomsHandler(
+        self.rooms_handler = RoomsHandler(
             self.file_name, self.drawing_config
         )  # Room data handler
 
@@ -68,51 +69,24 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
 
     async def async_extract_room_properties(self, json_data) -> RoomsProperties:
         """Extract room properties from the JSON data."""
-
-        return await self.rooms_handler.async_extract_room_properties(json_data)
-        # room_properties = {}
-        # self.rooms_pos = []
-        # pixel_size = json_data.get("pixelSize", [])
-        #
-        # for layer in json_data.get("layers", []):
-        #     if layer["__class"] == "MapLayer":
-        #         meta_data = layer.get("metaData", {})
-        #         segment_id = meta_data.get("segmentId")
-        #         if segment_id is not None:
-        #             name = meta_data.get("name")
-        #             compressed_pixels = layer.get("compressedPixels", [])
-        #             pixels = self.data.sublist(compressed_pixels, 3)
-        #             # Calculate x and y min/max from compressed pixels
-        #             (
-        #                 x_min,
-        #                 y_min,
-        #                 x_max,
-        #                 y_max,
-        #             ) = await self.data.async_get_rooms_coordinates(pixels, pixel_size)
-        #             corners = self.get_corners(x_max, x_min, y_max, y_min)
-        #             room_id = str(segment_id)
-        #             self.rooms_pos.append(
-        #                 {
-        #                     "name": name,
-        #                     "corners": corners,
-        #                 }
-        #             )
-        #             room_properties[room_id] = {
-        #                 "number": segment_id,
-        #                 "outline": corners,
-        #                 "name": name,
-        #                 "x": ((x_min + x_max) // 2),
-        #                 "y": ((y_min + y_max) // 2),
-        #             }
-        # if room_properties:
-        #     rooms = RoomStore(self.file_name, room_properties)
-        #     LOGGER.debug(
-        #         "%s: Rooms data extracted! %s", self.file_name, rooms.get_rooms()
-        #     )
-        # else:
-        #     LOGGER.debug("%s: Rooms data not available!", self.file_name)
-        #     self.rooms_pos = None
-        # return room_properties
+        room_properties = await self.rooms_handler.async_extract_room_properties(
+            json_data
+        )
+        if room_properties:
+            rooms = RoomStore(self.file_name, room_properties)
+            LOGGER.debug(
+                "%s: Rooms data extracted! %s", self.file_name, rooms.get_rooms()
+            )
+            # Convert room_properties to the format expected by async_get_robot_in_room
+            self.rooms_pos = []
+            for room_id, room_data in room_properties.items():
+                self.rooms_pos.append(
+                    {"name": room_data["name"], "outline": room_data["outline"]}
+                )
+        else:
+            LOGGER.debug("%s: Rooms data not available!", self.file_name)
+            self.rooms_pos = None
+        return room_properties
 
     # noinspection PyUnresolvedReferences,PyUnboundLocalVariable
     async def async_get_image_from_json(
@@ -164,9 +138,6 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                     img_np_array = await self.draw.create_empty_image(
                         size_x, size_y, colors["background"]
                     )
-
-                    LOGGER.info("%s: Drawing map with color blending", self.file_name)
-
                     # Draw layers and segments if enabled
                     room_id = 0
                     # Keep track of disabled rooms to skip their walls later
@@ -218,25 +189,13 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                                     room_element = getattr(
                                         DrawableElement, f"ROOM_{current_room_id}", None
                                     )
-                                    if room_element:
-                                        # Log the room check for debugging
-                                        LOGGER.debug(
-                                            "%s: Checking if room %d is enabled: %s",
-                                            self.file_name,
-                                            current_room_id,
-                                            self.drawing_config.is_enabled(
-                                                room_element
-                                            ),
-                                        )
 
-                                        # Skip this room if it's disabled
-                                        if not self.drawing_config.is_enabled(
-                                            room_element
-                                        ):
-                                            room_id = (
-                                                room_id + 1
-                                            ) % 16  # Increment room_id even if we skip
-                                            continue
+                                    # Skip this room if it's disabled
+                                    if not self.drawing_config.is_enabled(room_element):
+                                        room_id = (
+                                            room_id + 1
+                                        ) % 16  # Increment room_id even if we skip
+                                        continue
 
                             # Check if this is a wall layer and if walls are enabled
                             is_wall_layer = layer_type == "wall"
@@ -244,22 +203,7 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                                 if not self.drawing_config.is_enabled(
                                     DrawableElement.WALL
                                 ):
-                                    LOGGER.info(
-                                        "%s: Skipping wall layer because WALL element is disabled",
-                                        self.file_name,
-                                    )
-                                    continue
-
-                                # Filter out walls for disabled rooms
-                                if disabled_rooms:
-                                    # Need to modify compressed_pixels_list to exclude walls of disabled rooms
-                                    # This requires knowledge of which walls belong to which rooms
-                                    # For now, we'll just log that we're drawing walls for all rooms
-                                    LOGGER.debug(
-                                        "%s: Drawing walls for all rooms (including disabled ones)",
-                                        self.file_name,
-                                    )
-                                    # In a real implementation, we would filter the walls here
+                                    pass
 
                             # Draw the layer
                             (
@@ -281,10 +225,6 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                                 room_element = getattr(
                                     DrawableElement, f"ROOM_{room_id}", None
                                 )
-                                if room_element:
-                                    # This is a simplification - in a real implementation we would
-                                    # need to identify the exact pixels that belong to this room
-                                    pass
 
                     # Draw the virtual walls if enabled
                     if self.drawing_config.is_enabled(DrawableElement.VIRTUAL_WALL):