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

valetudo_map_parser/rand256_handler.py

@@ -2,19 +2,18 @@
 Image Handler Module for Valetudo Re Vacuums.
 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.a6
+Version: 0.1.10
 """
 
 from __future__ import annotations
 
-import logging
 import uuid
 from typing import Any
 
 import numpy as np
+from mvcrender.autocrop import AutoCrop
 
-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.types import (
     COLORS,
@@ -26,23 +25,18 @@ from .config.types import (
     RobotPosition,
     RoomsProperties,
     RoomStore,
-    WebPBytes,
+    LOGGER,
 )
 from .config.utils import (
     BaseHandler,
     initialize_drawing_config,
-    manage_drawable_elements,
-    numpy_to_webp_bytes,
-    prepare_resize_params,
+    point_in_polygon,
 )
 from .map_data import RandImageData
 from .reimg_draw import ImageDraw
 from .rooms_handler import RandRoomsHandler
 
 
-_LOGGER = logging.getLogger(__name__)
-
-
 # noinspection PyTypeChecker
 class ReImageHandler(BaseHandler, AutoCrop):
     """
@@ -60,9 +54,7 @@ class ReImageHandler(BaseHandler, AutoCrop):
         self.data = RandImageData  # Image Data
 
         # 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  # Go to position data
         self.img_base_layer = None  # Base image layer
         self.img_rotate = shared_data.image_rotate  # Image rotation
@@ -101,56 +93,40 @@ class ReImageHandler(BaseHandler, AutoCrop):
 
             # Update self.rooms_pos from room_properties for compatibility with other methods
             self.rooms_pos = []
-            room_ids = []  # Collect room IDs for shared.map_rooms
             for room_id, room_data in room_properties.items():
                 self.rooms_pos.append(
                     {"name": room_data["name"], "outline": room_data["outline"]}
                 )
-                # Store the room number (segment ID) for MQTT active zone mapping
-                room_ids.append(room_data["number"])
-
-            # Update shared.map_rooms with the room IDs for MQTT active zone mapping
-            self.shared.map_rooms = room_ids
-            _LOGGER.debug("Updated shared.map_rooms with room IDs: %s", room_ids)
 
+            # Update shared.map_rooms with the full room properties (consistent with Hypfer)
+            self.shared.map_rooms = room_properties
             # get the zones and points data
-            zone_properties = await self.async_zone_propriety(zones_data)
+            self.shared.map_pred_zones = await self.async_zone_propriety(zones_data)
             # get the points data
-            point_properties = await self.async_points_propriety(points_data)
-
-            if room_properties or zone_properties:
-                extracted_data = [
-                    f"{len(room_properties)} Rooms" if room_properties else None,
-                    f"{len(zone_properties)} Zones" if zone_properties else None,
-                ]
-                extracted_data = ", ".join(filter(None, extracted_data))
-                _LOGGER.debug("Extracted data: %s", extracted_data)
-            else:
+            self.shared.map_pred_points = await self.async_points_propriety(points_data)
+
+            if not (room_properties or self.shared.map_pred_zones):
                 self.rooms_pos = None
-                _LOGGER.debug("%s: Rooms and Zones data not available!", self.file_name)
 
-            rooms = RoomStore(self.file_name, room_properties)
-            _LOGGER.debug("Rooms Data: %s", rooms.get_rooms())
-            return room_properties, zone_properties, point_properties
+            _ = RoomStore(self.file_name, room_properties)
+            return room_properties
         except (RuntimeError, ValueError) as e:
-            _LOGGER.debug(
+            LOGGER.warning(
                 "No rooms Data or Error in extract_room_properties: %s",
                 e,
                 exc_info=True,
             )
-            return None, None, None
+            return None
 
     async def get_image_from_rrm(
         self,
         m_json: JsonType,  # json data
         destinations: None = None,  # MQTT destinations for labels
-        return_webp: bool = False,
-    ) -> WebPBytes | PilPNG | None:
+    ) -> PilPNG | None:
         """Generate Images from the json data.
         @param m_json: The JSON data to use to draw the image.
         @param destinations: MQTT destinations for labels (unused).
-        @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.
         """
         colors: Colors = {
             name: self.shared.user_colors[idx] for idx, name in enumerate(COLORS)
@@ -159,12 +135,12 @@ class ReImageHandler(BaseHandler, AutoCrop):
 
         try:
             if (m_json is not None) and (not isinstance(m_json, tuple)):
-                _LOGGER.info("%s: Composing the image for the camera.", self.file_name)
+                LOGGER.info("%s: Composing the image for the camera.", self.file_name)
                 self.json_data = m_json
                 size_x, size_y = self.data.get_rrm_image_size(m_json)
                 self.img_size = DEFAULT_IMAGE_SIZE
                 self.json_id = str(uuid.uuid4())  # image id
-                _LOGGER.info("Vacuum Data ID: %s", self.json_id)
+                LOGGER.info("Vacuum Data ID: %s", self.json_id)
 
                 (
                     img_np_array,
@@ -177,9 +153,6 @@ class ReImageHandler(BaseHandler, AutoCrop):
                 # Increment frame number
                 self.frame_number += 1
                 img_np_array = await self.async_copy_array(self.img_base_layer)
-                _LOGGER.debug(
-                    "%s: Frame number %s", self.file_name, str(self.frame_number)
-                )
                 if self.frame_number > 5:
                     self.frame_number = 0
 
@@ -188,20 +161,13 @@ class ReImageHandler(BaseHandler, AutoCrop):
                     img_np_array, m_json, colors, robot_position, robot_position_angle
                 )
 
-                # Return WebP bytes or PIL Image based on parameter
-                if return_webp:
-                    # Convert directly to WebP bytes for better performance
-                    webp_bytes = await numpy_to_webp_bytes(img_np_array)
-                    del img_np_array  # free memory
-                    return webp_bytes
-                else:
-                    # Convert to PIL Image using async utilities
-                    pil_img = await AsyncPIL.async_fromarray(img_np_array, mode="RGBA")
-                    del img_np_array  # free memory
-                    return await self._finalize_image(pil_img)
+                # Return PIL Image using async utilities
+                pil_img = await AsyncPIL.async_fromarray(img_np_array, mode="RGBA")
+                del img_np_array  # free memory
+                return await self._finalize_image(pil_img)
 
         except (RuntimeError, RuntimeWarning) as e:
-            _LOGGER.warning(
+            LOGGER.warning(
                 "%s: Runtime Error %s during image creation.",
                 self.file_name,
                 str(e),
@@ -215,6 +181,7 @@ class ReImageHandler(BaseHandler, AutoCrop):
     async def _setup_robot_and_image(
         self, m_json, size_x, size_y, colors, destinations
     ):
+        """Set up the elements of the map and the image."""
         (
             _,
             robot_position,
@@ -237,13 +204,7 @@ class ReImageHandler(BaseHandler, AutoCrop):
                     colors["background"],
                     DEFAULT_PIXEL_SIZE,
                 )
-                _LOGGER.info("%s: Completed base Layers", self.file_name)
-
-                # Update element map for rooms
-                if 0 < room_id <= 15:
-                    # This is a simplification - in a real implementation we would
-                    # need to identify the exact pixels that belong to each room
-                    pass
+                LOGGER.info("%s: Completed base Layers", self.file_name)
 
                 if room_id > 0 and not self.room_propriety:
                     self.room_propriety = await self.get_rooms_attributes(destinations)
@@ -252,8 +213,10 @@ class ReImageHandler(BaseHandler, AutoCrop):
                 if not self.rooms_pos and not self.room_propriety:
                     self.room_propriety = await self.get_rooms_attributes(destinations)
 
-                # Always check robot position for zooming (fallback)
-                if self.rooms_pos and robot_position and not hasattr(self, "robot_pos"):
+                # Always check robot position for zooming (update if room info is missing)
+                if self.rooms_pos and robot_position and (
+                    self.robot_pos is None or "in_room" not in self.robot_pos
+                ):
                     self.robot_pos = await self.async_get_robot_in_room(
                         (robot_position[0] * 10),
                         (robot_position[1] * 10),
@@ -300,12 +263,7 @@ class ReImageHandler(BaseHandler, AutoCrop):
                     # Restore original rooms_pos
                     self.rooms_pos = original_rooms_pos
 
-            except Exception as e:
-                _LOGGER.debug(
-                    "%s: Early room extraction failed: %s, falling back to robot-position zoom",
-                    self.file_name,
-                    e,
-                )
+            except (ValueError, KeyError, TypeError):
                 # Fallback to robot-position-based zoom if room extraction fails
                 if (
                     self.shared.image_auto_zoom
@@ -313,16 +271,13 @@ class ReImageHandler(BaseHandler, AutoCrop):
                     and robot_position
                 ):
                     self.zooming = True
-                    _LOGGER.debug(
-                        "%s: Enabling fallback robot-position-based zoom",
-                        self.file_name,
-                    )
 
         return self.img_base_layer, robot_position, robot_position_angle
 
     async def _draw_map_elements(
         self, img_np_array, m_json, colors, robot_position, robot_position_angle
     ):
+        """Draw map elements on the image."""
         # Draw charger if enabled
         if self.drawing_config.is_enabled(DrawableElement.CHARGER):
             img_np_array, self.charger_pos = await self.imd.async_draw_charger(
@@ -379,19 +334,10 @@ class ReImageHandler(BaseHandler, AutoCrop):
             active_zones = self.shared.rand256_active_zone
             if active_zones and any(zone for zone in active_zones):
                 self.zooming = True
-                _LOGGER.debug(
-                    "%s: Enabling zoom for Rand256 - active zones detected: %s",
-                    self.file_name,
-                    active_zones,
-                )
             else:
                 self.zooming = False
-                _LOGGER.debug(
-                    "%s: Zoom disabled for Rand256 - no active zones set",
-                    self.file_name,
-                )
 
-        img_np_array = await self.async_auto_trim_and_zoom_image(
+        img_np_array = self.auto_trim_and_zoom_image(
             img_np_array,
             detect_colour=colors["background"],
             margin_size=int(self.shared.margins),
@@ -402,77 +348,30 @@ class ReImageHandler(BaseHandler, AutoCrop):
         return img_np_array
 
     async def _finalize_image(self, pil_img):
-        if not self.shared.image_ref_width or not self.shared.image_ref_height:
-            _LOGGER.warning(
-                "Image finalization failed: Invalid image dimensions. Returning original image."
-            )
-            return pil_img
+        """Finalize the image by resizing if needed."""
+        if pil_img is None:
+            LOGGER.warning("%s: Image is None. Returning None.", self.file_name)
+            return None
         if self.check_zoom_and_aspect_ratio():
-            resize_params = prepare_resize_params(self, pil_img, True)
+            resize_params = self.prepare_resize_params(pil_img, True)
             pil_img = await self.async_resize_images(resize_params)
-        _LOGGER.debug("%s: Frame Completed.", self.file_name)
+        else:
+            LOGGER.warning(
+                "%s: Invalid image dimensions. Returning original image.",
+                self.file_name,
+            )
         return pil_img
 
     async def get_rooms_attributes(
         self, destinations: JsonType = None
     ) -> tuple[RoomsProperties, Any, Any]:
         """Return the rooms attributes."""
-        if self.room_propriety:
-            return self.room_propriety
         if self.json_data and destinations:
-            _LOGGER.debug("Checking for rooms data..")
             self.room_propriety = await self.extract_room_properties(
                 self.json_data, destinations
             )
-            if self.room_propriety:
-                _LOGGER.debug("Got Rooms Attributes.")
         return self.room_propriety
 
-    @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 async_get_robot_in_room(
         self, robot_x: int, robot_y: int, angle: float
     ) -> RobotPosition:
@@ -482,7 +381,7 @@ class ReImageHandler(BaseHandler, AutoCrop):
             # If we have outline data, use point_in_polygon for accurate detection
             if "outline" in self.robot_in_room:
                 outline = self.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,
@@ -491,6 +390,12 @@ class ReImageHandler(BaseHandler, AutoCrop):
                     }
                     # Handle active zones
                     self.active_zones = self.shared.rand256_active_zone
+                    LOGGER.debug(
+                        "%s: Robot is in %s room (polygon detection). %s",
+                        self.file_name,
+                        self.robot_in_room["room"],
+                        self.active_zones,
+                    )
                     self.zooming = False
                     if self.active_zones and (
                         self.robot_in_room["id"] in range(len(self.active_zones))
@@ -537,12 +442,6 @@ class ReImageHandler(BaseHandler, AutoCrop):
         # This helps prevent false positives for points very far from any room
         map_boundary = 50000  # Typical map size is around 25000-30000 units for Rand25
         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.robot_in_room = last_room
             self.zooming = False
             temp = {
@@ -555,10 +454,6 @@ class ReImageHandler(BaseHandler, AutoCrop):
 
         # Search through all rooms to find which one contains the robot
         if not self.rooms_pos:
-            _LOGGER.debug(
-                "%s: No rooms data available for robot position detection.",
-                self.file_name,
-            )
             self.robot_in_room = last_room
             self.zooming = False
             temp = {
@@ -569,13 +464,12 @@ class ReImageHandler(BaseHandler, AutoCrop):
             }
             return temp
 
-        _LOGGER.debug("%s: Searching for robot in rooms...", self.file_name)
         for room in self.rooms_pos:
             # Check if the room has an outline (polygon points)
             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.robot_in_room = {
                         "id": room_count,
@@ -598,19 +492,10 @@ class ReImageHandler(BaseHandler, AutoCrop):
                     else:
                         self.zooming = False
 
-                    _LOGGER.debug(
-                        "%s is in %s room (polygon detection).",
-                        self.file_name,
-                        self.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.robot_in_room = last_room
         self.zooming = False
         temp = {
@@ -625,7 +510,7 @@ class ReImageHandler(BaseHandler, AutoCrop):
         """Return the map calibration data."""
         if not self.calibration_data and self.crop_img_size:
             self.calibration_data = []
-            _LOGGER.info(
+            LOGGER.info(
                 "%s: Getting Calibrations points %s",
                 self.file_name,
                 str(self.crop_area),
@@ -643,32 +528,3 @@ class ReImageHandler(BaseHandler, AutoCrop):
                 self.calibration_data.append(calibration_point)
 
         return self.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)
-
-    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,
-        )
-
-    async def async_copy_array(self, original_array):
-        """Copy the array using async utilities."""
-        return await AsyncNumPy.async_copy(original_array)

valetudo_map_parser/reimg_draw.py

@@ -6,17 +6,12 @@ Version: 0.1.9.b42
 
 from __future__ import annotations
 
-import logging
-
 from .config.drawable import Drawable
 from .config.drawable_elements import DrawableElement
-from .config.types import Color, JsonType, NumpyArray
+from .config.types import LOGGER, Color, JsonType, NumpyArray
 from .map_data import ImageData, RandImageData
 
 
-_LOGGER = logging.getLogger(__name__)
-
-
 class ImageDraw:
     """Class to handle the image creation."""
 
@@ -48,7 +43,7 @@ class ImageDraw:
                     )
             return np_array
         except KeyError as e:
-            _LOGGER.warning(
+            LOGGER.warning(
                 "%s: Error in extraction of go-to target: %s",
                 self.file_name,
                 e,
@@ -70,7 +65,7 @@ class ImageDraw:
                 )
         except ValueError as e:
             self.img_h.segment_data = None
-            _LOGGER.info("%s: No segments data found: %s", self.file_name, e)
+            LOGGER.info("%s: No segments data found: %s", self.file_name, e)
 
     async def async_draw_base_layer(
         self,
@@ -87,13 +82,13 @@ class ImageDraw:
         walls_data = self.data.get_rrm_walls(m_json)
         floor_data = self.data.get_rrm_floor(m_json)
 
-        _LOGGER.info("%s: Empty image with background color", self.file_name)
+        LOGGER.info("%s: Empty image with background color", self.file_name)
         img_np_array = await self.draw.create_empty_image(
             self.img_h.img_size["x"], self.img_h.img_size["y"], color_background
         )
         room_id = 0
         if self.img_h.frame_number == 0:
-            _LOGGER.info("%s: Overlapping Layers", self.file_name)
+            LOGGER.info("%s: Overlapping Layers", self.file_name)
 
             # checking if there are segments too (sorted pixels in the raw data).
             await self.async_segment_data(m_json, size_x, size_y, pos_top, pos_left)
@@ -148,10 +143,10 @@ class ImageDraw:
         room_id = 0
         rooms_list = [color_wall]
         if not segment_data:
-            _LOGGER.info("%s: No segments data found.", self.file_name)
+            LOGGER.info("%s: No segments data found.", self.file_name)
             return room_id, img_np_array
 
-        _LOGGER.info("%s: Drawing segments.", self.file_name)
+        LOGGER.info("%s: Drawing segments.", self.file_name)
         for pixels in segment_data:
             room_color = self.img_h.shared.rooms_colors[room_id]
             rooms_list.append(room_color)
@@ -211,9 +206,8 @@ class ImageDraw:
                 self.data.get_rrm_charger_position(m_json)
             )
         except KeyError as e:
-            _LOGGER.warning("%s: No charger position found: %s", self.file_name, e)
+            LOGGER.warning("%s: No charger position found: %s", self.file_name, e)
         else:
-            _LOGGER.debug("Charger position: %s", charger_pos)
             if charger_pos:
                 charger_pos_dictionary = {
                     "x": (charger_pos[0] * 10),
@@ -239,7 +233,7 @@ class ImageDraw:
             zone_clean = None
 
         if zone_clean:
-            _LOGGER.info("%s: Got zones.", self.file_name)
+            LOGGER.info("%s: Got zones.", self.file_name)
             return await self.draw.zones(np_array, zone_clean, color_zone_clean)
         return np_array
 
@@ -253,7 +247,7 @@ class ImageDraw:
             virtual_walls = None
 
         if virtual_walls:
-            _LOGGER.info("%s: Got virtual walls.", self.file_name)
+            LOGGER.info("%s: Got virtual walls.", self.file_name)
             np_array = await self.draw.draw_virtual_walls(
                 np_array, virtual_walls, color_no_go
             )
@@ -281,7 +275,7 @@ class ImageDraw:
                 self.data.rrm_valetudo_path_array(path_pixel["points"]), 2
             )
         except KeyError as e:
-            _LOGGER.warning(
+            LOGGER.warning(
                 "%s: Error extracting paths data: %s", self.file_name, str(e)
             )
         finally:
@@ -298,7 +292,7 @@ class ImageDraw:
         except (ValueError, KeyError):
             entity_dict = None
         else:
-            _LOGGER.info("%s: Got the points in the json.", self.file_name)
+            LOGGER.info("%s: Got the points in the json.", self.file_name)
         return entity_dict
 
     async def async_get_robot_position(self, m_json: JsonType) -> tuple | None:
@@ -311,17 +305,12 @@ class ImageDraw:
             robot_pos = self.data.rrm_coordinates_to_valetudo(robot_pos_data)
             angle = self.data.get_rrm_robot_angle(m_json)
         except (ValueError, KeyError):
-            _LOGGER.warning("%s No robot position found.", self.file_name)
+            LOGGER.warning("%s No robot position found.", self.file_name)
             return None, None, None
         finally:
             robot_position_angle = round(angle[0], 0)
             if robot_pos and robot_position_angle:
                 robot_position = robot_pos
-                _LOGGER.debug(
-                    "robot position: %s, robot angle: %s",
-                    str(robot_pos),
-                    str(robot_position_angle),
-                )
                 if self.img_h.rooms_pos is None:
                     self.img_h.robot_pos = {
                         "x": robot_position[0] * 10,
@@ -351,6 +340,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