valetudo-map-parser 0.1.9b72__tar.gz → 0.1.9b74__tar.gz

{valetudo_map_parser-0.1.9b72 → valetudo_map_parser-0.1.9b74}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: valetudo-map-parser
-Version: 0.1.9b72
+Version: 0.1.9b74
 Summary: A Python library to parse Valetudo map data returning a PIL Image object.
 License: Apache-2.0
 Author: Sandro Cantarella
@@ -12,7 +12,6 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: Pillow (>=10.3.0)
 Requires-Dist: numpy (>=1.26.4)
-Requires-Dist: pandas (>=2.3.0)
 Requires-Dist: scipy (>=1.12.0)
 Project-URL: Bug Tracker, https://github.com/sca075/Python-package-valetudo-map-parser/issues
 Project-URL: Changelog, https://github.com/sca075/Python-package-valetudo-map-parser/releases

{valetudo_map_parser-0.1.9b72 → valetudo_map_parser-0.1.9b74}/SCR/valetudo_map_parser/config/drawable.py

@@ -14,7 +14,7 @@ import logging
 import math
 
 import numpy as np
-from PIL import ImageDraw, ImageFont
+from PIL import Image, ImageDraw, ImageFont
 
 from .color_utils import get_blended_color
 from .colors import ColorsManagement
@@ -223,7 +223,9 @@ class Drawable:
 
     @staticmethod
     def point_inside(x: int, y: int, points: list[Tuple[int, int]]) -> bool:
-        """Check if a point (x, y) is inside a polygon defined by a list of points."""
+        """
+        Check if a point (x, y) is inside a polygon defined by a list of points.
+        """
         n = len(points)
         inside = False
         xinters = 0.0
@@ -251,7 +253,7 @@ class Drawable:
     ) -> np.ndarray:
         """
         Draw a line on a NumPy array (layer) from point A to B using Bresenham's algorithm.
-    
+
         Args:
             layer: The numpy array to draw on (H, W, C)
             x1, y1: Start point coordinates
@@ -260,36 +262,36 @@ class Drawable:
             width: Width of the line in pixels
         """
         x1, y1, x2, y2 = int(x1), int(y1), int(x2), int(y2)
-    
+
         blended_color = get_blended_color(x1, y1, x2, y2, layer, color)
-    
+
         dx = abs(x2 - x1)
         dy = abs(y2 - y1)
         sx = 1 if x1 < x2 else -1
         sy = 1 if y1 < y2 else -1
         err = dx - dy
-    
+
         half_w = width // 2
         h, w = layer.shape[:2]
-    
+
         while True:
             # Draw a filled circle for thickness
-            yy, xx = np.ogrid[-half_w:half_w + 1, -half_w:half_w + 1]
+            yy, xx = np.ogrid[-half_w : half_w + 1, -half_w : half_w + 1]
             mask = xx**2 + yy**2 <= half_w**2
             y_min = max(0, y1 - half_w)
             y_max = min(h, y1 + half_w + 1)
             x_min = max(0, x1 - half_w)
             x_max = min(w, x1 + half_w + 1)
-    
+
             submask = mask[
-                (y_min - (y1 - half_w)):(y_max - (y1 - half_w)),
-                (x_min - (x1 - half_w)):(x_max - (x1 - half_w))
+                (y_min - (y1 - half_w)) : (y_max - (y1 - half_w)),
+                (x_min - (x1 - half_w)) : (x_max - (x1 - half_w)),
             ]
             layer[y_min:y_max, x_min:x_max][submask] = blended_color
-    
+
             if x1 == x2 and y1 == y2:
                 break
-    
+
             e2 = 2 * err
             if e2 > -dy:
                 err -= dy
@@ -297,24 +299,22 @@ class Drawable:
             if e2 < dx:
                 err += dx
                 y1 += sy
-    
+
+        return layer
+
+    @staticmethod
+    async def draw_virtual_walls(
+        layer: NumpyArray, virtual_walls, color: Color
+    ) -> NumpyArray:
+        """
+        Draw virtual walls on the input layer.
+        """
+        for wall in virtual_walls:
+            for i in range(0, len(wall), 4):
+                x1, y1, x2, y2 = wall[i : i + 4]
+                # Draw the virtual wall as a line with a fixed width of 6 pixels
+                layer = Drawable._line(layer, x1, y1, x2, y2, color, width=6)
         return layer
-    
-    
-    
-        @staticmethod
-        async def draw_virtual_walls(
-            layer: NumpyArray, virtual_walls, color: Color
-        ) -> NumpyArray:
-            """
-            Draw virtual walls on the input layer.
-            """
-            for wall in virtual_walls:
-                for i in range(0, len(wall), 4):
-                    x1, y1, x2, y2 = wall[i : i + 4]
-                    # Draw the virtual wall as a line with a fixed width of 6 pixels
-                    layer = Drawable._line(layer, x1, y1, x2, y2, color, width=6)
-            return layer
 
     @staticmethod
     async def lines(arr: NumpyArray, coords, width: int, color: Color) -> NumpyArray:
@@ -482,57 +482,58 @@ class Drawable:
     @staticmethod
     async def zones(layers: NumpyArray, coordinates, color: Color) -> NumpyArray:
         """
-        Draw the zones on the input layer with color blending.
-        Optimized with NumPy vectorized operations for better performance.
+        Draw zones as solid filled polygons with alpha blending using a per-zone mask.
+        Keeps API the same; no dotted rendering.
         """
-        dot_radius = 1  # Number of pixels for the dot
-        dot_spacing = 4  # Space between dots
+        if not coordinates:
+            return layers
+
+        height, width = layers.shape[:2]
+        # Precompute color and alpha
+        r, g, b, a = color
+        alpha = a / 255.0
+        inv_alpha = 1.0 - alpha
+        color_rgb = np.array([r, g, b], dtype=np.float32)
 
         for zone in coordinates:
-            points = zone["points"]
-            min_x = max(0, min(points[::2]))
-            max_x = min(layers.shape[1] - 1, max(points[::2]))
-            min_y = max(0, min(points[1::2]))
-            max_y = min(layers.shape[0] - 1, max(points[1::2]))
+            try:
+                pts = zone["points"]
+            except (KeyError, TypeError):
+                continue
+            if not pts or len(pts) < 6:
+                continue
 
-            # Skip if zone is outside the image
+            # Compute bounding box and clamp
+            min_x = max(0, int(min(pts[::2])))
+            max_x = min(width - 1, int(max(pts[::2])))
+            min_y = max(0, int(min(pts[1::2])))
+            max_y = min(height - 1, int(max(pts[1::2])))
             if min_x >= max_x or min_y >= max_y:
                 continue
 
-            # Sample a point from the zone to get the background color
-            # Use the center of the zone for sampling
-            sample_x = (min_x + max_x) // 2
-            sample_y = (min_y + max_y) // 2
-
-            # Blend the color with the background color at the sample point
-            if 0 <= sample_y < layers.shape[0] and 0 <= sample_x < layers.shape[1]:
-                blended_color = ColorsManagement.sample_and_blend_color(
-                    layers, sample_x, sample_y, color
-                )
-            else:
-                blended_color = color
-
-            # Create a grid of dot centers
-            x_centers = np.arange(min_x, max_x, dot_spacing)
-            y_centers = np.arange(min_y, max_y, dot_spacing)
-
-            # Draw dots at each grid point
-            for y in y_centers:
-                for x in x_centers:
-                    # Create a small mask for the dot
-                    y_min = max(0, y - dot_radius)
-                    y_max = min(layers.shape[0], y + dot_radius + 1)
-                    x_min = max(0, x - dot_radius)
-                    x_max = min(layers.shape[1], x + dot_radius + 1)
-
-                    # Create coordinate arrays for the dot
-                    y_indices, x_indices = np.ogrid[y_min:y_max, x_min:x_max]
-
-                    # Create a circular mask
-                    mask = (y_indices - y) ** 2 + (x_indices - x) ** 2 <= dot_radius**2
+            # Adjust polygon points to local bbox coordinates
+            poly_xy = [
+                (int(pts[i] - min_x), int(pts[i + 1] - min_y))
+                for i in range(0, len(pts), 2)
+            ]
+            box_w = max_x - min_x + 1
+            box_h = max_y - min_y + 1
+
+            # Build mask via PIL polygon fill (fast, C-impl)
+            mask_img = Image.new("L", (box_w, box_h), 0)
+            draw = ImageDraw.Draw(mask_img)
+            draw.polygon(poly_xy, fill=255)
+            zone_mask = np.array(mask_img, dtype=bool)
+            if not np.any(zone_mask):
+                continue
 
-                    # Apply the color to the masked region
-                    layers[y_min:y_max, x_min:x_max][mask] = blended_color
+            # Vectorized alpha blend on RGB channels only
+            region = layers[min_y : max_y + 1, min_x : max_x + 1]
+            rgb = region[..., :3].astype(np.float32)
+            mask3 = zone_mask[:, :, None]
+            blended_rgb = np.where(mask3, rgb * inv_alpha + color_rgb * alpha, rgb)
+            region[..., :3] = blended_rgb.astype(np.uint8)
+            # Leave alpha channel unchanged to avoid stacking transparency
 
         return layers
 
@@ -814,60 +815,60 @@ class Drawable:
         image: np.ndarray, obstacle_info_list, color: Color
     ) -> np.ndarray:
         """
-        Optimized async version of draw_obstacles using batch processing.
-        Includes color blending for better visual integration.
+        Optimized async version of draw_obstacles using a precomputed mask
+        and minimal Python overhead. Handles hundreds of obstacles efficiently.
         """
         if not obstacle_info_list:
             return image
 
-        # Extract alpha from color
+        h, w = image.shape[:2]
         alpha = color[3] if len(color) == 4 else 255
         need_blending = alpha < 255
 
-        # Extract obstacle centers and prepare for batch processing
+        # Precompute circular mask for radius
+        radius = 6
+        diameter = radius * 2 + 1
+        yy, xx = np.ogrid[-radius : radius + 1, -radius : radius + 1]
+        circle_mask = (xx**2 + yy**2) <= radius**2
+
+        # Collect valid obstacles
         centers = []
         for obs in obstacle_info_list:
             try:
                 x = obs["points"]["x"]
                 y = obs["points"]["y"]
 
-                # Skip if coordinates are out of bounds
-                if not (0 <= x < image.shape[1] and 0 <= y < image.shape[0]):
+                if not (0 <= x < w and 0 <= y < h):
                     continue
 
-                # Apply color blending if needed
-                obstacle_color = color
                 if need_blending:
-                    obstacle_color = ColorsManagement.sample_and_blend_color(
+                    obs_color = ColorsManagement.sample_and_blend_color(
                         image, x, y, color
                     )
+                else:
+                    obs_color = color
 
-                # Add to centers list with radius
-                centers.append({"center": (x, y), "radius": 6, "color": obstacle_color})
+                centers.append((x, y, obs_color))
             except (KeyError, TypeError):
                 continue
 
-        # Draw each obstacle with its blended color
-        if centers:
-            for obstacle in centers:
-                cx, cy = obstacle["center"]
-                radius = obstacle["radius"]
-                obs_color = obstacle["color"]
-
-                # Create a small mask for the obstacle
-                min_y = max(0, cy - radius)
-                max_y = min(image.shape[0], cy + radius + 1)
-                min_x = max(0, cx - radius)
-                max_x = min(image.shape[1], cx + radius + 1)
+        # Draw all obstacles
+        for cx, cy, obs_color in centers:
+            min_y = max(0, cy - radius)
+            max_y = min(h, cy + radius + 1)
+            min_x = max(0, cx - radius)
+            max_x = min(w, cx + radius + 1)
 
-                # Create coordinate arrays for the circle
-                y_indices, x_indices = np.ogrid[min_y:max_y, min_x:max_x]
+            # Slice mask to fit image edges
+            mask_y_start = min_y - (cy - radius)
+            mask_y_end = mask_y_start + (max_y - min_y)
+            mask_x_start = min_x - (cx - radius)
+            mask_x_end = mask_x_start + (max_x - min_x)
 
-                # Create a circular mask
-                mask = (y_indices - cy) ** 2 + (x_indices - cx) ** 2 <= radius**2
+            mask = circle_mask[mask_y_start:mask_y_end, mask_x_start:mask_x_end]
 
-                # Apply the color to the masked region
-                image[min_y:max_y, min_x:max_x][mask] = obs_color
+            # Apply color in one vectorized step
+            image[min_y:max_y, min_x:max_x][mask] = obs_color
 
         return image
 

{valetudo_map_parser-0.1.9b72 → valetudo_map_parser-0.1.9b74}/SCR/valetudo_map_parser/config/utils.py

@@ -1,6 +1,7 @@
 """Utility code for the valetudo map parser."""
 
 import datetime
+from time import time
 import hashlib
 import json
 from dataclasses import dataclass
@@ -136,26 +137,16 @@ class BaseHandler:
 
                 # Convert to binary (PNG bytes) if requested
                 if bytes_format:
-                    try:
-                        png_buffer = io.BytesIO()
-                        new_image.save(png_buffer, format="PNG")
-                        self.shared.binary_image = png_buffer.getvalue()
-                        png_buffer.close()
-                        LOGGER.debug(
-                            "%s: Binary image conversion completed", self.file_name
-                        )
-                    except Exception as e:
-                        LOGGER.warning(
-                            "%s: Failed to convert image to binary: %s",
-                            self.file_name,
-                            str(e),
-                        )
-                        self.shared.binary_image = None
+                    with io.BytesIO() as buf:
+                        new_image.save(buf, format="PNG", compress_level=1)
+                        self.shared.binary_image = buf.getvalue()
+                    LOGGER.debug(
+                        "%s: Binary image conversion completed", self.file_name
+                    )
                 else:
                     self.shared.binary_image = None
-
                 # Update the timestamp with current datetime
-                self.shared.image_last_updated = datetime.datetime.now().timestamp()
+                self.shared.image_last_updated = datetime.datetime.fromtimestamp(time())
                 LOGGER.debug(
                     "%s: Image processed and stored in shared data", self.file_name
                 )

{valetudo_map_parser-0.1.9b72 → valetudo_map_parser-0.1.9b74}/SCR/valetudo_map_parser/hypfer_handler.py

@@ -59,7 +59,9 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
         self.go_to = None  # vacuum go to data
         self.img_hash = None  # hash of the image calculated to check differences.
         self.img_base_layer = None  # numpy array store the map base layer.
-        self.img_work_layer = None  # persistent working buffer to avoid per-frame allocations
+        self.img_work_layer = (
+            None  # persistent working buffer to avoid per-frame allocations
+        )
         self.active_zones = None  # vacuum active zones.
         self.svg_wait = False  # SVG image creation wait.
         self.imd = ImDraw(self)  # Image Draw class.
@@ -216,7 +218,9 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                             is_wall_layer = layer_type == "wall"
                             if is_wall_layer:
                                 # Skip walls entirely if disabled
-                                if not self.drawing_config.is_enabled(DrawableElement.WALL):
+                                if not self.drawing_config.is_enabled(
+                                    DrawableElement.WALL
+                                ):
                                     continue
                             # Draw the layer
                             (
@@ -274,7 +278,6 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                     # Copy the new array in base layer.
                     self.img_base_layer = await self.async_copy_array(img_np_array)
 
-
                 self.shared.frame_number = self.frame_number
                 self.frame_number += 1
                 if (self.frame_number >= self.max_frames) or (

{valetudo_map_parser-0.1.9b72 → valetudo_map_parser-0.1.9b74}/SCR/valetudo_map_parser/map_data.py

@@ -9,8 +9,8 @@ Version: v0.1.6
 from __future__ import annotations
 
 import numpy as np
-import pandas as pd
-from .config.types import ImageSize, JsonType
+
+from SCR.valetudo_map_parser.config.types import ImageSize, JsonType
 
 
 class ImageData:
@@ -18,35 +18,45 @@ class ImageData:
 
     @staticmethod
     def sublist(lst, n):
-        """Split a list into n chunks of specified size."""
+        """Sub lists of specific n number of elements"""
         return [lst[i : i + n] for i in range(0, len(lst), n)]
 
     @staticmethod
     def sublist_join(lst, n):
-        """Join the lists in a unique list of n elements."""
+        """Join the lists in a unique list of n elements"""
         arr = np.array(lst)
         num_windows = len(lst) - n + 1
         result = [arr[i : i + n].tolist() for i in range(num_windows)]
         return result
 
+    # The below functions are basically the same ech one
+    # of them is allowing filtering and putting together in a
+    # list the specific Layers, Paths, Zones and Pints in the
+    # Vacuums Json in parallel.
+
     @staticmethod
     def get_obstacles(entity_dict: dict) -> list:
         """Get the obstacles positions from the entity data."""
-        obstacles = entity_dict.get("obstacle", [])
+        try:
+            obstacle_data = entity_dict.get("obstacle")
+        except KeyError:
+            return []
         obstacle_positions = []
-        for obstacle in obstacles:
-            label = obstacle.get("metaData", {}).get("label")
-            points = obstacle.get("points", [])
-            image_id = obstacle.get("metaData", {}).get("id")
-            if label and points:
-                obstacle_positions.append(
-                    {
+        if obstacle_data:
+            for obstacle in obstacle_data:
+                label = obstacle.get("metaData", {}).get("label")
+                points = obstacle.get("points", [])
+                image_id = obstacle.get("metaData", {}).get("id")
+
+                if label and points:
+                    obstacle_pos = {
                         "label": label,
                         "points": {"x": points[0], "y": points[1]},
                         "id": image_id,
                     }
-                )
-        return obstacle_positions
+                    obstacle_positions.append(obstacle_pos)
+            return obstacle_positions
+        return []
 
     @staticmethod
     def find_layers(
@@ -56,16 +66,17 @@ class ImageData:
         layer_dict = {} if layer_dict is None else layer_dict
         active_list = [] if active_list is None else active_list
         if isinstance(json_obj, dict):
-            if json_obj.get("__class") == "MapLayer":
+            if "__class" in json_obj and json_obj["__class"] == "MapLayer":
                 layer_type = json_obj.get("type")
                 active_type = json_obj.get("metaData")
                 if layer_type:
-                    layer_dict.setdefault(layer_type, []).append(
-                        json_obj.get("compressedPixels", [])
-                    )
+                    if layer_type not in layer_dict:
+                        layer_dict[layer_type] = []
+                    layer_dict[layer_type].append(json_obj.get("compressedPixels", []))
                 if layer_type == "segment":
-                    active_list.append(int(active_type.get("active", 0)))
-            for value in json_obj.values():
+                    active_list.append(int(active_type["active"]))
+
+            for value in json_obj.items():
                 ImageData.find_layers(value, layer_dict, active_list)
         elif isinstance(json_obj, list):
             for item in json_obj:
@@ -75,7 +86,8 @@ class ImageData:
     @staticmethod
     def find_points_entities(json_obj: JsonType, entity_dict: dict = None) -> dict:
         """Find the points entities in the json object."""
-        entity_dict = {} if entity_dict is None else entity_dict
+        if entity_dict is None:
+            entity_dict = {}
         if isinstance(json_obj, dict):
             if json_obj.get("__class") == "PointMapEntity":
                 entity_type = json_obj.get("type")
@@ -91,7 +103,9 @@ class ImageData:
     @staticmethod
     def find_paths_entities(json_obj: JsonType, entity_dict: dict = None) -> dict:
         """Find the paths entities in the json object."""
-        entity_dict = {} if entity_dict is None else entity_dict
+
+        if entity_dict is None:
+            entity_dict = {}
         if isinstance(json_obj, dict):
             if json_obj.get("__class") == "PathMapEntity":
                 entity_type = json_obj.get("type")
@@ -107,7 +121,8 @@ class ImageData:
     @staticmethod
     def find_zone_entities(json_obj: JsonType, entity_dict: dict = None) -> dict:
         """Find the zone entities in the json object."""
-        entity_dict = {} if entity_dict is None else entity_dict
+        if entity_dict is None:
+            entity_dict = {}
         if isinstance(json_obj, dict):
             if json_obj.get("__class") == "PolygonMapEntity":
                 entity_type = json_obj.get("type")
@@ -123,46 +138,59 @@ class ImageData:
     @staticmethod
     def find_virtual_walls(json_obj: JsonType) -> list:
         """Find the virtual walls in the json object."""
-        walls = []
+        virtual_walls = []
 
-        def _recursive(obj):
+        def find_virtual_walls_recursive(obj):
+            """Find the virtual walls in the json object recursively."""
             if isinstance(obj, dict):
-                if (
-                    obj.get("__class") == "LineMapEntity"
-                    and obj.get("type") == "virtual_wall"
-                ):
-                    walls.append(obj["points"])
+                if obj.get("__class") == "LineMapEntity":
+                    entity_type = obj.get("type")
+                    if entity_type == "virtual_wall":
+                        virtual_walls.append(obj["points"])
                 for value in obj.values():
-                    _recursive(value)
+                    find_virtual_walls_recursive(value)
             elif isinstance(obj, list):
                 for item in obj:
-                    _recursive(item)
+                    find_virtual_walls_recursive(item)
 
-        _recursive(json_obj)
-        return walls
+        find_virtual_walls_recursive(json_obj)
+        return virtual_walls
 
     @staticmethod
     async def async_get_rooms_coordinates(
         pixels: list, pixel_size: int = 5, rand: bool = False
     ) -> tuple:
-        """Extract the room coordinates from the vacuum pixels data."""
-        df = pd.DataFrame(pixels, columns=["x", "y", "length"])
-        if rand:
-            df["x_end"] = df["x"]
-            df["y_end"] = df["y"] + pixel_size
-        else:
-            df["x_end"] = df["x"] + df["length"]
-            df["y_end"] = df["y"] + pixel_size
-
-        min_x, max_x = df["x"].min(), df["x_end"].max()
-        min_y, max_y = df["y"].min(), df["y_end"].max()
-
+        """
+        Extract the room coordinates from the vacuum pixels data.
+        piexels: dict: The pixels data format [[x,y,z], [x1,y1,z1], [xn,yn,zn]].
+        pixel_size: int: The size of the pixel in mm (optional).
+        rand: bool: Return the coordinates in a rand256 format (optional).
+        """
+        # Initialize variables to store max and min coordinates
+        max_x, max_y = pixels[0][0], pixels[0][1]
+        min_x, min_y = pixels[0][0], pixels[0][1]
+        # Iterate through the data list to find max and min coordinates
+        for entry in pixels:
+            if rand:
+                x, y, _ = entry  # Extract x and y coordinates
+                max_x = max(max_x, x)  # Update max x coordinate
+                max_y = max(max_y, y + pixel_size)  # Update max y coordinate
+                min_x = min(min_x, x)  # Update min x coordinate
+                min_y = min(min_y, y)  # Update min y coordinate
+            else:
+                x, y, z = entry  # Extract x and y coordinates
+                max_x = max(max_x, x + z)  # Update max x coordinate
+                max_y = max(max_y, y + pixel_size)  # Update max y coordinate
+                min_x = min(min_x, x)  # Update min x coordinate
+                min_y = min(min_y, y)  # Update min y coordinate
         if rand:
             return (
-                ((max_x * pixel_size) * 10, (max_y * pixel_size) * 10),
-                ((min_x * pixel_size) * 10, (min_y * pixel_size) * 10),
+                (((max_x * pixel_size) * 10), ((max_y * pixel_size) * 10)),
+                (
+                    ((min_x * pixel_size) * 10),
+                    ((min_y * pixel_size) * 10),
+                ),
             )
-
         return (
             min_x * pixel_size,
             min_y * pixel_size,

{valetudo_map_parser-0.1.9b72 → valetudo_map_parser-0.1.9b74}/SCR/valetudo_map_parser/reimg_draw.py

@@ -9,6 +9,7 @@ from __future__ import annotations
 import logging
 
 from .config.drawable import Drawable
+from .config.drawable_elements import DrawableElement
 from .config.types import Color, JsonType, NumpyArray
 from .map_data import ImageData, RandImageData
 
@@ -107,16 +108,18 @@ class ImageDraw:
                 color_wall,
                 color_zone_clean,
             )
-            img_np_array = await self._draw_walls(
-                img_np_array,
-                walls_data,
-                size_x,
-                size_y,
-                pos_top,
-                pos_left,
-                pixel_size,
-                color_wall,
-            )
+            # Draw walls only if enabled in drawing config
+            if self.img_h.drawing_config.is_enabled(DrawableElement.WALL):
+                img_np_array = await self._draw_walls(
+                    img_np_array,
+                    walls_data,
+                    size_x,
+                    size_y,
+                    pos_top,
+                    pos_left,
+                    pixel_size,
+                    color_wall,
+                )
         return room_id, img_np_array
 
     async def _draw_floor(

{valetudo_map_parser-0.1.9b72 → valetudo_map_parser-0.1.9b74}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "valetudo-map-parser"
-version = "0.1.9b72"
+version = "0.1.9b74"
 description = "A Python library to parse Valetudo map data returning a PIL Image object."
 authors = ["Sandro Cantarella <gsca075@gmail.com>"]
 license = "Apache-2.0"
@@ -18,7 +18,6 @@ python = ">=3.12"
 numpy = ">=1.26.4"
 Pillow = ">=10.3.0"
 scipy = ">=1.12.0"
-pandas = ">=2.3.0"
 
 [tool.poetry.group.dev.dependencies]
 ruff = "*"