valetudo-map-parser 0.1.10rc6__py3-none-any.whl → 0.1.11b1__py3-none-any.whl

valetudo_map_parser/hypfer_draw.py

@@ -269,8 +269,6 @@ class ImageDraw:
             zone_clean = self.img_h.data.find_zone_entities(m_json)
         except (ValueError, KeyError):
             zone_clean = None
-        else:
-            _LOGGER.info("%s: Got zones.", self.file_name)
 
         if zone_clean:
             # Process zones sequentially to avoid memory-intensive array copies

valetudo_map_parser/hypfer_handler.py

@@ -8,25 +8,22 @@ Version: 0.1.10
 from __future__ import annotations
 
 import asyncio
-import numpy as np
 
+import numpy as np
+from mvcrender.autocrop import AutoCrop
 from PIL import Image
 
 from .config.async_utils import AsyncPIL
-
-# from .config.auto_crop import AutoCrop
-from mvcrender.autocrop import AutoCrop
 from .config.drawable_elements import DrawableElement
 from .config.shared import CameraShared
-
 from .config.types import (
     COLORS,
     LOGGER,
     CalibrationPoints,
     Colors,
+    JsonType,
     RoomsProperties,
     RoomStore,
-    JsonType,
 )
 from .config.utils import (
     BaseHandler,
@@ -49,9 +46,7 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
         self.calibration_data = None  # camera shared data.
         self.data = ImageData  # imported Image Data Module.
         # Initialize drawing configuration using the shared utility function
-        self.drawing_config, self.draw, self.enhanced_draw = initialize_drawing_config(
-            self
-        )
+        self.drawing_config, self.draw = initialize_drawing_config(self)
 
         self.go_to = None  # vacuum go to data
         self.img_hash = None  # hash of the image calculated to check differences.
@@ -60,7 +55,6 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
             None  # persistent working buffer to avoid per-frame allocations
         )
         self.active_zones = []  # vacuum active zones.
-        self.svg_wait = False  # SVG image creation wait.
         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.
@@ -79,7 +73,7 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
             json_data
         )
         if room_properties:
-            rooms = RoomStore(self.file_name, room_properties)
+            _ = RoomStore(self.file_name, room_properties)
             # 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():
@@ -260,7 +254,12 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                         )
                     LOGGER.info("%s: Completed base Layers", self.file_name)
                     # Copy the new array in base layer.
+                    # Delete old base layer before creating new one to free memory
+                    if self.img_base_layer is not None:
+                        del self.img_base_layer
                     self.img_base_layer = await self.async_copy_array(img_np_array)
+                    # Delete source array after copying to free memory
+                    del img_np_array
 
                 self.shared.frame_number = self.frame_number
                 self.frame_number += 1
@@ -274,6 +273,9 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                     or self.img_work_layer.shape != self.img_base_layer.shape
                     or self.img_work_layer.dtype != self.img_base_layer.dtype
                 ):
+                    # Delete old buffer before creating new one to free memory
+                    if self.img_work_layer is not None:
+                        del self.img_work_layer
                     self.img_work_layer = np.empty_like(self.img_base_layer)
 
                 # Copy the base layer into the persistent working buffer (no new allocation per frame)
@@ -348,21 +350,11 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                         robot_state=self.shared.vacuum_state,
                     )
 
-                    # Update element map for robot position
-                    if (
-                        hasattr(self.shared, "element_map")
-                        and self.shared.element_map is not None
-                    ):
-                        update_element_map_with_robot(
-                            self.shared.element_map,
-                            robot_position,
-                            DrawableElement.ROBOT,
-                        )
                 # Synchronize zooming state from ImageDraw to handler before auto-crop
                 self.zooming = self.imd.img_h.zooming
 
                 # Resize the image
-                img_np_array = self.async_auto_trim_and_zoom_image(
+                img_np_array = self.auto_trim_and_zoom_image(
                     img_np_array,
                     colors["background"],
                     int(self.shared.margins),

valetudo_map_parser/map_data.py

@@ -8,22 +8,22 @@ Version: v0.1.10
 
 from __future__ import annotations
 
-import numpy as np
+from dataclasses import asdict, dataclass, field
 from typing import (
-    List,
-    Sequence,
-    TypeVar,
     Any,
-    TypedDict,
-    NotRequired,
     Literal,
+    NotRequired,
     Optional,
+    Sequence,
+    TypedDict,
+    TypeVar,
 )
 
-from dataclasses import dataclass, field, asdict
+import numpy as np
 
 from .config.types import ImageSize, JsonType
 
+
 T = TypeVar("T")
 
 # --- Common Nested Structures ---
@@ -373,6 +373,11 @@ class ImageData:
             Else:
                 (min_x_mm, min_y_mm, max_x_mm, max_y_mm)
         """
+
+        def to_mm(coord):
+            """Convert pixel coordinates to millimeters."""
+            return round(coord * pixel_size * 10)
+
         if not pixels:
             raise ValueError("Pixels list cannot be empty.")
 
@@ -393,7 +398,6 @@ class ImageData:
             min_y = min(min_y, y)
 
         if rand:
-            to_mm = lambda v: v * pixel_size * 10
             return (to_mm(max_x), to_mm(max_y)), (to_mm(min_x), to_mm(min_y))
 
         return (
@@ -539,16 +543,18 @@ class RandImageData:
         return None
 
     @staticmethod
-    def get_rrm_currently_cleaned_zones(json_data: JsonType) -> dict:
+    def get_rrm_currently_cleaned_zones(json_data: JsonType) -> list[dict[str, Any]]:
         """Get the currently cleaned zones from the json."""
         re_zones = json_data.get("currently_cleaned_zones", [])
         formatted_zones = RandImageData._rrm_valetudo_format_zone(re_zones)
         return formatted_zones
 
     @staticmethod
-    def get_rrm_forbidden_zones(json_data: JsonType) -> dict:
+    def get_rrm_forbidden_zones(json_data: JsonType) -> list[dict[str, Any]]:
         """Get the forbidden zones from the json."""
-        re_zones = json_data.get("forbidden_zones", [])
+        re_zones = json_data.get("forbidden_zones", []) + json_data.get(
+            "forbidden_mop_zones", []
+        )
         formatted_zones = RandImageData._rrm_valetudo_format_zone(re_zones)
         return formatted_zones
 

valetudo_map_parser/rand256_handler.py

@@ -2,27 +2,26 @@
 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.a6
+Version: 0.1.10
 """
 
 from __future__ import annotations
 
-import logging
 import uuid
 from typing import Any
 
 import numpy as np
+from mvcrender.autocrop import AutoCrop
 
 from .config.async_utils import AsyncPIL
-
-# from .config.auto_crop import AutoCrop
-from mvcrender.autocrop import AutoCrop
 from .config.drawable_elements import DrawableElement
 from .config.types import (
     COLORS,
     DEFAULT_IMAGE_SIZE,
     DEFAULT_PIXEL_SIZE,
+    LOGGER,
     Colors,
+    Destinations,
     JsonType,
     PilPNG,
     RobotPosition,
@@ -39,9 +38,6 @@ from .reimg_draw import ImageDraw
 from .rooms_handler import RandRoomsHandler
 
 
-_LOGGER = logging.getLogger(__name__)
-
-
 # noinspection PyTypeChecker
 class ReImageHandler(BaseHandler, AutoCrop):
     """
@@ -59,11 +55,10 @@ class ReImageHandler(BaseHandler, AutoCrop):
         self.data = RandImageData  # Image Data
 
         # Initialize drawing configuration using the shared utility function
-        self.drawing_config, self.draw, self.enhanced_draw = initialize_drawing_config(
-            self
-        )
+        self.drawing_config, self.draw = initialize_drawing_config(self)
         self.go_to = None  # Go to position data
         self.img_base_layer = None  # Base image layer
+        self.img_work_layer = None  # Persistent working buffer (reused across frames)
         self.img_rotate = shared_data.image_rotate  # Image rotation
         self.room_propriety = None  # Room propriety data
         self.active_zones = None  # Active zones
@@ -74,7 +69,9 @@ class ReImageHandler(BaseHandler, AutoCrop):
         )  # Room data handler
 
     async def extract_room_properties(
-        self, json_data: JsonType, destinations: JsonType
+        self,
+        json_data: JsonType,
+        destinations: Destinations | None = None,
     ) -> RoomsProperties:
         """Extract the room properties."""
         # unsorted_id = RandImageData.get_rrm_segments_ids(json_data)
@@ -89,9 +86,10 @@ class ReImageHandler(BaseHandler, AutoCrop):
                     json_data, size_x, size_y, top, left, True
                 )
 
-            dest_json = destinations
-            zones_data = dict(dest_json).get("zones", [])
-            points_data = dict(dest_json).get("spots", [])
+
+            dest_json = destinations if destinations else {}
+            zones_data = dest_json.get("zones", [])
+            points_data = dest_json.get("spots", [])
 
             # Use the RandRoomsHandler to extract room properties
             room_properties = await self.rooms_handler.async_extract_room_properties(
@@ -100,39 +98,35 @@ class ReImageHandler(BaseHandler, AutoCrop):
 
             # Update self.rooms_pos from room_properties for compatibility with other methods
             self.rooms_pos = []
-            room_ids = []  # Collect room IDs for shared.map_rooms
             for room_id, room_data in room_properties.items():
                 self.rooms_pos.append(
                     {"name": room_data["name"], "outline": room_data["outline"]}
                 )
-                # Store the room number (segment ID) for MQTT active zone mapping
-                room_ids.append(room_data["number"])
-
-            # Update shared.map_rooms with the room IDs for MQTT active zone mapping
-            self.shared.map_rooms = room_ids
 
+            # Update shared.map_rooms with the full room properties (consistent with Hypfer)
+            self.shared.map_rooms = room_properties
             # get the zones and points data
-            zone_properties = await self.async_zone_propriety(zones_data)
+            self.shared.map_pred_zones = await self.async_zone_propriety(zones_data)
             # get the points data
-            point_properties = await self.async_points_propriety(points_data)
+            self.shared.map_pred_points = await self.async_points_propriety(points_data)
 
-            if not (room_properties or zone_properties):
+            if not (room_properties or self.shared.map_pred_zones):
                 self.rooms_pos = None
 
-            rooms = RoomStore(self.file_name, room_properties)
-            return room_properties, zone_properties, point_properties
+            _ = RoomStore(self.file_name, room_properties)
+            return room_properties
         except (RuntimeError, ValueError) as e:
-            _LOGGER.warning(
+            LOGGER.warning(
                 "No rooms Data or Error in extract_room_properties: %s",
                 e,
                 exc_info=True,
             )
-            return None, None, None
+            return None
 
     async def get_image_from_rrm(
         self,
         m_json: JsonType,  # json data
-        destinations: None = None,  # MQTT destinations for labels
+        destinations: Destinations | None = None,  # MQTT destinations for labels
     ) -> PilPNG | None:
         """Generate Images from the json data.
         @param m_json: The JSON data to use to draw the image.
@@ -146,12 +140,12 @@ class ReImageHandler(BaseHandler, AutoCrop):
 
         try:
             if (m_json is not None) and (not isinstance(m_json, tuple)):
-                _LOGGER.info("%s: Composing the image for the camera.", self.file_name)
+                LOGGER.info("%s: Composing the image for the camera.", self.file_name)
                 self.json_data = m_json
                 size_x, size_y = self.data.get_rrm_image_size(m_json)
                 self.img_size = DEFAULT_IMAGE_SIZE
                 self.json_id = str(uuid.uuid4())  # image id
-                _LOGGER.info("Vacuum Data ID: %s", self.json_id)
+                LOGGER.info("Vacuum Data ID: %s", self.json_id)
 
                 (
                     img_np_array,
@@ -163,10 +157,24 @@ class ReImageHandler(BaseHandler, AutoCrop):
 
                 # Increment frame number
                 self.frame_number += 1
-                img_np_array = await self.async_copy_array(self.img_base_layer)
                 if self.frame_number > 5:
                     self.frame_number = 0
 
+                # Ensure persistent working buffer exists and matches base (allocate only when needed)
+                if (
+                    self.img_work_layer is None
+                    or self.img_work_layer.shape != self.img_base_layer.shape
+                    or self.img_work_layer.dtype != self.img_base_layer.dtype
+                ):
+                    # Delete old buffer before creating new one to free memory
+                    if self.img_work_layer is not None:
+                        del self.img_work_layer
+                    self.img_work_layer = np.empty_like(self.img_base_layer)
+
+                # Copy the base layer into the persistent working buffer (no new allocation per frame)
+                np.copyto(self.img_work_layer, self.img_base_layer)
+                img_np_array = self.img_work_layer
+
                 # Draw map elements
                 img_np_array = await self._draw_map_elements(
                     img_np_array, m_json, colors, robot_position, robot_position_angle
@@ -174,11 +182,11 @@ class ReImageHandler(BaseHandler, AutoCrop):
 
                 # Return PIL Image using async utilities
                 pil_img = await AsyncPIL.async_fromarray(img_np_array, mode="RGBA")
-                del img_np_array  # free memory
+                # Note: Don't delete img_np_array here as it's the persistent work buffer
                 return await self._finalize_image(pil_img)
 
         except (RuntimeError, RuntimeWarning) as e:
-            _LOGGER.warning(
+            LOGGER.warning(
                 "%s: Runtime Error %s during image creation.",
                 self.file_name,
                 str(e),
@@ -192,6 +200,7 @@ class ReImageHandler(BaseHandler, AutoCrop):
     async def _setup_robot_and_image(
         self, m_json, size_x, size_y, colors, destinations
     ):
+        """Set up the elements of the map and the image."""
         (
             _,
             robot_position,
@@ -214,13 +223,7 @@ class ReImageHandler(BaseHandler, AutoCrop):
                     colors["background"],
                     DEFAULT_PIXEL_SIZE,
                 )
-                _LOGGER.info("%s: Completed base Layers", self.file_name)
-
-                # Update element map for rooms
-                if 0 < room_id <= 15:
-                    # This is a simplification - in a real implementation we would
-                    # need to identify the exact pixels that belong to each room
-                    pass
+                LOGGER.info("%s: Completed base Layers", self.file_name)
 
                 if room_id > 0 and not self.room_propriety:
                     self.room_propriety = await self.get_rooms_attributes(destinations)
@@ -229,14 +232,23 @@ class ReImageHandler(BaseHandler, AutoCrop):
                 if not self.rooms_pos and not self.room_propriety:
                     self.room_propriety = await self.get_rooms_attributes(destinations)
 
-                # Always check robot position for zooming (fallback)
-                if self.rooms_pos and robot_position and not hasattr(self, "robot_pos"):
+                # Always check robot position for zooming (update if room info is missing)
+                if (
+                    self.rooms_pos
+                    and robot_position
+                    and (self.robot_pos is None or "in_room" not in self.robot_pos)
+                ):
                     self.robot_pos = await self.async_get_robot_in_room(
                         (robot_position[0] * 10),
                         (robot_position[1] * 10),
                         robot_position_angle,
                     )
+                # Delete old base layer before creating new one to free memory
+                if self.img_base_layer is not None:
+                    del self.img_base_layer
                 self.img_base_layer = await self.async_copy_array(img_np_array)
+                # Delete source array after copying to free memory
+                del img_np_array
             else:
                 # If floor is disabled, create an empty image
                 background_color = self.drawing_config.get_property(
@@ -245,7 +257,12 @@ class ReImageHandler(BaseHandler, AutoCrop):
                 img_np_array = await self.draw.create_empty_image(
                     size_x, size_y, background_color
                 )
+                # Delete old base layer before creating new one to free memory
+                if self.img_base_layer is not None:
+                    del self.img_base_layer
                 self.img_base_layer = await self.async_copy_array(img_np_array)
+                # Delete source array after copying to free memory
+                del img_np_array
 
         # Check active zones BEFORE auto-crop to enable proper zoom functionality
         # This needs to run on every frame, not just frame 0
@@ -277,7 +294,7 @@ class ReImageHandler(BaseHandler, AutoCrop):
                     # Restore original rooms_pos
                     self.rooms_pos = original_rooms_pos
 
-            except Exception as e:
+            except (ValueError, KeyError, TypeError):
                 # Fallback to robot-position-based zoom if room extraction fails
                 if (
                     self.shared.image_auto_zoom
@@ -291,6 +308,7 @@ class ReImageHandler(BaseHandler, AutoCrop):
     async def _draw_map_elements(
         self, img_np_array, m_json, colors, robot_position, robot_position_angle
     ):
+        """Draw map elements on the image."""
         # Draw charger if enabled
         if self.drawing_config.is_enabled(DrawableElement.CHARGER):
             img_np_array, self.charger_pos = await self.imd.async_draw_charger(
@@ -350,7 +368,7 @@ class ReImageHandler(BaseHandler, AutoCrop):
             else:
                 self.zooming = False
 
-        img_np_array = self.async_auto_trim_and_zoom_image(
+        img_np_array = self.auto_trim_and_zoom_image(
             img_np_array,
             detect_colour=colors["background"],
             margin_size=int(self.shared.margins),
@@ -361,22 +379,24 @@ class ReImageHandler(BaseHandler, AutoCrop):
         return img_np_array
 
     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."
-            )
-            return pil_img
+        """Finalize the image by resizing if needed."""
+        if pil_img is None:
+            LOGGER.warning("%s: Image is None. Returning None.", self.file_name)
+            return None
         if self.check_zoom_and_aspect_ratio():
             resize_params = self.prepare_resize_params(pil_img, True)
             pil_img = await self.async_resize_images(resize_params)
+        else:
+            LOGGER.warning(
+                "%s: Invalid image dimensions. Returning original image.",
+                self.file_name,
+            )
         return pil_img
 
     async def get_rooms_attributes(
         self, destinations: JsonType = None
     ) -> tuple[RoomsProperties, Any, Any]:
         """Return the rooms attributes."""
-        if self.room_propriety:
-            return self.room_propriety
         if self.json_data and destinations:
             self.room_propriety = await self.extract_room_properties(
                 self.json_data, destinations
@@ -401,6 +421,12 @@ class ReImageHandler(BaseHandler, AutoCrop):
                     }
                     # Handle active zones
                     self.active_zones = self.shared.rand256_active_zone
+                    LOGGER.debug(
+                        "%s: Robot is in %s room (polygon detection). %s",
+                        self.file_name,
+                        self.robot_in_room["room"],
+                        self.active_zones,
+                    )
                     self.zooming = False
                     if self.active_zones and (
                         self.robot_in_room["id"] in range(len(self.active_zones))
@@ -515,7 +541,7 @@ class ReImageHandler(BaseHandler, AutoCrop):
         """Return the map calibration data."""
         if not self.calibration_data and self.crop_img_size:
             self.calibration_data = []
-            _LOGGER.info(
+            LOGGER.info(
                 "%s: Getting Calibrations points %s",
                 self.file_name,
                 str(self.crop_area),

valetudo_map_parser/reimg_draw.py

@@ -6,17 +6,12 @@ Version: 0.1.9.b42
 
 from __future__ import annotations
 
-import logging
-
 from .config.drawable import Drawable
 from .config.drawable_elements import DrawableElement
-from .config.types import Color, JsonType, NumpyArray
+from .config.types import LOGGER, Color, JsonType, NumpyArray
 from .map_data import ImageData, RandImageData
 
 
-_LOGGER = logging.getLogger(__name__)
-
-
 class ImageDraw:
     """Class to handle the image creation."""
 
@@ -48,7 +43,7 @@ class ImageDraw:
                     )
             return np_array
         except KeyError as e:
-            _LOGGER.warning(
+            LOGGER.warning(
                 "%s: Error in extraction of go-to target: %s",
                 self.file_name,
                 e,
@@ -70,7 +65,7 @@ class ImageDraw:
                 )
         except ValueError as e:
             self.img_h.segment_data = None
-            _LOGGER.info("%s: No segments data found: %s", self.file_name, e)
+            LOGGER.info("%s: No segments data found: %s", self.file_name, e)
 
     async def async_draw_base_layer(
         self,
@@ -87,13 +82,13 @@ class ImageDraw:
         walls_data = self.data.get_rrm_walls(m_json)
         floor_data = self.data.get_rrm_floor(m_json)
 
-        _LOGGER.info("%s: Empty image with background color", self.file_name)
+        LOGGER.info("%s: Empty image with background color", self.file_name)
         img_np_array = await self.draw.create_empty_image(
             self.img_h.img_size["x"], self.img_h.img_size["y"], color_background
         )
         room_id = 0
         if self.img_h.frame_number == 0:
-            _LOGGER.info("%s: Overlapping Layers", self.file_name)
+            LOGGER.info("%s: Overlapping Layers", self.file_name)
 
             # checking if there are segments too (sorted pixels in the raw data).
             await self.async_segment_data(m_json, size_x, size_y, pos_top, pos_left)
@@ -148,10 +143,10 @@ class ImageDraw:
         room_id = 0
         rooms_list = [color_wall]
         if not segment_data:
-            _LOGGER.info("%s: No segments data found.", self.file_name)
+            LOGGER.info("%s: No segments data found.", self.file_name)
             return room_id, img_np_array
 
-        _LOGGER.info("%s: Drawing segments.", self.file_name)
+        LOGGER.info("%s: Drawing segments.", self.file_name)
         for pixels in segment_data:
             room_color = self.img_h.shared.rooms_colors[room_id]
             rooms_list.append(room_color)
@@ -211,7 +206,7 @@ class ImageDraw:
                 self.data.get_rrm_charger_position(m_json)
             )
         except KeyError as e:
-            _LOGGER.warning("%s: No charger position found: %s", self.file_name, e)
+            LOGGER.warning("%s: No charger position found: %s", self.file_name, e)
         else:
             if charger_pos:
                 charger_pos_dictionary = {
@@ -238,7 +233,7 @@ class ImageDraw:
             zone_clean = None
 
         if zone_clean:
-            _LOGGER.info("%s: Got zones.", self.file_name)
+            LOGGER.info("%s: Got zones.", self.file_name)
             return await self.draw.zones(np_array, zone_clean, color_zone_clean)
         return np_array
 
@@ -252,7 +247,7 @@ class ImageDraw:
             virtual_walls = None
 
         if virtual_walls:
-            _LOGGER.info("%s: Got virtual walls.", self.file_name)
+            LOGGER.info("%s: Got virtual walls.", self.file_name)
             np_array = await self.draw.draw_virtual_walls(
                 np_array, virtual_walls, color_no_go
             )
@@ -280,7 +275,7 @@ class ImageDraw:
                 self.data.rrm_valetudo_path_array(path_pixel["points"]), 2
             )
         except KeyError as e:
-            _LOGGER.warning(
+            LOGGER.warning(
                 "%s: Error extracting paths data: %s", self.file_name, str(e)
             )
         finally:
@@ -297,7 +292,7 @@ class ImageDraw:
         except (ValueError, KeyError):
             entity_dict = None
         else:
-            _LOGGER.info("%s: Got the points in the json.", self.file_name)
+            LOGGER.info("%s: Got the points in the json.", self.file_name)
         return entity_dict
 
     async def async_get_robot_position(self, m_json: JsonType) -> tuple | None:
@@ -310,7 +305,7 @@ class ImageDraw:
             robot_pos = self.data.rrm_coordinates_to_valetudo(robot_pos_data)
             angle = self.data.get_rrm_robot_angle(m_json)
         except (ValueError, KeyError):
-            _LOGGER.warning("%s No robot position found.", self.file_name)
+            LOGGER.warning("%s No robot position found.", self.file_name)
             return None, None, None
         finally:
             robot_position_angle = round(angle[0], 0)