Release 2.7.2.0

v2.7.2.0

Update depthai dependency to 2.7.2.0

v1.0.0.0

Final release for Gen1 codebase.

v0.4.1.1

Fix for model downloader when there is space in path.
Moved open3d install as optional.
Added -fusb2 for calibration.
Switched to 400p stereo resolution by default.
Added orientation check in calibration.
Flip camera orientation for OAK-1 by default.
Removed deprecated CLI options.
Increased manual exposure limits.

Release 0.4.0.0

Included changes in the release:

[global]

• Ability to manually control focus and exposure of the RGB camera

[depthai-python]

• Wheels are prebuilt for Python 3.9, remove 3.5 support due to its EOL

[depthai-core]

• Fix watchdog recreation after device object deletion
• Add the ability to fetch USB speed and MyriadX serial number

Release 0.3.0.0

Hi all!
Yesterday we released a new DepthAI version - 0.3.0.0!

Changelog:

• Added color, rectified_left and rectitied_right streams (what is rectification?), together with an ability to run a NN on those streams
• Added median_kernel_size and lr_check options to depth pipeline config (you can use -med and -lrc flags in demo script to test them out)
• Added verbose output (-vv) to demo script which will print packets' metadata
• Added a Point Cloud Visualization (use -s rectified_right depth -pcl flags in demo script to preview)
• Added model downloader and removed all NN blobs from depthai repository - they are now downloaded when requested
• Fixed missing metadata for disparity, disparity_color and depth streams
• Fixed sequence number sync issue by adding a sync_sequence_numbers config option (you can test it by using the -seq flag with the demo script)
• Improved calibration system (ability to use two homography)
• Improved format of NN config file

Migrate from the previous release

The major change is related to the new NN config file format. There are now two inference modes: detection and raw, and you can skip the config file entirely, which will default to raw mode.

While in the raw mode, the DepthAI won't attempt to decode nn output tensor and send it directly to host, where you'll have to parse it manually.
As an example, take a look how age gender recognition handler has changed:

-    detections = []
-    for _, e in enumerate(nnet_packet.entries()):	
-        if e[1]["female"] > 0.8 or e[1]["male"] > 0.8:	
-            detections.append(e[0]["age"])  	
-            if e[1]["female"] > e[1]["male"]:	
-                detections.append("female")	
-            else:	
-                detections.append("male")	
-    return detections

+    output_list = nnet_packet.getOutputsList()
+    age_out = output_list[0]
+    age = age_out[0,0,0,0]
+    gender_out = output_list[1]
+    female_conf = gender_out[0,0,0,0]
+    male_conf = gender_out[0,1,0,0]
+
+    detection = None
+
+    conf_thr = 0.5
+    if female_conf > conf_thr or male_conf > conf_thr:
+        gender = "male"
+        if female_conf > male_conf:
+            gender = "female"
+        age = (int)(age*100)
+        detection = dict(gender=gender, age=age)
+    
+    return detection

While it looks more complex, it gives more freedom in using NN with custom outputs.

The other mode, detection, requires a config file to be in one of the following forms:

• MobilenetSSD-based
• YOLO-based

When using this mode, you can use the getDetectedObjects method, which will produce a Detection object

-        entries_prev = []
-        for e in nnet_packet.entries():	
-            if e[0]['id'] == -1.0 or e[0]['confidence'] == 0.0:	
-                break	
-            if e[0]['confidence'] > 0.5:	
-                entries_prev.append(e[0])
+        detections = list(nnet_packet.getDetectedObjects())

Next, you'll need to update places where you referenced the detection object to properly use the new format, just as the following

-            for i, e in enumerate(entries_prev):
-                left = int(e['left'] * img_w)
-                top = int(e['top'] * img_h)
-                right = int(e['right'] * img_w)
-                bottom = int(e['bottom'] * img_h)

+	     for detection in detections:
+                left = int(detection.x_min * img_w)
+                top = int(detection.y_min * img_h)
+                right = int(detection.x_max * img_w)
+                bottom = int(detection.y_max * img_h)

DepthAI - Release version 1.0.0

First DepthAI Release

Depthai documentation: https://docs.luxonis.com/

Release Notes:

• Calibration Improvements including checking for synchronization and displaying UI stacked.
• Cleanup of example scripts to allow running w/ -cnn option (see here for example usage).
• Fix example scripts to use the latest technique for using w/ and w/out depth (see examples, here).
• Enable configurable max distance threshold (configurable here)
• Option to enable bounding box on depth stream (use the -bb option).
• Timeout for sending neural results if grayscale cameras are not detected (e.g. if they are disconnected intentionally or unintentionally).
• Ability to run H.264 and/or H.265 encoding on color sensor alone. (See how to use here)
• Reduce resolution off of IMX378 to save resources (reduced from 4K to 1920x1080). Can go back up if of interest to anyone. We've since done further optimizations which make this not needed.
• macOS Support (see here)
• Ability to configure what portion of the bounding box is used for averaging depth (Z) and thereby X and Y locations. Configurable via padding_factor, here.
• Add capability to get the die temperatures off of DepthAI VPU. Selectable with meta_d2h stream. See here.
• Fix a segfault on closing streams caused by upgrade to OpenVINO 2020.1 XLink.
• Fix color aliasing effect with some neural models (see here)
• Store calibration, left-to-right, left-to-RGB, etc. board parameters to EEPROM. See PR here and example usage here.
• More rigorous mapping of depth and object detector bounding box (see here). Includes fix w/ balanced center-cropping on grayscale cameras.
• Facial landmark, age, and facial expression networks run standalone.
• Decode CNN structure based on JSON definition.
• Upgrade to OpenVINO to 2020.1
• Capability to pull JPEG from DepthAI API on-demand (see here)
• Capability to pull H.264/H.265-encoded 1080p stream from DepthAI (see here)
• Multi-stage vehicle detection application (available upon request, see here for example of it running)
• Custom training support (see here and here)
• Multi-output-tensor support. Allows running networks which aren't a single output tensor (like MobileNetSSD which is single-tensor).
• Add mirror capability to Calibration flow for more intuitive use.
• Implement timestamp onto all streams to allow host syncing as desired.
• Store calibration to EEPROM with versioning.
• Enable tighter stereo synchronization (now on the order of micro-second-level sync).
• Tie exposure of left and right together for better stereo matching.
• Fix for depth directionality here and here
• Open Source of DepthAI (depthai-api, here)
• Sanitize floating point returns in the C++ depthai-api so Python doesn't have to deal with them. (see )
• Implement USB2 mode (see here)
• Implement basic integration test system (here), which acts as a decent integration example.
• Host watchdog solution, which catches host-side errors (or example errors in coding, uncaught exceptions, etc.) and automatically restarts the script if an exception occurs. See here.
• Fix USB issue w/ Pi 4. See here.
• Allow selectable frame-rate per stream. See PR here and how to use here
• Platform-agnostic DepthAI reset. A watchdog runs in the DepthAI firmware. If the host does not respond within a certain period of time, DepthAI resets itself to wait for the host-side watchdog to trip and get DepthAI running again.
• megaAI (BW1093)
• 3D Object Localization MVP
• Allow user to select individual streams
• Colorized Depth capability
• Reduce frame latency on Raspberry Pi operation to be that of using w/ fast hosts