此页面由 AI 自动翻译。查看英文原版
DepthAI
  • DepthAI 组件
    • AprilTags
    • 基准测试
    • 相机
    • 校准
    • 深度
    • 检测网络
    • 事件
    • 特征跟踪器
    • 网关
    • 主机节点
    • 图像对齐
    • 图像处理
    • IMU
    • 杂项
    • 模型库
    • 神经深度
    • 神经网络
    • 对象跟踪器
    • 点云
    • 记录回放
    • RGBD
    • 脚本
    • 空间检测网络
    • 空间位置计算器
    • 立体深度
    • 同步
    • ToF
    • 视频编码器
    • 可视化工具
    • VSLAM
    • 扭曲
    • RVC2-特定
  • 高级教程
  • API 参考
  • 工具
软件栈
最后更新

本页目录

  • 演示
  • 源代码
Claude CodeCodexCursor
Luxonis 智能体工具包为你常用的编程智能体加载 Luxonis 上下文与技能,更快地基于 OAK 开发应用。
安装工具包
最后更新
Supported on:RVC2RVC4
此示例使用 ImageAlign 节点将 ToF 深度对齐到左侧或右侧单目摄像头(可通过 --camera left/--camera right 选择),并显示一个可调节 RGB/深度混合轨迹条的混合叠加层。

演示

ToF 对齐演示
此示例需要 DepthAI v3 API,请参阅 安装说明。

源代码

Python

Python
GitHub
1#!/usr/bin/env python3
2"""Align ToF depth over left or right camera and show a blended overlay.
3
4Usage:
5    python tof_align.py --camera left
6    python tof_align.py --camera right
7"""
8
9import argparse
10from datetime import timedelta
11
12import cv2
13import depthai as dai
14
15
16FPS = 30.0
17CAMERA_SIZE = (640, 400)
18
19MIN_DEPTH = 100.0
20MAX_DEPTH = 7000.0
21
22rgbWeight = 0.5
23depthWeight = 0.5
24
25
26def updateBlendWeights(percentRgb):
27    global rgbWeight, depthWeight
28    rgbWeight = float(percentRgb) / 100.0
29    depthWeight = 1.0 - rgbWeight
30
31
32def main():
33    parser = argparse.ArgumentParser(description="ToF depth overlay on left or right camera")
34    parser.add_argument(
35        "--camera",
36        choices=["left", "right"],
37        default="left",
38        help="Camera to align depth onto: left=CAM_B, right=CAM_C (default: left)",
39    )
40    args = parser.parse_args()
41
42    pipeline = dai.Pipeline()
43
44    camera_sockets = {
45        "left": dai.CameraBoardSocket.CAM_B,
46        "right": dai.CameraBoardSocket.CAM_C,
47    }
48
49    align_socket = camera_sockets[args.camera]
50    print(f"Aligning ToF depth over {args.camera} camera ({align_socket})")
51
52    tof = pipeline.create(dai.node.ToF)
53    tof.build(
54        boardSocket=dai.CameraBoardSocket.AUTO,
55        profile=dai.ToFConfig.Profile.MID_RANGE,
56        fps=FPS,
57    )
58
59    cam = pipeline.create(dai.node.Camera).build(align_socket)
60    camOut = cam.requestOutput(CAMERA_SIZE, enableUndistortion=True, fps=FPS)
61
62    align = pipeline.create(dai.node.ImageAlign)
63    align.setRunOnHost(True)
64    tof.depth.link(align.input)
65    camOut.link(align.inputAlignTo)
66
67    sync = pipeline.create(dai.node.Sync)
68    sync.setSyncThreshold(timedelta(seconds=0.5 / FPS))
69    sync.setRunOnHost(True)
70    camOut.link(sync.inputs["rgb"])
71    align.outputAligned.link(sync.inputs["depth_aligned"])
72    sync.inputs["rgb"].setBlocking(False)
73
74    syncQueue = sync.out.createOutputQueue()
75
76    window_blend = f"tof-overlay-{args.camera}"
77    window_depth = "depth-aligned"
78
79    with pipeline as p:
80        p.start()
81        cv2.namedWindow(window_blend)
82        cv2.namedWindow(window_depth)
83        cv2.createTrackbar("RGB Weight %", window_blend, int(rgbWeight * 100), 100, updateBlendWeights)
84
85        while p.isRunning():
86            msgGroup = syncQueue.get()
87            assert isinstance(msgGroup, dai.MessageGroup)
88
89            frameRgb = msgGroup["rgb"]
90            frameDepth = msgGroup["depth_aligned"]
91
92            cvFrame = frameRgb.getCvFrame()
93            if len(cvFrame.shape) == 2:
94                cvFrame = cv2.cvtColor(cvFrame, cv2.COLOR_GRAY2BGR)
95
96            depthColorized = dai.utility.colorizeDepthFrame(frameDepth, MIN_DEPTH, MAX_DEPTH, useLog=True).getCvFrame()
97            if depthColorized.shape[:2] != cvFrame.shape[:2]:
98                depthColorized = cv2.resize(
99                    depthColorized, (cvFrame.shape[1], cvFrame.shape[0])
100                )
101
102            cv2.imshow(window_depth, depthColorized)
103
104            blended = cv2.addWeighted(cvFrame, rgbWeight, depthColorized, depthWeight, 0)
105            cv2.imshow(window_blend, blended)
106
107            if cv2.waitKey(1) == ord("q"):
108                break
109
110
111if __name__ == "__main__":
112    main()

