valetudo-map-parser 0.1.9b75__py3-none-any.whl → 0.1.10__py3-none-any.whl

valetudo_map_parser/__init__.py

@@ -1,31 +1,46 @@
 """Valetudo map parser.
-Version: 0.1.9"""
+Version: 0.1.10"""
+
+from pathlib import Path
 
 from .config.colors import ColorsManagement
 from .config.drawable import Drawable
 from .config.drawable_elements import DrawableElement, DrawingConfig
-from .config.enhanced_drawable import EnhancedDrawable
 from .config.rand256_parser import RRMapParser
 from .config.shared import CameraShared, CameraSharedManager
+from .config.status_text.status_text import StatusText
+from .config.status_text.translations import translations as STATUS_TEXT_TRANSLATIONS
 from .config.types import (
     CameraModes,
+    ImageSize,
+    JsonType,
+    NumpyArray,
+    PilPNG,
     RoomsProperties,
     RoomStore,
     SnapshotStore,
     TrimCropData,
     UserLanguageStore,
-    JsonType,
-    PilPNG,
-    NumpyArray,
 )
 from .hypfer_handler import HypferMapImageHandler
+from .map_data import HyperMapData
 from .rand256_handler import ReImageHandler
-from .rooms_handler import RoomsHandler, RandRoomsHandler
+from .rooms_handler import RandRoomsHandler, RoomsHandler
+
+
+def get_default_font_path() -> str:
+    """Return the absolute path to the bundled default font directory.
+
+    This returns the path to the fonts folder; the caller can join a specific font file
+    to avoid hard-coding a particular font here.
+    """
+    return str((Path(__file__).resolve().parent / "config" / "fonts").resolve())
 
 
 __all__ = [
     "RoomsHandler",
     "RandRoomsHandler",
+    "HyperMapData",
     "HypferMapImageHandler",
     "ReImageHandler",
     "RRMapParser",
@@ -35,7 +50,6 @@ __all__ = [
     "Drawable",
     "DrawableElement",
     "DrawingConfig",
-    "EnhancedDrawable",
     "SnapshotStore",
     "UserLanguageStore",
     "RoomStore",
@@ -45,4 +59,8 @@ __all__ = [
     "JsonType",
     "PilPNG",
     "NumpyArray",
+    "ImageSize",
+    "StatusText",
+    "STATUS_TEXT_TRANSLATIONS",
+    "get_default_font_path",
 ]

valetudo_map_parser/config/auto_crop.py

@@ -6,10 +6,9 @@ from __future__ import annotations
 import logging
 
 import numpy as np
-from numpy import rot90
 from scipy import ndimage
 
-from .async_utils import AsyncNumPy, make_async
+from .async_utils import AsyncNumPy
 from .types import Color, NumpyArray, TrimCropData, TrimsData
 from .utils import BaseHandler
 
@@ -91,7 +90,6 @@ class AutoCrop:
 
     async def _async_auto_crop_data(self, tdata: TrimsData):  # , tdata=None
         """Load the auto crop data from the Camera config."""
-        _LOGGER.debug("Auto Crop init data: %s, %s", str(tdata), str(self.auto_crop))
         if not self.auto_crop:
             trims_data = TrimCropData.from_dict(dict(tdata.to_dict())).to_list()
             (
@@ -100,7 +98,6 @@ class AutoCrop:
                 self.trim_right,
                 self.trim_down,
             ) = trims_data
-            _LOGGER.debug("Auto Crop trims data: %s", trims_data)
             if trims_data != [0, 0, 0, 0]:
                 self._calculate_trimmed_dimensions()
             else:
@@ -118,10 +115,6 @@ class AutoCrop:
 
     async def _init_auto_crop(self):
         """Initialize the auto crop data."""
-        _LOGGER.debug("Auto Crop Init data: %s", str(self.auto_crop))
-        _LOGGER.debug(
-            "Auto Crop Init trims data: %r", self.handler.shared.trims.to_dict()
-        )
         if not self.auto_crop:  # and self.handler.shared.vacuum_state == "docked":
             self.auto_crop = await self._async_auto_crop_data(self.handler.shared.trims)
             if self.auto_crop:
@@ -131,7 +124,6 @@ class AutoCrop:
 
         # Fallback: Ensure auto_crop is valid
         if not self.auto_crop or any(v < 0 for v in self.auto_crop):
-            _LOGGER.debug("Auto-crop data unavailable. Scanning full image.")
             self.auto_crop = None
 
         return self.auto_crop
@@ -164,14 +156,6 @@ class AutoCrop:
         min_y, max_y = y_slice.start, y_slice.stop - 1
         min_x, max_x = x_slice.start, x_slice.stop - 1
 
-        _LOGGER.debug(
-            "%s: Found trims max and min values (y,x) (%s, %s) (%s, %s)...",
-            self.handler.file_name,
-            int(max_y),
-            int(max_x),
-            int(min_y),
-            int(min_x),
-        )
         return min_y, min_x, max_x, max_y
 
     async def async_get_room_bounding_box(
@@ -247,7 +231,7 @@ class AutoCrop:
             return None
 
         except Exception as e:
-            _LOGGER.error(
+            _LOGGER.warning(
                 "%s: Error calculating room bounding box for '%s': %s",
                 self.handler.file_name,
                 room_name,
@@ -403,7 +387,6 @@ class AutoCrop:
         try:
             self.auto_crop = await self._init_auto_crop()
             if (self.auto_crop is None) or (self.auto_crop == [0, 0, 0, 0]):
-                _LOGGER.debug("%s: Calculating auto trim box", self.handler.file_name)
                 # Find the coordinates of the first occurrence of a non-background color
                 min_y, min_x, max_x, max_y = await self.async_image_margins(
                     image_array, detect_colour
@@ -456,15 +439,7 @@ class AutoCrop:
             # Rotate the cropped image based on the given angle
             rotated = await self.async_rotate_the_image(trimmed, rotate)
             del trimmed  # Free memory.
-            _LOGGER.debug(
-                "%s: Auto Trim Box data: %s", self.handler.file_name, self.crop_area
-            )
             self.handler.crop_img_size = [rotated.shape[1], rotated.shape[0]]
-            _LOGGER.debug(
-                "%s: Auto Trimmed image size: %s",
-                self.handler.file_name,
-                self.handler.crop_img_size,
-            )
 
         except RuntimeError as e:
             _LOGGER.warning(

valetudo_map_parser/config/color_utils.py

@@ -1,8 +1,7 @@
 """Utility functions for color operations in the map parser."""
 
-from typing import Optional, Tuple
+from typing import Optional
 
-from .colors import ColorsManagement
 from .types import Color, NumpyArray
 
 
@@ -36,8 +35,8 @@ def get_blended_color(
         # Sample background at midpoint
         mid_x, mid_y = (x0 + x1) // 2, (y0 + y1) // 2
         if 0 <= mid_y < arr.shape[0] and 0 <= mid_x < arr.shape[1]:
-            return tuple(arr[mid_y, mid_x])
-        return (0, 0, 0, 0)  # Default if out of bounds
+            return Color(arr[mid_y, mid_x])
+        return Color(0, 0, 0, 0)  # Default if out of bounds
 
     # Calculate direction vector for offset sampling
     dx = x1 - x0

valetudo_map_parser/config/colors.py

@@ -250,7 +250,7 @@ class ColorsManagement:
             List[Tuple[int, int, int, int]]: List of RGBA colors with alpha channel added.
         """
         if len(alpha_channels) != len(rgb_colors):
