valetudo-map-parser 0.1.10rc6__py3-none-any.whl → 0.1.11b1__py3-none-any.whl

valetudo_map_parser/config/rand256_parser.py

@@ -1,7 +1,8 @@
-"""New Rand256 Map Parser - Based on Xiaomi/Roborock implementation with precise binary parsing."""
+"""New Rand256 Map Parser -
+Based on Xiaomi/Roborock implementation with precise binary parsing."""
 
-import struct
 import math
+import struct
 from enum import Enum
 from typing import Any, Dict, List, Optional
 
@@ -24,6 +25,14 @@ class RRMapParser:
         VIRTUAL_WALLS = 10
         CURRENTLY_CLEANED_BLOCKS = 11
         FORBIDDEN_MOP_ZONES = 12
+        OBSTACLES = 13
+        IGNORED_OBSTACLES = 14
+        OBSTACLES_WITH_PHOTO = 15
+        IGNORED_OBSTACLES_WITH_PHOTO = 16
+        CARPET_MAP = 17
+        MOP_PATH = 18
+        NO_CARPET_AREAS = 19
+        DIGEST = 1024
 
     class Tools:
         """Tools for coordinate transformations."""
@@ -33,6 +42,7 @@ class RRMapParser:
 
     def __init__(self):
         """Initialize the parser."""
+        self.is_valid = False
         self.map_data: Dict[str, Any] = {}
 
     # Xiaomi/Roborock style byte extraction methods
@@ -67,6 +77,64 @@ class RRMapParser:
         value = RRMapParser._get_int32(data, address)
         return value if value < 0x80000000 else value - 0x100000000
 
+    @staticmethod
+    def _parse_carpet_map(data: bytes) -> set[int]:
+        """Parse carpet map using Xiaomi method."""
+        carpet_map = set()
+
+        for i, v in enumerate(data):
+            if v:
+                carpet_map.add(i)
+        return carpet_map
+
+    @staticmethod
+    def _parse_area(header: bytes, data: bytes) -> list:
+        """Parse area using Xiaomi method."""
+        area_pairs = RRMapParser._get_int16(header, 0x08)
+        areas = []
+        for area_start in range(0, area_pairs * 16, 16):
+            x0 = RRMapParser._get_int16(data, area_start + 0)
+            y0 = RRMapParser._get_int16(data, area_start + 2)
+            x1 = RRMapParser._get_int16(data, area_start + 4)
+            y1 = RRMapParser._get_int16(data, area_start + 6)
+            x2 = RRMapParser._get_int16(data, area_start + 8)
+            y2 = RRMapParser._get_int16(data, area_start + 10)
+            x3 = RRMapParser._get_int16(data, area_start + 12)
+            y3 = RRMapParser._get_int16(data, area_start + 14)
+            areas.append(
+                [
+                    x0,
+                    RRMapParser.Tools.DIMENSION_MM - y0,
+                    x1,
+                    RRMapParser.Tools.DIMENSION_MM - y1,
+                    x2,
+                    RRMapParser.Tools.DIMENSION_MM - y2,
+                    x3,
+                    RRMapParser.Tools.DIMENSION_MM - y3,
+                ]
+            )
+        return areas
+
+    @staticmethod
+    def _parse_zones(data: bytes, header: bytes) -> list:
+        """Parse zones using Xiaomi method."""
+        zone_pairs = RRMapParser._get_int16(header, 0x08)
+        zones = []
+        for zone_start in range(0, zone_pairs * 8, 8):
+            x0 = RRMapParser._get_int16(data, zone_start + 0)
+            y0 = RRMapParser._get_int16(data, zone_start + 2)
+            x1 = RRMapParser._get_int16(data, zone_start + 4)
+            y1 = RRMapParser._get_int16(data, zone_start + 6)
+            zones.append(
+                [
+                    x0,
+                    RRMapParser.Tools.DIMENSION_MM - y0,
+                    x1,
+                    RRMapParser.Tools.DIMENSION_MM - y1,
+                ]
+            )
+        return zones
+
     @staticmethod
     def _parse_object_position(block_data_length: int, data: bytes) -> Dict[str, Any]:
         """Parse object position using Xiaomi method."""
@@ -82,6 +150,26 @@ class RRMapParser:
                 angle = raw_angle
         return {"position": [x, y], "angle": angle}
 
+    @staticmethod
+    def _parse_walls(data: bytes, header: bytes) -> list:
+        """Parse walls using Xiaomi method."""
+        wall_pairs = RRMapParser._get_int16(header, 0x08)
+        walls = []
+        for wall_start in range(0, wall_pairs * 8, 8):
+            x0 = RRMapParser._get_int16(data, wall_start + 0)
+            y0 = RRMapParser._get_int16(data, wall_start + 2)
+            x1 = RRMapParser._get_int16(data, wall_start + 4)
+            y1 = RRMapParser._get_int16(data, wall_start + 6)
+            walls.append(
+                [
+                    x0,
+                    RRMapParser.Tools.DIMENSION_MM - y0,
+                    x1,
+                    RRMapParser.Tools.DIMENSION_MM - y1,
+                ]
+            )
+        return walls
+
     @staticmethod
     def _parse_path_block(buf: bytes, offset: int, length: int) -> Dict[str, Any]:
         """Parse path block using EXACT same method as working parser."""
@@ -131,55 +219,66 @@ class RRMapParser:
         blocks = {}
         map_header_length = self._get_int16(raw, 0x02)
         block_start_position = map_header_length
-
         while block_start_position < len(raw):
             try:
-                # Parse block header using Xiaomi method
                 block_header_length = self._get_int16(raw, block_start_position + 0x02)
                 header = self._get_bytes(raw, block_start_position, block_header_length)
                 block_type = self._get_int16(header, 0x00)
                 block_data_length = self._get_int32(header, 0x04)
                 block_data_start = block_start_position + block_header_length
                 data = self._get_bytes(raw, block_data_start, block_data_length)
+                match block_type:
+                    case self.Types.DIGEST.value:
+                        self.is_valid = True
+                    case (
+                        self.Types.ROBOT_POSITION.value
+                        | self.Types.CHARGER_LOCATION.value
+                    ):
+                        blocks[block_type] = self._parse_object_position(
+                            block_data_length, data
+                        )
+                    case self.Types.PATH.value | self.Types.GOTO_PREDICTED_PATH.value:
+                        blocks[block_type] = self._parse_path_block(
+                            raw, block_start_position, block_data_length
+                        )
+                    case self.Types.CURRENTLY_CLEANED_ZONES.value:
+                        blocks[block_type] = {"zones": self._parse_zones(data, header)}
+                    case self.Types.FORBIDDEN_ZONES.value:
+                        blocks[block_type] = {
+                            "forbidden_zones": self._parse_area(header, data)
+                        }
+                    case self.Types.FORBIDDEN_MOP_ZONES.value:
+                        blocks[block_type] = {
+                            "forbidden_mop_zones": self._parse_area(header, data)
+                        }
+                    case self.Types.GOTO_TARGET.value:
+                        blocks[block_type] = {"position": self._parse_goto_target(data)}
+                    case self.Types.VIRTUAL_WALLS.value:
+                        blocks[block_type] = {
+                            "virtual_walls": self._parse_walls(data, header)
+                        }
+                    case self.Types.CARPET_MAP.value:
+                        data = RRMapParser._get_bytes(
+                            raw, block_data_start, block_data_length
+                        )
+                        blocks[block_type] = {
+                            "carpet_map": self._parse_carpet_map(data)
+                        }
+                    case self.Types.IMAGE.value:
+                        header_length = self._get_int8(header, 2)
+                        blocks[block_type] = self._parse_image_block(
+                            raw,
+                            block_start_position,
+                            block_data_length,
+                            header_length,
+                            pixels,
+                        )
 
-                # Parse different block types
-                if block_type == self.Types.ROBOT_POSITION.value:
-                    blocks[block_type] = self._parse_object_position(
-                        block_data_length, data
-                    )
-                elif block_type == self.Types.CHARGER_LOCATION.value:
-                    blocks[block_type] = self._parse_object_position(
-                        block_data_length, data
-                    )
-                elif block_type == self.Types.PATH.value:
-                    blocks[block_type] = self._parse_path_block(
-                        raw, block_start_position, block_data_length
-                    )
-                elif block_type == self.Types.GOTO_PREDICTED_PATH.value:
-                    blocks[block_type] = self._parse_path_block(
-                        raw, block_start_position, block_data_length
-                    )
-                elif block_type == self.Types.GOTO_TARGET.value:
-                    blocks[block_type] = {"position": self._parse_goto_target(data)}
-                elif block_type == self.Types.IMAGE.value:
-                    # Get header length for Gen1/Gen3 detection
-                    header_length = self._get_int8(header, 2)
-                    blocks[block_type] = self._parse_image_block(
-                        raw,
-                        block_start_position,
-                        block_data_length,
-                        header_length,
-                        pixels,
-                    )
-
-                # Move to next block using Xiaomi method
                 block_start_position = (
                     block_start_position + block_data_length + self._get_int8(header, 2)
                 )
