valetudo-map-parser 0.1.9b50__py3-none-any.whl → 0.1.9b52__py3-none-any.whl

valetudo_map_parser/hypfer_draw.py

@@ -23,6 +23,51 @@ 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:
@@ -414,75 +459,196 @@ class ImageDraw:
         _LOGGER.info("%s: Got the points in the json.", self.file_name)
         return entity_dict
 
+    @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:
         """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.img_h.robot_in_room:
-            # Check if the robot coordinates are inside the room's corners
-            if (
-                (self.img_h.robot_in_room["right"] >= int(robot_x))
-                and (self.img_h.robot_in_room["left"] <= int(robot_x))
-            ) and (
-                (self.img_h.robot_in_room["down"] >= int(robot_y))
-                and (self.img_h.robot_in_room["up"] <= int(robot_y))
+            # 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):
+                    temp = {
+                        "x": robot_x,
+                        "y": robot_y,
+                        "angle": angle,
+                        "in_room": self.img_h.robot_in_room["room"],
+                    }
+                    # Handle active zones
+                    if self.img_h.active_zones and (
+                        self.img_h.robot_in_room["id"]
+                        in range(len(self.img_h.active_zones))
+                    ):
+                        self.img_h.zooming = bool(
+                            self.img_h.active_zones[self.img_h.robot_in_room["id"]]
+                        )
+                    else:
+                        self.img_h.zooming = False
+                    return temp
+            # Fallback to bounding box check if no outline data
+            elif all(
+                k in self.img_h.robot_in_room for k in ["left", "right", "up", "down"]
             ):
-                temp = {
-                    "x": robot_x,
-                    "y": robot_y,
-                    "angle": angle,
-                    "in_room": self.img_h.robot_in_room["room"],
-                }
-                if self.img_h.active_zones and (
-                    self.img_h.robot_in_room["id"]
-                    in range(len(self.img_h.active_zones))
-                ):  # issue #100 Index out of range.
-                    self.img_h.zooming = bool(
-                        self.img_h.active_zones[self.img_h.robot_in_room["id"]]
-                    )
-                else:
-                    self.img_h.zooming = False
-                return temp
-        # else we need to search and use the async method.
+                if (
+                    (self.img_h.robot_in_room["right"] >= int(robot_x))
+                    and (self.img_h.robot_in_room["left"] <= int(robot_x))
+                ) and (
+                    (self.img_h.robot_in_room["down"] >= int(robot_y))
+                    and (self.img_h.robot_in_room["up"] <= int(robot_y))
+                ):
+                    temp = {
+                        "x": robot_x,
+                        "y": robot_y,
+                        "angle": angle,
+                        "in_room": self.img_h.robot_in_room["room"],
+                    }
+                    # Handle active zones
+                    if self.img_h.active_zones and (
+                        self.img_h.robot_in_room["id"]
+                        in range(len(self.img_h.active_zones))
+                    ):
+                        self.img_h.zooming = bool(
+                            self.img_h.active_zones[self.img_h.robot_in_room["id"]]
+                        )
+                    else:
+                        self.img_h.zooming = False
+                    return temp
+
+        # 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.img_h.robot_in_room:
             last_room = self.img_h.robot_in_room
-        for room in self.img_h.rooms_pos:
-            corners = room["corners"]
-            self.img_h.robot_in_room = {
-                "id": room_count,
-                "left": int(corners[0][0]),
-                "right": int(corners[2][0]),
-                "up": int(corners[0][1]),
-                "down": int(corners[2][1]),
-                "room": str(room["name"]),
+
+        # 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 = 20000  # Typical map size is around 5000-10000 units
+        if abs(robot_x) > map_boundary or abs(robot_y) > map_boundary:
+            _LOGGER.debug(
+                "%s robot position (%s, %s) is far outside map boundaries.",
+                self.file_name,
+                robot_x,
+                robot_y,
+            )
+            self.img_h.robot_in_room = last_room
+            self.img_h.zooming = False
+            temp = {
+                "x": robot_x,
+                "y": robot_y,
+                "angle": angle,
+                "in_room": last_room["room"] if last_room else None,
             }
-            room_count += 1
-            # Check if the robot coordinates are inside the room's corners
-            if (
-                (self.img_h.robot_in_room["right"] >= int(robot_x))
-                and (self.img_h.robot_in_room["left"] <= int(robot_x))
-            ) and (
-                (self.img_h.robot_in_room["down"] >= int(robot_y))
-                and (self.img_h.robot_in_room["up"] <= int(robot_y))
-            ):
-                temp = {
-                    "x": robot_x,
-                    "y": robot_y,
-                    "angle": angle,
-                    "in_room": self.img_h.robot_in_room["room"],
+            return temp
+
+        # Search through all rooms to find which one contains the robot
+        if self.img_h.rooms_pos is None:
+            _LOGGER.debug(
+                "%s: No rooms data available for robot position detection.",
+                self.file_name,
+            )
+            self.img_h.robot_in_room = last_room
+            self.img_h.zooming = False
+            temp = {
+                "x": robot_x,
+                "y": robot_y,
+                "angle": angle,
+                "in_room": last_room["room"] if last_room else None,
+            }
+            return temp
+
+        for room in self.img_h.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.img_h.robot_in_room = {
+                        "id": room_count,
+                        "room": str(room["name"]),
+                        "outline": outline,
+                    }
+                    temp = {
+                        "x": robot_x,
+                        "y": robot_y,
+                        "angle": angle,
+                        "in_room": self.img_h.robot_in_room["room"],
+                    }
+                    _LOGGER.debug(
+                        "%s is in %s room (polygon detection).",
+                        self.file_name,
+                        self.img_h.robot_in_room["room"],
+                    )
+                    return temp
+            # Fallback to bounding box if no outline is available
+            elif "corners" in room:
+                corners = room["corners"]
+                # Create a bounding box from the corners
+                self.img_h.robot_in_room = {
+                    "id": room_count,
+                    "left": int(corners[0][0]),
+                    "right": int(corners[2][0]),
+                    "up": int(corners[0][1]),
+                    "down": int(corners[2][1]),
+                    "room": str(room["name"]),
                 }
-                _LOGGER.debug(
-                    "%s is in %s room.",
-                    self.file_name,
-                    self.img_h.robot_in_room["room"],
-                )
-                del room, corners, robot_x, robot_y  # free memory.
-                return temp
-        del room, corners  # free memory.
+                # Check if the robot is inside the bounding box
+                if (
+                    (self.img_h.robot_in_room["right"] >= int(robot_x))
+                    and (self.img_h.robot_in_room["left"] <= int(robot_x))
+                ) and (
+                    (self.img_h.robot_in_room["down"] >= int(robot_y))
+                    and (self.img_h.robot_in_room["up"] <= int(robot_y))
+                ):
+                    temp = {
+                        "x": robot_x,
+                        "y": robot_y,
+                        "angle": angle,
+                        "in_room": self.img_h.robot_in_room["room"],
+                    }
+                    _LOGGER.debug(
+                        "%s is in %s room (bounding box detection).",
+                        self.file_name,
+                        self.img_h.robot_in_room["room"],
+                    )
+                    return temp
+            room_count += 1
+
+        # Robot not found in any room
         _LOGGER.debug(
-            "%s not located within Camera Rooms coordinates.",
+            "%s not located within any room coordinates.",
             self.file_name,
         )
         self.img_h.robot_in_room = last_room
@@ -493,7 +659,6 @@ class ImageDraw:
             "angle": angle,
             "in_room": last_room["room"] if last_room else None,
         }
-        # If the robot is not inside any room, return a default value
         return temp
 
     async def async_get_robot_position(self, entity_dict: dict) -> tuple | None:

valetudo_map_parser/hypfer_handler.py

@@ -9,12 +9,10 @@ from __future__ import annotations
 
 import json
 
-import numpy as np
 from PIL import Image
 
 from .config.auto_crop import AutoCrop
 from .config.drawable_elements import DrawableElement
-from .config.optimized_element_map import OptimizedElementMapGenerator
 from .config.shared import CameraShared
 from .config.types import (
     COLORS,
@@ -22,19 +20,15 @@ from .config.types import (
     CalibrationPoints,
     Colors,
     RoomsProperties,
-    RoomStore,
 )
 from .config.utils import (
     BaseHandler,
-    get_element_at_position,
-    get_room_at_position,
     initialize_drawing_config,
     manage_drawable_elements,
     prepare_resize_params,
-    update_element_map_with_robot,
 )
-from .config.room_outline import extract_room_outline_with_scipy
 from .hypfer_draw import ImageDraw as ImDraw
+from .hypfer_rooms_handler import HypferRoomsHandler
 from .map_data import ImageData
 
 
@@ -63,123 +57,62 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
         self.imd = ImDraw(self)  # Image Draw class.
         self.color_grey = (128, 128, 128, 255)
         self.file_name = self.shared.file_name  # file name of the vacuum.
-        self.element_map_manager = OptimizedElementMapGenerator(
-            self.drawing_config, self.shared
-        )  # Map of element codes
+        self.rooms_handler = HypferRoomsHandler(
+            self.file_name, self.drawing_config
+        )  # Room data handler
 
     @staticmethod
     def get_corners(x_max, x_min, y_max, y_min):
         """Get the corners of the room."""
         return [(x_min, y_min), (x_max, y_min), (x_max, y_max), (x_min, y_max)]
 
-    async def extract_room_outline_from_map(self, room_id_int, pixels, pixel_size):
-        """Extract the outline of a room using the pixel data and element map.
-
-        Args:
-            room_id_int: The room ID as an integer
-            pixels: List of pixel coordinates in the format [[x, y, z], ...]
-            pixel_size: Size of each pixel
-
-        Returns:
-            List of points forming the outline of the room
-        """
-        # Calculate x and y min/max from compressed pixels for rectangular fallback
-        x_values = []
-        y_values = []
-        for x, y, z in pixels:
-            for i in range(z):
-                x_values.append(x + i * pixel_size)
-                y_values.append(y)
-
-        if not x_values or not y_values:
-            return []
-
-        min_x, max_x = min(x_values), max(x_values)
-        min_y, max_y = min(y_values), max(y_values)
-
-        # If we don't have an element map, return a rectangular outline
-        if not hasattr(self, "element_map") or self.shared.element_map is None:
-            # Return rectangular outline
-            return [(min_x, min_y), (max_x, min_y), (max_x, max_y), (min_x, max_y)]
-
-        # Create a binary mask for this room using the pixel data
-        # This is more reliable than using the element_map since we're directly using the pixel data
-        height, width = self.shared.element_map.shape
-        room_mask = np.zeros((height, width), dtype=np.uint8)
-
-        # Fill the mask with room pixels using the pixel data
-        for x, y, z in pixels:
-            for i in range(z):
-                px = x + i * pixel_size
-                py = y
-                # Make sure we're within bounds
-                if 0 <= py < height and 0 <= px < width:
-                    # Mark a pixel_size x pixel_size block in the mask
-                    for dx in range(pixel_size):
-                        for dy in range(pixel_size):
-                            if py + dy < height and px + dx < width:
-                                room_mask[py + dy, px + dx] = 1
-
-        # Debug log to check if we have any room pixels
-        num_room_pixels = np.sum(room_mask)
-        LOGGER.debug(
-            "%s: Room %s mask has %d pixels",
-            self.file_name,
-            str(room_id_int),
-            int(num_room_pixels),
-        )
-
-        # Use the scipy-based room outline extraction
-        return await extract_room_outline_with_scipy(
-            room_mask, min_x, min_y, max_x, max_y, self.file_name, room_id_int
-        )
-
     async def async_extract_room_properties(self, json_data) -> RoomsProperties:
         """Extract room properties from the JSON data."""
 
-        room_properties = {}
-        self.rooms_pos = []
-        pixel_size = json_data.get("pixelSize", [])
-
-        for layer in json_data.get("layers", []):
-            if layer["__class"] == "MapLayer":
-                meta_data = layer.get("metaData", {})
-                segment_id = meta_data.get("segmentId")
-                if segment_id is not None:
-                    name = meta_data.get("name")
-                    compressed_pixels = layer.get("compressedPixels", [])
-                    pixels = self.data.sublist(compressed_pixels, 3)
-                    # Calculate x and y min/max from compressed pixels
-                    (
-                        x_min,
-                        y_min,
-                        x_max,
-                        y_max,
-                    ) = await self.data.async_get_rooms_coordinates(pixels, pixel_size)
-                    corners = self.get_corners(x_max, x_min, y_max, y_min)
-                    room_id = str(segment_id)
-                    self.rooms_pos.append(
-                        {
-                            "name": name,
-                            "corners": corners,
-                        }
-                    )
-                    room_properties[room_id] = {
-                        "number": segment_id,
-                        "outline": corners,
-                        "name": name,
-                        "x": ((x_min + x_max) // 2),
-                        "y": ((y_min + y_max) // 2),
-                    }
-        if room_properties:
-            rooms = RoomStore(self.file_name, room_properties)
-            LOGGER.debug(
-                "%s: Rooms data extracted! %s", self.file_name, rooms.get_rooms()
-            )
-        else:
-            LOGGER.debug("%s: Rooms data not available!", self.file_name)
-            self.rooms_pos = None
-        return room_properties
+        return await self.rooms_handler.async_extract_room_properties(json_data)
+        # room_properties = {}
+        # self.rooms_pos = []
+        # pixel_size = json_data.get("pixelSize", [])
+        #
+        # for layer in json_data.get("layers", []):
+        #     if layer["__class"] == "MapLayer":
+        #         meta_data = layer.get("metaData", {})
+        #         segment_id = meta_data.get("segmentId")
+        #         if segment_id is not None:
+        #             name = meta_data.get("name")
+        #             compressed_pixels = layer.get("compressedPixels", [])
+        #             pixels = self.data.sublist(compressed_pixels, 3)
+        #             # Calculate x and y min/max from compressed pixels
+        #             (
+        #                 x_min,
+        #                 y_min,
+        #                 x_max,
+        #                 y_max,
+        #             ) = await self.data.async_get_rooms_coordinates(pixels, pixel_size)
+        #             corners = self.get_corners(x_max, x_min, y_max, y_min)
+        #             room_id = str(segment_id)
+        #             self.rooms_pos.append(
+        #                 {
+        #                     "name": name,
+        #                     "corners": corners,
+        #                 }
+        #             )
+        #             room_properties[room_id] = {
+        #                 "number": segment_id,
+        #                 "outline": corners,
+        #                 "name": name,
+        #                 "x": ((x_min + x_max) // 2),
+        #                 "y": ((y_min + y_max) // 2),
+        #             }
+        # if room_properties:
+        #     rooms = RoomStore(self.file_name, room_properties)
+        #     LOGGER.debug(
+        #         "%s: Rooms data extracted! %s", self.file_name, rooms.get_rooms()
+        #     )
+        # else:
+        #     LOGGER.debug("%s: Rooms data not available!", self.file_name)
+        #     self.rooms_pos = None
+        # return room_properties
 
     # noinspection PyUnresolvedReferences,PyUnboundLocalVariable
     async def async_get_image_from_json(
@@ -471,36 +404,7 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
             if img_np_array is None:
                 LOGGER.warning("%s: Image array is None.", self.file_name)
                 return None
-            # Debug logging for element map creation
-            LOGGER.info(
-                "%s: Frame number: %d, has element_map: %s",
-                self.file_name,
-                self.frame_number,
-                hasattr(self.shared, "element_map"),
-            )
 
-            if (self.shared.element_map is None) and (self.frame_number == 1):
-                # Create element map for tracking what's drawn where
-                LOGGER.info(
-                    "%s: Creating element map with shape: %s",
-                    self.file_name,
-                    img_np_array.shape,
-                )
-
-                # Generate the element map directly from JSON data
-                # This will create a cropped element map containing only the non-zero elements
-                LOGGER.info("%s: Generating element map from JSON data", self.file_name)
-                self.shared.element_map = (
-                    await self.element_map_manager.async_generate_from_json(m_json)
-                )
-
-                LOGGER.info(
-                    "%s: Element map created with shape: %s",
-                    self.file_name,
-                    self.shared.element_map.shape
-                    if self.shared.element_map is not None
-                    else None,
-                )
             # Convert the numpy array to a PIL image
             pil_img = Image.fromarray(img_np_array, mode="RGBA")
             del img_np_array
@@ -584,17 +488,6 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
             value=value,
         )
 
-    def get_element_at_position(self, x: int, y: int) -> DrawableElement | None:
-        """Get the element code at a specific position."""
-
-        return get_element_at_position(self.shared.element_map, x, y)
-
-    def get_room_at_position(self, x: int, y: int) -> int | None:
-        """Get the room ID at a specific position, or None if not a room."""
-        return get_room_at_position(
-            self.shared.element_map, x, y, DrawableElement.ROOM_1
-        )
-
     @staticmethod
     async def async_copy_array(original_array):
         """Copy the array."""