-            LOGGER.error("Input lists must have the same length.")
+            LOGGER.warning("Input lists must have the same length.")
             return []
 
         # Fast path for empty lists
@@ -357,7 +357,7 @@ class ColorsManagement:
             self.color_cache.clear()
 
         except (ValueError, IndexError, UnboundLocalError) as e:
-            LOGGER.error("Error while populating colors: %s", e)
+            LOGGER.warning("Error while populating colors: %s", e)
 
     def initialize_user_colors(self, device_info: dict) -> List[Color]:
         """

valetudo_map_parser/config/drawable.py

@@ -11,13 +11,13 @@ Optimized with NumPy and SciPy for better performance.
 from __future__ import annotations
 
 import logging
-import math
+from pathlib import Path
 
 import numpy as np
+from mvcrender.blend import get_blended_color, sample_and_blend_color
+from mvcrender.draw import circle_u8, line_u8
 from PIL import Image, ImageDraw, ImageFont
 
-from .color_utils import get_blended_color
-from .colors import ColorsManagement
 from .types import Color, NumpyArray, PilPNG, Point, Tuple, Union
 
 
@@ -85,7 +85,7 @@ class Drawable:
                         and 0 <= center_x < image_array.shape[1]
                     ):
                         # Get blended color
-                        blended_color = ColorsManagement.sample_and_blend_color(
+                        blended_color = sample_and_blend_color(
                             image_array, center_x, center_y, full_color
                         )
                         # Apply blended color to the region
@@ -131,9 +131,7 @@ class Drawable:
             center_x = (start_col + end_col) // 2
 
             # Get blended color
-            blended_color = ColorsManagement.sample_and_blend_color(
-                layers, center_x, center_y, color
-            )
+            blended_color = sample_and_blend_color(layers, center_x, center_y, color)
 
             # Apply blended color
             layers[start_row:end_row, start_col:end_col] = blended_color
@@ -160,23 +158,24 @@ class Drawable:
 
         # Get blended colors for flag and pole
         flag_alpha = flag_color[3] if len(flag_color) == 4 else 255
-        pole_color_base = (0, 0, 255)  # Blue for the pole
+        pole_color_base = [0, 0, 255]  # Blue for the pole
         pole_alpha = 255
 
         # Blend flag color if needed
         if flag_alpha < 255:
-            flag_color = ColorsManagement.sample_and_blend_color(
-                layer, x, y, flag_color
-            )
+            flag_color = sample_and_blend_color(layer, x, y, flag_color)
 
         # Create pole color with alpha
-        pole_color: Color = (*pole_color_base, pole_alpha)
+        pole_color: Color = (
+            pole_color_base[0],
+            pole_color_base[1],
+            pole_color_base[2],
+            pole_alpha,
+        )
 
         # Blend pole color if needed
         if pole_alpha < 255:
-            pole_color = ColorsManagement.sample_and_blend_color(
-                layer, x, y, pole_color
-            )
+            pole_color = sample_and_blend_color(layer, x, y, pole_color)
 
         flag_size = 50
         pole_width = 6
@@ -223,83 +222,37 @@ 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
+        inters_x = 0.0
         p1x, p1y = points[0]
         for i in range(1, n + 1):
             p2x, p2y = points[i % n]
             if y > min(p1y, p2y):
                 if y <= max(p1y, p2y) and x <= max(p1x, p2x):
                     if p1y != p2y:
-                        xinters = (y - p1y) * (p2x - p1x) / (p2y - p1y) + p1x
-                    if p1x == p2x or x <= xinters:
+                        inters_x = (y - p1y) * (p2x - p1x) / (p2y - p1y) + p1x
+                    if p1x == p2x or x <= inters_x:
                         inside = not inside
             p1x, p1y = p2x, p2y
         return inside
 
     @staticmethod
     def _line(
-        layer: np.ndarray,
+        layer: NumpyArray,
         x1: int,
         y1: int,
         x2: int,
         y2: int,
         color: Color,
         width: int = 3,
-    ) -> 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
-            x2, y2: End point coordinates
-            color: Color to draw with (tuple or array)
-            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]
-            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)),
-            ]
-            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
-                x1 += sx
-            if e2 < dx:
-                err += dx
-                y1 += sy
-
+    ) -> NumpyArray:
+        """Segment-aware preblend, then stamp a solid line."""
+        width = int(max(1, width))
+        # Preblend once for this segment
+        seg = get_blended_color(int(x1), int(y1), int(x2), int(y2), layer, color)
+        line_u8(layer, int(x1), int(y1), int(x2), int(y2), seg, width)
         return layer
 
     @staticmethod
@@ -317,12 +270,14 @@ class Drawable:
         return layer
 
     @staticmethod
-    async def lines(arr: NumpyArray, coords, width: int, color: Color) -> NumpyArray:
+    async def lines(
+        arr: NumpyArray, coordinates, width: int, color: Color
+    ) -> NumpyArray:
         """
         Join the coordinates creating a continuous line (path).
         Optimized with vectorized operations for better performance.
         """
-        for coord in coords:
+        for coord in coordinates:
             x0, y0 = coord[0]
             try:
                 x1, y1 = coord[1]
@@ -333,11 +288,8 @@ class Drawable:
             if x0 == x1 and y0 == y1:
                 continue
 
-            # Get blended color for this line segment
-            blended_color = get_blended_color(x0, y0, x1, y1, arr, color)
-
             # Use the optimized line drawing method
-            arr = Drawable._line(arr, x0, y0, x1, y1, blended_color, width)
+            arr = Drawable._line(arr, x0, y0, x1, y1, color, width)
 
         return arr
 
@@ -351,35 +303,31 @@ class Drawable:
         outline_width: int = 0,
     ) -> NumpyArray:
         """
