valetudo-map-parser 0.1.10rc2__py3-none-any.whl → 0.1.10rc3__py3-none-any.whl

valetudo_map_parser/config/shared.py

@@ -304,7 +304,17 @@ class CameraSharedManager:
             trim_data = device_info.get("trims_data", DEFAULT_VALUES["trims_data"])
             instance.trims = TrimsData.from_dict(trim_data)
             # Robot size
-            instance.robot_size = device_info.get("robot_size", 25)
+            robot_size = device_info.get("robot_size", 25)
+            try:
+                robot_size = int(robot_size)
+            except (ValueError, TypeError):
+                robot_size = 25
+            # Clamp robot_size to [8, 25]
+            if robot_size < 8:
+                robot_size = 8
+            elif robot_size > 25:
+                robot_size = 25
+            instance.robot_size = robot_size
 
         except TypeError as ex:
             _LOGGER.warning(

valetudo_map_parser/config/types.py

@@ -81,6 +81,8 @@ class RoomStore:
                 instance = super(RoomStore, cls).__new__(cls)
                 instance.vacuum_id = vacuum_id
                 instance.vacuums_data = rooms_data or {}
+                instance.rooms_count = instance.get_rooms_count()
+                instance.floor = None
                 cls._instances[vacuum_id] = instance
             else:
                 if rooms_data is not None:
@@ -126,10 +128,10 @@ class UserLanguageStore:
         async with self._lock:
             self.user_languages[user_id] = language
 
-    async def get_user_language(self, user_id: str) -> str or None:
+    async def get_user_language(self, user_id: str) -> str:
         """Get the user language."""
         async with self._lock:
-            return self.user_languages.get(user_id, None)
+            return self.user_languages.get(user_id, "")
 
     async def get_all_languages(self):
         """Get all the user languages."""
@@ -197,13 +199,13 @@ class SnapshotStore:
 Color = Union[Tuple[int, int, int], Tuple[int, int, int, int]]
 Colors = Dict[str, Color]
 CalibrationPoints = list[dict[str, Any]]
-RobotPosition = dict[str, int | float]
+RobotPosition = Optional[dict[str, Union[int | float]]]
 ChargerPosition = dict[str, Any]
 RoomsProperties = dict[str, RoomProperty]
 ImageSize = dict[str, int | list[int]]
+Size = dict[str, int]
 JsonType = Any  # json.loads() return type is Any
 PilPNG = Image.Image  # Keep for backward compatibility
-WebPBytes = bytes  # WebP image as bytes
 NumpyArray = np.ndarray
 Point = Tuple[int, int]
 

valetudo_map_parser/config/utils.py

@@ -15,16 +15,17 @@ 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,
+    Size,
     NumpyArray,
     PilPNG,
     RobotPosition,
-    WebPBytes,
 )
 from ..map_data import HyperMapData
+from .async_utils import AsyncNumPy
 
 
 @dataclass
@@ -74,12 +75,16 @@ class BaseHandler:
         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
+        self.enhanced_draw: Optional[EnhancedDrawable] = 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
 
@@ -88,7 +93,7 @@ class BaseHandler:
         m_json: dict | None,
         destinations: list | None = None,
         bytes_format: bool = False,
-    ) -> PilPNG | None:
+    ) -> PilPNG | bytes:
         """
         Unified async function to get PIL image from JSON data for both Hypfer and Rand256 handlers.
 
@@ -116,14 +121,12 @@ 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(
@@ -152,11 +155,9 @@ class BaseHandler:
                     )
                 # 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()
+                    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())
                 return new_image
@@ -164,6 +165,8 @@ class BaseHandler:
                 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")
@@ -181,11 +184,23 @@ class BaseHandler:
                 self.shared.last_image if hasattr(self.shared, "last_image") else None
             )
 
+    def prepare_resize_params(self, pil_img: PilPNG, rand: bool=False) -> ResizeParams:
+        """Prepare resize parameters for image resizing."""
+        return ResizeParams(
+            pil_img=pil_img,
+            width=self.shared.image_ref_width,  # pil_img.width,
+            height=self.shared.image_ref_height,  # pil_img.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
 
@@ -203,6 +218,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:
@@ -382,17 +421,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 ["crop_img_size is not set"]
+            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
@@ -406,7 +449,12 @@ 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 ["crop_area is not set"]
+            return [
+                {"x": 0, "y": 0},
+                {"x": 0, "y": 0},
+                {"x": 0, "y": 0},
+                {"x": 0, "y": 0},
+            ]
         # get_calibration_data
         vacuum_points = [
             {
@@ -499,7 +547,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
@@ -520,7 +569,8 @@ class BaseHandler:
                 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
@@ -562,8 +612,7 @@ async def async_resize_image(params: ResizeParams):
     if params.aspect_ratio == "None":
         return params.pil_img
     if params.aspect_ratio != "None":
-        wsf, hsf = [int(x) for x in params.aspect_ratio.split(",")]
-
+        wsf, hsf = [int(x) for x in params.aspect_ratio.split(":")]
 
         if wsf == 0 or hsf == 0 or params.width <= 0 or params.height <= 0:
             LOGGER.warning(
@@ -595,19 +644,6 @@ async def async_resize_image(params: ResizeParams):
     return params.pil_img
 
 
-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, #pil_img.width,
-        height=handler.shared.image_ref_height, # pil_img.height,
-        aspect_ratio=handler.shared.image_aspect_ratio,
-        crop_size=handler.crop_img_size,
-        offset_func=handler.async_map_coordinates_offset,
-        is_rand=rand,
-    )
-
-
 def initialize_drawing_config(handler):
     """
     Initialize drawing configuration from device_info.
@@ -761,6 +797,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.
@@ -917,83 +998,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.
-
-    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 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()
 
 
-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)

valetudo_map_parser/hypfer_draw.py

@@ -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:
@@ -243,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
@@ -422,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:
@@ -462,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,
@@ -530,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(

valetudo_map_parser/hypfer_handler.py

@@ -12,13 +12,13 @@ import numpy as np
 
 from PIL import Image
 
-from .config.async_utils import AsyncNumPy, AsyncPIL
+from .config.async_utils import AsyncPIL
 
 # from .config.auto_crop import AutoCrop
 from mvcrender.autocrop import AutoCrop
 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,
@@ -26,15 +26,11 @@ from .config.types import (
     Colors,
     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
@@ -102,14 +98,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 = {
@@ -375,8 +369,6 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                     int(self.shared.image_rotate),
                     self.zooming,
                 )
-                # self.crop_img_size = [img_np_array.shape[1], img_np_array.shape[0]]
-                # LOGGER.info("%s: Image size: %s", self.file_name, self.crop_img_size)
             # If the image is None return None and log the error.
             if img_np_array is None:
                 LOGGER.warning("%s: Image array is None.", self.file_name)
@@ -387,27 +379,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
-                    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
-                    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.",
@@ -447,42 +428,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

valetudo_map_parser/rand256_handler.py

@@ -13,7 +13,7 @@ from typing import Any
 
 import numpy as np
 
-from .config.async_utils import AsyncNumPy, AsyncPIL
+from .config.async_utils import AsyncPIL
 
 # from .config.auto_crop import AutoCrop
 from mvcrender.autocrop import AutoCrop
@@ -28,14 +28,11 @@ from .config.types import (
     RobotPosition,
     RoomsProperties,
     RoomStore,
-    WebPBytes,
 )
 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
@@ -136,13 +133,11 @@ class ReImageHandler(BaseHandler, AutoCrop):
         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)
@@ -177,17 +172,10 @@ 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(
@@ -379,7 +367,7 @@ class ReImageHandler(BaseHandler, AutoCrop):
             )
             return pil_img
         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)
         return pil_img
 
@@ -395,51 +383,6 @@ class ReImageHandler(BaseHandler, AutoCrop):
             )
         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:
@@ -449,7 +392,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,
@@ -531,7 +474,7 @@ class ReImageHandler(BaseHandler, AutoCrop):
             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,
@@ -590,32 +533,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-0.1.10rc2.dist-info → valetudo_map_parser-0.1.10rc3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: valetudo-map-parser
-Version: 0.1.10rc2
+Version: 0.1.10rc3
 Summary: A Python library to parse Valetudo map data returning a PIL Image object.
 License: Apache-2.0
 License-File: LICENSE

{valetudo_map_parser-0.1.10rc2.dist-info → valetudo_map_parser-0.1.10rc3.dist-info}/RECORD

@@ -16,21 +16,21 @@ valetudo_map_parser/config/fonts/NotoSansCJKhk-VF.ttf,sha256=xIXXLKCJzmWoPEg8Hdv
 valetudo_map_parser/config/fonts/NotoSansKhojki.ttf,sha256=XJWzSmpN-Ql6jTfTvFojP_JkCHOztQvixQc1_7hPWrc,107388
 valetudo_map_parser/config/optimized_element_map.py,sha256=52BCnkvVv9bre52LeVIfT8nhnEIpc0TuWTv1xcNu0Rk,15744
 valetudo_map_parser/config/rand256_parser.py,sha256=LU3y7XvRRQxVen9iwom0dOaDnJJvhZdg97NqOYRZFas,16279
-valetudo_map_parser/config/shared.py,sha256=Sm5oWH0rmRMs0dBbGl5t7AxYyGvxKqEAR2RaCWLj3DY,12869
+valetudo_map_parser/config/shared.py,sha256=lvO3gz7aIVNCJ_K27S2Eh2yZcc5vdHI3WNG1KnyFOdg,13213
 valetudo_map_parser/config/status_text/status_text.py,sha256=PaynYW11vXH_vhDxhZrR9j-xeDrCxbB6YQQtN-kcaxQ,4052
 valetudo_map_parser/config/status_text/translations.py,sha256=mmPbJkl_2A59w49wnesQf3ocXqwZxBsrqNX-yt5FSCQ,9132
-valetudo_map_parser/config/types.py,sha256=lxk9NE3qcgVins6MdOXmIz0fKlO3TIeHWtP--34Srtg,17303
-valetudo_map_parser/config/utils.py,sha256=z4LorK6ZAZf1SvodJPBhNLfwLFgaLyPZVmJlzICA6uY,34870
-valetudo_map_parser/hypfer_draw.py,sha256=jui31k0hh7G0z2OV7pvpes4uXH6x-BHjJW83icdBlF4,25313
-valetudo_map_parser/hypfer_handler.py,sha256=Q51Uqi9lCvS8dP30VsEi_Enz8eZabA3C9V1-3h1QhVM,23079
+valetudo_map_parser/config/types.py,sha256=WfmTy8gPFU45ILLgqY20xeblHHmoWzeyVlPTD-N_cdo,17395
+valetudo_map_parser/config/utils.py,sha256=GG3WGgSK6W8XRTa2dpA3eEmQDc4tWgKq7Bbqf1SOpAM,36489
+valetudo_map_parser/hypfer_draw.py,sha256=4zajujSOvtpRI_GMlmlioM3mDo19MvuOP861LhZmVlw,22495
+valetudo_map_parser/hypfer_handler.py,sha256=bGqeOyrBp8swJAXnMlIqlpYaS4yf98F_qwoKe1ksu4Y,20607
 valetudo_map_parser/hypfer_rooms_handler.py,sha256=NkpOA6Gdq-2D3lLAxvtNuuWMvPXHxeMY2TO5RZLSHlU,22652
 valetudo_map_parser/map_data.py,sha256=gVW_QhUcz-fZOM1ltSynTxZRHgu7yGjvZp8zUfd0ClA,27253
 valetudo_map_parser/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-valetudo_map_parser/rand256_handler.py,sha256=6zea23fBc_5qfo1Vbt4MzuMS5ChE5IwDrWwzOqpSqH0,25249
+valetudo_map_parser/rand256_handler.py,sha256=tWTxWef-FTIs4XaEy7W-m88ABQYC8xPZUZFrBBCE2Rk,21603
 valetudo_map_parser/reimg_draw.py,sha256=a93UPwcVl5y9mXMY5DsNWD4_pXzm1QhC_n_WOokhEAE,12534
 valetudo_map_parser/rooms_handler.py,sha256=tE8BrXcdL0SeFAYsdFvjR3NVDfDi2RPKnXw9jD1e5k8,17494
-valetudo_map_parser-0.1.10rc2.dist-info/METADATA,sha256=J1_07W3Qu2VJSDhhHsQckGJ3Uhq7jBSO_6Z--oMsB70,3404
-valetudo_map_parser-0.1.10rc2.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-valetudo_map_parser-0.1.10rc2.dist-info/licenses/LICENSE,sha256=Lh-qBbuRV0-jiCIBhfV7NgdwFxQFOXH3BKOzK865hRs,10480
-valetudo_map_parser-0.1.10rc2.dist-info/licenses/NOTICE.txt,sha256=5lTOuWiU9aiEnJ2go8sc7lTJ7ntMBx0g0GFnNrswCY4,2533
-valetudo_map_parser-0.1.10rc2.dist-info/RECORD,,
+valetudo_map_parser-0.1.10rc3.dist-info/METADATA,sha256=ngK2oSwoYYlvLyWbXBheMS-0-G6T7I7OjCBDpVoXTbc,3404
+valetudo_map_parser-0.1.10rc3.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+valetudo_map_parser-0.1.10rc3.dist-info/licenses/LICENSE,sha256=Lh-qBbuRV0-jiCIBhfV7NgdwFxQFOXH3BKOzK865hRs,10480
+valetudo_map_parser-0.1.10rc3.dist-info/licenses/NOTICE.txt,sha256=5lTOuWiU9aiEnJ2go8sc7lTJ7ntMBx0g0GFnNrswCY4,2533
+valetudo_map_parser-0.1.10rc3.dist-info/RECORD,,