valetudo-map-parser 0.1.9b45__py3-none-any.whl → 0.1.9b46__py3-none-any.whl

valetudo_map_parser/config/optimized_element_map.py

@@ -34,7 +34,11 @@ class OptimizedElementMapGenerator:
         self.element_map = None
         self.element_map_shape = None
         self.scale_info = None
-        self.file_name = getattr(shared_data, 'file_name', 'ElementMap') if shared_data else 'ElementMap'
+        self.file_name = (
+            getattr(shared_data, "file_name", "ElementMap")
+            if shared_data
+            else "ElementMap"
+        )
 
     async def async_generate_from_json(self, json_data, existing_element_map=None):
         """Generate a 2D element map from JSON data with optimized performance.
@@ -74,56 +78,66 @@ class OptimizedElementMapGenerator:
         size_x = json_data["size"]["x"]
         size_y = json_data["size"]["y"]
         pixel_size = json_data["pixelSize"]
-        
+
         # Calculate downscale factor based on pixel size
         # Standard pixel size is 5mm, so adjust accordingly
         downscale_factor = max(1, pixel_size // 5 * 2)  # More aggressive downscaling
-        
+
         # Calculate dimensions for the downscaled map
         map_width = max(100, size_x // (pixel_size * downscale_factor))
         map_height = max(100, size_y // (pixel_size * downscale_factor))
-        
+
         LOGGER.info(
             "%s: Creating optimized element map with dimensions: %dx%d (downscale factor: %d)",
             self.file_name,
-            map_width, map_height, downscale_factor
+            map_width,
+            map_height,
+            downscale_factor,
         )
-        
+
         # Create the element map at the reduced size
         element_map = np.zeros((map_height, map_width), dtype=np.int32)
         element_map[:] = DrawableElement.FLOOR
-        
+
         # Store scaling information for coordinate conversion
         self.scale_info = {
             "original_size": (size_x, size_y),
             "map_size": (map_width, map_height),
             "scale_factor": downscale_factor * pixel_size,
-            "pixel_size": pixel_size
+            "pixel_size": pixel_size,
         }
-        
+
         # Process layers at the reduced resolution
         for layer in json_data.get("layers", []):
             layer_type = layer.get("type")
-            
+
             # Process rooms (segments)
             if layer_type == "segment":
                 # Get room ID
                 meta_data = layer.get("metaData", {})
                 segment_id = meta_data.get("segmentId")
-                
+
                 if segment_id is not None:
                     # Convert segment_id to int if it's a string
-                    segment_id_int = int(segment_id) if isinstance(segment_id, str) else segment_id
+                    segment_id_int = (
+                        int(segment_id) if isinstance(segment_id, str) else segment_id
+                    )
                     if 1 <= segment_id_int <= 15:
-                        room_element = getattr(DrawableElement, f"ROOM_{segment_id_int}", None)
-                        
+                        room_element = getattr(
+                            DrawableElement, f"ROOM_{segment_id_int}", None
+                        )
+
                         # Skip if room is disabled
-                        if room_element is None or not self.drawing_config.is_enabled(room_element):
+                        if room_element is None or not self.drawing_config.is_enabled(
+                            room_element
+                        ):
                             continue
-                        
+
                         # Create a temporary high-resolution mask for this room
-                        temp_mask = np.zeros((size_y // pixel_size, size_x // pixel_size), dtype=np.uint8)
-                        
+                        temp_mask = np.zeros(
+                            (size_y // pixel_size, size_x // pixel_size), dtype=np.uint8
+                        )
+
                         # Process pixels for this room
                         compressed_pixels = layer.get("compressedPixels", [])
                         if compressed_pixels:
@@ -131,34 +145,44 @@ class OptimizedElementMapGenerator:
                             for i in range(0, len(compressed_pixels), 3):
                                 if i + 2 < len(compressed_pixels):
                                     x = compressed_pixels[i]
-                                    y = compressed_pixels[i+1]
-                                    count = compressed_pixels[i+2]
-                                    
+                                    y = compressed_pixels[i + 1]
+                                    count = compressed_pixels[i + 2]
+
                                     # Set pixels in the high-resolution mask
                                     for j in range(count):
                                         px = x + j
-                                        if 0 <= y < temp_mask.shape[0] and 0 <= px < temp_mask.shape[1]:
+                                        if (
+                                            0 <= y < temp_mask.shape[0]
+                                            and 0 <= px < temp_mask.shape[1]
+                                        ):
                                             temp_mask[y, px] = 1
-                        
+
                         # Use scipy to downsample the mask efficiently
                         # This preserves the room shape better than simple decimation
                         downsampled_mask = ndimage.zoom(
-                            temp_mask, 
-                            (map_height / temp_mask.shape[0], map_width / temp_mask.shape[1]),
-                            order=0  # Nearest neighbor interpolation
+                            temp_mask,
+                            (
+                                map_height / temp_mask.shape[0],
+                                map_width / temp_mask.shape[1],
+                            ),
+                            order=0,  # Nearest neighbor interpolation
                         )
-                        
+
                         # Apply the downsampled mask to the element map
                         element_map[downsampled_mask > 0] = room_element
-                        
+
                         # Clean up
                         del temp_mask, downsampled_mask
-            
+
             # Process walls similarly
-            elif layer_type == "wall" and self.drawing_config.is_enabled(DrawableElement.WALL):
+            elif layer_type == "wall" and self.drawing_config.is_enabled(
+                DrawableElement.WALL
+            ):
                 # Create a temporary high-resolution mask for walls
-                temp_mask = np.zeros((size_y // pixel_size, size_x // pixel_size), dtype=np.uint8)
-                
+                temp_mask = np.zeros(
+                    (size_y // pixel_size, size_x // pixel_size), dtype=np.uint8
+                )
+
                 # Process compressed pixels for walls
                 compressed_pixels = layer.get("compressedPixels", [])
                 if compressed_pixels:
@@ -166,38 +190,43 @@ class OptimizedElementMapGenerator:
                     for i in range(0, len(compressed_pixels), 3):
                         if i + 2 < len(compressed_pixels):
                             x = compressed_pixels[i]
-                            y = compressed_pixels[i+1]
-                            count = compressed_pixels[i+2]
-                            
+                            y = compressed_pixels[i + 1]
+                            count = compressed_pixels[i + 2]
+
                             # Set pixels in the high-resolution mask
                             for j in range(count):
                                 px = x + j
-                                if 0 <= y < temp_mask.shape[0] and 0 <= px < temp_mask.shape[1]:
+                                if (
+                                    0 <= y < temp_mask.shape[0]
+                                    and 0 <= px < temp_mask.shape[1]
+                                ):
                                     temp_mask[y, px] = 1
-                
+
                 # Use scipy to downsample the mask efficiently
                 downsampled_mask = ndimage.zoom(
-                    temp_mask, 
+                    temp_mask,
                     (map_height / temp_mask.shape[0], map_width / temp_mask.shape[1]),
-                    order=0
+                    order=0,
                 )
-                
+
                 # Apply the downsampled mask to the element map
                 # Only overwrite floor pixels, not room pixels
-                wall_mask = (downsampled_mask > 0) & (element_map == DrawableElement.FLOOR)
+                wall_mask = (downsampled_mask > 0) & (
+                    element_map == DrawableElement.FLOOR
+                )
                 element_map[wall_mask] = DrawableElement.WALL
-                
+
                 # Clean up
                 del temp_mask, downsampled_mask
-        
+
         # Store the element map
         self.element_map = element_map
         self.element_map_shape = element_map.shape
-        
+
         LOGGER.info(
             "%s: Element map generation complete with shape: %s",
             self.file_name,
-            element_map.shape
+            element_map.shape,
         )
         return element_map
 
@@ -207,131 +236,141 @@ class OptimizedElementMapGenerator:
         map_data = json_data["map_data"]
         size_x = map_data["dimensions"]["width"]
         size_y = map_data["dimensions"]["height"]
-        
+
         # Calculate downscale factor
-        downscale_factor = max(1, min(size_x, size_y) // 500)  # Target ~500px in smallest dimension
-        
+        downscale_factor = max(
+            1, min(size_x, size_y) // 500
+        )  # Target ~500px in smallest dimension
+
         # Calculate dimensions for the downscaled map
         map_width = max(100, size_x // downscale_factor)
         map_height = max(100, size_y // downscale_factor)
-        
+
         LOGGER.info(
             "%s: Creating optimized Rand256 element map with dimensions: %dx%d (downscale factor: %d)",
             self.file_name,
-            map_width, map_height, downscale_factor
+            map_width,
+            map_height,
+            downscale_factor,
         )
-        
+
         # Create the element map at the reduced size
         element_map = np.zeros((map_height, map_width), dtype=np.int32)
         element_map[:] = DrawableElement.FLOOR
-        
+
         # Store scaling information for coordinate conversion
         self.scale_info = {
             "original_size": (size_x, size_y),
             "map_size": (map_width, map_height),
             "scale_factor": downscale_factor,
-            "pixel_size": 1  # Rand256 uses 1:1 pixel mapping
+            "pixel_size": 1,  # Rand256 uses 1:1 pixel mapping
         }
-        
+
         # Process rooms
         if "rooms" in map_data and map_data["rooms"]:
             for room in map_data["rooms"]:
                 # Get room ID and check if it's enabled
                 room_id_int = room["id"]
-                
+
                 # Get room element code (ROOM_1, ROOM_2, etc.)
                 room_element = None
                 if 0 < room_id_int <= 15:
                     room_element = getattr(DrawableElement, f"ROOM_{room_id_int}", None)
-                
+
                 # Skip if room is disabled
-                if room_element is None or not self.drawing_config.is_enabled(room_element):
+                if room_element is None or not self.drawing_config.is_enabled(
+                    room_element
+                ):
                     continue
-                
+
                 if "coordinates" in room:
                     # Create a high-resolution mask for this room
                     temp_mask = np.zeros((size_y, size_x), dtype=np.uint8)
-                    
+
                     # Fill the mask with room coordinates
                     for coord in room["coordinates"]:
                         x, y = coord
                         if 0 <= y < size_y and 0 <= x < size_x:
                             temp_mask[y, x] = 1
-                    
+
                     # Use scipy to downsample the mask efficiently
                     downsampled_mask = ndimage.zoom(
-                        temp_mask, 
+                        temp_mask,
                         (map_height / size_y, map_width / size_x),
-                        order=0  # Nearest neighbor interpolation
+                        order=0,  # Nearest neighbor interpolation
                     )
-                    
+
                     # Apply the downsampled mask to the element map
                     element_map[downsampled_mask > 0] = room_element
-                    
+
                     # Clean up
                     del temp_mask, downsampled_mask
-        
+
         # Process walls
-        if "walls" in map_data and map_data["walls"] and self.drawing_config.is_enabled(DrawableElement.WALL):
+        if (
+            "walls" in map_data
+            and map_data["walls"]
+            and self.drawing_config.is_enabled(DrawableElement.WALL)
+        ):
             # Create a high-resolution mask for walls
             temp_mask = np.zeros((size_y, size_x), dtype=np.uint8)
-            
+
             # Fill the mask with wall coordinates
             for coord in map_data["walls"]:
                 x, y = coord
                 if 0 <= y < size_y and 0 <= x < size_x:
                     temp_mask[y, x] = 1
-            
+
             # Use scipy to downsample the mask efficiently
             downsampled_mask = ndimage.zoom(
-                temp_mask, 
-                (map_height / size_y, map_width / size_x),
-                order=0
+                temp_mask, (map_height / size_y, map_width / size_x), order=0
             )
-            
+
             # Apply the downsampled mask to the element map
             # Only overwrite floor pixels, not room pixels
             wall_mask = (downsampled_mask > 0) & (element_map == DrawableElement.FLOOR)
             element_map[wall_mask] = DrawableElement.WALL
-            
+
             # Clean up
             del temp_mask, downsampled_mask
-        
+
         # Store the element map
         self.element_map = element_map
         self.element_map_shape = element_map.shape
-        
+
         LOGGER.info(
             "%s: Rand256 element map generation complete with shape: %s",
             self.file_name,
-            element_map.shape
+            element_map.shape,
         )
         return element_map
 
     def map_to_element_coordinates(self, x, y):
         """Convert map coordinates to element map coordinates."""
-        if not hasattr(self, 'scale_info'):
+        if not hasattr(self, "scale_info"):
             return x, y
-            
+
         scale = self.scale_info["scale_factor"]
         return int(x / scale), int(y / scale)
-        
+
     def element_to_map_coordinates(self, x, y):
         """Convert element map coordinates to map coordinates."""
-        if not hasattr(self, 'scale_info'):
+        if not hasattr(self, "scale_info"):
             return x, y
-            
+
         scale = self.scale_info["scale_factor"]
         return int(x * scale), int(y * scale)
 
     def get_element_at_position(self, x, y):
         """Get the element at the specified position."""
-        if not hasattr(self, 'element_map') or self.element_map is None:
+        if not hasattr(self, "element_map") or self.element_map is None:
             return None
-            
-        if not (0 <= y < self.element_map.shape[0] and 0 <= x < self.element_map.shape[1]):
+
+        if not (
+            0 <= y < self.element_map.shape[0] and 0 <= x < self.element_map.shape[1]
+        ):
             return None
-            
+
         return self.element_map[y, x]
 
     def get_room_at_position(self, x, y):
@@ -339,7 +378,7 @@ class OptimizedElementMapGenerator:
         element_code = self.get_element_at_position(x, y)
         if element_code is None:
             return None
-            
+
         # Check if it's a room (codes 101-115)
         if 101 <= element_code <= 115:
             return element_code
@@ -348,16 +387,20 @@ class OptimizedElementMapGenerator:
     def get_element_name(self, element_code):
         """Get the name of the element from its code."""
         if element_code is None:
-            return 'NONE'
+            return "NONE"
 
         # Check if it's a room
         if element_code >= 100:
             room_number = element_code - 100
-            return f'ROOM_{room_number}'
+            return f"ROOM_{room_number}"
 
         # Check standard elements
         for name, code in vars(DrawableElement).items():
-            if not name.startswith('_') and isinstance(code, int) and code == element_code:
+            if (
+                not name.startswith("_")
+                and isinstance(code, int)
+                and code == element_code
+            ):
                 return name
 
-        return f'UNKNOWN_{element_code}'
+        return f"UNKNOWN_{element_code}"

valetudo_map_parser/config/room_outline.py

@@ -16,13 +16,13 @@ async def extract_room_outline_with_scipy(
     room_mask, min_x, min_y, max_x, max_y, file_name=None, room_id=None
 ):
     """Extract a room outline using scipy for contour finding.
