valetudo-map-parser 0.1.9b43__tar.gz → 0.1.9b45__tar.gz

{valetudo_map_parser-0.1.9b43 → valetudo_map_parser-0.1.9b45}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: valetudo-map-parser
-Version: 0.1.9b43
+Version: 0.1.9b45
 Summary: A Python library to parse Valetudo map data returning a PIL Image object.
 License: Apache-2.0
 Author: Sandro Cantarella
@@ -12,6 +12,7 @@ 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: 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
 Project-URL: Homepage, https://github.com/sca075/Python-package-valetudo-map-parser

{valetudo_map_parser-0.1.9b43 → valetudo_map_parser-0.1.9b45}/SCR/valetudo_map_parser/config/colors.py

@@ -2,14 +2,10 @@
 
 from __future__ import annotations
 
-import logging
 from enum import StrEnum
 from typing import Dict, List, Tuple
 
-
-_LOGGER = logging.getLogger(__name__)
-
-Color = Tuple[int, int, int, int]  # RGBA color definition
+from .types import LOGGER, Color
 
 
 class SupportedColor(StrEnum):
@@ -38,7 +34,7 @@ class DefaultColors:
 
     COLORS_RGB: Dict[str, Tuple[int, int, int]] = {
         SupportedColor.CHARGER: (255, 128, 0),
-        SupportedColor.PATH: (238, 247, 255),
+        SupportedColor.PATH: (50, 150, 255),  # More vibrant blue for better visibility
         SupportedColor.PREDICTED_PATH: (93, 109, 126),
         SupportedColor.WALLS: (255, 255, 0),
         SupportedColor.ROBOT: (255, 255, 204),
@@ -77,6 +73,11 @@ class DefaultColors:
     DEFAULT_ALPHA: Dict[str, float] = {
         f"alpha_{key}": 255.0 for key in COLORS_RGB.keys()
     }
+    # Override specific alpha values
+    DEFAULT_ALPHA.update({
+        "alpha_color_path": 200.0,  # Make path slightly transparent but still very visible
+        "alpha_color_wall": 150.0,  # Keep walls semi-transparent
+    })
     DEFAULT_ALPHA.update({f"alpha_room_{i}": 255.0 for i in range(16)})
 
     @classmethod
@@ -142,6 +143,85 @@ class ColorsManagment:
         """
         return (*rgb, int(alpha)) if rgb else (0, 0, 0, int(alpha))
 
+    @staticmethod
+    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.
+
+        :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
+
+        # If foreground is fully opaque, just return it
+        if fg_a == 255:
+            return foreground
+
+        # If foreground is fully transparent, return background
+        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
+
+        # Calculate resulting alpha
+        out_alpha = fg_alpha + bg_alpha * (1 - fg_alpha)
+
+        # Avoid division by zero
+        if out_alpha < 0.0001:
+            return (0, 0, 0, 0)  # Fully transparent result
+
+        # Calculate blended RGB components
+        out_r = int((fg_r * fg_alpha + bg_r * bg_alpha * (1 - fg_alpha)) / out_alpha)
+        out_g = int((fg_g * fg_alpha + bg_g * bg_alpha * (1 - fg_alpha)) / out_alpha)
+        out_b = int((fg_b * fg_alpha + bg_b * bg_alpha * (1 - fg_alpha)) / out_alpha)
+
+        # Convert alpha back to [0-255] range
+        out_a = int(out_alpha * 255)
+
+        # Ensure values are in valid range
+        out_r = max(0, min(255, out_r))
+        out_g = max(0, min(255, out_g))
+        out_b = max(0, min(255, out_b))
+
+        return (out_r, out_g, out_b, out_a)
+
+    @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.
+
+        Args:
+            array: The RGBA numpy array representing the image
+            x, y: Coordinates to sample the background color from
+            foreground: Foreground RGBA color (r,g,b,a) to blend on top
+
+        Returns:
+            Blended RGBA color
+        """
+        # Ensure coordinates are within bounds
+        if array is None:
+            return foreground
+
+        height, width = array.shape[:2]
+        if not (0 <= y < height and 0 <= x < width):
+            return foreground  # Return foreground if coordinates are out of bounds
+
+        # Sample background color from the array
+        # The array is in RGBA format with shape (height, width, 4)
+        background = tuple(array[y, x])
+
+        # Blend the colors
+        return ColorsManagment.blend_colors(background, foreground)
+
     def get_user_colors(self) -> List[Color]:
         """Return the list of RGBA colors for user-defined map elements."""
         return self.user_colors
@@ -163,7 +243,7 @@ class ColorsManagment:
             try:
                 return self.rooms_colors[room_index]
             except (IndexError, KeyError):
-                _LOGGER.warning("Room index %s not found, using default.", room_index)
+                LOGGER.warning("Room index %s not found, using default.", room_index)
                 r, g, b = DefaultColors.DEFAULT_ROOM_COLORS[f"color_room_{room_index}"]
                 a = DefaultColors.DEFAULT_ALPHA[f"alpha_room_{room_index}"]
                 return r, g, b, int(a)
@@ -173,7 +253,7 @@ class ColorsManagment:
             index = list(SupportedColor).index(supported_color)
             return self.user_colors[index]
         except (IndexError, KeyError, ValueError):
-            _LOGGER.warning(
+            LOGGER.warning(
                 "Color for %s not found. Returning default.", supported_color
             )
             return DefaultColors.get_rgba(supported_color, 255)  # Transparent fallback

{valetudo_map_parser-0.1.9b43 → valetudo_map_parser-0.1.9b45}/SCR/valetudo_map_parser/config/drawable.py

@@ -174,11 +174,47 @@ class Drawable:
         y2: int,
         color: Color,
         width: int = 3,
+        blend: bool = True,
     ) -> NumpyArray:
         """
         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
+            x1, y1: Start point coordinates
+            x2, y2: End point coordinates
+            color: Color to draw with
+            width: Width of the line
+            blend: Whether to blend the color with the background
         """
+        from .colors import ColorsManagment
+
         x1, y1, x2, y2 = int(x1), int(y1), int(x2), int(y2)
+
+        # Sample background color at the endpoints and blend with foreground color if requested
+        if blend:
+            # Sample at start point
+            if 0 <= y1 < layer.shape[0] and 0 <= x1 < layer.shape[1]:
+                start_blended_color = ColorsManagment.sample_and_blend_color(layer, x1, y1, color)
+            else:
+                start_blended_color = color
+
+            # Sample at end point
+            if 0 <= y2 < layer.shape[0] and 0 <= x2 < layer.shape[1]:
+                end_blended_color = ColorsManagment.sample_and_blend_color(layer, x2, y2, color)
+            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
+            )
+        else:
+            blended_color = color
+
         dx = abs(x2 - x1)
         dy = abs(y2 - y1)
         sx = 1 if x1 < x2 else -1
