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,278 @@
|
|
|
1
|
+
"""
|
|
2
|
+
Geti Upload Node - uploads images to an Intel Geti platform project for annotation.
|
|
3
|
+
"""
|
|
4
|
+
|
|
5
|
+
import base64
|
|
6
|
+
import logging
|
|
7
|
+
import threading
|
|
8
|
+
from typing import Any, Dict, Optional
|
|
9
|
+
import numpy as np
|
|
10
|
+
import cv2
|
|
11
|
+
|
|
12
|
+
from pynode.nodes.base_node import BaseNode, Info, MessageKeys
|
|
13
|
+
|
|
14
|
+
logger = logging.getLogger(__name__)
|
|
15
|
+
|
|
16
|
+
_info = Info()
|
|
17
|
+
_info.add_text("Uploads images to an Intel Geti platform project for annotation and training.")
|
|
18
|
+
_info.add_header("Inputs")
|
|
19
|
+
_info.add_bullets(
|
|
20
|
+
("Input 0:", "Message containing an image in any supported format (numpy array, base64 JPEG, camera dict).")
|
|
21
|
+
)
|
|
22
|
+
_info.add_header("Outputs")
|
|
23
|
+
_info.add_bullets(
|
|
24
|
+
("Output 0:", "The original message is passed through after upload.")
|
|
25
|
+
)
|
|
26
|
+
_info.add_header("Properties")
|
|
27
|
+
_info.add_bullets(
|
|
28
|
+
("Host:", "URL of the Geti server (e.g. https://geti.example.com)."),
|
|
29
|
+
("Token:", "Personal access token from the Geti user menu."),
|
|
30
|
+
("Project Name:", "Name of the target project (or use Project ID)."),
|
|
31
|
+
("Project ID:", "UUID of the target project (or use Project Name)."),
|
|
32
|
+
("Dataset Name:", "Optional dataset within the project. Uses the training dataset if empty."),
|
|
33
|
+
("Verify SSL:", "Whether to verify SSL certificates for HTTPS connections."),
|
|
34
|
+
("Rate Limit:", "Minimum seconds between uploads (0 = no limit).")
|
|
35
|
+
)
|
|
36
|
+
_info.add_header("Notes")
|
|
37
|
+
_info.add_text("Requires the geti-sdk package. The node connects to Geti when the workflow starts and disconnects when it stops.")
|
|
38
|
+
|
|
39
|
+
|
|
40
|
+
class GetiUploadNode(BaseNode):
|
|
41
|
+
"""Uploads images to Intel Geti for annotation."""
|
|
42
|
+
|
|
43
|
+
display_name = 'Geti Upload'
|
|
44
|
+
icon = '\u2B06'
|
|
45
|
+
category = 'output'
|
|
46
|
+
color = '#4A90D9'
|
|
47
|
+
border_color = '#2E6BB0'
|
|
48
|
+
text_color = '#FFFFFF'
|
|
49
|
+
input_count = 1
|
|
50
|
+
output_count = 1
|
|
51
|
+
info = str(_info)
|
|
52
|
+
|
|
53
|
+
DEFAULT_CONFIG = {
|
|
54
|
+
'host': '',
|
|
55
|
+
'token': '',
|
|
56
|
+
'project_name': '',
|
|
57
|
+
'project_id': '',
|
|
58
|
+
'dataset_name': '',
|
|
59
|
+
'verify_certificate': False,
|
|
60
|
+
'rate_limit': 0,
|
|
61
|
+
MessageKeys.DROP_MESSAGES: True
|
|
62
|
+
}
|
|
63
|
+
|
|
64
|
+
properties = [
|
|
65
|
+
{
|
|
66
|
+
'name': 'host',
|
|
67
|
+
'label': 'Geti Server Host',
|
|
68
|
+
'type': 'text',
|
|
69
|
+
'default': '',
|
|
70
|
+
'placeholder': 'https://your_geti_server.com',
|
|
71
|
+
'help': 'URL or IP address of the Geti server'
|
|
72
|
+
},
|
|
73
|
+
{
|
|
74
|
+
'name': 'token',
|
|
75
|
+
'label': 'Personal Access Token',
|
|
76
|
+
'type': 'text',
|
|
77
|
+
'default': '',
|
|
78
|
+
'placeholder': 'Your Geti personal access token',
|
|
79
|
+
'help': 'Personal access token from Geti user menu'
|
|
80
|
+
},
|
|
81
|
+
{
|
|
82
|
+
'name': 'project_name',
|
|
83
|
+
'label': 'Project Name',
|
|
84
|
+
'type': 'text',
|
|
85
|
+
'default': '',
|
|
86
|
+
'placeholder': 'e.g. my-detection-project',
|
|
87
|
+
'help': 'Name of the Geti project (use this or Project ID)'
|
|
88
|
+
},
|
|
89
|
+
{
|
|
90
|
+
'name': 'project_id',
|
|
91
|
+
'label': 'Project ID',
|
|
92
|
+
'type': 'text',
|
|
93
|
+
'default': '',
|
|
94
|
+
'placeholder': 'e.g. 12345678-1234-...',
|
|
95
|
+
'help': 'UUID of the Geti project (use this or Project Name)'
|
|
96
|
+
},
|
|
97
|
+
{
|
|
98
|
+
'name': 'dataset_name',
|
|
99
|
+
'label': 'Dataset Name',
|
|
100
|
+
'type': 'text',
|
|
101
|
+
'default': '',
|
|
102
|
+
'placeholder': 'e.g. inference-data',
|
|
103
|
+
'help': 'Dataset within the project (optional, uses training dataset if empty)'
|
|
104
|
+
},
|
|
105
|
+
{
|
|
106
|
+
'name': 'verify_certificate',
|
|
107
|
+
'label': 'Verify SSL Certificate',
|
|
108
|
+
'type': 'checkbox',
|
|
109
|
+
'default': False,
|
|
110
|
+
'help': 'Verify SSL certificates for HTTPS connections'
|
|
111
|
+
},
|
|
112
|
+
{
|
|
113
|
+
'name': 'rate_limit',
|
|
114
|
+
'label': 'Rate Limit (seconds)',
|
|
115
|
+
'type': 'number',
|
|
116
|
+
'default': 0,
|
|
117
|
+
'min': 0,
|
|
118
|
+
'help': 'Minimum seconds between uploads (0 = no limit)'
|
|
119
|
+
},
|
|
120
|
+
{
|
|
121
|
+
'name': MessageKeys.DROP_MESSAGES,
|
|
122
|
+
'label': 'Drop Messages When Busy',
|
|
123
|
+
'type': 'checkbox',
|
|
124
|
+
'default': True
|
|
125
|
+
}
|
|
126
|
+
]
|
|
127
|
+
|
|
128
|
+
def __init__(self, node_id=None, name="geti upload"):
|
|
129
|
+
super().__init__(node_id, name)
|
|
130
|
+
self._geti_client = None
|
|
131
|
+
self._image_client = None
|
|
132
|
+
self._project = None
|
|
133
|
+
self._dataset = None
|
|
134
|
+
self._last_upload_time = 0.0
|
|
135
|
+
self._lock = threading.Lock()
|
|
136
|
+
|
|
137
|
+
def on_start(self):
|
|
138
|
+
"""Connect to Geti when the workflow starts."""
|
|
139
|
+
super().on_start()
|
|
140
|
+
self._connect()
|
|
141
|
+
|
|
142
|
+
def on_stop(self):
|
|
143
|
+
"""Disconnect from Geti when the workflow stops."""
|
|
144
|
+
self._disconnect()
|
|
145
|
+
super().on_stop()
|
|
146
|
+
|
|
147
|
+
def configure(self, config: Dict[str, Any]):
|
|
148
|
+
"""Reconnect if configuration changes while running."""
|
|
149
|
+
super().configure(config)
|
|
150
|
+
|
|
151
|
+
def _connect(self):
|
|
152
|
+
"""Establish connection to the Geti platform."""
|
|
153
|
+
host = self.config.get('host', '').strip()
|
|
154
|
+
token = self.config.get('token', '').strip()
|
|
155
|
+
project_name = self.config.get('project_name', '').strip()
|
|
156
|
+
project_id = self.config.get('project_id', '').strip()
|
|
157
|
+
dataset_name = self.config.get('dataset_name', '').strip()
|
|
158
|
+
verify_cert = self.get_config_bool('verify_certificate', False)
|
|
159
|
+
|
|
160
|
+
if not host or not token:
|
|
161
|
+
self.report_error("Geti host and token are required")
|
|
162
|
+
return
|
|
163
|
+
|
|
164
|
+
if not project_name and not project_id:
|
|
165
|
+
self.report_error("Either Project Name or Project ID must be specified")
|
|
166
|
+
return
|
|
167
|
+
|
|
168
|
+
try:
|
|
169
|
+
from geti_sdk import Geti
|
|
170
|
+
from geti_sdk.rest_clients import ProjectClient, ImageClient, DatasetClient
|
|
171
|
+
except ImportError:
|
|
172
|
+
self.report_error("geti-sdk package not installed. Install with: pip install geti-sdk")
|
|
173
|
+
return
|
|
174
|
+
|
|
175
|
+
try:
|
|
176
|
+
self._geti_client = Geti(
|
|
177
|
+
host=host,
|
|
178
|
+
token=token,
|
|
179
|
+
verify_certificate=verify_cert
|
|
180
|
+
)
|
|
181
|
+
|
|
182
|
+
project_client = ProjectClient(
|
|
183
|
+
session=self._geti_client.session,
|
|
184
|
+
workspace_id=self._geti_client.workspace_id
|
|
185
|
+
)
|
|
186
|
+
|
|
187
|
+
# Find project by name or ID
|
|
188
|
+
if project_name:
|
|
189
|
+
self._project = project_client.get_project_by_name(project_name)
|
|
190
|
+
else:
|
|
191
|
+
self._project = project_client.get_project_by_id(project_id)
|
|
192
|
+
|
|
193
|
+
if self._project is None:
|
|
194
|
+
self.report_error("Could not find the specified Geti project")
|
|
195
|
+
return
|
|
196
|
+
|
|
197
|
+
self._image_client = ImageClient(
|
|
198
|
+
session=self._geti_client.session,
|
|
199
|
+
workspace_id=self._geti_client.workspace_id,
|
|
200
|
+
project=self._project
|
|
201
|
+
)
|
|
202
|
+
|
|
203
|
+
# Resolve dataset if specified
|
|
204
|
+
self._dataset = None
|
|
205
|
+
if dataset_name:
|
|
206
|
+
try:
|
|
207
|
+
dataset_client = DatasetClient(
|
|
208
|
+
session=self._geti_client.session,
|
|
209
|
+
workspace_id=self._geti_client.workspace_id,
|
|
210
|
+
project=self._project
|
|
211
|
+
)
|
|
212
|
+
self._dataset = dataset_client.get_dataset_by_name(dataset_name)
|
|
213
|
+
except Exception as e:
|
|
214
|
+
self.report_error(f"Dataset '{dataset_name}' not found, using training dataset: {e}")
|
|
215
|
+
|
|
216
|
+
proj_label = getattr(self._project, 'name', None) or project_id
|
|
217
|
+
logger.info(f"[GetiUploadNode] Connected to {host} -> {proj_label}")
|
|
218
|
+
|
|
219
|
+
except Exception as e:
|
|
220
|
+
self.report_error(f"Geti connection failed: {e}")
|
|
221
|
+
self._geti_client = None
|
|
222
|
+
self._image_client = None
|
|
223
|
+
self._project = None
|
|
224
|
+
|
|
225
|
+
def _disconnect(self):
|
|
226
|
+
"""Close the Geti connection."""
|
|
227
|
+
if self._geti_client:
|
|
228
|
+
try:
|
|
229
|
+
self._geti_client.logout()
|
|
230
|
+
except Exception:
|
|
231
|
+
pass
|
|
232
|
+
finally:
|
|
233
|
+
self._geti_client = None
|
|
234
|
+
self._image_client = None
|
|
235
|
+
self._project = None
|
|
236
|
+
self._dataset = None
|
|
237
|
+
|
|
238
|
+
def on_input(self, msg: Dict[str, Any], input_index: int = 0):
|
|
239
|
+
"""Decode image from message and upload to Geti."""
|
|
240
|
+
if not self._image_client or not self._project:
|
|
241
|
+
self.report_error("Not connected to Geti (check configuration)")
|
|
242
|
+
self.send(msg)
|
|
243
|
+
return
|
|
244
|
+
|
|
245
|
+
# Rate limiting
|
|
246
|
+
rate_limit = self.get_config_float('rate_limit', 0)
|
|
247
|
+
if rate_limit > 0:
|
|
248
|
+
import time
|
|
249
|
+
now = time.time()
|
|
250
|
+
with self._lock:
|
|
251
|
+
if now - self._last_upload_time < rate_limit:
|
|
252
|
+
self.send(msg)
|
|
253
|
+
return
|
|
254
|
+
self._last_upload_time = now
|
|
255
|
+
|
|
256
|
+
# Extract and decode image
|
|
257
|
+
payload = msg.get(MessageKeys.PAYLOAD)
|
|
258
|
+
if payload is None:
|
|
259
|
+
self.report_error("No payload in message")
|
|
260
|
+
self.send(msg)
|
|
261
|
+
return
|
|
262
|
+
|
|
263
|
+
image, _ = self.decode_image(payload)
|
|
264
|
+
if image is None:
|
|
265
|
+
self.report_error("Could not decode image from message payload")
|
|
266
|
+
self.send(msg)
|
|
267
|
+
return
|
|
268
|
+
|
|
269
|
+
# Upload
|
|
270
|
+
try:
|
|
271
|
+
self._image_client.upload_image(
|
|
272
|
+
image=image,
|
|
273
|
+
dataset=self._dataset
|
|
274
|
+
)
|
|
275
|
+
except Exception as e:
|
|
276
|
+
self.report_error(f"Geti upload failed: {e}")
|
|
277
|
+
|
|
278
|
+
self.send(msg)
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
geti-sdk>=2.0.0
|
|
@@ -0,0 +1,310 @@
|
|
|
1
|
+
"""
|
|
2
|
+
Image Format Node - converts between numpy arrays and base64 encoded images.
|
|
3
|
+
Supports automatic detection and manual mode selection.
|
|
4
|
+
"""
|
|
5
|
+
|
|
6
|
+
import base64
|
|
7
|
+
import copy
|
|
8
|
+
import cv2
|
|
9
|
+
import numpy as np
|
|
10
|
+
from typing import Any, Dict
|
|
11
|
+
from pynode.nodes.base_node import BaseNode, Info, MessageKeys
|
|
12
|
+
|
|
13
|
+
_info = Info()
|
|
14
|
+
_info.add_text("Converts image data between numpy arrays and base64 encoded images. Supports automatic format detection.")
|
|
15
|
+
_info.add_header("Inputs")
|
|
16
|
+
_info.add_bullets(
|
|
17
|
+
("Input 0:", "Message with image data at the configured data path.")
|
|
18
|
+
)
|
|
19
|
+
_info.add_header("Outputs")
|
|
20
|
+
_info.add_bullets(
|
|
21
|
+
("Output 0:", "Message with converted image data.")
|
|
22
|
+
)
|
|
23
|
+
_info.add_header("Conversion Modes")
|
|
24
|
+
_info.add_bullets(
|
|
25
|
+
("Auto Detect:", "Automatically detect source format and convert."),
|
|
26
|
+
("Numpy to Base64:", "Convert numpy array to base64 JPEG/PNG string."),
|
|
27
|
+
("Base64 to Numpy:", "Decode base64 string to numpy array (BGR format)."),
|
|
28
|
+
("Binary to Numpy:", "Decode raw image bytes (e.g. from HTTP response) to numpy array."),
|
|
29
|
+
("Binary to Base64:", "Re-encode raw image bytes as base64 string.")
|
|
30
|
+
)
|
|
31
|
+
_info.add_header("Image Formats")
|
|
32
|
+
_info.add_bullets(
|
|
33
|
+
("JPEG:", "Lossy compression, smaller size, configurable quality."),
|
|
34
|
+
("PNG:", "Lossless compression, larger size, preserves all data.")
|
|
35
|
+
)
|
|
36
|
+
|
|
37
|
+
|
|
38
|
+
class ImageFormatNode(BaseNode):
|
|
39
|
+
"""
|
|
40
|
+
Image Format node - converts between numpy arrays and base64 encoded images.
|
|
41
|
+
"""
|
|
42
|
+
display_name = 'Image Format'
|
|
43
|
+
icon = '🔄'
|
|
44
|
+
category = 'vision'
|
|
45
|
+
color = '#FFB6C1'
|
|
46
|
+
border_color = '#FF69B4'
|
|
47
|
+
text_color = '#000000'
|
|
48
|
+
input_count = 1
|
|
49
|
+
output_count = 1
|
|
50
|
+
info = str(_info)
|
|
51
|
+
|
|
52
|
+
DEFAULT_CONFIG = {
|
|
53
|
+
'mode': 'auto',
|
|
54
|
+
MessageKeys.IMAGE.FORMAT: 'jpeg',
|
|
55
|
+
MessageKeys.IMAGE.JPEG_QUALITY: 85,
|
|
56
|
+
'data_path': f'{MessageKeys.PAYLOAD}.{MessageKeys.IMAGE.PATH}'
|
|
57
|
+
}
|
|
58
|
+
|
|
59
|
+
properties = [
|
|
60
|
+
{
|
|
61
|
+
'name': 'mode',
|
|
62
|
+
'label': 'Conversion Mode',
|
|
63
|
+
'type': 'select',
|
|
64
|
+
'options': [
|
|
65
|
+
{'value': 'auto', 'label': 'Auto Detect'},
|
|
66
|
+
{'value': 'to_base64', 'label': 'Numpy to Base64'},
|
|
67
|
+
{'value': 'to_numpy', 'label': 'Base64 to Numpy'},
|
|
68
|
+
{'value': 'bytes_to_numpy', 'label': 'Binary Buffer to Numpy'},
|
|
69
|
+
{'value': 'bytes_to_base64', 'label': 'Binary Buffer to Base64'}
|
|
70
|
+
],
|
|
71
|
+
'default': DEFAULT_CONFIG['mode']
|
|
72
|
+
},
|
|
73
|
+
{
|
|
74
|
+
'name': MessageKeys.IMAGE.FORMAT,
|
|
75
|
+
'label': 'Image Format',
|
|
76
|
+
'type': 'select',
|
|
77
|
+
'options': [
|
|
78
|
+
{'value': 'jpeg', 'label': 'JPEG'},
|
|
79
|
+
{'value': 'png', 'label': 'PNG'}
|
|
80
|
+
],
|
|
81
|
+
'default': DEFAULT_CONFIG[MessageKeys.IMAGE.FORMAT]
|
|
82
|
+
},
|
|
83
|
+
{
|
|
84
|
+
'name': MessageKeys.IMAGE.JPEG_QUALITY,
|
|
85
|
+
'label': 'JPEG Quality (1-100)',
|
|
86
|
+
'type': 'number',
|
|
87
|
+
'default': DEFAULT_CONFIG[MessageKeys.IMAGE.JPEG_QUALITY]
|
|
88
|
+
},
|
|
89
|
+
{
|
|
90
|
+
'name': 'data_path',
|
|
91
|
+
'label': 'Data Path',
|
|
92
|
+
'type': 'text',
|
|
93
|
+
'default': DEFAULT_CONFIG['data_path'],
|
|
94
|
+
'description': f'Dot-separated path to image data (e.g. {MessageKeys.PAYLOAD}.{MessageKeys.IMAGE.PATH})'
|
|
95
|
+
}
|
|
96
|
+
]
|
|
97
|
+
|
|
98
|
+
def __init__(self, node_id=None, name="image format"):
|
|
99
|
+
super().__init__(node_id, name)
|
|
100
|
+
|
|
101
|
+
def on_input(self, msg: Dict[str, Any], input_index: int = 0):
|
|
102
|
+
"""
|
|
103
|
+
Convert image data between numpy array and base64.
|
|
104
|
+
"""
|
|
105
|
+
mode = self.config.get('mode', 'auto')
|
|
106
|
+
data_path = self.config.get('data_path', MessageKeys.PAYLOAD)
|
|
107
|
+
|
|
108
|
+
data = self._get_nested_value(msg, data_path)
|
|
109
|
+
|
|
110
|
+
if data is None:
|
|
111
|
+
self.report_error(f"No data found at path '{data_path}'")
|
|
112
|
+
return
|
|
113
|
+
|
|
114
|
+
# Auto-detect mode
|
|
115
|
+
if mode == 'auto':
|
|
116
|
+
if isinstance(data, np.ndarray):
|
|
117
|
+
mode = 'to_base64'
|
|
118
|
+
elif isinstance(data, (bytes, bytearray)):
|
|
119
|
+
mode = 'bytes_to_numpy'
|
|
120
|
+
elif isinstance(data, dict) and data.get(MessageKeys.IMAGE.ENCODING) == 'base64':
|
|
121
|
+
mode = 'to_numpy'
|
|
122
|
+
elif isinstance(data, str):
|
|
123
|
+
mode = 'to_numpy'
|
|
124
|
+
else:
|
|
125
|
+
self.report_error(f"Cannot auto-detect conversion mode for type: {type(data)}")
|
|
126
|
+
return
|
|
127
|
+
|
|
128
|
+
# Perform conversion
|
|
129
|
+
try:
|
|
130
|
+
output_msg = copy.deepcopy(msg)
|
|
131
|
+
|
|
132
|
+
# Get the target object where we'll update fields
|
|
133
|
+
def get_parent_and_key(obj, path):
|
|
134
|
+
parts = path.split('.')
|
|
135
|
+
if len(parts) == 1:
|
|
136
|
+
return obj, parts[0]
|
|
137
|
+
for part in parts[:-1]:
|
|
138
|
+
if part not in obj or not isinstance(obj[part], dict):
|
|
139
|
+
obj[part] = {}
|
|
140
|
+
obj = obj[part]
|
|
141
|
+
return obj, parts[-1]
|
|
142
|
+
|
|
143
|
+
parent, key = get_parent_and_key(output_msg, data_path)
|
|
144
|
+
|
|
145
|
+
if mode == 'to_base64':
|
|
146
|
+
# Get the numpy array from the data
|
|
147
|
+
if isinstance(data, dict) and MessageKeys.IMAGE.DATA in data:
|
|
148
|
+
numpy_data = data[MessageKeys.IMAGE.DATA]
|
|
149
|
+
else:
|
|
150
|
+
numpy_data = data
|
|
151
|
+
|
|
152
|
+
# Convert to base64
|
|
153
|
+
converted = self._numpy_to_base64(numpy_data)
|
|
154
|
+
|
|
155
|
+
# Update the target dict in place if it exists and has the right structure
|
|
156
|
+
if key in parent and isinstance(parent[key], dict):
|
|
157
|
+
parent[key][MessageKeys.IMAGE.FORMAT] = converted[MessageKeys.IMAGE.FORMAT]
|
|
158
|
+
parent[key][MessageKeys.IMAGE.ENCODING] = converted[MessageKeys.IMAGE.ENCODING]
|
|
159
|
+
parent[key][MessageKeys.IMAGE.DATA] = converted[MessageKeys.IMAGE.DATA]
|
|
160
|
+
parent[key][MessageKeys.IMAGE.WIDTH] = converted[MessageKeys.IMAGE.WIDTH]
|
|
161
|
+
parent[key][MessageKeys.IMAGE.HEIGHT] = converted[MessageKeys.IMAGE.HEIGHT]
|
|
162
|
+
else:
|
|
163
|
+
parent[key] = converted
|
|
164
|
+
|
|
165
|
+
elif mode == 'to_numpy':
|
|
166
|
+
# Convert to numpy
|
|
167
|
+
numpy_array = self._base64_to_numpy(data)
|
|
168
|
+
|
|
169
|
+
# Update the target dict in place if it exists
|
|
170
|
+
if key in parent and isinstance(parent[key], dict):
|
|
171
|
+
parent[key][MessageKeys.IMAGE.FORMAT] = 'bgr'
|
|
172
|
+
parent[key][MessageKeys.IMAGE.ENCODING] = 'numpy'
|
|
173
|
+
parent[key][MessageKeys.IMAGE.DATA] = numpy_array
|
|
174
|
+
parent[key][MessageKeys.IMAGE.WIDTH] = numpy_array.shape[1]
|
|
175
|
+
parent[key][MessageKeys.IMAGE.HEIGHT] = numpy_array.shape[0]
|
|
176
|
+
else:
|
|
177
|
+
parent[key] = {
|
|
178
|
+
MessageKeys.IMAGE.FORMAT: 'bgr',
|
|
179
|
+
MessageKeys.IMAGE.ENCODING: 'numpy',
|
|
180
|
+
MessageKeys.IMAGE.DATA: numpy_array,
|
|
181
|
+
MessageKeys.IMAGE.WIDTH: numpy_array.shape[1],
|
|
182
|
+
MessageKeys.IMAGE.HEIGHT: numpy_array.shape[0]
|
|
183
|
+
}
|
|
184
|
+
elif mode == 'bytes_to_numpy':
|
|
185
|
+
raw = self._extract_bytes(data)
|
|
186
|
+
numpy_array = self._bytes_to_numpy(raw)
|
|
187
|
+
|
|
188
|
+
if key in parent and isinstance(parent[key], dict):
|
|
189
|
+
parent[key][MessageKeys.IMAGE.FORMAT] = 'bgr'
|
|
190
|
+
parent[key][MessageKeys.IMAGE.ENCODING] = 'numpy'
|
|
191
|
+
parent[key][MessageKeys.IMAGE.DATA] = numpy_array
|
|
192
|
+
parent[key][MessageKeys.IMAGE.WIDTH] = numpy_array.shape[1]
|
|
193
|
+
parent[key][MessageKeys.IMAGE.HEIGHT] = numpy_array.shape[0]
|
|
194
|
+
else:
|
|
195
|
+
parent[key] = {
|
|
196
|
+
MessageKeys.IMAGE.FORMAT: 'bgr',
|
|
197
|
+
MessageKeys.IMAGE.ENCODING: 'numpy',
|
|
198
|
+
MessageKeys.IMAGE.DATA: numpy_array,
|
|
199
|
+
MessageKeys.IMAGE.WIDTH: numpy_array.shape[1],
|
|
200
|
+
MessageKeys.IMAGE.HEIGHT: numpy_array.shape[0]
|
|
201
|
+
}
|
|
202
|
+
|
|
203
|
+
elif mode == 'bytes_to_base64':
|
|
204
|
+
raw = self._extract_bytes(data)
|
|
205
|
+
converted = self._bytes_to_base64(raw)
|
|
206
|
+
|
|
207
|
+
if key in parent and isinstance(parent[key], dict):
|
|
208
|
+
parent[key][MessageKeys.IMAGE.FORMAT] = converted[MessageKeys.IMAGE.FORMAT]
|
|
209
|
+
parent[key][MessageKeys.IMAGE.ENCODING] = converted[MessageKeys.IMAGE.ENCODING]
|
|
210
|
+
parent[key][MessageKeys.IMAGE.DATA] = converted[MessageKeys.IMAGE.DATA]
|
|
211
|
+
parent[key][MessageKeys.IMAGE.WIDTH] = converted[MessageKeys.IMAGE.WIDTH]
|
|
212
|
+
parent[key][MessageKeys.IMAGE.HEIGHT] = converted[MessageKeys.IMAGE.HEIGHT]
|
|
213
|
+
else:
|
|
214
|
+
parent[key] = converted
|
|
215
|
+
|
|
216
|
+
else:
|
|
217
|
+
self.report_error(f"Unknown mode: {mode}")
|
|
218
|
+
return
|
|
219
|
+
|
|
220
|
+
self.send(output_msg)
|
|
221
|
+
|
|
222
|
+
except Exception as e:
|
|
223
|
+
self.report_error(f"Conversion error: {e}")
|
|
224
|
+
|
|
225
|
+
def _numpy_to_base64(self, image: np.ndarray) -> Dict[str, Any]:
|
|
226
|
+
"""Convert numpy array to base64 encoded image."""
|
|
227
|
+
if not isinstance(image, np.ndarray):
|
|
228
|
+
raise ValueError(f"Expected numpy array, got {type(image)}")
|
|
229
|
+
|
|
230
|
+
img_format = self.config.get(MessageKeys.IMAGE.FORMAT, 'jpeg')
|
|
231
|
+
|
|
232
|
+
if img_format == 'jpeg':
|
|
233
|
+
quality = self.get_config_int(MessageKeys.IMAGE.JPEG_QUALITY, 85)
|
|
234
|
+
encode_params = [cv2.IMWRITE_JPEG_QUALITY, quality]
|
|
235
|
+
ret, buffer = cv2.imencode('.jpg', image, encode_params)
|
|
236
|
+
ext = 'jpeg'
|
|
237
|
+
elif img_format == 'png':
|
|
238
|
+
ret, buffer = cv2.imencode('.png', image)
|
|
239
|
+
ext = 'png'
|
|
240
|
+
else:
|
|
241
|
+
raise ValueError(f"Unsupported format: {img_format}")
|
|
242
|
+
|
|
243
|
+
if not ret:
|
|
244
|
+
raise RuntimeError("Failed to encode image")
|
|
245
|
+
|
|
246
|
+
# Convert to base64
|
|
247
|
+
img_base64 = base64.b64encode(buffer.tobytes()).decode('utf-8')
|
|
248
|
+
|
|
249
|
+
return {
|
|
250
|
+
MessageKeys.IMAGE.FORMAT: ext,
|
|
251
|
+
MessageKeys.IMAGE.ENCODING: 'base64',
|
|
252
|
+
MessageKeys.IMAGE.DATA: img_base64,
|
|
253
|
+
MessageKeys.IMAGE.WIDTH: image.shape[1],
|
|
254
|
+
MessageKeys.IMAGE.HEIGHT: image.shape[0]
|
|
255
|
+
}
|
|
256
|
+
|
|
257
|
+
def _extract_bytes(self, data: Any) -> bytes:
|
|
258
|
+
"""Extract raw bytes from various input shapes (bytes, dict with buffer/body)."""
|
|
259
|
+
if isinstance(data, (bytes, bytearray)):
|
|
260
|
+
return bytes(data)
|
|
261
|
+
if isinstance(data, dict):
|
|
262
|
+
# Support WebhookNode payload shape: {buffer: bytes, body: bytes}
|
|
263
|
+
for key in ('buffer', 'body', MessageKeys.IMAGE.DATA):
|
|
264
|
+
val = data.get(key)
|
|
265
|
+
if isinstance(val, (bytes, bytearray)):
|
|
266
|
+
return bytes(val)
|
|
267
|
+
raise ValueError(f"Cannot extract binary data from {type(data)}")
|
|
268
|
+
|
|
269
|
+
def _bytes_to_numpy(self, raw: bytes) -> np.ndarray:
|
|
270
|
+
"""Decode raw image bytes (JPEG/PNG/etc.) into a BGR numpy array."""
|
|
271
|
+
nparr = np.frombuffer(raw, np.uint8)
|
|
272
|
+
image = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
|
|
273
|
+
if image is None:
|
|
274
|
+
raise RuntimeError("Failed to decode binary image buffer")
|
|
275
|
+
return image
|
|
276
|
+
|
|
277
|
+
def _bytes_to_base64(self, raw: bytes) -> Dict[str, Any]:
|
|
278
|
+
"""Decode raw image bytes, re-encode to the configured format, and return base64."""
|
|
279
|
+
# Decode to numpy first so we can re-encode in the desired format/quality
|
|
280
|
+
image = self._bytes_to_numpy(raw)
|
|
281
|
+
return self._numpy_to_base64(image)
|
|
282
|
+
|
|
283
|
+
def _base64_to_numpy(self, data: Any) -> np.ndarray:
|
|
284
|
+
"""Convert base64 encoded image to numpy array."""
|
|
285
|
+
# Handle dict format
|
|
286
|
+
if isinstance(data, dict):
|
|
287
|
+
img_data = data.get(MessageKeys.IMAGE.DATA)
|
|
288
|
+
if img_data is None:
|
|
289
|
+
raise ValueError(f"No '{MessageKeys.IMAGE.DATA}' field in image dict")
|
|
290
|
+
# Handle raw base64 string
|
|
291
|
+
elif isinstance(data, str):
|
|
292
|
+
img_data = data
|
|
293
|
+
# Remove data URL prefix if present
|
|
294
|
+
if img_data.startswith(f'{MessageKeys.IMAGE.DATA}:{MessageKeys.IMAGE.PATH}'):
|
|
295
|
+
img_data = img_data.split(',')[1]
|
|
296
|
+
else:
|
|
297
|
+
raise ValueError(f"Cannot convert {type(data)} to numpy array")
|
|
298
|
+
|
|
299
|
+
# Decode base64
|
|
300
|
+
try:
|
|
301
|
+
img_bytes = base64.b64decode(img_data)
|
|
302
|
+
nparr = np.frombuffer(img_bytes, np.uint8)
|
|
303
|
+
image = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
|
|
304
|
+
|
|
305
|
+
if image is None:
|
|
306
|
+
raise RuntimeError("Failed to decode image")
|
|
307
|
+
|
|
308
|
+
return image
|
|
309
|
+
except Exception as e:
|
|
310
|
+
raise RuntimeError(f"Failed to decode base64 image: {e}")
|