valetudo-map-parser 0.1.9b49__tar.gz → 0.1.9b51__tar.gz

{valetudo_map_parser-0.1.9b49 → valetudo_map_parser-0.1.9b51}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: valetudo-map-parser
-Version: 0.1.9b49
+Version: 0.1.9b51
 Summary: A Python library to parse Valetudo map data returning a PIL Image object.
 License: Apache-2.0
 Author: Sandro Cantarella

{valetudo_map_parser-0.1.9b49 → valetudo_map_parser-0.1.9b51}/SCR/valetudo_map_parser/__init__.py

@@ -15,11 +15,13 @@ from .config.types import (
     TrimCropData,
     UserLanguageStore,
 )
+from .hypfer_rooms_handler import HypferRoomsHandler
 from .hypfer_handler import HypferMapImageHandler
 from .rand25_handler import ReImageHandler
 
 
 __all__ = [
+    "HypferRoomsHandler",
     "HypferMapImageHandler",
     "ReImageHandler",
     "RRMapParser",

valetudo_map_parser-0.1.9b51/SCR/valetudo_map_parser/config/color_utils.py

@@ -0,0 +1,105 @@
+"""Utility functions for color operations in the map parser."""
+
+from typing import Tuple, Optional
+
+from .colors import ColorsManagement
+from .types import NumpyArray, Color
+
+
+def get_blended_color(
+    x0: int,
+    y0: int,
+    x1: int,
+    y1: int,
+    arr: Optional[NumpyArray],
+    color: Color,
+) -> Color:
+    """
+    Get a blended color for a pixel based on the current element map and the new element to draw.
+
+    This function:
+    1. Gets the background colors at the start and end points (with offset to avoid sampling already drawn pixels)
+    2. Directly blends the foreground color with the background using straight alpha
+    3. Returns the average of the two blended colors
+
+    Returns:
+        Blended RGBA color to use for drawing
+    """
+    # Extract foreground color components
+    fg_r, fg_g, fg_b, fg_a = color
+    fg_alpha = fg_a / 255.0  # Convert to 0-1 range
+
+    # Fast path for fully opaque or transparent foreground
+    if fg_a == 255:
+        return color
+    if fg_a == 0:
+        # 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
+
+    # Calculate direction vector for offset sampling
+    dx = x1 - x0
+    dy = y1 - y0
+    length = max(1, (dx**2 + dy**2) ** 0.5)  # Avoid division by zero
+    offset = 5  # 5-pixel offset to avoid sampling already drawn pixels
+
+    # Calculate offset coordinates for start point (move away from the line)
+    offset_x0 = int(x0 - (offset * dx / length))
+    offset_y0 = int(y0 - (offset * dy / length))
+
+    # Calculate offset coordinates for end point (move away from the line)
+    offset_x1 = int(x1 + (offset * dx / length))
+    offset_y1 = int(y1 + (offset * dy / length))
+
+    # Sample background at offset start point
+    if 0 <= offset_y0 < arr.shape[0] and 0 <= offset_x0 < arr.shape[1]:
+        bg_color_start = arr[offset_y0, offset_x0]
+        # Direct straight alpha blending
+        start_r = int(fg_r * fg_alpha + bg_color_start[0] * (1 - fg_alpha))
+        start_g = int(fg_g * fg_alpha + bg_color_start[1] * (1 - fg_alpha))
+        start_b = int(fg_b * fg_alpha + bg_color_start[2] * (1 - fg_alpha))
+        start_a = int(fg_a + bg_color_start[3] * (1 - fg_alpha))
+        start_blended_color = (start_r, start_g, start_b, start_a)
+    else:
+        # If offset point is out of bounds, try original point
+        if 0 <= y0 < arr.shape[0] and 0 <= x0 < arr.shape[1]:
+            bg_color_start = arr[y0, x0]
+            start_r = int(fg_r * fg_alpha + bg_color_start[0] * (1 - fg_alpha))
+            start_g = int(fg_g * fg_alpha + bg_color_start[1] * (1 - fg_alpha))
+            start_b = int(fg_b * fg_alpha + bg_color_start[2] * (1 - fg_alpha))
+            start_a = int(fg_a + bg_color_start[3] * (1 - fg_alpha))
+            start_blended_color = (start_r, start_g, start_b, start_a)
+        else:
+            start_blended_color = color
+
+    # Sample background at offset end point
+    if 0 <= offset_y1 < arr.shape[0] and 0 <= offset_x1 < arr.shape[1]:
+        bg_color_end = arr[offset_y1, offset_x1]
+        # Direct straight alpha blending
+        end_r = int(fg_r * fg_alpha + bg_color_end[0] * (1 - fg_alpha))
+        end_g = int(fg_g * fg_alpha + bg_color_end[1] * (1 - fg_alpha))
+        end_b = int(fg_b * fg_alpha + bg_color_end[2] * (1 - fg_alpha))
+        end_a = int(fg_a + bg_color_end[3] * (1 - fg_alpha))
+        end_blended_color = (end_r, end_g, end_b, end_a)
+    else:
+        # If offset point is out of bounds, try original point
+        if 0 <= y1 < arr.shape[0] and 0 <= x1 < arr.shape[1]:
+            bg_color_end = arr[y1, x1]
+            end_r = int(fg_r * fg_alpha + bg_color_end[0] * (1 - fg_alpha))
+            end_g = int(fg_g * fg_alpha + bg_color_end[1] * (1 - fg_alpha))
+            end_b = int(fg_b * fg_alpha + bg_color_end[2] * (1 - fg_alpha))
+            end_a = int(fg_a + bg_color_end[3] * (1 - fg_alpha))
+            end_blended_color = (end_r, end_g, end_b, end_a)
+        else:
+            end_blended_color = color
+
+    # Use the average of the two blended colors
+    blended_color = (
+        (start_blended_color[0] + end_blended_color[0]) // 2,
+        (start_blended_color[1] + end_blended_color[1]) // 2,
+        (start_blended_color[2] + end_blended_color[2]) // 2,
+        (start_blended_color[3] + end_blended_color[3]) // 2,
+    )
+    return blended_color

{valetudo_map_parser-0.1.9b49 → valetudo_map_parser-0.1.9b51}/SCR/valetudo_map_parser/config/colors.py

@@ -139,7 +139,6 @@ color_array = [
 ]
 
 
-
 class SupportedColor(StrEnum):
     """Color of a supported map element."""
 
@@ -408,61 +407,56 @@ class ColorsManagement:
     def blend_colors(background: Color, foreground: Color) -> Color:
         """
         Blend foreground color with background color based on alpha values.
-
-        This is used when drawing elements that overlap on the map.
-        The alpha channel determines how much of the foreground color is visible.
-        Uses optimized calculations for better performance.
+        Optimized version with more fast paths and simplified calculations.
 
         :param background: Background RGBA color (r,g,b,a)
         :param foreground: Foreground RGBA color (r,g,b,a) to blend on top
         :return: Blended RGBA color
         """
-        # Extract components
-        bg_r, bg_g, bg_b, bg_a = background
-        fg_r, fg_g, fg_b, fg_a = foreground
+        # Fast paths for common cases
+        fg_a = foreground[3]
 
-        # Fast path for common cases
-        if fg_a == 255:
+        if fg_a == 255:  # Fully opaque foreground
             return foreground
-        if fg_a == 0:
-            return background
 
-        # Calculate alpha blending
-        # Convert alpha from [0-255] to [0-1] for calculations
-        fg_alpha = fg_a / 255.0
-        bg_alpha = bg_a / 255.0
+        if fg_a == 0:  # Fully transparent foreground
+            return background
 
-        # Calculate resulting alpha
-        out_alpha = fg_alpha + bg_alpha * (1 - fg_alpha)
+        bg_a = background[3]
+        if bg_a == 0:  # Fully transparent background
+            return foreground
 
-        # Avoid division by zero
-        if out_alpha < 0.0001:
-            return Color[0, 0, 0, 0]  # Fully transparent result
+        # Extract components (only after fast paths)
+        bg_r, bg_g, bg_b = background[:3]
+        fg_r, fg_g, fg_b = foreground[:3]
 
-        # Calculate blended RGB components
-        # Using a more efficient calculation method
-        alpha_ratio = fg_alpha / out_alpha
-        inv_alpha_ratio = 1.0 - alpha_ratio
+        # Pre-calculate the blend factor once (avoid repeated division)
+        blend = fg_a / 255.0
+        inv_blend = 1.0 - blend
 
-        out_r = int(fg_r * alpha_ratio + bg_r * inv_alpha_ratio)
-        out_g = int(fg_g * alpha_ratio + bg_g * inv_alpha_ratio)
-        out_b = int(fg_b * alpha_ratio + bg_b * inv_alpha_ratio)
+        # Simple linear interpolation for RGB channels
+        # This is faster than the previous implementation
+        out_r = int(fg_r * blend + bg_r * inv_blend)
+        out_g = int(fg_g * blend + bg_g * inv_blend)
+        out_b = int(fg_b * blend + bg_b * inv_blend)
 
-        # Convert alpha back to [0-255] range
-        out_a = int(out_alpha * 255)
+        # Alpha blending - simplified calculation
+        out_a = int(fg_a + bg_a * inv_blend)
 
-        # Ensure values are in valid range (using min/max for efficiency)
-        out_r = max(0, min(255, out_r))
-        out_g = max(0, min(255, out_g))
-        out_b = max(0, min(255, out_b))
+        # No need for min/max checks as the blend math keeps values in range
+        # when input values are valid (0-255)
 
         return [out_r, out_g, out_b, out_a]
 
+    # Cache for recently sampled background colors
+    _bg_color_cache = {}
+    _cache_size = 1024  # Limit cache size to avoid memory issues
+
     @staticmethod
     def sample_and_blend_color(array, x: int, y: int, foreground: Color) -> Color:
         """
         Sample the background color from the array at coordinates (x,y) and blend with foreground color.
-        Uses scipy.ndimage for efficient sampling when appropriate.
+        Optimized version with caching and faster sampling.
 
         Args:
             array: The RGBA numpy array representing the image
@@ -473,53 +467,43 @@ class ColorsManagement:
         Returns:
             Blended RGBA color
         """
-        # Ensure coordinates are within bounds
+        # Fast path for fully opaque foreground - no need to sample or blend
+        if foreground[3] == 255:
+            return foreground
+
+        # Ensure array exists
         if array is None:
             return foreground
 
+        # Check if coordinates are within bounds
         height, width = array.shape[:2]
         if not (0 <= y < height and 0 <= x < width):
-            return foreground  # Return foreground if coordinates are out of bounds
-
-        # Fast path for fully opaque foreground
-        if foreground[3] == 255:
             return foreground
 
-        # The array is in RGBA format with shape (height, width, 4)
-        try:
-            # Use scipy.ndimage for sampling with boundary handling
-            # This is more efficient for large arrays and handles edge cases better
-            if (
-                array.size > 1000000
-            ):  # Only use for larger arrays where the overhead is worth it
-                # Create coordinates array for the sampling point
-                coordinates = np.array([[y, x]])
-
-                # Sample each channel separately with nearest neighbor interpolation
-                # This is faster than sampling all channels at once for large arrays
-                r = ndimage.map_coordinates(
-                    array[..., 0], coordinates.T, order=0, mode="nearest"
-                )[0]
-                g = ndimage.map_coordinates(
-                    array[..., 1], coordinates.T, order=0, mode="nearest"
-                )[0]
-                b = ndimage.map_coordinates(
-                    array[..., 2], coordinates.T, order=0, mode="nearest"
-                )[0]
-                a = ndimage.map_coordinates(
-                    array[..., 3], coordinates.T, order=0, mode="nearest"
-                )[0]
-                background = (int(r), int(g), int(b), int(a))
-            else:
-                # For smaller arrays, direct indexing is faster
-                background = tuple(array[y, x])
-        except (IndexError, ValueError):
-            # Fallback to direct indexing if ndimage fails
+        # Check cache for this coordinate
+        cache_key = (id(array), x, y)
+        cache = ColorsManagement._bg_color_cache
+
+        if cache_key in cache:
+            background = cache[cache_key]
+        else:
+            # Sample the background color using direct indexing (fastest method)
             try:
-                background = tuple(array[y, x])
+                background = tuple(map(int, array[y, x]))
+
+                # Update cache (with simple LRU-like behavior)
+                if len(cache) >= ColorsManagement._cache_size:
+                    # Remove a random entry if cache is full
+                    cache.pop(next(iter(cache)))
+                cache[cache_key] = background
+
             except (IndexError, ValueError):
                 return foreground
 
+        # Fast path for fully transparent foreground
+        if foreground[3] == 0:
+            return background
+
         # Blend the colors
         return ColorsManagement.blend_colors(background, foreground)
 

{valetudo_map_parser-0.1.9b49 → valetudo_map_parser-0.1.9b51}/SCR/valetudo_map_parser/config/drawable.py

@@ -75,7 +75,7 @@ class Drawable:
                 # Get the region to update
                 region_slice = (
                     slice(row, row + pixel_size),
-                    slice(col + i * pixel_size, col + (i + 1) * pixel_size)
+                    slice(col + i * pixel_size, col + (i + 1) * pixel_size),
                 )
 
                 if need_blending:
@@ -84,8 +84,10 @@ class Drawable:
                     center_x = col + i * pixel_size + pixel_size // 2
 
                     # Only blend if coordinates are valid
-                    if (0 <= center_y < image_array.shape[0] and
-                        0 <= center_x < image_array.shape[1]):
+                    if (
+                        0 <= center_y < image_array.shape[0]
+                        and 0 <= center_x < image_array.shape[1]
+                    ):
                         # Get blended color
                         blended_color = ColorsManagement.sample_and_blend_color(
                             image_array, center_x, center_y, full_color
@@ -296,9 +298,11 @@ class Drawable:
             for x, y in zip(x_coords, y_coords):
                 for i in range(-half_width, half_width + 1):
                     for j in range(-half_width, half_width + 1):
-                        if (i*i + j*j <= half_width*half_width and  # Make it round
-                            0 <= x + i < layer.shape[1] and
-                            0 <= y + j < layer.shape[0]):
+                        if (
+                            i * i + j * j <= half_width * half_width  # Make it round
+                            and 0 <= x + i < layer.shape[1]
+                            and 0 <= y + j < layer.shape[0]
+                        ):
                             layer[y + j, x + i] = blended_color
 
         return layer
@@ -371,7 +375,7 @@ class Drawable:
         dist_sq = (y_indices - y) ** 2 + (x_indices - x) ** 2
 
         # Create masks for the circle and outline
-        circle_mask = dist_sq <= radius ** 2
+        circle_mask = dist_sq <= radius**2
 
         # Apply the fill color
         image[min_y:max_y, min_x:max_x][circle_mask] = color
@@ -468,7 +472,7 @@ class Drawable:
             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]]
+            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]):
@@ -476,7 +480,7 @@ class Drawable:
                     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
+            arr[min_y : max_y + 1, min_x : max_x + 1][mask] = fill_color
 
         return arr
 
@@ -530,7 +534,7 @@ class Drawable:
                     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
+                    mask = (y_indices - y) ** 2 + (x_indices - x) ** 2 <= dot_radius**2
 
                     # Apply the color to the masked region
                     layers[y_min:y_max, x_min:x_max][mask] = blended_color
@@ -607,8 +611,12 @@ class Drawable:
         y2 = int(tmp_y + r_cover * math.cos(a2))
 
         # Draw the direction line
-        if (0 <= x1 < tmp_width and 0 <= y1 < tmp_height and
-            0 <= x2 < tmp_width and 0 <= y2 < tmp_height):
+        if (
+            0 <= x1 < tmp_width
+            and 0 <= y1 < tmp_height
+            and 0 <= x2 < tmp_width
+            and 0 <= y2 < tmp_height
+        ):
             tmp_layer = Drawable._line(tmp_layer, x1, y1, x2, y2, outline, width=1)
 
         # Draw the lidar indicator
@@ -694,14 +702,14 @@ class Drawable:
         # Get image dimensions
         height, width = image.shape[:2]
 
-        if element_type == 'circle':
+        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'])
+                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]))
@@ -709,7 +717,9 @@ class Drawable:
 
             # 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]
+                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)
@@ -725,20 +735,22 @@ class Drawable:
                             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
+                            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':
+        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))
+                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])))
@@ -746,19 +758,25 @@ class Drawable:
 
             # 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]
+                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:
+                    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):
+                        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
@@ -783,8 +801,12 @@ class Drawable:
                                 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
+                                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
@@ -826,20 +848,16 @@ class Drawable:
                     )
 
                 # Add to centers list with radius
-                centers.append({
-                    'center': (x, y),
-                    'radius': 6,
-                    'color': obstacle_color
-                })
+                centers.append({"center": (x, y), "radius": 6, "color": obstacle_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']
+                cx, cy = obstacle["center"]
+                radius = obstacle["radius"]
+                obs_color = obstacle["color"]
 
                 # Create a small mask for the obstacle
                 min_y = max(0, cy - radius)
@@ -851,7 +869,7 @@ class Drawable:
                 y_indices, x_indices = np.ogrid[min_y:max_y, min_x:max_x]
 
                 # Create a circular mask
-                mask = (y_indices - cy)**2 + (x_indices - cx)**2 <= radius**2
+                mask = (y_indices - cy) ** 2 + (x_indices - cx) ** 2 <= radius**2
 
                 # Apply the color to the masked region
                 image[min_y:max_y, min_x:max_x][mask] = obs_color