Luxonis

https://docs.luxonis.com/
Admin
Luxonis provides hardware, software, and cloud solutions for robotic vision and edge AI...
Tokens:464,874
Snippets:3,207
Trust Score:9.2
Update:8 months ago
Show doc for...
Tokens:
Raw
### Run DepthAI v3 Python Examples

Source: https://docs.luxonis.com/software-v3/depthai

After installing the DepthAI library, these commands demonstrate how to navigate to the examples directory and run specific Python scripts, such as the Detection Network example or a script to display all camera streams.

```bash
1cd examples/python
2# Run YoloV6 detection example
3python3 DetectionNetwork/detection_network.py
4# Display all camera streams
5python3 Camera/camera_all.py
```

--------------------------------

### Clone and Run Dynamic Calibration Example (Python)

Source: https://docs.luxonis.com/hardware/platform/depth/dynamic-calibration

This snippet demonstrates how to clone the depthai-core repository, set up a Python virtual environment, install requirements, and run the DynamicCalibration integration example. It's a starting point for integrating auto-calibration into your projects.

```bash
1git clone https://github.com/luxonis/depthai-core.git
2cd depthai-core/
3python3 -m venv venv
4source venv/bin/activate
5python3 examples/python/install_requirements.py
6python3 examples/python/DynamicCalibration/calibration_integration.py
```

--------------------------------

### oakapp.toml Configuration Example

Source: https://docs.luxonis.com/software-v3/oak-apps

This TOML snippet demonstrates the structure of the oakapp.toml file. It includes required fields like 'identifier' and 'entrypoint', as well as optional sections for 'prepare_container' to install runtime dependencies and 'prepare_build_container' for build-time dependencies.

```toml
# (Required) App Identifier
identifier = "com.luxonis.python_demo"
# (Required) App Entrypoint
entrypoint = ["bash", "-c", "python3 /app/main.py"]

# (Optional) Prepare container commands
# Here is the place where you can install all the dependencies that are needed at run-time
prepare_container = [
    { type = "COPY", source = "requirements.txt", target = "requirements.txt" },
    { type = "RUN", command = "apt-get update" },
    { type = "RUN", command = "apt-get install -y python3-pip" },
    { type = "RUN", command = "pip3 install -r /app/requirements.txt --break-system-packages" },
]

# (Optional) Prepare build dependencies
# Here is the place where you can install all the dependencies that are needed at build-time
prepare_build_container = [
    # Example: npm, gcc, ...
]

# (Optional) Additional commands after all the app files are copied to the container
build_steps = []

```

--------------------------------

### RAE WiFi Configuration Files (Linux Command Line)

Source: https://docs.luxonis.com/hardware/rae/get-started

Example content for RAE's WiFi configuration files. This includes setting up the network SSID and passphrase in `wpa_supplicant.conf` and network interface settings in `20-wifi.network`.

```bash
ctrl_interface=/var/run/wpa_supplicant
ctrl_interface_group=root
network={
    ssid="<WIFI_SSID>"
    psk=<PASSPHRASE>
}
```

```bash
[Match]
Name=wlp1s0

[Network]
DHCP=ipv4

[DHCP]
UseDomains=true
```

--------------------------------

### Initiate OAK4 Setup Mode

Source: https://docs.luxonis.com/hardware/platform/deploy/oak4-deployment-guide/oak4-advanced

Put an OAK4 device into Setup Mode using the oakctl command. This prepares the device for local setup and is indicated by a blinking blue status light on the camera.

```bash
oakctl start-setup
```

--------------------------------

### Example oakapp.toml Configuration

Source: https://docs.luxonis.com/software-v3/oak-apps/configuration

This TOML file defines the metadata and build steps for an OAK App. It includes the app identifier, entrypoint, commands to prepare the runtime container by installing dependencies, and optional build dependencies.

```toml
1# (Required) App Identifier
2identifier = "com.luxonis.python_demo"
3# (Required) App Entrypoint
4entrypoint = ["bash", "-c", "python3 /app/main.py"]
5
6# (Optional) Prepare container commands
7# Here is the place where you can install all the dependencies that are needed at run-time
8prepare_container = [
9    { type = "COPY", source = "requirements.txt", target = "requirements.txt" },
10    { type = "RUN", command = "apt-get update" },
11    { type = "RUN", command = "apt-get install -y python3-pip" },
12    { type = "RUN", command = "pip3 install -r /app/requirements.txt --break-system-packages" },
13]
14
15# (Optional) Prepare build dependencies
16# Here is the place where you can install all the dependencies that are needed at build-time
17prepare_build_container = [
18    # Example: npm, gcc, ...
19]
20
21# (Optional) Additional commands after all the app files are copied to the container
22build_steps = []

```

--------------------------------

### Basalt VIO Pipeline Setup and Execution (Python)

Source: https://docs.luxonis.com/software-v3/depthai/examples/rvc2/vslam/basalt_vio

Sets up a DepthAI pipeline to capture stereo camera frames and IMU data, process them using BasaltVIO for visual odometry, and stream results to a RerunNode for visualization. Requires DepthAI v3 API and the depthai-core develop branch.

