valetudo-map-parser 0.1.10rc6__tar.gz → 0.1.11b0__tar.gz

{valetudo_map_parser-0.1.10rc6 → valetudo_map_parser-0.1.11b0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: valetudo-map-parser
-Version: 0.1.10rc6
+Version: 0.1.11b0
 Summary: A Python library to parse Valetudo map data returning a PIL Image object.
 License: Apache-2.0
 License-File: LICENSE
@@ -13,7 +13,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: Pillow (>=10.3.0)
-Requires-Dist: mvcrender (>=0.0.2)
+Requires-Dist: mvcrender (==0.0.6)
 Requires-Dist: numpy (>=1.26.4)
 Requires-Dist: scipy (>=1.12.0)
 Project-URL: Bug Tracker, https://github.com/sca075/Python-package-valetudo-map-parser/issues

{valetudo_map_parser-0.1.10rc6 → valetudo_map_parser-0.1.11b0}/SCR/valetudo_map_parser/__init__.py

@@ -6,27 +6,26 @@ 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,
-    ImageSize,
 )
-from .config.status_text.status_text import StatusText
-from .config.status_text.translations import translations as STATUS_TEXT_TRANSLATIONS
 from .hypfer_handler import HypferMapImageHandler
-from .rand256_handler import ReImageHandler
-from .rooms_handler import RoomsHandler, RandRoomsHandler
 from .map_data import HyperMapData
+from .rand256_handler import ReImageHandler
+from .rooms_handler import RandRoomsHandler, RoomsHandler
 
 
 def get_default_font_path() -> str:
@@ -51,7 +50,6 @@ __all__ = [
     "Drawable",
     "DrawableElement",
     "DrawingConfig",
-    "EnhancedDrawable",
     "SnapshotStore",
     "UserLanguageStore",
     "RoomStore",

{valetudo_map_parser-0.1.10rc6 → valetudo_map_parser-0.1.11b0}/SCR/valetudo_map_parser/config/drawable.py

@@ -14,10 +14,10 @@ import logging
 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, polygon_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
 
 
@@ -53,49 +53,30 @@ class Drawable:
     ) -> NumpyArray:
         """Draw the layers (rooms) from the vacuum JSON data onto the image array."""
         image_array = layer
-        # Extract alpha from color
-        alpha = color[3] if len(color) == 4 else 255
-
-        # Create the full color with alpha
-        full_color = color if len(color) == 4 else (*color, 255)
+        need_blending = color[3] < 255
 
-        # Check if we need to blend colors (alpha < 255)
-        need_blending = alpha < 255
-
-        # Loop through pixels to find min and max coordinates
         for x, y, z in pixels:
             col = x * pixel_size
             row = y * pixel_size
-            # Draw pixels as blocks
             for i in range(z):
-                # Get the region to update
                 region_slice = (
                     slice(row, row + pixel_size),
                     slice(col + i * pixel_size, col + (i + 1) * pixel_size),
                 )
 
                 if need_blending:
-                    # Sample the center of the region for blending
-                    center_y = row + pixel_size // 2
-                    center_x = col + i * pixel_size + pixel_size // 2
-
-                    # Only blend if coordinates are valid
+                    cy = row + pixel_size // 2
+                    cx = col + i * pixel_size + pixel_size // 2
                     if (
-                        0 <= center_y < image_array.shape[0]
-                        and 0 <= center_x < image_array.shape[1]
+                        0 <= cy < image_array.shape[0]
+                        and 0 <= cx < image_array.shape[1]
                     ):
-                        # Get blended color
-                        blended_color = ColorsManagement.sample_and_blend_color(
-                            image_array, center_x, center_y, full_color
-                        )
-                        # Apply blended color to the region
-                        image_array[region_slice] = blended_color
+                        px = sample_and_blend_color(image_array, cx, cy, color)
+                        image_array[region_slice] = px
                     else:
-                        # Use original color if out of bounds
-                        image_array[region_slice] = full_color
+                        image_array[region_slice] = color
                 else:
-                    # No blending needed, use direct assignment
-                    image_array[region_slice] = full_color
+                    image_array[region_slice] = color
 
         return image_array
 
@@ -131,9 +112,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
@@ -150,7 +129,7 @@ class Drawable:
         """
         Draw a flag centered at specified coordinates on the input layer.
         It uses the rotation angle of the image to orient the flag.
-        Includes color blending for better visual integration.
+        Uses mvcrender's polygon_u8 for efficient triangle drawing.
         """
         # Check if coordinates are within bounds
         height, width = layer.shape[:2]
@@ -165,9 +144,7 @@ class Drawable:
 
         # 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 = (
@@ -179,9 +156,7 @@ class Drawable:
 
         # 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
@@ -219,9 +194,12 @@ class Drawable:
             xp1, yp1 = center[0] - (pole_width // 2), y1
             xp2, yp2 = center[0] - (pole_width // 2), center[1] + flag_size
 
-        # Draw flag outline using _polygon_outline
-        points = [(x1, y1), (x2, y2), (x3, y3)]
-        layer = Drawable._polygon_outline(layer, points, 1, flag_color, flag_color)
+        # Draw flag triangle using mvcrender's polygon_u8 (much faster than _polygon_outline)
+        xs = np.array([x1, x2, x3], dtype=np.int32)
+        ys = np.array([y1, y2, y3], dtype=np.int32)
+        # Draw filled triangle with thin outline
+        polygon_u8(layer, xs, ys, flag_color, 1, flag_color)
+
         # Draw pole using _line
         layer = Drawable._line(layer, xp1, yp1, xp2, yp2, pole_color, pole_width)
         return layer
@@ -246,62 +224,19 @@ class Drawable:
 
     @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)
-
-            sub_mask = 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][sub_mask] = 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
@@ -337,11 +272,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
 
@@ -355,68 +287,34 @@ 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
 
-    @staticmethod
-    def _filled_circle_optimized(
-        image: np.ndarray,
-        center: Tuple[int, int],
-        radius: int,
-        color: Color,
-        outline_color: Color = None,
-        outline_width: int = 0,
-    ) -> np.ndarray:
-        """
-        Optimized _filled_circle ensuring dtype compatibility with uint8.
-        """
-        x, y = center
-        h, w = image.shape[:2]
-        color_np = np.array(color, dtype=image.dtype)
-        outline_color_np = (
-            np.array(outline_color, dtype=image.dtype)
-            if outline_color is not None
-            else None
-        )
-        y_indices, x_indices = np.meshgrid(np.arange(h), np.arange(w), indexing="ij")
-        dist_sq = (y_indices - y) ** 2 + (x_indices - x) ** 2
-        circle_mask = dist_sq <= radius**2
-        image[circle_mask] = color_np
-        if outline_width > 0 and outline_color_np is not None:
-            outer_mask = dist_sq <= (radius + outline_width) ** 2
-            outline_mask = outer_mask & ~circle_mask
-            image[outline_mask] = outline_color_np
-        return image
-
     @staticmethod
     def _ellipse(
         image: NumpyArray, center: Point, radius: int, color: Color
@@ -483,17 +381,18 @@ class Drawable:
     @staticmethod
     async def zones(layers: NumpyArray, coordinates, color: Color) -> NumpyArray:
         """
-        Draw zones as solid filled polygons with alpha blending using a per-zone mask.
-        Keeps API the same; no dotted rendering.
+        Draw zones as filled polygons with alpha blending using mvcrender.
+        Creates a mask with polygon_u8 and blends it onto the image with proper alpha.
+        This eliminates PIL dependency for zone drawing.
         """
         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
+        # Pre-allocate color array once (avoid creating it in every iteration)
         color_rgb = np.array([r, g, b], dtype=np.float32)
 
         for zone in coordinates:
@@ -501,6 +400,7 @@ class Drawable:
                 pts = zone["points"]
             except (KeyError, TypeError):
                 continue
+
             if not pts or len(pts) < 6:
                 continue
 
@@ -512,29 +412,48 @@ class Drawable:
             if min_x >= max_x or min_y >= max_y:
                 continue
 
-            # 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)
+            # Create mask using mvcrender's polygon_u8
+            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)
+
+            # 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)
+            del mask_rgba
+            del xs
+            del ys
+
             if not np.any(zone_mask):
+                del zone_mask
                 continue
 
-            # Vectorized alpha blend on RGB channels only
+            # Optimized alpha blend - minimize temporary allocations
             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
+
+            # Work directly on the region's RGB channels
+            rgb_region = region[..., :3]
+
+            # Apply blending only where mask is True
+            # Use boolean indexing to avoid creating full-size temporary arrays
+            rgb_masked = rgb_region[zone_mask].astype(np.float32)
+
+            # Blend: new_color = old_color * (1 - alpha) + zone_color * alpha
+            rgb_masked *= inv_alpha
+            rgb_masked += color_rgb * alpha
+
+            # Write back (convert to uint8)
+            rgb_region[zone_mask] = rgb_masked.astype(np.uint8)
+
+            del zone_mask
+            del rgb_masked
 
         return layers
 
@@ -649,161 +568,6 @@ class Drawable:
         )
         return background_image
 
