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

valetudo_map_parser/config/rand256_parser.py

@@ -1,7 +1,8 @@
-"""New Rand256 Map Parser - Based on Xiaomi/Roborock implementation with precise binary parsing."""
+"""New Rand256 Map Parser -
+Based on Xiaomi/Roborock implementation with precise binary parsing."""
 
-import struct
 import math
+import struct
 from enum import Enum
 from typing import Any, Dict, List, Optional
 
@@ -78,6 +79,7 @@ class RRMapParser:
 
     @staticmethod
     def _parse_carpet_map(data: bytes) -> set[int]:
+        """Parse carpet map using Xiaomi method."""
         carpet_map = set()
 
         for i, v in enumerate(data):
@@ -87,6 +89,7 @@ class RRMapParser:
 
     @staticmethod
     def _parse_area(header: bytes, data: bytes) -> list:
+        """Parse area using Xiaomi method."""
         area_pairs = RRMapParser._get_int16(header, 0x08)
         areas = []
         for area_start in range(0, area_pairs * 16, 16):
@@ -114,6 +117,7 @@ class RRMapParser:
 
     @staticmethod
     def _parse_zones(data: bytes, header: bytes) -> list:
+        """Parse zones using Xiaomi method."""
         zone_pairs = RRMapParser._get_int16(header, 0x08)
         zones = []
         for zone_start in range(0, zone_pairs * 8, 8):
@@ -146,9 +150,9 @@ class RRMapParser:
                 angle = raw_angle
         return {"position": [x, y], "angle": angle}
 
-
     @staticmethod
     def _parse_walls(data: bytes, header: bytes) -> list:
+        """Parse walls using Xiaomi method."""
         wall_pairs = RRMapParser._get_int16(header, 0x08)
         walls = []
         for wall_start in range(0, wall_pairs * 8, 8):
@@ -156,7 +160,14 @@ class RRMapParser:
             y0 = RRMapParser._get_int16(data, wall_start + 2)
             x1 = RRMapParser._get_int16(data, wall_start + 4)
             y1 = RRMapParser._get_int16(data, wall_start + 6)
-            walls.append([x0, RRMapParser.Tools.DIMENSION_MM - y0, x1, RRMapParser.Tools.DIMENSION_MM - y1])
+            walls.append(
+                [
+                    x0,
+                    RRMapParser.Tools.DIMENSION_MM - y0,
+                    x1,
+                    RRMapParser.Tools.DIMENSION_MM - y1,
+                ]
+            )
         return walls
 
     @staticmethod
@@ -204,6 +215,7 @@ class RRMapParser:
             return {}
 
     def parse_blocks(self, raw: bytes, pixels: bool = True) -> Dict[int, Any]:
+        """Parse all blocks using Xiaomi method."""
         blocks = {}
         map_header_length = self._get_int16(raw, 0x02)
         block_start_position = map_header_length
@@ -218,29 +230,53 @@ class RRMapParser:
                 match block_type:
                     case self.Types.DIGEST.value:
                         self.is_valid = True
-                    case self.Types.ROBOT_POSITION.value | self.Types.CHARGER_LOCATION.value:
-                        blocks[block_type] = self._parse_object_position(block_data_length, data)
+                    case (
+                        self.Types.ROBOT_POSITION.value
+                        | self.Types.CHARGER_LOCATION.value
+                    ):
+                        blocks[block_type] = self._parse_object_position(
+                            block_data_length, data
+                        )
                     case self.Types.PATH.value | self.Types.GOTO_PREDICTED_PATH.value:
-                        blocks[block_type] = self._parse_path_block(raw, block_start_position, block_data_length)
+                        blocks[block_type] = self._parse_path_block(
+                            raw, block_start_position, block_data_length
+                        )
                     case self.Types.CURRENTLY_CLEANED_ZONES.value:
                         blocks[block_type] = {"zones": self._parse_zones(data, header)}
                     case self.Types.FORBIDDEN_ZONES.value:
-                        blocks[block_type] = {"forbidden_zones": self._parse_area(header, data)}
+                        blocks[block_type] = {
+                            "forbidden_zones": self._parse_area(header, data)
+                        }
                     case self.Types.FORBIDDEN_MOP_ZONES.value:
-                        blocks[block_type] = {"forbidden_mop_zones": self._parse_area(header, data)}
+                        blocks[block_type] = {
+                            "forbidden_mop_zones": self._parse_area(header, data)
+                        }
                     case self.Types.GOTO_TARGET.value:
                         blocks[block_type] = {"position": self._parse_goto_target(data)}
                     case self.Types.VIRTUAL_WALLS.value:
-                        blocks[block_type] = {"virtual_walls": self._parse_walls(data, header)}
+                        blocks[block_type] = {
+                            "virtual_walls": self._parse_walls(data, header)
+                        }
                     case self.Types.CARPET_MAP.value:
-                        data = RRMapParser._get_bytes(raw, block_data_start, block_data_length)
-                        blocks[block_type] = {"carpet_map": self._parse_carpet_map(data)}
+                        data = RRMapParser._get_bytes(
+                            raw, block_data_start, block_data_length
+                        )
+                        blocks[block_type] = {
+                            "carpet_map": self._parse_carpet_map(data)
+                        }
                     case self.Types.IMAGE.value:
                         header_length = self._get_int8(header, 2)
                         blocks[block_type] = self._parse_image_block(
-                            raw, block_start_position, block_data_length, header_length, pixels)
-
-                block_start_position = block_start_position + block_data_length + self._get_int8(header, 2)
+                            raw,
+                            block_start_position,
+                            block_data_length,
+                            header_length,
+                            pixels,
+                        )
+
+                block_start_position = (
+                    block_start_position + block_data_length + self._get_int8(header, 2)
+                )
             except (struct.error, IndexError):
                 break
         return blocks

