|
depthai_v3 package from depthai repodepthai_v3 |
ROS Distro
|
Package Summary
| Version | 3.9.0 |
| License | MIT |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/luxonis/depthai-core.git |
| VCS Type | git |
| VCS Version | ros-old-devel |
| Last Updated | 2026-08-17 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Aljaž Sebastjan Ahtik
Authors
- Martin Peterlin
DepthAI Library
DepthAI library for interfacing with Luxonis DepthAI hardware. It’s written in C++ and offers Python bindings out of the box.
Important — You’re viewing the
v3.x.ybranch.
- For production projects that still rely on v2, check out the
v2_stablebranch.- Need to migrate? Follow the step-by-step v2 → v3 Porting Guide.
Documentation
Documentation is available over at Luxonis DepthAI API
Examples
Examples for both C++ and Python are available in the examples folder. To see how to build and run them see README.md for more information.
To build the examples in C++ configure with the following option added:
cmake -S. -Bbuild -D'DEPTHAI_BUILD_EXAMPLES=ON'
cmake --build build
Beta features
The beta namespace is a staging area for experimental DepthAI features. It
allows new features to be developed and iterated on quickly before they are
promoted to the main depthai namespace.
Beta features are well-developed, but minor API and behavioral changes may occur between DepthAI releases without notice.
In C++, beta nodes are available under dai::beta::node:
auto node = pipeline.create<dai::beta::node::ImgDetectionsFilter>();
In Python, they are available under dai.beta.node:
node = pipeline.create(dai.beta.node.ImgDetectionsFilter)
On-device execution of Beta nodes is supported only on RVC4. If running Beta nodes on RVC2, DepthAI automatically configures beta nodes to run on the host.
Dependencies
- CMake >= 3.20
- C/C++17 compiler
- [Linux] libudev >= 1.0.0
- [optional] OpenCV 4 (required if building examples and for record and replay)
- [optional] PCL (required for point cloud example)
To install libudev on Debian based systems (Ubuntu, etc.): sudo apt install libudev-dev
To install OpenCV:
MacOS: brew install opencv
Linux: sudo apt install libopencv-dev
Windows: choco install opencv
To install PCL:
MacOS: brew install pcl
Linux: sudo apt install libpcl-dev
Using Python bindings
Installing the latest pre-released version of the library can be done with:
python3 -m pip install --extra-index-url https://artifacts.luxonis.com/artifactory/luxonis-python-release-local/ --pre -U depthai
or by running:
python3 examples/python/install_requirements.py on the branch you want to install
For more specific information about Python bindings, see Python README.
Building
Make sure submodules are updated
git submodule update --init --recursive
Then configure and build
cmake -S . -B build
cmake --build build --parallel [num CPU cores]
On Windows it’s often required to specify the location of the OpenCV installation. In case you used chocolatey to install OpenCV, you can use the following command:
cmake -S . -B build -DOpenCV_DIR=C:/tools/opencv/build -DCMAKE_BUILD_TYPE=Release
cmake --build build --config Release --parallel [num CPU cores]
ℹ️ To speed up build times, use
cmake --build build --parallel [num CPU cores].
File truncated at 100 lines see the full file
Changelog for package depthai
3.9.0 (2026-08-17)
## Features
-
Beta features namespace
- Staging area for experimental DepthAI nodes and features
- Enables faster support for features whose public API may change without prior notice
- All nodes run natively on RVC4 and on the host for RVC2
- All parsers and unique messages from [depthai_nodes]{.title-ref} are ported over and have native support
- Parsers have exposed runtime configuration changes via config messages
- [Python](https://github.com/luxonis/depthai-core/tree/main/examples/python/Beta) and [C++ examples](https://github.com/luxonis/depthai-core/tree/main/examples/cpp/Beta) are available
-
[_RVC2_] PoE Bootloader update
- Embedded Bootloader version updated to v0.0.29
- Greatly improves RVC2 PoE device discoverability by fixing stale connection information that could result in [X_LINK_DEVICE_NOT_FOUND]{.title-ref} errors
- The bootloader is backward- and forward-compatible and independent of the DepthAI version
- Updating the recoverable _user bootloader is recommended for devices with frequent discovery failures. For full integration, we recommend flashing the _factory bootloader.
- The following three flashing paths are available:
- For a GUI experience, use [device_manager.py](https://github.com/luxonis/depthai-core/blob/main/utilities/device_manager.py). The update function is accessible within the "danger zone" section
- Using the provided [flash_network_bootloader.py](https://github.com/luxonis/depthai-core/blob/main/utilities/flash_network_bootloader.py) script. By default, the script flashes the _user bootloader; use the [-f]{.title-ref} flag to enable factory flashing
- Using the CLI command [depthai --flash <device_ip>]{.title-ref}. By default, the command flashes the _user bootloader; use the [-f]{.title-ref} flag to enable factory flashing
- For more information, follow the [tutorial](https://docs.luxonis.com/software-v3/depthai/depthai-components/bootloader) in our docs
-
[_RVC4_] Alpha parameter for image undistortion
- StereoDepth node now properly handles alpha scaling of undistortion on RVC4
- Camera output requests now accept an optional [alphaScaling]{.title-ref} value for controlling the balance between cropping and retaining the full field of view
-
Depth colorization utility
- Added [dai::utility::colorizeDepthFrame]{.title-ref} in C++ and [dai.utility.colorizeDepthFrame]{.title-ref} in Python
- Supports [ImgFrame]{.title-ref}, OpenCV matrices, configurable depth ranges and color maps, and logarithmic or linear scaling
- Can automatically derive visualization bounds from valid depth pixels and render invalid pixels as black
-
[*RVC4*] VideoEncoder improvements
- Improved latency for 4000 x 3000 H.264, H.265, and MJPEG encoding
- Fixed an issue where [setKeyframeFrequency]{.title-ref} had no effect on RVC4
## Bug fixes
-
[*RVC4*] 480 FPS mode
- Fixed a regression from 3.7.1 where the ImageManip pool size was too small to properly support 480 FPS HFR mode
- ImageManip can now grow its output pool when it is running low on frames
- Added [setMaxPoolSize]{.title-ref} to cap the maximum output-pool size
- [_RVC2] Added a total power limit for DOT and FLOOD projectors to avoid power resets on the RVC2 ToF 63D sensor
- [RVC2] SpatialLocationCalculator now remaps regions of interest correctly when the depth input is not aligned
- Fixed YOLOv6 and YOLOv6-R1 decoding, including stride-based box reconstruction and confidence handling
- Rectification now uses the transformations carried by its input frames and reinitializes when those transformations change
- Fixed ImageManip four-point transform did not account for normalized coordinates
- Fixed colorization flicker and inconsistent frame rates in the ToF examples
- ReplayVideo now reports a runtime error when FFmpeg cannot open a video instead of relying on an assertion
## Misc
- Added a [getConnectedCameras(CameraSensorType)]{.title-ref} overload for filtering connected cameras by sensor type
- Reworked stereo-pair discovery to consider only connected and
calibrated cameras with compatible sensors, valid extrinsics, and
suitable orientation
- Stereo pairs are now ordered by descending baseline length
- [cam_test.py]{.title-ref} now selects supported resolutions from the connected camera features instead of assuming 1280 x 800
File truncated at 100 lines see the full file
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged depthai_v3 at Robotics Stack Exchange
|
depthai_v3 package from depthai repodepthai_v3 |
ROS Distro
|
Package Summary
| Version | 3.9.0 |
| License | MIT |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/luxonis/depthai-core.git |
| VCS Type | git |
| VCS Version | ros-old-devel |
| Last Updated | 2026-08-17 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Aljaž Sebastjan Ahtik
Authors
- Martin Peterlin
DepthAI Library
DepthAI library for interfacing with Luxonis DepthAI hardware. It’s written in C++ and offers Python bindings out of the box.
Important — You’re viewing the
v3.x.ybranch.
- For production projects that still rely on v2, check out the
v2_stablebranch.- Need to migrate? Follow the step-by-step v2 → v3 Porting Guide.
Documentation
Documentation is available over at Luxonis DepthAI API
Examples
Examples for both C++ and Python are available in the examples folder. To see how to build and run them see README.md for more information.
To build the examples in C++ configure with the following option added:
cmake -S. -Bbuild -D'DEPTHAI_BUILD_EXAMPLES=ON'
cmake --build build
Beta features
The beta namespace is a staging area for experimental DepthAI features. It
allows new features to be developed and iterated on quickly before they are
promoted to the main depthai namespace.
Beta features are well-developed, but minor API and behavioral changes may occur between DepthAI releases without notice.
In C++, beta nodes are available under dai::beta::node:
auto node = pipeline.create<dai::beta::node::ImgDetectionsFilter>();
In Python, they are available under dai.beta.node:
node = pipeline.create(dai.beta.node.ImgDetectionsFilter)
On-device execution of Beta nodes is supported only on RVC4. If running Beta nodes on RVC2, DepthAI automatically configures beta nodes to run on the host.
Dependencies
- CMake >= 3.20
- C/C++17 compiler
- [Linux] libudev >= 1.0.0
- [optional] OpenCV 4 (required if building examples and for record and replay)
- [optional] PCL (required for point cloud example)
To install libudev on Debian based systems (Ubuntu, etc.): sudo apt install libudev-dev
To install OpenCV:
MacOS: brew install opencv
Linux: sudo apt install libopencv-dev
Windows: choco install opencv
To install PCL:
MacOS: brew install pcl
Linux: sudo apt install libpcl-dev
Using Python bindings
Installing the latest pre-released version of the library can be done with:
python3 -m pip install --extra-index-url https://artifacts.luxonis.com/artifactory/luxonis-python-release-local/ --pre -U depthai
or by running:
python3 examples/python/install_requirements.py on the branch you want to install
For more specific information about Python bindings, see Python README.
Building
Make sure submodules are updated
git submodule update --init --recursive
Then configure and build
cmake -S . -B build
cmake --build build --parallel [num CPU cores]
On Windows it’s often required to specify the location of the OpenCV installation. In case you used chocolatey to install OpenCV, you can use the following command:
cmake -S . -B build -DOpenCV_DIR=C:/tools/opencv/build -DCMAKE_BUILD_TYPE=Release
cmake --build build --config Release --parallel [num CPU cores]
ℹ️ To speed up build times, use
cmake --build build --parallel [num CPU cores].
File truncated at 100 lines see the full file
Changelog for package depthai
3.9.0 (2026-08-17)
## Features
-
Beta features namespace
- Staging area for experimental DepthAI nodes and features
- Enables faster support for features whose public API may change without prior notice
- All nodes run natively on RVC4 and on the host for RVC2
- All parsers and unique messages from [depthai_nodes]{.title-ref} are ported over and have native support
- Parsers have exposed runtime configuration changes via config messages
- [Python](https://github.com/luxonis/depthai-core/tree/main/examples/python/Beta) and [C++ examples](https://github.com/luxonis/depthai-core/tree/main/examples/cpp/Beta) are available
-
[_RVC2_] PoE Bootloader update
- Embedded Bootloader version updated to v0.0.29
- Greatly improves RVC2 PoE device discoverability by fixing stale connection information that could result in [X_LINK_DEVICE_NOT_FOUND]{.title-ref} errors
- The bootloader is backward- and forward-compatible and independent of the DepthAI version
- Updating the recoverable _user bootloader is recommended for devices with frequent discovery failures. For full integration, we recommend flashing the _factory bootloader.
- The following three flashing paths are available:
- For a GUI experience, use [device_manager.py](https://github.com/luxonis/depthai-core/blob/main/utilities/device_manager.py). The update function is accessible within the "danger zone" section
- Using the provided [flash_network_bootloader.py](https://github.com/luxonis/depthai-core/blob/main/utilities/flash_network_bootloader.py) script. By default, the script flashes the _user bootloader; use the [-f]{.title-ref} flag to enable factory flashing
- Using the CLI command [depthai --flash <device_ip>]{.title-ref}. By default, the command flashes the _user bootloader; use the [-f]{.title-ref} flag to enable factory flashing
- For more information, follow the [tutorial](https://docs.luxonis.com/software-v3/depthai/depthai-components/bootloader) in our docs
-
[_RVC4_] Alpha parameter for image undistortion
- StereoDepth node now properly handles alpha scaling of undistortion on RVC4
- Camera output requests now accept an optional [alphaScaling]{.title-ref} value for controlling the balance between cropping and retaining the full field of view
-
Depth colorization utility
- Added [dai::utility::colorizeDepthFrame]{.title-ref} in C++ and [dai.utility.colorizeDepthFrame]{.title-ref} in Python
- Supports [ImgFrame]{.title-ref}, OpenCV matrices, configurable depth ranges and color maps, and logarithmic or linear scaling
- Can automatically derive visualization bounds from valid depth pixels and render invalid pixels as black
-
[*RVC4*] VideoEncoder improvements
- Improved latency for 4000 x 3000 H.264, H.265, and MJPEG encoding
- Fixed an issue where [setKeyframeFrequency]{.title-ref} had no effect on RVC4
## Bug fixes
-
[*RVC4*] 480 FPS mode
- Fixed a regression from 3.7.1 where the ImageManip pool size was too small to properly support 480 FPS HFR mode
- ImageManip can now grow its output pool when it is running low on frames
- Added [setMaxPoolSize]{.title-ref} to cap the maximum output-pool size
- [_RVC2] Added a total power limit for DOT and FLOOD projectors to avoid power resets on the RVC2 ToF 63D sensor
- [RVC2] SpatialLocationCalculator now remaps regions of interest correctly when the depth input is not aligned
- Fixed YOLOv6 and YOLOv6-R1 decoding, including stride-based box reconstruction and confidence handling
- Rectification now uses the transformations carried by its input frames and reinitializes when those transformations change
- Fixed ImageManip four-point transform did not account for normalized coordinates
- Fixed colorization flicker and inconsistent frame rates in the ToF examples
- ReplayVideo now reports a runtime error when FFmpeg cannot open a video instead of relying on an assertion
## Misc
- Added a [getConnectedCameras(CameraSensorType)]{.title-ref} overload for filtering connected cameras by sensor type
- Reworked stereo-pair discovery to consider only connected and
calibrated cameras with compatible sensors, valid extrinsics, and
suitable orientation
- Stereo pairs are now ordered by descending baseline length
- [cam_test.py]{.title-ref} now selects supported resolutions from the connected camera features instead of assuming 1280 x 800
File truncated at 100 lines see the full file
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged depthai_v3 at Robotics Stack Exchange
|
depthai_v3 package from depthai repodepthai_v3 |
ROS Distro
|
Package Summary
| Version | 3.9.0 |
| License | MIT |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/luxonis/depthai-core.git |
| VCS Type | git |
| VCS Version | ros-old-devel |
| Last Updated | 2026-08-17 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Aljaž Sebastjan Ahtik
Authors
- Martin Peterlin
DepthAI Library
DepthAI library for interfacing with Luxonis DepthAI hardware. It’s written in C++ and offers Python bindings out of the box.
Important — You’re viewing the
v3.x.ybranch.
- For production projects that still rely on v2, check out the
v2_stablebranch.- Need to migrate? Follow the step-by-step v2 → v3 Porting Guide.
Documentation
Documentation is available over at Luxonis DepthAI API
Examples
Examples for both C++ and Python are available in the examples folder. To see how to build and run them see README.md for more information.
To build the examples in C++ configure with the following option added:
cmake -S. -Bbuild -D'DEPTHAI_BUILD_EXAMPLES=ON'
cmake --build build
Beta features
The beta namespace is a staging area for experimental DepthAI features. It
allows new features to be developed and iterated on quickly before they are
promoted to the main depthai namespace.
Beta features are well-developed, but minor API and behavioral changes may occur between DepthAI releases without notice.
In C++, beta nodes are available under dai::beta::node:
auto node = pipeline.create<dai::beta::node::ImgDetectionsFilter>();
In Python, they are available under dai.beta.node:
node = pipeline.create(dai.beta.node.ImgDetectionsFilter)
On-device execution of Beta nodes is supported only on RVC4. If running Beta nodes on RVC2, DepthAI automatically configures beta nodes to run on the host.
Dependencies
- CMake >= 3.20
- C/C++17 compiler
- [Linux] libudev >= 1.0.0
- [optional] OpenCV 4 (required if building examples and for record and replay)
- [optional] PCL (required for point cloud example)
To install libudev on Debian based systems (Ubuntu, etc.): sudo apt install libudev-dev
To install OpenCV:
MacOS: brew install opencv
Linux: sudo apt install libopencv-dev
Windows: choco install opencv
To install PCL:
MacOS: brew install pcl
Linux: sudo apt install libpcl-dev
Using Python bindings
Installing the latest pre-released version of the library can be done with:
python3 -m pip install --extra-index-url https://artifacts.luxonis.com/artifactory/luxonis-python-release-local/ --pre -U depthai
or by running:
python3 examples/python/install_requirements.py on the branch you want to install
For more specific information about Python bindings, see Python README.
Building
Make sure submodules are updated
git submodule update --init --recursive
Then configure and build
cmake -S . -B build
cmake --build build --parallel [num CPU cores]
On Windows it’s often required to specify the location of the OpenCV installation. In case you used chocolatey to install OpenCV, you can use the following command:
cmake -S . -B build -DOpenCV_DIR=C:/tools/opencv/build -DCMAKE_BUILD_TYPE=Release
cmake --build build --config Release --parallel [num CPU cores]
ℹ️ To speed up build times, use
cmake --build build --parallel [num CPU cores].
File truncated at 100 lines see the full file
Changelog for package depthai
3.9.0 (2026-08-17)
## Features
-
Beta features namespace
- Staging area for experimental DepthAI nodes and features
- Enables faster support for features whose public API may change without prior notice
- All nodes run natively on RVC4 and on the host for RVC2
- All parsers and unique messages from [depthai_nodes]{.title-ref} are ported over and have native support
- Parsers have exposed runtime configuration changes via config messages
- [Python](https://github.com/luxonis/depthai-core/tree/main/examples/python/Beta) and [C++ examples](https://github.com/luxonis/depthai-core/tree/main/examples/cpp/Beta) are available
-
[_RVC2_] PoE Bootloader update
- Embedded Bootloader version updated to v0.0.29
- Greatly improves RVC2 PoE device discoverability by fixing stale connection information that could result in [X_LINK_DEVICE_NOT_FOUND]{.title-ref} errors
- The bootloader is backward- and forward-compatible and independent of the DepthAI version
- Updating the recoverable _user bootloader is recommended for devices with frequent discovery failures. For full integration, we recommend flashing the _factory bootloader.
- The following three flashing paths are available:
- For a GUI experience, use [device_manager.py](https://github.com/luxonis/depthai-core/blob/main/utilities/device_manager.py). The update function is accessible within the "danger zone" section
- Using the provided [flash_network_bootloader.py](https://github.com/luxonis/depthai-core/blob/main/utilities/flash_network_bootloader.py) script. By default, the script flashes the _user bootloader; use the [-f]{.title-ref} flag to enable factory flashing
- Using the CLI command [depthai --flash <device_ip>]{.title-ref}. By default, the command flashes the _user bootloader; use the [-f]{.title-ref} flag to enable factory flashing
- For more information, follow the [tutorial](https://docs.luxonis.com/software-v3/depthai/depthai-components/bootloader) in our docs
-
[_RVC4_] Alpha parameter for image undistortion
- StereoDepth node now properly handles alpha scaling of undistortion on RVC4
- Camera output requests now accept an optional [alphaScaling]{.title-ref} value for controlling the balance between cropping and retaining the full field of view
-
Depth colorization utility
- Added [dai::utility::colorizeDepthFrame]{.title-ref} in C++ and [dai.utility.colorizeDepthFrame]{.title-ref} in Python
- Supports [ImgFrame]{.title-ref}, OpenCV matrices, configurable depth ranges and color maps, and logarithmic or linear scaling
- Can automatically derive visualization bounds from valid depth pixels and render invalid pixels as black
-
[*RVC4*] VideoEncoder improvements
- Improved latency for 4000 x 3000 H.264, H.265, and MJPEG encoding
- Fixed an issue where [setKeyframeFrequency]{.title-ref} had no effect on RVC4
## Bug fixes
-
[*RVC4*] 480 FPS mode
- Fixed a regression from 3.7.1 where the ImageManip pool size was too small to properly support 480 FPS HFR mode
- ImageManip can now grow its output pool when it is running low on frames
- Added [setMaxPoolSize]{.title-ref} to cap the maximum output-pool size
- [_RVC2] Added a total power limit for DOT and FLOOD projectors to avoid power resets on the RVC2 ToF 63D sensor
- [RVC2] SpatialLocationCalculator now remaps regions of interest correctly when the depth input is not aligned
- Fixed YOLOv6 and YOLOv6-R1 decoding, including stride-based box reconstruction and confidence handling
- Rectification now uses the transformations carried by its input frames and reinitializes when those transformations change
- Fixed ImageManip four-point transform did not account for normalized coordinates
- Fixed colorization flicker and inconsistent frame rates in the ToF examples
- ReplayVideo now reports a runtime error when FFmpeg cannot open a video instead of relying on an assertion
## Misc
- Added a [getConnectedCameras(CameraSensorType)]{.title-ref} overload for filtering connected cameras by sensor type
- Reworked stereo-pair discovery to consider only connected and
calibrated cameras with compatible sensors, valid extrinsics, and
suitable orientation
- Stereo pairs are now ordered by descending baseline length
- [cam_test.py]{.title-ref} now selects supported resolutions from the connected camera features instead of assuming 1280 x 800
File truncated at 100 lines see the full file
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged depthai_v3 at Robotics Stack Exchange
|
depthai_v3 package from depthai repodepthai_v3 |
ROS Distro
|
Package Summary
| Version | 3.9.0 |
| License | MIT |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/luxonis/depthai-core.git |
| VCS Type | git |
| VCS Version | ros-old-devel |
| Last Updated | 2026-08-17 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Aljaž Sebastjan Ahtik
Authors
- Martin Peterlin
DepthAI Library
DepthAI library for interfacing with Luxonis DepthAI hardware. It’s written in C++ and offers Python bindings out of the box.
Important — You’re viewing the
v3.x.ybranch.
- For production projects that still rely on v2, check out the
v2_stablebranch.- Need to migrate? Follow the step-by-step v2 → v3 Porting Guide.
Documentation
Documentation is available over at Luxonis DepthAI API
Examples
Examples for both C++ and Python are available in the examples folder. To see how to build and run them see README.md for more information.
To build the examples in C++ configure with the following option added:
cmake -S. -Bbuild -D'DEPTHAI_BUILD_EXAMPLES=ON'
cmake --build build
Beta features
The beta namespace is a staging area for experimental DepthAI features. It
allows new features to be developed and iterated on quickly before they are
promoted to the main depthai namespace.
Beta features are well-developed, but minor API and behavioral changes may occur between DepthAI releases without notice.
In C++, beta nodes are available under dai::beta::node:
auto node = pipeline.create<dai::beta::node::ImgDetectionsFilter>();
In Python, they are available under dai.beta.node:
node = pipeline.create(dai.beta.node.ImgDetectionsFilter)
On-device execution of Beta nodes is supported only on RVC4. If running Beta nodes on RVC2, DepthAI automatically configures beta nodes to run on the host.
Dependencies
- CMake >= 3.20
- C/C++17 compiler
- [Linux] libudev >= 1.0.0
- [optional] OpenCV 4 (required if building examples and for record and replay)
- [optional] PCL (required for point cloud example)
To install libudev on Debian based systems (Ubuntu, etc.): sudo apt install libudev-dev
To install OpenCV:
MacOS: brew install opencv
Linux: sudo apt install libopencv-dev
Windows: choco install opencv
To install PCL:
MacOS: brew install pcl
Linux: sudo apt install libpcl-dev
Using Python bindings
Installing the latest pre-released version of the library can be done with:
python3 -m pip install --extra-index-url https://artifacts.luxonis.com/artifactory/luxonis-python-release-local/ --pre -U depthai
or by running:
python3 examples/python/install_requirements.py on the branch you want to install
For more specific information about Python bindings, see Python README.
Building
Make sure submodules are updated
git submodule update --init --recursive
Then configure and build
cmake -S . -B build
cmake --build build --parallel [num CPU cores]
On Windows it’s often required to specify the location of the OpenCV installation. In case you used chocolatey to install OpenCV, you can use the following command:
cmake -S . -B build -DOpenCV_DIR=C:/tools/opencv/build -DCMAKE_BUILD_TYPE=Release
cmake --build build --config Release --parallel [num CPU cores]
ℹ️ To speed up build times, use
cmake --build build --parallel [num CPU cores].
File truncated at 100 lines see the full file
Changelog for package depthai
3.9.0 (2026-08-17)
## Features
-
Beta features namespace
- Staging area for experimental DepthAI nodes and features
- Enables faster support for features whose public API may change without prior notice
- All nodes run natively on RVC4 and on the host for RVC2
- All parsers and unique messages from [depthai_nodes]{.title-ref} are ported over and have native support
- Parsers have exposed runtime configuration changes via config messages
- [Python](https://github.com/luxonis/depthai-core/tree/main/examples/python/Beta) and [C++ examples](https://github.com/luxonis/depthai-core/tree/main/examples/cpp/Beta) are available
-
[_RVC2_] PoE Bootloader update
- Embedded Bootloader version updated to v0.0.29
- Greatly improves RVC2 PoE device discoverability by fixing stale connection information that could result in [X_LINK_DEVICE_NOT_FOUND]{.title-ref} errors
- The bootloader is backward- and forward-compatible and independent of the DepthAI version
- Updating the recoverable _user bootloader is recommended for devices with frequent discovery failures. For full integration, we recommend flashing the _factory bootloader.
- The following three flashing paths are available:
- For a GUI experience, use [device_manager.py](https://github.com/luxonis/depthai-core/blob/main/utilities/device_manager.py). The update function is accessible within the "danger zone" section
- Using the provided [flash_network_bootloader.py](https://github.com/luxonis/depthai-core/blob/main/utilities/flash_network_bootloader.py) script. By default, the script flashes the _user bootloader; use the [-f]{.title-ref} flag to enable factory flashing
- Using the CLI command [depthai --flash <device_ip>]{.title-ref}. By default, the command flashes the _user bootloader; use the [-f]{.title-ref} flag to enable factory flashing
- For more information, follow the [tutorial](https://docs.luxonis.com/software-v3/depthai/depthai-components/bootloader) in our docs
-
[_RVC4_] Alpha parameter for image undistortion
- StereoDepth node now properly handles alpha scaling of undistortion on RVC4
- Camera output requests now accept an optional [alphaScaling]{.title-ref} value for controlling the balance between cropping and retaining the full field of view
-
Depth colorization utility
- Added [dai::utility::colorizeDepthFrame]{.title-ref} in C++ and [dai.utility.colorizeDepthFrame]{.title-ref} in Python
- Supports [ImgFrame]{.title-ref}, OpenCV matrices, configurable depth ranges and color maps, and logarithmic or linear scaling
- Can automatically derive visualization bounds from valid depth pixels and render invalid pixels as black
-
[*RVC4*] VideoEncoder improvements
- Improved latency for 4000 x 3000 H.264, H.265, and MJPEG encoding
- Fixed an issue where [setKeyframeFrequency]{.title-ref} had no effect on RVC4
## Bug fixes
-
[*RVC4*] 480 FPS mode
- Fixed a regression from 3.7.1 where the ImageManip pool size was too small to properly support 480 FPS HFR mode
- ImageManip can now grow its output pool when it is running low on frames
- Added [setMaxPoolSize]{.title-ref} to cap the maximum output-pool size
- [_RVC2] Added a total power limit for DOT and FLOOD projectors to avoid power resets on the RVC2 ToF 63D sensor
- [RVC2] SpatialLocationCalculator now remaps regions of interest correctly when the depth input is not aligned
- Fixed YOLOv6 and YOLOv6-R1 decoding, including stride-based box reconstruction and confidence handling
- Rectification now uses the transformations carried by its input frames and reinitializes when those transformations change
- Fixed ImageManip four-point transform did not account for normalized coordinates
- Fixed colorization flicker and inconsistent frame rates in the ToF examples
- ReplayVideo now reports a runtime error when FFmpeg cannot open a video instead of relying on an assertion
## Misc
- Added a [getConnectedCameras(CameraSensorType)]{.title-ref} overload for filtering connected cameras by sensor type
- Reworked stereo-pair discovery to consider only connected and
calibrated cameras with compatible sensors, valid extrinsics, and
suitable orientation
- Stereo pairs are now ordered by descending baseline length
- [cam_test.py]{.title-ref} now selects supported resolutions from the connected camera features instead of assuming 1280 x 800
File truncated at 100 lines see the full file
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged depthai_v3 at Robotics Stack Exchange
|
depthai_v3 package from depthai repodepthai_v3 |
ROS Distro
|
Package Summary
| Version | 3.9.0 |
| License | MIT |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/luxonis/depthai-core.git |
| VCS Type | git |
| VCS Version | ros-old-devel |
| Last Updated | 2026-08-17 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Aljaž Sebastjan Ahtik
Authors
- Martin Peterlin
DepthAI Library
DepthAI library for interfacing with Luxonis DepthAI hardware. It’s written in C++ and offers Python bindings out of the box.
Important — You’re viewing the
v3.x.ybranch.
- For production projects that still rely on v2, check out the
v2_stablebranch.- Need to migrate? Follow the step-by-step v2 → v3 Porting Guide.
Documentation
Documentation is available over at Luxonis DepthAI API
Examples
Examples for both C++ and Python are available in the examples folder. To see how to build and run them see README.md for more information.
To build the examples in C++ configure with the following option added:
cmake -S. -Bbuild -D'DEPTHAI_BUILD_EXAMPLES=ON'
cmake --build build
Beta features
The beta namespace is a staging area for experimental DepthAI features. It
allows new features to be developed and iterated on quickly before they are
promoted to the main depthai namespace.
Beta features are well-developed, but minor API and behavioral changes may occur between DepthAI releases without notice.
In C++, beta nodes are available under dai::beta::node:
auto node = pipeline.create<dai::beta::node::ImgDetectionsFilter>();
In Python, they are available under dai.beta.node:
node = pipeline.create(dai.beta.node.ImgDetectionsFilter)
On-device execution of Beta nodes is supported only on RVC4. If running Beta nodes on RVC2, DepthAI automatically configures beta nodes to run on the host.
Dependencies
- CMake >= 3.20
- C/C++17 compiler
- [Linux] libudev >= 1.0.0
- [optional] OpenCV 4 (required if building examples and for record and replay)
- [optional] PCL (required for point cloud example)
To install libudev on Debian based systems (Ubuntu, etc.): sudo apt install libudev-dev
To install OpenCV:
MacOS: brew install opencv
Linux: sudo apt install libopencv-dev
Windows: choco install opencv
To install PCL:
MacOS: brew install pcl
Linux: sudo apt install libpcl-dev
Using Python bindings
Installing the latest pre-released version of the library can be done with:
python3 -m pip install --extra-index-url https://artifacts.luxonis.com/artifactory/luxonis-python-release-local/ --pre -U depthai
or by running:
python3 examples/python/install_requirements.py on the branch you want to install
For more specific information about Python bindings, see Python README.
Building
Make sure submodules are updated
git submodule update --init --recursive
Then configure and build
cmake -S . -B build
cmake --build build --parallel [num CPU cores]
On Windows it’s often required to specify the location of the OpenCV installation. In case you used chocolatey to install OpenCV, you can use the following command:
cmake -S . -B build -DOpenCV_DIR=C:/tools/opencv/build -DCMAKE_BUILD_TYPE=Release
cmake --build build --config Release --parallel [num CPU cores]
ℹ️ To speed up build times, use
cmake --build build --parallel [num CPU cores].
File truncated at 100 lines see the full file
Changelog for package depthai
3.9.0 (2026-08-17)
## Features
-
Beta features namespace
- Staging area for experimental DepthAI nodes and features
- Enables faster support for features whose public API may change without prior notice
- All nodes run natively on RVC4 and on the host for RVC2
- All parsers and unique messages from [depthai_nodes]{.title-ref} are ported over and have native support
- Parsers have exposed runtime configuration changes via config messages
- [Python](https://github.com/luxonis/depthai-core/tree/main/examples/python/Beta) and [C++ examples](https://github.com/luxonis/depthai-core/tree/main/examples/cpp/Beta) are available
-
[_RVC2_] PoE Bootloader update
- Embedded Bootloader version updated to v0.0.29
- Greatly improves RVC2 PoE device discoverability by fixing stale connection information that could result in [X_LINK_DEVICE_NOT_FOUND]{.title-ref} errors
- The bootloader is backward- and forward-compatible and independent of the DepthAI version
- Updating the recoverable _user bootloader is recommended for devices with frequent discovery failures. For full integration, we recommend flashing the _factory bootloader.
- The following three flashing paths are available:
- For a GUI experience, use [device_manager.py](https://github.com/luxonis/depthai-core/blob/main/utilities/device_manager.py). The update function is accessible within the "danger zone" section
- Using the provided [flash_network_bootloader.py](https://github.com/luxonis/depthai-core/blob/main/utilities/flash_network_bootloader.py) script. By default, the script flashes the _user bootloader; use the [-f]{.title-ref} flag to enable factory flashing
- Using the CLI command [depthai --flash <device_ip>]{.title-ref}. By default, the command flashes the _user bootloader; use the [-f]{.title-ref} flag to enable factory flashing
- For more information, follow the [tutorial](https://docs.luxonis.com/software-v3/depthai/depthai-components/bootloader) in our docs
-
[_RVC4_] Alpha parameter for image undistortion
- StereoDepth node now properly handles alpha scaling of undistortion on RVC4
- Camera output requests now accept an optional [alphaScaling]{.title-ref} value for controlling the balance between cropping and retaining the full field of view
-
Depth colorization utility
- Added [dai::utility::colorizeDepthFrame]{.title-ref} in C++ and [dai.utility.colorizeDepthFrame]{.title-ref} in Python
- Supports [ImgFrame]{.title-ref}, OpenCV matrices, configurable depth ranges and color maps, and logarithmic or linear scaling
- Can automatically derive visualization bounds from valid depth pixels and render invalid pixels as black
-
[*RVC4*] VideoEncoder improvements
- Improved latency for 4000 x 3000 H.264, H.265, and MJPEG encoding
- Fixed an issue where [setKeyframeFrequency]{.title-ref} had no effect on RVC4
## Bug fixes
-
[*RVC4*] 480 FPS mode
- Fixed a regression from 3.7.1 where the ImageManip pool size was too small to properly support 480 FPS HFR mode
- ImageManip can now grow its output pool when it is running low on frames
- Added [setMaxPoolSize]{.title-ref} to cap the maximum output-pool size
- [_RVC2] Added a total power limit for DOT and FLOOD projectors to avoid power resets on the RVC2 ToF 63D sensor
- [RVC2] SpatialLocationCalculator now remaps regions of interest correctly when the depth input is not aligned
- Fixed YOLOv6 and YOLOv6-R1 decoding, including stride-based box reconstruction and confidence handling
- Rectification now uses the transformations carried by its input frames and reinitializes when those transformations change
- Fixed ImageManip four-point transform did not account for normalized coordinates
- Fixed colorization flicker and inconsistent frame rates in the ToF examples
- ReplayVideo now reports a runtime error when FFmpeg cannot open a video instead of relying on an assertion
## Misc
- Added a [getConnectedCameras(CameraSensorType)]{.title-ref} overload for filtering connected cameras by sensor type
- Reworked stereo-pair discovery to consider only connected and
calibrated cameras with compatible sensors, valid extrinsics, and
suitable orientation
- Stereo pairs are now ordered by descending baseline length
- [cam_test.py]{.title-ref} now selects supported resolutions from the connected camera features instead of assuming 1280 x 800
File truncated at 100 lines see the full file
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged depthai_v3 at Robotics Stack Exchange
|
depthai_v3 package from depthai repodepthai_v3 |
ROS Distro
|
Package Summary
| Version | 3.9.0 |
| License | MIT |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/luxonis/depthai-core.git |
| VCS Type | git |
| VCS Version | ros-old-devel |
| Last Updated | 2026-08-17 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Aljaž Sebastjan Ahtik
Authors
- Martin Peterlin
DepthAI Library
DepthAI library for interfacing with Luxonis DepthAI hardware. It’s written in C++ and offers Python bindings out of the box.
Important — You’re viewing the
v3.x.ybranch.
- For production projects that still rely on v2, check out the
v2_stablebranch.- Need to migrate? Follow the step-by-step v2 → v3 Porting Guide.
Documentation
Documentation is available over at Luxonis DepthAI API
Examples
Examples for both C++ and Python are available in the examples folder. To see how to build and run them see README.md for more information.
To build the examples in C++ configure with the following option added:
cmake -S. -Bbuild -D'DEPTHAI_BUILD_EXAMPLES=ON'
cmake --build build
Beta features
The beta namespace is a staging area for experimental DepthAI features. It
allows new features to be developed and iterated on quickly before they are
promoted to the main depthai namespace.
Beta features are well-developed, but minor API and behavioral changes may occur between DepthAI releases without notice.
In C++, beta nodes are available under dai::beta::node:
auto node = pipeline.create<dai::beta::node::ImgDetectionsFilter>();
In Python, they are available under dai.beta.node:
node = pipeline.create(dai.beta.node.ImgDetectionsFilter)
On-device execution of Beta nodes is supported only on RVC4. If running Beta nodes on RVC2, DepthAI automatically configures beta nodes to run on the host.
Dependencies
- CMake >= 3.20
- C/C++17 compiler
- [Linux] libudev >= 1.0.0
- [optional] OpenCV 4 (required if building examples and for record and replay)
- [optional] PCL (required for point cloud example)
To install libudev on Debian based systems (Ubuntu, etc.): sudo apt install libudev-dev
To install OpenCV:
MacOS: brew install opencv
Linux: sudo apt install libopencv-dev
Windows: choco install opencv
To install PCL:
MacOS: brew install pcl
Linux: sudo apt install libpcl-dev
Using Python bindings
Installing the latest pre-released version of the library can be done with:
python3 -m pip install --extra-index-url https://artifacts.luxonis.com/artifactory/luxonis-python-release-local/ --pre -U depthai
or by running:
python3 examples/python/install_requirements.py on the branch you want to install
For more specific information about Python bindings, see Python README.
Building
Make sure submodules are updated
git submodule update --init --recursive
Then configure and build
cmake -S . -B build
cmake --build build --parallel [num CPU cores]
On Windows it’s often required to specify the location of the OpenCV installation. In case you used chocolatey to install OpenCV, you can use the following command:
cmake -S . -B build -DOpenCV_DIR=C:/tools/opencv/build -DCMAKE_BUILD_TYPE=Release
cmake --build build --config Release --parallel [num CPU cores]
ℹ️ To speed up build times, use
cmake --build build --parallel [num CPU cores].
File truncated at 100 lines see the full file
Changelog for package depthai
3.9.0 (2026-08-17)
## Features
-
Beta features namespace
- Staging area for experimental DepthAI nodes and features
- Enables faster support for features whose public API may change without prior notice
- All nodes run natively on RVC4 and on the host for RVC2
- All parsers and unique messages from [depthai_nodes]{.title-ref} are ported over and have native support
- Parsers have exposed runtime configuration changes via config messages
- [Python](https://github.com/luxonis/depthai-core/tree/main/examples/python/Beta) and [C++ examples](https://github.com/luxonis/depthai-core/tree/main/examples/cpp/Beta) are available
-
[_RVC2_] PoE Bootloader update
- Embedded Bootloader version updated to v0.0.29
- Greatly improves RVC2 PoE device discoverability by fixing stale connection information that could result in [X_LINK_DEVICE_NOT_FOUND]{.title-ref} errors
- The bootloader is backward- and forward-compatible and independent of the DepthAI version
- Updating the recoverable _user bootloader is recommended for devices with frequent discovery failures. For full integration, we recommend flashing the _factory bootloader.
- The following three flashing paths are available:
- For a GUI experience, use [device_manager.py](https://github.com/luxonis/depthai-core/blob/main/utilities/device_manager.py). The update function is accessible within the "danger zone" section
- Using the provided [flash_network_bootloader.py](https://github.com/luxonis/depthai-core/blob/main/utilities/flash_network_bootloader.py) script. By default, the script flashes the _user bootloader; use the [-f]{.title-ref} flag to enable factory flashing
- Using the CLI command [depthai --flash <device_ip>]{.title-ref}. By default, the command flashes the _user bootloader; use the [-f]{.title-ref} flag to enable factory flashing
- For more information, follow the [tutorial](https://docs.luxonis.com/software-v3/depthai/depthai-components/bootloader) in our docs
-
[_RVC4_] Alpha parameter for image undistortion
- StereoDepth node now properly handles alpha scaling of undistortion on RVC4
- Camera output requests now accept an optional [alphaScaling]{.title-ref} value for controlling the balance between cropping and retaining the full field of view
-
Depth colorization utility
- Added [dai::utility::colorizeDepthFrame]{.title-ref} in C++ and [dai.utility.colorizeDepthFrame]{.title-ref} in Python
- Supports [ImgFrame]{.title-ref}, OpenCV matrices, configurable depth ranges and color maps, and logarithmic or linear scaling
- Can automatically derive visualization bounds from valid depth pixels and render invalid pixels as black
-
[*RVC4*] VideoEncoder improvements
- Improved latency for 4000 x 3000 H.264, H.265, and MJPEG encoding
- Fixed an issue where [setKeyframeFrequency]{.title-ref} had no effect on RVC4
## Bug fixes
-
[*RVC4*] 480 FPS mode
- Fixed a regression from 3.7.1 where the ImageManip pool size was too small to properly support 480 FPS HFR mode
- ImageManip can now grow its output pool when it is running low on frames
- Added [setMaxPoolSize]{.title-ref} to cap the maximum output-pool size
- [_RVC2] Added a total power limit for DOT and FLOOD projectors to avoid power resets on the RVC2 ToF 63D sensor
- [RVC2] SpatialLocationCalculator now remaps regions of interest correctly when the depth input is not aligned
- Fixed YOLOv6 and YOLOv6-R1 decoding, including stride-based box reconstruction and confidence handling
- Rectification now uses the transformations carried by its input frames and reinitializes when those transformations change
- Fixed ImageManip four-point transform did not account for normalized coordinates
- Fixed colorization flicker and inconsistent frame rates in the ToF examples
- ReplayVideo now reports a runtime error when FFmpeg cannot open a video instead of relying on an assertion
## Misc
- Added a [getConnectedCameras(CameraSensorType)]{.title-ref} overload for filtering connected cameras by sensor type
- Reworked stereo-pair discovery to consider only connected and
calibrated cameras with compatible sensors, valid extrinsics, and
suitable orientation
- Stereo pairs are now ordered by descending baseline length
- [cam_test.py]{.title-ref} now selects supported resolutions from the connected camera features instead of assuming 1280 x 800
File truncated at 100 lines see the full file
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged depthai_v3 at Robotics Stack Exchange
|
depthai_v3 package from depthai repodepthai_v3 |
ROS Distro
|
Package Summary
| Version | 3.9.0 |
| License | MIT |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/luxonis/depthai-core.git |
| VCS Type | git |
| VCS Version | ros-old-devel |
| Last Updated | 2026-08-17 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Aljaž Sebastjan Ahtik
Authors
- Martin Peterlin
DepthAI Library
DepthAI library for interfacing with Luxonis DepthAI hardware. It’s written in C++ and offers Python bindings out of the box.
Important — You’re viewing the
v3.x.ybranch.
- For production projects that still rely on v2, check out the
v2_stablebranch.- Need to migrate? Follow the step-by-step v2 → v3 Porting Guide.
Documentation
Documentation is available over at Luxonis DepthAI API
Examples
Examples for both C++ and Python are available in the examples folder. To see how to build and run them see README.md for more information.
To build the examples in C++ configure with the following option added:
cmake -S. -Bbuild -D'DEPTHAI_BUILD_EXAMPLES=ON'
cmake --build build
Beta features
The beta namespace is a staging area for experimental DepthAI features. It
allows new features to be developed and iterated on quickly before they are
promoted to the main depthai namespace.
Beta features are well-developed, but minor API and behavioral changes may occur between DepthAI releases without notice.
In C++, beta nodes are available under dai::beta::node:
auto node = pipeline.create<dai::beta::node::ImgDetectionsFilter>();
In Python, they are available under dai.beta.node:
node = pipeline.create(dai.beta.node.ImgDetectionsFilter)
On-device execution of Beta nodes is supported only on RVC4. If running Beta nodes on RVC2, DepthAI automatically configures beta nodes to run on the host.
Dependencies
- CMake >= 3.20
- C/C++17 compiler
- [Linux] libudev >= 1.0.0
- [optional] OpenCV 4 (required if building examples and for record and replay)
- [optional] PCL (required for point cloud example)
To install libudev on Debian based systems (Ubuntu, etc.): sudo apt install libudev-dev
To install OpenCV:
MacOS: brew install opencv
Linux: sudo apt install libopencv-dev
Windows: choco install opencv
To install PCL:
MacOS: brew install pcl
Linux: sudo apt install libpcl-dev
Using Python bindings
Installing the latest pre-released version of the library can be done with:
python3 -m pip install --extra-index-url https://artifacts.luxonis.com/artifactory/luxonis-python-release-local/ --pre -U depthai
or by running:
python3 examples/python/install_requirements.py on the branch you want to install
For more specific information about Python bindings, see Python README.
Building
Make sure submodules are updated
git submodule update --init --recursive
Then configure and build
cmake -S . -B build
cmake --build build --parallel [num CPU cores]
On Windows it’s often required to specify the location of the OpenCV installation. In case you used chocolatey to install OpenCV, you can use the following command:
cmake -S . -B build -DOpenCV_DIR=C:/tools/opencv/build -DCMAKE_BUILD_TYPE=Release
cmake --build build --config Release --parallel [num CPU cores]
ℹ️ To speed up build times, use
cmake --build build --parallel [num CPU cores].
File truncated at 100 lines see the full file
Changelog for package depthai
3.9.0 (2026-08-17)
## Features
-
Beta features namespace
- Staging area for experimental DepthAI nodes and features
- Enables faster support for features whose public API may change without prior notice
- All nodes run natively on RVC4 and on the host for RVC2
- All parsers and unique messages from [depthai_nodes]{.title-ref} are ported over and have native support
- Parsers have exposed runtime configuration changes via config messages
- [Python](https://github.com/luxonis/depthai-core/tree/main/examples/python/Beta) and [C++ examples](https://github.com/luxonis/depthai-core/tree/main/examples/cpp/Beta) are available
-
[_RVC2_] PoE Bootloader update
- Embedded Bootloader version updated to v0.0.29
- Greatly improves RVC2 PoE device discoverability by fixing stale connection information that could result in [X_LINK_DEVICE_NOT_FOUND]{.title-ref} errors
- The bootloader is backward- and forward-compatible and independent of the DepthAI version
- Updating the recoverable _user bootloader is recommended for devices with frequent discovery failures. For full integration, we recommend flashing the _factory bootloader.
- The following three flashing paths are available:
- For a GUI experience, use [device_manager.py](https://github.com/luxonis/depthai-core/blob/main/utilities/device_manager.py). The update function is accessible within the "danger zone" section
- Using the provided [flash_network_bootloader.py](https://github.com/luxonis/depthai-core/blob/main/utilities/flash_network_bootloader.py) script. By default, the script flashes the _user bootloader; use the [-f]{.title-ref} flag to enable factory flashing
- Using the CLI command [depthai --flash <device_ip>]{.title-ref}. By default, the command flashes the _user bootloader; use the [-f]{.title-ref} flag to enable factory flashing
- For more information, follow the [tutorial](https://docs.luxonis.com/software-v3/depthai/depthai-components/bootloader) in our docs
-
[_RVC4_] Alpha parameter for image undistortion
- StereoDepth node now properly handles alpha scaling of undistortion on RVC4
- Camera output requests now accept an optional [alphaScaling]{.title-ref} value for controlling the balance between cropping and retaining the full field of view
-
Depth colorization utility
- Added [dai::utility::colorizeDepthFrame]{.title-ref} in C++ and [dai.utility.colorizeDepthFrame]{.title-ref} in Python
- Supports [ImgFrame]{.title-ref}, OpenCV matrices, configurable depth ranges and color maps, and logarithmic or linear scaling
- Can automatically derive visualization bounds from valid depth pixels and render invalid pixels as black
-
[*RVC4*] VideoEncoder improvements
- Improved latency for 4000 x 3000 H.264, H.265, and MJPEG encoding
- Fixed an issue where [setKeyframeFrequency]{.title-ref} had no effect on RVC4
## Bug fixes
-
[*RVC4*] 480 FPS mode
- Fixed a regression from 3.7.1 where the ImageManip pool size was too small to properly support 480 FPS HFR mode
- ImageManip can now grow its output pool when it is running low on frames
- Added [setMaxPoolSize]{.title-ref} to cap the maximum output-pool size
- [_RVC2] Added a total power limit for DOT and FLOOD projectors to avoid power resets on the RVC2 ToF 63D sensor
- [RVC2] SpatialLocationCalculator now remaps regions of interest correctly when the depth input is not aligned
- Fixed YOLOv6 and YOLOv6-R1 decoding, including stride-based box reconstruction and confidence handling
- Rectification now uses the transformations carried by its input frames and reinitializes when those transformations change
- Fixed ImageManip four-point transform did not account for normalized coordinates
- Fixed colorization flicker and inconsistent frame rates in the ToF examples
- ReplayVideo now reports a runtime error when FFmpeg cannot open a video instead of relying on an assertion
## Misc
- Added a [getConnectedCameras(CameraSensorType)]{.title-ref} overload for filtering connected cameras by sensor type
- Reworked stereo-pair discovery to consider only connected and
calibrated cameras with compatible sensors, valid extrinsics, and
suitable orientation
- Stereo pairs are now ordered by descending baseline length
- [cam_test.py]{.title-ref} now selects supported resolutions from the connected camera features instead of assuming 1280 x 800
File truncated at 100 lines see the full file
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged depthai_v3 at Robotics Stack Exchange
|
depthai_v3 package from depthai repodepthai_v3 |
ROS Distro
|
Package Summary
| Version | 3.9.0 |
| License | MIT |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/luxonis/depthai-core.git |
| VCS Type | git |
| VCS Version | ros-old-devel |
| Last Updated | 2026-08-17 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Aljaž Sebastjan Ahtik
Authors
- Martin Peterlin
DepthAI Library
DepthAI library for interfacing with Luxonis DepthAI hardware. It’s written in C++ and offers Python bindings out of the box.
Important — You’re viewing the
v3.x.ybranch.
- For production projects that still rely on v2, check out the
v2_stablebranch.- Need to migrate? Follow the step-by-step v2 → v3 Porting Guide.
Documentation
Documentation is available over at Luxonis DepthAI API
Examples
Examples for both C++ and Python are available in the examples folder. To see how to build and run them see README.md for more information.
To build the examples in C++ configure with the following option added:
cmake -S. -Bbuild -D'DEPTHAI_BUILD_EXAMPLES=ON'
cmake --build build
Beta features
The beta namespace is a staging area for experimental DepthAI features. It
allows new features to be developed and iterated on quickly before they are
promoted to the main depthai namespace.
Beta features are well-developed, but minor API and behavioral changes may occur between DepthAI releases without notice.
In C++, beta nodes are available under dai::beta::node:
auto node = pipeline.create<dai::beta::node::ImgDetectionsFilter>();
In Python, they are available under dai.beta.node:
node = pipeline.create(dai.beta.node.ImgDetectionsFilter)
On-device execution of Beta nodes is supported only on RVC4. If running Beta nodes on RVC2, DepthAI automatically configures beta nodes to run on the host.
Dependencies
- CMake >= 3.20
- C/C++17 compiler
- [Linux] libudev >= 1.0.0
- [optional] OpenCV 4 (required if building examples and for record and replay)
- [optional] PCL (required for point cloud example)
To install libudev on Debian based systems (Ubuntu, etc.): sudo apt install libudev-dev
To install OpenCV:
MacOS: brew install opencv
Linux: sudo apt install libopencv-dev
Windows: choco install opencv
To install PCL:
MacOS: brew install pcl
Linux: sudo apt install libpcl-dev
Using Python bindings
Installing the latest pre-released version of the library can be done with:
python3 -m pip install --extra-index-url https://artifacts.luxonis.com/artifactory/luxonis-python-release-local/ --pre -U depthai
or by running:
python3 examples/python/install_requirements.py on the branch you want to install
For more specific information about Python bindings, see Python README.
Building
Make sure submodules are updated
git submodule update --init --recursive
Then configure and build
cmake -S . -B build
cmake --build build --parallel [num CPU cores]
On Windows it’s often required to specify the location of the OpenCV installation. In case you used chocolatey to install OpenCV, you can use the following command:
cmake -S . -B build -DOpenCV_DIR=C:/tools/opencv/build -DCMAKE_BUILD_TYPE=Release
cmake --build build --config Release --parallel [num CPU cores]
ℹ️ To speed up build times, use
cmake --build build --parallel [num CPU cores].
File truncated at 100 lines see the full file
Changelog for package depthai
3.9.0 (2026-08-17)
## Features
-
Beta features namespace
- Staging area for experimental DepthAI nodes and features
- Enables faster support for features whose public API may change without prior notice
- All nodes run natively on RVC4 and on the host for RVC2
- All parsers and unique messages from [depthai_nodes]{.title-ref} are ported over and have native support
- Parsers have exposed runtime configuration changes via config messages
- [Python](https://github.com/luxonis/depthai-core/tree/main/examples/python/Beta) and [C++ examples](https://github.com/luxonis/depthai-core/tree/main/examples/cpp/Beta) are available
-
[_RVC2_] PoE Bootloader update
- Embedded Bootloader version updated to v0.0.29
- Greatly improves RVC2 PoE device discoverability by fixing stale connection information that could result in [X_LINK_DEVICE_NOT_FOUND]{.title-ref} errors
- The bootloader is backward- and forward-compatible and independent of the DepthAI version
- Updating the recoverable _user bootloader is recommended for devices with frequent discovery failures. For full integration, we recommend flashing the _factory bootloader.
- The following three flashing paths are available:
- For a GUI experience, use [device_manager.py](https://github.com/luxonis/depthai-core/blob/main/utilities/device_manager.py). The update function is accessible within the "danger zone" section
- Using the provided [flash_network_bootloader.py](https://github.com/luxonis/depthai-core/blob/main/utilities/flash_network_bootloader.py) script. By default, the script flashes the _user bootloader; use the [-f]{.title-ref} flag to enable factory flashing
- Using the CLI command [depthai --flash <device_ip>]{.title-ref}. By default, the command flashes the _user bootloader; use the [-f]{.title-ref} flag to enable factory flashing
- For more information, follow the [tutorial](https://docs.luxonis.com/software-v3/depthai/depthai-components/bootloader) in our docs
-
[_RVC4_] Alpha parameter for image undistortion
- StereoDepth node now properly handles alpha scaling of undistortion on RVC4
- Camera output requests now accept an optional [alphaScaling]{.title-ref} value for controlling the balance between cropping and retaining the full field of view
-
Depth colorization utility
- Added [dai::utility::colorizeDepthFrame]{.title-ref} in C++ and [dai.utility.colorizeDepthFrame]{.title-ref} in Python
- Supports [ImgFrame]{.title-ref}, OpenCV matrices, configurable depth ranges and color maps, and logarithmic or linear scaling
- Can automatically derive visualization bounds from valid depth pixels and render invalid pixels as black
-
[*RVC4*] VideoEncoder improvements
- Improved latency for 4000 x 3000 H.264, H.265, and MJPEG encoding
- Fixed an issue where [setKeyframeFrequency]{.title-ref} had no effect on RVC4
## Bug fixes
-
[*RVC4*] 480 FPS mode
- Fixed a regression from 3.7.1 where the ImageManip pool size was too small to properly support 480 FPS HFR mode
- ImageManip can now grow its output pool when it is running low on frames
- Added [setMaxPoolSize]{.title-ref} to cap the maximum output-pool size
- [_RVC2] Added a total power limit for DOT and FLOOD projectors to avoid power resets on the RVC2 ToF 63D sensor
- [RVC2] SpatialLocationCalculator now remaps regions of interest correctly when the depth input is not aligned
- Fixed YOLOv6 and YOLOv6-R1 decoding, including stride-based box reconstruction and confidence handling
- Rectification now uses the transformations carried by its input frames and reinitializes when those transformations change
- Fixed ImageManip four-point transform did not account for normalized coordinates
- Fixed colorization flicker and inconsistent frame rates in the ToF examples
- ReplayVideo now reports a runtime error when FFmpeg cannot open a video instead of relying on an assertion
## Misc
- Added a [getConnectedCameras(CameraSensorType)]{.title-ref} overload for filtering connected cameras by sensor type
- Reworked stereo-pair discovery to consider only connected and
calibrated cameras with compatible sensors, valid extrinsics, and
suitable orientation
- Stereo pairs are now ordered by descending baseline length
- [cam_test.py]{.title-ref} now selects supported resolutions from the connected camera features instead of assuming 1280 x 800
File truncated at 100 lines see the full file
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged depthai_v3 at Robotics Stack Exchange
|
depthai_v3 package from depthai repodepthai_v3 |
ROS Distro
|
Package Summary
| Version | 3.9.0 |
| License | MIT |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/luxonis/depthai-core.git |
| VCS Type | git |
| VCS Version | ros-old-devel |
| Last Updated | 2026-08-17 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Aljaž Sebastjan Ahtik
Authors
- Martin Peterlin
DepthAI Library
DepthAI library for interfacing with Luxonis DepthAI hardware. It’s written in C++ and offers Python bindings out of the box.
Important — You’re viewing the
v3.x.ybranch.
- For production projects that still rely on v2, check out the
v2_stablebranch.- Need to migrate? Follow the step-by-step v2 → v3 Porting Guide.
Documentation
Documentation is available over at Luxonis DepthAI API
Examples
Examples for both C++ and Python are available in the examples folder. To see how to build and run them see README.md for more information.
To build the examples in C++ configure with the following option added:
cmake -S. -Bbuild -D'DEPTHAI_BUILD_EXAMPLES=ON'
cmake --build build
Beta features
The beta namespace is a staging area for experimental DepthAI features. It
allows new features to be developed and iterated on quickly before they are
promoted to the main depthai namespace.
Beta features are well-developed, but minor API and behavioral changes may occur between DepthAI releases without notice.
In C++, beta nodes are available under dai::beta::node:
auto node = pipeline.create<dai::beta::node::ImgDetectionsFilter>();
In Python, they are available under dai.beta.node:
node = pipeline.create(dai.beta.node.ImgDetectionsFilter)
On-device execution of Beta nodes is supported only on RVC4. If running Beta nodes on RVC2, DepthAI automatically configures beta nodes to run on the host.
Dependencies
- CMake >= 3.20
- C/C++17 compiler
- [Linux] libudev >= 1.0.0
- [optional] OpenCV 4 (required if building examples and for record and replay)
- [optional] PCL (required for point cloud example)
To install libudev on Debian based systems (Ubuntu, etc.): sudo apt install libudev-dev
To install OpenCV:
MacOS: brew install opencv
Linux: sudo apt install libopencv-dev
Windows: choco install opencv
To install PCL:
MacOS: brew install pcl
Linux: sudo apt install libpcl-dev
Using Python bindings
Installing the latest pre-released version of the library can be done with:
python3 -m pip install --extra-index-url https://artifacts.luxonis.com/artifactory/luxonis-python-release-local/ --pre -U depthai
or by running:
python3 examples/python/install_requirements.py on the branch you want to install
For more specific information about Python bindings, see Python README.
Building
Make sure submodules are updated
git submodule update --init --recursive
Then configure and build
cmake -S . -B build
cmake --build build --parallel [num CPU cores]
On Windows it’s often required to specify the location of the OpenCV installation. In case you used chocolatey to install OpenCV, you can use the following command:
cmake -S . -B build -DOpenCV_DIR=C:/tools/opencv/build -DCMAKE_BUILD_TYPE=Release
cmake --build build --config Release --parallel [num CPU cores]
ℹ️ To speed up build times, use
cmake --build build --parallel [num CPU cores].
File truncated at 100 lines see the full file
Changelog for package depthai
3.9.0 (2026-08-17)
## Features
-
Beta features namespace
- Staging area for experimental DepthAI nodes and features
- Enables faster support for features whose public API may change without prior notice
- All nodes run natively on RVC4 and on the host for RVC2
- All parsers and unique messages from [depthai_nodes]{.title-ref} are ported over and have native support
- Parsers have exposed runtime configuration changes via config messages
- [Python](https://github.com/luxonis/depthai-core/tree/main/examples/python/Beta) and [C++ examples](https://github.com/luxonis/depthai-core/tree/main/examples/cpp/Beta) are available
-
[_RVC2_] PoE Bootloader update
- Embedded Bootloader version updated to v0.0.29
- Greatly improves RVC2 PoE device discoverability by fixing stale connection information that could result in [X_LINK_DEVICE_NOT_FOUND]{.title-ref} errors
- The bootloader is backward- and forward-compatible and independent of the DepthAI version
- Updating the recoverable _user bootloader is recommended for devices with frequent discovery failures. For full integration, we recommend flashing the _factory bootloader.
- The following three flashing paths are available:
- For a GUI experience, use [device_manager.py](https://github.com/luxonis/depthai-core/blob/main/utilities/device_manager.py). The update function is accessible within the "danger zone" section
- Using the provided [flash_network_bootloader.py](https://github.com/luxonis/depthai-core/blob/main/utilities/flash_network_bootloader.py) script. By default, the script flashes the _user bootloader; use the [-f]{.title-ref} flag to enable factory flashing
- Using the CLI command [depthai --flash <device_ip>]{.title-ref}. By default, the command flashes the _user bootloader; use the [-f]{.title-ref} flag to enable factory flashing
- For more information, follow the [tutorial](https://docs.luxonis.com/software-v3/depthai/depthai-components/bootloader) in our docs
-
[_RVC4_] Alpha parameter for image undistortion
- StereoDepth node now properly handles alpha scaling of undistortion on RVC4
- Camera output requests now accept an optional [alphaScaling]{.title-ref} value for controlling the balance between cropping and retaining the full field of view
-
Depth colorization utility
- Added [dai::utility::colorizeDepthFrame]{.title-ref} in C++ and [dai.utility.colorizeDepthFrame]{.title-ref} in Python
- Supports [ImgFrame]{.title-ref}, OpenCV matrices, configurable depth ranges and color maps, and logarithmic or linear scaling
- Can automatically derive visualization bounds from valid depth pixels and render invalid pixels as black
-
[*RVC4*] VideoEncoder improvements
- Improved latency for 4000 x 3000 H.264, H.265, and MJPEG encoding
- Fixed an issue where [setKeyframeFrequency]{.title-ref} had no effect on RVC4
## Bug fixes
-
[*RVC4*] 480 FPS mode
- Fixed a regression from 3.7.1 where the ImageManip pool size was too small to properly support 480 FPS HFR mode
- ImageManip can now grow its output pool when it is running low on frames
- Added [setMaxPoolSize]{.title-ref} to cap the maximum output-pool size
- [_RVC2] Added a total power limit for DOT and FLOOD projectors to avoid power resets on the RVC2 ToF 63D sensor
- [RVC2] SpatialLocationCalculator now remaps regions of interest correctly when the depth input is not aligned
- Fixed YOLOv6 and YOLOv6-R1 decoding, including stride-based box reconstruction and confidence handling
- Rectification now uses the transformations carried by its input frames and reinitializes when those transformations change
- Fixed ImageManip four-point transform did not account for normalized coordinates
- Fixed colorization flicker and inconsistent frame rates in the ToF examples
- ReplayVideo now reports a runtime error when FFmpeg cannot open a video instead of relying on an assertion
## Misc
- Added a [getConnectedCameras(CameraSensorType)]{.title-ref} overload for filtering connected cameras by sensor type
- Reworked stereo-pair discovery to consider only connected and
calibrated cameras with compatible sensors, valid extrinsics, and
suitable orientation
- Stereo pairs are now ordered by descending baseline length
- [cam_test.py]{.title-ref} now selects supported resolutions from the connected camera features instead of assuming 1280 x 800
File truncated at 100 lines see the full file
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged depthai_v3 at Robotics Stack Exchange
|
depthai_v3 package from depthai repodepthai_v3 |
ROS Distro
|
Package Summary
| Version | 3.9.0 |
| License | MIT |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/luxonis/depthai-core.git |
| VCS Type | git |
| VCS Version | ros-old-devel |
| Last Updated | 2026-08-17 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Aljaž Sebastjan Ahtik
Authors
- Martin Peterlin
DepthAI Library
DepthAI library for interfacing with Luxonis DepthAI hardware. It’s written in C++ and offers Python bindings out of the box.
Important — You’re viewing the
v3.x.ybranch.
- For production projects that still rely on v2, check out the
v2_stablebranch.- Need to migrate? Follow the step-by-step v2 → v3 Porting Guide.
Documentation
Documentation is available over at Luxonis DepthAI API
Examples
Examples for both C++ and Python are available in the examples folder. To see how to build and run them see README.md for more information.
To build the examples in C++ configure with the following option added:
cmake -S. -Bbuild -D'DEPTHAI_BUILD_EXAMPLES=ON'
cmake --build build
Beta features
The beta namespace is a staging area for experimental DepthAI features. It
allows new features to be developed and iterated on quickly before they are
promoted to the main depthai namespace.
Beta features are well-developed, but minor API and behavioral changes may occur between DepthAI releases without notice.
In C++, beta nodes are available under dai::beta::node:
auto node = pipeline.create<dai::beta::node::ImgDetectionsFilter>();
In Python, they are available under dai.beta.node:
node = pipeline.create(dai.beta.node.ImgDetectionsFilter)
On-device execution of Beta nodes is supported only on RVC4. If running Beta nodes on RVC2, DepthAI automatically configures beta nodes to run on the host.
Dependencies
- CMake >= 3.20
- C/C++17 compiler
- [Linux] libudev >= 1.0.0
- [optional] OpenCV 4 (required if building examples and for record and replay)
- [optional] PCL (required for point cloud example)
To install libudev on Debian based systems (Ubuntu, etc.): sudo apt install libudev-dev
To install OpenCV:
MacOS: brew install opencv
Linux: sudo apt install libopencv-dev
Windows: choco install opencv
To install PCL:
MacOS: brew install pcl
Linux: sudo apt install libpcl-dev
Using Python bindings
Installing the latest pre-released version of the library can be done with:
python3 -m pip install --extra-index-url https://artifacts.luxonis.com/artifactory/luxonis-python-release-local/ --pre -U depthai
or by running:
python3 examples/python/install_requirements.py on the branch you want to install
For more specific information about Python bindings, see Python README.
Building
Make sure submodules are updated
git submodule update --init --recursive
Then configure and build
cmake -S . -B build
cmake --build build --parallel [num CPU cores]
On Windows it’s often required to specify the location of the OpenCV installation. In case you used chocolatey to install OpenCV, you can use the following command:
cmake -S . -B build -DOpenCV_DIR=C:/tools/opencv/build -DCMAKE_BUILD_TYPE=Release
cmake --build build --config Release --parallel [num CPU cores]
ℹ️ To speed up build times, use
cmake --build build --parallel [num CPU cores].
File truncated at 100 lines see the full file
Changelog for package depthai
3.9.0 (2026-08-17)
## Features
-
Beta features namespace
- Staging area for experimental DepthAI nodes and features
- Enables faster support for features whose public API may change without prior notice
- All nodes run natively on RVC4 and on the host for RVC2
- All parsers and unique messages from [depthai_nodes]{.title-ref} are ported over and have native support
- Parsers have exposed runtime configuration changes via config messages
- [Python](https://github.com/luxonis/depthai-core/tree/main/examples/python/Beta) and [C++ examples](https://github.com/luxonis/depthai-core/tree/main/examples/cpp/Beta) are available
-
[_RVC2_] PoE Bootloader update
- Embedded Bootloader version updated to v0.0.29
- Greatly improves RVC2 PoE device discoverability by fixing stale connection information that could result in [X_LINK_DEVICE_NOT_FOUND]{.title-ref} errors
- The bootloader is backward- and forward-compatible and independent of the DepthAI version
- Updating the recoverable _user bootloader is recommended for devices with frequent discovery failures. For full integration, we recommend flashing the _factory bootloader.
- The following three flashing paths are available:
- For a GUI experience, use [device_manager.py](https://github.com/luxonis/depthai-core/blob/main/utilities/device_manager.py). The update function is accessible within the "danger zone" section
- Using the provided [flash_network_bootloader.py](https://github.com/luxonis/depthai-core/blob/main/utilities/flash_network_bootloader.py) script. By default, the script flashes the _user bootloader; use the [-f]{.title-ref} flag to enable factory flashing
- Using the CLI command [depthai --flash <device_ip>]{.title-ref}. By default, the command flashes the _user bootloader; use the [-f]{.title-ref} flag to enable factory flashing
- For more information, follow the [tutorial](https://docs.luxonis.com/software-v3/depthai/depthai-components/bootloader) in our docs
-
[_RVC4_] Alpha parameter for image undistortion
- StereoDepth node now properly handles alpha scaling of undistortion on RVC4
- Camera output requests now accept an optional [alphaScaling]{.title-ref} value for controlling the balance between cropping and retaining the full field of view
-
Depth colorization utility
- Added [dai::utility::colorizeDepthFrame]{.title-ref} in C++ and [dai.utility.colorizeDepthFrame]{.title-ref} in Python
- Supports [ImgFrame]{.title-ref}, OpenCV matrices, configurable depth ranges and color maps, and logarithmic or linear scaling
- Can automatically derive visualization bounds from valid depth pixels and render invalid pixels as black
-
[*RVC4*] VideoEncoder improvements
- Improved latency for 4000 x 3000 H.264, H.265, and MJPEG encoding
- Fixed an issue where [setKeyframeFrequency]{.title-ref} had no effect on RVC4
## Bug fixes
-
[*RVC4*] 480 FPS mode
- Fixed a regression from 3.7.1 where the ImageManip pool size was too small to properly support 480 FPS HFR mode
- ImageManip can now grow its output pool when it is running low on frames
- Added [setMaxPoolSize]{.title-ref} to cap the maximum output-pool size
- [_RVC2] Added a total power limit for DOT and FLOOD projectors to avoid power resets on the RVC2 ToF 63D sensor
- [RVC2] SpatialLocationCalculator now remaps regions of interest correctly when the depth input is not aligned
- Fixed YOLOv6 and YOLOv6-R1 decoding, including stride-based box reconstruction and confidence handling
- Rectification now uses the transformations carried by its input frames and reinitializes when those transformations change
- Fixed ImageManip four-point transform did not account for normalized coordinates
- Fixed colorization flicker and inconsistent frame rates in the ToF examples
- ReplayVideo now reports a runtime error when FFmpeg cannot open a video instead of relying on an assertion
## Misc
- Added a [getConnectedCameras(CameraSensorType)]{.title-ref} overload for filtering connected cameras by sensor type
- Reworked stereo-pair discovery to consider only connected and
calibrated cameras with compatible sensors, valid extrinsics, and
suitable orientation
- Stereo pairs are now ordered by descending baseline length
- [cam_test.py]{.title-ref} now selects supported resolutions from the connected camera features instead of assuming 1280 x 800
File truncated at 100 lines see the full file
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged depthai_v3 at Robotics Stack Exchange
|
depthai_v3 package from depthai repodepthai_v3 |
ROS Distro
|
Package Summary
| Version | 3.9.0 |
| License | MIT |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/luxonis/depthai-core.git |
| VCS Type | git |
| VCS Version | ros-old-devel |
| Last Updated | 2026-08-17 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Aljaž Sebastjan Ahtik
Authors
- Martin Peterlin
DepthAI Library
DepthAI library for interfacing with Luxonis DepthAI hardware. It’s written in C++ and offers Python bindings out of the box.
Important — You’re viewing the
v3.x.ybranch.
- For production projects that still rely on v2, check out the
v2_stablebranch.- Need to migrate? Follow the step-by-step v2 → v3 Porting Guide.
Documentation
Documentation is available over at Luxonis DepthAI API
Examples
Examples for both C++ and Python are available in the examples folder. To see how to build and run them see README.md for more information.
To build the examples in C++ configure with the following option added:
cmake -S. -Bbuild -D'DEPTHAI_BUILD_EXAMPLES=ON'
cmake --build build
Beta features
The beta namespace is a staging area for experimental DepthAI features. It
allows new features to be developed and iterated on quickly before they are
promoted to the main depthai namespace.
Beta features are well-developed, but minor API and behavioral changes may occur between DepthAI releases without notice.
In C++, beta nodes are available under dai::beta::node:
auto node = pipeline.create<dai::beta::node::ImgDetectionsFilter>();
In Python, they are available under dai.beta.node:
node = pipeline.create(dai.beta.node.ImgDetectionsFilter)
On-device execution of Beta nodes is supported only on RVC4. If running Beta nodes on RVC2, DepthAI automatically configures beta nodes to run on the host.
Dependencies
- CMake >= 3.20
- C/C++17 compiler
- [Linux] libudev >= 1.0.0
- [optional] OpenCV 4 (required if building examples and for record and replay)
- [optional] PCL (required for point cloud example)
To install libudev on Debian based systems (Ubuntu, etc.): sudo apt install libudev-dev
To install OpenCV:
MacOS: brew install opencv
Linux: sudo apt install libopencv-dev
Windows: choco install opencv
To install PCL:
MacOS: brew install pcl
Linux: sudo apt install libpcl-dev
Using Python bindings
Installing the latest pre-released version of the library can be done with:
python3 -m pip install --extra-index-url https://artifacts.luxonis.com/artifactory/luxonis-python-release-local/ --pre -U depthai
or by running:
python3 examples/python/install_requirements.py on the branch you want to install
For more specific information about Python bindings, see Python README.
Building
Make sure submodules are updated
git submodule update --init --recursive
Then configure and build
cmake -S . -B build
cmake --build build --parallel [num CPU cores]
On Windows it’s often required to specify the location of the OpenCV installation. In case you used chocolatey to install OpenCV, you can use the following command:
cmake -S . -B build -DOpenCV_DIR=C:/tools/opencv/build -DCMAKE_BUILD_TYPE=Release
cmake --build build --config Release --parallel [num CPU cores]
ℹ️ To speed up build times, use
cmake --build build --parallel [num CPU cores].
File truncated at 100 lines see the full file
Changelog for package depthai
3.9.0 (2026-08-17)
## Features
-
Beta features namespace
- Staging area for experimental DepthAI nodes and features
- Enables faster support for features whose public API may change without prior notice
- All nodes run natively on RVC4 and on the host for RVC2
- All parsers and unique messages from [depthai_nodes]{.title-ref} are ported over and have native support
- Parsers have exposed runtime configuration changes via config messages
- [Python](https://github.com/luxonis/depthai-core/tree/main/examples/python/Beta) and [C++ examples](https://github.com/luxonis/depthai-core/tree/main/examples/cpp/Beta) are available
-
[_RVC2_] PoE Bootloader update
- Embedded Bootloader version updated to v0.0.29
- Greatly improves RVC2 PoE device discoverability by fixing stale connection information that could result in [X_LINK_DEVICE_NOT_FOUND]{.title-ref} errors
- The bootloader is backward- and forward-compatible and independent of the DepthAI version
- Updating the recoverable _user bootloader is recommended for devices with frequent discovery failures. For full integration, we recommend flashing the _factory bootloader.
- The following three flashing paths are available:
- For a GUI experience, use [device_manager.py](https://github.com/luxonis/depthai-core/blob/main/utilities/device_manager.py). The update function is accessible within the "danger zone" section
- Using the provided [flash_network_bootloader.py](https://github.com/luxonis/depthai-core/blob/main/utilities/flash_network_bootloader.py) script. By default, the script flashes the _user bootloader; use the [-f]{.title-ref} flag to enable factory flashing
- Using the CLI command [depthai --flash <device_ip>]{.title-ref}. By default, the command flashes the _user bootloader; use the [-f]{.title-ref} flag to enable factory flashing
- For more information, follow the [tutorial](https://docs.luxonis.com/software-v3/depthai/depthai-components/bootloader) in our docs
-
[_RVC4_] Alpha parameter for image undistortion
- StereoDepth node now properly handles alpha scaling of undistortion on RVC4
- Camera output requests now accept an optional [alphaScaling]{.title-ref} value for controlling the balance between cropping and retaining the full field of view
-
Depth colorization utility
- Added [dai::utility::colorizeDepthFrame]{.title-ref} in C++ and [dai.utility.colorizeDepthFrame]{.title-ref} in Python
- Supports [ImgFrame]{.title-ref}, OpenCV matrices, configurable depth ranges and color maps, and logarithmic or linear scaling
- Can automatically derive visualization bounds from valid depth pixels and render invalid pixels as black
-
[*RVC4*] VideoEncoder improvements
- Improved latency for 4000 x 3000 H.264, H.265, and MJPEG encoding
- Fixed an issue where [setKeyframeFrequency]{.title-ref} had no effect on RVC4
## Bug fixes
-
[*RVC4*] 480 FPS mode
- Fixed a regression from 3.7.1 where the ImageManip pool size was too small to properly support 480 FPS HFR mode
- ImageManip can now grow its output pool when it is running low on frames
- Added [setMaxPoolSize]{.title-ref} to cap the maximum output-pool size
- [_RVC2] Added a total power limit for DOT and FLOOD projectors to avoid power resets on the RVC2 ToF 63D sensor
- [RVC2] SpatialLocationCalculator now remaps regions of interest correctly when the depth input is not aligned
- Fixed YOLOv6 and YOLOv6-R1 decoding, including stride-based box reconstruction and confidence handling
- Rectification now uses the transformations carried by its input frames and reinitializes when those transformations change
- Fixed ImageManip four-point transform did not account for normalized coordinates
- Fixed colorization flicker and inconsistent frame rates in the ToF examples
- ReplayVideo now reports a runtime error when FFmpeg cannot open a video instead of relying on an assertion
## Misc
- Added a [getConnectedCameras(CameraSensorType)]{.title-ref} overload for filtering connected cameras by sensor type
- Reworked stereo-pair discovery to consider only connected and
calibrated cameras with compatible sensors, valid extrinsics, and
suitable orientation
- Stereo pairs are now ordered by descending baseline length
- [cam_test.py]{.title-ref} now selects supported resolutions from the connected camera features instead of assuming 1280 x 800
File truncated at 100 lines see the full file
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged depthai_v3 at Robotics Stack Exchange
|
depthai_v3 package from depthai repodepthai_v3 |
ROS Distro
|
Package Summary
| Version | 3.9.0 |
| License | MIT |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/luxonis/depthai-core.git |
| VCS Type | git |
| VCS Version | ros-old-devel |
| Last Updated | 2026-08-17 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Aljaž Sebastjan Ahtik
Authors
- Martin Peterlin
DepthAI Library
DepthAI library for interfacing with Luxonis DepthAI hardware. It’s written in C++ and offers Python bindings out of the box.
Important — You’re viewing the
v3.x.ybranch.
- For production projects that still rely on v2, check out the
v2_stablebranch.- Need to migrate? Follow the step-by-step v2 → v3 Porting Guide.
Documentation
Documentation is available over at Luxonis DepthAI API
Examples
Examples for both C++ and Python are available in the examples folder. To see how to build and run them see README.md for more information.
To build the examples in C++ configure with the following option added:
cmake -S. -Bbuild -D'DEPTHAI_BUILD_EXAMPLES=ON'
cmake --build build
Beta features
The beta namespace is a staging area for experimental DepthAI features. It
allows new features to be developed and iterated on quickly before they are
promoted to the main depthai namespace.
Beta features are well-developed, but minor API and behavioral changes may occur between DepthAI releases without notice.
In C++, beta nodes are available under dai::beta::node:
auto node = pipeline.create<dai::beta::node::ImgDetectionsFilter>();
In Python, they are available under dai.beta.node:
node = pipeline.create(dai.beta.node.ImgDetectionsFilter)
On-device execution of Beta nodes is supported only on RVC4. If running Beta nodes on RVC2, DepthAI automatically configures beta nodes to run on the host.
Dependencies
- CMake >= 3.20
- C/C++17 compiler
- [Linux] libudev >= 1.0.0
- [optional] OpenCV 4 (required if building examples and for record and replay)
- [optional] PCL (required for point cloud example)
To install libudev on Debian based systems (Ubuntu, etc.): sudo apt install libudev-dev
To install OpenCV:
MacOS: brew install opencv
Linux: sudo apt install libopencv-dev
Windows: choco install opencv
To install PCL:
MacOS: brew install pcl
Linux: sudo apt install libpcl-dev
Using Python bindings
Installing the latest pre-released version of the library can be done with:
python3 -m pip install --extra-index-url https://artifacts.luxonis.com/artifactory/luxonis-python-release-local/ --pre -U depthai
or by running:
python3 examples/python/install_requirements.py on the branch you want to install
For more specific information about Python bindings, see Python README.
Building
Make sure submodules are updated
git submodule update --init --recursive
Then configure and build
cmake -S . -B build
cmake --build build --parallel [num CPU cores]
On Windows it’s often required to specify the location of the OpenCV installation. In case you used chocolatey to install OpenCV, you can use the following command:
cmake -S . -B build -DOpenCV_DIR=C:/tools/opencv/build -DCMAKE_BUILD_TYPE=Release
cmake --build build --config Release --parallel [num CPU cores]
ℹ️ To speed up build times, use
cmake --build build --parallel [num CPU cores].
File truncated at 100 lines see the full file
Changelog for package depthai
3.9.0 (2026-08-17)
## Features
-
Beta features namespace
- Staging area for experimental DepthAI nodes and features
- Enables faster support for features whose public API may change without prior notice
- All nodes run natively on RVC4 and on the host for RVC2
- All parsers and unique messages from [depthai_nodes]{.title-ref} are ported over and have native support
- Parsers have exposed runtime configuration changes via config messages
- [Python](https://github.com/luxonis/depthai-core/tree/main/examples/python/Beta) and [C++ examples](https://github.com/luxonis/depthai-core/tree/main/examples/cpp/Beta) are available
-
[_RVC2_] PoE Bootloader update
- Embedded Bootloader version updated to v0.0.29
- Greatly improves RVC2 PoE device discoverability by fixing stale connection information that could result in [X_LINK_DEVICE_NOT_FOUND]{.title-ref} errors
- The bootloader is backward- and forward-compatible and independent of the DepthAI version
- Updating the recoverable _user bootloader is recommended for devices with frequent discovery failures. For full integration, we recommend flashing the _factory bootloader.
- The following three flashing paths are available:
- For a GUI experience, use [device_manager.py](https://github.com/luxonis/depthai-core/blob/main/utilities/device_manager.py). The update function is accessible within the "danger zone" section
- Using the provided [flash_network_bootloader.py](https://github.com/luxonis/depthai-core/blob/main/utilities/flash_network_bootloader.py) script. By default, the script flashes the _user bootloader; use the [-f]{.title-ref} flag to enable factory flashing
- Using the CLI command [depthai --flash <device_ip>]{.title-ref}. By default, the command flashes the _user bootloader; use the [-f]{.title-ref} flag to enable factory flashing
- For more information, follow the [tutorial](https://docs.luxonis.com/software-v3/depthai/depthai-components/bootloader) in our docs
-
[_RVC4_] Alpha parameter for image undistortion
- StereoDepth node now properly handles alpha scaling of undistortion on RVC4
- Camera output requests now accept an optional [alphaScaling]{.title-ref} value for controlling the balance between cropping and retaining the full field of view
-
Depth colorization utility
- Added [dai::utility::colorizeDepthFrame]{.title-ref} in C++ and [dai.utility.colorizeDepthFrame]{.title-ref} in Python
- Supports [ImgFrame]{.title-ref}, OpenCV matrices, configurable depth ranges and color maps, and logarithmic or linear scaling
- Can automatically derive visualization bounds from valid depth pixels and render invalid pixels as black
-
[*RVC4*] VideoEncoder improvements
- Improved latency for 4000 x 3000 H.264, H.265, and MJPEG encoding
- Fixed an issue where [setKeyframeFrequency]{.title-ref} had no effect on RVC4
## Bug fixes
-
[*RVC4*] 480 FPS mode
- Fixed a regression from 3.7.1 where the ImageManip pool size was too small to properly support 480 FPS HFR mode
- ImageManip can now grow its output pool when it is running low on frames
- Added [setMaxPoolSize]{.title-ref} to cap the maximum output-pool size
- [_RVC2] Added a total power limit for DOT and FLOOD projectors to avoid power resets on the RVC2 ToF 63D sensor
- [RVC2] SpatialLocationCalculator now remaps regions of interest correctly when the depth input is not aligned
- Fixed YOLOv6 and YOLOv6-R1 decoding, including stride-based box reconstruction and confidence handling
- Rectification now uses the transformations carried by its input frames and reinitializes when those transformations change
- Fixed ImageManip four-point transform did not account for normalized coordinates
- Fixed colorization flicker and inconsistent frame rates in the ToF examples
- ReplayVideo now reports a runtime error when FFmpeg cannot open a video instead of relying on an assertion
## Misc
- Added a [getConnectedCameras(CameraSensorType)]{.title-ref} overload for filtering connected cameras by sensor type
- Reworked stereo-pair discovery to consider only connected and
calibrated cameras with compatible sensors, valid extrinsics, and
suitable orientation
- Stereo pairs are now ordered by descending baseline length
- [cam_test.py]{.title-ref} now selects supported resolutions from the connected camera features instead of assuming 1280 x 800
File truncated at 100 lines see the full file
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged depthai_v3 at Robotics Stack Exchange
|
depthai_v3 package from depthai repodepthai_v3 |
ROS Distro
|
Package Summary
| Version | 3.9.0 |
| License | MIT |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/luxonis/depthai-core.git |
| VCS Type | git |
| VCS Version | ros-old-devel |
| Last Updated | 2026-08-17 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Aljaž Sebastjan Ahtik
Authors
- Martin Peterlin
DepthAI Library
DepthAI library for interfacing with Luxonis DepthAI hardware. It’s written in C++ and offers Python bindings out of the box.
Important — You’re viewing the
v3.x.ybranch.
- For production projects that still rely on v2, check out the
v2_stablebranch.- Need to migrate? Follow the step-by-step v2 → v3 Porting Guide.
Documentation
Documentation is available over at Luxonis DepthAI API
Examples
Examples for both C++ and Python are available in the examples folder. To see how to build and run them see README.md for more information.
To build the examples in C++ configure with the following option added:
cmake -S. -Bbuild -D'DEPTHAI_BUILD_EXAMPLES=ON'
cmake --build build
Beta features
The beta namespace is a staging area for experimental DepthAI features. It
allows new features to be developed and iterated on quickly before they are
promoted to the main depthai namespace.
Beta features are well-developed, but minor API and behavioral changes may occur between DepthAI releases without notice.
In C++, beta nodes are available under dai::beta::node:
auto node = pipeline.create<dai::beta::node::ImgDetectionsFilter>();
In Python, they are available under dai.beta.node:
node = pipeline.create(dai.beta.node.ImgDetectionsFilter)
On-device execution of Beta nodes is supported only on RVC4. If running Beta nodes on RVC2, DepthAI automatically configures beta nodes to run on the host.
Dependencies
- CMake >= 3.20
- C/C++17 compiler
- [Linux] libudev >= 1.0.0
- [optional] OpenCV 4 (required if building examples and for record and replay)
- [optional] PCL (required for point cloud example)
To install libudev on Debian based systems (Ubuntu, etc.): sudo apt install libudev-dev
To install OpenCV:
MacOS: brew install opencv
Linux: sudo apt install libopencv-dev
Windows: choco install opencv
To install PCL:
MacOS: brew install pcl
Linux: sudo apt install libpcl-dev
Using Python bindings
Installing the latest pre-released version of the library can be done with:
python3 -m pip install --extra-index-url https://artifacts.luxonis.com/artifactory/luxonis-python-release-local/ --pre -U depthai
or by running:
python3 examples/python/install_requirements.py on the branch you want to install
For more specific information about Python bindings, see Python README.
Building
Make sure submodules are updated
git submodule update --init --recursive
Then configure and build
cmake -S . -B build
cmake --build build --parallel [num CPU cores]
On Windows it’s often required to specify the location of the OpenCV installation. In case you used chocolatey to install OpenCV, you can use the following command:
cmake -S . -B build -DOpenCV_DIR=C:/tools/opencv/build -DCMAKE_BUILD_TYPE=Release
cmake --build build --config Release --parallel [num CPU cores]
ℹ️ To speed up build times, use
cmake --build build --parallel [num CPU cores].
File truncated at 100 lines see the full file
Changelog for package depthai
3.9.0 (2026-08-17)
## Features
-
Beta features namespace
- Staging area for experimental DepthAI nodes and features
- Enables faster support for features whose public API may change without prior notice
- All nodes run natively on RVC4 and on the host for RVC2
- All parsers and unique messages from [depthai_nodes]{.title-ref} are ported over and have native support
- Parsers have exposed runtime configuration changes via config messages
- [Python](https://github.com/luxonis/depthai-core/tree/main/examples/python/Beta) and [C++ examples](https://github.com/luxonis/depthai-core/tree/main/examples/cpp/Beta) are available
-
[_RVC2_] PoE Bootloader update
- Embedded Bootloader version updated to v0.0.29
- Greatly improves RVC2 PoE device discoverability by fixing stale connection information that could result in [X_LINK_DEVICE_NOT_FOUND]{.title-ref} errors
- The bootloader is backward- and forward-compatible and independent of the DepthAI version
- Updating the recoverable _user bootloader is recommended for devices with frequent discovery failures. For full integration, we recommend flashing the _factory bootloader.
- The following three flashing paths are available:
- For a GUI experience, use [device_manager.py](https://github.com/luxonis/depthai-core/blob/main/utilities/device_manager.py). The update function is accessible within the "danger zone" section
- Using the provided [flash_network_bootloader.py](https://github.com/luxonis/depthai-core/blob/main/utilities/flash_network_bootloader.py) script. By default, the script flashes the _user bootloader; use the [-f]{.title-ref} flag to enable factory flashing
- Using the CLI command [depthai --flash <device_ip>]{.title-ref}. By default, the command flashes the _user bootloader; use the [-f]{.title-ref} flag to enable factory flashing
- For more information, follow the [tutorial](https://docs.luxonis.com/software-v3/depthai/depthai-components/bootloader) in our docs
-
[_RVC4_] Alpha parameter for image undistortion
- StereoDepth node now properly handles alpha scaling of undistortion on RVC4
- Camera output requests now accept an optional [alphaScaling]{.title-ref} value for controlling the balance between cropping and retaining the full field of view
-
Depth colorization utility
- Added [dai::utility::colorizeDepthFrame]{.title-ref} in C++ and [dai.utility.colorizeDepthFrame]{.title-ref} in Python
- Supports [ImgFrame]{.title-ref}, OpenCV matrices, configurable depth ranges and color maps, and logarithmic or linear scaling
- Can automatically derive visualization bounds from valid depth pixels and render invalid pixels as black
-
[*RVC4*] VideoEncoder improvements
- Improved latency for 4000 x 3000 H.264, H.265, and MJPEG encoding
- Fixed an issue where [setKeyframeFrequency]{.title-ref} had no effect on RVC4
## Bug fixes
-
[*RVC4*] 480 FPS mode
- Fixed a regression from 3.7.1 where the ImageManip pool size was too small to properly support 480 FPS HFR mode
- ImageManip can now grow its output pool when it is running low on frames
- Added [setMaxPoolSize]{.title-ref} to cap the maximum output-pool size
- [_RVC2] Added a total power limit for DOT and FLOOD projectors to avoid power resets on the RVC2 ToF 63D sensor
- [RVC2] SpatialLocationCalculator now remaps regions of interest correctly when the depth input is not aligned
- Fixed YOLOv6 and YOLOv6-R1 decoding, including stride-based box reconstruction and confidence handling
- Rectification now uses the transformations carried by its input frames and reinitializes when those transformations change
- Fixed ImageManip four-point transform did not account for normalized coordinates
- Fixed colorization flicker and inconsistent frame rates in the ToF examples
- ReplayVideo now reports a runtime error when FFmpeg cannot open a video instead of relying on an assertion
## Misc
- Added a [getConnectedCameras(CameraSensorType)]{.title-ref} overload for filtering connected cameras by sensor type
- Reworked stereo-pair discovery to consider only connected and
calibrated cameras with compatible sensors, valid extrinsics, and
suitable orientation
- Stereo pairs are now ordered by descending baseline length
- [cam_test.py]{.title-ref} now selects supported resolutions from the connected camera features instead of assuming 1280 x 800
File truncated at 100 lines see the full file
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged depthai_v3 at Robotics Stack Exchange
|
depthai_v3 package from depthai repodepthai_v3 |
ROS Distro
|
Package Summary
| Version | 3.9.0 |
| License | MIT |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/luxonis/depthai-core.git |
| VCS Type | git |
| VCS Version | ros-old-devel |
| Last Updated | 2026-08-17 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Aljaž Sebastjan Ahtik
Authors
- Martin Peterlin
DepthAI Library
DepthAI library for interfacing with Luxonis DepthAI hardware. It’s written in C++ and offers Python bindings out of the box.
Important — You’re viewing the
v3.x.ybranch.
- For production projects that still rely on v2, check out the
v2_stablebranch.- Need to migrate? Follow the step-by-step v2 → v3 Porting Guide.
Documentation
Documentation is available over at Luxonis DepthAI API
Examples
Examples for both C++ and Python are available in the examples folder. To see how to build and run them see README.md for more information.
To build the examples in C++ configure with the following option added:
cmake -S. -Bbuild -D'DEPTHAI_BUILD_EXAMPLES=ON'
cmake --build build
Beta features
The beta namespace is a staging area for experimental DepthAI features. It
allows new features to be developed and iterated on quickly before they are
promoted to the main depthai namespace.
Beta features are well-developed, but minor API and behavioral changes may occur between DepthAI releases without notice.
In C++, beta nodes are available under dai::beta::node:
auto node = pipeline.create<dai::beta::node::ImgDetectionsFilter>();
In Python, they are available under dai.beta.node:
node = pipeline.create(dai.beta.node.ImgDetectionsFilter)
On-device execution of Beta nodes is supported only on RVC4. If running Beta nodes on RVC2, DepthAI automatically configures beta nodes to run on the host.
Dependencies
- CMake >= 3.20
- C/C++17 compiler
- [Linux] libudev >= 1.0.0
- [optional] OpenCV 4 (required if building examples and for record and replay)
- [optional] PCL (required for point cloud example)
To install libudev on Debian based systems (Ubuntu, etc.): sudo apt install libudev-dev
To install OpenCV:
MacOS: brew install opencv
Linux: sudo apt install libopencv-dev
Windows: choco install opencv
To install PCL:
MacOS: brew install pcl
Linux: sudo apt install libpcl-dev
Using Python bindings
Installing the latest pre-released version of the library can be done with:
python3 -m pip install --extra-index-url https://artifacts.luxonis.com/artifactory/luxonis-python-release-local/ --pre -U depthai
or by running:
python3 examples/python/install_requirements.py on the branch you want to install
For more specific information about Python bindings, see Python README.
Building
Make sure submodules are updated
git submodule update --init --recursive
Then configure and build
cmake -S . -B build
cmake --build build --parallel [num CPU cores]
On Windows it’s often required to specify the location of the OpenCV installation. In case you used chocolatey to install OpenCV, you can use the following command:
cmake -S . -B build -DOpenCV_DIR=C:/tools/opencv/build -DCMAKE_BUILD_TYPE=Release
cmake --build build --config Release --parallel [num CPU cores]
ℹ️ To speed up build times, use
cmake --build build --parallel [num CPU cores].
File truncated at 100 lines see the full file
Changelog for package depthai
3.9.0 (2026-08-17)
## Features
-
Beta features namespace
- Staging area for experimental DepthAI nodes and features
- Enables faster support for features whose public API may change without prior notice
- All nodes run natively on RVC4 and on the host for RVC2
- All parsers and unique messages from [depthai_nodes]{.title-ref} are ported over and have native support
- Parsers have exposed runtime configuration changes via config messages
- [Python](https://github.com/luxonis/depthai-core/tree/main/examples/python/Beta) and [C++ examples](https://github.com/luxonis/depthai-core/tree/main/examples/cpp/Beta) are available
-
[_RVC2_] PoE Bootloader update
- Embedded Bootloader version updated to v0.0.29
- Greatly improves RVC2 PoE device discoverability by fixing stale connection information that could result in [X_LINK_DEVICE_NOT_FOUND]{.title-ref} errors
- The bootloader is backward- and forward-compatible and independent of the DepthAI version
- Updating the recoverable _user bootloader is recommended for devices with frequent discovery failures. For full integration, we recommend flashing the _factory bootloader.
- The following three flashing paths are available:
- For a GUI experience, use [device_manager.py](https://github.com/luxonis/depthai-core/blob/main/utilities/device_manager.py). The update function is accessible within the "danger zone" section
- Using the provided [flash_network_bootloader.py](https://github.com/luxonis/depthai-core/blob/main/utilities/flash_network_bootloader.py) script. By default, the script flashes the _user bootloader; use the [-f]{.title-ref} flag to enable factory flashing
- Using the CLI command [depthai --flash <device_ip>]{.title-ref}. By default, the command flashes the _user bootloader; use the [-f]{.title-ref} flag to enable factory flashing
- For more information, follow the [tutorial](https://docs.luxonis.com/software-v3/depthai/depthai-components/bootloader) in our docs
-
[_RVC4_] Alpha parameter for image undistortion
- StereoDepth node now properly handles alpha scaling of undistortion on RVC4
- Camera output requests now accept an optional [alphaScaling]{.title-ref} value for controlling the balance between cropping and retaining the full field of view
-
Depth colorization utility
- Added [dai::utility::colorizeDepthFrame]{.title-ref} in C++ and [dai.utility.colorizeDepthFrame]{.title-ref} in Python
- Supports [ImgFrame]{.title-ref}, OpenCV matrices, configurable depth ranges and color maps, and logarithmic or linear scaling
- Can automatically derive visualization bounds from valid depth pixels and render invalid pixels as black
-
[*RVC4*] VideoEncoder improvements
- Improved latency for 4000 x 3000 H.264, H.265, and MJPEG encoding
- Fixed an issue where [setKeyframeFrequency]{.title-ref} had no effect on RVC4
## Bug fixes
-
[*RVC4*] 480 FPS mode
- Fixed a regression from 3.7.1 where the ImageManip pool size was too small to properly support 480 FPS HFR mode
- ImageManip can now grow its output pool when it is running low on frames
- Added [setMaxPoolSize]{.title-ref} to cap the maximum output-pool size
- [_RVC2] Added a total power limit for DOT and FLOOD projectors to avoid power resets on the RVC2 ToF 63D sensor
- [RVC2] SpatialLocationCalculator now remaps regions of interest correctly when the depth input is not aligned
- Fixed YOLOv6 and YOLOv6-R1 decoding, including stride-based box reconstruction and confidence handling
- Rectification now uses the transformations carried by its input frames and reinitializes when those transformations change
- Fixed ImageManip four-point transform did not account for normalized coordinates
- Fixed colorization flicker and inconsistent frame rates in the ToF examples
- ReplayVideo now reports a runtime error when FFmpeg cannot open a video instead of relying on an assertion
## Misc
- Added a [getConnectedCameras(CameraSensorType)]{.title-ref} overload for filtering connected cameras by sensor type
- Reworked stereo-pair discovery to consider only connected and
calibrated cameras with compatible sensors, valid extrinsics, and
suitable orientation
- Stereo pairs are now ordered by descending baseline length
- [cam_test.py]{.title-ref} now selects supported resolutions from the connected camera features instead of assuming 1280 x 800
File truncated at 100 lines see the full file
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged depthai_v3 at Robotics Stack Exchange
|
depthai_v3 package from depthai repodepthai_v3 |
ROS Distro
|
Package Summary
| Version | 3.9.0 |
| License | MIT |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/luxonis/depthai-core.git |
| VCS Type | git |
| VCS Version | ros-old-devel |
| Last Updated | 2026-08-17 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Aljaž Sebastjan Ahtik
Authors
- Martin Peterlin
DepthAI Library
DepthAI library for interfacing with Luxonis DepthAI hardware. It’s written in C++ and offers Python bindings out of the box.
Important — You’re viewing the
v3.x.ybranch.
- For production projects that still rely on v2, check out the
v2_stablebranch.- Need to migrate? Follow the step-by-step v2 → v3 Porting Guide.
Documentation
Documentation is available over at Luxonis DepthAI API
Examples
Examples for both C++ and Python are available in the examples folder. To see how to build and run them see README.md for more information.
To build the examples in C++ configure with the following option added:
cmake -S. -Bbuild -D'DEPTHAI_BUILD_EXAMPLES=ON'
cmake --build build
Beta features
The beta namespace is a staging area for experimental DepthAI features. It
allows new features to be developed and iterated on quickly before they are
promoted to the main depthai namespace.
Beta features are well-developed, but minor API and behavioral changes may occur between DepthAI releases without notice.
In C++, beta nodes are available under dai::beta::node:
auto node = pipeline.create<dai::beta::node::ImgDetectionsFilter>();
In Python, they are available under dai.beta.node:
node = pipeline.create(dai.beta.node.ImgDetectionsFilter)
On-device execution of Beta nodes is supported only on RVC4. If running Beta nodes on RVC2, DepthAI automatically configures beta nodes to run on the host.
Dependencies
- CMake >= 3.20
- C/C++17 compiler
- [Linux] libudev >= 1.0.0
- [optional] OpenCV 4 (required if building examples and for record and replay)
- [optional] PCL (required for point cloud example)
To install libudev on Debian based systems (Ubuntu, etc.): sudo apt install libudev-dev
To install OpenCV:
MacOS: brew install opencv
Linux: sudo apt install libopencv-dev
Windows: choco install opencv
To install PCL:
MacOS: brew install pcl
Linux: sudo apt install libpcl-dev
Using Python bindings
Installing the latest pre-released version of the library can be done with:
python3 -m pip install --extra-index-url https://artifacts.luxonis.com/artifactory/luxonis-python-release-local/ --pre -U depthai
or by running:
python3 examples/python/install_requirements.py on the branch you want to install
For more specific information about Python bindings, see Python README.
Building
Make sure submodules are updated
git submodule update --init --recursive
Then configure and build
cmake -S . -B build
cmake --build build --parallel [num CPU cores]
On Windows it’s often required to specify the location of the OpenCV installation. In case you used chocolatey to install OpenCV, you can use the following command:
cmake -S . -B build -DOpenCV_DIR=C:/tools/opencv/build -DCMAKE_BUILD_TYPE=Release
cmake --build build --config Release --parallel [num CPU cores]
ℹ️ To speed up build times, use
cmake --build build --parallel [num CPU cores].
File truncated at 100 lines see the full file
Changelog for package depthai
3.9.0 (2026-08-17)
## Features
-
Beta features namespace
- Staging area for experimental DepthAI nodes and features
- Enables faster support for features whose public API may change without prior notice
- All nodes run natively on RVC4 and on the host for RVC2
- All parsers and unique messages from [depthai_nodes]{.title-ref} are ported over and have native support
- Parsers have exposed runtime configuration changes via config messages
- [Python](https://github.com/luxonis/depthai-core/tree/main/examples/python/Beta) and [C++ examples](https://github.com/luxonis/depthai-core/tree/main/examples/cpp/Beta) are available
-
[_RVC2_] PoE Bootloader update
- Embedded Bootloader version updated to v0.0.29
- Greatly improves RVC2 PoE device discoverability by fixing stale connection information that could result in [X_LINK_DEVICE_NOT_FOUND]{.title-ref} errors
- The bootloader is backward- and forward-compatible and independent of the DepthAI version
- Updating the recoverable _user bootloader is recommended for devices with frequent discovery failures. For full integration, we recommend flashing the _factory bootloader.
- The following three flashing paths are available:
- For a GUI experience, use [device_manager.py](https://github.com/luxonis/depthai-core/blob/main/utilities/device_manager.py). The update function is accessible within the "danger zone" section
- Using the provided [flash_network_bootloader.py](https://github.com/luxonis/depthai-core/blob/main/utilities/flash_network_bootloader.py) script. By default, the script flashes the _user bootloader; use the [-f]{.title-ref} flag to enable factory flashing
- Using the CLI command [depthai --flash <device_ip>]{.title-ref}. By default, the command flashes the _user bootloader; use the [-f]{.title-ref} flag to enable factory flashing
- For more information, follow the [tutorial](https://docs.luxonis.com/software-v3/depthai/depthai-components/bootloader) in our docs
-
[_RVC4_] Alpha parameter for image undistortion
- StereoDepth node now properly handles alpha scaling of undistortion on RVC4
- Camera output requests now accept an optional [alphaScaling]{.title-ref} value for controlling the balance between cropping and retaining the full field of view
-
Depth colorization utility
- Added [dai::utility::colorizeDepthFrame]{.title-ref} in C++ and [dai.utility.colorizeDepthFrame]{.title-ref} in Python
- Supports [ImgFrame]{.title-ref}, OpenCV matrices, configurable depth ranges and color maps, and logarithmic or linear scaling
- Can automatically derive visualization bounds from valid depth pixels and render invalid pixels as black
-
[*RVC4*] VideoEncoder improvements
- Improved latency for 4000 x 3000 H.264, H.265, and MJPEG encoding
- Fixed an issue where [setKeyframeFrequency]{.title-ref} had no effect on RVC4
## Bug fixes
-
[*RVC4*] 480 FPS mode
- Fixed a regression from 3.7.1 where the ImageManip pool size was too small to properly support 480 FPS HFR mode
- ImageManip can now grow its output pool when it is running low on frames
- Added [setMaxPoolSize]{.title-ref} to cap the maximum output-pool size
- [_RVC2] Added a total power limit for DOT and FLOOD projectors to avoid power resets on the RVC2 ToF 63D sensor
- [RVC2] SpatialLocationCalculator now remaps regions of interest correctly when the depth input is not aligned
- Fixed YOLOv6 and YOLOv6-R1 decoding, including stride-based box reconstruction and confidence handling
- Rectification now uses the transformations carried by its input frames and reinitializes when those transformations change
- Fixed ImageManip four-point transform did not account for normalized coordinates
- Fixed colorization flicker and inconsistent frame rates in the ToF examples
- ReplayVideo now reports a runtime error when FFmpeg cannot open a video instead of relying on an assertion
## Misc
- Added a [getConnectedCameras(CameraSensorType)]{.title-ref} overload for filtering connected cameras by sensor type
- Reworked stereo-pair discovery to consider only connected and
calibrated cameras with compatible sensors, valid extrinsics, and
suitable orientation
- Stereo pairs are now ordered by descending baseline length
- [cam_test.py]{.title-ref} now selects supported resolutions from the connected camera features instead of assuming 1280 x 800
File truncated at 100 lines see the full file
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged depthai_v3 at Robotics Stack Exchange
|
depthai_v3 package from depthai repodepthai_v3 |
ROS Distro
|
Package Summary
| Version | 3.9.0 |
| License | MIT |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/luxonis/depthai-core.git |
| VCS Type | git |
| VCS Version | ros-old-devel |
| Last Updated | 2026-08-17 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Aljaž Sebastjan Ahtik
Authors
- Martin Peterlin
DepthAI Library
DepthAI library for interfacing with Luxonis DepthAI hardware. It’s written in C++ and offers Python bindings out of the box.
Important — You’re viewing the
v3.x.ybranch.
- For production projects that still rely on v2, check out the
v2_stablebranch.- Need to migrate? Follow the step-by-step v2 → v3 Porting Guide.
Documentation
Documentation is available over at Luxonis DepthAI API
Examples
Examples for both C++ and Python are available in the examples folder. To see how to build and run them see README.md for more information.
To build the examples in C++ configure with the following option added:
cmake -S. -Bbuild -D'DEPTHAI_BUILD_EXAMPLES=ON'
cmake --build build
Beta features
The beta namespace is a staging area for experimental DepthAI features. It
allows new features to be developed and iterated on quickly before they are
promoted to the main depthai namespace.
Beta features are well-developed, but minor API and behavioral changes may occur between DepthAI releases without notice.
In C++, beta nodes are available under dai::beta::node:
auto node = pipeline.create<dai::beta::node::ImgDetectionsFilter>();
In Python, they are available under dai.beta.node:
node = pipeline.create(dai.beta.node.ImgDetectionsFilter)
On-device execution of Beta nodes is supported only on RVC4. If running Beta nodes on RVC2, DepthAI automatically configures beta nodes to run on the host.
Dependencies
- CMake >= 3.20
- C/C++17 compiler
- [Linux] libudev >= 1.0.0
- [optional] OpenCV 4 (required if building examples and for record and replay)
- [optional] PCL (required for point cloud example)
To install libudev on Debian based systems (Ubuntu, etc.): sudo apt install libudev-dev
To install OpenCV:
MacOS: brew install opencv
Linux: sudo apt install libopencv-dev
Windows: choco install opencv
To install PCL:
MacOS: brew install pcl
Linux: sudo apt install libpcl-dev
Using Python bindings
Installing the latest pre-released version of the library can be done with:
python3 -m pip install --extra-index-url https://artifacts.luxonis.com/artifactory/luxonis-python-release-local/ --pre -U depthai
or by running:
python3 examples/python/install_requirements.py on the branch you want to install
For more specific information about Python bindings, see Python README.
Building
Make sure submodules are updated
git submodule update --init --recursive
Then configure and build
cmake -S . -B build
cmake --build build --parallel [num CPU cores]
On Windows it’s often required to specify the location of the OpenCV installation. In case you used chocolatey to install OpenCV, you can use the following command:
cmake -S . -B build -DOpenCV_DIR=C:/tools/opencv/build -DCMAKE_BUILD_TYPE=Release
cmake --build build --config Release --parallel [num CPU cores]
ℹ️ To speed up build times, use
cmake --build build --parallel [num CPU cores].
File truncated at 100 lines see the full file
Changelog for package depthai
3.9.0 (2026-08-17)
## Features
-
Beta features namespace
- Staging area for experimental DepthAI nodes and features
- Enables faster support for features whose public API may change without prior notice
- All nodes run natively on RVC4 and on the host for RVC2
- All parsers and unique messages from [depthai_nodes]{.title-ref} are ported over and have native support
- Parsers have exposed runtime configuration changes via config messages
- [Python](https://github.com/luxonis/depthai-core/tree/main/examples/python/Beta) and [C++ examples](https://github.com/luxonis/depthai-core/tree/main/examples/cpp/Beta) are available
-
[_RVC2_] PoE Bootloader update
- Embedded Bootloader version updated to v0.0.29
- Greatly improves RVC2 PoE device discoverability by fixing stale connection information that could result in [X_LINK_DEVICE_NOT_FOUND]{.title-ref} errors
- The bootloader is backward- and forward-compatible and independent of the DepthAI version
- Updating the recoverable _user bootloader is recommended for devices with frequent discovery failures. For full integration, we recommend flashing the _factory bootloader.
- The following three flashing paths are available:
- For a GUI experience, use [device_manager.py](https://github.com/luxonis/depthai-core/blob/main/utilities/device_manager.py). The update function is accessible within the "danger zone" section
- Using the provided [flash_network_bootloader.py](https://github.com/luxonis/depthai-core/blob/main/utilities/flash_network_bootloader.py) script. By default, the script flashes the _user bootloader; use the [-f]{.title-ref} flag to enable factory flashing
- Using the CLI command [depthai --flash <device_ip>]{.title-ref}. By default, the command flashes the _user bootloader; use the [-f]{.title-ref} flag to enable factory flashing
- For more information, follow the [tutorial](https://docs.luxonis.com/software-v3/depthai/depthai-components/bootloader) in our docs
-
[_RVC4_] Alpha parameter for image undistortion
- StereoDepth node now properly handles alpha scaling of undistortion on RVC4
- Camera output requests now accept an optional [alphaScaling]{.title-ref} value for controlling the balance between cropping and retaining the full field of view
-
Depth colorization utility
- Added [dai::utility::colorizeDepthFrame]{.title-ref} in C++ and [dai.utility.colorizeDepthFrame]{.title-ref} in Python
- Supports [ImgFrame]{.title-ref}, OpenCV matrices, configurable depth ranges and color maps, and logarithmic or linear scaling
- Can automatically derive visualization bounds from valid depth pixels and render invalid pixels as black
-
[*RVC4*] VideoEncoder improvements
- Improved latency for 4000 x 3000 H.264, H.265, and MJPEG encoding
- Fixed an issue where [setKeyframeFrequency]{.title-ref} had no effect on RVC4
## Bug fixes
-
[*RVC4*] 480 FPS mode
- Fixed a regression from 3.7.1 where the ImageManip pool size was too small to properly support 480 FPS HFR mode
- ImageManip can now grow its output pool when it is running low on frames
- Added [setMaxPoolSize]{.title-ref} to cap the maximum output-pool size
- [_RVC2] Added a total power limit for DOT and FLOOD projectors to avoid power resets on the RVC2 ToF 63D sensor
- [RVC2] SpatialLocationCalculator now remaps regions of interest correctly when the depth input is not aligned
- Fixed YOLOv6 and YOLOv6-R1 decoding, including stride-based box reconstruction and confidence handling
- Rectification now uses the transformations carried by its input frames and reinitializes when those transformations change
- Fixed ImageManip four-point transform did not account for normalized coordinates
- Fixed colorization flicker and inconsistent frame rates in the ToF examples
- ReplayVideo now reports a runtime error when FFmpeg cannot open a video instead of relying on an assertion
## Misc
- Added a [getConnectedCameras(CameraSensorType)]{.title-ref} overload for filtering connected cameras by sensor type
- Reworked stereo-pair discovery to consider only connected and
calibrated cameras with compatible sensors, valid extrinsics, and
suitable orientation
- Stereo pairs are now ordered by descending baseline length
- [cam_test.py]{.title-ref} now selects supported resolutions from the connected camera features instead of assuming 1280 x 800
File truncated at 100 lines see the full file
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged depthai_v3 at Robotics Stack Exchange
|
depthai_v3 package from depthai repodepthai_v3 |
ROS Distro
|
Package Summary
| Version | 3.9.0 |
| License | MIT |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/luxonis/depthai-core.git |
| VCS Type | git |
| VCS Version | ros-old-devel |
| Last Updated | 2026-08-17 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Aljaž Sebastjan Ahtik
Authors
- Martin Peterlin
DepthAI Library
DepthAI library for interfacing with Luxonis DepthAI hardware. It’s written in C++ and offers Python bindings out of the box.
Important — You’re viewing the
v3.x.ybranch.
- For production projects that still rely on v2, check out the
v2_stablebranch.- Need to migrate? Follow the step-by-step v2 → v3 Porting Guide.
Documentation
Documentation is available over at Luxonis DepthAI API
Examples
Examples for both C++ and Python are available in the examples folder. To see how to build and run them see README.md for more information.
To build the examples in C++ configure with the following option added:
cmake -S. -Bbuild -D'DEPTHAI_BUILD_EXAMPLES=ON'
cmake --build build
Beta features
The beta namespace is a staging area for experimental DepthAI features. It
allows new features to be developed and iterated on quickly before they are
promoted to the main depthai namespace.
Beta features are well-developed, but minor API and behavioral changes may occur between DepthAI releases without notice.
In C++, beta nodes are available under dai::beta::node:
auto node = pipeline.create<dai::beta::node::ImgDetectionsFilter>();
In Python, they are available under dai.beta.node:
node = pipeline.create(dai.beta.node.ImgDetectionsFilter)
On-device execution of Beta nodes is supported only on RVC4. If running Beta nodes on RVC2, DepthAI automatically configures beta nodes to run on the host.
Dependencies
- CMake >= 3.20
- C/C++17 compiler
- [Linux] libudev >= 1.0.0
- [optional] OpenCV 4 (required if building examples and for record and replay)
- [optional] PCL (required for point cloud example)
To install libudev on Debian based systems (Ubuntu, etc.): sudo apt install libudev-dev
To install OpenCV:
MacOS: brew install opencv
Linux: sudo apt install libopencv-dev
Windows: choco install opencv
To install PCL:
MacOS: brew install pcl
Linux: sudo apt install libpcl-dev
Using Python bindings
Installing the latest pre-released version of the library can be done with:
python3 -m pip install --extra-index-url https://artifacts.luxonis.com/artifactory/luxonis-python-release-local/ --pre -U depthai
or by running:
python3 examples/python/install_requirements.py on the branch you want to install
For more specific information about Python bindings, see Python README.
Building
Make sure submodules are updated
git submodule update --init --recursive
Then configure and build
cmake -S . -B build
cmake --build build --parallel [num CPU cores]
On Windows it’s often required to specify the location of the OpenCV installation. In case you used chocolatey to install OpenCV, you can use the following command:
cmake -S . -B build -DOpenCV_DIR=C:/tools/opencv/build -DCMAKE_BUILD_TYPE=Release
cmake --build build --config Release --parallel [num CPU cores]
ℹ️ To speed up build times, use
cmake --build build --parallel [num CPU cores].
File truncated at 100 lines see the full file
Changelog for package depthai
3.9.0 (2026-08-17)
## Features
-
Beta features namespace
- Staging area for experimental DepthAI nodes and features
- Enables faster support for features whose public API may change without prior notice
- All nodes run natively on RVC4 and on the host for RVC2
- All parsers and unique messages from [depthai_nodes]{.title-ref} are ported over and have native support
- Parsers have exposed runtime configuration changes via config messages
- [Python](https://github.com/luxonis/depthai-core/tree/main/examples/python/Beta) and [C++ examples](https://github.com/luxonis/depthai-core/tree/main/examples/cpp/Beta) are available
-
[_RVC2_] PoE Bootloader update
- Embedded Bootloader version updated to v0.0.29
- Greatly improves RVC2 PoE device discoverability by fixing stale connection information that could result in [X_LINK_DEVICE_NOT_FOUND]{.title-ref} errors
- The bootloader is backward- and forward-compatible and independent of the DepthAI version
- Updating the recoverable _user bootloader is recommended for devices with frequent discovery failures. For full integration, we recommend flashing the _factory bootloader.
- The following three flashing paths are available:
- For a GUI experience, use [device_manager.py](https://github.com/luxonis/depthai-core/blob/main/utilities/device_manager.py). The update function is accessible within the "danger zone" section
- Using the provided [flash_network_bootloader.py](https://github.com/luxonis/depthai-core/blob/main/utilities/flash_network_bootloader.py) script. By default, the script flashes the _user bootloader; use the [-f]{.title-ref} flag to enable factory flashing
- Using the CLI command [depthai --flash <device_ip>]{.title-ref}. By default, the command flashes the _user bootloader; use the [-f]{.title-ref} flag to enable factory flashing
- For more information, follow the [tutorial](https://docs.luxonis.com/software-v3/depthai/depthai-components/bootloader) in our docs
-
[_RVC4_] Alpha parameter for image undistortion
- StereoDepth node now properly handles alpha scaling of undistortion on RVC4
- Camera output requests now accept an optional [alphaScaling]{.title-ref} value for controlling the balance between cropping and retaining the full field of view
-
Depth colorization utility
- Added [dai::utility::colorizeDepthFrame]{.title-ref} in C++ and [dai.utility.colorizeDepthFrame]{.title-ref} in Python
- Supports [ImgFrame]{.title-ref}, OpenCV matrices, configurable depth ranges and color maps, and logarithmic or linear scaling
- Can automatically derive visualization bounds from valid depth pixels and render invalid pixels as black
-
[*RVC4*] VideoEncoder improvements
- Improved latency for 4000 x 3000 H.264, H.265, and MJPEG encoding
- Fixed an issue where [setKeyframeFrequency]{.title-ref} had no effect on RVC4
## Bug fixes
-
[*RVC4*] 480 FPS mode
- Fixed a regression from 3.7.1 where the ImageManip pool size was too small to properly support 480 FPS HFR mode
- ImageManip can now grow its output pool when it is running low on frames
- Added [setMaxPoolSize]{.title-ref} to cap the maximum output-pool size
- [_RVC2] Added a total power limit for DOT and FLOOD projectors to avoid power resets on the RVC2 ToF 63D sensor
- [RVC2] SpatialLocationCalculator now remaps regions of interest correctly when the depth input is not aligned
- Fixed YOLOv6 and YOLOv6-R1 decoding, including stride-based box reconstruction and confidence handling
- Rectification now uses the transformations carried by its input frames and reinitializes when those transformations change
- Fixed ImageManip four-point transform did not account for normalized coordinates
- Fixed colorization flicker and inconsistent frame rates in the ToF examples
- ReplayVideo now reports a runtime error when FFmpeg cannot open a video instead of relying on an assertion
## Misc
- Added a [getConnectedCameras(CameraSensorType)]{.title-ref} overload for filtering connected cameras by sensor type
- Reworked stereo-pair discovery to consider only connected and
calibrated cameras with compatible sensors, valid extrinsics, and
suitable orientation
- Stereo pairs are now ordered by descending baseline length
- [cam_test.py]{.title-ref} now selects supported resolutions from the connected camera features instead of assuming 1280 x 800
File truncated at 100 lines see the full file
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged depthai_v3 at Robotics Stack Exchange
|
depthai_v3 package from depthai repodepthai_v3 |
ROS Distro
|
Package Summary
| Version | 3.9.0 |
| License | MIT |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/luxonis/depthai-core.git |
| VCS Type | git |
| VCS Version | ros-old-devel |
| Last Updated | 2026-08-17 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Aljaž Sebastjan Ahtik
Authors
- Martin Peterlin
DepthAI Library
DepthAI library for interfacing with Luxonis DepthAI hardware. It’s written in C++ and offers Python bindings out of the box.
Important — You’re viewing the
v3.x.ybranch.
- For production projects that still rely on v2, check out the
v2_stablebranch.- Need to migrate? Follow the step-by-step v2 → v3 Porting Guide.
Documentation
Documentation is available over at Luxonis DepthAI API
Examples
Examples for both C++ and Python are available in the examples folder. To see how to build and run them see README.md for more information.
To build the examples in C++ configure with the following option added:
cmake -S. -Bbuild -D'DEPTHAI_BUILD_EXAMPLES=ON'
cmake --build build
Beta features
The beta namespace is a staging area for experimental DepthAI features. It
allows new features to be developed and iterated on quickly before they are
promoted to the main depthai namespace.
Beta features are well-developed, but minor API and behavioral changes may occur between DepthAI releases without notice.
In C++, beta nodes are available under dai::beta::node:
auto node = pipeline.create<dai::beta::node::ImgDetectionsFilter>();
In Python, they are available under dai.beta.node:
node = pipeline.create(dai.beta.node.ImgDetectionsFilter)
On-device execution of Beta nodes is supported only on RVC4. If running Beta nodes on RVC2, DepthAI automatically configures beta nodes to run on the host.
Dependencies
- CMake >= 3.20
- C/C++17 compiler
- [Linux] libudev >= 1.0.0
- [optional] OpenCV 4 (required if building examples and for record and replay)
- [optional] PCL (required for point cloud example)
To install libudev on Debian based systems (Ubuntu, etc.): sudo apt install libudev-dev
To install OpenCV:
MacOS: brew install opencv
Linux: sudo apt install libopencv-dev
Windows: choco install opencv
To install PCL:
MacOS: brew install pcl
Linux: sudo apt install libpcl-dev
Using Python bindings
Installing the latest pre-released version of the library can be done with:
python3 -m pip install --extra-index-url https://artifacts.luxonis.com/artifactory/luxonis-python-release-local/ --pre -U depthai
or by running:
python3 examples/python/install_requirements.py on the branch you want to install
For more specific information about Python bindings, see Python README.
Building
Make sure submodules are updated
git submodule update --init --recursive
Then configure and build
cmake -S . -B build
cmake --build build --parallel [num CPU cores]
On Windows it’s often required to specify the location of the OpenCV installation. In case you used chocolatey to install OpenCV, you can use the following command:
cmake -S . -B build -DOpenCV_DIR=C:/tools/opencv/build -DCMAKE_BUILD_TYPE=Release
cmake --build build --config Release --parallel [num CPU cores]
ℹ️ To speed up build times, use
cmake --build build --parallel [num CPU cores].
File truncated at 100 lines see the full file
Changelog for package depthai
3.9.0 (2026-08-17)
## Features
-
Beta features namespace
- Staging area for experimental DepthAI nodes and features
- Enables faster support for features whose public API may change without prior notice
- All nodes run natively on RVC4 and on the host for RVC2
- All parsers and unique messages from [depthai_nodes]{.title-ref} are ported over and have native support
- Parsers have exposed runtime configuration changes via config messages
- [Python](https://github.com/luxonis/depthai-core/tree/main/examples/python/Beta) and [C++ examples](https://github.com/luxonis/depthai-core/tree/main/examples/cpp/Beta) are available
-
[_RVC2_] PoE Bootloader update
- Embedded Bootloader version updated to v0.0.29
- Greatly improves RVC2 PoE device discoverability by fixing stale connection information that could result in [X_LINK_DEVICE_NOT_FOUND]{.title-ref} errors
- The bootloader is backward- and forward-compatible and independent of the DepthAI version
- Updating the recoverable _user bootloader is recommended for devices with frequent discovery failures. For full integration, we recommend flashing the _factory bootloader.
- The following three flashing paths are available:
- For a GUI experience, use [device_manager.py](https://github.com/luxonis/depthai-core/blob/main/utilities/device_manager.py). The update function is accessible within the "danger zone" section
- Using the provided [flash_network_bootloader.py](https://github.com/luxonis/depthai-core/blob/main/utilities/flash_network_bootloader.py) script. By default, the script flashes the _user bootloader; use the [-f]{.title-ref} flag to enable factory flashing
- Using the CLI command [depthai --flash <device_ip>]{.title-ref}. By default, the command flashes the _user bootloader; use the [-f]{.title-ref} flag to enable factory flashing
- For more information, follow the [tutorial](https://docs.luxonis.com/software-v3/depthai/depthai-components/bootloader) in our docs
-
[_RVC4_] Alpha parameter for image undistortion
- StereoDepth node now properly handles alpha scaling of undistortion on RVC4
- Camera output requests now accept an optional [alphaScaling]{.title-ref} value for controlling the balance between cropping and retaining the full field of view
-
Depth colorization utility
- Added [dai::utility::colorizeDepthFrame]{.title-ref} in C++ and [dai.utility.colorizeDepthFrame]{.title-ref} in Python
- Supports [ImgFrame]{.title-ref}, OpenCV matrices, configurable depth ranges and color maps, and logarithmic or linear scaling
- Can automatically derive visualization bounds from valid depth pixels and render invalid pixels as black
-
[*RVC4*] VideoEncoder improvements
- Improved latency for 4000 x 3000 H.264, H.265, and MJPEG encoding
- Fixed an issue where [setKeyframeFrequency]{.title-ref} had no effect on RVC4
## Bug fixes
-
[*RVC4*] 480 FPS mode
- Fixed a regression from 3.7.1 where the ImageManip pool size was too small to properly support 480 FPS HFR mode
- ImageManip can now grow its output pool when it is running low on frames
- Added [setMaxPoolSize]{.title-ref} to cap the maximum output-pool size
- [_RVC2] Added a total power limit for DOT and FLOOD projectors to avoid power resets on the RVC2 ToF 63D sensor
- [RVC2] SpatialLocationCalculator now remaps regions of interest correctly when the depth input is not aligned
- Fixed YOLOv6 and YOLOv6-R1 decoding, including stride-based box reconstruction and confidence handling
- Rectification now uses the transformations carried by its input frames and reinitializes when those transformations change
- Fixed ImageManip four-point transform did not account for normalized coordinates
- Fixed colorization flicker and inconsistent frame rates in the ToF examples
- ReplayVideo now reports a runtime error when FFmpeg cannot open a video instead of relying on an assertion
## Misc
- Added a [getConnectedCameras(CameraSensorType)]{.title-ref} overload for filtering connected cameras by sensor type
- Reworked stereo-pair discovery to consider only connected and
calibrated cameras with compatible sensors, valid extrinsics, and
suitable orientation
- Stereo pairs are now ordered by descending baseline length
- [cam_test.py]{.title-ref} now selects supported resolutions from the connected camera features instead of assuming 1280 x 800
File truncated at 100 lines see the full file
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged depthai_v3 at Robotics Stack Exchange
|
depthai_v3 package from depthai repodepthai_v3 |
ROS Distro
|
Package Summary
| Version | 3.9.0 |
| License | MIT |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/luxonis/depthai-core.git |
| VCS Type | git |
| VCS Version | ros-old-devel |
| Last Updated | 2026-08-17 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Aljaž Sebastjan Ahtik
Authors
- Martin Peterlin
DepthAI Library
DepthAI library for interfacing with Luxonis DepthAI hardware. It’s written in C++ and offers Python bindings out of the box.
Important — You’re viewing the
v3.x.ybranch.
- For production projects that still rely on v2, check out the
v2_stablebranch.- Need to migrate? Follow the step-by-step v2 → v3 Porting Guide.
Documentation
Documentation is available over at Luxonis DepthAI API
Examples
Examples for both C++ and Python are available in the examples folder. To see how to build and run them see README.md for more information.
To build the examples in C++ configure with the following option added:
cmake -S. -Bbuild -D'DEPTHAI_BUILD_EXAMPLES=ON'
cmake --build build
Beta features
The beta namespace is a staging area for experimental DepthAI features. It
allows new features to be developed and iterated on quickly before they are
promoted to the main depthai namespace.
Beta features are well-developed, but minor API and behavioral changes may occur between DepthAI releases without notice.
In C++, beta nodes are available under dai::beta::node:
auto node = pipeline.create<dai::beta::node::ImgDetectionsFilter>();
In Python, they are available under dai.beta.node:
node = pipeline.create(dai.beta.node.ImgDetectionsFilter)
On-device execution of Beta nodes is supported only on RVC4. If running Beta nodes on RVC2, DepthAI automatically configures beta nodes to run on the host.
Dependencies
- CMake >= 3.20
- C/C++17 compiler
- [Linux] libudev >= 1.0.0
- [optional] OpenCV 4 (required if building examples and for record and replay)
- [optional] PCL (required for point cloud example)
To install libudev on Debian based systems (Ubuntu, etc.): sudo apt install libudev-dev
To install OpenCV:
MacOS: brew install opencv
Linux: sudo apt install libopencv-dev
Windows: choco install opencv
To install PCL:
MacOS: brew install pcl
Linux: sudo apt install libpcl-dev
Using Python bindings
Installing the latest pre-released version of the library can be done with:
python3 -m pip install --extra-index-url https://artifacts.luxonis.com/artifactory/luxonis-python-release-local/ --pre -U depthai
or by running:
python3 examples/python/install_requirements.py on the branch you want to install
For more specific information about Python bindings, see Python README.
Building
Make sure submodules are updated
git submodule update --init --recursive
Then configure and build
cmake -S . -B build
cmake --build build --parallel [num CPU cores]
On Windows it’s often required to specify the location of the OpenCV installation. In case you used chocolatey to install OpenCV, you can use the following command:
cmake -S . -B build -DOpenCV_DIR=C:/tools/opencv/build -DCMAKE_BUILD_TYPE=Release
cmake --build build --config Release --parallel [num CPU cores]
ℹ️ To speed up build times, use
cmake --build build --parallel [num CPU cores].
File truncated at 100 lines see the full file
Changelog for package depthai
3.9.0 (2026-08-17)
## Features
-
Beta features namespace
- Staging area for experimental DepthAI nodes and features
- Enables faster support for features whose public API may change without prior notice
- All nodes run natively on RVC4 and on the host for RVC2
- All parsers and unique messages from [depthai_nodes]{.title-ref} are ported over and have native support
- Parsers have exposed runtime configuration changes via config messages
- [Python](https://github.com/luxonis/depthai-core/tree/main/examples/python/Beta) and [C++ examples](https://github.com/luxonis/depthai-core/tree/main/examples/cpp/Beta) are available
-
[_RVC2_] PoE Bootloader update
- Embedded Bootloader version updated to v0.0.29
- Greatly improves RVC2 PoE device discoverability by fixing stale connection information that could result in [X_LINK_DEVICE_NOT_FOUND]{.title-ref} errors
- The bootloader is backward- and forward-compatible and independent of the DepthAI version
- Updating the recoverable _user bootloader is recommended for devices with frequent discovery failures. For full integration, we recommend flashing the _factory bootloader.
- The following three flashing paths are available:
- For a GUI experience, use [device_manager.py](https://github.com/luxonis/depthai-core/blob/main/utilities/device_manager.py). The update function is accessible within the "danger zone" section
- Using the provided [flash_network_bootloader.py](https://github.com/luxonis/depthai-core/blob/main/utilities/flash_network_bootloader.py) script. By default, the script flashes the _user bootloader; use the [-f]{.title-ref} flag to enable factory flashing
- Using the CLI command [depthai --flash <device_ip>]{.title-ref}. By default, the command flashes the _user bootloader; use the [-f]{.title-ref} flag to enable factory flashing
- For more information, follow the [tutorial](https://docs.luxonis.com/software-v3/depthai/depthai-components/bootloader) in our docs
-
[_RVC4_] Alpha parameter for image undistortion
- StereoDepth node now properly handles alpha scaling of undistortion on RVC4
- Camera output requests now accept an optional [alphaScaling]{.title-ref} value for controlling the balance between cropping and retaining the full field of view
-
Depth colorization utility
- Added [dai::utility::colorizeDepthFrame]{.title-ref} in C++ and [dai.utility.colorizeDepthFrame]{.title-ref} in Python
- Supports [ImgFrame]{.title-ref}, OpenCV matrices, configurable depth ranges and color maps, and logarithmic or linear scaling
- Can automatically derive visualization bounds from valid depth pixels and render invalid pixels as black
-
[*RVC4*] VideoEncoder improvements
- Improved latency for 4000 x 3000 H.264, H.265, and MJPEG encoding
- Fixed an issue where [setKeyframeFrequency]{.title-ref} had no effect on RVC4
## Bug fixes
-
[*RVC4*] 480 FPS mode
- Fixed a regression from 3.7.1 where the ImageManip pool size was too small to properly support 480 FPS HFR mode
- ImageManip can now grow its output pool when it is running low on frames
- Added [setMaxPoolSize]{.title-ref} to cap the maximum output-pool size
- [_RVC2] Added a total power limit for DOT and FLOOD projectors to avoid power resets on the RVC2 ToF 63D sensor
- [RVC2] SpatialLocationCalculator now remaps regions of interest correctly when the depth input is not aligned
- Fixed YOLOv6 and YOLOv6-R1 decoding, including stride-based box reconstruction and confidence handling
- Rectification now uses the transformations carried by its input frames and reinitializes when those transformations change
- Fixed ImageManip four-point transform did not account for normalized coordinates
- Fixed colorization flicker and inconsistent frame rates in the ToF examples
- ReplayVideo now reports a runtime error when FFmpeg cannot open a video instead of relying on an assertion
## Misc
- Added a [getConnectedCameras(CameraSensorType)]{.title-ref} overload for filtering connected cameras by sensor type
- Reworked stereo-pair discovery to consider only connected and
calibrated cameras with compatible sensors, valid extrinsics, and
suitable orientation
- Stereo pairs are now ordered by descending baseline length
- [cam_test.py]{.title-ref} now selects supported resolutions from the connected camera features instead of assuming 1280 x 800
File truncated at 100 lines see the full file
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged depthai_v3 at Robotics Stack Exchange
|
depthai_v3 package from depthai repodepthai_v3 |
ROS Distro
|
Package Summary
| Version | 3.9.0 |
| License | MIT |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/luxonis/depthai-core.git |
| VCS Type | git |
| VCS Version | ros-old-devel |
| Last Updated | 2026-08-17 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Aljaž Sebastjan Ahtik
Authors
- Martin Peterlin
DepthAI Library
DepthAI library for interfacing with Luxonis DepthAI hardware. It’s written in C++ and offers Python bindings out of the box.
Important — You’re viewing the
v3.x.ybranch.
- For production projects that still rely on v2, check out the
v2_stablebranch.- Need to migrate? Follow the step-by-step v2 → v3 Porting Guide.
Documentation
Documentation is available over at Luxonis DepthAI API
Examples
Examples for both C++ and Python are available in the examples folder. To see how to build and run them see README.md for more information.
To build the examples in C++ configure with the following option added:
cmake -S. -Bbuild -D'DEPTHAI_BUILD_EXAMPLES=ON'
cmake --build build
Beta features
The beta namespace is a staging area for experimental DepthAI features. It
allows new features to be developed and iterated on quickly before they are
promoted to the main depthai namespace.
Beta features are well-developed, but minor API and behavioral changes may occur between DepthAI releases without notice.
In C++, beta nodes are available under dai::beta::node:
auto node = pipeline.create<dai::beta::node::ImgDetectionsFilter>();
In Python, they are available under dai.beta.node:
node = pipeline.create(dai.beta.node.ImgDetectionsFilter)
On-device execution of Beta nodes is supported only on RVC4. If running Beta nodes on RVC2, DepthAI automatically configures beta nodes to run on the host.
Dependencies
- CMake >= 3.20
- C/C++17 compiler
- [Linux] libudev >= 1.0.0
- [optional] OpenCV 4 (required if building examples and for record and replay)
- [optional] PCL (required for point cloud example)
To install libudev on Debian based systems (Ubuntu, etc.): sudo apt install libudev-dev
To install OpenCV:
MacOS: brew install opencv
Linux: sudo apt install libopencv-dev
Windows: choco install opencv
To install PCL:
MacOS: brew install pcl
Linux: sudo apt install libpcl-dev
Using Python bindings
Installing the latest pre-released version of the library can be done with:
python3 -m pip install --extra-index-url https://artifacts.luxonis.com/artifactory/luxonis-python-release-local/ --pre -U depthai
or by running:
python3 examples/python/install_requirements.py on the branch you want to install
For more specific information about Python bindings, see Python README.
Building
Make sure submodules are updated
git submodule update --init --recursive
Then configure and build
cmake -S . -B build
cmake --build build --parallel [num CPU cores]
On Windows it’s often required to specify the location of the OpenCV installation. In case you used chocolatey to install OpenCV, you can use the following command:
cmake -S . -B build -DOpenCV_DIR=C:/tools/opencv/build -DCMAKE_BUILD_TYPE=Release
cmake --build build --config Release --parallel [num CPU cores]
ℹ️ To speed up build times, use
cmake --build build --parallel [num CPU cores].
File truncated at 100 lines see the full file
Changelog for package depthai
3.9.0 (2026-08-17)
## Features
-
Beta features namespace
- Staging area for experimental DepthAI nodes and features
- Enables faster support for features whose public API may change without prior notice
- All nodes run natively on RVC4 and on the host for RVC2
- All parsers and unique messages from [depthai_nodes]{.title-ref} are ported over and have native support
- Parsers have exposed runtime configuration changes via config messages
- [Python](https://github.com/luxonis/depthai-core/tree/main/examples/python/Beta) and [C++ examples](https://github.com/luxonis/depthai-core/tree/main/examples/cpp/Beta) are available
-
[_RVC2_] PoE Bootloader update
- Embedded Bootloader version updated to v0.0.29
- Greatly improves RVC2 PoE device discoverability by fixing stale connection information that could result in [X_LINK_DEVICE_NOT_FOUND]{.title-ref} errors
- The bootloader is backward- and forward-compatible and independent of the DepthAI version
- Updating the recoverable _user bootloader is recommended for devices with frequent discovery failures. For full integration, we recommend flashing the _factory bootloader.
- The following three flashing paths are available:
- For a GUI experience, use [device_manager.py](https://github.com/luxonis/depthai-core/blob/main/utilities/device_manager.py). The update function is accessible within the "danger zone" section
- Using the provided [flash_network_bootloader.py](https://github.com/luxonis/depthai-core/blob/main/utilities/flash_network_bootloader.py) script. By default, the script flashes the _user bootloader; use the [-f]{.title-ref} flag to enable factory flashing
- Using the CLI command [depthai --flash <device_ip>]{.title-ref}. By default, the command flashes the _user bootloader; use the [-f]{.title-ref} flag to enable factory flashing
- For more information, follow the [tutorial](https://docs.luxonis.com/software-v3/depthai/depthai-components/bootloader) in our docs
-
[_RVC4_] Alpha parameter for image undistortion
- StereoDepth node now properly handles alpha scaling of undistortion on RVC4
- Camera output requests now accept an optional [alphaScaling]{.title-ref} value for controlling the balance between cropping and retaining the full field of view
-
Depth colorization utility
- Added [dai::utility::colorizeDepthFrame]{.title-ref} in C++ and [dai.utility.colorizeDepthFrame]{.title-ref} in Python
- Supports [ImgFrame]{.title-ref}, OpenCV matrices, configurable depth ranges and color maps, and logarithmic or linear scaling
- Can automatically derive visualization bounds from valid depth pixels and render invalid pixels as black
-
[*RVC4*] VideoEncoder improvements
- Improved latency for 4000 x 3000 H.264, H.265, and MJPEG encoding
- Fixed an issue where [setKeyframeFrequency]{.title-ref} had no effect on RVC4
## Bug fixes
-
[*RVC4*] 480 FPS mode
- Fixed a regression from 3.7.1 where the ImageManip pool size was too small to properly support 480 FPS HFR mode
- ImageManip can now grow its output pool when it is running low on frames
- Added [setMaxPoolSize]{.title-ref} to cap the maximum output-pool size
- [_RVC2] Added a total power limit for DOT and FLOOD projectors to avoid power resets on the RVC2 ToF 63D sensor
- [RVC2] SpatialLocationCalculator now remaps regions of interest correctly when the depth input is not aligned
- Fixed YOLOv6 and YOLOv6-R1 decoding, including stride-based box reconstruction and confidence handling
- Rectification now uses the transformations carried by its input frames and reinitializes when those transformations change
- Fixed ImageManip four-point transform did not account for normalized coordinates
- Fixed colorization flicker and inconsistent frame rates in the ToF examples
- ReplayVideo now reports a runtime error when FFmpeg cannot open a video instead of relying on an assertion
## Misc
- Added a [getConnectedCameras(CameraSensorType)]{.title-ref} overload for filtering connected cameras by sensor type
- Reworked stereo-pair discovery to consider only connected and
calibrated cameras with compatible sensors, valid extrinsics, and
suitable orientation
- Stereo pairs are now ordered by descending baseline length
- [cam_test.py]{.title-ref} now selects supported resolutions from the connected camera features instead of assuming 1280 x 800
File truncated at 100 lines see the full file