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

valetudo_map_parser/config/utils.py

@@ -1,27 +1,29 @@
 """Utility code for the valetudo map parser."""
 
 import datetime
-from time import time
 import hashlib
+import io
 import json
 from dataclasses import dataclass
-from typing import Callable, List, Optional
-import io
+from time import time
+from typing import Callable, List, Optional, Tuple
 
 import numpy as np
 from PIL import Image, ImageOps
 
+from ..map_data import HyperMapData
+from .async_utils import AsyncNumPy
 from .drawable import Drawable
 from .drawable_elements import DrawingConfig
-from .enhanced_drawable import EnhancedDrawable
+from .status_text.status_text import StatusText
 from .types import (
     LOGGER,
     ChargerPosition,
-    ImageSize,
+    Destinations,
     NumpyArray,
     PilPNG,
     RobotPosition,
-    WebPBytes,
+    Size,
 )
 
 
@@ -69,24 +71,27 @@ class BaseHandler:
         self.crop_img_size = [0, 0]
         self.offset_x = 0
         self.offset_y = 0
-        self.crop_area = None
+        self.crop_area = [0, 0, 0, 0]
         self.zooming = False
         self.async_resize_images = async_resize_image
+        # Drawing components are initialized by initialize_drawing_config in handlers
+        self.drawing_config: Optional[DrawingConfig] = None
+        self.draw: Optional[Drawable] = None
 
     def get_frame_number(self) -> int:
         """Return the frame number of the image."""
         return self.frame_number
 
-    def get_robot_position(self) -> RobotPosition | None:
+    def get_robot_position(self) -> RobotPosition:
         """Return the robot position."""
         return self.robot_pos
 
     async def async_get_image(
         self,
         m_json: dict | None,
-        destinations: list | None = None,
+        destinations: Destinations | None = None,
         bytes_format: bool = False,
-    ) -> PilPNG | None:
+    ) -> Tuple[PilPNG | bytes, dict]:
         """
         Unified async function to get PIL image from JSON data for both Hypfer and Rand256 handlers.
 
@@ -99,7 +104,9 @@ 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
-        @return: PIL Image or None
+        @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 and data dictionary
         """
         try:
             # Backup current image to last_image before processing new one
@@ -112,13 +119,13 @@ class BaseHandler:
                 new_image = await self.get_image_from_rrm(
                     m_json=m_json,
                     destinations=destinations,
-                    return_webp=False,  # Always return PIL Image
                 )
+
             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
                 )
             else:
                 LOGGER.warning(
@@ -133,36 +140,47 @@ class BaseHandler:
 
             # Store the new image in shared data
             if new_image is not None:
+                # Update shared data
+                await self._async_update_shared_data(destinations)
                 self.shared.new_image = new_image
-
+                # Add text to the image
+                if self.shared.show_vacuum_state:
+                    text_editor = StatusText(self.shared)
+                    img_text = await text_editor.get_status_text(new_image)
+                    Drawable.status_text(
+                        new_image,
+                        img_text[1],
+                        self.shared.user_colors[8],
+                        img_text[0],
+                        self.shared.vacuum_status_font,
+                        self.shared.vacuum_status_position,
+                    )
                 # Convert to binary (PNG bytes) if requested
                 if bytes_format:
-                    with io.BytesIO() as buf:
-                        new_image.save(buf, format="PNG", compress_level=1)
-                        self.shared.binary_image = buf.getvalue()
-                    LOGGER.debug(
-                        "%s: Binary image conversion completed", self.file_name
-                    )
+                    self.shared.binary_image = pil_to_png_bytes(new_image)
                 else:
-                    self.shared.binary_image = None
+                    self.shared.binary_image = pil_to_png_bytes(self.shared.last_image)
                 # Update the timestamp with current datetime
                 self.shared.image_last_updated = datetime.datetime.fromtimestamp(time())
-                LOGGER.debug(
-                    "%s: Image processed and stored in shared data", self.file_name
-                )
-                return new_image
+                LOGGER.debug("%s: Frame Completed.", self.file_name)
+                data = {}
+                if bytes_format:
+                    data = self.shared.to_dict()
+                return new_image, data
             else:
                 LOGGER.warning(
                     "%s: Failed to generate image from JSON data", self.file_name
                 )
+                if bytes_format and hasattr(self.shared, "last_image"):
+                    return pil_to_png_bytes(self.shared.last_image), {}
                 return (
                     self.shared.last_image
                     if hasattr(self.shared, "last_image")
                     else None
-                )
+                ), {}
 
         except Exception as e:
-            LOGGER.error(
+            LOGGER.warning(
                 "%s: Error in async_get_image: %s",
                 self.file_name,
                 str(e),
@@ -172,11 +190,71 @@ class BaseHandler:
                 self.shared.last_image if hasattr(self.shared, "last_image") else None
             )
 
+    async def _async_update_shared_data(self, destinations: Destinations | None = None):
+        """Update the shared data with the latest information."""
+
+        if hasattr(self, "get_rooms_attributes") and (
+            self.shared.map_rooms is None and destinations is not None
+        ):
+            self.shared.map_rooms = await self.get_rooms_attributes(destinations)
+            if self.shared.map_rooms:
+                LOGGER.debug("%s: Rand256 attributes rooms updated", self.file_name)
+
+
+        if hasattr(self, "async_get_rooms_attributes") and (
+            self.shared.map_rooms is None
+        ):
+            if self.shared.map_rooms is None:
+                self.shared.map_rooms = await self.async_get_rooms_attributes()
+                if self.shared.map_rooms:
+                    LOGGER.debug("%s: Hyper attributes rooms updated", self.file_name)
+
+        if (
+            hasattr(self, "get_calibration_data")
+            and self.shared.attr_calibration_points is None
+        ):
+            self.shared.attr_calibration_points = self.get_calibration_data(
+                self.shared.image_rotate
+            )
+
+        if not self.shared.image_size:
+            self.shared.image_size = self.get_img_size()
+
+        self.shared.vac_json_id = self.get_json_id()
+
+        if not self.shared.charger_position:
+            self.shared.charger_position = self.get_charger_position()
+
+        self.shared.current_room = self.get_robot_position()
+
+    def prepare_resize_params(
+        self, pil_img: PilPNG, rand: bool = False
+    ) -> ResizeParams:
+        """Prepare resize parameters for image resizing."""
+        if self.shared.image_rotate in [0, 180]:
+            width, height = pil_img.size
+        else:
+            height, width = pil_img.size
+        LOGGER.debug(
+            "Shared PIL image size: %s x %s",
+            self.shared.image_ref_width,
+            self.shared.image_ref_height,
+        )
+        return ResizeParams(
+            pil_img=pil_img,
+            width=width,
+            height=height,
+            aspect_ratio=self.shared.image_aspect_ratio,
+            crop_size=self.crop_img_size,
+            offset_func=self.async_map_coordinates_offset,
+            is_rand=rand,
+        )
+
     def get_charger_position(self) -> ChargerPosition | None:
         """Return the charger position."""
         return self.charger_pos
 
-    def get_img_size(self) -> ImageSize | None:
+    def get_img_size(self) -> Size | None:
         """Return the size of the image."""
         return self.img_size
 
@@ -194,6 +272,30 @@ class BaseHandler:
             or self.shared.image_aspect_ratio != "None"
         )
 