valetudo_map_parser/config/shared.py

@@ -7,18 +7,20 @@ Version: v0.1.12
 import asyncio
 import logging
 from typing import List
+
 from PIL import Image
 
+from .utils import pil_size_rotation
 from .types import (
     ATTR_CALIBRATION_POINTS,
     ATTR_CAMERA_MODE,
     ATTR_CONTENT_TYPE,
+    ATTR_IMAGE_LAST_UPDATED,
     ATTR_MARGINS,
     ATTR_OBSTACLES,
     ATTR_POINTS,
     ATTR_ROOMS,
     ATTR_ROTATE,
-    ATTR_IMAGE_LAST_UPDATED,
     ATTR_VACUUM_BATTERY,
     ATTR_VACUUM_CHARGING,
     ATTR_VACUUM_JSON_ID,
@@ -38,10 +40,11 @@ from .types import (
     CONF_VAC_STAT_SIZE,
     CONF_ZOOM_LOCK_RATIO,
     DEFAULT_VALUES,
+    NOT_STREAMING_STATES,
     CameraModes,
     Colors,
-    TrimsData,
     PilPNG,
+    TrimsData,
 )
 
 
@@ -117,10 +120,17 @@ class CameraShared:
         self.trims = TrimsData.from_dict(DEFAULT_VALUES["trims_data"])
         self.skip_room_ids: List[str] = []
         self.device_info = None
+        self._battery_state = None
 
     def vacuum_bat_charged(self) -> bool:
         """Check if the vacuum is charging."""
-        return (self.vacuum_state == "docked") and (int(self.vacuum_battery) < 100)
+        if self.vacuum_state != "docked":
+                self._battery_state = "not_charging"
+        elif (self._battery_state == "charging") and (int(self.vacuum_battery) == 100):
+            self._battery_state = "charged"
+        else:
+            self._battery_state = "charging" if int(self.vacuum_battery) < 100 else "not_charging"
+        return (self.vacuum_state == "docked") and (self._battery_state == "charged")
 
     @staticmethod
     def _compose_obstacle_links(vacuum_host_ip: str, obstacles: list) -> list | None:
@@ -207,16 +217,25 @@ class CameraShared:
 
         return attrs
 
+    def is_streaming(self) -> bool:
+        """Return true if the device is streaming."""
+        updated_status = self.vacuum_state
+        attr_is_streaming = ((updated_status not in NOT_STREAMING_STATES 
+                              or self.vacuum_bat_charged()) 
+                             or not self.binary_image)
+        return attr_is_streaming
+
     def to_dict(self) -> dict:
         """Return a dictionary with image and attributes data."""
-        return {
+        data = {
             "image": {
                 "binary": self.binary_image,
-                "pil_image": self.new_image,
-                "size": self.new_image.size if self.new_image else (10, 10),
+                "size": pil_size_rotation(self.image_rotate, self.new_image),
+                "streaming": self.is_streaming()
             },
             "attributes": self.generate_attributes(),
         }
+        return data
 
 
 class CameraSharedManager:

valetudo_map_parser/config/status_text/status_text.py

@@ -9,6 +9,7 @@ from __future__ import annotations
 from ..types import LOGGER, PilPNG
 from .translations import translations
 
+
 LOGGER.propagate = True
 
 

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, TypedDict, Union, List, NotRequired
+from typing import Any, Dict, List, NotRequired, Optional, Tuple, TypedDict, Union
 
 import numpy as np
 from PIL import Image
@@ -34,12 +34,11 @@ class Room(TypedDict):
     id: int
 
 
-# list[dict[str, str | list[int]]] | list[dict[str, str | list[list[int]]]] | list[dict[str, str | int]] | int]'
 class Destinations(TypedDict, total=False):
     spots: NotRequired[Optional[List[Spot]]]
     zones: NotRequired[Optional[List[Zone]]]
     rooms: NotRequired[Optional[List[Room]]]
-    updated: NotRequired[Optional[float]]
+    updated: NotRequired[Optional[float | int]]
 
 
 class RoomProperty(TypedDict):
@@ -222,7 +221,9 @@ class SnapshotStore:
 Color = Union[Tuple[int, int, int], Tuple[int, int, int, int]]
 Colors = Dict[str, Color]
 CalibrationPoints = list[dict[str, Any]]
-RobotPosition = Optional[dict[str, Union[int | float]]]
+RobotPosition: type[tuple[Any, Any, dict[str, int | float] | None]] = tuple[
+    Any, Any, dict[str, int | float] | None
+]
 ChargerPosition = dict[str, Any]
 RoomsProperties = dict[str, RoomProperty]
 ImageSize = dict[str, int | list[int]]

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(
@@ -199,10 +200,11 @@ class BaseHandler:
         if hasattr(self, "get_rooms_attributes") and (
             self.shared.map_rooms is None and destinations is not None
         ):
-            (self.shared.map_rooms,) = 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
         ):
@@ -233,15 +235,8 @@ class BaseHandler:
         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,
@@ -662,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":
@@ -701,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.
@@ -709,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
@@ -721,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
+    # Initialize drawing utilities
+    draw = Drawable()
 
-    return drawing_config, draw, enhanced_draw
-
-
-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(
@@ -996,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
@@ -1037,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,24 +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 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,
@@ -48,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.
@@ -77,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():
@@ -258,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
@@ -272,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)
@@ -346,16 +350,6 @@ 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
 

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 (
@@ -548,8 +552,9 @@ class RandImageData:
     @staticmethod
     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.extend(json_data.get("forbidden_mop_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