C++

1#include <argparse/argparse.hpp>
2#include <chrono>
3#include <iostream>
4#include <opencv2/opencv.hpp>
5#include <string>
6
7#include "depthai/depthai.hpp"
8
9constexpr float FPS = 30.0f;
10const cv::Size CAMERA_SIZE(640, 400);
11
12constexpr float MIN_DEPTH = 100.0f;
13constexpr float MAX_DEPTH = 7000.0f;
14float rgbWeight = 0.5f;
15float depthWeight = 0.5f;
16
17void updateBlendWeights(int percentRgb, void*) {
18    rgbWeight = static_cast<float>(percentRgb) / 100.0f;
19    depthWeight = 1.0f - rgbWeight;
20}
21
22int main(int argc, char** argv) {
23    argparse::ArgumentParser program("tof_align");
24    program.add_description("Align ToF depth over left or right camera and show a blended overlay.");
25    program.add_argument("--camera")
26        .default_value(std::string("left"))
27        .choices("left", "right")
28        .help("Camera to align depth onto: left=CAM_B, right=CAM_C (default: left)");
29
30    try {
31        program.parse_args(argc, argv);
32    } catch(const std::runtime_error& err) {
33        std::cerr << err.what() << '\n';
34        std::cerr << program;
35        return EXIT_FAILURE;
36    }
37
38    const std::string cameraArg = program.get<std::string>("--camera");
39    const dai::CameraBoardSocket alignSocket = (cameraArg == "right") ? dai::CameraBoardSocket::CAM_C : dai::CameraBoardSocket::CAM_B;
40    std::cout << "Aligning ToF depth over " << cameraArg << " camera\n";
41
42    dai::Pipeline pipeline;
43
44    auto tof = pipeline.create<dai::node::ToF>();
45    tof->build(dai::CameraBoardSocket::AUTO, dai::ToFConfig::Profile::MID_RANGE, FPS);
46
47    auto cam = pipeline.create<dai::node::Camera>()->build(alignSocket);
48    auto camOut = cam->requestOutput(std::make_pair(CAMERA_SIZE.width, CAMERA_SIZE.height), std::nullopt, dai::ImgResizeMode::CROP, FPS, true);
49
50    auto align = pipeline.create<dai::node::ImageAlign>();
51    align->setRunOnHost(true);
52    tof->depth.link(align->input);
53    camOut->link(align->inputAlignTo);
54
55    auto sync = pipeline.create<dai::node::Sync>();
56    sync->setSyncThreshold(std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::duration<double>(0.5 / FPS)));
57    sync->setRunOnHost(true);
58    camOut->link(sync->inputs["rgb"]);
59    align->outputAligned.link(sync->inputs["depth_aligned"]);
60    sync->inputs["rgb"].setBlocking(false);
61
62    auto syncQueue = sync->out.createOutputQueue();
63
64    const std::string windowBlend = "tof-overlay-" + cameraArg;
65    const std::string windowDepth = "depth-aligned";
66
67    pipeline.start();
68    cv::namedWindow(windowBlend);
69    cv::namedWindow(windowDepth);
70    cv::createTrackbar("RGB Weight %", windowBlend, nullptr, 100, updateBlendWeights);
71    cv::setTrackbarPos("RGB Weight %", windowBlend, static_cast<int>(rgbWeight * 100));
72
73    while(pipeline.isRunning()) {
74        auto messageGroup = syncQueue->get<dai::MessageGroup>();
75        if(messageGroup == nullptr) continue;
76
77        auto frameRgb = messageGroup->get<dai::ImgFrame>("rgb");
78        auto frameDepth = messageGroup->get<dai::ImgFrame>("depth_aligned");
79
80        cv::Mat cvFrame = frameRgb->getCvFrame();
81        if(cvFrame.channels() == 1) {
82            cv::cvtColor(cvFrame, cvFrame, cv::COLOR_GRAY2BGR);
83        }
84
85        cv::Mat depthColorized = dai::utility::colorizeDepthFrame(*frameDepth, MIN_DEPTH, MAX_DEPTH, cv::COLORMAP_JET, true).getCvFrame();
86        if(depthColorized.size() != cvFrame.size()) {
87            cv::resize(depthColorized, depthColorized, cvFrame.size());
88        }
89
90        cv::imshow(windowDepth, depthColorized);
91
92        cv::Mat blended;
93        cv::addWeighted(cvFrame, rgbWeight, depthColorized, depthWeight, 0, blended);
94        cv::imshow(windowBlend, blended);
95
96        if(cv::waitKey(1) == 'q') {
97            break;
98        }
99    }
100
101    return 0;
102}

需要帮助?

请访问讨论论坛以获取技术支持或您可能有的任何其他问题。