valetudo-map-parser 0.1.9a6__tar.gz → 0.1.9a8__tar.gz

{valetudo_map_parser-0.1.9a6 → valetudo_map_parser-0.1.9a8}/PKG-INFO

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

@@ -7,6 +7,7 @@ import logging
 
 import numpy as np
 from numpy import rot90
+from scipy import ndimage
 
 from .types import Color, NumpyArray, TrimCropData, TrimsData
 from .utils import BaseHandler
@@ -89,7 +90,7 @@ class AutoCrop:
 
     async def _async_auto_crop_data(self, tdata: TrimsData):  # , tdata=None
         """Load the auto crop data from the Camera config."""
-        _LOGGER.debug("Auto Crop data: %s, %s", str(tdata), str(self.auto_crop))
+        _LOGGER.debug("Auto Crop init 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()
             (
@@ -139,7 +140,7 @@ class AutoCrop:
     ) -> tuple[int, int, int, int]:
         """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
@@ -269,7 +270,7 @@ class AutoCrop:
 
             # Get the current room name from robot_pos (not robot_in_room)
             current_room = self.handler.robot_pos.get("in_room") if self.handler.robot_pos else None
-
+            _LOGGER.info(f"Current room: {current_room}")
 
             if not current_room:
                 # For Rand256 handler, try to zoom based on robot position even without room data
@@ -303,12 +304,9 @@ class AutoCrop:
                         self.auto_crop[0] : self.auto_crop[2],
                     ]
 
-
-
             # Calculate bounding box from room outline
             bounding_box = await self.async_get_room_bounding_box(current_room, rand256)
 
-
             if not bounding_box:
                 _LOGGER.warning(
                     "%s: Could not calculate bounding box for room '%s'. Using full image.",
@@ -328,9 +326,6 @@ class AutoCrop:
             trim_right = right + margin_size
             trim_up = up - margin_size
             trim_down = 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])

{valetudo_map_parser-0.1.9a6 → valetudo_map_parser-0.1.9a8}/SCR/valetudo_map_parser/hypfer_draw.py

@@ -426,6 +426,39 @@ class ImageDraw:
         _LOGGER.info("%s: Got the points in the json.", self.file_name)
         return entity_dict
 
+    def _check_active_zone_and_set_zooming(self) -> None:
+        """Helper function to check active zones and set zooming state."""
+        if self.img_h.active_zones and self.img_h.robot_in_room:
+            from .config.types import RoomStore
+            segment_id = str(self.img_h.robot_in_room["id"])
+            room_store = RoomStore(self.file_name)
+            room_keys = list(room_store.get_rooms().keys())
+
+            _LOGGER.debug(
+                "%s: Active zones debug - segment_id: %s, room_keys: %s, active_zones: %s",
+                self.file_name, segment_id, room_keys, self.img_h.active_zones
+            )
+
+            if segment_id in room_keys:
+                position = room_keys.index(segment_id)
+                _LOGGER.debug(
+                    "%s: Segment ID %s found at position %s, active_zones[%s] = %s",
+                    self.file_name, segment_id, position, position,
+                    self.img_h.active_zones[position] if position < len(self.img_h.active_zones) else "OUT_OF_BOUNDS"
+                )
+                if position < len(self.img_h.active_zones):
+                    self.img_h.zooming = bool(self.img_h.active_zones[position])
+                else:
+                    self.img_h.zooming = False
+            else:
+                _LOGGER.warning(
+                    "%s: Segment ID %s not found in room_keys %s",
+                    self.file_name, segment_id, room_keys
+                )
+                self.img_h.zooming = False
+        else:
+            self.img_h.zooming = False
+
     @staticmethod
     def point_in_polygon(x: int, y: int, polygon: list) -> bool:
         """
@@ -474,15 +507,7 @@ class ImageDraw:
                         "in_room": self.img_h.robot_in_room["room"],
                     }
                     # Handle active zones