```python
import signal
import time
import depthai as dai
from rerun_node import RerunNode
# Create pipeline

with dai.Pipeline() as p:
    fps = 60
    width = 640
    height = 400
    # Define sources and outputs
    left = p.create(dai.node.Camera).build(dai.CameraBoardSocket.CAM_B, sensorFps=fps)
    right = p.create(dai.node.Camera).build(dai.CameraBoardSocket.CAM_C, sensorFps=fps)
    imu = p.create(dai.node.IMU)
    odom = p.create(dai.node.BasaltVIO)

    rerunViewer = RerunNode()
    imu.enableIMUSensor([dai.IMUSensor.ACCELEROMETER_RAW, dai.IMUSensor.GYROSCOPE_RAW], 200)
    imu.setBatchReportThreshold(1)
    imu.setMaxBatchReports(10)

    # Linking
    left.requestOutput((width, height)).link(odom.left)
    right.requestOutput((width, height)).link(odom.right)
    imu.out.link(odom.imu)
    odom.passthrough.link(rerunViewer.inputImg)
    odom.transform.link(rerunViewer.inputTrans)
    p.start()
    while p.isRunning():
        time.sleep(0.01)
```

--------------------------------

### YAML Calibration File Examples

Source: https://docs.luxonis.com/software-v3/depthai/ros/driver

Provides examples of how to specify calibration file paths in YAML format for camera information management. These examples demonstrate local file paths, package-relative paths, and absolute paths.

```yaml
- file:///full/path/to/local/file.yaml
- file:///full/path/to/videre/file.ini
- package://camera_info_manager/tests/test_calibration.yaml
- package://ros_package_name/calibrations/camera3.yaml
```

--------------------------------

### Run Generic Neural Network App with Python Environment

Source: https://docs.luxonis.com/software-v3

This set of commands details how to run the generic neural network example application after setting up a Python virtual environment. It includes cloning the repository, creating and activating a virtual environment, installing dependencies, and finally running the main Python script.

```bash
# Clone the repo
git clone --depth 1 --branch main https://github.com/luxonis/oak-examples.git
# Change directory to the generic-example
cd oak-examples/neural-networks/generic-example/
# Create and enter virtual python environment
python3 -m venv venv
source venv/bin/activate
# Install requirements into the environment
pip install -r requirements.txt
# Run the app and follow instructions to open the web viewer
python3 main.py
```

--------------------------------

### Set up DepthAI ROS Workspace and Build

Source: https://docs.luxonis.com/software-v3/depthai/ros/build-from-source

Clones the depthai-core and depthai-ros repositories into a new ROS workspace, installs dependencies using rosdep, and builds the workspace using colcon. It also includes sourcing the ROS setup script.

```bash
mkdir -p dai_ws/src
cd dai_ws/src
git clone --branch kitled https://github.com/luxonis/depthai-core.git && cd depthai-core && git submodule update --init --recursive
git clone --branch kilted https://github.com/luxonis/depthai-ros.git
cd ..
rosdep install --from-paths src --ignore-src -r -y
source /opt/ros/$ROS_DISTRO/setup.bash
MAKEFLAGS="-j1 -l1" colcon build
source install/setup.bash
```

--------------------------------

### Basalt VIO RTab Pipeline Setup (Python)

Source: https://docs.luxonis.com/software-v3/depthai/examples/rvc2/vslam/basalt_vio_rtab

Sets up a DepthAI pipeline integrating stereo cameras, IMU, Basalt VIO, RTAB-Map SLAM, and RerunNode for visualization. It configures stereo depth, IMU sensors, and SLAM parameters for real-time 3D occupancy grid generation and point cloud visualization.

```python
import time
import depthai as dai
from rerun_node import RerunNode

# Create pipeline

with dai.Pipeline() as p:
    fps = 60
    width = 640
    height = 400
    # Define sources and outputs
    left = p.create(dai.node.Camera).build(dai.CameraBoardSocket.CAM_B, sensorFps=fps)
    right = p.create(dai.node.Camera).build(dai.CameraBoardSocket.CAM_C, sensorFps=fps)
    imu = p.create(dai.node.IMU)
    odom = p.create(dai.node.BasaltVIO)
    slam = p.create(dai.node.RTABMapSLAM)
    stereo = p.create(dai.node.StereoDepth)
    params = {"RGBD/CreateOccupancyGrid": "true",
            "Grid/3D": "true",
            "Rtabmap/SaveWMState": "true"}
    slam.setParams(params)

    rerunViewer = RerunNode()
    imu.enableIMUSensor([dai.IMUSensor.ACCELEROMETER_RAW, dai.IMUSensor.GYROSCOPE_RAW], 200)
    imu.setBatchReportThreshold(1)
    imu.setMaxBatchReports(10)

    stereo.setExtendedDisparity(False)
    stereo.setLeftRightCheck(True)
    stereo.setSubpixel(True)
    stereo.setRectifyEdgeFillColor(0)
    stereo.enableDistortionCorrection(True)
    stereo.initialConfig.setLeftRightCheckThreshold(10)
    stereo.setDepthAlign(dai.CameraBoardSocket.CAM_B)


    left.requestOutput((width, height)).link(stereo.left)
    right.requestOutput((width, height)).link(stereo.right)
    stereo.syncedLeft.link(odom.left)
    stereo.syncedRight.link(odom.right)
    stereo.depth.link(slam.depth)
    stereo.rectifiedLeft.link(slam.rect)
    imu.out.link(odom.imu)

    odom.transform.link(slam.odom)
    slam.transform.link(rerunViewer.inputTrans)
    slam.passthroughRect.link(rerunViewer.inputImg)
    slam.occupancyGridMap.link(rerunViewer.inputGrid)
    slam.obstaclePCL.link(rerunViewer.inputObstaclePCL)
    slam.groundPCL.link(rerunViewer.inputGroundPCL)
    p.start()
    while p.isRunning():
        time.sleep(1)
```

--------------------------------

### Install DepthAI and Template App (Command Line)

Source: https://docs.luxonis.com/software-v3/template

Installs the core DepthAI Python package and clones the template application repository. It then navigates into the template directory and installs its Python dependencies.

```bash
pip install depthai --force-reinstall
git clone https://github.com/luxonis/oak-template.git
cd oak-template
pip install -r requirements.txt
```

--------------------------------

### Manual Model and Parser Setup (Python)

Source: https://docs.luxonis.com/software-v3/ai-inference/inference

Illustrates the manual setup of a model and a parser as independent nodes. This approach allows for more control over configuration and custom parser implementation. It involves importing a parser node, creating independent model and parser nodes, configuring them, and linking them within the pipeline.

```Python
from depthai_nodes.node import <ParserNode>

# OR custom parser implementation
class ParserNode(dai.node.ThreadedHostNode):
    def __init__(self) -> None:
        super().__init__()
        self.input = self.createInput()
        self.out = self.createOutput()
    def build(self) -> "ParserNode":
        return self
    def run(self) -> None:
        nn_out_raw = self.input.get()
        nn_out_processed = ... # custom post-processing
        self.out.send(nn_out_processed)
```

```Python
# Initialize model and parser nodes
model = pipeline.create(dai.node.NeuralNetwork)
parser = pipeline.create(<ParserNode>)

# Configure nodes (example: setting model path)
model.setModelPath("<path/to/model_executable>")

# Link nodes in the pipeline
width, height = ... # model input size
camera_stream = camera.requestOutput(size=(width, height))
camera_stream.link(model.input)
model.out.link(parser.input)
```

--------------------------------

### Run DepthAI Example App

Source: https://docs.luxonis.com/hardware/platform/deploy/to-rpi

Execute a Python example script from the depthai-python library to run an application, such as an RGB MobileNet object detection model.

```python
python depthai-python/examples/MobileNet/rgb_mobilenet.py
```

--------------------------------

### Install oakctl CLI for Linux/MacOS

Source: https://docs.luxonis.com/software-v3

This command installs the oakctl CLI tool on 64-bit Linux or macOS systems. It fetches the installer script from a remote URL and executes it. This tool is essential for managing and configuring OAK4 devices.

```bash
bash -c "$(curl -fsSL https://oakctl-releases.luxonis.com/oakctl-installer.sh)"
```

--------------------------------

### Advanced Examples

Source: https://docs.luxonis.com/software-v3/ai-inference/benchmarking

Examples demonstrating advanced configurations for benchmarking, including custom durations, power monitoring, and local DLC benchmarking.

```APIDOC
## Advanced Examples

### NN Archive with Custom Duration
Benchmark an exported NN Archive on RVC2 with a longer test duration and save results for later comparison.

### Method
POST

### Endpoint
`/websites/luxonis/modelconverter/benchmark

### Parameters
#### Query Parameters
- **model-path** (string) - Required - Path or slug of the model archive.
- **benchmark-time** (integer) - Optional - Duration in seconds for time-based benchmarking. Set to 60 for longer duration.
- **save** (boolean) - Optional - Saves results to CSV for comparison.

### Request Example
```bash
modelconverter benchmark rvc2 \
  --model-path path/to/model_archive.tar.xz \
  --benchmark-time 60 \
  --save
```

### HubAI Model with Power Monitoring
Benchmark a Model Zoo model using its HubAI Model Slug on RVC4 with power consumption and DSP utilization metrics.

### Method
POST

### Endpoint
`/websites/luxonis/modelconverter/benchmark

### Parameters
#### Query Parameters
- **model-path** (string) - Required - HubAI Model Slug (e.g., `yolov6-nano:r2-coco-512x288`).
- **device-ip** (string) - Optional - IP address of the target RVC4 device.
- **power-benchmark** (boolean) - Optional - Enables power consumption metrics collection.
- **dsp-benchmark** (boolean) - Optional - Enables DSP utilization metrics collection.

### Request Example
```bash
modelconverter benchmark rvc4 \
  --model-path yolov6-nano:r2-coco-512x288 \
  --device-ip 192.168.1.50 \
  --power-benchmark \
  --dsp-benchmark
```

### Local DLC via SNPE
Benchmark a local `.dlc` file using SNPE tools with a controlled workload size.

### Method
POST

### Endpoint
`/websites/luxonis/modelconverter/benchmark

### Parameters
#### Query Parameters
- **model-path** (string) - Required - Path to the local `.dlc` file.
- **no-dai-benchmark** (boolean) - Optional - Disables DAI benchmarking and uses SNPE tools over ADB.
- **device-ip** (string) - Optional - IP address of the target device.
- **num-images** (integer) - Optional - Number of generated input images to process.

