valetudo-map-parser 0.1.9b100__py3-none-any.whl → 0.1.10__py3-none-any.whl

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
@@ -10,6 +10,7 @@ import logging
 
 from .config.drawable_elements import DrawableElement
 from .config.types import Color, JsonType, NumpyArray, RobotPosition, RoomStore
+from .config.utils import point_in_polygon
 
 
 _LOGGER = logging.getLogger(__name__)
@@ -23,51 +24,6 @@ class ImageDraw:
         self.img_h = image_handler
         self.file_name = self.img_h.shared.file_name
 
-    @staticmethod
-    def point_in_polygon(x: int, y: int, polygon: list) -> bool:
-        """
-        Check if a point is inside a polygon using ray casting algorithm.
-        Enhanced version with better handling of edge cases.
-
-        Args:
-            x: X coordinate of the point
-            y: Y coordinate of the point
-            polygon: List of (x, y) tuples forming the polygon
-
-        Returns:
-            True if the point is inside the polygon, False otherwise
-        """
-        # Ensure we have a valid polygon with at least 3 points
-        if len(polygon) < 3:
-            return False
-
-        # Make sure the polygon is closed (last point equals first point)
-        if polygon[0] != polygon[-1]:
-            polygon = polygon + [polygon[0]]
-
-        # Use winding number algorithm for better accuracy
-        wn = 0  # Winding number counter
-
-        # Loop through all edges of the polygon
-        for i in range(len(polygon) - 1):  # Last vertex is first vertex
-            p1x, p1y = polygon[i]
-            p2x, p2y = polygon[i + 1]
-
-            # Test if a point is left/right/on the edge defined by two vertices
-            if p1y <= y:  # Start y <= P.y
-                if p2y > y:  # End y > P.y (upward crossing)
-                    # Point left of edge
-                    if ((p2x - p1x) * (y - p1y) - (x - p1x) * (p2y - p1y)) > 0:
-                        wn += 1  # Valid up intersect
-            else:  # Start y > P.y
-                if p2y <= y:  # End y <= P.y (downward crossing)
-                    # Point right of edge
-                    if ((p2x - p1x) * (y - p1y) - (x - p1x) * (p2y - p1y)) < 0:
-                        wn -= 1  # Valid down intersect
-
-        # If winding number is not 0, the point is inside the polygon
-        return wn != 0
-
     async def draw_go_to_flag(
         self, np_array: NumpyArray, entity_dict: dict, color_go_to: Color
     ) -> NumpyArray:
@@ -191,8 +147,7 @@ class ImageDraw:
         Returns:
             The updated image array
         """
-        # Log the wall color to verify alpha is being passed correctly
-        _LOGGER.debug("%s: Drawing walls with color %s", self.file_name, color_wall)
+        # Draw walls
 
         # If there are no disabled rooms, draw all walls
         if not disabled_rooms:
@@ -202,9 +157,6 @@ class ImageDraw:
 
         # If there are disabled rooms, we need to check each wall pixel
         # to see if it belongs to a disabled room
-        _LOGGER.debug(
-            "%s: Filtering walls for disabled rooms: %s", self.file_name, disabled_rooms
-        )
 
         # Get the element map if available
         element_map = getattr(self.img_h, "element_map", None)
@@ -247,7 +199,7 @@ class ImageDraw:
                     # Get the element at this position
                     element = element_map[check_y, check_x]
 
-                    # Check if this element is a disabled room
+                    # Check if this element is a disabled one
                     # Room elements are in the range 101-115 (ROOM_1 to ROOM_15)
                     if 101 <= element <= 115:
                         room_id = element - 101  # Convert to 0-based index
@@ -263,12 +215,6 @@ class ImageDraw:
                 filtered_pixels.append((x, y, z))
 
         # Draw the filtered walls
-        _LOGGER.debug(
-            "%s: Drawing %d of %d wall pixels after filtering",
-            self.file_name,
-            len(filtered_pixels),
-            len(pixels),
-        )
         if filtered_pixels:
             return await self.img_h.draw.from_json_to_image(
                 img_np_array, filtered_pixels, pixel_size, color_wall
@@ -310,15 +256,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 +354,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:
@@ -433,26 +361,8 @@ class ImageDraw:
             room_store = RoomStore(self.file_name)
             room_keys = list(room_store.get_rooms().keys())
 
-            _LOGGER.debug(
-                "%s: Active zones debug - segment_id: %s, room_keys: %s, active_zones: %s",
-                self.file_name,
-                segment_id,
-                room_keys,
-                self.img_h.active_zones,
-            )
-
             if segment_id in room_keys:
                 position = room_keys.index(segment_id)
-                _LOGGER.debug(
-                    "%s: Segment ID %s found at position %s, active_zones[%s] = %s",
-                    self.file_name,
-                    segment_id,
-                    position,
-                    position,
-                    self.img_h.active_zones[position]
-                    if position < len(self.img_h.active_zones)
-                    else "OUT_OF_BOUNDS",
-                )
                 if position < len(self.img_h.active_zones):
                     self.img_h.zooming = bool(self.img_h.active_zones[position])
                 else:
@@ -468,37 +378,6 @@ class ImageDraw:
         else:
             self.img_h.zooming = False
 
-    @staticmethod
-    def point_in_polygon(x: int, y: int, polygon: list) -> bool:
-        """
-        Check if a point is inside a polygon using ray casting algorithm.
-
-        Args:
-            x: X coordinate of the point
-            y: Y coordinate of the point
-            polygon: List of (x, y) tuples forming the polygon
-
-        Returns:
-            True if the point is inside the polygon, False otherwise
-        """
-        n = len(polygon)
-        inside = False
-
-        p1x, p1y = polygon[0]
-        xinters = None  # Initialize with default value
-        for i in range(1, n + 1):
-            p2x, p2y = polygon[i % n]
-            if y > min(p1y, p2y):
-                if y <= max(p1y, p2y):
-                    if x <= max(p1x, p2x):
-                        if p1y != p2y:
-                            xinters = (y - p1y) * (p2x - p1x) / (p2y - p1y) + p1x
-                        if p1x == p2x or (xinters is not None and x <= xinters):
-                            inside = not inside
-            p1x, p1y = p2x, p2y
-
-        return inside
-
     async def async_get_robot_in_room(
         self, robot_y: int = 0, robot_x: int = 0, angle: float = 0.0
     ) -> RobotPosition:
@@ -508,7 +387,7 @@ class ImageDraw:
             # If we have outline data, use point_in_polygon for accurate detection
             if "outline" in self.img_h.robot_in_room:
                 outline = self.img_h.robot_in_room["outline"]
-                if self.point_in_polygon(int(robot_x), int(robot_y), outline):
+                if point_in_polygon(int(robot_x), int(robot_y), outline):
                     temp = {
                         "x": robot_x,
                         "y": robot_y,
@@ -549,12 +428,6 @@ class ImageDraw:
         # This helps prevent false positives for points very far from any room
         map_boundary = 20000  # Typical map size is around 5000-10000 units
         if abs(robot_x) > map_boundary or abs(robot_y) > map_boundary:
-            _LOGGER.debug(
-                "%s robot position (%s, %s) is far outside map boundaries.",
-                self.file_name,
-                robot_x,
-                robot_y,
-            )
             self.img_h.robot_in_room = last_room
             self.img_h.zooming = False
             temp = {
@@ -567,10 +440,6 @@ class ImageDraw:
 
         # Search through all rooms to find which one contains the robot
         if self.img_h.rooms_pos is None:
-            _LOGGER.debug(
-                "%s: No rooms data available for robot position detection.",
-                self.file_name,
-            )
             self.img_h.robot_in_room = last_room
             self.img_h.zooming = False
             temp = {
@@ -586,7 +455,7 @@ class ImageDraw:
             if "outline" in room:
                 outline = room["outline"]
                 # Use point_in_polygon for accurate detection with complex shapes
-                if self.point_in_polygon(int(robot_x), int(robot_y), outline):
+                if point_in_polygon(int(robot_x), int(robot_y), outline):
                     # Robot is in this room
                     self.img_h.robot_in_room = {
                         "id": room.get(
@@ -608,26 +477,8 @@ class ImageDraw:
                         room_store = RoomStore(self.file_name)
                         room_keys = list(room_store.get_rooms().keys())
 
-                        _LOGGER.debug(
-                            "%s: Active zones debug - segment_id: %s, room_keys: %s, active_zones: %s",
-                            self.file_name,
-                            segment_id,
-                            room_keys,
-                            self.img_h.active_zones,
-                        )
-
                         if segment_id in room_keys:
                             position = room_keys.index(segment_id)
-                            _LOGGER.debug(
-                                "%s: Segment ID %s found at position %s, active_zones[%s] = %s",
-                                self.file_name,
-                                segment_id,
-                                position,
-                                position,
-                                self.img_h.active_zones[position]
-                                if position < len(self.img_h.active_zones)
-                                else "OUT_OF_BOUNDS",
-                            )
                             if position < len(self.img_h.active_zones):
                                 self.img_h.zooming = bool(
                                     self.img_h.active_zones[position]
@@ -645,11 +496,6 @@ class ImageDraw:
                     else:
                         self.img_h.zooming = False
 
-                    _LOGGER.debug(
-                        "%s is in %s room (polygon detection).",
-                        self.file_name,
-                        self.img_h.robot_in_room["room"],
-                    )
                     return temp
             # Fallback to bounding box if no outline is available
             elif "corners" in room:
@@ -683,19 +529,10 @@ class ImageDraw:
                     # Handle active zones
                     self._check_active_zone_and_set_zooming()
 
-                    _LOGGER.debug(
-                        "%s is in %s room (bounding box detection).",
-                        self.file_name,
-                        self.img_h.robot_in_room["room"],
-                    )
                     return temp
             room_count += 1
 
         # Robot not found in any room
-        _LOGGER.debug(
-            "%s not located within any room coordinates.",
-            self.file_name,
-        )
         self.img_h.robot_in_room = last_room
         self.img_h.zooming = False
         temp = {

valetudo_map_parser/hypfer_handler.py

@@ -2,37 +2,32 @@
 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
 
 import asyncio
-import numpy as np
 
+import numpy as np
+from mvcrender.autocrop import AutoCrop
 from PIL import Image
 
-from .config.async_utils import AsyncNumPy, AsyncPIL
-from .config.auto_crop import AutoCrop
+from .config.async_utils import AsyncPIL
 from .config.drawable_elements import DrawableElement
 from .config.shared import CameraShared
-from .config.utils import pil_to_webp_bytes
 from .config.types import (
     COLORS,
     LOGGER,
     CalibrationPoints,
     Colors,
+    JsonType,
     RoomsProperties,
     RoomStore,
-    WebPBytes,
-    JsonType,
 )
 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
 from .map_data import ImageData
@@ -50,11 +45,8 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
         AutoCrop.__init__(self, self)
         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.
@@ -62,8 +54,7 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
         self.img_work_layer = (
             None  # persistent working buffer to avoid per-frame allocations
         )
-        self.active_zones = None  # vacuum active zones.
-        self.svg_wait = False  # SVG image creation wait.
+        self.active_zones = []  # vacuum active zones.
         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.
@@ -82,10 +73,7 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
             json_data
         )
         if room_properties:
-            rooms = RoomStore(self.file_name, room_properties)
-            LOGGER.debug(
-                "%s: Rooms data extracted! %s", self.file_name, rooms.get_rooms()
-            )
+            _ = 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():
@@ -97,7 +85,6 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                     }
                 )
         else:
-            LOGGER.debug("%s: Rooms data not available!", self.file_name)
             self.rooms_pos = None
         return room_properties
 
@@ -105,14 +92,12 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
     async def async_get_image_from_json(
         self,
         m_json: JsonType | None,
-        return_webp: bool = False,
-    ) -> WebPBytes | Image.Image | None:
+    ) -> 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.
-        @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.
+        @return Image.Image: PIL Image.
         """
         # Initialize the colors.
         colors: Colors = {
@@ -121,21 +106,12 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
         # Check if the JSON data is not None else process the image.
         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 +121,16 @@ 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)
+                self.active_zones = self.json_data.active_zones
+
+                new_frame_hash = await self.calculate_array_hash(
+                    self.json_data.layers, self.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 +139,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)
@@ -180,11 +160,6 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                                     ):
                                         # Add this room to the disabled rooms set
                                         disabled_rooms.add(room_id)
-                                        LOGGER.debug(
-                                            "%s: Room %d is disabled and will be skipped",
-                                            self.file_name,
-                                            current_room_id,
-                                        )
                                 room_id = (
                                     room_id + 1
                                 ) % 16  # Cycle room_id back to 0 after 15
@@ -193,7 +168,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 +236,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)
@@ -284,12 +262,6 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                     new_frame_hash != self.img_hash
                 ):
                     self.frame_number = 0
-                LOGGER.debug(
-                    "%s: %s at Frame Number: %s",
-                    self.file_name,
-                    str(self.json_id),
-                    str(self.frame_number),
-                )
                 # Ensure persistent working buffer exists and matches base (allocate only when needed)
                 if (
                     self.img_work_layer is None
@@ -366,24 +338,15 @@ 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,
                     )
 
-                    # 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 = await 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),
@@ -400,29 +363,16 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                 # Convert to PIL for resizing
                 pil_img = await AsyncPIL.async_fromarray(img_np_array, mode="RGBA")
                 del img_np_array
