valetudo-map-parser 0.1.11b2__py3-none-any.whl → 0.1.12b0__py3-none-any.whl

valetudo_map_parser/__init__.py

@@ -1,5 +1,5 @@
 """Valetudo map parser.
-Version: 0.1.10"""
+Version: 0.1.12"""
 
 from pathlib import Path
 
@@ -22,6 +22,58 @@ from .config.types import (
     TrimCropData,
     UserLanguageStore,
 )
+from .config.utils import ResizeParams, async_resize_image
+from .const import (
+    ATTR_CALIBRATION_POINTS,
+    ATTR_CAMERA_MODE,
+    ATTR_CONTENT_TYPE,
+    ATTR_FRIENDLY_NAME,
+    ATTR_IMAGE_LAST_UPDATED,
+    ATTR_JSON_DATA,
+    ATTR_OBSTACLES,
+    ATTR_POINTS,
+    ATTR_ROOMS,
+    ATTR_ROTATE,
+    ATTR_SNAPSHOT,
+    ATTR_SNAPSHOT_PATH,
+    ATTR_VACUUM_BATTERY,
+    ATTR_VACUUM_CHARGING,
+    ATTR_VACUUM_JSON_ID,
+    ATTR_VACUUM_POSITION,
+    ATTR_VACUUM_STATUS,
+    ATTR_VACUUM_TOPIC,
+    ATTR_ZONES,
+    CAMERA_STORAGE,
+    COLORS,
+    CONF_ASPECT_RATIO,
+    CONF_AUTO_ZOOM,
+    CONF_EXPORT_SVG,
+    CONF_OFFSET_BOTTOM,
+    CONF_OFFSET_LEFT,
+    CONF_OFFSET_RIGHT,
+    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_ZOOM_LOCK_RATIO,
+    DECODED_TOPICS,
+    DEFAULT_IMAGE_SIZE,
+    DEFAULT_PIXEL_SIZE,
+    DEFAULT_VALUES,
+    FONTS_AVAILABLE,
+    ICON,
+    NAME,
+    NON_DECODED_TOPICS,
+    NOT_STREAMING_STATES,
+    SENSOR_NO_DATA,
+)
 from .hypfer_handler import HypferMapImageHandler
 from .map_data import HyperMapData
 from .rand256_handler import ReImageHandler
@@ -38,29 +90,86 @@ def get_default_font_path() -> str:
 
 
 __all__ = [
-    "RoomsHandler",
-    "RandRoomsHandler",
-    "HyperMapData",
-    "HypferMapImageHandler",
-    "ReImageHandler",
-    "RRMapParser",
+    # Attribute Constants
+    "ATTR_CALIBRATION_POINTS",
+    "ATTR_CAMERA_MODE",
+    "ATTR_CONTENT_TYPE",
+    "ATTR_FRIENDLY_NAME",
+    "ATTR_IMAGE_LAST_UPDATED",
+    "ATTR_JSON_DATA",
+    "ATTR_OBSTACLES",
+    "ATTR_POINTS",
+    "ATTR_ROOMS",
+    "ATTR_ROTATE",
+    "ATTR_SNAPSHOT",
+    "ATTR_SNAPSHOT_PATH",
+    "ATTR_VACUUM_BATTERY",
+    "ATTR_VACUUM_CHARGING",
+    "ATTR_VACUUM_JSON_ID",
+    "ATTR_VACUUM_POSITION",
+    "ATTR_VACUUM_STATUS",
+    "ATTR_VACUUM_TOPIC",
+    "ATTR_ZONES",
+    # Configuration Constants
+    "CAMERA_STORAGE",
+    "COLORS",
+    "CONF_ASPECT_RATIO",
+    "CONF_AUTO_ZOOM",
+    "CONF_EXPORT_SVG",
+    "CONF_OFFSET_BOTTOM",
+    "CONF_OFFSET_LEFT",
+    "CONF_OFFSET_RIGHT",
+    "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_ZOOM_LOCK_RATIO",
+    # Default Values
+    "DECODED_TOPICS",
+    "DEFAULT_IMAGE_SIZE",
+    "DEFAULT_PIXEL_SIZE",
+    "DEFAULT_VALUES",
+    "FONTS_AVAILABLE",
+    "ICON",
+    "NAME",
+    "NON_DECODED_TOPICS",
+    "NOT_STREAMING_STATES",
+    "SENSOR_NO_DATA",
+    # Classes and Handlers
     "CameraShared",
     "CameraSharedManager",
     "ColorsManagement",
     "Drawable",
     "DrawableElement",
     "DrawingConfig",
-    "SnapshotStore",
-    "UserLanguageStore",
-    "RoomStore",
-    "RoomsProperties",
-    "TrimCropData",
+    "HyperMapData",
+    "HypferMapImageHandler",
+    "RRMapParser",
+    "RandRoomsHandler",
+    "ReImageHandler",
+    "RoomsHandler",
+    "StatusText",
+    # Types
     "CameraModes",
+    "ImageSize",
     "JsonType",
-    "PilPNG",
     "NumpyArray",
-    "ImageSize",
-    "StatusText",
+    "PilPNG",
+    "RoomsProperties",
+    "RoomStore",
+    "SnapshotStore",
+    "TrimCropData",
+    "UserLanguageStore",
+    # Utilities
+    "ResizeParams",
     "STATUS_TEXT_TRANSLATIONS",
+    "async_resize_image",
     "get_default_font_path",
 ]

valetudo_map_parser/config/async_utils.py

@@ -49,7 +49,7 @@ class AsyncPIL:
     ) -> 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

valetudo_map_parser/config/colors.py

@@ -6,9 +6,8 @@ from enum import StrEnum
 from typing import Dict, List, Tuple
 
 import numpy as np
-from scipy import ndimage
 
-from .types import (
+from ..const import (
     ALPHA_BACKGROUND,
     ALPHA_CHARGER,
     ALPHA_GO_TO,
@@ -59,10 +58,8 @@ from .types import (
     COLOR_TEXT,
     COLOR_WALL,
     COLOR_ZONE_CLEAN,
-    LOGGER,
-    Color,
 )
-
+from .types import LOGGER, Color
 
 color_transparent = (0, 0, 0, 0)
 color_charger = (0, 128, 0, 255)
@@ -404,120 +401,6 @@ class ColorsManagement:
         """
         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.