-
             except (struct.error, IndexError):
                 break
-
         return blocks
 
     def _parse_image_block(
@@ -365,8 +464,32 @@ class RRMapParser:
                 ]
 
             # Add missing fields to match expected JSON format
-            parsed_map_data["forbidden_zones"] = []
-            parsed_map_data["virtual_walls"] = []
+            parsed_map_data["currently_cleaned_zones"] = (
+                blocks[self.Types.CURRENTLY_CLEANED_ZONES.value]["zones"]
+                if self.Types.CURRENTLY_CLEANED_ZONES.value in blocks
+                else []
+            )
+            parsed_map_data["forbidden_zones"] = (
+                blocks[self.Types.FORBIDDEN_ZONES.value]["forbidden_zones"]
+                if self.Types.FORBIDDEN_ZONES.value in blocks
+                else []
+            )
+            parsed_map_data["forbidden_mop_zones"] = (
+                blocks[self.Types.FORBIDDEN_MOP_ZONES.value]["forbidden_mop_zones"]
+                if self.Types.FORBIDDEN_MOP_ZONES.value in blocks
+                else []
+            )
+            parsed_map_data["virtual_walls"] = (
+                blocks[self.Types.VIRTUAL_WALLS.value]["virtual_walls"]
+                if self.Types.VIRTUAL_WALLS.value in blocks
+                else []
+            )
+            parsed_map_data["carpet_areas"] = (
+                blocks[self.Types.CARPET_MAP.value]["carpet_map"]
+                if self.Types.CARPET_MAP.value in blocks
+                else []
+            )
+            parsed_map_data["is_valid"] = self.is_valid
 
             return parsed_map_data
 
@@ -388,8 +511,3 @@ class RRMapParser:
             except (struct.error, IndexError, ValueError):
                 return None
         return self.map_data
-
-    @staticmethod
-    def get_int32(data: bytes, address: int) -> int:
-        """Get a 32-bit integer from the data - kept for compatibility."""
-        return struct.unpack_from("<i", data, address)[0]

valetudo_map_parser/config/shared.py

@@ -7,17 +7,20 @@ Version: v0.1.12
 import asyncio
 import logging
 from typing import List
+
 from PIL import Image
 
+from .utils import pil_size_rotation
 from .types import (
     ATTR_CALIBRATION_POINTS,
     ATTR_CAMERA_MODE,
+    ATTR_CONTENT_TYPE,
+    ATTR_IMAGE_LAST_UPDATED,
     ATTR_MARGINS,
     ATTR_OBSTACLES,
     ATTR_POINTS,
     ATTR_ROOMS,
     ATTR_ROTATE,
-    ATTR_SNAPSHOT,
     ATTR_VACUUM_BATTERY,
     ATTR_VACUUM_CHARGING,
     ATTR_VACUUM_JSON_ID,
@@ -39,8 +42,8 @@ from .types import (
     DEFAULT_VALUES,
     CameraModes,
     Colors,
-    TrimsData,
     PilPNG,
+    TrimsData,
 )
 
 
@@ -179,12 +182,14 @@ class CameraShared:
     def generate_attributes(self) -> dict:
         """Generate and return the shared attribute's dictionary."""
         attrs = {
+            ATTR_IMAGE_LAST_UPDATED: self.image_last_updated,
+            ATTR_CONTENT_TYPE: self.image_format,
+            ATTR_VACUUM_JSON_ID: self.vac_json_id,
             ATTR_CAMERA_MODE: self.camera_mode,
+            ATTR_VACUUM_STATUS: self.vacuum_state,
             ATTR_VACUUM_BATTERY: f"{self.vacuum_battery}%",
             ATTR_VACUUM_CHARGING: self.vacuum_bat_charged(),
             ATTR_VACUUM_POSITION: self.current_room,
-            ATTR_VACUUM_STATUS: self.vacuum_state,
-            ATTR_VACUUM_JSON_ID: self.vac_json_id,
             ATTR_CALIBRATION_POINTS: self.attr_calibration_points,
         }
         if self.obstacles_pos and self.vacuum_ips:
@@ -193,8 +198,6 @@ class CameraShared:
             )
             attrs[ATTR_OBSTACLES] = self.obstacles_data
 
-        attrs[ATTR_SNAPSHOT] = self.snapshot_take if self.enable_snapshots else False
-
         shared_attrs = {
             ATTR_ROOMS: self.map_rooms,
             ATTR_ZONES: self.map_pred_zones,
@@ -208,13 +211,12 @@ class CameraShared:
 
     def to_dict(self) -> dict:
         """Return a dictionary with image and attributes data."""
+
         return {
             "image": {
                 "binary": self.binary_image,
-                "pil_image_size": self.new_image.size,
-                "size": self.new_image.size if self.new_image else None,
-                "format": self.image_format,
-                "updated": self.image_last_updated,
+                "pil_image": self.new_image,
+                "size": pil_size_rotation(self.image_rotate, self.new_image),
             },
             "attributes": self.generate_attributes(),
         }

valetudo_map_parser/config/status_text/status_text.py

@@ -9,6 +9,7 @@ from __future__ import annotations
 from ..types import LOGGER, PilPNG
 from .translations import translations
 
+
 LOGGER.propagate = True
 
 

valetudo_map_parser/config/types.py

@@ -8,7 +8,7 @@ import json
 import logging
 import threading
 from dataclasses import asdict, dataclass
-from typing import Any, Dict, Optional, Tuple, TypedDict, Union, List, NotRequired
+from typing import Any, Dict, List, NotRequired, Optional, Tuple, TypedDict, Union
 
 import numpy as np
 from PIL import Image
@@ -18,23 +18,28 @@ DEFAULT_ROOMS = 1
 
 LOGGER = logging.getLogger(__package__)
 
+
 class Spot(TypedDict):
     name: str
     coordinates: List[int]  # [x, y]
 
+
 class Zone(TypedDict):
     name: str
     coordinates: List[List[int]]  # [[x1, y1, x2, y2, repeats], ...]
 
+
 class Room(TypedDict):
     name: str
     id: int
 
+
 class Destinations(TypedDict, total=False):
     spots: NotRequired[Optional[List[Spot]]]
     zones: NotRequired[Optional[List[Zone]]]
     rooms: NotRequired[Optional[List[Room]]]
-    updated: NotRequired[Optional[int]]
+    updated: NotRequired[Optional[float | int]]
+
 
 class RoomProperty(TypedDict):
     number: int
@@ -216,7 +221,9 @@ class SnapshotStore:
 Color = Union[Tuple[int, int, int], Tuple[int, int, int, int]]
 Colors = Dict[str, Color]
 CalibrationPoints = list[dict[str, Any]]
-RobotPosition = Optional[dict[str, Union[int | float]]]
+RobotPosition: type[tuple[Any, Any, dict[str, int | float] | None]] = tuple[
+    Any, Any, dict[str, int | float] | None
+]
 ChargerPosition = dict[str, Any]
 RoomsProperties = dict[str, RoomProperty]
 ImageSize = dict[str, int | list[int]]
@@ -227,9 +234,11 @@ NumpyArray = np.ndarray
 Point = Tuple[int, int]
 
 CAMERA_STORAGE = "valetudo_camera"
+ATTR_IMAGE_LAST_UPDATED = "image_last_updated"
 ATTR_ROTATE = "rotate_image"
 ATTR_CROP = "crop_image"
 ATTR_MARGINS = "margins"
+ATTR_CONTENT_TYPE = "content_type"
 CONF_OFFSET_TOP = "offset_top"
 CONF_OFFSET_BOTTOM = "offset_bottom"
 CONF_OFFSET_LEFT = "offset_left"

valetudo_map_parser/config/utils.py

@@ -1,32 +1,30 @@
 """Utility code for the valetudo map parser."""
 
 import datetime
-from time import time
 import hashlib
+import io
 import json
 from dataclasses import dataclass
+from time import time
 from typing import Callable, List, Optional, Tuple
-import io
 
 import numpy as np
 from PIL import Image, ImageOps
 
+from ..map_data import HyperMapData
+from .async_utils import AsyncNumPy
 from .drawable import Drawable
 from .drawable_elements import DrawingConfig
-from .enhanced_drawable import EnhancedDrawable
 from .status_text.status_text import StatusText
-
 from .types import (
     LOGGER,
     ChargerPosition,
-    Size,
+    Destinations,
     NumpyArray,
     PilPNG,
     RobotPosition,
-    Destinations
+    Size,
 )
-from ..map_data import HyperMapData
-from .async_utils import AsyncNumPy
 
 
 @dataclass
@@ -79,7 +77,6 @@ class BaseHandler:
         # 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."""
@@ -114,6 +111,12 @@ class BaseHandler:
         try:
             # Backup current image to last_image before processing new one
             if hasattr(self.shared, "new_image") and self.shared.new_image is not None:
+                # Close old last_image to free memory before replacing it
+                if hasattr(self.shared, "last_image") and self.shared.last_image is not None:
+                    try:
+                        self.shared.last_image.close()
+                    except Exception:
+                        pass  # Ignore errors if image is already closed
                 self.shared.last_image = self.shared.new_image
 
             # Call the appropriate handler method based on handler type
@@ -197,26 +200,28 @@ class BaseHandler:
         """Update the shared data with the latest information."""
 
         if hasattr(self, "get_rooms_attributes") and (
-                self.shared.map_rooms is None and destinations is not None
+            self.shared.map_rooms is None and destinations is not None
         ):
-            (
-                self.shared.map_rooms,
-                self.shared.map_pred_zones,
-                self.shared.map_pred_points,
-            ) = await self.get_rooms_attributes(destinations)
+            self.shared.map_rooms = await self.get_rooms_attributes(destinations)
             if self.shared.map_rooms:
                 LOGGER.debug("%s: Rand256 attributes rooms updated", self.file_name)
 
+
         if hasattr(self, "async_get_rooms_attributes") and (
-                self.shared.map_rooms is None
+            self.shared.map_rooms is None
         ):
             if self.shared.map_rooms is None:
                 self.shared.map_rooms = await self.async_get_rooms_attributes()
                 if self.shared.map_rooms:
                     LOGGER.debug("%s: Hyper attributes rooms updated", self.file_name)
 
-        if hasattr(self, "get_calibration_data") and self.shared.attr_calibration_points is None:
-            self.shared.attr_calibration_points = self.get_calibration_data(self.shared.image_rotate)
+        if (
+            hasattr(self, "get_calibration_data")
+            and self.shared.attr_calibration_points is None
+        ):
+            self.shared.attr_calibration_points = self.get_calibration_data(
+                self.shared.image_rotate
+            )
 
         if not self.shared.image_size:
             self.shared.image_size = self.get_img_size()
@@ -228,14 +233,12 @@ class BaseHandler:
 
         self.shared.current_room = self.get_robot_position()
 
-    def prepare_resize_params(self, pil_img: PilPNG, rand: bool=False) -> ResizeParams:
+    def prepare_resize_params(
+        self, pil_img: PilPNG, rand: bool = False
+    ) -> ResizeParams:
         """Prepare resize parameters for image resizing."""
-        if self.shared.image_rotate in [0, 180]:
-            width, height = pil_img.size
-        else:
-            height, width = pil_img.size
-        LOGGER.debug("Shared PIL image size: %s x %s", self.shared.image_ref_width,
-                     self.shared.image_ref_height)
+        width, height = pil_size_rotation(self.shared.image_rotate, pil_img)
+
         return ResizeParams(
             pil_img=pil_img,
             width=width,
@@ -656,9 +659,6 @@ class BaseHandler:
 
 async def async_resize_image(params: ResizeParams):
     """Resize the image to the given dimensions and aspect ratio."""
-    LOGGER.debug("Resizing image to aspect ratio: %s", params.aspect_ratio)
-    LOGGER.debug("Original image size: %s x %s", params.width, params.height)
-    LOGGER.debug("Image crop size: %s", params.crop_size)
     if params.aspect_ratio == "None":
         return params.pil_img
     if params.aspect_ratio != "None":
@@ -695,6 +695,17 @@ async def async_resize_image(params: ResizeParams):
     return params.pil_img
 
 
+def pil_size_rotation(image_rotate, pil_img):
+    """Return the size of the image."""
+    if not pil_img:
+        return 0, 0
+    if image_rotate in [0, 180]:
+        width, height = pil_img.size
+    else:
+        height, width = pil_img.size
+    return width, height
+
+
 def initialize_drawing_config(handler):
     """
     Initialize drawing configuration from device_info.
@@ -703,7 +714,7 @@ def initialize_drawing_config(handler):
         handler: The handler instance with shared data and file_name attributes
 
     Returns:
-        Tuple of (DrawingConfig, Drawable, EnhancedDrawable)
+        Tuple of (DrawingConfig, Drawable)
     """
 
     # Initialize drawing configuration
@@ -715,98 +726,10 @@ def initialize_drawing_config(handler):
     ):
         drawing_config.update_from_device_info(handler.shared.device_info)
 
-    # Initialize both drawable systems for backward compatibility
-    draw = Drawable()  # Legacy drawing utilities
-    enhanced_draw = EnhancedDrawable(drawing_config)  # New enhanced drawing system
-
-    return drawing_config, draw, enhanced_draw
+    # Initialize drawing utilities
+    draw = Drawable()
 
-
-def blend_colors(base_color, overlay_color):
-    """
-    Blend two RGBA colors using alpha compositing.
-
-    Args:
-        base_color: Base RGBA color tuple (r, g, b, a)
-        overlay_color: Overlay RGBA color tuple (r, g, b, a)
-
-    Returns:
-        Blended RGBA color tuple (r, g, b, a)
-    """
-    r1, g1, b1, a1 = base_color
-    r2, g2, b2, a2 = overlay_color
-
-    # Convert alpha to 0-1 range
-    a1 = a1 / 255.0
-    a2 = a2 / 255.0
-
-    # Calculate resulting alpha
-    a_out = a1 + a2 * (1 - a1)
-
-    # Avoid division by zero
-    if a_out < 0.0001:
-        return [0, 0, 0, 0]
-
-    # Calculate blended RGB components
-    r_out = (r1 * a1 + r2 * a2 * (1 - a1)) / a_out
-    g_out = (g1 * a1 + g2 * a2 * (1 - a1)) / a_out
-    b_out = (b1 * a1 + b2 * a2 * (1 - a1)) / a_out
-
-    # Convert back to 0-255 range and return as tuple
-    return (
-        int(max(0, min(255, r_out))),
-        int(max(0, min(255, g_out))),
-        int(max(0, min(255, b_out))),
-        int(max(0, min(255, a_out * 255))),
-    )
-
-
-def blend_pixel(array, x, y, color, element, element_map=None, drawing_config=None):
-    """
-    Blend a pixel color with the existing color at the specified position.
-    Also updates the element map if the new element has higher z-index.
-
-    Args:
-        array: The image array to modify
-        x: X coordinate
-        y: Y coordinate
-        color: RGBA color tuple to blend
-        element: Element code for the pixel
-        element_map: Optional element map to update
-        drawing_config: Optional drawing configuration for z-index lookup
-
-    Returns:
-        None
-    """
-    # Check bounds
-    if not (0 <= y < array.shape[0] and 0 <= x < array.shape[1]):
-        return
-
-    # Get current element at this position
-    current_element = None
-    if element_map is not None:
-        current_element = element_map[y, x]
-
-    # Get z-index values for comparison
-    current_z = 0
-    new_z = 0
-
-    if drawing_config is not None:
-        current_z = (
-            drawing_config.get_property(current_element, "z_index", 0)
-            if current_element
-            else 0
-        )
-        new_z = drawing_config.get_property(element, "z_index", 0)
-
-    # Update element map if new element has higher z-index
-    if element_map is not None and new_z >= current_z:
-        element_map[y, x] = element
-
-    # Blend colors
-    base_color = array[y, x]
-    blended_color = blend_colors(base_color, color)
-    array[y, x] = blended_color
+    return drawing_config, draw
 
 
 def manage_drawable_elements(
@@ -990,12 +913,6 @@ async def async_extract_room_outline(
 
         # If we found too few boundary points, use the rectangular outline
         if len(boundary_points) < 8:  # Need at least 8 points for a meaningful shape
-            LOGGER.debug(
-                "%s: Room %s has too few boundary points (%d), using rectangular outline",
-                file_name,
-                str(room_id_int),
-                len(boundary_points),
-            )
             return rect_outline
 
         # Use a more sophisticated algorithm to create a coherent outline
@@ -1031,13 +948,6 @@ async def async_extract_room_outline(
         # Convert NumPy int64 values to regular Python integers
         simplified_outline = [(int(x), int(y)) for x, y in simplified_outline]
 
-        LOGGER.debug(
-            "%s: Room %s outline has %d points",
-            file_name,
-            str(room_id_int),
-            len(simplified_outline),
-        )
-
         return simplified_outline
 
     except (ValueError, IndexError, TypeError, ArithmeticError) as e: