valetudo-map-parser 0.1.9b69__tar.gz → 0.1.9b71__tar.gz

{valetudo_map_parser-0.1.9b69 → valetudo_map_parser-0.1.9b71}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: valetudo-map-parser
-Version: 0.1.9b69
+Version: 0.1.9b71
 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.9b69 → valetudo_map_parser-0.1.9b71}/SCR/valetudo_map_parser/config/drawable.py

@@ -12,8 +12,6 @@ from __future__ import annotations
 
 import logging
 import math
-import asyncio
-import inspect
 
 import numpy as np
 from PIL import ImageDraw, ImageFont
@@ -46,12 +44,8 @@ class Drawable:
         width: int, height: int, background_color: Color
     ) -> NumpyArray:
         """Create the empty background image NumPy array.
-        Background color is specified as an RGBA tuple.
-        Optimized: Uses np.empty + broadcast instead of np.full for better performance."""
-        # Use np.empty + broadcast instead of np.full (avoids double initialization)
-        img_array = np.empty((height, width, 4), dtype=np.uint8)
-        img_array[:] = background_color  # Broadcast color to all pixels efficiently
-        return img_array
+        Background color is specified as an RGBA tuple."""
+        return np.full((height, width, 4), background_color, dtype=np.uint8)
 
     @staticmethod
     async def from_json_to_image(
@@ -158,8 +152,6 @@ class Drawable:
         It uses the rotation angle of the image to orient the flag.
         Includes color blending for better visual integration.
         """
-        await asyncio.sleep(0)  # Yield control
-
         # Check if coordinates are within bounds
         height, width = layer.shape[:2]
         x, y = center
@@ -231,9 +223,7 @@ class Drawable:
 
     @staticmethod
     def point_inside(x: int, y: int, points: list[Tuple[int, int]]) -> bool:
-        """
-        Check if a point (x, y) is inside a polygon defined by a list of points.
-        """
+        """Check if a point (x, y) is inside a polygon defined by a list of points."""
         n = len(points)
         inside = False
         xinters = 0.0
@@ -250,140 +240,85 @@ class Drawable:
         return inside
 
     @staticmethod
+    def _bresenham_line_coords(x1: int, y1: int, x2: int, y2: int) -> Tuple[np.ndarray, np.ndarray]:
+        """Return integer coordinates for a line using Bresenham's algorithm."""
+        dx = abs(x2 - x1)
+        dy = abs(y2 - y1)
+        sx = 1 if x1 < x2 else -1
+        sy = 1 if y1 < y2 else -1
+        err = dx - dy
+    
+        xs, ys = [], []
+        while True:
+            xs.append(x1)
+            ys.append(y1)
+            if x1 == x2 and y1 == y2:
+                break
+            e2 = 2 * err
+            if e2 > -dy:
+                err -= dy
+                x1 += sx
+            if e2 < dx:
+                err += dx
+                y1 += sy
+        return np.array(xs, dtype=int), np.array(ys, dtype=int)
+    
+    
     def _line(
-        layer: NumpyArray,
+        layer: np.ndarray,
         x1: int,
         y1: int,
         x2: int,
         y2: int,
         color: Color,
         width: int = 3,
-    ) -> NumpyArray:
-        """
-        Draw a line on a NumPy array (layer) from point A to B using vectorized operations.
-
+    ) -> np.ndarray:
+        """Draw a line on a NumPy array (layer) from point A to B using a fully vectorized approach.
+    
         Args:
-            layer: The numpy array to draw on
+            layer: The numpy array to draw on (H, W, C)
             x1, y1: Start point coordinates
             x2, y2: End point coordinates
-            color: Color to draw with
-            width: Width of the line
+            color: Color to draw with (tuple or array)
+            width: Width of the line in pixels
         """
-        # Ensure coordinates are integers
         x1, y1, x2, y2 = int(x1), int(y1), int(x2), int(y2)
-
-        # Get blended color for the line
+        h, w = layer.shape[:2]
+    
         blended_color = get_blended_color(x1, y1, x2, y2, layer, color)
-
-        # Calculate line length
-        length = max(abs(x2 - x1), abs(y2 - y1))
-        if length == 0:  # Handle case of a single point
-            # Draw a dot with the specified width
-            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] = blended_color
-            return layer
-
-        # Create parametric points along the line
-        t = np.linspace(0, 1, length * 2)  # Double the points for smoother lines
-        x_coords = np.round(x1 * (1 - t) + x2 * t).astype(int)
-        y_coords = np.round(y1 * (1 - t) + y2 * t).astype(int)
-
-        # Draw the line with the specified width
+    
+        # Get core line coordinates
+        xs, ys = _bresenham_line_coords(x1, y1, x2, y2)
+    
         if width == 1:
-            # Fast path for width=1
-            for x, y in zip(x_coords, y_coords):
-                if 0 <= x < layer.shape[1] and 0 <= y < layer.shape[0]:
-                    layer[y, x] = blended_color
-        else:
-            # For thicker lines, draw a rectangle at each point
-            half_width = width // 2
-            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  # 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
-
-    @staticmethod
-    def draw_lines_batch(
-        layer: NumpyArray,
-        line_segments: list,
-        color: Color,
-        width: int = 3,
-    ) -> NumpyArray:
-        """
-        Draw multiple line segments with batch processing for better performance.
-
-        Args:
-            layer: The numpy array to draw on
-            line_segments: List of tuples [(x1, y1, x2, y2), ...]
-            color: Color to draw with
-            width: Width of the lines
-        """
-        if not line_segments:
+            # Clip to bounds in one go
+            mask = (xs >= 0) & (xs < w) & (ys >= 0) & (ys < h)
+            layer[ys[mask], xs[mask]] = blended_color
             return layer
-
-        # Pre-calculate blended color once for the entire batch
-        # Use the first line segment for color sampling
-        x1, y1, x2, y2 = line_segments[0]
-        blended_color = get_blended_color(x1, y1, x2, y2, layer, color)
-
-        # Fast path for fully opaque colors - skip individual blending
-        if color[3] == 255:
-            blended_color = color
-
-        # Process all line segments with the same blended color
-        for x1, y1, x2, y2 in line_segments:
-            # Ensure coordinates are integers
-            x1, y1, x2, y2 = int(x1), int(y1), int(x2), int(y2)
-
-            # Calculate line length
-            length = max(abs(x2 - x1), abs(y2 - y1))
-            if length == 0:  # Handle case of a single point
-                # Draw a dot with the specified width
-                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] = blended_color
-                continue
-
-            # Create parametric points along the line
-            t = np.linspace(0, 1, length + 1)  # Reduced from length * 2 to length + 1
-            x_coords = np.round(x1 * (1 - t) + x2 * t).astype(int)
-            y_coords = np.round(y1 * (1 - t) + y2 * t).astype(int)
-
-            # Draw the line with the specified width
-            if width == 1:
-                # Fast path for width=1
-                for x, y in zip(x_coords, y_coords):
-                    if 0 <= x < layer.shape[1] and 0 <= y < layer.shape[0]:
-                        layer[y, x] = blended_color
-            else:
-                # For thicker lines, draw a rectangle at each point
-                half_width = width // 2
-                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  # Make it round
-                                and 0 <= x + i < layer.shape[1]
-                                and 0 <= y + j < layer.shape[0]
-                            ):
-                                layer[y + j, x + i] = blended_color
-
+    
+        # Precompute circular mask for thickness
+        r = width // 2
+        yy, xx = np.ogrid[-r:r + 1, -r:r + 1]
+        circle_mask = (xx**2 + yy**2) <= r**2
+        dy_idx, dx_idx = np.nonzero(circle_mask)  # offsets inside the circle
+        dy_idx -= r
+        dx_idx -= r
+    
+        # Broadcast offsets to all line points
+        all_x = (xs[:, None] + dx_idx[None, :]).ravel()
+        all_y = (ys[:, None] + dy_idx[None, :]).ravel()
+    
+        # Clip to image bounds
+        valid = (all_x >= 0) & (all_x < w) & (all_y >= 0) & (all_y < h)
+        all_x = all_x[valid]
+        all_y = all_y[valid]
+    
+        # Draw all pixels in one go
+        layer[all_y, all_x] = blended_color
+    
         return layer
 
+
     @staticmethod
     async def draw_virtual_walls(
         layer: NumpyArray, virtual_walls, color: Color
@@ -402,15 +337,8 @@ class Drawable:
     async def lines(arr: NumpyArray, coords, width: int, color: Color) -> NumpyArray:
         """
         Join the coordinates creating a continuous line (path).
-        Optimized with batch processing for better performance.
+        Optimized with vectorized operations for better performance.
         """
-
-        # Handle case where arr might be a coroutine (shouldn't happen but let's be safe)
-        if inspect.iscoroutine(arr):
-            arr = await arr
-
-        # Collect all line segments for batch processing
-        line_segments = []
         for coord in coords:
             x0, y0 = coord[0]
             try:
@@ -422,16 +350,11 @@ class Drawable:
             if x0 == x1 and y0 == y1:
                 continue
 
-            line_segments.append((x0, y0, x1, y1))
-
-        # Process all line segments in batches
-        batch_size = 100  # Process 100 lines at a time
-        for i in range(0, len(line_segments), batch_size):
-            batch = line_segments[i : i + batch_size]
-            arr = Drawable.draw_lines_batch(arr, batch, color, width)
+            # Get blended color for this line segment
+            blended_color = get_blended_color(x0, y0, x1, y1, arr, color)
 
-            # Yield control between batches to prevent blocking
-            await asyncio.sleep(0)
+            # Use the optimized line drawing method
+            arr = Drawable._line(arr, x0, y0, x1, y1, blended_color, width)
 
         return arr
 
@@ -577,130 +500,56 @@ class Drawable:
     async def zones(layers: NumpyArray, coordinates, color: Color) -> NumpyArray:
         """
         Draw the zones on the input layer with color blending.
