0.1.12 Release Ready

SCR/valetudo_map_parser/__init__.py

@@ -54,14 +54,14 @@
     CONF_OFFSET_TOP,
     CONF_SNAPSHOTS_ENABLE,
     CONF_TRIMS_SAVE,
-    CONF_VACUUM_CONFIG_ENTRY_ID,
-    CONF_VACUUM_CONNECTION_STRING,
-    CONF_VACUUM_ENTITY_ID,
-    CONF_VACUUM_IDENTIFIERS,
     CONF_VAC_STAT,
     CONF_VAC_STAT_FONT,
     CONF_VAC_STAT_POS,
     CONF_VAC_STAT_SIZE,
+    CONF_VACUUM_CONFIG_ENTRY_ID,
+    CONF_VACUUM_CONNECTION_STRING,
+    CONF_VACUUM_ENTITY_ID,
+    CONF_VACUUM_IDENTIFIERS,
     CONF_ZOOM_LOCK_RATIO,
     DECODED_TOPICS,
     DEFAULT_IMAGE_SIZE,

SCR/valetudo_map_parser/config/async_utils.py

@@ -49,7 +49,7 @@ async def async_resize(
     ) -> Image.Image:
         """Async image resizing."""
         if resample is None:
-            resample = Image.LANCZOS
+            resample = Image.Resampling.LANCZOS
         return await make_async(image.resize, size, resample)
 
     @staticmethod

SCR/valetudo_map_parser/config/colors.py

@@ -61,6 +61,7 @@
 )
 from .types import LOGGER, Color
 
+
 color_transparent = (0, 0, 0, 0)
 color_charger = (0, 128, 0, 255)
 color_move = (238, 247, 255, 255)

SCR/valetudo_map_parser/config/drawable.py

@@ -12,7 +12,7 @@
 
 import logging
 from pathlib import Path
-from typing import Tuple, Union
+from typing import Union
 
 import numpy as np
 from mvcrender.blend import get_blended_color, sample_and_blend_color
@@ -205,24 +205,6 @@ async def go_to_flag(
         layer = Drawable._line(layer, xp1, yp1, xp2, yp2, pole_color, pole_width)
         return layer
 
-    @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."""
-        n = len(points)
-        inside = False
-        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:
-                        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: NumpyArray,
@@ -329,56 +311,6 @@ def _ellipse(
         image[y1:y2, x1:x2] = color
         return image
 
-    @staticmethod
-    def _polygon_outline(
-        arr: NumpyArray,
-        points: list[Tuple[int, int]],
-        width: int,
-        outline_color: Color,
-        fill_color: Color = None,
-    ) -> NumpyArray:
-        """
-        Draw the outline of a polygon on the array using _line, and optionally fill it.
-        Uses NumPy vectorized operations for improved performance.
-        """
-        # Draw the outline
-        for i, _ in enumerate(points):
-            current_point = points[i]
-            next_point = points[(i + 1) % len(points)]
-            arr = Drawable._line(
-                arr,
-                current_point[0],
-                current_point[1],
-                next_point[0],
-                next_point[1],
-                outline_color,
-                width,
-            )
-
-        # Fill the polygon if a fill color is provided
-        if fill_color is not None:
-            # Get the bounding box of the polygon
-            min_x = max(0, min(p[0] for p in points))
-            max_x = min(arr.shape[1] - 1, max(p[0] for p in points))
-            min_y = max(0, min(p[1] for p in points))
-            max_y = min(arr.shape[0] - 1, max(p[1] for p in points))
-
-            # Create a mask for the polygon region
-            mask = np.zeros((max_y - min_y + 1, max_x - min_x + 1), dtype=bool)
-
-            # Adjust points to the mask's coordinate system
-            adjusted_points = [(p[0] - min_x, p[1] - min_y) for p in points]
-
-            # Test each point in the grid
-            for i in range(mask.shape[0]):
-                for j in range(mask.shape[1]):
-                    mask[i, j] = Drawable.point_inside(j, i, adjusted_points)
-
-            # Apply the fill color to the masked region
-            arr[min_y : max_y + 1, min_x : max_x + 1][mask] = fill_color
-
-        return arr
-
     @staticmethod
     async def zones(layers: NumpyArray, coordinates, color: Color) -> NumpyArray:
         """
@@ -420,14 +352,18 @@ async def zones(layers: NumpyArray, coordinates, color: Color) -> NumpyArray:
             mask_rgba = np.zeros((box_h, box_w, 4), dtype=np.uint8)
 
             # Convert points to xs, ys arrays (adjusted to local bbox coordinates)
-            xs = np.array([int(pts[i] - min_x) for i in range(0, len(pts), 2)], dtype=np.int32)
-            ys = np.array([int(pts[i] - min_y) for i in range(1, len(pts), 2)], dtype=np.int32)
+            xs = np.array(
+                [int(pts[i] - min_x) for i in range(0, len(pts), 2)], dtype=np.int32
+            )
+            ys = np.array(
+                [int(pts[i] - min_y) for i in range(1, len(pts), 2)], dtype=np.int32
+            )
 
             # Draw filled polygon on mask
             polygon_u8(mask_rgba, xs, ys, (0, 0, 0, 0), 0, (255, 255, 255, 255))
 
             # Extract boolean mask from first channel
-            zone_mask = (mask_rgba[:, :, 0] > 0)
+            zone_mask = mask_rgba[:, :, 0] > 0
             del mask_rgba
             del xs
             del ys