valetudo-map-parser 0.1.8__py3-none-any.whl → 0.1.9a1__py3-none-any.whl

valetudo_map_parser/rand25_handler.py

@@ -2,147 +2,131 @@
 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: v2024.12.0
+Version: 0.1.9.b42
 """
 
 from __future__ import annotations
 
 import logging
 import uuid
+from typing import Any
 
-from PIL import Image, ImageOps
+import numpy as np
+from PIL import Image
 
-from .config.types import COLORS, DEFAULT_IMAGE_SIZE, DEFAULT_PIXEL_SIZE
-from .config.types import Colors, JsonType, PilPNG, RobotPosition, RoomsProperties
 from .config.auto_crop import AutoCrop
-from .images_utils import ImageUtils as ImUtils
-from .map_data import ImageData
+from .config.drawable_elements import DrawableElement
+from .config.types import (
+    COLORS,
+    DEFAULT_IMAGE_SIZE,
+    DEFAULT_PIXEL_SIZE,
+    Colors,
+    JsonType,
+    PilPNG,
+    RobotPosition,
+    RoomsProperties,
+    RoomStore,
+)
+from .config.utils import (
+    BaseHandler,
+    initialize_drawing_config,
+    manage_drawable_elements,
+    prepare_resize_params,
+)
+from .map_data import RandImageData
 from .reimg_draw import ImageDraw
+from .rooms_handler import RandRoomsHandler
+
 
 _LOGGER = logging.getLogger(__name__)
 
 
 # noinspection PyTypeChecker
-class ReImageHandler(object):
+class ReImageHandler(BaseHandler, AutoCrop):
     """
     Image Handler for Valetudo Re Vacuums.
     """
 
-    def __init__(self, camera_shared):
+    def __init__(self, shared_data):
+        BaseHandler.__init__(self)
+        self.shared = shared_data  # Shared data
+        AutoCrop.__init__(self, self)
         self.auto_crop = None  # Auto crop flag
         self.segment_data = None  # Segment data
         self.outlines = None  # Outlines data
         self.calibration_data = None  # Calibration data
-        self.charger_pos = None  # Charger position
-        self.crop_area = None  # Crop area
-        self.crop_img_size = None  # Crop image size
-        self.data = ImageData  # Image Data
-        self.frame_number = 0  # Image Frame number
-        self.max_frames = 1024
+        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.go_to = None  # Go to position data
         self.img_base_layer = None  # Base image layer
-        self.img_rotate = camera_shared.image_rotate  # Image rotation
-        self.img_size = None  # Image size
-        self.json_data = None  # Json data
-        self.json_id = None  # Json id
-        self.path_pixels = None  # Path pixels data
-        self.robot_in_room = None  # Robot in room data
-        self.robot_pos = None  # Robot position
+        self.img_rotate = shared_data.image_rotate  # Image rotation
         self.room_propriety = None  # Room propriety data
-        self.rooms_pos = None  # Rooms position data
-        self.shared = camera_shared  # Shared data
         self.active_zones = None  # Active zones
-        self.trim_down = None  # Trim down
-        self.trim_left = None  # Trim left
-        self.trim_right = None  # Trim right
-        self.trim_up = None  # Trim up
-        self.zooming = False  # Zooming flag
         self.file_name = self.shared.file_name  # File name
-        self.offset_x = 0  # offset x for the aspect ratio.
-        self.offset_y = 0  # offset y for the aspect ratio.
-        self.offset_top = self.shared.offset_top  # offset top
-        self.offset_bottom = self.shared.offset_down  # offset bottom
-        self.offset_left = self.shared.offset_left  # offset left
-        self.offset_right = self.shared.offset_right  # offset right
         self.imd = ImageDraw(self)  # Image Draw
-        self.imu = ImUtils(self)  # Image Utils
-        self.ac = AutoCrop(self)
+        self.rooms_handler = RandRoomsHandler(self.file_name, self.drawing_config)  # Room data handler
 
     async def extract_room_properties(
         self, json_data: JsonType, destinations: JsonType
     ) -> RoomsProperties:
         """Extract the room properties."""
-        unsorted_id = ImageData.get_rrm_segments_ids(json_data)
-        size_x, size_y = ImageData.get_rrm_image_size(json_data)
-        top, left = ImageData.get_rrm_image_position(json_data)
+        # unsorted_id = RandImageData.get_rrm_segments_ids(json_data)
+        size_x, size_y = RandImageData.get_rrm_image_size(json_data)
+        top, left = RandImageData.get_rrm_image_position(json_data)
         try:
             if not self.segment_data or not self.outlines:
                 (
                     self.segment_data,
                     self.outlines,
-                ) = await ImageData.async_get_rrm_segments(
+                ) = await RandImageData.async_get_rrm_segments(
                     json_data, size_x, size_y, top, left, True
                 )
+
             dest_json = destinations
-            room_data = dict(dest_json).get("rooms", [])
             zones_data = dict(dest_json).get("zones", [])
             points_data = dict(dest_json).get("spots", [])
-            room_id_to_data = {room["id"]: room for room in room_data}
+
+            # Use the RandRoomsHandler to extract room properties
+            room_properties = await self.rooms_handler.async_extract_room_properties(
+                json_data, dest_json
+            )
+
+            # Update self.rooms_pos from room_properties for compatibility with other methods
             self.rooms_pos = []
-            room_properties = {}
-            if self.outlines:
-                for id_x, room_id in enumerate(unsorted_id):
-                    if room_id in room_id_to_data:
-                        room_info = room_id_to_data[room_id]
-                        name = room_info.get("name")
-                        # Calculate x and y min/max from outlines
-                        x_min = self.outlines[id_x][0][0]
-                        x_max = self.outlines[id_x][1][0]
-                        y_min = self.outlines[id_x][0][1]
-                        y_max = self.outlines[id_x][1][1]
-                        corners = [
-                            (x_min, y_min),
-                            (x_max, y_min),
-                            (x_max, y_max),
-                            (x_min, y_max),
-                        ]
-                        # rand256 vacuums accept int(room_id) or str(name)
-                        # the card will soon support int(room_id) but the camera will send name
-                        # this avoids the manual change of the values in the card.
-                        self.rooms_pos.append(
-                            {
-                                "name": name,
-                                "corners": corners,
-                            }
-                        )
-                        room_properties[int(room_id)] = {
-                            "number": int(room_id),
-                            "outline": corners,
-                            "name": name,
-                            "x": (x_min + x_max) // 2,
-                            "y": (y_min + y_max) // 2,
-                        }
-                # get the zones and points data
-                zone_properties = await self.imu.async_zone_propriety(zones_data)
-                # get the points data
-                point_properties = await self.imu.async_points_propriety(points_data)
-
-                if room_properties != {}:
-                    if zone_properties != {}:
-                        _LOGGER.debug("Rooms and Zones, data extracted!")
-                    else:
-                        _LOGGER.debug("Rooms, data extracted!")
-                elif zone_properties != {}:
-                    _LOGGER.debug("Zones, data extracted!")
-                else:
-                    self.rooms_pos = None
-                    _LOGGER.debug(
-                        f"{self.file_name}: Rooms and Zones data not available!"
-                    )
-                return room_properties, zone_properties, point_properties
-        except Exception as e:
+            for room_id, room_data in room_properties.items():
+                self.rooms_pos.append(
+                    {"name": room_data["name"], "outline": room_data["outline"]}
+                )
+
+            # get the zones and points data
+            zone_properties = 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.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
+        except (RuntimeError, ValueError) as e:
             _LOGGER.debug(
-                f"No rooms Data or Error in extract_room_properties: {e}",
+                "No rooms Data or Error in extract_room_properties: %s",
+                e,
                 exc_info=True,
             )
             return None, None, None
@@ -160,164 +144,175 @@ class ReImageHandler(object):
 
         try:
             if (m_json is not None) and (not isinstance(m_json, tuple)):
-                _LOGGER.info(f"{self.file_name}: Composing the image for the camera.")
-                # buffer json data
+                _LOGGER.info("%s: Composing the image for the camera.", self.file_name)
                 self.json_data = m_json
-                # get the image size
                 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(f"Vacuum Data ID: {self.json_id}")
-                # get the robot position
+                _LOGGER.info("Vacuum Data ID: %s", self.json_id)
+
                 (
-                    robot_pos,
+                    img_np_array,
                     robot_position,
                     robot_position_angle,
-                ) = await self.imd.async_get_robot_position(m_json)
-                if self.frame_number == 0:
-                    room_id, img_np_array = await self.imd.async_draw_base_layer(
-                        m_json,
-                        size_x,
-                        size_y,
-                        colors["wall"],
-                        colors["zone_clean"],
-                        colors["background"],
-                        DEFAULT_PIXEL_SIZE,
-                    )
-                    _LOGGER.info(f"{self.file_name}: Completed base Layers")
-                    if (room_id > 0) and not self.room_propriety:
-                        self.room_propriety = await self.get_rooms_attributes(
-                            destinations
-                        )
-                        if self.rooms_pos:
-                            self.robot_pos = await self.async_get_robot_in_room(
-                                (robot_position[0] * 10),
-                                (robot_position[1] * 10),
-                                robot_position_angle,
-                            )
-                    self.img_base_layer = await self.imd.async_copy_array(img_np_array)
-
-                # If there is a zone clean we draw it now.
-                self.frame_number += 1
-                img_np_array = await self.imd.async_copy_array(self.img_base_layer)
-                _LOGGER.debug(f"{self.file_name}: Frame number {self.frame_number}")
-                if self.frame_number > 5:
-                    self.frame_number = 0
-                # All below will be drawn each time
-                # charger
-                img_np_array, self.charger_pos = await self.imd.async_draw_charger(
-                    img_np_array, m_json, colors["charger"]
-                )
-                # zone clean
-                img_np_array = await self.imd.async_draw_zones(
-                    m_json, img_np_array, colors["zone_clean"]
-                )
-                # virtual walls
-                img_np_array = await self.imd.async_draw_virtual_restrictions(
-                    m_json, img_np_array, colors["no_go"]
-                )
-                # draw path
-                img_np_array = await self.imd.async_draw_path(
-                    img_np_array, m_json, colors["move"]
-                )
-                # go to flag and predicted path
-                await self.imd.async_draw_go_to_flag(
-                    img_np_array, m_json, colors["go_to"]
-                )
-                # draw the robot
-                img_np_array = await self.imd.async_draw_robot_on_map(
-                    img_np_array, robot_position, robot_position_angle, colors["robot"]
+                ) = await self._setup_robot_and_image(
+                    m_json, size_x, size_y, colors, destinations
                 )
+
+                # Increment frame number
+                self.frame_number += 1
+                img_np_array = await self.async_copy_array(self.img_base_layer)
                 _LOGGER.debug(
-                    f"{self.file_name}:"
-                    f" Auto cropping the image with rotation {int(self.shared.image_rotate)}"
+                    "%s: Frame number %s", self.file_name, str(self.frame_number)
                 )
-                img_np_array = await self.ac.async_auto_trim_and_zoom_image(
-                    img_np_array,
-                    colors["background"],
-                    int(self.shared.margins),
-                    int(self.shared.image_rotate),
-                    self.zooming,
-                    rand256=True,
+                if self.frame_number > 5:
+                    self.frame_number = 0
+
+                # Draw map elements
+                img_np_array = await self._draw_map_elements(
+                    img_np_array, m_json, colors, robot_position, robot_position_angle
                 )
+
+                # Final adjustments
                 pil_img = Image.fromarray(img_np_array, mode="RGBA")
                 del img_np_array  # free memory
-                # reduce the image size if the zoomed image is bigger then the original.
-                if (
-                    self.shared.image_auto_zoom
-                    and self.shared.vacuum_state == "cleaning"
-                    and self.zooming
-                    and self.shared.image_zoom_lock_ratio
-                    or self.shared.image_aspect_ratio != "None"
-                ):
-                    width = self.shared.image_ref_width
-                    height = self.shared.image_ref_height
-                    if self.shared.image_aspect_ratio != "None":
-                        wsf, hsf = [
-                            int(x) for x in self.shared.image_aspect_ratio.split(",")
-                        ]
-                        _LOGGER.debug(f"Aspect Ratio: {wsf}, {hsf}")
-                        if wsf == 0 or hsf == 0:
-                            return pil_img
-                        new_aspect_ratio = wsf / hsf
-                        aspect_ratio = width / height
-                        if aspect_ratio > new_aspect_ratio:
-                            new_width = int(pil_img.height * new_aspect_ratio)
-                            new_height = pil_img.height
-                        else:
-                            new_width = pil_img.width
-                            new_height = int(pil_img.width / new_aspect_ratio)
-
-                        resized = ImageOps.pad(pil_img, (new_width, new_height))
-                        (
-                            self.crop_img_size[0],
-                            self.crop_img_size[1],
-                        ) = await self.async_map_coordinates_offset(
-                            wsf, hsf, new_width, new_height
-                        )
-                        _LOGGER.debug(
-                            f"{self.file_name}: Image Aspect Ratio ({wsf}, {hsf}): {new_width}x{new_height}"
-                        )
-                        _LOGGER.debug(f"{self.file_name}: Frame Completed.")
-                        return resized
-                    else:
-                        _LOGGER.debug(f"{self.file_name}: Frame Completed.")
-                        return ImageOps.pad(pil_img, (width, height))
-                else:
-                    _LOGGER.debug(f"{self.file_name}: Frame Completed.")
-                    return pil_img
+
+                return await self._finalize_image(pil_img)
+
         except (RuntimeError, RuntimeWarning) as e:
             _LOGGER.warning(
-                f"{self.file_name}: Error {e} during image creation.",
+                "%s: Runtime Error %s during image creation.",
+                self.file_name,
+                str(e),
                 exc_info=True,
             )
             return None
 
-    def get_frame_number(self) -> int:
-        """Return the frame number."""
-        return self.frame_number
+        # If we reach here without returning, return None
+        return None
+
+    async def _setup_robot_and_image(
+        self, m_json, size_x, size_y, colors, destinations
+    ):
+        (
+            _,
+            robot_position,
+            robot_position_angle,
+        ) = await self.imd.async_get_robot_position(m_json)
+
+        if self.frame_number == 0:
+            # Create element map for tracking what's drawn where
+            self.element_map = np.zeros((size_y, size_x), dtype=np.int32)
+            self.element_map[:] = DrawableElement.FLOOR
+
+            # Draw base layer if floor is enabled
+            if self.drawing_config.is_enabled(DrawableElement.FLOOR):
+                room_id, img_np_array = await self.imd.async_draw_base_layer(
+                    m_json,
+                    size_x,
+                    size_y,
+                    colors["wall"],
+                    colors["zone_clean"],
+                    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
+
+                if room_id > 0 and not self.room_propriety:
+                    self.room_propriety = await self.get_rooms_attributes(destinations)
+                    if self.rooms_pos:
+                        self.robot_pos = await self.async_get_robot_in_room(
+                            (robot_position[0] * 10),
+                            (robot_position[1] * 10),
+                            robot_position_angle,
+                        )
+                self.img_base_layer = await self.async_copy_array(img_np_array)
+            else:
+                # If floor is disabled, create an empty image
+                background_color = self.drawing_config.get_property(
+                    DrawableElement.FLOOR, "color", colors["background"]
+                )
+                img_np_array = await self.draw.create_empty_image(
+                    size_x, size_y, background_color
+                )
+                self.img_base_layer = await self.async_copy_array(img_np_array)
+        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 charger if enabled
+        if self.drawing_config.is_enabled(DrawableElement.CHARGER):
+            img_np_array, self.charger_pos = await self.imd.async_draw_charger(
+                img_np_array, m_json, colors["charger"]
+            )
 
-    def get_robot_position(self) -> any:
-        """Return the robot position."""
-        return self.robot_pos
+        # Draw zones if enabled
+        if self.drawing_config.is_enabled(DrawableElement.RESTRICTED_AREA):
+            img_np_array = await self.imd.async_draw_zones(
+                m_json, img_np_array, colors["zone_clean"]
+            )
 
-    def get_charger_position(self) -> any:
-        """Return the charger position."""
-        return self.charger_pos
+        # Draw virtual restrictions if enabled
+        if self.drawing_config.is_enabled(DrawableElement.VIRTUAL_WALL):
+            img_np_array = await self.imd.async_draw_virtual_restrictions(
+                m_json, img_np_array, colors["no_go"]
+            )
 
-    def get_img_size(self) -> any:
-        """Return the image size."""
-        return self.img_size
+        # Draw path if enabled
+        if self.drawing_config.is_enabled(DrawableElement.PATH):
+            img_np_array = await self.imd.async_draw_path(
+                img_np_array, m_json, colors["move"]
+            )
+
+        # Draw go-to flag if enabled
+        if self.drawing_config.is_enabled(DrawableElement.GO_TO_TARGET):
+            img_np_array = await self.imd.async_draw_go_to_flag(
+                img_np_array, m_json, colors["go_to"]
+            )
 
-    def get_json_id(self) -> str:
-        """Return the json id."""
-        return self.json_id
+        # Draw robot if enabled
+        if robot_position and self.drawing_config.is_enabled(DrawableElement.ROBOT):
+            # Get robot color (allows for customization)
+            robot_color = self.drawing_config.get_property(
+                DrawableElement.ROBOT, "color", colors["robot"]
+            )
+
+            img_np_array = await self.imd.async_draw_robot_on_map(
+                img_np_array, robot_position, robot_position_angle, robot_color
+            )
+
+        img_np_array = await self.async_auto_trim_and_zoom_image(
+            img_np_array,
+            detect_colour=colors["background"],
+            margin_size=int(self.shared.margins),
+            rotate=int(self.shared.image_rotate),
+            zoom=self.zooming,
+            rand256=True,
+        )
+        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
+        if self.check_zoom_and_aspect_ratio():
+            resize_params = prepare_resize_params(self, pil_img, True)
+            pil_img = await self.async_resize_images(resize_params)
+        _LOGGER.debug("%s: Frame Completed.", self.file_name)
+        return pil_img
 
     async def get_rooms_attributes(
         self, destinations: JsonType = None
-    ) -> RoomsProperties:
+    ) -> tuple[RoomsProperties, Any, Any]:
         """Return the rooms attributes."""
         if self.room_propriety:
             return self.room_propriety
@@ -330,101 +325,221 @@ class ReImageHandler(object):
                 _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:
         """Get the robot position and return in what room is."""
+        # First check if we already have a cached room and if the robot is still in it
+        if self.robot_in_room:
+            # 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):
+                    temp = {
+                        "x": robot_x,
+                        "y": robot_y,
+                        "angle": angle,
+                        "in_room": self.robot_in_room["room"],
+                    }
+                    # Handle active zones
+                    self.active_zones = self.shared.rand256_active_zone
+                    self.zooming = False
+                    if self.active_zones and (
+                        self.robot_in_room["id"]
+                        in range(len(self.active_zones))
+                    ):
+                        self.zooming = bool(
+                            self.active_zones[self.robot_in_room["id"]]
+                        )
+                    else:
+                        self.zooming = False
+                    return temp
+            # Fallback to bounding box check if no outline data
+            elif all(
+                k in self.robot_in_room for k in ["left", "right", "up", "down"]
+            ):
+                if (
+                    (self.robot_in_room["right"] <= int(robot_x) <= self.robot_in_room["left"])
+                    and (self.robot_in_room["up"] <= int(robot_y) <= self.robot_in_room["down"])
+                ):
+                    temp = {
+                        "x": robot_x,
+                        "y": robot_y,
+                        "angle": angle,
+                        "in_room": self.robot_in_room["room"],
+                    }
+                    # Handle active zones
+                    self.active_zones = self.shared.rand256_active_zone
+                    self.zooming = False
+                    if self.active_zones and (
+                        self.robot_in_room["id"]
+                        in range(len(self.active_zones))
+                    ):
+                        self.zooming = bool(
+                            self.active_zones[self.robot_in_room["id"]]
+                        )
+                    else:
+                        self.zooming = False
+                    return temp
 
-        def _check_robot_position(x: int, y: int) -> bool:
-            x_in_room = (self.robot_in_room["left"] >= x) and (
-                self.robot_in_room["right"] <= x
-            )
-            y_in_room = (self.robot_in_room["up"] >= y) and (
-                self.robot_in_room["down"] <= y
-            )
-            return x_in_room and y_in_room
+        # If we don't have a cached room or the robot is not in it, search all rooms
+        last_room = None
+        room_count = 0
+        if self.robot_in_room:
+            last_room = self.robot_in_room
 
-        # Check if the robot coordinates are inside the room's
-        if self.robot_in_room and _check_robot_position(robot_x, robot_y):
+        # Check if the robot is far outside the normal map boundaries
+        # 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 = {
                 "x": robot_x,
                 "y": robot_y,
                 "angle": angle,
-                "in_room": self.robot_in_room["room"],
+                "in_room": last_room["room"] if last_room else "unknown",
             }
-            self.active_zones = self.shared.rand256_active_zone
+            return temp
+
+        # 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
-            if self.active_zones and (
-                (self.robot_in_room["id"]) in range(len(self.active_zones))
-            ):  # issue #100 Index out of range
-                self.zooming = bool(self.active_zones[self.robot_in_room["id"]])
+            temp = {
+                "x": robot_x,
+                "y": robot_y,
+                "angle": angle,
+                "in_room": last_room["room"] if last_room else "unknown",
+            }
             return temp
-        # else we need to search and use the async method
-        _LOGGER.debug(f"{self.file_name} changed room.. searching..")
-        room_count = -1
-        last_room = None
-        if self.rooms_pos:
-            if self.robot_in_room:
-                last_room = self.robot_in_room
-            for room in self.rooms_pos:
-                corners = room["corners"]
-                room_count += 1
-                self.robot_in_room = {
-                    "id": room_count,
-                    "left": corners[0][0],
-                    "right": corners[2][0],
-                    "up": corners[0][1],
-                    "down": corners[2][1],
-                    "room": room["name"],
-                }
-                # Check if the robot coordinates are inside the room's corners
-                if _check_robot_position(robot_x, robot_y):
+
+        _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):
+                    # Robot is in this room
+                    self.robot_in_room = {
+                        "id": room_count,
+                        "room": str(room["name"]),
+                        "outline": outline,
+                    }
                     temp = {
                         "x": robot_x,
                         "y": robot_y,
                         "angle": angle,
                         "in_room": self.robot_in_room["room"],
                     }
+
+                    # Handle active zones - Set zooming based on active zones
+                    self.active_zones = self.shared.rand256_active_zone
+                    self.zooming = False
+                    if self.active_zones and (
+                        self.robot_in_room["id"]
+                        in range(len(self.active_zones))
+                    ):
+                        self.zooming = bool(
+                            self.active_zones[self.robot_in_room["id"]]
+                        )
+                    else:
+                        self.zooming = False
+
                     _LOGGER.debug(
-                        f"{self.file_name} is in {self.robot_in_room['room']}"
+                        "%s is in %s room (polygon detection).",
+                        self.file_name,
+                        self.robot_in_room["room"],
                     )
-                    del room, corners, robot_x, robot_y  # free memory.
                     return temp
-            del room, corners  # free memory.
-            _LOGGER.debug(
-                f"{self.file_name}: Not located within Camera Rooms coordinates."
-            )
-            self.zooming = False
-            self.robot_in_room = last_room
-            temp = {
-                "x": robot_x,
-                "y": robot_y,
-                "angle": angle,
-                "in_room": 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 = {
+            "x": robot_x,
+            "y": robot_y,
+            "angle": angle,
+            "in_room": last_room["room"] if last_room else "unknown",
+        }
+        return temp
 
-    def get_calibration_data(self, rotation_angle: int = 0) -> any:
+    def get_calibration_data(self, rotation_angle: int = 0) -> Any:
         """Return the map calibration data."""
-        if not self.calibration_data:
+        if not self.calibration_data and self.crop_img_size:
             self.calibration_data = []
             _LOGGER.info(
-                f"{self.file_name}: Getting Calibrations points {self.crop_area}"
+                "%s: Getting Calibrations points %s",
+                self.file_name,
+                str(self.crop_area),
             )
 
             # Define the map points (fixed)
-            map_points = [
-                {"x": 0, "y": 0},  # Top-left corner 0
-                {"x": self.crop_img_size[0], "y": 0},  # Top-right corner 1
-                {
-                    "x": self.crop_img_size[0],
-                    "y": self.crop_img_size[1],
-                },  # Bottom-right corner 2
-                {"x": 0, "y": self.crop_img_size[1]},  # Bottom-left corner (optional) 3
-            ]
+            map_points = self.get_map_points()
 
             # Valetudo Re version need corrections of the coordinates and are implemented with *10
-            vacuum_points = self.imu.re_get_vacuum_points(rotation_angle)
+            vacuum_points = self.re_get_vacuum_points(rotation_angle)
 
             # Create the calibration data for each point
             for vacuum_point, map_point in zip(vacuum_points, map_points):
@@ -433,23 +548,27 @@ class ReImageHandler(object):
 
         return self.calibration_data
 
-    async def async_map_coordinates_offset(
-        self, wsf: int, hsf: int, width: int, height: int
-    ) -> tuple[int, int]:
-        """
-        Offset the coordinates to the map.
-        """
+    # 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)
 
-        if wsf == 1 and hsf == 1:
-            self.imu.set_image_offset_ratio_1_1(width, height, rand256=True)
-        elif wsf == 2 and hsf == 1:
-            self.imu.set_image_offset_ratio_2_1(width, height, rand256=True)
-        elif wsf == 3 and hsf == 2:
-            self.imu.set_image_offset_ratio_3_2(width, height, rand256=True)
-        elif wsf == 5 and hsf == 4:
-            self.imu.set_image_offset_ratio_5_4(width, height, rand256=True)
-        elif wsf == 9 and hsf == 16:
-            self.imu.set_image_offset_ratio_9_16(width, height, rand256=True)
-        elif wsf == 16 and hsf == 9:
-            self.imu.set_image_offset_ratio_16_9(width, height, rand256=True)
-        return width, height
+    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,
+        )