-        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
-        """
-        # Fast paths for common cases
-        fg_a = foreground[3]
-
-        if fg_a == 255:  # Fully opaque foreground
-            return foreground
-
-        if fg_a == 0:  # Fully transparent foreground
-            return background
-
-        bg_a = background[3]
-        if bg_a == 0:  # Fully transparent background
-            return foreground
-
-        # Extract components (only after fast paths)
-        bg_r, bg_g, bg_b = background[:3]
-        fg_r, fg_g, fg_b = foreground[:3]
-
-        # Pre-calculate the blend factor once (avoid repeated division)
-        blend = fg_a / 255.0
-        inv_blend = 1.0 - blend
-
-        # 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)
-
-        # Alpha blending - simplified calculation
-        out_a = int(fg_a + bg_a * inv_blend)
-
-        # 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.
-        Optimized version with caching and faster sampling.
-
-        Args:
-            array: The RGBA numpy array representing the image
-            x: Coordinate X to sample the background color from
-            y: Coordinate Y to sample the background color from
-            foreground: Foreground RGBA color (r,g,b,a) to blend on top
-
-        Returns:
-            Blended RGBA color
-        """
-        # 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
-
-        # 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(map(int, array[y, x]))
-
-                # Update cache (with simple LRU-like behavior)
-                try:
-                    if len(cache) >= ColorsManagement._cache_size:
-                        # Remove a random entry if cache is full
-                        if cache:  # Make sure cache is not empty
-                            cache.pop(next(iter(cache)))
-                        else:
-                            # If cache is somehow empty but len reported >= _cache_size
-                            # This is an edge case that shouldn't happen but we handle it
-                            pass
-                    cache[cache_key] = background
-                except KeyError:
-                    # If we encounter a KeyError, reset the cache
-                    # This is a rare edge case that might happen in concurrent access
-                    ColorsManagement._bg_color_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)
-
     def get_user_colors(self) -> List[Color]:
         """Return the list of RGBA colors for user-defined map elements."""
         return self.user_colors
@@ -525,303 +408,3 @@ class ColorsManagement:
     def get_rooms_colors(self) -> List[Color]:
         """Return the list of RGBA colors for rooms."""
         return self.rooms_colors
-
-    @staticmethod
-    def batch_blend_colors(image_array, mask, foreground_color):
-        """
-        Blend a foreground color with all pixels in an image where the mask is True.
-        Uses scipy.ndimage for efficient batch processing.
-
-        Args:
-            image_array: NumPy array of shape (height, width, 4) containing RGBA image data
-            mask: Boolean mask of shape (height, width) indicating pixels to blend
-            foreground_color: RGBA color tuple to blend with the masked pixels
-
-        Returns:
-            Modified image array with blended colors
-        """
-        if not np.any(mask):
-            return image_array  # No pixels to blend
-
-        # Extract foreground components
-        fg_r, fg_g, fg_b, fg_a = foreground_color
-
-        # Fast path for fully opaque foreground
-        if fg_a == 255:
-            # Just set the color directly where mask is True
-            image_array[mask, 0] = fg_r
-            image_array[mask, 1] = fg_g
-            image_array[mask, 2] = fg_b
-            image_array[mask, 3] = fg_a
-            return image_array
-
-        # Fast path for fully transparent foreground
-        if fg_a == 0:
-            return image_array  # No change needed
-
-        # For semi-transparent foreground, we need to blend
-        # Extract background components where mask is True
-        bg_pixels = image_array[mask]
-
-        # Convert alpha from [0-255] to [0-1] for calculations
-        fg_alpha = fg_a / 255.0
-        bg_alpha = bg_pixels[:, 3] / 255.0
-
-        # Calculate resulting alpha
-        out_alpha = fg_alpha + bg_alpha * (1 - fg_alpha)
-
-        # Calculate alpha ratios for blending
-        # Handle division by zero by setting ratio to 0 where out_alpha is near zero
-        alpha_ratio = np.zeros_like(out_alpha)
-        valid_alpha = out_alpha > 0.0001
-        alpha_ratio[valid_alpha] = fg_alpha / out_alpha[valid_alpha]
-        inv_alpha_ratio = 1.0 - alpha_ratio
-
-        # Calculate blended RGB components
-        out_r = np.clip(
-            (fg_r * alpha_ratio + bg_pixels[:, 0] * inv_alpha_ratio), 0, 255
-        ).astype(np.uint8)
-        out_g = np.clip(
-            (fg_g * alpha_ratio + bg_pixels[:, 1] * inv_alpha_ratio), 0, 255
-        ).astype(np.uint8)
-        out_b = np.clip(
-            (fg_b * alpha_ratio + bg_pixels[:, 2] * inv_alpha_ratio), 0, 255
-        ).astype(np.uint8)
-        out_a = np.clip((out_alpha * 255), 0, 255).astype(np.uint8)
-
-        # Update the image array with blended values
-        image_array[mask, 0] = out_r
-        image_array[mask, 1] = out_g
-        image_array[mask, 2] = out_b
-        image_array[mask, 3] = out_a
-
-        return image_array
-
-    @staticmethod
-    def process_regions_with_colors(image_array, regions_mask, colors):
-        """
-        Process multiple regions in an image with different colors using scipy.ndimage.
-        This is much faster than processing each region separately.
-
-        Args:
-            image_array: NumPy array of shape (height, width, 4) containing RGBA image data
-            regions_mask: NumPy array of shape (height, width) with integer labels for different regions
-            colors: List of RGBA color tuples corresponding to each region label
-
-        Returns:
-            Modified image array with all regions colored and blended
-        """
-        # Skip processing if no regions or colors
-        if regions_mask is None or not np.any(regions_mask) or not colors:
-            return image_array
-
-        # Get unique region labels (excluding 0 which is typically background)
-        unique_labels = np.unique(regions_mask)
-        unique_labels = unique_labels[unique_labels > 0]  # Skip background (0)
-
-        if len(unique_labels) == 0:
-            return image_array  # No regions to process
-
-        # Process each region with its corresponding color
-        for label in unique_labels:
-            if label <= len(colors):
-                # Create mask for this region
-                region_mask = regions_mask == label
-
-                # Get color for this region
-                color = colors[label - 1] if label - 1 < len(colors) else colors[0]
-
-                # Apply color to this region
-                image_array = ColorsManagement.batch_blend_colors(
-                    image_array, region_mask, color
-                )
-
-        return image_array
-
-    @staticmethod
-    def apply_color_to_shapes(image_array, shapes, color, thickness=1):
-        """
-        Apply a color to multiple shapes (lines, circles, etc.) using scipy.ndimage.
-
-        Args:
-            image_array: NumPy array of shape (height, width, 4) containing RGBA image data
-            shapes: List of shape definitions (each a list of points or parameters)
-            color: RGBA color tuple to apply to the shapes
-            thickness: Line thickness for shapes
-
-        Returns:
-            Modified image array with shapes drawn and blended
-        """
-        height, width = image_array.shape[:2]
-
-        # Create a mask for all shapes
-        shapes_mask = np.zeros((height, width), dtype=bool)
-
-        # Draw all shapes into the mask
-        for shape in shapes:
-            if len(shape) >= 2:  # At least two points for a line
-                # Draw line into mask
-                for i in range(len(shape) - 1):
-                    x1, y1 = shape[i]
-                    x2, y2 = shape[i + 1]
-
-                    # Use Bresenham's line algorithm via scipy.ndimage.map_coordinates
-                    # Create coordinates for the line
-                    length = int(np.hypot(x2 - x1, y2 - y1))
-                    if length == 0:
-                        continue
-
-                    t = np.linspace(0, 1, length * 2)
-                    x = np.round(x1 * (1 - t) + x2 * t).astype(int)
-                    y = np.round(y1 * (1 - t) + y2 * t).astype(int)
-
-                    # Filter points outside the image
-                    valid = (0 <= x) & (x < width) & (0 <= y) & (y < height)
-                    x, y = x[valid], y[valid]
-
-                    # Add points to mask
-                    if thickness == 1:
-                        shapes_mask[y, x] = True
-                    else:
-                        # For thicker lines, use a disk structuring element
-                        # Create a disk structuring element once
-                        disk_radius = thickness
-                        disk_size = 2 * disk_radius + 1
-                        disk_struct = np.zeros((disk_size, disk_size), dtype=bool)
-                        y_grid, x_grid = np.ogrid[
-                            -disk_radius : disk_radius + 1,
-                            -disk_radius : disk_radius + 1,
-                        ]
-                        mask = x_grid**2 + y_grid**2 <= disk_radius**2
-                        disk_struct[mask] = True
-
-                        # Use scipy.ndimage.binary_dilation for efficient dilation
-                        # Create a temporary mask for this line segment
-                        line_mask = np.zeros_like(shapes_mask)
-                        line_mask[y, x] = True
-                        # Dilate the line with the disk structuring element
-                        dilated_line = ndimage.binary_dilation(
-                            line_mask, structure=disk_struct
-                        )
-                        # Add to the overall shapes mask
-                        shapes_mask |= dilated_line
-
-        # Apply color to all shapes at once
-        return ColorsManagement.batch_blend_colors(image_array, shapes_mask, color)
-
-    @staticmethod
-    def batch_sample_colors(image_array, coordinates):
-        """
-        Efficiently sample colors from multiple coordinates in an image using scipy.ndimage.
-
-        Args:
-            image_array: NumPy array of shape (height, width, 4) containing RGBA image data
-            coordinates: List of (x,y) tuples or numpy array of shape (N,2) with coordinates to sample
-
-        Returns:
-            NumPy array of shape (N,4) containing the RGBA colors at each coordinate
-        """
-        if len(coordinates) == 0:
-            return np.array([])
-
-        height, width = image_array.shape[:2]
-
-        # Convert coordinates to numpy array if not already
-        coords = np.array(coordinates)
-
-        # Separate x and y coordinates
-        x_coords = coords[:, 0]
-        y_coords = coords[:, 1]
-
-        # Create a mask for valid coordinates (within image bounds)
-        valid_mask = (
-            (0 <= x_coords) & (x_coords < width) & (0 <= y_coords) & (y_coords < height)
-        )
-
-        # Initialize result array with zeros
-        result = np.zeros((len(coordinates), 4), dtype=np.uint8)
-
-        if not np.any(valid_mask):
-            return result  # No valid coordinates
-
-        # Filter valid coordinates
-        valid_x = x_coords[valid_mask].astype(int)
-        valid_y = y_coords[valid_mask].astype(int)
-
-        # Use scipy.ndimage.map_coordinates for efficient sampling
-        # This is much faster than looping through coordinates
-        for channel in range(4):
-            # Sample this color channel for all valid coordinates at once
-            channel_values = ndimage.map_coordinates(
-                image_array[..., channel],
-                np.vstack((valid_y, valid_x)),
-                order=0,  # Use nearest-neighbor interpolation
-                mode="nearest",
-            )
-
-            # Assign sampled values to result array
-            result[valid_mask, channel] = channel_values
-
-        return result
-
-    def cached_blend_colors(self, background: Color, foreground: Color) -> Color:
-        """
-        Cached version of blend_colors that stores frequently used combinations.
-        This improves performance when the same color combinations are used repeatedly.
-
-        Args:
-            background: Background RGBA color tuple
-            foreground: Foreground RGBA color tuple
-
-        Returns:
-            Blended RGBA color tuple
-        """
-        # Fast paths for common cases
-        if foreground[3] == 255:
-            return foreground
-        if foreground[3] == 0:
-            return background
-
-        # Create a cache key from the color tuples
-        cache_key = (background, foreground)
-
-        # Check if this combination is in the cache
-        if cache_key in self.color_cache:
-            return self.color_cache[cache_key]
-
-        # Calculate the blended color
-        result = ColorsManagement.blend_colors(background, foreground)
-
-        # Store in cache (with a maximum cache size to prevent memory issues)
-        if len(self.color_cache) < 1000:  # Limit cache size
-            self.color_cache[cache_key] = result
-
-        return result
-
-    def get_colour(self, supported_color: SupportedColor) -> Color:
-        """
-        Retrieve the color for a specific map element, prioritizing user-defined values.
-
-        :param supported_color: The SupportedColor key for the desired color.
-        :return: The RGBA color for the given map element.
-        """
-        # Handle room-specific colors
-        if supported_color.startswith("color_room_"):
-            room_index = int(supported_color.split("_")[-1])
-            try:
-                return self.rooms_colors[room_index]
-            except (IndexError, KeyError):
-                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)
-
-        # Handle general map element colors
-        try:
-            index = list(SupportedColor).index(supported_color)
-            return self.user_colors[index]
-        except (IndexError, KeyError, ValueError):
-            LOGGER.warning(
-                "Color for %s not found. Returning default.", supported_color
-            )
-            return DefaultColors.get_rgba(supported_color, 255)  # Transparent fallback