### Request Example
```bash
modelconverter benchmark rvc4 \
  --model-path path/to/model.dlc \
  --no-dai-benchmark \
  --device-ip 192.168.1.50 \
  --num-images 500
```

### Response
#### Success Response (200)
- **message** (string) - Indicates successful execution of the advanced benchmark example.

#### Response Example
```json
{
  "message": "Advanced benchmark example executed successfully."
}
```
```

--------------------------------

### Setup DepthAI Pipeline with Camera, Detection Network, and Remote Connector (Python)

Source: https://docs.luxonis.com/software-v3/depthai/examples/visualizer/custom_visualizations

This Python code sets up a DepthAI pipeline. It initializes a camera, a detection network (yolov6-nano), and the custom `ImgAnnotationsGenerator`. It links these components and configures a `dai.RemoteConnection` to stream encoded images, raw detections, and generated annotations. The pipeline is started and registered with the remote connector, allowing for remote visualization and control.

```python
remoteConnector = dai.RemoteConnection()

# Create pipeline
with dai.Pipeline() as pipeline:
    cameraNode = pipeline.create(dai.node.Camera).build(dai.CameraBoardSocket.CAM_A)
    detectionNetwork = pipeline.create(dai.node.DetectionNetwork).build(
        cameraNode, dai.NNModelDescription("yolov6-nano")
    )
    imageAnnotationsGenerator = pipeline.create(ImgAnnotationsGenerator)
    outputToVisualize = cameraNode.requestOutput((640,480), type=dai.ImgFrame.Type.NV12)
    detectionNetwork.out.link(imageAnnotationsGenerator.inputDet)

    # Add the remote connector topics
    remoteConnector.addTopic("encoded", outputToVisualize, "images")
    remoteConnector.addTopic("detections", detectionNetwork.out, "images")
    remoteConnector.addTopic("annotations", imageAnnotationsGenerator.output, "images")

    pipeline.start()

    # Register the pipeline with the remote connector
    remoteConnector.registerPipeline(pipeline)

    while pipeline.isRunning():
        if remoteConnector.waitKey(1) == ord("q"):
            pipeline.stop()
            break

```

--------------------------------

### Verify and Update oakctl

Source: https://docs.luxonis.com/hardware/platform/deploy/oak4-deployment-guide/oak4-advanced

Verify the installed version of the oakctl tool and update it if necessary. A minimum version of 0.16.2 is recommended for local OAK4 setup.

```bash
oakctl version
oakctl self-update
```

--------------------------------

### Create Host Display Node and Pipeline in Python

Source: https://docs.luxonis.com/software-v3/depthai/depthai-components/host_nodes

Demonstrates how to define a custom HostDisplay node that processes and displays frames, and then integrates it into a Luxonis pipeline. This example uses OpenCV for display and allows stopping the pipeline by pressing 'q'.

```Python
class HostDisplay(dai.node.HostNode):
    def build(self, frameOutput: dai.Node.Output):
        self.link_args(frameOutput) # Has to match the inputs to the `process` method

        # This sends all the processing to the pipeline where it's executed by the `pipeline.runTasks()` or implicitly by `pipeline.run()` method.
        # It's needed as the GUI window needs to be updated in the main thread, and the `process` method is by default called in a separate thread.
        self.sendProcessingToPipeline(True)
        return self

    def onStart(self) -> None: # Optional method
        print("HostDisplay started")

    def process(self, message: dai.ImgFrame):
        cv2.imshow("HostDisplay", message.getCvFrame())
        key = cv2.waitKey(1)
        if key == ord('q'):
            print("Detected 'q' - stopping the pipeline...")
            self.stopPipeline()

p = dai.Pipeline()
with p:
    camera = p.create(dai.node.Camera).build()
    hostDisplay = p.create(HostDisplay).build(camera.requestOutput((300, 300)))

    p.run() # Will block until the pipeline is stopped by someone else (in this case it's the display node)
```

--------------------------------

### OAK Visualizer Basic Setup

Source: https://docs.luxonis.com/software-v3/depthai/tools/oak-visualizer

Demonstrates how to set up the OAK Visualizer by creating a RemoteConnection, defining a pipeline with a camera node, and registering the stream to the visualizer.

```APIDOC
## POST /websites/luxonis/oak-visualizer

### Description
This endpoint allows for the basic setup and streaming of camera data to the OAK Visualizer. It involves creating a `RemoteConnection` server, defining a DepthAI pipeline with a camera node, and registering the camera stream as a topic for visualization in the browser.

### Method
POST

