pynode-flow 0.2.0__py3-none-any.whl

pynode/nodes/BBoxMetricsNode/bbox_metrics_node.py

@@ -0,0 +1,250 @@
+"""
+BBoxMetricsNode - Calculate metrics from bounding boxes
+
+This node calculates various metrics from bounding box predictions including:
+- Width and height
+- Area
+- Aspect ratio
+- Center point coordinates
+- Diagonal length
+
+Input format:
+    msg['detections'] - List of detections with bounding boxes
+    OR
+    msg['boxes'] - Array of bounding boxes [x1, y1, x2, y2]
+    OR
+    msg['bbox'] - Single bounding box [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
+
+_info = Info()
+_info.add_text("Calculates geometric metrics from bounding boxes including dimensions, area, aspect ratio, center point, and diagonal length.")
+_info.add_header("Input")
+_info.add_bullets(
+    ("detections:", "List of detection objects containing 'bbox' field."),
+    ("boxes:", "Array of bounding boxes [x1, y1, x2, y2]."),
+    ("bbox:", "Single bounding box [x1, y1, x2, y2]."),
+)
+_info.add_header("Output")
+_info.add_bullets(
+    ("metrics:", "Calculated metrics (width, height, area, aspect_ratio, center, diagonal)."),
+    ("detections:", "Original detections with 'metrics' field added to each."),
+)
+_info.add_header("Properties")
+_info.add_bullets(
+    ("Metrics to Calculate:", "Select which metrics to compute."),
+    ("Normalize:", "Normalize values by image dimensions."),
+    ("Image Dimensions:", "Reference size for normalization."),
+)
+
+
+class BBoxMetricsNode(BaseNode):
+    """Calculate metrics from bounding boxes"""
+    info = str(_info)
+    display_name = 'BBox Metrics'
+    icon = '📏'
+    category = 'analysis'
+    color = '#FFE5B4'
+    border_color = '#D4AF37'
+    text_color = '#000000'
+    
+    DEFAULT_CONFIG = {
+        'metrics': ['width', 'height', 'area', 'aspect_ratio', 'center', 'diagonal'],
+        'normalize': False,
+        'use_image_dimensions': False,
+        'image_width': 1920,
+        'image_height': 1080
+    }
+    
+    properties = [
+        {
+            'name': 'metrics',
+            'label': 'Metrics to Calculate',
+            'type': 'multiselect',
+            'options': ['width', 'height', 'area', 'aspect_ratio', 'center', 'diagonal'],
+            'default': DEFAULT_CONFIG['metrics']
+        },
+        {
+            'name': 'normalize',
+            'label': 'Normalize by Image Size',
+            'type': 'checkbox',
+            'default': DEFAULT_CONFIG['normalize']
+        },
+        {
+            'name': 'use_image_dimensions',
+            'label': 'Use Image Dimensions from Message',
+            'type': 'checkbox',
+            'default': DEFAULT_CONFIG['use_image_dimensions']
+        },
+        {
+            'name': 'image_width',
+            'label': 'Reference Image Width',
+            'type': 'number',
+            'default': DEFAULT_CONFIG['image_width'],
+            'showIf': {'use_image_dimensions': False}
+        },
+        {
+            'name': 'image_height',
+            'label': 'Reference Image Height',
+            'type': 'number',
+            'default': DEFAULT_CONFIG['image_height'],
+            'showIf': {'use_image_dimensions': False}
+        }
+    ]
+    
+    def __init__(self, node_id=None, name="BBox Metrics"):
+        super().__init__(node_id, name)
+    
+    def _calculate_bbox_metrics(self, bbox, normalize=False, img_w=1920, img_h=1080, bbox_format='xyxy'):
+        """
+        Calculate metrics for a single bounding box
+        
+        Args:
+            bbox: Bounding box in specified format
+            normalize: Whether to normalize metrics by image dimensions
+            img_w: Image width for normalization
+            img_h: Image height for normalization
+            bbox_format: Format of bbox - 'xyxy' [x1,y1,x2,y2], 'xywh' [x,y,w,h], 'cxcywh' [cx,cy,w,h]
+        
+        Returns:
+            Dictionary of metrics
+        """
+        # Convert bbox to xyxy format for consistent processing
+        if bbox_format == 'xyxy':
+            x1, y1, x2, y2 = bbox[:4]
+        elif bbox_format == 'xywh':
+            x, y, w, h = bbox[:4]
+            x1, y1, x2, y2 = x, y, x + w, y + h
+        elif bbox_format == 'cxcywh':
+            cx, cy, w, h = bbox[:4]
+            x1 = cx - w / 2
+            y1 = cy - h / 2
+            x2 = cx + w / 2
+            y2 = cy + h / 2
+        else:
+            # Default to xyxy if unknown format
+            x1, y1, x2, y2 = bbox[:4]
+        
+        # Basic dimensions
+        width = abs(x2 - x1)
+        height = abs(y2 - y1)
+        area = width * height
+        
+        # Center point
+        center_x = (x1 + x2) / 2
+        center_y = (y1 + y2) / 2
+        
+        # Aspect ratio (width/height)
+        aspect_ratio = width / height if height > 0 else 0
+        
+        # Diagonal length
+        diagonal = np.sqrt(width**2 + height**2)
+        
+        metrics = {
+            'width': width,
+            'height': height,
+            'area': area,
+            'aspect_ratio': aspect_ratio,
+            'center': {'x': center_x, 'y': center_y},
+            'diagonal': diagonal,
+            'bbox': [x1, y1, x2, y2],
+            'bbox_format': 'xyxy'  # Output is always normalized to xyxy
+        }
+        
+        # Normalize if requested
+        if normalize:
+            metrics['width_normalized'] = width / img_w
+            metrics['height_normalized'] = height / img_h
+            metrics['area_normalized'] = area / (img_w * img_h)
+            metrics['center_normalized'] = [center_x / img_w, center_y / img_h]
+            metrics['diagonal_normalized'] = diagonal / np.sqrt(img_w**2 + img_h**2)
+        
+        # Filter to only requested metrics
+        selected_metrics = self.config.get('metrics', [])
+        if selected_metrics:
+            filtered = {k: v for k, v in metrics.items() if k in selected_metrics or k == 'bbox'}
+            # Always include normalized versions if normalize is enabled
+            if normalize:
+                for key in list(filtered.keys()):
+                    norm_key = f"{key}_normalized"
+                    if norm_key in metrics:
+                        filtered[norm_key] = metrics[norm_key]
+            return filtered
+        
+        return metrics
+    
+    def on_input(self, msg: Dict[str, Any], input_index: int = 0):
+        """Calculate bounding box metrics"""
+        try:
+            normalize = self.config.get('normalize', False)
+            use_image_dimensions = self.config.get('use_image_dimensions', True)
+            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)
+            
+            # Get bbox format from message (default to xyxy)
+            bbox_format = data_source.get('bbox_format', 'xyxy')
+            
+            # Try to get image dimensions from message if enabled
+            if use_image_dimensions:
+                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):
+                    # Handle nested image structure
+                    img_w = data_source[MessageKeys.IMAGE.PATH].get(MessageKeys.IMAGE.WIDTH, img_w)
+                    img_h = data_source[MessageKeys.IMAGE.PATH].get(MessageKeys.IMAGE.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 bounding boxes
+            if 'detections' in data_source:
+                detections = data_source['detections']
+                if isinstance(detections, list):
+                    for det in detections:
+                        if 'bbox' in det or 'box' in det:
+                            bbox = det.get('bbox', det.get('box'))
+                            # Check for detection-specific bbox_format, fallback to message-level
+                            det_bbox_format = det.get('bbox_format', bbox_format)
+                            det['metrics'] = self._calculate_bbox_metrics(bbox, normalize, img_w, img_h, det_bbox_format)
+                    data_source['detections'] = detections
+                    self.send(msg)
+            
+            # Process array of boxes
+            elif 'boxes' in data_source:
+                boxes = data_source['boxes']
+                if isinstance(boxes, (list, np.ndarray)):
+                    metrics_list = []
+                    for bbox in boxes:
+                        metrics = self._calculate_bbox_metrics(bbox, normalize, img_w, img_h, bbox_format)
+                        metrics_list.append(metrics)
+                    data_source['metrics'] = metrics_list
+                    self.send(msg)
+            
+            # Process single bbox
+            elif 'bbox' in data_source:
+                bbox = data_source['bbox']
+                metrics = self._calculate_bbox_metrics(bbox, normalize, img_w, img_h, bbox_format)
+                data_source['metrics'] = metrics
+                self.send(msg)
+            
+            else:
+                self.report_error(f"No bounding boxes found in message. Expected 'detections', 'boxes', or 'bbox' field.")
+                
+        except Exception as e:
+            self.report_error(f"Error calculating bbox metrics: {str(e)}")
+            import traceback
+            self.report_error(traceback.format_exc())

pynode/nodes/BBoxMetricsNode/requirements.txt

@@ -0,0 +1 @@
+numpy

pynode/nodes/BatchNode/__init__.py

@@ -0,0 +1,3 @@
+from .batch_node import BatchNode
+
+__all__ = ['BatchNode']

pynode/nodes/BatchNode/batch_node.py

@@ -0,0 +1,86 @@
+"""
+Batch Node - groups messages into batches.
+"""
+
+from typing import Any, Dict, List
+from pynode.nodes.base_node import BaseNode, Info, MessageKeys
+
+_info = Info()
+_info.add_text("Collects incoming messages into batches and sends them together as an array.")
+_info.add_header("Input")
+_info.add_bullets(
+    ("payload:", "Any message payload to be collected into a batch."),
+)
+_info.add_header("Output")
+_info.add_bullets(
+    ("payload:", "Array of payloads from the batched messages."),
+    ("batch_size:", "Number of messages in the batch."),
+)
+_info.add_header("Properties")
+_info.add_bullets(
+    ("Batch Size:", "Number of messages to collect before sending."),
+    ("Overlap:", "Number of messages to retain for the next batch."),
+)
+
+
+class BatchNode(BaseNode):
+    """
+    Batch Node - collects messages into batches and sends them together.
+    """
+    info = str(_info)
+    display_name = 'Batch'
+    icon = '📦'
+    category = 'function'
+    color = '#DDA0DD'
+    border_color = '#BA55D3'
+    text_color = '#000000'
+    input_count = 1
+    output_count = 1
+    
+    DEFAULT_CONFIG = {
+        'batch_size': 10,
+        'overlap': 0,
+        MessageKeys.DROP_MESSAGES: False
+    }
+    
+    properties = [
+        {
+            'name': 'batch_size',
+            'label': 'Batch Size',
+            'type': 'number',
+            'default': DEFAULT_CONFIG['batch_size']
+        },
+        {
+            'name': 'overlap',
+            'label': 'Overlap (messages)',
+            'type': 'number',
+            'default': DEFAULT_CONFIG['overlap'],
+        }
+    ]
+    
+    def __init__(self, node_id=None, name="batch"):
+        super().__init__(node_id, name)
+        self.buffer = []
+    
+    def on_input(self, msg: Dict[str, Any], input_index: int = 0):
+        """Collect messages into batches."""
+        self.buffer.append(msg.copy())
+        
+        batch_size = self.get_config_int('batch_size', 10)
+        
+        if len(self.buffer) >= batch_size:
+            # Send batch
+            batch = self.buffer[:batch_size]
+            out_msg = self.create_message(
+                payload=[m.get(MessageKeys.PAYLOAD) for m in batch],
+                topic=batch[0].get(MessageKeys.TOPIC, '') if batch else '',
+                batch_size=len(batch)
+            )
+            self.send(out_msg)
+            
+            # Handle overlap
+            overlap = self.get_config_int('overlap', 0)
+            if overlap > 0 and overlap < batch_size:
+                self.buffer = self.buffer[batch_size - overlap:]
+            else:
+                self.buffer = []

pynode/nodes/BatchNode/requirements.txt

@@ -0,0 +1 @@
+# No external dependencies - uses only Python standard library

pynode/nodes/CameraNode/__init__.py

@@ -0,0 +1,4 @@
+from .camera_node import CameraNode
+
+__all__ = ['CameraNode']
+

pynode/nodes/CameraNode/camera_node.py

@@ -0,0 +1,204 @@
+"""
+Camera node - captures frames from a webcam using OpenCV.
+"""
+
+import cv2
+import base64
+import threading
+import time
+from typing import Any, Dict
+from pynode.nodes.base_node import BaseNode, Info, MessageKeys
+
+_info = Info()
+_info.add_text("Captures video frames from a webcam or video device using OpenCV and outputs them as messages.")
+_info.add_header("Inputs")
+_info.add_text("This node has no inputs. It generates frames automatically when the workflow starts.")
+_info.add_header("Output")
+_info.add_bullets(
+    ("payload.image:", "Image data (JPEG base64 or numpy array depending on config)."),
+    ("payload.image.width:", "Frame width in pixels."),
+    ("payload.image.height:", "Frame height in pixels."),
+)
+_info.add_header("Properties")
+_info.add_bullets(
+    ("Camera Index:", "Device index (0 for default camera)."),
+    ("Frame Rate:", "Target FPS for capture."),
+    ("Width/Height:", "Resolution settings."),
+    ("Encode as JPEG:", "Output as base64 JPEG or raw numpy array."),
+)
+
+
+class CameraNode(BaseNode):
+    """
+    Camera node - captures frames from a webcam and outputs them as messages.
+    """
+    info = str(_info)
+    display_name = 'Camera'
+    icon = '📷'
+    category = 'input'
+    color = '#C0DEED'
+    border_color = '#7FA7C9'
+    text_color = '#000000'
+    input_count = 0  # No input
+    output_count = 1
+    
+    DEFAULT_CONFIG = {
+        MessageKeys.CAMERA.DEVICE_INDEX: 0,
+        MessageKeys.CAMERA.FPS: 30,
+        MessageKeys.CAMERA.WIDTH: 640,
+        MessageKeys.CAMERA.HEIGHT: 480,
+        MessageKeys.CAMERA.ENCODE_JPEG: False,
+        MessageKeys.CAMERA.JPEG_QUALITY: 75
+    }
+    
+    properties = [
+        {
+            'name': MessageKeys.CAMERA.DEVICE_INDEX,
+            'label': 'Camera Index',
+            'type': 'number',
+            'default': DEFAULT_CONFIG[MessageKeys.CAMERA.DEVICE_INDEX]
+        },
+        {
+            'name': MessageKeys.CAMERA.FPS,
+            'label': 'Frame Rate (FPS)',
+            'type': 'number',
+            'default': DEFAULT_CONFIG[MessageKeys.CAMERA.FPS]
+        },
+        {
+            'name': MessageKeys.CAMERA.WIDTH,
+            'label': 'Width',
+            'type': 'number',
+            'default': DEFAULT_CONFIG[MessageKeys.CAMERA.WIDTH]
+        },
+        {
+            'name': MessageKeys.CAMERA.HEIGHT,
+            'label': 'Height',
+            'type': 'number',
+            'default': DEFAULT_CONFIG[MessageKeys.CAMERA.HEIGHT]
+        },
+        {
+            'name': MessageKeys.CAMERA.ENCODE_JPEG,
+            'label': 'Encode as JPEG',
+            'type': 'checkbox',
+            'default': DEFAULT_CONFIG[MessageKeys.CAMERA.ENCODE_JPEG]
+        },
+        {
+            'name': MessageKeys.CAMERA.JPEG_QUALITY,
+            'label': 'JPEG Quality (1-100)',
+            'type': 'number',
+            'default': DEFAULT_CONFIG[MessageKeys.CAMERA.JPEG_QUALITY]
+        }
+    ]
+    
+    def __init__(self, node_id=None, name="camera"):
+        super().__init__(node_id, name)
+        self.camera = None
+        self.capture_thread = None
+        self.running = False
+    
+    def on_start(self):
+        """Start the camera capture when workflow starts."""
+        super().on_start()  # Start base node worker thread
+        
+        camera_index = self.get_config_int(MessageKeys.CAMERA.DEVICE_INDEX, 0)
+        fps = self.get_config_int(MessageKeys.CAMERA.FPS, 10)
+        width = self.get_config_int(MessageKeys.CAMERA.WIDTH, 640)
+        height = self.get_config_int(MessageKeys.CAMERA.HEIGHT, 480)
+        
+        try:
+            # Open the camera
+            self.camera = cv2.VideoCapture(camera_index)
+            
+            if not self.camera.isOpened():
+                self.report_error(f"Failed to open camera {camera_index}")
+                return
+            
+            # Set resolution
+            self.camera.set(cv2.CAP_PROP_FRAME_WIDTH, width)
+            self.camera.set(cv2.CAP_PROP_FRAME_HEIGHT, height)
+            
+            # Start capture thread
+            self.running = True
+            self.capture_thread = threading.Thread(target=self._capture_loop, args=(fps,), daemon=True)
+            self.capture_thread.start()
+            
+        except Exception as e:
+            self.report_error(f"Error starting camera: {e}")
+    
+    def on_stop(self):
+        """Stop the camera capture when workflow stops."""
+        super().on_stop()  # Stop base node worker thread
+        
+        self.running = False
+        
+        if self.capture_thread:
+            self.capture_thread.join(timeout=2.0)
+            self.capture_thread = None
+        
+        if self.camera:
+            self.camera.release()
+            self.camera = None
+    
+    def on_close(self):
+        """Cleanup when node is deleted."""
+        self.on_stop()
+    
+    def _capture_loop(self, fps):
+        """Capture frames in a loop and send them as messages."""
+        frame_interval = 1.0 / fps
+        encode_jpeg = self.config.get(MessageKeys.CAMERA.ENCODE_JPEG, True)
+        
+        while self.running and self.camera and self.camera.isOpened():
+            start_time = time.time()
+            
+            try:
+                ret, frame = self.camera.read()
+                
+                if not ret or frame is None:
+                    self.report_error("Failed to capture frame")
+                    time.sleep(frame_interval)
+                    continue
+                
+                # Prepare the payload
+                if encode_jpeg:
+                    # Encode frame as JPEG with quality setting
+                    jpeg_quality = self.get_config_int(MessageKeys.CAMERA.JPEG_QUALITY, 75)
+                    encode_params = (cv2.IMWRITE_JPEG_QUALITY, jpeg_quality)
+                    ret, buffer = cv2.imencode('.jpg', frame, encode_params)
+                    if ret:
+                        # Convert to bytes (more efficient than base64)
+                        jpeg_bytes = buffer.tobytes()
+                        # Convert to base64 for JSON transmission
+                        jpeg_base64 = base64.b64encode(jpeg_bytes).decode('utf-8')
+                        payload = {
+                            MessageKeys.IMAGE.FORMAT: 'jpeg',
+                            MessageKeys.IMAGE.ENCODING: 'base64',
+                            MessageKeys.IMAGE.DATA: jpeg_base64,
+                            MessageKeys.IMAGE.WIDTH: frame.shape[1],
+                            MessageKeys.IMAGE.HEIGHT: frame.shape[0]
+                        }
+                    else:
+                        self.report_error("Failed to encode JPEG")
+                        continue
+                else:
+                    # Send raw frame as numpy array
+                    payload = {
+                        MessageKeys.IMAGE.FORMAT: 'bgr',
+                        MessageKeys.IMAGE.ENCODING: 'numpy',
+                        MessageKeys.IMAGE.DATA: frame,
+                        MessageKeys.IMAGE.WIDTH: frame.shape[1],
+                        MessageKeys.IMAGE.HEIGHT: frame.shape[0]
+                    }
+                
+                # Create and send message with image wrapped in payload.image
+                msg = self.create_message(payload={MessageKeys.IMAGE.PATH: payload}, topic='camera/frame')
+                self.send(msg)
+                
+            except Exception as e:
+                self.report_error(f"Error capturing frame: {e}")
+            
+            # Maintain frame rate
+            elapsed = time.time() - start_time
+            sleep_time = max(0, frame_interval - elapsed)
+            if sleep_time > 0:
+                time.sleep(sleep_time)

pynode/nodes/CameraNode/requirements.txt

@@ -0,0 +1,2 @@
+opencv-python>=4.5.0
+numpy>=1.19.0

pynode/nodes/ChangeNode/__init__.py

@@ -0,0 +1 @@
+from .change_node import ChangeNode