DepthAI C++ API

DepthAI C++ API can be found on Github luxonis/depthai-core. Below is the reference documentation for the C++ API.

namespace

dai

using

DepthUnit = LengthUnit

using

Edge = std::array< uint32_t, 2 >

using

NNArchiveConfig = std::variant< dai::nn_archive::v1::Config >

using

VisualizeType = std::variant< std::shared_ptr< ImgAnnotations >, std::shared_ptr< ImgFrame >, std::monostate >

using

MedianFilterParams = dai::filters::params::MedianFilter

using

SpatialFilterParams = dai::filters::params::SpatialFilter

using

SpeckleFilterParams = dai::filters::params::SpeckleFilter

using

TemporalFilterParams = dai::filters::params::TemporalFilter

using

FilterParams = std::variant< MedianFilterParams, SpatialFilterParams, SpeckleFilterParams, TemporalFilterParams >

using

Clock = std::chrono::steady_clock

static constant

constexpr static uint32_t BOARD_CONFIG_MAGIC1

static constant

constexpr static uint32_t BOARD_CONFIG_MAGIC2

static constant

constexpr const char * LOG_DEFAULT_PATTERN

constant

constexpr int MAX_UPPER_THRESHOLD

constant

constexpr int MIN_LOWER_THRESHOLD

static constant

constexpr static auto DEFAULT_SERIALIZATION_TYPE

inline function

std::string toString(CameraBoardSocket socket)

function

DEPTHAI_SERIALIZE_EXT(CameraSensorConfig, width, height, minFps, maxFps, fov, type)

inline function

std::string toString(CameraSensorType type)

function

DEPTHAI_SERIALIZE_EXT(ChipTemperature, css, mss, upa, dss, average)

function

DEPTHAI_SERIALIZE_EXT(ChipTemperatureRVC4, cpuss, gpuss, mdmss, video, ddr, camera, average)

function

DEPTHAI_SERIALIZE_EXT(Color, r, g, b, a)

function

DEPTHAI_SERIALIZE_EXT(CpuUsage, average, msTime)

constant function

constexpr float getSIPrefixMultiplier(SIPrefix unit)

constant function

constexpr float getLengthUnitMultiplier(LengthUnit unit)

function

 DEPTHAI_SERIALIZE_EXT(DetectionParserOptions, nnFamily, subtype, confidenceThreshold, decodingFamily, decodeKeypoints, decodeSegmentation, classes, classNames, coordinates, nKeypoints, strides, anchors, anchorMasks, outputNamesToUse, anchorsV2, iouThreshold, keypointEdges, keypointLabelNames)

function

 DEPTHAI_SERIALIZE_OPTIONAL_EXT(EepromData, version, boardCustom, boardName, boardRev, boardConf, hardwareConf, productName, deviceName, batchName, batchTime, boardOptions, cameraData, stereoRectificationData, imuExtrinsics, housingExtrinsics, miscellaneousData, stereoUseSpecTranslation, stereoEnableDistortionCorrection, verticalCameraSocket)

inline function

std::string toString(ExternalFrameSyncRole role)

inline function

std::string toString(HousingCoordinateSystem housing)

static inline function

const std::unordered_map< std::string, std::unordered_map< dai::HousingCoordinateSystem, std::array< float, 3 > > > & getHousingCoordinates()

function

DEPTHAI_SERIALIZE_EXT(MemoryInfo, remaining, used, total)

function

DEPTHAI_SERIALIZE_EXT(Point2f, x, y, normalized, hasNormalized)

function

DEPTHAI_SERIALIZE_EXT(Point3d, x, y, z)

function

DEPTHAI_SERIALIZE_EXT(Point3f, x, y, z)

function

DEPTHAI_SERIALIZE_EXT(Point3fRGBA, x, y, z, r, g, b, a)

function

DEPTHAI_SERIALIZE_EXT(Quaterniond, qx, qy, qz, qw)

function

DEPTHAI_SERIALIZE_EXT(Rect, x, y, width, height, normalized, hasNormalized)

function

DEPTHAI_SERIALIZE_EXT(RotatedRect, center, size, angle)

function

DEPTHAI_SERIALIZE_EXT(Size2f, width, height, normalized, hasNormalized)

function

 DEPTHAI_SERIALIZE_EXT(StereoRectification, rectifiedRotationLeft, rectifiedRotationRight, leftCameraSocket, rightCameraSocket)

function

 DEPTHAI_SERIALIZE_EXT(TensorInfo, order, dataType, numDimensions, dims, strides, name, offset, quantization, qpScale, qpZp)

inline function

std::ostream & operator<<(std::ostream & os, const TensorInfo::StorageOrder & so)

inline function

std::ostream & operator<<(std::ostream & os, const TensorInfo::DataType & dt)

function

DEPTHAI_SERIALIZE_EXT(Timestamp, sec, nsec)

function

DEPTHAI_SERIALIZE_EXT(BoardConfig::USB, vid, pid, flashBootedVid, flashBootedPid, maxSpeed, productName, manufacturer)

function

DEPTHAI_SERIALIZE_EXT(BoardConfig::Network, mtu, xlinkTcpNoDelay)

function

DEPTHAI_SERIALIZE_EXT(BoardConfig::GPIO, mode, direction, level, pull, drive, schmitt, slewFast)

function

DEPTHAI_SERIALIZE_EXT(BoardConfig::UART, tmp)

function

DEPTHAI_SERIALIZE_EXT(BoardConfig::Camera, name, sensorType, orientation)

function

DEPTHAI_SERIALIZE_EXT(BoardConfig::IMU, bus, interrupt, wake, csGpio, boot, reset)

function

DEPTHAI_SERIALIZE_EXT(BoardConfig::UVC, cameraName, width, height, frameType, enable)

function

 DEPTHAI_SERIALIZE_EXT(BoardConfig, usb, network, sysctl, watchdogTimeoutMs, watchdogInitialDelayMs, gpio, uart, pcieInternalClock, usb3PhyInternalClock, emmc, logPath, logSizeMax, logVerbosity, logDevicePrints, nonExclusiveMode, camera, imu, uvc, defaultImuExtr)

function

DEPTHAI_SERIALIZE_EXT(CrashDump, crashReports, depthaiCommitHash, deviceId)

function

std::string platform2string(Platform platform)

function

Platform string2platform(const std::string & platform)

function

DEPTHAI_SERIALIZE_EXT(LogMessage, nodeIdName, level, time, colorRangeStart, colorRangeEnd, payload)

function

fs::path getModelFromZoo(const NNModelDescription & modelDescription, bool useCached, const fs::path & cacheDirectory, const std::string & apiKey, const std::string & progressFormat)

function

bool downloadModelsFromZoo(const fs::path & path, const fs::path & cacheDirectory, const std::string & apiKey, const std::string & progressFormat)

function

std::ostream & operator<<(std::ostream & os, const NNModelDescription & modelDescription)

inline function

NNArchiveConfigVersion getNNArchiveConfigVersion(const NNArchiveConfig & config)

function

 DEPTHAI_SERIALIZE_EXT(NodeConnectionSchema, node1Id, node1OutputGroup, node1Output, node2Id, node2InputGroup, node2Input)

function

DEPTHAI_SERIALIZE_EXT(NodeIoInfo, group, name, type, blocking, queueSize, waitForMessage, id)

function

DEPTHAI_SERIALIZE_EXT(NodeObjInfo, id, parentId, name, alias, deviceId, deviceNode, properties, logLevel, ioInfo)

function

DEPTHAI_SERIALIZE_EXT(PipelineSchema, connections, globalProperties, nodes, bridges)

function

DEPTHAI_SERIALIZE_EXT(AprilTag, id, hamming, decisionMargin, topLeft, topRight, bottomRight, bottomLeft)

function

bool isDatatypeSubclassOf(DatatypeEnum parent, DatatypeEnum children)

function

DEPTHAI_SERIALIZE_EXT(IMUReport, sequence, accuracy, timestamp, tsDevice)

function

DEPTHAI_SERIALIZE_EXT(IMUReportAccelerometer, x, y, z, sequence, accuracy, timestamp, tsDevice)

function

DEPTHAI_SERIALIZE_EXT(IMUReportGyroscope, x, y, z, sequence, accuracy, timestamp, tsDevice)

function

DEPTHAI_SERIALIZE_EXT(IMUReportMagneticField, x, y, z, sequence, accuracy, timestamp, tsDevice)

function

 DEPTHAI_SERIALIZE_EXT(IMUReportRotationVectorWAcc, i, j, k, real, rotationVectorAccuracy, sequence, accuracy, timestamp, tsDevice)

function

DEPTHAI_SERIALIZE_EXT(IMUPacket, acceleroMeter, gyroscope, magneticField, rotationVector)

function

DEPTHAI_SERIALIZE_EXT(CircleAnnotation, position, diameter, thickness, fillColor, outlineColor)

function

DEPTHAI_SERIALIZE_EXT(PointsAnnotation, type, points, outlineColor, outlineColors, fillColor, thickness)

function

DEPTHAI_SERIALIZE_EXT(TextAnnotation, position, text, fontSize, textColor, backgroundColor)

function

DEPTHAI_SERIALIZE_EXT(ImgAnnotation, circles, points, texts)

function

DEPTHAI_SERIALIZE_EXT(SpatialLocationCalculatorConfigThresholds, lowerThreshold, upperThreshold)

function

DEPTHAI_SERIALIZE_EXT(SpatialLocationCalculatorConfigData, roi, depthThresholds, calculationAlgorithm, stepSize)

function

 DEPTHAI_SERIALIZE_EXT(SpatialLocations, config, depthAverage, depthMode, depthMedian, depthMin, depthMax, depthAveragePixelCount, spatialCoordinates)

function

DEPTHAI_SERIALIZE_EXT(TrackedFeature, position, id, age, harrisScore, trackingError, descriptor)

function

DEPTHAI_SERIALIZE_EXT(Transform, matrix)

function

DEPTHAI_SERIALIZE_EXT(AprilTagProperties, initialConfig, inputConfigSync)

function

DEPTHAI_SERIALIZE_EXT(AutoCalibrationProperties, initialConfig)

function

DEPTHAI_SERIALIZE_EXT(BenchmarkInProperties, reportEveryNMessages, attachLatencies, logReportsAsWarnings)

function

DEPTHAI_SERIALIZE_EXT(BenchmarkOutProperties, numMessages, fps)

function

 DEPTHAI_SERIALIZE_EXT(CameraProperties, initialControl, boardSocket, sensorType, cameraName, imageOrientation, resolutionWidth, resolutionHeight, mockIspWidth, mockIspHeight, mockIspFps, fps, isp3aFps, numFramesPoolRaw, maxSizePoolRaw, numFramesPoolIsp, maxSizePoolIsp, numFramesPoolVideo, numFramesPoolPreview, numFramesPoolStill, numFramesPoolOutputs, maxSizePoolOutputs, outputRequests)

function

DEPTHAI_SERIALIZE_EXT(CastProperties, numFramesPool, outputType, scale, offset)

function

 DEPTHAI_SERIALIZE_EXT(ColorCameraProperties, initialControl, boardSocket, cameraName, imageOrientation, previewType, previewHeight, previewWidth, videoWidth, videoHeight, stillWidth, stillHeight, mockIspWidth, mockIspHeight, resolution, fps, isp3aFps, sensorCropX, sensorCropY, previewKeepAspectRatio, ispScale, numFramesPoolRaw, numFramesPoolIsp, numFramesPoolVideo, numFramesPoolPreview, numFramesPoolStill, warpMeshSource, warpMeshUri, warpMeshWidth, warpMeshHeight, calibAlpha, warpMeshStepWidth, warpMeshStepHeight, eventFilter, rawPacked)

function

DEPTHAI_SERIALIZE_EXT(DetectionParserProperties, numFramesPool, networkInputs, parser)

function

DEPTHAI_SERIALIZE_EXT(DeviceNodeGroupProperties, dummy)

function

DEPTHAI_SERIALIZE_EXT(DynamicCalibrationProperties, emptyBool)

function

DEPTHAI_SERIALIZE_EXT(EdgeDetectorProperties, initialConfig, outputFrameSize, numFramesPool)

function

DEPTHAI_SERIALIZE_EXT(FeatureTrackerProperties, initialConfig, numShaves, numMemorySlices)

function

DEPTHAI_SERIALIZE_EXT(GateProperties, initialConfig)

function

 DEPTHAI_SERIALIZE_EXT(GlobalProperties, leonCssFrequencyHz, leonMssFrequencyHz, pipelineName, pipelineVersion, cameraTuningBlobSize, cameraTuningBlobUri, cameraSocketTuningBlobSize, cameraSocketTuningBlobUri, calibData, eepromId, xlinkChunkSize, sippBufferSize, sippDmaBufferSize)

function

 DEPTHAI_SERIALIZE_EXT(IMUSensorConfig, sensitivityEnabled, sensitivityRelative, changeSensitivity, reportRate, sensorId)

function

DEPTHAI_SERIALIZE_EXT(IMUProperties, imuSensors, batchReportThreshold, maxBatchReports, enableFirmwareUpdate)

function

 DEPTHAI_SERIALIZE_EXT(ImageAlignProperties, initialConfig, numFramesPool, alignWidth, alignHeight, warpHwIds, interpolation, outKeepAspectRatio, numShaves)

function

DEPTHAI_SERIALIZE_EXT(ImageFiltersProperties, initialConfig)

function

DEPTHAI_SERIALIZE_EXT(ToFDepthConfidenceFilterProperties, initialConfig)

function

DEPTHAI_SERIALIZE_EXT(ImageManipProperties, initialConfig, outputFrameSize, numFramesPool, backend, performanceMode)

function

DEPTHAI_SERIALIZE_EXT(MessageDemuxProperties, processor)

function

 DEPTHAI_SERIALIZE_EXT(MonoCameraProperties, initialControl, boardSocket, cameraName, imageOrientation, mockIspWidth, mockIspHeight, resolution, fps, isp3aFps, numFramesPool, numFramesPoolRaw, rawPacked)

function

DEPTHAI_SERIALIZE_EXT(NeuralDepthProperties, initialConfig)

function

 DEPTHAI_SERIALIZE_EXT(NeuralNetworkProperties, modelSource, blobSize, blobUri, modelUri, numFrames, numThreads, numNCEPerThread, numShavesPerThread, backend, backendProperties, deviceModel)

function

 DEPTHAI_SERIALIZE_EXT(ObjectTrackerProperties, trackerThreshold, maxObjectsToTrack, detectionLabelsToTrack, trackerType, trackerIdAssignmentPolicy, trackingPerClass, occlusionRatioThreshold, trackletMaxLifespan, trackletBirthThreshold)

function

DEPTHAI_SERIALIZE_EXT(PointCloudProperties, initialConfig, numFramesPool)

function

DEPTHAI_SERIALIZE_EXT(PoolProperties, numMessages, maxMessageSize, datatype, processor)

function

DEPTHAI_SERIALIZE_EXT(RectificationProperties, outputWidth, outputHeight, enableRectification)

function

DEPTHAI_SERIALIZE_EXT(SPIInProperties, streamName, busId, maxDataSize, numFrames)

function

DEPTHAI_SERIALIZE_EXT(SPIOutProperties, streamName, busId)

function

DEPTHAI_SERIALIZE_EXT(ScriptProperties, scriptUri, scriptName, processor)

function

DEPTHAI_SERIALIZE_EXT(SegmentationParserProperties, labels, networkOutputName, classesInOneLayer, backgroundClass)

function

 DEPTHAI_SERIALIZE_EXT(SpatialDetectionNetworkProperties, detectedBBScaleFactor, depthThresholds, calculationAlgorithm, stepSize)

function

DEPTHAI_SERIALIZE_EXT(SpatialLocationCalculatorProperties, roiConfig)

function

 DEPTHAI_SERIALIZE_EXT(StereoDepthProperties, initialConfig, depthAlignCamera, enableRectification, rectifyEdgeFillColor, width, height, outWidth, outHeight, outKeepAspectRatio, mesh, enableRuntimeStereoModeSwitch, numFramesPool, numPostProcessingShaves, numPostProcessingMemorySlices, focalLengthFromCalibration, useHomographyRectification, enableFrameSync, baseline, focalLength, disparityToDepthUseSpecTranslation, rectificationUseSpecTranslation, depthAlignmentUseSpecTranslation, alphaScaling)

function

DEPTHAI_SERIALIZE_EXT(SyncProperties, syncThresholdNs, syncAttempts, processor)

function

DEPTHAI_SERIALIZE_EXT(SystemLoggerProperties, rateHz)

function

DEPTHAI_SERIALIZE_EXT(ThermalProperties, initialConfig, numFramesPool, boardSocket, fps)

function

 DEPTHAI_SERIALIZE_EXT(ToFProperties, initialConfig, numFramesPool, numShaves, warpHwIds, boardSocket, cameraName, imageOrientation, fps, numFramesPoolRaw)

function

DEPTHAI_SERIALIZE_EXT(UVCProperties, gpioInit, gpioStreamOn, gpioStreamOff)

function

 DEPTHAI_SERIALIZE_EXT(VideoEncoderProperties, bitrate, keyframeFrequency, maxBitrate, numBFrames, numFramesPool, outputFrameSize, profile, quality, lossless, rateCtrlMode, frameRate)

function

DEPTHAI_SERIALIZE_EXT(VppProperties, initialConfig, numFramesPool)

function

 DEPTHAI_SERIALIZE_EXT(WarpProperties, outputWidth, outputHeight, outputFrameSize, numFramesPool, meshWidth, meshHeight, meshUri, warpHwIds, interpolation)

function

 DEPTHAI_SERIALIZE_EXT(PipelineEventAggregationProperties, aggregationWindowSize, statsUpdateIntervalMs, eventWaitWindow, traceOutput)

function

bool initialize()

function

bool initialize(std::string additionalInfo, bool installSignalHandler, void * javavm)

function

bool initialize(const char * additionalInfo, bool installSignalHandler, void * javavm)

function

bool initialize(void * javavm)

inline function

void swap(JoiningThread & x, JoiningThread & y)

enum

ImgResizeMode

enumerator

CROP

Keeps aspect ratio. Crops the image to get the correct output aspect ratio. Crops some FOV to match the required FOV, then scale. No potential NN accuracy decrease.

enumerator

STRETCH

Doesn't keep aspect ratio. Squishes or streches the image to fill the required pixel area. Preserves full FOV, but frames are stretched to match the FOV, which might decrease NN accuracy.

enumerator

LETTERBOX

Keeps aspect ratio. Envelop the image with a background color to get the corect output aspect ratio. Preserves full FOV by padding/letterboxing, but smaller frame means less features which might decrease NN accuracy.

enum

int32_t CameraBoardSocket

Which Camera socket to use.AUTO denotes that the decision will be made by device

enumerator

AUTO

enumerator

CAM_A

enumerator

CAM_B

enumerator

CAM_C

enumerator

CAM_D

enumerator

VERTICAL

enumerator

CAM_E

enumerator

CAM_F

enumerator

CAM_G

enumerator

CAM_H

enumerator

CAM_I

enumerator

CAM_J

enumerator

RGB

enumerator

CENTER

enumerator

LEFT

enumerator

RIGHT

enum

int32_t CameraExposureOffset

Describe possible exposure offsets

enumerator

START

enumerator

MIDDLE

enumerator

END

enum

int32_t CameraImageOrientation

Camera sensor image orientation / pixel readout. This exposes direct sensor settings. 90 or 270 degrees rotation is not available.AUTO denotes that the decision will be made by device (e.g. on OAK-1/megaAI: ROTATE_180_DEG).

enumerator

AUTO

enumerator

NORMAL

enumerator

HORIZONTAL_MIRROR

enumerator

VERTICAL_FLIP

enumerator

ROTATE_180_DEG

enum

int8_t CameraModel

Which CameraModel to initialize the calibration with.

enumerator

Perspective

enumerator

Fisheye

enumerator

Equirectangular

enumerator

RadialDivision

enum

int32_t CameraSensorType

enumerator

AUTO

enumerator

COLOR

enumerator

MONO

enumerator

TOF

enumerator

THERMAL

enum

int32_t Colormap

enumerator

NONE

enumerator

TURBO

enumerator

JET

enumerator

STEREO_TURBO

enumerator

STEREO_JET

enum

int32_t ConnectionInterface

enumerator

USB

enumerator

ETHERNET

enumerator

WIFI

enum

int32_t SIPrefix

enumerator

GIGA

enumerator

MEGA

enumerator

KILO

enumerator

DEKA

enumerator

DEFAULT

enumerator

CENTI

enumerator

MILLI

enum

int32_t LengthUnit

Measurement unit for depth and calibration data.

enumerator

METER

enumerator

CENTIMETER

enumerator

MILLIMETER

enumerator

INCH

enumerator

FOOT

enumerator

CUSTOM

enum

DeviceModelZoo

On device models, relevant for RVC4 platform

enumerator

NEURAL_DEPTH_LARGE

enumerator

NEURAL_DEPTH_MEDIUM

enumerator

NEURAL_DEPTH_SMALL

enumerator

NEURAL_DEPTH_NANO

enum

int32_t ExternalFrameSyncRole

Which external frame sync role the device should have.AUTO_DETECT denotes that the decision will be made by device. It will choose between MASTER and SLAVE.

enumerator

AUTO_DETECT

enumerator

MASTER

enumerator

SLAVE

enum

int32_t FrameEvent

enumerator

NONE

enumerator

READOUT_START

enumerator

READOUT_END

enum

int32_t HousingCoordinateSystem

Which Housing to use.AUTO denotes that the decision will be made by device

enumerator

AUTO

enumerator

CAM_A

enumerator

CAM_B

enumerator

CAM_C

enumerator

CAM_D

enumerator

CAM_E

enumerator

CAM_F

enumerator

CAM_G

enumerator

CAM_H

enumerator

CAM_I

enumerator

CAM_J

enumerator

FRONT_CAM_A

enumerator

FRONT_CAM_B

enumerator

FRONT_CAM_C

enumerator

FRONT_CAM_D

enumerator

FRONT_CAM_E

enumerator

FRONT_CAM_F

enumerator

FRONT_CAM_G

enumerator

FRONT_CAM_H

enumerator

FRONT_CAM_I

enumerator

FRONT_CAM_J

enumerator

VESA_A

enumerator

VESA_B

enumerator

VESA_C

enumerator

VESA_D

enumerator

VESA_E

enumerator

VESA_F

enumerator

VESA_G

enumerator

VESA_H

enumerator

VESA_I

enumerator

VESA_J

enumerator

IMU

enum

std::int32_t Interpolation

Interpolation type

enumerator

AUTO

enumerator

BILINEAR

enumerator

BICUBIC

enumerator

NEAREST_NEIGHBOR

enumerator

BYPASS

enumerator

DEFAULT

enumerator

DEFAULT_DISPARITY_DEPTH

enum

int32_t ProcessorType

On which processor the node will be placedEnum specifying processor

enumerator

LEON_CSS

enumerator

LEON_MSS

enumerator

CPU

enumerator

DSP

enum

int32_t UsbSpeed

Get USB Speed

enumerator

UNKNOWN

enumerator

LOW

enumerator

FULL

enumerator

HIGH

enumerator

SUPER

enumerator

SUPER_PLUS

enum

Platform

enumerator

RVC2

enumerator

RVC3

enumerator

RVC4

enum

std::int32_t LogLevel

enumerator

TRACE

enumerator

DEBUG

enumerator

INFO

enumerator

WARN

enumerator

ERR

enumerator

CRITICAL

enumerator

OFF

enum

NNArchiveConfigVersion

enumerator

enum

std::int32_t DatatypeEnum

enumerator

ADatatype

enumerator

Buffer

enumerator

ImgFrame

enumerator

EncodedFrame

enumerator

SegmentationMask

enumerator

GateControl

enumerator

NNData

enumerator

ImageManipConfig

enumerator

CameraControl

enumerator

ImgDetections

enumerator

SpatialImgDetections

enumerator

SystemInformation

enumerator

SystemInformationRVC4

enumerator

SpatialLocationCalculatorConfig

enumerator

SpatialLocationCalculatorData

enumerator

EdgeDetectorConfig

enumerator

AprilTagConfig

enumerator

AprilTags

enumerator

Tracklets

enumerator

IMUData

enumerator

StereoDepthConfig

enumerator

NeuralDepthConfig

enumerator

FeatureTrackerConfig

enumerator

ThermalConfig

enumerator

ToFConfig

enumerator

TrackedFeatures

enumerator

BenchmarkReport

enumerator

MessageGroup

enumerator

MapData

enumerator

TransformData

enumerator

PointCloudConfig

enumerator

PointCloudData

enumerator

RGBDData

enumerator

ImageAlignConfig

enumerator

ImgAnnotations

enumerator

ImageFiltersConfig

enumerator

ToFDepthConfidenceFilterConfig

enumerator

ObjectTrackerConfig

enumerator

DynamicCalibrationControl

enumerator

DynamicCalibrationResult

enumerator

AutoCalibrationConfig

enumerator

AutoCalibrationResult

enumerator

CalibrationQuality

enumerator

CalibrationMetrics

enumerator

CoverageData

enumerator

SegmentationParserConfig

enumerator

PipelineEvent

enumerator

PipelineState

enumerator

PipelineEventAggregationConfig

enumerator

VppConfig

enumerator

PacketizedData

enum

std::uint32_t ImageFiltersPresetMode

enumerator

TOF_LOW_RANGE

enumerator

TOF_MID_RANGE

enumerator

TOF_HIGH_RANGE

enum

std::uint8_t PointsAnnotationType

enumerator

UNKNOWN

enumerator

POINTS

enumerator

LINE_LOOP

enumerator

LINE_STRIP

enumerator

LINE_LIST

enum

uint32_t SpatialLocationCalculatorAlgorithm

SpatialLocationCalculatorAlgorithm configuration modesContains calculation method used to obtain spatial locations.

enumerator

AVERAGE

enumerator

MEAN

enumerator

MIN

enumerator

MAX

enumerator

MODE

enumerator

MEDIAN

enum

std::int32_t IMUSensor

Available IMU sensors. More details about each sensor can be found in the datasheet:

enumerator

ACCELEROMETER_RAW

Section 2.1.1Acceleration of the device without any postprocessing, straight from the sensor. Units are [m/s^2]

enumerator

ACCELEROMETER

Section 2.1.1Acceleration of the device including gravity. Units are [m/s^2]

enumerator

LINEAR_ACCELERATION

Section 2.1.1Acceleration of the device with gravity removed. Units are [m/s^2]

enumerator

GRAVITY

Section 2.1.1Gravity. Units are [m/s^2]

enumerator

GYROSCOPE_RAW

Section 2.1.2The angular velocity of the device without any postprocessing, straight from the sensor. Units are [rad/s]

enumerator

GYROSCOPE_CALIBRATED

Section 2.1.2The angular velocity of the device. Units are [rad/s]

enumerator

GYROSCOPE_UNCALIBRATED

Section 2.1.2Angular velocity without bias compensation. Units are [rad/s]

enumerator

MAGNETOMETER_RAW

Section 2.1.3Magnetic field measurement without any postprocessing, straight from the sensor. Units are [uTesla]

enumerator

MAGNETOMETER_CALIBRATED

Section 2.1.3The fully calibrated magnetic field measurement. Units are [uTesla]

enumerator

MAGNETOMETER_UNCALIBRATED

Section 2.1.3The magnetic field measurement without hard-iron offset applied. Units are [uTesla]

enumerator

ROTATION_VECTOR

Section 2.2The rotation vector provides an orientation output that is expressed as a quaternion referenced to magnetic north and gravity. It is produced by fusing the outputs of the accelerometer, gyroscope and magnetometer. The rotation vector is the most accurate orientation estimate available. The magnetometer provides correction in yaw to reduce drift and the gyroscope enables the most responsive performance.

enumerator

GAME_ROTATION_VECTOR

Section 2.2The game rotation vector is an orientation output that is expressed as a quaternion with no specific reference for heading, while roll and pitch are referenced against gravity. It is produced by fusing the outputs of the accelerometer and the gyroscope (i.e. no magnetometer). The game rotation vector does not use the magnetometer to correct the gyroscopes drift in yaw. This is a deliberate omission (as specified by Google) to allow gaming applications to use a smoother representation of the orientation without the jumps that an instantaneous correction provided by a magnetic field update could provide. Long term the output will likely drift in yaw due to the characteristics of gyroscopes, but this is seen as preferable for this output versus a corrected output.

enumerator

GEOMAGNETIC_ROTATION_VECTOR

Section 2.2The geomagnetic rotation vector is an orientation output that is expressed as a quaternion referenced to magnetic north and gravity. It is produced by fusing the outputs of the accelerometer and magnetometer. The gyroscope is specifically excluded in order to produce a rotation vector output using less power than is required to produce the rotation vector of section 2.2.4. The consequences of removing the gyroscope are: Less responsive output since the highly dynamic outputs of the gyroscope are not used More errors in the presence of varying magnetic fields.

enumerator

ARVR_STABILIZED_ROTATION_VECTOR

Section 2.2Estimates of the magnetic field and the roll/pitch of the device can create a potential correction in the rotation vector produced. For applications (typically augmented or virtual reality applications) where a sudden jump can be disturbing, the output is adjusted to prevent these jumps in a manner that takes account of the velocity of the sensor system.

enumerator

ARVR_STABILIZED_GAME_ROTATION_VECTOR

Section 2.2While the magnetometer is removed from the calculation of the game rotation vector, the accelerometer itself can create a potential correction in the rotation vector produced (i.e. the estimate of gravity changes). For applications (typically augmented or virtual reality applications) where a sudden jump can be disturbing, the output is adjusted to prevent these jumps in a manner that takes account of the velocity of the sensor system. This process is called AR/VR stabilization.

enum

std::int32_t TrackerType

enumerator

SHORT_TERM_KCF

enumerator

SHORT_TERM_IMAGELESS

enumerator

ZERO_TERM_IMAGELESS

enumerator

ZERO_TERM_COLOR_HISTOGRAM

enum

std::int32_t TrackerIdAssignmentPolicy

enumerator

UNIQUE_ID

enumerator

SMALLEST_ID

enum

LockingQueueState

enumerator

SUCCESS

enumerator

BLOCKED

enumerator

CANCELLED

enum

SerializationType

enumerator

LIBNOP

enumerator

JSON

enumerator

JSON_MSGPACK

class

dai::Capability

Derived by dai::CapabilityCRTP< Capability, ImgFrameCapability >

function

const char * getName()

function

~Capability()

class

dai::CapabilityCRTP

variable

friend Derived

variable

friend Base

function

~CapabilityCRTP()

inline function

const char * getName()

class

dai::CapabilityRange

variable

std::optional< std::variant< T, std::pair< T, T >, std::vector< T > > > value

inline function

void minMax(const std::pair< T, T > & minMax)

inline function

void minMax(const std::tuple< T, T > & minMax)

inline function

void minMax(const T & min, const T & max)

inline function

void fixed(const T & fixed)

inline function

void discrete(const std::vector< T > & discreteValues)

function

DEPTHAI_SERIALIZE(CapabilityRange, value)

class

dai::ImgFrameCapability

variable

CapabilityRange< std::pair< uint32_t, uint32_t > > size

variable

CapabilityRange< float > fps

variable

std::optional< ImgFrame::Type > type

variable

ImgResizeMode resizeMode

variable

std::optional< bool > enableUndistortion

variable

bool ispOutput

function

~ImgFrameCapability()

function

DEPTHAI_SERIALIZE(ImgFrameCapability, size, fps, type, resizeMode, enableUndistortion, ispOutput)

struct

dai::CameraSensorConfig

#include CameraFeatures.hpp

variable

std::int32_t width

variable

std::int32_t height

variable

float minFps

variable

float maxFps

variable

Rect fov

variable

CameraSensorType type

struct

dai::CameraFeatures

#include CameraFeatures.hpp

variable

CameraBoardSocket socket

Board socket where the camera was detected

variable

std::string sensorName

Camera sensor name, e.g: "IMX378", "OV9282"

variable

std::int32_t width

Maximum sensor resolution

variable

std::int32_t height

variable

CameraImageOrientation orientation

Default camera orientation, board dependent

variable

std::vector< CameraSensorType > supportedTypes

List of supported types of processing for the given camera.For some sensors it's not possible to determine if they are color or mono (e.g. OV9782 and OV9282), so this could return more than one entry

variable

bool hasAutofocusIC

Whether an autofocus VCM IC was detected

variable

bool hasAutofocus

Whether camera has auto focus capabilities, or is a fixed focus lens

variable

std::string name

Camera name or alias

variable

std::vector< std::string > additionalNames

Additional camera names or aliases

variable

std::vector< CameraSensorConfig > configs

Available sensor configs

variable

std::optional< CameraSensorConfig > calibrationResolution

function

 DEPTHAI_SERIALIZE(CameraFeatures, socket, sensorName, width, height, orientation, supportedTypes, hasAutofocusIC, hasAutofocus, name, additionalNames, configs, calibrationResolution)

struct

dai::CameraInfo

#include CameraInfo.hpp

variable

uint16_t width

variable

uint16_t height

variable

uint8_t lensPosition

variable

std::vector< std::vector< float > > intrinsicMatrix

variable

std::vector< float > distortionCoeff

variable

Extrinsics extrinsics

variable

float specHfovDeg

variable

CameraModel cameraType

function

 DEPTHAI_SERIALIZE(CameraInfo, cameraType, width, height, specHfovDeg, lensPosition, intrinsicMatrix, distortionCoeff, extrinsics)

struct

dai::ChipTemperature

#include ChipTemperature.hpp

variable

float css

CPU Subsystem

variable

float mss

Media Subsystem

variable

float upa

Shave Array

variable

float dss

DRAM Subsystem

variable

float average

Average of measurements

struct

dai::ChipTemperatureRVC4

#include ChipTemperatureRVC4.hpp

variable

float cpuss

CPU Subsystem

variable

float gpuss

GPU Subsystem

variable

float mdmss

Modem Subsystem

variable

float video

Video

variable

float ddr

DDR Memory

variable

float camera

Camera

variable

float average

Average of measurements

struct

dai::Color

#include Color.hpp

variable

float r

variable

float g

variable

float b

variable

float a

function

Color()

inline function

Color(float r, float g, float b, float a)

Parameters

r: Red value
g: Green value
b: Blue value
a: Alpha value

Parameters

std::invalid_argument: if r,g,b,a values are not in range [0.0, 1.0]

struct

dai::CpuUsage

#include CpuUsage.hpp

variable

float average

Average CPU usage, expressed with a normalized value (0-1)

variable

int32_t msTime

Time span in which the average was calculated in milliseconds

struct

dai::DetectionParserOptions

#include DetectionParserOptions.hpp

variable

DetectionNetworkType nnFamily

variable

std::string subtype

variable

float confidenceThreshold

variable

YoloDecodingFamily decodingFamily

variable

bool decodeKeypoints

variable

bool decodeSegmentation

variable

int classes

variable

std::optional< std::vector< std::string > > classNames

variable

int coordinates

variable

std::optional< int > nKeypoints

variable

std::vector< int > strides

variable

std::vector< float > anchors

variable

std::map< std::string, std::vector< int > > anchorMasks

variable

std::vector< std::string > outputNamesToUse

variable

std::vector< std::vector< std::vector< float > > > anchorsV2

variable

float iouThreshold

variable

std::vector< dai::Edge > keypointEdges

variable

std::vector< std::string > keypointLabelNames

struct

dai::EepromData

#include EepromData.hpp

variable

uint32_t version

variable

std::string productName

variable

std::string boardCustom

variable

std::string boardName

variable

std::string boardRev

variable

std::string boardConf

variable

std::string hardwareConf

variable

std::string deviceName

variable

std::string batchName

variable

uint64_t batchTime

variable

uint32_t boardOptions

variable

std::unordered_map< CameraBoardSocket, CameraInfo > cameraData

variable

StereoRectification stereoRectificationData

variable

Extrinsics imuExtrinsics

variable

Extrinsics housingExtrinsics

variable

std::vector< uint8_t > miscellaneousData

variable

bool stereoUseSpecTranslation

variable

bool stereoEnableDistortionCorrection

variable

CameraBoardSocket verticalCameraSocket

struct

dai::Extrinsics

#include Extrinsics.hpp

variable

std::vector< std::vector< float > > rotationMatrix

variable

Point3f translation

(x, y, z) pose of destCameraSocket w.r.t currentCameraSocket obtained through calibration

variable

Point3f specTranslation

(x, y, z) pose of destCameraSocket w.r.t currentCameraSocket measured through CAD design

variable

CameraBoardSocket toCameraSocket

function

DEPTHAI_SERIALIZE(Extrinsics, rotationMatrix, translation, specTranslation, toCameraSocket)

struct

dai::ImgTransformation

#include ImgTransformations.hpp

function

ImgTransformation()

inline function

ImgTransformation(size_t width, size_t height)

inline function

ImgTransformation(size_t srcWidth, size_t srcHeight, size_t width, size_t height)

inline function

ImgTransformation(size_t width, size_t height, std::array< std::array< float, 3 >, 3 > sourceIntrinsicMatrix)

inline function

 ImgTransformation(size_t width, size_t height, std::array< std::array< float, 3 >, 3 > sourceIntrinsicMatrix, CameraModel distortionModel, std::vector< float > distortionCoefficients)

function

dai::Point2f transformPoint(dai::Point2f point)

Transform a point from the source frame to the current frame.

Parameters

point: Point to transform

Returns

Transformed point

function

dai::RotatedRect transformRect(dai::RotatedRect rect)

Transform a rotated rect from the source frame to the current frame.

Parameters

rect: Rectangle to transform

Returns

Transformed rectangle

function

dai::Point2f invTransformPoint(dai::Point2f point)

Transform a point from the current frame to the source frame.

Parameters

point: Point to transform

Returns

Transformed point

function

dai::RotatedRect invTransformRect(dai::RotatedRect rect)

Transform a rotated rect from the current frame to the source frame.

Parameters

rect: Rectangle to transform

Returns

Transformed rectangle

function

std::pair< size_t, size_t > getSize()

Retrieve the size of the frame. Should be equal to the size of the corresponding ImgFrame message.

Returns

Size of the frame

function

std::pair< size_t, size_t > getSourceSize()

Retrieve the size of the source frame from which this frame was derived.

Returns

Size of the frame

function

std::array< std::array< float, 3 >, 3 > getMatrix()

Retrieve the transformation matrix from the source frame to the current frame.

Returns

Transformation matrix

function

std::array< std::array< float, 3 >, 3 > getMatrixInv()

Retrieve the inverse transformation matrix from the current frame to the source frame.

Returns

Inverse transformation matrix

function

std::array< std::array< float, 3 >, 3 > getSourceIntrinsicMatrix()

Retrieve the intrinsic matrix of the source sensor.

Returns

Intrinsic matrix

function

std::array< std::array< float, 3 >, 3 > getSourceIntrinsicMatrixInv()

Retrieve the inverse intrinsic matrix of the source sensor.

Returns

Inverse intrinsic matrix

function

CameraModel getDistortionModel()

Retrieve the distortion model of the source sensor

Returns

Distortion model

function

std::vector< float > getDistortionCoefficients()

Retrieve the distortion coefficients of the source sensor

Returns

vector of distortion coefficients

function

std::array< std::array< float, 3 >, 3 > getIntrinsicMatrix()

Retrieve the total intrinsic matrix calculated from intrinsic * transform.

Returns

total intrinsic matrix

function

std::array< std::array< float, 3 >, 3 > getIntrinsicMatrixInv()

Retrieve the inverse of the total intrinsic matrix calculated from intrinsic * transform.

Returns

inverse total intrinsic matrix

function

float getDFov(bool source)

Retrieve the diagonal field of view of the image.

Parameters

source: If true, the source field of view will be returned. Otherwise, the current field of view will be returned.

Returns

Diagonal field of view in degrees

function

float getHFov(bool source)

Retrieve the horizontal field of view of the image.

Parameters

source: If true, the source field of view will be returned. Otherwise, the current field of view will be returned.

Returns

Horizontal field of view in degrees

function

float getVFov(bool source)

Retrieve the vertical field of view of the image.

Parameters

source: If true, the source field of view will be returned. Otherwise, the current field of view will be returned.

Returns

Vertical field of view in degrees

function

std::vector< dai::RotatedRect > getSrcCrops()

function

bool getSrcMaskPt(size_t x, size_t y)

Returns true if the point is inside the transformed region of interest (determined by crops used).

function

bool getDstMaskPt(size_t x, size_t y)

Returns true if the point is inside the image region (not in the background region).

function

ImgTransformation & addTransformation(std::array< std::array< float, 3 >, 3 > matrix)

Add a new transformation.

Parameters

matrix: Transformation matrix

function

ImgTransformation & addCrop(int x, int y, int width, int height)

Add a crop transformation.

Parameters

x: X coordinate of the top-left corner of the crop
y: Y coordinate of the top-left corner of the crop
width: Width of the crop
height: Height of the crop

function

ImgTransformation & addPadding(int top, int bottom, int left, int right)

Add a pad transformation. Works like crop, but in reverse.

Parameters

top: Padding on the top
bottom: Padding on the bottom
left: Padding on the left
right: Padding on the right

function

ImgTransformation & addFlipVertical()

Add a vertical flip transformation.

function

ImgTransformation & addFlipHorizontal()

Add a horizontal flip transformation.

function

ImgTransformation & addRotation(float angle, dai::Point2f rotationPoint)

Add a rotation transformation.

Parameters

angle: Angle in degrees
rotationPoint: Point around which to rotate

function

ImgTransformation & addScale(float scaleX, float scaleY)

Add a scale transformation.

Parameters

scaleX: Scale factor in the horizontal direction
scaleY: Scale factor in the vertical direction

function

ImgTransformation & addSrcCrops(const std::vector< dai::RotatedRect > & crops)

function

ImgTransformation & setSize(size_t width, size_t height)

function

ImgTransformation & setSourceSize(size_t width, size_t height)

function

ImgTransformation & setIntrinsicMatrix(std::array< std::array< float, 3 >, 3 > intrinsicMatrix)

function

ImgTransformation & setDistortionModel(CameraModel model)

function

ImgTransformation & setDistortionCoefficients(std::vector< float > coefficients)

function

dai::Point2f remapPointTo(const ImgTransformation & to, dai::Point2f point)

Remap a point from this transformation to another. If the intrinsics are different (e.g. different camera), the function will also use the intrinsics to remap the point.

Parameters

to: Transformation to remap to
point: Point to remap

function

dai::Point2f remapPointFrom(const ImgTransformation & from, dai::Point2f point)

Remap a point to this transformation from another. If the intrinsics are different (e.g. different camera), the function will also use the intrinsics to remap the point.

Parameters

from: Transformation to remap from
point: Point to remap

function

dai::RotatedRect remapRectTo(const ImgTransformation & to, dai::RotatedRect rect)

Remap a rotated rect from this transformation to another. If the intrinsics are different (e.g. different camera), the function will also use the intrinsics to remap the rect.

Parameters

to: Transformation to remap to
rect: RotatedRect to remap

function

dai::RotatedRect remapRectFrom(const ImgTransformation & from, dai::RotatedRect rect)

Remap a rotated rect to this transformation from another. If the intrinsics are different (e.g. different camera), the function will also use the intrinsics to remap the rect.

Parameters

from: Transformation to remap from
point: RotatedRect to remap

function

bool isAlignedTo(const ImgTransformation & to)

Check if the transformations are aligned

Parameters

to: Transformation to compare with

function

bool isValid()

Check if the transformations are valid. The transformations are valid if the source frame size and the current frame size are set.

function

 DEPTHAI_SERIALIZE(ImgTransformation, transformationMatrix, transformationMatrixInv, sourceIntrinsicMatrix, sourceIntrinsicMatrixInv, distortionModel, distortionCoefficients, srcWidth, srcHeight, width, height, srcCrops)

struct

dai::Keypoint

variable

Point3f imageCoordinates

variable

float confidence

variable

uint32_t label

variable

std::string labelName

function

Keypoint()

inline explicit function

Keypoint(Point3f imageCoordinates, float conf, uint32_t label, std::string labelName)

inline explicit function

Keypoint(Point2f imageCoordinates, float confidence, uint32_t label, std::string labelName)

inline explicit function

Keypoint(float x, float y, float z, float confidence, uint32_t label, std::string labelName)

function

DEPTHAI_SERIALIZE(dai::Keypoint, imageCoordinates, confidence, label, labelName)

struct

dai::KeypointsList

inline function

void setKeypoints(const std::vector< Point3f > & kps3)

Sets the keypoints list.

Parameters

keypoints: list of Point3f objects to set.

Parameters

This will clear any existing keypoints and edges.

inline function

void setKeypoints(const std::vector< Point2f > & kps2)

Sets the keypoints list.

Parameters

keypoints: list of Point2f objects to set.

Parameters

This will clear any existing keypoints and edges.

function

DEPTHAI_SERIALIZE(KeypointsList, keypoints, edges)

enum

KeypointsListT< Keypoint > Base

struct

dai::KeypointsListT

function

KeypointsListT()

inline explicit function

KeypointsListT(std::vector< KeypointT > keypoints, std::vector< Edge > edges)

inline explicit function

KeypointsListT(std::vector< KeypointT > keypoints)

function

~KeypointsListT()

inline function

iterator begin()

inline function

iterator end()

inline function

const_iterator begin()

inline function

const_iterator end()

inline function

const_iterator cbegin()

inline function

const_iterator cend()

inline function

bool empty()

inline function

size_t size()

inline function

value_type & operator[](size_t i)

inline function

const value_type & operator[](size_t i)

inline function

void setKeypoints(const std::vector< KeypointT > kps)

Sets the keypoints list.

Parameters

keypoints: list of Keypoint objects to set.

Parameters

This will clear any existing keypoints and edges.

inline function

void setKeypoints(std::vector< KeypointT > keypoints, std::vector< Edge > edges)

Sets the keypoints list.

Parameters

keypoints: list of Keypoint objects and edges to set.

Parameters

This will clear any existing keypoints and edges.

inline function

void setEdges(std::vector< Edge > edges)

Set the indices of the edges.

Parameters

edges: Vector of edge indices.

inline function

std::vector< KeypointT > getKeypoints()

Get keypoints.

Returns

Vector of Keypoint objects.

inline function

std::vector< Edge > getEdges()

Get the indices of the edges.

Returns

Vector of edge indices.

inline function

std::vector< Point3f > getPoints3f()

Get only image coordinates of the keypoints.

Returns

Vector of Point3f coordinates.

inline function

std::vector< Point2f > getPoints2f()

Get only image 2D coordinates of the keypoints and drop the z axis values.

Returns

Vector of Point2f coordinates.

enum

KeypointT value_type

enum

typename std::vector< KeypointT >::iterator iterator

enum

typename std::vector< KeypointT >::const_iterator const_iterator

struct

dai::MemoryInfo

#include MemoryInfo.hpp

variable

int64_t remaining

variable

int64_t used

variable

int64_t total

struct

dai::Point2f

#include Point2f.hpp

variable

float x

variable

float y

variable

bool normalized

variable

bool hasNormalized

function

Point2f()

inline function

Point2f(float x, float y)

inline function

Point2f(float x, float y, bool normalized)

inline function

bool isNormalized()

struct

dai::Point3d

#include Point3d.hpp

variable

double x

variable

double y

variable

double z

function

Point3d()

inline function

Point3d(double x, double y, double z)

struct

dai::Point3f

#include Point3f.hpp

variable

float x

variable

float y

variable

float z

function

Point3f()

inline function

Point3f(float x, float y, float z)

struct

dai::Point3fRGBA

#include Point3fRGBA.hpp

variable

float x

variable

float y

variable

float z

variable

uint8_t r

variable

uint8_t g

variable

uint8_t b

variable

uint8_t a

function

Point3fRGBA()

inline function

Point3fRGBA(float x, float y, float z, uint8_t r, uint8_t g, uint8_t b, uint8_t a)

struct

dai::Quaterniond

#include Quaterniond.hpp

variable

double qx

variable

double qy

variable

double qz

variable

double qw

function

Quaterniond()

inline function

Quaterniond(double qx, double qy, double qz, double qw)

struct

dai::Rect

#include Rect.hpp

variable

float x

variable

float y

variable

float width

variable

float height

variable

bool normalized

variable

bool hasNormalized

function

Rect()

inline function

Rect(float x, float y, float width, float height)

Construct Rectangle from (x, y) coordinates of the top-left corner, width and height.

inline function

Rect(float x, float y, float width, float height, bool normalized)

Construct Rectangle from (x, y) coordinates of the top-left corner, width, height and normalization flag.

Parameters

x: Top-left x coordinate
y: Top-left y coordinate
width: Width of the rectangle
height: Height of the rectangle
normalized: Whether the rectangle is normalized (coordinates in [0,1] range) or not

inline function

Rect(const Rect & r)

Copy constructor

inline function

Rect(const Point2f & org, const Size2f & sz)

Construct Rectangle from top left point and size

inline function

Rect(const Point2f & org, const Size2f & sz, bool normalized)

Construct Rectangle from top left point, size and normalization flag.

Parameters

: if normalized is true, the coordinates are in [0,1] range

inline function

Rect(const Point2f & pt1, const Point2f & pt2)

Construct Rectangle between any two given points. Constructor will determine top-left and bottom-right points.

Parameters

pt1: First point
pt2: Second point

inline function

Rect(const Point2f & pt1, const Point2f & pt2, bool normalized)

Construct Rectangle between any two given points with normalization flag. Constructor will determine top-left and bottom-right points.

Parameters

pt1: First point
pt2: Second point
normalized: Whether the rectangle is normalized (coordinates in [0,1] range) or not

function

Rect & operator=(const Rect & r)

function

Rect & operator=(Rect && r)

inline function

Point2f topLeft()

The top-left corner.

inline function

Point2f bottomRight()

The bottom-right corner

inline function

Size2f size()

Size (width, height) of the rectangle

inline function

float area()

Area (width*height) of the rectangle

inline function

bool empty()

True if rectangle is empty.

inline function

bool contains(const Point2f & pt)

Checks whether the rectangle contains the point.

inline function

bool isNormalized()

Whether rectangle is normalized (coordinates in [0,1] range) or not.

inline function

Rect denormalize(int destWidth, int destHeight)

Denormalize rectangle.

Parameters

destWidth: Destination frame width.
destHeight: Destination frame height.

inline function

Rect normalize(int srcWidth, int srcHeight)

Normalize rectangle.

Parameters

srcWidth: Source frame width.
srcHeight: Source frame height.

struct

dai::RotatedRect

#include RotatedRect.hpp

variable

Point2f center

variable

Size2f size

variable

float angle

function

RotatedRect()

inline function

RotatedRect(const Point2f & center, const Size2f & size, float angle)

A rotated rectangle is specified by the center point, size, and rotation angle in degrees.

inline function

RotatedRect(const Rect & rect, float angle)

Construct RotatedRect from provided dai::Rect rect and angle

Parameters

rect: dai::Rect rectangle
angle: Rotation angle in degrees

inline function

operator Rect()

inline function

bool isNormalized()

inline function

RotatedRect normalize(unsigned int width, unsigned int height)

Normalize the rotated rectangle. The normalized rectangle will have center and size coordinates in range [0,1]

Returns

Normalized rotated rectangle

inline function

RotatedRect denormalize(unsigned int width, unsigned int height, bool force)

Denormalize the rotated rectangle. The denormalized rectangle will have center and size coordinates in range [0, width] and [0, height]

Returns

Denormalized rotated rectangle

inline function

std::array< dai::Point2f, 4 > getPoints()

Get the 4 corner points of the rotated rectangle

Returns

4 corner points

inline function

std::array< float, 4 > getOuterRect()

Returns the outer non-rotated rectangle

Returns

[minx, miny, maxx, maxy]

inline function

std::tuple< dai::Point2f, dai::Size2f > getOuterXYWH()

Returns the outer non-rotated rectangle in the COCO (xmin, ymin, width, height) format.

Returns

(top-left point, size)

inline function

std::tuple< dai::Point2f, dai::Size2f > getOuterCXCYWH()

Returns the outer non-rotated rectangle in the YOLO (xcenter, ycenter, width, height) format.

Returns

(center point, size)

struct

dai::Size2f

#include Size2f.hpp

variable

float width

variable

float height

variable

bool normalized

variable

bool hasNormalized

function

Size2f()

inline function

Size2f(float width, float height)

inline function

Size2f(float width, float height, bool normalized)

inline function

bool isNormalized()

struct

dai::SpatialKeypoint

variable

Point3f imageCoordinates

variable

float confidence

variable

uint32_t label

variable

std::string labelName

variable

Point3f spatialCoordinates

function

SpatialKeypoint()

inline explicit function

 SpatialKeypoint(Point3f imageCoordinates, Point3f spatialCoordinates, float conf, uint32_t label, std::string labelName)

inline explicit function

 SpatialKeypoint(Point2f imageCoordinates, Point3f spatialCoordinates, float conf, uint32_t label, std::string labelName)

inline explicit function

 SpatialKeypoint(float x, float y, float z, float sx, float sy, float sz, float conf, uint32_t label, std::string labelName)

function

DEPTHAI_SERIALIZE(dai::SpatialKeypoint, imageCoordinates, confidence, label, labelName, spatialCoordinates)

struct

dai::SpatialKeypointsList

inline function

void setKeypoints(const std::vector< Point3f > & kps3)

Sets the keypoints list.

Parameters

keypoints: list of Point3f objects to set.

Parameters

This will clear any existing keypoints and edges.

inline function

void setSpatialCoordinates(const std::vector< Point3f > & spatialCoordinates)

Sets the keypoints from a vector of 3D spatial points.

Parameters

spatialCoordinates: vector of Point3f objects to set as spatial coordinates.

Parameters

The size of spatialCoordinates must match the number of keypoints.

inline function

std::vector< Point3f > getSpatialCoordinates()

Get spatial coordinates of the keypoints.

Returns

Vector of Point3f spatial coordinates.

function

DEPTHAI_SERIALIZE(SpatialKeypointsList, keypoints, edges)

enum

KeypointsListT< SpatialKeypoint > Base

struct

dai::StereoPair

#include StereoPair.hpp

variable

CameraBoardSocket left

variable

CameraBoardSocket right

variable

float baseline

Baseline in centimeters.

variable

bool isVertical

function

DEPTHAI_SERIALIZE(StereoPair, left, right, baseline, isVertical)

struct

dai::StereoRectification

#include StereoRectification.hpp

variable

std::vector< std::vector< float > > rectifiedRotationLeft

variable

std::vector< std::vector< float > > rectifiedRotationRight

variable

CameraBoardSocket leftCameraSocket

variable

CameraBoardSocket rightCameraSocket

struct

dai::TensorInfo

#include TensorInfo.hpp

variable

StorageOrder order

variable

DataType dataType

variable

unsigned int numDimensions

variable

std::vector< unsigned > dims

variable

std::vector< unsigned > strides

variable

std::string name

variable

unsigned int offset

variable

bool quantization

variable

float qpScale

variable

float qpZp

inline function

void validateStorageOrder()

inline function

int getDataTypeSize()

inline function

int getWidth()

inline function

int getHeight()

inline function

std::size_t getTensorSize()

inline function

int getChannels()

inline function

size_t getChannelStride()

inline function

size_t getWidthStride()

inline function

size_t getHeightStride()

enum

int StorageOrder

enumerator

NHWC

enumerator

NHCW

enumerator

NCHW

enumerator

HWC

enumerator

CHW

enumerator

WHC

enumerator

HCW

enumerator

WCH

enumerator

CWH

enumerator

enum

int DataType

enumerator

FP16

enumerator

U8F

enumerator

INT

enumerator

FP32

enumerator

FP64

struct

dai::Timestamp

#include Timestamp.hpp

variable

int64_t sec

variable

int64_t nsec

inline function

std::chrono::time_point< std::chrono::steady_clock, std::chrono::steady_clock::duration > get()

struct

dai::BoardConfig

variable

USB usb

variable

Network network

variable

std::vector< std::string > sysctl

Optional list of FreeBSD sysctl parameters to be set (system, network, etc.). For example: "net.inet.tcp.delayed_ack=0" (this one is also set by default)

variable

std::optional< uint32_t > watchdogTimeoutMs

variable

std::optional< uint32_t > watchdogInitialDelayMs

variable

std::unordered_map< std::int8_t, GPIO > gpio

variable

std::unordered_map< std::int8_t, UART > uart

variable

std::optional< bool > pcieInternalClock

variable

std::optional< bool > usb3PhyInternalClock

variable

std::optional< bool > mipi4LaneRgb

variable

std::optional< bool > emmc

variable

std::optional< std::string > logPath

variable

std::optional< size_t > logSizeMax

variable

std::optional< LogLevel > logVerbosity

variable

std::optional< bool > logDevicePrints

variable

bool nonExclusiveMode

variable

std::unordered_map< CameraBoardSocket, Camera > camera

variable

std::optional< IMU > imu

variable

std::optional< UVC > uvc

variable

std::unordered_map< std::string, Extrinsics > defaultImuExtr

struct

dai::BoardConfig::Camera

#include BoardConfig.hpp

variable

std::string name

variable

std::optional< CameraSensorType > sensorType

variable

std::optional< CameraImageOrientation > orientation

struct

dai::BoardConfig::GPIO

#include BoardConfig.hpp

variable

Mode mode

variable

Direction direction

variable

Level level

variable

Pull pull

variable

Drive drive

variable

bool schmitt

variable

bool slewFast

function

GPIO()

inline function

GPIO(Direction direction)

inline function

GPIO(Direction direction, Level level)

inline function

GPIO(Direction direction, Level level, Pull pull)

inline function

GPIO(Direction direction, Mode mode)

inline function

GPIO(Direction direction, Mode mode, Pull pull)

enum

std::int8_t Mode

enumerator

ALT_MODE_0

enumerator

ALT_MODE_1

enumerator

ALT_MODE_2

enumerator

ALT_MODE_3

enumerator

ALT_MODE_4

enumerator

ALT_MODE_5

enumerator

ALT_MODE_6

enumerator

DIRECT

enum

std::int8_t Direction

enumerator

INPUT

enumerator

OUTPUT

enum

std::int8_t Level

enumerator

LOW

enumerator

HIGH

enum

std::int8_t Pull

enumerator

NO_PULL

enumerator

PULL_UP

enumerator

PULL_DOWN

enumerator

BUS_KEEPER

enum

std::int8_t Drive

enumerator

MA_2

enumerator

MA_4

enumerator

MA_8

enumerator

MA_12

struct

dai::BoardConfig::IMU

variable

int8_t bus

variable

int8_t interrupt

variable

int8_t wake

variable

int8_t csGpio

variable

int8_t boot

variable

int8_t reset

inline function

IMU()

struct

dai::BoardConfig::Network

#include BoardConfig.hpp

variable

uint16_t mtu

Network MTU, 0 is auto (usually 1500 for Ethernet) or forwarded from bootloader (not yet implemented there). Note: not advised to increase past 1500 for now

variable

bool xlinkTcpNoDelay

Sets the

struct

dai::BoardConfig::UART

#include BoardConfig.hpp

variable

std::int8_t tmp

struct

dai::BoardConfig::USB

#include BoardConfig.hpp

variable

uint16_t vid

variable

uint16_t pid

variable

uint16_t flashBootedVid

variable

uint16_t flashBootedPid

variable

UsbSpeed maxSpeed

variable

std::string productName

variable

std::string manufacturer

struct

dai::BoardConfig::UVC

#include BoardConfig.hpp

variable

std::string cameraName

variable

uint16_t width

variable

uint16_t height

variable

ImgFrame::Type frameType

variable

bool enable

inline function

UVC(uint16_t width, uint16_t height)

inline function

UVC()

class

dai::CalibrationHandler

#include CalibrationHandler.hpp

function

CalibrationHandler()

explicit function

CalibrationHandler(std::filesystem::path eepromDataPath, std::optional< bool > validateCalibration)

Construct a new Calibration Handler object using the eeprom json file created from calibration procedure.

Parameters

eepromDataPath: takes the full path to the json file containing the calibration and device info.
validateCalibration: Enable internal check for extrinsics cycling links or dangling references.

function

 CalibrationHandler(std::filesystem::path calibrationDataPath, std::filesystem::path boardConfigPath, std::optional< bool > validateCalibration)

Construct a new Calibration Handler object using the board config json file and .calib binary files created using gen1 calibration.

Parameters

calibrationDataPath: Full Path to the .calib binary file from the gen1 calibration. (Supports only Version 5)
boardConfigPath: Full Path to the board config json file containing device information.
validateCalibration: Enable internal check for extrinsics cycling links or dangling references.

explicit function

CalibrationHandler(EepromData eepromData, std::optional< bool > validateCalibration)

Construct a new Calibration Handler object from EepromData object.

Parameters

eepromData: EepromData data structure containing the calibration data.
validateCalibration: Enable internal check for extrinsics cycling links or dangling references.

function

dai::EepromData getEepromData()

Get the Eeprom Data object

Returns

EepromData object which contains the raw calibration data

function

std::vector< std::vector< float > > getCameraIntrinsics(CameraBoardSocket cameraId, int resizeWidth, int resizeHeight, Point2f topLeftPixelId, Point2f bottomRightPixelId, bool keepAspectRatio)

Get the Camera Intrinsics object

Parameters

cameraId: Uses the cameraId to identify which camera intrinsics to return
resizewidth: resized width of the image for which intrinsics is requested. resizewidth = -1 represents width is same as default intrinsics
resizeHeight: resized height of the image for which intrinsics is requested. resizeHeight = -1 represents height is same as default intrinsics
topLeftPixelId: (x, y) point represents the top left corner coordinates of the cropped image which is used to modify the intrinsics for the respective cropped image
bottomRightPixelId: (x, y) point represents the bottom right corner coordinates of the cropped image which is used to modify the intrinsics for the respective cropped image
keepAspectRatio: Enabling this will scale on width or height depending on which provides the max resolution and crops the remaining part of the other side

Returns

Represents the 3x3 intrinsics matrix of the respective camera at the requested size and crop dimensions.

function

std::vector< std::vector< float > > getCameraIntrinsics(CameraBoardSocket cameraId, Size2f destShape, Point2f topLeftPixelId, Point2f bottomRightPixelId, bool keepAspectRatio)

Get the Camera Intrinsics object

Parameters

cameraId: Uses the cameraId to identify which camera intrinsics to return
destShape: resized width and height of the image for which intrinsics is requested.
topLeftPixelId: (x, y) point represents the top left corner coordinates of the cropped image which is used to modify the intrinsics for the respective cropped image
bottomRightPixelId: (x, y) point represents the bottom right corner coordinates of the cropped image which is used to modify the intrinsics for the respective cropped image
keepAspectRatio: Enabling this will scale on width or height depending on which provides the max resolution and crops the remaining part of the other side

Returns

Represents the 3x3 intrinsics matrix of the respective camera at the requested size and crop dimensions.

function

std::vector< std::vector< float > > getCameraIntrinsics(CameraBoardSocket cameraId, std::tuple< int, int > destShape, Point2f topLeftPixelId, Point2f bottomRightPixelId, bool keepAspectRatio)

Get the Camera Intrinsics object

Parameters

cameraId: Uses the cameraId to identify which camera intrinsics to return
destShape: resized width and height of the image for which intrinsics is requested.
topLeftPixelId: (x, y) point represents the top left corner coordinates of the cropped image which is used to modify the intrinsics for the respective cropped image
bottomRightPixelId: (x, y) point represents the bottom right corner coordinates of the cropped image which is used to modify the intrinsics for the respective cropped image
keepAspectRatio: Enabling this will scale on width or height depending on which provides the max resolution and crops the remaining part of the other side

Returns

Represents the 3x3 intrinsics matrix of the respective camera at the requested size and crop dimensions.

function

std::tuple< std::vector< std::vector< float > >, int, int > getDefaultIntrinsics(CameraBoardSocket cameraId)

Get the Default Intrinsics object

Parameters

cameraId: Uses the cameraId to identify which camera intrinsics to return

Returns

Represents the 3x3 intrinsics matrix of the respective camera along with width and height at which it was calibrated.

function

std::vector< float > getDistortionCoefficients(CameraBoardSocket cameraId)

Get the Distortion Coefficients object

Parameters

cameraId: Uses the cameraId to identify which distortion Coefficients to return.

Returns

the distortion coefficients of the requested camera in this order: [k1,k2,p1,p2,k3,k4,k5,k6,s1,s2,s3,s4,τx,τy] for CameraModel::Perspective or [k1, k2, k3, k4] for CameraModel::Fisheye see Perspective model (Rational Polynomial Model) see

function

float getFov(CameraBoardSocket cameraId, bool useSpec)

Get the Fov of the camera

Parameters

cameraId: of the camera of which we are fetching fov.
useSpec: Disabling this bool will calculate the fov based on intrinsics (focal length, image width), instead of getting it from the camera specs

Returns

field of view of the camera with given cameraId.

function

uint8_t getLensPosition(CameraBoardSocket cameraId)

Get the lens position of the given camera

Parameters

cameraId: of the camera with lens position is requested.

Returns

lens position of the camera with given cameraId at which it was calibrated.

function

CameraModel getDistortionModel(CameraBoardSocket cameraId)

Get the distortion model of the given camera

Parameters

cameraId: of the camera with lens position is requested.

Returns

lens position of the camera with given cameraId at which it was calibrated.

function

std::vector< std::vector< float > > getCameraExtrinsics(CameraBoardSocket srcCamera, CameraBoardSocket dstCamera, bool useSpecTranslation, LengthUnit unit)

Get the Camera Extrinsics object between two cameras from the calibration data if there is a linked connection between any two cameras then the relative rotation and translation is returned by this function.

Parameters

srcCamera: Camera Id of the camera which will be considered as origin.
dstCamera: Camera Id of the destination camera to which we are fetching the rotation and translation from the SrcCamera
useSpecTranslation: Enabling this bool uses the translation information from the board design data
unit: Units of the returned translation (default: centimeters)

Returns

a transformationMatrix which is 4x4 in homogeneous coordinate system

function

std::vector< std::vector< float > > getHousingCalibration(CameraBoardSocket srcCamera, const HousingCoordinateSystem housingCS, bool useSpecTranslation, LengthUnit unit)

Get the transformation matrix between a camera and a chosen housing coordinate system. The returned 4x4 homogeneous transformation matrix maps points from the camera's coordinate system into the specified housing coordinate system.The transformation consists of a rotation matrix and translation vector extracted either from the calibration data or from the board design (specification) data, depending on the

Parameters

srcCamera: Camera whose coordinate frame will be treated as the origin.
housingCS: The housing coordinate system to which the camera transformation is requested (e.g. VESA_RIGHT, FRONT_COVER_LEFT, etc.).
useSpecTranslation: If true, uses board-design (spec) translation values. If false, uses calibrated translation values.
unit: Units of the returned translation (default: centimeters)

Returns

A 4x4 homogeneous transformation matrix.

function

std::vector< float > getCameraTranslationVector(CameraBoardSocket srcCamera, CameraBoardSocket dstCamera, bool useSpecTranslation, LengthUnit unit)

Get the Camera translation vector between two cameras from the calibration data.

Parameters

srcCamera: Camera Id of the camera which will be considered as origin.
dstCamera: Camera Id of the destination camera to which we are fetching the translation vector from the SrcCamera
useSpecTranslation: Disabling this bool uses the translation information from the calibration data (not the board design data)
unit: Units of the returned translation (default: centimeters)

Returns

a translation vector like [x, y, z]

function

std::vector< std::vector< float > > getCameraRotationMatrix(CameraBoardSocket srcCamera, CameraBoardSocket dstCamera)

Get the Camera rotation matrix between two cameras from the calibration data.

Parameters

srcCamera: Camera Id of the camera which will be considered as origin.
dstCamera: Camera Id of the destination camera to which we are fetching the rotation vector from the SrcCamera

Returns

a 3x3 rotation matrix Matrix representation of rotation matrix

function

float getBaselineDistance(CameraBoardSocket cam1, CameraBoardSocket cam2, bool useSpecTranslation, LengthUnit unit)

Get the baseline distance between two specified cameras. By default it will get the baseline between CameraBoardSocket.RIGHT and CameraBoardSocket.LEFT.

Parameters

cam1: First camera
cam2: Second camera
useSpecTranslation: Enabling this bool uses the translation information from the board design data (not the calibration data)
unit: Units of the returned baseline distance (default: centimeters)

Returns

baseline distance

function

std::vector< std::vector< float > > getCameraToImuExtrinsics(CameraBoardSocket cameraId, bool useSpecTranslation, LengthUnit unit)

Get the Camera To Imu Extrinsics object From the data loaded if there is a linked connection between IMU and the given camera then there relative rotation and translation from the camera to IMU is returned.

Parameters

cameraId: Camera Id of the camera which will be considered as origin. from which Transformation matrix to the IMU will be found
useSpecTranslation: Enabling this bool uses the translation information from the board design data
unit: Units of the returned translation (default: centimeters)

Returns

Returns a transformationMatrix which is 4x4 in homogeneous coordinate system

function

std::vector< std::vector< float > > getImuToCameraExtrinsics(CameraBoardSocket cameraId, bool useSpecTranslation, LengthUnit unit)

Get the Imu To Camera Extrinsics object from the data loaded if there is a linked connection between IMU and the given camera then there relative rotation and translation from the IMU to Camera is returned.

Parameters

cameraId: Camera Id of the camera which will be considered as destination. To which Transformation matrix from the IMU will be found.
useSpecTranslation: Enabling this bool uses the translation information from the board design data
unit: Units of the returned translation (default: centimeters)

Returns

Returns a transformationMatrix which is 4x4 in homogeneous coordinate system

function

std::vector< std::vector< float > > getStereoRightRectificationRotation()

Get the Stereo Right Rectification Rotation object

Returns

returns a 3x3 rectification rotation matrix

function

std::vector< std::vector< float > > getStereoLeftRectificationRotation()

Get the Stereo Left Rectification Rotation object

Returns

returns a 3x3 rectification rotation matrix

function

dai::CameraBoardSocket getStereoLeftCameraId()

Get the camera id of the camera which is used as left camera of the stereo setup

Returns

cameraID of the camera used as left camera

function

dai::CameraBoardSocket getStereoRightCameraId()

Get the camera id of the camera which is used as right camera of the stereo setup

Returns

cameraID of the camera used as right camera

function

bool eepromToJsonFile(std::filesystem::path destPath)

Write raw calibration/board data to json file.

Parameters

destPath: Full path to the json file in which raw calibration data will be stored

Returns

True on success, false otherwise

function

nlohmann::json eepromToJson()

Get JSON representation of calibration data

Returns

JSON structure

function

void setBoardInfo(std::string boardName, std::string boardRev)

Set the Board Info object

Parameters

version: Sets the version of the Calibration data(Current version is 6)
boardName: Sets your board name.
boardRev: set your board revision id.

function

void setBoardInfo(std::string productName, std::string boardName, std::string boardRev, std::string boardConf, std::string hardwareConf, std::string batchName, uint64_t batchTime, uint32_t boardOptions, std::string boardCustom)

Set the Board Info object. Creates version 7 EEPROM data

Parameters

productName: Sets product name (alias).
boardName: Sets board name.
boardRev: Sets board revision id.
boardConf: Sets board configuration id.
hardwareConf: Sets hardware configuration id.
batchName: Sets batch name.
batchTime: Sets batch time (unix timestamp).
boardCustom: Sets a custom board (Default empty string).

function

void setBoardInfo(std::string deviceName, std::string productName, std::string boardName, std::string boardRev, std::string boardConf, std::string hardwareConf, std::string batchName, uint64_t batchTime, uint32_t boardOptions, std::string boardCustom)

Set the Board Info object. Creates version 7 EEPROM data

Parameters

deviceName: Sets device name.
productName: Sets product name (alias).
boardName: Sets board name.
boardRev: Sets board revision id.
boardConf: Sets board configuration id.
hardwareConf: Sets hardware configuration id.
batchName: Sets batch name. Not supported anymore
batchTime: Sets batch time (unix timestamp).
boardCustom: Sets a custom board (Default empty string).

function

void setDeviceName(std::string deviceName)

Set the deviceName which responses to getDeviceName of Device

Parameters

deviceName: Sets device name.

function

void setProductName(std::string productName)

Set the productName which acts as alisas for users to identify the device

Parameters

productName: Sets product name (alias).

function

void setCameraIntrinsics(CameraBoardSocket cameraId, std::vector< std::vector< float >> intrinsics, Size2f frameSize)

Set the Camera Intrinsics object

Parameters

cameraId: CameraId of the camera for which Camera intrinsics are being loaded
intrinsics: 3x3 intrinsics matrix
frameSize: Represents the width and height of the image at which intrinsics are calculated.

function

void setCameraIntrinsics(CameraBoardSocket cameraId, std::vector< std::vector< float >> intrinsics, int width, int height)

Set the Camera Intrinsics object

Parameters

cameraId: CameraId of the camera for which Camera intrinsics are being loaded
intrinsics: 3x3 intrinsics matrix
width: Represents the width of the image at which intrinsics are calculated.
height: Represents the height of the image at which intrinsics are calculated.

function

void setCameraIntrinsics(CameraBoardSocket cameraId, std::vector< std::vector< float >> intrinsics, std::tuple< int, int > frameSize)

Set the Camera Intrinsics object

Parameters

cameraId: CameraId of the camera for which Camera intrinsics are being loaded
intrinsics: 3x3 intrinsics matrix
frameSize: Represents the width and height of the image at which intrinsics are calculated.

function

void setDistortionCoefficients(CameraBoardSocket cameraId, std::vector< float > distortionCoefficients)

Sets the distortion Coefficients obtained from camera calibration

Parameters

cameraId: Camera Id of the camera for which distortion coefficients are computed
distortionCoefficients: Distortion Coefficients of the respective Camera.

function

void setFov(CameraBoardSocket cameraId, float hfov)

Set the Fov of the Camera

Parameters

cameraId: Camera Id of the camera
hfov: Horizontal fov of the camera from Camera Datasheet

function

void setLensPosition(CameraBoardSocket cameraId, uint8_t lensPosition)

Sets the distortion Coefficients obtained from camera calibration

Parameters

cameraId: Camera Id of the camera
lensPosition: lens posiotion value of the camera at the time of calibration

function

void setCameraType(CameraBoardSocket cameraId, CameraModel cameraModel)

Set the Camera Type object

Parameters

cameraId: CameraId of the camera for which cameraModel Type is being updated.
cameraModel: Type of the model the camera represents

function

void setCameraExtrinsics(CameraBoardSocket srcCameraId, CameraBoardSocket destCameraId, std::vector< std::vector< float >> rotationMatrix, std::vector< float > translation, std::vector< float > specTranslation)

Set the Camera Extrinsics object

Parameters

srcCameraId: Camera Id of the camera which will be considered as relative origin.
destCameraId: Camera Id of the camera which will be considered as destination from srcCameraId.
rotationMatrix: Rotation between srcCameraId and destCameraId origins.
translation: Translation between srcCameraId and destCameraId origins.
specTranslation: Translation between srcCameraId and destCameraId origins from the design.

function

void setImuExtrinsics(CameraBoardSocket destCameraId, std::vector< std::vector< float >> rotationMatrix, std::vector< float > translation, std::vector< float > specTranslation)

Set the Imu to Camera Extrinsics object

Parameters

destCameraId: Camera Id of the camera which will be considered as destination from IMU.
rotationMatrix: Rotation between srcCameraId and destCameraId origins.
translation: Translation between IMU and destCameraId origins.
specTranslation: Translation between IMU and destCameraId origins from the design.

function

void setStereoLeft(CameraBoardSocket cameraId, std::vector< std::vector< float >> rectifiedRotation)

Set the Stereo Left Rectification object

Parameters

cameraId: CameraId of the camera which will be used as left Camera of stereo Setup
rectifiedRotation: Rectification rotation of the left camera required for feature matching

function

void setStereoRight(CameraBoardSocket cameraId, std::vector< std::vector< float >> rectifiedRotation)

Set the Stereo Right Rectification object

Parameters

cameraId: CameraId of the camera which will be used as left Camera of stereo Setup
rectifiedRotation: Rectification rotation of the left camera required for feature matching

function

bool validateCameraArray()

Using left camera as the head it iterates over the camera extrinsics connection to check if all the camera extrinsics are connected and no loop exists.

Returns

true on proper connection with no loops.

function

void validateCalibrationHandler(bool throwOnError)

Validate Calibration handler properties and how they are set, so there is no:

Cycling links
Missing links
Dangling connections

Parameters

throwOnError: Throw runtime error on failture.

class

dai::CallbackHandler

function

void setCallback(std::function< std::shared_ptr< ADatatype >(std::shared_ptr< ADatatype >)> cb)

function

 CallbackHandler(std::shared_ptr< XLinkConnection > conn, const std::string & streamName, std::function< std::shared_ptr< ADatatype >(std::shared_ptr< ADatatype >)> cb)

function

~CallbackHandler()

struct

dai::CrashDump

variable

std::vector< CrashReport > crashReports

variable

std::string depthaiCommitHash

variable

std::string deviceId

inline function

nlohmann::json serializeToJson()

struct

dai::CrashDump::CrashReport

variable

ProcessorType processor

variable

std::string errorSource

variable

uint32_t crashedThreadId

variable

ErrorSourceInfo errorSourceInfo

variable

std::vector< ThreadCallstack > threadCallstack

variable

std::vector< std::string > prints

variable

uint64_t uptimeNs

variable

uint64_t timerRaw

variable

uint64_t statusFlags

function

 DEPTHAI_SERIALIZE(CrashReport, processor, errorSource, crashedThreadId, errorSourceInfo, threadCallstack, prints, uptimeNs, timerRaw, statusFlags)

struct

dai::CrashDump::CrashReport::ErrorSourceInfo

variable

AssertContext assertContext

variable

TrapContext trapContext

variable

uint32_t errorId

function

DEPTHAI_SERIALIZE(ErrorSourceInfo, assertContext, trapContext, errorId)

struct

dai::CrashDump::CrashReport::ErrorSourceInfo::AssertContext

variable

std::string fileName

variable

std::string functionName

variable

uint32_t line

function

DEPTHAI_SERIALIZE(AssertContext, fileName, functionName, line)

struct

dai::CrashDump::CrashReport::ErrorSourceInfo::TrapContext

variable

uint32_t trapNumber

variable

uint32_t trapAddress

variable

std::string trapName

function

DEPTHAI_SERIALIZE(TrapContext, trapNumber, trapAddress, trapName)

struct

dai::CrashDump::CrashReport::ThreadCallstack

variable

uint32_t threadId

variable

std::string threadName

variable

std::string threadStatus

variable

uint32_t stackBottom

variable

uint32_t stackTop

variable

uint32_t stackPointer

variable

uint32_t instructionPointer

variable

std::vector< CallstackContext > callStack

function

 DEPTHAI_SERIALIZE(ThreadCallstack, threadId, threadName, threadStatus, stackBottom, stackTop, stackPointer, instructionPointer, callStack)

struct

dai::CrashDump::CrashReport::ThreadCallstack::CallstackContext

variable

uint32_t callSite

variable

uint32_t calledTarget

variable

uint32_t framePointer

variable

std::string context

function

DEPTHAI_SERIALIZE(CallstackContext, callSite, calledTarget, framePointer, context)

class

dai::Device

#include Device.hpp

function

Device()

Connects to any available device with a DEFAULT_SEARCH_TIME timeout. Uses OpenVINO version OpenVINO::VERSION_UNIVERSAL

function

~Device()

function

Platform getPlatform()

function

std::string getPlatformAsString()

function

DeviceBase()

Connects to any available device with a DEFAULT_SEARCH_TIME timeout. Uses OpenVINO version OpenVINO::VERSION_UNIVERSAL

function

DeviceBase(UsbSpeed maxUsbSpeed)

Connects to device

Parameters

maxUsbSpeed: Maximum allowed USB speed

function

DeviceBase(const DeviceInfo & devInfo, UsbSpeed maxUsbSpeed)

Connects to device specified by devInfo.

Parameters

devInfo: DeviceInfo which specifies which device to connect to
maxUsbSpeed: Maximum allowed USB speed

function

DeviceBase(const DeviceInfo & devInfo, const std::filesystem::path & pathToCmd)

Connects to device specified by devInfo.

Parameters

devInfo: DeviceInfo which specifies which device to connect to
pathToCmd: Path to custom device firmware

explicit function

DeviceBase(Config config)

Connects to any available device with custom config.

Parameters

config: Device custom configuration to boot with

function

DeviceBase(Config config, const DeviceInfo & devInfo)

Connects to device 'devInfo' with custom config.

Parameters

config: Device custom configuration to boot with
devInfo: DeviceInfo which specifies which device to connect to

explicit function

DeviceBase(const DeviceInfo & devInfo)

Connects to any available device with a DEFAULT_SEARCH_TIME timeout. Uses OpenVINO version OpenVINO::VERSION_UNIVERSAL

Parameters

devInfo: DeviceInfo which specifies which device to connect to

function

DeviceBase(std::string nameOrDeviceId)

Connects to any available device with a DEFAULT_SEARCH_TIME timeout. Uses OpenVINO version OpenVINO::VERSION_UNIVERSAL

Parameters

nameOrDeviceId: Creates DeviceInfo with nameOrDeviceId to connect to

function

DeviceBase(std::string nameOrDeviceId, UsbSpeed maxUsbSpeed)

Connects to any available device with a DEFAULT_SEARCH_TIME timeout. Uses OpenVINO version OpenVINO::VERSION_UNIVERSAL

Parameters

nameOrDeviceId: Creates DeviceInfo with nameOrDeviceId to connect to
maxUsbSpeed: Maximum allowed USB speed

function

DeviceBase(Config config, UsbSpeed maxUsbSpeed)

Connects to device specified by devInfo.

Parameters

config: Config with which the device will be booted with
maxUsbSpeed: Maximum allowed USB speed

function

DeviceBase(Config config, const std::filesystem::path & pathToCmd)

Connects to any available device with a DEFAULT_SEARCH_TIME timeout.

Parameters

config: Config with which the device will be booted with
pathToCmd: Path to custom device firmware

function

DeviceBase(Config config, const DeviceInfo & devInfo, UsbSpeed maxUsbSpeed)

Connects to device specified by devInfo.

Parameters

config: Config with which the device will be booted with
devInfo: DeviceInfo which specifies which device to connect to
maxUsbSpeed: Maximum allowed USB speed

function

DeviceBase(Config config, const DeviceInfo & devInfo, const std::filesystem::path & pathToCmd, bool dumpOnly)

Connects to device specified by devInfo.

Parameters

config: Config with which the device will be booted with
devInfo: DeviceInfo which specifies which device to connect to
pathToCmd: Path to custom device firmware
dumpOnly: If true only the minimal connection is established to retrieve the crash dump

enum

ReconnectionStatus

class

dai::DeviceBase

#include DeviceBase.hppDerived by dai::Device

function

DeviceBase()

Connects to any available device with a DEFAULT_SEARCH_TIME timeout. Uses OpenVINO version OpenVINO::VERSION_UNIVERSAL

function

DeviceBase(UsbSpeed maxUsbSpeed)

Connects to device

Parameters

maxUsbSpeed: Maximum allowed USB speed

function

DeviceBase(const DeviceInfo & devInfo, UsbSpeed maxUsbSpeed)

Connects to device specified by devInfo.

Parameters

devInfo: DeviceInfo which specifies which device to connect to
maxUsbSpeed: Maximum allowed USB speed

function

DeviceBase(const DeviceInfo & devInfo, const std::filesystem::path & pathToCmd)

Connects to device specified by devInfo.

Parameters

devInfo: DeviceInfo which specifies which device to connect to
pathToCmd: Path to custom device firmware

explicit function

DeviceBase(Config config)

Connects to any available device with custom config.

Parameters

config: Device custom configuration to boot with

function

DeviceBase(Config config, const DeviceInfo & devInfo)

Connects to device 'devInfo' with custom config.

Parameters

config: Device custom configuration to boot with
devInfo: DeviceInfo which specifies which device to connect to

explicit function

DeviceBase(const DeviceInfo & devInfo)

Connects to any available device with a DEFAULT_SEARCH_TIME timeout. Uses OpenVINO version OpenVINO::VERSION_UNIVERSAL

Parameters

devInfo: DeviceInfo which specifies which device to connect to

function

DeviceBase(std::string nameOrDeviceId)

Connects to any available device with a DEFAULT_SEARCH_TIME timeout. Uses OpenVINO version OpenVINO::VERSION_UNIVERSAL

Parameters

nameOrDeviceId: Creates DeviceInfo with nameOrDeviceId to connect to

function

DeviceBase(std::string nameOrDeviceId, UsbSpeed maxUsbSpeed)

Connects to any available device with a DEFAULT_SEARCH_TIME timeout. Uses OpenVINO version OpenVINO::VERSION_UNIVERSAL

Parameters

nameOrDeviceId: Creates DeviceInfo with nameOrDeviceId to connect to
maxUsbSpeed: Maximum allowed USB speed

function

DeviceBase(Config config, UsbSpeed maxUsbSpeed)

Connects to device specified by devInfo.

Parameters

config: Config with which the device will be booted with
maxUsbSpeed: Maximum allowed USB speed

function

DeviceBase(Config config, const std::filesystem::path & pathToCmd)

Connects to any available device with a DEFAULT_SEARCH_TIME timeout.

Parameters

config: Config with which the device will be booted with
pathToCmd: Path to custom device firmware

function

DeviceBase(Config config, const DeviceInfo & devInfo, UsbSpeed maxUsbSpeed)

Connects to device specified by devInfo.

Parameters

config: Config with which the device will be booted with
devInfo: DeviceInfo which specifies which device to connect to
maxUsbSpeed: Maximum allowed USB speed

function

DeviceBase(Config config, const DeviceInfo & devInfo, const std::filesystem::path & pathToCmd, bool dumpOnly)

Connects to device specified by devInfo.

Parameters

config: Config with which the device will be booted with
devInfo: DeviceInfo which specifies which device to connect to
pathToCmd: Path to custom device firmware
dumpOnly: If true only the minimal connection is established to retrieve the crash dump

function

~DeviceBase()

Device destructor

Parameters

In the destructor of the derived class, remember to call close()

function

std::optional< Version > getBootloaderVersion()

Gets Bootloader version if it was booted through Bootloader

Returns

DeviceBootloader::Version if booted through Bootloader or none otherwise

function

bool isPipelineRunning()

Checks if devices pipeline is already running

Returns

True if running, false otherwise

function

bool startPipeline(const Pipeline & pipeline)

Starts the execution of a given pipeline

Parameters

pipeline: OpenVINO version of the pipeline must match the one which the device was booted with.

Returns

True if pipeline started, false otherwise

function

void setLogLevel(LogLevel level)

Sets the devices logging severity level. This level affects which logs are transferred from device to host.

Parameters

level: Logging severity

function

void setNodeLogLevel(int64_t id, LogLevel level)

Sets the logging severity level for a specific node with a given ID.

Parameters

id: Node ID
level: Logging severity

function

LogLevel getLogLevel()

Gets current logging severity level of the device.

Returns

Logging severity level

function

LogLevel getNodeLogLevel(int64_t id)

Gets the logging severity level for a specific node with a given ID.

Parameters

id: Node ID

Returns

Logging severity level

function

void setXLinkChunkSize(int sizeBytes)

Sets the chunk size for splitting device-sent XLink packets. A larger value could increase performance, and 0 disables chunking. A negative value is ignored. Device defaults are configured per protocol, currently 64*1024 for both USB and Ethernet.

Parameters

sizeBytes: XLink chunk size in bytes

function

int getXLinkChunkSize()

Gets current XLink chunk size.

Returns

XLink chunk size in bytes

function

void setXLinkRateLimit(int maxRateBytesPerSecond, int burstSize, int waitUs)

Sets the maximum transmission rate for the XLink connection on device side, using a simple token bucket algorithm. Useful for bandwidth throttling

Parameters

maxRateBytesPerSecond: Rate limit in Bytes/second
burstSize: Size in Bytes for how much to attempt to send once, 0 = auto
waitUs: Time in microseconds to wait for replenishing tokens, 0 = auto

function

DeviceInfo getDeviceInfo()

Get the Device Info object o the device which is currently running

Returns

DeviceInfo of the current device in execution

function

std::string getDeviceName()

Get device name if available

Returns

device name or empty string if not available

function

std::string getProductName()

Get product name if available

Returns

product name or empty string if not available

function

std::string getMxId()

Get MxId of device

Returns

MxId of connected device

function

std::string getDeviceId()

Get DeviceId of device

Returns

DeviceId of connected device

function

void setLogOutputLevel(LogLevel level)

Sets logging level which decides printing level to standard output. If lower than setLogLevel, no messages will be printed

Parameters

level: Standard output printing severity

function

LogLevel getLogOutputLevel()

Gets logging level which decides printing level to standard output.

Returns

Standard output printing severity

function

bool setIrLaserDotProjectorIntensity(float intensity, int mask)

Sets the intensity of the IR Laser Dot Projector. Limits: up to 765mA at 30% frame time duty cycle when exposure time is longer than 30% frame time. Otherwise, duty cycle is 100% of exposure time, with current increased up to max 1200mA to make up for shorter duty cycle. The duty cycle is controlled by

Parameters

intensity: Intensity on range 0 to 1, that will determine brightness. 0 or negative to turn off
mask: Optional mask to modify only Left (0x1) or Right (0x2) sides on OAK-D-Pro-W-DEV

Returns

True on success, false if not found or other failure

function

bool setIrFloodLightIntensity(float intensity, int mask)

Sets the intensity of the IR Flood Light. Limits: Intensity is directly normalized to 0 - 1500mA current. The duty cycle is 30% when exposure time is longer than 30% frame time. Otherwise, duty cycle is 100% of exposure time. The duty cycle is controlled by the

Parameters

intensity: Intensity on range 0 to 1, that will determine brightness, 0 or negative to turn off
mask: Optional mask to modify only Left (0x1) or Right (0x2) sides on OAK-D-Pro-W-DEV

Returns

True on success, false if not found or other failure

function

std::vector< std::tuple< std::string, int, int > > getIrDrivers()

Retrieves detected IR laser/LED drivers.

Returns

Vector of tuples containing: driver name, I2C bus, I2C address. For OAK-D-Pro it should be

function

dai::CrashDump getState()

Retrieves current device state in a crash dump format. It halts the device temporarily and might affect the running pipeline, it's best to close the device after this operation. Supported only on RVC2.

function

dai::CrashDump getCrashDump(bool clearCrashDump)

Retrieves crash dump for debugging.

function

bool hasCrashDump()

Retrieves whether the is crash dump stored on device or not.

function

ProfilingData getProfilingData()

Get current accumulated profiling data

Returns

ProfilingData from the specific device

function

int addLogCallback(std::function< void(LogMessage)> callback)

Add a callback for device logging. The callback will be called from a separate thread with the LogMessage being passed.

Parameters

callback: Callback to call whenever a log message arrives

Returns

Id which can be used to later remove the callback

function

bool removeLogCallback(int callbackId)

Removes a callback

Parameters

callbackId: Id of callback to be removed

Returns

True if callback was removed, false otherwise

function

void setSystemInformationLoggingRate(float rateHz)

Sets rate of system information logging ("info" severity). Default 1Hz If parameter is less or equal to zero, then system information logging will be disabled

Parameters

rateHz: Logging rate in Hz

function

float getSystemInformationLoggingRate()

Gets current rate of system information logging ("info" severity) in Hz.

Returns

Logging rate in Hz

function

std::vector< CameraBoardSocket > getConnectedCameras()

Get cameras that are connected to the device

Returns

Vector of connected cameras

function

std::vector< ConnectionInterface > getConnectionInterfaces()

Get connection interfaces for device

Returns

Vector of connection type

function

std::vector< CameraFeatures > getConnectedCameraFeatures()

Get cameras that are connected to the device with their features/properties

Returns

Vector of connected camera features

function

std::vector< StereoPair > getStereoPairs()

Get stereo pairs based on the device type.

Returns

Vector of stereo pairs

function

std::vector< StereoPair > getAvailableStereoPairs()

Get stereo pairs taking into account the calibration and connected cameras.

Parameters

This method will always return a subset of

Returns

Vector of stereo pairs

function

std::unordered_map< CameraBoardSocket, std::string > getCameraSensorNames()

Get sensor names for cameras that are connected to the device

Returns

Map/dictionary with camera sensor names, indexed by socket

function

std::string getConnectedIMU()

Get connected IMU type

Returns

IMU type

function

dai::Version getIMUFirmwareVersion()

Get connected IMU firmware version

Returns

IMU firmware version

function

dai::Version getEmbeddedIMUFirmwareVersion()

Get embedded IMU firmware version to which IMU can be upgraded

Returns

Get embedded IMU firmware version to which IMU can be upgraded.

function

bool startIMUFirmwareUpdate(bool forceUpdate)

Starts IMU firmware update asynchronously only if IMU node is not running. If current firmware version is the same as embedded firmware version then it's no-op. Can be overridden by forceUpdate parameter. State of firmware update can be monitored using getIMUFirmwareUpdateStatus API.

Parameters

forceUpdate: Force firmware update or not. Will perform FW update regardless of current version and embedded firmware version.

Returns

Returns whether firmware update can be started. Returns false if IMU node is started.

function

std::tuple< bool, float > getIMUFirmwareUpdateStatus()

Get IMU firmware update status

Returns

Whether IMU firmware update is done and last firmware update progress as percentage. return value true and 100 means that the update was successful return value true and other than 100 means that the update failed

function

MemoryInfo getDdrMemoryUsage()

Retrieves current DDR memory information from device

Returns

Used, remaining and total ddr memory

function

MemoryInfo getCmxMemoryUsage()

Retrieves current CMX memory information from device

Returns

Used, remaining and total cmx memory

function

MemoryInfo getLeonCssHeapUsage()

Retrieves current CSS Leon CPU heap information from device

Returns

Used, remaining and total heap memory

function

MemoryInfo getLeonMssHeapUsage()

Retrieves current MSS Leon CPU heap information from device

Returns

Used, remaining and total heap memory

function

ChipTemperature getChipTemperature()

Retrieves current chip temperature as measured by device

Returns

Temperature of various onboard sensors

function

CpuUsage getLeonCssCpuUsage()

Retrieves average CSS Leon CPU usage

Returns

Average CPU usage and sampling duration

function

CpuUsage getLeonMssCpuUsage()

Retrieves average MSS Leon CPU usage

Returns

Average CPU usage and sampling duration

function

int64_t getProcessMemoryUsage()

Retrieves current Rss memory usage of the device process

Returns

Current Rss memory used

function

bool isEepromAvailable()

Check if EEPROM is available

Returns

True if EEPROM is present on board, false otherwise

function

bool tryFlashCalibration(CalibrationHandler calibrationDataHandler)

Stores the Calibration and Device information to the Device EEPROM

Parameters

calibrationObj: CalibrationHandler object which is loaded with calibration information.

Returns

true on successful flash, false on failure

function

void flashCalibration(CalibrationHandler calibrationDataHandler)

Stores the Calibration and Device information to the Device EEPROM

Parameters

std::runtime_error: if failed to flash the calibration

Parameters

calibrationObj: CalibrationHandler object which is loaded with calibration information.

function

void setCalibration(CalibrationHandler calibrationDataHandler)

Sets the Calibration at runtime. This is not persistent and will be lost after device reset.

Parameters

std::runtime_error: if failed to set the calibration

Parameters

calibrationObj: CalibrationHandler object which is loaded with calibration information.

function

std::shared_ptr< CalibrationHandler > tryGetCalibration()

Retrieves the CalibrationHandler shared pointer; If can not get calibration returns nullptr

Returns

The CalibrationHandler object containing the non-persistent calibration

function

CalibrationHandler getCalibration()

Retrieves the CalibrationHandler object containing the non-persistent calibration

Parameters

std::runtime_error: if failed to get the calibration

Returns

The CalibrationHandler object containing the non-persistent calibration

function

CalibrationHandler readCalibration()

Fetches the EEPROM data from the device and loads it into CalibrationHandler object If no calibration is flashed, it returns default

Returns

The CalibrationHandler object containing the calibration currently flashed on device EEPROM

function

CalibrationHandler readCalibration2()

Fetches the EEPROM data from the device and loads it into CalibrationHandler object

Parameters

std::runtime_error: if no calibration is flashed

Returns

The CalibrationHandler object containing the calibration currently flashed on device EEPROM

function

CalibrationHandler readCalibrationOrDefault()

Fetches the EEPROM data from the device and loads it into CalibrationHandler object If no calibration is flashed, it returns default

Returns

The CalibrationHandler object containing the calibration currently flashed on device EEPROM

function

void factoryResetCalibration()

Factory reset EEPROM data if factory backup is available.

Parameters

std::runtime_error: If factory reset was unsuccessful

function

void flashFactoryCalibration(CalibrationHandler calibrationHandler)

Stores the Calibration and Device information to the Device EEPROM in Factory area To perform this action, correct env variable must be set

Parameters

std::runtime_error: if failed to flash the calibration

Returns

True on successful flash, false on failure

function

void flashEepromClear()

Destructive action, deletes User area EEPROM contents Requires PROTECTED permissions

Parameters

std::runtime_error: if failed to flash the calibration

Returns

True on successful flash, false on failure

function

void flashFactoryEepromClear()

Destructive action, deletes Factory area EEPROM contents Requires FACTORY PROTECTED permissions

Parameters

std::runtime_error: if failed to flash the calibration

Returns

True on successful flash, false on failure

function

CalibrationHandler readFactoryCalibration()

Fetches the EEPROM data from Factory area and loads it into CalibrationHandler object

Parameters

std::runtime_error: if no calibration is flashed

Returns

The CalibrationHandler object containing the calibration currently flashed on device EEPROM in Factory Area

function

CalibrationHandler readFactoryCalibrationOrDefault()

Fetches the EEPROM data from Factory area and loads it into CalibrationHandler object If no calibration is flashed, it returns default

Returns

The CalibrationHandler object containing the calibration currently flashed on device EEPROM in Factory Area

function

std::vector< std::uint8_t > readCalibrationRaw()

Fetches the raw EEPROM data from User area

Parameters

std::runtime_error: if any error occurred

Returns

Binary dump of User area EEPROM data

function

std::vector< std::uint8_t > readFactoryCalibrationRaw()

Fetches the raw EEPROM data from Factory area

Parameters

std::runtime_error: if any error occurred

Returns

Binary dump of Factory area EEPROM data

function

UsbSpeed getUsbSpeed()

Retrieves USB connection speed

Returns

USB connection speed of connected device if applicable. Unknown otherwise.

function

bool isNeuralDepthSupported()

Checks if Neural Depth is supported on the device

Returns

True if supported, false otherwise

function

void setTimesync(std::chrono::milliseconds period, int numSamples, bool random)

Configures Timesync service on device. It keeps host and device clocks in sync First time timesync is started it waits until the initial sync is completed Afterwards the function changes the following parameters

Parameters

period: Interval between timesync runs
numSamples: Number of timesync samples per run which are used to compute a better value. Set to zero to disable timesync
random: If true partial timesync requests will be performed at random intervals, otherwise at fixed intervals

function

void setTimesync(bool enable)

Enables or disables Timesync service on device. It keeps host and device clocks in sync.

Parameters

enable: Enables or disables consistent timesyncing

function

void close()

Explicitly closes connection to device.

Parameters

This function does not need to be explicitly called as destructor closes the device automatically

function

bool isClosed()

Is the device already closed (or disconnected)

Parameters

This function is thread-unsafe and may return outdated incorrect values. It is only meant for use in simple single-threaded code. Well written code should handle exceptions when calling any DepthAI apis to handle hardware events and multithreaded use.

function

void crashDevice()

Crashes the device

Parameters

ONLY FOR TESTING PURPOSES, it causes an unrecoverable crash on the device

inline function

std::shared_ptr< XLinkConnection > getConnection()

Returns underlying XLinkConnection

inline function

std::shared_ptr< const XLinkConnection > getConnection()

Returns underlying XLinkConnection

function

void setMaxReconnectionAttempts(int maxAttempts, std::function< void(ReconnectionStatus)> callBack)

Sets max number of automatic reconnection attempts

Parameters

maxAttempts: Maximum number of reconnection attempts, 0 to disable reconnection
callBack: Callback to be called when reconnection is attempted

function

std::tuple< bool, std::string > setExternalFrameSyncRole(ExternalFrameSyncRole role)

Sets external frame sync role for the device

Parameters

role: External frame sync role to be set, AUTO_DETECT by default

Returns

Tuple of bool and string. Bool specifies if role was set without failures. String is the error message describing the failure reason.

function

ExternalFrameSyncRole getExternalFrameSyncRole()

Gets external frame sync role for the device

Returns

Gets external frame sync role

function

std::tuple< bool, std::string > setExternalStrobeRelativeLimits(float min, float max)

Sets the relative external strobe limits. Limits the strobe duty cycle, between 0 and 1, as a fraction of the whole period. 0 means always off, 1 means always on. The rising edge of the strobe signal is always synced to end of exposure. The falling edge of the strobe signal is then limited according to the min and max values. Default values are 0.005 and 0.995

Parameters

min: Minimum strobe value
max: Maximum strobe value

Returns

Tuple of bool and string. Bool specifies if role was set without failures. String is the error message describing the failure reason.

function

void setExternalStrobeEnable(bool enable)

Set whether the external strobe should be enabled. External strobe signal is low for the duration of exposure, and high for the rest of the frame.

Parameters

enable: Enables or disables strobe

struct

dai::DeviceBase::Config

#include DeviceBase.hpp

variable

OpenVINO::Version version

variable

BoardConfig board

variable

bool nonExclusiveMode

variable

std::optional< LogLevel > outputLogLevel

variable

std::optional< LogLevel > logLevel

enum

ReconnectionStatus

enumerator

RECONNECTED

enumerator

RECONNECTING

enumerator

RECONNECT_FAILED

class

dai::DeviceBootloader

#include DeviceBootloader.hpp

function

DeviceBootloader()

explicit function

DeviceBootloader(const DeviceInfo & devInfo)

Connects to or boots device in bootloader mode depending on devInfo state; flashing not allowed

Parameters

devInfo: DeviceInfo of which to boot or connect to

function

DeviceBootloader(const DeviceInfo & devInfo, T allowFlashingBootloader)

Connects to or boots device in bootloader mode depending on devInfo state.

Parameters

devInfo: DeviceInfo of which to boot or connect to
allowFlashingBootloader: (bool) Set to true to allow flashing the devices bootloader

function

DeviceBootloader(const DeviceInfo & devInfo, Type type, bool allowFlashingBootloader)

Connects to device in bootloader of specified type. Throws if it wasn't possible. This constructor will automatically boot into specified bootloader type if not already running

Parameters

devInfo: DeviceInfo of which to boot or connect to
type: Type of bootloader to boot/connect to.
allowFlashingBootloader: Set to true to allow flashing the devices bootloader. Defaults to false

function

DeviceBootloader(const DeviceInfo & devInfo, const fs::path & pathToBootloader, bool allowFlashingBootloader)

Connects to or boots device in bootloader mode depending on devInfo state with a custom bootloader firmware.

Parameters

devInfo: DeviceInfo of which to boot or connect to
pathToBootloader: Custom bootloader firmware to boot
allowFlashingBootloader: Set to true to allow flashing the devices bootloader. Defaults to false

function

DeviceBootloader(std::string nameOrDeviceId, bool allowFlashingBootloader)

Connects to device with specified name/device id

Parameters

nameOrDeviceId: Creates DeviceInfo with nameOrDeviceId to connect to
allowFlashingBootloader: Set to true to allow flashing the devices bootloader. Defaults to false

function

~DeviceBootloader()

function

std::tuple< bool, std::string > flash(std::function< void(float)> progressCallback, const Pipeline & pipeline, bool compress, std::string applicationName, Memory memory, bool checkChecksum)

Flashes a given pipeline to the device.

Parameters

progressCallback: Callback that sends back a value between 0..1 which signifies current flashing progress
pipeline: Pipeline to flash to the board
compress: Compresses application to reduce needed memory size
applicationName: Name the application that is flashed

function

std::tuple< bool, std::string > flash(const Pipeline & pipeline, bool compress, std::string applicationName, Memory memory, bool checkChecksum)

Flashes a given pipeline to the device.

Parameters

pipeline: Pipeline to flash to the board
compress: Compresses application to reduce needed memory size
applicationName: Optional name the application that is flashed

function

ApplicationInfo readApplicationInfo(Memory memory)

Reads information about flashed application in specified memory from device

Parameters

memory: Specifies which memory to query

function

std::tuple< bool, std::string > flashDepthaiApplicationPackage(std::function< void(float)> progressCallback, std::vector< uint8_t > package, Memory memory)

Flashes a specific depthai application package that was generated using createDepthaiApplicationPackage or saveDepthaiApplicationPackage

Parameters

progressCallback: Callback that sends back a value between 0..1 which signifies current flashing progress
package: Depthai application package to flash to the board

function

std::tuple< bool, std::string > flashDepthaiApplicationPackage(std::vector< uint8_t > package, Memory memory)

Flashes a specific depthai application package that was generated using createDepthaiApplicationPackage or saveDepthaiApplicationPackage

Parameters

package: Depthai application package to flash to the board

function

std::tuple< bool, std::string > flashClear(Memory memory)

Clears flashed application on the device, by removing SBR boot structure Doesn't remove fast boot header capability to still boot the application

function

std::tuple< bool, std::string > flashBootloader(std::function< void(float)> progressCallback, const fs::path & path)

Flashes bootloader to the current board

Parameters

progressCallback: Callback that sends back a value between 0..1 which signifies current flashing progress
path: Optional parameter to custom bootloader to flash

function

std::tuple< bool, std::string > flashBootloader(Memory memory, Type type, std::function< void(float)> progressCallback, const fs::path & path)

Flash selected bootloader to the current board

Parameters

memory: Memory to flash
type: Bootloader type to flash
progressCallback: Callback that sends back a value between 0..1 which signifies current flashing progress
path: Optional parameter to custom bootloader to flash

function

std::tuple< bool, std::string > flashUserBootloader(std::function< void(float)> progressCallback, const fs::path & path)

Flashes user bootloader to the current board. Available for NETWORK bootloader type

Parameters

progressCallback: Callback that sends back a value between 0..1 which signifies current flashing progress
path: Optional parameter to custom bootloader to flash

function

std::tuple< bool, std::string > flashGpioModeBootHeader(Memory memory, int gpioMode)

Flash boot header which boots same as equivalent GPIO mode would

Parameters

gpioMode: GPIO mode equivalent

function

std::tuple< bool, std::string > flashUsbRecoveryBootHeader(Memory memory)

Flash USB recovery boot header. Switches to USB ROM Bootloader

Parameters

memory: Which memory to flash the header to

function

std::tuple< bool, std::string > flashBootHeader(Memory memory, int32_t frequency, int64_t location, int32_t dummyCycles, int64_t offset)

Flash optimized boot header

Parameters

memory: Which memory to flasht the header to
frequency: SPI specific parameter, frequency in MHz
location: Target location the header should boot to. Default to location of bootloader
dummyCycles: SPI specific parameter
offset: Offset in memory to flash the header to. Defaults to offset of boot header

Returns

status as std::tuple<bool, std::string>

function

std::tuple< bool, std::string > flashFastBootHeader(Memory memory, int32_t frequency, int64_t location, int32_t dummyCycles, int64_t offset)

Flash fast boot header. Application must already be present in flash, or location must be specified manually. Note - Can soft brick your device if firmware location changes.

Parameters

memory: Which memory to flash the header to
frequency: SPI specific parameter, frequency in MHz
location: Target location the header should boot to. Default to location of bootloader
dummyCycles: SPI specific parameter
offset: Offset in memory to flash the header to. Defaults to offset of boot header

Returns

status as std::tuple<bool, std::string>

function

std::tuple< bool, std::string > flashCustom(Memory memory, size_t offset, const std::vector< uint8_t > & data, std::function< void(float)> progressCb)

Flash arbitrary data at custom offset in specified memory

Parameters

memory: Memory to flash
offset: Offset at which to flash the given data in bytes
progressCallback: Callback that sends back a value between 0..1 which signifies current flashing progress
data: Data to flash

function

std::tuple< bool, std::string > flashCustom(Memory memory, size_t offset, const uint8_t * data, size_t size, std::function< void(float)> progressCb)

function

std::tuple< bool, std::string > flashCustom(Memory memory, size_t offset, std::string filename, std::function< void(float)> progressCb)

function

std::tuple< bool, std::string > readCustom(Memory memory, size_t offset, size_t size, std::vector< uint8_t > & data, std::function< void(float)> progressCb)

Reads arbitrary data at custom offset in specified memory

Parameters

memory: Memory to read
offset: Offset at which to read the specified bytes
size: Number of bytes to read
data: Data to read to. Must be at least 'size' number of bytes big
progressCallback: Callback that sends back a value between 0..1 which signifies current reading progress

function

std::tuple< bool, std::string > readCustom(Memory memory, size_t offset, size_t size, uint8_t * data, std::function< void(float)> progressCb)

function

std::tuple< bool, std::string > readCustom(Memory memory, size_t offset, size_t size, std::string filename, std::function< void(float)> progressCb)

function

std::tuple< bool, std::string, std::vector< uint8_t > > readCustom(Memory memory, size_t offset, size_t size, std::function< void(float)> progressCb)

function

nlohmann::json readConfigData(Memory memory, Type type)

Reads configuration data from bootloader

Returns

Unstructured configuration data

Parameters

memory: Optional - from which memory to read configuration data
type: Optional - from which type of bootloader to read configuration data

function

std::tuple< bool, std::string > flashConfigData(nlohmann::json configData, Memory memory, Type type)

Flashes configuration data to bootloader

Parameters

configData: Unstructured configuration data
memory: Optional - to which memory flash configuration
type: Optional - for which type of bootloader to flash configuration

function

std::tuple< bool, std::string > flashConfigFile(const fs::path & configPath, Memory memory, Type type)

Flashes configuration data to bootloader

Parameters

configPath: Unstructured configuration data
memory: Optional - to which memory flash configuration
type: Optional - for which type of bootloader to flash configuration

function

std::tuple< bool, std::string > flashConfigClear(Memory memory, Type type)

Clears configuration data

Parameters

memory: Optional - on which memory to clear configuration data
type: Optional - for which type of bootloader to clear configuration data

function

Config readConfig(Memory memory, Type type)

Reads configuration from bootloader

Parameters

memory: Optional - from which memory to read configuration
type: Optional - from which type of bootloader to read configuration

Returns

Configuration structure

function

std::tuple< bool, std::string > flashConfig(const Config & config, Memory memory, Type type)

Flashes configuration to bootloader

Parameters

configData: Configuration structure
memory: Optional - to which memory flash configuration
type: Optional - for which type of bootloader to flash configuration

function

MemoryInfo getMemoryInfo(Memory memory)

Retrieves information about specified memory

Parameters

memory: Specifies which memory to query

function

bool isUserBootloaderSupported()

Checks whether User Bootloader is supported with current bootloader

Returns

true of User Bootloader is supported, false otherwise

function

bool isUserBootloader()

Retrieves whether current bootloader is User Bootloader (B out of A/B configuration)

function

void bootMemory(const std::vector< uint8_t > & fw)

Boots a custom FW in memory

Parameters

A: runtime exception if there are any communication issues

function

void bootUsbRomBootloader()

Boots into integrated ROM bootloader in USB mode

Parameters

A: runtime exception if there are any communication issues

function

Version getVersion()

Returns

Version of current running bootloader

function

bool isEmbeddedVersion()

Returns

True when bootloader was booted using latest bootloader integrated in the library. False when bootloader is already running on the device and just connected to.

function

Type getType()

Returns

Type of currently connected bootloader

function

bool isAllowedFlashingBootloader()

Returns

True if allowed to flash bootloader

function

void close()

Explicitly closes connection to device.

Parameters

This function does not need to be explicitly called as destructor closes the device automatically

function

bool isClosed()

Is the device already closed (or disconnected)

Parameters

struct

dai::DeviceBootloader::ApplicationInfo

variable

Memory memory

variable

bool hasApplication

variable

std::string firmwareVersion

variable

std::string applicationName

struct

dai::DeviceBootloader::Config

function

void setStaticIPv4(std::string ip, std::string mask, std::string gateway)

function

void setDynamicIPv4(std::string ip, std::string mask, std::string gateway)

function

bool isStaticIPV4()

function

std::string getIPv4()

function

std::string getIPv4Mask()

function

std::string getIPv4Gateway()

function

void setDnsIPv4(std::string dns, std::string dnsAlt)

function

std::string getDnsIPv4()

function

std::string getDnsAltIPv4()

function

void setUsbTimeout(std::chrono::milliseconds ms)

function

std::chrono::milliseconds getUsbTimeout()

function

void setNetworkTimeout(std::chrono::milliseconds ms)

function

std::chrono::milliseconds getNetworkTimeout()

function

void setMacAddress(std::string mac)

function

std::string getMacAddress()

function

void setUsbMaxSpeed(UsbSpeed speed)

function

UsbSpeed getUsbMaxSpeed()

function

nlohmann::json toJson()

struct

dai::DeviceBootloader::MemoryInfo

variable

bool available

variable

std::int64_t size

variable

std::string info

enum

dai::bootloader::Type Type

enum

dai::bootloader::Memory Memory

enum

dai::bootloader::Section Section

enum

dai::bootloader::UsbConfig UsbConfig

enum

dai::bootloader::NetworkConfig NetworkConfig

enum

dai::Version Version

class

dai::DeviceGate

#include DeviceGate.hpp

function

DeviceGate(const DeviceInfo & deviceInfo)

Connects to DepthAI Gate

Parameters

deviceInfo: Device to connect to

function

~DeviceGate()

function

bool isOkay()

function

bool createSession(bool exclusive)

function

bool startSession()

function

bool stopSession()

function

bool deleteSession()

function

bool destroySession()

function

SessionState getState()

function

std::optional< CrashDump > waitForSessionEnd()

function

std::optional< CrashDump > getCrashDump()

function

Version getVersion()

function

VersionInfo getAllVersion()

function

bool isBootedNonExclusive()

struct

dai::DeviceGate::CrashDump

variable

std::vector< uint8_t > data

variable

std::string filename

struct

dai::DeviceGate::VersionInfo

variable

std::string gate

variable

std::string os

enum

SessionState

enumerator

NOT_CREATED

enumerator

CREATED

enumerator

RUNNING

enumerator

STOPPED

enumerator

STOPPING

enumerator

CRASHED

enumerator

DESTROYED

enumerator

ERROR_STATE

struct

dai::EepromError

struct

dai::Version

#include Version.hpp

explicit function

Version(const std::string & v)

function

 Version(unsigned major, unsigned minor, unsigned patch, const PreReleaseType & type, const std::optional< uint16_t > & preReleaseVersion, const std::string & buildInfo)

inline function

Version(unsigned major, unsigned minor, unsigned patch, const std::string & buildInfo)

function

bool operator==(const Version & other)

function

bool operator<(const Version & other)

inline function

bool operator!=(const Version & rhs)

inline function

bool operator>(const Version & rhs)

inline function

bool operator<=(const Version & rhs)

inline function

bool operator>=(const Version & rhs)

function

std::string toString()

function

std::string toStringSemver()

function

std::string getBuildInfo()

enum

uint16_t PreReleaseType

enumerator

ALPHA

enumerator

BETA

enumerator

NONE

struct

dai::LogMessage

variable

std::string nodeIdName

variable

LogLevel level

variable

Timestamp time

variable

size_t colorRangeStart

variable

size_t colorRangeEnd

variable

std::string payload

struct

dai::SlugComponents

variable

std::string teamName

variable

std::string modelSlug

variable

std::string modelVariantSlug

variable

std::string modelRef

function

std::string merge()

struct

dai::NNModelDescription

variable

std::string model

Model slug = REQUIRED parameter

variable

std::string platform

Hardware platform - RVC2, RVC3, RVC4, ... = REQUIRED parameter

variable

std::string optimizationLevel

Optimization level = OPTIONAL parameter

variable

std::string compressionLevel

Compression level = OPTIONAL parameter

variable

std::string snpeVersion

SNPE version = OPTIONAL parameter

variable

std::string modelPrecisionType

modelPrecisionType = OPTIONAL parameter

variable

std::string globalMetadataEntryName

Name of the entry in the global metadata file

function

void saveToYamlFile(const fs::path & yamlPath)

function

bool check()

function

std::string toString()

struct

dai::NNArchiveOptions

function

DEPTAHI_ARG_DEFAULT(NNArchiveEntry::Compression, compression, NNArchiveEntry::Compression::AUTO)

class

dai::NNArchive

function

NNArchive(const std::filesystem::path & archivePath, NNArchiveOptions options)

function

std::optional< OpenVINO::Blob > getBlob()

function

std::optional< OpenVINO::SuperBlob > getSuperBlob()

function

std::optional< std::vector< uint8_t > > getOtherModelFormat()

function

const NNArchiveVersionedConfig & getVersionedConfig()

function

std::optional< std::pair< uint32_t, uint32_t > > getInputSize(uint32_t index)

function

std::optional< uint32_t > getInputWidth(uint32_t index)

function

std::optional< uint32_t > getInputHeight(uint32_t index)

function

std::vector< dai::Platform > getSupportedPlatforms()

inline function

const T & getConfig()

function

dai::nn_archive::v1::Head getHeadConfig(uint32_t index)

function

model::ModelType getModelType()

class

dai::NNArchiveEntry

enum

uint8_t Compression

enumerator

AUTO

Try to guess the file format from the file extension. .json -> RAW_FS everything else use libarchive to guess the format supported formats are:

enumerator

RAW_FS

The entry isn't compressed. Access it directly on the filesystem.

enumerator

TAR

Force libarchive to treat the file as .tar

enumerator

TAR_GZ

Force libarchive to treat the file as .tar.gz

enumerator

TAR_XZ

Force libarchive to treat the file as .tar.xz

enum

uint8_t Seek

Check stdio.h SEEK_SET, SEEK_CUR, SEEK_END for meaning.

enumerator

SET

enumerator

CUR

enumerator

END

class

dai::NNArchiveVersionedConfig

explicit function

NNArchiveVersionedConfig(const std::vector< uint8_t > & data, NNArchiveEntry::Compression compression)

@data Should point to a whole compressed NNArchive read to memory if compression is not set to RAW_FS. If compression is set to RAW_FS, then this should point to just the config.json file read to memory.

explicit function

NNArchiveVersionedConfig(const std::filesystem::path & path, NNArchiveEntry::Compression compression)

@path Should point to: 1) if compression is set to RAW_FS: to just the config.json file. 2) if compression is set to AUTO: to whole compressed NNArchive or just the config.json file which must end in .json . 3) else: to whole compressed NNArchive. see NNArchive class for parameter explanation

function

 NNArchiveVersionedConfig(const std::function< int()> & openCallback, const std::function< std::shared_ptr< std::vector< uint8_t >>()> & readCallback, const std::function< int64_t(int64_t offset, NNArchiveEntry::Seek whence)> & seekCallback, const std::function< int64_t(int64_t request)> & skipCallback, const std::function< int()> & closeCallback, NNArchiveEntry::Compression compression)

Returned data should be just the config.json if compression == RAW_FS or the whole NNArchive otherwise see NNArchive class for parameter explanation

inline function

NNArchiveVersionedConfig(const NNArchiveConfig & config)

inline function

NNArchiveConfigVersion getVersion()

inline function

const T & getConfig()

inline function

const NNArchiveConfig & getConfig()

class

dai::OpenVINO

#include OpenVINO.hpp

struct

dai::OpenVINO::Blob

#include OpenVINO.hpp

variable

Version version

variable

Device device

variable

std::unordered_map< std::string, TensorInfo > networkInputs

variable

std::unordered_map< std::string, TensorInfo > networkOutputs

variable

uint32_t stageCount

variable

uint32_t numShaves

variable

uint32_t numSlices

variable

std::vector< uint8_t > data

function

Blob(std::vector< uint8_t > data)

function

Blob(const std::filesystem::path & path)

class

dai::OpenVINO::SuperBlob

#include OpenVINO.hpp

function

SuperBlob(std::vector< uint8_t > data)

function

SuperBlob(const std::filesystem::path & pathToSuperBlobFile)

function

dai::OpenVINO::Blob getBlobWithNumShaves(int numShaves)

enum

Version

enumerator

VERSION_2020_3

enumerator

VERSION_2020_4

enumerator

VERSION_2021_1

enumerator

VERSION_2021_2

enumerator

VERSION_2021_3

enumerator

VERSION_2021_4

enumerator

VERSION_2022_1

enumerator

VERSION_UNIVERSAL

enum

Device

enumerator

VPU

enumerator

VPUX

struct

dai::Asset

#include AssetManager.hpp

variable

const std::string key

variable

std::vector< std::uint8_t > data

variable

std::uint32_t alignment

function

Asset()

inline explicit function

Asset(std::string k)

function

std::string getRelativeUri()

class

dai::AssetsMutable

function

void set(std::string, std::uint32_t offset, std::uint32_t size, std::uint32_t alignment)

class

dai::AssetManager

#include AssetManager.hpp

function

AssetManager()

function

AssetManager(std::string rootPath)

function

void addExisting(std::vector< std::shared_ptr< Asset >> assets)

Adds all assets in an array to the AssetManager

Parameters

assets: Vector of assets to add

function

std::string getRootPath()

Get root path of the asset manager

Returns

Root path

function

void setRootPath(const std::string & rootPath)

Set root path of the asset manager

Parameters

rootPath: Root path

function

std::shared_ptr< dai::Asset > set(Asset asset)

Adds or overwrites an asset object to AssetManager.

Parameters

asset: Asset to add

Returns

Shared pointer to asset

function

std::shared_ptr< dai::Asset > set(const std::string & key, Asset asset)

Adds or overwrites an asset object to AssetManager with a specified key. Key value will be assigned to an Asset as well

Parameters

key: Key under which the asset should be stored
asset: Asset to store

Returns

Shared pointer to asset

function

std::shared_ptr< dai::Asset > set(const std::string & key, const std::filesystem::path & path, int alignment)

Loads file into asset manager under specified key.

Parameters

key: Key under which the asset should be stored
path: Path to file which to load as asset
alignment: [Optional] alignment of asset data in asset storage. Default is 64B

function

std::shared_ptr< dai::Asset > set(const std::string & key, const std::vector< std::uint8_t > & data, int alignment)

Loads file into asset manager under specified key.

Parameters

key: Key under which the asset should be stored
data: Asset data
alignment: [Optional] alignment of asset data in asset storage. Default is 64B

Returns

Shared pointer to asset

function

std::shared_ptr< dai::Asset > set(const std::string & key, std::vector< std::uint8_t > && data, int alignment)

function

std::shared_ptr< const Asset > get(const std::string & key)

Returns

Asset assigned to the specified key or a nullptr otherwise

function

std::shared_ptr< Asset > get(const std::string & key)

Returns

Asset assigned to the specified key or a nullptr otherwise

function

std::vector< std::shared_ptr< const Asset > > getAll()

Returns

All asset stored in the AssetManager

function

std::vector< std::shared_ptr< Asset > > getAll()

Returns

All asset stored in the AssetManager

function

std::size_t size()

Returns

Number of asset stored in the AssetManager

function

void remove(const std::string & key)

Removes asset with key

Parameters

key: Key of asset to remove

function

void serialize(AssetsMutable & assets, std::vector< std::uint8_t > & assetStorage, std::string prefix)

struct

dai::AssetView

variable

std::uint8_t * data

variable

std::uint32_t size

variable

std::uint32_t alignment

inline function

AssetView(std::uint8_t * d, std::uint32_t s, std::uint32_t a)

class

dai::Assets

Derived by dai::AssetsMutable

inline function

void setStorage(std::uint8_t * ps)

inline function

bool has(const std::string & key)

inline function

AssetView get(const std::string & key)

inline function

std::vector< std::pair< std::string, AssetView > > getAll()

function

DEPTHAI_SERIALIZE(Assets, map)

class

dai::DeviceNode

variable

copyable_unique_ptr< Properties > propertiesHolder

function

DeviceNode()

function

~DeviceNode()

function

void run()

inline function

bool runOnHost()

function

const std::shared_ptr< Device > getDevice()

function

Properties & getProperties()

function

void setLogLevel(dai::LogLevel level)

function

dai::LogLevel getLogLevel()

class

dai::DeviceNodeCRTP

variable

Properties & properties

function

~DeviceNodeCRTP()

inline function

const char * getName()

enum

Props Properties

class

dai::HostRunnable

Derived by dai::node::AprilTag, dai::node::AutoCalibration, dai::node::BenchmarkIn, dai::node::BenchmarkOut, dai::node::DetectionParser, dai::node::DynamicCalibration, dai::node::ImageAlign, dai::node::ImageFilters, dai::node::ImageManip, dai::node::ObjectTracker, dai::node::Rectification, dai::node::SegmentationParser, dai::node::SpatialLocationCalculator, dai::node::Sync, dai::node::ToFDepthConfidenceFilter, dai::node::internal::PipelineEventAggregation

function

HostRunnable()

function

~HostRunnable()

class

dai::DeviceNodeGroup

Derived by dai::node::DetectionNetwork, dai::node::NeuralAssistedStereo, dai::node::SpatialDetectionNetwork, dai::node::ToF

inline function

const char * getName()

function

~DeviceNodeGroup()

inline function

DeviceNodeGroup(const std::shared_ptr< Device > & device)

function

void setLogLevel(dai::LogLevel level)

function

dai::LogLevel getLogLevel()

function

DeviceNode()

function

DeviceNode(const std::shared_ptr< Device > & device, std::unique_ptr< Properties > props, bool conf)

function

DeviceNode(std::unique_ptr< Properties > props, bool conf)

class

dai::InputQueue

function

void send(const std::shared_ptr< ADatatype > & msg)

class

dai::MessageQueue

#include MessageQueue.hppDerived by dai::Node::Input

variable

std::mutex callbacksMtx

variable

std::unordered_map< CallbackId, std::function< void(std::string, std::shared_ptr< ADatatype >)> > callbacks

variable

CallbackId uniqueCallbackId

explicit function

MessageQueue(unsigned int maxSize, bool blocking)

explicit function

 MessageQueue(std::string name, unsigned int maxSize, bool blocking, utility::PipelineEventDispatcherInterface * pipelineEventDispatcher)

inline function

MessageQueue(const MessageQueue & c)

inline function

MessageQueue(MessageQueue && m)

inline function

MessageQueue & operator=(const MessageQueue & c)

inline function

MessageQueue & operator=(MessageQueue && m)

function

~MessageQueue()

function

std::string getName()

function

void setName(std::string name)

Set the name of the queue

function

bool isClosed()

Check whether queue is closed

function

void close()

Closes the queue and unblocks any waiting consumers or producers

function

void setBlocking(bool blocking)

Sets queue behavior when full (maxSize)

Parameters

blocking: Specifies if block or overwrite the oldest message in the queue

function

bool getBlocking()

Gets current queue behavior when full (maxSize)

Returns

True if blocking, false otherwise

function

void setMaxSize(unsigned int maxSize)

Sets queue maximum size

Parameters

maxSize: Specifies maximum number of messages in the queue

Parameters

If maxSize is smaller than size, queue will not be truncated immediately, only after messages are popped

function

unsigned int getMaxSize()

Gets queue maximum size

Returns

Maximum queue size

function

unsigned int getSize()

Gets queue current size

Returns

Current queue size

function

unsigned int isFull()

Gets whether queue is full

Returns

True if queue is full, false otherwise

function

CallbackId addCallback(std::function< void(std::string, std::shared_ptr< ADatatype >)>)

Adds a callback on message received

Parameters

callback: Callback function with queue name and message pointer

Returns

Callback id

function

CallbackId addCallback(const std::function< void(std::shared_ptr< ADatatype >)> &)

Adds a callback on message received

Parameters

callback: Callback function with message pointer

Returns

Callback id

function

CallbackId addCallback(const std::function< void()> & callback)

Adds a callback on message received

Parameters

callback: Callback function without any parameters

Returns

Callback id

function

CallbackId addCondVar(std::shared_ptr< std::condition_variable > cv)

Adds a condition variable to be notified on message queue destruction

Parameters

cv: Condition variable to be notified

Returns

Condition variable id

function

bool removeCallback(CallbackId callbackId)

Removes a callback

Parameters

callbackId: Id of callback to be removed

Returns

True if callback was removed, false otherwise

function

bool removeCondVar(CallbackId condVarId)

Removes a condition variable

Parameters

condVarId: Id of condition variable to be removed

Returns

True if condition variable was removed, false otherwise

inline function

bool has()

Check whether front of the queue has message of type T

Returns

True if queue isn't empty and the first element is of type T, false otherwise

inline function

bool has()

Check whether front of the queue has a message (isn't empty)

Returns

True if queue isn't empty, false otherwise

inline function

std::shared_ptr< T > tryGet()

Try to retrieve message T from queue. If message isn't of type T it returns nullptr

Returns

Message of type T or nullptr if no message available

inline function

std::shared_ptr< ADatatype > tryGet()

Try to retrieve message from queue. If no message available, return immediately with nullptr

Returns

Message or nullptr if no message available

inline function

std::shared_ptr< T > get()

Block until a message is available.

Returns

Message of type T or nullptr if no message available

inline function

std::shared_ptr< ADatatype > get()

Block until a message is available.

Returns

Message or nullptr if no message available

inline function

std::shared_ptr< T > front()

Gets first message in the queue.

Returns

Message of type T or nullptr if no message available

inline function

std::shared_ptr< ADatatype > front()

Gets first message in the queue.

Returns

Message or nullptr if no message available

inline function

std::shared_ptr< T > get(std::chrono::duration< Rep, Period > timeout, bool & hasTimedout)

Block until a message is available with a timeout.

Parameters

timeout: Duration for which the function should block
hasTimedout: Outputs true if timeout occurred, false otherwise

Returns

Message of type T otherwise nullptr if message isn't type T or timeout occurred

inline function

std::shared_ptr< ADatatype > get(std::chrono::duration< Rep, Period > timeout, bool & hasTimedout)

Block until a message is available with a timeout.

Parameters

timeout: Duration for which the function should block
hasTimedout: Outputs true if timeout occurred, false otherwise

Returns

Message of type T otherwise nullptr if message isn't type T or timeout occurred

inline function

std::vector< std::shared_ptr< T > > tryGetAll()

Try to retrieve all messages in the queue.

Returns

Vector of messages which can either be of type T or nullptr

inline function

std::vector< std::shared_ptr< ADatatype > > tryGetAll()

Try to retrieve all messages in the queue.

Returns

Vector of messages

inline function

std::vector< std::shared_ptr< T > > getAll()

Block until at least one message in the queue. Then return all messages from the queue.

Returns

Vector of messages which can either be of type T or nullptr

inline function

std::vector< std::shared_ptr< ADatatype > > getAll()

Block until at least one message in the queue. Then return all messages from the queue.

Returns

Vector of messages

inline function

std::vector< std::shared_ptr< T > > getAll(std::chrono::duration< Rep, Period > timeout, bool & hasTimedout)

Block for maximum timeout duration. Then return all messages from the queue.

Parameters

timeout: Maximum duration to block
hasTimedout: Outputs true if timeout occurred, false otherwise

Returns

Vector of messages which can either be of type T or nullptr

inline function

std::vector< std::shared_ptr< ADatatype > > getAll(std::chrono::duration< Rep, Period > timeout, bool & hasTimedout)

Block for maximum timeout duration. Then return all messages from the queue.

Parameters

timeout: Maximum duration to block
hasTimedout: Outputs true if timeout occurred, false otherwise

Returns

Vector of messages

function

void send(const std::shared_ptr< ADatatype > & msg)

Adds a message to the queue, which will be picked up and sent to the device. Can either block if 'blocking' behavior is true or overwrite oldest

Parameters

msg: Message to add to the queue

function

bool send(const std::shared_ptr< ADatatype > & msg, std::chrono::milliseconds timeout)

Adds message to the queue, which will be picked up and sent to the device. Can either block until timeout if 'blocking' behavior is true or overwrite oldest

Parameters

msg: Message to add to the queue
timeout: Maximum duration to block in milliseconds

function

bool send(const ADatatype & msg, std::chrono::milliseconds timeout)

Adds message to the queue, which will be picked up and sent to the device. Can either block until timeout if 'blocking' behavior is true or overwrite oldest

Parameters

msg: Message to add to the queue
timeout: Maximum duration to block in milliseconds

function

bool trySend(const std::shared_ptr< ADatatype > & msg)

Tries sending a message

Parameters

msg: message to send

class

dai::MessageQueue::QueueException

inline explicit function

QueueException(const std::string & message)

function

~QueueException()

enum

int CallbackId

class

dai::Node

#include Node.hppDerived by dai::NodeGroup, dai::ThreadedNode

variable

Id id

variable

Id inputId

variable

Id outputId

variable

std::string alias

function

Node(const Node &)

function

Node & operator=(const Node &)

function

Node(Node &&)

function

Node & operator=(Node &&)

function

std::string createUniqueInputName()

function

std::string createUniqueOutputName()

function

Pipeline getParentPipeline()

function

const Pipeline getParentPipeline()

inline function

std::string getAlias()

inline function

void setAlias(std::string alias)

function

const char * getName()

inline function

void start()

inline function

void wait()

inline function

void stop()

function

void stopPipeline()

function

void buildStage1()

function

void buildStage2()

function

void buildStage3()

function

void postBuildStage()

function

std::vector< Output > getOutputs()

function

std::vector< Input > getInputs()

function

std::vector< Output * > getOutputRefs()

function

std::vector< const Output * > getOutputRefs()

function

std::vector< Input * > getInputRefs()

function

std::vector< const Input * > getInputRefs()

function

std::vector< OutputMap * > getOutputMapRefs()

function

std::vector< InputMap * > getInputMapRefs()

function

Output * getOutputRef(std::string name)

function

Output * getOutputRef(std::string group, std::string name)

function

Input * getInputRef(std::string name)

function

Input * getInputRef(std::string group, std::string name)

function

OutputMap * getOutputMapRef(std::string group)

function

InputMap * getInputMapRef(std::string group)

function

bool isSourceNode()

function

~Node()

function

const AssetManager & getAssetManager()

function

AssetManager & getAssetManager()

function

std::vector< uint8_t > loadResource(std::filesystem::path uri)

function

std::vector< uint8_t > moveResource(std::filesystem::path uri)

inline function

std::shared_ptr< N > create()

function

void add(std::shared_ptr< Node > node)

function

std::vector< std::shared_ptr< Node > > getAllNodes()

function

std::shared_ptr< const Node > getNode(Node::Id id)

function

std::shared_ptr< Node > getNode(Node::Id id)

function

void remove(std::shared_ptr< Node > node)

function

ConnectionMap getConnectionMap()

function

void link(const Node::Output & out, const Node::Input & in)

function

void unlink(const Node::Output & out, const Node::Input & in)

function

void link(std::shared_ptr< Node > in)

function

Node::Output * requestOutput(const Capability & capability, bool onHost)

function

std::vector< std::pair< Input &, std::shared_ptr< Capability > > > getRequiredInputs()

function

bool runOnHost()

inline function

const NodeMap & getNodeMap()

inline function

void buildInternal()

struct

dai::Node::Connection

#include Node.hpp

variable

Id outputId

variable

std::string outputName

variable

std::string outputGroup

variable

Id inputId

variable

std::string inputName

variable

std::string inputGroup

function

Connection(Output out, Input in)

function

Connection(ConnectionInternal c)

function

bool operator==(const Connection & rhs)

struct

dai::Node::ConnectionInternal

#include Node.hpp

variable

std::weak_ptr< Node > outputNode

variable

std::string outputName

variable

std::string outputGroup

variable

std::weak_ptr< Node > inputNode

variable

std::string inputName

variable

std::string inputGroup

variable

Output * out

variable

Input * in

function

ConnectionInternal(Output & out, Input & in)

function

bool operator==(const ConnectionInternal & rhs)

struct

dai::Node::ConnectionInternal::Hash

function

size_t operator()(const dai::Node::ConnectionInternal & obj)

struct

dai::Node::DatatypeHierarchy

variable

DatatypeEnum datatype

variable

bool descendants

inline function

DatatypeHierarchy(DatatypeEnum d, bool c)

class

dai::Node::Input

variable

std::vector< DatatypeHierarchy > possibleDatatypes

function

~Input()

inline explicit function

Input(Node & par, InputDescription desc, bool ref)

inline function

const Node & getParent()

Get the parent node

inline function

Node & getParent()

Get the parent node

inline function

Type getType()

Get type

function

std::string toString()

Input to string representation

function

void setWaitForMessage(bool waitForMessage)

Overrides default wait for message behavior. Applicable for nodes with multiple inputs. Specifies behavior whether to wait for this input when a Node processes certain data or not.

Parameters

waitForMessage: Whether to wait for message to arrive to this input or not

function

bool getWaitForMessage()

Get behavior whether to wait for this input when a Node processes certain data or not

Returns

Whether to wait for message to arrive to this input or not

function

std::vector< DatatypeHierarchy > getPossibleDatatypes()

Get possible datatypes that can be received

function

void setPossibleDatatypes(std::vector< DatatypeHierarchy > types)

Set possible datatypes that can be received

function

void setReusePreviousMessage(bool reusePreviousMessage)

Equivalent to setWaitForMessage but with inverted logic.

function

bool getReusePreviousMessage()

Equivalent to getWaitForMessage but with inverted logic.

function

void setGroup(std::string group)

Set group name for this input

function

std::string getGroup()

Get group name for this input

function

bool isConnected()

Check if this input is connected

function

std::shared_ptr< InputQueue > createInputQueue(unsigned int maxSize, bool blocking)

function

std::shared_ptr< dai::node::internal::XLinkInBridge > getXLinkBridge()

enum

Type

enumerator

SReceiver

enumerator

MReceiver

struct

dai::Node::InputDescription

variable

std::string name

variable

std::string group

variable

bool blocking

variable

int queueSize

variable

std::vector< DatatypeHierarchy > types DEFAULT_TYPES

variable

bool waitForMessage

class

dai::Node::InputMap

#include Node.hpp

variable

std::string name

function

InputMap(Node & parent, InputDescription defaultInput)

function

InputMap(Node & parent, std::string name, InputDescription defaultInput)

function

Input & operator[](const std::string & key)

function

Input & operator[](std::pair< std::string, std::string > groupKey)

function

bool has(const std::string & key)

class

dai::Node::Output

function

~Output()

inline function

Output(Node & par, OutputDescription desc, bool ref)

inline function

Node & getParent()

inline function

const Node & getParent()

function

std::string toString()

inline function

std::string getName()

Get name of the output

inline function

std::string getGroup()

Get group of the output

inline function

void setGroup(std::string group)

Set group name for this output

inline function

void setName(std::string name)

Set name for this output

inline function

Type getType()

Get type of the output

function

std::vector< DatatypeHierarchy > getPossibleDatatypes()

Get possible datatypes that can be sent

function

void setPossibleDatatypes(std::vector< DatatypeHierarchy > types)

Set possible datatypes that can be sent

function

bool isSamePipeline(const Input & in)

Check if this output and given input are on the same pipeline.

Parameters

canConnect for checking if connection is possible

Returns

True if output and input are on the same pipeline

function

bool canConnect(const Input & in)

Check if connection is possible

Parameters

in: Input to connect to

Returns

True if connection is possible, false otherwise

function

std::vector< ConnectionInternal > getConnections()

Retrieve all connections from this output

Returns

Vector of connections

inline function

std::vector< QueueConnection > getQueueConnections()

Retrieve all queue connections from this output

Returns

Vector of queue connections

function

std::shared_ptr< dai::MessageQueue > createOutputQueue(unsigned int maxSize, bool blocking)

function

void link(Input & in)

Link current output to input.Throws an error if this output cannot be linked to given input, or if they are already linked

Parameters

in: Input to link to

function

void link(std::shared_ptr< Node > in)

function

void unlink(Input & in)

Unlink a previously linked connectionThrows an error if not linked.

Parameters

in: Input from which to unlink from

function

void send(const std::shared_ptr< ADatatype > & msg)

Sends a Message to all connected inputs

Parameters

msg: Message to send to all connected inputs

function

bool trySend(const std::shared_ptr< ADatatype > & msg)

Try sending a message to all connected inputs

Parameters

msg: Message to send to all connected inputs

Returns

True if ALL connected inputs got the message, false otherwise

function

std::shared_ptr< dai::node::internal::XLinkOutBridge > getXLinkBridge()

struct

dai::Node::Output::QueueConnection

variable

Output * output

variable

std::shared_ptr< MessageQueue > queue

inline function

bool operator==(const QueueConnection & rhs)

enum

Type

enumerator

MSender

enumerator

SSender

struct

dai::Node::OutputDescription

variable

std::string name

variable

std::string group

variable

std::vector< DatatypeHierarchy > types DEFAULT_TYPES

class

dai::Node::OutputMap

#include Node.hpp

variable

std::string name

function

OutputMap(Node & parent, std::string name, OutputDescription defaultOutput, bool ref)

function

OutputMap(Node & parent, OutputDescription defaultOutput, bool ref)

function

Output & operator[](const std::string & key)

function

Output & operator[](std::pair< std::string, std::string > groupKey)

struct

dai::Node::PairHash

inline function

std::size_t operator()(const std::pair< T1, T2 > & pair)

enum

std::int64_t Id

class

dai::SourceNode

Derived by dai::node::Camera, dai::node::ColorCamera, dai::node::IMU, dai::node::MonoCamera

function

~SourceNode()

function

NodeRecordParams getNodeRecordParams()

function

Node::Output & getRecordOutput()

function

Node::Input & getReplayInput()

class

dai::NodeCRTP

Derived by dai::node::PipelineStateMerge

variable

friend Derived

variable

friend Base

function

~NodeCRTP()

inline function

const char * getName()

struct

dai::NodeConnectionSchema

#include NodeConnectionSchema.hpp

variable

int64_t node1Id

variable

std::string node1OutputGroup

variable

std::string node1Output

variable

int64_t node2Id

variable

std::string node2InputGroup

variable

std::string node2Input

inline function

bool operator==(const NodeConnectionSchema & rhs)

class

dai::NodeGroup

function

NodeGroup()

function

~NodeGroup()

inline function

const char * getName()

struct

dai::NodeIoInfo

#include NodeIoInfo.hpp

variable

std::string group

variable

std::string name

variable

Type type

variable

bool blocking

variable

int queueSize

variable

bool waitForMessage

variable

uint32_t id

enum

Type

enumerator

MSender

enumerator

SSender

enumerator

MReceiver

enumerator

SReceiver

struct

dai::NodeObjInfo

#include NodeObjInfo.hpp

variable

int64_t id

variable

int64_t parentId

variable

std::string name

variable

std::string alias

variable

std::string deviceId

variable

bool deviceNode

variable

std::vector< std::uint8_t > properties

variable

LogLevel logLevel

variable

std::unordered_map< std::tuple< std::string, std::string >, NodeIoInfo, IoInfoKey > ioInfo

struct

dai::NodeObjInfo::IoInfoKey

inline function

std::size_t operator()(const std::tuple< std::string, std::string > & k)

class

dai::PipelineImpl

inline function

PipelineImpl(bool createImplicitDevice)

inline function

PipelineImpl(std::shared_ptr< Device > device)

function

PipelineImpl(const PipelineImpl &)

function

PipelineImpl & operator=(const PipelineImpl &)

function

PipelineImpl(PipelineImpl &&)

function

PipelineImpl & operator=(PipelineImpl &&)

function

~PipelineImpl()

class

dai::Pipeline

#include Pipeline.hpp

inline function

PipelineImpl * impl()

inline function

const PipelineImpl * impl()

inline function

std::vector< std::shared_ptr< Node > > getSourceNodes()

explicit function

Pipeline(bool createImplicitDevice)

Creates a pipeline

Parameters

createImplicitDevice: If true, creates a default device (default = true)

explicit function

Pipeline(std::shared_ptr< Device > device)

Creates a pipeline with specified device

explicit function

Pipeline(std::shared_ptr< PipelineImpl > pimpl)

Creates a pipeline with specified device

inline function

GlobalProperties getGlobalProperties()

Returns

Global properties of current pipeline

inline function

void setGlobalProperties(GlobalProperties globalProperties)

Sets global properties of pipeline

function

PipelineSchema getPipelineSchema(SerializationType type, bool includePipelineDebugging)

Returns

Pipeline schema

function

PipelineSchema getDevicePipelineSchema(SerializationType type, bool includePipelineDebugging)

Returns

Device pipeline schema (without host only nodes and connections)

inline function

void serialize(PipelineSchema & schema, Assets & assets, std::vector< std::uint8_t > & assetStorage)

inline function

nlohmann::json serializeToJson(bool includeAssests)

inline function

std::shared_ptr< N > create(Args &&... args)

Creates and adds a node to the pipeline.Node is specified by template argument N

inline function

void add(std::shared_ptr< Node > node)

Adds an existing node to the pipeline

inline function

void remove(std::shared_ptr< Node > node)

inline function

std::vector< std::shared_ptr< Node > > getAllNodes()

inline function

std::shared_ptr< const Node > getNode(Node::Id id)

inline function

std::shared_ptr< Node > getNode(Node::Id id)

inline function

std::vector< Node::Connection > getConnections()

inline function

NodeConnectionMap getConnectionMap()

inline function

const AssetManager & getAssetManager()

inline function

AssetManager & getAssetManager()

inline function

void setOpenVINOVersion(OpenVINO::Version version)

inline function

void setCalibrationData(CalibrationHandler calibrationDataHandler)

Sets the calibration in pipeline which overrides the calibration data in eeprom

Parameters

calibrationDataHandler: CalibrationHandler object which is loaded with calibration information.

inline function

CalibrationHandler getCalibrationData()

gets the calibration data which is set through pipeline

Returns

the calibrationHandler with calib data in the pipeline

inline function

bool isCalibrationDataAvailable()

check if calib data has been set or the default will be returned

Returns

true - calib data has been set

Returns

false - calib data has not been set - default will be returned

inline function

std::optional< EepromData > getEepromData()

gets the eeprom data from the pipeline

Returns

eepromData from the the pipeline

inline function

void setEepromData(std::optional< EepromData > eepromData)

Sets the eeprom data in pipeline

Parameters

eepromData: EepromData object that is loaded in the pipeline.

inline function

uint32_t getEepromId()

Gets the eeprom id from the pipeline

Returns

eeprom id from the pipeline

inline function

void setCameraTuningBlobPath(const fs::path & path)

inline function

void setCameraTuningBlobPath(CameraBoardSocket socket, const fs::path & path)

inline function

void setXLinkChunkSize(int sizeBytes)

Set chunk size for splitting device-sent XLink packets, in bytes. A larger value could increase performance, with 0 disabling chunking. A negative value won't modify the device defaults - configured per protocol, currently 64*1024 for both USB and Ethernet.

inline function

void setSippBufferSize(int sizeBytes)

SIPP (Signal Image Processing Pipeline) internal memory pool. SIPP is a framework used to schedule HW filters, e.g. ISP, Warp, Median filter etc. Changing the size of this pool is meant for advanced use cases, pushing the limits of the HW. By default memory is allocated in high speed CMX memory. Setting to 0 will allocate in DDR 256 kilobytes. Units are bytes.

inline function

void setSippDmaBufferSize(int sizeBytes)

SIPP (Signal Image Processing Pipeline) internal DMA memory pool. SIPP is a framework used to schedule HW filters, e.g. ISP, Warp, Median filter etc. Changing the size of this pool is meant for advanced use cases, pushing the limits of the HW. Memory is allocated in high speed CMX memory Units are bytes.

inline function

void setBoardConfig(BoardConfig board)

inline function

BoardConfig getBoardConfig()

inline function

Device::Config getDeviceConfig()

inline function

bool isRunning()

inline function

bool isBuilt()

inline function

void build()

inline function

void buildDevice()

inline function

void start()

inline function

void wait()

inline function

void stop()

inline function

void processTasks(bool waitForTasks, double timeoutSeconds)

inline function

void run()

inline function

std::shared_ptr< Device > getDefaultDevice()

inline function

void addTask(std::function< void()> task)

function

void enableHolisticRecord(const RecordConfig & config)

function

void enableHolisticReplay(const std::string & pathToRecording)

function

void enablePipelineDebugging(bool enable)

function

bool isPipelineDebuggingEnabled()

function

std::shared_ptr< MessageQueue > getPipelineStateOut()

function

std::shared_ptr< InputQueue > getPipelineStateRequest()

function

PipelineStateApi getPipelineState()

enum

PipelineImpl::NodeConnectionMap NodeConnectionMap

struct

dai::PipelineSchema

#include PipelineSchema.hpp

variable

std::vector< NodeConnectionSchema > connections

variable

GlobalProperties globalProperties

variable

std::unordered_map< int64_t, NodeObjInfo > nodes

variable

std::vector< std::pair< int64_t, int64_t > > bridges

class

dai::NodesStateApi

#include PipelineStateApi.hpp

inline explicit function

 NodesStateApi(std::vector< Node::Id > nodeIds, std::shared_ptr< MessageQueue > pipelineStateOut, std::shared_ptr< InputQueue > pipelineStateRequest)

function

PipelineState summary()

function

PipelineState detailed()

function

std::unordered_map< Node::Id, std::unordered_map< std::string, NodeState::OutputQueueState > > outputs()

function

std::unordered_map< Node::Id, std::unordered_map< std::string, NodeState::InputQueueState > > inputs()

function

std::unordered_map< Node::Id, std::unordered_map< std::string, NodeState::Timing > > otherTimings()

class

dai::NodeStateApi

inline explicit function

 NodeStateApi(Node::Id nodeId, std::shared_ptr< MessageQueue > pipelineStateOut, std::shared_ptr< InputQueue > pipelineStateRequest)

inline function

NodeState summary()

inline function

NodeState detailed()

inline function

std::unordered_map< std::string, NodeState::OutputQueueState > outputs()

inline function

std::unordered_map< std::string, NodeState::InputQueueState > inputs()

inline function

std::unordered_map< std::string, NodeState::Timing > otherTimings()

function

std::unordered_map< std::string, NodeState::OutputQueueState > outputs(const std::vector< std::string > & outputNames)

function

NodeState::OutputQueueState outputs(const std::string & outputName)

function

std::vector< NodeState::DurationEvent > events()

function

std::unordered_map< std::string, NodeState::InputQueueState > inputs(const std::vector< std::string > & inputNames)

function

NodeState::InputQueueState inputs(const std::string & inputName)

function

std::unordered_map< std::string, NodeState::Timing > otherTimings(const std::vector< std::string > & timingNames)

function

NodeState::Timing otherTimings(const std::string & timingName)

class

dai::PipelineStateApi

inline function

 PipelineStateApi(std::shared_ptr< MessageQueue > pipelineStateOut, std::shared_ptr< InputQueue > pipelineStateRequest, const std::vector< std::shared_ptr< Node >> & allNodes)

inline function

NodesStateApi nodes()

inline function

NodesStateApi nodes(const std::vector< Node::Id > & nodeIds)

inline function

NodeStateApi nodes(Node::Id nodeId)

function

void stateAsync(std::function< void(const PipelineState &)> callback, std::optional< PipelineEventAggregationConfig > config)

class

dai::Subnode

inline function

Subnode(Node & parent, std::string alias)

inline function

T & operator*()

inline function

T * operator->()

class

dai::ThreadedNode

Derived by dai::DeviceNode, dai::node::ThreadedHostNode

variable

Output pipelineEventOutput

variable

spimpl::impl_ptr< Impl > pimpl

function

ThreadedNode()

function

~ThreadedNode()

inline function

void onStart()

inline function

void onStop()

function

void start()

function

void wait()

function

void stop()

function

void run()

function

bool isRunning()

function

bool mainLoop()

function

void setLogLevel(dai::LogLevel level)

function

dai::LogLevel getLogLevel()

function

utility::PipelineEventDispatcherInterface::BlockPipelineEvent inputBlockEvent(bool startNow)

function

utility::PipelineEventDispatcherInterface::BlockPipelineEvent outputBlockEvent(bool startNow)

function

utility::PipelineEventDispatcherInterface::BlockPipelineEvent blockEvent(PipelineEvent::Type type, const std::string & source, bool startNow)

function

Node(const Node &)

function

Node(Node &&)

function

Node()

function

Node(bool conf)

struct

dai::TraceEvent

variable

Event event

variable

Status status

variable

uint32_t srcId

variable

uint32_t dstId

variable

Timestamp timestamp

enum

std::uint8_t Event

enumerator

SEND

enumerator

RECEIVE

enum

std::uint8_t Status

enumerator

START

enumerator

END

enumerator

TIMEOUT

class

dai::ADatatype

#include ADatatype.hppDerived by dai::Buffer

variable

std::shared_ptr< Memory > data

inline explicit function

ADatatype()

function

~ADatatype()

function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

inline function

DatatypeEnum getDatatype()

class

dai::AprilTagConfig

#include AprilTagConfig.hpp

variable

Family family

AprilTag family.

variable

std::int32_t quadDecimate

Detection of quads can be done on a lower-resolution image, improving speed at a cost of pose accuracy and a slight decrease in detection rate. Decoding the binary payload is still done at full resolution.

variable

float quadSigma

What Gaussian blur should be applied to the segmented image. Parameter is the standard deviation in pixels. Very noisy images benefit from non-zero values (e.g. 0.8).

variable

bool refineEdges

When non-zero, the edges of the each quad are adjusted to "snap to" strong gradients nearby. This is useful when decimation is employed, as it can increase the quality of the initial quad estimate substantially. Generally recommended to be on. Very computationally inexpensive. Option is ignored if quadDecimate = 1.

variable

float decodeSharpening

How much sharpening should be done to decoded images? This can help decode small tags but may or may not help in odd lighting conditions or low light conditions. The default value is 0.25.

variable

std::int32_t maxHammingDistance

Max number of error bits that should be corrected. Accepting large numbers of corrected errors leads to greatly increased false positive rates. As of this implementation, the detector cannot detect tags with a hamming distance greater than 2.

variable

QuadThresholds quadThresholds

AprilTag quad threshold parameters.

function

AprilTagConfig()

function

~AprilTagConfig()

function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

inline function

DatatypeEnum getDatatype()

function

AprilTagConfig & setFamily(Family family)

Parameters

family: AprilTag family

function

 DEPTHAI_SERIALIZE(AprilTagConfig, Buffer::sequenceNum, Buffer::ts, Buffer::tsDevice, family, quadDecimate, quadSigma, refineEdges, decodeSharpening, maxHammingDistance, quadThresholds)

struct

dai::AprilTagConfig::QuadThresholds

#include AprilTagConfig.hpp

variable

std::int32_t minClusterPixels

Reject quads containing too few pixels.

variable

std::int32_t maxNmaxima

How many corner candidates to consider when segmenting a group of pixels into a quad.

variable

float criticalDegree

Reject quads where pairs of edges have angles that are close to straight or close to 180 degrees. Zero means that no quads are rejected. (In degrees).

variable

float maxLineFitMse

When fitting lines to the contours, what is the maximum mean squared error allowed? This is useful in rejecting contours that are far from being quad shaped; rejecting these quads "early" saves expensive decoding processing.

variable

std::int32_t minWhiteBlackDiff

When we build our model of black & white pixels, we add an extra check that the white model must be (overall) brighter than the black model. How much brighter? (in pixel values: [0,255]).

variable

bool deglitch

Should the thresholded image be deglitched? Only useful for very noisy images

function

 DEPTHAI_SERIALIZE(QuadThresholds, minClusterPixels, maxNmaxima, criticalDegree, maxLineFitMse, minWhiteBlackDiff, deglitch)

enum

std::int32_t Family

Supported AprilTag families.

enumerator

TAG_36H11

enumerator

TAG_36H10

enumerator

TAG_25H9

enumerator

TAG_16H5

enumerator

TAG_CIR21H7

enumerator

TAG_STAND41H12

struct

dai::AprilTag

#include AprilTags.hpp

variable

int id

The decoded ID of the tag

variable

int hamming

How many error bits were corrected? Note: accepting large numbers of corrected errors leads to greatly increased false positive rates. As of this implementation, the detector cannot detect tags with a hamming distance greater than 2.

variable

float decisionMargin

A measure of the quality of the binary decoding process; the average difference between the intensity of a data bit versus the decision threshold. Higher numbers roughly indicate better decodes. This is a reasonable measure of detection accuracy only for very small tags

variable

Point2f topLeft

The detected top left coordinates.

variable

Point2f topRight

The detected top right coordinates.

variable

Point2f bottomRight

The detected bottom right coordinates.

variable

Point2f bottomLeft

The detected bottom left coordinates.

class

dai::AprilTags

#include AprilTags.hpp

variable

std::vector< AprilTag > aprilTags

function

AprilTags()

Construct AprilTags message.

function

~AprilTags()

function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

inline function

DatatypeEnum getDatatype()

function

DEPTHAI_SERIALIZE(AprilTags, Buffer::sequenceNum, Buffer::ts, Buffer::tsDevice, aprilTags)

struct

dai::AutoCalibrationConfig

#include AutoCalibrationConfig.hpp

variable

Mode mode

variable

int sleepingTime

variable

double calibrationConfidenceThreshold

variable

double dataConfidenceThreshold

variable

unsigned int maxIterations

variable

unsigned int maxImagesPerRecalibration

variable

int validationSetSize

variable

bool flashCalibration

function

AutoCalibrationConfig()

inline function

 AutoCalibrationConfig(Mode mode, int sleepingTime, double calibrationConfidence, double dataConfidence, unsigned int maxIter, unsigned int maxImg, int valSize, bool flash)

Full constructor for initializing auto-calibration parameters.

Parameters

mode: Calibration trigger mode (ON_START or CONTINUOUS).
sleepingTime: Time in seconds between calibration cycles.
calibrationConfidence: Threshold for accepting a new calibration result.
dataConfidence: Threshold for the quality of input data/features.
maxIter: Maximum number of optimization iterations.
maxImg: Maximum number of images to collect for a single recalibration.
valSize: Number of images used to validate the calibration result.
flash: Whether to save the resulting calibration to non-volatile memory.

function

~AutoCalibrationConfig()

function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

inline function

DatatypeEnum getDatatype()

function

 DEPTHAI_SERIALIZE(AutoCalibrationConfig, mode, sleepingTime, calibrationConfidenceThreshold, dataConfidenceThreshold, maxIterations, maxImagesPerRecalibration, validationSetSize, flashCalibration)

enum

int Mode

Defines when the auto-calibration process should be triggered.

enumerator

ON_START

Run calibration once upon pipeline startup.

enumerator

CONTINUOUS

Periodically run calibration while the pipeline is running.

class

dai::AutoCalibrationResult

#include AutoCalibrationResult.hpp

variable

double dataConfidence

variable

double calibrationConfidence

variable

bool passed

variable

CalibrationHandler calibration

function

AutoCalibrationResult()

inline function

AutoCalibrationResult(double dataConfidence, double calibrationConfidence, bool passed, CalibrationHandler calibration)

Full constructor for AutoCalibrationResult.

Parameters

dataConfidence: Confidence score of the input data used for calibration.
calibrationConfidence: Confidence score of the resulting calibration.
passed: Whether the calibration cycle met the required thresholds.
calibration: The actual calibration handler containing the new parameters.

function

~AutoCalibrationResult()

function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

inline function

DatatypeEnum getDatatype()

function

DEPTHAI_SERIALIZE(AutoCalibrationResult, dataConfidence, calibrationConfidence, passed, calibration)

class

dai::BenchmarkReport

#include BenchmarkReport.hpp

variable

float fps

variable

float timeTotal

variable

float numMessagesReceived

variable

float averageLatency

variable

std::vector< float > latencies

function

BenchmarkReport()

function

~BenchmarkReport()

function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

inline function

DatatypeEnum getDatatype()

function

 DEPTHAI_SERIALIZE(BenchmarkReport, Buffer::sequenceNum, Buffer::ts, Buffer::tsDevice, fps, timeTotal, numMessagesReceived, averageLatency, latencies)

class

dai::Buffer

#include Buffer.hppDerived by dai::ImgDetectionsT< ImgDetection >, dai::ImgDetectionsT< SpatialImgDetection >, dai::AprilTagConfig, dai::AprilTags, dai::AutoCalibrationConfig, dai::AutoCalibrationResult, dai::BenchmarkReport, dai::CalibrationMetrics, dai::CalibrationQuality, dai::CameraControl, dai::CoverageData, dai::DynamicCalibrationControl, dai::DynamicCalibrationResult, dai::EdgeDetectorConfig, dai::EncodedFrame, dai::FeatureTrackerConfig, dai::GateControl, dai::IMUData, dai::ImageAlignConfig, dai::ImageFiltersConfig, dai::ImageManipConfig, dai::ImgAnnotations, dai::ImgDetectionsT< DetectionT >, dai::ImgFrame, dai::MapData, dai::MessageGroup, dai::NNData, dai::NeuralDepthConfig, dai::ObjectTrackerConfig, dai::PipelineEvent, dai::PipelineEventAggregationConfig, dai::PipelineState, dai::PointCloudConfig, dai::PointCloudData, dai::RGBDData, dai::SegmentationMask, dai::SegmentationParserConfig, dai::SpatialLocationCalculatorConfig, dai::SpatialLocationCalculatorData, dai::StereoDepthConfig, dai::SystemInformation, dai::SystemInformationRVC4, dai::ThermalConfig, dai::ToFConfig, dai::ToFDepthConfidenceFilterConfig, dai::TrackedFeatures, dai::Tracklets, dai::TransformData, dai::VppConfig

variable

int64_t sequenceNum

variable

Timestamp ts

variable

Timestamp tsDevice

function

Buffer()

function

Buffer(size_t size)

function

Buffer(long fd)

function

Buffer(long fd, size_t size)

function

~Buffer()

function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

inline function

DatatypeEnum getDatatype()

function

span< uint8_t > getData()

function

span< const uint8_t > getData()

function

void setData(const std::vector< std::uint8_t > & data)

Parameters

data: Copies data to internal buffer

function

void setData(const long fd)

function

void setData(std::vector< std::uint8_t > && data)

Parameters

data: Moves data to internal buffer

function

std::chrono::time_point< std::chrono::steady_clock, std::chrono::steady_clock::duration > getTimestamp()

Retrieves timestamp related to dai::Clock::now()

function

std::chrono::time_point< std::chrono::steady_clock, std::chrono::steady_clock::duration > getTimestampDevice()

Retrieves timestamp directly captured from device's monotonic clock, not synchronized to host time. Used mostly for debugging

function

void setTimestamp(std::chrono::time_point< std::chrono::steady_clock, std::chrono::steady_clock::duration > timestamp)

Sets image timestamp related to dai::Clock::now()

function

void setTimestampDevice(std::chrono::time_point< std::chrono::steady_clock, std::chrono::steady_clock::duration > timestamp)

Sets image timestamp related to dai::Clock::now()

function

int64_t getSequenceNum()

Retrieves image sequence number

function

void setSequenceNum(int64_t sequenceNum)

Sets image sequence number

function

span< const uint8_t > getRecordData()

function

dai::VisualizeType getVisualizationMessage()

Get visualizable message

Returns

Visualizable message, either ImgFrame, ImgAnnotations or std::monostate (None)

function

DEPTHAI_SERIALIZE(Buffer, sequenceNum, ts, tsDevice)

class

dai::CameraControl

#include CameraControl.hpp

variable

uint64_t cmdMask

variable

AutoFocusMode autoFocusMode

variable

uint8_t lensPosition

Lens/VCM position, range: 0..255. Used with

max 255: macro focus, at 8cm distance
infinite focus at about 120..130 (may vary from module to module)
lower values lead to out-of-focus (lens too close to the sensor array)

variable

float lensPositionRaw

variable

uint8_t lensPosAutoInfinity

variable

uint8_t lensPosAutoMacro

variable

ManualExposureParams expManual

variable

RegionParams aeRegion

variable

RegionParams afRegion

variable

AutoWhiteBalanceMode awbMode

variable

SceneMode sceneMode

variable

AntiBandingMode antiBandingMode

variable

CaptureIntent captureIntent

variable

ControlMode controlMode

variable

EffectMode effectMode

variable

FrameSyncMode frameSyncMode

variable

StrobeConfig strobeConfig

variable

StrobeTimings strobeTimings

variable

uint32_t aeMaxExposureTimeUs

variable

bool aeLockMode

variable

bool awbLockMode

variable

int8_t expCompensation

variable

int8_t brightness

variable

int8_t contrast

variable

int8_t saturation

variable

uint8_t sharpness

variable

uint8_t lumaDenoise

variable

uint8_t chromaDenoise

variable

uint16_t wbColorTemp

variable

uint8_t lowPowerNumFramesBurst

variable

uint8_t lowPowerNumFramesDiscard

variable

bool enableHdr

variable

std::vector< std::pair< std::string, std::string > > miscControls

function

CameraControl()

function

CameraControl & setCaptureStill(bool capture)

Set a command to capture a still image

function

CameraControl & setStartStreaming()

Set a command to start streaming

function

CameraControl & setStopStreaming()

Set a command to stop streaming

function

CameraControl & setExternalTrigger(int numFramesBurst, int numFramesDiscard)

Set a command to enable external trigger snapshot modeA rising edge on the sensor FSIN pin will make it capture a sequence of

function

CameraControl & setFrameSyncMode(FrameSyncMode mode)

Set the frame sync mode for continuous streaming operation mode, translating to how the camera pin FSIN/FSYNC is used: input/output/disabled

function

CameraControl & setStrobeSensor(int activeLevel)

Enable STROBE output on sensor pin, optionally configuring the polarity. Note: for many sensors the polarity is high-active and not configurable

function

CameraControl & setStrobeExternal(int gpioNumber, int activeLevel)

Enable STROBE output driven by a MyriadX GPIO, optionally configuring the polarity This normally requires a FSIN/FSYNC/trigger input for MyriadX (usually GPIO 41), to generate timings

function

CameraControl & setStrobeDisable()

Disable STROBE output

function

CameraControl & setAutoFocusMode(AutoFocusMode mode)

Set a command to specify autofocus mode. Default

function

CameraControl & setAutoFocusTrigger()

Set a command to trigger autofocus

function

CameraControl & setAutoFocusLensRange(int infinityPosition, int macroPosition)

Set autofocus lens range,

function

CameraControl & setAutoFocusRegion(uint16_t startX, uint16_t startY, uint16_t width, uint16_t height)

Set a command to specify focus region in pixels. Note: the region should be mapped to the configured sensor resolution, before ISP scaling

Parameters

startX: X coordinate of top left corner of region
startY: Y coordinate of top left corner of region
width: Region width
height: Region height

function

CameraControl & setManualFocus(uint8_t lensPosition)

Set a command to specify manual focus position

Parameters

lensPosition: specify lens position 0..255

function

CameraControl & setManualFocusRaw(float lensPositionRaw)

Set a command to specify manual focus position (more precise control).

Parameters

lensPositionRaw: specify lens position 0.0f .. 1.0f

Returns

CameraControl&

function

CameraControl & setAutoExposureEnable()

Set a command to enable auto exposure

function

CameraControl & setAutoExposureLock(bool lock)

Set a command to stop the auto-exposure algorithm. The latest AE sensor configuration is kept.

Parameters

lock: Auto exposure lock mode enabled or disabled

function

CameraControl & setAutoExposureRegion(uint16_t startX, uint16_t startY, uint16_t width, uint16_t height)

Set a command to specify auto exposure region in pixels. Note: the region should be mapped to the configured sensor resolution, before ISP scaling

Parameters

startX: X coordinate of top left corner of region
startY: Y coordinate of top left corner of region
width: Region width
height: Region height

function

CameraControl & setAutoExposureCompensation(int compensation)

Set a command to specify auto exposure compensation. This modifies the brightness target with positive numbers making the image brighter and negative numbers making the image darker.

Parameters

compensation: Compensation value between -9..9, default 0

function

CameraControl & setAutoExposureLimit(uint32_t maxExposureTimeUs)

Set a command to specify the maximum exposure time limit for auto-exposure. By default the AE algorithm prioritizes increasing exposure over ISO, up to around frame-time (subject to further limits imposed by anti-banding)

Parameters

maxExposureTimeUs: Maximum exposure time in microseconds

function

CameraControl & setAutoExposureLimit(std::chrono::microseconds maxExposureTime)

Parameters

maxExposureTime: Maximum exposure time

function

CameraControl & setAntiBandingMode(AntiBandingMode mode)

Set a command to specify anti-banding mode. Anti-banding / anti-flicker works in auto-exposure mode, by controlling the exposure time to be applied in multiples of half the mains period, for example in multiple of 10ms for 50Hz (period 20ms) AC-powered illumination sources.If the scene would be too bright for the smallest exposure step (10ms in the example, with ISO at a minimum of 100), anti-banding is not effective.

Parameters

mode: Anti-banding mode to use. Default:

function

CameraControl & setManualExposure(uint32_t exposureTimeUs, uint32_t sensitivityIso)

Set a command to manually specify exposure

Parameters

exposureTimeUs: Exposure time in microseconds
sensitivityIso: Sensitivity as ISO value, usual range 100..1600

function

CameraControl & setManualExposure(std::chrono::microseconds exposureTime, uint32_t sensitivityIso)

Set a command to manually specify exposure

Parameters

exposureTime: Exposure time
sensitivityIso: Sensitivity as ISO value, usual range 100..1600

function

CameraControl & setAutoWhiteBalanceMode(AutoWhiteBalanceMode mode)

Set a command to specify auto white balance mode

Parameters

mode: Auto white balance mode to use. Default

function

CameraControl & setAutoWhiteBalanceLock(bool lock)

Set a command to specify auto white balance lock

Parameters

lock: Auto white balance lock mode enabled or disabled

function

CameraControl & setManualWhiteBalance(int colorTemperatureK)

Set a command to manually specify white-balance color correction

Parameters

colorTemperatureK: Light source color temperature in kelvins, range 1000..12000

function

CameraControl & setBrightness(int value)

Set a command to adjust image brightness

Parameters

value: Brightness, range -10..10, default 0

function

CameraControl & setContrast(int value)

Set a command to adjust image contrast

Parameters

value: Contrast, range -10..10, default 0

function

CameraControl & setSaturation(int value)

Set a command to adjust image saturation

Parameters

value: Saturation, range -10..10, default 0

function

CameraControl & setSharpness(int value)

Set a command to adjust image sharpness

Parameters

value: Sharpness, range 0..4, default 1

function

CameraControl & setLumaDenoise(int value)

Set a command to adjust luma denoise amount

Parameters

value: Luma denoise amount, range 0..4, default 1

function

CameraControl & setChromaDenoise(int value)

Set a command to adjust chroma denoise amount

Parameters

value: Chroma denoise amount, range 0..4, default 1

function

CameraControl & setSceneMode(SceneMode mode)

Set a command to specify scene mode

Parameters

mode: Scene mode

function

CameraControl & setEffectMode(EffectMode mode)

Set a command to specify effect mode

Parameters

mode: Effect mode

function

CameraControl & setMisc(std::string control, std::string value)

Set a miscellaneous control. The controls set by this function get appended to a list, processed after the standard controls

Parameters

control: Control name
value: Value as a string

function

CameraControl & setMisc(std::string control, int value)

Set a miscellaneous control. The controls set by this function get appended to a list, processed after the standard controls

Parameters

control: Control name
value: Value as an integer number

function

CameraControl & setMisc(std::string control, float value)

Set a miscellaneous control. The controls set by this function get appended to a list, processed after the standard controls

Parameters

control: Control name
value: Value as a floating point number

function

void clearMiscControls()

Clear the list of miscellaneous controls set by

function

std::vector< std::pair< std::string, std::string > > getMiscControls()

Get the list of miscellaneous controls set by

Returns

A list of <key, value> pairs as strings

function

CameraControl & setControlMode(ControlMode mode)

Set a command to specify control mode

Parameters

mode: Control mode

function

CameraControl & setHdr(bool enable)

Whether or not to enable HDR (High Dynamic Range) mode

Parameters

enable: True to enable HDR mode, false to disable

function

CameraControl & setCaptureIntent(CaptureIntent mode)

Set a command to specify capture intent mode

Parameters

mode: Capture intent mode

function

bool getCaptureStill()

Check whether command to capture a still is set

Returns

True if capture still command is set

function

std::chrono::microseconds getExposureTime()

Retrieves exposure time

function

int getSensitivity()

Retrieves sensitivity, as an ISO value

function

int getLensPosition()

Retrieves lens position, range 0..255. Returns -1 if not available

function

bool getHdr()

Whether or not HDR (High Dynamic Range) mode is enabled

Returns

True if HDR mode is enabled, false otherwise

inline function

void setCommand(Command cmd, bool value)

inline function

void clearCommand(Command cmd)

inline function

bool getCommand(Command cmd)

function

~CameraControl()

function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

inline function

DatatypeEnum getDatatype()

function

 DEPTHAI_SERIALIZE(CameraControl, cmdMask, autoFocusMode, lensPosition, lensPositionRaw, lensPosAutoInfinity, lensPosAutoMacro, expManual, aeRegion, afRegion, awbMode, sceneMode, antiBandingMode, aeLockMode, awbLockMode, captureIntent, controlMode, effectMode, frameSyncMode, strobeConfig, strobeTimings, aeMaxExposureTimeUs, expCompensation, brightness, contrast, saturation, sharpness, lumaDenoise, chromaDenoise, wbColorTemp, lowPowerNumFramesBurst, lowPowerNumFramesDiscard, enableHdr, miscControls)

function

float getLensPositionRaw()

Retrieves lens position, range 0.0f..1.0f.

struct

dai::CameraControl::ManualExposureParams

variable

uint32_t exposureTimeUs

variable

uint32_t sensitivityIso

variable

uint32_t frameDurationUs

function

DEPTHAI_SERIALIZE(ManualExposureParams, exposureTimeUs, sensitivityIso, frameDurationUs)

struct

dai::CameraControl::RegionParams

variable

uint16_t x

variable

uint16_t y

variable

uint16_t width

variable

uint16_t height

variable

uint32_t priority

function

DEPTHAI_SERIALIZE(RegionParams, x, y, width, height, priority)

struct

dai::CameraControl::StrobeConfig

variable

uint8_t enable

variable

uint8_t activeLevel

variable

int8_t gpioNumber

function

DEPTHAI_SERIALIZE(StrobeConfig, enable, activeLevel, gpioNumber)

struct

dai::CameraControl::StrobeTimings

variable

int32_t exposureBeginOffsetUs

variable

int32_t exposureEndOffsetUs

variable

uint32_t durationUs

function

DEPTHAI_SERIALIZE(StrobeTimings, exposureBeginOffsetUs, exposureEndOffsetUs, durationUs)

enum

uint8_t Command

enumerator

START_STREAM

enumerator

STOP_STREAM

enumerator

STILL_CAPTURE

enumerator

MOVE_LENS

enumerator

AF_TRIGGER

enumerator

AE_MANUAL

enumerator

AE_AUTO

enumerator

AWB_MODE

enumerator

SCENE_MODE

enumerator

ANTIBANDING_MODE

enumerator

EXPOSURE_COMPENSATION

enumerator

AE_LOCK

enumerator

AE_TARGET_FPS_RANGE

enumerator

AWB_LOCK

enumerator

CAPTURE_INTENT

enumerator

CONTROL_MODE

enumerator

FRAME_DURATION

enumerator

SENSITIVITY

enumerator

EFFECT_MODE

enumerator

AF_MODE

enumerator

NOISE_REDUCTION_STRENGTH

enumerator

SATURATION

enumerator

BRIGHTNESS

enumerator

STREAM_FORMAT

enumerator

RESOLUTION

enumerator

SHARPNESS

enumerator

CUSTOM_USECASE

enumerator

CUSTOM_CAPT_MODE

enumerator

CUSTOM_EXP_BRACKETS

enumerator

CUSTOM_CAPTURE

enumerator

CONTRAST

enumerator

AE_REGION

enumerator

AF_REGION

enumerator

LUMA_DENOISE

enumerator

CHROMA_DENOISE

enumerator

WB_COLOR_TEMP

enumerator

EXTERNAL_TRIGGER

enumerator

AF_LENS_RANGE

enumerator

FRAME_SYNC

enumerator

STROBE_CONFIG

enumerator

STROBE_TIMINGS

enumerator

MOVE_LENS_RAW

enumerator

HDR

enum

uint8_t AutoFocusMode

enumerator

OFF

Autofocus disabled. Suitable for manual focus

enumerator

AUTO

Basic automatic focus mode. In this mode, the lens does not move unless the autofocus trigger action is called.

enumerator

MACRO

Close-up focusing mode - this mode is optimized for focusing on objects very close to the camera.

enumerator

CONTINUOUS_VIDEO

In this mode, the AF algorithm modifies the lens position continually to attempt to provide a constantly-in-focus image stream. The focusing behavior should be suitable for good quality video recording; typically this means slower focus movement and no overshoots.

enumerator

CONTINUOUS_PICTURE

In this mode, the AF algorithm modifies the lens position continually to attempt to provide a constantly-in-focus image stream. The focusing behavior should be suitable for still image capture; typically this means focusing as fast as possible

enumerator

EDOF

Extended depth of field (digital focus) mode. The camera device will produce images with an extended depth of field automatically. AF triggers are ignored.

enum

uint8_t AutoWhiteBalanceMode

enumerator

OFF

The camera device's auto-white balance routine is disabled.

enumerator

AUTO

The camera device's auto-white balance routine is active.

enumerator

INCANDESCENT

The camera device's auto-white balance routine is disabled; the camera device uses incandescent light as the assumed scene illumination for white balance.

enumerator

FLUORESCENT

The camera device's auto-white balance routine is disabled; the camera device uses fluorescent light as the assumed scene illumination for white balance.

enumerator

WARM_FLUORESCENT

The camera device's auto-white balance routine is disabled; the camera device uses warm fluorescent light as the assumed scene illumination for white balance.

enumerator

DAYLIGHT

The camera device's auto-white balance routine is disabled; the camera device uses daylight light as the assumed scene illumination for white balance.

enumerator

CLOUDY_DAYLIGHT

The camera device's auto-white balance routine is disabled; the camera device uses cloudy daylight light as the assumed scene illumination for white balance.

enumerator

TWILIGHT

The camera device's auto-white balance routine is disabled; the camera device uses twilight light as the assumed scene illumination for white balance.

enumerator

SHADE

The camera device's auto-white balance routine is disabled; the camera device uses shade light as the assumed scene illumination for white balance.

enum

uint8_t SceneMode

enumerator

UNSUPPORTED

Indicates that no scene modes are set for a given capture request.

enumerator

FACE_PRIORITY

If face detection support exists, use face detection data for auto-focus, auto-white balance, and auto-exposure routines.

enumerator

ACTION

Optimized for photos of quickly moving objects. Similar to SPORTS scene mode.

enumerator

PORTRAIT

Optimized for still photos of people.

enumerator

LANDSCAPE

Optimized for photos of distant macroscopic objects.

enumerator

NIGHT

Optimized for low-light settings.

enumerator

NIGHT_PORTRAIT

Optimized for still photos of people in low-light settings.

enumerator

THEATRE

Optimized for dim, indoor settings where flash must remain off.

enumerator

BEACH

Optimized for bright, outdoor beach settings.

enumerator

SNOW

Optimized for bright, outdoor settings containing snow.

enumerator

SUNSET

Optimized for scenes of the setting sun.

enumerator

STEADYPHOTO

Optimized to avoid blurry photos due to small amounts of device motion (for example: due to hand shake).

enumerator

FIREWORKS

Optimized for nighttime photos of fireworks.

enumerator

SPORTS

Optimized for photos of quickly moving people.

enumerator

PARTY

Optimized for dim, indoor settings with multiple moving people.

enumerator

CANDLELIGHT

Optimized for dim settings where the main light source is a candle.

enumerator

BARCODE

Optimized for accurately capturing a photo of barcode for use by camera applications that wish to read the barcode value.

enum

uint8_t AntiBandingMode

enumerator

OFF

The camera device will not adjust exposure duration to avoid banding problems.

enumerator

MAINS_50_HZ

The camera device will adjust exposure duration to avoid banding problems with 50Hz illumination sources.

enumerator

MAINS_60_HZ

The camera device will adjust exposure duration to avoid banding problems with 60Hz illumination sources.

enumerator

AUTO

The camera device will automatically adapt its antibanding routine to the current illumination condition. This is the default mode if AUTO is available on given camera device.

enum

uint8_t CaptureIntent

enumerator

CUSTOM

The goal of this request doesn't fall into the other categories. The camera device will default to preview-like behavior.

enumerator

PREVIEW

This request is for a preview-like use case.

enumerator

STILL_CAPTURE

This request is for a still capture-type use case.

enumerator

VIDEO_RECORD

This request is for a video recording use case.

enumerator

VIDEO_SNAPSHOT

This request is for a video snapshot (still image while recording video) use case. The camera device should take the highest-quality image possible (given the other settings) without disrupting the frame rate of video recording.

enumerator

ZERO_SHUTTER_LAG

This request is for a ZSL usecase; the application will stream full-resolution images and reprocess one or several later for a final capture.

enum

uint8_t ControlMode

enumerator

OFF

Full application control of pipeline. All control by the device's metering and focusing (3A) routines is disabled.

enumerator

AUTO

Use settings for each individual 3A routine. Manual control of capture parameters is disabled.

enumerator

USE_SCENE_MODE

Use a specific scene mode. Enabling this disables Auto-Exposure, AWB and AF controls;

enum

uint8_t EffectMode

enumerator

OFF

No color effect will be applied.

enumerator

MONO

A "monocolor" effect where the image is mapped into a single color. This will typically be grayscale.

enumerator

NEGATIVE

A "photo-negative" effect where the image's colors are inverted.

enumerator

SOLARIZE

A "solarisation" effect (Sabattier effect) where the image is wholly or partially reversed in tone.

enumerator

SEPIA

A "sepia" effect where the image is mapped into warm gray, red, and brown tones.

enumerator

POSTERIZE

A "posterization" effect where the image uses discrete regions of tone rather than a continuous gradient of tones.

enumerator

WHITEBOARD

A "whiteboard" effect where the image is typically displayed as regions of white, with black or grey details.

enumerator

BLACKBOARD

A "blackboard" effect where the image is typically displayed as regions of black, with white or grey details.

enumerator

AQUA

An "aqua" effect where a blue hue is added to the image.

enum

uint8_t FrameSyncMode

enumerator

OFF

enumerator

OUTPUT

enumerator

INPUT

class

dai::DynamicCalibrationControl

#include DynamicCalibrationControl.hpp

variable

Command command

inline function

DynamicCalibrationControl()

inline explicit function

DynamicCalibrationControl(Command cmd)

function

~DynamicCalibrationControl()

inline function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

inline function

DatatypeEnum getDatatype()

struct

dai::DynamicCalibrationControl::Commands

#include DynamicCalibrationControl.hpp

struct

dai::DynamicCalibrationControl::Commands::ApplyCalibration

#include DynamicCalibrationControl.hpp

variable

CalibrationHandler calibration

variable

bool flash

function

ApplyCalibration()

inline explicit function

ApplyCalibration(const CalibrationHandler & calibration, bool flash)

function

DEPTHAI_SERIALIZE(ApplyCalibration, calibration, flash)

struct

dai::DynamicCalibrationControl::Commands::Calibrate

#include DynamicCalibrationControl.hpp

variable

bool force

inline explicit function

Calibrate(bool force)

function

DEPTHAI_SERIALIZE(Calibrate, force)

struct

dai::DynamicCalibrationControl::Commands::CalibrationQuality

#include DynamicCalibrationControl.hpp

variable

bool force

inline explicit function

CalibrationQuality(bool force)

function

DEPTHAI_SERIALIZE(CalibrationQuality, force)

struct

dai::DynamicCalibrationControl::Commands::ComputeCalibrationMetrics

#include DynamicCalibrationControl.hpp

variable

dai::CalibrationHandler calibration

inline explicit function

ComputeCalibrationMetrics(dai::CalibrationHandler & calibration)

function

DEPTHAI_SERIALIZE(ComputeCalibrationMetrics, calibration)

struct

dai::DynamicCalibrationControl::Commands::LoadImage

#include DynamicCalibrationControl.hpp

struct

dai::DynamicCalibrationControl::Commands::ResetData

#include DynamicCalibrationControl.hpp

struct

dai::DynamicCalibrationControl::Commands::SetPerformanceMode

#include DynamicCalibrationControl.hpp

variable

PerformanceMode performanceMode

inline function

SetPerformanceMode()

inline explicit function

SetPerformanceMode(PerformanceMode performanceMode)

function

DEPTHAI_SERIALIZE(SetPerformanceMode, performanceMode)

struct

dai::DynamicCalibrationControl::Commands::StartCalibration

#include DynamicCalibrationControl.hpp

variable

float loadImagePeriod

variable

float calibrationPeriod

inline explicit function

StartCalibration(float loadImagePeriod, float calibrationPeriod)

function

DEPTHAI_SERIALIZE(StartCalibration, loadImagePeriod, calibrationPeriod)

struct

dai::DynamicCalibrationControl::Commands::StopCalibration

#include DynamicCalibrationControl.hpp

enum

int PerformanceMode

enumerator

DEFAULT

enumerator

STATIC_SCENERY

enumerator

OPTIMIZE_SPEED

enumerator

OPTIMIZE_PERFORMANCE

enumerator

SKIP_CHECKS

enum

std::variant< std::monostate, Commands::Calibrate, Commands::CalibrationQuality, Commands::StartCalibration, Commands::StopCalibration, Commands::LoadImage, Commands::ApplyCalibration, Commands::ResetData, Commands::SetPerformanceMode, Commands::ComputeCalibrationMetrics > Command

struct

dai::CoverageData

#include DynamicCalibrationResults.hpp

function

CoverageData()

function

~CoverageData()

function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

inline function

DatatypeEnum getDatatype()

function

DEPTHAI_SERIALIZE(CoverageData, coveragePerCellA, coveragePerCellB, meanCoverage, dataAcquired, coverageAcquired)

struct

dai::CalibrationQuality

#include DynamicCalibrationResults.hpp

variable

std::optional< Data > qualityData

Optional quality metrics.

variable

std::string info

Human-readable result description.

function

CalibrationQuality()

function

~CalibrationQuality()

inline function

CalibrationQuality(Data qualityData, std::string info)

inline function

CalibrationQuality(std::string info)

function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

inline function

DatatypeEnum getDatatype()

function

DEPTHAI_SERIALIZE(CalibrationQuality, qualityData, info)

struct

dai::CalibrationQuality::Data

#include DynamicCalibrationResults.hpp

variable

std::array< float, 3 > rotationChange

Rotation difference between old and new extrinsics (degrees).

variable

std::vector< double > depthErrorDifference

Predicted relative depth error difference between current and new calibration. Reported at reference distances [1m, 2m, 5m, 10m]. Units: percent [%].

variable

float sampsonErrorCurrent

Sampson error of currently installed calibration.

variable

float sampsonErrorNew

Estimated new Sampson error if the new calibration is applied.

function

DEPTHAI_SERIALIZE(Data, rotationChange, sampsonErrorCurrent, sampsonErrorNew, depthErrorDifference)

struct

dai::CalibrationMetrics

#include DynamicCalibrationResults.hpp

variable

double calibrationConfidence

variable

double dataConfidence

inline function

CalibrationMetrics()

function

~CalibrationMetrics()

inline function

DatatypeEnum getDatatype()

function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

function

DEPTHAI_SERIALIZE(CalibrationMetrics, calibrationConfidence, dataConfidence)

struct

dai::DynamicCalibrationResult

#include DynamicCalibrationResults.hpp

variable

std::optional< Data > calibrationData

Optional calibration result data.

variable

std::string info

Informational result message.

function

DynamicCalibrationResult()

function

~DynamicCalibrationResult()

inline function

DynamicCalibrationResult(const Data & data, std::string information)

inline function

DynamicCalibrationResult(std::string information)

function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

inline function

DatatypeEnum getDatatype()

function

DEPTHAI_SERIALIZE(DynamicCalibrationResult, calibrationData, info)

struct

dai::DynamicCalibrationResult::Data

#include DynamicCalibrationResults.hpp

variable

dai::CalibrationHandler newCalibration

Calibration produced by dynamic calibration.

variable

dai::CalibrationHandler currentCalibration

Calibration present before dynamic calibration.

variable

CalibrationQuality::Data calibrationDifference

Per-metric comparison of new vs old calibration.

variable

double dataConfidence

function

DEPTHAI_SERIALIZE(Data, newCalibration, currentCalibration, calibrationDifference, dataConfidence)

class

dai::EdgeDetectorConfig

#include EdgeDetectorConfig.hpp

variable

EdgeDetectorConfigData config

function

EdgeDetectorConfig()

function

~EdgeDetectorConfig()

function

void setSobelFilterKernels(const std::vector< std::vector< int >> & horizontalKernel, const std::vector< std::vector< int >> & verticalKernel)

Set sobel filter horizontal and vertical 3x3 kernels

Parameters

horizontalKernel: Used for horizontal gradient computation in 3x3 Sobel filter
verticalKernel: Used for vertical gradient computation in 3x3 Sobel filter

function

EdgeDetectorConfigData getConfigData()

Retrieve configuration data for EdgeDetector

Returns

EdgeDetectorConfigData: sobel filter horizontal and vertical 3x3 kernels

function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

inline function

DatatypeEnum getDatatype()

function

DEPTHAI_SERIALIZE(EdgeDetectorConfig, Buffer::sequenceNum, Buffer::ts, Buffer::tsDevice, config)

struct

dai::EdgeDetectorConfig::EdgeDetectorConfigData

variable

std::vector< std::vector< int > > sobelFilterHorizontalKernel

Used for horizontal gradient computation in 3x3 Sobel filter Format - 3x3 matrix, 2nd column must be 0 Default - +1 0 -1; +2 0 -2; +1 0 -1

variable

std::vector< std::vector< int > > sobelFilterVerticalKernel

Used for vertical gradient computation in 3x3 Sobel filter Format - 3x3 matrix, 2nd row must be 0 Default - +1 +2 +1; 0 0 0; -1 -2 -1

function

DEPTHAI_SERIALIZE(EdgeDetectorConfigData, sobelFilterHorizontalKernel, sobelFilterVerticalKernel)

class

dai::EncodedFrame

variable

CameraSettings cam

variable

uint32_t instanceNum

variable

unsigned int width

variable

unsigned int height

variable

uint32_t quality

variable

uint32_t bitrate

variable

Profile profile

variable

bool lossless

variable

FrameType type

variable

uint32_t frameOffset

variable

uint32_t frameSize

variable

ImgTransformation transformation

function

~EncodedFrame()

function

unsigned int getInstanceNum()

Retrieves instance number

function

unsigned int getWidth()

Retrieves image width in pixels

function

unsigned int getHeight()

Retrieves image height in pixels

function

std::chrono::microseconds getExposureTime()

Retrieves exposure time

function

int getSensitivity()

Retrieves sensitivity, as an ISO value

function

int getColorTemperature()

Retrieves white-balance color temperature of the light source, in kelvins

function

int getLensPosition()

Retrieves lens position, range 0..255. Returns -1 if not available

function

float getLensPositionRaw()

Retrieves lens position, range 0.0f..1.0f. Returns -1 if not available

function

unsigned int getQuality()

Retrieves the encoding quality

function

unsigned int getBitrate()

Retrieves the encoding bitrate

function

bool getLossless()

Returns true if encoding is lossless (JPEG only)

function

FrameType getFrameType()

Retrieves frame type (H26x only)

function

Profile getProfile()

Retrieves the encoding profile (JPEG, AVC or HEVC)

function

EncodedFrame & setInstanceNum(unsigned int instance)

Instance number relates to the origin of the frame (which camera)

Parameters

instance: Instance number

function

EncodedFrame & setWidth(unsigned int width)

Specifies frame width

Parameters

width: frame width

function

EncodedFrame & setHeight(unsigned int height)

Specifies frame height

Parameters

height: frame height

function

EncodedFrame & setSize(unsigned int width, unsigned int height)

Specifies frame size

Parameters

height: frame height
width: frame width

function

EncodedFrame & setSize(std::tuple< unsigned int, unsigned int > size)

Specifies frame size

Parameters

size: frame size

function

EncodedFrame & setQuality(unsigned int quality)

Specifies the encoding quality

Parameters

quality: Encoding quality

function

EncodedFrame & setBitrate(unsigned int bitrate)

Specifies the encoding quality

Parameters

quality: Encoding quality

function

EncodedFrame & setLossless(bool lossless)

Specifies if encoding is lossless (JPEG only)

Parameters

lossless: True if lossless

function

EncodedFrame & setFrameType(FrameType type)

Specifies the frame type (H26x only)

Parameters

type: Type of h26x frame (I, P, B)

function

EncodedFrame & setProfile(Profile profile)

Specifies the encoding profile

Parameters

profile: Encoding profile

function

ImgFrame getImgFrameMeta()

function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

inline function

DatatypeEnum getDatatype()

function

 DEPTHAI_SERIALIZE(EncodedFrame, cam, instanceNum, width, height, quality, bitrate, profile, lossless, type, frameOffset, frameSize, transformation, Buffer::sequenceNum, Buffer::ts, Buffer::tsDevice)

enum

std::uint8_t Profile

enumerator

JPEG

enumerator

AVC

enumerator

HEVC

enum

std::uint8_t FrameType

enumerator

Unknown

enum

ImgFrame::CameraSettings CameraSettings

class

dai::FeatureTrackerConfig

#include FeatureTrackerConfig.hpp

variable

CornerDetector cornerDetector

Corner detector configuration. Used for feature detection.

variable

MotionEstimator motionEstimator

Motion estimator configuration. Used for feature reidentification between current and previous features.

variable

FeatureMaintainer featureMaintainer

FeatureMaintainer configuration. Used for feature maintaining.

function

FeatureTrackerConfig()

Construct FeatureTrackerConfig message.

function

~FeatureTrackerConfig()

function

FeatureTrackerConfig & setCornerDetector(CornerDetector::Type cornerDetector)

Set corner detector algorithm type.

Parameters

cornerDetector: Corner detector type, HARRIS or SHI_THOMASI

function

FeatureTrackerConfig & setCornerDetector(CornerDetector config)

Set corner detector full configuration.

Parameters

config: Corner detector configuration

function

FeatureTrackerConfig & setOpticalFlow()

Set optical flow as motion estimation algorithm type.

function

FeatureTrackerConfig & setOpticalFlow(MotionEstimator::OpticalFlow config)

Set optical flow full configuration.

Parameters

config: Optical flow configuration

function

FeatureTrackerConfig & setHwMotionEstimation()

Set hardware accelerated motion estimation using block matching. Faster than optical flow (software implementation) but might not be as accurate.

function

FeatureTrackerConfig & setNumTargetFeatures(std::int32_t numTargetFeatures)

Set number of target features to detect.

Parameters

numTargetFeatures: Number of features

function

FeatureTrackerConfig & setMotionEstimator(bool enable)

Enable or disable motion estimator.

Parameters

enable:

function

FeatureTrackerConfig & setMotionEstimator(MotionEstimator config)

Set motion estimator full configuration.

Parameters

config: Motion estimator configuration

function

FeatureTrackerConfig & setFeatureMaintainer(bool enable)

Enable or disable feature maintainer.

Parameters

enable:

function

FeatureTrackerConfig & setFeatureMaintainer(FeatureMaintainer config)

Set feature maintainer full configuration.

Parameters

config: feature maintainer configuration

function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

inline function

DatatypeEnum getDatatype()

function

DEPTHAI_SERIALIZE(FeatureTrackerConfig, cornerDetector, motionEstimator, featureMaintainer)

struct

dai::FeatureTrackerConfig::CornerDetector

#include FeatureTrackerConfig.hpp

variable

Type type

Corner detector algorithm type.

variable

std::int32_t cellGridDimension

Ensures distributed feature detection across the image. Image is divided into horizontal and vertical cells, each cell has a target feature count = numTargetFeatures / cellGridDimension. Each cell has its own feature threshold. A value of 4 means that the image is divided into 4x4 cells of equal width/height. Maximum 4, minimum 1.

variable

std::int32_t numTargetFeatures

Target number of features to detect. Maximum number of features is determined at runtime based on algorithm type.

variable

std::int32_t numMaxFeatures

Hard limit for the maximum number of features that can be detected. 0 means auto, will be set to the maximum value based on memory constraints.

variable

bool enableSobel

Enable 3x3 Sobel operator to smoothen the image whose gradient is to be computed. If disabled, a simple 1D row/column differentiator is used for gradient.

variable

bool enableSorting

Enable sorting detected features based on their score or not.

variable

Thresholds thresholds

Threshold settings. These are advanced settings, suitable for debugging/special cases.

function

 DEPTHAI_SERIALIZE(CornerDetector, type, cellGridDimension, numTargetFeatures, numMaxFeatures, thresholds, enableSobel, enableSorting)

struct

dai::FeatureTrackerConfig::CornerDetector::Thresholds

#include FeatureTrackerConfig.hpp

variable

float initialValue

Minimum strength of a feature which will be detected. 0 means automatic threshold update. Recommended so the tracker can adapt to different scenes/textures. Each cell has its own threshold. Empirical value.

variable

float min

Minimum limit for threshold. Applicable when automatic threshold update is enabled. 0 means auto, 6000000 for HARRIS, 1200 for SHI_THOMASI. Empirical value.

variable

float max

Maximum limit for threshold. Applicable when automatic threshold update is enabled. 0 means auto. Empirical value.

variable

float decreaseFactor

When detected number of features exceeds the maximum in a cell threshold is lowered by multiplying its value with this factor.

variable

float increaseFactor

When detected number of features doesn't exceed the maximum in a cell, threshold is increased by multiplying its value with this factor.

function

DEPTHAI_SERIALIZE(Thresholds, initialValue, min, max, decreaseFactor, increaseFactor)

enum

std::int32_t Type

enumerator

HARRIS

Harris corner detector.

enumerator

SHI_THOMASI

Shi-Thomasi corner detector.

struct

dai::FeatureTrackerConfig::FeatureMaintainer

#include FeatureTrackerConfig.hpp

variable

bool enable

Enable feature maintaining or not.

variable

float minimumDistanceBetweenFeatures

Used to filter out detected feature points that are too close. Requires sorting enabled in detector. Unit of measurement is squared euclidean distance in pixels.

variable

float lostFeatureErrorThreshold

Optical flow measures the tracking error for every feature. If the point can’t be tracked or it’s out of the image it will set this error to a maximum value. This threshold defines the level where the tracking accuracy is considered too bad to keep the point.

variable

float trackedFeatureThreshold

Once a feature was detected and we started tracking it, we need to update its Harris score on each image. This is needed because a feature point can disappear, or it can become too weak to be tracked. This threshold defines the point where such a feature must be dropped. As the goal of the algorithm is to provide longer tracks, we try to add strong points and track them until they are absolutely untrackable. This is why, this value is usually smaller than the detection threshold.

function

 DEPTHAI_SERIALIZE(FeatureMaintainer, enable, minimumDistanceBetweenFeatures, lostFeatureErrorThreshold, trackedFeatureThreshold)

struct

dai::FeatureTrackerConfig::MotionEstimator

#include FeatureTrackerConfig.hpp

variable

bool enable

Enable motion estimation or not.

variable

Type type

Motion estimator algorithm type.

variable

OpticalFlow opticalFlow

Optical flow configuration. Takes effect only if MotionEstimator algorithm type set to LUCAS_KANADE_OPTICAL_FLOW.

function

DEPTHAI_SERIALIZE(MotionEstimator, enable, type, opticalFlow)

struct

dai::FeatureTrackerConfig::MotionEstimator::OpticalFlow

#include FeatureTrackerConfig.hpp

variable

std::int32_t pyramidLevels

Number of pyramid levels, only for optical flow. AUTO means it's decided based on input resolution: 3 if image width <= 640, else 4. Valid values are either 3/4 for VGA, 4 for 720p and above.

variable

std::int32_t searchWindowWidth

Image patch width used to track features. Must be an odd number, maximum 9. N means the algorithm will be able to track motion at most (N-1)/2 pixels in a direction per pyramid level. Increasing this number increases runtime

variable

std::int32_t searchWindowHeight

Image patch height used to track features. Must be an odd number, maximum 9. N means the algorithm will be able to track motion at most (N-1)/2 pixels in a direction per pyramid level. Increasing this number increases runtime

variable

float epsilon

Feature tracking termination criteria. Optical flow will refine the feature position on each pyramid level until the displacement between two refinements is smaller than this value. Decreasing this number increases runtime.

variable

std::int32_t maxIterations

Feature tracking termination criteria. Optical flow will refine the feature position maximum this many times on each pyramid level. If the Epsilon criteria described in the previous chapter is not met after this number of iterations, the algorithm will continue with the current calculated value. Increasing this number increases runtime.

function

DEPTHAI_SERIALIZE(OpticalFlow, pyramidLevels, searchWindowWidth, searchWindowHeight, epsilon, maxIterations)

enum

std::int32_t Type

enumerator

LUCAS_KANADE_OPTICAL_FLOW

Using the pyramidal Lucas-Kanade optical flow method.

enumerator

HW_MOTION_ESTIMATION

Using a dense motion estimation hardware block (Block matcher).

class

dai::GateControl

variable

bool open

variable

int numMessages

variable

int fps

function

GateControl()

inline function

GateControl(bool open, int numMessages, int fps)

function

~GateControl()

inline function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

inline function

DatatypeEnum getDatatype()

function

DEPTHAI_SERIALIZE(GateControl, open, numMessages, fps)

struct

dai::IMUReport

Derived by dai::IMUReportAccelerometer, dai::IMUReportGyroscope, dai::IMUReportMagneticField, dai::IMUReportRotationVectorWAcc

variable

int32_t sequence

The sequence number increments once for each report sent. Gaps in the sequence numbers indicate missing or dropped reports. Max value 2^32 after which resets to 0.

variable

Accuracy accuracy

Accuracy of sensor

variable

Timestamp timestamp

Generation timestamp, synced to host time

variable

Timestamp tsDevice

Generation timestamp, direct device monotonic clock

inline function

std::chrono::time_point< std::chrono::steady_clock, std::chrono::steady_clock::duration > getTimestamp()

Retrieves timestamp related to dai::Clock::now()

inline function

std::chrono::time_point< std::chrono::steady_clock, std::chrono::steady_clock::duration > getTimestampDevice()

Retrieves timestamp directly captured from device's monotonic clock, not synchronized to host time. Used mostly for debugging

inline function

int32_t getSequenceNum()

Retrieves IMU report sequence number

enum

std::uint8_t Accuracy

enumerator

UNRELIABLE

enumerator

LOW

enumerator

MEDIUM

enumerator

HIGH

struct

dai::IMUReportAccelerometer

#include IMUData.hpp

variable

float x

variable

float y

variable

float z

struct

dai::IMUReportGyroscope

#include IMUData.hpp

variable

float x

variable

float y

variable

float z

struct

dai::IMUReportMagneticField

#include IMUData.hpp

variable

float x

variable

float y

variable

float z

struct

dai::IMUReportRotationVectorWAcc

#include IMUData.hpp

variable

float i

variable

float j

variable

float k

variable

float real

variable

float rotationVectorAccuracy

struct

dai::IMUPacket

#include IMUData.hpp

variable

IMUReportAccelerometer acceleroMeter

variable

IMUReportGyroscope gyroscope

variable

IMUReportMagneticField magneticField

variable

IMUReportRotationVectorWAcc rotationVector

class

dai::IMUData

#include IMUData.hpp

variable

std::vector< IMUPacket > packets

function

IMUData()

function

~IMUData()

function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

inline function

DatatypeEnum getDatatype()

function

DEPTHAI_SERIALIZE(IMUData, Buffer::ts, Buffer::tsDevice, Buffer::sequenceNum, packets)

class

dai::ImageAlignConfig

#include ImageAlignConfig.hpp

variable

uint16_t staticDepthPlane

Optional static depth plane to align to, in depth units, by default millimeters

function

ImageAlignConfig()

function

~ImageAlignConfig()

function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

inline function

DatatypeEnum getDatatype()

function

DEPTHAI_SERIALIZE(ImageAlignConfig, staticDepthPlane)

class

dai::ImageFiltersConfig

variable

std::vector< std::int32_t > filterIndices

Index of the filter to be applied

variable

std::vector< FilterParams > filterParams

Parameters of the filter to be applied

function

~ImageFiltersConfig()

function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

inline function

DatatypeEnum getDatatype()

function

ImageFiltersConfig & updateFilterAtIndex(std::int32_t index, FilterParams params)

Insert filter parameters describing how a filter at index index should be updated

Parameters

index: Index of the filter to be inserted
params: Parameters of the filter to be inserted

function

ImageFiltersConfig & insertFilter(FilterParams params)

Insert filter parameters describing how a new filter should be inserted

Parameters

params: Parameters of the filter to be inserted

function

void setProfilePreset(ImageFiltersPresetMode presetMode)

Set preset mode for ImageFiltersConfig.

Parameters

presetMode: Preset mode for ImageFiltersConfig.

function

DEPTHAI_SERIALIZE(ImageFiltersConfig, filterIndices, filterParams)

class

dai::ToFDepthConfidenceFilterConfig

variable

float confidenceThreshold

Threshold for the confidence filter

function

~ToFDepthConfidenceFilterConfig()

function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

inline function

DatatypeEnum getDatatype()

function

void setProfilePreset(ImageFiltersPresetMode presetMode)

Set preset mode for ImageFiltersPresetMode.

Parameters

presetMode: Preset mode for ImageFiltersPresetMode.

function

DEPTHAI_SERIALIZE(ToFDepthConfidenceFilterConfig, confidenceThreshold)

struct

dai::OpBase

Derived by dai::Affine, dai::Crop, dai::Flip, dai::FourPoints, dai::Perspective, dai::Resize, dai::Rotate, dai::Translate

function

~OpBase()

function

std::string toStr()

struct

dai::Translate

variable

float offsetX

variable

float offsetY

variable

bool normalized

function

~Translate()

function

Translate()

inline function

Translate(float offsetX, float offsetY, bool normalized)

inline function

std::string toStr()

function

DEPTHAI_SERIALIZE(Translate, offsetX, offsetY, normalized)

struct

dai::Rotate

variable

float angle

variable

bool center

variable

float offsetX

variable

float offsetY

variable

bool normalized

function

~Rotate()

function

Rotate()

inline explicit function

Rotate(float angle, bool center, float offsetX, float offsetY, bool normalized)

inline function

std::string toStr()

function

DEPTHAI_SERIALIZE(Rotate, angle, center, offsetX, offsetY, normalized)

struct

dai::Resize

variable

float width

variable

float height

variable

bool normalized

variable

Mode mode

function

~Resize()

function

Resize()

inline function

Resize(float width, float height, bool normalized)

inline function

std::string toStr()

function

DEPTHAI_SERIALIZE(Resize, width, height, normalized, mode)

enum

Mode

enumerator

VALUE

enumerator

FIT

enumerator

FILL

struct

dai::Flip

variable

Direction direction

variable

bool center

function

~Flip()

function

Flip()

inline explicit function

Flip(Direction direction, bool center)

inline function

std::string toStr()

function

DEPTHAI_SERIALIZE(Flip, direction, center)

enum

Direction

enumerator

HORIZONTAL

enumerator

VERTICAL

struct

dai::Affine

variable

std::array< float, 4 > matrix

function

~Affine()

function

Affine()

inline explicit function

Affine(std::array< float, 4 > matrix)

inline function

std::string toStr()

function

DEPTHAI_SERIALIZE(Affine, matrix)

struct

dai::Perspective

variable

std::array< float, 9 > matrix

function

~Perspective()

function

Perspective()

inline explicit function

Perspective(std::array< float, 9 > matrix)

inline function

std::string toStr()

function

DEPTHAI_SERIALIZE(Perspective, matrix)

struct

dai::FourPoints

variable

std::array< dai::Point2f, 4 > src

variable

std::array< dai::Point2f, 4 > dst

variable

bool normalized

function

~FourPoints()

function

FourPoints()

inline function

FourPoints(std::array< dai::Point2f, 4 > src, std::array< dai::Point2f, 4 > dst, bool normalized)

inline function

std::string toStr()

function

DEPTHAI_SERIALIZE(FourPoints, src, dst, normalized)

struct

dai::Crop

variable

float width

variable

float height

variable

bool normalized

variable

bool center

function

~Crop()

inline function

Crop()

inline function

Crop(float width, float height, bool normalized, bool center)

inline function

Crop clone()

inline function

std::string toStr()

function

DEPTHAI_SERIALIZE(Crop, width, height, normalized, center)

struct

dai::ManipOp

variable

std::variant< Translate, Rotate, Resize, Flip, Affine, Perspective, FourPoints, Crop > op

function

ManipOp()

inline function

ManipOp(Translate op)

inline function

ManipOp(Rotate op)

inline function

ManipOp(Resize op)

inline function

ManipOp(Flip op)

inline function

ManipOp(Affine op)

inline function

ManipOp(Perspective op)

inline function

ManipOp(FourPoints op)

inline function

ManipOp(Crop op)

function

DEPTHAI_SERIALIZE(ManipOp, op)

class

dai::ImageManipOpsEnums

Derived by dai::ImageManipOpsBase< Container >, dai::ImageManipOpsBase< C >

enum

uint8_t Background

enumerator

COLOR

enum

uint8_t ResizeMode

enumerator

NONE

enumerator

STRETCH

enumerator

LETTERBOX

enumerator

CENTER_CROP

class

dai::ImageManipOpsBase

variable

uint32_t outputWidth

variable

uint32_t outputHeight

variable

bool center

variable

ResizeMode resizeMode

variable

Background background

variable

uint32_t backgroundR

variable

uint32_t backgroundG

variable

uint32_t backgroundB

variable

Colormap colormap

variable

bool undistort

variable

C operations

inline function

void cloneTo(ImageManipOpsBase< C2 > & to)

inline function

bool hasWarp(const size_t inputWidth, const size_t inputHeight)

inline function

ImageManipOpsBase & addOp(ManipOp op)

inline function

ImageManipOpsBase & transformPerspective(std::array< float, 9 > matrix)

inline function

ImageManipOpsBase & transformAffine(std::array< float, 4 > matrix)

inline function

ImageManipOpsBase & transformFourPoints(std::array< dai::Point2f, 4 > src, std::array< dai::Point2f, 4 > dst, bool normalizedCoords)

inline function

ImageManipOpsBase & flipHorizontal(bool center)

inline function

ImageManipOpsBase & flipVertical(bool center)

inline function

ImageManipOpsBase & resize(float width, float height, bool normalized)

inline function

ImageManipOpsBase & crop(float x, float y, float w, float h, bool normalized, bool center)

inline function

ImageManipOpsBase & resizeFit()

inline function

ImageManipOpsBase & resizeFill()

inline function

ImageManipOpsBase & resizeWidthKeepAspectRatio(float width, bool normalized)

inline function

ImageManipOpsBase & resizeHeightKeepAspectRatio(float height, bool normalized)

inline function

ImageManipOpsBase & rotateRadians(float angle, bool center, float offsetX, float offsetY, bool normalized)

inline function

ImageManipOpsBase & rotateDegrees(float angle, bool center, float offsetX, float offsetY, bool normalized)

inline function

ImageManipOpsBase & translate(float offsetX, float offsetY, bool normalizedCoords)

inline function

ImageManipOpsBase & setOutputSize(float width, float height)

inline function

ImageManipOpsBase & setOutputResize(uint32_t width, uint32_t height, ResizeMode mode)

inline function

ImageManipOpsBase & setOutputCenter(bool c)

inline function

ImageManipOpsBase & setBackgroundColor(uint32_t red, uint32_t green, uint32_t blue)

inline function

ImageManipOpsBase & setBackgroundColor(uint32_t val)

inline function

ImageManipOpsBase & setColormap(Colormap clr)

inline function

ImageManipOpsBase & setUndistort(bool undistort)

inline function

bool getUndistort()

inline function

const C & getOperations()

inline function

ImageManipOpsBase & clear()

function

 DEPTHAI_SERIALIZE(ImageManipOpsBase, operations, outputWidth, outputHeight, center, resizeMode, background, backgroundR, backgroundG, backgroundB, colormap, undistort)

class

dai::ImageManipConfig

#include ImageManipConfig.hpp

variable

ImageManipOpsBase< Container > base

variable

ImgFrame::Type outputFrameType

variable

bool reusePreviousImage

variable

bool skipCurrentImage

function

ImageManipConfig()

function

~ImageManipConfig()

function

ImageManipConfig & clearOps()

Removes all operations from the list (does not affect output configuration)

function

ImageManipConfig & addCrop(uint32_t x, uint32_t y, uint32_t w, uint32_t h)

Crops the image to the specified rectangle

Parameters

x: X coordinate of the top-left corner
y: Y coordinate of the top-left corner
w: Width of the rectangle
h: Height of the rectangle

function

ImageManipConfig & addCrop(dai::Rect rect, bool normalizedCoords)

Crops the image to the specified rectangle

Parameters

rect: Rect to crop
normalizedCoords: If true, the coordinates are normalized to range [0, 1] where 1 maps to the width/height of the image

function

ImageManipConfig & addCropRotatedRect(dai::RotatedRect rotatedRect, bool normalizedCoords)

Crops the image to the specified (rotated) rectangle

Parameters

rect: RotatedRect to crop
normalizedCoords: If true, the coordinates are normalized to range [0, 1] where 1 maps to the width/height of the image

function

ImageManipConfig & addScale(float scaleX, float scaleY)

Rescales the image using the specified factors

Parameters

scaleX: Scale factor for the X axis
scaleY: Scale factor for the Y axis. If not specified, scaleY is set to the same value as scaleX

function

ImageManipConfig & addRotateDeg(float angle)

Rotates the image around its center by the specified angle in degrees

Parameters

angle: Angle in radians

function

ImageManipConfig & addRotateDeg(float angle, Point2f center)

Rotates the image around the specified point by the specified angle in degrees

Parameters

angle: Angle in radians
center: Center of the rotation using normalized coordinates

function

ImageManipConfig & addFlipHorizontal()

Flips the image horizontally

function

ImageManipConfig & addFlipVertical()

Flips the image vertically

function

ImageManipConfig & addTransformAffine(std::array< float, 4 > matrix)

Applies an affine transformation to the image

Parameters

matrix: an array containing a 2x2 matrix representing the affine transformation

function

ImageManipConfig & addTransformPerspective(std::array< float, 9 > matrix)

Applies a perspective transformation to the image

Parameters

matrix: an array containing a 3x3 matrix representing the perspective transformation

function

ImageManipConfig & addTransformFourPoints(std::array< dai::Point2f, 4 > src, std::array< dai::Point2f, 4 > dst, bool normalizedCoords)

Applies a perspective transformation to the image

Parameters

src: Source points
dst: Destination points
normalizedCoords: If true, the coordinates are normalized to range [0, 1] where 1 maps to the width/height of the image

function

ImageManipConfig & setOutputSize(uint32_t w, uint32_t h, ResizeMode mode)

Sets the output size of the image

Parameters

w: Width of the output image
h: Height of the output image
mode: Resize mode. NONE - no resize, STRETCH - stretch to fit, LETTERBOX - keep aspect ratio and pad with background color, CENTER_CROP - keep aspect ratio and crop

function

ImageManipConfig & setOutputCenter(bool c)

Centers the content in the output image without resizing

Parameters

c: True to center the content, false otherwise

function

ImageManipConfig & setColormap(Colormap colormap)

Sets the colormap to be applied to a grayscale image

Parameters

colormap: Colormap type to be applied

function

ImageManipConfig & setBackgroundColor(uint32_t red, uint32_t green, uint32_t blue)

Sets the rgb background color of the output image

Parameters

red: Red component of the background color
green: Green component of the background color
blue: Blue component of the background color

function

ImageManipConfig & setBackgroundColor(uint32_t val)

Sets the grayscale background color of the output image

Parameters

val: Grayscale value of the background color

function

ImageManipConfig & setFrameType(ImgFrame::Type frameType)

Sets the frame type of the output image

Parameters

frameType: Frame type of the output image

function

ImageManipConfig & setUndistort(bool undistort)

Sets the undistort flag

function

bool getUndistort()

Gets the undistort flag

Returns

True if undistort is enabled, false otherwise

function

ImageManipConfig & setReusePreviousImage(bool reuse)

Instruct ImageManip to not remove current image from its queue and use the same for next message.

Parameters

reuse: True to enable reuse, false otherwise

function

ImageManipConfig & setSkipCurrentImage(bool skip)

Instructs ImageManip to skip current image and wait for next in queue.

Parameters

skip: True to skip current image, false otherwise

function

bool getReusePreviousImage()

Instruct ImageManip to not remove current image from its queue and use the same for next message.

Returns

True to enable reuse, false otherwise

function

bool getSkipCurrentImage()

Instructs ImageManip to skip current image and wait for next in queue.

Returns

True to skip current image, false otherwise

function

DEPTHAI_SERIALIZE(ImageManipConfig, base, outputFrameType, reusePreviousImage, skipCurrentImage)

function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

inline function

DatatypeEnum getDatatype()

enum

ImageManipOpsBase< Container >::ResizeMode ResizeMode

struct

dai::CircleAnnotation

variable

Point2f position

variable

float diameter

variable

float thickness

variable

Color fillColor

variable

Color outlineColor

struct

dai::PointsAnnotation

variable

PointsAnnotationType type

variable

std::vector< Point2f > points

variable

Color outlineColor

variable

std::vector< Color > outlineColors

variable

Color fillColor

variable

float thickness

struct

dai::TextAnnotation

variable

Point2f position

variable

std::string text

variable

float fontSize

variable

Color textColor

variable

Color backgroundColor

struct

dai::ImgAnnotation

variable

std::vector< CircleAnnotation > circles

variable

std::vector< PointsAnnotation > points

variable

std::vector< TextAnnotation > texts

class

dai::ImgAnnotations

#include ImgAnnotations.hpp

variable

std::vector< ImgAnnotation > annotations

variable

std::optional< ImgTransformation > transformation

function

ImgAnnotations()

Construct ImgAnnotations message.

inline explicit function

ImgAnnotations(std::vector< ImgAnnotation > annotations)

function

~ImgAnnotations()

function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

inline function

DatatypeEnum getDatatype()

function

DEPTHAI_SERIALIZE(ImgAnnotations, Buffer::sequenceNum, Buffer::ts, Buffer::tsDevice, annotations, transformation)

struct

dai::ImgDetection

variable

uint32_t label

variable

std::string labelName

variable

float confidence

variable

float xmin

variable

float ymin

variable

float xmax

variable

float ymax

variable

std::optional< RotatedRect > boundingBox

variable

std::optional< KeypointsList > keypoints

function

ImgDetection()

function

ImgDetection(const RotatedRect & boundingBox, float confidence, uint32_t label)

function

ImgDetection(const RotatedRect & boundingBox, std::string labelName, float confidence, uint32_t label)

function

ImgDetection(const RotatedRect & boundingBox, const KeypointsList & keypoints, float confidence, uint32_t label)

function

 ImgDetection(const RotatedRect & boundingBox, const KeypointsList & keypoints, std::string labelName, float confidence, uint32_t label)

function

void setBoundingBox(RotatedRect boundingBox)

Sets the bounding box and the legacy coordinates of the detection.

function

RotatedRect getBoundingBox()

Returns bounding box if it was set, else it constructs a new one from the legacy xmin, ymin, xmax, ymax values.

function

void setOuterBoundingBox(const float xmin, const float ymin, const float xmax, const float ymax)

Sets the bounding box and the legacy coordinates of the detection from the top-left and bottom-right points.

function

std::array< float, 4 > getOuterBoundingBox()

Returns the outer bounding box as [minx, miny, maxx, maxy].

function

void setKeypoints(const KeypointsList keypoints)

Sets the keypoints of the detection.

Parameters

keypoints: list of Keypoint objects to set.

Parameters

This will clear any existing keypoints and edges.

function

void setKeypoints(const std::vector< Keypoint > keypoints)

Sets the keypoints of the detection.

Parameters

keypoints: list of Keypoint objects to set.

Parameters

This will clear any existing keypoints and edges.

function

void setKeypoints(const std::vector< Keypoint > keypoints, const std::vector< Edge > edges)

Sets the keypoints of the detection.

Parameters

keypoints: list of Point2f objects to set.

Parameters

This will clear any existing keypoints and edges.

function

void setKeypoints(const std::vector< Point3f > keypoints)

Sets the keypoints of the detection.

Parameters

keypoints: list of Point3f objects to set.

Parameters

This will clear any existing keypoints and edges.

function

void setKeypoints(const std::vector< Point2f > keypoints)

Sets the keypoints of the detection.

Parameters

keypoints: list of Point2f objects to set.

Parameters

This will clear any existing keypoints and edges.

function

std::vector< Keypoint > getKeypoints()

Returns a list of Keypoint objects, or empty list if no keypoints were set.

function

std::vector< Point2f > getKeypoints2f()

Returns a list of Point2f coordinates of the keypoints, or empty list if no keypoints were set.

function

std::vector< Point3f > getKeypoints3f()

Returns a list of Point3f coordinates of the keypoints, or empty list if no keypoints were set.

function

void setEdges(const std::vector< Edge > edges)

Sets edges for the keypoints, throws if no keypoints were set beforehand.

function

std::vector< Edge > getEdges()

Returns a list of edges, each edge is a pair of indices, or empty list if no keypoints were set.

function

float getCenterX()

Returns the X coordinate of the center of the bounding box.

function

float getCenterY()

Returns the Y coordinate of the center of the bounding box.

function

float getWidth()

Returns the width of the (rotated) bounding box.

function

float getHeight()

Returns the height of the (rotated) bounding box.

function

float getAngle()

Returns the angle of the bounding box.

function

DEPTHAI_SERIALIZE(ImgDetection, label, labelName, confidence, xmin, ymin, xmax, ymax, boundingBox, keypoints)

class

dai::ImgDetections

#include ImgDetections.hpp

variable

std::vector< DetectionT > detections

variable

size_t segmentationMaskHeight

variable

size_t segmentationMaskWidth

variable

std::optional< ImgTransformation > transformation

function

~ImgDetections()

function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

inline function

DatatypeEnum getDatatype()

function

 DEPTHAI_SERIALIZE(ImgDetections, Base::Buffer::sequenceNum, Base::Buffer::ts, Base::Buffer::tsDevice, detections, transformation, segmentationMaskWidth, segmentationMaskHeight)

enum

ImgDetectionsT< dai::ImgDetection > Base

class

dai::ImgDetectionsT

variable

std::vector< DetectionT > detections

variable

std::optional< ImgTransformation > transformation

function

ImgDetectionsT()

function

~ImgDetectionsT()

function

std::size_t getSegmentationMaskWidth()

Returns the width of the segmentation mask.

function

std::size_t getSegmentationMaskHeight()

Returns the height of the segmentation mask.

function

void setSegmentationMask(const std::vector< std::uint8_t > & mask, size_t width, size_t height)

Sets the segmentation mask from a vector of bytes. The size of the vector must be equal to width * height.

function

void setSegmentationMask(dai::ImgFrame & frame)

Sets the segmentation mask from an ImgFrame.

Parameters

frame: Frame must be of type GRAY8

function

std::optional< std::vector< std::uint8_t > > getMaskData()

Returns a copy of the segmentation mask data as a vector of bytes. If mask data is not set, returns std::nullopt.

function

std::optional< dai::ImgFrame > getSegmentationMask()

Returns the segmentation mask as an ImgFrame. If mask data is not set, returns std::nullopt.

function

void setCvSegmentationMask(cv::Mat mask)

Parameters

This API only available if OpenCV support is enabled Copies cv::Mat data to Segmentation Mask buffer

Parameters

frame: Input cv::Mat frame from which to copy the data

Parameters

Throws if mask is not a single channel INT8 type.

function

std::optional< cv::Mat > getCvSegmentationMask(cv::MatAllocator * allocator)

Retrieves mask data as a cv::Mat copy with specified width and height. If mask data is not set, returns std::nullopt.

Parameters

allocator: Allows callers to supply a custom cv::MatAllocator for zero-copy/custom memory management; nullptr uses OpenCV’s default.

function

std::optional< cv::Mat > getCvSegmentationMaskByIndex(uint8_t index, cv::MatAllocator * allocator)

Returns a binary mask where pixels belonging to the instance index are set to 1, others to 0. If mask data is not set, returns std::nullopt.

Parameters

index: Instance index
allocator: Allows callers to supply a custom cv::MatAllocator for zero-copy/custom memory management; nullptr uses OpenCV’s default.

function

std::optional< cv::Mat > getCvSegmentationMaskByClass(uint8_t semanticClass, cv::MatAllocator * allocator)

Retrieves data by the semantic class. If no mask data is not set, returns std::nullopt.

Parameters

semanticClass: Semantic class index
allocator: Allows callers to supply a custom cv::MatAllocator for zero-copy/custom memory management; nullptr uses OpenCV’s default.

class

dai::ImgFrame

#include ImgFrame.hpp

variable

Specs fb

variable

Specs sourceFb

variable

CameraSettings cam

variable

uint32_t category

variable

uint32_t instanceNum

variable

dai::FrameEvent event

variable

ImgTransformation transformation

function

ImgFrame()

Construct ImgFrame message. Timestamp is set to now

function

ImgFrame(long fd)

function

ImgFrame(size_t size)

function

ImgFrame(long fd, size_t size)

function

~ImgFrame()

function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

inline function

DatatypeEnum getDatatype()

function

std::chrono::time_point< std::chrono::steady_clock, std::chrono::steady_clock::duration > getTimestamp(CameraExposureOffset offset)

Retrieves image timestamp (at the specified offset of exposure) related to dai::Clock::now()

function

std::chrono::time_point< std::chrono::steady_clock, std::chrono::steady_clock::duration > getTimestampDevice(CameraExposureOffset offset)

Retrieves image timestamp (at the specified offset of exposure) directly captured from device's monotonic clock, not synchronized to host time. Used when monotonicity is required.

function

unsigned int getInstanceNum()

Retrieves instance number

function

unsigned int getCategory()

Retrieves image category

function

unsigned int getWidth()

Retrieves image width in pixels

function

unsigned int getStride()

Retrieves image line stride in bytes

function

unsigned int getPlaneStride(int planeIndex)

Retrieves image plane stride (offset to next plane) in bytes

Parameters

current: plane index, 0 or 1

function

unsigned int getHeight()

Retrieves image height in pixels

function

unsigned int getPlaneHeight()

Retrieves image plane height in lines

function

unsigned int getSourceWidth()

Retrieves source image width in pixels

function

unsigned int getSourceHeight()

Retrieves source image height in pixels

function

Type getType()

Retrieves image type

function

float getBytesPerPixel()

Retrieves image bytes per pixel

function

std::chrono::microseconds getExposureTime()

Retrieves exposure time

function

int getSensitivity()

Retrieves sensitivity, as an ISO value

function

int getColorTemperature()

Retrieves white-balance color temperature of the light source, in kelvins

function

int getLensPosition()

Retrieves lens position, range 0..255. Returns -1 if not available

function

float getLensPositionRaw()

Retrieves lens position, range 0.0f..1.0f. Returns -1 if not available

function

ImgTransformation & getTransformation()

Retrieves image transformation data

function

ImgFrame & setInstanceNum(unsigned int instance)

Instance number relates to the origin of the frame (which camera)

Parameters

instance: Instance number

function

ImgFrame & setCategory(unsigned int category)

Parameters

category: Image category

function

ImgFrame & setWidth(unsigned int width)

Specifies frame width

Parameters

width: frame width

function

ImgFrame & setStride(unsigned int stride)

Specifies frame stride

Parameters

stride: frame stride

function

ImgFrame & setHeight(unsigned int height)

Specifies frame height

Parameters

height: frame height

function

ImgFrame & setSize(unsigned int width, unsigned int height)

Specifies frame size

Parameters

height: frame height
width: frame width

function

ImgFrame & setSize(std::tuple< unsigned int, unsigned int > size)

Specifies frame size

Parameters

size: frame size

function

ImgFrame & setSourceSize(unsigned int width, unsigned int height)

Specifies source frame size

Parameters

height: frame height
width: frame width

function

ImgFrame & setSourceSize(std::tuple< unsigned int, unsigned int > size)

Specifies source frame size

Parameters

size: frame size

function

ImgFrame & setType(Type type)

Specifies frame type, RGB, BGR, ...

Parameters

type: Type of image

function

ImgFrame & setTransformation(const ImgTransformation & transformation)

Specifies image transformation data

Parameters

transformation: transformation data

function

Point2f remapPointFromSource(const Point2f & point)

Remap a point from the current frame to the source frame

Parameters

point: point to remap

Returns

remapped point

function

Point2f remapPointToSource(const Point2f & point)

Remap a point from the source frame to the current frame

Parameters

point: point to remap

Returns

remapped point

function

Rect remapRectFromSource(const Rect & rect)

Remap a rectangle from the source frame to the current frame

Parameters

rect: rectangle to remap

Returns

remapped rectangle

function

Rect remapRectToSource(const Rect & rect)

Remap a rectangle from the current frame to the source frame

Parameters

rect: rectangle to remap

Returns

remapped rectangle

function

ImgFrame & setMetadata(const ImgFrame & sourceFrame)

Convenience function to initialize meta data from another frame Copies over timestamps, transformations done on the image, etc.

Parameters

sourceFrame: source frame from which the metadata is taken from

function

ImgFrame & setMetadata(const std::shared_ptr< ImgFrame > & sourceFrame)

Convenience function to initialize meta data from another frame Copies over timestamps, transformations done on the image, etc.

Parameters

sourceFrame: shared pointer to source frame from which the metadata is taken from

function

ImgFrame & copyDataFrom(const ImgFrame & sourceFrame)

Convenience function to set the data of the ImgFrame

Parameters

data: data to set

function

ImgFrame & copyDataFrom(const std::shared_ptr< ImgFrame > & sourceFrame)

Convenience function to set the data of the ImgFrame

Parameters

data: data to set

function

std::shared_ptr< ImgFrame > clone()

Create a clone of the ImgFrame with metadata and data copied

Returns

cloned ImgFrame

function

float getSourceDFov()

Parameters

Fov API works correctly only on rectilinear frames Get the source diagonal field of view in degrees

Returns

field of view in degrees

function

float getSourceHFov()

Parameters

Fov API works correctly only on rectilinear frames Get the source horizontal field of view

Parameters

degrees: field of view in degrees

function

float getSourceVFov()

Parameters

Fov API works correctly only on rectilinear frames Get the source vertical field of view

Parameters

degrees: field of view in degrees

function

bool validateTransformations()

Check that the image transformation match the image size

Returns

true if the transformations are valid

function

ImgFrame & setFrame(cv::Mat frame)

Parameters

This API only available if OpenCV support is enabled

ImgFrame buffer

Parameters

frame: Input cv::Mat frame from which to copy the data

function

cv::Mat getFrame(bool copy)

Parameters

This API only available if OpenCV support is enabled

Parameters

copy: If false only a reference to data is made, otherwise a copy

Returns

cv::Mat with corresponding to ImgFrame parameters

function

cv::Mat getCvFrame(cv::MatAllocator * allocator)

Parameters

This API only available if OpenCV support is enabled

ImgFrame is converted to color BGR interleaved or grayscale depending on type.A copy is always made

Returns

cv::Mat for use in opencv functions

function

ImgFrame & setCvFrame(cv::Mat frame, Type type)

Parameters

This API only available if OpenCV support is enabled

ImgFrame buffer and converts to a specific type.

Parameters

frame: Input cv::Mat BGR frame or single channel frame from which to copy the data from.
type: Specifies the target image format for the internal buffer, including color space, layout, and bit depth.

function

 DEPTHAI_SERIALIZE(ImgFrame, Buffer::ts, Buffer::tsDevice, Buffer::sequenceNum, fb, sourceFb, cam, category, instanceNum, transformation)

function

std::chrono::time_point< std::chrono::steady_clock, std::chrono::steady_clock::duration > getTimestamp()

Retrieves timestamp related to dai::Clock::now()

function

std::chrono::time_point< std::chrono::steady_clock, std::chrono::steady_clock::duration > getTimestampDevice()

Retrieves timestamp directly captured from device's monotonic clock, not synchronized to host time. Used mostly for debugging

struct

dai::ImgFrame::CameraSettings

variable

int32_t exposureTimeUs

variable

int32_t sensitivityIso

variable

int32_t lensPosition

variable

int32_t wbColorTemp

variable

float lensPositionRaw

function

DEPTHAI_SERIALIZE(CameraSettings, exposureTimeUs, sensitivityIso, lensPosition, wbColorTemp, lensPositionRaw)

struct

dai::ImgFrame::Specs

variable

Type type

variable

unsigned int width

variable

unsigned int height

variable

unsigned int stride

variable

unsigned int bytesPP

variable

unsigned int p1Offset

variable

unsigned int p2Offset

variable

unsigned int p3Offset

function

DEPTHAI_SERIALIZE(Specs, type, width, height, stride, bytesPP, p1Offset, p2Offset, p3Offset)

enum

Type

enumerator

YUV422i

enumerator

YUV444p

enumerator

YUV420p

enumerator

YUV422p

enumerator

YUV400p

enumerator

RGBA8888

enumerator

RGB161616

enumerator

RGB888p

enumerator

BGR888p

enumerator

RGB888i

enumerator

BGR888i

enumerator

LUT2

enumerator

LUT4

enumerator

LUT16

enumerator

RAW16

enumerator

RAW14

enumerator

RAW12

enumerator

RAW10

enumerator

RAW8

enumerator

PACK10

enumerator

PACK12

enumerator

YUV444i

enumerator

NV12

enumerator

NV21

enumerator

BITSTREAM

enumerator

HDR

enumerator

RGBF16F16F16p

enumerator

BGRF16F16F16p

enumerator

RGBF16F16F16i

enumerator

BGRF16F16F16i

enumerator

GRAY8

enumerator

GRAYF16

enumerator

RAW32

enumerator

NONE

class

dai::MapData

#include MapData.hpp

variable

dai::ImgFrame map

variable

float minX

variable

float minY

function

MapData()

function

~MapData()

function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

function

DEPTHAI_SERIALIZE(MapData, Buffer::ts, Buffer::tsDevice, Buffer::sequenceNum, map, minX, minY)

class

dai::MessageGroup

#include MessageGroup.hpp

variable

std::map< std::string, std::shared_ptr< ADatatype > > group

function

~MessageGroup()

function

std::shared_ptr< ADatatype > operator[](const std::string & name)

inline function

std::shared_ptr< T > get(const std::string & name)

inline function

std::shared_ptr< ADatatype > get(const std::string & name)

function

void add(const std::string & name, const std::shared_ptr< ADatatype > & value)

function

std::map< std::string, std::shared_ptr< ADatatype > >::iterator begin()

function

std::map< std::string, std::shared_ptr< ADatatype > >::iterator end()

function

bool isSynced(int64_t thresholdNs)

True if all messages in the group are in the interval

Parameters

thresholdNs: Maximal interval between messages

function

int64_t getIntervalNs()

Retrieves interval between the first and the last message in the group.

function

int64_t getNumMessages()

function

std::vector< std::string > getMessageNames()

Gets the names of messages in the group

function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

inline function

DatatypeEnum getDatatype()

function

DEPTHAI_SERIALIZE(MessageGroup, group, Buffer::ts, Buffer::tsDevice, Buffer::sequenceNum)

class

dai::NNData

#include NNData.hpp

variable

std::vector< TensorInfo > tensors

variable

unsigned int batchSize

variable

std::optional< ImgTransformation > transformation

function

NNData()

Construct NNData message.

function

NNData(size_t size)

function

~NNData()

function

std::vector< std::string > getAllLayerNames()

Returns

Names of all layers added

function

std::vector< TensorInfo > getAllLayers()

Returns

All layers and their information

function

std::optional< TensorInfo > getTensorInfo(const std::string & name)

Retrieve tensor information

Parameters

name: Name of the tensor

Returns

Tensor information

function

bool getLayer(const std::string & name, TensorInfo & tensor)

Retrieve layers tensor information

Parameters

name: Name of the layer
tensor: Outputs tensor information of that layer

Returns

True if layer exists, false otherwise

function

bool hasLayer(const std::string & name)

Checks if given layer exists

Parameters

name: Name of the layer

Returns

True if layer exists, false otherwise

function

bool getLayerDatatype(const std::string & name, TensorInfo::DataType & datatype)

Retrieve datatype of a layers tensor

Parameters

name: Name of the layer
datatype: Datatype of layers tensor

Returns

True if layer exists, false otherwise

function

TensorInfo::DataType getTensorDatatype(const std::string & name)

Get the datatype of a given tensor

Returns

TensorInfo::DataType tensor datatype

function

TensorInfo::DataType getFirstTensorDatatype()

Get the datatype of the first tensor

Returns

TensorInfo::DataType tensor datatype

function

span< std::uint8_t > emplaceTensor(TensorInfo & tensor)

Emplace a tensor This function allocates memory for the tensor and return over the said memory. It is up to the caller to fill the memory out with meaningful data.

Returns

Span over the allocated memory

function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

inline function

DatatypeEnum getDatatype()

function

DEPTHAI_SERIALIZE(NNData, Buffer::sequenceNum, Buffer::ts, Buffer::tsDevice, tensors, batchSize, transformation)

class

dai::NeuralDepthConfig

#include NeuralDepthConfig.hpp

variable

AlgorithmControl algorithmControl

Controls the flow of stereo algorithm - left-right check, subpixel etc.

variable

PostProcessing postProcessing

Controls the postprocessing of disparity and/or depth map.

function

NeuralDepthConfig()

Construct NeuralDepthConfig message.

function

~NeuralDepthConfig()

function

NeuralDepthConfig & setConfidenceThreshold(uint8_t confThr)

Confidence threshold for disparity calculation

Parameters

confThr: Confidence threshold value 0..255

function

uint8_t getConfidenceThreshold()

Get confidence threshold for disparity calculation

function

NeuralDepthConfig & setEdgeThreshold(uint8_t edgeThr)

Set edge threshold for disparity calculation

Parameters

edgeThr: Edge threshold value 0..255

function

uint8_t getEdgeThreshold()

Get edge threshold for disparity calculation

function

NeuralDepthConfig & setDepthUnit(AlgorithmControl::DepthUnit depthUnit)

Set depth unit of depth map.

function

AlgorithmControl::DepthUnit getDepthUnit()

Get depth unit of depth map.

function

NeuralDepthConfig & setCustomDepthUnitMultiplier(float multiplier)

Set custom depth unit multiplier relative to 1 meter.

function

float getCustomDepthUnitMultiplier()

Get custom depth unit multiplier relative to 1 meter.

function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

function

DEPTHAI_SERIALIZE(NeuralDepthConfig, algorithmControl, postProcessing)

struct

dai::NeuralDepthConfig::AlgorithmControl

variable

DepthUnit depthUnit

Measurement unit for depth data. Depth data is integer value, multiple of depth unit.

variable

float customDepthUnitMultiplier

Custom depth unit multiplier, if custom depth unit is enabled, relative to 1 meter. A multiplier of 1000 effectively means depth unit in millimeter.

function

DEPTHAI_SERIALIZE(AlgorithmControl, depthUnit, customDepthUnitMultiplier)

enum

dai::DepthUnit DepthUnit

struct

dai::NeuralDepthConfig::PostProcessing

variable

uint8_t confidenceThreshold

Confidence threshold for disparity calculation, Confidences above this value will be considered valid. Valid range is [0,255].

variable

uint8_t edgeThreshold

Edge threshold for disparity calculation, Pixels with edge magnitude below this value will be considered invalid. Valid range is [0,255].

variable

TemporalFilter temporalFilter

Temporal filtering with optional persistence.

function

DEPTHAI_SERIALIZE(PostProcessing, confidenceThreshold, edgeThreshold, temporalFilter)

enum

filters::params::TemporalFilter TemporalFilter

class

dai::ObjectTrackerConfig

#include ObjectTrackerConfig.hpp

variable

std::vector< int32_t > trackletIdsToRemove

Tracklet IDs to remove from tracking. Tracklet will transition to REMOVED state.

function

ObjectTrackerConfig()

Construct ObjectTrackerConfig message.

function

~ObjectTrackerConfig()

function

ObjectTrackerConfig & forceRemoveID(int32_t id)

Force remove a tracklet with specified ID.

function

ObjectTrackerConfig & forceRemoveIDs(std::vector< int32_t > ids)

Force remove tracklets with specified IDs.

function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

inline function

DatatypeEnum getDatatype()

function

DEPTHAI_SERIALIZE(ObjectTrackerConfig, Buffer::sequenceNum, Buffer::ts, Buffer::tsDevice, trackletIdsToRemove)

class

dai::PipelineEvent

#include PipelineEvent.hpp

variable

int64_t nodeId

variable

Status status

variable

std::optional< uint32_t > queueSize

variable

Interval interval

variable

Type type

variable

std::string source

function

PipelineEvent()

function

~PipelineEvent()

inline function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

inline function

DatatypeEnum getDatatype()

function

 DEPTHAI_SERIALIZE(PipelineEvent, Buffer::ts, Buffer::tsDevice, Buffer::sequenceNum, nodeId, status, queueSize, interval, type, source)

enum

std::int32_t Type

enumerator

CUSTOM

enumerator

LOOP

enumerator

INPUT

enumerator

OUTPUT

enumerator

INPUT_BLOCK

enumerator

OUTPUT_BLOCK

enum

std::int32_t Interval

enumerator

NONE

enumerator

START

enumerator

END

enum

std::int32_t Status

enumerator

SUCCESS

enumerator

BLOCKED

enumerator

CANCELLED

class

dai::NodeEventAggregationConfig

variable

int64_t nodeId

variable

std::optional< std::vector< std::string > > inputs

variable

std::optional< std::vector< std::string > > outputs

variable

std::optional< std::vector< std::string > > others

variable

bool events

function

DEPTHAI_SERIALIZE(NodeEventAggregationConfig, nodeId, inputs, outputs, others, events)

class

dai::PipelineEventAggregationConfig

#include PipelineEventAggregationConfig.hpp

variable

std::vector< NodeEventAggregationConfig > nodes

variable

std::optional< uint32_t > repeatIntervalSeconds

function

PipelineEventAggregationConfig()

function

~PipelineEventAggregationConfig()

function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

inline function

DatatypeEnum getDatatype()

function

 DEPTHAI_SERIALIZE(PipelineEventAggregationConfig, Buffer::ts, Buffer::tsDevice, Buffer::sequenceNum, nodes, repeatIntervalSeconds)

class

dai::NodeState

variable

State state

variable

std::vector< DurationEvent > events

variable

std::unordered_map< std::string, OutputQueueState > outputStates

variable

std::unordered_map< std::string, InputQueueState > inputStates

variable

Timing inputsGetTiming

variable

Timing outputsSendTiming

variable

Timing mainLoopTiming

variable

std::unordered_map< std::string, Timing > otherTimings

function

 DEPTHAI_SERIALIZE(NodeState, state, events, outputStates, inputStates, inputsGetTiming, outputsSendTiming, mainLoopTiming, otherTimings)

struct

dai::NodeState::DurationEvent

variable

PipelineEvent startEvent

variable

uint64_t durationUs

function

DEPTHAI_SERIALIZE(DurationEvent, startEvent, durationUs)

struct

dai::NodeState::DurationStats

variable

uint64_t minMicros

variable

uint64_t maxMicros

variable

uint64_t averageMicrosRecent

variable

uint64_t stdDevMicrosRecent

variable

uint64_t minMicrosRecent

variable

uint64_t maxMicrosRecent

variable

uint64_t medianMicrosRecent

function

 DEPTHAI_SERIALIZE(DurationStats, minMicros, maxMicros, averageMicrosRecent, stdDevMicrosRecent, minMicrosRecent, maxMicrosRecent, medianMicrosRecent)

struct

dai::NodeState::InputQueueState

variable

enum dai::NodeState::InputQueueState::State state

variable

uint32_t numQueued

variable

Timing timing

variable

QueueStats queueStats

inline function

bool isValid()

function

DEPTHAI_SERIALIZE(InputQueueState, state, numQueued, timing, queueStats)

enum

std::int32_t State

enumerator

IDLE

enumerator

WAITING

enumerator

BLOCKED

struct

dai::NodeState::OutputQueueState

variable

enum dai::NodeState::OutputQueueState::State state

variable

Timing timing

inline function

bool isValid()

function

DEPTHAI_SERIALIZE(OutputQueueState, state, timing)

enum

std::int32_t State

enumerator

IDLE

enumerator

SENDING

struct

dai::NodeState::QueueStats

variable

uint32_t maxQueued

variable

uint32_t minQueuedRecent

variable

uint32_t maxQueuedRecent

variable

uint32_t medianQueuedRecent

function

DEPTHAI_SERIALIZE(QueueStats, maxQueued, minQueuedRecent, maxQueuedRecent, medianQueuedRecent)

struct

dai::NodeState::Timing

variable

float fps

variable

DurationStats durationStats

inline function

bool isValid()

function

DEPTHAI_SERIALIZE(Timing, fps, durationStats)

enum

std::int32_t State

enumerator

IDLE

enumerator

GETTING_INPUTS

enumerator

PROCESSING

enumerator

SENDING_OUTPUTS

class

dai::PipelineState

#include PipelineState.hpp

variable

std::unordered_map< int64_t, NodeState > nodeStates

variable

uint32_t configSequenceNum

function

PipelineState()

function

~PipelineState()

inline function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

inline function

DatatypeEnum getDatatype()

function

nlohmann::json toJson()

function

DEPTHAI_SERIALIZE(PipelineState, Buffer::ts, Buffer::tsDevice, Buffer::sequenceNum, nodeStates, configSequenceNum)

class

dai::PointCloudConfig

#include PointCloudConfig.hpp

function

PointCloudConfig()

Construct PointCloudConfig message.

function

~PointCloudConfig()

function

bool getSparse()

Retrieve sparse point cloud calculation status.

Returns

true if sparse point cloud calculation is enabled, false otherwise

function

std::array< std::array< float, 4 >, 4 > getTransformationMatrix()

Retrieve transformation matrix for point cloud calculation.

Returns

4x4 transformation matrix

function

PointCloudConfig & setSparse(bool enable)

Enable or disable sparse point cloud calculation.

Parameters

enable:

function

PointCloudConfig & setTransformationMatrix(const std::array< std::array< float, 4 >, 4 > & transformationMatrix)

Set 4x4 transformation matrix for point cloud calculation. Default is an identity matrix.

Parameters

transformationMatrix:

function

PointCloudConfig & setTransformationMatrix(const std::array< std::array< float, 3 >, 3 > & transformationMatrix)

Set 3x3 transformation matrix for point cloud calculation. Default is an identity matrix.

Parameters

transformationMatrix:

inline function

DatatypeEnum getDatatype()

function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

function

DEPTHAI_SERIALIZE(PointCloudConfig, Buffer::sequenceNum, Buffer::ts, Buffer::tsDevice, sparse, transformationMatrix)

class

dai::PointCloudData

#include PointCloudData.hpp

function

PointCloudData()

Construct PointCloudData message.

function

~PointCloudData()

function

std::vector< Point3f > getPoints()

function

std::vector< Point3fRGBA > getPointsRGB()

function

void setPoints(const std::vector< Point3f > & points)

function

void setPointsRGB(const std::vector< Point3fRGBA > & points)

function

unsigned int getInstanceNum()

Retrieves instance number

function

unsigned int getWidth()

Retrieves the height in pixels - in case of a sparse point cloud, this represents the hight of the frame which was used to generate the point cloud

function

unsigned int getHeight()

Retrieves the height in pixels - in case of a sparse point cloud, this represents the hight of the frame which was used to generate the point cloud

function

float getMinX()

Retrieves minimal x coordinate in depth units (millimeter by default)

function

float getMinY()

Retrieves minimal y coordinate in depth units (millimeter by default)

function

float getMinZ()

Retrieves minimal z coordinate in depth units (millimeter by default)

function

float getMaxX()

Retrieves maximal x coordinate in depth units (millimeter by default)

function

float getMaxY()

Retrieves maximal y coordinate in depth units (millimeter by default)

function

float getMaxZ()

Retrieves maximal z coordinate in depth units (millimeter by default)

function

bool isSparse()

Retrieves whether point cloud is sparse

function

bool isColor()

Retrieves whether point cloud is color

function

PointCloudData & setWidth(unsigned int width)

Specifies frame width

Parameters

width: frame width

function

PointCloudData & setHeight(unsigned int height)

Specifies frame height

Parameters

height: frame height

function

PointCloudData & setSize(unsigned int width, unsigned int height)

Specifies frame size

Parameters

height: frame height
width: frame width

function

PointCloudData & setSize(std::tuple< unsigned int, unsigned int > size)

Specifies frame size

Parameters

size: frame size

function

PointCloudData & setMinX(float val)

Specifies minimal x coordinate in depth units (millimeter by default)

Parameters

val: minimal x coordinate in depth units (millimeter by default)

function

PointCloudData & setMinY(float val)

Specifies minimal y coordinate in depth units (millimeter by default)

Parameters

val: minimal y coordinate in depth units (millimeter by default)

function

PointCloudData & setMinZ(float val)

Specifies minimal z coordinate in depth units (millimeter by default)

Parameters

val: minimal z coordinate in depth units (millimeter by default)

function

PointCloudData & setMaxX(float val)

Specifies maximal x coordinate in depth units (millimeter by default)

Parameters

val: maximal x coordinate in depth units (millimeter by default)

function

PointCloudData & setMaxY(float val)

Specifies maximal y coordinate in depth units (millimeter by default)

Parameters

val: maximal y coordinate in depth units (millimeter by default)

function

PointCloudData & setMaxZ(float val)

Specifies maximal z coordinate in depth units (millimeter by default)

Parameters

val: maximal z coordinate in depth units (millimeter by default)

function

PointCloudData & setSparse(bool val)

Specifies whether point cloud is sparse

Parameters

val: whether point cloud is sparse

function

PointCloudData & setColor(bool val)

Specifies whether point cloud is color

Parameters

val: whether point cloud is color

function

PointCloudData & setInstanceNum(unsigned int instanceNum)

Specifies instance number

Parameters

instanceNum: instance number

inline function

void getPclData()

inline function

void setPclData(T...)

function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

inline function

DatatypeEnum getDatatype()

function

 DEPTHAI_SERIALIZE(PointCloudData, width, height, minx, miny, minz, maxx, maxy, maxz, sparse, instanceNum, Buffer::ts, Buffer::tsDevice, Buffer::sequenceNum)

function

int64_t getSequenceNum()

Retrieves image sequence number

function

std::chrono::time_point< std::chrono::steady_clock, std::chrono::steady_clock::duration > getTimestamp()

Retrieves timestamp related to dai::Clock::now()

function

std::chrono::time_point< std::chrono::steady_clock, std::chrono::steady_clock::duration > getTimestampDevice()

Retrieves timestamp directly captured from device's monotonic clock, not synchronized to host time. Used mostly for debugging

struct

dai::PointCloudData::dependent_false

class

dai::RGBDData

#include RGBDData.hpp

function

RGBDData()

Construct RGBD message.

function

~RGBDData()

function

void setRGBFrame(const FrameVariant & frame)

function

void setDepthFrame(const FrameVariant & frame)

function

std::optional< FrameVariant > getRGBFrame()

function

std::optional< FrameVariant > getDepthFrame()

function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

inline function

DatatypeEnum getDatatype()

function

DEPTHAI_SERIALIZE(RGBDData, colorFrame, depthFrame, Buffer::ts, Buffer::tsDevice, Buffer::sequenceNum)

enum

std::variant< std::shared_ptr< ImgFrame >, std::shared_ptr< EncodedFrame > > FrameVariant

class

dai::SegmentationMask

#include SegmentationMask.hpp

variable

std::optional< ImgTransformation > transformation

function

SegmentationMask()

function

SegmentationMask(const std::vector< std::uint8_t > & data, size_t width, size_t height)

function

~SegmentationMask()

function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

inline function

DatatypeEnum getDatatype()

function

void setSize(size_t width, size_t height)

Sets the size of the segmentation mask.

Parameters

Use with caution as it sets the metadata of the mask without allocating or resizing the underlying data array.

function

std::size_t getWidth()

Returns the width of the segmentation mask.

function

std::size_t getHeight()

Returns the height of the segmentation mask.

function

void setMask(const std::vector< std::uint8_t > & mask, size_t width, size_t height)

Sets the segmentation mask from a vector of bytes. The size of the vector must be equal to width * height.

function

void setMask(dai::ImgFrame & frame)

Sets the segmentation mask from an ImgFrame.

Parameters

frame: Frame must be of type GRAY8

function

void setMask(span< const std::uint8_t > mask, size_t width, size_t height)

Sets the segmentation mask from a byte span without an extra temporary vector. The span size must be equal to width * height.

function

span< std::uint8_t > prepareMask(size_t width, size_t height)

Prepares internal storage for writing and returns a mutable view to it. The caller must fill exactly width * height bytes.

function

void setLabels(const std::vector< std::string > & labels)

Sets the class labels associated with the segmentation mask. The label at index

Parameters

labels: Vector of class labels

function

std::vector< std::uint8_t > getMaskData()

Returns a copy of the segmentation mask data as a vector of bytes. If mask data is not set, returns an empty vector.

function

dai::ImgFrame getFrame()

Returns the segmentation mask as an ImgFrame. If mask data is not set, returns an empty frame with only metadata set.

function

std::optional< uint32_t > getArea(uint8_t index)

Returns the area (number of pixels) of the specified instance/class index in the segmentation mask.

Parameters

index: Instance/Class index

Parameters

If index is not present in the mask, returns std::nullopt.

function

std::optional< dai::Point2f > getCentroid(uint8_t index)

Returns the normalized centroid (x,y) coordinates of the specified instance/class index in the segmentation mask.

Parameters

index: Instance/Class index

Parameters

If index is not present in the mask, returns std::nullopt.

function

std::vector< uint8_t > getUniqueIndices()

Returns a list of sorted unique indices present in the segmentation mask.

function

std::vector< std::string > getLabels()

Returns all class labels associated with the segmentation mask. If no labels are set, returns an empty vector.

function

std::vector< std::uint8_t > getMaskByIndex(uint8_t index)

Returns a binary mask where pixels belonging to the specified instance/class index are set to 1, others to 0. If mask data is not set, returns an empty vector.

function

std::vector< std::uint8_t > getMaskByLabel(const std::string & label)

Returns a binary mask where pixels belonging to the specified class label are set to 1, others to 0. If labels are not set or label not found, returns an empty vector.

function

bool hasValidMask()

Returns true if the mask data is not empty and has valid size (width * height).

function

void setCvMask(cv::Mat mask)

Parameters

This API only available if OpenCV support is enabled Copies cv::Mat data to Segmentation Mask buffer

Parameters

frame: Input cv::Mat frame from which to copy the data

Parameters

Throws if mask is not a single channel INT8 type.

function

cv::Mat getCvMask(cv::MatAllocator * allocator)

Retrieves mask data as a cv::Mat copy with specified width and height. If mask data is not set, returns an empty matrix.

Parameters

allocator: Allows callers to supply a custom cv::MatAllocator for zero-copy/custom memory management; nullptr uses OpenCV’s default.

function

cv::Mat getCvMaskByIndex(uint8_t index, cv::MatAllocator * allocator)

Returns a binary mask where pixels belonging to the instance index are set to 1, others to 0. If mask data is not set, returns an empty matrix.

Parameters

index: Instance index
allocator: Allows callers to supply a custom cv::MatAllocator for zero-copy/custom memory management; nullptr uses OpenCV’s default.

function

std::vector< std::vector< dai::Point2f > > getContour(uint8_t index)

Calls the opencv findContours function and filters the results based on the provided index. Returns filtered contour as a vector of vectors of non-normalized points. If mask data is not set, returns an empty vector.

Parameters

index: class index

function

std::vector< dai::RotatedRect > getBoundingBoxes(uint8_t index, bool calculateRotation)

Returns a bounding box for each continuous region with the specified index.

Parameters

index: class index
calculateRotation: If true, returns rotated bounding boxes, otherwise returns the outer, axis-aligned bounding boxes.

function

 DEPTHAI_SERIALIZE(SegmentationMask, Buffer::ts, Buffer::tsDevice, Buffer::sequenceNum, transformation, width, height, labels)

class

dai::SegmentationParserConfig

variable

float confidenceThreshold

variable

unsigned int stepSize

function

SegmentationParserConfig()

Construct SegmentationParserConfig message.

function

~SegmentationParserConfig()

function

void setConfidenceThreshold(float threshold)

Add a confidence threshold to the argmax operation over the segmentation tensor. Pixels with confidence values below this threshold will be assigned the background class (255).

Parameters

threshold: Confidence threshold for segmentation parsing

Parameters

Default is -1.0f, which means no thresholding is applied.

Parameters

Only applicable if output classes are not in a single layer (eg. classesInOneLayer = false).

function

float getConfidenceThreshold()

Get confidence threshold

function

void setStepSize(unsigned int stepSize)

Sets the step size for segmentation parsing. A step size of 1 means every pixel is processed, a step size of 2 means every second pixel is processed, and so on. This can be used to speed up processing at the cost of lower resolution masks.

Parameters

stepSize: Step size for segmentation parsing

function

unsigned int getStepSize()

Gets the step size for segmentation parsing.

function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

inline function

DatatypeEnum getDatatype()

function

DEPTHAI_SERIALIZE(SegmentationParserConfig, confidenceThreshold, stepSize)

struct

dai::SpatialImgDetection

#include SpatialImgDetections.hpp

variable

uint32_t label

variable

std::string labelName

variable

float confidence

variable

float xmin

variable

float ymin

variable

float xmax

variable

float ymax

variable

std::optional< RotatedRect > boundingBox

variable

std::optional< SpatialKeypointsList > keypoints

variable

Point3f spatialCoordinates

variable

SpatialLocationCalculatorConfigData boundingBoxMapping

function

SpatialImgDetection()

function

SpatialImgDetection(const RotatedRect & boundingBox, Point3f spatialCoordinates, float confidence, uint32_t label)

function

 SpatialImgDetection(const RotatedRect & boundingBox, Point3f spatialCoordinates, std::string labelName, float confidence, uint32_t label)

function

 SpatialImgDetection(const RotatedRect & boundingBox, Point3f spatialCoordinates, const SpatialKeypointsList & keypoints, float confidence, uint32_t label)

function

 SpatialImgDetection(const RotatedRect & boundingBox, Point3f spatialCoordinates, const SpatialKeypointsList & keypoints, std::string labelName, float confidence, uint32_t label)

function

void setBoundingBox(RotatedRect boundingBox)

Sets the bounding box and the legacy coordinates of the detection.

function

RotatedRect getBoundingBox()

Returns bounding box if it was set, else it constructs a new one from the legacy xmin, ymin, xmax, ymax values.

function

void setOuterBoundingBox(const float xmin, const float ymin, const float xmax, const float ymax)

Sets the bounding box and the legacy coordinates of the detection from the top-left and bottom-right points.

function

void setKeypoints(const SpatialKeypointsList keypoints)

Sets the keypoints of the detection.

Parameters

keypoints: list of Keypoint objects to set.

Parameters

This will clear any existing keypoints and edges.

function

void setKeypoints(const std::vector< SpatialKeypoint > keypoints)

Sets the keypoints of the detection.

Parameters

keypoints: list of Keypoint objects to set.

Parameters

This will clear any existing keypoints and edges.

function

void setKeypoints(const std::vector< SpatialKeypoint > keypoints, const std::vector< Edge > edges)

Sets the keypoints of the detection.

Parameters

keypoints: list of Point2f objects to set.

Parameters

This will clear any existing keypoints and edges.

function

void setKeypoints(const std::vector< Point3f > keypoints)

Sets the keypoints of the detection.

Parameters

keypoints: list of Point3f objects to set.

Parameters

This will clear any existing keypoints and edges.

function

void setSpatialCoordinate(const Point3f spatialCoordinates)

Sets spatial coordinates for the detection.

Parameters

spatialCoordinates: list of Point3f objects to set.

Parameters

The size of spatialCoordinates.

function

void setEdges(const std::vector< Edge > edges)

Sets edges for the keypoints, throws if no keypoints were set beforehand.

function

dai::ImgDetection getImgDetection()

Converts SpatialImgDetection to ImgDetection by dropping spatial data.

Returns

dai::ImgDetection object.

function

std::vector< SpatialKeypoint > getKeypoints()

Returns a list of Keypoint objects, or empty list if no keypoints were set.

function

std::vector< dai::Point3f > getKeypointSpatialCoordinates()

Returns a list of spatial coordinates for each keypoint, or empty list if no keypoints were set.

function

std::vector< Edge > getEdges()

Returns a list of edges, each edge is a pair of indices, or empty list if no keypoints were set.

function

float getCenterX()

Returns the X coordinate of the center of the bounding box.

function

float getCenterY()

Returns the Y coordinate of the center of the bounding box.

function

float getWidth()

Returns the width of the (rotated) bounding box.

function

float getHeight()

Returns the height of the (rotated) bounding box.

function

float getAngle()

Returns the angle of the bounding box.

function

 DEPTHAI_SERIALIZE(SpatialImgDetection, label, labelName, confidence, xmin, ymin, xmax, ymax, boundingBox, keypoints, spatialCoordinates, boundingBoxMapping)

class

dai::SpatialImgDetections

#include SpatialImgDetections.hpp

function

~SpatialImgDetections()

function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

inline function

DatatypeEnum getDatatype()

function

 DEPTHAI_SERIALIZE(SpatialImgDetections, Base::Buffer::sequenceNum, Base::Buffer::ts, Base::Buffer::tsDevice, detections, transformation, segmentationMaskWidth, segmentationMaskHeight)

enum

ImgDetectionsT< SpatialImgDetection > Base

struct

dai::SpatialLocationCalculatorConfigThresholds

#include SpatialLocationCalculatorConfig.hpp

variable

uint32_t lowerThreshold

Values less or equal than this threshold are not taken into calculation.

variable

uint32_t upperThreshold

Values greater or equal than this threshold are not taken into calculation.

struct

dai::SpatialLocationCalculatorConfigData

#include SpatialLocationCalculatorConfig.hpp

variable

Rect roi

Region of interest for spatial location calculation.

variable

SpatialLocationCalculatorConfigThresholds depthThresholds

Upper and lower thresholds for depth values to take into consideration.

variable

SpatialLocationCalculatorAlgorithm calculationAlgorithm

Calculation method used to obtain spatial locations Average/mean: the average of ROI is used for calculation. Min: the minimum value inside ROI is used for calculation. Max: the maximum value inside ROI is used for calculation. Mode: the most frequent value inside ROI is used for calculation. Median: the median value inside ROI is used for calculation. Default: median.

variable

std::int32_t stepSize

Step size for calculation. Step size 1 means that every pixel is taken into calculation, size 2 means every second etc. Default value AUTO: for AVERAGE, MIN, MAX step size is 1; for MODE/MEDIAN it's 2.

class

dai::SpatialLocationCalculatorConfig

#include SpatialLocationCalculatorConfig.hpp

variable

int32_t globalStepSize

variable

uint32_t globalLowerThreshold

variable

uint32_t globalUpperThreshold

variable

SpatialLocationCalculatorAlgorithm globalCalculationAlgorithm

variable

int32_t globalKeypointRadius

variable

bool calculateSpatialKeypoints

variable

bool useSegmentation

variable

bool segmentationPassthrough

variable

float bBoxScaleFactor

variable

std::vector< SpatialLocationCalculatorConfigData > config

function

SpatialLocationCalculatorConfig()

Construct SpatialLocationCalculatorConfig message.

function

~SpatialLocationCalculatorConfig()

function

void setROIs(std::vector< SpatialLocationCalculatorConfigData > ROIs)

Specify additional regions of interest (ROI) to calculate their spatial coordinates. Results of ROI coordinates are available on SpatialLocationCalculatorData output.

Parameters

ROIs: Vector of configuration parameters for ROIs (region of interests)

function

void addROI(SpatialLocationCalculatorConfigData & ROI)

Add a new region of interest (ROI) to configuration data.

Parameters

roi: Configuration parameters for ROI

function

void setDepthThresholds(uint32_t lowerThreshold, uint32_t upperThreshold)

Set the lower and upper depth value thresholds to be used in the spatial calculations.

Parameters

lowerThreshold: Lower threshold in depth units (millimeter by default).
upperThreshold: Upper threshold in depth units (millimeter by default).

function

void setCalculationAlgorithm(SpatialLocationCalculatorAlgorithm calculationAlgorithm)

Set spatial location calculation algorithm. Possible values:

MEDIAN: Median of all depth values in the ROI
AVERAGE: Average of all depth values in the ROI
MIN: Minimum depth value in the ROI
MAX: Maximum depth value in the ROI
MODE: Most frequent depth value in the ROI

function

void setStepSize(int32_t stepSize)

Set step size for spatial location calculation. Step size 1 means that every pixel is taken into calculation, size 2 means every second etc. for AVERAGE, MIN, MAX step size is 1; for MODE/MEDIAN it's 2.

function

void setKeypointRadius(int32_t radius)

Set radius around keypoints to calculate spatial coordinates.

Parameters

radius: Radius in pixels.

Parameters

Only applicable to Keypoints or ImgDetections with keypoints.

function

void setCalculateSpatialKeypoints(bool calculateSpatialKeypoints)

If false, spatial coordinates of keypoints will not be calculated.

Parameters

calculateSpatialKeypoints:

Parameters

Only applicable to ImgDetections with keypoints.

function

void setUseSegmentation(bool useSegmentation)

Specify whether to consider only segmented pixels within a detection bounding box for spatial calculations.

Parameters

useSegmentation:

Parameters

Only applicable to ImgDetections with segmentation masks.

function

void setSegmentationPassthrough(bool passthroughSegmentation)

Specify whether to passthrough segmentation mask along with spatial detections.

Parameters

passthroughSegmentation:

Parameters

Only applicable to ImgDetections with segmentation masks.

function

void setBoundingBoxScaleFactor(float scaleFactor)

Set scale factor for bounding boxes used in spatial calculations.

Parameters

scaleFactor: Scale factor must be in the interval (0,1].

function

std::vector< SpatialLocationCalculatorConfigData > getConfigData()

Retrieve configuration data for SpatialLocationCalculator

Returns

Vector of configuration parameters for ROIs (region of interests)

function

std::pair< int32_t, int32_t > getDepthThresholds()

function

SpatialLocationCalculatorAlgorithm getCalculationAlgorithm()

function

int32_t getStepSize()

function

int32_t getKeypointRadius()

Retrieve radius around keypoints used to calculate spatial coordinates.

function

bool getCalculateSpatialKeypoints()

Retrieve whether keypoints are used for spatial location calculation.

Parameters

Only applicable to ImgDetections with keypoints.

function

bool getUseSegmentation()

Retrieve whether segmentation is used for spatial location calculation.

Parameters

Only applicable to ImgDetections with segmentation masks.

function

bool getSegmentationPassthrough()

Retrieve whether segmentation is passed through along with spatial detections.

Parameters

Only applicable to ImgDetections with segmentation masks.

function

float getBoundingBoxScaleFactor()

Retrieve scale factor for bounding boxes used in spatial calculations.

function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

inline function

DatatypeEnum getDatatype()

function

 DEPTHAI_SERIALIZE(SpatialLocationCalculatorConfig, globalStepSize, globalLowerThreshold, globalUpperThreshold, globalCalculationAlgorithm, globalKeypointRadius, calculateSpatialKeypoints, useSegmentation, segmentationPassthrough, bBoxScaleFactor, config)

struct

dai::SpatialLocations

#include SpatialLocationCalculatorData.hpp

variable

SpatialLocationCalculatorConfigData config

Configuration for selected ROI

variable

float depthAverage

Average of depth values inside the ROI between the specified thresholds in config. Calculated only if calculation method is set to AVERAGE or MIN oR MAX.

variable

float depthMode

Most frequent of depth values inside the ROI between the specified thresholds in config. Calculated only if calculation method is set to MODE.

variable

float depthMedian

Median of depth values inside the ROI between the specified thresholds in config. Calculated only if calculation method is set to MEDIAN.

variable

std::uint16_t depthMin

Minimum of depth values inside the ROI between the specified thresholds in config. Calculated only if calculation method is set to AVERAGE or MIN oR MAX.

variable

std::uint16_t depthMax

Maximum of depth values inside the ROI between the specified thresholds in config. Calculated only if calculation method is set to AVERAGE or MIN oR MAX.

variable

std::uint32_t depthAveragePixelCount

Number of depth values used in calculations.

variable

Point3f spatialCoordinates

Spatial coordinates - x,y,z; x,y are the relative positions of the center of ROI to the center of depth map

class

dai::SpatialLocationCalculatorData

#include SpatialLocationCalculatorData.hpp

variable

std::vector< SpatialLocations > spatialLocations

function

SpatialLocationCalculatorData()

Construct SpatialLocationCalculatorData message.

function

~SpatialLocationCalculatorData()

function

std::vector< SpatialLocations > getSpatialLocations()

Retrieve configuration data for SpatialLocationCalculatorData.

Returns

Vector of spatial location data, carrying spatial information (X,Y,Z)

function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

inline function

DatatypeEnum getDatatype()

function

DEPTHAI_SERIALIZE(SpatialLocationCalculatorData, Buffer::sequenceNum, Buffer::ts, Buffer::tsDevice, spatialLocations)

class

dai::StereoDepthConfig

#include StereoDepthConfig.hpp

variable

AlgorithmControl algorithmControl

Controls the flow of stereo algorithm - left-right check, subpixel etc.

variable

PostProcessing postProcessing

Controls the postprocessing of disparity and/or depth map.

variable

CensusTransform censusTransform

Census transform settings.

variable

CostMatching costMatching

Cost matching settings.

variable

CostAggregation costAggregation

Cost aggregation settings.

variable

ConfidenceMetrics confidenceMetrics

Confidence metrics settings.

variable

dai::ProcessorType filtersBackend

function

StereoDepthConfig()

Construct StereoDepthConfig message.

function

~StereoDepthConfig()

function

StereoDepthConfig & setDepthAlign(AlgorithmControl::DepthAlign align)

Parameters

align: Set the disparity/depth alignment: centered (between the 'left' and 'right' inputs), or from the perspective of a rectified output stream

function

StereoDepthConfig & setConfidenceThreshold(int confThr)

Confidence threshold for disparity calculation

Parameters

confThr: Confidence threshold value 0..255

function

int getConfidenceThreshold()

Get confidence threshold for disparity calculation

function

StereoDepthConfig & setMedianFilter(MedianFilter median)

Parameters

median: Set kernel size for disparity/depth median filtering, or disable

function

MedianFilter getMedianFilter()

Get median filter setting

function

StereoDepthConfig & setBilateralFilterSigma(uint16_t sigma)

A larger value of the parameter means that farther colors within the pixel neighborhood will be mixed together, resulting in larger areas of semi-equal color.

Parameters

sigma: Set sigma value for 5x5 bilateral filter. 0..65535

function

uint16_t getBilateralFilterSigma()

Get sigma value for 5x5 bilateral filter

function

StereoDepthConfig & setLeftRightCheckThreshold(int threshold)

Parameters

threshold: Set threshold for left-right, right-left disparity map combine, 0..255

function

int getLeftRightCheckThreshold()

Get threshold for left-right check combine

function

StereoDepthConfig & setLeftRightCheck(bool enable)

Computes and combines disparities in both L-R and R-L directions, and combine them.For better occlusion handling, discarding invalid disparity values

function

bool getLeftRightCheck()

Get left-right check setting

function

StereoDepthConfig & setExtendedDisparity(bool enable)

Disparity range increased from 95 to 190, combined from full resolution and downscaled images. Suitable for short range objects

function

bool getExtendedDisparity()

Get extended disparity setting

function

StereoDepthConfig & setSubpixel(bool enable)

Computes disparity with sub-pixel interpolation (3 fractional bits by default).Suitable for long range. Currently incompatible with extended disparity

function

bool getSubpixel()

Get subpixel setting

function

StereoDepthConfig & setSubpixelFractionalBits(int subpixelFractionalBits)

Number of fractional bits for subpixel mode. Default value: 3. Valid values: 3,4,5. Defines the number of fractional disparities: 2^x. Median filter postprocessing is supported only for 3 fractional bits.

function

int getSubpixelFractionalBits()

Get number of fractional bits for subpixel mode

function

StereoDepthConfig & setDepthUnit(AlgorithmControl::DepthUnit depthUnit)

Set depth unit of depth map.Meter, centimeter, millimeter, inch, foot or custom unit is available.

function

AlgorithmControl::DepthUnit getDepthUnit()

Get depth unit of depth map.

function

StereoDepthConfig & setCustomDepthUnitMultiplier(float multiplier)

Set custom depth unit multiplier relative to 1 meter.

function

float getCustomDepthUnitMultiplier()

Get custom depth unit multiplier relative to 1 meter.

function

StereoDepthConfig & setDisparityShift(int disparityShift)

Shift input frame by a number of pixels to increase minimum depth. For example shifting by 48 will change effective disparity search range from (0,95] to [48,143]. An alternative approach to reducing the minZ. We normally only recommend doing this when it is known that there will be no objects farther away than MaxZ, such as having a depth camera mounted above a table pointing down at the table surface.

function

StereoDepthConfig & setNumInvalidateEdgePixels(int32_t numInvalidateEdgePixels)

Invalidate X amount of pixels at the edge of disparity frame. For right and center alignment X pixels will be invalidated from the right edge, for left alignment from the left edge.

function

StereoDepthConfig & setFiltersComputeBackend(dai::ProcessorType filtersBackend)

Set filters compute backend

function

dai::ProcessorType getFiltersComputeBackend()

Get filters compute backend

function

float getMaxDisparity()

Useful for normalization of the disparity map.

Returns

Maximum disparity value that the node can return

function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

inline function

DatatypeEnum getDatatype()

function

 DEPTHAI_SERIALIZE(StereoDepthConfig, algorithmControl, postProcessing, censusTransform, costMatching, costAggregation, confidenceMetrics, filtersBackend)

struct

dai::StereoDepthConfig::AlgorithmControl

variable

DepthAlign depthAlign

Set the disparity/depth alignment to the perspective of a rectified output, or center it

variable

DepthUnit depthUnit

Measurement unit for depth data. Depth data is integer value, multiple of depth unit.

variable

float customDepthUnitMultiplier

Custom depth unit multiplier, if custom depth unit is enabled, relative to 1 meter. A multiplier of 1000 effectively means depth unit in millimeter.

variable

bool enableLeftRightCheck

Computes and combines disparities in both L-R and R-L directions, and combine them. For better occlusion handling

variable

bool enableSwLeftRightCheck

Enables software left right check. Applicable to RVC4 only.

variable

bool enableExtended

Disparity range increased from 95 to 190, combined from full resolution and downscaled images. Suitable for short range objects

variable

bool enableSubpixel

Computes disparity with sub-pixel interpolation (5 fractional bits), suitable for long range

variable

std::int32_t leftRightCheckThreshold

Left-right check threshold for left-right, right-left disparity map combine, 0..128 Used only when left-right check mode is enabled. Defines the maximum difference between the confidence of pixels from left-right and right-left confidence maps

variable

std::int32_t subpixelFractionalBits

Number of fractional bits for subpixel modeValid values: 3,4,5Defines the number of fractional disparities: 2^xMedian filter postprocessing is supported only for 3 fractional bits

variable

std::int32_t disparityShift

variable

std::optional< float > centerAlignmentShiftFactor

variable

std::int32_t numInvalidateEdgePixels

Invalidate X amount of pixels at the edge of disparity frame. For right and center alignment X pixels will be invalidated from the right edge, for left alignment from the left edge.

function

 DEPTHAI_SERIALIZE(AlgorithmControl, depthAlign, depthUnit, customDepthUnitMultiplier, enableLeftRightCheck, enableSwLeftRightCheck, enableExtended, enableSubpixel, leftRightCheckThreshold, subpixelFractionalBits, disparityShift, centerAlignmentShiftFactor, numInvalidateEdgePixels)

enum

int32_t DepthAlign

Align the disparity/depth to the perspective of a rectified output, or center it

enumerator

RECTIFIED_RIGHT

enumerator

RECTIFIED_LEFT

enumerator

CENTER

enum

dai::DepthUnit DepthUnit

struct

dai::StereoDepthConfig::CensusTransform

#include StereoDepthConfig.hpp

variable

KernelSize kernelSize

Census transform kernel size.

variable

uint64_t kernelMask

Census transform mask, default - auto, mask is set based on resolution and kernel size. Disabled for 400p input resolution. Enabled for 720p. 0XA82415 for 5x5 census transform kernel. 0XAA02A8154055 for 7x7 census transform kernel. 0X2AA00AA805540155 for 7x9 census transform kernel. Empirical values.

variable

bool enableMeanMode

If enabled, each pixel in the window is compared with the mean window value instead of the central pixel.

variable

uint32_t threshold

Census transform comparison threshold value.

variable

int8_t noiseThresholdOffset

Used to reduce small fixed levels of noise across all luminance values in the current image. Valid range is [0,127]. Default value is 0.

variable

int8_t noiseThresholdScale

Used to reduce noise values that increase with luminance in the current image. Valid range is [-128,127]. Default value is 0.

function

 DEPTHAI_SERIALIZE(CensusTransform, kernelSize, kernelMask, enableMeanMode, threshold, noiseThresholdOffset, noiseThresholdScale)

enum

std::int32_t KernelSize

Census transform kernel size possible values.

enumerator

AUTO

enumerator

KERNEL_5x5

enumerator

KERNEL_7x7

enumerator

KERNEL_7x9

struct

dai::StereoDepthConfig::ConfidenceMetrics

variable

uint8_t occlusionConfidenceWeight

Weight used with occlusion estimation to generate final confidence map. Valid range is [0,32]

variable

uint8_t motionVectorConfidenceWeight

Weight used with local neighborhood motion vector variance estimation to generate final confidence map. Valid range is [0,32].

variable

uint8_t motionVectorConfidenceThreshold

Threshold offset for MV variance in confidence generation. A value of 0 allows most variance. Valid range is [0,3].

variable

uint8_t flatnessConfidenceWeight

Weight used with flatness estimation to generate final confidence map. Valid range is [0,32].

variable

uint8_t flatnessConfidenceThreshold

Threshold for flatness check in SGM block. Valid range is [1,7].

variable

bool flatnessOverride

Flag to indicate whether final confidence value will be overidden by flatness value. Valid range is {true,false}.

function

 DEPTHAI_SERIALIZE(ConfidenceMetrics, occlusionConfidenceWeight, motionVectorConfidenceWeight, motionVectorConfidenceThreshold, flatnessConfidenceWeight, flatnessConfidenceThreshold, flatnessOverride)

struct

dai::StereoDepthConfig::CostAggregation

#include StereoDepthConfig.hpp

variable

uint8_t divisionFactor

Cost calculation linear equation parameters.

variable

uint16_t horizontalPenaltyCostP1

Horizontal P1 penalty cost parameter.

variable

uint16_t horizontalPenaltyCostP2

Horizontal P2 penalty cost parameter.

variable

uint16_t verticalPenaltyCostP1

Vertical P1 penalty cost parameter.

variable

uint16_t verticalPenaltyCostP2

Vertical P2 penalty cost parameter.

variable

P1Config p1Config

variable

P2Config p2Config

function

 DEPTHAI_SERIALIZE(CostAggregation, divisionFactor, horizontalPenaltyCostP1, horizontalPenaltyCostP2, verticalPenaltyCostP1, verticalPenaltyCostP2, p1Config, p2Config)

struct

dai::StereoDepthConfig::CostAggregation::P1Config

#include StereoDepthConfig.hpp

variable

bool enableAdaptive

Used to disable/enable adaptive penalty.

variable

uint8_t defaultValue

Used as the default penalty value when nAdapEnable is disabled. A bigger value enforces higher smoothness and reduced noise at the cost of lower edge accuracy. This value must be smaller than P2 default penalty. Valid range is [10,50].

variable

uint8_t edgeValue

Penalty value on edges when nAdapEnable is enabled. A smaller penalty value permits higher change in disparity. This value must be smaller than or equal to P2 edge penalty. Valid range is [10,50].

variable

uint8_t smoothValue

Penalty value on low texture regions when nAdapEnable is enabled. A smaller penalty value permits higher change in disparity. This value must be smaller than or equal to P2 smoothness penalty. Valid range is [10,50].

variable

uint8_t edgeThreshold

Threshold value on edges when nAdapEnable is enabled. A bigger value permits higher neighboring feature dissimilarity tolerance. This value is shared with P2 penalty configuration. Valid range is [8,16].

variable

uint8_t smoothThreshold

Threshold value on low texture regions when nAdapEnable is enabled. A bigger value permits higher neighboring feature dissimilarity tolerance. This value is shared with P2 penalty configuration. Valid range is [2,12].

function

DEPTHAI_SERIALIZE(P1Config, enableAdaptive, defaultValue, edgeValue, smoothValue, edgeThreshold, smoothThreshold)

struct

dai::StereoDepthConfig::CostAggregation::P2Config

#include StereoDepthConfig.hpp

variable

bool enableAdaptive

Used to disable/enable adaptive penalty.

variable

uint8_t defaultValue

Used as the default penalty value when nAdapEnable is disabled. A bigger value enforces higher smoothness and reduced noise at the cost of lower edge accuracy. This value must be larger than P1 default penalty. Valid range is [20,100].

variable

uint8_t edgeValue

Penalty value on edges when nAdapEnable is enabled. A smaller penalty value permits higher change in disparity. This value must be larger than or equal to P1 edge penalty. Valid range is [20,100].

variable

uint8_t smoothValue

Penalty value on low texture regions when nAdapEnable is enabled. A smaller penalty value permits higher change in disparity. This value must be larger than or equal to P1 smoothness penalty. Valid range is [20,100].

function

DEPTHAI_SERIALIZE(P2Config, enableAdaptive, defaultValue, edgeValue, smoothValue)

struct

dai::StereoDepthConfig::CostMatching

#include StereoDepthConfig.hpp

variable

DisparityWidth disparityWidth

Disparity search range, default 96 pixels.

variable

bool enableCompanding

Disparity companding using sparse matching. Matching pixel by pixel for N disparities. Matching every 2nd pixel for M disparitites. Matching every 4th pixel for T disparities. In case of 96 disparities: N=48, M=32, T=16. This way the search range is extended to 176 disparities, by sparse matching. Note: when enabling this flag only depth map will be affected, disparity map is not.

variable

uint8_t invalidDisparityValue

Used only for debug purposes, SW postprocessing handled only invalid value of 0 properly.

variable

uint8_t confidenceThreshold

Disparities with confidence value over this threshold are accepted.

variable

bool enableSwConfidenceThresholding

Enable software confidence thresholding. Applicable to RVC4 only.

variable

LinearEquationParameters linearEquationParameters

Cost calculation linear equation parameters.

function

 DEPTHAI_SERIALIZE(CostMatching, disparityWidth, enableCompanding, invalidDisparityValue, confidenceThreshold, enableSwConfidenceThresholding, linearEquationParameters)

struct

dai::StereoDepthConfig::CostMatching::LinearEquationParameters

#include StereoDepthConfig.hpp

variable

uint8_t alpha

variable

uint8_t beta

variable

uint8_t threshold

function

DEPTHAI_SERIALIZE(LinearEquationParameters, alpha, beta, threshold)

enum

std::uint32_t DisparityWidth

Disparity search range: 64 or 96 pixels are supported by the HW.

enumerator

DISPARITY_64

enumerator

DISPARITY_96

struct

dai::StereoDepthConfig::PostProcessing

#include StereoDepthConfig.hpp

variable

std::array< Filter, 5 > filteringOrder

Order of filters to be applied if filtering is enabled.

variable

MedianFilter median

Set kernel size for disparity/depth median filtering, or disable

variable

std::int16_t bilateralSigmaValue

Sigma value for bilateral filter. 0 means disabled. A larger value of the parameter means that farther colors within the pixel neighborhood will be mixed together.

variable

SpatialFilter spatialFilter

Edge-preserving filtering: This type of filter will smooth the depth noise while attempting to preserve edges.

variable

TemporalFilter temporalFilter

Temporal filtering with optional persistence.

variable

ThresholdFilter thresholdFilter

Threshold filtering. Filters out distances outside of a given interval.

variable

BrightnessFilter brightnessFilter

Brightness filtering. If input frame pixel is too dark or too bright, disparity will be invalidated. The idea is that for too dark/too bright pixels we have low confidence, since that area was under/over exposed and details were lost.

variable

SpeckleFilter speckleFilter

Speckle filtering. Removes speckle noise.

variable

DecimationFilter decimationFilter

Decimation filter. Reduces disparity/depth map x/y complexity, reducing runtime complexity for other filters.

variable

HoleFilling holeFilling

variable

AdaptiveMedianFilter adaptiveMedianFilter

function

 DEPTHAI_SERIALIZE(PostProcessing, filteringOrder, median, bilateralSigmaValue, spatialFilter, temporalFilter, thresholdFilter, brightnessFilter, speckleFilter, decimationFilter, holeFilling, adaptiveMedianFilter)

struct

dai::StereoDepthConfig::PostProcessing::AdaptiveMedianFilter

variable

bool enable

Flag to enable adaptive median filtering for a final pass of filtering on low confidence pixels.

variable

uint8_t confidenceThreshold

Confidence threshold for adaptive median filtering. Should be less than nFillConfThresh value used in evaDfsHoleFillConfig. Valid range is [0,255].

function

DEPTHAI_SERIALIZE(AdaptiveMedianFilter, enable, confidenceThreshold)

struct

dai::StereoDepthConfig::PostProcessing::BrightnessFilter

#include StereoDepthConfig.hpp

variable

std::int32_t minBrightness

Minimum pixel brightness. If input pixel is less or equal than this value the depth value is invalidated.

variable

std::int32_t maxBrightness

Maximum range in depth units. If input pixel is less or equal than this value the depth value is invalidated.

function

DEPTHAI_SERIALIZE(BrightnessFilter, minBrightness, maxBrightness)

struct

dai::StereoDepthConfig::PostProcessing::DecimationFilter

#include StereoDepthConfig.hpp

variable

std::uint32_t decimationFactor

Decimation factor. Valid values are 1,2,3,4. Disparity/depth map x/y resolution will be decimated with this value.

variable

DecimationMode decimationMode

Decimation algorithm type.

function

DEPTHAI_SERIALIZE(DecimationFilter, decimationFactor, decimationMode)

enum

int32_t DecimationMode

Decimation algorithm type.

enumerator

PIXEL_SKIPPING

enumerator

NON_ZERO_MEDIAN

enumerator

NON_ZERO_MEAN

struct

dai::StereoDepthConfig::PostProcessing::HoleFilling

variable

bool enable

Flag to enable post-processing hole-filling.

variable

uint8_t highConfidenceThreshold

Pixels with confidence higher than this value are used to calculate an average disparity per superpixel. Valid range is [1,255]

variable

uint8_t fillConfidenceThreshold

Pixels with confidence below this value will be filled with the average disparity of their corresponding superpixel. Valid range is [1,255].

variable

uint8_t minValidDisparity

Represents the required percentange of pixels with confidence value above nHighConfThresh that are used to calculate average disparity per superpixel, where 1 means 50% or half, 2 means 25% or a quarter and 3 means 12.5% or an eighth. If the required number of pixels are not found, the holes will not be filled.

variable

bool invalidateDisparities

If enabled, sets to 0 the disparity of pixels with confidence below nFillConfThresh, which did not pass nMinValidPixels criteria. Valid range is {true, false}.

function

 DEPTHAI_SERIALIZE(HoleFilling, enable, highConfidenceThreshold, fillConfidenceThreshold, minValidDisparity, invalidateDisparities)

struct

dai::StereoDepthConfig::PostProcessing::ThresholdFilter

#include StereoDepthConfig.hpp

variable

std::int32_t minRange

Minimum range in depth units. Depth values under this value are invalidated.

variable

std::int32_t maxRange

Maximum range in depth units. Depth values over this value are invalidated.

function

DEPTHAI_SERIALIZE(ThresholdFilter, minRange, maxRange)

enum

int32_t Filter

enumerator

NONE

enumerator

DECIMATION

enumerator

SPECKLE

enumerator

MEDIAN

enumerator

SPATIAL

enumerator

TEMPORAL

enumerator

FILTER_COUNT

enum

filters::params::SpatialFilter SpatialFilter

enum

filters::params::TemporalFilter TemporalFilter

enum

filters::params::SpeckleFilter SpeckleFilter

enum

filters::params::MedianFilter MedianFilter

class

dai::StreamMessageParser

class

dai::SystemInformation

#include SystemInformation.hpp

variable

MemoryInfo ddrMemoryUsage

variable

MemoryInfo cmxMemoryUsage

variable

MemoryInfo leonCssMemoryUsage

variable

MemoryInfo leonMssMemoryUsage

variable

CpuUsage leonCssCpuUsage

variable

CpuUsage leonMssCpuUsage

variable

ChipTemperature chipTemperature

function

SystemInformation()

Construct SystemInformation message.

function

~SystemInformation()

function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

inline function

DatatypeEnum getDatatype()

function

 DEPTHAI_SERIALIZE(SystemInformation, ddrMemoryUsage, cmxMemoryUsage, leonCssMemoryUsage, leonMssMemoryUsage, leonCssCpuUsage, leonMssCpuUsage, chipTemperature)

class

dai::SystemInformationRVC4

#include SystemInformationRVC4.hpp

variable

MemoryInfo ddrMemoryUsage

variable

int64_t processMemoryUsage

variable

CpuUsage cpuAvgUsage

variable

CpuUsage processCpuAvgUsage

variable

std::vector< CpuUsage > cpuUsages

variable

ChipTemperatureRVC4 chipTemperature

function

SystemInformationRVC4()

Construct SystemInformation message.

function

~SystemInformationRVC4()

function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

inline function

DatatypeEnum getDatatype()

function

 DEPTHAI_SERIALIZE(SystemInformationRVC4, ddrMemoryUsage, processMemoryUsage, cpuAvgUsage, processCpuAvgUsage, cpuUsages, chipTemperature)

class

dai::ThermalConfig

#include ThermalConfig.hpp

variable

ThermalAmbientParams ambientParams

variable

ThermalFFCParams ffcParams

variable

ThermalImageParams imageParams

function

ThermalConfig()

Construct ThermalConfig message.

function

~ThermalConfig()

function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

inline function

DatatypeEnum getDatatype()

function

DEPTHAI_SERIALIZE(ThermalConfig, ambientParams, ffcParams, imageParams)

struct

dai::ThermalConfig::ThermalAmbientParams

#include ThermalConfig.hpp

variable

std::optional< uint16_t > distance

variable

std::optional< uint16_t > reflectionTemperature

variable

std::optional< uint16_t > atmosphericTemperature

variable

std::optional< uint8_t > targetEmissivity

variable

std::optional< uint8_t > atmosphericTransmittance

variable

std::optional< ThermalGainMode > gainMode

function

 DEPTHAI_SERIALIZE(ThermalAmbientParams, distance, reflectionTemperature, atmosphericTemperature, targetEmissivity, atmosphericTransmittance, gainMode)

struct

dai::ThermalConfig::ThermalFFCParams

variable

std::optional< bool > autoFFC

variable

std::optional< uint16_t > minFFCInterval

Minimum FFC interval when auto FFC is enabled. The time interval between two FFC should not be less than this value.

variable

std::optional< uint16_t > maxFFCInterval

Maximum FFC interval when auto FFC is enabled. The time interval between two FFC should not be more than this value.

variable

std::optional< uint16_t > autoFFCTempThreshold

Auto FFC trigger threshold. The condition for triggering the auto FFC is that the change of Vtemp value exceeds a certain threshold, which is called the Auto FFC trigger threshold.

variable

std::optional< bool > fallProtection

The shutter blade may open/close abnormally during strong mechanical shock (such as fall), and a monitoring process is designed in the firmware to correct the abnormal shutter switch in time. Turn on or off the fall protect mechanism.

variable

std::optional< uint16_t > minShutterInterval

Frequent FFC will cause shutter heating, resulting in abnormal FFC effect and abnormal temperature measurement. Regardless of which mechanism triggers FFC, the minimum trigger interval must be limited.

variable

std::optional< bool > closeManualShutter

variable

std::optional< uint16_t > antiFallProtectionThresholdHighGainMode

variable

std::optional< uint16_t > antiFallProtectionThresholdLowGainMode

function

 DEPTHAI_SERIALIZE(ThermalFFCParams, autoFFC, minFFCInterval, maxFFCInterval, autoFFCTempThreshold, fallProtection, minShutterInterval, closeManualShutter, antiFallProtectionThresholdHighGainMode, antiFallProtectionThresholdLowGainMode)

struct

dai::ThermalConfig::ThermalImageParams

variable

std::optional< uint8_t > timeNoiseFilterLevel

variable

std::optional< uint8_t > spatialNoiseFilterLevel

variable

std::optional< uint8_t > digitalDetailEnhanceLevel

variable

std::optional< uint8_t > brightnessLevel

variable

std::optional< uint8_t > contrastLevel

variable

std::optional< ThermalImageOrientation > orientation

function

 DEPTHAI_SERIALIZE(ThermalImageParams, timeNoiseFilterLevel, spatialNoiseFilterLevel, digitalDetailEnhanceLevel, brightnessLevel, contrastLevel, orientation)

enum

ThermalImageOrientation

enumerator

Normal

enumerator

Mirror

enumerator

Flip

enumerator

MirrorFlip

enum

ThermalGainMode

Thermal sensor gain mode. Use low gain in high energy environments.

enumerator

LOW

enumerator

HIGH

class

dai::ToFConfig

#include ToFConfig.hpp

variable

filters::params::MedianFilter median

Set kernel size for depth median filtering, or disable

variable

int phaseUnwrappingLevel

variable

uint16_t phaseUnwrapErrorThreshold

variable

bool enablePhaseShuffleTemporalFilter

variable

bool enableBurstMode

variable

bool enableDistortionCorrection

variable

std::optional< bool > enableFPPNCorrection

variable

std::optional< bool > enableOpticalCorrection

variable

std::optional< bool > enableTemperatureCorrection

variable

std::optional< bool > enableWiggleCorrection

variable

std::optional< bool > enablePhaseUnwrapping

function

ToFConfig()

Construct ToFConfig message.

function

~ToFConfig()

function

ToFConfig & setMedianFilter(filters::params::MedianFilter median)

Parameters

median: Set kernel size for median filtering, or disable

function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

inline function

DatatypeEnum getDatatype()

function

void setProfilePreset(ImageFiltersPresetMode presetMode)

Set preset mode for ToFConfig.

Parameters

presetMode: Preset mode for ToFConfig.

function

 DEPTHAI_SERIALIZE(ToFConfig, median, enablePhaseShuffleTemporalFilter, enableBurstMode, enableDistortionCorrection, enableFPPNCorrection, enableOpticalCorrection, enableTemperatureCorrection, enableWiggleCorrection, enablePhaseUnwrapping, phaseUnwrappingLevel, phaseUnwrapErrorThreshold)

struct

dai::TrackedFeature

#include TrackedFeatures.hpp

variable

Point2f position

x, y position of the detected feature

variable

uint32_t id

Feature ID. Persistent between frames if motion estimation is enabled.

variable

uint32_t age

Feature age in frames

variable

float harrisScore

Feature harris score

variable

float trackingError

Feature tracking error

variable

std::array< uint8_t, 32 > descriptor

Feature descriptor

class

dai::TrackedFeatures

#include TrackedFeatures.hpp

variable

std::vector< TrackedFeature > trackedFeatures

function

TrackedFeatures()

Construct TrackedFeatures message.

function

~TrackedFeatures()

function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

inline function

DatatypeEnum getDatatype()

function

DEPTHAI_SERIALIZE(TrackedFeatures, trackedFeatures, Buffer::sequenceNum, Buffer::ts, Buffer::tsDevice)

struct

dai::Tracklet

#include Tracklets.hpp

variable

Rect roi

Tracked region of interest.

variable

std::int32_t id

Tracklet's ID.

variable

std::int32_t label

Tracklet's label ID.

variable

std::int32_t age

Number of frames it is being tracked for.

variable

TrackingStatus status

Status of tracklet.

variable

ImgDetection srcImgDetection

Image detection that is tracked.

variable

Point3f spatialCoordinates

Spatial coordinates of tracklet.

function

DEPTHAI_SERIALIZE(Tracklet, roi, id, label, age, status, srcImgDetection, spatialCoordinates)

enum

std::int32_t TrackingStatus

enumerator

NEW

The object is newly added.

enumerator

TRACKED

The object is being tracked.

enumerator

LOST

The object gets lost now. The object can be tracked again automatically(long term tracking) or by specifying detected object manually(short term and zero term tracking).

enumerator

REMOVED

The object is removed.

class

dai::Tracklets

#include Tracklets.hpp

variable

std::vector< Tracklet > tracklets

Retrieve data for Tracklets.

Returns

Vector of object tracker data, carrying tracking information.

variable

ImgTransformation transformation

function

Tracklets()

Construct Tracklets message.

function

~Tracklets()

function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

function

DEPTHAI_SERIALIZE(Tracklets, tracklets, transformation, Buffer::ts, Buffer::tsDevice, Buffer::sequenceNum)

struct

dai::Transform

variable

std::array< std::array< double, 4 >, 4 > matrix

class

dai::TransformData

#include TransformData.hpp

variable

Transform transform

function

TransformData()

Construct TransformData message.

function

TransformData(const Transform & transform)

function

TransformData(const std::array< std::array< double, 4 >, 4 > & data)

function

TransformData(double x, double y, double z, double qx, double qy, double qz, double qw)

function

TransformData(double x, double y, double z, double roll, double pitch, double yaw)

function

~TransformData()

function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

inline function

DatatypeEnum getDatatype()

function

Point3d getTranslation()

function

Point3d getRotationEuler()

function

Quaterniond getQuaternion()

function

DEPTHAI_SERIALIZE(TransformData, Buffer::sequenceNum, Buffer::ts, Buffer::tsDevice, transform)

class

dai::VppConfig

#include VppConfig.hpp

variable

float blending

variable

float distanceGamma

variable

uint8_t maxPatchSize

variable

PatchColoringType patchColoringType

variable

bool uniformPatch

variable

InjectionParameters injectionParameters

variable

int maxNumThreads

variable

int maxFPS

function

VppConfig()

function

~VppConfig()

inline function

float getBlending()

inline function

void setBlending(float value)

inline function

float getDistanceGamma()

inline function

void setDistanceGamma(float value)

inline function

uint8_t getMaxPatchSize()

inline function

void setMaxPatchSize(uint8_t value)

inline function

PatchColoringType getPatchColoringType()

inline function

void setPatchColoringType(PatchColoringType type)

inline function

bool getUniformPatch()

inline function

void setUniformPatch(bool value)

inline function

InjectionParameters getInjectionParameters()

inline function

void setInjectionParameters(const InjectionParameters & params)

inline function

int getMaxNumThreads()

inline function

void setMaxNumThreads(int value)

inline function

int getMaxFPS()

inline function

void setMaxFPS(int value)

inline function

void serialize(std::vector< std::uint8_t > & metadata, DatatypeEnum & datatype)

function

 DEPTHAI_SERIALIZE(VppConfig, blending, distanceGamma, maxPatchSize, patchColoringType, uniformPatch, injectionParameters, maxNumThreads, maxFPS)

struct

dai::VppConfig::InjectionParameters

variable

bool useInjection

variable

int kernelSize

variable

float textureThreshold

variable

float confidenceThreshold

variable

int morphologyIterations

variable

bool useMorphology

inline function

bool getUseInjection()

inline function

void setUseInjection(bool value)

inline function

int getKernelSize()

inline function

void setKernelSize(int value)

inline function

float getTextureThreshold()

inline function

void setTextureThreshold(float value)

inline function

float getConfidenceThreshold()

inline function

void setConfidenceThreshold(float value)

inline function

int getMorphologyIterations()

inline function

void setMorphologyIterations(int value)

inline function

bool isUseMorphology()

inline function

void setUseMorphology(bool value)

function

 DEPTHAI_SERIALIZE(InjectionParameters, useInjection, kernelSize, textureThreshold, confidenceThreshold, morphologyIterations, useMorphology)

enum

int PatchColoringType

enumerator

RANDOM

enumerator

MAXDIST

struct

dai::AprilTagProperties

#include AprilTagProperties.hpp

variable

AprilTagConfig initialConfig

variable

bool inputConfigSync

variable

int numThreads

function

~AprilTagProperties()

struct

dai::AutoCalibrationProperties

variable

AutoCalibrationConfig initialConfig

function

~AutoCalibrationProperties()

struct

dai::BenchmarkInProperties

#include BenchmarkInProperties.hpp

variable

uint32_t reportEveryNMessages

Specify how many messages to measure for each report

variable

bool attachLatencies

Specify whether the latenices are attached to the report individually

variable

bool logReportsAsWarnings

Send the reports also as logger warnings

function

~BenchmarkInProperties()

struct

dai::BenchmarkOutProperties

#include BenchmarkOutProperties.hpp

variable

int numMessages

Number of messages to send

variable

float fps

FPS for sending, 0 means as fast as possible

function

~BenchmarkOutProperties()

struct

dai::CameraProperties

#include CameraProperties.hpp

variable

std::vector< ImgFrameCapability > outputRequests

variable

CameraControl initialControl

Initial controls applied to the camera node

variable

CameraBoardSocket boardSocket

Which socket will this camera node use

variable

CameraSensorType sensorType

Camera sensor type (you can pick one in case the given sensor supports multiple types)

variable

std::string cameraName

Which camera name will this camera node use (e.g. "IMX378", "OV9282")

variable

CameraImageOrientation imageOrientation

Camera sensor image orientation / pixel readout

variable

int32_t resolutionWidth

Select the camera sensor width (e.g. 1920, 1280, 640, etc.)

variable

int32_t resolutionHeight

Select the camera sensor height (e.g. 1080, 720, 400, etc.)

variable

int32_t mockIspWidth

Select the mock isp width. Overrides resolutionWidth/height if mockIsp is connected (e.g. 1920, 1280, 640, etc.)

variable

int32_t mockIspHeight

Select the mock isp height. Overrides resolutionWidth/height if mockIsp is connected (e.g. 1080, 720, 400, etc.)

variable

float mockIspFps

Select the mock isp fps. Overrides fps if mockIsp is connected (e.g. 30, 25, 20, etc.)

variable

float fps

Camera sensor FPS (e.g. 30, 25, 20, etc.)

variable

int isp3aFps

Isp 3A rate (auto focus, auto exposure, auto white balance, camera controls etc.). Default (0) matches the camera FPS, meaning that 3A is running on each frame. Reducing the rate of 3A reduces the CPU usage on CSS, but also increases the convergence rate of 3A. Note that camera controls will be processed at this rate. E.g. if camera is running at 30 fps, and camera control is sent at every frame, but 3A fps is set to 15, the camera control messages will be processed at 15 fps rate, which will lead to queueing.

variable

int numFramesPoolRaw

Number of frames in different pools and the maximum size in bytes of each pool (number of frames will be automatically reduced if the size is exceeded) Raw pool

variable

int maxSizePoolRaw

variable

int numFramesPoolIsp

Isp pool

variable

int maxSizePoolIsp

variable

int numFramesPoolVideo

Video pool

variable

int numFramesPoolPreview

Preview pool

variable

int numFramesPoolStill

Still pool

variable

std::optional< int > numFramesPoolOutputs

Outputs frame pools

variable

std::optional< int > maxSizePoolOutputs

function

~CameraProperties()

struct

dai::CastProperties

#include CastProperties.hpp

variable

dai::ImgFrame::Type outputType

variable

std::optional< float > scale

variable

std::optional< float > offset

variable

int numFramesPool

function

~CastProperties()

struct

dai::ColorCameraProperties

#include ColorCameraProperties.hpp

variable

CameraControl initialControl

Initial controls applied to ColorCamera node

variable

CameraBoardSocket boardSocket

Which socket will color camera use

variable

std::string cameraName

Which camera name will color camera use

variable

CameraImageOrientation imageOrientation

Camera sensor image orientation / pixel readout

variable

ImgFrame::Type previewType

Frame type

variable

uint32_t previewHeight

Preview frame output height

variable

uint32_t previewWidth

Preview frame output width

variable

int32_t videoWidth

Preview frame output width

variable

int32_t videoHeight

Preview frame output height

variable

int32_t stillWidth

Preview frame output width

variable

int32_t stillHeight

Preview frame output height

variable

int32_t mockIspWidth

Select the mock isp width. Overrides resolutionWidth/height if mockIsp is connected.

variable

int32_t mockIspHeight

Select the mock isp height. Overrides resolutionWidth/height if mockIsp is connected.

variable

SensorResolution resolution

Select the camera sensor resolution

variable

float fps

Camera sensor FPS

variable

int isp3aFps

variable

float sensorCropX

Initial sensor crop, -1 signifies center crop

variable

float sensorCropY

variable

bool previewKeepAspectRatio

Whether to keep aspect ratio of input (video size) or not

variable

IspScale ispScale

Configure scaling for

variable

int numFramesPoolRaw

Pool sizes

variable

int numFramesPoolIsp

variable

int numFramesPoolVideo

variable

int numFramesPoolPreview

variable

int numFramesPoolStill

variable

WarpMeshSource warpMeshSource

variable

std::string warpMeshUri

variable

int warpMeshWidth

variable

int warpMeshHeight

variable

float calibAlpha

variable

int warpMeshStepWidth

variable

int warpMeshStepHeight

variable

std::vector< dai::FrameEvent > eventFilter

List of events to receive, the rest will be ignored

variable

std::optional< bool > rawPacked

Configures whether the camera

function

~ColorCameraProperties()

struct

dai::ColorCameraProperties::IspScale

variable

int32_t horizNumerator

variable

int32_t horizDenominator

variable

int32_t vertNumerator

variable

int32_t vertDenominator

function

DEPTHAI_SERIALIZE(IspScale, horizNumerator, horizDenominator, vertNumerator, vertDenominator)

enum

int32_t SensorResolution

Select the camera sensor resolution

enumerator

THE_1080_P

enumerator

THE_4_K

enumerator

THE_12_MP

enumerator

THE_13_MP

enumerator

THE_720_P

enumerator

THE_800_P

enumerator

THE_1200_P

enumerator

THE_5_MP

enumerator

THE_4000X3000

enumerator

THE_5312X6000

enumerator

THE_48_MP

enumerator

THE_240X180

enumerator

THE_1280X962

enumerator

THE_2000X1500

enumerator

THE_2028X1520

enumerator

THE_2104X1560

enumerator

THE_1440X1080

enumerator

THE_1352X1012

enumerator

THE_2024X1520

enum

int32_t ColorOrder

For 24 bit color these can be either RGB or BGR

enumerator

BGR

enumerator

RGB

enum

WarpMeshSource

Warp mesh source

enumerator

AUTO

enumerator

NONE

enumerator

CALIBRATION

enumerator

URI

struct

dai::DetectionParserProperties

#include DetectionParserProperties.hpp

variable

int numFramesPool

variable

std::unordered_map< std::string, TensorInfo > networkInputs

variable

DetectionParserOptions parser

function

~DetectionParserProperties()

struct

dai::DeviceNodeGroupProperties

#include DeviceNodeGroupProperties.hpp

variable

int dummy

function

~DeviceNodeGroupProperties()

struct

dai::DynamicCalibrationProperties

#include DynamicCalibrationProperties.hpp

variable

bool emptyBool

function

~DynamicCalibrationProperties()

struct

dai::EdgeDetectorProperties

#include EdgeDetectorProperties.hpp

variable

EdgeDetectorConfig initialConfig

variable

int outputFrameSize

Maximum output frame size in bytes (eg: 300x300 BGR image -> 300*300*3 bytes)

variable

int numFramesPool

function

~EdgeDetectorProperties()

struct

dai::FeatureTrackerProperties

#include FeatureTrackerProperties.hpp

variable

FeatureTrackerConfig initialConfig

Initial feature tracker config

variable

std::int32_t numShaves

Number of shaves reserved for feature tracking. Optical flow can use 1 or 2 shaves, while for corner detection only 1 is enough. Hardware motion estimation doesn't require shaves. Maximum 2, minimum 1.

variable

std::int32_t numMemorySlices

Number of memory slices reserved for feature tracking. Optical flow can use 1 or 2 memory slices, while for corner detection only 1 is enough. Maximum number of features depends on the number of allocated memory slices. Hardware motion estimation doesn't require memory slices. Maximum 2, minimum 1.

function

~FeatureTrackerProperties()

struct

dai::GateProperties

#include GateProperties.hpp

variable

GateControl initialConfig

function

~GateProperties()

struct

dai::GlobalProperties

#include GlobalProperties.hpp

variable

double leonCssFrequencyHz

Set frequency of Leon OS - Increasing can improve performance, at the cost of higher power draw

variable

double leonMssFrequencyHz

Set frequency of Leon RT - Increasing can improve performance, at the cost of higher power draw

variable

std::optional< std::string > pipelineName

variable

std::optional< std::string > pipelineVersion

variable

std::optional< dai::EepromData > calibData

Calibration data sent through pipeline

variable

uint32_t eepromId

Unique identifier for the eeprom data in the pipeline.

variable

std::optional< std::uint32_t > cameraTuningBlobSize

Camera tuning blob size in bytes

variable

std::string cameraTuningBlobUri

Uri which points to camera tuning blob

variable

std::unordered_map< CameraBoardSocket, std::uint32_t > cameraSocketTuningBlobSize

Socket specific camera tuning blob size in bytes

variable

std::unordered_map< CameraBoardSocket, std::string > cameraSocketTuningBlobUri

Socket specific camera tuning blob uri

variable

int32_t xlinkChunkSize

Chunk size for splitting device-sent XLink packets, in bytes. A larger value could increase performance, with 0 disabling chunking. A negative value won't modify the device defaults - configured per protocol, currently 64*1024 for both USB and Ethernet.

variable

uint32_t sippBufferSize

variable

uint32_t sippDmaBufferSize

function

~GlobalProperties()

inline function

GlobalProperties & setFrom(const GlobalProperties & other)

struct

dai::IMUSensorConfig

variable

bool sensitivityEnabled

variable

bool sensitivityRelative

variable

uint16_t changeSensitivity

variable

uint32_t reportRate

variable

IMUSensor sensorId

struct

dai::IMUProperties

variable

std::vector< IMUSensorConfig > imuSensors

variable

std::int32_t batchReportThreshold

variable

std::int32_t maxBatchReports

variable

std::optional< bool > enableFirmwareUpdate

Whether to perform firmware update or not. Default value: false.

function

~IMUProperties()

struct

dai::ImageAlignProperties

#include ImageAlignProperties.hpp

variable

ImageAlignConfig initialConfig

variable

int numFramesPool

variable

int alignWidth

Optional output width

variable

int alignHeight

Optional output height

variable

std::vector< int > warpHwIds

variable

Interpolation interpolation

variable

bool outKeepAspectRatio

Whether to keep aspect ratio of the input or not

variable

std::int32_t numShaves

Number of shaves reserved.

function

~ImageAlignProperties()

enum

dai::Interpolation Interpolation

struct

dai::ImageFiltersProperties

variable

ImageFiltersConfig initialConfig

Initial config for the filter pipeline

function

~ImageFiltersProperties()

struct

dai::ToFDepthConfidenceFilterProperties

variable

ToFDepthConfidenceFilterConfig initialConfig

Initial config for the ToF depth confidence filter

function

~ToFDepthConfidenceFilterProperties()

struct

dai::ImageManipProperties

#include ImageManipProperties.hpp

variable

ImageManipConfig initialConfig

variable

int outputFrameSize

variable

int numFramesPool

variable

Backend backend

variable

PerformanceMode performanceMode

function

~ImageManipProperties()

enum

uint8_t Backend

Enable hardware accelerated image manipulation if set to HW. Only applied on RVC4. This can cause some unexpected behavior when using multiple ImageManip nodes in series. Currently, the only operation affected is downscaling.

enumerator

CPU

enumerator

enum

uint8_t PerformanceMode

Set performance mode for ImageManip with a tradeoff between performance and power consumption. Only applied on RVC4. This only affects scaling NV12 and GRAY images.

PERFORMANCE: High performance, high power consumption. Uses the OpenCV backend.
BALANCED: Balanced performance and power consumption. Uses the FastCV backend configured for high performance where possible with a fallback to OpenCV.
LOW_POWER: Low performance, low power consumption. Uses the FastCV backend configured for low power where possible with a fallback to OpenCV.

enumerator

PERFORMANCE

enumerator

BALANCED

enumerator

LOW_POWER

struct

dai::MessageDemuxProperties

#include MessageDemuxProperties.hpp

variable

ProcessorType processor

Which processor should execute the node.

function

~MessageDemuxProperties()

struct

dai::MonoCameraProperties

#include MonoCameraProperties.hpp

variable

CameraControl initialControl

Initial controls applied to MonoCamera node

variable

CameraBoardSocket boardSocket

Which socket will mono camera use

variable

std::string cameraName

Which camera name will mono camera use

variable

CameraImageOrientation imageOrientation

Camera sensor image orientation / pixel readout

variable

SensorResolution resolution

Select the camera sensor resolution

variable

int32_t mockIspWidth

Select the mock isp width. Overrides resolutionWidth/height if mockIsp is connected.

variable

int32_t mockIspHeight

Select the mock isp height. Overrides resolutionWidth/height if mockIsp is connected.

variable

float fps

Camera sensor FPS

variable

int isp3aFps

variable

int numFramesPool

Frame pool size for the main output, ISP processed

variable

int numFramesPoolRaw

Frame pool size for the

variable

std::vector< dai::FrameEvent > eventFilter

List of events to receive, the rest will be ignored

variable

std::optional< bool > rawPacked

Configures whether the camera

function

~MonoCameraProperties()

enum

int32_t SensorResolution

Select the camera sensor resolution: 1280×720, 1280×800, 640×400, 640×480, 1920×1200, ...

enumerator

THE_720_P

enumerator

THE_800_P

enumerator

THE_400_P

enumerator

THE_480_P

enumerator

THE_1200_P

enumerator

THE_4000X3000

enumerator

THE_4224X3136

struct

dai::NeuralDepthProperties

#include NeuralDepthProperties.hpp

variable

NeuralDepthConfig initialConfig

function

~NeuralDepthProperties()

struct

dai::NeuralNetworkProperties

#include NeuralNetworkProperties.hpp

variable

ModelSource modelSource

variable

std::optional< std::uint32_t > blobSize

Blob binary size in bytes

variable

std::string blobUri

Uri which points to blob

variable

std::string modelUri

Uri which points to the model description

variable

std::uint32_t numFrames

Number of available output tensors in pool

variable

std::uint32_t numThreads

Number of threads to create for running inference. 0 = auto

variable

std::uint32_t numNCEPerThread

Number of NCE (Neural Compute Engine) per inference thread. 0 = auto

variable

std::uint32_t numShavesPerThread

Number of Shaves per inference thread. 0 = auto

variable

std::string backend

Specify which backend is used. "" = auto

variable

std::map< std::string, std::string > backendProperties

Specify backend properties

variable

std::optional< DeviceModelZoo > deviceModel

Device model from device model zoo

function

~NeuralNetworkProperties()

enum

ModelSource

Specify where the node should source the model

enumerator

BLOB

enumerator

CUSTOM_MODEL

struct

dai::ObjectTrackerProperties

#include ObjectTrackerProperties.hpp

variable

float trackerThreshold

Confidence threshold for tracklets. Above this threshold detections will be tracked. Default 0, all detections are tracked.

variable

std::int32_t maxObjectsToTrack

Maximum number of objects to track. Maximum 60 for SHORT_TERM_KCF, maximum 1000 for other tracking methods. Default 60.

variable

std::vector< std::uint32_t > detectionLabelsToTrack

Which detections labels to track. Default all labels are tracked.

variable

TrackerType trackerType

Tracking method.

variable

TrackerIdAssignmentPolicy trackerIdAssignmentPolicy

New ID assignment policy.

variable

bool trackingPerClass

Whether tracker should take into consideration class label for tracking.

variable

float occlusionRatioThreshold

Occlusion ratio threshold. Used to filter out overlapping tracklets.

variable

uint32_t trackletMaxLifespan

Tracklet lifespan in number of frames. Number of frames after which a LOST tracklet is removed.

variable

uint32_t trackletBirthThreshold

Tracklet birth threshold. Minimum consecutive tracked frames required to consider a tracklet as a new instance.

function

~ObjectTrackerProperties()

struct

dai::PointCloudProperties

#include PointCloudProperties.hpp

variable

PointCloudConfig initialConfig

variable

int numFramesPool

function

~PointCloudProperties()

struct

dai::PoolProperties

#include PoolProperties.hpp

variable

std::optional< int > numMessages

Number of messages in pool

variable

std::optional< std::int64_t > maxMessageSize

Size of data allocated for each message

variable

std::optional< DatatypeEnum > datatype

Optional datatype of messages in the pool

variable

std::optional< ProcessorType > processor

Which processor should hold the pool

function

~PoolProperties()

struct

dai::Properties

function

void serialize(std::vector< std::uint8_t > & data, SerializationType type)

function

std::unique_ptr< Properties > clone()

function

~Properties()

struct

dai::PropertiesSerializable

#include Properties.hpp

inline function

void serialize(std::vector< std::uint8_t > & data, SerializationType type)

inline function

std::unique_ptr< Properties > clone()

struct

dai::RectificationProperties

variable

std::optional< uint32_t > outputWidth

variable

std::optional< uint32_t > outputHeight

variable

bool enableRectification

function

~RectificationProperties()

struct

dai::SPIInProperties

#include SPIInProperties.hpp

variable

std::string streamName

Name of stream

variable

int busId

SPI bus to use

variable

std::uint32_t maxDataSize

Maximum input data size

variable

std::uint32_t numFrames

Number of frames in pool

function

~SPIInProperties()

struct

dai::SPIOutProperties

#include SPIOutProperties.hpp

variable

std::string streamName

Name of stream

variable

int busId

SPI bus to use

function

~SPIOutProperties()

struct

dai::ScriptProperties

#include ScriptProperties.hpp

variable

std::string scriptUri

Uri which points to actual script

variable

std::string scriptName

Name of script

variable

ProcessorType processor

Which processor should execute the script

function

~ScriptProperties()

struct

dai::SegmentationParserProperties

variable

std::vector< std::string > labels

variable

std::string networkOutputName

variable

bool classesInOneLayer

variable

bool backgroundClass

function

~SegmentationParserProperties()

struct

dai::SpatialDetectionNetworkProperties

#include SpatialDetectionNetworkProperties.hpp

variable

float detectedBBScaleFactor

variable

SpatialLocationCalculatorConfigThresholds depthThresholds

variable

SpatialLocationCalculatorAlgorithm calculationAlgorithm

variable

std::int32_t stepSize

function

~SpatialDetectionNetworkProperties()

struct

dai::SpatialLocationCalculatorProperties

#include SpatialLocationCalculatorProperties.hpp

variable

SpatialLocationCalculatorConfig roiConfig

function

~SpatialLocationCalculatorProperties()

struct

dai::StereoDepthProperties

#include StereoDepthProperties.hpp

variable

StereoDepthConfig initialConfig

variable

CameraBoardSocket depthAlignCamera

Which camera to align disparity/depth to. When configured (not AUTO), takes precedence over 'depthAlign'

variable

bool enableRectification

Enable stereo rectification/dewarp or not. Useful to disable when replaying pre-recorded rectified frames.

variable

std::int32_t rectifyEdgeFillColor

Fill color for missing data at frame edges - grayscale 0..255, or -1 to replicate pixels

variable

std::optional< std::int32_t > width

Input frame width. Optional (taken from MonoCamera nodes if they exist)

variable

std::optional< std::int32_t > height

Input frame height. Optional (taken from MonoCamera nodes if they exist)

variable

std::optional< std::int32_t > outWidth

Output disparity/depth width. Currently only used when aligning to RGB

variable

std::optional< std::int32_t > outHeight

Output disparity/depth height. Currently only used when aligning to RGB

variable

bool outKeepAspectRatio

Whether to keep aspect ratio of the input (rectified) or not

variable

RectificationMesh mesh

Specify a direct warp mesh to be used for rectification, instead of intrinsics + extrinsic matrices

variable

bool enableRuntimeStereoModeSwitch

Whether to enable switching stereo modes at runtime or not. E.g. standard to subpixel, standard+LR-check to subpixel + LR-check. Note: It will allocate resources for worst cases scenario, should be enabled only if dynamic mode switch is required. Default value: false.

variable

int numFramesPool

variable

std::int32_t numPostProcessingShaves

Number of shaves reserved for stereo depth post processing. Post processing can use multiple shaves to increase performance. -1 means auto, resources will be allocated based on enabled filters. 0 means that it will reuse the shave assigned for main stereo algorithm. For optimal performance it's recommended to allocate more than 0, so post processing will run in parallel with main stereo algorithm. Minimum 1, maximum 10.

variable

std::int32_t numPostProcessingMemorySlices

Number of memory slices reserved for stereo depth post processing. -1 means auto, memory will be allocated based on initial stereo settings and number of shaves. 0 means that it will reuse the memory slices assigned for main stereo algorithm. For optimal performance it's recommended to allocate more than 0, so post processing will run in parallel with main stereo algorithm. Minimum 1, maximum 6.

variable

bool focalLengthFromCalibration

Whether to use horizontal focal length from calibration intrinsics (fx) or calculate based on calibration FOV. Default value is true. If set to false it's calculated from FOV and image resolution: focalLength = calib.width / (2.f * tan(calib.fov / 2 / 180.f * pi));

variable

std::optional< bool > useHomographyRectification

Use 3x3 homography matrix for stereo rectification instead of sparse mesh generated on device. Default behaviour is AUTO, for lenses with FOV over 85 degrees sparse mesh is used, otherwise 3x3 homography. If custom mesh data is provided through loadMeshData or loadMeshFiles this option is ignored. true: 3x3 homography matrix generated from calibration data is used for stereo rectification, can't correct lens distortion. false: sparse mesh is generated on-device from calibration data with mesh step specified with setMeshStep (Default: (16, 16)), can correct lens distortion. Implementation for generating the mesh is same as opencv's initUndistortRectifyMap function. Only the first 8 distortion coefficients are used from calibration data.

variable

bool enableFrameSync

Whether to enable frame syncing inside stereo node or not. Suitable if inputs are known to be synced.

variable

std::optional< float > baseline

Override baseline from calibration. Used only in disparity to depth conversion. Units are centimeters.

variable

std::optional< float > focalLength

Override focal length from calibration. Used only in disparity to depth conversion. Units are pixels.

variable

std::optional< bool > disparityToDepthUseSpecTranslation

Use baseline information for disparity to depth conversion from specs (design data) or from calibration. Suitable for debugging. Utilizes calibrated value as default

variable

std::optional< bool > rectificationUseSpecTranslation

Obtain rectification matrices using spec translation (design data) or from calibration in calculations. Suitable for debugging. Default: false

variable

std::optional< bool > depthAlignmentUseSpecTranslation

Use baseline information for depth alignment from specs (design data) or from calibration. Suitable for debugging. Utilizes calibrated value as default

variable

std::optional< float > alphaScaling

Free scaling parameter between 0 (when all the pixels in the undistorted image are valid) and 1 (when all the source image pixels are retained in the undistorted image). On some high distortion lenses, and/or due to rectification (image rotated) invalid areas may appear even with alpha=0, in these cases alpha < 0.0 helps removing invalid areas. See getOptimalNewCameraMatrix from opencv for more details.

function

~StereoDepthProperties()

struct

dai::StereoDepthProperties::RectificationMesh

variable

std::string meshLeftUri

Uri which points to the mesh array for 'left' input rectification

variable

std::string meshRightUri

Uri which points to the mesh array for 'right' input rectification

variable

std::optional< std::uint32_t > meshSize

Mesh array size in bytes, for each of 'left' and 'right' (need to match)

variable

uint16_t stepWidth

Distance between mesh points, in the horizontal direction

variable

uint16_t stepHeight

Distance between mesh points, in the vertical direction

function

DEPTHAI_SERIALIZE(RectificationMesh, meshLeftUri, meshRightUri, meshSize, stepWidth, stepHeight)

enum

dai::StereoDepthConfig::MedianFilter MedianFilter

enum

dai::StereoDepthConfig::AlgorithmControl::DepthAlign DepthAlign

struct

dai::SyncProperties

#include SyncProperties.hpp

variable

int64_t syncThresholdNs

The maximal interval the messages can be apart in nanoseconds.

variable

int32_t syncAttempts

The number of syncing attempts before fail (num of replaced messages).

variable

ProcessorType processor

Which processor should execute the node.

function

~SyncProperties()

struct

dai::SystemLoggerProperties

#include SystemLoggerProperties.hpp

variable

float rateHz

Rate at which the messages are going to be sent in hertz

function

~SystemLoggerProperties()

struct

dai::ThermalProperties

#include ThermalProperties.hpp

variable

ThermalConfig initialConfig

Initial Thermal config

variable

int numFramesPool

Num frames in output pool

variable

CameraBoardSocket boardSocket

Which socket will color camera use

variable

float fps

Camera sensor FPS

function

~ThermalProperties()

struct

dai::ToFProperties

#include ToFProperties.hpp

variable

ToFConfig initialConfig

Initial ToF config

variable

int numFramesPool

Num frames in output pool

variable

std::optional< std::int32_t > numShaves

Number of shaves reserved for ToF decoding.

variable

std::vector< int > warpHwIds

variable

CameraBoardSocket boardSocket

Which socket will color camera use

variable

std::string cameraName

Which camera name will color camera use

variable

CameraImageOrientation imageOrientation

Camera sensor image orientation / pixel readout

variable

float fps

Camera sensor FPS

variable

int numFramesPoolRaw

Pool sizes

function

~ToFProperties()

struct

dai::UVCProperties

#include UVCProperties.hpp

variable

std::unordered_map< int, int > gpioInit

variable

std::unordered_map< int, int > gpioStreamOn

variable

std::unordered_map< int, int > gpioStreamOff

function

~UVCProperties()

struct

dai::VideoEncoderProperties

#include VideoEncoderProperties.hpp

variable

std::int32_t bitrate

Specifies preferred bitrate (in bit/s) of compressed output bitstream in CBR mode"0" for automatic computation, based on input resolution and FPS: 720p30: 4Mbps, 1080p30: 8.5Mbps, 1440p30: 14Mbps, 2160p30: 20Mbps

variable

std::int32_t keyframeFrequency

Every x number of frames a keyframe will be inserted

variable

std::int32_t maxBitrate

Specifies maximum bitrate (in bit/s) of compressed output bitstream in CBR mode"0" to follow

variable

std::int32_t numBFrames

Specifies number of B frames to be inserted

variable

std::uint32_t numFramesPool

This options specifies how many frames are available in this node's pool. Helps when receiver is slow at consuming.Value "0" indicates automatic number of frames assignment

variable

std::int32_t outputFrameSize

Specifies max output frame size in pool. Value "0" indicates auto

variable

Profile profile

Encoding profile, H264, H265 or MJPEG

variable

std::int32_t quality

Value between 0-100% (approximates quality)

variable

bool lossless

Lossless mode ([M]JPEG only)

variable

RateControlMode rateCtrlMode

Rate control mode specifies if constant or variable bitrate should be used (H264 / H265)

variable

float frameRate

Frame rate

function

~VideoEncoderProperties()

enum

int RateControlMode

Rate control mode specifies if constant or variable bitrate should be used (H264 / H265)

enumerator

CBR

enumerator

VBR

enum

int Profile

Encoding profile, H264 (AVC), H265 (HEVC) or MJPEG

enumerator

H264_BASELINE

enumerator

H264_HIGH

enumerator

H264_MAIN

enumerator

H265_MAIN

enumerator

MJPEG

struct

dai::VppProperties

#include VppProperties.hpp

variable

VppConfig initialConfig

Initial VPP configuration

variable

int numFramesPool

Number of frames in pool for output frames

function

~VppProperties()

struct

dai::WarpProperties

#include WarpProperties.hpp

variable

int outputWidth

variable

int outputHeight

variable

int outputFrameSize

variable

int numFramesPool

variable

int meshWidth

variable

int meshHeight

variable

std::string meshUri

variable

std::vector< int > warpHwIds

variable

Interpolation interpolation

function

~WarpProperties()

struct

dai::PipelineEventAggregationProperties

#include PipelineEventAggregationProperties.hpp

variable

uint32_t aggregationWindowSize

variable

uint32_t statsUpdateIntervalMs

variable

uint32_t eventWaitWindow

variable

bool traceOutput

function

~PipelineEventAggregationProperties()

class

dai::RemoteConnection

#include RemoteConnection.hpp

explicit function

RemoteConnection(const std::string & address, uint16_t webSocketPort, bool serveFrontend, uint16_t httpPort)

function

~RemoteConnection()

function

void addTopic(const std::string & topicName, Node::Output & output, const std::string & group, bool useVisualizationIfAvailable)

function

std::shared_ptr< MessageQueue > addTopic(const std::string & topicName, const std::string & group, unsigned int maxSize, bool blocking, bool useVisualizationIfAvailable)

function

bool removeTopic(const std::string & topicName)

function

void registerPipeline(const Pipeline & pipeline)

function

int waitKey(int delayMs)

function

void registerService(const std::string & serviceName, std::function< nlohmann::json(const nlohmann::json &)> callback)

function

void registerBinaryService(const std::string & serviceName, std::function< std::vector< uint8_t >(const std::vector< uint8_t > &)> callback)

class

dai::AtomicBool

function

AtomicBool()

function

~AtomicBool()

inline function

AtomicBool(const AtomicBool & othr)

inline function

AtomicBool & operator=(const AtomicBool & othr)

inline function

AtomicBool(AtomicBool &&)

inline function

AtomicBool & operator=(AtomicBool && othr)

class

dai::JoiningThread

function

JoiningThread()

inline function

JoiningThread(const JoiningThread &)

function

JoiningThread(JoiningThread &&)

inline function

JoiningThread & operator=(JoiningThread && thr)

inline function

~JoiningThread()

inline function

JoiningThread(std::thread t)

inline function

void swap(JoiningThread & x)

class

dai::LockingQueue

function

LockingQueue()

inline explicit function

LockingQueue(unsigned maxSize, bool blocking)

inline function

LockingQueue(const LockingQueue & obj)

inline function

LockingQueue(LockingQueue && obj)

inline function

LockingQueue & operator=(const LockingQueue & obj)

inline function

LockingQueue & operator=(LockingQueue && obj)

inline function

void setMaxSize(unsigned sz)

inline function

void setBlocking(bool bl)

inline function

unsigned getMaxSize()

inline function

unsigned getSize()

inline function

unsigned isFull()

inline function

bool getBlocking()

inline function

void destruct()

inline function

bool isDestroyed()

function

~LockingQueue()

inline function

bool waitAndConsumeAll(std::function< void(T &)> callback, std::chrono::duration< Rep, Period > timeout)

inline function

bool waitAndConsumeAll(std::function< void(T &)> callback)

inline function

bool consumeAll(std::function< void(T &)> callback)

inline function

bool push(T const & data, std::function< void(LockingQueueState, size_t)> callback)

inline function

bool push(T && data, std::function< void(LockingQueueState, size_t)> callback)

inline function

bool tryWaitAndPush(T const & data, std::chrono::duration< Rep, Period > timeout, std::function< void(LockingQueueState, size_t)> callback)

inline function

bool tryWaitAndPush(T && data, std::chrono::duration< Rep, Period > timeout, std::function< void(LockingQueueState, size_t)> callback)

inline function

bool empty()

inline function

bool front(T & value)

inline function

bool tryPop(T & value)

inline function

bool waitAndPop(T & value)

inline function

bool tryWaitAndPop(T & value, std::chrono::duration< Rep, Period > timeout)

inline function

void waitEmpty()

class

dai::Memory

Derived by dai::SharedMemory, dai::StreamPacketMemory, dai::VectorMemory, dai::impl::_ImageManipMemory

function

~Memory()

function

span< std::uint8_t > getData()

function

span< const std::uint8_t > getData()

function

std::size_t getMaxSize()

function

std::size_t getOffset()

function

void setSize(std::size_t)

inline function

std::size_t getSize()

class

dai::Pimpl

function

Pimpl()

function

Pimpl(Args && ...)

function

~Pimpl()

function

T * operator->()

function

T & operator*()

struct

dai::ProfilingData

variable

long long numBytesWritten

variable

long long numBytesRead

class

dai::ProtoSerializable

Derived by dai::EncodedFrame, dai::IMUData, dai::ImgAnnotations, dai::ImgDetections, dai::ImgFrame, dai::PointCloudData, dai::RGBDData, dai::SegmentationMask, dai::SpatialImgDetections

function

~ProtoSerializable()

inline function

std::vector< std::uint8_t > serializeProto(T...)

inline function

SchemaPair serializeSchema(T...)

struct

dai::ProtoSerializable::dependent_false

struct

dai::ProtoSerializable::SchemaPair

variable

std::string schemaName

variable

std::string schema

struct

dai::RecordConfig

#include RecordReplay.hpp

variable

RecordReplayState state

variable

std::filesystem::path outputDir

variable

VideoEncoding videoEncoding

variable

CompressionLevel compressionLevel

struct

dai::RecordConfig::VideoEncoding

variable

bool enabled

variable

int bitrate

variable

Profile profile

variable

bool lossless

variable

int quality

enum

RecordReplayState

enumerator

RECORD

enumerator

REPLAY

enumerator

NONE

enum

uint8_t CompressionLevel

enumerator

NONE

enumerator

FASTEST

enumerator

FAST

enumerator

DEFAULT

enumerator

SLOW

enumerator

SLOWEST

enum

dai::VideoEncoderProperties::Profile Profile

struct

dai::NodeRecordParams

variable

bool video

variable

std::string name

class

dai::SharedMemory

function

SharedMemory()

inline function

SharedMemory(long argFd)

inline function

SharedMemory(long argFd, std::size_t size)

inline function

SharedMemory(const char * name)

inline function

SharedMemory(const char * name, std::size_t size)

function

~SharedMemory()

inline function

SharedMemory & operator=(long argFd)

inline function

span< std::uint8_t > getData()

inline function

span< const std::uint8_t > getData()

inline function

std::size_t getMaxSize()

inline function

std::size_t getOffset()

inline function

void setSize(std::size_t size)

inline function

std::size_t getSize()

inline function

long getFd()

class

dai::VectorMemory

function

VectorMemory()

inline function

VectorMemory(const std::vector< std::uint8_t > & d)

inline function

VectorMemory(std::vector< std::uint8_t > && d)

inline function

VectorMemory & operator=(std::vector< std::uint8_t > && d)

function

~VectorMemory()

function

span< std::uint8_t > getData()

function

span< const std::uint8_t > getData()

function

std::size_t getMaxSize()

function

std::size_t getOffset()

function

void setSize(std::size_t size)

class

dai::copyable_unique_ptr

#include copyable_unique_ptr.hpp

struct

dai::DeviceInfo

#include XLinkConnection.hpp

variable

std::string name

variable

std::string deviceId

variable

XLinkDeviceState_t state

variable

XLinkProtocol_t protocol

variable

XLinkPlatform_t platform

variable

XLinkError_t status

function

DeviceInfo()

function

 DeviceInfo(std::string name, std::string deviceId, XLinkDeviceState_t state, XLinkProtocol_t protocol, XLinkPlatform_t platform, XLinkError_t status)

explicit function

DeviceInfo(std::string deviceIdOrName)

Creates a DeviceInfo by checking whether supplied parameter is a DeviceID or IP/USB name

Parameters

deviceIdOrName: Either DeviceId, IP Address or USB port name

explicit function

DeviceInfo(const deviceDesc_t & desc)

function

deviceDesc_t getXLinkDeviceDesc()

function

std::string getMxId()

function

std::string getDeviceId()

function

std::string toString()

class

dai::XLinkConnection

#include XLinkConnection.hpp

function

 XLinkConnection(const DeviceInfo & deviceDesc, std::vector< std::uint8_t > mvcmdBinary, XLinkDeviceState_t expectedState)

function

XLinkConnection(const DeviceInfo & deviceDesc, std::filesystem::path pathToMvcmd, XLinkDeviceState_t expectedState)

explicit function

XLinkConnection(const DeviceInfo & deviceDesc, XLinkDeviceState_t expectedState)

function

~XLinkConnection()

function

void setRebootOnDestruction(bool reboot)

function

bool getRebootOnDestruction()

function

int getLinkId()

function

void close()

Explicitly closes xlink connection.

Parameters

This function does not need to be explicitly called as destructor closes the connection automatically

function

bool isClosed()

Is the connection already closed (or disconnected)

Parameters

function

ProfilingData getProfilingData()

Get current accumulated profiling data

Returns

ProfilingData from the specific connection

class

dai::StreamPacketDesc

Derived by dai::StreamPacketMemory

inline function

StreamPacketDesc()

function

StreamPacketDesc(const StreamPacketDesc &)

function

StreamPacketDesc(StreamPacketDesc && other)

function

StreamPacketDesc & operator=(const StreamPacketDesc &)

function

StreamPacketDesc & operator=(StreamPacketDesc && other)

function

~StreamPacketDesc()

class

dai::StreamPacketMemory

function

StreamPacketMemory()

inline function

StreamPacketMemory(StreamPacketDesc && d)

inline function

StreamPacketMemory & operator=(StreamPacketDesc && d)

function

span< std::uint8_t > getData()

function

span< const std::uint8_t > getData()

function

std::size_t getMaxSize()

function

std::size_t getOffset()

function

void setSize(size_t size)

class

dai::XLinkStream

function

XLinkStream(const std::shared_ptr< XLinkConnection > conn, const std::string & name, std::size_t maxWriteSize)

function

XLinkStream(const XLinkStream &)

function

XLinkStream(XLinkStream && stream)

function

XLinkStream & operator=(const XLinkStream &)

function

XLinkStream & operator=(XLinkStream && stream)

function

~XLinkStream()

function

void write(span< const uint8_t > data, span< const uint8_t > data2)

function

void write(span< const uint8_t > data)

function

void write(long fd)

function

void write(long fd, span< const uint8_t > data)

function

void write(const void * data, std::size_t size)

function

std::vector< std::uint8_t > read()

function

std::vector< std::uint8_t > read(std::chrono::milliseconds timeout)

function

std::vector< std::uint8_t > read(XLinkTimespec & timestampReceived)

function

void read(std::vector< std::uint8_t > & data)

function

void read(std::vector< std::uint8_t > & data, long & fd)

function

void read(std::vector< std::uint8_t > & data, XLinkTimespec & timestampReceived)

function

void read(std::vector< std::uint8_t > & data, long & fd, XLinkTimespec & timestampReceived)

function

void writeSplit(const void * data, std::size_t size, std::size_t split)

function

void writeSplit(const std::vector< uint8_t > & data, std::size_t split)

function

StreamPacketDesc readMove()

function

bool write(const void * data, std::size_t size, std::chrono::milliseconds timeout)

function

bool write(const std::uint8_t * data, std::size_t size, std::chrono::milliseconds timeout)

function

bool write(const std::vector< std::uint8_t > & data, std::chrono::milliseconds timeout)

function

bool read(std::vector< std::uint8_t > & data, std::chrono::milliseconds timeout)

function

bool readMove(StreamPacketDesc & packet, const std::chrono::milliseconds timeout)

function

streamPacketDesc_t * readRaw()

function

bool readRaw(streamPacketDesc_t *& pPacket, std::chrono::milliseconds timeout)

function

void readRawRelease()

function

streamId_t getStreamId()

function

std::string getStreamName()

struct

dai::XLinkError

Derived by dai::XLinkReadError, dai::XLinkWriteError

variable

const XLinkError_t status

variable

const std::string streamName

function

~XLinkError()

inline function

XLinkError(XLinkError_t statusID, std::string stream, const std::string & message)

struct

dai::XLinkReadError

function

~XLinkReadError()

function

XLinkReadError(XLinkError_t status, const std::string & stream)

enum

XLinkError XLinkError

struct

dai::XLinkWriteError

function

~XLinkWriteError()

function

XLinkWriteError(XLinkError_t status, const std::string & stream)

enum

XLinkError XLinkError

namespace

dai::bootloader

static constant

constexpr static const char * XLINK_CHANNEL_BOOTLOADER

static constant

constexpr static const char * XLINK_CHANNEL_WATCHDOG

static constant

constexpr static std::uint32_t XLINK_STREAM_MAX_SIZE

static constant

constexpr static const std::chrono::milliseconds XLINK_WATCHDOG_TIMEOUT

function

 DEPTHAI_BOOTLOADER_NLOHMANN_DEFINE_TYPE_OPTIONAL_NON_INTRUSIVE(NetworkConfig, timeoutMs, ipv4, ipv4Mask, ipv4Gateway, ipv4Dns, ipv4DnsAlt, staticIpv4, ipv6, ipv6Prefix, ipv6Gateway, ipv6Dns, ipv6DnsAlt, staticIpv6, mac)

function

DEPTHAI_BOOTLOADER_NLOHMANN_DEFINE_TYPE_OPTIONAL_NON_INTRUSIVE(UsbConfig, timeoutMs, maxUsbSpeed, vid, pid)

function

 DEPTHAI_BOOTLOADER_NLOHMANN_DEFINE_TYPE_OPTIONAL_NON_INTRUSIVE(Config, appMem, usb, network, userBlSize, userBlChecksum)

inline function

const Structure getStructure(Type type)

enum

std::int32_t Memory

enumerator

AUTO

enumerator

FLASH

enumerator

EMMC

enum

std::int32_t Section

enumerator

AUTO

enumerator

HEADER

enumerator

BOOTLOADER

enumerator

BOOTLOADER_CONFIG

enumerator

APPLICATION

enumerator

USER_BOOTLOADER

enum

std::int32_t Type

enumerator

AUTO

enumerator

USB

enumerator

NETWORK

struct

dai::bootloader::NetworkConfig

variable

int timeoutMs

If timeout < 0 - waits forever if timeout == 0 - no timeout if timeout > 0 - waits timeout milliseconds

variable

std::uint32_t ipv4

variable

std::uint32_t ipv4Mask

variable

std::uint32_t ipv4Gateway

variable

std::uint32_t ipv4Dns

variable

std::uint32_t ipv4DnsAlt

variable

bool staticIpv4

variable

std::array< uint32_t, 4 > ipv6

variable

std::uint32_t ipv6Prefix

variable

std::array< uint32_t, 4 > ipv6Gateway

variable

std::array< uint32_t, 4 > ipv6Dns

variable

std::array< uint32_t, 4 > ipv6DnsAlt

variable

bool staticIpv6

variable

std::array< uint8_t, 6 > mac

struct

dai::bootloader::UsbConfig

variable

int timeoutMs

If timeout < 0 - waits forever if timeout == 0 - no timeout if timeout > 0 - waits timeout milliseconds

variable

int maxUsbSpeed

UNKNOWN = 0, LOW, FULL, HIGH, SUPER, SUPER_PLUS

variable

uint16_t vid

variable

uint16_t pid

struct

dai::bootloader::Config

Derived by dai::DeviceBootloader::Config

variable

Memory appMem

variable

UsbConfig usb

variable

NetworkConfig network

variable

uint32_t userBlSize

variable

uint32_t userBlChecksum

struct

dai::bootloader::Structure

Derived by dai::bootloader::NetworkBootloaderStructure, dai::bootloader::UsbBootloaderStructure

variable

std::map< Section, long > offset

variable

std::map< Section, long > size

function

Structure()

struct

dai::bootloader::NetworkBootloaderStructure

inline function

NetworkBootloaderStructure()

struct

dai::bootloader::UsbBootloaderStructure

inline function

UsbBootloaderStructure()

namespace

dai::bootloader::request

enum

uint32_t Command

enumerator

USB_ROM_BOOT

enumerator

BOOT_APPLICATION

enumerator

UPDATE_FLASH

enumerator

GET_BOOTLOADER_VERSION

enumerator

BOOT_MEMORY

enumerator

UPDATE_FLASH_EX

enumerator

UPDATE_FLASH_EX_2

enumerator

NO_OP

enumerator

GET_BOOTLOADER_TYPE

enumerator

SET_BOOTLOADER_CONFIG

enumerator

GET_BOOTLOADER_CONFIG

enumerator

BOOTLOADER_MEMORY

enumerator

GET_BOOTLOADER_COMMIT

enumerator

UPDATE_FLASH_BOOT_HEADER

enumerator

READ_FLASH

enumerator

GET_APPLICATION_DETAILS

enumerator

GET_MEMORY_DETAILS

enumerator

IS_USER_BOOTLOADER

struct

dai::bootloader::request::BaseRequest

variable

Command cmd

inline function

BaseRequest(Command command)

struct

dai::bootloader::request::UsbRomBoot

inline function

UsbRomBoot()

struct

dai::bootloader::request::BootApplication

inline function

BootApplication()

struct

dai::bootloader::request::UpdateFlash

variable

Storage storage

variable

uint32_t totalSize

variable

uint32_t numPackets

inline function

UpdateFlash()

enum

uint32_t Storage

enumerator

SBR

enumerator

BOOTLOADER

struct

dai::bootloader::request::GetBootloaderVersion

inline function

GetBootloaderVersion()

struct

dai::bootloader::request::BootMemory

variable

uint32_t totalSize

variable

uint32_t numPackets

inline function

BootMemory()

struct

dai::bootloader::request::UpdateFlashEx

variable

Memory memory

variable

Section section

variable

uint32_t totalSize

variable

uint32_t numPackets

inline function

UpdateFlashEx()

struct

dai::bootloader::request::UpdateFlashEx2

variable

Memory memory

variable

uint32_t offset

variable

uint32_t totalSize

variable

uint32_t numPackets

inline function

UpdateFlashEx2()

struct

dai::bootloader::request::GetBootloaderType

inline function

GetBootloaderType()

struct

dai::bootloader::request::SetBootloaderConfig

variable

Memory memory

variable

int64_t offset

variable

uint32_t clearConfig

variable

uint32_t totalSize

variable

uint32_t numPackets

inline function

SetBootloaderConfig()

struct

dai::bootloader::request::GetBootloaderConfig

variable

Memory memory

variable

int64_t offset

variable

uint32_t maxSize

inline function

GetBootloaderConfig()

struct

dai::bootloader::request::BootloaderMemory

inline function

BootloaderMemory()

struct

dai::bootloader::request::GetBootloaderCommit

inline function

GetBootloaderCommit()

struct

dai::bootloader::request::UpdateFlashBootHeader

variable

Type type

variable

int64_t offset

variable

int64_t location

variable

int32_t dummyCycles

variable

int32_t frequency

variable

int32_t gpioMode

inline function

UpdateFlashBootHeader()

enum

int32_t Type

enumerator

GPIO_MODE

enumerator

USB_RECOVERY

enumerator

NORMAL

enumerator

FAST

struct

dai::bootloader::request::ReadFlash

variable

Memory memory

variable

uint32_t offset

variable

uint32_t totalSize

inline function

ReadFlash()

struct

dai::bootloader::request::GetApplicationDetails

variable

Memory memory

inline function

GetApplicationDetails()

struct

dai::bootloader::request::GetMemoryDetails

variable

Memory memory

inline function

GetMemoryDetails()

struct

dai::bootloader::request::IsUserBootloader

inline function

IsUserBootloader()

namespace

dai::bootloader::response

enum

uint32_t Command

enumerator

FLASH_COMPLETE

enumerator

FLASH_STATUS_UPDATE

enumerator

BOOTLOADER_VERSION

enumerator

BOOTLOADER_TYPE

enumerator

GET_BOOTLOADER_CONFIG

enumerator

BOOTLOADER_MEMORY

enumerator

BOOT_APPLICATION

enumerator

BOOTLOADER_COMMIT

enumerator

READ_FLASH

enumerator

APPLICATION_DETAILS

enumerator

MEMORY_DETAILS

enumerator

IS_USER_BOOTLOADER

enumerator

NO_OP

struct

dai::bootloader::response::BaseResponse

variable

Command cmd

inline function

BaseResponse(Command command)

struct

dai::bootloader::response::FlashComplete

variable

uint32_t success

variable

char errorMsg

inline function

FlashComplete()

struct

dai::bootloader::response::FlashStatusUpdate

variable

float progress

inline function

FlashStatusUpdate()

struct

dai::bootloader::response::BootloaderVersion

variable

uint32_t major

variable

uint32_t minor

variable

uint32_t patch

inline function

BootloaderVersion()

struct

dai::bootloader::response::BootloaderType

variable

Type type

inline function

BootloaderType()

struct

dai::bootloader::response::GetBootloaderConfig

variable

uint32_t success

variable

char errorMsg

variable

uint32_t totalSize

variable

uint32_t numPackets

inline function

GetBootloaderConfig()

struct

dai::bootloader::response::BootloaderMemory

variable

Memory memory

inline function

BootloaderMemory()

struct

dai::bootloader::response::BootApplication

variable

uint32_t success

variable

char errorMsg

inline function

BootApplication()

struct

dai::bootloader::response::BootloaderCommit

variable

char commitStr

inline function

BootloaderCommit()

struct

dai::bootloader::response::ReadFlash

variable

uint32_t success

variable

char errorMsg

variable

uint32_t totalSize

variable

uint32_t numPackets

inline function

ReadFlash()

struct

dai::bootloader::response::ApplicationDetails

variable

uint32_t success

variable

char errorMsg

variable

uint32_t hasApplication

variable

uint32_t hasFirmwareVersion

variable

uint32_t hasApplicationName

variable

char firmwareVersionStr

variable

char applicationNameStr

inline function

ApplicationDetails()

struct

dai::bootloader::response::MemoryDetails

variable

uint32_t hasMemory

variable

Memory memory

variable

int64_t memorySize

variable

char memoryInfo

inline function

MemoryDetails()

struct

dai::bootloader::response::IsUserBootloader

variable

uint32_t isUserBootloader

inline function

IsUserBootloader()

struct

dai::bootloader::response::NoOp

variable

uint32_t invalidOp

inline function

NoOp()

namespace

dai::build

static constant

constexpr static bool HAVE_OPENCV_SUPPORT

static constant

constexpr static bool HAVE_LIBUSB_SUPPORT

namespace

dai::device

static constant

constexpr static const char * XLINK_CHANNEL_PIPELINE_CONFIG

static constant

constexpr static const char * XLINK_CHANNEL_MAIN_RPC

static constant

constexpr static const char * XLINK_CHANNEL_TIMESYNC

static constant

constexpr static const char * XLINK_CHANNEL_LOG

static constant

constexpr static const char * XLINK_CHANNEL_WATCHDOG

static constant

constexpr static std::uint32_t XLINK_USB_BUFFER_MAX_SIZE

static constant

constexpr static const std::chrono::milliseconds XLINK_USB_WATCHDOG_TIMEOUT

static constant

constexpr static const std::chrono::milliseconds XLINK_TCP_WATCHDOG_TIMEOUT

static constant

constexpr static const int XLINK_MESSAGE_METADATA_MAX_SIZE

namespace

dai::filters

namespace

dai::filters::params

enum

int32_t MedianFilter

enumerator

MEDIAN_OFF

enumerator

KERNEL_3x3

enumerator

KERNEL_5x5

enumerator

KERNEL_7x7

struct

dai::filters::params::SpatialFilter

#include FilterParams.hpp

variable

bool enable

Whether to enable or disable the filter.

variable

std::uint8_t holeFillingRadius

An in-place heuristic symmetric hole-filling mode applied horizontally during the filter passes. Intended to rectify minor artefacts with minimal performance impact. Search radius for hole filling.

variable

float alpha

The Alpha factor in an exponential moving average with Alpha=1 - no filter. Alpha = 0 - infinite filter. Determines the amount of smoothing.

variable

std::int32_t delta

Step-size boundary. Establishes the threshold used to preserve "edges". If the disparity value between neighboring pixels exceed the disparity threshold set by this delta parameter, then filtering will be temporarily disabled. Default value 0 means auto: 3 disparity integer levels. In case of subpixel mode it's 3*number of subpixel levels.

variable

std::int32_t numIterations

Number of iterations over the image in both horizontal and vertical direction.

function

DEPTHAI_SERIALIZE(SpatialFilter, enable, holeFillingRadius, alpha, delta, numIterations)

struct

dai::filters::params::TemporalFilter

#include FilterParams.hpp

variable

bool enable

Whether to enable or disable the filter.

variable

PersistencyMode persistencyMode

Persistency mode. If the current disparity/depth value is invalid, it will be replaced by an older value, based on persistency mode.

variable

float alpha

The Alpha factor in an exponential moving average with Alpha=1 - no filter. Alpha = 0 - infinite filter. Determines the extent of the temporal history that should be averaged.

variable

std::int32_t delta

Step-size boundary. Establishes the threshold used to preserve surfaces (edges). If the disparity value between neighboring pixels exceed the disparity threshold set by this delta parameter, then filtering will be temporarily disabled. Default value 0 means auto: 3 disparity integer levels. In case of subpixel mode it's 3*number of subpixel levels.

function

DEPTHAI_SERIALIZE(TemporalFilter, enable, persistencyMode, alpha, delta)

enum

int32_t PersistencyMode

Persistency algorithm type.

enumerator

PERSISTENCY_OFF

enumerator

VALID_8_OUT_OF_8

enumerator

VALID_2_IN_LAST_3

enumerator

VALID_2_IN_LAST_4

enumerator

VALID_2_OUT_OF_8

enumerator

VALID_1_IN_LAST_2

enumerator

VALID_1_IN_LAST_5

enumerator

VALID_1_IN_LAST_8

enumerator

PERSISTENCY_INDEFINITELY

struct

dai::filters::params::SpeckleFilter

#include FilterParams.hpp

variable

bool enable

Whether to enable or disable the filter.

variable

std::uint32_t speckleRange

Speckle search range.

variable

std::uint32_t differenceThreshold

Maximum difference between neighbor disparity pixels to put them into the same blob. Units in disparity integer levels.

function

DEPTHAI_SERIALIZE(SpeckleFilter, enable, speckleRange, differenceThreshold)

namespace

dai::impl

constant

constexpr ImgFrame::Type VALID_TYPE_COLOR

constant

constexpr ImgFrame::Type VALID_TYPE_GRAY

function

void loop(N & node, const ImageManipConfig & initialConfig, std::shared_ptr< spdlog::async_logger > logger, std::function< size_t(const ImageManipConfig &, const ImgFrame &)> build, std::function< bool(std::shared_ptr< Memory > &, std::shared_ptr< ImageManipData >)> apply, std::function< void(const ImgFrame &, ImgFrame &)> getFrame)

function

FrameSpecs getSrcFrameSpecs(dai::ImgFrame::Specs srcSpecs)

function

size_t getAlignedOutputFrameSize(ImgFrame::Type type, size_t width, size_t height)

constant function

constexpr T ALIGN_UP(T value, std::size_t alignment)

function

FrameSpecs getCcDstFrameSpecs(FrameSpecs srcSpecs, dai::ImgFrame::Type from, dai::ImgFrame::Type to)

function

FrameSpecs getDstFrameSpecs(size_t width, size_t height, dai::ImgFrame::Type type)

function

void transformOpenCV(const uint8_t * src, uint8_t * dst, const size_t srcWidth, const size_t srcHeight, const size_t srcStride, const size_t dstWidth, const size_t dstHeight, const size_t dstStride, const uint16_t numChannels, const uint16_t bpp, const std::array< std::array< float, 3 >, 3 > matrix, const std::vector< uint32_t > & background, const FrameSpecs & srcImgSpecs, const size_t sourceMinX, const size_t sourceMinY, const size_t sourceMaxX, const size_t sourceMaxY)

function

void transformFastCV(const uint8_t * src, uint8_t * dst, const size_t srcWidth, const size_t srcHeight, const size_t srcStride, const size_t dstWidth, const size_t dstHeight, const size_t dstStride, const uint16_t numChannels, const uint16_t bpp, const std::array< std::array< float, 3 >, 3 > matrix, const std::vector< uint32_t > & background, const FrameSpecs & srcImgSpecs, const size_t sourceMinX, const size_t sourceMinY, const size_t sourceMaxX, const size_t sourceMaxY, uint32_t * fastCvBorder)

static inline function

int clampi(int val, int minv, int maxv)

static inline function

float clampf(float val, float minv, float maxv)

function

bool isTypeSupported(dai::ImgFrame::Type type)

function

bool getFrameTypeInfo(dai::ImgFrame::Type outFrameType, int & outNumPlanes, float & outBpp)

static inline function

void YUVfromRGB(float & Y, float & U, float & V, const float R, const float G, const float B)

static inline function

void RGBfromYUV(float & R, float & G, float & B, float Y, float U, float V)

function

overloaded(Ts...)

inline function

bool floatEq(float a, float b)

inline function

bool isSingleChannelu8(const std::shared_ptr< dai::ImgFrame > img)

inline function

bool isSingleChannelu8(const dai::ImgFrame::Type type)

inline function

bool isSingleChannel(const dai::ImgFrame::Type type)

inline function

std::string getOpStr(const T & op)

function

std::string getConfigString(const dai::ImageManipOpsBase< C > & ops)

inline function

std::array< std::array< float, 3 >, 3 > matmul(std::array< std::array< float, 3 >, 3 > A, std::array< std::array< float, 3 >, 3 > B)

inline function

std::array< float, 2 > matvecmul(std::array< std::array< float, 3 >, 3 > M, std::array< float, 2 > vec)

inline function

std::array< float, 2 > matvecmul(std::array< std::array< float, 2 >, 2 > M, std::array< float, 2 > vec)

function

std::tuple< float, float, float, float > getOuterRect(const std::vector< std::array< float, 2 >> points)

function

std::vector< std::array< float, 2 > > getHull(const std::vector< std::array< float, 2 >> points)

function

dai::RotatedRect getOuterRotatedRect(const std::vector< std::array< float, 2 >> & points)

function

std::array< std::array< float, 3 >, 3 > getResizeMat(Resize o, float width, float height, uint32_t outputWidth, uint32_t outputHeight)

function

void getTransformImpl(const ManipOp & op, std::array< std::array< float, 3 >, 3 > & transform, std::array< std::array< float, 2 >, 4 > & imageCorners, std::vector< std::array< std::array< float, 2 >, 4 >> & srcCorners, uint32_t & outputWidth, uint32_t & outputHeight)

function

std::tuple< std::array< std::array< float, 3 >, 3 >, std::array< std::array< float, 2 >, 4 >, std::vector< std::array< std::array< float, 2 >, 4 > > > getTransform(const C & ops, uint32_t inputWidth, uint32_t inputHeight, uint32_t outputWidth, uint32_t outputHeight)

function

void getOutputSizeFromCorners(const std::array< std::array< float, 2 >, 4 > & corners, const bool center, const std::array< std::array< float, 3 >, 3 > transformInv, const uint32_t srcWidth, const uint32_t srcHeight, uint32_t & outputWidth, uint32_t & outputHeight)

function

std::tuple< std::array< std::array< float, 3 >, 3 >, std::array< std::array< float, 2 >, 4 >, std::vector< std::array< std::array< float, 2 >, 4 > > > getFullTransform(dai::ImageManipOpsBase< C > & base, size_t inputWidth, size_t inputHeight, dai::ImgFrame::Type type, dai::ImgFrame::Type outputFrameType, C & outputOps)

inline function

dai::ImgFrame::Type getValidType(dai::ImgFrame::Type type)

function

size_t getFrameSize(const ImgFrame::Type type, const FrameSpecs & specs)

function

void printSpecs(spdlog::async_logger & logger, FrameSpecs specs)

class

dai::impl::_ImageManipMemory

function

_ImageManipMemory()

inline function

_ImageManipMemory(size_t size)

inline function

_ImageManipMemory(span< uint8_t > data)

inline function

uint8_t * data()

inline function

const uint8_t * data()

inline function

size_t size()

inline function

span< uint8_t > getData()

inline function

span< const uint8_t > getData()

inline function

size_t getMaxSize()

inline function

size_t getOffset()

inline function

void setSize(size_t size)

inline function

void setOffset(size_t offset)

inline function

void shallowCopyFrom(_ImageManipMemory & other)

inline function

std::shared_ptr< _ImageManipMemory > offset(size_t offset)

class

dai::impl::_ImageManipBuffer

function

_ImageManipBuffer()

inline function

_ImageManipBuffer(size_t size)

inline function

T * data()

inline function

const T * data()

inline function

size_t size()

inline function

span< T > getData()

inline function

span< const T > getData()

struct

dai::impl::FrameSpecs

variable

uint32_t width

variable

uint32_t height

variable

uint32_t p1Offset

variable

uint32_t p2Offset

variable

uint32_t p3Offset

variable

uint32_t p1Stride

variable

uint32_t p2Stride

variable

uint32_t p3Stride

class

dai::impl::UndistortOpenCvImpl

inline function

UndistortOpenCvImpl(std::shared_ptr< spdlog::async_logger > logger)

function

BuildStatus build(std::array< float, 9 > cameraMatrix, std::array< float, 9 > newCameraMatrix, std::vector< float > distCoeffs, dai::ImgFrame::Type type, uint32_t srcWidth, uint32_t srcHeight, uint32_t dstWidth, uint32_t dstHeight)

function

void undistort(cv::Mat & src, cv::Mat & dst)

enum

BuildStatus

enumerator

ONE_SHOT

enumerator

TWO_SHOT

enumerator

NOT_USED

enumerator

NOT_BUILT

enumerator

ERROR

class

dai::impl::Warp

Derived by dai::impl::WarpH< ImageManipBuffer, ImageManipData >

variable

std::array< std::array< float, 3 >, 3 > matrix

variable

ImageManipOpsBase< Container >::Background background

variable

uint32_t backgroundColor

variable

bool enableUndistort

variable

bool undistortOneShot

variable

ImgFrame::Type type

variable

FrameSpecs srcSpecs

variable

FrameSpecs dstSpecs

variable

size_t sourceMinX

variable

size_t sourceMinY

variable

size_t sourceMaxX

variable

size_t sourceMaxY

function

Warp()

inline function

Warp(std::shared_ptr< spdlog::async_logger > logger)

function

~Warp()

inline function

void init(ImageManipProperties &)

function

void build(const FrameSpecs srcFrameSpecs, const FrameSpecs dstFrameSpecs, const ImgFrame::Type type, const std::array< std::array< float, 3 >, 3 > matrix, std::vector< std::array< std::array< float, 2 >, 4 >> srcCorners)

function

void buildUndistort(bool enable, const std::array< float, 9 > & cameraMatrix, const std::array< float, 9 > & newCameraMatrix, const std::vector< float > & distCoeffs, const ImgFrame::Type type, const uint32_t srcWidth, const uint32_t srcHeight, const uint32_t dstWidth, const uint32_t dstHeight)

function

void apply(const std::shared_ptr< ImageManipData > src, std::shared_ptr< ImageManipData > dst)

inline function

void setLogger(std::shared_ptr< spdlog::async_logger > logger)

function

Warp & setBackgroundColor(uint32_t r, uint32_t g, uint32_t b)

class

dai::impl::WarpH

function

void build(const FrameSpecs srcFrameSpecs, const FrameSpecs dstFrameSpecs, const ImgFrame::Type type, const std::array< std::array< float, 3 >, 3 > matrix, std::vector< std::array< std::array< float, 2 >, 4 >> srcCorners)

function

void buildUndistort(bool enable, const std::array< float, 9 > & cameraMatrix, const std::array< float, 9 > & newCameraMatrix, const std::vector< float > & distCoeffs, const ImgFrame::Type type, const uint32_t srcWidth, const uint32_t srcHeight, const uint32_t dstWidth, const uint32_t dstHeight)

function

void apply(const std::shared_ptr< ImageManipData > src, std::shared_ptr< ImageManipData > dst)

class

dai::impl::ColorChange

function

ColorChange()

inline function

ColorChange(std::shared_ptr< spdlog::async_logger > logger)

inline function

void setLogger(std::shared_ptr< spdlog::async_logger > logger)

function

void build(const FrameSpecs srcFrameSpecs, const FrameSpecs dstFrameSpecs, const ImgFrame::Type typeFrom, const ImgFrame::Type typeTo)

function

void apply(const std::shared_ptr< ImageManipData > src, std::shared_ptr< ImageManipData > dst)

class

dai::impl::ImageManipOperations

inline function

ImageManipOperations(ImageManipProperties props, std::shared_ptr< spdlog::async_logger > logger)

function

ImageManipOperations & build(const ImageManipOpsBase< Container > & base, ImgFrame::Type outputFrameType, FrameSpecs srcFrameSpecs, ImgFrame::Type type)

function

ImageManipOperations & buildUndistort(bool enable, const std::array< float, 9 > & cameraMatrix, const std::array< float, 9 > & newCameraMatrix, const std::vector< float > & distCoeffs, const ImgFrame::Type type, const uint32_t srcWidth, const uint32_t srcHeight, const uint32_t dstWidth, const uint32_t dstHeight)

function

bool apply(const std::shared_ptr< ImageManipData > src, std::shared_ptr< ImageManipData > dst)

function

size_t getOutputPlaneSize(uint8_t plane)

function

size_t getOutputSize()

function

size_t getOutputWidth()

function

size_t getOutputHeight()

function

size_t getOutputStride(uint8_t plane)

function

FrameSpecs getOutputFrameSpecs(ImgFrame::Type type)

inline function

ImgFrame::Type getOutputFrameType()

function

std::vector< RotatedRect > getSrcCrops()

function

std::array< std::array< float, 3 >, 3 > getMatrix()

inline function

bool undistortEnabled()

function

std::string toString()

struct

dai::impl::overloaded

namespace

dai::internal

function

DEPTHAI_SERIALIZE_EXT(XLinkInProperties, streamName, maxDataSize, numFrames)

function

DEPTHAI_SERIALIZE_EXT(XLinkOutProperties, maxFpsLimit, streamName, metadataOnly, packetSize, bytesPerSecondLimit)

struct

dai::internal::VariantSwitch

inline function

void operator()(int index, json const & value, Variant & v)

struct

dai::internal::VariantSwitch< 0 >

inline function

void operator()(int index, json const & value, Variant & v)

struct

dai::internal::VariantReadNop

inline function

void operator()(int index, Reader * reader, Variant & v)

struct

dai::internal::VariantReadNop< 0 >

inline function

void operator()(int index, Reader * reader, Variant & v)

struct

dai::internal::XLinkInProperties

#include XLinkInProperties.hpp

variable

std::string streamName

Name of stream

variable

std::uint32_t maxDataSize

Maximum input data size: NV12 --> 1.5 = (3/2) bytes per pixel, roughly 17.6MB for a 4032x3056 frame

variable

std::uint32_t numFrames

Number of frames in pool

function

~XLinkInProperties()

struct

dai::internal::XLinkOutProperties

#include XLinkOutProperties.hpp

variable

float maxFpsLimit

Set a limit to how many packets will be sent further to host

variable

std::string streamName

Name of stream

variable

bool metadataOnly

Whether to transfer data or only object attributes

variable

int packetSize

Max bytes per packet (-1 = unlimited)

variable

int bytesPerSecondLimit

Maximal bytes per second (-1 = unlimited)

function

~XLinkOutProperties()

namespace

dai::matrix

function

std::vector< std::vector< float > > matMul(std::vector< std::vector< float >> & firstMatrix, std::vector< std::vector< float >> & secondMatrix)

function

bool matInv(std::vector< std::vector< float >> & A, std::vector< std::vector< float >> & inverse)

function

std::array< std::array< float, 2 >, 2 > getMatrixInverse(const std::array< std::array< float, 2 >, 2 > & matrix)

function

std::array< std::array< float, 3 >, 3 > getMatrixInverse(const std::array< std::array< float, 3 >, 3 > & matrix)

function

std::vector< std::vector< float > > createRotationMatrix(float theta)

function

std::vector< std::vector< float > > createScalingMatrix(float scaleX, float scaleY)

function

std::vector< std::vector< float > > createTranslationMatrix(float dx, float dy)

function

std::vector< float > rotationMatrixToVector(const std::vector< std::vector< float >> & R)

function

std::vector< std::vector< float > > rvecToRotationMatrix(const double rvec)

function

void printMatrix(std::vector< std::vector< float >> & matrix)

namespace

dai::model

function

ModelType readModelType(const std::filesystem::path & modelPath)

enum

ModelType

enumerator

BLOB

enumerator

SUPERBLOB

enumerator

DLC

enumerator

NNARCHIVE

enumerator

OTHER

namespace

dai::modelzoo

function

void setHealthEndpoint(const std::string & endpoint)

function

void setDownloadEndpoint(const std::string & endpoint)

function

void setDefaultCachePath(const fs::path & path)

function

void setDefaultModelsPath(const fs::path & path)

function

std::string getHealthEndpoint()

function

std::string getDownloadEndpoint()

function

fs::path getDefaultCachePath()

function

fs::path getDefaultModelsPath()

namespace

dai::nn_archive

namespace

dai::nn_archive::v1

enum

int DataType

Data type of the input data (e.g., 'float32').Represents all existing data types used in i/o streams of the model.Precision of the model weights.Data type of the output data (e.g., 'float32'). Data type of the input data (e.g., 'float32').Represents all existing data types used in i/o streams of the model.Precision of the model weights.Data type of the output data (e.g., 'float32').

enumerator

BOOLEAN

enumerator

FLOAT16

enumerator

FLOAT32

enumerator

FLOAT64

enumerator

INT16

enumerator

INT32

enumerator

INT4

enumerator

INT64

enumerator

INT8

enumerator

STRING

enumerator

UINT16

enumerator

UINT32

enumerator

UINT4

enumerator

UINT64

enumerator

UINT8

enum

int InputType

Type of input data (e.g., 'image').Represents a type of input the model is expecting. Type of input data (e.g., 'image').Represents a type of input the model is expecting.

enumerator

IMAGE

enumerator

RAW

struct

dai::nn_archive::v1::Config

#include Config.hpp

variable

std::optional< std::string > configVersion

String representing config schema version in format 'x.y' where x is major version and y is minor version.

variable

Model model

A Model object representing the neural network used in the archive.

struct

dai::nn_archive::v1::Head

#include Head.hpp

variable

Metadata metadata

Metadata of the parser.

variable

std::optional< std::string > name

Optional name of the head.

variable

std::optional< std::vector< std::string > > outputs

Specify which outputs are fed into the parser. If None, all outputs are fed.

variable

std::string parser

Name of the parser responsible for processing the models output.

struct

dai::nn_archive::v1::Input

#include Input.hpp

variable

DataType dtype

Data type of the input data (e.g., 'float32').

variable

InputType inputType

Type of input data (e.g., 'image').

variable

std::optional< std::string > layout

Lettercode interpretation of the input data dimensions (e.g., 'NCHW')

variable

std::string name

Name of the input layer.

variable

PreprocessingBlock preprocessing

Preprocessing steps applied to the input data.

variable

std::vector< int64_t > shape

Shape of the input data as a list of integers (e.g. [H,W], [H,W,C], [N,H,W,C], ...).

struct

dai::nn_archive::v1::Metadata

#include Metadata.hpp

variable

std::optional< std::vector< std::vector< std::vector< double > > > > anchors

Predefined bounding boxes of different sizes and aspect ratios. The innermost lists are length 2 tuples of box sizes. The middle lists are anchors for each output. The outmost lists go from smallest to largest output.

variable

std::optional< std::vector< std::string > > classes

Names of object classes recognized by the model.

variable

std::optional< double > confThreshold

Confidence score threshold above which a detected object is considered valid.

variable

std::optional< double > iouThreshold

Non-max supression threshold limiting boxes intersection.

variable

std::optional< int64_t > maxDet

Maximum detections per image.

variable

std::optional< int64_t > nClasses

Number of object classes recognized by the model.

variable

std::optional< std::string > postprocessorPath

Path to the postprocessor.

variable

std::optional< bool > isSoftmax

True, if output is already softmaxed.True, if output is already softmaxed in YOLO instance segmentation.

variable

std::optional< std::string > boxesOutputs

Output name corresponding to predicted bounding box coordinates.

variable

std::optional< std::string > scoresOutputs

Output name corresponding to predicted bounding box confidence scores.

variable

std::optional< std::vector< std::string > > anglesOutputs

A list of output names for the angles.

variable

std::optional< std::vector< std::string > > keypointsOutputs

A list of output names for the keypoints.

variable

std::optional< std::vector< std::string > > maskOutputs

A list of output names for each mask output.

variable

std::optional< int64_t > nKeypoints

Number of keypoints per bbox in YOLO keypoint detection.

variable

std::optional< int64_t > nPrototypes

Number of prototypes per bbox in YOLO instance segmnetation.

variable

std::optional< std::string > protosOutputs

Output name for the protos.

variable

std::optional< std::string > subtype

YOLO family decoding subtype (e.g. yolov5, yolov6, yolov7 etc.).

variable

std::optional< std::vector< std::string > > yoloOutputs

A list of output names for each of the different YOLO grid sizes.

variable

nlohmann::json extraParams

Additional parameters

struct

dai::nn_archive::v1::MetadataClass

#include MetadataClass.hpp

variable

std::string name

Name of the model.

variable

std::string path

Relative path to the model executable.

variable

std::optional< DataType > precision

Precision of the model weights.

struct

dai::nn_archive::v1::Model

#include Model.hpp

variable

std::optional< std::vector< Head > > heads

List of Head objects defining the model heads. If not defined, we assume a raw output.

variable

std::vector< Input > inputs

List of Input objects defining the model inputs.

variable

MetadataClass metadata

Metadata object defining the model metadata.

variable

std::vector< Output > outputs

List of Output objects defining the model outputs.

struct

dai::nn_archive::v1::Output

#include Output.hpp

variable

DataType dtype

Data type of the output data (e.g., 'float32').

variable

std::optional< std::string > layout

List of letters describing the output layout (e.g. 'NC').

variable

std::string name

Name of the output layer.

variable

std::optional< std::vector< int64_t > > shape

Shape of the output as a list of integers (e.g. [1, 1000]).

struct

dai::nn_archive::v1::PreprocessingBlock

#include PreprocessingBlock.hpp

variable

std::optional< std::string > daiType

DepthAI input type which is read by DepthAI to automatically setup the pipeline.

variable

std::optional< bool > interleavedToPlanar

If True input to the model is interleaved (NHWC) else planar (NCHW).

variable

std::optional< std::vector< double > > mean

Mean values in channel order. Order depends on the order in which the model was trained on.

variable

std::optional< bool > reverseChannels

If True input to the model is RGB else BGR.

variable

std::optional< std::vector< double > > scale

Standardization values in channel order. Order depends on the order in which the model was trained on.

namespace

dai::node

using

CustomThreadedNode = NodeCRTP< ThreadedHostNode, T >

using

DepthSource = std::variant< std::shared_ptr< StereoDepth >, std::shared_ptr< NeuralDepth >, std::shared_ptr< ToF > >

using

CustomNode = NodeCRTP< HostNode, T >

using

XLinkOutProperties = ::dai::internal::XLinkOutProperties

class

dai::node::BasaltVIO

#include BasaltVIO.hpp

variable

Subnode< node::Sync > sync

variable

InputMap & inputs

variable

std::string leftInputName

variable

std::string rightInputName

variable

Input & left

Input left image on which VIO is performed.

variable

Input & right

Input right image on which VIO is performed.

variable

Input imu

Input IMU data.

variable

Output transform

Output transform data.

variable

Output passthrough

Output passthrough of left image.

function

BasaltVIO()

function

~BasaltVIO()

function

void buildInternal()

inline function

void setImuUpdateRate(int rate)

inline function

void setConfigPath(const std::string & path)

function

void setConfig(const VioConfig & config)

inline function

void setUseSpecTranslation(bool use)

function

void setLocalTransform(const std::shared_ptr< TransformData > & transform)

function

void setImuExtrinsics(const std::shared_ptr< TransformData > & imuExtr)

function

void setAccelBias(const std::vector< double > & accelBias)

function

void setAccelNoiseStd(const std::vector< double > & accelNoiseStd)

function

void setGyroBias(const std::vector< double > & gyroBias)

function

void setGyroNoiseStd(const std::vector< double > & gyroNoiseStd)

function

void setDefaultVIOConfig()

function

void runSyncOnHost(bool runOnHost)

struct

dai::node::BasaltVIO::VioConfig

variable

std::string optical_flow_type

variable

int optical_flow_detection_grid_size

variable

int optical_flow_detection_num_points_cell

variable

int optical_flow_detection_min_threshold

variable

int optical_flow_detection_max_threshold

variable

bool optical_flow_detection_nonoverlap

variable

float optical_flow_max_recovered_dist2

variable

int optical_flow_pattern

variable

int optical_flow_max_iterations

variable

int optical_flow_levels

variable

float optical_flow_epipolar_error

variable

int optical_flow_skip_frames

variable

MatchingGuessType optical_flow_matching_guess_type

variable

float optical_flow_matching_default_depth

variable

float optical_flow_image_safe_radius

variable

bool optical_flow_recall_enable

variable

bool optical_flow_recall_all_cams

variable

bool optical_flow_recall_num_points_cell

variable

bool optical_flow_recall_over_tracking

variable

bool optical_flow_recall_update_patch_viewpoint

variable

float optical_flow_recall_max_patch_dist

variable

std::vector< float > optical_flow_recall_max_patch_norms

variable

LinearizationType vio_linearization_type

variable

bool vio_sqrt_marg

variable

int vio_max_states

variable

int vio_max_kfs

variable

int vio_min_frames_after_kf

variable

float vio_new_kf_keypoints_thresh

variable

bool vio_debug

variable

bool vio_extended_logging

variable

int vio_max_iterations

variable

double vio_obs_std_dev

variable

double vio_obs_huber_thresh

variable

double vio_min_triangulation_dist

variable

bool vio_enforce_realtime

variable

bool vio_use_lm

variable

double vio_lm_lambda_initial

variable

double vio_lm_lambda_min

variable

double vio_lm_lambda_max

variable

bool vio_scale_jacobian

variable

double vio_init_pose_weight

variable

double vio_init_ba_weight

variable

double vio_init_bg_weight

variable

bool vio_marg_lost_landmarks

variable

bool vio_fix_long_term_keyframes

variable

double vio_kf_marg_feature_ratio

variable

KeyframeMargCriteria vio_kf_marg_criteria

variable

double mapper_obs_std_dev

variable

double mapper_obs_huber_thresh

variable

int mapper_detection_num_points

variable

double mapper_num_frames_to_match

variable

double mapper_frames_to_match_threshold

variable

double mapper_min_matches

variable

double mapper_ransac_threshold

variable

double mapper_min_track_length

variable

double mapper_max_hamming_distance

variable

double mapper_second_best_test_ratio

variable

int mapper_bow_num_bits

variable

double mapper_min_triangulation_dist

variable

bool mapper_no_factor_weights

variable

bool mapper_use_factors

variable

bool mapper_use_lm

variable

double mapper_lm_lambda_min

variable

double mapper_lm_lambda_max

enum

LinearizationType

enumerator

ABS_QR

enumerator

ABS_SC

enumerator

REL_SC

enum

MatchingGuessType

enumerator

SAME_PIXEL

enumerator

REPROJ_FIX_DEPTH

enumerator

REPROJ_AVG_DEPTH

enum

KeyframeMargCriteria

enumerator

KF_MARG_DEFAULT

enumerator

KF_MARG_FORWARD_VECTOR

class

dai::node::ThreadedHostNode

Derived by dai::NodeCRTP< dai::node::ThreadedHostNode, RTABMapSLAM >, dai::node::HostNode

function

~ThreadedHostNode()

inline function

bool runOnHost()

function

ThreadedNode()

class

dai::node::AprilTag

#include AprilTag.hpp

variable

std::shared_ptr< AprilTagConfig > initialConfig

Initial config to use when calculating spatial location data.

variable

Input inputConfig

Input AprilTagConfig message with ability to modify parameters in runtime. Default queue is non-blocking with size 4.

variable

Input inputImage

Input message with depth data used to retrieve spatial information about detected object. Default queue is non-blocking with size 4.

variable

Output out

Outputs AprilTags message that carries spatial location results.

variable

Output outConfig

Outputs AprilTagConfig message that contains current configuration.

variable

Output passthroughInputImage

Passthrough message on which the calculation was performed. Suitable for when input queue is set to non-blocking behavior.

function

AprilTag()

function

AprilTag(std::unique_ptr< Properties > props)

function

void setWaitForConfigInput(bool wait)

Specify whether or not wait until configuration message arrives to inputConfig Input.

Parameters

wait: True to wait for configuration message, false otherwise.

function

bool getWaitForConfigInput()

function

void setNumThreads(int numThreads)

Set number of threads to use for AprilTag detection.

Parameters

numThreads: Number of threads to use.

function

int getNumThreads()

Get number of threads to use for AprilTag detection.

Returns

Number of threads to use.

function

void setRunOnHost(bool runOnHost)

Specify whether to run on host or device By default, the node will run on device.

function

bool runOnHost()

Check if the node is set to run on host

function

void run()

function

void buildInternal()

inline function

DeviceNodeCRTP()

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props, bool confMode)

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device, std::unique_ptr< Properties > props, bool confMode)

class

dai::node::AutoCalibration

variable

std::shared_ptr< AutoCalibrationConfig > initialConfig

variable

Output output

function

std::shared_ptr< AutoCalibration > build(const std::shared_ptr< Camera > & cameraLeft, const std::shared_ptr< Camera > & cameraRight)

function

~AutoCalibration()

function

void run()

function

void setRunOnHost(bool runOnHost)

function

bool runOnHost()

function

void buildInternal()

inline function

DeviceNodeCRTP()

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props, bool confMode)

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device, std::unique_ptr< Properties > props, bool confMode)

enum

dai::DynamicCalibrationControl DCC

class

dai::node::BenchmarkIn

variable

Input input

Receive messages as fast as possible

variable

Output passthrough

Passthrough for input messages (so the node can be placed between other nodes)

variable

Output report

Send a benchmark report when the set number of messages are received

function

void sendReportEveryNMessages(uint32_t n)

Specify how many messages to measure for each report

function

void setRunOnHost(bool runOnHost)

Specify whether to run on host or device By default, the node will run on device.

function

bool runOnHost()

Check if the node is set to run on host

function

void logReportsAsWarnings(bool logReportsAsWarnings)

Log the reports as warnings

function

void measureIndividualLatencies(bool attachLatencies)

Attach latencies to the report

function

void run()

inline function

DeviceNodeCRTP()

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props, bool confMode)

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device, std::unique_ptr< Properties > props, bool confMode)

class

dai::node::BenchmarkOut

variable

Output out

Send messages out as fast as possible

variable

Input input

Message that will be sent repeatedly

function

void setNumMessagesToSend(int num)

Sets number of messages to send, by default send messages indefinitely

Parameters

num: number of messages to send

function

void setFps(float fps)

Set FPS at which the node is sending out messages. 0 means as fast as possible

function

void setRunOnHost(bool runOnHost)

Specify whether to run on host or device By default, the node will run on device.

function

bool runOnHost()

Check if the node is set to run on host

function

void run()

inline function

DeviceNodeCRTP()

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props, bool confMode)

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device, std::unique_ptr< Properties > props, bool confMode)

class

dai::node::Camera

variable

CameraControl initialControl

Initial control options to apply to sensor

variable

Input inputControl

Input for CameraControl message, which can modify camera parameters in runtime

variable

Input mockIsp

Input for mocking 'isp' functionality on RVC2. Default queue is blocking with size 8

variable

Output raw

Outputs ImgFrame message that carries RAW10-packed (MIPI CSI-2 format) frame data.Captured directly from the camera sensor, and the source for the 'isp' output.

variable

OutputMap dynamicOutputs

function

Node::Output * requestOutput(std::pair< uint32_t, uint32_t > size, std::optional< ImgFrame::Type > type, ImgResizeMode resizeMode, std::optional< float > fps, std::optional< bool > enableUndistortion)

Get video output with specified size.

function

Node::Output * requestOutput(const Capability & capability, bool onHost)

Request output with advanced controls. Mainly to be used by custom node writers.

function

Node::Output * requestFullResolutionOutput(std::optional< ImgFrame::Type > type, std::optional< float > fps, bool useHighestResolution)

Get a high resolution output with full FOV on the sensor. By default the function will not use the resolutions higher than 5000x4000, as those often need a lot of resources, making them hard to use in combination with other nodes.

Parameters

type: Type of the output (NV12, BGR, ...) - by default it's auto-selected for best performance
fps: FPS of the output - by default it's auto-selected to highest possible that a sensor config support or 30, whichever is lower
useHighestResolution: If true, the function will use the highest resolution available on the sensor, even if it's higher than 5000x4000

function

Node::Output * requestIspOutput(std::optional< float > fps)

Request output with isp resolution. The fps does not vote.

function

std::shared_ptr< Camera > build(dai::CameraBoardSocket boardSocket, std::optional< std::pair< uint32_t, uint32_t >> sensorResolution, std::optional< float > sensorFps)

Build with a specific board socket

Parameters

boardSocket: Board socket to use
sensorResolution: Sensor resolution to use - by default it's auto-detected from the requested outputs
sensorFps: Sensor FPS to use - by default it's auto-detected from the requested outputs (maximum is used)

inline function

std::shared_ptr< Camera > setSensorType(CameraSensorType sensorType)

Set the sensor type to use

Parameters

sensorType: Sensor type to use

inline function

CameraSensorType getSensorType()

Get the sensor type

Returns

Sensor type

function

std::shared_ptr< Camera > setImageOrientation(CameraImageOrientation imageOrientation)

Set camera image orientation

Parameters

imageOrientation: Image orientation to set

Returns

Shared pointer to the camera node

function

CameraImageOrientation getImageOrientation()

Get camera image orientation

Returns

Image orientation

function

std::shared_ptr< Camera > build(dai::CameraBoardSocket boardSocket, ReplayVideo & replay)

Build with a specific board socket and mock input

function

std::shared_ptr< Camera > build(ReplayVideo & replay)

Build with mock input

function

uint32_t getMaxWidth()

Get max width of the camera (can only be called after build)

function

uint32_t getMaxHeight()

Get max height of the camera (can only be called after build)

function

CameraBoardSocket getBoardSocket()

Retrieves which board socket to use

Returns

Board socket to use

function

std::shared_ptr< Camera > setRawNumFramesPool(int num)

Set number of frames in raw pool (will be automatically reduced if the maximum pool memory size is exceeded)

Parameters

num: Number of frames

Returns

Shared pointer to the camera node

function

std::shared_ptr< Camera > setMaxSizePoolRaw(int size)

Set maximum size of raw pool

Parameters

size: Maximum size in bytes of raw pool

Returns

Shared pointer to the camera node

function

std::shared_ptr< Camera > setIspNumFramesPool(int num)

Set number of frames in isp pool (will be automatically reduced if the maximum pool memory size is exceeded)

Parameters

num: Number of frames

Returns

Shared pointer to the camera node

function

std::shared_ptr< Camera > setMaxSizePoolIsp(int size)

Set maximum size of isp pool

Parameters

size: Maximum size in bytes of isp pool

Returns

Shared pointer to the camera node

function

std::shared_ptr< Camera > setNumFramesPools(int raw, int isp, int outputs)

Set number of frames in all pools (will be automatically reduced if the maximum pool memory size is exceeded)

Parameters

raw: Number of frames in raw pool
isp: Number of frames in isp pool
outputs: Number of frames in outputs pools

Returns

Shared pointer to the camera node

function

std::shared_ptr< Camera > setMaxSizePools(int raw, int isp, int outputs)

Set maximum memory size of all pools

Parameters

raw: Maximum size in bytes of raw pool
isp: Maximum size in bytes of isp pool
outputs: Maximum size in bytes of outputs pools

Returns

Shared pointer to the camera node

function

std::shared_ptr< Camera > setOutputsNumFramesPool(int num)

Set number of frames in pools for all outputs

Parameters

num: Number of frames in pools for all outputs

Returns

Shared pointer to the camera node

function

std::shared_ptr< Camera > setOutputsMaxSizePool(int size)

Set maximum size of pools for all outputs

Parameters

size: Maximum size in bytes of pools for all outputs

Returns

Shared pointer to the camera node

function

int getRawNumFramesPool()

Get number of frames in raw pool

Returns

Number of frames

function

int getMaxSizePoolRaw()

Get maximum size of raw pool

Returns

Maximum size in bytes of raw pool

function

int getIspNumFramesPool()

Get number of frames in isp pool

Returns

Number of frames

function

int getMaxSizePoolIsp()

Get maximum size of isp pool

Returns

Maximum size in bytes of isp pool

function

std::optional< int > getOutputsNumFramesPool()

Get number of frames in outputs pool for all outputs

Returns

Number of frames

function

std::optional< size_t > getOutputsMaxSizePool()

Get maximum size of outputs pool for all outputs

Returns

Maximum size in bytes of image manip pool

function

Camera & setMockIsp(ReplayVideo & replay)

Set mock ISP for Camera node. Automatically sets mockIsp size.

Parameters

replay: ReplayVideo node to use as mock ISP

function

Camera()

explicit function

Camera(std::shared_ptr< Device > & defaultDevice)

explicit function

Camera(std::unique_ptr< Properties > props)

function

void buildStage1()

function

float getMaxRequestedFps()

function

uint32_t getMaxRequestedWidth()

function

uint32_t getMaxRequestedHeight()

inline function

DeviceNodeCRTP()

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props, bool confMode)

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device, std::unique_ptr< Properties > props, bool confMode)

class

dai::node::ColorCamera

#include ColorCamera.hpp

variable

CameraControl initialControl

Initial control options to apply to sensor

variable

Input inputControl

Input for CameraControl message, which can modify camera parameters in runtime

variable

Input mockIsp

Input for mocking 'isp' functionality. Default queue is blocking with size 8

variable

Output video

Outputs ImgFrame message that carries NV12 encoded (YUV420, UV plane interleaved) frame data.Suitable for use with VideoEncoder node

variable

Output preview

Outputs ImgFrame message that carries BGR/RGB planar/interleaved encoded frame data.Suitable for use with NeuralNetwork node

variable

Output still

Outputs ImgFrame message that carries NV12 encoded (YUV420, UV plane interleaved) frame data.The message is sent only when a CameraControl message arrives to inputControl with captureStill command set.

variable

Output isp

Outputs ImgFrame message that carries YUV420 planar (I420/IYUV) frame data.Generated by the ISP engine, and the source for the 'video', 'preview' and 'still' outputs

variable

Output raw

Outputs ImgFrame message that carries RAW10-packed (MIPI CSI-2 format) frame data.Captured directly from the camera sensor, and the source for the 'isp' output.

variable

Output frameEvent

Outputs metadata-only ImgFrame message as an early indicator of an incoming frame.It's sent on the MIPI SoF (start-of-frame) event, just after the exposure of the current frame has finished and before the exposure for next frame starts. Could be used to synchronize various processes with camera capture. Fields populated: camera id, sequence number, timestamp

function

ColorCamera()

function

ColorCamera(std::unique_ptr< Properties > props)

function

int getScaledSize(int input, int num, int denom)

Computes the scaled size given numerator and denominator

function

void setBoardSocket(CameraBoardSocket boardSocket)

Specify which board socket to use

Parameters

boardSocket: Board socket to use

function

CameraBoardSocket getBoardSocket()

Retrieves which board socket to use

Returns

Board socket to use

function

void setCamera(std::string name)

Specify which camera to use by name

Parameters

name: Name of the camera to use

function

std::string getCamera()

Retrieves which camera to use by name

Returns

Name of the camera to use

function

void setCamId(int64_t id)

function

int64_t getCamId()

function

void setImageOrientation(CameraImageOrientation imageOrientation)

function

CameraImageOrientation getImageOrientation()

function

void setColorOrder(ColorCameraProperties::ColorOrder colorOrder)

function

ColorCameraProperties::ColorOrder getColorOrder()

function

void setInterleaved(bool interleaved)

function

bool getInterleaved()

function

void setPreviewType(ImgFrame::Type type)

function

ImgFrame::Type getPreviewType()

function

void setFp16(bool fp16)

function

bool getFp16()

function

void setPreviewSize(int width, int height)

function

void setPreviewSize(std::tuple< int, int > size)

function

void setPreviewNumFramesPool(int num)

function

void setVideoSize(int width, int height)

function

void setVideoSize(std::tuple< int, int > size)

function

void setVideoNumFramesPool(int num)

function

void setStillSize(int width, int height)

function

void setStillSize(std::tuple< int, int > size)

function

void setMockIspSize(int width, int height)

function

void setStillNumFramesPool(int num)

function

void setResolution(Properties::SensorResolution resolution)

function

Properties::SensorResolution getResolution()

function

void setRawNumFramesPool(int num)

function

void setIspNumFramesPool(int num)

function

void setNumFramesPool(int raw, int isp, int preview, int video, int still)

function

void setIspScale(int numerator, int denominator)

Set 'isp' output scaling (numerator/denominator), preserving the aspect ratio. The fraction numerator/denominator is simplified first to a irreducible form, then a set of hardware scaler constraints applies: max numerator = 16, max denominator = 63

function

void setIspScale(std::tuple< int, int > scale)

function

void setIspScale(int horizNum, int horizDenom, int vertNum, int vertDenom)

Set 'isp' output scaling, per each direction. If the horizontal scaling factor (horizNum/horizDen) is different than the vertical scaling factor (vertNum/vertDen), a distorted (stretched or squished) image is generated

function

void setIspScale(std::tuple< int, int > horizScale, std::tuple< int, int > vertScale)

function

void setFps(float fps)

Set rate at which camera should produce frames

Parameters

fps: Rate in frames per second

function

void setIsp3aFps(int isp3aFps)

function

void setFrameEventFilter(const std::vector< dai::FrameEvent > & events)

function

std::vector< dai::FrameEvent > getFrameEventFilter()

function

float getFps()

Get rate at which camera should produce frames

Returns

Rate in frames per second

function

std::tuple< int, int > getPreviewSize()

function

int getPreviewWidth()

function

int getPreviewHeight()

function

std::tuple< int, int > getVideoSize()

function

int getVideoWidth()

function

int getVideoHeight()

function

std::tuple< int, int > getStillSize()

function

int getStillWidth()

function

int getStillHeight()

function

std::tuple< int, int > getResolutionSize()

function

int getResolutionWidth()

function

int getResolutionHeight()

function

std::tuple< int, int > getIspSize()

function

int getIspWidth()

function

int getIspHeight()

function

void sensorCenterCrop()

Specify sensor center crop. Resolution size / video size

function

void setSensorCrop(float x, float y)

Specifies the cropping that happens when converting ISP to video output. By default, video will be center cropped from the ISP output. Note that this doesn't actually do on-sensor cropping (and MIPI-stream only that region), but it does postprocessing on the ISP (on RVC).

Parameters

x: Top left X coordinate
y: Top left Y coordinate

function

std::tuple< float, float > getSensorCrop()

Returns

Sensor top left crop coordinates

function

float getSensorCropX()

function

float getSensorCropY()

function

void setPreviewKeepAspectRatio(bool keep)

Specifies whether preview output should preserve aspect ratio, after downscaling from video size or not.

Parameters

keep: If true, a larger crop region will be considered to still be able to create the final image in the specified aspect ratio. Otherwise video size is resized to fit preview size

function

bool getPreviewKeepAspectRatio()

Parameters

setPreviewKeepAspectRatio

Returns

Preview keep aspect ratio option

function

int getPreviewNumFramesPool()

function

int getVideoNumFramesPool()

function

int getStillNumFramesPool()

function

int getRawNumFramesPool()

function

int getIspNumFramesPool()

function

void setRawOutputPacked(bool packed)

Configures whether the camera ToF.

inline function

DeviceNodeCRTP()

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props, bool confMode)

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device, std::unique_ptr< Properties > props, bool confMode)

class

dai::node::DetectionNetwork

#include DetectionNetwork.hpp

variable

Subnode< NeuralNetwork > neuralNetwork

variable

Subnode< DetectionParser > detectionParser

variable

Output & out

Outputs ImgDetections message that carries parsed detection results. Overrides NeuralNetwork 'out' with ImgDetections output message type.

variable

Output & outNetwork

Outputs unparsed inference results.

variable

Input & input

Input message with data to be inferred upon Default queue is blocking with size 5

variable

Output & passthrough

Passthrough message on which the inference was performed.Suitable for when input queue is set to non-blocking behavior.

function

DetectionNetwork(const std::shared_ptr< Device > & device)

function

std::shared_ptr< DetectionNetwork > build(Node::Output & input, const NNArchive & nnArchive)

function

std::shared_ptr< DetectionNetwork > build(const std::shared_ptr< Camera > & input, const Model & model, std::optional< float > fps, std::optional< dai::ImgResizeMode > resizeMode)

function

std::shared_ptr< DetectionNetwork > build(const std::shared_ptr< Camera > & input, const Model & model, const ImgFrameCapability & capability)

function

std::shared_ptr< DetectionNetwork > build(const std::shared_ptr< ReplayVideo > & input, const Model & model, std::optional< float > fps)

function

void setNNArchive(const NNArchive & nnArchive)

function

void setNNArchive(const NNArchive & nnArchive, int numShaves)

function

void setFromModelZoo(NNModelDescription description, bool useCached)

function

void setFromModelZoo(NNModelDescription description, int numShaves, bool useCached)

function

void setBlobPath(const std::filesystem::path & path)

Load network blob into assets and use once pipeline is started.

Parameters

Error: if file doesn't exist or isn't a valid network blob.

Parameters

path: Path to network blob

function

void setBlob(OpenVINO::Blob blob)

Load network blob into assets and use once pipeline is started.

Parameters

blob: Network blob

function

void setBlob(const std::filesystem::path & path)

Same functionality as the setBlobPath(). Load network blob into assets and use once pipeline is started.

Parameters

Error: if file doesn't exist or isn't a valid network blob.

Parameters

path: Path to network blob

function

void setModelPath(const std::filesystem::path & modelPath)

Load network model into assets.

Parameters

modelPath: Path to the model file.

function

void setNumPoolFrames(int numFrames)

Specifies how many frames will be available in the pool

Parameters

numFrames: How many frames will pool have

function

void setNumInferenceThreads(int numThreads)

How many threads should the node use to run the network.

Parameters

numThreads: Number of threads to dedicate to this node

function

void setNumNCEPerInferenceThread(int numNCEPerThread)

How many Neural Compute Engines should a single thread use for inference

Parameters

numNCEPerThread: Number of NCE per thread

function

void setNumShavesPerInferenceThread(int numShavesPerThread)

How many Shaves should a single thread use for inference

Parameters

numShavesPerThread: Number of shaves per thread

function

void setBackend(std::string backend)

Specifies backend to use

Parameters

backend: String specifying backend to use

function

void setBackendProperties(std::map< std::string, std::string > properties)

Set backend properties

Parameters

backendProperties: backend properties map

function

int getNumInferenceThreads()

How many inference threads will be used to run the network

Returns

Number of threads, 0, 1 or 2. Zero means AUTO

function

void setConfidenceThreshold(float thresh)

Specifies confidence threshold at which to filter the rest of the detections.

Parameters

thresh: Detection confidence must be greater than specified threshold to be added to the list

function

float getConfidenceThreshold()

Retrieves threshold at which to filter the rest of the detections.

Returns

Detection confidence

function

std::vector< std::pair< Input &, std::shared_ptr< Capability > > > getRequiredInputs()

function

std::optional< std::vector< std::string > > getClasses()

function

void buildInternal()

enum

NeuralNetwork::Model Model

class

dai::node::DetectionParser

#include DetectionParser.hpp

variable

Input input

Input NN results with detection data to parse Default queue is blocking with size 5

variable

Output out

Outputs image frame with detected edges

function

~DetectionParser()

function

std::shared_ptr< DetectionParser > build(Node::Output & nnInput, const NNArchive & nnArchive)

function

void setNumFramesPool(int numFramesPool)

Specify number of frames in pool.

Parameters

numFramesPool: How many frames should the pool have

function

int getNumFramesPool()

Returns number of frames in pool

function

void setNNArchive(const NNArchive & nnArchive)

function

void setModelPath(const std::filesystem::path & modelPath)

Load network xml and bin files into assets.

Parameters

xmlModelPath: Path to the neural network model file.

function

void setBlobPath(const std::filesystem::path & path)

Load network blob into assets and use once pipeline is started.

Parameters

Error: if file doesn't exist or isn't a valid network blob.

Parameters

path: Path to network blob

function

void setBlob(OpenVINO::Blob blob)

Retrieves some input tensor information from the blob

Parameters

blob: OpenVINO blob to retrieve the information from

function

void setBlob(const std::filesystem::path & path)

Same functionality as the setBlobPath(). Load network blob into assets and use once pipeline is started.

Parameters

Error: if file doesn't exist or isn't a valid network blob.

Parameters

path: Path to network blob

function

void setInputImageSize(int width, int height)

Set input image sizeThis should only be used instead of setBlob, not besides it

function

void setInputImageSize(std::tuple< int, int > size)

Set preview output size, as a tuple<width, height>

function

void setNNFamily(DetectionNetworkType type)

Sets NN Family to parse. Possible values are:DetectionNetworkType::YOLO - 0 DetectionNetworkType::MOBILENET - 1

Parameters

If NN Family is set manually, user must ensure that it matches the actual model being used.

function

DetectionNetworkType getNNFamily()

Gets NN Family to parse

function

void setConfidenceThreshold(float thresh)

Specifies confidence threshold at which to filter the rest of the detections.

Parameters

thresh: Detection confidence must be greater than specified threshold to be added to the list

function

float getConfidenceThreshold()

Retrieves threshold at which to filter the rest of the detections.

Returns

Detection confidence

function

void setNumClasses(int numClasses)

Set number of classes. This will clear any previously set class names.

Parameters

numClasses: Number of classes

function

void setClasses(const std::vector< std::string > & classes)

Set class names. This will clear any previously set number of classes.

Parameters

classes: Vector of class names

function

void setCoordinateSize(int coordinates)

Sets the number of coordinates per bounding box.

Parameters

coordinates: Number of coordinates. Default is 4

function

void setAnchors(std::vector< float > anchors)

Set anchors for anchor-based yolo models

Parameters

anchors: Flattened vector of anchors

Parameters

This method is deprecated, use setAnchorsV2 instead.

function

void setAnchorMasks(std::map< std::string, std::vector< int >> anchorMasks)

Set anchor masks for anchor-based yolo models

Parameters

anchorMasks: Map of anchor masks

function

void setAnchors(const std::vector< std::vector< std::vector< float >>> & anchors)

Set anchors for anchor-based yolo models (v2)

Parameters

anchors: 3D vector of anchors [layer][anchor][dim]

function

void setIouThreshold(float thresh)

Set IOU threshold for non-maxima suppression

Parameters

thresh: IOU threshold

function

void setSubtype(const std::string & subtype)

Set subtype for the parser.

Parameters

subtype: Subtype string, currently supported subtypes are: yolov6r1, yolov6r2 yolov8n, yolov6, yolov8, yolov10, yolov11, yolov3, yolov3-tiny, yolov5, yolov7, yolo-p, yolov5-u

function

void setDecodeKeypoints(bool decode)

Enable/disable keypoints decoding. If enabled, number of keypoints must also be set.

function

void setDecodeSegmentation(bool decode)

Enable/disable segmentation mask decoding.

function

void setNumKeypoints(int numKeypoints)

Set number of keypoints to decode. Automatically enables keypoints decoding.

function

void setStrides(const std::vector< int > & strides)

Set strides for yolo models

function

void setKeypointEdges(const std::vector< dai::Edge > & edges)

Set edges connections between keypoints.

Parameters

edges: Vector edges connections represented as pairs of keypoint indices.

Parameters

This is only applicable if keypoints decoding is enabled.

function

int getNumClasses()

Get number of classes to decode.

function

std::optional< std::vector< std::string > > getClasses()

Get class names to decode.

function

int getCoordinateSize()

Get number of coordinates per bounding box.

function

std::vector< float > getAnchors()

Get anchors for anchor-based yolo models

function

std::map< std::string, std::vector< int > > getAnchorMasks()

Get anchor masks for anchor-based yolo models

function

float getIouThreshold()

Get IOU threshold for non-maxima suppression

function

std::string getSubtype()

Get subtype for the parser.

function

bool getDecodeKeypoints()

Get whether keypoints decoding is enabled.

function

bool getDecodeSegmentation()

Get whether segmentation mask decoding is enabled.

function

int getNKeypoints()

Get number of keypoints to decode.

function

std::vector< int > getStrides()

Get strides for yolo models

function

const NNArchiveVersionedConfig & getNNArchiveVersionedConfig()

Get NNArchive set for this node

function

void setRunOnHost(bool runOnHost)

Specify whether to run on host or device By default, the node will run on device.

function

bool runOnHost()

Check if the node is set to run on host

function

void run()

function

void decodeMobilenet(dai::NNData & nnData, dai::ImgDetections & outDetections, float confidenceThr)

inline function

DeviceNodeCRTP()

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props, bool confMode)

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device, std::unique_ptr< Properties > props, bool confMode)

class

dai::node::DynamicCalibration

variable

Input inputControl

Input DynamicCalibrationControl message with ability to modify parameters in runtime.

variable

Output calibrationOutput

Output calibration quality result

variable

Output qualityOutput

variable

Output metricsOutput

variable

Output coverageOutput

variable

Input syncInput

variable

Subnode< node::Sync > sync

variable

InputMap & inputs

variable

std::string leftInputName

variable

std::string rightInputName

variable

Input & left

Input left image

variable

Input & right

Input right image

function

~DynamicCalibration()

function

void buildInternal()

function

void setRunOnHost(bool runOnHost)

Specify whether to run on host or device By default, the node will run on host on RVC2 and on device on RVC4.

function

bool runOnHost()

inline function

DeviceNodeCRTP()

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props, bool confMode)

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device, std::unique_ptr< Properties > props, bool confMode)

class

dai::node::EdgeDetector

#include EdgeDetector.hpp

variable

std::shared_ptr< EdgeDetectorConfig > initialConfig

Initial config to use for edge detection.

variable

Input inputConfig

Input EdgeDetectorConfig message with ability to modify parameters in runtime. Default queue is non-blocking with size 4.

variable

Input inputImage

Input image on which edge detection is performed. Default queue is non-blocking with size 4.

variable

Output outputImage

Outputs image frame with detected edges

variable

Output passthroughInputImage

Passthrough message on which the calculation was performed.

function

EdgeDetector()

function

EdgeDetector(std::unique_ptr< Properties > props)

function

void setNumFramesPool(int numFramesPool)

Specify number of frames in pool.

Parameters

numFramesPool: How many frames should the pool have

function

void setMaxOutputFrameSize(int maxFrameSize)

Specify maximum size of output image.

Parameters

maxFrameSize: Maximum frame size in bytes

inline function

DeviceNodeCRTP()

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props, bool confMode)

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device, std::unique_ptr< Properties > props, bool confMode)

class

dai::node::FeatureTracker

#include FeatureTracker.hpp

variable

std::shared_ptr< FeatureTrackerConfig > initialConfig

Initial config to use for feature tracking.

variable

Input inputConfig

Input FeatureTrackerConfig message with ability to modify parameters in runtime. Default queue is non-blocking with size 4.

variable

Input inputImage

Input message with frame data on which feature tracking is performed. Default queue is non-blocking with size 4.

variable

Output outputFeatures

Outputs TrackedFeatures message that carries tracked features results.

variable

Output passthroughInputImage

Passthrough message on which the calculation was performed. Suitable for when input queue is set to non-blocking behavior.

function

FeatureTracker()

function

FeatureTracker(std::unique_ptr< Properties > props)

function

void setHardwareResources(int numShaves, int numMemorySlices)

Specify allocated hardware resources for feature tracking. 2 shaves/memory slices are required for optical flow, 1 for corner detection only.

Parameters

numShaves: Number of shaves. Maximum 2.
numMemorySlices: Number of memory slices. Maximum 2.

inline function

DeviceNodeCRTP()

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props, bool confMode)

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device, std::unique_ptr< Properties > props, bool confMode)

class

dai::node::Gate

#include Gate.hpp

variable

std::shared_ptr< GateControl > initialConfig

variable

Input input

variable

Output output

variable

Input inputControl

function

Gate(std::unique_ptr< Properties > props)

function

Gate()

function

void setRunOnHost(bool runOnHost)

Specify whether to run on host or device By default, the node will run on device.

function

bool runOnHost()

function

void run()

inline function

DeviceNodeCRTP()

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props, bool confMode)

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device, std::unique_ptr< Properties > props, bool confMode)

class

dai::node::IMU

#include IMU.hpp

variable

Output out

Outputs IMUData message that carries IMU packets.

variable

Input mockIn

Mock IMU data for replaying recorded data

function

void enableIMUSensor(IMUSensorConfig sensorConfig)

Enable a new IMU sensor with explicit configuration

function

void enableIMUSensor(const std::vector< IMUSensorConfig > & sensorConfigs)

Enable a list of IMU sensors with explicit configuration

function

void enableIMUSensor(IMUSensor sensor, uint32_t reportRate)

Enable a new IMU sensor with default configuration

function

void enableIMUSensor(const std::vector< IMUSensor > & sensors, uint32_t reportRate)

Enable a list of IMU sensors with default configuration

function

void setBatchReportThreshold(std::int32_t batchReportThreshold)

Above this packet threshold data will be sent to host, if queue is not blocked

function

std::int32_t getBatchReportThreshold()

Above this packet threshold data will be sent to host, if queue is not blocked

function

void setMaxBatchReports(std::int32_t maxBatchReports)

Maximum number of IMU packets in a batch report

function

std::int32_t getMaxBatchReports()

Maximum number of IMU packets in a batch report

function

void enableFirmwareUpdate(bool enable)

Whether to perform firmware update or not. Default value: false.

inline function

DeviceNodeCRTP()

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props, bool confMode)

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device, std::unique_ptr< Properties > props, bool confMode)

class

dai::node::ImageAlign

#include ImageAlign.hpp

variable

std::shared_ptr< ImageAlignConfig > initialConfig

Initial config to use when calculating spatial location data.

variable

Input inputConfig

Input message with ability to modify parameters in runtime. Default queue is non-blocking with size 4.

variable

Input input

Input message. Default queue is non-blocking with size 4.

variable

Input inputAlignTo

Input align to message. Default queue is non-blocking with size 1.

variable

Output outputAligned

Outputs ImgFrame message that is aligned to inputAlignTo.

variable

Output passthroughInput

Passthrough message on which the calculation was performed. Suitable for when input queue is set to non-blocking behavior.

function

ImageAlign & setOutputSize(int alignWidth, int alignHeight)

Specify the output size of the aligned image

function

ImageAlign & setOutKeepAspectRatio(bool keep)

Specify whether to keep aspect ratio when resizing

function

ImageAlign & setInterpolation(Interpolation interp)

Specify interpolation method to use when resizing

function

ImageAlign & setNumShaves(int numShaves)

Specify number of shaves to use for this node

function

ImageAlign & setNumFramesPool(int numFramesPool)

Specify number of frames in the pool

function

void setRunOnHost(bool runOnHost)

Specify whether to run on host or device By default, the node will run on device.

function

bool runOnHost()

Check if the node is set to run on host

function

void run()

inline function

DeviceNodeCRTP()

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props, bool confMode)

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device, std::unique_ptr< Properties > props, bool confMode)

class

dai::node::ImageFilters

variable

std::shared_ptr< ImageFiltersConfig > initialConfig

Initial config for image filters.

variable

Node::Input input

Input for image frames to be filtered

variable

Node::Output output

Filtered frame

variable

Node::Input inputConfig

Config to be set for a specific filter

function

std::shared_ptr< ImageFilters > build(Node::Output & input, ImageFiltersPresetMode presetMode)

Build the node.

Parameters

input: Input for image frames to be filtered
presetMode: Preset mode for image filters

Returns

Shared pointer to the node

function

std::shared_ptr< ImageFilters > build(ImageFiltersPresetMode presetMode)

Build the node.

Parameters

presetMode: Preset mode for image filters

Returns

Shared pointer to the node

function

void run()

function

void setRunOnHost(bool runOnHost)

Specify whether to run on host or device By default, the node will run on device.

function

bool runOnHost()

Check if the node is set to run on host

function

void setDefaultProfilePreset(ImageFiltersPresetMode mode)

Set default profile preset for ImageFilters.

Parameters

mode: Preset mode for ImageFilters.

inline function

DeviceNodeCRTP()

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props, bool confMode)

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device, std::unique_ptr< Properties > props, bool confMode)

class

dai::node::ToFDepthConfidenceFilter

#include ImageFilters.hpp

variable

std::shared_ptr< ToFDepthConfidenceFilterConfig > initialConfig

Initial config for ToF depth confidence filter.

variable

Node::Input depth

Depth frame image, expected ImgFrame type is RAW8 or RAW16.

variable

Node::Input amplitude

Amplitude frame image, expected ImgFrame type is RAW8 or RAW16.

variable

Node::Output filteredDepth

RAW16 encoded filtered depth frame

variable

Node::Output confidence

RAW16 encoded confidence frame

variable

Node::Input inputConfig

Config message for runtime filter configuration

function

std::shared_ptr< ToFDepthConfidenceFilter > build(Node::Output & depth, Node::Output & amplitude, ImageFiltersPresetMode presetMode)

Build the node.

Parameters

depth: Depth frame image, expected ImgFrame type is RAW8 or RAW16.
amplitude: Amplitude frame image, expected ImgFrame type is RAW8 or RAW16.
presetMode: Preset mode for ToF depth confidence filter

Returns

Shared pointer to the node

function

std::shared_ptr< ToFDepthConfidenceFilter > build(ImageFiltersPresetMode presetMode)

Build the node.

Parameters

presetMode: Preset mode for ToF depth confidence filter

Returns

Shared pointer to the node

function

void run()

function

void setRunOnHost(bool runOnHost)

Specify whether to run on host or device By default, the node will run on device.

function

bool runOnHost()

Check if the node is set to run on host

inline function

DeviceNodeCRTP()

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props, bool confMode)

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device, std::unique_ptr< Properties > props, bool confMode)

class

dai::node::ImageManip

#include ImageManip.hpp

variable

std::shared_ptr< ImageManipConfig > initialConfig

Initial config to use when manipulating frames

variable

Input inputConfig

Input ImageManipConfig message with ability to modify parameters in runtime

variable

Input inputImage

Input image to be modified

variable

Output out

Outputs ImgFrame message that carries modified image.

function

ImageManip()

function

ImageManip(std::unique_ptr< Properties > props)

inline function

std::shared_ptr< ImageManip > build()

function

void setNumFramesPool(int numFramesPool)

Specify number of frames in pool.

Parameters

numFramesPool: How many frames should the pool have

function

void setMaxOutputFrameSize(int maxFrameSize)

Specify maximum size of output image.

Parameters

maxFrameSize: Maximum frame size in bytes

function

ImageManip & setRunOnHost(bool runOnHost)

Specify whether to run on host or device

Parameters

runOnHost: Run node on host

function

ImageManip & setBackend(Backend backend)

Set CPU as backend preference

Parameters

backend: Backend preference

function

ImageManip & setPerformanceMode(PerformanceMode performanceMode)

Set performance mode

Parameters

performanceMode: Performance mode

function

bool runOnHost()

Check if the node is set to run on host

function

void run()

inline function

DeviceNodeCRTP()

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props, bool confMode)

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device, std::unique_ptr< Properties > props, bool confMode)

enum

ImageManipProperties::Backend Backend

enum

ImageManipProperties::PerformanceMode PerformanceMode

class

dai::node::MessageDemux

variable

Input input

Input message of type MessageGroup

variable

OutputMap outputs

A map of outputs, where keys are same as in the input MessageGroup

function

~MessageDemux()

function

void setProcessor(ProcessorType type)

Specify on which processor the node should run. RVC2 only.

Parameters

type: Processor type - Leon CSS or Leon MSS

function

ProcessorType getProcessor()

Get on which processor the node should run

Returns

Processor type - Leon CSS or Leon MSS

inline function

DeviceNodeCRTP()

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props, bool confMode)

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device, std::unique_ptr< Properties > props, bool confMode)

class

dai::node::MonoCamera

#include MonoCamera.hpp

variable

CameraControl initialControl

Initial control options to apply to sensor

variable

Input inputControl

Input for CameraControl message, which can modify camera parameters in runtime Default queue is blocking with size 8

variable

Input mockIsp

Input for mocking 'isp' functionality. Default queue is blocking with size 8

variable

Output out

Outputs ImgFrame message that carries RAW8 encoded (grayscale) frame data.Suitable for use StereoDepth node. Processed by ISP

variable

Output raw

Outputs ImgFrame message that carries RAW10-packed (MIPI CSI-2 format) frame data.Captured directly from the camera sensor

variable

Output frameEvent

function

MonoCamera()

function

MonoCamera(std::unique_ptr< Properties > props)

function

void setBoardSocket(CameraBoardSocket boardSocket)

Specify which board socket to use

Parameters

boardSocket: Board socket to use

function

CameraBoardSocket getBoardSocket()

Retrieves which board socket to use

Returns

Board socket to use

function

void setCamera(std::string name)

Specify which camera to use by name

Parameters

name: Name of the camera to use

function

std::string getCamera()

Retrieves which camera to use by name

Returns

Name of the camera to use

function

void setCamId(int64_t id)

function

int64_t getCamId()

function

void setImageOrientation(CameraImageOrientation imageOrientation)

function

CameraImageOrientation getImageOrientation()

function

void setMockIspSize(int width, int height)

function

void setResolution(Properties::SensorResolution resolution)

function

Properties::SensorResolution getResolution()

function

void setFrameEventFilter(const std::vector< dai::FrameEvent > & events)

function

std::vector< dai::FrameEvent > getFrameEventFilter()

function

void setFps(float fps)

Set rate at which camera should produce frames

Parameters

fps: Rate in frames per second

function

void setIsp3aFps(int isp3aFps)

function

float getFps()

Get rate at which camera should produce frames

Returns

Rate in frames per second

function

std::tuple< int, int > getResolutionSize()

function

int getResolutionWidth()

function

int getResolutionHeight()

function

void setNumFramesPool(int num)

function

void setRawNumFramesPool(int num)

function

int getNumFramesPool()

function

int getRawNumFramesPool()

function

void setRawOutputPacked(bool packed)

Configures whether the camera ToF.

inline function

DeviceNodeCRTP()

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props, bool confMode)

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device, std::unique_ptr< Properties > props, bool confMode)

class

dai::node::NeuralAssistedStereo

#include NeuralAssistedStereo.hpp

variable

Subnode< node::Rectification > rectification

variable

Subnode< node::NeuralDepth > neuralDepth

variable

Subnode< node::Vpp > vpp

variable

Subnode< node::StereoDepth > stereoDepth

variable

Input & left

variable

Input & right

variable

Output & rectifiedLeft

variable

Output & rectifiedRight

variable

Output & vppLeft

variable

Output & vppRight

variable

Output & neuralDisparity

variable

Output & neuralConfidence

variable

Input & inputVppConfig

variable

Input & inputStereoConfig

variable

Input & inputNeuralConfig

variable

Output & depth

variable

Output & disparity

function

~NeuralAssistedStereo()

function

NeuralAssistedStereo(const std::shared_ptr< Device > & device)

function

std::shared_ptr< NeuralAssistedStereo > build(Output & leftInput, Output & rightInput, DeviceModelZoo neuralModel, bool rectifyImages)

enum

Node::Input Input

enum

Node::Output Output

class

dai::node::NeuralDepth

#include NeuralDepth.hpp

variable

std::shared_ptr< NeuralDepthConfig > initialConfig

Initial config to use for NeuralDepth.

variable

Subnode< Sync > sync

variable

Subnode< MessageDemux > messageDemux

variable

Subnode< Rectification > rectification

variable

Subnode< NeuralNetwork > neuralNetwork

variable

Input & left

Input for left ImgFrame of left-right pair

variable

Input & right

Input for right ImgFrame of left-right pair

variable

Output & rectifiedLeft

Output for rectified left ImgFrame

variable

Output & rectifiedRight

Output for rectified right ImgFrame

variable

Input inputConfig

Input config to modify parameters in runtime.

variable

Input nnDataInput

Input NNData to parse

variable

Input leftInternal

Input left frame internal, used to extract frame info

variable

Input rightInternal

Input right frame internal, used to extract frame info

variable

Output disparity

Output disparity ImgFrame

variable

Output depth

Output depth ImgFrame

variable

Output edge

Output edge ImgFrame

variable

Output confidence

Output confidence ImgFrame

function

NeuralDepth()

function

NeuralDepth & setRectification(bool enable)

Enable or disable rectification (useful for prerectified inputs)

function

std::shared_ptr< NeuralDepth > build(Output & left, Output & right, DeviceModelZoo model)

function

void buildInternal()

class

dai::node::NeuralNetwork

#include NeuralNetwork.hpp

variable

Input input

Input message with data to be inferred upon

variable

Output out

Outputs NNData message that carries inference results

variable

Output passthrough

Passthrough message on which the inference was performed.Suitable for when input queue is set to non-blocking behavior.

variable

InputMap inputs

Inputs mapped to network inputs. Useful for inferring from separate data sources Default input is non-blocking with queue size 1 and waits for messages

variable

OutputMap passthroughs

Passthroughs which correspond to specified input

function

~NeuralNetwork()

function

std::shared_ptr< NeuralNetwork > build(Node::Output & input, const NNArchive & nnArchive)

function

std::shared_ptr< NeuralNetwork > build(const std::shared_ptr< Camera > & input, const Model & model, std::optional< float > fps, std::optional< dai::ImgResizeMode > resizeMode)

function

std::shared_ptr< NeuralNetwork > build(const std::shared_ptr< Camera > & input, const Model & model, const ImgFrameCapability & capability)

function

std::shared_ptr< NeuralNetwork > build(const std::shared_ptr< ReplayVideo > & input, const Model & model, std::optional< float > fps)

function

std::optional< std::reference_wrapper< const NNArchive > > getNNArchive()

function

void setNNArchive(const NNArchive & nnArchive)

function

void setNNArchive(const NNArchive & nnArchive, int numShaves)

function

void setFromModelZoo(NNModelDescription description, bool useCached)

function

void setBlobPath(const std::filesystem::path & path)

Load network blob into assets and use once pipeline is started.

Parameters

Error: if file doesn't exist or isn't a valid network blob.

Parameters

path: Path to network blob

function

void setBlob(OpenVINO::Blob blob)

Load network blob into assets and use once pipeline is started.

Parameters

blob: Network blob

function

void setBlob(const std::filesystem::path & path)

Same functionality as the setBlobPath(). Load network blob into assets and use once pipeline is started.

Parameters

Error: if file doesn't exist or isn't a valid network blob.

Parameters

path: Path to network blob

function

void setOtherModelFormat(std::vector< uint8_t > model)

Load network model into assets and use once pipeline is started.

Parameters

model: Network model

function

void setOtherModelFormat(const std::filesystem::path & path)

Load network model into assets and use once pipeline is started.

Parameters

Error: if file doesn't exist or isn't a valid network model.

Parameters

path: Path to the network model

function

void setModelPath(const std::filesystem::path & modelPath)

Load network xml and bin files into assets.

Parameters

xmlModelPath: Path to the neural network model file.

function

void setNumPoolFrames(int numFrames)

Specifies how many frames will be available in the pool

Parameters

numFrames: How many frames will pool have

function

void setNumInferenceThreads(int numThreads)

How many threads should the node use to run the network.

Parameters

numThreads: Number of threads to dedicate to this node

function

void setNumNCEPerInferenceThread(int numNCEPerThread)

How many Neural Compute Engines should a single thread use for inference

Parameters

numNCEPerThread: Number of NCE per thread

function

void setNumShavesPerInferenceThread(int numShavesPerThread)

How many Shaves should a single thread use for inference

Parameters

numShavesPerThread: Number of shaves per thread

function

void setBackend(std::string backend)

Specifies backend to use

Parameters

backend: String specifying backend to use

function

void setBackendProperties(std::map< std::string, std::string > properties)

Set backend properties

Parameters

backendProperties: backend properties map

function

int getNumInferenceThreads()

How many inference threads will be used to run the network

Returns

Number of threads, 0, 1 or 2. Zero means AUTO

function

void setModelFromDeviceZoo(DeviceModelZoo model)

Set model from Device Model Zoo

Parameters

model: DeviceModelZoo model enum

Parameters

Only applicable for RVC4 devices with OS 1.20.5 or higher

inline function

DeviceNodeCRTP()

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props, bool confMode)

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device, std::unique_ptr< Properties > props, bool confMode)

enum

std::variant< NNModelDescription, NNArchive, std::string > Model

class

dai::node::ObjectTracker

#include ObjectTracker.hpp

variable

Input inputTrackerFrame

Input ImgFrame message on which tracking will be performed. RGBp, BGRp, NV12, YUV420p types are supported. Default queue is non-blocking with size 4.

variable

Input inputDetectionFrame

Input ImgFrame message on which object detection was performed. Default queue is non-blocking with size 4.

variable

Input inputDetections

Input message with image detection from neural network. Default queue is non-blocking with size 4.

variable

Input inputConfig

Input ObjectTrackerConfig message with ability to modify parameters at runtime. Default queue is non-blocking with size 4.

variable

Output out

Outputs Tracklets message that carries object tracking results.

variable

Output passthroughTrackerFrame

Passthrough ImgFrame message on which tracking was performed. Suitable for when input queue is set to non-blocking behavior.

variable

Output passthroughDetectionFrame

Passthrough ImgFrame message on which object detection was performed. Suitable for when input queue is set to non-blocking behavior.

variable

Output passthroughDetections

Passthrough image detections message from neural network output. Suitable for when input queue is set to non-blocking behavior.

function

void setTrackerThreshold(float threshold)

Specify tracker threshold.

Parameters

threshold: Above this threshold the detected objects will be tracked. Default 0, all image detections are tracked.

function

void setMaxObjectsToTrack(std::int32_t maxObjectsToTrack)

Specify maximum number of object to track.

Parameters

maxObjectsToTrack: Maximum number of object to track. Maximum 60 in case of SHORT_TERM_KCF, otherwise 1000.

function

void setDetectionLabelsToTrack(std::vector< std::uint32_t > labels)

Specify detection labels to track.

Parameters

labels: Detection labels to track. Default every label is tracked from image detection network output.

function

void setTrackerType(TrackerType type)

Specify tracker type algorithm.

Parameters

type: Tracker type.

function

void setTrackerIdAssignmentPolicy(TrackerIdAssignmentPolicy type)

Specify tracker ID assignment policy.

Parameters

type: Tracker ID assignment policy.

function

void setTrackingPerClass(bool trackingPerClass)

Whether tracker should take into consideration class label for tracking.

function

void setOcclusionRatioThreshold(float theshold)

Set the occlusion ratio threshold. Used to filter out overlapping tracklets.

Parameters

theshold: Occlusion ratio threshold. Default 0.3.

function

void setTrackletMaxLifespan(uint32_t trackletMaxLifespan)

Set the tracklet lifespan in number of frames. Number of frames after which a LOST tracklet is removed.

Parameters

trackletMaxLifespan: Tracklet lifespan in number of frames. Default 120.

function

void setTrackletBirthThreshold(uint32_t trackletBirthThreshold)

Set the tracklet birth threshold. Minimum consecutive tracked frames required to consider a tracklet as a new (TRACKED) instance.

Parameters

trackletBirthThreshold: Tracklet birth threshold. Default 3.

function

void setRunOnHost(bool runOnHost)

Specify whether to run on host or device By default, the node will run on device.

function

bool runOnHost()

Check if the node is set to run on host

function

void run()

inline function

DeviceNodeCRTP()

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props, bool confMode)

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device, std::unique_ptr< Properties > props, bool confMode)

class

dai::node::PointCloud

#include PointCloud.hpp

variable

std::shared_ptr< PointCloudConfig > initialConfig

Initial config to use when computing the point cloud.

variable

Input inputConfig

Input PointCloudConfig message with ability to modify parameters in runtime. Default queue is non-blocking with size 4.

variable

Input inputDepth

Input message with depth data used to create the point cloud. Default queue is non-blocking with size 4.

variable

Output outputPointCloud

Outputs PointCloudData message

variable

Output passthroughDepth

Passthrough depth from which the point cloud was calculated. Suitable for when input queue is set to non-blocking behavior.

function

void setNumFramesPool(int numFramesPool)

Specify number of frames in pool.

Parameters

numFramesPool: How many frames should the pool have

class

dai::node::Rectification

variable

Input input1

Input images to be rectified

variable

Input input2

variable

Output passthrough1

Passthrough for input messages (so the node can be placed between other nodes)

variable

Output passthrough2

variable

Output output1

Send outputs

variable

Output output2

function

void setRunOnHost(bool runOnHost)

Specify whether to run on host or device By default, the node will run on device.

function

Rectification & setOutputSize(uint32_t width, uint32_t height)

Set output size

inline function

Rectification & setOutputSize(std::pair< uint32_t, uint32_t > size)

Set output size

inline function

Rectification & enableRectification(bool enable)

Enable or disable rectification (useful for minimal changes during debugging)

function

bool runOnHost()

Check if the node is set to run on host

function

void run()

function

CalibrationHandler getCalibrationData()

inline function

DeviceNodeCRTP()

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props, bool confMode)

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device, std::unique_ptr< Properties > props, bool confMode)

class

dai::node::SPIIn

#include SPIIn.hpp

variable

Output out

Outputs message of same type as send from host.

function

void setStreamName(const std::string & name)

Specifies stream name over which the node will receive data

Parameters

name: Stream name

function

void setBusId(int id)

Specifies SPI Bus number to use

Parameters

id: SPI Bus id

function

void setMaxDataSize(std::uint32_t maxDataSize)

Set maximum message size it can receive

Parameters

maxDataSize: Maximum size in bytes

function

void setNumFrames(std::uint32_t numFrames)

Set number of frames in pool for sending messages forward

Parameters

numFrames: Maximum number of frames in pool

function

std::string getStreamName()

function

int getBusId()

function

std::uint32_t getMaxDataSize()

function

std::uint32_t getNumFrames()

function

void buildInternal()

inline function

DeviceNodeCRTP()

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props, bool confMode)

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device, std::unique_ptr< Properties > props, bool confMode)

class

dai::node::SPIOut

#include SPIOut.hpp

variable

Input input

Input for any type of messages to be transferred over SPI stream Default queue is blocking with size 8

inline function

void setStreamName(std::string name)

Specifies stream name over which the node will send data

Parameters

name: Stream name

inline function

void setBusId(int busId)

Specifies SPI Bus number to use

Parameters

id: SPI Bus id

inline function

void buildInternal()

inline function

DeviceNodeCRTP()

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props, bool confMode)

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device, std::unique_ptr< Properties > props, bool confMode)

class

dai::node::Script

variable

InputMap inputs

Inputs to Script node. Can be accessed using subscript operator (Eg: inputs['in1']) By default inputs are set to blocking with queue size 8

variable

OutputMap outputs

Outputs from Script node. Can be accessed subscript operator (Eg: outputs['out1'])

function

void setScriptPath(const std::filesystem::path & path, const std::string & name)

Specify local filesystem path to load the script

Parameters

path: Filesystem path to load the script
name: Optionally set a name of this script, otherwise the name defaults to the path

function

void setScript(const std::string & script, const std::string & name)

Sets script data to be interpreted

Parameters

script: Script string to be interpreted
name: Optionally set a name of this script

function

void setScript(const std::vector< std::uint8_t > & data, const std::string & name)

Sets script data to be interpreted

Parameters

data: Binary data that represents the script to be interpreted
name: Optionally set a name of this script

function

std::filesystem::path getScriptPath()

function

std::string getScriptName()

function

void setProcessor(ProcessorType type)

Set on which processor the script should run

Parameters

type: Processor type - Leon CSS or Leon MSS

function

ProcessorType getProcessor()

Get on which processor the script should run

Returns

Processor type - Leon CSS or Leon MSS

function

void buildInternal()

function

void buildStage1()

inline function

DeviceNodeCRTP()

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props, bool confMode)

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device, std::unique_ptr< Properties > props, bool confMode)

class

dai::node::SegmentationParser

#include SegmentationParser.hpp

variable

std::shared_ptr< SegmentationParserConfig > initialConfig

Initial config to use when parsing segmentation masks.

variable

Input input

Input NN results with segmentation data to parser

variable

Input inputConfig

Input SegmentationParserConfig message with ability to modify parameters in runtime.

variable

Output out

Outputs segmentation mask

function

~SegmentationParser()

function

SegmentationParser()

inline function

SegmentationParser(std::unique_ptr< Properties > props)

function

std::shared_ptr< SegmentationParser > build(Node::Output & nnInput, const Model & model)

function

std::shared_ptr< SegmentationParser > build(Node::Output & nnInput, const dai::nn_archive::v1::Head & head)

function

void setLabels(const std::vector< std::string > & labels)

Sets the class labels associated with the segmentation mask. The label at index $i$ in the

Parameters

labels: Vector of class labels

function

std::vector< std::string > getLabels()

Returns the class labels associated with the segmentation mask.

function

void setBackgroundClass(bool backgroundClass)

Sets whether the first class (index 0) is considered the background class. If true, the pixels classified as index 0 will be treated as background.

Parameters

backgroundClass: Boolean indicating if the first class is the background class

Parameters

Only applicable if the number of classes is greater than 1 and the output classes are not in a single layer (eg. classesInOneLayer = false).

function

bool getBackgroundClass()

Gets whether the first class (index 0) is considered the background class.

function

void setRunOnHost(bool runOnHost)

Specify whether to run on host or device By default, the node will run on device.

function

bool runOnHost()

Check if the node is set to run on host

function

void run()

function

void buildInternal()

inline function

DeviceNodeCRTP()

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props, bool confMode)

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device, std::unique_ptr< Properties > props, bool confMode)

enum

std::variant< NNModelDescription, NNArchive, std::string > Model

class

dai::node::SpatialDetectionNetwork

#include SpatialDetectionNetwork.hpp

variable

Properties & properties

variable

Subnode< NeuralNetwork > neuralNetwork

variable

Subnode< DetectionParser > detectionParser

variable

Subnode< SpatialLocationCalculator > spatialLocationCalculator

variable

std::unique_ptr< Subnode< ImageAlign > > depthAlign

variable

Input & input

Input message with data to be inferred upon Default queue is blocking with size 5

variable

Output & outNetwork

Outputs unparsed inference results.

variable

Output & passthrough

Passthrough message on which the inference was performed.Suitable for when input queue is set to non-blocking behavior.

variable

Input & inputDepth

Input message with depth data used to retrieve spatial information about detected object Default queue is non-blocking with size 4

variable

Output & out

Outputs ImgDetections message that carries parsed detection results.

variable

Output & passthroughDepth

Passthrough message for depth frame on which the spatial location calculation was performed. Suitable for when input queue is set to non-blocking behavior.

explicit function

SpatialDetectionNetwork(const std::shared_ptr< Device > & device)

explicit function

SpatialDetectionNetwork(std::unique_ptr< Properties > props)

function

SpatialDetectionNetwork(std::unique_ptr< Properties > props, bool confMode)

function

SpatialDetectionNetwork(const std::shared_ptr< Device > & device, std::unique_ptr< Properties > props, bool confMode)

function

std::shared_ptr< SpatialDetectionNetwork > build(const std::shared_ptr< Camera > & inputRgb, const DepthSource & depthSource, const Model & model, std::optional< float > fps, std::optional< dai::ImgResizeMode > resizeMode)

function

std::shared_ptr< SpatialDetectionNetwork > build(const std::shared_ptr< Camera > & inputRgb, const DepthSource & depthSource, const Model & model, const ImgFrameCapability & capability)

function

void setNNArchive(const NNArchive & nnArchive)

function

void setFromModelZoo(NNModelDescription description, bool useCached)

function

void setNNArchive(const NNArchive & nnArchive, int numShaves)

function

void setBlobPath(const std::filesystem::path & path)

Backwards compatibility interface Load network blob into assets and use once pipeline is started.

Parameters

Error: if file doesn't exist or isn't a valid network blob.

Parameters

path: Path to network blob

function

void setBlob(OpenVINO::Blob blob)

Load network blob into assets and use once pipeline is started.

Parameters

blob: Network blob

function

void setBlob(const std::filesystem::path & path)

Same functionality as the setBlobPath(). Load network blob into assets and use once pipeline is started.

Parameters

Error: if file doesn't exist or isn't a valid network blob.

Parameters

path: Path to network blob

function

void setModelPath(const std::filesystem::path & modelPath)

Load network file into assets.

Parameters

modelPath: Path to the model file.

function

void setNumPoolFrames(int numFrames)

Specifies how many frames will be available in the pool

Parameters

numFrames: How many frames will pool have

function

void setNumInferenceThreads(int numThreads)

How many threads should the node use to run the network.

Parameters

numThreads: Number of threads to dedicate to this node

function

void setNumNCEPerInferenceThread(int numNCEPerThread)

How many Neural Compute Engines should a single thread use for inference

Parameters

numNCEPerThread: Number of NCE per thread

function

void setNumShavesPerInferenceThread(int numShavesPerThread)

How many Shaves should a single thread use for inference

Parameters

numShavesPerThread: Number of shaves per thread

function

void setBackend(std::string backend)

Specifies backend to use

Parameters

backend: String specifying backend to use

function

void setBackendProperties(std::map< std::string, std::string > properties)

Set backend properties

Parameters

backendProperties: backend properties map

function

int getNumInferenceThreads()

How many inference threads will be used to run the network

Returns

Number of threads, 0, 1 or 2. Zero means AUTO

function

void setConfidenceThreshold(float thresh)

Specifies confidence threshold at which to filter the rest of the detections.

Parameters

thresh: Detection confidence must be greater than specified threshold to be added to the list

function

float getConfidenceThreshold()

Retrieves threshold at which to filter the rest of the detections.

Returns

Detection confidence

function

void setBoundingBoxScaleFactor(float scaleFactor)

Custom interface Specifies scale factor for detected bounding boxes.

Parameters

scaleFactor: Scale factor must be in the interval (0,1].

function

void setDepthLowerThreshold(uint32_t lowerThreshold)

Specifies lower threshold in depth units (millimeter by default) for depth values which will used to calculate spatial data

Parameters

lowerThreshold: LowerThreshold must be in the interval [0,upperThreshold] and less than upperThreshold.

function

void setDepthUpperThreshold(uint32_t upperThreshold)

Specifies upper threshold in depth units (millimeter by default) for depth values which will used to calculate spatial data

Parameters

upperThreshold: UpperThreshold must be in the interval (lowerThreshold,65535].

function

void setSpatialCalculationAlgorithm(dai::SpatialLocationCalculatorAlgorithm calculationAlgorithm)

Specifies spatial location calculator algorithm: Average/Min/Max

Parameters

calculationAlgorithm: Calculation algorithm.

function

void setSpatialCalculationStepSize(int stepSize)

Specifies spatial location calculator step size for depth calculation. Step size 1 means that every pixel is taken into calculation, size 2 means every second etc.

Parameters

stepSize: Step size.

function

std::optional< std::vector< std::string > > getClasses()

function

void buildInternal()

enum

SpatialDetectionNetworkProperties Properties

enum

NeuralNetwork::Model Model

class

dai::node::SpatialLocationCalculator

#include SpatialLocationCalculator.hpp

variable

std::shared_ptr< SpatialLocationCalculatorConfig > initialConfig

Initial config to use when calculating spatial location data.

variable

Input inputConfig

Input SpatialLocationCalculatorConfig message with ability to modify parameters in runtime. Default queue is non-blocking with size 4.

variable

Input inputDetections

Input messages on which spatial location will be calculated. Possible datatypes are ImgDetections or Keypoints.

variable

Input inputDepth

Input message with depth data used to retrieve spatial information about detected object. Default queue is non-blocking with size 4.

variable

Output out

Outputs SpatialLocationCalculatorData message that carries spatial locations for each additional ROI that is specified in the config.

variable

Output outputDetections

Outputs SpatialImgDetections message that carries spatial locations along with original input data.

variable

Output passthroughDepth

Passthrough message on which the calculation was performed. Suitable for when input queue is set to non-blocking behavior.

function

SpatialLocationCalculator()

inline function

SpatialLocationCalculator(std::unique_ptr< Properties > props)

function

void setRunOnHost(bool runOnHost)

Specify whether to run on host or device By default, the node will run on device.

function

bool runOnHost()

Check if the node is set to run on host

function

void run()

inline function

DeviceNodeCRTP()

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props, bool confMode)

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device, std::unique_ptr< Properties > props, bool confMode)

class

dai::node::StereoDepth

#include StereoDepth.hpp

variable

std::shared_ptr< StereoDepthConfig > initialConfig

Initial config to use for StereoDepth.

variable

Input inputConfig

Input StereoDepthConfig message with ability to modify parameters in runtime.

variable

Input inputAlignTo

Input align to message. Default queue is non-blocking with size 1.

variable

Input left

Input for left ImgFrame of left-right pair

variable

Input right

Input for right ImgFrame of left-right pair

variable

Output depth

Outputs ImgFrame message that carries RAW16 encoded (0..65535) depth data in depth units (millimeter by default).Non-determined / invalid depth values are set to 0

variable

Output disparity

Outputs ImgFrame message that carries RAW8 / RAW16 encoded disparity data: RAW8 encoded (0..95) for standard mode; RAW8 encoded (0..190) for extended disparity mode; RAW16 encoded for subpixel disparity mode:

0..760 for 3 fractional bits (by default)
0..1520 for 4 fractional bits
0..3040 for 5 fractional bits

variable

Output syncedLeft

Passthrough ImgFrame message from 'left' Input.

variable

Output syncedRight

Passthrough ImgFrame message from 'right' Input.

variable

Output rectifiedLeft

Outputs ImgFrame message that carries RAW8 encoded (grayscale) rectified frame data.

variable

Output rectifiedRight

Outputs ImgFrame message that carries RAW8 encoded (grayscale) rectified frame data.

variable

Output outConfig

Outputs StereoDepthConfig message that contains current stereo configuration.

variable

Output debugDispLrCheckIt1

Outputs ImgFrame message that carries left-right check first iteration (before combining with second iteration) disparity map. Useful for debugging/fine tuning.

variable

Output debugDispLrCheckIt2

Outputs ImgFrame message that carries left-right check second iteration (before combining with first iteration) disparity map. Useful for debugging/fine tuning.

variable

Output debugExtDispLrCheckIt1

Outputs ImgFrame message that carries extended left-right check first iteration (downscaled frame, before combining with second iteration) disparity map. Useful for debugging/fine tuning.

variable

Output debugExtDispLrCheckIt2

Outputs ImgFrame message that carries extended left-right check second iteration (downscaled frame, before combining with first iteration) disparity map. Useful for debugging/fine tuning.

variable

Output debugDispCostDump

Outputs ImgFrame message that carries cost dump of disparity map. Useful for debugging/fine tuning.

variable

Output confidenceMap

Outputs ImgFrame message that carries RAW8 confidence map. Lower values mean lower confidence of the calculated disparity value. RGB alignment, left-right check or any postprocessing (e.g., median filter) is not performed on confidence map.

function

StereoDepth()

inline function

std::shared_ptr< StereoDepth > build(Node::Output & left, Node::Output & right, PresetMode presetMode)

function

std::shared_ptr< StereoDepth > build(bool autoCreateCameras, PresetMode presetMode, std::pair< int, int > size, std::optional< float > fps)

Create StereoDepth node. Note that this API is global and if used autocreated cameras can't be reused.

Parameters

autoCreateCameras: If true, will create left and right nodes if they don't exist
presetMode: Preset mode for stereo depth

function

void loadMeshFiles(const std::filesystem::path & pathLeft, const std::filesystem::path & pathRight)

Specify local filesystem paths to the mesh calibration files for 'left' and 'right' inputs.When a mesh calibration is set, it overrides the camera intrinsics/extrinsics matrices. Overrides useHomographyRectification behavior. Mesh format: a sequence of (y,x) points as 'float' with coordinates from the input image to be mapped in the output. The mesh can be subsampled, configured by With a 1280x800 resolution and the default (16,16) step, the required mesh size is:width: 1280 / 16 + 1 = 81height: 800 / 16 + 1 = 51

function

void loadMeshData(const std::vector< std::uint8_t > & dataLeft, const std::vector< std::uint8_t > & dataRight)

Specify mesh calibration data for 'left' and 'right' inputs, as vectors of bytes. Overrides useHomographyRectification behavior. See

function

void setMeshStep(int width, int height)

Set the distance between mesh points. Default: (16, 16)

function

void setInputResolution(int width, int height)

Specify input resolution sizeOptional if MonoCamera exists, otherwise necessary

function

void setInputResolution(std::tuple< int, int > resolution)

Specify input resolution sizeOptional if MonoCamera exists, otherwise necessary

function

void setOutputSize(int width, int height)

Specify disparity/depth output resolution size, implemented by scaling.Currently only applicable when aligning to RGB camera

function

void setOutputKeepAspectRatio(bool keep)

Specifies whether the frames resized by

function

void setDepthAlign(Properties::DepthAlign align)

Parameters

align: Set the disparity/depth alignment: centered (between the 'left' and 'right' inputs), or from the perspective of a rectified output stream

function

void setDepthAlign(CameraBoardSocket camera)

Parameters

camera: Set the camera from whose perspective the disparity/depth will be aligned

function

void setRectification(bool enable)

Rectify input images or not.

function

void setLeftRightCheck(bool enable)

Computes and combines disparities in both L-R and R-L directions, and combine them.For better occlusion handling, discarding invalid disparity values

function

void setSubpixel(bool enable)

Computes disparity with sub-pixel interpolation (3 fractional bits by default).Suitable for long range. Currently incompatible with extended disparity

function

void setSubpixelFractionalBits(int subpixelFractionalBits)

function

void setExtendedDisparity(bool enable)

Disparity range increased from 0-95 to 0-190, combined from full resolution and downscaled images.Suitable for short range objects. Currently incompatible with sub-pixel disparity

function

void setRectifyEdgeFillColor(int color)

Fill color for missing data at frame edges

Parameters

color: Grayscale 0..255, or -1 to replicate pixels

function

void setRuntimeModeSwitch(bool enable)

Enable runtime stereo mode switch, e.g. from standard to LR-check. Note: when enabled resources allocated for worst case to enable switching to any mode.

function

void setNumFramesPool(int numFramesPool)

Specify number of frames in pool.

Parameters

numFramesPool: How many frames should the pool have

function

void setPostProcessingHardwareResources(int numShaves, int numMemorySlices)

Specify allocated hardware resources for stereo depth. Suitable only to increase post processing runtime.

Parameters

numShaves: Number of shaves.
numMemorySlices: Number of memory slices.

function

void setDefaultProfilePreset(PresetMode mode)

Sets a default preset based on specified option.

Parameters

mode: Stereo depth preset mode

function

void useHomographyRectification(bool useHomographyRectification)

Parameters

useHomographyRectification: true: 3x3 homography matrix generated from calibration data is used for stereo rectification, can't correct lens distortion. false: sparse mesh is generated on-device from calibration data with mesh step specified with setMeshStep (Default: (16, 16)), can correct lens distortion. Implementation for generating the mesh is same as opencv's initUndistortRectifyMap function. Only the first 8 distortion coefficients are used from calibration data.

function

void enableDistortionCorrection(bool enableDistortionCorrection)

Equivalent to useHomographyRectification(!enableDistortionCorrection)

function

void setFrameSync(bool enableFrameSync)

Whether to enable frame syncing inside stereo node or not. Suitable if inputs are known to be synced.

function

void setBaseline(float baseline)

Override baseline from calibration. Used only in disparity to depth conversion. Units are centimeters.

function

void setFocalLength(float focalLength)

Override focal length from calibration. Used only in disparity to depth conversion. Units are pixels.

function

void setDisparityToDepthUseSpecTranslation(bool specTranslation)

Use baseline information for disparity to depth conversion from specs (design data) or from calibration. Default: true

function

void setRectificationUseSpecTranslation(bool specTranslation)

Obtain rectification matrices using spec translation (design data) or from calibration in calculations. Should be used only for debugging. Default: false

function

void setDepthAlignmentUseSpecTranslation(bool specTranslation)

Use baseline information for depth alignment from specs (design data) or from calibration. Default: true

function

void setAlphaScaling(float alpha)

enum

std::uint32_t PresetMode

Preset modes for stereo depth.

enumerator

FAST_ACCURACY

enumerator

FAST_DENSITY

enumerator

DEFAULT

enumerator

FACE

enumerator

HIGH_DETAIL

enumerator

ROBOTICS

enumerator

DENSITY

enumerator

ACCURACY

enum

dai::StereoDepthConfig::MedianFilter MedianFilter

class

dai::node::Sync

#include Sync.hpp

variable

InputMap inputs

A map of inputs

variable

Output out

Output message of type MessageGroup

function

void setSyncThreshold(std::chrono::nanoseconds syncThreshold)

Set the maximal interval between messages in the group

Parameters

syncThreshold: Maximal interval between messages in the group

function

void setSyncAttempts(int syncAttempts)

Set the number of attempts to get the specified max interval between messages in the group

Parameters

syncAttempts: Number of attempts to get the specified max interval between messages in the group:
- if syncAttempts = 0 then the node sends a message as soon at the group is filled
- if syncAttempts > 0 then the node will make syncAttemts attempts to synchronize before sending out a message
- if syncAttempts = -1 (default) then the node will only send a message if successfully synchronized

function

void setProcessor(ProcessorType type)

Specify on which processor the node should run. RVC2 only.

Parameters

type: Processor type - Leon CSS or Leon MSS

function

ProcessorType getProcessor()

Get on which processor the node should run

Returns

Processor type - Leon CSS or Leon MSS

function

std::chrono::nanoseconds getSyncThreshold()

Gets the maximal interval between messages in the group in milliseconds

function

int getSyncAttempts()

Gets the number of sync attempts

function

void setRunOnHost(bool runOnHost)

Specify whether to run on host or device By default, the node will run on device.

function

bool runOnHost()

Check if the node is set to run on host

function

void run()

inline function

DeviceNodeCRTP()

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props, bool confMode)

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device, std::unique_ptr< Properties > props, bool confMode)

class

dai::node::SystemLogger

#include SystemLogger.hpp

variable

Output out

Outputs SystemInformation[RVC4] message that carries various system information like memory and CPU usage, temperatures, ... For series 2 devices output SystemInformation message, for series 4 devices output SystemInformationRVC4 message

function

void setRate(float hz)

Specify logging rate, at which messages will be sent out

Parameters

hz: Sending rate in hertz (messages per second)

function

float getRate()

Gets logging rate, at which messages will be sent out

function

void buildInternal()

inline function

DeviceNodeCRTP()

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props, bool confMode)

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device, std::unique_ptr< Properties > props, bool confMode)

class

dai::node::Thermal

#include Thermal.hpp

variable

std::shared_ptr< ThermalConfig > initialConfig

Initial config to use for thermal sensor.

variable

Input inputConfig

Input ThermalConfig message with ability to modify parameters in runtime. Default queue is non-blocking with size 4.

variable

Output temperature

Outputs FP16 (degC) thermal image.

variable

Output color

Outputs YUV422i grayscale thermal image.

function

Thermal()

function

Thermal(std::unique_ptr< Properties > props)

function

std::shared_ptr< Thermal > build(dai::CameraBoardSocket boardSocket, float fps)

Build with a specific board socket and fps.

function

CameraBoardSocket getBoardSocket()

Retrieves which board socket to use

Returns

Board socket to use

function

void setFps(float fps)

inline function

DeviceNodeCRTP()

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props, bool confMode)

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device, std::unique_ptr< Properties > props, bool confMode)

class

dai::node::ToFBase

#include ToF.hpp

variable

std::shared_ptr< ToFConfig > initialConfig

Initial config to use for feature tracking.

variable

Input inputConfig

Input ToFConfig message with ability to modify parameters in runtime. Default queue is non-blocking with size 4.

variable

Output depth

variable

Output amplitude

variable

Output intensity

variable

Output phase

function

ToFBase()

function

ToFBase(std::unique_ptr< Properties > props)

function

std::shared_ptr< ToFBase > build(dai::CameraBoardSocket boardSocket, dai::ImageFiltersPresetMode presetMode, std::optional< float > fps)

Build with a specific board socket

inline function

void setProfilePreset(dai::ImageFiltersPresetMode presetMode)

Set profile preset for ToFConfig

Parameters

presetMode: Preset mode for ToFConfig

function

CameraBoardSocket getBoardSocket()

Retrieves which board socket to use

Returns

Board socket to use

inline function

DeviceNodeCRTP()

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props, bool confMode)

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device, std::unique_ptr< Properties > props, bool confMode)

class

dai::node::ToF

variable

Subnode< ToFBase > tofBase

variable

Subnode< ImageFilters > imageFilters

variable

Output & rawDepth

Raw depth output from ToF sensor

variable

Output & depth

Filtered depth output

variable

Output & amplitude

Amplitude output

variable

Output & intensity

Intensity output

variable

Output & phase

Phase output

variable

Input & tofBaseInputConfig

Input config for ToF base node

variable

Input & imageFiltersInputConfig

Input config for image filters

variable

ToFBase & tofBaseNode

ToF base node

variable

ImageFilters & imageFiltersNode

Image filters node

inline function

ToF(const std::shared_ptr< Device > & device)

function

~ToF()

inline function

void buildInternal()

inline function

std::shared_ptr< ToF > build(dai::CameraBoardSocket boardSocket, dai::ImageFiltersPresetMode presetMode, std::optional< float > fps)

class

dai::node::UVC

#include UVC.hpp

variable

Input input

Input for image frames to be streamed over UVC Default queue is blocking with size 8

function

UVC()

function

UVC(std::unique_ptr< Properties > props)

function

~UVC()

function

void setGpiosOnInit(std::unordered_map< int, int > list)

function

void setGpiosOnStreamOn(std::unordered_map< int, int > list)

function

void setGpiosOnStreamOff(std::unordered_map< int, int > list)

inline function

DeviceNodeCRTP()

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props, bool confMode)

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device, std::unique_ptr< Properties > props, bool confMode)

class

dai::node::VideoEncoder

#include VideoEncoder.hpp

variable

Input input

Input for NV12 ImgFrame to be encoded

variable

Output bitstream

Outputs ImgFrame message that carries BITSTREAM encoded (MJPEG, H264 or H265) frame data. Mutually exclusive with out.

variable

Output out

Outputs EncodedFrame message that carries encoded (MJPEG, H264 or H265) frame data. Mutually exclusive with bitstream.

function

std::shared_ptr< VideoEncoder > build(Node::Output & input)

function

void setDefaultProfilePreset(float fps, Properties::Profile profile)

Sets a default preset based on specified frame rate and profile

Parameters

fps: Frame rate in frames per second
profile: Encoding profile

function

void setNumFramesPool(int frames)

Set number of frames in pool

Parameters

frames: Number of pool frames

function

int getNumFramesPool()

Get number of frames in pool

Returns

Number of pool frames

function

void setRateControlMode(Properties::RateControlMode mode)

function

void setProfile(Properties::Profile profile)

function

void setBitrate(int bitrate)

function

void setBitrateKbps(int bitrateKbps)

function

void setKeyframeFrequency(int freq)

Set keyframe frequency. Every Nth frame a keyframe is inserted.Applicable only to H264 and H265 profilesExamples:

30 FPS video, keyframe frequency: 30. Every 1s a keyframe will be inserted
60 FPS video, keyframe frequency: 180. Every 3s a keyframe will be inserted

function

void setNumBFrames(int numBFrames)

function

void setQuality(int quality)

Set quality

Parameters

quality: Value between 0-100%. Approximates quality

function

void setLossless(bool lossless)

Set lossless mode. Applies only to [M]JPEG profile

Parameters

lossless: True to enable lossless jpeg encoding, false otherwise

function

void setFrameRate(float frameRate)

Sets expected frame rate

Parameters

frameRate: Frame rate in frames per second

function

void setMaxOutputFrameSize(int maxFrameSize)

Specifies maximum output encoded frame size

function

Properties::RateControlMode getRateControlMode()

function

Properties::Profile getProfile()

function

int getBitrate()

function

int getBitrateKbps()

function

int getKeyframeFrequency()

function

int getNumBFrames()

function

int getQuality()

function

float getFrameRate()

function

bool getLossless()

function

int getMaxOutputFrameSize()

inline function

DeviceNodeCRTP()

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props, bool confMode)

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device, std::unique_ptr< Properties > props, bool confMode)

class

dai::node::Vpp

#include Vpp.hpp

variable

std::shared_ptr< VppConfig > initialConfig

Initial config to use for VPP.

variable

Subnode< node::Sync > sync

variable

Input syncedInputs

"Synchronised Left Img, Right Img, Dispatiy and confidence input."

variable

const std::string leftInputName

variable

const std::string rightInputName

variable

const std::string disparityName

variable

const std::string confidenceName

variable

Input & left

Input for left rectified ImgFrame

variable

Input & right

Input for right rectified ImgFrame

variable

Input & disparity

Low resolution disparity in pixels (in integers - 16 times bigger)

variable

Input & confidence

Confidence of the dispatiry (in integers - 16 times bigger).

variable

Input inputConfig

variable

Output leftOut

Output ImgFrame message that carries the processed left image with virtual projection pattern applied.

variable

Output rightOut

Output ImgFrame message that carries the processed right image with virtual projection pattern applied.

function

Vpp()

function

Vpp(std::unique_ptr< Properties > props)

function

~Vpp()

function

std::shared_ptr< Vpp > build(Output & leftInput, Output & rightInput, Output & disparityInput, Output & confidenceInput)

function

void buildInternal()

inline function

DeviceNodeCRTP()

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props, bool confMode)

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device, std::unique_ptr< Properties > props, bool confMode)

class

dai::node::Warp

#include Warp.hpp

variable

Input inputImage

Input image to be modified Default queue is blocking with size 8

variable

Output out

Outputs ImgFrame message that carries warped image.

function

void setOutputSize(std::tuple< int, int > size)

Sets output frame size in pixels

Parameters

size: width and height in pixels

function

void setOutputSize(int width, int height)

function

void setWarpMesh(const std::vector< Point2f > & meshData, int width, int height)

Set a custom warp mesh

Parameters

meshData: 2D plane of mesh points, starting from top left to bottom right
width: Width of mesh
height: Height of mesh

function

void setWarpMesh(const std::vector< std::pair< float, float >> & meshData, int width, int height)

function

void setNumFramesPool(int numFramesPool)

Specify number of frames in pool.

Parameters

numFramesPool: How many frames should the pool have

function

void setMaxOutputFrameSize(int maxFrameSize)

Specify maximum size of output image.

Parameters

maxFrameSize: Maximum frame size in bytes

function

void setHwIds(std::vector< int > ids)

Specify which hardware warp engines to use

Parameters

ids: Which warp engines to use (0, 1, 2)

function

std::vector< int > getHwIds()

function

void setInterpolation(dai::Interpolation interpolation)

Specify which interpolation method to use

Parameters

interpolation: type of interpolation

function

dai::Interpolation getInterpolation()

inline function

DeviceNodeCRTP()

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props, bool confMode)

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device, std::unique_ptr< Properties > props, bool confMode)

class

dai::node::Display

variable

Input input

explicit function

Display(std::string name)

function

void run()

class

dai::node::HostCamera

variable

Output out

function

void run()

class

dai::node::HostNode

variable

InputMap & inputs

variable

Output out

function

std::shared_ptr< Buffer > processGroup(std::shared_ptr< dai::MessageGroup > in)

inline function

void sendProcessingToPipeline(bool send)

inline function

void runSyncingOnHost()

inline function

void runSyncingOnDevice()

class

dai::node::RGBD

#include RGBD.hpp

variable

Subnode< node::Sync > sync

variable

InputMap & inputs

variable

std::string colorInputName

variable

std::string depthInputName

variable

Input & inColor

variable

Input & inDepth

variable

Output pcl

Output point cloud.

variable

Output rgbd

Output RGBD frames.

function

RGBD()

function

~RGBD()

function

std::shared_ptr< RGBD > build()

function

std::shared_ptr< RGBD > build(bool autocreate, StereoDepth::PresetMode mode, std::pair< int, int > frameSize, std::optional< float > fps)

function

std::shared_ptr< RGBD > build(const std::shared_ptr< Camera > & camera, const DepthSource & depthSource, std::pair< int, int > frameSize, std::optional< float > fps)

function

void setDepthUnit(StereoDepthConfig::AlgorithmControl::DepthUnit depthUnit)

function

void useCPU()

function

void useCPUMT(uint32_t numThreads)

function

void useGPU(uint32_t device)

function

void printDevices()

function

void buildInternal()

class

dai::node::RecordVideo

#include Record.hpp

variable

Input input

Input for ImgFrame or EncodedFrame messages to be recordedDefault queue is blocking with size 15

function

void run()

function

std::filesystem::path getRecordMetadataFile()

function

std::filesystem::path getRecordVideoFile()

function

CompressionLevel getCompressionLevel()

function

RecordVideo & setRecordMetadataFile(const std::filesystem::path & recordFile)

function

RecordVideo & setRecordVideoFile(const std::filesystem::path & recordFile)

function

RecordVideo & setCompressionLevel(CompressionLevel compressionLevel)

function

RecordVideo & setFps(unsigned int fps)

enum

dai::RecordConfig::CompressionLevel CompressionLevel

class

dai::node::RecordMetadataOnly

#include Record.hpp

variable

Input input

Input IMU messages to be recorded (will support other types in the future)Default queue is blocking with size 8

function

void run()

function

std::filesystem::path getRecordFile()

function

CompressionLevel getCompressionLevel()

function

RecordMetadataOnly & setRecordFile(const std::filesystem::path & recordFile)

function

RecordMetadataOnly & setCompressionLevel(CompressionLevel compressionLevel)

enum

dai::RecordConfig::CompressionLevel CompressionLevel

class

dai::node::ReplayVideo

#include Replay.hpp

variable

Output out

Output for any type of messages to be transferred over XLink streamDefault queue is blocking with size 8

function

void run()

function

std::filesystem::path getReplayMetadataFile()

function

std::filesystem::path getReplayVideoFile()

function

ImgFrame::Type getOutFrameType()

function

std::tuple< int, int > getSize()

function

float getFps()

function

bool getLoop()

function

ReplayVideo & setReplayMetadataFile(const std::filesystem::path & replayFile)

function

ReplayVideo & setReplayVideoFile(const std::filesystem::path & replayVideo)

function

ReplayVideo & setOutFrameType(ImgFrame::Type outFrameType)

function

ReplayVideo & setSize(std::tuple< int, int > size)

function

ReplayVideo & setSize(int width, int height)

function

ReplayVideo & setFps(float fps)

function

ReplayVideo & setLoop(bool loop)

class

dai::node::ReplayMetadataOnly

#include Replay.hpp

variable

Output out

Output for any type of messages to be transferred over XLink streamDefault queue is blocking with size 8

function

void run()

function

std::filesystem::path getReplayFile()

function

float getFps()

function

bool getLoop()

function

ReplayMetadataOnly & setReplayFile(const std::filesystem::path & replayFile)

function

ReplayMetadataOnly & setFps(float fps)

function

ReplayMetadataOnly & setLoop(bool loop)

class

dai::node::PipelineStateMerge

#include PipelineStateMerge.hpp

variable

Input inputDevice

variable

Input inputHost

variable

Input request

Input PipelineEventAggregationConfig message with state request parameters

variable

Output outRequest

Output PipelineEventAggregationConfig message with state request parameters

variable

Output out

Output message of type

function

std::shared_ptr< PipelineStateMerge > build(bool hasDeviceNodes, bool hasHostNodes)

function

PipelineStateMerge & setAllowConfiguration(bool allow)

True by default. Set to false when the node should only wait for states and not for configuration inputs. Used for merging trace outputs.

function

void run()

class

dai::node::RTABMapSLAM

#include RTABMapSLAM.hpp

variable

Subnode< node::Sync > sync

variable

InputMap & inputs

variable

std::string rectInputName

variable

std::string depthInputName

variable

std::string featuresInputName

variable

Input & rect

Input rectified image on which SLAM is performed.

variable

Input & depth

Input depth image on which SLAM is performed.

variable

Input features

Input tracked features on which SLAM is performed (optional).

variable

Input odom

Input odometry pose.

variable

Output transform

Output transform.

variable

Output odomCorrection

Output odometry correction (map to odom).

variable

Output obstaclePCL

Output obstacle point cloud.

variable

Output groundPCL

Output ground point cloud.

variable

Output occupancyGridMap

Output occupancy grid map.

variable

Output passthroughRect

Output passthrough rectified image.

variable

Output passthroughDepth

Output passthrough depth image.

variable

Output passthroughFeatures

Output passthrough features.

variable

Output passthroughOdom

Output passthrough odometry pose.

function

RTABMapSLAM()

function

~RTABMapSLAM()

function

void setParams(const std::map< std::string, std::string > & params)

Set RTABMap parameters. For the list of all parameters visit

inline function

void setDatabasePath(const std::string & path)

Set RTABMap database path. "/tmp/rtabmap.tmp.db" by default.

inline function

void setLoadDatabaseOnStart(bool load)

Whether to load the database on start. False by default.

inline function

void setSaveDatabaseOnClose(bool save)

Whether to save the database on close. False by default.

function

void saveDatabase()

inline function

void setSaveDatabasePeriodically(bool save)

Whether to save the database periodically. False by default.

inline function

void setSaveDatabasePeriod(double interval)

Set the interval at which the database is saved. 30.0s by default.

function

void setPublishObstacleCloud(bool publish)

Whether to publish the obstacle point cloud. True by default.

function

void setPublishGroundCloud(bool publish)

Whether to publish the ground point cloud. True by default.

function

void setPublishGrid(bool publish)

Whether to publish the ground point cloud. True by default.

inline function

void setFreq(float f)

Set the frequency at which the node processes data. 1Hz by default.

inline function

void setAlphaScaling(float alpha)

Set the alpha scaling factor for the camera model.

function

void setUseFeatures(bool use)

Whether to use input features for SLAM. False by default.

function

void setLocalTransform(std::shared_ptr< TransformData > transform)

function

std::shared_ptr< TransformData > getLocalTransform()

function

void triggerNewMap()

Trigger a new map.

function

void buildInternal()

class

dai::node::RTABMapVIO

#include RTABMapVIO.hpp

variable

std::string rectInputName

variable

std::string depthInputName

variable

std::string featuresInputName

variable

Subnode< node::Sync > sync

variable

InputMap & inputs

variable

Input & rect

Input rectified image on which VIO is performed.

variable

Input & depth

Input depth image on which VIO is performed.

variable

Input features

Input tracked features on which VIO is performed (optional).

variable

Input imu

Input IMU data.

variable

Output transform

Output transform.

variable

Output passthroughRect

Passthrough rectified frame.

variable

Output passthroughDepth

Passthrough depth frame.

variable

Output passthroughFeatures

Passthrough features.

function

RTABMapVIO()

function

~RTABMapVIO()

function

void setParams(const std::map< std::string, std::string > & params)

Set RTABMap parameters.

function

void setUseFeatures(bool use)

Whether to use input features or calculate them internally.

function

void setLocalTransform(std::shared_ptr< TransformData > transform)

function

void reset(std::shared_ptr< TransformData > transform)

Reset Odometry.

function

void buildInternal()

namespace

dai::node::internal

using

XLinkInProperties = ::dai::internal::XLinkInProperties

using

XLinkOutProperties = ::dai::internal::XLinkOutProperties

struct

dai::node::internal::XLinkInBridge

#include Node.hpp

variable

std::shared_ptr< dai::node::internal::XLinkOutHost > xLinkOutHost

variable

std::shared_ptr< dai::node::internal::XLinkIn > xLinkIn

struct

dai::node::internal::XLinkOutBridge

#include Node.hpp

variable

std::shared_ptr< dai::node::internal::XLinkOut > xLinkOut

variable

std::shared_ptr< dai::node::internal::XLinkInHost > xLinkInHost

class

dai::node::internal::PipelineEventAggregation

#include PipelineEventAggregation.hpp

variable

InputMap inputs

A map of inputs

variable

Input request

Input PipelineEventAggregationConfig message with state request parameters

variable

Output out

Output message of type PipelineState

variable

Output outTrace

Continuous output message of type PipelineState

function

void setRunOnHost(bool runOnHost)

Specify whether to run on host or device By default, the node will run on device.

function

bool runOnHost()

Check if the node is set to run on host

function

void run()

function

PipelineEventAggregation & setTraceOutput(bool enable)

inline function

DeviceNodeCRTP()

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props, bool confMode)

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device, std::unique_ptr< Properties > props, bool confMode)

class

dai::node::internal::XLinkIn

#include XLinkIn.hpp

variable

Output out

Outputs message of same type as send from host.

function

~XLinkIn()

function

void setStreamName(const std::string & name)

Specifies XLink stream name to use.The name should not start with double underscores '__', as those are reserved for internal use.

Parameters

name: Stream name

function

void setMaxDataSize(std::uint32_t maxDataSize)

Set maximum message size it can receive

Parameters

maxDataSize: Maximum size in bytes

function

void setNumFrames(std::uint32_t numFrames)

Set number of frames in pool for sending messages forward

Parameters

numFrames: Maximum number of frames in pool

function

std::string getStreamName()

function

std::uint32_t getMaxDataSize()

function

std::uint32_t getNumFrames()

inline function

DeviceNodeCRTP()

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props, bool confMode)

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device, std::unique_ptr< Properties > props, bool confMode)

class

dai::node::internal::XLinkInHost

variable

Output out

function

void setStreamName(const std::string & name)

function

void setConnection(std::shared_ptr< XLinkConnection > conn)

function

void disconnect()

function

void run()

class

dai::node::internal::XLinkOut

#include XLinkOut.hpp

variable

Input input

Input for any type of messages to be transferred over XLink streamDefault queue is blocking with size 8

function

void setStreamName(const std::string & name)

Specifies XLink stream name to use.The name should not start with double underscores '__', as those are reserved for internal use.

Parameters

name: Stream name

function

void setFpsLimit(float fps)

Specifies a message sending limit. It's approximated from specified rate.

Parameters

fps: Approximate rate limit in messages per second

function

void setMetadataOnly(bool metadataOnly)

Specify whether to transfer only messages attributes and not buffer data

function

void setPacketSize(int packetSize)

function

void setBytesPerSecondLimit(int bytesPerSecondLimit)

function

std::string getStreamName()

function

float getFpsLimit()

function

bool getMetadataOnly()

function

int getPacketSize()

function

int getBytesPerSecondLimit()

function

void buildInternal()

inline function

DeviceNodeCRTP()

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props)

inline function

DeviceNodeCRTP(std::unique_ptr< Properties > props, bool confMode)

inline function

DeviceNodeCRTP(const std::shared_ptr< Device > & device, std::unique_ptr< Properties > props, bool confMode)

class

dai::node::internal::XLinkOutHost

variable

Input in

function

void setStreamName(const std::string & name)

function

void setConnection(std::shared_ptr< XLinkConnection > conn)

function

void allowStreamResize(bool allow)

function

void disconnect()

function

void run()

namespace

dai::node::test

class

dai::node::test::MyConsumer

#include MyConsumer.hpp

variable

Input input

Input for any type of messages to be transferred over XLink stream Default queue is blocking with size 8

inline function

void run()

class

dai::node::test::MyProducer

#include MyProducer.hpp

variable

Output out

Outputs message of same type as sent from host.

function

void run()

namespace

dai::proto

namespace

dai::proto::event

namespace

dai::utility

function

std::uint32_t checksum(const void * buffer, std::size_t size, uint32_t prevChecksum)

Simple hash function - djb2

Parameters

buffer: Pointer to buffer of data to hash
size: Size of buffer in bytes
prevChecksum: Previous checksum - useful for doing hash on blocks of data

function

std::uint32_t checksum(const void * buffer, std::size_t size)

Simple hash function - djb2

Parameters

buffer: Pointer to buffer of data to hash
size: Size of buffer in bytes

function

std::vector< uint8_t > deflate(uint8_t * data, size_t size, int compressionLevel)

function

std::vector< uint8_t > inflate(uint8_t * data, size_t size)

function

std::vector< std::string > filenamesInTar(const std::filesystem::path & tarPath)

Gets a list of filenames contained within a tar archive.

Parameters

tarPath: Path to the tar file to read

Returns

Vector of paths for the files within the tar archive

function

void tarFiles(const std::filesystem::path & tarPath, const std::vector< std::filesystem::path > & filesOnDisk, const std::vector< std::string > & filesInTar)

Creates a tar archive containing the specified files.

Parameters

tarPath: Path where the tar file will be created
filesOnDisk: Vector of paths to file on the host filesystem to include in the archive
filesInTar: Vector of paths for the files within the tar archive

function

void untarFiles(const std::filesystem::path & tarPath, const std::vector< std::string > & filesInTar, const std::vector< std::filesystem::path > & filesOnDisk)

Extracts files from a tar archive.

Parameters

tarPath: Path to the tar file to extract from
filesInTar: Vector of paths for the files within the tar to extract
filesOnDisk: Vector of paths where the extracted files should be written

inline function

bool serialize(const T & obj, std::vector< std::uint8_t > & data)

inline function

bool deserialize(const std::uint8_t * data, std::size_t size, T & obj)

inline function

bool serialize(const T & obj, std::vector< std::uint8_t > & data, SerializationType type)

inline function

std::vector< std::uint8_t > serialize(const T & obj, SerializationType type)

inline function

bool deserialize(const std::uint8_t * data, std::size_t size, T & obj, SerializationType type)

inline function

bool deserialize(const std::vector< std::uint8_t > & data, T & obj, SerializationType type)

inline function

std::vector< std::uint8_t > serialize(const T & obj)

inline function

bool deserialize(const std::vector< std::uint8_t > & data, T & obj)

inline function

bool serialize(const T & obj, std::vector< std::uint8_t > & data)

inline function

std::vector< std::uint8_t > serialize(const T & obj)

inline function

bool deserialize(const std::uint8_t * data, std::size_t size, T & obj)

inline function

bool deserialize(const std::vector< std::uint8_t > & data, T & obj)

function

std::string jsonDisplay(const nlohmann::json & json, int level, int indent)

enum

SendSnapCallbackStatus

enumerator

SUCCESS

enumerator

FILE_BATCH_PREPARATION_FAILED

enumerator

GROUP_CONTAINS_REJECTED_FILES

enumerator

FILE_UPLOAD_FAILED

enumerator

SEND_EVENT_FAILED

enumerator

EVENT_REJECTED

class

dai::utility::CircularBuffer

#include CircularBuffer.hppDerived by dai::utility::WindowedAverageBuffer< T >

inline function

CircularBuffer(size_t size)

function

~CircularBuffer()

inline function

T & add(T value)

inline function

std::vector< T > getBuffer()

inline function

T first()

inline function

T last()

inline function

size_t size()

inline function

void clear()

inline function

T & at(size_t pos)

inline function

const T & at(size_t pos)

inline function

iterator begin()

inline function

iterator end()

inline function

reverse_iterator rbegin()

inline function

reverse_iterator rend()

class

dai::utility::CircularBuffer::iterator

inline function

iterator(CircularBuffer * parent, size_t pos)

inline function

reference operator*()

inline function

pointer operator->()

inline function

iterator & operator++()

inline function

iterator operator++(int)

inline function

bool operator==(const iterator & other)

inline function

bool operator!=(const iterator & other)

enum

std::forward_iterator_tag iterator_category

enum

T value_type

enum

std::ptrdiff_t difference_type

enum

T * pointer

enum

T & reference

class

dai::utility::CircularBuffer::reverse_iterator

inline function

reverse_iterator(CircularBuffer * parent, size_t pos)

inline function

reference operator*()

inline function

pointer operator->()

inline function

reverse_iterator & operator++()

inline function

reverse_iterator operator++(int)

inline function

bool operator==(const reverse_iterator & other)

inline function

bool operator!=(const reverse_iterator & other)

enum

std::bidirectional_iterator_tag iterator_category

enum

T value_type

enum

std::ptrdiff_t difference_type

enum

T * pointer

enum

T & reference

class

dai::utility::WindowedAverageBuffer

#include CircularBuffer.hpp

inline function

WindowedAverageBuffer(size_t size, T initialValue)

inline function

void onSwap(T & oldValue, T & newValue)

inline function

void onAdd(T & newValue)

inline function

T getAverage()

class

dai::utility::FileData

function

FileData(std::string data, std::string fileTag, std::string mimeType)

explicit function

FileData(std::filesystem::path filePath, std::string fileTag)

explicit function

FileData(const std::shared_ptr< ImgFrame > & imgFrame, std::string fileTag)

explicit function

FileData(const std::shared_ptr< EncodedFrame > & encodedFrame, std::string fileTag)

explicit function

FileData(const std::shared_ptr< ImgDetections > & imgDetections, std::string fileTag)

function

bool toFile(const std::filesystem::path & inputPath)

class

dai::utility::FileGroup

function

void addFile(std::string fileTag, std::string data, std::string mimeType)

function

void addFile(std::string fileTag, std::filesystem::path filePath)

function

void addFile(const std::optional< std::string > & fileTag, const std::shared_ptr< ImgFrame > & imgFrame)

function

void addFile(const std::optional< std::string > & fileTag, const std::shared_ptr< EncodedFrame > & encodedFrame)

function

void addFile(const std::optional< std::string > & fileTag, const std::shared_ptr< ImgDetections > & imgDetections)

function

void addImageDetectionsPair(const std::optional< std::string > & fileTag, const std::shared_ptr< ImgFrame > & imgFrame, const std::shared_ptr< ImgDetections > & imgDetections)

function

void addImageDetectionsPair(const std::optional< std::string > & fileTag, const std::shared_ptr< EncodedFrame > & encodedFrame, const std::shared_ptr< ImgDetections > & imgDetections)

struct

dai::utility::SendSnapCallbackResult

variable

std::string snapName

variable

int64_t snapTimestamp

variable

std::string snapLocalID

variable

std::optional< std::string > snapHubID

variable

std::string snapPayload

variable

SendSnapCallbackStatus uploadStatus

class

dai::utility::EventsManager

explicit function

EventsManager(std::string apiKey, bool uploadCachedOnStart)

inline explicit function

EventsManager(bool uploadCachedOnStart)

function

~EventsManager()

function

std::optional< std::string > sendEvent(const std::string & name, const std::vector< std::string > & tags, const std::unordered_map< std::string, std::string > & extras, const std::vector< std::string > & associateFiles)

Send an event to the events service

Parameters

name: Name of the event
tags: List of tags to send
extras: Extra data to send
associateFiles: List of associate files with ids

Returns

LocalID of the sent Event

function

std::optional< std::string > sendSnap(const std::string & name, const std::shared_ptr< FileGroup > fileGroup, const std::vector< std::string > & tags, const std::unordered_map< std::string, std::string > & extras, const std::function< void(SendSnapCallbackResult)> successCallback, const std::function< void(SendSnapCallbackResult)> failureCallback)

Send a snap to the events service. Snaps should be used for sending images and other files.

Parameters

name: Name of the snap
fileGroup: FileGroup containing FileData objects to send
tags: List of tags to send
extras: Extra data to send
successCallback: Callback to be called when the snap is successfully uploaded to the hub
failureCallback: Callback to be called if the snap upload is unsuccessful

Returns

LocalID of the sent Snap

function

std::optional< std::string > sendSnap(const std::string & name, const std::optional< std::string > & fileTag, const std::shared_ptr< ImgFrame > imgFrame, const std::optional< std::shared_ptr< ImgDetections >> & imgDetections, const std::vector< std::string > & tags, const std::unordered_map< std::string, std::string > & extras, const std::function< void(SendSnapCallbackResult)> successCallback, const std::function< void(SendSnapCallbackResult)> failureCallback)

Send a snap to the events service, with an ImgFrame and ImgDetections pair as files

Parameters

name: Name of the snap
fileTag: File tag used to create FileData
imgFrame: ImgFrame to send
imgDetections: ImgDetections to sent
tags: List of tags to send
extras: Extra data to send
successCallback: Callback to be called when the snap is successfully uploaded to the hub
failureCallback: Callback to be called if the snap upload is unsuccessful

Returns

LocalID of the sent Snap

function

bool waitForPendingUploads(uint64_t timeoutMs)

Wait for pending snaps/events to be processed by the background upload thread

Parameters

timeoutMs: Timeout in milliseconds. 0 means wait until uploads are finished, connection is dropped, or manager is stopped

Returns

true if the pending data was uploaded before timeout, false if not - either because of timeout, dropped connection, or shutdown

function

void setLogResponse(bool logResponse)

Set whether to log the responses from the server. By default, logResponse is set to false

Parameters

logResponse: bool

Returns

void

function

void setVerifySsl(bool verifySsl)

Set whether to verify the SSL certificate. By default, verifySsl is set to false

Parameters

verifySsl: bool

Returns

void

function

void setCacheDir(const std::string & cacheDir)

Set the cache directory for storing cached data. By default, the cache directory is set to /internal/private

Parameters

cacheDir: Cache directory

Returns

void

function

void setCacheIfCannotSend(bool cacheIfCannotSend)

Set whether to cache data if it cannot be sent. By default, cacheIfCannotSend is set to false

Parameters

cacheIfCannotSend: bool

Returns

void

class

dai::utility::PipelineEventDispatcher

function

PipelineEventDispatcher()

inline function

PipelineEventDispatcher(int64_t & nodeId, Node::Output * output)

function

void startEvent(PipelineEvent::Type type, const std::string & source, std::optional< uint32_t > queueSize)

function

void startInputEvent(const std::string & source, std::optional< uint32_t > queueSize)

function

void startOutputEvent(const std::string & source)

function

void startCustomEvent(const std::string & source)

function

void endEvent(PipelineEvent::Type type, const std::string & source, std::optional< uint32_t > queueSize)

function

void endInputEvent(const std::string & source, std::optional< uint32_t > queueSize)

function

void endOutputEvent(const std::string & source)

function

void endCustomEvent(const std::string & source)

function

void startTrackedEvent(PipelineEvent event, std::optional< std::chrono::time_point< std::chrono::steady_clock >> ts)

function

void startTrackedEvent(PipelineEvent::Type type, const std::string & source, int64_t sequenceNum, std::optional< std::chrono::time_point< std::chrono::steady_clock >> ts)

function

void endTrackedEvent(PipelineEvent event, std::optional< std::chrono::time_point< std::chrono::steady_clock >> ts)

function

void endTrackedEvent(PipelineEvent::Type type, const std::string & source, int64_t sequenceNum, std::optional< std::chrono::time_point< std::chrono::steady_clock >> ts)

function

void pingEvent(PipelineEvent::Type type, const std::string & source)

function

void pingMainLoopEvent()

function

void pingCustomEvent(const std::string & source)

function

void pingInputEvent(const std::string & source, PipelineEvent::Status status, std::optional< uint32_t > queueSize)

function

BlockPipelineEvent blockEvent(PipelineEvent::Type type, const std::string & source, std::optional< std::chrono::time_point< std::chrono::steady_clock >> ts, bool startNow)

function

BlockPipelineEvent inputBlockEvent(bool startNow)

function

BlockPipelineEvent outputBlockEvent(bool startNow)

function

BlockPipelineEvent customBlockEvent(const std::string & source, bool startNow)

class

dai::utility::PipelineEventDispatcherInterface

Derived by dai::utility::PipelineEventDispatcher

variable

bool sendEvents

function

~PipelineEventDispatcherInterface()

function

void startEvent(PipelineEvent::Type type, const std::string & source, std::optional< uint32_t > queueSize)

function

void startInputEvent(const std::string & source, std::optional< uint32_t > queueSize)

function

void startOutputEvent(const std::string & source)

function

void startCustomEvent(const std::string & source)

function

void endEvent(PipelineEvent::Type type, const std::string & source, std::optional< uint32_t > queueSize)

function

void endInputEvent(const std::string & source, std::optional< uint32_t > queueSize)

function

void endOutputEvent(const std::string & source)

function

void endCustomEvent(const std::string & source)

function

void startTrackedEvent(PipelineEvent event, std::optional< std::chrono::time_point< std::chrono::steady_clock >> ts)

function

void startTrackedEvent(PipelineEvent::Type type, const std::string & source, int64_t sequenceNum, std::optional< std::chrono::time_point< std::chrono::steady_clock >> ts)

function

void endTrackedEvent(PipelineEvent event, std::optional< std::chrono::time_point< std::chrono::steady_clock >> ts)

function

void endTrackedEvent(PipelineEvent::Type type, const std::string & source, int64_t sequenceNum, std::optional< std::chrono::time_point< std::chrono::steady_clock >> ts)

function

void pingEvent(PipelineEvent::Type type, const std::string & source)

function

void pingMainLoopEvent()

function

void pingCustomEvent(const std::string & source)

function

void pingInputEvent(const std::string & source, PipelineEvent::Status status, std::optional< uint32_t > queueSize)

function

BlockPipelineEvent blockEvent(PipelineEvent::Type type, const std::string & source, std::optional< std::chrono::time_point< std::chrono::steady_clock >> ts, bool startNow)

function

BlockPipelineEvent inputBlockEvent(bool startNow)

function

BlockPipelineEvent outputBlockEvent(bool startNow)

function

BlockPipelineEvent customBlockEvent(const std::string & source, bool startNow)

class

dai::utility::PipelineEventDispatcherInterface::BlockPipelineEvent

inline function

void start(std::optional< std::chrono::time_point< std::chrono::steady_clock >> ts)

inline function

 BlockPipelineEvent(PipelineEventDispatcherInterface & dispatcher, PipelineEvent::Type type, const std::string & source, std::optional< std::chrono::time_point< std::chrono::steady_clock >> ts, bool startNow)

inline function

void end()

inline function

void cancel()

inline function

void setQueueSize(uint32_t qs)

inline function

void setEndTimestamp(std::chrono::time_point< std::chrono::steady_clock > ts)

inline function

~BlockPipelineEvent()

class

dai::utility::VectorWriter

inline function

VectorWriter(Args &&... args)

function

VectorWriter(const VectorWriter &)

function

VectorWriter & operator=(const VectorWriter &)

inline function

nop::Status< void > Prepare(std::size_t)

inline function

nop::Status< void > Write(std::uint8_t byte)

inline function

nop::Status< void > Write(const void * begin, const void * end)

inline function

nop::Status< void > Skip(std::size_t padding_bytes, std::uint8_t padding_value)

inline function

const std::vector< std::uint8_t > & ref()

inline function

std::vector< std::uint8_t > & ref()

inline function

std::vector< std::uint8_t > && take()

ON THIS PAGE

DepthAI C++ API

dai

ImgResizeMode

int32_t CameraBoardSocket

int32_t CameraExposureOffset

int32_t CameraImageOrientation

int8_t CameraModel

int32_t CameraSensorType

int32_t Colormap

int32_t ConnectionInterface

int32_t SIPrefix

int32_t LengthUnit

DeviceModelZoo

int32_t ExternalFrameSyncRole

int32_t FrameEvent

int32_t HousingCoordinateSystem

std::int32_t Interpolation

int32_t ProcessorType

int32_t UsbSpeed

Platform

std::int32_t LogLevel

NNArchiveConfigVersion

std::int32_t DatatypeEnum

std::uint32_t ImageFiltersPresetMode

std::uint8_t PointsAnnotationType

uint32_t SpatialLocationCalculatorAlgorithm

std::int32_t IMUSensor

std::int32_t TrackerType

std::int32_t TrackerIdAssignmentPolicy

LockingQueueState

SerializationType

dai::Capability

dai::CapabilityCRTP

dai::CapabilityRange

dai::ImgFrameCapability

dai::CameraSensorConfig

dai::CameraFeatures

dai::CameraInfo

dai::ChipTemperature

dai::ChipTemperatureRVC4

dai::Color

dai::CpuUsage

dai::DetectionParserOptions

dai::EepromData

dai::Extrinsics

dai::ImgTransformation

dai::Keypoint

dai::KeypointsList

KeypointsListT< Keypoint > Base

dai::KeypointsListT

KeypointT value_type

typename std::vector< KeypointT >::iterator iterator

typename std::vector< KeypointT >::const_iterator const_iterator

dai::MemoryInfo

dai::Point2f

dai::Point3d

dai::Point3f

dai::Point3fRGBA

dai::Quaterniond

dai::Rect

dai::RotatedRect

dai::Size2f

dai::SpatialKeypoint

dai::SpatialKeypointsList

KeypointsListT< SpatialKeypoint > Base

dai::StereoPair

dai::StereoRectification

dai::TensorInfo

int StorageOrder

int DataType

dai::Timestamp

dai::BoardConfig

dai::BoardConfig::Camera

dai::BoardConfig::GPIO

std::int8_t Mode

std::int8_t Direction

std::int8_t Level

std::int8_t Pull

std::int8_t Drive