-                    if self.img_h.active_zones and (
-                        self.img_h.robot_in_room["id"]
-                        in range(len(self.img_h.active_zones))
-                    ):
-                        self.img_h.zooming = bool(
-                            self.img_h.active_zones[self.img_h.robot_in_room["id"]]
-                        )
-                    else:
-                        self.img_h.zooming = False
+                    self._check_active_zone_and_set_zooming()
                     return temp
             # Fallback to bounding box check if no outline data
             elif all(
@@ -502,15 +527,7 @@ class ImageDraw:
                         "in_room": self.img_h.robot_in_room["room"],
                     }
                     # Handle active zones
-                    if self.img_h.active_zones and (
-                        self.img_h.robot_in_room["id"]
-                        in range(len(self.img_h.active_zones))
-                    ):
-                        self.img_h.zooming = bool(
-                            self.img_h.active_zones[self.img_h.robot_in_room["id"]]
-                        )
-                    else:
-                        self.img_h.zooming = False
+                    self._check_active_zone_and_set_zooming()
                     return temp
 
         # If we don't have a cached room or the robot is not in it, search all rooms
@@ -563,7 +580,7 @@ class ImageDraw:
                 if self.point_in_polygon(int(robot_x), int(robot_y), outline):
                     # Robot is in this room
                     self.img_h.robot_in_room = {
-                        "id": room_count,
+                        "id": room.get("id", room_count),  # Use actual segment ID if available
                         "room": str(room["name"]),
                         "outline": outline,
                     }
@@ -574,15 +591,34 @@ class ImageDraw:
                         "in_room": self.img_h.robot_in_room["room"],
                     }
 
-                    # Handle active zones - Set zooming based on active zones
+                    # Handle active zones - Map segment ID to active_zones position
                     if self.img_h.active_zones:
-                        # Convert room ID to integer index
-                        room_id = int(self.img_h.robot_in_room["id"])
-                        if room_id < len(self.img_h.active_zones):
-                            self.img_h.zooming = bool(
-                                self.img_h.active_zones[room_id]
+                        from .config.types import RoomStore
+                        segment_id = str(self.img_h.robot_in_room["id"])
+                        room_store = RoomStore(self.file_name)
+                        room_keys = list(room_store.get_rooms().keys())
+
+                        _LOGGER.debug(
+                            "%s: Active zones debug - segment_id: %s, room_keys: %s, active_zones: %s",
+                            self.file_name, segment_id, room_keys, self.img_h.active_zones
+                        )
+
+                        if segment_id in room_keys:
+                            position = room_keys.index(segment_id)
+                            _LOGGER.debug(
+                                "%s: Segment ID %s found at position %s, active_zones[%s] = %s",
+                                self.file_name, segment_id, position, position,
+                                self.img_h.active_zones[position] if position < len(self.img_h.active_zones) else "OUT_OF_BOUNDS"
                             )
+                            if position < len(self.img_h.active_zones):
+                                self.img_h.zooming = bool(self.img_h.active_zones[position])
+                            else:
+                                self.img_h.zooming = False
                         else:
+                            _LOGGER.warning(
+                                "%s: Segment ID %s not found in room_keys %s",
+                                self.file_name, segment_id, room_keys
+                            )
                             self.img_h.zooming = False
                     else:
                         self.img_h.zooming = False
@@ -598,7 +634,7 @@ class ImageDraw:
                 corners = room["corners"]
                 # Create a bounding box from the corners
                 self.img_h.robot_in_room = {
-                    "id": room_count,
+                    "id": room.get("id", room_count),  # Use actual segment ID if available
                     "left": int(corners[0][0]),
                     "right": int(corners[2][0]),
                     "up": int(corners[0][1]),
@@ -620,18 +656,8 @@ class ImageDraw:
                         "in_room": self.img_h.robot_in_room["room"],
                     }
 
-                    # Handle active zones - Set zooming based on active zones
-                    if self.img_h.active_zones:
-                        # Convert room ID to integer index
-                        room_id = int(self.img_h.robot_in_room["id"])
-                        if room_id < len(self.img_h.active_zones):
-                            self.img_h.zooming = bool(
-                                self.img_h.active_zones[room_id]
-                            )
-                        else:
-                            self.img_h.zooming = False
-                    else:
-                        self.img_h.zooming = False
+                    # Handle active zones
+                    self._check_active_zone_and_set_zooming()
 
                     _LOGGER.debug(
                         "%s is in %s room (bounding box detection).",

{valetudo_map_parser-0.1.9a6 → valetudo_map_parser-0.1.9a8}/SCR/valetudo_map_parser/hypfer_handler.py

@@ -81,7 +81,7 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
             self.rooms_pos = []
             for room_id, room_data in room_properties.items():
                 self.rooms_pos.append(
-                    {"name": room_data["name"], "outline": room_data["outline"]}
+                    {"id": room_id, "name": room_data["name"], "outline": room_data["outline"]}
                 )
         else:
             LOGGER.debug("%s: Rooms data not available!", self.file_name)
@@ -131,6 +131,8 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                 # Get the pixels size and layers from the JSON data
                 pixel_size = int(m_json["pixelSize"])
                 layers, active = self.data.find_layers(m_json["layers"], {}, [])
+                # Populate active_zones from the JSON data
+                self.active_zones = active
                 new_frame_hash = await self.calculate_array_hash(layers, active)
                 if self.frame_number == 0:
                     self.img_hash = new_frame_hash

{valetudo_map_parser-0.1.9a6 → valetudo_map_parser-0.1.9a8}/SCR/valetudo_map_parser/rand25_handler.py

@@ -2,7 +2,7 @@
 Image Handler Module for Valetudo Re Vacuums.
 It returns the PIL PNG image frame relative to the Map Data extrapolated from the vacuum json.
 It also returns calibration, rooms data to the card and other images information to the camera.
-Version: 0.1.9.b42
+Version: 0.1.9.a6
 """
 
 from __future__ import annotations
@@ -264,10 +264,6 @@ class ReImageHandler(BaseHandler, AutoCrop):
             and robot_position
             and destinations  # Check if we have destinations data for room extraction
         ):
-            _LOGGER.debug(
-                "%s: Attempting early room extraction for active zone checking",
-                self.file_name
-            )
             # Extract room data early if we have destinations
             try:
                 temp_room_properties = await self.rooms_handler.async_extract_room_properties(
@@ -293,12 +289,6 @@ class ReImageHandler(BaseHandler, AutoCrop):
                     # Restore original rooms_pos
                     self.rooms_pos = original_rooms_pos
 
-                    _LOGGER.debug(
-                        "%s: Early robot room detection for zoom: robot in %s, zooming=%s",
-                        self.file_name,
-                        robot_room_result.get("in_room", "unknown"),
-                        self.zooming
-                    )
             except Exception as e:
                 _LOGGER.debug(
                     "%s: Early room extraction failed: %s, falling back to robot-position zoom",
@@ -367,7 +357,7 @@ class ReImageHandler(BaseHandler, AutoCrop):
         if robot_position:
             self.robot_position = robot_position
 
-        # Check if zoom should be enabled based on active zones
+        # Check if Zoom should be enabled based on active zones
         if (
             self.shared.image_auto_zoom
             and self.shared.vacuum_state == "cleaning"
@@ -593,7 +583,6 @@ class ReImageHandler(BaseHandler, AutoCrop):
 
                     # Handle active zones - Set zooming based on active zones
                     self.active_zones = self.shared.rand256_active_zone
-                    self.zooming = False
                     if self.active_zones and (
                         self.robot_in_room["id"]
                         in range(len(self.active_zones))

{valetudo_map_parser-0.1.9a6 → valetudo_map_parser-0.1.9a8}/pyproject.toml

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