pynode-flow 0.2.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- pynode/__init__.py +37 -0
- pynode/__main__.py +9 -0
- pynode/_perf.py +65 -0
- pynode/_version.py +24 -0
- pynode/api/__init__.py +15 -0
- pynode/api/helpers.py +79 -0
- pynode/api/nodes.py +423 -0
- pynode/api/services.py +124 -0
- pynode/api/sse.py +58 -0
- pynode/api/uploads.py +59 -0
- pynode/api/workflows.py +466 -0
- pynode/config.py +93 -0
- pynode/install_nodes.py +143 -0
- pynode/main.py +118 -0
- pynode/node_registry.py +156 -0
- pynode/nodes/AutoSyncNode/auto_sync_node.py +151 -0
- pynode/nodes/BBoxMetricsNode/__init__.py +3 -0
- pynode/nodes/BBoxMetricsNode/bbox_metrics_node.py +250 -0
- pynode/nodes/BBoxMetricsNode/requirements.txt +1 -0
- pynode/nodes/BatchNode/__init__.py +3 -0
- pynode/nodes/BatchNode/batch_node.py +86 -0
- pynode/nodes/BatchNode/requirements.txt +1 -0
- pynode/nodes/CameraNode/__init__.py +4 -0
- pynode/nodes/CameraNode/camera_node.py +204 -0
- pynode/nodes/CameraNode/requirements.txt +2 -0
- pynode/nodes/ChangeNode/__init__.py +1 -0
- pynode/nodes/ChangeNode/change_node.py +255 -0
- pynode/nodes/ChangeNode/requirements.txt +1 -0
- pynode/nodes/ConfidenceFilterNode/__init__.py +4 -0
- pynode/nodes/ConfidenceFilterNode/confidence_filter_node.py +208 -0
- pynode/nodes/ConfidenceFilterNode/requirements.txt +1 -0
- pynode/nodes/CounterNode/__init__.py +3 -0
- pynode/nodes/CounterNode/counter_node.py +191 -0
- pynode/nodes/CropNode/__init__.py +4 -0
- pynode/nodes/CropNode/crop_node.py +317 -0
- pynode/nodes/CropNode/requirements.txt +2 -0
- pynode/nodes/DebugNode/__init__.py +4 -0
- pynode/nodes/DebugNode/debug_node.py +169 -0
- pynode/nodes/DebugNode/requirements.txt +1 -0
- pynode/nodes/DelayNode/delay_node.py +218 -0
- pynode/nodes/DelayNode/requirements.txt +1 -0
- pynode/nodes/DrawPredictionsNode/__init__.py +3 -0
- pynode/nodes/DrawPredictionsNode/draw_predictions_node.py +365 -0
- pynode/nodes/DrawPredictionsNode/requirements.txt +2 -0
- pynode/nodes/ErrorNode/error_node.py +94 -0
- pynode/nodes/ErrorNode/requirements.txt +1 -0
- pynode/nodes/FilterNode/__init__.py +3 -0
- pynode/nodes/FilterNode/filter_node.py +102 -0
- pynode/nodes/FilterNode/requirements.txt +1 -0
- pynode/nodes/FrameSourceNode/__init__.py +4 -0
- pynode/nodes/FrameSourceNode/frame_source_node.py +319 -0
- pynode/nodes/FrameSourceNode/requirements.txt +1 -0
- pynode/nodes/FunctionNode/__init__.py +3 -0
- pynode/nodes/FunctionNode/function_node.py +168 -0
- pynode/nodes/FunctionNode/requirements.txt +1 -0
- pynode/nodes/GateNode/gate_node.py +60 -0
- pynode/nodes/GateNode/requirements.txt +1 -0
- pynode/nodes/GetiUploadNode/__init__.py +3 -0
- pynode/nodes/GetiUploadNode/geti_upload_node.py +278 -0
- pynode/nodes/GetiUploadNode/requirements.txt +1 -0
- pynode/nodes/ImageFormatNode/__init__.py +4 -0
- pynode/nodes/ImageFormatNode/image_format_node.py +310 -0
- pynode/nodes/ImageFormatNode/requirements.txt +2 -0
- pynode/nodes/ImageUploadNode/image_upload_node.py +96 -0
- pynode/nodes/ImageViewerNode/__init__.py +4 -0
- pynode/nodes/ImageViewerNode/image_viewer_node.py +162 -0
- pynode/nodes/ImageViewerNode/requirements.txt +2 -0
- pynode/nodes/ImageWriterNode/__init__.py +3 -0
- pynode/nodes/ImageWriterNode/imagewriter_node.py +352 -0
- pynode/nodes/ImageWriterNode/requirements.txt +1 -0
- pynode/nodes/InferenceNode/InferenceEngine/__init__.py +15 -0
- pynode/nodes/InferenceNode/InferenceEngine/device_detection.py +149 -0
- pynode/nodes/InferenceNode/InferenceEngine/engines/base_engine.py +155 -0
- pynode/nodes/InferenceNode/InferenceEngine/engines/example_engine_template.py +272 -0
- pynode/nodes/InferenceNode/InferenceEngine/engines/geti_engine.py +309 -0
- pynode/nodes/InferenceNode/InferenceEngine/engines/onnx_engine.py +346 -0
- pynode/nodes/InferenceNode/InferenceEngine/engines/pass_engine.py +86 -0
- pynode/nodes/InferenceNode/InferenceEngine/engines/ultralytics_engine.py +863 -0
- pynode/nodes/InferenceNode/InferenceEngine/inference_engine_factory.py +533 -0
- pynode/nodes/InferenceNode/InferenceEngine/readme.md +107 -0
- pynode/nodes/InferenceNode/InferenceEngine/result_converters.py +121 -0
- pynode/nodes/InferenceNode/inference_node.py +451 -0
- pynode/nodes/InferenceNode/requirements.txt +13 -0
- pynode/nodes/InjectNode/inject_node.py +245 -0
- pynode/nodes/InjectNode/requirements.txt +1 -0
- pynode/nodes/JoinNode/__init__.py +3 -0
- pynode/nodes/JoinNode/join_node.py +156 -0
- pynode/nodes/JoinNode/requirements.txt +1 -0
- pynode/nodes/LabelFilterNode/__init__.py +3 -0
- pynode/nodes/LabelFilterNode/label_filter_node.py +188 -0
- pynode/nodes/LabelFilterNode/requirements.txt +1 -0
- pynode/nodes/MQTTNode/__init__.py +8 -0
- pynode/nodes/MQTTNode/mqtt_in_node.py +148 -0
- pynode/nodes/MQTTNode/mqtt_out_node.py +157 -0
- pynode/nodes/MQTTNode/mqtt_service.py +367 -0
- pynode/nodes/MQTTNode/requirements.txt +1 -0
- pynode/nodes/MessageWriterNode/__init__.py +7 -0
- pynode/nodes/MessageWriterNode/messagereader_node.py +568 -0
- pynode/nodes/MessageWriterNode/messagewriter_node.py +505 -0
- pynode/nodes/OmronCameraNode/__init__.py +3 -0
- pynode/nodes/OmronCameraNode/omron_camera_node.py +652 -0
- pynode/nodes/OmronCameraNode/requirements.txt +4 -0
- pynode/nodes/OpenCV/__init__.py +1 -0
- pynode/nodes/OpenCV/arithmetic_node.py +376 -0
- pynode/nodes/OpenCV/bitwise_node.py +127 -0
- pynode/nodes/OpenCV/blend_node.py +127 -0
- pynode/nodes/OpenCV/blob_detector_node.py +233 -0
- pynode/nodes/OpenCV/blur_node.py +141 -0
- pynode/nodes/OpenCV/color_space_node.py +139 -0
- pynode/nodes/OpenCV/colormap_node.py +262 -0
- pynode/nodes/OpenCV/contours_node.py +258 -0
- pynode/nodes/OpenCV/denormalize_coords_node.py +365 -0
- pynode/nodes/OpenCV/draw_node.py +312 -0
- pynode/nodes/OpenCV/edge_detector_node.py +177 -0
- pynode/nodes/OpenCV/equirectangular_node.py +447 -0
- pynode/nodes/OpenCV/fft_node.py +102 -0
- pynode/nodes/OpenCV/focus_estimation_node.py +189 -0
- pynode/nodes/OpenCV/frequency_filter_node.py +241 -0
- pynode/nodes/OpenCV/histogram_node.py +160 -0
- pynode/nodes/OpenCV/hough_circles_node.py +224 -0
- pynode/nodes/OpenCV/hough_lines_node.py +243 -0
- pynode/nodes/OpenCV/in_range_node.py +186 -0
- pynode/nodes/OpenCV/morphology_node.py +136 -0
- pynode/nodes/OpenCV/normalize_coords_node.py +344 -0
- pynode/nodes/OpenCV/paste_node.py +244 -0
- pynode/nodes/OpenCV/perspective_node.py +174 -0
- pynode/nodes/OpenCV/realsense_depth_node.py +253 -0
- pynode/nodes/OpenCV/requirements.txt +2 -0
- pynode/nodes/OpenCV/resize_node.py +175 -0
- pynode/nodes/OpenCV/rotate_node.py +159 -0
- pynode/nodes/OpenCV/template_match_node.py +227 -0
- pynode/nodes/OpenCV/threshold_node.py +167 -0
- pynode/nodes/PointInShapeNode/__init__.py +3 -0
- pynode/nodes/PointInShapeNode/point_in_shape_node.py +313 -0
- pynode/nodes/PointInShapeNode/requirements.txt +2 -0
- pynode/nodes/PolygonMetricsNode/__init__.py +3 -0
- pynode/nodes/PolygonMetricsNode/polygon_metrics_node.py +331 -0
- pynode/nodes/PolygonMetricsNode/requirements.txt +2 -0
- pynode/nodes/QueueLengthProbeNode/__init__.py +3 -0
- pynode/nodes/QueueLengthProbeNode/queue_length_probe_node.py +116 -0
- pynode/nodes/Qwen3VLMNode/__init__.py +3 -0
- pynode/nodes/Qwen3VLMNode/qwen3_vlm_node.py +519 -0
- pynode/nodes/Qwen3VLMNode/requirements.txt +5 -0
- pynode/nodes/RESTEndpointNode/__init__.py +3 -0
- pynode/nodes/RESTEndpointNode/rest_endpoint_node.py +491 -0
- pynode/nodes/RangeNode/__init__.py +3 -0
- pynode/nodes/RangeNode/range_node.py +115 -0
- pynode/nodes/RangeNode/requirements.txt +1 -0
- pynode/nodes/RateProbeNode/__init__.py +3 -0
- pynode/nodes/RateProbeNode/rate_probe_node.py +183 -0
- pynode/nodes/RateProbeNode/requirements.txt +1 -0
- pynode/nodes/RoboflowUploadNode/__init__.py +3 -0
- pynode/nodes/RoboflowUploadNode/requirements.txt +1 -0
- pynode/nodes/RoboflowUploadNode/roboflow_upload_node.py +229 -0
- pynode/nodes/SliceNode/README.md +149 -0
- pynode/nodes/SliceNode/__init__.py +5 -0
- pynode/nodes/SliceNode/merge_predictions_node.py +444 -0
- pynode/nodes/SliceNode/requirements.txt +3 -0
- pynode/nodes/SliceNode/slice_collector_node.py +370 -0
- pynode/nodes/SliceNode/slice_image_node.py +380 -0
- pynode/nodes/SplitNode/__init__.py +3 -0
- pynode/nodes/SplitNode/requirements.txt +1 -0
- pynode/nodes/SplitNode/split_node.py +155 -0
- pynode/nodes/SwitchNode/requirements.txt +1 -0
- pynode/nodes/SwitchNode/switch_node.py +259 -0
- pynode/nodes/SyncNode/__init__.py +3 -0
- pynode/nodes/SyncNode/sync_node.py +287 -0
- pynode/nodes/TemplateNode/requirements.txt +1 -0
- pynode/nodes/TemplateNode/template_node.py +86 -0
- pynode/nodes/TrackerNode/__init__.py +2 -0
- pynode/nodes/TrackerNode/supervision_tracker_node.py +248 -0
- pynode/nodes/TrackerNode/tracker_node.py +745 -0
- pynode/nodes/UltralyticsNode/__init__.py +4 -0
- pynode/nodes/UltralyticsNode/requirements.txt +2 -0
- pynode/nodes/UltralyticsNode/ultralytics_node.py +364 -0
- pynode/nodes/UnknownNode/__init__.py +93 -0
- pynode/nodes/VLLMNode/__init__.py +3 -0
- pynode/nodes/VLLMNode/vllm_node.py +345 -0
- pynode/nodes/VideoReaderNode/__init__.py +3 -0
- pynode/nodes/VideoReaderNode/video_reader_node.py +425 -0
- pynode/nodes/VideoWriterNode/__init__.py +3 -0
- pynode/nodes/VideoWriterNode/video_writer_node.py +441 -0
- pynode/nodes/WebhookNode/__init__.py +3 -0
- pynode/nodes/WebhookNode/webhook_node.py +591 -0
- pynode/nodes/__init__.py +109 -0
- pynode/nodes/base_node.py +562 -0
- pynode/nodes/image_utils.py +291 -0
- pynode/nodes/info.py +109 -0
- pynode/nodes/mDNSNode/__init__.py +13 -0
- pynode/nodes/mDNSNode/mdns_broadcast_node.py +214 -0
- pynode/nodes/mDNSNode/mdns_discovery_node.py +362 -0
- pynode/nodes/mDNSNode/mdns_manager.py +399 -0
- pynode/nodes/mDNSNode/requirements.txt +1 -0
- pynode/nodes/messages.py +81 -0
- pynode/server.py +187 -0
- pynode/static/images/favicon4.png +0 -0
- pynode/static/index.html +200 -0
- pynode/static/js/README.md +139 -0
- pynode/static/js/auth.js +89 -0
- pynode/static/js/clipboard.js +152 -0
- pynode/static/js/config.js +14 -0
- pynode/static/js/connections.js +844 -0
- pynode/static/js/debug.js +524 -0
- pynode/static/js/events.js +775 -0
- pynode/static/js/history.js +199 -0
- pynode/static/js/main.js +55 -0
- pynode/static/js/minimap.js +242 -0
- pynode/static/js/nodes.js +995 -0
- pynode/static/js/palette.js +255 -0
- pynode/static/js/properties.js +1270 -0
- pynode/static/js/selection.js +241 -0
- pynode/static/js/state.js +211 -0
- pynode/static/js/ui-utils.js +28 -0
- pynode/static/js/viewport.js +204 -0
- pynode/static/js/workflow.js +469 -0
- pynode/static/js/workflows.js +344 -0
- pynode/static/style.css +2751 -0
- pynode/workflow_engine.py +483 -0
- pynode/workflow_manager.py +440 -0
- pynode_flow-0.2.0.dist-info/METADATA +520 -0
- pynode_flow-0.2.0.dist-info/RECORD +227 -0
- pynode_flow-0.2.0.dist-info/WHEEL +5 -0
- pynode_flow-0.2.0.dist-info/entry_points.txt +3 -0
- pynode_flow-0.2.0.dist-info/licenses/LICENSE +21 -0
- pynode_flow-0.2.0.dist-info/scm_file_list.json +270 -0
- pynode_flow-0.2.0.dist-info/scm_version.json +8 -0
- pynode_flow-0.2.0.dist-info/top_level.txt +1 -0
|
@@ -0,0 +1,121 @@
|
|
|
1
|
+
#!/usr/bin/env python3
|
|
2
|
+
"""
|
|
3
|
+
Utilities for converting between different inference engine result formats.
|
|
4
|
+
Uses official Geti SDK data models for proper format compliance.
|
|
5
|
+
Supports conversion between Ultralytics and Geti inference result formats.
|
|
6
|
+
"""
|
|
7
|
+
|
|
8
|
+
from typing import Dict, List, Any, Optional
|
|
9
|
+
import logging
|
|
10
|
+
|
|
11
|
+
logger = logging.getLogger(__name__)
|
|
12
|
+
|
|
13
|
+
# Import Geti SDK data models
|
|
14
|
+
try:
|
|
15
|
+
from geti_sdk.data_models.shapes import Rectangle as GetiRectangle, ShapeType as GetiShapeType
|
|
16
|
+
from geti_sdk.data_models.predictions import Prediction
|
|
17
|
+
from geti_sdk.data_models.label import ScoredLabel
|
|
18
|
+
from geti_sdk.data_models.annotations import Annotation
|
|
19
|
+
from geti_sdk.data_models.annotation_scene import AnnotationScene
|
|
20
|
+
|
|
21
|
+
GETI_SDK_AVAILABLE = True
|
|
22
|
+
|
|
23
|
+
except ImportError as e:
|
|
24
|
+
logger.warning(f"Geti SDK not available: {e}. Using fallback Rectangle class.")
|
|
25
|
+
GETI_SDK_AVAILABLE = False
|
|
26
|
+
GetiRectangle = None
|
|
27
|
+
GetiShapeType = None
|
|
28
|
+
|
|
29
|
+
|
|
30
|
+
# Fallback classes that work whether SDK is available or not
|
|
31
|
+
class ShapeType:
|
|
32
|
+
RECTANGLE = "RECTANGLE"
|
|
33
|
+
|
|
34
|
+
|
|
35
|
+
class Rectangle:
|
|
36
|
+
def __init__(self, x: float, y: float, width: float, height: float, type=ShapeType.RECTANGLE):
|
|
37
|
+
self.x = x
|
|
38
|
+
self.y = y
|
|
39
|
+
self.width = width
|
|
40
|
+
self.height = height
|
|
41
|
+
self.type = type
|
|
42
|
+
|
|
43
|
+
def __repr__(self):
|
|
44
|
+
return f"Rectangle(x={self.x}, y={self.y}, width={self.width}, height={self.height}, type=<ShapeType.{self.type}: '{self.type}'>)"
|
|
45
|
+
|
|
46
|
+
|
|
47
|
+
def create_rectangle(x: float, y: float, width: float, height: float):
|
|
48
|
+
"""Create a Rectangle using Geti SDK if available, otherwise use fallback."""
|
|
49
|
+
if GETI_SDK_AVAILABLE and GetiRectangle is not None and GetiShapeType is not None:
|
|
50
|
+
return GetiRectangle(x=int(x), y=int(y), width=int(width), height=int(height))
|
|
51
|
+
else:
|
|
52
|
+
return Rectangle(x=x, y=y, width=width, height=height, type=ShapeType.RECTANGLE)
|
|
53
|
+
|
|
54
|
+
|
|
55
|
+
def extract_detections_summary(result: Dict[str, Any]) -> Dict[str, Any]:
|
|
56
|
+
"""
|
|
57
|
+
Extract a simplified summary of detections from any result format.
|
|
58
|
+
|
|
59
|
+
Args:
|
|
60
|
+
result: Inference result from any supported engine
|
|
61
|
+
|
|
62
|
+
Returns:
|
|
63
|
+
Dict with simplified detection summary
|
|
64
|
+
"""
|
|
65
|
+
if not result.get('success', False):
|
|
66
|
+
return {
|
|
67
|
+
'engine': 'unknown',
|
|
68
|
+
'detection_count': 0,
|
|
69
|
+
'classes_detected': [],
|
|
70
|
+
'confidence_range': (0.0, 0.0),
|
|
71
|
+
'detections': []
|
|
72
|
+
}
|
|
73
|
+
|
|
74
|
+
engine = result.get('results', {}).get('engine', 'unknown')
|
|
75
|
+
detections = []
|
|
76
|
+
|
|
77
|
+
if engine == 'ultralytics':
|
|
78
|
+
ultra_results = result.get('results', {}).get('results', [])
|
|
79
|
+
for result_item in ultra_results:
|
|
80
|
+
for detection in result_item.get('detections', []):
|
|
81
|
+
detections.append({
|
|
82
|
+
'class_name': detection.get('class_name', 'unknown'),
|
|
83
|
+
'confidence': detection.get('confidence', 0.0),
|
|
84
|
+
'bbox': detection.get('bbox', [])
|
|
85
|
+
})
|
|
86
|
+
|
|
87
|
+
elif engine == 'geti':
|
|
88
|
+
predictions = result.get('results', {}).get('results', {}).get('predictions', [])
|
|
89
|
+
for prediction in predictions:
|
|
90
|
+
shape = prediction.get('shape')
|
|
91
|
+
bbox = []
|
|
92
|
+
if shape and hasattr(shape, 'x'):
|
|
93
|
+
bbox = [shape.x, shape.y, shape.x + shape.width, shape.y + shape.height]
|
|
94
|
+
|
|
95
|
+
detections.append({
|
|
96
|
+
'class_name': prediction.get('label', 'unknown'),
|
|
97
|
+
'confidence': prediction.get('confidence', 0.0),
|
|
98
|
+
'bbox': bbox
|
|
99
|
+
})
|
|
100
|
+
|
|
101
|
+
classes_detected = list(set(d['class_name'] for d in detections))
|
|
102
|
+
confidences = [d['confidence'] for d in detections]
|
|
103
|
+
confidence_range = (min(confidences, default=0.0), max(confidences, default=0.0))
|
|
104
|
+
|
|
105
|
+
return {
|
|
106
|
+
'engine': engine,
|
|
107
|
+
'detection_count': len(detections),
|
|
108
|
+
'classes_detected': classes_detected,
|
|
109
|
+
'confidence_range': confidence_range,
|
|
110
|
+
'detections': detections
|
|
111
|
+
}
|
|
112
|
+
|
|
113
|
+
|
|
114
|
+
# Export all functions
|
|
115
|
+
__all__ = [
|
|
116
|
+
'Rectangle',
|
|
117
|
+
'ShapeType',
|
|
118
|
+
'create_rectangle',
|
|
119
|
+
'extract_detections_summary',
|
|
120
|
+
'GETI_SDK_AVAILABLE'
|
|
121
|
+
]
|
|
@@ -0,0 +1,451 @@
|
|
|
1
|
+
"""
|
|
2
|
+
Inference Node - Performs inference using multiple backends (Ultralytics, Geti, ONNX, etc.)
|
|
3
|
+
Supports engine selection, model file upload, target hardware selection, and inference.
|
|
4
|
+
"""
|
|
5
|
+
|
|
6
|
+
import base64
|
|
7
|
+
import cv2
|
|
8
|
+
import logging
|
|
9
|
+
import os
|
|
10
|
+
import numpy as np
|
|
11
|
+
from typing import Any, Dict, List, Optional
|
|
12
|
+
from pynode.nodes.base_node import BaseNode, Info, MessageKeys
|
|
13
|
+
|
|
14
|
+
logger = logging.getLogger(__name__)
|
|
15
|
+
|
|
16
|
+
_info = Info()
|
|
17
|
+
_info.add_text("Performs object detection and inference using multiple backends including Ultralytics YOLO, Intel Geti, and ONNX Runtime.")
|
|
18
|
+
_info.add_header("Inputs")
|
|
19
|
+
_info.add_bullets(("Input 0:", "Image message with 'image' field (base64 or numpy array)"))
|
|
20
|
+
_info.add_header("Outputs")
|
|
21
|
+
_info.add_bullets(
|
|
22
|
+
("Output 0:", "Detection results with optional annotated image"),
|
|
23
|
+
)
|
|
24
|
+
_info.add_header("Configuration")
|
|
25
|
+
_info.add_bullets(
|
|
26
|
+
("Engine Type:", "Select inference backend (Ultralytics, Geti, ONNX, etc.)"),
|
|
27
|
+
("Model File:", "Path to model file (.pt, .onnx, .xml, .zip)"),
|
|
28
|
+
("Target Hardware:", "CPU, CUDA GPU, or Intel OpenVINO devices"),
|
|
29
|
+
("Confidence:", "Minimum confidence threshold (0.0-1.0)"),
|
|
30
|
+
("IoU:", "IoU threshold for Non-Maximum Suppression"),
|
|
31
|
+
("Draw Results:", "Overlay detections on output image"),
|
|
32
|
+
)
|
|
33
|
+
|
|
34
|
+
# Try to import torch for device detection
|
|
35
|
+
try:
|
|
36
|
+
import torch as _torch
|
|
37
|
+
_HAS_TORCH = True
|
|
38
|
+
except ImportError:
|
|
39
|
+
_torch = None # type: ignore
|
|
40
|
+
_HAS_TORCH = False
|
|
41
|
+
|
|
42
|
+
|
|
43
|
+
class InferenceNode(BaseNode):
|
|
44
|
+
"""
|
|
45
|
+
Inference Node - performs inference using multiple backends.
|
|
46
|
+
Supports Ultralytics YOLO, Geti, ONNX, and other inference engines.
|
|
47
|
+
"""
|
|
48
|
+
# Visual properties
|
|
49
|
+
display_name = 'Inference'
|
|
50
|
+
info = str(_info)
|
|
51
|
+
icon = '🧠'
|
|
52
|
+
category = 'vision'
|
|
53
|
+
color = '#7B68EE' # Medium slate blue
|
|
54
|
+
border_color = '#6A5ACD'
|
|
55
|
+
text_color = '#FFFFFF'
|
|
56
|
+
input_count = 1
|
|
57
|
+
output_count = 1
|
|
58
|
+
|
|
59
|
+
DEFAULT_CONFIG = {
|
|
60
|
+
'engine_type': 'ultralytics',
|
|
61
|
+
'model_path': '',
|
|
62
|
+
'device': 'cpu',
|
|
63
|
+
'confidence': '0.25',
|
|
64
|
+
'iou': '0.45',
|
|
65
|
+
'draw_results': 'true',
|
|
66
|
+
'include_image': True,
|
|
67
|
+
'include_predictions': True,
|
|
68
|
+
'drop_messages': 'true' # Enable by default to prevent queue buildup
|
|
69
|
+
}
|
|
70
|
+
|
|
71
|
+
@staticmethod
|
|
72
|
+
def _get_available_engines() -> List[Dict[str, str]]:
|
|
73
|
+
"""Get available inference engines from the factory."""
|
|
74
|
+
try:
|
|
75
|
+
from pynode.nodes.InferenceNode.InferenceEngine.inference_engine_factory import InferenceEngineFactory
|
|
76
|
+
engines = InferenceEngineFactory.get_available_engines_with_names()
|
|
77
|
+
return [
|
|
78
|
+
{'value': engine_type, 'label': display_name}
|
|
79
|
+
for engine_type, display_name in engines.items()
|
|
80
|
+
]
|
|
81
|
+
except Exception as e:
|
|
82
|
+
logger.warning(f"Error getting available engines: {e}")
|
|
83
|
+
# Fallback to common engines
|
|
84
|
+
return [
|
|
85
|
+
{'value': 'ultralytics', 'label': 'Ultralytics YOLO'},
|
|
86
|
+
{'value': 'geti', 'label': 'Geti'},
|
|
87
|
+
{'value': 'onnx', 'label': 'ONNX Runtime'},
|
|
88
|
+
{'value': 'pass', 'label': 'Pass-through (Testing)'}
|
|
89
|
+
]
|
|
90
|
+
|
|
91
|
+
@staticmethod
|
|
92
|
+
def _get_device_options() -> List[Dict[str, str]]:
|
|
93
|
+
"""Get available hardware devices for inference."""
|
|
94
|
+
devices = [
|
|
95
|
+
{'value': 'cpu', 'label': 'CPU'},
|
|
96
|
+
]
|
|
97
|
+
|
|
98
|
+
# Check for CUDA devices (NVIDIA GPUs)
|
|
99
|
+
try:
|
|
100
|
+
if _HAS_TORCH and _torch is not None and _torch.cuda.is_available():
|
|
101
|
+
for i in range(_torch.cuda.device_count()):
|
|
102
|
+
props = _torch.cuda.get_device_properties(i)
|
|
103
|
+
memory_gb = props.total_memory / (1024**3)
|
|
104
|
+
label = f"CUDA:{i} - {props.name} ({memory_gb:.1f}GB)"
|
|
105
|
+
devices.append({'value': f'cuda:{i}', 'label': label})
|
|
106
|
+
except Exception as e:
|
|
107
|
+
logger.warning(f"Error detecting CUDA devices: {e}")
|
|
108
|
+
|
|
109
|
+
# Add Intel OpenVINO devices (enumerated via openvino when available;
|
|
110
|
+
# falls back to the historical static CPU/GPU/NPU list otherwise)
|
|
111
|
+
try:
|
|
112
|
+
from pynode.nodes.InferenceNode.InferenceEngine.device_detection import (
|
|
113
|
+
get_intel_device_options,
|
|
114
|
+
)
|
|
115
|
+
devices.extend(get_intel_device_options())
|
|
116
|
+
except Exception as e:
|
|
117
|
+
logger.warning(f"Error detecting Intel OpenVINO devices: {e}")
|
|
118
|
+
devices.extend([
|
|
119
|
+
{'value': 'intel:cpu', 'label': 'Intel CPU (OpenVINO)'},
|
|
120
|
+
{'value': 'intel:gpu', 'label': 'Intel GPU (OpenVINO)'},
|
|
121
|
+
{'value': 'intel:npu', 'label': 'Intel NPU (OpenVINO)'},
|
|
122
|
+
])
|
|
123
|
+
|
|
124
|
+
return devices
|
|
125
|
+
|
|
126
|
+
@classmethod
|
|
127
|
+
def get_properties(cls):
|
|
128
|
+
"""Dynamic properties with engine and device detection."""
|
|
129
|
+
return [
|
|
130
|
+
{
|
|
131
|
+
'name': 'engine_type',
|
|
132
|
+
'label': 'Inference Engine',
|
|
133
|
+
'type': 'select',
|
|
134
|
+
'options': cls._get_available_engines(),
|
|
135
|
+
'help': 'Select the inference backend to use'
|
|
136
|
+
},
|
|
137
|
+
{
|
|
138
|
+
'name': 'model_path',
|
|
139
|
+
'label': 'Model File',
|
|
140
|
+
'type': 'file',
|
|
141
|
+
'accept': '.pt,.onnx,.xml,.zip,.pth',
|
|
142
|
+
'help': 'Upload or select a model file (.pt, .onnx, .xml, .zip)'
|
|
143
|
+
},
|
|
144
|
+
{
|
|
145
|
+
'name': 'device',
|
|
146
|
+
'label': 'Target Hardware',
|
|
147
|
+
'type': 'select',
|
|
148
|
+
'options': cls._get_device_options(),
|
|
149
|
+
'help': 'Select target hardware for inference'
|
|
150
|
+
},
|
|
151
|
+
{
|
|
152
|
+
'name': 'confidence',
|
|
153
|
+
'label': 'Confidence Threshold',
|
|
154
|
+
'type': 'text',
|
|
155
|
+
'placeholder': '0.25',
|
|
156
|
+
'help': 'Minimum confidence score for detections (0.0-1.0)'
|
|
157
|
+
},
|
|
158
|
+
{
|
|
159
|
+
'name': 'iou',
|
|
160
|
+
'label': 'IoU Threshold',
|
|
161
|
+
'type': 'text',
|
|
162
|
+
'placeholder': '0.45',
|
|
163
|
+
'help': 'IoU threshold for Non-Maximum Suppression'
|
|
164
|
+
},
|
|
165
|
+
{
|
|
166
|
+
'name': 'draw_results',
|
|
167
|
+
'label': 'Draw Results on Image',
|
|
168
|
+
'type': 'select',
|
|
169
|
+
'options': [
|
|
170
|
+
{'value': 'true', 'label': 'Yes'},
|
|
171
|
+
{'value': 'false', 'label': 'No'}
|
|
172
|
+
],
|
|
173
|
+
'help': 'Overlay detections on the output image'
|
|
174
|
+
},
|
|
175
|
+
{
|
|
176
|
+
'name': 'include_image',
|
|
177
|
+
'label': 'Include Image in Output',
|
|
178
|
+
'type': 'checkbox',
|
|
179
|
+
'default': True,
|
|
180
|
+
'help': 'Include the processed image in output message'
|
|
181
|
+
},
|
|
182
|
+
{
|
|
183
|
+
'name': 'include_predictions',
|
|
184
|
+
'label': 'Include Predictions in Output',
|
|
185
|
+
'type': 'checkbox',
|
|
186
|
+
'default': True,
|
|
187
|
+
'help': 'Include detection predictions in output message'
|
|
188
|
+
}
|
|
189
|
+
]
|
|
190
|
+
|
|
191
|
+
properties = property(lambda self: self.get_properties())
|
|
192
|
+
# print(properties)
|
|
193
|
+
|
|
194
|
+
@staticmethod
|
|
195
|
+
def _get_default_device():
|
|
196
|
+
"""Get default device based on availability."""
|
|
197
|
+
if _HAS_TORCH and _torch is not None and _torch.cuda.is_available():
|
|
198
|
+
return 'cuda:0'
|
|
199
|
+
return 'cpu'
|
|
200
|
+
|
|
201
|
+
def _standardize_task_string(self, task: str) -> str:
|
|
202
|
+
# Check for task indicators in filename
|
|
203
|
+
if 'detect' in task or 'det' in task:
|
|
204
|
+
return 'detection'
|
|
205
|
+
elif 'seg' in task or 'segment' in task:
|
|
206
|
+
return 'segmentation'
|
|
207
|
+
elif 'cls' in task or 'classify' in task:
|
|
208
|
+
return 'classification'
|
|
209
|
+
elif 'pose' in task:
|
|
210
|
+
return 'pose'
|
|
211
|
+
elif 'obb' in task:
|
|
212
|
+
return 'obb'
|
|
213
|
+
else:
|
|
214
|
+
# Default to detection
|
|
215
|
+
return 'detection'
|
|
216
|
+
|
|
217
|
+
def __init__(self, node_id=None, name="Inference"):
|
|
218
|
+
super().__init__(node_id, name)
|
|
219
|
+
# Configure with defaults, then set device dynamically
|
|
220
|
+
config = self.DEFAULT_CONFIG.copy()
|
|
221
|
+
config['device'] = self._get_default_device()
|
|
222
|
+
self.configure(config)
|
|
223
|
+
|
|
224
|
+
# Engine state
|
|
225
|
+
self.engine = None
|
|
226
|
+
self._engine_loaded = False
|
|
227
|
+
self._current_engine_type = None
|
|
228
|
+
self._current_model_path = None
|
|
229
|
+
self._current_device = None
|
|
230
|
+
|
|
231
|
+
def _get_engine_factory(self):
|
|
232
|
+
"""Get the inference engine factory (lazy import)."""
|
|
233
|
+
try:
|
|
234
|
+
from pynode.nodes.InferenceNode.InferenceEngine.inference_engine_factory import InferenceEngineFactory
|
|
235
|
+
return InferenceEngineFactory
|
|
236
|
+
except ImportError as e:
|
|
237
|
+
self.report_error(f"Failed to import InferenceEngineFactory: {e}")
|
|
238
|
+
return None
|
|
239
|
+
|
|
240
|
+
def _load_engine(self) -> bool:
|
|
241
|
+
"""Load or reload the inference engine based on current configuration."""
|
|
242
|
+
engine_type = self.config.get('engine_type', 'ultralytics')
|
|
243
|
+
model_path = self.config.get('model_path', '')
|
|
244
|
+
device = self.config.get('device', 'cpu')
|
|
245
|
+
|
|
246
|
+
# Check if we need to reload
|
|
247
|
+
needs_reload = (
|
|
248
|
+
not self._engine_loaded or
|
|
249
|
+
engine_type != self._current_engine_type or
|
|
250
|
+
model_path != self._current_model_path or
|
|
251
|
+
device != self._current_device
|
|
252
|
+
)
|
|
253
|
+
|
|
254
|
+
if not needs_reload and self.engine is not None:
|
|
255
|
+
return True
|
|
256
|
+
|
|
257
|
+
# Validate model path
|
|
258
|
+
if not model_path:
|
|
259
|
+
# For some engines like ultralytics, allow auto-download of default models
|
|
260
|
+
if engine_type == 'ultralytics':
|
|
261
|
+
model_path = 'yolov8n.pt' # Default to nano model
|
|
262
|
+
self.config['model_path'] = model_path
|
|
263
|
+
else:
|
|
264
|
+
self.report_error("No model file specified")
|
|
265
|
+
return False
|
|
266
|
+
|
|
267
|
+
# Get the factory
|
|
268
|
+
factory = self._get_engine_factory()
|
|
269
|
+
if factory is None:
|
|
270
|
+
return False
|
|
271
|
+
|
|
272
|
+
try:
|
|
273
|
+
# Create the engine instance
|
|
274
|
+
logger.info(f"Creating {engine_type} engine with model: {model_path}, device: {device}")
|
|
275
|
+
self.engine = factory.create(
|
|
276
|
+
engine_type=engine_type,
|
|
277
|
+
model_path=model_path,
|
|
278
|
+
device=device
|
|
279
|
+
)
|
|
280
|
+
|
|
281
|
+
# Load the model
|
|
282
|
+
if not self.engine.load(model_path, device):
|
|
283
|
+
self.report_error(f"Failed to load model: {model_path}")
|
|
284
|
+
self.engine = None
|
|
285
|
+
self._engine_loaded = False
|
|
286
|
+
return False
|
|
287
|
+
|
|
288
|
+
# Update state
|
|
289
|
+
self._engine_loaded = True
|
|
290
|
+
self._current_engine_type = engine_type
|
|
291
|
+
self._current_model_path = model_path
|
|
292
|
+
self._current_device = device
|
|
293
|
+
|
|
294
|
+
logger.info(f"Successfully loaded {engine_type} engine on {device}")
|
|
295
|
+
return True
|
|
296
|
+
|
|
297
|
+
except Exception as e:
|
|
298
|
+
error_msg = f"Failed to create/load engine: {e}"
|
|
299
|
+
logger.error(error_msg)
|
|
300
|
+
self.report_error(error_msg)
|
|
301
|
+
self.engine = None
|
|
302
|
+
self._engine_loaded = False
|
|
303
|
+
return False
|
|
304
|
+
|
|
305
|
+
def configure(self, config: Dict[str, Any]):
|
|
306
|
+
"""Override configure to reload engine when configuration changes."""
|
|
307
|
+
old_engine_type = self.config.get('engine_type') if hasattr(self, 'config') else None
|
|
308
|
+
old_model_path = self.config.get('model_path') if hasattr(self, 'config') else None
|
|
309
|
+
old_device = self.config.get('device') if hasattr(self, 'config') else None
|
|
310
|
+
|
|
311
|
+
super().configure(config)
|
|
312
|
+
|
|
313
|
+
new_engine_type = self.config.get('engine_type')
|
|
314
|
+
new_model_path = self.config.get('model_path')
|
|
315
|
+
new_device = self.config.get('device')
|
|
316
|
+
|
|
317
|
+
# Check if engine-related config changed
|
|
318
|
+
if (old_engine_type != new_engine_type or
|
|
319
|
+
old_model_path != new_model_path or
|
|
320
|
+
old_device != new_device):
|
|
321
|
+
# Mark for reload on next inference
|
|
322
|
+
if old_engine_type is not None: # Only if not initial setup
|
|
323
|
+
self._engine_loaded = False
|
|
324
|
+
|
|
325
|
+
def get_engine_info(self) -> Dict[str, Any]:
|
|
326
|
+
"""Get information about the current engine state."""
|
|
327
|
+
if self.engine is None:
|
|
328
|
+
return {
|
|
329
|
+
'loaded': False,
|
|
330
|
+
'engine_type': self.config.get('engine_type'),
|
|
331
|
+
'model_path': self.config.get('model_path'),
|
|
332
|
+
'device': self.config.get('device')
|
|
333
|
+
}
|
|
334
|
+
|
|
335
|
+
info = self.engine.get_info()
|
|
336
|
+
info['loaded'] = self._engine_loaded
|
|
337
|
+
return info
|
|
338
|
+
|
|
339
|
+
def on_input(self, msg: Dict[str, Any], input_index: int = 0):
|
|
340
|
+
"""
|
|
341
|
+
Process incoming image messages and perform inference.
|
|
342
|
+
"""
|
|
343
|
+
# Lazy load engine on first use
|
|
344
|
+
if not self._engine_loaded:
|
|
345
|
+
if not self._load_engine():
|
|
346
|
+
error_msg = "Engine not loaded, skipping inference"
|
|
347
|
+
self.report_error(error_msg)
|
|
348
|
+
return
|
|
349
|
+
|
|
350
|
+
if self.engine is None:
|
|
351
|
+
error_msg = "Engine not available, skipping inference"
|
|
352
|
+
self.report_error(error_msg)
|
|
353
|
+
return
|
|
354
|
+
|
|
355
|
+
# Get image from message
|
|
356
|
+
payload = msg.get(MessageKeys.PAYLOAD)
|
|
357
|
+
if payload is None:
|
|
358
|
+
error_msg = "No payload in message"
|
|
359
|
+
self.report_error(error_msg)
|
|
360
|
+
return
|
|
361
|
+
|
|
362
|
+
# Decode image using base node helper
|
|
363
|
+
image, input_format = self.decode_image(payload)
|
|
364
|
+
|
|
365
|
+
if image is None or input_format is None:
|
|
366
|
+
error_msg = "Failed to decode image from payload"
|
|
367
|
+
self.report_error(error_msg)
|
|
368
|
+
return
|
|
369
|
+
|
|
370
|
+
try:
|
|
371
|
+
# Perform inference
|
|
372
|
+
results = self.engine.infer(image)
|
|
373
|
+
|
|
374
|
+
# Check for inference errors
|
|
375
|
+
if isinstance(results, dict) and results.get('success') is False:
|
|
376
|
+
error_msg = f"Inference failed: {results.get('error', 'Unknown error')}"
|
|
377
|
+
self.report_error(error_msg)
|
|
378
|
+
return
|
|
379
|
+
|
|
380
|
+
# Get configuration options
|
|
381
|
+
draw_results = self.get_config_bool('draw_results', True)
|
|
382
|
+
include_image = self.config.get('include_image', True)
|
|
383
|
+
include_predictions = self.config.get('include_predictions', True)
|
|
384
|
+
|
|
385
|
+
# Prepare output image
|
|
386
|
+
output_image = image
|
|
387
|
+
if draw_results:
|
|
388
|
+
try:
|
|
389
|
+
output_image = self.engine.draw(image.copy(), results)
|
|
390
|
+
except Exception as e:
|
|
391
|
+
logger.warning(f"Failed to draw results: {e}")
|
|
392
|
+
output_image = image
|
|
393
|
+
|
|
394
|
+
# Convert results to JSON format
|
|
395
|
+
try:
|
|
396
|
+
json_results = self.engine.result_to_json(results, output_format="dict")
|
|
397
|
+
except Exception as e:
|
|
398
|
+
logger.warning(f"Failed to convert results to JSON: {e}")
|
|
399
|
+
json_results = {"predictions": [], "num_detections": 0}
|
|
400
|
+
|
|
401
|
+
# Build output payload
|
|
402
|
+
payload_out = {}
|
|
403
|
+
|
|
404
|
+
if include_image:
|
|
405
|
+
# Encode image back to same format as input using base node helper
|
|
406
|
+
encoded_image = self.encode_image(output_image, input_format)
|
|
407
|
+
if encoded_image is not None:
|
|
408
|
+
payload_out[MessageKeys.IMAGE.PATH] = encoded_image
|
|
409
|
+
else:
|
|
410
|
+
self.report_error("Failed to encode output image")
|
|
411
|
+
return
|
|
412
|
+
|
|
413
|
+
if include_predictions:
|
|
414
|
+
# Extract predictions from json_results
|
|
415
|
+
if isinstance(json_results, dict):
|
|
416
|
+
payload_out['detections'] = json_results.get('predictions', [])
|
|
417
|
+
payload_out['detection_count'] = json_results.get('num_detections', 0)
|
|
418
|
+
payload_out['task_type'] = self._standardize_task_string(json_results.get('task_type', 'detections'))
|
|
419
|
+
payload_out['bbox_format'] = 'xyxy'
|
|
420
|
+
else:
|
|
421
|
+
payload_out['detections'] = []
|
|
422
|
+
payload_out['detection_count'] = 0
|
|
423
|
+
|
|
424
|
+
# Add engine info to payload
|
|
425
|
+
payload_out['engine_type'] = self._current_engine_type
|
|
426
|
+
payload_out['device'] = self._current_device
|
|
427
|
+
|
|
428
|
+
# Preserve original message properties and update payload
|
|
429
|
+
msg[MessageKeys.PAYLOAD] = payload_out
|
|
430
|
+
msg[MessageKeys.TOPIC] = msg.get(MessageKeys.TOPIC, 'inference')
|
|
431
|
+
|
|
432
|
+
# Send the message
|
|
433
|
+
self.send(msg)
|
|
434
|
+
|
|
435
|
+
except Exception as e:
|
|
436
|
+
import traceback
|
|
437
|
+
error_msg = f"Error during inference: {e}\n{traceback.format_exc()}"
|
|
438
|
+
logger.error(error_msg)
|
|
439
|
+
self.report_error(f"Error during inference: {e}")
|
|
440
|
+
|
|
441
|
+
def on_stop(self):
|
|
442
|
+
"""Clean up resources when node is stopped."""
|
|
443
|
+
super().on_stop()
|
|
444
|
+
self.engine = None
|
|
445
|
+
self._engine_loaded = False
|
|
446
|
+
|
|
447
|
+
def to_dict(self) -> Dict[str, Any]:
|
|
448
|
+
"""Serialize node to dictionary for API/storage."""
|
|
449
|
+
data = super().to_dict()
|
|
450
|
+
data['engineInfo'] = self.get_engine_info()
|
|
451
|
+
return data
|