valetudo-map-parser 0.1.10b1__tar.gz → 0.1.10b2__tar.gz

{valetudo_map_parser-0.1.10b1 → valetudo_map_parser-0.1.10b2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: valetudo-map-parser
-Version: 0.1.10b1
+Version: 0.1.10b2
 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.10b1 → valetudo_map_parser-0.1.10b2}/SCR/valetudo_map_parser/__init__.py

@@ -22,11 +22,13 @@ from .config.types import (
 from .hypfer_handler import HypferMapImageHandler
 from .rand256_handler import ReImageHandler
 from .rooms_handler import RoomsHandler, RandRoomsHandler
+from .map_data import HyperMapData
 
 
 __all__ = [
     "RoomsHandler",
     "RandRoomsHandler",
+    "HyperMapData",
     "HypferMapImageHandler",
     "ReImageHandler",
     "RRMapParser",

{valetudo_map_parser-0.1.10b1 → valetudo_map_parser-0.1.10b2}/SCR/valetudo_map_parser/config/drawable.py

@@ -11,7 +11,6 @@ Optimized with NumPy and SciPy for better performance.
 from __future__ import annotations
 
 import logging
-import math
 
 import numpy as np
 from PIL import Image, ImageDraw, ImageFont
@@ -160,7 +159,7 @@ class Drawable:
 
         # Get blended colors for flag and pole
         flag_alpha = flag_color[3] if len(flag_color) == 4 else 255
-        pole_color_base = (0, 0, 255)  # Blue for the pole
+        pole_color_base = [0, 0, 255]  # Blue for the pole
         pole_alpha = 255
 
         # Blend flag color if needed
@@ -170,7 +169,12 @@ class Drawable:
             )
 
         # Create pole color with alpha
-        pole_color: Color = (*pole_color_base, pole_alpha)
+        pole_color: Color = (
+            pole_color_base[0],
+            pole_color_base[1],
+            pole_color_base[2],
+            pole_alpha,
+        )
 
         # Blend pole color if needed
         if pole_alpha < 255:
@@ -223,20 +227,18 @@ class Drawable:
 
     @staticmethod
     def point_inside(x: int, y: int, points: list[Tuple[int, int]]) -> bool:
-        """
-        Check if a point (x, y) is inside a polygon defined by a list of points.
-        """
+        """Check if a point (x, y) is inside a polygon defined by a list of points."""
         n = len(points)
         inside = False
-        xinters = 0.0
+        inters_x = 0.0
         p1x, p1y = points[0]
         for i in range(1, n + 1):
             p2x, p2y = points[i % n]
             if y > min(p1y, p2y):
                 if y <= max(p1y, p2y) and x <= max(p1x, p2x):
                     if p1y != p2y:
-                        xinters = (y - p1y) * (p2x - p1x) / (p2y - p1y) + p1x
-                    if p1x == p2x or x <= xinters:
+                        inters_x = (y - p1y) * (p2x - p1x) / (p2y - p1y) + p1x
+                    if p1x == p2x or x <= inters_x:
                         inside = not inside
             p1x, p1y = p2x, p2y
         return inside
@@ -251,8 +253,7 @@ class Drawable:
         color: Color,
         width: int = 3,
     ) -> np.ndarray:
-        """
-        Draw a line on a NumPy array (layer) from point A to B using Bresenham's algorithm.
+        """Draw a line on a NumPy array (layer) from point A to B using Bresenham's algorithm.
 
         Args:
             layer: The numpy array to draw on (H, W, C)
@@ -283,11 +284,11 @@ class Drawable:
             x_min = max(0, x1 - half_w)
             x_max = min(w, x1 + half_w + 1)
 
-            submask = mask[
+            sub_mask = mask[
                 (y_min - (y1 - half_w)) : (y_max - (y1 - half_w)),
                 (x_min - (x1 - half_w)) : (x_max - (x1 - half_w)),
             ]
-            layer[y_min:y_max, x_min:x_max][submask] = blended_color
+            layer[y_min:y_max, x_min:x_max][sub_mask] = blended_color
 
             if x1 == x2 and y1 == y2:
                 break
@@ -317,12 +318,14 @@ class Drawable:
         return layer
 
     @staticmethod
-    async def lines(arr: NumpyArray, coords, width: int, color: Color) -> NumpyArray:
+    async def lines(
+        arr: NumpyArray, coordinates, width: int, color: Color
+    ) -> NumpyArray:
         """
         Join the coordinates creating a continuous line (path).
         Optimized with vectorized operations for better performance.
         """
-        for coord in coords:
+        for coord in coordinates:
             x0, y0 = coord[0]
             try:
                 x1, y1 = coord[1]
@@ -466,9 +469,6 @@ class Drawable:
             # Adjust points to the mask's coordinate system
             adjusted_points = [(p[0] - min_x, p[1] - min_y) for p in points]
 
-            # Create a grid of coordinates and use it to test all points at once
-            y_indices, x_indices = np.mgrid[0 : mask.shape[0], 0 : mask.shape[1]]
-
             # Test each point in the grid
             for i in range(mask.shape[0]):
                 for j in range(mask.shape[1]):
@@ -545,77 +545,87 @@ class Drawable:
         angle: float,
         fill: Color,
         robot_state: str | None = None,
-        radius: int = 25  # user-configurable
+        radius: int = 25,  # user-configurable
     ) -> NumpyArray:
         """
         Draw the robot with configurable size. All elements scale with radius.
         """
         # Minimum radius to keep things visible
         radius = max(8, min(radius, 25))
