valetudo-map-parser 0.1.9b55__py3-none-any.whl → 0.1.9b57__py3-none-any.whl

valetudo_map_parser/hypfer_handler.py

@@ -21,11 +21,13 @@ from .config.types import (
     Colors,
     RoomsProperties,
     RoomStore,
+    WebPBytes,
 )
 from .config.utils import (
     BaseHandler,
     initialize_drawing_config,
     manage_drawable_elements,
+    numpy_to_webp_bytes,
     prepare_resize_params,
 )
 from .hypfer_draw import ImageDraw as ImDraw
@@ -81,7 +83,11 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
             self.rooms_pos = []
             for room_id, room_data in room_properties.items():
                 self.rooms_pos.append(
-                    {"name": room_data["name"], "outline": room_data["outline"]}
+                    {
+                        "id": room_id,
+                        "name": room_data["name"],
+                        "outline": room_data["outline"],
+                    }
                 )
         else:
             LOGGER.debug("%s: Rooms data not available!", self.file_name)
@@ -92,12 +98,14 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
     async def async_get_image_from_json(
         self,
         m_json: json | None,
-    ) -> Image.Image | None:
+        return_webp: bool = False,
+    ) -> WebPBytes | Image.Image | None:
         """Get the image from the JSON data.
         It uses the ImageDraw class to draw some of the elements of the image.
         The robot itself will be drawn in this function as per some of the values are needed for other tasks.
         @param m_json: The JSON data to use to draw the image.
-        @return Image.Image: The image to display.
+        @param return_webp: If True, return WebP bytes; if False, return PIL Image (default).
+        @return WebPBytes | Image.Image: WebP bytes or PIL Image depending on return_webp parameter.
         """
         # Initialize the colors.
         colors: Colors = {
@@ -131,6 +139,8 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                 # Get the pixels size and layers from the JSON data
                 pixel_size = int(m_json["pixelSize"])
                 layers, active = self.data.find_layers(m_json["layers"], {}, [])
+                # Populate active_zones from the JSON data
+                self.active_zones = active
                 new_frame_hash = await self.calculate_array_hash(layers, active)
                 if self.frame_number == 0:
                     self.img_hash = new_frame_hash
@@ -240,20 +250,30 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
 
                     # Draw obstacles if enabled
                     if self.drawing_config.is_enabled(DrawableElement.OBSTACLE):
-                        img_np_array = await self.imd.async_draw_obstacle(
-                            img_np_array, entity_dict, colors["no_go"]
-                        )
+                        self.shared.obstacles_pos = self.data.get_obstacles(entity_dict)
+                        if self.shared.obstacles_pos:
+                            img_np_array = await self.imd.async_draw_obstacle(
+                                img_np_array, self.shared.obstacles_pos, colors["no_go"]
+                            )
                     # 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
                         )
-                        if self.rooms_pos and robot_position and robot_position_angle:
-                            self.robot_pos = await self.imd.async_get_robot_in_room(
-                                robot_x=(robot_position[0]),
-                                robot_y=(robot_position[1]),
-                                angle=robot_position_angle,
-                            )
+
+                    # 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
+                        )
+
+                    # Always check robot position for zooming (moved outside the condition)
+                    if self.rooms_pos and robot_position and robot_position_angle:
+                        self.robot_pos = await self.imd.async_get_robot_in_room(
+                            robot_x=(robot_position[0]),
+                            robot_y=(robot_position[1]),
+                            angle=robot_position_angle,
+                        )
                     LOGGER.info("%s: Completed base Layers", self.file_name)
                     # Copy the new array in base layer.
                     self.img_base_layer = await self.async_copy_array(img_np_array)
@@ -332,6 +352,9 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                             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 = await self.async_auto_trim_and_zoom_image(
                     img_np_array,
@@ -345,16 +368,43 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                 LOGGER.warning("%s: Image array is None.", self.file_name)
                 return None
 
-            # Convert the numpy array to a PIL image
-            pil_img = Image.fromarray(img_np_array, mode="RGBA")
-            del img_np_array
-            # reduce the image size if the zoomed image is bigger then the original.
+            # Handle resizing if needed, then return based on format preference
             if self.check_zoom_and_aspect_ratio():
+                # Convert to PIL for resizing
+                pil_img = Image.fromarray(img_np_array, mode="RGBA")
+                del img_np_array
                 resize_params = prepare_resize_params(self, pil_img, False)
                 resized_image = await self.async_resize_images(resize_params)
-                return resized_image
-            LOGGER.debug("%s: Frame Completed.", self.file_name)
-            return pil_img
+
+                # Return WebP bytes or PIL Image based on parameter
+                if return_webp:
+                    from .config.utils import pil_to_webp_bytes
+                    webp_bytes = await pil_to_webp_bytes(
+                        resized_image,
+                        quality=90,
+                        lossless=False
+                    )
+                    return webp_bytes
+                else:
+                    return resized_image
+            else:
+                # Return WebP bytes or PIL Image based on parameter
+                if return_webp:
+                    # Convert directly from NumPy to WebP for better performance
+                    webp_bytes = await numpy_to_webp_bytes(
+                        img_np_array,
+                        quality=90,
+                        lossless=False
+                    )
+                    del img_np_array
+                    LOGGER.debug("%s: Frame Completed.", self.file_name)
+                    return webp_bytes
+                else:
+                    # Convert to PIL Image (original behavior)
+                    pil_img = Image.fromarray(img_np_array, mode="RGBA")
+                    del img_np_array
+                    LOGGER.debug("%s: Frame Completed.", self.file_name)
+                    return pil_img
         except (RuntimeError, RuntimeWarning) as e:
             LOGGER.warning(
                 "%s: Error %s during image creation.",

valetudo_map_parser/map_data.py

@@ -10,7 +10,7 @@ from __future__ import annotations
 
 import numpy as np
 
-from .config.types import Colors, ImageSize, JsonType, NumpyArray
+from .config.types import ImageSize, JsonType
 
 
 class ImageData:
@@ -34,6 +34,30 @@ class ImageData:
     # list the specific Layers, Paths, Zones and Pints in the
     # Vacuums Json in parallel.
 
+    @staticmethod
+    def get_obstacles(entity_dict: dict) -> list:
+        """Get the obstacles positions from the entity data."""
+        try:
+            obstacle_data = entity_dict.get("obstacle")
+        except KeyError:
+            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 = {
+                        "label": label,
+                        "points": {"x": points[0], "y": points[1]},
+                        "id": image_id,
+                    }
+                    obstacle_positions.append(obstacle_pos)
+            return obstacle_positions
+        return []
+
     @staticmethod
     def find_layers(
         json_obj: JsonType, layer_dict: dict, active_list: list
@@ -284,7 +308,7 @@ class RandImageData:
         Return the calculated angle and original angle.
         """
         angle_c = round(json_data.get("robot_angle", 0))
-        angle = (360 - angle_c + 80) if angle_c < 0 else (180 - angle_c - 80)
+        angle = (360 - angle_c + 95) if angle_c < 0 else (180 - angle_c - 85)
         return angle % 360, json_data.get("robot_angle", 0)
 
     @staticmethod