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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: valetudo-map-parser
-Version: 0.1.9b44
+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,7 +12,6 @@ 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: scikit-image (>=0.22.0)
 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

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

@@ -194,6 +194,34 @@ class ColorsManagment:
 
         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

{valetudo_map_parser-0.1.9b44 → 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
@@ -221,6 +257,8 @@ 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:
@@ -230,6 +268,27 @@ class Drawable:
             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
@@ -252,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
@@ -360,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:
@@ -370,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

{valetudo_map_parser-0.1.9b44 → valetudo_map_parser-0.1.9b45}/SCR/valetudo_map_parser/hypfer_handler.py

@@ -26,11 +26,8 @@ from .config.types import (
 )
 from .config.utils import (
     BaseHandler,
-    blend_colors,
-    blend_pixel,
     get_element_at_position,
     get_room_at_position,
-    handle_room_outline_error,
     initialize_drawing_config,
     manage_drawable_elements,
     prepare_resize_params,
@@ -159,26 +156,7 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                         x_max,
                         y_max,
                     ) = await self.data.async_get_rooms_coordinates(pixels, pixel_size)
-
-                    # Get rectangular corners as a fallback
                     corners = self.get_corners(x_max, x_min, y_max, y_min)
-
-                    # Try to extract a more accurate room outline from the element map
-                    try:
-                        # Extract the room outline using the element map
-                        outline = await self.extract_room_outline_from_map(
-                            segment_id, pixels, pixel_size
-                        )
-                        LOGGER.debug(
-                            "%s: Traced outline for room %s with %d points",
-                            self.file_name,
-                            segment_id,
-                            len(outline),
-                        )
-                    except (ValueError, IndexError, TypeError, ArithmeticError) as e:
-                        handle_room_outline_error(self.file_name, segment_id, e)
-                        outline = corners
-
                     room_id = str(segment_id)
                     self.rooms_pos.append(
                         {
@@ -188,7 +166,7 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                     )
                     room_properties[room_id] = {
                         "number": segment_id,
-                        "outline": outline,  # Use the detailed outline from the element map
+                        "outline": corners,
                         "name": name,
                         "x": ((x_min + x_max) // 2),
                         "y": ((y_min + y_max) // 2),
@@ -597,29 +575,6 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
         """Get the room ID at a specific position, or None if not a room."""
         return get_room_at_position(self.shared.element_map, x, y, DrawableElement.ROOM_1)
 
-    @staticmethod
-    def blend_colors(base_color, overlay_color):
-        """
-        Blend two RGBA colors, considering alpha channels.
-
-        Args:
-            base_color: The base RGBA color
-            overlay_color: The overlay RGBA color to blend on top
-
-        Returns:
-            The blended RGBA color
-        """
-        return blend_colors(base_color, overlay_color)
-
-    def blend_pixel(self, array, x, y, color, element):
-        """
-        Blend a pixel color with the existing color at the specified position.
-        Also updates the element map if the new element has higher z-index.
-        """
-        return blend_pixel(
-            array, x, y, color, element, self.shared.element_map, self.drawing_config
-        )
-
     @staticmethod
     async def async_copy_array(original_array):
         """Copy the array."""

{valetudo_map_parser-0.1.9b44 → valetudo_map_parser-0.1.9b45}/SCR/valetudo_map_parser/rand25_handler.py

@@ -130,7 +130,7 @@ class ReImageHandler(BaseHandler, AutoCrop):
 
     async def extract_room_properties(
         self, json_data: JsonType, destinations: JsonType
-    ) -> RoomsProperties:
+    ) -> tuple[RoomsProperties, Any, Any]:
         """Extract the room properties."""
         unsorted_id = RandImageData.get_rrm_segments_ids(json_data)
         size_x, size_y = RandImageData.get_rrm_image_size(json_data)
@@ -153,7 +153,7 @@ class ReImageHandler(BaseHandler, AutoCrop):
             if not self.outlines:
                 # Return empty data if no outlines are available
                 _LOGGER.debug("%s: No outlines available", self.file_name)
-                return None, None, None
+                return None, None, None  # Return empty data for all three return values
 
             # If we have outlines, proceed with processing
             for id_x, room_id in enumerate(unsorted_id):
@@ -231,7 +231,7 @@ class ReImageHandler(BaseHandler, AutoCrop):
                 e,
                 exc_info=True,
             )
-            return None, None, None
+            return None, None, None  # Return empty data in case of error
 
     async def get_image_from_rrm(
         self,
@@ -427,7 +427,7 @@ class ReImageHandler(BaseHandler, AutoCrop):
 
     async def get_rooms_attributes(
         self, destinations: JsonType = None
-    ) -> RoomsProperties:
+    ) -> tuple[RoomsProperties, Any, Any]:
         """Return the rooms attributes."""
         if self.room_propriety:
             return self.room_propriety

{valetudo_map_parser-0.1.9b44 → valetudo_map_parser-0.1.9b45}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "valetudo-map-parser"
-version = "0.1.9b44"
+version = "0.1.9b45"
 description = "A Python library to parse Valetudo map data returning a PIL Image object."
 authors = ["Sandro Cantarella <gsca075@gmail.com>"]
 license = "Apache-2.0"
@@ -18,7 +18,6 @@ python = ">=3.12"
 numpy = ">=1.26.4"
 Pillow = ">=10.3.0"
 scipy = ">=1.12.0"
-scikit-image = ">=0.22.0"
 
 [tool.poetry.group.dev.dependencies]
 ruff = "*"