pynode-flow 0.2.0__py3-none-any.whl

pynode/nodes/PolygonMetricsNode/polygon_metrics_node.py

@@ -0,0 +1,331 @@
+"""
+PolygonMetricsNode - Calculate metrics from polygons
+
+This node calculates various metrics from polygon predictions including:
+- Polygon area
+- Bounding box (width, height, area)
+- Maximum internal rectangle
+- Minimum external rectangle
+- Perimeter
+- Centroid
+
+Input format:
+    msg['detections'] - List of detections with polygons
+    OR
+    msg['polygons'] - List of polygons (array of points)
+    OR
+    msg['polygon'] - Single polygon (array of points [[x1,y1], [x2,y2], ...])
+
+Output format:
+    msg['metrics'] - Dictionary containing calculated metrics
+    msg['detections'] - Original detections with added 'metrics' field
+"""
+
+import sys
+import os
+from typing import Any, Dict
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '../..')))
+
+from pynode.nodes.base_node import BaseNode, Info, MessageKeys
+import numpy as np
+import cv2
+
+_info = Info()
+_info.add_text("Calculate metrics from polygons including area, perimeter, bounding box, centroid, and rectangles.")
+_info.add_header("Inputs")
+_info.add_bullets(
+    ("detections:", "List of detections with polygons"),
+    ("polygons:", "List of polygons"),
+    ("polygon:", "Single polygon [[x1,y1], [x2,y2], ...]")
+)
+_info.add_header("Outputs")
+_info.add_bullets(
+    ("metrics:", "Dictionary with calculated metrics"),
+    ("detections:", "Original detections with added 'metrics' field")
+)
+
+
+class PolygonMetricsNode(BaseNode):
+    """Calculate metrics from polygons"""
+    
+    info = str(_info)
+    display_name = 'Polygon Metrics'
+    icon = '⬡'
+    category = 'analysis'
+    color = '#E6E6FA'
+    border_color = '#9370DB'
+    text_color = '#000000'
+    
+    DEFAULT_CONFIG = {
+        'metrics': ['area', 'perimeter', 'bbox', 'centroid', 'max_internal_rect', 'min_external_rect'],
+        'normalize': False,
+        'image_width': 1920,
+        'image_height': 1080
+    }
+    
+    properties = [
+        {
+            'name': 'metrics',
+            'label': 'Metrics to Calculate',
+            'type': 'multiselect',
+            'options': ['area', 'perimeter', 'bbox', 'centroid', 'max_internal_rect', 'min_external_rect'],
+            'default': DEFAULT_CONFIG['metrics']
+        },
+        {
+            'name': 'normalize',
+            'label': 'Normalize by Image Size',
+            'type': 'checkbox',
+            'default': DEFAULT_CONFIG['normalize']
+        },
+        {
+            'name': 'image_width',
+            'label': 'Image Width (for normalization)',
+            'type': 'number',
+            'default': DEFAULT_CONFIG['image_width']
+        },
+        {
+            'name': 'image_height',
+            'label': 'Image Height (for normalization)',
+            'type': 'number',
+            'default': DEFAULT_CONFIG['image_height']
+        }
+    ]
+    
+    def __init__(self, node_id=None, name="Polygon Metrics"):
+        super().__init__(node_id, name)
+    
+    def _polygon_area(self, points):
+        """Calculate polygon area using shoelace formula"""
+        if len(points) < 3:
+            return 0.0
+        
+        points = np.array(points)
+        x = points[:, 0]
+        y = points[:, 1]
+        return 0.5 * np.abs(np.dot(x, np.roll(y, 1)) - np.dot(y, np.roll(x, 1)))
+    
+    def _polygon_perimeter(self, points):
+        """Calculate polygon perimeter"""
+        if len(points) < 2:
+            return 0.0
+        
+        points = np.array(points)
+        # Calculate distance between consecutive points
+        diffs = np.diff(points, axis=0, append=[points[0]])
+        distances = np.sqrt(np.sum(diffs**2, axis=1))
+        return np.sum(distances)
+    
+    def _polygon_centroid(self, points):
+        """Calculate polygon centroid"""
+        if len(points) < 3:
+            return [0.0, 0.0]
+        
+        points = np.array(points)
+        M = cv2.moments(points.astype(np.float32))
+        
+        if M['m00'] != 0:
+            cx = M['m10'] / M['m00']
+            cy = M['m01'] / M['m00']
+            return [float(cx), float(cy)]
+        else:
+            # Fallback to simple average
+            return [float(np.mean(points[:, 0])), float(np.mean(points[:, 1]))]
+    
+    def _polygon_bounding_box(self, points):
+        """Get bounding box of polygon"""
+        if len(points) < 1:
+            return [0, 0, 0, 0]
+        
+        points = np.array(points)
+        x_min = np.min(points[:, 0])
+        y_min = np.min(points[:, 1])
+        x_max = np.max(points[:, 0])
+        y_max = np.max(points[:, 1])
+        
+        return [float(x_min), float(y_min), float(x_max), float(y_max)]
+    
+    def _minimum_external_rect(self, points):
+        """Calculate minimum area rectangle that contains the polygon"""
+        if len(points) < 3:
+            return None
+        
+        points = np.array(points, dtype=np.float32)
+        rect = cv2.minAreaRect(points)
+        box = cv2.boxPoints(rect)
+        
+        # rect is ((center_x, center_y), (width, height), angle)
+        center, size, angle = rect
+        width, height = size
+        
+        return {
+            'center': [float(center[0]), float(center[1])],
+            'width': float(width),
+            'height': float(height),
+            'area': float(width * height),
+            'angle': float(angle),
+            'corners': box.tolist()
+        }
+    
+    def _maximum_internal_rect(self, points, image_width=1920, image_height=1080):
+        """
+        Estimate maximum inscribed rectangle.
+        This is a simplified approximation using the bounding box approach.
+        For more accurate results, more complex algorithms would be needed.
+        """
+        if len(points) < 3:
+            return None
+        
+        # Get bounding box as approximation
+        bbox = self._polygon_bounding_box(points)
+        x1, y1, x2, y2 = bbox
+        width = x2 - x1
+        height = y2 - y1
+        
+        # For convex polygons, we could do better, but this is a reasonable approximation
+        # Scale down by a factor to ensure it fits inside
+        scale_factor = 0.9
+        scaled_width = width * scale_factor
+        scaled_height = height * scale_factor
+        
+        center = [(x1 + x2) / 2, (y1 + y2) / 2]
+        
+        return {
+            'center': center,
+            'width': float(scaled_width),
+            'height': float(scaled_height),
+            'area': float(scaled_width * scaled_height),
+            'bbox': [
+                center[0] - scaled_width/2,
+                center[1] - scaled_height/2,
+                center[0] + scaled_width/2,
+                center[1] + scaled_height/2
+            ]
+        }
+    
+    def _calculate_polygon_metrics(self, polygon, normalize=False, img_w=1920, img_h=1080):
+        """
+        Calculate metrics for a single polygon
+        
+        Args:
+            polygon: List of points [[x1, y1], [x2, y2], ...]
+            normalize: Whether to normalize metrics by image dimensions
+            img_w: Image width for normalization
+            img_h: Image height for normalization
+        
+        Returns:
+            Dictionary of metrics
+        """
+        if isinstance(polygon, np.ndarray):
+            if polygon.ndim == 1:
+                # Reshape flat array to points
+                polygon = polygon.reshape(-1, 2)
+            polygon = polygon.tolist()
+        
+        # Calculate all metrics
+        area = self._polygon_area(polygon)
+        perimeter = self._polygon_perimeter(polygon)
+        centroid = self._polygon_centroid(polygon)
+        bbox = self._polygon_bounding_box(polygon)
+        min_rect = self._minimum_external_rect(polygon)
+        max_rect = self._maximum_internal_rect(polygon, img_w, img_h)
+        
+        bbox_width = bbox[2] - bbox[0]
+        bbox_height = bbox[3] - bbox[1]
+        bbox_area = bbox_width * bbox_height
+        
+        metrics = {
+            'area': float(area),
+            'perimeter': float(perimeter),
+            'centroid': centroid,
+            'bbox': bbox,
+            'bbox_width': float(bbox_width),
+            'bbox_height': float(bbox_height),
+            'bbox_area': float(bbox_area),
+            'min_external_rect': min_rect,
+            'max_internal_rect': max_rect,
+            'num_points': len(polygon)
+        }
+        
+        # Normalize if requested
+        if normalize:
+            metrics['area_normalized'] = area / (img_w * img_h)
+            metrics['perimeter_normalized'] = perimeter / (img_w + img_h)
+            metrics['centroid_normalized'] = [centroid[0] / img_w, centroid[1] / img_h]
+            metrics['bbox_width_normalized'] = bbox_width / img_w
+            metrics['bbox_height_normalized'] = bbox_height / img_h
+            metrics['bbox_area_normalized'] = bbox_area / (img_w * img_h)
+        
+        # Filter to only requested metrics
+        selected_metrics = self.config.get('metrics', [])
+        if selected_metrics and isinstance(selected_metrics, list):
+            filtered = {k: v for k, v in metrics.items() 
+                       if any(sel in k for sel in selected_metrics) or k == 'num_points'}
+            return filtered
+        
+        return metrics
+    
+    def on_input(self, msg: Dict[str, Any], input_index: int = 0):
+        """Calculate polygon metrics"""
+        try:
+            normalize = self.config.get('normalize', False)
+            img_w = self.get_config_int('image_width', 1920)
+            img_h = self.get_config_int('image_height', 1080)
+            
+            # Check both top level and payload for data
+            data_source = msg.get(MessageKeys.PAYLOAD, msg)
+            
+            # Try to get image dimensions from message
+            if MessageKeys.IMAGE.PATH in data_source and hasattr(data_source[MessageKeys.IMAGE.PATH], 'shape'):
+                img_h, img_w = data_source[MessageKeys.IMAGE.PATH].shape[:2]
+            elif MessageKeys.IMAGE.PATH in data_source and isinstance(data_source[MessageKeys.IMAGE.PATH], dict):
+                img_w = data_source[MessageKeys.IMAGE.PATH].get('width', img_w)
+                img_h = data_source[MessageKeys.IMAGE.PATH].get('height', img_h)
+            elif 'image_width' in data_source:
+                img_w = data_source['image_width']
+                img_h = data_source.get('image_height', img_h)
+            
+            # Process detections with polygons
+            if 'detections' in data_source:
+                detections = data_source['detections']
+                if isinstance(detections, list):
+                    for det in detections:
+                        # Look for polygon data in various formats
+                        polygon = None
+                        if 'polygon' in det:
+                            polygon = det['polygon']
+                        elif 'segmentation' in det:
+                            polygon = det['segmentation']
+                        elif 'mask' in det and isinstance(det['mask'], list):
+                            polygon = det['mask']
+                        
+                        if polygon is not None:
+                            det['metrics'] = self._calculate_polygon_metrics(polygon, normalize, img_w, img_h)
+                    
+                    data_source['detections'] = detections
+                    self.send(msg)
+            
+            # Process array of polygons
+            elif 'polygons' in data_source:
+                polygons = data_source['polygons']
+                if isinstance(polygons, list):
+                    metrics_list = []
+                    for polygon in polygons:
+                        metrics = self._calculate_polygon_metrics(polygon, normalize, img_w, img_h)
+                        metrics_list.append(metrics)
+                    data_source['metrics'] = metrics_list
+                    self.send(msg)
+            
+            # Process single polygon
+            elif 'polygon' in data_source:
+                polygon = data_source['polygon']
+                metrics = self._calculate_polygon_metrics(polygon, normalize, img_w, img_h)
+                data_source['metrics'] = metrics
+                self.send(msg)
+            
+            else:
+                self.report_error(f"No polygons found in message. Expected 'detections', 'polygons', or 'polygon' field.")
+                
+        except Exception as e:
+            self.report_error(f"Error calculating polygon metrics: {str(e)}")
+            import traceback
+            self.report_error(traceback.format_exc())