### Endpoint
/websites/luxonis/oak-visualizer/setup

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```python
import depthai as dai

# Create a RemoteConnection (Visualizer server)
visualizer = dai.RemoteConnection()

# Create pipeline
with dai.Pipeline() as pipeline:
    # Create camera node
    # Build method without arguments will use the default camera
    rgb_cam = pipeline.create(dai.node.Camera).build()

    # Request NV12 stream with resolution of 1280x720 from the camera
    rgb_stream = rgb_cam.requestOutput(size=(1280, 720), type=dai.ImgFrame.Type.NV12)

    # Add camera stream as a topic to the Visualizer
    visualizer.addTopic("rgb", rgb_stream)

    # Build and start the pipeline
    pipeline.start()

    # Register the pipeline graph to be visualized in the Visualizer
    visualizer.registerPipeline(pipeline)

    # Main loop executed while the pipeline is running
    while pipeline.isRunning():
        # Check for key presses in the Visualizer
        if visualizer.waitKey(1) == ord('q'):
            # If 'q' is pressed, stop the pipeline
            pipeline.stop()
```

### Response
#### Success Response (200)
Indicates successful setup and that the visualizer is accessible at `http://localhost:8080`.

#### Response Example
```json
{
  "status": "success",
  "message": "OAK Visualizer is running. Access it at http://localhost:8080"
}
```
```

--------------------------------

### Apply WiFi Settings and Reboot RAE (Linux Command Line)

Source: https://docs.luxonis.com/hardware/rae/get-started

Commands to apply the new WiFi settings and restart necessary services on the RAE robot. This includes stopping the access point, starting the WiFi client, and restarting the network manager.

```bash
systemctl stop hostapd
wpa_supplicant -B -i wlp1s0 -c /etc/wpa_supplicant.conf
systemctl restart systemd-networkd
```

```bash
robothub-ctl stop
robothub-ctl startup disable
```

--------------------------------

### Container Preparation Steps (oakapp.toml)

Source: https://docs.luxonis.com/software-v3/oak-apps/base-image

Specifies the commands to execute for preparing the application's container environment. This typically involves copying dependency files like requirements.txt and installing the necessary packages using a package manager like pip. These steps ensure dependencies are met before the application runs.

```toml
1prepare_container = [
2    { type = "COPY", source = "./requirements.txt", target = "./requirements.txt" },
3    { type = "RUN", command = "python3.12 -m pip install -r /app/requirements.txt --break-system-packages"}
]
```

--------------------------------

### Python: Migrate RGB Stream from DepthAI v2 to v3

Source: https://docs.luxonis.com/software-v3/depthai/tutorials/v2-vs-v3

Demonstrates the minimal code changes required to port a simple RGB streaming example from DepthAI v2 to v3. It highlights the removal of explicit XLink nodes and the simplified pipeline start and output queue creation.

```python
#!/usr/bin/env python3

import cv2
import depthai as dai

# Create pipeline
pipeline = dai.Pipeline()

# Define source and output
camRgb = pipeline.create(dai.node.ColorCamera)

# ORIG – explicit XLink removed in v3
# xoutVideo = pipeline.create(dai.node.XLinkOut)
# xoutVideo.setStreamName("video")

# Properties
camRgb.setBoardSocket(dai.CameraBoardSocket.CAM_A)
camRgb.setResolution(dai.ColorCameraProperties.SensorResolution.THE_1080_P)
camRgb.setVideoSize(1920, 1080)

# Linking
# ORIG
# camRgb.video.link(xoutVideo.input)
# NEW – output queue straight from the node
videoQueue = camRgb.video.createOutputQueue()

# ORIG – entire `with dai.Device` block removed
# with dai.Device(pipeline) as device:
#   video = device.getOutputQueue(name="video", maxSize=1, blocking=False)
#   while True:
# NEW – start the pipeline
pipeline.start()
while pipeline.isRunning():
    videoIn = videoQueue.get()  # blocking
    cv2.imshow("video", videoIn.getCvFrame())
    if cv2.waitKey(1) == ord('q'):
        break

```

--------------------------------

### Basic OAK Visualizer Setup (Python)

Source: https://docs.luxonis.com/software-v3/depthai/tools/oak-visualizer

This Python code demonstrates the basic setup for the OAK Visualizer. It creates a RemoteConnection to act as the Visualizer server, configures a camera node to stream NV12 data, adds this stream as a topic to the Visualizer, and registers the pipeline for visualization. The application runs until the user presses 'q' in the Visualizer.

```python
import depthai as dai

# Create a RemoteConnection (Visualizer server)
visualizer = dai.RemoteConnection()

# Create pipeline
with dai.Pipeline() as pipeline:
    # Create camera node
    # Build method without arguments will use the default camera
    rgb_cam = pipeline.create(dai.node.Camera).build()

    # Request NV12 stream with resolution of 1280x720 from the camera
    rgb_stream = rgb_cam.requestOutput(size=(1280, 720), type=dai.ImgFrame.Type.NV12)

    # Add camera stream as a topic to the Visualizer
    visualizer.addTopic("rgb", rgb_stream)

    # Build and start the pipeline
    pipeline.start()

    # Register the pipeline graph to be visualized in the Visualizer
    visualizer.registerPipeline(pipeline)

    # Main loop executed while the pipeline is running
    while pipeline.isRunning():
        # Check for key presses in the Visualizer
        if visualizer.waitKey(1) == ord('q'):
            # If 'q' is pressed, stop the pipeline
            pipeline.stop()
```

--------------------------------

### Install DepthAI Python Package and Clone Template App

Source: https://docs.luxonis.com/software-v3

This snippet shows how to install the DepthAI Python package and clone the template application repository. The `pip install depthai --force-reinstall` command ensures the latest version is installed, while cloning the template app provides a starting point for custom application development.

```bash
# Install core packages
pip install depthai --force-reinstall
# Clone the template app
git clone https://github.com/luxonis/oak-template.git
# Change directory to the template app
cd oak-template
# Install requirements
pip install -r requirements.txt
```

--------------------------------

### Run Model Conversion with Calibration using CLI

Source: https://docs.luxonis.com/software-v3/ai-inference/conversion/rvc-conversion/offline/modelconverter

This example demonstrates running a model conversion to RVC4 with quantization enabled. It specifies the NN Archive path and provides calibration data manually.

```bash
1modelconverter convert rvc4 --path archives/<nn_archive>.tar.xz \
2    calibration.path calibration_data/<calibration_data_dir>
```

--------------------------------

### Backend Service Build Steps (oakapp.toml)

Source: https://docs.luxonis.com/software-v3/oak-apps/base-image

Defines the build steps for registering and enabling the application's backend service. This involves creating necessary directories, copying the service's run script, and ensuring it has execute permissions. This script is crucial for starting the backend when the OAK app is launched.

```toml
1build_steps = [
2    "mkdir -p /etc/service/backend",
3    "cp /app/backend-run.sh /etc/service/backend/run",
4    "chmod +x /etc/service/backend/run",
]
```

--------------------------------

### Install DepthAI and DepthAI Nodes Libraries

Source: https://docs.luxonis.com/software-v3/ai-inference/inference

Installs the necessary DepthAI (v3) and DepthAI Nodes libraries using pip. These libraries are essential for creating inference pipelines and utilizing custom host nodes for model output decoding.

```bash
pip install depthai --force-reinstall
pip install depthai-nodes
```

--------------------------------

### Get Color Camera Sensor Crop - depthai

Source: https://docs.luxonis.com/software-v3/depthai/api/python

Retrieves the sensor crop coordinates for the top-left corner. This indicates the starting point of the sensor area being used.

```python
camera.getSensorCrop()
```

--------------------------------

### Get Color Camera Sensor Crop Y - depthai

Source: https://docs.luxonis.com/software-v3/depthai/api/python

Retrieves the sensor's top-left y-coordinate for cropping. This specifies the vertical starting point of the cropped sensor area.

```python
camera.getSensorCropY()
```

--------------------------------

### Display Calibration Help Information

Source: https://docs.luxonis.com/hardware/platform/depth/manual-calibration

This command displays detailed help information for the `calibrate.py` script, including all available arguments and usage examples. This is useful for understanding the various calibration options.

```bash
python3 calibrate.py --help
```

--------------------------------

### Generate WiFi Passphrase (Linux Command Line)

Source: https://docs.luxonis.com/hardware/rae/get-started

Command to generate a WPA passphrase for a given WiFi SSID. This passphrase is used in the wpa_supplicant configuration file.

```bash
wpa_passphrase <WIFI_SSID>
```

--------------------------------

### Get Device Information - Python

Source: https://docs.luxonis.com/software-v3/depthai/depthai-components/device

Retrieves and prints the DeviceID, USB speed, and connected cameras of the default Luxonis device. This requires the depthai library to be installed and a device to be connected.

```python
with dai.Pipeline() as pipeline:
    device = pipeline.getDefaultDevice()
    # Print DeviceID, USB speed, and available cameras on the device
    print('DeviceID:',device.getDeviceInfo().getDeviceId())
    print('USB speed:',device.getUsbSpeed())
    print('Connected cameras:',device.getConnectedCameras())
```

--------------------------------

### Get Color Camera Sensor Crop X - depthai

Source: https://docs.luxonis.com/software-v3/depthai/api/python

Retrieves the sensor's top-left x-coordinate for cropping. This specifies the horizontal starting point of the cropped sensor area.

```python
camera.getSensorCropX()
```

--------------------------------

### Include RealSense Driver Launch Description (Python)

Source: https://docs.luxonis.com/software-v3/depthai/ros/driver

This Python code snippet shows how to include the RealSense camera launch description. It utilizes `IncludeLaunchDescription` and `PythonLaunchDescriptionSource` to point to the `rs_launch.py` file within the `realsense2_camera` package. It also demonstrates enabling the pointcloud feature.

```python
rs_camera_launch_include = IncludeLaunchDescription(
  PythonLaunchDescriptionSource([
      PathJoinSubstitution([
          FindPackageShare('realsense2_camera'),
          'launch',
          'rs_launch.py',
      ])
  ]),
  launch_arguments={
      'pointcloud.enable': 'true',
  }.items()
)
```

--------------------------------

### RAE WiFi Access Point Credentials

Source: https://docs.luxonis.com/hardware/rae/get-started

Default WiFi credentials for the RAE robot's access point. Used to initially connect a device to the RAE for configuration.

```text
SSID: RAE-<ID>
Password: wifiwifi@
RAEs IP: 192.168.11.1
```

--------------------------------

### Get Source Inverse Intrinsic Matrix from ImgTransformation

Source: https://docs.luxonis.com/software-v3/depthai/api/python

Retrieves the inverse of the intrinsic camera matrix of the original source frame. This allows for coordinate transformations relative to the original camera setup.

```python
def getSourceIntrinsicMatrixInv(self) -> typing.Annotated[list[typing.Annotated[list[float], pybind11_stubgen.typing_ext.FixedSize(3)]], pybind11_stubgen.typing_ext.FixedSize(3)]: typing.Annotated[list[typing.Annotated[list[float], pybind11_stubgen.typing_ext.FixedSize(3)]], pybind11_stubgen.typing_ext.FixedSize(3)]
```

--------------------------------

### Initialize Host Script for Connecting to Camera TCP Server (Python)

Source: https://docs.luxonis.com/software-v3/depthai/tutorials/standalone

This Python script is designed to run on a host computer to connect to the Luxonis device's TCP server. It imports necessary libraries for socket communication, regular expressions, image processing (OpenCV), and numerical operations (NumPy). It includes a placeholder for the camera's IP address, which needs to be configured by the user.

```Python
import socket
import re
import cv2
import numpy as np

# Enter your own IP! After you run oak.py script, it will print the IP in the terminal
OAK_IP = "10.12.101.188"

```

--------------------------------

### RAE USB-C SSH Connection Details

Source: https://docs.luxonis.com/hardware/rae/get-started

Credentials and IP address for connecting to the RAE robot via SSH over a USB-C connection. This method allows direct command-line access.

```text
root@192.168.197.55 (no password is required)
RAEs IP: 192.168.197.55
```

--------------------------------

### Deploy Generic Neural Network App with oakctl

Source: https://docs.luxonis.com/software-v3

This sequence of commands demonstrates how to deploy a generic neural network application using the oakctl CLI. It involves connecting to the device, cloning the example repository, navigating to the app directory, and running the application. This is a quick way to test pre-made applications.

```bash
# Connect to the device
oakctl connect
# Clone the repo
git clone --depth 1 --branch main https://github.com/luxonis/oak-examples.git
# Change directory to the generic-example
cd oak-examples/neural-networks/generic-example/
# Run the app and follow instructions to open the web viewer
oakctl app run .
```

--------------------------------

### Access RAE Local Web Interface

Source: https://docs.luxonis.com/hardware/rae/get-started

URL format for accessing the RAE robot's local web interface. This requires knowing the RAE's IP address on the network.

```text
https://<IP of RAE>:9010
```

--------------------------------

### Get Stereo Left Camera ID (Python)

Source: https://docs.luxonis.com/software-v3/depthai/api/python

Returns the camera ID of the camera designated as the 'left' camera in a stereo vision setup. This is crucial for configuring stereo calibration and depth perception algorithms.

```python
def getStereoLeftCameraId(self) -> 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
    """
    pass
```

--------------------------------

### Retrieve Input Frame and Model Output (Python)

Source: https://docs.luxonis.com/software-v3/ai-inference/inference

Retrieves the input frame and parsed model outputs from their respective queues after the pipeline has started. This code demonstrates how to access and process the data streams.

```python
1while pipeline.isRunning():
2
3    # Get Camera Output
4    frame_queue_output = frame_queue.get()
5    frame = frame_queue_output.getCvFrame()
6    ...
7
8    # Get Parsed Output(s)
9    parser_output = parser_output_queue.get()
10    ...

```

--------------------------------

### Launch Camera in Basic RGBD Configuration (Python)

Source: https://docs.luxonis.com/software-v3/depthai/ros/driver

Launches the camera in a basic RGBD configuration without loading any Neural Networks. It also loads ROS depth processing nodes for RGBD pointcloud. Configured via `rgbd_pcl.launch.py`.

```python
rgbd_pcl.launch.py
```

--------------------------------

### Get Stereo Left Rectification Rotation

Source: https://docs.luxonis.com/software-v3/depthai/api/python

Retrieves the 3x3 rectification rotation matrix for the left camera in a stereo setup. This is crucial for aligning stereo camera views for accurate depth perception and feature matching.

```python
getStereoLeftRectificationRotation(self) -> list[list[float]]
```

--------------------------------

### Accessing NNData Layers and Tensor Information

Source: https://docs.luxonis.com/software-v3/depthai/depthai-components/messages/nn_data

Provides C++ code examples for retrieving information about layers and tensors within an NNData message. This includes getting layer names, tensor details, datatypes, and checking for layer existence.

```cpp
#include <depthai/depthai.hpp>
#include <vector>
#include <string>
#include <iostream>

// Assume 'receivedNNData' is an NNData object received from a device or created on the host
// Example placeholder for receivedNNData
dai::NNData receivedNNData;

// Get all layer names
std::vector<std::string> layerNames = receivedNNData.getAllLayerNames();
std::cout << "Layer names:" << std::endl;
for (const auto& name : layerNames) {
    std::cout << "- " << name << std::endl;
}

// Check if a specific layer exists
std::string targetLayer = "my_layer";
if (receivedNNData.hasLayer(targetLayer)) {
    std::cout << "Layer '" << targetLayer << "' exists." << std::endl;

    // Get tensor information for a specific layer
    std::optional<dai::TensorInfo> tensorInfoOpt = receivedNNData.getTensorInfo(targetLayer);
    if (tensorInfoOpt) {
        dai::TensorInfo info = *tensorInfoOpt;
        std::cout << "Info for '" << targetLayer << "':" << std::endl;
        std::cout << "  Name: " << info.name << std::endl;
        std::cout << "  Dimensions: " << info.dims.size() << " dimensions" << std::endl;
        std::cout << "  DataType: " << static_cast<int>(info.dataType) << std::endl; // Cast to int for display
    }

    // Get the datatype of the layer's tensor
    dai::TensorInfo::DataType dataType;
    if (receivedNNData.getLayerDatatype(targetLayer, dataType)) {
        std::cout << "Datatype for '" << targetLayer << "': " << static_cast<int>(dataType) << std::endl;
    }
} else {
    std::cout << "Layer '" << targetLayer << "' does not exist." << std::endl;
}

// Get the datatype of the first tensor in the message
dai::TensorInfo::DataType firstTensorDataType = receivedNNData.getFirstTensorDatatype();
std::cout << "Datatype of the first tensor: " << static_cast<int>(firstTensorDataType) << std::endl;

```

--------------------------------

### Run App with oakctl (Shell)

Source: https://docs.luxonis.com/software-v3/oak-apps/apikey-good-practices

Illustrates how to run an application using the 'oakctl' command-line tool. This command can deploy apps to the camera and ensures that the .env file is copied over to the App environment.

```bash
1oakctl app run .
```

--------------------------------

### Get Stereo Right Rectification Rotation

Source: https://docs.luxonis.com/software-v3/depthai/api/python

Retrieves the 3x3 rectification rotation matrix for the right camera in a stereo setup. This matrix is used to align the right camera's view with the left camera for accurate stereo processing.

```python
getStereoRightRectificationRotation(self) -> list[list[float]]
```

--------------------------------

### Initialize and Configure Feature Tracker (Python)

Source: https://docs.luxonis.com/software-v3/depthai/examples/feature_tracker/feature_tracker

This snippet shows the initialization and configuration of the DepthAI feature tracker. It involves setting corner detector parameters like `numMaxFeatures` and `harrisScore`, and optionally enabling/disabling motion estimation. The configuration is then sent to the device.

```python
cornerDetector = dai.FeatureTrackerConfig.CornerDetector()
cornerDetector.numMaxFeatures = cv2.getTrackbarPos('numMaxFeatures', 'Features')
cornerDetector.numTargetFeatures = cornerDetector.numMaxFeatures

thresholds = dai.FeatureTrackerConfig.CornerDetector.Thresholds()
thresholds.initialValue = cv2.getTrackbarPos('harrisScore','Features')
cornerDetector.thresholds = thresholds

cfg = dai.FeatureTrackerConfig()
cfg.setCornerDetector(cornerDetector)
cfg.setMotionEstimator(motionEstimator)

if motionEstimator.enable == False:
    motionEstimator.enable = True
    cfg.setMotionEstimator(motionEstimator)
    print("Enabling motionEstimator")
else:
    motionEstimator.enable = False
    cfg.setMotionEstimator(motionEstimator)
    print("Disabling motionEstimator")

inputConfigQueue.send(cfg)
```

--------------------------------

### Runtime Error for Incorrect SHAVE Count (Command Line)

Source: https://docs.luxonis.com/software-v3/ai-inference/inference

Example of a RuntimeError indicating that a neural network blob was compiled for a different number of SHAVEs than available on the device. This typically occurs on older devices like OAK-D Lite.

```bash
1NeuralNetwork: Blob compiled for ... shaves, but only ... are available in current configuration
```

--------------------------------

### Setup Linux udev Rules for Movidius Devices

Source: https://docs.luxonis.com/hardware/platform/deploy/usb-deployment-guide

This snippet configures udev rules on Linux systems to grant necessary permissions for Movidius USB devices. It ensures that the DepthAI library can properly access and communicate with the OAK camera.

```bash
echo 'SUBSYSTEM=="usb", ATTRS{idVendor}=="03e7", MODE="0666"' | sudo tee /etc/udev/rules.d/80-movidius.rules
sudo udevadm control --reload-rules && sudo udevadm trigger
```

--------------------------------

### Configure Local Docker Registry and Build

Source: https://docs.luxonis.com/software-v3/oak-apps/configuration

Commands to set up and use a local Docker registry for building and pushing images. Includes running a registry container, disabling TLS, creating a buildx driver, and building a multi-platform image.

```bash
docker run -d -p 5000:5000 --name zot ghcr.io/project-zot/zot-linux-amd64:latest

# Only for local testing with insecure registry
regctl registry set --tls=disabled localhost:5000
docker buildx create --use --driver docker-container --driver-opt network=host

# Create a simple base image
echo "FROM debian:bookworm-slim" > ./Dockerfile

# set IP address of your local registry if not running on localhost
docker buildx build -f ./Dockerfile --platform=linux/arm64 -t 127.0.0.1:5000/my-base:local --push .
```

--------------------------------

### Enable Factory Mode

Source: https://docs.luxonis.com/hardware/platform/deploy/oak4-som-development-guide

Enables factory mode on Luxonis OS by creating a file named `enabled` under the `/persist/factory/` directory. This mode removes the root password and allows SSH login without a password, simplifying device setup in a factory environment.

```bash
touch /persist/factory/enabled
```
Tokens:
Raw