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

valetudo_map_parser/config/utils.py

@@ -1,32 +1,30 @@
 """Utility code for the valetudo map parser."""
 
 import datetime
-from time import time
 import hashlib
+import io
 import json
 from dataclasses import dataclass
+from time import time
 from typing import Callable, List, Optional, Tuple
-import io
 
 import numpy as np
 from PIL import Image, ImageOps
 
+from ..map_data import HyperMapData
+from .async_utils import AsyncNumPy
 from .drawable import Drawable
 from .drawable_elements import DrawingConfig
-from .enhanced_drawable import EnhancedDrawable
 from .status_text.status_text import StatusText
-
 from .types import (
     LOGGER,
     ChargerPosition,
-    Size,
+    Destinations,
     NumpyArray,
     PilPNG,
     RobotPosition,
-    Destinations
+    Size,
 )
-from ..map_data import HyperMapData
-from .async_utils import AsyncNumPy
 
 
 @dataclass
@@ -79,7 +77,6 @@ class BaseHandler:
         # Drawing components are initialized by initialize_drawing_config in handlers
         self.drawing_config: Optional[DrawingConfig] = None
         self.draw: Optional[Drawable] = None
-        self.enhanced_draw: Optional[EnhancedDrawable] = None
 
     def get_frame_number(self) -> int:
         """Return the frame number of the image."""
@@ -114,6 +111,12 @@ class BaseHandler:
         try:
             # Backup current image to last_image before processing new one
             if hasattr(self.shared, "new_image") and self.shared.new_image is not None:
+                # Close old last_image to free memory before replacing it
+                if hasattr(self.shared, "last_image") and self.shared.last_image is not None:
+                    try:
+                        self.shared.last_image.close()
+                    except Exception:
+                        pass  # Ignore errors if image is already closed
                 self.shared.last_image = self.shared.new_image
 
             # Call the appropriate handler method based on handler type
@@ -174,13 +177,11 @@ class BaseHandler:
                 LOGGER.warning(
                     "%s: Failed to generate image from JSON data", self.file_name
                 )