-    
+
     Args:
         room_mask: Binary mask of the room (1 for room, 0 for non-room)
         min_x, min_y, max_x, max_y: Bounding box coordinates
         file_name: Optional file name for logging
         room_id: Optional room ID for logging
-        
+
     Returns:
         List of points forming the outline of the room
     """
@@ -34,11 +34,11 @@ async def extract_room_outline_with_scipy(
             str(room_id) if room_id is not None else "unknown",
         )
         return [(min_x, min_y), (max_x, min_y), (max_x, max_y), (min_x, max_y)]
-    
+
     # Use scipy to clean up the mask (remove noise, fill holes)
     # Fill small holes
     room_mask = ndimage.binary_fill_holes(room_mask).astype(np.uint8)
-    
+
     # Remove small objects
     labeled_array, num_features = ndimage.label(room_mask)
     if num_features > 1:
@@ -46,11 +46,11 @@ async def extract_room_outline_with_scipy(
         component_sizes = np.bincount(labeled_array.ravel())[1:]
         largest_component = np.argmax(component_sizes) + 1
         room_mask = (labeled_array == largest_component).astype(np.uint8)
-    
+
     # Find the boundary points by tracing the perimeter
     boundary_points = []
     height, width = room_mask.shape
-    
+
     # Scan horizontally (top and bottom edges)
     for x in range(width):
         # Top edge
@@ -58,13 +58,13 @@ async def extract_room_outline_with_scipy(
             if room_mask[y, x] == 1:
                 boundary_points.append((x + min_x, y + min_y))
                 break
-                
+
         # Bottom edge
-        for y in range(height-1, -1, -1):
+        for y in range(height - 1, -1, -1):
             if room_mask[y, x] == 1:
                 boundary_points.append((x + min_x, y + min_y))
                 break
-    
+
     # Scan vertically (left and right edges)
     for y in range(height):
         # Left edge
@@ -72,19 +72,19 @@ async def extract_room_outline_with_scipy(
             if room_mask[y, x] == 1:
                 boundary_points.append((x + min_x, y + min_y))
                 break
-                
+
         # Right edge
-        for x in range(width-1, -1, -1):
+        for x in range(width - 1, -1, -1):
             if room_mask[y, x] == 1:
                 boundary_points.append((x + min_x, y + min_y))
                 break
-    
+
     # Remove duplicates while preserving order
     unique_points = []
     for point in boundary_points:
         if point not in unique_points:
             unique_points.append(point)
-    
+
     # If we have too few points, return a simple rectangle
     if len(unique_points) < 4:
         LOGGER.warning(
@@ -93,17 +93,17 @@ async def extract_room_outline_with_scipy(
             str(room_id) if room_id is not None else "unknown",
         )
         return [(min_x, min_y), (max_x, min_y), (max_x, max_y), (min_x, max_y)]
-    
+
     # Simplify the outline by keeping only significant points
     simplified = simplify_outline(unique_points, tolerance=5)
-    
+
     LOGGER.debug(
         "%s: Extracted outline for room %s with %d points",
         file_name or "RoomOutline",
         str(room_id) if room_id is not None else "unknown",
         len(simplified),
     )
-    
+
     return simplified
 
 
@@ -111,38 +111,38 @@ def simplify_outline(points, tolerance=5):
     """Simplify an outline by removing points that don't contribute much to the shape."""
     if len(points) <= 4:
         return points