-                resize_params = prepare_resize_params(self, pil_img, False)
+                resize_params = self.prepare_resize_params(pil_img)
                 resized_image = await self.async_resize_images(resize_params)
 
-                # Return WebP bytes or PIL Image based on parameter
-                if return_webp:
-                    webp_bytes = await pil_to_webp_bytes(resized_image)
-                    return webp_bytes
-                else:
-                    return resized_image
+                # Return PIL Image
+                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)
-                    del img_np_array
-                    LOGGER.debug("%s: Frame Completed.", self.file_name)
-                    return webp_bytes
-                else:
-                    # Convert to PIL Image (original behavior)
-                    pil_img = await AsyncPIL.async_fromarray(img_np_array, mode="RGBA")
-                    del img_np_array
-                    LOGGER.debug("%s: Frame Completed.", self.file_name)
-                    return pil_img
+                # Return PIL Image (convert from NumPy)
+                pil_img = await AsyncPIL.async_fromarray(img_np_array, mode="RGBA")
+                del img_np_array
+                return pil_img
         except (RuntimeError, RuntimeWarning) as e:
             LOGGER.warning(
                 "%s: Error %s during image creation.",
@@ -438,19 +388,15 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
         if self.room_propriety:
             return self.room_propriety
         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)
         return self.room_propriety
 
-    def get_calibration_data(self) -> CalibrationPoints:
+    def get_calibration_data(self, rotation_angle: int = 0) -> CalibrationPoints:
         """Get the calibration data from the JSON data.
         this will create the attribute calibration points."""
         calibration_data = []
-        rotation_angle = self.shared.image_rotate
         LOGGER.info("Getting %s Calibrations points.", self.file_name)
 
         # Define the map points (fixed)
@@ -465,42 +411,6 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
         del vacuum_points, map_points, calibration_point, rotation_angle  # free memory.
         return calibration_data
 
-    # Element selection methods
-    def enable_element(self, element_code: DrawableElement) -> None:
-        """Enable drawing of a specific element."""
-        self.drawing_config.enable_element(element_code)
-        LOGGER.info(
-            "%s: Enabled element %s, now enabled: %s",
-            self.file_name,
-            element_code.name,
-            self.drawing_config.is_enabled(element_code),
-        )
-
-    def disable_element(self, element_code: DrawableElement) -> None:
-        """Disable drawing of a specific element."""
-        manage_drawable_elements(self, "disable", element_code=element_code)
-
-    def set_elements(self, element_codes: list[DrawableElement]) -> None:
-        """Enable only the specified elements, disable all others."""
-        manage_drawable_elements(self, "set_elements", element_codes=element_codes)
-
-    def set_element_property(
-        self, element_code: DrawableElement, property_name: str, value
-    ) -> None:
-        """Set a drawing property for an element."""
-        manage_drawable_elements(
-            self,
-            "set_property",
-            element_code=element_code,
-            property_name=property_name,
-            value=value,
-        )
-
-    @staticmethod
-    async def async_copy_array(original_array):
-        """Copy the array."""
-        return await AsyncNumPy.async_copy(original_array)
-
     async def _prepare_zone_data(self, m_json):
         """Prepare zone data for parallel processing."""
         await asyncio.sleep(0)  # Yield control