pynode/nodes/PolygonMetricsNode/requirements.txt

@@ -0,0 +1,2 @@
+numpy
+opencv-python

pynode/nodes/QueueLengthProbeNode/__init__.py

@@ -0,0 +1,3 @@
+from .queue_length_probe_node import QueueLengthProbeNode
+
+__all__ = ['QueueLengthProbeNode']

pynode/nodes/QueueLengthProbeNode/queue_length_probe_node.py

@@ -0,0 +1,116 @@
+"""
+Queue Length Probe Node - monitors message queue length.
+Passes messages through while tracking and displaying the queue length.
+"""
+
+from typing import Any, Dict, Optional
+from pynode.nodes.base_node import BaseNode, Info, MessageKeys
+
+_info = Info()
+_info.add_text("Monitors message queue length by displaying the _queue_length value from incoming messages. Displays the queue length on the node and outputs queue length information.")
+_info.add_header("Inputs")
+_info.add_bullets(
+    ("Input 0:", "Any message to monitor (should contain _queue_length)")
+)
+_info.add_header("Outputs")
+_info.add_bullets(
+    ("Output 0:", f"Original message with queue length statistics in {MessageKeys.PAYLOAD}")
+)
+_info.add_header("Configuration")
+_info.add_bullets(
+    ("None:", "No configuration options")
+)
+_info.add_header("Output Message")
+_info.add_code(f'{MessageKeys.MSG}.{MessageKeys.PAYLOAD}.queue_length').text(" - Current queue length as a number").end()
+_info.add_code(f'{MessageKeys.MSG}.{MessageKeys.PAYLOAD}.display').text(" - Human-readable queue length string (e.g., '5 queued', '0 queued')").end()
+_info.add_code(f'{MessageKeys.MSG}.{MessageKeys.PAYLOAD}.source_node').text(" - ID of the node where the queue length was measured").end()
+
+
+class QueueLengthProbeNode(BaseNode):
+    """
+    Queue Length Probe node - monitors and displays message queue length.
+    Passes all messages through unchanged while displaying queue length.
+    """
+    info = str(_info)
+    display_name = 'Queue Length Probe'
+    icon = '📊'
+    category = 'node probes'
+    color = '#E2D96E'
+    border_color = '#B8AF4A'
+    text_color = '#000000'
+    input_count = 1
+    output_count = 1
+    ui_component = 'queue-length-display'
+    ui_component_config = {
+        'format': '{value} queued',
+        'precision': 0
+    }
+
+    sse_handlers = [
+        {'type': 'queue_length', 'handler': 'get_queue_length_sse', 'throttle': 0.5},
+    ]
+
+    DEFAULT_CONFIG = {
+        MessageKeys.DROP_MESSAGES: 'false'
+    }
+
+    properties = [
+        {
+            'name': MessageKeys.DROP_MESSAGES,
+            'label': 'Drop Messages When Busy',
+            'type': 'checkbox',
+            'default': False
+        }
+    ]
+    
+    def __init__(self, node_id=None, name="queue length probe"):
+        super().__init__(node_id, name)
+        self._current_queue_length = 0
+    
+    def on_input(self, msg: Dict[str, Any], input_index: int = 0):
+        """
+        Pass through the message and extract queue length for display.
+        Sends queue length information as the payload.
+        """
+        # Extract queue length from the message
+        queue_length = msg.get(MessageKeys.QUEUE_LENGTH, 0)
+        self._current_queue_length = queue_length
+        
+        # Replace payload with queue length statistics (like RateProbeNode)
+        msg[MessageKeys.PAYLOAD] = {
+            'queue_length': queue_length,
+            'display': self.get_queue_length_display(queue_length),
+            'source_node': msg.get('source_node_id', 'unknown')
+        }
+        msg[MessageKeys.TOPIC] = msg.get(MessageKeys.TOPIC, 'queue_length')
+        
+        # Send the message through
+        self.send(msg)
+    
+    def get_queue_length(self) -> int:
+        """Get the current queue length."""
+        return self._current_queue_length
+    
+    def get_queue_length_display(self, queue_length: Optional[int] = None) -> str:
+        """Get formatted queue length string for display."""
+        if queue_length is None:
+            queue_length = self._current_queue_length
+            
+        if queue_length == 0:
+            return "No items queued"
+        elif queue_length == 1:
+            return "1 item queued"
+        else:
+            return f"{queue_length} items queued"
+    
+    def on_stop(self):
+        """Reset queue length when stopped."""
+        self._current_queue_length = 0
+        super().on_stop()
+
+    def get_queue_length_sse(self):
+        """SSE handler: return queue length data for broadcast."""
+        return {
+            'display': self.get_queue_length_display(),
+            'queue_length': self.get_queue_length(),
+        }

pynode/nodes/Qwen3VLMNode/__init__.py

@@ -0,0 +1,3 @@
+from .qwen3_vlm_node import Qwen3VLMNode
+
+__all__ = ['Qwen3VLMNode']