-        Draw a filled circle on the image using NumPy.
-        Optimized to only process the bounding box of the circle.
+        Draw a filled circle and optional outline using mvcrender.draw.circle_u8.
+        If alpha<255, preblend once at the center and stamp solid.
         """
-        y, x = center
-        height, width = image.shape[:2]
-
-        # Calculate the bounding box of the circle
-        min_y = max(0, y - radius - outline_width)
-        max_y = min(height, y + radius + outline_width + 1)
-        min_x = max(0, x - radius - outline_width)
-        max_x = min(width, x + radius + outline_width + 1)
-
-        # Create coordinate arrays for the bounding box
-        y_indices, x_indices = np.ogrid[min_y:max_y, min_x:max_x]
-
-        # Calculate distances from center
-        dist_sq = (y_indices - y) ** 2 + (x_indices - x) ** 2
+        cy, cx = (
+            int(center[0]),
+            int(center[1]),
+        )  # incoming Point is (y,x) in your codebase
+        h, w = image.shape[:2]
+        if not (0 <= cx < w and 0 <= cy < h):
+            return image
 
-        # Create masks for the circle and outline
-        circle_mask = dist_sq <= radius**2
+        fill_rgba = color
+        if fill_rgba[3] < 255:
+            fill_rgba = sample_and_blend_color(image, cx, cy, fill_rgba)
 
-        # Apply the fill color
-        image[min_y:max_y, min_x:max_x][circle_mask] = color
+        circle_u8(image, int(cx), int(cy), int(radius), fill_rgba, -1)
 
-        # Draw the outline if needed
-        if outline_width > 0 and outline_color is not None:
-            outer_mask = dist_sq <= (radius + outline_width) ** 2
-            outline_mask = outer_mask & ~circle_mask
-            image[min_y:max_y, min_x:max_x][outline_mask] = outline_color
+        if outline_color is not None and outline_width > 0:
+            out_rgba = outline_color
+            if out_rgba[3] < 255:
+                out_rgba = sample_and_blend_color(image, cx, cy, out_rgba)
+            # outlined stroke thickness = outline_width
+            circle_u8(
+                image, int(cx), int(cy), int(radius), out_rgba, int(outline_width)
+            )
 
         return image
 
@@ -466,9 +414,6 @@ class Drawable:
             # Adjust points to the mask's coordinate system
             adjusted_points = [(p[0] - min_x, p[1] - min_y) for p in points]
 
-            # Create a grid of coordinates and use it to test all points at once
-            y_indices, x_indices = np.mgrid[0 : mask.shape[0], 0 : mask.shape[1]]
-
             # Test each point in the grid
             for i in range(mask.shape[0]):
                 for j in range(mask.shape[1]):
@@ -545,68 +490,63 @@ class Drawable:
         angle: float,
         fill: Color,
         robot_state: str | None = None,
+        radius: int = 25,  # user-configurable
     ) -> NumpyArray:
         """