@@ -189,7 +225,7 @@ class Drawable:
             for i in range(-width // 2, (width + 1) // 2):
                 for j in range(-width // 2, (width + 1) // 2):
                     if 0 <= x1 + i < layer.shape[1] and 0 <= y1 + j < layer.shape[0]:
-                        layer[y1 + j, x1 + i] = color
+                        layer[y1 + j, x1 + i] = blended_color
             if x1 == x2 and y1 == y2:
                 break
             e2 = 2 * err
@@ -220,12 +256,39 @@ class Drawable:
         """
         Join the coordinates creating a continuous line (path).
         """
+        import logging
+        from .colors import ColorsManagment
+
+        _LOGGER = logging.getLogger(__name__)
+        _LOGGER.debug("Drawing lines with %d coordinates, width %d, color %s", len(coords), width, color)
         for coord in coords:
             x0, y0 = coord[0]
             try:
                 x1, y1 = coord[1]
             except IndexError:
                 x1, y1 = x0, y0
+            _LOGGER.debug("Drawing line from (%d, %d) to (%d, %d)", x0, y0, x1, y1)
+
+            # Sample background color at the endpoints and blend with foreground color
+            # This is more efficient than sampling at every pixel
+            if 0 <= y0 < arr.shape[0] and 0 <= x0 < arr.shape[1]:
+                start_blended_color = ColorsManagment.sample_and_blend_color(arr, x0, y0, color)
+            else:
+                start_blended_color = color
+
+            if 0 <= y1 < arr.shape[0] and 0 <= x1 < arr.shape[1]:
+                end_blended_color = ColorsManagment.sample_and_blend_color(arr, x1, y1, color)
+            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
+            )
+
             dx = abs(x1 - x0)
             dy = abs(y1 - y0)
             sx = 1 if x0 < x1 else -1
@@ -248,8 +311,9 @@ class Drawable:
                 x, y = pixel
                 for i in range(width):
                     for j in range(width):
-                        if 0 <= x + i < arr.shape[1] and 0 <= y + j < arr.shape[0]:
-                            arr[y + j, x + i] = color
+                        px, py = x + i, y + j
+                        if 0 <= px < arr.shape[1] and 0 <= py < arr.shape[0]:
+                            arr[py, px] = blended_color
         return arr
 
     @staticmethod
@@ -356,8 +420,10 @@ class Drawable:
     @staticmethod
     async def zones(layers: NumpyArray, coordinates, color: Color) -> NumpyArray:
         """
-        Draw the zones on the input layer.
+        Draw the zones on the input layer with color blending.
         """
+        from .colors import ColorsManagment
+
         dot_radius = 1  # Number of pixels for the dot
         dot_spacing = 4  # Space between dots
         for zone in coordinates:
@@ -366,10 +432,22 @@ class Drawable:
             max_x = max(points[::2])
             min_y = min(points[1::2])
             max_y = max(points[1::2])
+
+            # 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 = ColorsManagment.sample_and_blend_color(layers, sample_x, sample_y, color)
+            else:
+                blended_color = color
+
             for y in range(min_y, max_y, dot_spacing):
                 for x in range(min_x, max_x, dot_spacing):
                     for _ in range(dot_radius):
-                        layers = Drawable._ellipse(layers, (x, y), dot_radius, color)
+                        layers = Drawable._ellipse(layers, (x, y), dot_radius, blended_color)
         return layers
 
     @staticmethod