-                if bytes_format and hasattr(self.shared, "last_image"):
-                    return pil_to_png_bytes(self.shared.last_image), {}
                 return (
                     self.shared.last_image
                     if hasattr(self.shared, "last_image")
                     else None
-                ), {}
+                ), self.shared.to_dict()
 
         except Exception as e:
             LOGGER.warning(
@@ -197,26 +198,28 @@ class BaseHandler:
         """Update the shared data with the latest information."""
 
         if hasattr(self, "get_rooms_attributes") and (
-                self.shared.map_rooms is None and destinations is not None
+            self.shared.map_rooms is None and destinations is not None
         ):
-            (
-                self.shared.map_rooms,
-                self.shared.map_pred_zones,
-                self.shared.map_pred_points,
-            ) = await self.get_rooms_attributes(destinations)
+            self.shared.map_rooms = await self.get_rooms_attributes(destinations)
             if self.shared.map_rooms:
                 LOGGER.debug("%s: Rand256 attributes rooms updated", self.file_name)
 
+
         if hasattr(self, "async_get_rooms_attributes") and (
-                self.shared.map_rooms is None
+            self.shared.map_rooms is None
         ):
             if self.shared.map_rooms is None:
                 self.shared.map_rooms = await self.async_get_rooms_attributes()
                 if self.shared.map_rooms:
                     LOGGER.debug("%s: Hyper attributes rooms updated", self.file_name)
 
-        if hasattr(self, "get_calibration_data") and self.shared.attr_calibration_points is None:
-            self.shared.attr_calibration_points = self.get_calibration_data(self.shared.image_rotate)
+        if (
+            hasattr(self, "get_calibration_data")
+            and self.shared.attr_calibration_points is None
+        ):
+            self.shared.attr_calibration_points = self.get_calibration_data(
+                self.shared.image_rotate
+            )
 
         if not self.shared.image_size:
             self.shared.image_size = self.get_img_size()
@@ -228,14 +231,12 @@ class BaseHandler:
 
         self.shared.current_room = self.get_robot_position()
 
-    def prepare_resize_params(self, pil_img: PilPNG, rand: bool=False) -> ResizeParams:
+    def prepare_resize_params(
+        self, pil_img: PilPNG, rand: bool = False
+    ) -> ResizeParams:
         """Prepare resize parameters for image resizing."""
-        if self.shared.image_rotate in [0, 180]:
-            width, height = pil_img.size
-        else:
-            height, width = pil_img.size
-        LOGGER.debug("Shared PIL image size: %s x %s", self.shared.image_ref_width,
-                     self.shared.image_ref_height)
+        width, height = pil_size_rotation(self.shared.image_rotate, pil_img)
+
         return ResizeParams(
             pil_img=pil_img,
             width=width,
@@ -656,9 +657,6 @@ class BaseHandler:
 
 async def async_resize_image(params: ResizeParams):
     """Resize the image to the given dimensions and aspect ratio."""
-    LOGGER.debug("Resizing image to aspect ratio: %s", params.aspect_ratio)
-    LOGGER.debug("Original image size: %s x %s", params.width, params.height)
-    LOGGER.debug("Image crop size: %s", params.crop_size)
     if params.aspect_ratio == "None":
         return params.pil_img
     if params.aspect_ratio != "None":
@@ -695,6 +693,17 @@ async def async_resize_image(params: ResizeParams):
     return params.pil_img
 
 
+def pil_size_rotation(image_rotate, pil_img):
+    """Return the size of the image."""
+    if not pil_img:
+        return 0, 0
+    if image_rotate in [0, 180]:
+        width, height = pil_img.size
+    else:
+        height, width = pil_img.size
+    return width, height
+
+
 def initialize_drawing_config(handler):
     """
     Initialize drawing configuration from device_info.
@@ -703,7 +712,7 @@ def initialize_drawing_config(handler):
         handler: The handler instance with shared data and file_name attributes
 
     Returns:
-        Tuple of (DrawingConfig, Drawable, EnhancedDrawable)
+        Tuple of (DrawingConfig, Drawable)
     """
 
     # Initialize drawing configuration
@@ -715,98 +724,10 @@ def initialize_drawing_config(handler):
     ):
         drawing_config.update_from_device_info(handler.shared.device_info)
 
-    # Initialize both drawable systems for backward compatibility
-    draw = Drawable()  # Legacy drawing utilities
-    enhanced_draw = EnhancedDrawable(drawing_config)  # New enhanced drawing system
-
-    return drawing_config, draw, enhanced_draw
+    # Initialize drawing utilities
+    draw = Drawable()
 
-
-def blend_colors(base_color, overlay_color):
-    """
-    Blend two RGBA colors using alpha compositing.
-
-    Args:
-        base_color: Base RGBA color tuple (r, g, b, a)
-        overlay_color: Overlay RGBA color tuple (r, g, b, a)
-
-    Returns:
-        Blended RGBA color tuple (r, g, b, a)
-    """
-    r1, g1, b1, a1 = base_color
-    r2, g2, b2, a2 = overlay_color
-
-    # Convert alpha to 0-1 range
-    a1 = a1 / 255.0
-    a2 = a2 / 255.0
-
-    # Calculate resulting alpha
-    a_out = a1 + a2 * (1 - a1)
-
-    # Avoid division by zero
-    if a_out < 0.0001:
-        return [0, 0, 0, 0]
-
-    # Calculate blended RGB components
-    r_out = (r1 * a1 + r2 * a2 * (1 - a1)) / a_out
-    g_out = (g1 * a1 + g2 * a2 * (1 - a1)) / a_out
-    b_out = (b1 * a1 + b2 * a2 * (1 - a1)) / a_out
-
-    # Convert back to 0-255 range and return as tuple
-    return (
-        int(max(0, min(255, r_out))),
-        int(max(0, min(255, g_out))),
-        int(max(0, min(255, b_out))),
-        int(max(0, min(255, a_out * 255))),
-    )
-
-
-def blend_pixel(array, x, y, color, element, element_map=None, drawing_config=None):
-    """
-    Blend a pixel color with the existing color at the specified position.
-    Also updates the element map if the new element has higher z-index.
-
-    Args:
-        array: The image array to modify
-        x: X coordinate
-        y: Y coordinate
-        color: RGBA color tuple to blend
-        element: Element code for the pixel
-        element_map: Optional element map to update
-        drawing_config: Optional drawing configuration for z-index lookup
-
-    Returns:
-        None
-    """
-    # Check bounds
-    if not (0 <= y < array.shape[0] and 0 <= x < array.shape[1]):
-        return
-
-    # Get current element at this position
-    current_element = None
-    if element_map is not None:
-        current_element = element_map[y, x]
-
-    # Get z-index values for comparison
-    current_z = 0
-    new_z = 0
-
-    if drawing_config is not None:
-        current_z = (
-            drawing_config.get_property(current_element, "z_index", 0)
-            if current_element
-            else 0
-        )
-        new_z = drawing_config.get_property(element, "z_index", 0)
-
-    # Update element map if new element has higher z-index
-    if element_map is not None and new_z >= current_z:
-        element_map[y, x] = element
-
-    # Blend colors
-    base_color = array[y, x]
-    blended_color = blend_colors(base_color, color)
-    array[y, x] = blended_color
+    return drawing_config, draw
 
 
 def manage_drawable_elements(
@@ -990,12 +911,6 @@ async def async_extract_room_outline(
 
         # If we found too few boundary points, use the rectangular outline
         if len(boundary_points) < 8:  # Need at least 8 points for a meaningful shape
-            LOGGER.debug(
-                "%s: Room %s has too few boundary points (%d), using rectangular outline",
-                file_name,
-                str(room_id_int),
-                len(boundary_points),
-            )
             return rect_outline
 
         # Use a more sophisticated algorithm to create a coherent outline
@@ -1031,13 +946,6 @@ async def async_extract_room_outline(
         # Convert NumPy int64 values to regular Python integers
         simplified_outline = [(int(x), int(y)) for x, y in simplified_outline]
 
-        LOGGER.debug(
-            "%s: Room %s outline has %d points",
-            file_name,
-            str(room_id_int),
-            len(simplified_outline),
-        )
-
         return simplified_outline
 
     except (ValueError, IndexError, TypeError, ArithmeticError) as e:

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