-    
+
     # Start with the first point
     simplified = [points[0]]
-    
+
     # Process remaining points
     for i in range(1, len(points) - 1):
         # Get previous and next points
         prev = simplified[-1]
         current = points[i]
         next_point = points[i + 1]
-        
+
         # Calculate vectors
         v1 = (current[0] - prev[0], current[1] - prev[1])
         v2 = (next_point[0] - current[0], next_point[1] - current[1])
-        
+
         # Calculate change in direction
         dot_product = v1[0] * v2[0] + v1[1] * v2[1]
-        len_v1 = (v1[0]**2 + v1[1]**2)**0.5
-        len_v2 = (v2[0]**2 + v2[1]**2)**0.5
-        
+        len_v1 = (v1[0] ** 2 + v1[1] ** 2) ** 0.5
+        len_v2 = (v2[0] ** 2 + v2[1] ** 2) ** 0.5
+
         # Avoid division by zero
         if len_v1 == 0 or len_v2 == 0:
             continue
-            
+
         # Calculate cosine of angle between vectors
         cos_angle = dot_product / (len_v1 * len_v2)
-        
+
         # If angle is significant or distance is large, keep the point
         if abs(cos_angle) < 0.95 or len_v1 > tolerance or len_v2 > tolerance:
             simplified.append(current)
-    
+
     # Add the last point
     simplified.append(points[-1])
-    
+
     return simplified