valetudo-map-parser 0.1.9b41__py3-none-any.whl → 0.1.9b42__py3-none-any.whl

valetudo_map_parser/hypfer_draw.py

@@ -8,6 +8,7 @@ from __future__ import annotations
 
 import logging
 
+from .config.drawable_elements import DrawableElement
 from .config.types import Color, JsonType, NumpyArray, RobotPosition
 
 
@@ -44,8 +45,22 @@ class ImageDraw:
         color_wall,
         color_zone_clean,
         pixel_size,
+        disabled_rooms=None,
     ):
-        """Draw the base layer of the map."""
+        """Draw the base layer of the map.
+
+        Args:
+            img_np_array: The image array to draw on
+            compressed_pixels_list: The list of compressed pixels to draw
+            layer_type: The type of layer to draw (segment, floor, wall)
+            color_wall: The color to use for walls
+            color_zone_clean: The color to use for clean zones
+            pixel_size: The size of each pixel
+            disabled_rooms: A set of room IDs that are disabled
+
+        Returns:
+            A tuple of (room_id, img_np_array)
+        """
         room_id = 0
 
         for compressed_pixels in compressed_pixels_list:
@@ -62,7 +77,7 @@ class ImageDraw:
                 )
             elif layer_type == "wall":
                 img_np_array = await self._process_wall_layer(
-                    img_np_array, pixels, pixel_size, color_wall
+                    img_np_array, pixels, pixel_size, color_wall, disabled_rooms
                 )
 
         return room_id, img_np_array
@@ -71,6 +86,25 @@ class ImageDraw:
         self, img_np_array, pixels, layer_type, room_id, pixel_size, color_zone_clean
     ):
         """Process a room layer (segment or floor)."""
+        # Check if this room should be drawn
+        draw_room = True
+        if layer_type == "segment" and hasattr(self.img_h, "drawing_config"):
+            # The room_id is 0-based, but DrawableElement.ROOM_x is 1-based
+            current_room_id = room_id + 1
+            if 1 <= current_room_id <= 15:
+                # Use the DrawableElement imported at the top of the file
+
+                room_element = getattr(DrawableElement, f"ROOM_{current_room_id}", None)
+                if room_element and hasattr(self.img_h.drawing_config, "is_enabled"):
+                    draw_room = self.img_h.drawing_config.is_enabled(room_element)
+                    _LOGGER.debug(
+                        "%s: Room %d is %s",
+                        self.file_name,
+                        current_room_id,
+                        "enabled" if draw_room else "disabled",
+                    )
+
+        # Get the room color
         room_color = self.img_h.shared.rooms_colors[room_id]
 
         try:
@@ -79,13 +113,18 @@ class ImageDraw:
                     room_id, room_color, color_zone_clean
                 )
 
-            img_np_array = await self.img_h.draw.from_json_to_image(
-                img_np_array, pixels, pixel_size, room_color
-            )
+            # Only draw the room if it's enabled
+            if draw_room:
+                img_np_array = await self.img_h.draw.from_json_to_image(
+                    img_np_array, pixels, pixel_size, room_color
+                )
+
+            # Always increment the room_id, even if the room is not drawn
             room_id = (room_id + 1) % 16  # Cycle room_id back to 0 after 15
 
         except IndexError as e:
             _LOGGER.warning("%s: Image Draw Error: %s", self.file_name, str(e))
+
         _LOGGER.debug(
             "%s Active Zones: %s and Room ID: %s",
             self.file_name,
@@ -104,12 +143,106 @@ class ImageDraw:
                 )
         return room_color
 