-    @staticmethod
-    def draw_filled_circle(
-        image: np.ndarray,
-        centers: Tuple[int, int],
-        radius: int,
-        color: Tuple[int, int, int, int],
-    ) -> np.ndarray:
-        """
-        Draw multiple filled circles at once using a single NumPy mask.
-        """
-        h, w = image.shape[:2]
-        y_indices, x_indices = np.ogrid[:h, :w]  # Precompute coordinate grids
-        mask = np.zeros((h, w), dtype=bool)
-        for cx, cy in centers:
-            mask |= (x_indices - cx) ** 2 + (y_indices - cy) ** 2 <= radius**2
-        image[mask] = color
-        return image
-
-    @staticmethod
-    def batch_draw_elements(
-        image: np.ndarray,
-        elements: list,
-        element_type: str,
-        color: Color,
-    ) -> np.ndarray:
-        """
-        Efficiently draw multiple elements of the same type at once.
-
-        Args:
-            image: The image array to draw on
-            elements: List of element data (coordinates, etc.)
-            element_type: Type of element to draw ('circle', 'line', etc.)
-            color: Color to use for drawing
-
-        Returns:
-            Modified image array
-        """
-        if not elements or len(elements) == 0:
-            return image
-
-        # Get image dimensions
-        height, width = image.shape[:2]
-
-        if element_type == "circle":
-            # Extract circle centers and radii
-            centers = []
-            radii = []
-            for elem in elements:
-                if isinstance(elem, dict) and "center" in elem and "radius" in elem:
-                    centers.append(elem["center"])
-                    radii.append(elem["radius"])
-                elif isinstance(elem, (list, tuple)) and len(elem) >= 3:
-                    # Format: (x, y, radius)
-                    centers.append((elem[0], elem[1]))
-                    radii.append(elem[2])
-
-            # Process circles with the same radius together
-            for radius in set(radii):
-                same_radius_centers = [
-                    centers[i] for i in range(len(centers)) if radii[i] == radius
-                ]
-                if same_radius_centers:
-                    # Create a combined mask for all circles with this radius
-                    mask = np.zeros((height, width), dtype=bool)
-                    for cx, cy in same_radius_centers:
-                        if 0 <= cx < width and 0 <= cy < height:
-                            # Calculate circle bounds
-                            min_y = max(0, cy - radius)
-                            max_y = min(height, cy + radius + 1)
-                            min_x = max(0, cx - radius)
-                            max_x = min(width, cx + radius + 1)
-
-                            # Create coordinate arrays for the circle
-                            y_indices, x_indices = np.ogrid[min_y:max_y, min_x:max_x]
-
-                            # Add this circle to the mask
-                            circle_mask = (y_indices - cy) ** 2 + (
-                                x_indices - cx
-                            ) ** 2 <= radius**2
-                            mask[min_y:max_y, min_x:max_x] |= circle_mask
-
-                    # Apply color to all circles at once
-                    image[mask] = color
-
-        elif element_type == "line":
-            # Extract line endpoints
-            lines = []
-            widths = []
-            for elem in elements:
-                if isinstance(elem, dict) and "start" in elem and "end" in elem:
-                    lines.append((elem["start"], elem["end"]))
-                    widths.append(elem.get("width", 1))
-                elif isinstance(elem, (list, tuple)) and len(elem) >= 4:
-                    # Format: (x1, y1, x2, y2, [width])
-                    lines.append(((elem[0], elem[1]), (elem[2], elem[3])))
-                    widths.append(elem[4] if len(elem) > 4 else 1)
-
-            # Process lines with the same width together
-            for width in set(widths):
-                same_width_lines = [
-                    lines[i] for i in range(len(lines)) if widths[i] == width
-                ]
-                if same_width_lines:
-                    # Create a combined mask for all lines with this width
-                    mask = np.zeros((height, width), dtype=bool)
-
-                    # Draw all lines into the mask
-                    for start, end in same_width_lines:
-                        x1, y1 = start
-                        x2, y2 = end
-
-                        # Skip invalid lines
-                        if not (
-                            0 <= x1 < width
-                            and 0 <= y1 < height
-                            and 0 <= x2 < width
-                            and 0 <= y2 < height
-                        ):
-                            continue
-
-                        # Use Bresenham's algorithm to get line points
-                        length = max(abs(x2 - x1), abs(y2 - y1))
-                        if length == 0:
-                            continue
-
-                        t = np.linspace(0, 1, length * 2)
-                        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_coordinates, y_coordinates):
-                            if width == 1:
-                                mask[y, x] = True
-                            else:
-                                # For thicker lines
-                                half_width = width // 2
-                                min_y = max(0, y - half_width)
-                                max_y = min(height, y + half_width + 1)
-                                min_x = max(0, x - half_width)
-                                max_x = min(width, x + half_width + 1)
-
-                                # Create a circular brush
-                                y_indices, x_indices = np.ogrid[
-                                    min_y:max_y, min_x:max_x
-                                ]
-                                brush = (y_indices - y) ** 2 + (
-                                    x_indices - x
-                                ) ** 2 <= half_width**2
-                                mask[min_y:max_y, min_x:max_x] |= brush
-
-                    # Apply color to all lines at once
-                    image[mask] = color
-
-        return image
-
     @staticmethod
     async def async_draw_obstacles(
         image: np.ndarray, obstacle_info_list, color: Color
@@ -835,9 +599,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
 

{valetudo_map_parser-0.1.10rc6 → valetudo_map_parser-0.1.11b0}/SCR/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