Python API Reference¶

Classes:

`ADatatype`	Abstract message
`AprilTag`	AprilTag structure.
`AprilTagConfig`	AprilTagConfig message.
`AprilTagProperties`	Specify properties for AprilTag
`AprilTags`	AprilTags message.
`Asset`	Asset is identified with string key and can store arbitrary binary data
`AssetManager`	AssetManager can store assets and serialize
`BoardConfig`
`Buffer`	Base message - buffer of binary data
`CalibrationHandler`	CalibrationHandler is an interface to read/load/write structured calibration and device data.
`CameraBoardSocket`	Which Camera socket to use.
`CameraControl`	CameraControl message.
`CameraExposureOffset`	Members:
`CameraFeatures`	CameraFeatures structure
`CameraImageOrientation`	Camera sensor image orientation / pixel readout.
`CameraInfo`	CameraInfo structure
`CameraModel`	Which CameraModel to initialize the calibration with.
`CameraProperties`	Specify properties for ColorCamera such as camera ID, …
`CameraSensorType`	Camera sensor type
`ChipTemperature`	Chip temperature information.
`Clock`
`ColorCameraProperties`	Specify properties for ColorCamera such as camera ID, …
`Colormap`	Camera sensor type
`CpuUsage`	CpuUsage structure
`DataInputQueue`	Access to send messages through XLink stream
`DataOutputQueue`	Access to receive messages coming from XLink stream
`DatatypeEnum`	Members:
`DetectionNetworkProperties`	Specify properties for DetectionNetwork
`DetectionNetworkType`	Members:
`DetectionParserOptions`	Specifies how to parse output of detection networks
`DetectionParserProperties`	Specify properties for DetectionParser
`Device`	Represents the DepthAI device with the methods to interact with it.
`DeviceBase`	The core of depthai device for RAII, connects to device and maintains watchdog, timesync, …
`DeviceBootloader`	Represents the DepthAI bootloader with the methods to interact with it.
`DeviceDesc`
`DeviceInfo`	Describes a connected device
`EdgeDetectorConfig`	EdgeDetectorConfig message.
`EdgeDetectorConfigData`	EdgeDetectorConfigData configuration data structure
`EdgeDetectorProperties`	Specify properties for EdgeDetector
`EepromData`	EepromData structure
`Extrinsics`	Extrinsics structure
`FeatureTrackerConfig`	FeatureTrackerConfig message.
`FeatureTrackerProperties`	Specify properties for FeatureTracker
`FrameEvent`	Members:
`GlobalProperties`	Specify properties which apply for whole pipeline
`IMUData`	IMUData message.
`IMUPacket`	IMU output
`IMUProperties`
`IMUReport`
`IMUReportAccelerometer`	Accelerometer
`IMUReportGyroscope`	Gyroscope
`IMUReportMagneticField`	Magnetic field
`IMUReportRotationVectorWAcc`	Rotation Vector with Accuracy
`IMUSensor`	Available IMU sensors.
`IMUSensorConfig`
`ImageManipConfig`	ImageManipConfig message.
`ImgDetection`	ImgDetection structure
`ImgDetections`	ImgDetections message.
`ImgFrame`	ImgFrame message.
`LogLevel`	Members:
`LogMessage`
`MedianFilter`	Median filter config for disparity post-processing
`MemoryInfo`	MemoryInfo structure
`MonoCameraProperties`	Specify properties for MonoCamera such as camera ID, …
`NNData`	NNData message.
`NeuralNetworkProperties`	Specify properties for NeuralNetwork such as blob path, …
`Node`	Abstract Node
`ObjectTrackerProperties`	Specify properties for ObjectTracker
`OpenVINO`	Support for basic OpenVINO related actions like version identification of neural network blobs,…
`Pipeline`
`Point2f`	Point2f structure
`Point3f`	Point3f structure
`ProcessorType`	Members:
`Properties`	Base Properties structure
`RawAprilTagConfig`	RawAprilTags configuration structure
`RawBuffer`	RawBuffer structure
`RawCameraControl`	RawCameraControl structure
`RawEdgeDetectorConfig`	RawEdgeDetectorConfig configuration structure
`RawFeatureTrackerConfig`	RawFeatureTrackerConfig configuration structure
`RawIMUData`
`RawImageManipConfig`	RawImageManipConfig structure
`RawImgDetections`	RawImgDetections structure
`RawImgFrame`	RawImgFrame structure
`RawNNData`	RawNNData structure
`RawSpatialImgDetections`	RawSpatialImgDetections structure
`RawStereoDepthConfig`	RawStereoDepthConfig configuration structure
`RawSystemInformation`	System information of device
`RawTrackedFeatures`	RawTrackedFeatures structure
`RawTracklets`	RawTracklets structure
`Rect`	Rect structure
`RotatedRect`	RotatedRect structure
`SPIInProperties`	Properties for SPIIn node
`SPIOutProperties`	Specify properties for SPIOut node
`ScriptProperties`	Specify ScriptProperties options such as script uri, script name, …
`SerializationType`	Members:
`Size2f`	Size2f structure
`SpatialDetectionNetworkProperties`	Specify properties for SpatialDetectionNetwork
`SpatialImgDetection`	SpatialImgDetection structure
`SpatialImgDetections`	SpatialImgDetections message.
`SpatialLocationCalculatorAlgorithm`	Members:
`SpatialLocationCalculatorConfig`	SpatialLocationCalculatorConfig message.
`SpatialLocationCalculatorConfigData`	SpatialLocation configuration data structure
`SpatialLocationCalculatorConfigThresholds`	SpatialLocation configuration thresholds structure
`SpatialLocationCalculatorData`	SpatialLocationCalculatorData message.
`SpatialLocationCalculatorProperties`	Specify properties for SpatialLocationCalculator
`SpatialLocations`	SpatialLocations structure
`StereoDepthConfig`	StereoDepthConfig message.
`StereoDepthProperties`	Specify properties for StereoDepth
`StereoRectification`	StereoRectification structure
`SystemInformation`	SystemInformation message.
`SystemLoggerProperties`	SystemLoggerProperties structure
`TensorInfo`	TensorInfo structure
`Timestamp`	Timestamp structure
`TrackedFeature`	TrackedFeature structure
`TrackedFeatures`	TrackedFeatures message.
`TrackerIdAssignmentPolicy`	Members:
`TrackerType`	Members:
`Tracklet`	Tracklet structure
`Tracklets`	Tracklets message.
`UsbSpeed`	Get USB Speed
`Version`	Version structure
`VideoEncoderProperties`	Specify properties for VideoEncoder such as profile, bitrate, …
`WarpProperties`	Specify properties for Warp
`XLinkConnection`	Represents connection between host and device over XLink protocol
`XLinkDeviceState`	Members:
`XLinkError_t`	Members:
`XLinkInProperties`	Specify properties for XLinkIn such as stream name, …
`XLinkOutProperties`	Specify properties for XLinkOut such as stream name, …
`XLinkPlatform`	Members:
`XLinkProtocol`	Members:

Exceptions:

`EepromError`
`XLinkError`
`XLinkReadError`
`XLinkWriteError`

Functions:

isDatatypeSubclassOf(arg0, arg1)

class depthai.ADatatype¶

Bases: pybind11_builtins.pybind11_object

Abstract message

Methods:

`__init__`(args, *kwargs)	Initialize self.
`getRaw`(self)

__init__(*args, **kwargs)¶: Initialize self. See help(type(self)) for accurate signature.

getRaw(self: depthai.ADatatype) → depthai.RawBuffer ¶

class depthai.AprilTag¶

Bases: pybind11_builtins.pybind11_object

AprilTag structure.

Methods:

__init__(self)

Attributes:

`bottomLeft`	The detected bottom left coordinates.
`bottomRight`	The detected bottom right coordinates.
`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.
`hamming`	accepting large numbers of corrected errors leads to greatly increased false positive rates.
`id`	The decoded ID of the tag
`topLeft`	The detected top left coordinates.
`topRight`	The detected top right coordinates.

__init__(self: depthai.AprilTag) → None ¶

property bottomLeft¶: The detected bottom left coordinates.

property bottomRight¶: The detected bottom right coordinates.

property 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– not effective for larger tags (where we could have sampled anywhere within a bit cell and still gotten a good detection.

property hamming¶

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.

Type: How many error bits were corrected? Note

property id¶: The decoded ID of the tag

property topLeft¶: The detected top left coordinates.

property topRight¶: The detected top right coordinates.

class depthai.AprilTagConfig¶

Bases: depthai.Buffer

AprilTagConfig message.

Classes:

`Family`	Supported AprilTag families.
`QuadThresholds`	AprilTag quad threshold parameters.

Methods:

`__init__`(self)
`get`(self)	Retrieve configuration data for AprilTag.
`set`(self, arg0)	Set explicit configuration.
`setFamily`(self, family)	Parameter `family`:

class Family¶

Bases: pybind11_builtins.pybind11_object

Supported AprilTag families.

Members:

TAG_36H11

TAG_36H10

TAG_25H9

TAG_16H5

TAG_CIR21H7

TAG_STAND41H12

Attributes:

`TAG_16H5`
`TAG_25H9`
`TAG_36H10`
`TAG_36H11`
`TAG_CIR21H7`
`TAG_STAND41H12`
`name`
`value`

Methods:

__init__(self, value)

TAG_16H5 = <Family.TAG_16H5: 3>¶

TAG_25H9 = <Family.TAG_25H9: 2>¶

TAG_36H10 = <Family.TAG_36H10: 1>¶

TAG_36H11 = <Family.TAG_36H11: 0>¶

TAG_CIR21H7 = <Family.TAG_CIR21H7: 4>¶

TAG_STAND41H12 = <Family.TAG_STAND41H12: 5>¶

__init__(self: depthai.RawAprilTagConfig.Family, value: int) → None ¶

property name¶

property value¶

class QuadThresholds¶

Bases: pybind11_builtins.pybind11_object

AprilTag quad threshold parameters.

Methods:

__init__(self)

Attributes:

`criticalDegree`	Reject quads where pairs of edges have angles that are close to straight or close to 180 degrees.
`deglitch`	Should the thresholded image be deglitched? Only useful for very noisy images
`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.
`maxNmaxima`	How many corner candidates to consider when segmenting a group of pixels into a quad.
`minClusterPixels`	Reject quads containing too few pixels.
`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.

__init__(self: depthai.RawAprilTagConfig.QuadThresholds) → None ¶

property 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).

property deglitch¶: Should the thresholded image be deglitched? Only useful for very noisy images

property 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.

property maxNmaxima¶: How many corner candidates to consider when segmenting a group of pixels into a quad.

property minClusterPixels¶: Reject quads containing too few pixels.

property 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]).

__init__(self: depthai.AprilTagConfig) → None ¶

get(self: depthai.AprilTagConfig) → depthai.RawAprilTagConfig ¶

Retrieve configuration data for AprilTag.

Returns: config for stereo depth algorithm

set(self: depthai.AprilTagConfig, arg0: depthai.RawAprilTagConfig) → depthai.AprilTagConfig ¶

Set explicit configuration.

Parameter config:: Explicit configuration

setFamily(self: depthai.AprilTagConfig, family: depthai.RawAprilTagConfig.Family) → depthai.AprilTagConfig ¶

Parameter family:: AprilTag family

class depthai.AprilTagProperties¶

Bases: pybind11_builtins.pybind11_object

Specify properties for AprilTag

Methods:

__init__(*args, **kwargs)

Initialize self.

Attributes:

`initialConfig`
`inputConfigSync`	Whether to wait for config at ‘inputConfig’ IO

__init__(*args, **kwargs)¶: Initialize self. See help(type(self)) for accurate signature.

property initialConfig¶

property inputConfigSync¶: Whether to wait for config at ‘inputConfig’ IO

class depthai.AprilTags¶

Bases: depthai.Buffer

AprilTags message.

Methods:

`__init__`(self)
`getSequenceNum`(self)	Retrieves image sequence number
`getTimestamp`(self)	Retrieves image timestamp related to dai::Clock::now()
`getTimestampDevice`(self)	Retrieves image timestamp directly captured from device’s monotonic clock, not synchronized to host time.
`setSequenceNum`(self, arg0)	Retrieves image sequence number
`setTimestamp`(self, arg0)	Sets image timestamp related to dai::Clock::now()
`setTimestampDevice`(self, arg0)	Sets image timestamp related to dai::Clock::now()

Attributes:

aprilTags

__init__(self: depthai.AprilTags) → None ¶

property aprilTags¶

getSequenceNum(self: depthai.AprilTags) → int ¶: Retrieves image sequence number

getTimestamp(self: depthai.AprilTags) → datetime.timedelta ¶: Retrieves image timestamp related to dai::Clock::now()

getTimestampDevice(self: depthai.AprilTags) → datetime.timedelta ¶: Retrieves image timestamp directly captured from device’s monotonic clock, not synchronized to host time. Used mostly for debugging

setSequenceNum(self: depthai.AprilTags, arg0: int) → depthai.AprilTags ¶: Retrieves image sequence number

setTimestamp(self: depthai.AprilTags, arg0: datetime.timedelta) → depthai.AprilTags ¶: Sets image timestamp related to dai::Clock::now()

setTimestampDevice(self: depthai.AprilTags, arg0: datetime.timedelta) → depthai.AprilTags ¶: Sets image timestamp related to dai::Clock::now()

class depthai.Asset¶

Bases: pybind11_builtins.pybind11_object

Asset is identified with string key and can store arbitrary binary data

Methods:

__init__(*args, **kwargs)

Overloaded function.

Attributes:

`alignment`
`data`
`key`

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: depthai.Asset) -> None
__init__(self: depthai.Asset, arg0: str) -> None

property alignment¶

property data¶

property key¶

class depthai.AssetManager¶

Bases: pybind11_builtins.pybind11_object

AssetManager can store assets and serialize

Methods:

`__init__`(self)
`addExisting`(self, assets)	Adds all assets in an array to the AssetManager
`get`(args, *kwargs)	Overloaded function.
`getAll`(args, *kwargs)	Overloaded function.
`remove`(self, key)	Removes asset with key
`set`(args, *kwargs)	Overloaded function.
`size`(self)	returns Number of asset stored in the AssetManager

__init__(self: depthai.AssetManager) → None ¶

addExisting(self: depthai.AssetManager, assets: List[depthai.Asset]) → None ¶

Adds all assets in an array to the AssetManager

Parameter assets:: Vector of assets to add

get(*args, **kwargs)¶

Overloaded function.

get(self: depthai.AssetManager, key: str) -> depthai.Asset

Returns: Asset assigned to the specified key or a nullptr otherwise

get(self: depthai.AssetManager, key: str) -> depthai.Asset

Returns: Asset assigned to the specified key or a nullptr otherwise

getAll(*args, **kwargs)¶

Overloaded function.

getAll(self: depthai.AssetManager) -> List[depthai.Asset]

Returns: All asset stored in the AssetManager

getAll(self: depthai.AssetManager) -> List[depthai.Asset]

Returns: All asset stored in the AssetManager

remove(self: depthai.AssetManager, key: str) → None ¶

Removes asset with key

Parameter key:: Key of asset to remove

set(*args, **kwargs)¶

Overloaded function.

set(self: depthai.AssetManager, asset: depthai.Asset) -> depthai.Asset

Adds or overwrites an asset object to AssetManager.

Parameter asset:: Asset to add

Returns: Shared pointer to asset

set(self: depthai.AssetManager, key: str, asset: depthai.Asset) -> depthai.Asset

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

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

Returns: Shared pointer to asset

set(self: depthai.AssetManager, key: str, path: Path, alignment: int = 64) -> depthai.Asset

Loads file into asset manager under specified key.

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

set(self: depthai.AssetManager, key: str, data: List[int], alignment: int = 64) -> depthai.Asset

Loads file into asset manager under specified key.

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

Returns: Shared pointer to asset

size(self: depthai.AssetManager) → int ¶

Returns: Number of asset stored in the AssetManager

class depthai.BoardConfig¶

Bases: pybind11_builtins.pybind11_object

Classes:

`GPIO`
`GPIOMap`
`ItemsView_GPIOMap`
`ItemsView_UARTMap`
`KeysView_GPIOMap`
`KeysView_UARTMap`
`Network`	Network configuration
`UART`	UART instance config
`UARTMap`
`USB`
`ValuesView_GPIOMap`
`ValuesView_UARTMap`

Methods:

__init__(self)

Attributes:

`emmc`
`gpio`
`logDevicePrints`
`logPath`
`logSizeMax`
`logVerbosity`
`mipi4LaneRgb`
`network`
`pcieInternalClock`
`sysctl`
`uart`
`usb`
`usb3PhyInternalClock`
`watchdogInitialDelayMs`
`watchdogTimeoutMs`

class GPIO¶

Bases: pybind11_builtins.pybind11_object

Attributes:

Classes:

`Direction`	Members:
`Drive`	Drive strength in mA (2, 4, 8 and 12mA)
`Level`	Members:
`Mode`	Members:
`Pull`	Members:

Methods:

__init__(*args, **kwargs)

Overloaded function.

ALT_MODE_0 = <Mode.ALT_MODE_0: 0>¶

ALT_MODE_1 = <Mode.ALT_MODE_1: 1>¶

ALT_MODE_2 = <Mode.ALT_MODE_2: 2>¶

ALT_MODE_3 = <Mode.ALT_MODE_3: 3>¶

ALT_MODE_4 = <Mode.ALT_MODE_4: 4>¶

ALT_MODE_5 = <Mode.ALT_MODE_5: 5>¶

ALT_MODE_6 = <Mode.ALT_MODE_6: 6>¶

BUS_KEEPER = <Pull.BUS_KEEPER: 3>¶

DIRECT = <Mode.DIRECT: 7>¶

class Direction¶

Bases: pybind11_builtins.pybind11_object

Members:

INPUT :

OUTPUT :

Attributes:

`INPUT`
`OUTPUT`
`name`
`value`

Methods:

__init__(self, value)

INPUT = <Direction.INPUT: 0>¶

OUTPUT = <Direction.OUTPUT: 1>¶

__init__(self: depthai.BoardConfig.GPIO.Direction, value: int) → None ¶

property name¶

property value¶

class Drive¶

Bases: pybind11_builtins.pybind11_object

Drive strength in mA (2, 4, 8 and 12mA)

Members:

MA_2 :

MA_4 :

MA_8 :

MA_12 :

Attributes:

`MA_12`
`MA_2`
`MA_4`
`MA_8`
`name`
`value`

Methods:

__init__(self, value)

MA_12 = <Drive.MA_12: 12>¶

MA_2 = <Drive.MA_2: 2>¶

MA_4 = <Drive.MA_4: 4>¶

MA_8 = <Drive.MA_8: 8>¶

__init__(self: depthai.BoardConfig.GPIO.Drive, value: int) → None ¶

property name¶

property value¶

HIGH = <Level.HIGH: 1>¶

INPUT = <Direction.INPUT: 0>¶

LOW = <Level.LOW: 0>¶

class Level¶

Bases: pybind11_builtins.pybind11_object

Members:

LOW :

HIGH :

Attributes:

`HIGH`
`LOW`
`name`
`value`

Methods:

__init__(self, value)

HIGH = <Level.HIGH: 1>¶

LOW = <Level.LOW: 0>¶

__init__(self: depthai.BoardConfig.GPIO.Level, value: int) → None ¶

property name¶

property value¶

MA_12 = <Drive.MA_12: 12>¶

MA_2 = <Drive.MA_2: 2>¶

MA_4 = <Drive.MA_4: 4>¶

MA_8 = <Drive.MA_8: 8>¶

class Mode¶

Bases: pybind11_builtins.pybind11_object

Members:

ALT_MODE_0 :

ALT_MODE_1 :

ALT_MODE_2 :

ALT_MODE_3 :

ALT_MODE_4 :

ALT_MODE_5 :

ALT_MODE_6 :

DIRECT :

Attributes:

`ALT_MODE_0`
`ALT_MODE_1`
`ALT_MODE_2`
`ALT_MODE_3`
`ALT_MODE_4`
`ALT_MODE_5`
`ALT_MODE_6`
`DIRECT`
`name`
`value`

Methods:

__init__(self, value)

ALT_MODE_0 = <Mode.ALT_MODE_0: 0>¶

ALT_MODE_1 = <Mode.ALT_MODE_1: 1>¶

ALT_MODE_2 = <Mode.ALT_MODE_2: 2>¶

ALT_MODE_3 = <Mode.ALT_MODE_3: 3>¶

ALT_MODE_4 = <Mode.ALT_MODE_4: 4>¶

ALT_MODE_5 = <Mode.ALT_MODE_5: 5>¶

ALT_MODE_6 = <Mode.ALT_MODE_6: 6>¶

DIRECT = <Mode.DIRECT: 7>¶

__init__(self: depthai.BoardConfig.GPIO.Mode, value: int) → None ¶

property name¶

property value¶

NO_PULL = <Pull.NO_PULL: 0>¶

OUTPUT = <Direction.OUTPUT: 1>¶

PULL_DOWN = <Pull.PULL_DOWN: 2>¶

PULL_UP = <Pull.PULL_UP: 1>¶

class Pull¶

Bases: pybind11_builtins.pybind11_object

Members:

NO_PULL :

PULL_UP :

PULL_DOWN :

BUS_KEEPER :

Attributes:

`BUS_KEEPER`
`NO_PULL`
`PULL_DOWN`
`PULL_UP`
`name`
`value`

Methods:

__init__(self, value)

BUS_KEEPER = <Pull.BUS_KEEPER: 3>¶

NO_PULL = <Pull.NO_PULL: 0>¶

PULL_DOWN = <Pull.PULL_DOWN: 2>¶

PULL_UP = <Pull.PULL_UP: 1>¶

__init__(self: depthai.BoardConfig.GPIO.Pull, value: int) → None ¶

property name¶

property value¶

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: depthai.BoardConfig.GPIO) -> None
__init__(self: depthai.BoardConfig.GPIO, arg0: depthai.BoardConfig.GPIO.Direction) -> None
__init__(self: depthai.BoardConfig.GPIO, arg0: depthai.BoardConfig.GPIO.Direction, arg1: depthai.BoardConfig.GPIO.Level) -> None
__init__(self: depthai.BoardConfig.GPIO, arg0: depthai.BoardConfig.GPIO.Direction, arg1: depthai.BoardConfig.GPIO.Level, arg2: depthai.BoardConfig.GPIO.Pull) -> None
__init__(self: depthai.BoardConfig.GPIO, arg0: depthai.BoardConfig.GPIO.Direction, arg1: depthai.BoardConfig.GPIO.Mode) -> None
__init__(self: depthai.BoardConfig.GPIO, arg0: depthai.BoardConfig.GPIO.Direction, arg1: depthai.BoardConfig.GPIO.Mode, arg2: depthai.BoardConfig.GPIO.Pull) -> None

property direction¶

property drive¶

property level¶

property mode¶

property pull¶

property schmitt¶

property slewFast¶

class GPIOMap¶

Bases: pybind11_builtins.pybind11_object

Methods:

`__init__`(self)
`items`(self)
`keys`(self)
`values`(self)

__init__(self: depthai.BoardConfig.GPIOMap) → None ¶

items(self: depthai.BoardConfig.GPIOMap) → depthai.BoardConfig.ItemsView_GPIOMap ¶

keys(self: depthai.BoardConfig.GPIOMap) → depthai.BoardConfig.KeysView_GPIOMap ¶

values(self: depthai.BoardConfig.GPIOMap) → depthai.BoardConfig.ValuesView_GPIOMap ¶

class ItemsView_GPIOMap¶

Bases: pybind11_builtins.pybind11_object

Methods:

__init__(*args, **kwargs)

Initialize self.

__init__(*args, **kwargs)¶: Initialize self. See help(type(self)) for accurate signature.

class ItemsView_UARTMap¶

Bases: pybind11_builtins.pybind11_object

Methods:

__init__(*args, **kwargs)

Initialize self.

__init__(*args, **kwargs)¶: Initialize self. See help(type(self)) for accurate signature.

class KeysView_GPIOMap¶

Bases: pybind11_builtins.pybind11_object

Methods:

__init__(*args, **kwargs)

Initialize self.

__init__(*args, **kwargs)¶: Initialize self. See help(type(self)) for accurate signature.

class KeysView_UARTMap¶

Bases: pybind11_builtins.pybind11_object

Methods:

__init__(*args, **kwargs)

Initialize self.

__init__(*args, **kwargs)¶: Initialize self. See help(type(self)) for accurate signature.

class Network¶

Bases: pybind11_builtins.pybind11_object

Network configuration

Methods:

__init__(self)

Attributes:

`mtu`
`xlinkTcpNoDelay`

__init__(self: depthai.BoardConfig.Network) → None ¶

property mtu¶

property xlinkTcpNoDelay¶

class UART¶

Bases: pybind11_builtins.pybind11_object

UART instance config

Methods:

__init__(self)

Attributes:

tmp

__init__(self: depthai.BoardConfig.UART) → None ¶

property tmp¶

class UARTMap¶

Bases: pybind11_builtins.pybind11_object

Methods:

`__init__`(self)
`items`(self)
`keys`(self)
`values`(self)

__init__(self: depthai.BoardConfig.UARTMap) → None ¶

items(self: depthai.BoardConfig.UARTMap) → depthai.BoardConfig.ItemsView_UARTMap ¶

keys(self: depthai.BoardConfig.UARTMap) → depthai.BoardConfig.KeysView_UARTMap ¶

values(self: depthai.BoardConfig.UARTMap) → depthai.BoardConfig.ValuesView_UARTMap ¶

class USB¶

Bases: pybind11_builtins.pybind11_object

Methods:

__init__(self)

Attributes:

`flashBootedPid`
`flashBootedVid`
`maxSpeed`
`pid`
`vid`

__init__(self: depthai.BoardConfig.USB) → None ¶

property flashBootedPid¶

property flashBootedVid¶

property maxSpeed¶

property pid¶

property vid¶

class ValuesView_GPIOMap¶

Bases: pybind11_builtins.pybind11_object

Methods:

__init__(*args, **kwargs)

Initialize self.

__init__(*args, **kwargs)¶: Initialize self. See help(type(self)) for accurate signature.

class ValuesView_UARTMap¶

Bases: pybind11_builtins.pybind11_object

Methods:

__init__(*args, **kwargs)

Initialize self.

__init__(*args, **kwargs)¶: Initialize self. See help(type(self)) for accurate signature.

__init__(self: depthai.BoardConfig) → None ¶

property emmc¶

property gpio¶

property logDevicePrints¶

property logPath¶

property logSizeMax¶

property logVerbosity¶

property mipi4LaneRgb¶

property network¶

property pcieInternalClock¶

property sysctl¶

property uart¶

property usb¶

property usb3PhyInternalClock¶

property watchdogInitialDelayMs¶

property watchdogTimeoutMs¶

class depthai.Buffer¶

Bases: depthai.ADatatype

Base message - buffer of binary data

Methods:

`__init__`(self)	Creates Buffer message
`getData`(self)	Get non-owning reference to internal buffer
`setData`(args, *kwargs)	Overloaded function.

__init__(self: depthai.Buffer) → None ¶: Creates Buffer message

getData(self: object) → numpy.ndarray[numpy.uint8]¶

Get non-owning reference to internal buffer

Returns: Reference to internal buffer

setData(*args, **kwargs)¶

Overloaded function.

setData(self: depthai.Buffer, arg0: List[int]) -> None

Parameter data:: Copies data to internal buffer

setData(self: depthai.Buffer, arg0: numpy.ndarray[numpy.uint8]) -> None

Parameter data:: Copies data to internal buffer

class depthai.CalibrationHandler¶

Bases: pybind11_builtins.pybind11_object

CalibrationHandler is an interface to read/load/write structured calibration and device data. The following fields are protected and aren’t allowed to be overridden by default: - boardName - boardRev - boardConf - hardwareConf - batchName - batchTime - boardOptions - productName

Methods:

`__init__`(args, *kwargs)	Overloaded function.
`eepromToJson`(self)	Get JSON representation of calibration data
`eepromToJsonFile`(self, destPath)	Write raw calibration/board data to json file.
`fromJson`(arg0)	Construct a new Calibration Handler object from JSON EepromData.
`getBaselineDistance`(self, cam1, cam2, …)	Get the baseline distance between two specified cameras.
`getCameraExtrinsics`(self, srcCamera, …)	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 (in centimeters) is returned by this function.
`getCameraIntrinsics`(args, *kwargs)	Overloaded function.
`getCameraToImuExtrinsics`(self, cameraId, …)	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.
`getCameraTranslationVector`(self, srcCamera, …)	Get the Camera translation vector between two cameras from the calibration data.
`getDefaultIntrinsics`(self, cameraId)	Get the Default Intrinsics object
`getDistortionCoefficients`(self, cameraId)	Get the Distortion Coefficients object
`getEepromData`(self)	Get the Eeprom Data object
`getFov`(self, cameraId, useSpec)	Get the Fov of the camera
`getImuToCameraExtrinsics`(self, cameraId, …)	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.
`getLensPosition`(self, cameraId)	Get the lens position of the given camera
`getStereoLeftCameraId`(self)	Get the camera id of the camera which is used as left camera of the stereo setup
`getStereoLeftRectificationRotation`(self)	Get the Stereo Left Rectification Rotation object
`getStereoRightCameraId`(self)	Get the camera id of the camera which is used as right camera of the stereo setup
`getStereoRightRectificationRotation`(self)	Get the Stereo Right Rectification Rotation object
`setBoardInfo`(args, *kwargs)	Overloaded function.
`setCameraExtrinsics`(self, srcCameraId, …)	Set the Camera Extrinsics object
`setCameraIntrinsics`(args, *kwargs)	Overloaded function.
`setCameraType`(self, cameraId, cameraModel)	Set the Camera Type object
`setDistortionCoefficients`(self, cameraId, …)	Sets the distortion Coefficients obtained from camera calibration
`setFov`(self, cameraId, hfov)	Set the Fov of the Camera
`setImuExtrinsics`(self, destCameraId, …)	Set the Imu to Camera Extrinsics object
`setLensPosition`(self, cameraId, lensPosition)	Sets the distortion Coefficients obtained from camera calibration
`setProductName`(self, productName)	Set the productName which acts as alisas for users to identify the device
`setStereoLeft`(self, cameraId, rectifiedRotation)	Set the Stereo Left Rectification object
`setStereoRight`(self, cameraId, rectifiedRotation)	Set the Stereo Right Rectification object

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: depthai.CalibrationHandler) -> None
__init__(self: depthai.CalibrationHandler, arg0: Path) -> None

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

Parameter eepromDataPath:: takes the full path to the json file containing the calibration and device info.

__init__(self: depthai.CalibrationHandler, arg0: Path, arg1: Path) -> None

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

Parameter calibrationDataPath:: Full Path to the .calib binary file from the gen1 calibration. (Supports only Version 5)
Parameter boardConfigPath:: Full Path to the board config json file containing device information.

__init__(self: depthai.CalibrationHandler, arg0: depthai.EepromData) -> None

Construct a new Calibration Handler object from EepromData object.

Parameter eepromData:: EepromData data structure containing the calibration data.

eepromToJson(self: depthai.CalibrationHandler) → json¶

Get JSON representation of calibration data

Returns: JSON structure

eepromToJsonFile(self: depthai.CalibrationHandler, destPath: Path) → bool ¶

Write raw calibration/board data to json file.

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

Returns: True on success, false otherwise

static fromJson(arg0: json) → depthai.CalibrationHandler ¶

Construct a new Calibration Handler object from JSON EepromData.

Parameter eepromDataJson:: EepromData as JSON

getBaselineDistance(self: depthai.CalibrationHandler, cam1: depthai.CameraBoardSocket = <CameraBoardSocket.???: 2>, cam2: depthai.CameraBoardSocket = <CameraBoardSocket.???: 1>, useSpecTranslation: bool = True) → float ¶

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

Parameter cam1:: First camera
Parameter cam2:: Second camera
Parameter useSpecTranslation:: Enabling this bool uses the translation information from the board design data (not the calibration data)

Returns: baseline distance in centimeters

getCameraExtrinsics(self: depthai.CalibrationHandler, srcCamera: depthai.CameraBoardSocket, dstCamera: depthai.CameraBoardSocket, useSpecTranslation: bool = False) → List[List[float]]¶

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 (in centimeters) is returned by this function.

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

Returns: a transformationMatrix which is 4x4 in homogeneous coordinate system

Matrix representation of transformation matrix f[ text{Transformation Matrix} = left [ begin{matrix} r_{00} & r_{01} & r_{02} & T_x \ r_{10} & r_{11} & r_{12} & T_y \ r_{20} & r_{21} & r_{22} & T_z \ 0 & 0 & 0 & 1 end{matrix} right ] f]

getCameraIntrinsics(*args, **kwargs)¶

Overloaded function.

getCameraIntrinsics(self: depthai.CalibrationHandler, cameraId: depthai.CameraBoardSocket, resizeWidth: int = -1, resizeHeight: int = -1, topLeftPixelId: depthai.Point2f = <depthai.Point2f object at 0x7f72e2afb8f0>, bottomRightPixelId: depthai.Point2f = <depthai.Point2f object at 0x7f72e2afc070>, keepAspectRatio: bool = True) -> List[List[float]]

Get the Camera Intrinsics object

Parameter cameraId:: Uses the cameraId to identify which camera intrinsics to return
Parameter resizewidth:: resized width of the image for which intrinsics is requested. resizewidth = -1 represents width is same as default intrinsics
Parameter resizeHeight:: resized height of the image for which intrinsics is requested. resizeHeight = -1 represents height is same as default intrinsics
Parameter 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
Parameter 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
Parameter 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.

Matrix representation of intrinsic matrix f[ text{Intrinsic Matrix} = left [ begin{matrix} f_x & 0 & c_x \ 0 & f_y & c_y \ 0 & 0 & 1 end{matrix} right ] f]

getCameraIntrinsics(self: depthai.CalibrationHandler, cameraId: depthai.CameraBoardSocket, destShape: depthai.Size2f, topLeftPixelId: depthai.Point2f = <depthai.Point2f object at 0x7f72e2afbef0>, bottomRightPixelId: depthai.Point2f = <depthai.Point2f object at 0x7f72e2afb970>, keepAspectRatio: bool = True) -> List[List[float]]

Get the Camera Intrinsics object

Parameter cameraId:: Uses the cameraId to identify which camera intrinsics to return
Parameter destShape:: resized width and height of the image for which intrinsics is requested.
Parameter 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
Parameter 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
Parameter 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.

Matrix representation of intrinsic matrix f[ text{Intrinsic Matrix} = left [ begin{matrix} f_x & 0 & c_x \ 0 & f_y & c_y \ 0 & 0 & 1 end{matrix} right ] f]

getCameraIntrinsics(self: depthai.CalibrationHandler, cameraId: depthai.CameraBoardSocket, destShape: Tuple[int, int], topLeftPixelId: depthai.Point2f = <depthai.Point2f object at 0x7f72e2afbbb0>, bottomRightPixelId: depthai.Point2f = <depthai.Point2f object at 0x7f72e2afbfb0>, keepAspectRatio: bool = True) -> List[List[float]]

Get the Camera Intrinsics object

Parameter cameraId:: Uses the cameraId to identify which camera intrinsics to return
Parameter destShape:: resized width and height of the image for which intrinsics is requested.
Parameter 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
Parameter 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
Parameter 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.

Matrix representation of intrinsic matrix f[ text{Intrinsic Matrix} = left [ begin{matrix} f_x & 0 & c_x \ 0 & f_y & c_y \ 0 & 0 & 1 end{matrix} right ] f]

getCameraToImuExtrinsics(self: depthai.CalibrationHandler, cameraId: depthai.CameraBoardSocket, useSpecTranslation: bool = False) → List[List[float]]¶

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.

Parameter cameraId:: Camera Id of the camera which will be considered as origin. from which Transformation matrix to the IMU will be found
Parameter useSpecTranslation:: Enabling this bool uses the translation information from the board design data

Returns: Returns a transformationMatrix which is 4x4 in homogeneous coordinate system

Matrix representation of transformation matrix f[ text{Transformation Matrix} = left [ begin{matrix} r_{00} & r_{01} & r_{02} & T_x \ r_{10} & r_{11} & r_{12} & T_y \ r_{20} & r_{21} & r_{22} & T_z \ 0 & 0 & 0 & 1 end{matrix} right ] f]

getCameraTranslationVector(self: depthai.CalibrationHandler, srcCamera: depthai.CameraBoardSocket, dstCamera: depthai.CameraBoardSocket, useSpecTranslation: bool = True) → List[float]¶

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

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

Returns: a translation vector like [x, y, z] in centimeters

getDefaultIntrinsics(self: depthai.CalibrationHandler, cameraId: depthai.CameraBoardSocket) → Tuple[List[List[float]], int, int]¶

Get the Default Intrinsics object

Parameter 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.

Matrix representation of intrinsic matrix f[ text{Intrinsic Matrix} = left [ begin{matrix} f_x & 0 & c_x \ 0 & f_y & c_y \ 0 & 0 & 1 end{matrix} right ] f]

getDistortionCoefficients(self: depthai.CalibrationHandler, cameraId: depthai.CameraBoardSocket) → List[float]¶

Get the Distortion Coefficients object

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

Returns: [k1,k2,p1,p2,k3,k4,k5,k6,s1,s2,s3,s4,τx,τy]
Return type: the distortion coefficients of the requested camera in this order

getEepromData(self: depthai.CalibrationHandler) → depthai.EepromData ¶

Get the Eeprom Data object

Returns: EepromData object which contains the raw calibration data

getFov(self: depthai.CalibrationHandler, cameraId: depthai.CameraBoardSocket, useSpec: bool = True) → float ¶

Get the Fov of the camera

Parameter cameraId:: of the camera of which we are fetching fov.
Parameter 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.

getImuToCameraExtrinsics(self: depthai.CalibrationHandler, cameraId: depthai.CameraBoardSocket, useSpecTranslation: bool = False) → List[List[float]]¶

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.

Parameter cameraId:: Camera Id of the camera which will be considered as destination. To which Transformation matrix from the IMU will be found.
Parameter useSpecTranslation:: Enabling this bool uses the translation information from the board design data

Returns: Returns a transformationMatrix which is 4x4 in homogeneous coordinate system

Matrix representation of transformation matrix f[ text{Transformation Matrix} = left [ begin{matrix} r_{00} & r_{01} & r_{02} & T_x \ r_{10} & r_{11} & r_{12} & T_y \ r_{20} & r_{21} & r_{22} & T_z \ 0 & 0 & 0 & 1 end{matrix} right ] f]

getLensPosition(self: depthai.CalibrationHandler, cameraId: depthai.CameraBoardSocket) → int ¶

Get the lens position of the given camera

Parameter cameraId:: of the camera with lens position is requested.

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

getStereoLeftCameraId(self: depthai.CalibrationHandler) → depthai.CameraBoardSocket ¶

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

getStereoLeftRectificationRotation(self: depthai.CalibrationHandler) → List[List[float]]¶

Get the Stereo Left Rectification Rotation object

Returns: returns a 3x3 rectification rotation matrix

getStereoRightCameraId(self: depthai.CalibrationHandler) → depthai.CameraBoardSocket ¶

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

getStereoRightRectificationRotation(self: depthai.CalibrationHandler) → List[List[float]]¶

Get the Stereo Right Rectification Rotation object

Returns: returns a 3x3 rectification rotation matrix

setBoardInfo(*args, **kwargs)¶

Overloaded function.

setBoardInfo(self: depthai.CalibrationHandler, boardName: str, boardRev: str) -> None

Set the Board Info object

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

setBoardInfo(self: depthai.CalibrationHandler, productName: str, boardName: str, boardRev: str, boardConf: str, hardwareConf: str, batchName: str, batchTime: int, boardOptions: int, boardCustom: str = ‘’) -> None

Set the Board Info object. Creates version 7 EEPROM data

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

setCameraExtrinsics(self: depthai.CalibrationHandler, srcCameraId: depthai.CameraBoardSocket, destCameraId: depthai.CameraBoardSocket, rotationMatrix: List[List[float]], translation: List[float], specTranslation: List[float] = [0.0, 0.0, 0.0]) → None ¶

Set the Camera Extrinsics object

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

setCameraIntrinsics(*args, **kwargs)¶

Overloaded function.

setCameraIntrinsics(self: depthai.CalibrationHandler, cameraId: depthai.CameraBoardSocket, intrinsics: List[List[float]], frameSize: depthai.Size2f) -> None

Set the Camera Intrinsics object

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

Matrix representation of intrinsic matrix f[ text{Intrinsic Matrix} = left [ begin{matrix} f_x & 0 & c_x \ 0 & f_y & c_y \ 0 & 0 & 1 end{matrix} right ] f]

setCameraIntrinsics(self: depthai.CalibrationHandler, cameraId: depthai.CameraBoardSocket, intrinsics: List[List[float]], width: int, height: int) -> None

Set the Camera Intrinsics object

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

Matrix representation of intrinsic matrix f[ text{Intrinsic Matrix} = left [ begin{matrix} f_x & 0 & c_x \ 0 & f_y & c_y \ 0 & 0 & 1 end{matrix} right ] f]

setCameraIntrinsics(self: depthai.CalibrationHandler, cameraId: depthai.CameraBoardSocket, intrinsics: List[List[float]], frameSize: Tuple[int, int]) -> None

Set the Camera Intrinsics object

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

Matrix representation of intrinsic matrix f[ text{Intrinsic Matrix} = left [ begin{matrix} f_x & 0 & c_x \ 0 & f_y & c_y \ 0 & 0 & 1 end{matrix} right ] f]

setCameraType(self: depthai.CalibrationHandler, cameraId: depthai.CameraBoardSocket, cameraModel: depthai.CameraModel) → None ¶

Set the Camera Type object

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

setDistortionCoefficients(self: depthai.CalibrationHandler, cameraId: depthai.CameraBoardSocket, distortionCoefficients: List[float]) → None ¶

Sets the distortion Coefficients obtained from camera calibration

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

setFov(self: depthai.CalibrationHandler, cameraId: depthai.CameraBoardSocket, hfov: float) → None ¶

Set the Fov of the Camera

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

setImuExtrinsics(self: depthai.CalibrationHandler, destCameraId: depthai.CameraBoardSocket, rotationMatrix: List[List[float]], translation: List[float], specTranslation: List[float] = [0.0, 0.0, 0.0]) → None ¶

Set the Imu to Camera Extrinsics object

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

setLensPosition(self: depthai.CalibrationHandler, cameraId: depthai.CameraBoardSocket, lensPosition: int) → None ¶

Sets the distortion Coefficients obtained from camera calibration

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

setProductName(self: depthai.CalibrationHandler, productName: str) → None ¶

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

Parameter productName:: Sets product name (alias).

setStereoLeft(self: depthai.CalibrationHandler, cameraId: depthai.CameraBoardSocket, rectifiedRotation: List[List[float]]) → None ¶

Set the Stereo Left Rectification object

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

Homography of the Left Rectification = Intrinsics_right * rectifiedRotation * inv(Intrinsics_left)

setStereoRight(self: depthai.CalibrationHandler, cameraId: depthai.CameraBoardSocket, rectifiedRotation: List[List[float]]) → None ¶

Set the Stereo Right Rectification object

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

Homography of the Right Rectification = Intrinsics_right * rectifiedRotation * inv(Intrinsics_right)

class depthai.CameraBoardSocket¶

Bases: pybind11_builtins.pybind11_object

Which Camera socket to use.

AUTO denotes that the decision will be made by device

Members:

AUTO

RGB

LEFT

RIGHT

CENTER

CAM_A

CAM_B

CAM_C

CAM_D

CAM_E

CAM_F

CAM_G

CAM_H

Attributes:

`AUTO`
`CAM_A`
`CAM_B`
`CAM_C`
`CAM_D`
`CAM_E`
`CAM_F`
`CAM_G`
`CAM_H`
`CENTER`
`LEFT`
`RGB`
`RIGHT`
`name`
`value`

Methods:

__init__(self, value)

AUTO = <CameraBoardSocket.AUTO: -1>¶

CAM_A = <CameraBoardSocket.RGB: 0>¶

CAM_B = <CameraBoardSocket.LEFT: 1>¶

CAM_C = <CameraBoardSocket.RIGHT: 2>¶

CAM_D = <CameraBoardSocket.CAM_D: 3>¶

CAM_E = <CameraBoardSocket.CAM_E: 4>¶

CAM_F = <CameraBoardSocket.CAM_F: 5>¶

CAM_G = <CameraBoardSocket.CAM_G: 6>¶

CAM_H = <CameraBoardSocket.CAM_H: 7>¶

CENTER = <CameraBoardSocket.RGB: 0>¶

LEFT = <CameraBoardSocket.LEFT: 1>¶

RGB = <CameraBoardSocket.RGB: 0>¶

RIGHT = <CameraBoardSocket.RIGHT: 2>¶

__init__(self: depthai.CameraBoardSocket, value: int) → None ¶

property name¶

property value¶

class depthai.CameraControl¶

Bases: depthai.Buffer

CameraControl message. Specifies various camera control commands like:

Still capture
Auto/manual focus
Auto/manual white balance
Auto/manual exposure
Anti banding
…

By default the camera enables 3A, with auto-focus in CONTINUOUS_VIDEO mode, auto-white-balance in AUTO mode, and auto-exposure with anti-banding for 50Hz mains frequency.

Classes:

`AntiBandingMode`	Members:
`AutoFocusMode`	Members:
`AutoWhiteBalanceMode`	Members:
`Command`	Members:
`EffectMode`	Members:
`FrameSyncMode`	Members:
`SceneMode`	Members:

Methods:

`__init__`(self)	Construct CameraControl message
`getCaptureStill`(self)	Check whether command to capture a still is set
`getExposureTime`(self)	Retrieves exposure time
`getLensPosition`(self)	Retrieves lens position, range 0..255.
`getSensitivity`(self)	Retrieves sensitivity, as an ISO value
`setAntiBandingMode`(self, mode)	Set a command to specify anti-banding mode.
`setAutoExposureCompensation`(self, compensation)	Set a command to specify auto exposure compensation
`setAutoExposureEnable`(self)	Set a command to enable auto exposure
`setAutoExposureLock`(self, lock)	Set a command to specify lock auto exposure
`setAutoExposureRegion`(self, startX, startY, …)	Set a command to specify auto exposure region in pixels.
`setAutoFocusLensRange`(self, …)	Set autofocus lens range, infinityPosition < macroPosition, valid values 0..255.
`setAutoFocusMode`(self, mode)	Set a command to specify autofocus mode.
`setAutoFocusRegion`(self, startX, startY, …)	Set a command to specify focus region in pixels.
`setAutoFocusTrigger`(self)	Set a command to trigger autofocus
`setAutoWhiteBalanceLock`(self, lock)	Set a command to specify auto white balance lock
`setAutoWhiteBalanceMode`(self, mode)	Set a command to specify auto white balance mode
`setBrightness`(self, value)	Set a command to adjust image brightness
`setCaptureStill`(self, capture)	Set a command to capture a still image
`setChromaDenoise`(self, value)	Set a command to adjust chroma denoise amount
`setContrast`(self, value)	Set a command to adjust image contrast
`setEffectMode`(self, mode)	Set a command to specify effect mode
`setExternalTrigger`(self, numFramesBurst, …)	Set a command to enable external trigger snapshot mode
`setFrameSyncMode`(self, mode)	Set the frame sync mode for continuous streaming operation mode, translating to how the camera pin FSIN/FSYNC is used: input/output/disabled
`setLumaDenoise`(self, value)	Set a command to adjust luma denoise amount
`setManualExposure`(args, *kwargs)	Overloaded function.
`setManualFocus`(self, lensPosition)	Set a command to specify manual focus position
`setManualWhiteBalance`(self, colorTemperatureK)	Set a command to manually specify white-balance color correction
`setSaturation`(self, value)	Set a command to adjust image saturation
`setSceneMode`(self, mode)	Set a command to specify scene mode
`setSharpness`(self, value)	Set a command to adjust image sharpness
`setStartStreaming`(self)	Set a command to start streaming
`setStopStreaming`(self)	Set a command to stop streaming
`setStrobeDisable`(self)	Disable STROBE output
`setStrobeExternal`(self, gpioNumber, 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
`setStrobeSensor`(self, activeLevel)	Enable STROBE output on sensor pin, optionally configuring the polarity.

class AntiBandingMode¶

Bases: pybind11_builtins.pybind11_object

Members:

OFF

MAINS_50_HZ

MAINS_60_HZ

AUTO

Attributes:

`AUTO`
`MAINS_50_HZ`
`MAINS_60_HZ`
`OFF`
`name`
`value`

Methods:

__init__(self, value)

AUTO = <AntiBandingMode.AUTO: 3>¶

MAINS_50_HZ = <AntiBandingMode.MAINS_50_HZ: 1>¶

MAINS_60_HZ = <AntiBandingMode.MAINS_60_HZ: 2>¶

OFF = <AntiBandingMode.OFF: 0>¶

__init__(self: depthai.RawCameraControl.AntiBandingMode, value: int) → None ¶

property name¶

property value¶

class AutoFocusMode¶

Bases: pybind11_builtins.pybind11_object

Members:

OFF

AUTO

MACRO

CONTINUOUS_VIDEO

CONTINUOUS_PICTURE

EDOF

Attributes:

`AUTO`
`CONTINUOUS_PICTURE`
`CONTINUOUS_VIDEO`
`EDOF`
`MACRO`
`OFF`
`name`
`value`

Methods:

__init__(self, value)

AUTO = <AutoFocusMode.AUTO: 1>¶

CONTINUOUS_PICTURE = <AutoFocusMode.CONTINUOUS_PICTURE: 4>¶

CONTINUOUS_VIDEO = <AutoFocusMode.CONTINUOUS_VIDEO: 3>¶

EDOF = <AutoFocusMode.EDOF: 5>¶

MACRO = <AutoFocusMode.MACRO: 2>¶

OFF = <AutoFocusMode.OFF: 0>¶

__init__(self: depthai.RawCameraControl.AutoFocusMode, value: int) → None ¶

property name¶

property value¶

class AutoWhiteBalanceMode¶

Bases: pybind11_builtins.pybind11_object

Members:

OFF

AUTO

INCANDESCENT

FLUORESCENT

WARM_FLUORESCENT

DAYLIGHT

CLOUDY_DAYLIGHT

TWILIGHT

SHADE

Attributes:

`AUTO`
`CLOUDY_DAYLIGHT`
`DAYLIGHT`
`FLUORESCENT`
`INCANDESCENT`
`OFF`
`SHADE`
`TWILIGHT`
`WARM_FLUORESCENT`
`name`
`value`

Methods:

__init__(self, value)

AUTO = <AutoWhiteBalanceMode.AUTO: 1>¶

CLOUDY_DAYLIGHT = <AutoWhiteBalanceMode.CLOUDY_DAYLIGHT: 6>¶

DAYLIGHT = <AutoWhiteBalanceMode.DAYLIGHT: 5>¶

FLUORESCENT = <AutoWhiteBalanceMode.FLUORESCENT: 3>¶

INCANDESCENT = <AutoWhiteBalanceMode.INCANDESCENT: 2>¶

OFF = <AutoWhiteBalanceMode.OFF: 0>¶

SHADE = <AutoWhiteBalanceMode.SHADE: 8>¶

TWILIGHT = <AutoWhiteBalanceMode.TWILIGHT: 7>¶

WARM_FLUORESCENT = <AutoWhiteBalanceMode.WARM_FLUORESCENT: 4>¶

__init__(self: depthai.RawCameraControl.AutoWhiteBalanceMode, value: int) → None ¶

property name¶

property value¶

class Command¶

Bases: pybind11_builtins.pybind11_object

Members:

START_STREAM

STOP_STREAM

STILL_CAPTURE

MOVE_LENS

AF_TRIGGER

AE_MANUAL

AE_AUTO

AWB_MODE

SCENE_MODE

ANTIBANDING_MODE

EXPOSURE_COMPENSATION

AE_LOCK

AE_TARGET_FPS_RANGE

AWB_LOCK

CAPTURE_INTENT

CONTROL_MODE

FRAME_DURATION

SENSITIVITY

EFFECT_MODE

AF_MODE

NOISE_REDUCTION_STRENGTH

SATURATION

BRIGHTNESS

STREAM_FORMAT

RESOLUTION

SHARPNESS

CUSTOM_USECASE

CUSTOM_CAPT_MODE

CUSTOM_EXP_BRACKETS

CUSTOM_CAPTURE

CONTRAST

AE_REGION

AF_REGION

LUMA_DENOISE

CHROMA_DENOISE

WB_COLOR_TEMP

Attributes:

Methods:

__init__(self, value)

AE_AUTO = <Command.AE_AUTO: 7>¶

AE_LOCK = <Command.AE_LOCK: 13>¶

AE_MANUAL = <Command.AE_MANUAL: 6>¶

AE_REGION = <Command.AE_REGION: 45>¶

AE_TARGET_FPS_RANGE = <Command.AE_TARGET_FPS_RANGE: 14>¶

AF_MODE = <Command.AF_MODE: 26>¶

AF_REGION = <Command.AF_REGION: 46>¶

AF_TRIGGER = <Command.AF_TRIGGER: 5>¶

ANTIBANDING_MODE = <Command.ANTIBANDING_MODE: 10>¶

AWB_LOCK = <Command.AWB_LOCK: 16>¶

AWB_MODE = <Command.AWB_MODE: 8>¶

BRIGHTNESS = <Command.BRIGHTNESS: 31>¶

CAPTURE_INTENT = <Command.CAPTURE_INTENT: 17>¶

CHROMA_DENOISE = <Command.CHROMA_DENOISE: 48>¶

CONTRAST = <Command.CONTRAST: 44>¶

CONTROL_MODE = <Command.CONTROL_MODE: 18>¶

CUSTOM_CAPTURE = <Command.CUSTOM_CAPTURE: 43>¶

CUSTOM_CAPT_MODE = <Command.CUSTOM_CAPT_MODE: 41>¶

CUSTOM_EXP_BRACKETS = <Command.CUSTOM_EXP_BRACKETS: 42>¶

CUSTOM_USECASE = <Command.CUSTOM_USECASE: 40>¶

EFFECT_MODE = <Command.EFFECT_MODE: 24>¶

EXPOSURE_COMPENSATION = <Command.EXPOSURE_COMPENSATION: 11>¶

FRAME_DURATION = <Command.FRAME_DURATION: 21>¶

LUMA_DENOISE = <Command.LUMA_DENOISE: 47>¶

MOVE_LENS = <Command.MOVE_LENS: 4>¶

NOISE_REDUCTION_STRENGTH = <Command.NOISE_REDUCTION_STRENGTH: 27>¶

RESOLUTION = <Command.RESOLUTION: 34>¶

SATURATION = <Command.SATURATION: 28>¶

SCENE_MODE = <Command.SCENE_MODE: 9>¶

SENSITIVITY = <Command.SENSITIVITY: 23>¶

SHARPNESS = <Command.SHARPNESS: 35>¶

START_STREAM = <Command.START_STREAM: 1>¶

STILL_CAPTURE = <Command.STILL_CAPTURE: 3>¶

STOP_STREAM = <Command.STOP_STREAM: 2>¶

STREAM_FORMAT = <Command.STREAM_FORMAT: 33>¶

WB_COLOR_TEMP = <Command.WB_COLOR_TEMP: 49>¶

__init__(self: depthai.RawCameraControl.Command, value: int) → None ¶

property name¶

property value¶

class EffectMode¶

Bases: pybind11_builtins.pybind11_object

Members:

OFF

MONO

NEGATIVE

SOLARIZE

SEPIA

POSTERIZE

WHITEBOARD

BLACKBOARD

AQUA

Attributes:

`AQUA`
`BLACKBOARD`
`MONO`
`NEGATIVE`
`OFF`
`POSTERIZE`
`SEPIA`
`SOLARIZE`
`WHITEBOARD`
`name`
`value`

Methods:

__init__(self, value)

AQUA = <EffectMode.AQUA: 8>¶

BLACKBOARD = <EffectMode.BLACKBOARD: 7>¶

MONO = <EffectMode.MONO: 1>¶

NEGATIVE = <EffectMode.NEGATIVE: 2>¶

OFF = <EffectMode.OFF: 0>¶

POSTERIZE = <EffectMode.POSTERIZE: 5>¶

SEPIA = <EffectMode.SEPIA: 4>¶

SOLARIZE = <EffectMode.SOLARIZE: 3>¶

WHITEBOARD = <EffectMode.WHITEBOARD: 6>¶

__init__(self: depthai.RawCameraControl.EffectMode, value: int) → None ¶

property name¶

property value¶

class FrameSyncMode¶

Bases: pybind11_builtins.pybind11_object

Members:

OFF

OUTPUT

INPUT

Attributes:

`INPUT`
`OFF`
`OUTPUT`
`name`
`value`

Methods:

__init__(self, value)

INPUT = <FrameSyncMode.INPUT: 2>¶

OFF = <FrameSyncMode.OFF: 0>¶

OUTPUT = <FrameSyncMode.OUTPUT: 1>¶

__init__(self: depthai.RawCameraControl.FrameSyncMode, value: int) → None ¶

property name¶

property value¶

class SceneMode¶

Bases: pybind11_builtins.pybind11_object

Members:

UNSUPPORTED

FACE_PRIORITY

ACTION

PORTRAIT

LANDSCAPE

NIGHT

NIGHT_PORTRAIT

THEATRE

BEACH

SNOW

SUNSET

STEADYPHOTO

FIREWORKS

SPORTS

PARTY

CANDLELIGHT

BARCODE

Attributes:

`ACTION`
`BARCODE`
`BEACH`
`CANDLELIGHT`
`FACE_PRIORITY`
`FIREWORKS`
`LANDSCAPE`
`NIGHT`
`NIGHT_PORTRAIT`
`PARTY`
`PORTRAIT`
`SNOW`
`SPORTS`
`STEADYPHOTO`
`SUNSET`
`THEATRE`
`UNSUPPORTED`
`name`
`value`

Methods:

__init__(self, value)

ACTION = <SceneMode.ACTION: 2>¶

BARCODE = <SceneMode.BARCODE: 16>¶

BEACH = <SceneMode.BEACH: 8>¶

CANDLELIGHT = <SceneMode.CANDLELIGHT: 15>¶

FACE_PRIORITY = <SceneMode.FACE_PRIORITY: 1>¶

FIREWORKS = <SceneMode.FIREWORKS: 12>¶

LANDSCAPE = <SceneMode.LANDSCAPE: 4>¶

NIGHT = <SceneMode.NIGHT: 5>¶

NIGHT_PORTRAIT = <SceneMode.NIGHT_PORTRAIT: 6>¶

PARTY = <SceneMode.PARTY: 14>¶

PORTRAIT = <SceneMode.PORTRAIT: 3>¶

SNOW = <SceneMode.SNOW: 9>¶

SPORTS = <SceneMode.SPORTS: 13>¶

STEADYPHOTO = <SceneMode.STEADYPHOTO: 11>¶

SUNSET = <SceneMode.SUNSET: 10>¶

THEATRE = <SceneMode.THEATRE: 7>¶

UNSUPPORTED = <SceneMode.UNSUPPORTED: 0>¶

__init__(self: depthai.RawCameraControl.SceneMode, value: int) → None ¶

property name¶

property value¶

__init__(self: depthai.CameraControl) → None ¶: Construct CameraControl message

getCaptureStill(self: depthai.CameraControl) → bool ¶

Check whether command to capture a still is set

Returns: True if capture still command is set

getExposureTime(self: depthai.CameraControl) → datetime.timedelta ¶: Retrieves exposure time

getLensPosition(self: depthai.CameraControl) → int ¶: Retrieves lens position, range 0..255. Returns -1 if not available

getSensitivity(self: depthai.CameraControl) → int ¶: Retrieves sensitivity, as an ISO value

setAntiBandingMode(self: depthai.CameraControl, mode: depthai.RawCameraControl.AntiBandingMode) → depthai.CameraControl ¶

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.

Parameter mode:: Anti-banding mode to use. Default: MAINS_50_HZ

setAutoExposureCompensation(self: depthai.CameraControl, compensation: int) → depthai.CameraControl ¶

Set a command to specify auto exposure compensation

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

setAutoExposureEnable(self: depthai.CameraControl) → depthai.CameraControl ¶: Set a command to enable auto exposure

setAutoExposureLock(self: depthai.CameraControl, lock: bool) → depthai.CameraControl ¶

Set a command to specify lock auto exposure

Parameter lock:: Auto exposure lock mode enabled or disabled

setAutoExposureRegion(self: depthai.CameraControl, startX: int, startY: int, width: int, height: int) → depthai.CameraControl ¶

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

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

setAutoFocusLensRange(self: depthai.CameraControl, infinityPosition: int, macroPosition: int) → depthai.CameraControl ¶: Set autofocus lens range, infinityPosition < macroPosition, valid values 0..255. May help to improve autofocus in case the lens adjustment is not typical/tuned

setAutoFocusMode(self: depthai.CameraControl, mode: depthai.RawCameraControl.AutoFocusMode) → depthai.CameraControl ¶: Set a command to specify autofocus mode. Default CONTINUOUS_VIDEO

setAutoFocusRegion(self: depthai.CameraControl, startX: int, startY: int, width: int, height: int) → depthai.CameraControl ¶

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

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

setAutoFocusTrigger(self: depthai.CameraControl) → depthai.CameraControl ¶: Set a command to trigger autofocus

setAutoWhiteBalanceLock(self: depthai.CameraControl, lock: bool) → depthai.CameraControl ¶

Set a command to specify auto white balance lock

Parameter lock:: Auto white balance lock mode enabled or disabled

setAutoWhiteBalanceMode(self: depthai.CameraControl, mode: depthai.RawCameraControl.AutoWhiteBalanceMode) → depthai.CameraControl ¶

Set a command to specify auto white balance mode

Parameter mode:: Auto white balance mode to use. Default AUTO

setBrightness(self: depthai.CameraControl, value: int) → depthai.CameraControl ¶

Set a command to adjust image brightness

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

setCaptureStill(self: depthai.CameraControl, capture: bool) → depthai.CameraControl ¶: Set a command to capture a still image

setChromaDenoise(self: depthai.CameraControl, value: int) → depthai.CameraControl ¶

Set a command to adjust chroma denoise amount

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

setContrast(self: depthai.CameraControl, value: int) → depthai.CameraControl ¶

Set a command to adjust image contrast

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

setEffectMode(self: depthai.CameraControl, mode: depthai.RawCameraControl.EffectMode) → depthai.CameraControl ¶

Set a command to specify effect mode

Parameter mode:: Effect mode

setExternalTrigger(self: depthai.CameraControl, numFramesBurst: int, numFramesDiscard: int) → depthai.CameraControl ¶

Set a command to enable external trigger snapshot mode

A rising edge on the sensor FSIN pin will make it capture a sequence of numFramesBurst frames. First numFramesDiscard will be skipped as configured (can be set to 0 as well), as they may have degraded quality

setFrameSyncMode(self: depthai.CameraControl, mode: depthai.RawCameraControl.FrameSyncMode) → depthai.CameraControl ¶: Set the frame sync mode for continuous streaming operation mode, translating to how the camera pin FSIN/FSYNC is used: input/output/disabled

setLumaDenoise(self: depthai.CameraControl, value: int) → depthai.CameraControl ¶

Set a command to adjust luma denoise amount

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

setManualExposure(*args, **kwargs)¶

Overloaded function.

setManualExposure(self: depthai.CameraControl, exposureTimeUs: int, sensitivityIso: int) -> depthai.CameraControl

Set a command to manually specify exposure

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

setManualExposure(self: depthai.CameraControl, exposureTime: datetime.timedelta, sensitivityIso: int) -> None

Set a command to manually specify exposure

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

setManualFocus(self: depthai.CameraControl, lensPosition: int) → depthai.CameraControl ¶

Set a command to specify manual focus position

Parameter lensPosition:: specify lens position 0..255

setManualWhiteBalance(self: depthai.CameraControl, colorTemperatureK: int) → depthai.CameraControl ¶

Set a command to manually specify white-balance color correction

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

setSaturation(self: depthai.CameraControl, value: int) → depthai.CameraControl ¶

Set a command to adjust image saturation

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

setSceneMode(self: depthai.CameraControl, mode: depthai.RawCameraControl.SceneMode) → depthai.CameraControl ¶

Set a command to specify scene mode

Parameter mode:: Scene mode

setSharpness(self: depthai.CameraControl, value: int) → depthai.CameraControl ¶

Set a command to adjust image sharpness

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

setStartStreaming(self: depthai.CameraControl) → depthai.CameraControl ¶: Set a command to start streaming

setStopStreaming(self: depthai.CameraControl) → depthai.CameraControl ¶: Set a command to stop streaming

setStrobeDisable(self: depthai.CameraControl) → depthai.CameraControl ¶: Disable STROBE output

setStrobeExternal(self: depthai.CameraControl, gpioNumber: int, activeLevel: int) → depthai.CameraControl ¶: 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

setStrobeSensor(self: depthai.CameraControl, activeLevel: int) → depthai.CameraControl ¶: Enable STROBE output on sensor pin, optionally configuring the polarity. Note: for many sensors the polarity is high-active and not configurable

class depthai.CameraExposureOffset¶

Bases: pybind11_builtins.pybind11_object

Members:

START

MIDDLE

END

Attributes:

`END`
`MIDDLE`
`START`
`name`
`value`

Methods:

__init__(self, value)

END = <CameraExposureOffset.END: 2>¶

MIDDLE = <CameraExposureOffset.MIDDLE: 1>¶

START = <CameraExposureOffset.START: 0>¶

__init__(self: depthai.CameraExposureOffset, value: int) → None ¶

property name¶

property value¶

class depthai.CameraFeatures¶

Bases: pybind11_builtins.pybind11_object

CameraFeatures structure

Characterizes detected cameras on board

Methods:

__init__(self)

Attributes:

`hasAutofocus`
`height`
`name`
`orientation`
`sensorName`
`socket`
`supportedTypes`
`width`

__init__(self: depthai.CameraFeatures) → None ¶

property hasAutofocus¶

property height¶

property name¶

property orientation¶

property sensorName¶

property socket¶

property supportedTypes¶

property width¶

class depthai.CameraImageOrientation¶

Bases: pybind11_builtins.pybind11_object

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).

Members:

AUTO

NORMAL

HORIZONTAL_MIRROR

VERTICAL_FLIP

ROTATE_180_DEG

Attributes:

`AUTO`
`HORIZONTAL_MIRROR`
`NORMAL`
`ROTATE_180_DEG`
`VERTICAL_FLIP`
`name`
`value`

Methods:

__init__(self, value)

AUTO = <CameraImageOrientation.AUTO: -1>¶

HORIZONTAL_MIRROR = <CameraImageOrientation.HORIZONTAL_MIRROR: 1>¶

NORMAL = <CameraImageOrientation.NORMAL: 0>¶

ROTATE_180_DEG = <CameraImageOrientation.ROTATE_180_DEG: 3>¶

VERTICAL_FLIP = <CameraImageOrientation.VERTICAL_FLIP: 2>¶

__init__(self: depthai.CameraImageOrientation, value: int) → None ¶

property name¶

property value¶

class depthai.CameraInfo¶

Bases: pybind11_builtins.pybind11_object

CameraInfo structure

Methods:

__init__(self)

Attributes:

`cameraType`
`distortionCoeff`
`extrinsics`
`height`
`intrinsicMatrix`
`specHfovDeg`
`width`

__init__(self: depthai.CameraInfo) → None ¶

property cameraType¶

property distortionCoeff¶

property extrinsics¶

property height¶

property intrinsicMatrix¶

property specHfovDeg¶

property width¶

class depthai.CameraModel¶

Bases: pybind11_builtins.pybind11_object

Which CameraModel to initialize the calibration with.

Members:

Perspective

Fisheye

Equirectangular

RadialDivision

Attributes:

`Equirectangular`
`Fisheye`
`Perspective`
`RadialDivision`
`name`
`value`

Methods:

__init__(self, value)

Equirectangular = <CameraModel.Equirectangular: 2>¶

Fisheye = <CameraModel.Fisheye: 1>¶

Perspective = <CameraModel.Perspective: 0>¶

RadialDivision = <CameraModel.RadialDivision: 3>¶

__init__(self: depthai.CameraModel, value: int) → None ¶

property name¶

property value¶

class depthai.CameraProperties¶

Bases: pybind11_builtins.pybind11_object

Specify properties for ColorCamera such as camera ID, …

Classes:

`ColorOrder`	For 24 bit color these can be either RGB or BGR
`WarpMeshSource`	Warp mesh source

Methods:

__init__(*args, **kwargs)

Initialize self.

Attributes:

class ColorOrder¶

Bases: pybind11_builtins.pybind11_object

For 24 bit color these can be either RGB or BGR

Members:

BGR

RGB

Attributes:

`BGR`
`RGB`
`name`
`value`

Methods:

__init__(self, value)

BGR = <ColorOrder.BGR: 0>¶

RGB = <ColorOrder.RGB: 1>¶

__init__(self: depthai.CameraProperties.ColorOrder, value: int) → None ¶

property name¶

property value¶

class WarpMeshSource¶

Bases: pybind11_builtins.pybind11_object

Warp mesh source

Members:

AUTO

NONE

CALIBRATION

URI

Attributes:

`AUTO`
`CALIBRATION`
`NONE`
`URI`
`name`
`value`

Methods:

__init__(self, value)

AUTO = <WarpMeshSource.AUTO: -1>¶

CALIBRATION = <WarpMeshSource.CALIBRATION: 1>¶

NONE = <WarpMeshSource.NONE: 0>¶

URI = <WarpMeshSource.URI: 2>¶

__init__(self: depthai.CameraProperties.WarpMeshSource, value: int) → None ¶

property name¶

property value¶

__init__(*args, **kwargs)¶: Initialize self. See help(type(self)) for accurate signature.

property boardSocket¶

property calibAlpha¶

property colorOrder¶

property fp16¶

property fps¶

property imageOrientation¶

property initialControl¶

property interleaved¶

property ispScale¶

property numFramesPoolIsp¶

property numFramesPoolPreview¶

property numFramesPoolRaw¶

property numFramesPoolStill¶

property numFramesPoolVideo¶

property previewHeight¶

property previewKeepAspectRatio¶

property previewWidth¶

property sensorCropX¶

property sensorCropY¶

property stillHeight¶

property stillWidth¶

property videoHeight¶

property videoWidth¶

property warpMeshHeight¶

property warpMeshSource¶

property warpMeshStepHeight¶

property warpMeshStepWidth¶

property warpMeshUri¶

property warpMeshWidth¶

class depthai.CameraSensorType¶

Bases: pybind11_builtins.pybind11_object

Camera sensor type

Members:

COLOR

MONO

TOF

THERMAL

Attributes:

`COLOR`
`MONO`
`THERMAL`
`TOF`
`name`
`value`

Methods:

__init__(self, value)

COLOR = <CameraSensorType.COLOR: 0>¶

MONO = <CameraSensorType.MONO: 1>¶

THERMAL = <CameraSensorType.THERMAL: 3>¶

TOF = <CameraSensorType.TOF: 2>¶

__init__(self: depthai.CameraSensorType, value: int) → None ¶

property name¶

property value¶

class depthai.ChipTemperature¶

Bases: pybind11_builtins.pybind11_object

Chip temperature information.

Multiple temperature measurement points and their average

Methods:

__init__(self)

Attributes:

`average`
`css`
`dss`
`mss`
`upa`

__init__(self: depthai.ChipTemperature) → None ¶

property average¶

property css¶

property dss¶

property mss¶

property upa¶

class depthai.Clock¶

Bases: pybind11_builtins.pybind11_object

Methods:

`__init__`(args, *kwargs)	Initialize self.
`now`()

__init__(*args, **kwargs)¶: Initialize self. See help(type(self)) for accurate signature.

now() → datetime.timedelta ¶

class depthai.ColorCameraProperties¶

Bases: pybind11_builtins.pybind11_object

Specify properties for ColorCamera such as camera ID, …

Classes:

`ColorOrder`	For 24 bit color these can be either RGB or BGR
`SensorResolution`	Select the camera sensor resolution

Methods:

__init__(*args, **kwargs)

Initialize self.

Attributes:

class ColorOrder¶

Bases: pybind11_builtins.pybind11_object

For 24 bit color these can be either RGB or BGR

Members:

BGR

RGB

Attributes:

`BGR`
`RGB`
`name`
`value`

Methods:

__init__(self, value)

BGR = <ColorOrder.BGR: 0>¶

RGB = <ColorOrder.RGB: 1>¶

__init__(self: depthai.ColorCameraProperties.ColorOrder, value: int) → None ¶

property name¶

property value¶

class SensorResolution¶

Bases: pybind11_builtins.pybind11_object

Select the camera sensor resolution

Members:

THE_1080_P

THE_1200_P

THE_4_K

THE_5_MP

THE_12_MP

THE_4000X3000

THE_13_MP

THE_5312X6000

THE_48_MP

THE_720_P

THE_800_P

THE_1440X1080

Attributes:

`THE_1080_P`
`THE_1200_P`
`THE_12_MP`
`THE_13_MP`
`THE_1440X1080`
`THE_4000X3000`
`THE_48_MP`
`THE_4_K`
`THE_5312X6000`
`THE_5_MP`
`THE_720_P`
`THE_800_P`
`name`
`value`

Methods:

__init__(self, value)

THE_1080_P = <SensorResolution.THE_1080_P: 0>¶

THE_1200_P = <SensorResolution.THE_1200_P: 6>¶

THE_12_MP = <SensorResolution.THE_12_MP: 2>¶

THE_13_MP = <SensorResolution.THE_13_MP: 3>¶

THE_1440X1080 = <SensorResolution.THE_1440X1080: 11>¶

THE_4000X3000 = <SensorResolution.THE_4000X3000: 8>¶

THE_48_MP = <SensorResolution.THE_48_MP: 10>¶

THE_4_K = <SensorResolution.THE_4_K: 1>¶

THE_5312X6000 = <SensorResolution.THE_5312X6000: 9>¶

THE_5_MP = <SensorResolution.THE_5_MP: 7>¶

THE_720_P = <SensorResolution.THE_720_P: 4>¶

THE_800_P = <SensorResolution.THE_800_P: 5>¶

__init__(self: depthai.ColorCameraProperties.SensorResolution, value: int) → None ¶

property name¶

property value¶

__init__(*args, **kwargs)¶: Initialize self. See help(type(self)) for accurate signature.

property boardSocket¶

property colorOrder¶

property eventFilter¶

property fp16¶

property fps¶

property imageOrientation¶

property initialControl¶

property interleaved¶

property ispScale¶

property numFramesPoolIsp¶

property numFramesPoolPreview¶

property numFramesPoolRaw¶

property numFramesPoolStill¶

property numFramesPoolVideo¶

property previewHeight¶

property previewKeepAspectRatio¶

property previewWidth¶

property resolution¶

property sensorCropX¶

property sensorCropY¶

property stillHeight¶

property stillWidth¶

property videoHeight¶

property videoWidth¶

class depthai.Colormap¶

Bases: pybind11_builtins.pybind11_object

Camera sensor type

Members:

NONE

JET

TURBO

STEREO_JET

STEREO_TURBO

Attributes:

`JET`
`NONE`
`STEREO_JET`
`STEREO_TURBO`
`TURBO`
`name`
`value`

Methods:

__init__(self, value)

JET = <Colormap.JET: 2>¶

NONE = <Colormap.NONE: 0>¶

STEREO_JET = <Colormap.STEREO_JET: 4>¶

STEREO_TURBO = <Colormap.STEREO_TURBO: 3>¶

TURBO = <Colormap.TURBO: 1>¶

__init__(self: depthai.Colormap, value: int) → None ¶

property name¶

property value¶

class depthai.CpuUsage¶

Bases: pybind11_builtins.pybind11_object

CpuUsage structure

Average usage in percent and time span of the average (since last query)

Methods:

__init__(self)

Attributes:

`average`
`msTime`

__init__(self: depthai.CpuUsage) → None ¶

property average¶

property msTime¶

class depthai.DataInputQueue¶

Bases: pybind11_builtins.pybind11_object

Access to send messages through XLink stream

Methods:

`__init__`(args, *kwargs)	Initialize self.
`close`(self)	Closes the queue and the underlying thread
`getBlocking`(self)	Gets current queue behavior when full (maxSize)
`getMaxSize`(self)	Gets queue maximum size
`getName`(self)	Gets queues name
`isClosed`(self)	Check whether queue is closed
`send`(args, *kwargs)	Overloaded function.
`setBlocking`(self, blocking)	Sets queue behavior when full (maxSize)
`setMaxSize`(self, maxSize)	Sets queue maximum size

__init__(*args, **kwargs)¶: Initialize self. See help(type(self)) for accurate signature.

close(self: depthai.DataInputQueue) → None ¶: Closes the queue and the underlying thread

getBlocking(self: depthai.DataInputQueue) → bool ¶

Gets current queue behavior when full (maxSize)

Returns: True if blocking, false otherwise

getMaxSize(self: depthai.DataInputQueue) → int ¶

Gets queue maximum size

Returns: Maximum queue size

getName(self: depthai.DataInputQueue) → str ¶

Gets queues name

Returns: Queue name

isClosed(self: depthai.DataInputQueue) → bool ¶: Check whether queue is closed

send(*args, **kwargs)¶

Overloaded function.

send(self: depthai.DataInputQueue, msg: depthai.ADatatype) -> None

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

Parameter msg:: Message to add to the queue

send(self: depthai.DataInputQueue, rawMsg: depthai.RawBuffer) -> None

Adds a raw 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

Parameter rawMsg:: Message to add to the queue

setBlocking(self: depthai.DataInputQueue, blocking: bool) → None ¶

Sets queue behavior when full (maxSize)

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

setMaxSize(self: depthai.DataInputQueue, maxSize: int) → None ¶

Sets queue maximum size

Parameter maxSize:: Specifies maximum number of messages in the queue

class depthai.DataOutputQueue¶

Bases: pybind11_builtins.pybind11_object

Access to receive messages coming from XLink stream

Methods:

`__init__`(args, *kwargs)	Initialize self.
`addCallback`(args, *kwargs)	Overloaded function.
`close`(self)	Closes the queue and the underlying thread
`get`(self)	Block until a message is available.
`getAll`(self)	Block until at least one message in the queue.
`getBlocking`(self)	Gets current queue behavior when full (maxSize)
`getMaxSize`(self)	Gets queue maximum size
`getName`(self)	Gets queues name
`has`(self)	Check whether front of the queue has a message (isn’t empty)
`isClosed`(self)	Check whether queue is closed
`removeCallback`(self, callbackId)	Removes a callback
`setBlocking`(self, blocking)	Sets queue behavior when full (maxSize)
`setMaxSize`(self, maxSize)	Sets queue maximum size
`tryGet`(self)	Try to retrieve message from queue.
`tryGetAll`(self)	Try to retrieve all messages in the queue.

__init__(*args, **kwargs)¶: Initialize self. See help(type(self)) for accurate signature.

addCallback(*args, **kwargs)¶

Overloaded function.

addCallback(self: depthai.DataOutputQueue, callback: function) -> int

Adds a callback on message received

Parameter callback:: Callback function with queue name and message pointer

Returns: Callback id

addCallback(self: depthai.DataOutputQueue, callback: function) -> int

Adds a callback on message received

Parameter callback:: Callback function with message pointer

Returns: Callback id

addCallback(self: depthai.DataOutputQueue, callback: function) -> int

Adds a callback on message received

Parameter callback:: Callback function without any parameters

Returns: Callback id

close(self: depthai.DataOutputQueue) → None ¶: Closes the queue and the underlying thread

get(self: depthai.DataOutputQueue) → depthai.ADatatype ¶

Block until a message is available.

Returns: Message or nullptr if no message available

getAll(self: depthai.DataOutputQueue) → List[depthai.ADatatype]¶

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

Returns: Vector of messages

getBlocking(self: depthai.DataOutputQueue) → bool ¶

Gets current queue behavior when full (maxSize)

Returns: True if blocking, false otherwise

getMaxSize(self: depthai.DataOutputQueue) → int ¶

Gets queue maximum size

Returns: Maximum queue size

getName(self: depthai.DataOutputQueue) → str ¶

Gets queues name

Returns: Queue name

has(self: depthai.DataOutputQueue) → bool ¶

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

Returns: True if queue isn’t empty, false otherwise

isClosed(self: depthai.DataOutputQueue) → bool ¶: Check whether queue is closed

removeCallback(self: depthai.DataOutputQueue, callbackId: int) → bool ¶

Removes a callback

Parameter callbackId:: Id of callback to be removed

Returns: True if callback was removed, false otherwise

setBlocking(self: depthai.DataOutputQueue, blocking: bool) → None ¶

Sets queue behavior when full (maxSize)

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

setMaxSize(self: depthai.DataOutputQueue, maxSize: int) → None ¶

Sets queue maximum size

Parameter maxSize:: Specifies maximum number of messages in the queue

tryGet(self: depthai.DataOutputQueue) → depthai.ADatatype ¶

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

Returns: Message or nullptr if no message available

tryGetAll(self: depthai.DataOutputQueue) → List[depthai.ADatatype]¶

Try to retrieve all messages in the queue.

Returns: Vector of messages

class depthai.DatatypeEnum¶

Bases: pybind11_builtins.pybind11_object

Members:

Buffer

ImgFrame

NNData

ImageManipConfig

CameraControl

ImgDetections

SpatialImgDetections

SystemInformation

SpatialLocationCalculatorConfig

SpatialLocationCalculatorData

EdgeDetectorConfig

AprilTagConfig

AprilTags

Tracklets

IMUData

StereoDepthConfig

FeatureTrackerConfig

TrackedFeatures

Attributes:

Methods:

__init__(self, value)

AprilTagConfig = <DatatypeEnum.AprilTagConfig: 11>¶

AprilTags = <DatatypeEnum.AprilTags: 12>¶

Buffer = <DatatypeEnum.Buffer: 0>¶

CameraControl = <DatatypeEnum.CameraControl: 4>¶

EdgeDetectorConfig = <DatatypeEnum.EdgeDetectorConfig: 10>¶

FeatureTrackerConfig = <DatatypeEnum.FeatureTrackerConfig: 16>¶

IMUData = <DatatypeEnum.IMUData: 14>¶

ImageManipConfig = <DatatypeEnum.ImageManipConfig: 3>¶

ImgDetections = <DatatypeEnum.ImgDetections: 5>¶

ImgFrame = <DatatypeEnum.ImgFrame: 1>¶

NNData = <DatatypeEnum.NNData: 2>¶

SpatialImgDetections = <DatatypeEnum.SpatialImgDetections: 6>¶

SpatialLocationCalculatorConfig = <DatatypeEnum.SpatialLocationCalculatorConfig: 8>¶

SpatialLocationCalculatorData = <DatatypeEnum.SpatialLocationCalculatorData: 9>¶

StereoDepthConfig = <DatatypeEnum.StereoDepthConfig: 15>¶

SystemInformation = <DatatypeEnum.SystemInformation: 7>¶

TrackedFeatures = <DatatypeEnum.TrackedFeatures: 17>¶

Tracklets = <DatatypeEnum.Tracklets: 13>¶

__init__(self: depthai.DatatypeEnum, value: int) → None ¶

property name¶

property value¶

class depthai.DetectionNetworkProperties¶

Bases: depthai.NeuralNetworkProperties

Specify properties for DetectionNetwork

Methods:

__init__(*args, **kwargs)

Initialize self.

Attributes:

parser

__init__(*args, **kwargs)¶: Initialize self. See help(type(self)) for accurate signature.

property parser¶

class depthai.DetectionNetworkType¶

Bases: pybind11_builtins.pybind11_object

Members:

YOLO

MOBILENET

Attributes:

`MOBILENET`
`YOLO`
`name`
`value`

Methods:

__init__(self, value)

MOBILENET = <DetectionNetworkType.MOBILENET: 1>¶

YOLO = <DetectionNetworkType.YOLO: 0>¶

__init__(self: depthai.DetectionNetworkType, value: int) → None ¶

property name¶

property value¶

class depthai.DetectionParserOptions¶

Bases: pybind11_builtins.pybind11_object

Specifies how to parse output of detection networks

Methods:

__init__(*args, **kwargs)

Initialize self.

Attributes:

`anchorMasks`
`anchors`
`classes`
`confidenceThreshold`
`coordinates`
`iouThreshold`
`nnFamily`

__init__(*args, **kwargs)¶: Initialize self. See help(type(self)) for accurate signature.

property anchorMasks¶

property anchors¶

property classes¶

property confidenceThreshold¶

property coordinates¶

property iouThreshold¶

property nnFamily¶

class depthai.DetectionParserProperties¶

Bases: pybind11_builtins.pybind11_object

Specify properties for DetectionParser

Methods:

__init__(*args, **kwargs)

Initialize self.

Attributes:

parser

Options for parser

__init__(*args, **kwargs)¶: Initialize self. See help(type(self)) for accurate signature.

property parser¶: Options for parser

class depthai.Device¶

Bases: depthai.DeviceBase

Represents the DepthAI device with the methods to interact with it. Implements the host-side queues to connect with XLinkIn and XLinkOut nodes

Classes:

Config

Device specific configuration

Methods:

`__init__`(args, *kwargs)	Overloaded function.
`getInputQueue`(args, *kwargs)	Overloaded function.
`getInputQueueNames`(self)	Get all available input queue names
`getOutputQueue`(args, *kwargs)	Overloaded function.
`getOutputQueueNames`(self)	Get all available output queue names
`getQueueEvent`(args, *kwargs)	Overloaded function.
`getQueueEvents`(args, *kwargs)	Overloaded function.

class Config¶

Bases: pybind11_builtins.pybind11_object

Device specific configuration

Methods:

__init__(self)

Attributes:

`board`
`nonExclusiveMode`
`version`

__init__(self: depthai.Device.Config) → None ¶

property board¶

property nonExclusiveMode¶

property version¶

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: depthai.Device, pipeline: depthai.Pipeline) -> None

Connects to any available device with a DEFAULT_SEARCH_TIME timeout.

Parameter pipeline:: Pipeline to be executed on the device

__init__(self: depthai.Device, pipeline: depthai.Pipeline, usb2Mode: bool) -> None

Connects to any available device with a DEFAULT_SEARCH_TIME timeout.

Parameter pipeline:: Pipeline to be executed on the device
Parameter usb2Mode:: Boot device using USB2 mode firmware

__init__(self: depthai.Device, pipeline: depthai.Pipeline, maxUsbSpeed: depthai.UsbSpeed) -> None

Connects to any available device with a DEFAULT_SEARCH_TIME timeout.

Parameter pipeline:: Pipeline to be executed on the device
Parameter maxUsbSpeed:: Maximum allowed USB speed

__init__(self: depthai.Device, pipeline: depthai.Pipeline, pathToCmd: Path) -> None

Connects to any available device with a DEFAULT_SEARCH_TIME timeout.

Parameter pipeline:: Pipeline to be executed on the device
Parameter pathToCmd:: Path to custom device firmware

__init__(self: depthai.Device, pipeline: depthai.Pipeline, devInfo: depthai.DeviceInfo, usb2Mode: bool = False) -> None

Connects to device specified by devInfo.

Parameter pipeline:: Pipeline to be executed on the device
Parameter devInfo:: DeviceInfo which specifies which device to connect to
Parameter usb2Mode:: Boot device using USB2 mode firmware

__init__(self: depthai.Device, pipeline: depthai.Pipeline, deviceInfo: depthai.DeviceInfo, maxUsbSpeed: depthai.UsbSpeed) -> None

Connects to device specified by devInfo.

Parameter pipeline:: Pipeline to be executed on the device
Parameter devInfo:: DeviceInfo which specifies which device to connect to
Parameter maxUsbSpeed:: Maximum allowed USB speed

__init__(self: depthai.Device, pipeline: depthai.Pipeline, devInfo: depthai.DeviceInfo, pathToCmd: Path) -> None

Connects to device specified by devInfo.

Parameter pipeline:: Pipeline to be executed on the device
Parameter devInfo:: DeviceInfo which specifies which device to connect to
Parameter pathToCmd:: Path to custom device firmware

__init__(self: depthai.Device, version: depthai.OpenVINO.Version = <Version.???: 7>) -> None

Connects to any available device with a DEFAULT_SEARCH_TIME timeout.

Parameter version:: OpenVINO version which the device will be booted with.

__init__(self: depthai.Device, version: depthai.OpenVINO.Version, usb2Mode: bool = False) -> None

Connects to any available device with a DEFAULT_SEARCH_TIME timeout.

Parameter version:: OpenVINO version which the device will be booted with
Parameter usb2Mode:: Boot device using USB2 mode firmware

__init__(self: depthai.Device, version: depthai.OpenVINO.Version, maxUsbSpeed: depthai.UsbSpeed) -> None

Connects to device specified by devInfo.

Parameter version:: OpenVINO version which the device will be booted with
Parameter maxUsbSpeed:: Maximum allowed USB speed

__init__(self: depthai.Device, version: depthai.OpenVINO.Version, pathToCmd: Path) -> None

Connects to any available device with a DEFAULT_SEARCH_TIME timeout.

Parameter version:: OpenVINO version which the device will be booted with
Parameter pathToCmd:: Path to custom device firmware

__init__(self: depthai.Device, version: depthai.OpenVINO.Version, deviceInfo: depthai.DeviceInfo, usb2Mode: bool = False) -> None

Connects to device specified by devInfo.

Parameter version:: OpenVINO version which the device will be booted with
Parameter devInfo:: DeviceInfo which specifies which device to connect to
Parameter usb2Mode:: Boot device using USB2 mode firmware

__init__(self: depthai.Device, version: depthai.OpenVINO.Version, deviceInfo: depthai.DeviceInfo, maxUsbSpeed: depthai.UsbSpeed) -> None

Connects to device specified by devInfo.

Parameter version:: OpenVINO version which the device will be booted with
Parameter devInfo:: DeviceInfo which specifies which device to connect to
Parameter maxUsbSpeed:: Maximum allowed USB speed

__init__(self: depthai.Device, version: depthai.OpenVINO.Version, deviceDesc: depthai.DeviceInfo, pathToCmd: Path) -> None

Connects to device specified by devInfo.

Parameter version:: OpenVINO version which the device will be booted with
Parameter devInfo:: DeviceInfo which specifies which device to connect to
Parameter pathToCmd:: Path to custom device firmware

__init__(self: depthai.Device, config: depthai.Device.Config) -> None

Connects to any available device with custom config.

Parameter config:: Device custom configuration to boot with

__init__(self: depthai.Device, config: depthai.Device.Config, deviceInfo: depthai.DeviceInfo) -> None

Connects to device ‘devInfo’ with custom config.

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

__init__(self: depthai.Device, deviceInfo: depthai.DeviceInfo) -> None

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

Parameter devInfo:: DeviceInfo which specifies which device to connect to

__init__(self: depthai.Device, deviceInfo: depthai.DeviceInfo, maxUsbSpeed: depthai.UsbSpeed) -> None

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

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

__init__(self: depthai.Device, nameOrDeviceId: str) -> None

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

Parameter nameOrDeviceId:: Creates DeviceInfo with nameOrDeviceId to connect to

__init__(self: depthai.Device, nameOrDeviceId: str, maxUsbSpeed: depthai.UsbSpeed) -> None

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

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

getInputQueue(*args, **kwargs)¶

Overloaded function.

getInputQueue(self: depthai.Device, name: str) -> depthai.DataInputQueue

Gets an input queue corresponding to stream name. If it doesn’t exist it throws

Parameter name:: Queue/stream name, set in XLinkIn node

Returns: Smart pointer to DataInputQueue

getInputQueue(self: depthai.Device, name: str, maxSize: int, blocking: bool = True) -> depthai.DataInputQueue

Gets an input queue corresponding to stream name. If it doesn’t exist it throws. Also sets queue options

Parameter name:: Queue/stream name, set in XLinkOut node
Parameter maxSize:: Maximum number of messages in queue
Parameter blocking:: Queue behavior once full. True: blocking, false: overwriting of oldest messages. Default: true

Returns: Smart pointer to DataInputQueue

getInputQueueNames(self: depthai.Device) → List[str]¶

Get all available input queue names

Returns: Vector of input queue names

getOutputQueue(*args, **kwargs)¶

Overloaded function.

getOutputQueue(self: depthai.Device, name: str) -> depthai.DataOutputQueue

Gets an output queue corresponding to stream name. If it doesn’t exist it throws

Parameter name:: Queue/stream name, created by XLinkOut node

Returns: Smart pointer to DataOutputQueue

getOutputQueue(self: depthai.Device, name: str, maxSize: int, blocking: bool = True) -> depthai.DataOutputQueue

Gets a queue corresponding to stream name, if it exists, otherwise it throws. Also sets queue options

Parameter name:: Queue/stream name, set in XLinkOut node
Parameter maxSize:: Maximum number of messages in queue
Parameter blocking:: Queue behavior once full. True specifies blocking and false overwriting of oldest messages. Default: true

Returns: Smart pointer to DataOutputQueue

getOutputQueueNames(self: depthai.Device) → List[str]¶

Get all available output queue names

Returns: Vector of output queue names

getQueueEvent(*args, **kwargs)¶

Overloaded function.

getQueueEvent(self: depthai.Device, queueNames: List[str], timeout: datetime.timedelta = datetime.timedelta(days=-1, seconds=86399, microseconds=999999)) -> str

Gets or waits until any of specified queues has received a message

Parameter queueNames:: Names of queues for which to wait for
Parameter timeout:: Timeout after which return regardless. If negative then wait is indefinite. Default is -1

Returns: Queue name which received a message first

getQueueEvent(self: depthai.Device, queueName: str, timeout: datetime.timedelta = datetime.timedelta(days=-1, seconds=86399, microseconds=999999)) -> str

Gets or waits until specified queue has received a message

Parameter queueNames:: Name of queues for which to wait for
Parameter timeout:: Timeout after which return regardless. If negative then wait is indefinite. Default is -1

Returns: Queue name which received a message

getQueueEvent(self: depthai.Device, timeout: datetime.timedelta = datetime.timedelta(days=-1, seconds=86399, microseconds=999999)) -> str

Gets or waits until any queue has received a message

Parameter timeout:: Timeout after which return regardless. If negative then wait is indefinite. Default is -1

Returns: Queue name which received a message

getQueueEvents(*args, **kwargs)¶

Overloaded function.

getQueueEvents(self: depthai.Device, queueNames: List[str], maxNumEvents: int = 18446744073709551615, timeout: datetime.timedelta = datetime.timedelta(days=-1, seconds=86399, microseconds=999999)) -> List[str]

Gets or waits until any of specified queues has received a message

Parameter queueNames:: Names of queues for which to block
Parameter maxNumEvents:: Maximum number of events to remove from queue - Default is unlimited
Parameter timeout:: Timeout after which return regardless. If negative then wait is indefinite - Default is -1

Returns: Names of queues which received messages first

getQueueEvents(self: depthai.Device, queueName: str, maxNumEvents: int = 18446744073709551615, timeout: datetime.timedelta = datetime.timedelta(days=-1, seconds=86399, microseconds=999999)) -> List[str]

Gets or waits until specified queue has received a message

Parameter queueName:: Name of queues for which to wait for
Parameter maxNumEvents:: Maximum number of events to remove from queue. Default is unlimited
Parameter timeout:: Timeout after which return regardless. If negative then wait is indefinite. Default is -1

Returns: Names of queues which received messages first

getQueueEvents(self: depthai.Device, maxNumEvents: int = 18446744073709551615, timeout: datetime.timedelta = datetime.timedelta(days=-1, seconds=86399, microseconds=999999)) -> List[str]

Gets or waits until any queue has received a message

Parameter maxNumEvents:: Maximum number of events to remove from queue. Default is unlimited
Parameter timeout:: Timeout after which return regardless. If negative then wait is indefinite. Default is -1

Returns: Names of queues which received messages first

class depthai.DeviceBase¶

Bases: pybind11_builtins.pybind11_object

The core of depthai device for RAII, connects to device and maintains watchdog, timesync, …

Methods:

`__init__`(args, *kwargs)	Overloaded function.
`addLogCallback`(self, callback, None])	Add a callback for device logging.
`close`(self)	Closes the connection to device.
`factoryResetCalibration`(self)	Factory reset EEPROM data if factory backup is available.
`flashCalibration`(self, calibrationDataHandler)	Stores the Calibration and Device information to the Device EEPROM
`flashCalibration2`(self, arg0)	Stores the Calibration and Device information to the Device EEPROM
`flashEepromClear`(self)	Destructive action, deletes User area EEPROM contents Requires PROTECTED permissions
`flashFactoryCalibration`(self, arg0)	Stores the Calibration and Device information to the Device EEPROM in Factory area To perform this action, correct env variable must be set
`flashFactoryEepromClear`(self)	Destructive action, deletes Factory area EEPROM contents Requires FACTORY PROTECTED permissions
`getAllAvailableDevices`()	Returns all available devices
`getAllConnectedDevices`()	Returns information of all connected devices.
`getAnyAvailableDevice`(args, *kwargs)	Overloaded function.
`getBootloaderVersion`(self)	Gets Bootloader version if it was booted through Bootloader
`getCameraSensorNames`(self)	Get sensor names for cameras that are connected to the device
`getChipTemperature`(self)	Retrieves current chip temperature as measured by device
`getCmxMemoryUsage`(self)	Retrieves current CMX memory information from device
`getConnectedCameraFeatures`(self)	Get cameras that are connected to the device with their features/properties
`getConnectedCameras`(self)	Get cameras that are connected to the device
`getDdrMemoryUsage`(self)	Retrieves current DDR memory information from device
`getDeviceByMxId`(mxId)	Finds a device by MX ID.
`getDeviceInfo`(self)	Get the Device Info object o the device which is currently running
`getDeviceName`(self)	Get device name if available
`getEmbeddedDeviceBinary`(args, *kwargs)	Overloaded function.
`getFirstAvailableDevice`(skipInvalidDevices)	Gets first available device.
`getIrDrivers`(self)	Retrieves detected IR laser/LED drivers.
`getLeonCssCpuUsage`(self)	Retrieves average CSS Leon CPU usage
`getLeonCssHeapUsage`(self)	Retrieves current CSS Leon CPU heap information from device
`getLeonMssCpuUsage`(self)	Retrieves average MSS Leon CPU usage
`getLeonMssHeapUsage`(self)	Retrieves current MSS Leon CPU heap information from device
`getLogLevel`(self)	Gets current logging severity level of the device.
`getLogOutputLevel`(self)	Gets logging level which decides printing level to standard output.
`getMxId`(self)	Get MxId of device
`getSystemInformationLoggingRate`(self)	Gets current rate of system information logging (“info” severity) in Hz.
`getUsbSpeed`(self)	Retrieves USB connection speed
`getXLinkChunkSize`(self)	Gets current XLink chunk size.
`isClosed`(self)	Is the device already closed (or disconnected)
`isEepromAvailable`(self)	Check if EEPROM is available
`isPipelineRunning`(self)	Checks if devices pipeline is already running
`readCalibration`(self)	Fetches the EEPROM data from the device and loads it into CalibrationHandler object If no calibration is flashed, it returns default
`readCalibration2`(self)	Fetches the EEPROM data from the device and loads it into CalibrationHandler object
`readCalibrationOrDefault`(self)	Fetches the EEPROM data from the device and loads it into CalibrationHandler object If no calibration is flashed, it returns default
`readCalibrationRaw`(self)	Fetches the raw EEPROM data from User area
`readFactoryCalibration`(self)	Fetches the EEPROM data from Factory area and loads it into CalibrationHandler object
`readFactoryCalibrationOrDefault`(self)	Fetches the EEPROM data from Factory area and loads it into CalibrationHandler object If no calibration is flashed, it returns default
`readFactoryCalibrationRaw`(self)	Fetches the raw EEPROM data from Factory area
`removeLogCallback`(self, callbackId)	Removes a callback
`setIrFloodLightBrightness`(self, mA, mask)	Sets the brightness of the IR Flood Light.
`setIrLaserDotProjectorBrightness`(self, mA, mask)	Sets the brightness of the IR Laser Dot Projector.
`setLogLevel`(self, level)	Sets the devices logging severity level.
`setLogOutputLevel`(self, level)	Sets logging level which decides printing level to standard output.
`setSystemInformationLoggingRate`(self, rateHz)	Sets rate of system information logging (“info” severity).
`setTimesync`(args, *kwargs)	Overloaded function.
`setXLinkChunkSize`(self, sizeBytes)	Sets the chunk size for splitting device-sent XLink packets.
`startPipeline`(args, *kwargs)	Overloaded function.

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: depthai.DeviceBase, pipeline: depthai.Pipeline) -> None

Connects to any available device with a DEFAULT_SEARCH_TIME timeout.

Parameter pipeline:: Pipeline to be executed on the device

__init__(self: depthai.DeviceBase, pipeline: depthai.Pipeline, usb2Mode: bool) -> None

Connects to any available device with a DEFAULT_SEARCH_TIME timeout.

Parameter pipeline:: Pipeline to be executed on the device
Parameter usb2Mode:: Boot device using USB2 mode firmware

__init__(self: depthai.DeviceBase, pipeline: depthai.Pipeline, maxUsbSpeed: depthai.UsbSpeed) -> None

Connects to any available device with a DEFAULT_SEARCH_TIME timeout.

Parameter pipeline:: Pipeline to be executed on the device
Parameter maxUsbSpeed:: Maximum allowed USB speed

__init__(self: depthai.DeviceBase, pipeline: depthai.Pipeline, pathToCmd: Path) -> None

Connects to any available device with a DEFAULT_SEARCH_TIME timeout.

Parameter pipeline:: Pipeline to be executed on the device
Parameter pathToCmd:: Path to custom device firmware

__init__(self: depthai.DeviceBase, pipeline: depthai.Pipeline, devInfo: depthai.DeviceInfo, usb2Mode: bool = False) -> None

Connects to device specified by devInfo.

Parameter pipeline:: Pipeline to be executed on the device
Parameter devInfo:: DeviceInfo which specifies which device to connect to
Parameter usb2Mode:: Boot device using USB2 mode firmware

__init__(self: depthai.DeviceBase, pipeline: depthai.Pipeline, deviceInfo: depthai.DeviceInfo, maxUsbSpeed: depthai.UsbSpeed) -> None

Connects to device specified by devInfo.

Parameter pipeline:: Pipeline to be executed on the device
Parameter devInfo:: DeviceInfo which specifies which device to connect to
Parameter maxUsbSpeed:: Maximum allowed USB speed

__init__(self: depthai.DeviceBase, pipeline: depthai.Pipeline, devInfo: depthai.DeviceInfo, pathToCmd: Path) -> None

Connects to device specified by devInfo.

Parameter pipeline:: Pipeline to be executed on the device
Parameter devInfo:: DeviceInfo which specifies which device to connect to
Parameter pathToCmd:: Path to custom device firmware

__init__(self: depthai.DeviceBase, version: depthai.OpenVINO.Version = <Version.???: 7>) -> None

Connects to any available device with a DEFAULT_SEARCH_TIME timeout.

Parameter version:: OpenVINO version which the device will be booted with.

__init__(self: depthai.DeviceBase, version: depthai.OpenVINO.Version, usb2Mode: bool = False) -> None

Connects to any available device with a DEFAULT_SEARCH_TIME timeout.

Parameter version:: OpenVINO version which the device will be booted with
Parameter usb2Mode:: Boot device using USB2 mode firmware

__init__(self: depthai.DeviceBase, version: depthai.OpenVINO.Version, maxUsbSpeed: depthai.UsbSpeed) -> None

Connects to device specified by devInfo.

Parameter version:: OpenVINO version which the device will be booted with
Parameter maxUsbSpeed:: Maximum allowed USB speed

__init__(self: depthai.DeviceBase, version: depthai.OpenVINO.Version, pathToCmd: Path) -> None

Connects to any available device with a DEFAULT_SEARCH_TIME timeout.

Parameter version:: OpenVINO version which the device will be booted with
Parameter pathToCmd:: Path to custom device firmware

__init__(self: depthai.DeviceBase, version: depthai.OpenVINO.Version, deviceInfo: depthai.DeviceInfo, usb2Mode: bool = False) -> None

Connects to device specified by devInfo.

Parameter version:: OpenVINO version which the device will be booted with
Parameter devInfo:: DeviceInfo which specifies which device to connect to
Parameter usb2Mode:: Boot device using USB2 mode firmware

__init__(self: depthai.DeviceBase, version: depthai.OpenVINO.Version, deviceInfo: depthai.DeviceInfo, maxUsbSpeed: depthai.UsbSpeed) -> None

Connects to device specified by devInfo.

Parameter version:: OpenVINO version which the device will be booted with
Parameter devInfo:: DeviceInfo which specifies which device to connect to
Parameter maxUsbSpeed:: Maximum allowed USB speed

__init__(self: depthai.DeviceBase, version: depthai.OpenVINO.Version, deviceDesc: depthai.DeviceInfo, pathToCmd: Path) -> None

Connects to device specified by devInfo.

Parameter version:: OpenVINO version which the device will be booted with
Parameter devInfo:: DeviceInfo which specifies which device to connect to
Parameter pathToCmd:: Path to custom device firmware

__init__(self: depthai.DeviceBase, config: depthai.Device.Config) -> None

Connects to any available device with custom config.

Parameter config:: Device custom configuration to boot with

__init__(self: depthai.DeviceBase, config: depthai.Device.Config, deviceInfo: depthai.DeviceInfo) -> None

Connects to device ‘devInfo’ with custom config.

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

__init__(self: depthai.DeviceBase, deviceInfo: depthai.DeviceInfo) -> None

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

Parameter devInfo:: DeviceInfo which specifies which device to connect to

__init__(self: depthai.DeviceBase, deviceInfo: depthai.DeviceInfo, maxUsbSpeed: depthai.UsbSpeed) -> None

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

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

__init__(self: depthai.DeviceBase, nameOrDeviceId: str) -> None

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

Parameter nameOrDeviceId:: Creates DeviceInfo with nameOrDeviceId to connect to

__init__(self: depthai.DeviceBase, nameOrDeviceId: str, maxUsbSpeed: depthai.UsbSpeed) -> None

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

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

addLogCallback(self: depthai.DeviceBase, callback: Callable[[depthai.LogMessage], None]) → int ¶

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

Parameter callback:: Callback to call whenever a log message arrives

Returns: Id which can be used to later remove the callback

close(self: depthai.DeviceBase) → None ¶: Closes the connection to device. Better alternative is the usage of context manager: with depthai.Device(pipeline) as device:

factoryResetCalibration(self: depthai.DeviceBase) → None ¶

Factory reset EEPROM data if factory backup is available.

Throws:: std::runtime_exception If factory reset was unsuccessful

flashCalibration(self: depthai.DeviceBase, calibrationDataHandler: depthai.CalibrationHandler) → bool ¶

Stores the Calibration and Device information to the Device EEPROM

Parameter calibrationObj:: CalibrationHandler object which is loaded with calibration information.

Returns: true on successful flash, false on failure

flashCalibration2(self: depthai.DeviceBase, arg0: depthai.CalibrationHandler) → None ¶

Stores the Calibration and Device information to the Device EEPROM

Throws:: std::runtime_exception if failed to flash the calibration
Parameter calibrationObj:: CalibrationHandler object which is loaded with calibration information.

flashEepromClear(self: depthai.DeviceBase) → None ¶

Destructive action, deletes User area EEPROM contents Requires PROTECTED permissions

Throws:: std::runtime_exception if failed to flash the calibration

Returns: True on successful flash, false on failure

flashFactoryCalibration(self: depthai.DeviceBase, arg0: depthai.CalibrationHandler) → None ¶

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

Throws:: std::runtime_exception if failed to flash the calibration

Returns: True on successful flash, false on failure

flashFactoryEepromClear(self: depthai.DeviceBase) → None ¶

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

Throws:: std::runtime_exception if failed to flash the calibration

Returns: True on successful flash, false on failure

static getAllAvailableDevices() → List[depthai.DeviceInfo]¶

Returns all available devices

Returns: Vector of available devices

static getAllConnectedDevices() → List[depthai.DeviceInfo]¶

Returns information of all connected devices. The devices could be both connectable as well as already connected to devices.

Returns: Vector of connected device information

static getAnyAvailableDevice(*args, **kwargs)¶

Overloaded function.

getAnyAvailableDevice(timeout: datetime.timedelta) -> Tuple[bool, depthai.DeviceInfo]

Waits for any available device with a timeout

Parameter timeout:: duration of time to wait for the any device

Returns: Tuple of bool and DeviceInfo. Bool specifies if device was found. DeviceInfo specifies the found device

getAnyAvailableDevice() -> Tuple[bool, depthai.DeviceInfo]

Gets any available device

Returns: Tuple of bool and DeviceInfo. Bool specifies if device was found. DeviceInfo specifies the found device

getBootloaderVersion(self: depthai.DeviceBase) → Optional[depthai.Version]¶

Gets Bootloader version if it was booted through Bootloader

Returns: DeviceBootloader::Version if booted through Bootloader or none otherwise

getCameraSensorNames(self: depthai.DeviceBase) → Dict[depthai.CameraBoardSocket, str]¶

Get sensor names for cameras that are connected to the device

Returns: Map/dictionary with camera sensor names, indexed by socket

getChipTemperature(self: depthai.DeviceBase) → depthai.ChipTemperature ¶

Retrieves current chip temperature as measured by device

Returns: Temperature of various onboard sensors

getCmxMemoryUsage(self: depthai.DeviceBase) → depthai.MemoryInfo ¶

Retrieves current CMX memory information from device

Returns: Used, remaining and total cmx memory

getConnectedCameraFeatures(self: depthai.DeviceBase) → List[depthai.CameraFeatures]¶

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

Returns: Vector of connected camera features

getConnectedCameras(self: depthai.DeviceBase) → List[depthai.CameraBoardSocket]¶

Get cameras that are connected to the device

Returns: Vector of connected cameras

getDdrMemoryUsage(self: depthai.DeviceBase) → depthai.MemoryInfo ¶

Retrieves current DDR memory information from device

Returns: Used, remaining and total ddr memory

static getDeviceByMxId(mxId: str) → Tuple[bool, depthai.DeviceInfo]¶

Finds a device by MX ID. Example: 14442C10D13EABCE00

Parameter mxId:: MyraidX ID which uniquely specifies a device

Returns: Tuple of bool and DeviceInfo. Bool specifies if device was found. DeviceInfo specifies the found device

getDeviceInfo(self: depthai.DeviceBase) → depthai.DeviceInfo ¶

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

Returns: DeviceInfo of the current device in execution

getDeviceName(self: depthai.DeviceBase) → object ¶

Get device name if available

Returns: device name or empty string if not available

static getEmbeddedDeviceBinary(*args, **kwargs)¶

Overloaded function.

getEmbeddedDeviceBinary(usb2Mode: bool, version: depthai.OpenVINO.Version = <Version.???: 7>) -> List[int]

Gets device firmware binary for a specific OpenVINO version

Parameter usb2Mode:: USB2 mode firmware
Parameter version:: Version of OpenVINO which firmware will support

Returns: Firmware binary

getEmbeddedDeviceBinary(config: depthai.Device.Config) -> List[int]

Gets device firmware binary for a specific configuration

Parameter config:: FW with applied configuration

Returns: Firmware binary

static getFirstAvailableDevice(skipInvalidDevices: bool = True) → Tuple[bool, depthai.DeviceInfo]¶

Gets first available device. Device can be either in XLINK_UNBOOTED or XLINK_BOOTLOADER state

Returns: Tuple of bool and DeviceInfo. Bool specifies if device was found. DeviceInfo specifies the found device

getIrDrivers(self: depthai.DeviceBase) → List[Tuple[str, int, int]]¶

Retrieves detected IR laser/LED drivers.

Returns: driver name, I2C bus, I2C address. For OAK-D- Pro it should be [{“LM3644”, 2, 0x63}]
Return type: Vector of tuples containing

getLeonCssCpuUsage(self: depthai.DeviceBase) → depthai.CpuUsage ¶

Retrieves average CSS Leon CPU usage

Returns: Average CPU usage and sampling duration

getLeonCssHeapUsage(self: depthai.DeviceBase) → depthai.MemoryInfo ¶

Retrieves current CSS Leon CPU heap information from device

Returns: Used, remaining and total heap memory

getLeonMssCpuUsage(self: depthai.DeviceBase) → depthai.CpuUsage ¶

Retrieves average MSS Leon CPU usage

Returns: Average CPU usage and sampling duration

getLeonMssHeapUsage(self: depthai.DeviceBase) → depthai.MemoryInfo ¶

Retrieves current MSS Leon CPU heap information from device

Returns: Used, remaining and total heap memory

getLogLevel(self: depthai.DeviceBase) → depthai.LogLevel ¶

Gets current logging severity level of the device.

Returns: Logging severity level

getLogOutputLevel(self: depthai.DeviceBase) → depthai.LogLevel ¶

Gets logging level which decides printing level to standard output.

Returns: Standard output printing severity

getMxId(self: depthai.DeviceBase) → str ¶

Get MxId of device

Returns: MxId of connected device

getSystemInformationLoggingRate(self: depthai.DeviceBase) → float ¶

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

Returns: Logging rate in Hz

getUsbSpeed(self: depthai.DeviceBase) → depthai.UsbSpeed ¶

Retrieves USB connection speed

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

getXLinkChunkSize(self: depthai.DeviceBase) → int ¶

Gets current XLink chunk size.

Returns: XLink chunk size in bytes

isClosed(self: depthai.DeviceBase) → bool ¶: Is the device already closed (or disconnected)

isEepromAvailable(self: depthai.DeviceBase) → bool ¶

Check if EEPROM is available

Returns: True if EEPROM is present on board, false otherwise

isPipelineRunning(self: depthai.DeviceBase) → bool ¶

Checks if devices pipeline is already running

Returns: True if running, false otherwise

readCalibration(self: depthai.DeviceBase) → depthai.CalibrationHandler ¶

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

readCalibration2(self: depthai.DeviceBase) → depthai.CalibrationHandler ¶

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

Throws:: std::runtime_exception if no calibration is flashed

Returns: The CalibrationHandler object containing the calibration currently flashed on device EEPROM

readCalibrationOrDefault(self: depthai.DeviceBase) → depthai.CalibrationHandler ¶

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

readCalibrationRaw(self: depthai.DeviceBase) → List[int]¶

Fetches the raw EEPROM data from User area

Throws:: std::runtime_exception if any error occurred

Returns: Binary dump of User area EEPROM data

readFactoryCalibration(self: depthai.DeviceBase) → depthai.CalibrationHandler ¶

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

Throws:: std::runtime_exception if no calibration is flashed

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

readFactoryCalibrationOrDefault(self: depthai.DeviceBase) → depthai.CalibrationHandler ¶

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

readFactoryCalibrationRaw(self: depthai.DeviceBase) → List[int]¶

Fetches the raw EEPROM data from Factory area

Throws:: std::runtime_exception if any error occurred

Returns: Binary dump of Factory area EEPROM data

removeLogCallback(self: depthai.DeviceBase, callbackId: int) → bool ¶

Removes a callback

Parameter callbackId:: Id of callback to be removed

Returns: True if callback was removed, false otherwise

setIrFloodLightBrightness(self: depthai.DeviceBase, mA: float, mask: int = - 1) → bool ¶

Sets the brightness of the IR Flood Light. Limits: up to 1500mA at 30% duty cycle. The duty cycle is controlled by the left camera STROBE, aligned to start of exposure. If the dot projector is also enabled, its lower duty cycle limits take precedence. The emitter is turned off by default

Parameter mA:: Current in mA that will determine brightness, 0 or negative to turn off
Parameter 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

setIrLaserDotProjectorBrightness(self: depthai.DeviceBase, mA: float, mask: int = - 1) → bool ¶

Sets the brightness of the IR Laser Dot Projector. Limits: up to 765mA at 30% duty cycle, up to 1200mA at 6% duty cycle. The duty cycle is controlled by left camera STROBE, aligned to start of exposure. The emitter is turned off by default

Parameter mA:: Current in mA that will determine brightness, 0 or negative to turn off
Parameter 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

setLogLevel(self: depthai.DeviceBase, level: depthai.LogLevel) → None ¶

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

Parameter level:: Logging severity

setLogOutputLevel(self: depthai.DeviceBase, level: depthai.LogLevel) → None ¶

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

Parameter level:: Standard output printing severity

setSystemInformationLoggingRate(self: depthai.DeviceBase, rateHz: float) → None ¶

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

Parameter rateHz:: Logging rate in Hz

setTimesync(*args, **kwargs)¶

Overloaded function.

setTimesync(self: depthai.DeviceBase, arg0: datetime.timedelta, arg1: int, arg2: bool) -> None

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

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

setTimesync(self: depthai.DeviceBase, enable: bool) -> None

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

Parameter enable:: Enables or disables consistent timesyncing

setXLinkChunkSize(self: depthai.DeviceBase, sizeBytes: int) → None ¶

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.

Parameter sizeBytes:: XLink chunk size in bytes

startPipeline(*args, **kwargs)¶

Overloaded function.

startPipeline(self: depthai.DeviceBase) -> None

Starts the execution of the devices pipeline

Returns: True if pipeline started, false otherwise

startPipeline(self: depthai.DeviceBase, arg0: depthai.Pipeline) -> bool

Starts the execution of a given pipeline

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

Returns: True if pipeline started, false otherwise

class depthai.DeviceBootloader¶

Bases: pybind11_builtins.pybind11_object

Represents the DepthAI bootloader with the methods to interact with it.

Classes:

`ApplicationInfo`
`Config`
`Memory`	Members:
`MemoryInfo`
`NetworkConfig`
`Section`	Members:
`Type`	Members:
`UsbConfig`

Methods:

`__init__`(args, *kwargs)	Overloaded function.
`bootMemory`(self, fw)	Boots a custom FW in memory
`bootUsbRomBootloader`(self)	Boots into integrated ROM bootloader in USB mode
`close`(self)	Closes the connection to device.
`createDepthaiApplicationPackage`(args, *kwargs)	Overloaded function.
`flash`(args, *kwargs)	Overloaded function.
`flashBootHeader`(self, memory, frequency, …)	Flash optimized boot header
`flashBootloader`(args, *kwargs)	Overloaded function.
`flashClear`(self, memory)	Clears flashed application on the device, by removing SBR boot structure Doesn’t remove fast boot header capability to still boot the application
`flashConfig`(self, config, memory, type)	Flashes configuration to bootloader
`flashConfigClear`(self, memory, type)	Clears configuration data
`flashConfigData`(self, configData, memory, type)	Flashes configuration data to bootloader
`flashConfigFile`(self, configData, memory, type)	Flashes configuration data to bootloader
`flashCustom`(args, *kwargs)	Overloaded function.
`flashDepthaiApplicationPackage`(args, *kwargs)	Overloaded function.
`flashFastBootHeader`(self, memory, frequency, …)	Flash fast boot header.
`flashGpioModeBootHeader`(self, memory, mode)	Flash boot header which boots same as equivalent GPIO mode would
`flashUsbRecoveryBootHeader`(self, memory)	Flash USB recovery boot header.
`flashUserBootloader`(self, progressCallback, …)	Flashes user bootloader to the current board.
`getAllAvailableDevices`()	Searches for connected devices in either UNBOOTED or BOOTLOADER states.
`getEmbeddedBootloaderBinary`(arg0)	returns Embedded bootloader binary
`getEmbeddedBootloaderVersion`()	returns Embedded bootloader version
`getFirstAvailableDevice`()	Searches for connected devices in either UNBOOTED or BOOTLOADER states and returns first available.
`getMemoryInfo`(self, arg0)	Retrieves information about specified memory
`getType`(self)	returns Type of currently connected bootloader
`getVersion`(self)	returns Version of current running bootloader
`isAllowedFlashingBootloader`(self)	returns True if allowed to flash bootloader
`isEmbeddedVersion`(self)	returns True when bootloader was booted using latest bootloader integrated in the
`isUserBootloader`(self)	Retrieves whether current bootloader is User Bootloader (B out of A/B configuration)
`isUserBootloaderSupported`(self)	Checks whether User Bootloader is supported with current bootloader
`readApplicationInfo`(self, memory)	Reads information about flashed application in specified memory from device
`readConfig`(self, memory, type)	Reads configuration from bootloader
`readConfigData`(self, memory, type)	Reads configuration data from bootloader
`readCustom`(args, *kwargs)	Overloaded function.
`saveDepthaiApplicationPackage`(args, *kwargs)	Overloaded function.

class ApplicationInfo¶

Bases: pybind11_builtins.pybind11_object

Methods:

__init__(self)

Attributes:

`applicationName`
`firmwareVersion`
`hasApplication`

__init__(self: depthai.DeviceBootloader.ApplicationInfo) → None ¶

property applicationName¶

property firmwareVersion¶

property hasApplication¶

class Config¶

Bases: pybind11_builtins.pybind11_object

Methods:

`__init__`(self)
`fromJson`(self)
`getDnsAltIPv4`(self)
`getDnsIPv4`(self)
`getIPv4`(self)
`getIPv4Gateway`(self)
`getIPv4Mask`(self)
`getMacAddress`(self)
`getNetworkTimeout`(self)
`getUsbMaxSpeed`(self)
`getUsbTimeout`(self)
`isStaticIPV4`(self)
`setDnsIPv4`(self, arg0, arg1)
`setDynamicIPv4`(self, arg0, arg1, arg2)
`setMacAddress`(self, arg0)
`setNetworkTimeout`(self, arg0)
`setStaticIPv4`(self, arg0, arg1, arg2)
`setUsbMaxSpeed`(self, arg0)
`setUsbTimeout`(self, arg0)
`toJson`(self)

Attributes:

`appMem`
`network`
`usb`

__init__(self: depthai.DeviceBootloader.Config) → None ¶

property appMem¶

fromJson(self: json) → depthai.DeviceBootloader.Config ¶

getDnsAltIPv4(self: depthai.DeviceBootloader.Config) → str ¶

getDnsIPv4(self: depthai.DeviceBootloader.Config) → str ¶

getIPv4(self: depthai.DeviceBootloader.Config) → str ¶

getIPv4Gateway(self: depthai.DeviceBootloader.Config) → str ¶

getIPv4Mask(self: depthai.DeviceBootloader.Config) → str ¶

getMacAddress(self: depthai.DeviceBootloader.Config) → str ¶

getNetworkTimeout(self: depthai.DeviceBootloader.Config) → datetime.timedelta ¶

getUsbMaxSpeed(self: depthai.DeviceBootloader.Config) → depthai.UsbSpeed ¶

getUsbTimeout(self: depthai.DeviceBootloader.Config) → datetime.timedelta ¶

isStaticIPV4(self: depthai.DeviceBootloader.Config) → bool ¶

property network¶

setDnsIPv4(self: depthai.DeviceBootloader.Config, arg0: str, arg1: str) → None ¶

setDynamicIPv4(self: depthai.DeviceBootloader.Config, arg0: str, arg1: str, arg2: str) → None ¶

setMacAddress(self: depthai.DeviceBootloader.Config, arg0: str) → None ¶

setNetworkTimeout(self: depthai.DeviceBootloader.Config, arg0: datetime.timedelta) → None ¶

setStaticIPv4(self: depthai.DeviceBootloader.Config, arg0: str, arg1: str, arg2: str) → None ¶

setUsbMaxSpeed(self: depthai.DeviceBootloader.Config, arg0: depthai.UsbSpeed) → None ¶

setUsbTimeout(self: depthai.DeviceBootloader.Config, arg0: datetime.timedelta) → None ¶

toJson(self: depthai.DeviceBootloader.Config) → json¶

property usb¶

class Memory¶

Bases: pybind11_builtins.pybind11_object

Members:

AUTO

FLASH

EMMC

Attributes:

`AUTO`
`EMMC`
`FLASH`
`name`
`value`

Methods:

__init__(self, value)

AUTO = <Memory.AUTO: -1>¶

EMMC = <Memory.EMMC: 1>¶

FLASH = <Memory.FLASH: 0>¶

__init__(self: depthai.DeviceBootloader.Memory, value: int) → None ¶

property name¶

property value¶

class MemoryInfo¶

Bases: pybind11_builtins.pybind11_object

Methods:

__init__(self)

Attributes:

`available`
`info`
`size`

__init__(self: depthai.DeviceBootloader.MemoryInfo) → None ¶

property available¶

property info¶

property size¶

class NetworkConfig¶

Bases: pybind11_builtins.pybind11_object

Methods:

__init__(self)

Attributes:

`ipv4`
`ipv4Dns`
`ipv4DnsAlt`
`ipv4Gateway`
`ipv4Mask`
`ipv6`
`ipv6Dns`
`ipv6DnsAlt`
`ipv6Gateway`
`ipv6Prefix`
`mac`
`staticIpv4`
`staticIpv6`
`timeoutMs`

__init__(self: depthai.DeviceBootloader.NetworkConfig) → None ¶

property ipv4¶

property ipv4Dns¶

property ipv4DnsAlt¶

property ipv4Gateway¶

property ipv4Mask¶

property ipv6¶

property ipv6Dns¶

property ipv6DnsAlt¶

property ipv6Gateway¶

property ipv6Prefix¶

property mac¶

property staticIpv4¶

property staticIpv6¶

property timeoutMs¶

class Section¶

Bases: pybind11_builtins.pybind11_object

Members:

AUTO

HEADER

BOOTLOADER

BOOTLOADER_CONFIG

APPLICATION

Attributes:

`APPLICATION`
`AUTO`
`BOOTLOADER`
`BOOTLOADER_CONFIG`
`HEADER`
`name`
`value`

Methods:

__init__(self, value)

APPLICATION = <Section.APPLICATION: 3>¶

AUTO = <Section.AUTO: -1>¶

BOOTLOADER = <Section.BOOTLOADER: 1>¶

BOOTLOADER_CONFIG = <Section.BOOTLOADER_CONFIG: 2>¶

HEADER = <Section.HEADER: 0>¶

__init__(self: depthai.DeviceBootloader.Section, value: int) → None ¶

property name¶

property value¶

class Type¶

Bases: pybind11_builtins.pybind11_object

Members:

AUTO

USB

NETWORK

Attributes:

`AUTO`
`NETWORK`
`USB`
`name`
`value`

Methods:

__init__(self, value)

AUTO = <Type.AUTO: -1>¶

NETWORK = <Type.NETWORK: 1>¶

USB = <Type.USB: 0>¶

__init__(self: depthai.DeviceBootloader.Type, value: int) → None ¶

property name¶

property value¶

class UsbConfig¶

Bases: pybind11_builtins.pybind11_object

Methods:

__init__(self)

Attributes:

`maxUsbSpeed`
`pid`
`timeoutMs`
`vid`

__init__(self: depthai.DeviceBootloader.UsbConfig) → None ¶

property maxUsbSpeed¶

property pid¶

property timeoutMs¶

property vid¶

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: depthai.DeviceBootloader, devInfo: depthai.DeviceInfo, allowFlashingBootloader: bool = False) -> None
__init__(self: depthai.DeviceBootloader, devInfo: depthai.DeviceInfo, pathToCmd: Path, allowFlashingBootloader: bool = False) -> None

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

Parameter devInfo:: DeviceInfo of which to boot or connect to

bootMemory(self: depthai.DeviceBootloader, fw: List[int]) → None ¶

Boots a custom FW in memory

Parameter fw:: $Throws:

A runtime exception if there are any communication issues

bootUsbRomBootloader(self: depthai.DeviceBootloader) → None ¶

Boots into integrated ROM bootloader in USB mode

Throws:: A runtime exception if there are any communication issues

close(self: depthai.DeviceBootloader) → None ¶: Closes the connection to device. Better alternative is the usage of context manager: with depthai.DeviceBootloader(deviceInfo) as bootloader:

static createDepthaiApplicationPackage(*args, **kwargs)¶

Overloaded function.

createDepthaiApplicationPackage(pipeline: depthai.Pipeline, pathToCmd: Path = ‘’, compress: bool = False, applicationName: str = ‘’, checkChecksum: bool = False) -> List[int]

Creates application package which can be flashed to depthai device.

Parameter pipeline:: Pipeline from which to create the application package
Parameter pathToCmd:: Optional path to custom device firmware
Parameter compress:: Optional boolean which specifies if contents should be compressed
Parameter applicationName:: Optional name the application that is flashed

Returns: Depthai application package

createDepthaiApplicationPackage(pipeline: depthai.Pipeline, compress: bool, applicationName: str = ‘’, checkChecksum: bool = False) -> List[int]

Creates application package which can be flashed to depthai device.

Parameter pipeline:: Pipeline from which to create the application package
Parameter compress:: Specifies if contents should be compressed
Parameter applicationName:: Name the application that is flashed

Returns: Depthai application package

flash(*args, **kwargs)¶

Overloaded function.

flash(self: depthai.DeviceBootloader, progressCallback: Callable[[float], None], pipeline: depthai.Pipeline, compress: bool = False, applicationName: str = ‘’, memory: depthai.DeviceBootloader.Memory = <Memory.AUTO: -1>, checkChecksum: bool = False) -> Tuple[bool, str]

Flashes a given pipeline to the device.

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

flash(self: depthai.DeviceBootloader, pipeline: depthai.Pipeline, compress: bool = False, applicationName: str = ‘’, memory: depthai.DeviceBootloader.Memory = <Memory.AUTO: -1>, checkChecksum: bool = False) -> Tuple[bool, str]

Flashes a given pipeline to the device.

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

flashBootHeader(self: depthai.DeviceBootloader, memory: depthai.DeviceBootloader.Memory, frequency: int = - 1, location: int = - 1, dummyCycles: int = - 1, offset: int = - 1) → Tuple[bool, str]¶

Flash optimized boot header

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

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

flashBootloader(*args, **kwargs)¶

Overloaded function.

flashBootloader(self: depthai.DeviceBootloader, progressCallback: Callable[[float], None], path: Path = ‘’) -> Tuple[bool, str]

Flashes bootloader to the current board

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

flashBootloader(self: depthai.DeviceBootloader, memory: depthai.DeviceBootloader.Memory, type: depthai.DeviceBootloader.Type, progressCallback: Callable[[float], None], path: Path = ‘’) -> Tuple[bool, str]

Flash selected bootloader to the current board

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

flashClear(self: depthai.DeviceBootloader, memory: depthai.DeviceBootloader.Memory = <Memory.AUTO: -1>) → Tuple[bool, str]¶: Clears flashed application on the device, by removing SBR boot structure Doesn’t remove fast boot header capability to still boot the application

flashConfig(self: depthai.DeviceBootloader, config: depthai.DeviceBootloader.Config, memory: depthai.DeviceBootloader.Memory = <Memory.AUTO: -1>, type: depthai.DeviceBootloader.Type = <Type.AUTO: -1>) → Tuple[bool, str]¶

Flashes configuration to bootloader

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

flashConfigClear(self: depthai.DeviceBootloader, memory: depthai.DeviceBootloader.Memory = <Memory.AUTO: -1>, type: depthai.DeviceBootloader.Type = <Type.AUTO: -1>) → Tuple[bool, str]¶

Clears configuration data

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

flashConfigData(self: depthai.DeviceBootloader, configData: json, memory: depthai.DeviceBootloader.Memory = <Memory.AUTO: -1>, type: depthai.DeviceBootloader.Type = <Type.AUTO: -1>) → Tuple[bool, str]¶

Flashes configuration data to bootloader

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

flashConfigFile(self: depthai.DeviceBootloader, configData: Path, memory: depthai.DeviceBootloader.Memory = <Memory.AUTO: -1>, type: depthai.DeviceBootloader.Type = <Type.AUTO: -1>) → Tuple[bool, str]¶

Flashes configuration data to bootloader

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

flashCustom(*args, **kwargs)¶

Overloaded function.

flashCustom(self: depthai.DeviceBootloader, memory: depthai.DeviceBootloader.Memory, offset: int, data: List[int], progressCallback: Callable[[float], None] = None) -> Tuple[bool, str]

Flash arbitrary data at custom offset in specified memory

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

flashCustom(self: depthai.DeviceBootloader, memory: depthai.DeviceBootloader.Memory, offset: int, filename: str, progressCallback: Callable[[float], None] = None) -> Tuple[bool, str]

Flash arbitrary data at custom offset in specified memory

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

flashDepthaiApplicationPackage(*args, **kwargs)¶

Overloaded function.

flashDepthaiApplicationPackage(self: depthai.DeviceBootloader, progressCallback: Callable[[float], None], package: List[int], memory: depthai.DeviceBootloader.Memory = <Memory.AUTO: -1>) -> Tuple[bool, str]

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

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

flashDepthaiApplicationPackage(self: depthai.DeviceBootloader, package: List[int], memory: depthai.DeviceBootloader.Memory = <Memory.AUTO: -1>) -> Tuple[bool, str]

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

Parameter package:: Depthai application package to flash to the board

flashFastBootHeader(self: depthai.DeviceBootloader, memory: depthai.DeviceBootloader.Memory, frequency: int = - 1, location: int = - 1, dummyCycles: int = - 1, offset: int = - 1) → Tuple[bool, str]¶

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.

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

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

flashGpioModeBootHeader(self: depthai.DeviceBootloader, memory: depthai.DeviceBootloader.Memory, mode: int) → Tuple[bool, str]¶

Flash boot header which boots same as equivalent GPIO mode would

Parameter gpioMode:: GPIO mode equivalent

flashUsbRecoveryBootHeader(self: depthai.DeviceBootloader, memory: depthai.DeviceBootloader.Memory) → Tuple[bool, str]¶

Flash USB recovery boot header. Switches to USB ROM Bootloader

Parameter memory:: Which memory to flash the header to

flashUserBootloader(self: depthai.DeviceBootloader, progressCallback: Callable[[float], None], path: Path = '') → Tuple[bool, str]¶

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

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

static getAllAvailableDevices() → List[depthai.DeviceInfo]¶

Searches for connected devices in either UNBOOTED or BOOTLOADER states.

Returns: Vector of all found devices

static getEmbeddedBootloaderBinary(arg0: depthai.DeviceBootloader.Type) → List[int]¶

Returns: Embedded bootloader binary

static getEmbeddedBootloaderVersion() → depthai.Version ¶

Returns: Embedded bootloader version

static getFirstAvailableDevice() → Tuple[bool, depthai.DeviceInfo]¶

Searches for connected devices in either UNBOOTED or BOOTLOADER states and returns first available.

Returns: Tuple of boolean and DeviceInfo. If found boolean is true and DeviceInfo describes the device. Otherwise false

getMemoryInfo(self: depthai.DeviceBootloader, arg0: depthai.DeviceBootloader.Memory) → depthai.DeviceBootloader.MemoryInfo ¶

Retrieves information about specified memory

Parameter memory:: Specifies which memory to query

getType(self: depthai.DeviceBootloader) → depthai.DeviceBootloader.Type ¶

Returns: Type of currently connected bootloader

getVersion(self: depthai.DeviceBootloader) → depthai.Version ¶

Returns: Version of current running bootloader

isAllowedFlashingBootloader(self: depthai.DeviceBootloader) → bool ¶

Returns: True if allowed to flash bootloader

isEmbeddedVersion(self: depthai.DeviceBootloader) → bool ¶

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.

isUserBootloader(self: depthai.DeviceBootloader) → bool ¶: Retrieves whether current bootloader is User Bootloader (B out of A/B configuration)

isUserBootloaderSupported(self: depthai.DeviceBootloader) → bool ¶

Checks whether User Bootloader is supported with current bootloader

Returns: true of User Bootloader is supported, false otherwise

readApplicationInfo(self: depthai.DeviceBootloader, memory: depthai.DeviceBootloader.Memory) → depthai.DeviceBootloader.ApplicationInfo ¶

Reads information about flashed application in specified memory from device

Parameter memory:: Specifies which memory to query

readConfig(self: depthai.DeviceBootloader, memory: depthai.DeviceBootloader.Memory = <Memory.AUTO: -1>, type: depthai.DeviceBootloader.Type = <Type.AUTO: -1>) → depthai.DeviceBootloader.Config ¶

Reads configuration from bootloader

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

Returns: Configuration structure

readConfigData(self: depthai.DeviceBootloader, memory: depthai.DeviceBootloader.Memory = <Memory.AUTO: -1>, type: depthai.DeviceBootloader.Type = <Type.AUTO: -1>) → json¶

Reads configuration data from bootloader

Returns: Unstructured configuration data

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

readCustom(*args, **kwargs)¶

Overloaded function.

readCustom(self: depthai.DeviceBootloader, memory: depthai.DeviceBootloader.Memory, offset: int, size: int, filename: str, progressCallback: Callable[[float], None] = None) -> Tuple[bool, str]

Reads arbitrary data at custom offset in specified memory

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

readCustom(self: depthai.DeviceBootloader, memory: depthai.DeviceBootloader.Memory, offset: int, size: int, progressCallback: Callable[[float], None] = None) -> Tuple[bool, str, List[int]]

Reads arbitrary data at custom offset in specified memory

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

static saveDepthaiApplicationPackage(*args, **kwargs)¶

Overloaded function.

saveDepthaiApplicationPackage(path: Path, pipeline: depthai.Pipeline, pathToCmd: Path = ‘’, compress: bool = False, applicationName: str = ‘’, checkChecksum: bool = False) -> None

Saves application package to a file which can be flashed to depthai device.

Parameter path:: Path where to save the application package
Parameter pipeline:: Pipeline from which to create the application package
Parameter pathToCmd:: Optional path to custom device firmware
Parameter compress:: Optional boolean which specifies if contents should be compressed
Parameter applicationName:: Optional name the application that is flashed

saveDepthaiApplicationPackage(path: Path, pipeline: depthai.Pipeline, compress: bool, applicationName: str = ‘’, checkChecksum: bool = False) -> None

Saves application package to a file which can be flashed to depthai device.

Parameter path:: Path where to save the application package
Parameter pipeline:: Pipeline from which to create the application package
Parameter compress:: Specifies if contents should be compressed
Parameter applicationName:: Optional name the application that is flashed

class depthai.DeviceDesc¶

Bases: pybind11_builtins.pybind11_object

Methods:

__init__(self)

Attributes:

`mxid`
`name`
`platform`
`protocol`
`state`
`status`

__init__(self: depthai.DeviceDesc) → None ¶

property mxid¶

property name¶

property platform¶

property protocol¶

property state¶

property status¶

class depthai.DeviceInfo¶

Bases: pybind11_builtins.pybind11_object

Describes a connected device

Methods:

`__init__`(args, *kwargs)	Overloaded function.
`getMxId`(self)
`getXLinkDeviceDesc`(self)

Attributes:

`desc`
`mxid`
`name`
`platform`
`protocol`
`state`
`status`

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: depthai.DeviceInfo) -> None
__init__(self: depthai.DeviceInfo, name: str, mxid: str, state: depthai.XLinkDeviceState, protocol: depthai.XLinkProtocol, platform: depthai.XLinkPlatform, status: depthai.XLinkError_t) -> None
__init__(self: depthai.DeviceInfo, mxidOrName: str) -> None

Creates a DeviceInfo by checking whether supplied parameter is a MXID or IP/USB name

Parameter mxidOrName:: Either MXID, IP Address or USB port name

__init__(self: depthai.DeviceInfo, arg0: depthai.DeviceDesc) -> None

property desc¶

getMxId(self: depthai.DeviceInfo) → str ¶

getXLinkDeviceDesc(self: depthai.DeviceInfo) → depthai.DeviceDesc ¶

property mxid¶

property name¶

property platform¶

property protocol¶

property state¶

property status¶

class depthai.EdgeDetectorConfig¶

Bases: depthai.Buffer

EdgeDetectorConfig message. Carries sobel edge filter config.

Methods:

`__init__`(self)
`getConfigData`(self)	Retrieve configuration data for EdgeDetector
`setSobelFilterKernels`(self, …)	Set sobel filter horizontal and vertical 3x3 kernels

__init__(self: depthai.EdgeDetectorConfig) → None ¶

getConfigData(self: depthai.EdgeDetectorConfig) → depthai.EdgeDetectorConfigData ¶

Retrieve configuration data for EdgeDetector

Returns: sobel filter horizontal and vertical 3x3 kernels
Return type: EdgeDetectorConfigData

setSobelFilterKernels(self: depthai.EdgeDetectorConfig, horizontalKernel: List[List[int]], verticalKernel: List[List[int]]) → None ¶

Set sobel filter horizontal and vertical 3x3 kernels

Parameter horizontalKernel:: Used for horizontal gradient computation in 3x3 Sobel filter
Parameter verticalKernel:: Used for vertical gradient computation in 3x3 Sobel filter

class depthai.EdgeDetectorConfigData¶

Bases: pybind11_builtins.pybind11_object

EdgeDetectorConfigData configuration data structure

Methods:

__init__(self)

Attributes:

`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
`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

__init__(self: depthai.EdgeDetectorConfigData) → None ¶

property 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

property 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

class depthai.EdgeDetectorProperties¶

Bases: pybind11_builtins.pybind11_object

Specify properties for EdgeDetector

Methods:

__init__(*args, **kwargs)

Initialize self.

Attributes:

`initialConfig`	Initial edge detector config
`numFramesPool`	Num frames in output pool
`outputFrameSize`	300x300 BGR image -> 3003003 bytes)

__init__(*args, **kwargs)¶: Initialize self. See help(type(self)) for accurate signature.

property initialConfig¶: Initial edge detector config

property numFramesPool¶: Num frames in output pool

property outputFrameSize¶

300x300 BGR image -> 300*300*3 bytes)

Type: Maximum output frame size in bytes (eg

class depthai.EepromData¶

Bases: pybind11_builtins.pybind11_object

EepromData structure

Contains the Calibration and Board data stored on device

Methods:

__init__(self)

Attributes:

`batchName`
`batchTime`
`boardConf`
`boardCustom`
`boardName`
`boardOptions`
`boardRev`
`cameraData`
`hardwareConf`
`imuExtrinsics`
`miscellaneousData`
`productName`
`stereoRectificationData`
`version`

__init__(self: depthai.EepromData) → None ¶

property batchName¶

property batchTime¶

property boardConf¶

property boardCustom¶

property boardName¶

property boardOptions¶

property boardRev¶

property cameraData¶

property hardwareConf¶

property imuExtrinsics¶

property miscellaneousData¶

property productName¶

property stereoRectificationData¶

property version¶

exception depthai.EepromError¶: Bases: RuntimeError

class depthai.Extrinsics¶

Bases: pybind11_builtins.pybind11_object

Extrinsics structure

Methods:

__init__(self)

Attributes:

`rotationMatrix`
`specTranslation`
`toCameraSocket`
`translation`

__init__(self: depthai.Extrinsics) → None ¶

property rotationMatrix¶

property specTranslation¶

property toCameraSocket¶

property translation¶

class depthai.FeatureTrackerConfig¶

Bases: depthai.Buffer

FeatureTrackerConfig message. Carries config for feature tracking algorithm

Classes:

`CornerDetector`	Corner detector configuration structure.
`FeatureMaintainer`	FeatureMaintainer configuration structure.
`MotionEstimator`	Used for feature reidentification between current and previous features.

Methods:

`__init__`(args, *kwargs)	Overloaded function.
`get`(self)	Retrieve configuration data for FeatureTracker.
`set`(self, config)	Set explicit configuration.
`setCornerDetector`(args, *kwargs)	Overloaded function.
`setFeatureMaintainer`(args, *kwargs)	Overloaded function.
`setHwMotionEstimation`(self)	Set hardware accelerated motion estimation using block matching.
`setMotionEstimator`(args, *kwargs)	Overloaded function.
`setNumTargetFeatures`(self, numTargetFeatures)	Set number of target features to detect.
`setOpticalFlow`(args, *kwargs)	Overloaded function.

class CornerDetector¶

Bases: pybind11_builtins.pybind11_object

Corner detector configuration structure.

Classes:

`Thresholds`	Threshold settings structure for corner detector.
`Type`	Members:

Methods:

__init__(self)

Attributes:

`cellGridDimension`	Ensures distributed feature detection across the image.
`enableSobel`	Enable 3x3 Sobel operator to smoothen the image whose gradient is to be computed.
`enableSorting`	Enable sorting detected features based on their score or not.
`numMaxFeatures`	Hard limit for the maximum number of features that can be detected.
`numTargetFeatures`	Target number of features to detect.
`thresholds`	Threshold settings.
`type`	Corner detector algorithm type.

class Thresholds¶

Bases: pybind11_builtins.pybind11_object

Threshold settings structure for corner detector.

Methods:

__init__(self)

Attributes:

`decreaseFactor`	When detected number of features exceeds the maximum in a cell threshold is lowered by multiplying its value with this factor.
`increaseFactor`	When detected number of features doesn’t exceed the maximum in a cell, threshold is increased by multiplying its value with this factor.
`initialValue`	Minimum strength of a feature which will be detected.
`max`	Maximum limit for threshold.
`min`	Minimum limit for threshold.

__init__(self: depthai.RawFeatureTrackerConfig.CornerDetector.Thresholds) → None ¶

property decreaseFactor¶: When detected number of features exceeds the maximum in a cell threshold is lowered by multiplying its value with this factor.

property increaseFactor¶: When detected number of features doesn’t exceed the maximum in a cell, threshold is increased by multiplying its value with this factor.

property 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.

property max¶: Maximum limit for threshold. Applicable when automatic threshold update is enabled. 0 means auto. Empirical value.

property min¶: Minimum limit for threshold. Applicable when automatic threshold update is enabled. 0 means auto, 6000000 for HARRIS, 1200 for SHI_THOMASI. Empirical value.

class Type¶

Bases: pybind11_builtins.pybind11_object

Members:

HARRIS

SHI_THOMASI

Attributes:

`HARRIS`
`SHI_THOMASI`
`name`
`value`

Methods:

__init__(self, value)

HARRIS = <Type.HARRIS: 0>¶

SHI_THOMASI = <Type.SHI_THOMASI: 1>¶

__init__(self: depthai.RawFeatureTrackerConfig.CornerDetector.Type, value: int) → None ¶

property name¶

property value¶

__init__(self: depthai.RawFeatureTrackerConfig.CornerDetector) → None ¶

property 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.

property 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.

property enableSorting¶: Enable sorting detected features based on their score or not.

property 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.

property numTargetFeatures¶: Target number of features to detect. Maximum number of features is determined at runtime based on algorithm type.

property thresholds¶: Threshold settings. These are advanced settings, suitable for debugging/special cases.

property type¶: Corner detector algorithm type.

class FeatureMaintainer¶

Bases: pybind11_builtins.pybind11_object

FeatureMaintainer configuration structure.

Methods:

__init__(self)

Attributes:

`enable`	Enable feature maintaining or not.
`lostFeatureErrorThreshold`	Optical flow measures the tracking error for every feature.
`minimumDistanceBetweenFeatures`	Used to filter out detected feature points that are too close.
`trackedFeatureThreshold`	Once a feature was detected and we started tracking it, we need to update its Harris score on each image.

__init__(self: depthai.RawFeatureTrackerConfig.FeatureMaintainer) → None ¶

property enable¶: Enable feature maintaining or not.

property 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.

property 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.

property 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.

class MotionEstimator¶

Bases: pybind11_builtins.pybind11_object

Used for feature reidentification between current and previous features.

Classes:

`OpticalFlow`	Optical flow configuration structure.
`Type`	Members:

Methods:

__init__(self)

Attributes:

`enable`	Enable motion estimation or not.
`opticalFlow`	Optical flow configuration.
`type`	Motion estimator algorithm type.

class OpticalFlow¶

Bases: pybind11_builtins.pybind11_object

Optical flow configuration structure.

Methods:

__init__(self)

Attributes:

`epsilon`	Feature tracking termination criteria.
`maxIterations`	Feature tracking termination criteria.
`pyramidLevels`	Number of pyramid levels, only for optical flow.
`searchWindowHeight`	Image patch height used to track features.
`searchWindowWidth`	Image patch width used to track features.

__init__(self: depthai.RawFeatureTrackerConfig.MotionEstimator.OpticalFlow) → None ¶

property 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.

property 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.

property 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.

property 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

property 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

class Type¶

Bases: pybind11_builtins.pybind11_object

Members:

LUCAS_KANADE_OPTICAL_FLOW

HW_MOTION_ESTIMATION

Attributes:

`HW_MOTION_ESTIMATION`
`LUCAS_KANADE_OPTICAL_FLOW`
`name`
`value`

Methods:

__init__(self, value)

HW_MOTION_ESTIMATION = <Type.HW_MOTION_ESTIMATION: 1>¶

LUCAS_KANADE_OPTICAL_FLOW = <Type.LUCAS_KANADE_OPTICAL_FLOW: 0>¶

__init__(self: depthai.RawFeatureTrackerConfig.MotionEstimator.Type, value: int) → None ¶

property name¶

property value¶

__init__(self: depthai.RawFeatureTrackerConfig.MotionEstimator) → None ¶

property enable¶: Enable motion estimation or not.

property opticalFlow¶: Optical flow configuration. Takes effect only if MotionEstimator algorithm type set to LUCAS_KANADE_OPTICAL_FLOW.

property type¶: Motion estimator algorithm type.

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: depthai.FeatureTrackerConfig) -> None
__init__(self: depthai.FeatureTrackerConfig, arg0: depthai.RawFeatureTrackerConfig) -> None

get(self: depthai.FeatureTrackerConfig) → depthai.RawFeatureTrackerConfig ¶

Retrieve configuration data for FeatureTracker.

Returns: config for feature tracking algorithm

set(self: depthai.FeatureTrackerConfig, config: depthai.RawFeatureTrackerConfig) → depthai.FeatureTrackerConfig ¶

Set explicit configuration.

Parameter config:: Explicit configuration

setCornerDetector(*args, **kwargs)¶

Overloaded function.

setCornerDetector(self: depthai.FeatureTrackerConfig, cornerDetector: depthai.RawFeatureTrackerConfig.CornerDetector.Type) -> depthai.FeatureTrackerConfig

Set corner detector algorithm type.

Parameter cornerDetector:: Corner detector type, HARRIS or SHI_THOMASI

setCornerDetector(self: depthai.FeatureTrackerConfig, config: depthai.RawFeatureTrackerConfig.CornerDetector) -> depthai.FeatureTrackerConfig

Set corner detector full configuration.

Parameter config:: Corner detector configuration

setFeatureMaintainer(*args, **kwargs)¶

Overloaded function.

setFeatureMaintainer(self: depthai.FeatureTrackerConfig, enable: bool) -> depthai.FeatureTrackerConfig

Enable or disable feature maintainer.

Parameter enable:

setFeatureMaintainer(self: depthai.FeatureTrackerConfig, config: depthai.RawFeatureTrackerConfig.FeatureMaintainer) -> depthai.FeatureTrackerConfig

Set feature maintainer full configuration.

Parameter config:: feature maintainer configuration

setHwMotionEstimation(self: depthai.FeatureTrackerConfig) → depthai.FeatureTrackerConfig ¶: Set hardware accelerated motion estimation using block matching. Faster than optical flow (software implementation) but might not be as accurate.

setMotionEstimator(*args, **kwargs)¶

Overloaded function.

setMotionEstimator(self: depthai.FeatureTrackerConfig, enable: bool) -> depthai.FeatureTrackerConfig

Enable or disable motion estimator.

Parameter enable:

setMotionEstimator(self: depthai.FeatureTrackerConfig, config: depthai.RawFeatureTrackerConfig.MotionEstimator) -> depthai.FeatureTrackerConfig

Set motion estimator full configuration.

Parameter config:: Motion estimator configuration

setNumTargetFeatures(self: depthai.FeatureTrackerConfig, numTargetFeatures: int) → depthai.FeatureTrackerConfig ¶

Set number of target features to detect.

Parameter numTargetFeatures:: Number of features

setOpticalFlow(*args, **kwargs)¶

Overloaded function.

setOpticalFlow(self: depthai.FeatureTrackerConfig) -> depthai.FeatureTrackerConfig

Set optical flow as motion estimation algorithm type.

setOpticalFlow(self: depthai.FeatureTrackerConfig, config: depthai.RawFeatureTrackerConfig.MotionEstimator.OpticalFlow) -> depthai.FeatureTrackerConfig

Set optical flow full configuration.

Parameter config:: Optical flow configuration

class depthai.FeatureTrackerProperties¶

Bases: pybind11_builtins.pybind11_object

Specify properties for FeatureTracker

Methods:

__init__(*args, **kwargs)

Initialize self.

Attributes:

`initialConfig`	Initial feature tracker config
`numMemorySlices`	Number of memory slices reserved for feature tracking.
`numShaves`	Number of shaves reserved for feature tracking.

__init__(*args, **kwargs)¶: Initialize self. See help(type(self)) for accurate signature.

property initialConfig¶: Initial feature tracker config

property 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.

property 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.

class depthai.FrameEvent¶

Bases: pybind11_builtins.pybind11_object

Members:

NONE

READOUT_START

READOUT_END

Attributes:

`NONE`
`READOUT_END`
`READOUT_START`
`name`
`value`

Methods:

__init__(self, value)

NONE = <FrameEvent.NONE: 0>¶

READOUT_END = <FrameEvent.READOUT_END: 2>¶

READOUT_START = <FrameEvent.READOUT_START: 1>¶

__init__(self: depthai.FrameEvent, value: int) → None ¶

property name¶

property value¶

class depthai.GlobalProperties¶

Bases: pybind11_builtins.pybind11_object

Specify properties which apply for whole pipeline

Methods:

__init__(*args, **kwargs)

Initialize self.

Attributes:

`cameraTuningBlobSize`	Camera tuning blob size in bytes
`cameraTuningBlobUri`	Uri which points to camera tuning blob
`leonOsFrequencyHz`
`leonRtFrequencyHz`
`pipelineName`
`pipelineVersion`
`xlinkChunkSize`	Chunk size for splitting device-sent XLink packets, in bytes.

__init__(*args, **kwargs)¶: Initialize self. See help(type(self)) for accurate signature.

property cameraTuningBlobSize¶: Camera tuning blob size in bytes

property cameraTuningBlobUri¶: Uri which points to camera tuning blob

property leonOsFrequencyHz¶

property leonRtFrequencyHz¶

property pipelineName¶

property pipelineVersion¶

property 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.

class depthai.IMUData¶

Bases: depthai.Buffer

IMUData message. Carries normalized detection results

Methods:

__init__(self)

Attributes:

packets

Detections

__init__(self: depthai.IMUData) → None ¶

property packets¶: Detections

class depthai.IMUPacket¶

Bases: pybind11_builtins.pybind11_object

IMU output

Contains combined output for all possible modes. Only the enabled outputs are populated.

Methods:

__init__(self)

Attributes:

`acceleroMeter`
`gyroscope`
`magneticField`
`rotationVector`

__init__(self: depthai.IMUPacket) → None ¶

property acceleroMeter¶

property gyroscope¶

property magneticField¶

property rotationVector¶

class depthai.IMUProperties¶

Bases: pybind11_builtins.pybind11_object

Methods:

__init__(*args, **kwargs)

Initialize self.

Attributes: