valetudo-map-parser 0.1.9b52__py3-none-any.whl → 0.1.9b53__py3-none-any.whl

valetudo_map_parser/config/colors.py

@@ -492,10 +492,20 @@ class ColorsManagement:
                 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
+                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

valetudo_map_parser/config/drawable.py

@@ -57,9 +57,6 @@ class Drawable:
         # Extract alpha from color
         alpha = color[3] if len(color) == 4 else 255
 
-        # For debugging
-        _LOGGER.debug("Drawing with color %s and alpha %s", color, alpha)
-
         # Create the full color with alpha
         full_color = color if len(color) == 4 else (*color, 255)
 

valetudo_map_parser/hypfer_rooms_handler.py

@@ -38,48 +38,130 @@ class HypferRoomsHandler:
         """
         self.vacuum_id = vacuum_id
         self.drawing_config = drawing_config
+        self.current_json_data = None  # Will store the current JSON data being processed
 
     @staticmethod
     def sublist(data: list, chunk_size: int) -> list:
         return [data[i : i + chunk_size] for i in range(0, len(data), chunk_size)]
 
+    # Cache for RDP results
+    _rdp_cache = {}
+
     @staticmethod
     def perpendicular_distance(
         point: tuple[int, int], line_start: tuple[int, int], line_end: tuple[int, int]
     ) -> float:
-        """Calculate the perpendicular distance from a point to a line."""
+        """Calculate the perpendicular distance from a point to a line.
+        Optimized for performance.
+        """
+        # Fast path for point-to-point distance
         if line_start == line_end:
-            return sqrt(
-                (point[0] - line_start[0]) ** 2 + (point[1] - line_start[1]) ** 2
-            )
+            dx = point[0] - line_start[0]
+            dy = point[1] - line_start[1]
+            return sqrt(dx*dx + dy*dy)
 
         x, y = point
         x1, y1 = line_start
         x2, y2 = line_end
 
-        # Calculate the line length
-        line_length = sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
-        if line_length == 0:
+        # Precompute differences for efficiency
+        dx = x2 - x1
+        dy = y2 - y1
+
+        # Calculate the line length squared (avoid sqrt until needed)
+        line_length_sq = dx*dx + dy*dy
+        if line_length_sq == 0:
             return 0
 
         # Calculate the distance from the point to the line
-        return abs((y2 - y1) * x - (x2 - x1) * y + x2 * y1 - y2 * x1) / line_length
+        # Using the formula: |cross_product| / |line_vector|
+        # This is more efficient than the original formula
+        cross_product = abs(dy * x - dx * y + x2 * y1 - y2 * x1)
+        return cross_product / sqrt(line_length_sq)
 
     async def rdp(
         self, points: List[Tuple[int, int]], epsilon: float
     ) -> List[Tuple[int, int]]:
-        """Ramer-Douglas-Peucker algorithm for simplifying a curve."""
+        """Ramer-Douglas-Peucker algorithm for simplifying a curve.
+        Optimized with caching and better performance.
+        """
+        # Create a hashable key for caching
+        # Convert points to a tuple for hashing
+        points_tuple = tuple(points)
+        cache_key = (points_tuple, epsilon)
+
+        # Check cache first
+        if cache_key in self._rdp_cache:
+            return self._rdp_cache[cache_key]
+
+        # Base case
         if len(points) <= 2:
             return points
 
-        # Find the point with the maximum distance
-        dmax = 0
-        index = 0
-        for i in range(1, len(points) - 1):
-            d = self.perpendicular_distance(points[i], points[0], points[-1])
-            if d > dmax:
-                index = i
-                dmax = d
+        # For very small point sets, process directly without recursion
+        if len(points) <= 5:
+            # Find the point with the maximum distance
+            dmax = 0
+            index = 0
+            for i in range(1, len(points) - 1):
+                d = self.perpendicular_distance(points[i], points[0], points[-1])
+                if d > dmax:
+                    index = i
+                    dmax = d
+
+            # If max distance is greater than epsilon, keep the point
+            if dmax > epsilon:
+                result = [points[0]] + [points[index]] + [points[-1]]
+            else:
+                result = [points[0], points[-1]]
+
+            # Cache and return
+            self._rdp_cache[cache_key] = result
+            return result
+
+        # For larger point sets, use numpy for faster distance calculation
+        if len(points) > 20:
+            # Convert to numpy arrays for vectorized operations
+            points_array = np.array(points)
+            start = points_array[0]
+            end = points_array[-1]
+
+            # Calculate perpendicular distances in one vectorized operation
+            line_vector = end - start
+            line_length = np.linalg.norm(line_vector)
+
+            if line_length == 0:
+                # If start and end are the same, use direct distance
+                distances = np.linalg.norm(points_array[1:-1] - start, axis=1)
+            else:
+                # Normalize line vector
+                line_vector = line_vector / line_length
+                # Calculate perpendicular distances using vector operations
+                vectors_to_points = points_array[1:-1] - start
+                # Project vectors onto line vector
+                projections = np.dot(vectors_to_points, line_vector)
+                # Calculate projected points on line
+                projected_points = start + np.outer(projections, line_vector)
+                # Calculate distances from points to their projections
+                distances = np.linalg.norm(points_array[1:-1] - projected_points, axis=1)
+
+            # Find the point with maximum distance
+            if len(distances) > 0:
+                max_idx = np.argmax(distances)
+                dmax = distances[max_idx]
+                index = max_idx + 1  # +1 because we skipped the first point
+            else:
+                dmax = 0
+                index = 0
+        else:
+            # For medium-sized point sets, use the original algorithm
+            dmax = 0
+            index = 0
+            for i in range(1, len(points) - 1):
+                d = self.perpendicular_distance(points[i], points[0], points[-1])
+                if d > dmax:
+                    index = i
+                    dmax = d
 
         # If max distance is greater than epsilon, recursively simplify
         if dmax > epsilon:
@@ -88,9 +170,23 @@ class HypferRoomsHandler:
             second_segment = await self.rdp(points[index:], epsilon)
 
             # Build the result list (avoiding duplicating the common point)
-            return first_segment[:-1] + second_segment
+            result = first_segment[:-1] + second_segment
         else:
-            return [points[0], points[-1]]
+            result = [points[0], points[-1]]
+
+        # Limit cache size
+        if len(self._rdp_cache) > 100:  # Keep only 100 most recent items
+            try:
+                self._rdp_cache.pop(next(iter(self._rdp_cache)))
+            except (StopIteration, KeyError):
+                pass
+
+        # Cache the result
+        self._rdp_cache[cache_key] = result
+        return result
+
+    # Cache for corner results
+    _corners_cache = {}
 
     async def async_get_corners(
         self, mask: np.ndarray, epsilon_factor: float = 0.05
@@ -98,6 +194,7 @@ class HypferRoomsHandler:
         """
         Get the corners of a room shape as a list of (x, y) tuples.
         Uses contour detection and Douglas-Peucker algorithm to simplify the contour.
+        Optimized with caching and faster calculations.
 
         Args:
             mask: Binary mask of the room (1 for room, 0 for background)
@@ -106,7 +203,18 @@ class HypferRoomsHandler:
         Returns:
             List of (x, y) tuples representing the corners of the room
         """
-        # Find contours in the mask
+        # Create a hash of the mask and epsilon factor for caching
+        mask_hash = hash((mask.tobytes(), epsilon_factor))
+
+        # Check if we have a cached result
+        if mask_hash in self._corners_cache:
+            return self._corners_cache[mask_hash]
+
+        # Fast path for empty masks
+        if not np.any(mask):
+            return []
+
+        # Find contours in the mask - this uses our optimized method with caching
         contour = await self.async_moore_neighbor_trace(mask)
 
         if not contour:
@@ -118,7 +226,7 @@ class HypferRoomsHandler:
             x_min, x_max = np.min(x_indices), np.max(x_indices)
             y_min, y_max = np.min(y_indices), np.max(y_indices)
 
-            return [
+            result = [
                 (x_min, y_min),  # Top-left
                 (x_max, y_min),  # Top-right
                 (x_max, y_max),  # Bottom-right
@@ -126,12 +234,28 @@ class HypferRoomsHandler:
                 (x_min, y_min),  # Back to top-left to close the polygon
             ]
 
-        # Calculate the perimeter of the contour
-        perimeter = 0
-        for i in range(len(contour) - 1):
-            x1, y1 = contour[i]
-            x2, y2 = contour[i + 1]
-            perimeter += np.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
+            # Cache the result
+            self._corners_cache[mask_hash] = result
+            return result
+
+        # For small contours (less than 10 points), skip simplification
+        if len(contour) <= 10:
+            # Ensure the contour is closed
+            if contour[0] != contour[-1]:
+                contour.append(contour[0])
+
+            # Cache and return
+            self._corners_cache[mask_hash] = contour
+            return contour
+
+        # For larger contours, calculate perimeter more efficiently using numpy
+        points = np.array(contour)
+        # Calculate differences between consecutive points
+        diffs = np.diff(points, axis=0)
+        # Calculate squared distances
+        squared_dists = np.sum(diffs**2, axis=1)
+        # Calculate perimeter as sum of distances
+        perimeter = np.sum(np.sqrt(squared_dists))
 
         # Apply Douglas-Peucker algorithm to simplify the contour
         epsilon = epsilon_factor * perimeter
@@ -147,7 +271,7 @@ class HypferRoomsHandler:
             LOGGER.debug(
                 f"{self.vacuum_id}: Too few points in contour, using bounding box"
             )
-            return [
+            result = [
                 (x_min, y_min),  # Top-left
                 (x_max, y_min),  # Top-right
                 (x_max, y_max),  # Bottom-right
@@ -155,16 +279,34 @@ class HypferRoomsHandler:
                 (x_min, y_min),  # Back to top-left to close the polygon
             ]
 
+            # Cache the result
+            self._corners_cache[mask_hash] = result
+            return result
+
         # Ensure the contour is closed
         if simplified_contour[0] != simplified_contour[-1]:
             simplified_contour.append(simplified_contour[0])
 
+        # Limit cache size
+        if len(self._corners_cache) > 50:  # Keep only 50 most recent items
+            try:
+                self._corners_cache.pop(next(iter(self._corners_cache)))
+            except (StopIteration, KeyError):
+                pass
+
+        # Cache the result
+        self._corners_cache[mask_hash] = simplified_contour
         return simplified_contour
 
+    # Cache for labeled arrays to avoid redundant calculations
+    _label_cache = {}
+    _hull_cache = {}
+
     @staticmethod
     async def async_moore_neighbor_trace(mask: np.ndarray) -> List[Tuple[int, int]]:
         """
-        Trace the contour of a binary mask using an optimized Moore-Neighbor tracing.
+        Trace the contour of a binary mask using an optimized approach.
+        Uses caching and simplified algorithms for better performance.
 
         Args:
             mask: Binary mask of the room (1 for room, 0 for background)
@@ -172,81 +314,129 @@ class HypferRoomsHandler:
         Returns:
             List of (x, y) tuples representing the contour
         """
-        # Convert to uint8 and pad
-        padded = np.pad(mask.astype(np.uint8), 1, mode="constant")
-        height, width = padded.shape
-
-        # Find the first non-zero point efficiently (scan row by row)
-        # This is much faster than np.argwhere() for large arrays
-        start = None
-        for y in range(height):
-            # Use NumPy's any() to quickly check if there are any 1s in this row
-            if np.any(padded[y]):
-                # Find the first 1 in this row
-                x = np.where(padded[y] == 1)[0][0]
-                start = (int(x), int(y))
-                break
-
-        if start is None:
+        # Create a hash of the mask for caching
+        mask_hash = hash(mask.tobytes())
+
+        # Check if we have a cached result
+        if mask_hash in HypferRoomsHandler._hull_cache:
+            return HypferRoomsHandler._hull_cache[mask_hash]
+
+        # Fast path for empty masks
+        if not np.any(mask):
             return []
 
-        # Pre-compute directions
-        directions = [
-            (-1, -1),
-            (-1, 0),
-            (-1, 1),
-            (0, 1),
-            (1, 1),
-            (1, 0),
-            (1, -1),
-            (0, -1),
-        ]
-
-        # Use a 2D array for visited tracking (faster than set)
-        visited = np.zeros((height, width), dtype=bool)
-
-        # Initialize contour
-        contour = []
-        contour.append((int(start[0] - 1), int(start[1] - 1)))  # Adjust for padding
-
-        current = start
-        prev_dir = 7
-        visited[current[1], current[0]] = True
-
-        # Main tracing loop
-        while True:
-            found = False
-
-            # Check all 8 directions
-            for i in range(8):
-                dir_idx = (prev_dir + i) % 8
-                dx, dy = directions[dir_idx]
-                nx, ny = current[0] + dx, current[1] + dy
-
-                # Bounds check and value check
-                if (
-                    0 <= ny < height
-                    and 0 <= nx < width
-                    and padded[ny, nx] == 1
-                    and not visited[ny, nx]
-                ):
-                    current = (nx, ny)
-                    visited[ny, nx] = True
-                    contour.append(
-                        (int(nx - 1), int(ny - 1))
-                    )  # Adjust for padding and convert to int
-                    prev_dir = (dir_idx + 5) % 8
-                    found = True
-                    break
-
-            # Check termination conditions
-            if not found or (
-                len(contour) > 3
-                and (int(current[0] - 1), int(current[1] - 1)) == contour[0]
-            ):
-                break
-
-        return contour
+        # Find bounding box of non-zero elements (much faster than full labeling for simple cases)
+        y_indices, x_indices = np.where(mask > 0)
+        if len(x_indices) == 0 or len(y_indices) == 0:
+            return []
+
+        # For very small rooms (less than 100 pixels), just use bounding box
+        if len(x_indices) < 100:
+            x_min, x_max = np.min(x_indices), np.max(x_indices)
+            y_min, y_max = np.min(y_indices), np.max(y_indices)
+
+            # Create a simple rectangle
+            hull_vertices = [
+                (int(x_min), int(y_min)),  # Top-left
+                (int(x_max), int(y_min)),  # Top-right
+                (int(x_max), int(y_max)),  # Bottom-right
+                (int(x_min), int(y_max)),  # Bottom-left
+                (int(x_min), int(y_min)),  # Back to top-left to close the polygon
+            ]
+
+            # Cache and return the result
+            HypferRoomsHandler._hull_cache[mask_hash] = hull_vertices
+            return hull_vertices
+
+        # For larger rooms, use convex hull but with optimizations
+        try:
+            # Import here to avoid overhead for small rooms
+            from scipy import ndimage
+            from scipy.spatial import ConvexHull
+
+            # Use cached labeled array if available
+            if mask_hash in HypferRoomsHandler._label_cache:
+                labeled_array = HypferRoomsHandler._label_cache[mask_hash]
+            else:
+                # Find connected components - this is expensive
+                labeled_array, _ = ndimage.label(mask)
+                # Cache the result for future use
+                HypferRoomsHandler._label_cache[mask_hash] = labeled_array
+
+                # Limit cache size to prevent memory issues
+                if len(HypferRoomsHandler._label_cache) > 50:  # Keep only 50 most recent items
+                    # Remove oldest item (first key)
+                    try:
+                        HypferRoomsHandler._label_cache.pop(next(iter(HypferRoomsHandler._label_cache)))
+                    except (StopIteration, KeyError):
+                        # Handle edge case of empty cache
+                        pass
+
+            # Create a mask with all components
+            all_components_mask = (labeled_array > 0)
+
+            # Sample points instead of using all points for large masks
+            # This significantly reduces computation time for ConvexHull
+            if len(x_indices) > 1000:
+                # Sample every 10th point for very large rooms
+                step = 10
+            elif len(x_indices) > 500:
+                # Sample every 5th point for medium-sized rooms
+                step = 5
+            else:
+                # Use all points for smaller rooms
+                step = 1
+
+            # Sample points using the step size
+            sampled_y = y_indices[::step]
+            sampled_x = x_indices[::step]
+
+            # Create a list of points
+            points = np.column_stack((sampled_x, sampled_y))
+
+            # Compute the convex hull
+            hull = ConvexHull(points)
+
+            # Extract the vertices of the convex hull
+            hull_vertices = [(int(points[v, 0]), int(points[v, 1])) for v in hull.vertices]
+
+            # Ensure the hull is closed
+            if hull_vertices[0] != hull_vertices[-1]:
+                hull_vertices.append(hull_vertices[0])
+
+            # Cache and return the result
+            HypferRoomsHandler._hull_cache[mask_hash] = hull_vertices
+
+            # Limit hull cache size
+            if len(HypferRoomsHandler._hull_cache) > 50:
+                try:
+                    HypferRoomsHandler._hull_cache.pop(next(iter(HypferRoomsHandler._hull_cache)))
+                except (StopIteration, KeyError):
+                    pass
+
+            return hull_vertices
+
+        except Exception as e:
+            LOGGER.warning(f"Failed to compute convex hull: {e}. Falling back to bounding box.")
+
+            # Fallback to bounding box if convex hull fails
+            x_min, x_max = np.min(x_indices), np.max(x_indices)
+            y_min, y_max = np.min(y_indices), np.max(y_indices)
+
+            # Create a simple rectangle
+            hull_vertices = [
+                (int(x_min), int(y_min)),  # Top-left
+                (int(x_max), int(y_min)),  # Top-right
+                (int(x_max), int(y_max)),  # Bottom-right
+                (int(x_min), int(y_max)),  # Bottom-left
+                (int(x_min), int(y_min)),  # Back to top-left to close the polygon
+            ]
+
+            # Cache and return the result
+            HypferRoomsHandler._hull_cache[mask_hash] = hull_vertices
+            return hull_vertices
+
+
 
     async def async_extract_room_properties(
         self, json_data: Dict[str, Any]
@@ -267,6 +457,9 @@ class HypferRoomsHandler:
         vacuum_id = self.vacuum_id
         room_id_counter = 0
 
+        # Store the JSON data for reference in other methods
+        self.current_json_data = json_data
+
         for layer in json_data.get("layers", []):
             if layer.get("__class") == "MapLayer" and layer.get("type") == "segment":
                 meta_data = layer.get("metaData", {})

{valetudo_map_parser-0.1.9b52.dist-info → valetudo_map_parser-0.1.9b53.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: valetudo-map-parser
-Version: 0.1.9b52
+Version: 0.1.9b53
 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.9b52.dist-info → valetudo_map_parser-0.1.9b53.dist-info}/RECORD

@@ -2,8 +2,8 @@ valetudo_map_parser/__init__.py,sha256=cewtLadNSOg3X2Ts2SuG8mTJqo0ncsFRg_sQ4VkM4
 valetudo_map_parser/config/__init__.py,sha256=DQ9plV3ZF_K25Dp5ZQHPDoG-40dQoJNdNi-dfNeR3Zc,48
 valetudo_map_parser/config/auto_crop.py,sha256=6OvRsWzXMXBaSEvgwpaaisNdozDKiDyTmPjknFxoUMc,12624
 valetudo_map_parser/config/color_utils.py,sha256=D4NXRhuPdQ7UDKM3vLNYR0HnACl9AB75EnfCp5tGliI,4502
-valetudo_map_parser/config/colors.py,sha256=5nk8QbNomv_WeE2rOLIswroGsxV4RZMd0slXrPlt-MY,29297
-valetudo_map_parser/config/drawable.py,sha256=VhaNK62EBCxcQdNg7-dyUNepsYX6IFzej3raOt7_rVU,34268
+valetudo_map_parser/config/colors.py,sha256=LE7sl4Qy0TkxbkjgB3dotYIfXqhc-fllkFQxexVvUvg,29909
+valetudo_map_parser/config/drawable.py,sha256=qenuxD1-Vvyus9o8alJFYRqL54aO3pakMqPSYNGvpe8,34169
 valetudo_map_parser/config/drawable_elements.py,sha256=bkEwdbx1upt9vaPaqE_VR1rtwRsaiH-IVKc3mHNa8IY,12065
 valetudo_map_parser/config/enhanced_drawable.py,sha256=6yGoOq_dLf2VCghO_URSyGfLAshFyzS3iEPeHw1PeDo,12586
 valetudo_map_parser/config/optimized_element_map.py,sha256=52BCnkvVv9bre52LeVIfT8nhnEIpc0TuWTv1xcNu0Rk,15744
@@ -14,13 +14,13 @@ valetudo_map_parser/config/types.py,sha256=e-eZSwbPm3m5JfCDaKhnUFspmcRFSv74huxeg
 valetudo_map_parser/config/utils.py,sha256=RsMjpjVqNbkI502yhLiRaB0GjCADqmRRcz-TkC6zklQ,31073
 valetudo_map_parser/hypfer_draw.py,sha256=P8CrKysLaBb63ZArfqxN2Og6JCU6sPHPFHOte5noCGg,26654
 valetudo_map_parser/hypfer_handler.py,sha256=WYFrp-q5wBsy0cTcVQUCXXVGTtW30z2W2dYvjKz2el8,23292
-valetudo_map_parser/hypfer_rooms_handler.py,sha256=3QL8QZc6aMXxYn_L6gv1iL204I0rAzutWPVzc_4MfJ4,14505
+valetudo_map_parser/hypfer_rooms_handler.py,sha256=NkpOA6Gdq-2D3lLAxvtNuuWMvPXHxeMY2TO5RZLSHlU,22652
 valetudo_map_parser/map_data.py,sha256=zQKE8EzWxR0r0qyfD1QQq51T1wFrpcIeXtnpm92-LXQ,17743
 valetudo_map_parser/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 valetudo_map_parser/rand25_handler.py,sha256=eLFX_gmGLaWQwvp8hVj8CgcNOfLsYNIdE1OLRcQy_yM,19988
 valetudo_map_parser/reimg_draw.py,sha256=1q8LkNTPHEA9Tsapc_JnVw51kpPYNhaBU-KmHkefCQY,12507
-valetudo_map_parser-0.1.9b52.dist-info/LICENSE,sha256=Lh-qBbuRV0-jiCIBhfV7NgdwFxQFOXH3BKOzK865hRs,10480
-valetudo_map_parser-0.1.9b52.dist-info/METADATA,sha256=jd0uF9vdxA_LxkXlWoLtOCyWvXJD3knHXVTQYDNn3E4,3321
-valetudo_map_parser-0.1.9b52.dist-info/NOTICE.txt,sha256=5lTOuWiU9aiEnJ2go8sc7lTJ7ntMBx0g0GFnNrswCY4,2533
-valetudo_map_parser-0.1.9b52.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-valetudo_map_parser-0.1.9b52.dist-info/RECORD,,
+valetudo_map_parser-0.1.9b53.dist-info/LICENSE,sha256=Lh-qBbuRV0-jiCIBhfV7NgdwFxQFOXH3BKOzK865hRs,10480
+valetudo_map_parser-0.1.9b53.dist-info/METADATA,sha256=i8nDujD2s2Qs62WwEv-3AIO23XJTvxvSZXY5QcswEtc,3321
+valetudo_map_parser-0.1.9b53.dist-info/NOTICE.txt,sha256=5lTOuWiU9aiEnJ2go8sc7lTJ7ntMBx0g0GFnNrswCY4,2533
+valetudo_map_parser-0.1.9b53.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+valetudo_map_parser-0.1.9b53.dist-info/RECORD,,