-    
+
         height, width = layers.shape[:2]
         if not (0 <= x < width and 0 <= y < height):
             return layers
-    
+
         # Bounding box
-        box_size = radius * 2 + 2
         top_left_x = max(0, x - radius - 1)
         top_left_y = max(0, y - radius - 1)
         bottom_right_x = min(width, x + radius + 1)
         bottom_right_y = min(height, y + radius + 1)
-    
+
         if top_left_x >= bottom_right_x or top_left_y >= bottom_right_y:
             return layers
-    
+
         tmp_width = bottom_right_x - top_left_x
         tmp_height = bottom_right_y - top_left_y
         tmp_layer = layers[top_left_y:bottom_right_y, top_left_x:bottom_right_x].copy()
-    
+
         tmp_x = x - top_left_x
         tmp_y = y - top_left_y
-    
+
         # All geometry proportional to radius
-        r_scaled = max(1, radius / 11.0)
-        r_cover  = int(r_scaled * 12)
-        r_lidar  = max(1, int(r_scaled * 3))
+        r_scaled: float = max(1.0, radius / 11.0)
+        r_cover = int(r_scaled * 10)
+        r_lidar = max(1, int(r_scaled * 3))
         r_button = max(1, int(r_scaled * 1))
-        lidar_offset = int(radius * 0.6)   # was fixed 15
+        lidar_offset = int(radius * 0.6)  # was fixed 15
         button_offset = int(radius * 0.8)  # was fixed 20
-    
+
         lidar_angle = np.deg2rad(angle + 90)
-    
+
         if robot_state == "error":
             outline = Drawable.ERROR_OUTLINE
             fill = Drawable.ERROR_COLOR
         else:
             outline = (fill[0] // 2, fill[1] // 2, fill[2] // 2, fill[3])
-    
+
         # Body
-        tmp_layer = Drawable._filled_circle(tmp_layer, (tmp_y, tmp_x), radius, fill, outline, 1)
-    
+        tmp_layer = Drawable._filled_circle(
+            tmp_layer, (tmp_y, tmp_x), radius, fill, outline, 1
+        )
+
         # Direction wedge
         angle -= 90
-        a1 = ((angle + 90) - 80) / 180 * math.pi
-        a2 = ((angle + 90) + 80) / 180 * math.pi
+        a1 = np.deg2rad((angle + 90) - 80)
+        a2 = np.deg2rad((angle + 90) + 80)
         x1 = int(tmp_x - r_cover * np.sin(a1))
         y1 = int(tmp_y + r_cover * np.cos(a1))
         x2 = int(tmp_x - r_cover * np.sin(a2))
         y2 = int(tmp_y + r_cover * np.cos(a2))
-        if 0 <= x1 < tmp_width and 0 <= y1 < tmp_height and 0 <= x2 < tmp_width and 0 <= y2 < tmp_height:
+        if (
+            0 <= x1 < tmp_width
+            and 0 <= y1 < tmp_height
+            and 0 <= x2 < tmp_width
+            and 0 <= y2 < tmp_height
+        ):
             tmp_layer = Drawable._line(tmp_layer, x1, y1, x2, y2, outline, width=1)
-    
+
         # Lidar
         lidar_x = int(tmp_x + lidar_offset * np.cos(lidar_angle))
         lidar_y = int(tmp_y + lidar_offset * np.sin(lidar_angle))
         if 0 <= lidar_x < tmp_width and 0 <= lidar_y < tmp_height:
-            tmp_layer = Drawable._filled_circle(tmp_layer, (lidar_y, lidar_x), r_lidar, outline)
-    
+            tmp_layer = Drawable._filled_circle(
+                tmp_layer, (lidar_y, lidar_x), r_lidar, outline
+            )
+
         # Button
         butt_x = int(tmp_x - button_offset * np.cos(lidar_angle))
         butt_y = int(tmp_y - button_offset * np.sin(lidar_angle))
         if 0 <= butt_x < tmp_width and 0 <= butt_y < tmp_height:
-            tmp_layer = Drawable._filled_circle(tmp_layer, (butt_y, butt_x), r_button, outline)
-    
+            tmp_layer = Drawable._filled_circle(
+                tmp_layer, (butt_y, butt_x), r_button, outline
+            )
+
         layers[top_left_y:bottom_right_y, top_left_x:bottom_right_x] = tmp_layer
         return layers
 
@@ -764,11 +774,11 @@ class Drawable:
                             continue
 
                         t = np.linspace(0, 1, length * 2)
-                        x_coords = np.round(x1 * (1 - t) + x2 * t).astype(int)
-                        y_coords = np.round(y1 * (1 - t) + y2 * t).astype(int)
+                        x_coordinates = np.round(x1 * (1 - t) + x2 * t).astype(int)
+                        y_coordinates = np.round(y1 * (1 - t) + y2 * t).astype(int)
 
                         # Add line points to mask
-                        for x, y in zip(x_coords, y_coords):
+                        for x, y in zip(x_coordinates, y_coordinates):
                             if width == 1:
                                 mask[y, x] = True
                             else:
@@ -810,7 +820,6 @@ class Drawable:
 
         # Precompute circular mask for radius
         radius = 6
-        diameter = radius * 2 + 1
         yy, xx = np.ogrid[-radius : radius + 1, -radius : radius + 1]
         circle_mask = (xx**2 + yy**2) <= radius**2
 

{valetudo_map_parser-0.1.10b1 → valetudo_map_parser-0.1.10b2}/SCR/valetudo_map_parser/config/shared.py

@@ -69,6 +69,7 @@ class CameraShared:
         self.image_last_updated: float = 0.0  # Last image update time
         self.image_format = "image/pil"  # Image format
         self.image_size = None  # Image size
+        self.robot_size = None  # Robot size
         self.image_auto_zoom: bool = False  # Auto zoom image
         self.image_zoom_lock_ratio: bool = True  # Zoom lock ratio
         self.image_ref_height: int = 0  # Image reference height
@@ -306,6 +307,8 @@ class CameraSharedManager:
                 "%s: Updating shared trims with: %s", instance.file_name, trim_data
             )
             instance.trims = TrimsData.from_dict(trim_data)