-        Optimized with parallel processing for better performance.
+        Optimized with NumPy vectorized operations for better performance.
         """
-        await asyncio.sleep(0)  # Yield control
-
         dot_radius = 1  # Number of pixels for the dot
         dot_spacing = 4  # Space between dots
 
-        # Process zones in parallel if there are multiple zones
-        if len(coordinates) > 1:
-            # Create tasks for parallel zone processing
-            zone_tasks = []
-            for zone in coordinates:
-                zone_tasks.append(
-                    Drawable._process_single_zone(
-                        layers.copy(), zone, color, dot_radius, dot_spacing
-                    )
-                )
-
-            # Execute all zone processing tasks in parallel
-            zone_results = await asyncio.gather(*zone_tasks, return_exceptions=True)
-
-            # Merge results back into the main layer
-            for result in zone_results:
-                if not isinstance(result, Exception):
-                    # Simple overlay - pixels that are different from original get updated
-                    mask = result != layers
-                    layers[mask] = result[mask]
-        else:
-            # Single zone - process directly
-            for zone in coordinates:
-                points = zone["points"]
-                min_x = max(0, min(points[::2]))
-                max_x = min(layers.shape[1] - 1, max(points[::2]))
-                min_y = max(0, min(points[1::2]))
-                max_y = min(layers.shape[0] - 1, max(points[1::2]))
-
-                # Skip if zone is outside the image
-                if min_x >= max_x or min_y >= max_y:
-                    continue
-
-                # 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 = ColorsManagement.sample_and_blend_color(
-                        layers, sample_x, sample_y, color
-                    )
-                else:
-                    blended_color = color
-
-                # Create a grid of dot centers
-                x_centers = np.arange(min_x, max_x, dot_spacing)
-                y_centers = np.arange(min_y, max_y, dot_spacing)
-
-                # Draw dots at each grid point
-                for y in y_centers:
-                    for x in x_centers:
-                        # Create a small mask for the dot
-                        y_min = max(0, y - dot_radius)
-                        y_max = min(layers.shape[0], y + dot_radius + 1)
-                        x_min = max(0, x - dot_radius)
-                        x_max = min(layers.shape[1], x + dot_radius + 1)
+        for zone in coordinates:
+            points = zone["points"]
+            min_x = max(0, min(points[::2]))
+            max_x = min(layers.shape[1] - 1, max(points[::2]))
+            min_y = max(0, min(points[1::2]))
+            max_y = min(layers.shape[0] - 1, max(points[1::2]))
 
-                        # Create coordinate arrays for the dot
-                        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
-
-                        # Apply the color to the masked region
-                        layers[y_min:y_max, x_min:x_max][mask] = blended_color
-
-        return layers
-
-    @staticmethod
-    async def _process_single_zone(
-        layers: NumpyArray, zone, color: Color, dot_radius: int, dot_spacing: int
-    ) -> NumpyArray:
-        """Process a single zone for parallel execution."""
-        await asyncio.sleep(0)  # Yield control
+            # Skip if zone is outside the image
+            if min_x >= max_x or min_y >= max_y:
+                continue
 
-        points = zone["points"]
-        min_x = max(0, min(points[::2]))
-        max_x = min(layers.shape[1] - 1, max(points[::2]))
-        min_y = max(0, min(points[1::2]))
-        max_y = min(layers.shape[0] - 1, 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
 
-        # Skip if zone is outside the image
-        if min_x >= max_x or min_y >= max_y:
-            return layers
-
-        # Sample a point from the zone to get the background color
-        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 = ColorsManagement.sample_and_blend_color(
+                    layers, sample_x, sample_y, color
+                )
+            else:
+                blended_color = color
 
-        # 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 = ColorsManagement.sample_and_blend_color(
-                layers, sample_x, sample_y, color
-            )
-        else:
-            blended_color = color
+            # Create a grid of dot centers
+            x_centers = np.arange(min_x, max_x, dot_spacing)
+            y_centers = np.arange(min_y, max_y, dot_spacing)
 
-        # Create a dotted pattern within the zone
-        for y in range(min_y, max_y + 1, dot_spacing):
-            for x in range(min_x, max_x + 1, dot_spacing):
-                if Drawable.point_inside(x, y, points):
-                    # Draw a small filled circle (dot) using vectorized operations
+            # Draw dots at each grid point
+            for y in y_centers:
+                for x in x_centers:
+                    # Create a small mask for the dot
                     y_min = max(0, y - dot_radius)
                     y_max = min(layers.shape[0], y + dot_radius + 1)
                     x_min = max(0, x - dot_radius)
                     x_max = min(layers.shape[1], x + dot_radius + 1)
 
-                    if y_min < y_max and x_min < x_max:
-                        y_indices, x_indices = np.ogrid[y_min:y_max, x_min:x_max]
-                        mask = (y_indices - y) ** 2 + (
-                            x_indices - x
-                        ) ** 2 <= dot_radius**2
-                        layers[y_min:y_max, x_min:x_max][mask] = blended_color
+                    # Create coordinate arrays for the dot
+                    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
+
+                    # Apply the color to the masked region
+                    layers[y_min:y_max, x_min:x_max][mask] = blended_color
 
         return layers
 

{valetudo_map_parser-0.1.9b69 → valetudo_map_parser-0.1.9b71}/SCR/valetudo_map_parser/hypfer_draw.py

@@ -1,12 +1,11 @@
 """
 Image Draw Class for Valetudo Hypfer Image Handling.
 This class is used to simplify the ImageHandler class.