+    # Element selection methods centralized here
+    def enable_element(self, element_code):
+        """Enable drawing of a specific element."""
+        if hasattr(self, "drawing_config") and self.drawing_config is not None:
+            self.drawing_config.enable_element(element_code)
+
+    def disable_element(self, element_code):
+        """Disable drawing of a specific element."""
+        manage_drawable_elements(self, "disable", element_code=element_code)
+
+    def set_elements(self, element_codes: list):
+        """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, property_name: str, value):
+        """Set a drawing property for an element."""
+        manage_drawable_elements(
+            self,
+            "set_property",
+            element_code=element_code,
+            property_name=property_name,
+            value=value,
+        )
+
     def _set_image_offset_ratio_1_1(
         self, width: int, height: int, rand256: Optional[bool] = False
     ) -> None:
@@ -214,12 +316,6 @@ class BaseHandler:
             elif rotation in [90, 270]:
                 self.offset_y = (self.crop_img_size[0] - width) // 2
                 self.offset_x = self.crop_img_size[1] - height
-        LOGGER.debug(
-            "%s Image Coordinates Offsets (x,y): %s. %s",
-            self.file_name,
-            self.offset_x,
-            self.offset_y,
-        )
 
     def _set_image_offset_ratio_2_1(
         self, width: int, height: int, rand256: Optional[bool] = False
@@ -242,13 +338,6 @@ class BaseHandler:
                 self.offset_x = width - self.crop_img_size[0]
                 self.offset_y = height - self.crop_img_size[1]
 
-        LOGGER.debug(
-            "%s Image Coordinates Offsets (x,y): %s. %s",
-            self.file_name,
-            self.offset_x,
-            self.offset_y,
-        )
-
     def _set_image_offset_ratio_3_2(
         self, width: int, height: int, rand256: Optional[bool] = False
     ) -> None:
@@ -273,13 +362,6 @@ class BaseHandler:
                 self.offset_y = (self.crop_img_size[0] - width) // 2
                 self.offset_x = self.crop_img_size[1] - height
 
-        LOGGER.debug(
-            "%s Image Coordinates Offsets (x,y): %s. %s",
-            self.file_name,
-            self.offset_x,
-            self.offset_y,
-        )
-
     def _set_image_offset_ratio_5_4(
         self, width: int, height: int, rand256: Optional[bool] = False
     ) -> None:
@@ -305,13 +387,6 @@ class BaseHandler:
                 self.offset_y = (self.crop_img_size[0] - width) // 2
                 self.offset_x = self.crop_img_size[1] - height
 
-        LOGGER.debug(
-            "%s Image Coordinates Offsets (x,y): %s. %s",
-            self.file_name,
-            self.offset_x,
-            self.offset_y,
-        )
-
     def _set_image_offset_ratio_9_16(
         self, width: int, height: int, rand256: Optional[bool] = False
     ) -> None:
@@ -333,13 +408,6 @@ class BaseHandler:
                 self.offset_x = width - self.crop_img_size[0]
                 self.offset_y = height - self.crop_img_size[1]
 
-        LOGGER.debug(
-            "%s Image Coordinates Offsets (x,y): %s. %s",
-            self.file_name,
-            self.offset_x,
-            self.offset_y,
-        )
-
     def _set_image_offset_ratio_16_9(
         self, width: int, height: int, rand256: Optional[bool] = False
     ) -> None:
@@ -361,13 +429,6 @@ class BaseHandler:
                 self.offset_x = width - self.crop_img_size[0]
                 self.offset_y = height - self.crop_img_size[1]
 
-        LOGGER.debug(
-            "%s Image Coordinates Offsets (x,y): %s. %s",
-            self.file_name,
-            self.offset_x,
-            self.offset_y,
-        )
-
     async def async_map_coordinates_offset(
         self, params: OffsetParams
     ) -> tuple[int, int]:
@@ -414,15 +475,21 @@ class BaseHandler:
             return hashlib.sha256(data_json.encode()).hexdigest()
         return None
 
-    @staticmethod
-    async def async_copy_array(original_array: NumpyArray) -> NumpyArray:
-        """Copy the array."""
-        return NumpyArray.copy(original_array)
+    async def async_copy_array(self, original_array: NumpyArray) -> NumpyArray:
+        """Copy the array using AsyncNumPy to yield control to the event loop."""
+        return await AsyncNumPy.async_copy(original_array)
 
     def get_map_points(
         self,
     ) -> list[dict[str, int] | dict[str, int] | dict[str, int] | dict[str, int]]:
         """Return the map points."""
+        if not self.crop_img_size:
+            return [
+                {"x": 0, "y": 0},
+                {"x": 0, "y": 0},
+                {"x": 0, "y": 0},
+                {"x": 0, "y": 0},
+            ]
         return [
             {"x": 0, "y": 0},  # Top-left corner 0
             {"x": self.crop_img_size[0], "y": 0},  # Top-right corner 1
@@ -435,7 +502,13 @@ class BaseHandler:
 
     def get_vacuum_points(self, rotation_angle: int) -> list[dict[str, int]]:
         """Calculate the calibration points based on the rotation angle."""
-
+        if not self.crop_area:
+            return [
+                {"x": 0, "y": 0},
+                {"x": 0, "y": 0},
+                {"x": 0, "y": 0},
+                {"x": 0, "y": 0},
+            ]
         # get_calibration_data
         vacuum_points = [
             {
@@ -528,7 +601,8 @@ class BaseHandler:
 
         return vacuum_points
 
-    async def async_zone_propriety(self, zones_data) -> dict:
+    @staticmethod
+    async def async_zone_propriety(zones_data) -> dict:
         """Get the zone propriety"""
         zone_properties = {}
         id_count = 1
@@ -546,10 +620,11 @@ class BaseHandler:
                 }
                 id_count += 1
             if id_count > 1:
-                LOGGER.debug("%s: Zones Properties updated.", self.file_name)
+                pass
         return zone_properties
 
-    async def async_points_propriety(self, points_data) -> dict:
+    @staticmethod
+    async def async_points_propriety(points_data) -> dict:
         """Get the point propriety"""
         point_properties = {}
         id_count = 1
@@ -567,7 +642,7 @@ class BaseHandler:
                 }
                 id_count += 1
             if id_count > 1:
-                LOGGER.debug("%s: Point Properties updated.", self.file_name)
+                pass
         return point_properties
 
     @staticmethod
@@ -585,8 +660,14 @@ class BaseHandler:
 
 async def async_resize_image(params: ResizeParams):
     """Resize the image to the given dimensions and aspect ratio."""
-    if params.aspect_ratio:
-        wsf, hsf = [int(x) for x in params.aspect_ratio.split(",")]
+    LOGGER.debug("Resizing image to aspect ratio: %s", params.aspect_ratio)
+    LOGGER.debug("Original image size: %s x %s", params.width, params.height)
+    LOGGER.debug("Image crop size: %s", params.crop_size)
+    if params.aspect_ratio == "None":
+        return params.pil_img
+    if params.aspect_ratio != "None":
+        ratio = params.aspect_ratio.replace(",", ":").replace(" ", "")
+        wsf, hsf = [int(x) for x in ratio.split(":")]
 
         if wsf == 0 or hsf == 0 or params.width <= 0 or params.height <= 0:
             LOGGER.warning(
@@ -609,29 +690,13 @@ async def async_resize_image(params: ResizeParams):
             new_width = params.pil_img.width
             new_height = int(params.pil_img.width / new_aspect_ratio)
 
-        LOGGER.debug("Resizing image to aspect ratio: %s, %s", wsf, hsf)
-        LOGGER.debug("New image size: %s x %s", new_width, new_height)
-
         if (params.crop_size is not None) and (params.offset_func is not None):
             offset = OffsetParams(wsf, hsf, new_width, new_height, params.is_rand)
             params.crop_size[0], params.crop_size[1] = await params.offset_func(offset)
-
+        LOGGER.debug("New image size: %r * %r", new_width, new_height)
         return ImageOps.pad(params.pil_img, (new_width, new_height))
 
-    return ImageOps.pad(params.pil_img, (params.width, params.height))
-
-
-def prepare_resize_params(handler, pil_img, rand):
-    """Prepare resize parameters for image resizing."""
-    return ResizeParams(
-        pil_img=pil_img,
-        width=handler.shared.image_ref_width,
-        height=handler.shared.image_ref_height,
-        aspect_ratio=handler.shared.image_aspect_ratio,
-        crop_size=handler.crop_img_size,
-        offset_func=handler.async_map_coordinates_offset,
-        is_rand=rand,
-    )
+    return params.pil_img
 
 
 def initialize_drawing_config(handler):
@@ -642,7 +707,7 @@ def initialize_drawing_config(handler):
         handler: The handler instance with shared data and file_name attributes
 
     Returns:
-        Tuple of (DrawingConfig, Drawable, EnhancedDrawable)
+        Tuple of (DrawingConfig, Drawable)
     """
 
     # Initialize drawing configuration