+            # Robot size
+            instance.robot_size = device_info.get("robot_size", 25)
 
         except TypeError as ex:
             _LOGGER.error("Shared data can't be initialized due to a TypeError! %s", ex)

{valetudo_map_parser-0.1.10b1 → valetudo_map_parser-0.1.10b2}/SCR/valetudo_map_parser/config/types.py

@@ -443,31 +443,31 @@ RATIO_VALUES = [
 FONTS_AVAILABLE = [
     {
         "label": "Fira Sans",
-        "value": "custom_components/mqtt_vacuum_camera/utils/fonts/FiraSans.ttf",
+        "value": "config/utils/fonts/FiraSans.ttf",
     },
     {
         "label": "Inter",
-        "value": "custom_components/mqtt_vacuum_camera/utils/fonts/Inter-VF.ttf",
+        "value": "config/utils/fonts/Inter-VF.ttf",
     },
     {
         "label": "M Plus Regular",
-        "value": "custom_components/mqtt_vacuum_camera/utils/fonts/MPLUSRegular.ttf",
+        "value": "config/utils/fonts/MPLUSRegular.ttf",
     },
     {
         "label": "Noto Sans CJKhk",
-        "value": "custom_components/mqtt_vacuum_camera/utils/fonts/NotoSansCJKhk-VF.ttf",
+        "value": "config/utils/fonts/NotoSansCJKhk-VF.ttf",
     },
     {
         "label": "Noto Kufi Arabic",
-        "value": "custom_components/mqtt_vacuum_camera/utils/fonts/NotoKufiArabic-VF.ttf",
+        "value": "config/utils/fonts/NotoKufiArabic-VF.ttf",
     },
     {
         "label": "Noto Sans Khojki",
-        "value": "custom_components/mqtt_vacuum_camera/utils/fonts/NotoSansKhojki.ttf",
+        "value": "config/utils/fonts/NotoSansKhojki.ttf",
     },
     {
         "label": "Lato Regular",
-        "value": "custom_components/mqtt_vacuum_camera/utils/fonts/Lato-Regular.ttf",
+        "value": "config/utils/fonts/Lato-Regular.ttf",
     },
 ]
 

{valetudo_map_parser-0.1.10b1 → valetudo_map_parser-0.1.10b2}/SCR/valetudo_map_parser/config/utils.py

@@ -23,7 +23,7 @@ from .types import (
     RobotPosition,
     WebPBytes,
 )
-
+from ..map_data import HyperMapData
 
 @dataclass
 class ResizeParams:
@@ -86,6 +86,8 @@ class BaseHandler:
         m_json: dict | None,
         destinations: list | None = None,
         bytes_format: bool = False,
+        text_enabled: bool = False,
+        vacuum_status: str | None = None,
     ) -> PilPNG | None:
         """
         Unified async function to get PIL image from JSON data for both Hypfer and Rand256 handlers.
@@ -99,6 +101,8 @@ class BaseHandler:
         @param m_json: The JSON data to use to draw the image
         @param destinations: MQTT destinations for labels (used by Rand256)
         @param bytes_format: If True, also convert to PNG bytes and store in shared.binary_image
+        @param text_enabled: If True, draw text on the image
+        @param vacuum_status: Vacuum status to display on the image
         @return: PIL Image or None
         """
         try:
@@ -116,6 +120,7 @@ class BaseHandler:
                 )
             elif hasattr(self, "async_get_image_from_json"):
                 # This is a Hypfer handler
+                self.json_data = await HyperMapData.async_from_valetudo_json(m_json)
                 new_image = await self.async_get_image_from_json(
                     m_json=m_json,
                     return_webp=False,  # Always return PIL Image

{valetudo_map_parser-0.1.10b1 → valetudo_map_parser-0.1.10b2}/SCR/valetudo_map_parser/hypfer_draw.py

@@ -1,7 +1,7 @@
 """
 Image Draw Class for Valetudo Hypfer Image Handling.
 This class is used to simplify the ImageHandler class.
-Version: 0.1.9
+Version: 0.1.10
 """
 
 from __future__ import annotations
@@ -310,15 +310,6 @@ class ImageDraw:
             return np_array
         return np_array
 
-    async def async_get_json_id(self, my_json: JsonType) -> str | None:
-        """Return the JSON ID from the image."""
-        try:
-            json_id = my_json["metaData"]["nonce"]
-        except (ValueError, KeyError) as e:
-            _LOGGER.debug("%s: No JsonID provided: %s", self.file_name, str(e))
-            json_id = None
-        return json_id
-
     async def async_draw_zones(
         self,
         m_json: JsonType,
@@ -417,15 +408,6 @@ class ImageDraw:
                 )
         return np_array
 
-    async def async_get_entity_data(self, m_json: JsonType) -> dict or None:
-        """Get the entity data from the JSON data."""
-        try:
-            entity_dict = self.img_h.data.find_points_entities(m_json)
-        except (ValueError, KeyError):
-            return None
-        _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:

{valetudo_map_parser-0.1.10b1 → valetudo_map_parser-0.1.10b2}/SCR/valetudo_map_parser/hypfer_handler.py

@@ -2,7 +2,7 @@
 Hypfer Image Handler Class.
 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
+Version: 0.1.10
 """
 
 from __future__ import annotations
@@ -122,20 +122,12 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
         try:
             if m_json is not None:
                 LOGGER.debug("%s: Creating Image.", self.file_name)
-                # buffer json data
-                self.json_data = m_json
                 # Get the image size from the JSON data
-                size_x = int(m_json["size"]["x"])
-                size_y = int(m_json["size"]["y"])
-                self.img_size = {
-                    "x": size_x,
-                    "y": size_y,
-                    "centre": [(size_x // 2), (size_y // 2)],
-                }
+                self.img_size = self.json_data.image_size
                 # Get the JSON ID from the JSON data.
-                self.json_id = await self.imd.async_get_json_id(m_json)
+                self.json_id = self.json_data.json_id
                 # Check entity data.
-                entity_dict = await self.imd.async_get_entity_data(m_json)
+                entity_dict = self.json_data.entity_dict
                 # Update the Robot position.
                 (
                     robot_pos,
@@ -145,15 +137,15 @@ 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)
+
+                new_frame_hash = await self.calculate_array_hash(
+                    self.json_data.layers, self.json_data.active_zones
+                )
                 if self.frame_number == 0:
                     self.img_hash = new_frame_hash
                     # Create empty image
                     img_np_array = await self.draw.create_empty_image(
-                        size_x, size_y, colors["background"]
+                        self.img_size["x"], self.img_size["y"], colors["background"]
                     )
                     # Draw layers and segments if enabled
                     room_id = 0
@@ -162,7 +154,10 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
 
                     if self.drawing_config.is_enabled(DrawableElement.FLOOR):
                         # First pass: identify disabled rooms
-                        for layer_type, compressed_pixels_list in layers.items():
+                        for (
+                            layer_type,
+                            compressed_pixels_list,
+                        ) in self.json_data.layers.items():
                             # Check if this is a room layer
                             if layer_type == "segment":
                                 # The room_id is the current room being processed (0-based index)
@@ -193,7 +188,10 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                         room_id = 0
 
                         # Second pass: draw enabled rooms and walls
-                        for layer_type, compressed_pixels_list in layers.items():
+                        for (
+                            layer_type,
+                            compressed_pixels_list,
+                        ) in self.json_data.layers.items():
                             # Check if this is a room layer
                             is_room_layer = layer_type == "segment"
 
@@ -258,13 +256,13 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                     # Robot and rooms position
                     if (room_id > 0) and not self.room_propriety:
                         self.room_propriety = await self.async_extract_room_properties(
-                            self.json_data
+                            self.json_data.json_data
                         )
 
                     # Ensure room data is available for robot room detection (even if not extracted above)
                     if not self.rooms_pos and not self.room_propriety:
                         self.room_propriety = await self.async_extract_room_properties(
-                            self.json_data
+                            self.json_data.json_data
                         )
 
                     # Always check robot position for zooming (moved outside the condition)
@@ -366,6 +364,7 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                         y=robot_position[1],
                         angle=robot_position_angle,
                         fill=robot_color,
+                        radius=self.shared.robot_size,
                         robot_state=self.shared.vacuum_state,
                     )
 
@@ -440,7 +439,7 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
         if self.json_data:
             LOGGER.debug("Checking %s Rooms data..", self.file_name)
             self.room_propriety = await self.async_extract_room_properties(
-                self.json_data
+                self.json_data.json_data
             )
             if self.room_propriety:
                 LOGGER.debug("Got %s Rooms Attributes.", self.file_name)

{valetudo_map_parser-0.1.10b1 → valetudo_map_parser-0.1.10b2}/SCR/valetudo_map_parser/map_data.py

@@ -3,26 +3,125 @@ Collections of Json and List routines
 ImageData is part of the Image_Handler
 used functions to search data in the json
 provided for the creation of the new camera frame
-Version: v0.1.6
+Version: v0.1.10
 """
 
 from __future__ import annotations
 
 import numpy as np
+from typing import List, Sequence, TypeVar, Any, TypedDict, NotRequired, Literal
+
+from dataclasses import dataclass, field
 
 from .config.types import ImageSize, JsonType
 
+T = TypeVar("T")
+
+# --- Common Nested Structures ---
+
+
+class RangeStats(TypedDict):
+    min: int
+    max: int
+    mid: int
+    avg: int
+
+
+class Dimensions(TypedDict):
+    x: RangeStats
+    y: RangeStats
+    pixelCount: int
+
+
+# --- Layer Types ---
+
+
+class FloorWallMeta(TypedDict, total=False):
+    area: int
+
+
+class SegmentMeta(TypedDict, total=False):
+    segmentId: str
+    active: bool
+    source: str
+    area: int
+
+
+class MapLayerBase(TypedDict):
+    __class__: Literal["MapLayer"]
+    type: str
+    pixels: list[int]
+    compressedPixels: list[int]
+    dimensions: Dimensions
+
+
+class FloorWallLayer(MapLayerBase):
+    metaData: FloorWallMeta
+    type: Literal["floor", "wall"]
+
+
+class SegmentLayer(MapLayerBase):
+    metaData: SegmentMeta
+    type: Literal["segment"]
+
+
+# --- Entity Types ---
+
+
+class PointMeta(TypedDict, total=False):
+    angle: float
+    label: str
+    id: str
+
+
+class PointMapEntity(TypedDict):
+    __class__: Literal["PointMapEntity"]
+    type: str
+    points: list[int]
+    metaData: NotRequired[PointMeta]
+
+
+class PathMapEntity(TypedDict):
+    __class__: Literal["PathMapEntity"]
+    type: str
+    points: list[int]
+    metaData: dict[str, object]  # flexible for now
+
+
+Entity = PointMapEntity | PathMapEntity
+
+# --- Top-level Map ---
+
+
+class MapMeta(TypedDict, total=False):
+    version: int
+    totalLayerArea: int
+
+
+class Size(TypedDict):
+    x: int
+    y: int
+
+
+class ValetudoMap(TypedDict):
+    __class__: Literal["ValetudoMap"]
+    metaData: MapMeta
+    size: Size
+    pixelSize: int
+    layers: list[FloorWallLayer | SegmentLayer]
+    entities: list[Entity]
+
 
 class ImageData:
     """Class to handle the image data."""
 
     @staticmethod
-    def sublist(lst, n):
+    def sublist(lst: Sequence[T], n: int) -> list[Sequence[T]]:
         """Sub lists of specific n number of elements"""
         return [lst[i : i + n] for i in range(0, len(lst), n)]
 
     @staticmethod
-    def sublist_join(lst, n):
+    def sublist_join(lst: Sequence[T], n: int) -> list[list[T]]:
         """Join the lists in a unique list of n elements"""
         arr = np.array(lst)
         num_windows = len(lst) - n + 1
@@ -35,57 +134,131 @@ class ImageData:
     # Vacuums Json in parallel.
 
     @staticmethod
-    def get_obstacles(entity_dict: dict) -> list:
-        """Get the obstacles positions from the entity data."""
+    def get_image_size(json_data: JsonType) -> dict[str, int | list[int]]:
+        """Get the image size from the json."""
+        if json_data:
+            size_x = int(json_data["size"]["x"])
+            size_y = int(json_data["size"]["y"])
+            return {
+                "x": size_x,
+                "y": size_y,
+                "centre": [(size_x // 2), (size_y // 2)],
+            }
+        return {"x": 0, "y": 0, "centre": [0, 0]}
+
+    @staticmethod
+    def get_json_id(json_data: JsonType) -> str | None:
+        """Get the json id from the json."""
         try:
-            obstacle_data = entity_dict.get("obstacle")
-        except KeyError:
+            json_id = json_data["metaData"]["nonce"]
+        except (ValueError, KeyError):
+            json_id = None
+        return json_id
+
+    @staticmethod
+    def get_obstacles(
+        entity_dict: dict[str, list[PointMapEntity]],
+    ) -> list[dict[str, str | int | None]]:
+        """
+        Extract obstacle positions from Valetudo entity data.
+
+        Args:
+            entity_dict: Parsed JSON-like dict containing obstacle data.
+
+        Returns:
+            A list of obstacle dicts with keys:
+                - 'label': obstacle label string
+                - 'points': dict with 'x' and 'y' coordinates
+                - 'id': obstacle image/metadata ID (if any)
+            Returns an empty list if no valid obstacles found.
+        """
+        obstacle_data = entity_dict.get("obstacle")  # .get() won't raise KeyError
+        if not obstacle_data:
             return []
-        obstacle_positions = []
-        if obstacle_data:
-            for obstacle in obstacle_data:
-                label = obstacle.get("metaData", {}).get("label")
-                points = obstacle.get("points", [])
-                image_id = obstacle.get("metaData", {}).get("id")
-
-                if label and points:
-                    obstacle_pos = {
+
+        obstacle_positions: list[dict[str, Any]] = []
+
+        for obstacle in obstacle_data:
+            meta = obstacle.get("metaData", {}) or {}
+            label = meta.get("label")
+            image_id = meta.get("id")
+            points = obstacle.get("points") or []
+
+            # Expecting at least two coordinates for a valid obstacle
+            if label and len(points) >= 2:
+                obstacle_positions.append(
+                    {
                         "label": label,
                         "points": {"x": points[0], "y": points[1]},
                         "id": image_id,
                     }
-                    obstacle_positions.append(obstacle_pos)
-            return obstacle_positions
-        return []
+                )
+
+        return obstacle_positions
 
     @staticmethod
     def find_layers(
-        json_obj: JsonType, layer_dict: dict, active_list: list
-    ) -> tuple[dict, list]:
-        """Find the layers in the json object."""
-        layer_dict = {} if layer_dict is None else layer_dict
-        active_list = [] if active_list is None else active_list
+        json_obj: JsonType,
+        layer_dict: dict[str, list[Any]] | None,
+        active_list: list[int] | None,
+    ) -> tuple[dict[str, list[Any]], list[int]]:
+        """
+        Recursively traverse a JSON-like structure to find MapLayer entries.
+
+        Args:
+            json_obj: The JSON-like object (dicts/lists) to search.
+            layer_dict: Optional mapping of layer_type to a list of compressed pixel data.
+            active_list: Optional list of active segment flags.
+
+        Returns:
+            A tuple:
+                - dict mapping layer types to their compressed pixel arrays.
+                - list of integers marking active segment layers.
+        """
+        if layer_dict is None:
+            layer_dict = {}
+        if active_list is None:
+            active_list = []
+
         if isinstance(json_obj, dict):
-            if "__class" in json_obj and json_obj["__class"] == "MapLayer":
+            if json_obj.get("__class") == "MapLayer":
                 layer_type = json_obj.get("type")
-                active_type = json_obj.get("metaData")
+                meta_data = json_obj.get("metaData") or {}
                 if layer_type:
-                    if layer_type not in layer_dict:
-                        layer_dict[layer_type] = []
-                    layer_dict[layer_type].append(json_obj.get("compressedPixels", []))
+                    layer_dict.setdefault(layer_type, []).append(
+                        json_obj.get("compressedPixels", [])
+                    )
                 if layer_type == "segment":
-                    active_list.append(int(active_type["active"]))
-
-            for value in json_obj.items():
+                    # Safely extract "active" flag if present and convertible to int
+                    try:
+                        active_list.append(int(meta_data.get("active", 0)))
+                    except (ValueError, TypeError):
+                        pass  # skip invalid/missing 'active' values
+
+            # json_obj.items() yields (key, value), so we only want the values
+            for _, value in json_obj.items():
                 ImageData.find_layers(value, layer_dict, active_list)
+
         elif isinstance(json_obj, list):
             for item in json_obj:
                 ImageData.find_layers(item, layer_dict, active_list)
+
         return layer_dict, active_list
 
     @staticmethod
-    def find_points_entities(json_obj: JsonType, entity_dict: dict = None) -> dict:
-        """Find the points entities in the json object."""
+    def find_points_entities(
+        json_obj: ValetudoMap, entity_dict: dict = None
+    ) -> dict[str, list[PointMapEntity]]:
+        """
+        Traverse a ValetudoMap and collect PointMapEntity objects by their `type`.
+
+        Args:
+            json_obj: The full parsed JSON structure of a ValetudoMap.
+            entity_dict: Optional starting dict to append into.
+
+        Returns:
+            A dict mapping entity type strings to lists of PointMapEntitys.
+        """
         if entity_dict is None:
             entity_dict = {}
         if isinstance(json_obj, dict):
@@ -101,7 +274,9 @@ class ImageData:
         return entity_dict
 
     @staticmethod
-    def find_paths_entities(json_obj: JsonType, entity_dict: dict = None) -> dict:
+    def find_paths_entities(
+        json_obj: JsonType, entity_dict: dict[str, list[Entity]] | None = None
+    ) -> dict[str, list[Entity]]:
         """Find the paths entities in the json object."""
 
         if entity_dict is None:
@@ -119,7 +294,9 @@ class ImageData:
         return entity_dict
 
     @staticmethod
-    def find_zone_entities(json_obj: JsonType, entity_dict: dict = None) -> dict:
+    def find_zone_entities(
+        json_obj: JsonType, entity_dict: dict[str, list[Entity]] | None = None
+    ) -> dict[str, list[Entity]]:
         """Find the zone entities in the json object."""
         if entity_dict is None:
             entity_dict = {}
@@ -136,61 +313,81 @@ class ImageData:
         return entity_dict
 
     @staticmethod
-    def find_virtual_walls(json_obj: JsonType) -> list:
-        """Find the virtual walls in the json object."""
-        virtual_walls = []
+    def find_virtual_walls(json_obj: JsonType) -> list[list[tuple[float, float]]]:
+        """
+        Recursively search a JSON-like structure for virtual wall line entities.
+
+        Args:
+            json_obj: The JSON-like data (dicts/lists) to search.
+
+        Returns:
+            A list of point lists, where each point list belongs to a virtual wall.
+        """
+        virtual_walls: list[list[tuple[float, float]]] = []
 
-        def find_virtual_walls_recursive(obj):
-            """Find the virtual walls in the json object recursively."""
+        def _recurse(obj: Any) -> None:
             if isinstance(obj, dict):
-                if obj.get("__class") == "LineMapEntity":
-                    entity_type = obj.get("type")
-                    if entity_type == "virtual_wall":
-                        virtual_walls.append(obj["points"])
+                if (
+                    obj.get("__class") == "LineMapEntity"
+                    and obj.get("type") == "virtual_wall"
+                ):
+                    points = obj.get("points")
+                    if isinstance(points, list):
+                        virtual_walls.append(
+                            points
+                        )  # Type checkers may refine further here
+
                 for value in obj.values():
-                    find_virtual_walls_recursive(value)
+                    _recurse(value)
+
             elif isinstance(obj, list):
                 for item in obj:
-                    find_virtual_walls_recursive(item)
+                    _recurse(item)
 
-        find_virtual_walls_recursive(json_obj)
+        _recurse(json_obj)
         return virtual_walls
 
     @staticmethod
     async def async_get_rooms_coordinates(
-        pixels: list, pixel_size: int = 5, rand: bool = False
-    ) -> tuple:
+        pixels: Sequence[tuple[int, int, int]], pixel_size: int = 5, rand: bool = False
+    ) -> tuple[int, int, int, int] | tuple[tuple[int, int], tuple[int, int]]:
         """
-        Extract the room coordinates from the vacuum pixels data.
-        piexels: dict: The pixels data format [[x,y,z], [x1,y1,z1], [xn,yn,zn]].
-        pixel_size: int: The size of the pixel in mm (optional).
-        rand: bool: Return the coordinates in a rand256 format (optional).
+        Extract the room bounding box coordinates from vacuum pixel data.
+
+        Args:
+            pixels: Sequence of (x, y, z) values representing pixels.
+            pixel_size: Size of each pixel in mm. Defaults to 5.
+            rand: If True, return coordinates in rand256 format.
+
+        Returns:
+            If rand is True:
+                ((max_x_mm, max_y_mm), (min_x_mm, min_y_mm))
+            Else:
+                (min_x_mm, min_y_mm, max_x_mm, max_y_mm)
         """
-        # Initialize variables to store max and min coordinates
-        max_x, max_y = pixels[0][0], pixels[0][1]
-        min_x, min_y = pixels[0][0], pixels[0][1]
-        # Iterate through the data list to find max and min coordinates
-        for entry in pixels:
+        if not pixels:
+            raise ValueError("Pixels list cannot be empty.")
+
+        # Initialise min/max using the first pixel
+        first_x, first_y, _ = pixels[0]
+        min_x = max_x = first_x
+        min_y = max_y = first_y
+
+        for x, y, z in pixels:
             if rand:
-                x, y, _ = entry  # Extract x and y coordinates
-                max_x = max(max_x, x)  # Update max x coordinate
-                max_y = max(max_y, y + pixel_size)  # Update max y coordinate
-                min_x = min(min_x, x)  # Update min x coordinate
-                min_y = min(min_y, y)  # Update min y coordinate
+                max_x = max(max_x, x)
+                max_y = max(max_y, y + pixel_size)
             else:
-                x, y, z = entry  # Extract x and y coordinates
-                max_x = max(max_x, x + z)  # Update max x coordinate
-                max_y = max(max_y, y + pixel_size)  # Update max y coordinate
-                min_x = min(min_x, x)  # Update min x coordinate
-                min_y = min(min_y, y)  # Update min y coordinate
+                max_x = max(max_x, x + z)
+                max_y = max(max_y, y + pixel_size)
+
+            min_x = min(min_x, x)
+            min_y = min(min_y, y)
+
         if rand:
-            return (
-                (((max_x * pixel_size) * 10), ((max_y * pixel_size) * 10)),
-                (
-                    ((min_x * pixel_size) * 10),
-                    ((min_y * pixel_size) * 10),
-                ),
-            )
+            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 (
             min_x * pixel_size,
             min_y * pixel_size,
@@ -279,7 +476,7 @@ class RandImageData:
         return json_data.get("path", {})
 
     @staticmethod
-    def get_rrm_goto_predicted_path(json_data: JsonType) -> list or None:
+    def get_rrm_goto_predicted_path(json_data: JsonType) -> List or None:
         """Get the predicted path data from the json."""
         try:
             predicted_path = json_data.get("goto_predicted_path", {})
@@ -348,7 +545,7 @@ class RandImageData:
         return formatted_zones
 
     @staticmethod
-    def _rrm_valetudo_format_zone(coordinates: list) -> any:
+    def _rrm_valetudo_format_zone(coordinates: list) -> Any:
         """Format the zones from RRM to Valetudo."""
         formatted_zones = []
         for zone_data in coordinates:
@@ -497,3 +694,55 @@ class RandImageData:
         except KeyError:
             return None
         return seg_ids
+
+
+@dataclass
+class HyperMapData:
+    """Class to handle the map data snapshots."""
+
+    json_data: Any = None
+    json_id: str = "" or None
+    obstacles: dict[str, list[Any]] = field(default_factory=dict)
+    paths: dict[str, list[Any]] = field(default_factory=dict)
+    image_size: dict[str, int | list[int]] = field(default_factory=dict)
+    areas: dict[str, list[Any]] = field(default_factory=dict)
+    pixel_size: int = 0
+    entity_dict: dict[str, list[Any]] = field(default_factory=dict)
+    layers: dict[str, list[Any]] = field(default_factory=dict)
+    active_zones: list[int] = field(default_factory=list)
+    virtual_walls: list[list[tuple[float, float]]] = field(default_factory=list)
+
+    @classmethod
+    async def async_from_valetudo_json(cls, json_data: Any) -> "HyperMapData":
+        """
+        Build a fully-populated MapSnapshot from raw Valetudo JSON
+        using ImageData's helper functions.
+        """
+
+        # Call into your refactored static/class methods
+        json_id = ImageData.get_json_id(json_data)
+        paths = ImageData.find_paths_entities(json_data)
+        image_size = ImageData.get_image_size(json_data)
+        areas = ImageData.find_zone_entities(json_data)
+        # Hypothetical obstacles finder, if you have one
+        obstacles = getattr(ImageData, "find_obstacles_entities", lambda *_: {})(
+            json_data
+        )
+        virtual_walls = ImageData.find_virtual_walls(json_data)
+        pixel_size = int(json_data["pixelSize"])
+        layers, active_zones = ImageData.find_layers(json_data["layers"], {}, [])
+        entity_dict = ImageData.find_points_entities(json_data)
+
+        return cls(
+            json_data=json_data,
+            json_id=json_id,
+            image_size=image_size,
+            obstacles=obstacles,
+            paths=paths,
+            areas=areas,
+            virtual_walls=virtual_walls,
+            entity_dict=entity_dict,
+            pixel_size=pixel_size,
+            layers=layers,
+            active_zones=active_zones,
+        )

{valetudo_map_parser-0.1.10b1 → valetudo_map_parser-0.1.10b2}/SCR/valetudo_map_parser/reimg_draw.py

@@ -351,6 +351,7 @@ class ImageDraw:
                 y=robot_pos[1],
                 angle=robot_angle,
                 fill=color_robot,
+                radius=self.img_h.shared.robot_size,
                 robot_state=self.img_h.shared.vacuum_state,
             )
         return np_array

{valetudo_map_parser-0.1.10b1 → valetudo_map_parser-0.1.10b2}/pyproject.toml

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