package fixes and path additions

Author: wuestenarchitekten

LICENSE

@@ -0,0 +1,6 @@
+# Shared Use License
+
+This software in source and binary forms is owned by Derivative Inc. (Derivative) and can only be used, and/or modified for use, in conjunction with Derivative's TouchDesigner software, and only if you are a licensee who has accepted Derivative's TouchDesigner license or assignment agreement (which also govern the use of this software). You may share or redistribute a modified version of this software provided the following conditions are met:
+
+1. The shared files or redistribution must retain the information set out above and this list of conditions.
+2. Derivative's name (Derivative Inc.) or its trademarks may not be used to endorse or promote products derived from this software without specific prior written permission from Derivative.

TDOAK.toe

@@ -1,4 +1,4 @@
-from __future__ import annotations
+from __future__ import annotations
 
 # detection_input_pipeline.py — YOLO object detection on HOST frames (depthai v3)
 # Load into the Pipeline DAT parameter of the OAK component.
@@ -11,7 +11,7 @@
 #
 # Feed it once per frame from an Execute DAT:
 #   def onFrameStart(frame):
-#       op('TDOAK').ext.OAKManagerExt.SendFrame('image_in', op('moviefilein1'))
+#       op('TDOAK').SendFrame('image_in', op('moviefilein1'))
 #
 # Streams:
 #   'rgb'        — the letterboxed frame inference ran on (loops back from the device),

src/TDOAK/TDOAK.tox

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+# mono_depth_pipeline.py — monocular (single-camera) depth via MiDaS v2.1 (depthai v3)
+# Neural depth from ONE ordinary RGB camera — no stereo pair, no ToF.
+# Load into the Pipeline DAT parameter of the OAK component.
+#
+# REQUIRES the `depthai_nodes` package (provides ParsingNeuralNetwork, which resolves the
+# model from the Luxonis Model Zoo and parses its output for you).
+#
+# MiDaS v2.1 ships an RVC2 (Myriad X / OAK-D) build — unlike Depth-Anything, which is
+# RVC4-only and won't run on these devices.
+#
+# Streams:
+#   'rgb'   — BGR passthrough: the exact frame inference ran on (384x256), so the depth
+#             map below is pixel-aligned with it.
+#   'depth' — a depthai_nodes Map2D message. OAKManagerExt's built-in Map2D decoder turns
+#             it into a float32 (H, W) array, so a Script TOP bound to 'depth' fills
+#             automatically as a single-channel float TOP. Values are RELATIVE inverse
+#             depth (larger = nearer), NOT metric — normalize for display, e.g. divide by
+#             the frame's max in a Script TOP or with a Math/Normalize TOP downstream.
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import depthai as dai
+
+# Model Zoo slug + variant. Other RVC2 variants: 256x192 (faster), 288x512 / 384x512 (finer).
+MODEL: str = 'luxonis/midas-v2-1:small-384x256'
+
+
+def build(pipeline: dai.Pipeline) -> tuple[dict[str, dai.DataOutputQueue], list[str]]:
+    import depthai as dai
+    from depthai_nodes.node import ParsingNeuralNetwork
+
+    cam = pipeline.create(dai.node.Camera).build()
+    nn  = pipeline.create(ParsingNeuralNetwork).build(cam, MODEL)
+
+    queues: dict[str, dai.DataOutputQueue] = {
+        'rgb':   nn.passthrough.createOutputQueue(maxSize=1, blocking=False),
+        'depth': nn.out.createOutputQueue(maxSize=1, blocking=False),
+    }
+
+    return queues, ['rgb', 'depth']

src/TDOAK/TDOAKCamCtl.tox

@@ -0,0 +1,22 @@
+"""
+def parse(msg):
+	# WORKER THREAD — no op()/TD access. Decode the model's message into plain,
+	# thread-safe data (numpy array, or list/dict of primitives). Return None to skip.
+	return msg.getTensor("pose")        # or keypoints, clusters, segmentation, ...
+"""
+import numpy as np
+
+def fill(scriptOp, data):                 # data: list[PoseEntry]
+	# MAIN THREAD — full TD access, runs inside the operator's cook.
+	scriptOp.clear()
+	if not data:
+		scriptOp.copyNumpyArray(np.zeros((2, 17), dtype=np.float32))  # keep 2 ch, 0 samples
+		return
+	# Stack every person's keypoints as samples -> (P*17, 2)
+	kp = np.concatenate(
+		[np.asarray(p['keypoints'], dtype=np.float32) for p in data],
+		axis=0,
+		)
+	arr = np.ascontiguousarray(kp.T)        # (2, P*17): ch0 = x, ch1 = y
+	arr[1] = 1.0 - arr[1]                   # flip Y to match the flipud'd rgb display
+	scriptOp.copyNumpyArray(arr)            # -> channels chan1 (x), chan2 (y)

src/TDOAK/examples/detection_input_pipeline.py

@@ -0,0 +1,46 @@
+"""
+def parse(msg):
+	# WORKER THREAD — no op()/TD access. Decode the model's message into plain,
+	# thread-safe data (numpy array, or list/dict of primitives). Return None to skip.
+	return msg.getTensor("pose")        # or keypoints, clusters, segmentation, ...
+"""
+import numpy as np
+
+def fill(scriptOp, data):                 # data: list[PoseEntry]
+	# MAIN THREAD — full TD access, runs inside the operator's cook.
+	stagingData = scriptOp.createGeometryStagingData()
+
+	if not data:
+		scriptOp.buildGeometry(stagingData)
+		return
+	
+	stagingData.createPointAttrib(name='P')
+	# Stack every person's keypoints as samples -> (P*17, 2)
+
+	kp = np.concatenate(
+		[np.asarray(p['keypoints'], dtype=np.float32) for p in data],
+		axis=0,
+		)
+	
+	# this is of shape (n*17,2), but we need 3 coordinates per point
+	kp = np.pad(kp, ((0, 0), (0, 1)), mode='constant')
+	# flip y
+	kp[:, 1] = 1 - kp[:, 1]
+	stagingData.appendPointAttribValues('P', kp.tolist())
+
+	# now build the edges between the keypoints
+	# be careful, as we have to add 18 to every new detected array point indexes to account for more than 1 detection.
+	
+	edge_chunks = []
+	for i, p in enumerate(data):
+	    edges = np.asarray(p['edges'], dtype=np.float32)
+	    edges += i * 18
+	    edge_chunks.append(edges)
+	
+	edges = np.concatenate(edge_chunks, axis=0)
+
+	for e in edges:
+		stagingData.appendPrimLine(int(e[0]),int(e[1]))
+
+	scriptOp.buildGeometry(stagingData)
+