-Version: 2024.07.2
+Version: 0.1.9
 """
 
 from __future__ import annotations
 
-import asyncio
 import logging
 
 from .config.drawable_elements import DrawableElement

{valetudo_map_parser-0.1.9b69 → valetudo_map_parser-0.1.9b71}/SCR/valetudo_map_parser/hypfer_handler.py

@@ -8,6 +8,7 @@ Version: 0.1.9
 from __future__ import annotations
 
 import asyncio
+import numpy as np
 
 from PIL import Image
 
@@ -58,6 +59,7 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
         self.go_to = None  # vacuum go to data
         self.img_hash = None  # hash of the image calculated to check differences.
         self.img_base_layer = None  # numpy array store the map base layer.
+        self.img_work_layer = None  # persistent working buffer to avoid per-frame allocations
         self.active_zones = None  # vacuum active zones.
         self.svg_wait = False  # SVG image creation wait.
         self.imd = ImDraw(self)  # Image Draw class.
@@ -210,14 +212,12 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                                         ) % 16  # Increment room_id even if we skip
                                         continue
 
-                            # Check if this is a wall layer and if walls are enabled
+                            # Draw the layer ONLY if enabled
                             is_wall_layer = layer_type == "wall"
                             if is_wall_layer:
-                                if not self.drawing_config.is_enabled(
-                                    DrawableElement.WALL
-                                ):
-                                    pass
-
+                                # Skip walls entirely if disabled
+                                if not self.drawing_config.is_enabled(DrawableElement.WALL):
+                                    continue
                             # Draw the layer
                             (
                                 room_id,
@@ -273,6 +273,8 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                     LOGGER.info("%s: Completed base Layers", self.file_name)
                     # Copy the new array in base layer.
                     self.img_base_layer = await self.async_copy_array(img_np_array)
+
+
                 self.shared.frame_number = self.frame_number
                 self.frame_number += 1
                 if (self.frame_number >= self.max_frames) or (
@@ -285,8 +287,17 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                     str(self.json_id),
                     str(self.frame_number),
                 )
-                # Copy the base layer to the new image.
-                img_np_array = await self.async_copy_array(self.img_base_layer)
+                # Ensure persistent working buffer exists and matches base (allocate only when needed)
+                if (
+                    self.img_work_layer is None
+                    or self.img_work_layer.shape != self.img_base_layer.shape
+                    or self.img_work_layer.dtype != self.img_base_layer.dtype
+                ):
+                    self.img_work_layer = np.empty_like(self.img_base_layer)
+
+                # Copy the base layer into the persistent working buffer (no new allocation per frame)
+                np.copyto(self.img_work_layer, self.img_base_layer)
+                img_np_array = self.img_work_layer
 
                 # Prepare parallel data extraction tasks
                 data_tasks = []

{valetudo_map_parser-0.1.9b69 → valetudo_map_parser-0.1.9b71}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "valetudo-map-parser"
-version = "0.1.9b69"
+version = "0.1.9b71"
 description = "A Python library to parse Valetudo map data returning a PIL Image object."
 authors = ["Sandro Cantarella <gsca075@gmail.com>"]
 license = "Apache-2.0"