-    async def _process_wall_layer(self, img_np_array, pixels, pixel_size, color_wall):
-        """Process a wall layer."""
-        return await self.img_h.draw.from_json_to_image(
-            img_np_array, pixels, pixel_size, color_wall
+    async def _process_wall_layer(
+        self, img_np_array, pixels, pixel_size, color_wall, disabled_rooms=None
+    ):
+        """Process a wall layer.
+
+        Args:
+            img_np_array: The image array to draw on
+            pixels: The pixels to draw
+            pixel_size: The size of each pixel
+            color_wall: The color to use for the walls
+            disabled_rooms: A set of room IDs that are disabled
+
+        Returns:
+            The updated image array
+        """
+        # Log the wall color to verify alpha is being passed correctly
+        _LOGGER.debug("%s: Drawing walls with color %s", self.file_name, color_wall)
+
+        # If there are no disabled rooms, draw all walls
+        if not disabled_rooms:
+            return await self.img_h.draw.from_json_to_image(
+                img_np_array, pixels, pixel_size, color_wall
+            )
+
+        # If there are disabled rooms, we need to check each wall pixel
+        # to see if it belongs to a disabled room
+        _LOGGER.debug(
+            "%s: Filtering walls for disabled rooms: %s", self.file_name, disabled_rooms
         )
 
+        # Get the element map if available
+        element_map = getattr(self.img_h, "element_map", None)
+        if element_map is None:
+            _LOGGER.warning(
+                "%s: Element map not available, drawing all walls", self.file_name
+            )
+            return await self.img_h.draw.from_json_to_image(
+                img_np_array, pixels, pixel_size, color_wall
+            )
+
+        # Filter out walls that belong to disabled rooms
+        filtered_pixels = []
+        for x, y, z in pixels:
+            # Check if this wall pixel is adjacent to a disabled room
+            # by checking the surrounding pixels in the element map
+            is_disabled_room_wall = False
+
+            # Check the element map at this position and surrounding positions
+            # to see if this wall is adjacent to a disabled room
+            for dx in range(-1, 2):
+                for dy in range(-1, 2):
+                    # Skip the center pixel
+                    if dx == 0 and dy == 0:
+                        continue
+
+                    # Calculate the position to check
+                    check_x = x + dx
+                    check_y = y + dy
+
+                    # Make sure the position is within bounds
+                    if (
+                        check_x < 0
+                        or check_y < 0
+                        or check_x >= element_map.shape[1]
+                        or check_y >= element_map.shape[0]
+                    ):
+                        continue
+
+                    # Get the element at this position
+                    element = element_map[check_y, check_x]
+
+                    # Check if this element is a disabled room
+                    # 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
+                        if room_id in disabled_rooms:
+                            is_disabled_room_wall = True
+                            break
+
+                if is_disabled_room_wall:
+                    break
+
+            # If this wall is not adjacent to a disabled room, add it to the filtered pixels
+            if not is_disabled_room_wall:
+                filtered_pixels.append((x, y, z))
+
+        # Draw the filtered walls
+        _LOGGER.debug(
+            "%s: Drawing %d of %d wall pixels after filtering",
+            self.file_name,
+            len(filtered_pixels),
+            len(pixels),
+        )
+        if filtered_pixels:
+            return await self.img_h.draw.from_json_to_image(
+                img_np_array, filtered_pixels, pixel_size, color_wall
+            )
+
+        return img_np_array
+
     async def async_draw_obstacle(
         self, np_array: NumpyArray, entity_dict: dict, color_no_go: Color
     ) -> NumpyArray:
@@ -118,6 +251,7 @@ class ImageDraw:
             obstacle_data = entity_dict.get("obstacle")
         except KeyError:
             _LOGGER.info("%s No obstacle found.", self.file_name)
+            return np_array
         else:
             obstacle_positions = []
             if obstacle_data:
@@ -151,6 +285,7 @@ class ImageDraw:
             charger_pos = entity_dict.get("charger_location")
         except KeyError:
             _LOGGER.warning("%s: No charger position found.", self.file_name)
+            return np_array
         else:
             if charger_pos:
                 charger_pos = charger_pos[0]["points"]
@@ -311,58 +446,57 @@ class ImageDraw:
                     self.img_h.zooming = False
                 return temp
         # else we need to search and use the async method.
-        if self.img_h.rooms_pos:
-            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"]),
-                }
-                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"],
-                    }
-                    _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.
-            _LOGGER.debug(
-                "%s not located within Camera Rooms coordinates.",
-                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,
+        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"]),
             }
-            # If the robot is not inside any room, return a default value
-            return temp
+            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"],
+                }
+                _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.
+        _LOGGER.debug(
+            "%s not located within Camera Rooms coordinates.",
+            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,
+        }
+        # 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:
         """Get the robot position from the entity data."""