-        Draw the robot on a smaller array to reduce memory cost.
-        Optimized with NumPy vectorized operations for better performance.
+        Draw the robot with configurable size. All elements scale with radius.
         """
-        # Ensure coordinates are within bounds
+        # Minimum radius to keep things visible
+        radius = max(8, min(radius, 25))
+
         height, width = layers.shape[:2]
         if not (0 <= x < width and 0 <= y < height):
             return layers
 
-        # Calculate the bounding box for the robot
-        radius = 25
-        box_size = radius * 2 + 2  # Add a small margin
-
-        # Calculate the region to draw on
+        # Bounding box
         top_left_x = max(0, x - radius - 1)
         top_left_y = max(0, y - radius - 1)
         bottom_right_x = min(width, x + radius + 1)
         bottom_right_y = min(height, y + radius + 1)
 
-        # Skip if the robot is completely outside the image
         if top_left_x >= bottom_right_x or top_left_y >= bottom_right_y:
             return layers
 
-        # Create a temporary layer for the robot
         tmp_width = bottom_right_x - top_left_x
         tmp_height = bottom_right_y - top_left_y
         tmp_layer = layers[top_left_y:bottom_right_y, top_left_x:bottom_right_x].copy()
 
-        # Calculate the robot center in the temporary layer
         tmp_x = x - top_left_x
         tmp_y = y - top_left_y
 
-        # Calculate robot parameters
-        r_scaled = radius // 11
-        r_cover = r_scaled * 12
+        # All geometry proportional to radius
+        r_scaled: float = max(1.0, radius / 11.0)
+        r_cover = int(r_scaled * 10)
+        r_lidar = max(1, int(r_scaled * 3))
+        r_button = max(1, int(r_scaled * 1))
+        lidar_offset = int(radius * 0.6)  # was fixed 15
+        button_offset = int(radius * 0.8)  # was fixed 20
+
         lidar_angle = np.deg2rad(angle + 90)
-        r_lidar = r_scaled * 3
-        r_button = r_scaled * 1
 
-        # Set colors based on robot state
         if robot_state == "error":
             outline = Drawable.ERROR_OUTLINE
             fill = Drawable.ERROR_COLOR
         else:
             outline = (fill[0] // 2, fill[1] // 2, fill[2] // 2, fill[3])
 
-        # Draw the main robot body
+        # Body
         tmp_layer = Drawable._filled_circle(
             tmp_layer, (tmp_y, tmp_x), radius, fill, outline, 1
         )
 
-        # Draw the robot direction indicator
+        # Direction wedge
         angle -= 90
-        a1 = ((angle + 90) - 80) / 180 * math.pi
-        a2 = ((angle + 90) + 80) / 180 * math.pi
-        x1 = int(tmp_x - r_cover * math.sin(a1))
-        y1 = int(tmp_y + r_cover * math.cos(a1))
-        x2 = int(tmp_x - r_cover * math.sin(a2))
-        y2 = int(tmp_y + r_cover * math.cos(a2))
-
-        # Draw the direction line
+        a1 = np.deg2rad((angle + 90) - 80)
+        a2 = np.deg2rad((angle + 90) + 80)
+        x1 = int(tmp_x - r_cover * np.sin(a1))
+        y1 = int(tmp_y + r_cover * np.cos(a1))
+        x2 = int(tmp_x - r_cover * np.sin(a2))
+        y2 = int(tmp_y + r_cover * np.cos(a2))
         if (
             0 <= x1 < tmp_width
             and 0 <= y1 < tmp_height
@@ -615,25 +555,23 @@ class Drawable:
         ):
             tmp_layer = Drawable._line(tmp_layer, x1, y1, x2, y2, outline, width=1)
 
-        # Draw the lidar indicator
-        lidar_x = int(tmp_x + 15 * np.cos(lidar_angle))
-        lidar_y = int(tmp_y + 15 * np.sin(lidar_angle))
+        # Lidar
+        lidar_x = int(tmp_x + lidar_offset * np.cos(lidar_angle))
+        lidar_y = int(tmp_y + lidar_offset * np.sin(lidar_angle))
         if 0 <= lidar_x < tmp_width and 0 <= lidar_y < tmp_height:
             tmp_layer = Drawable._filled_circle(
                 tmp_layer, (lidar_y, lidar_x), r_lidar, outline
             )
 
-        # Draw the button indicator
-        butt_x = int(tmp_x - 20 * np.cos(lidar_angle))
-        butt_y = int(tmp_y - 20 * np.sin(lidar_angle))
+        # Button
+        butt_x = int(tmp_x - button_offset * np.cos(lidar_angle))
+        butt_y = int(tmp_y - button_offset * np.sin(lidar_angle))
         if 0 <= butt_x < tmp_width and 0 <= butt_y < tmp_height:
             tmp_layer = Drawable._filled_circle(
                 tmp_layer, (butt_y, butt_x), r_button, outline
             )
 
-        # Copy the robot layer back to the main layer
         layers[top_left_y:bottom_right_y, top_left_x:bottom_right_x] = tmp_layer
-
         return layers
 
     @staticmethod
@@ -781,11 +719,11 @@ class Drawable:
                             continue
 
                         t = np.linspace(0, 1, length * 2)
-                        x_coords = np.round(x1 * (1 - t) + x2 * t).astype(int)
-                        y_coords = np.round(y1 * (1 - t) + y2 * t).astype(int)
+                        x_coordinates = np.round(x1 * (1 - t) + x2 * t).astype(int)
+                        y_coordinates = np.round(y1 * (1 - t) + y2 * t).astype(int)
 
                         # Add line points to mask
-                        for x, y in zip(x_coords, y_coords):
+                        for x, y in zip(x_coordinates, y_coordinates):
                             if width == 1:
                                 mask[y, x] = True
                             else:
@@ -827,7 +765,6 @@ class Drawable:
 
         # 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
 
@@ -842,9 +779,7 @@ class Drawable:
                     continue
 
                 if need_blending:
-                    obs_color = ColorsManagement.sample_and_blend_color(
-                        image, x, y, color
-                    )
+                    obs_color = sample_and_blend_color(image, x, y, color)
                 else:
                     obs_color = color
 
@@ -882,11 +817,25 @@ class Drawable:
         position: bool,
     ) -> None:
         """Draw the status text on the image."""
-        path_default_font = (
-            "custom_components/mqtt_vacuum_camera/utils/fonts/FiraSans.ttf"
-        )
-        default_font = ImageFont.truetype(path_default_font, size)
-        user_font = ImageFont.truetype(path_font, size)
+        module_dir = Path(__file__).resolve().parent
+        default_font_path = module_dir / "fonts" / "FiraSans.ttf"
+        # Load default font with safety fallback to PIL's built-in if missing
+        try:
+            default_font = ImageFont.truetype(str(default_font_path), size)
+        except OSError:
+            _LOGGER.warning(
+                "Default font not found at %s; using PIL default font",
+                default_font_path,
+            )
+            default_font = ImageFont.load_default()
+
+        # Use provided font directly if available; else fall back to default
+        user_font = default_font
+        if path_font:
+            try:
+                user_font = ImageFont.truetype(str(path_font), size)
+            except OSError:
+                user_font = default_font
         if position:
             x, y = 10, 10
         else:

valetudo_map_parser/config/drawable_elements.py

@@ -9,8 +9,6 @@ from __future__ import annotations
 from enum import IntEnum
 from typing import Dict, List, Tuple, Union
 
-import numpy as np
-
 from .colors import DefaultColors, SupportedColor
 from .types import LOGGER