@@ -654,11 +719,10 @@ def initialize_drawing_config(handler):
     ):
         drawing_config.update_from_device_info(handler.shared.device_info)
 
-    # Initialize both drawable systems for backward compatibility
-    draw = Drawable()  # Legacy drawing utilities
-    enhanced_draw = EnhancedDrawable(drawing_config)  # New enhanced drawing system
+    # Initialize drawing utilities
+    draw = Drawable()
 
-    return drawing_config, draw, enhanced_draw
+    return drawing_config, draw
 
 
 def blend_colors(base_color, overlay_color):
@@ -787,6 +851,51 @@ def manage_drawable_elements(
         handler.drawing_config.set_property(element_code, property_name, value)
 
 
+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
+
+
 def handle_room_outline_error(file_name, room_id, error):
     """
     Handle errors during room outline extraction.
@@ -943,83 +1052,14 @@ async def async_extract_room_outline(
         return rect_outline
 
 
-async def numpy_to_webp_bytes(
-    img_np_array: np.ndarray, quality: int = 85, lossless: bool = False
-) -> WebPBytes:
-    """
-    Convert NumPy array directly to WebP bytes.
+def pil_to_png_bytes(pil_img: Image.Image, compress_level: int = 1) -> bytes:
+    """Convert PIL Image to PNG bytes asynchronously."""
+    with io.BytesIO() as buf:
+        pil_img.save(buf, format="PNG", compress_level=compress_level)
+        return buf.getvalue()
 
-    Args:
-        img_np_array: RGBA NumPy array
-        quality: WebP quality (0-100, ignored if lossless=True)
-        lossless: Use lossless WebP compression
 
-    Returns:
-        WebP image as bytes
-    """
-    # Convert NumPy array to PIL Image
-    pil_img = Image.fromarray(img_np_array, mode="RGBA")
-
-    # Create bytes buffer
-    webp_buffer = io.BytesIO()
-
-    # Save as WebP - PIL images should use lossless=True for best results
-    pil_img.save(
-        webp_buffer,
-        format="WEBP",
-        lossless=True,  # Always lossless for PIL images
-        method=1,  # Fastest method for lossless
-    )
-
-    # Get bytes and cleanup
-    webp_bytes = webp_buffer.getvalue()
-    webp_buffer.close()
-
-    return webp_bytes
-
-
-async def pil_to_webp_bytes(
-    pil_img: Image.Image, quality: int = 85, lossless: bool = False
-) -> bytes:
-    """
-    Convert PIL Image to WebP bytes.
-
-    Args:
-        pil_img: PIL Image object
-        quality: WebP quality (0-100, ignored if lossless=True)
-        lossless: Use lossless WebP compression
-
-    Returns:
-        WebP image as bytes
-    """
-    # Create bytes buffer
-    webp_buffer = io.BytesIO()
-
-    # Save as WebP - PIL images should use lossless=True for best results
-    pil_img.save(
-        webp_buffer,
-        format="WEBP",
-        lossless=True,  # Always lossless for PIL images
-        method=1,  # Fastest method for lossless
-    )
-
-    # Get bytes and cleanup
-    webp_bytes = webp_buffer.getvalue()
-    webp_buffer.close()
-
-    return webp_bytes
-
-
-def webp_bytes_to_pil(webp_bytes: bytes) -> Image.Image:
-    """
-    Convert WebP bytes back to PIL Image for display or further processing.
-
-    Args:
-        webp_bytes: WebP image as bytes
-
-    Returns:
-        PIL Image object
-    """
-    webp_buffer = io.BytesIO(webp_bytes)
-    pil_img = Image.open(webp_buffer)
-    return pil_img
+def png_bytes_to_pil(png_bytes: bytes) -> Image.Image:
+    """Convert PNG bytes back to a PIL Image."""
+    png_buffer = io.BytesIO(png_bytes)
+    return Image.open(png_buffer)