AZURE KINECT 采集rgbd序列

最新推荐文章于 2023-05-18 18:27:36 发布
最新推荐文章于 2023-05-18 18:27:36 发布
阅读量467 收藏 4
点赞数 1
分类专栏： 相机 视觉 文章标签： azure opencv 计算机视觉
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39849839/article/details/128240600
版权

参考了官方的去畸变以及采集代码

// C++
#include <iostream>
#include <chrono>
#include <string>
// OpenCV
#include <opencv2/opencv.hpp>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
// Kinect DK
#include <k4a/k4a.hpp>
#include "undistort.hpp"
using namespace cv;
using namespace std;

// 宏
// 方便控制是否 std::cout 信息
#define DEBUG_std_cout 0

static void calibration_blob(k4a_device_t& device, string filename = "calibration.txt")
{



    size_t calibration_size = 0;
    k4a_buffer_result_t buffer_result = k4a_device_get_raw_calibration(device, NULL, &calibration_size);
    if (buffer_result == K4A_BUFFER_RESULT_TOO_SMALL)
    {
        vector<uint8_t> calibration_buffer = vector<uint8_t>(calibration_size);
        buffer_result = k4a_device_get_raw_calibration(device, calibration_buffer.data(), &calibration_size);
        if (buffer_result == K4A_BUFFER_RESULT_SUCCEEDED)
        {
            ofstream file(filename, ofstream::binary);
            file.write(reinterpret_cast<const char *>(&calibration_buffer[0]), (long)calibration_size);
            file.close();
            cout << "Calibration blob for device " << " (serial no. "
                 << ") is saved to " << filename << endl;
        }
        else
        {
            cout << "Failed to get calibration blob" << endl;
            exit(-1);
        }
    }
    else
    {
        cout << "Failed to get calibration blob size" << endl;
        exit(-1);
    }
}

_k4a_calibration_camera_t print_calibration(k4a_device_t& device, k4a_device_configuration_t& deviceConfig)
{


    k4a_calibration_t calibration;

    // get calibration
    if (K4A_RESULT_SUCCEEDED !=
        k4a_device_get_calibration(device, deviceConfig.depth_mode, deviceConfig.color_resolution, &calibration))
    {
        cout << "Failed to get calibration" << endl;
        exit(-1);
    }

//    auto calib = calibration.depth_camera_calibration;
    auto calib = calibration.color_camera_calibration;

    cout << "resolution width: " << calib.resolution_width << endl;
    cout << "resolution height: " << calib.resolution_height << endl;
    cout << "principal point x: " << calib.intrinsics.parameters.param.cx << endl;
    cout << "principal point y: " << calib.intrinsics.parameters.param.cy << endl;
    cout << "focal length x: " << calib.intrinsics.parameters.param.fx << endl;
    cout << "focal length y: " << calib.intrinsics.parameters.param.fy << endl;
    cout << "radial distortion coefficients:" << endl;
    cout << "k1: " << calib.intrinsics.parameters.param.k1 << endl;
    cout << "k2: " << calib.intrinsics.parameters.param.k2 << endl;
    cout << "k3: " << calib.intrinsics.parameters.param.k3 << endl;
    cout << "k4: " << calib.intrinsics.parameters.param.k4 << endl;
    cout << "k5: " << calib.intrinsics.parameters.param.k5 << endl;
    cout << "k6: " << calib.intrinsics.parameters.param.k6 << endl;
    cout << "center of distortion in Z=1 plane, x: " << calib.intrinsics.parameters.param.codx << endl;
    cout << "center of distortion in Z=1 plane, y: " << calib.intrinsics.parameters.param.cody << endl;
    cout << "tangential distortion coefficient x: " << calib.intrinsics.parameters.param.p1 << endl;
    cout << "tangential distortion coefficient y: " << calib.intrinsics.parameters.param.p2 << endl;
    cout << "metric radius: " << calib.intrinsics.parameters.param.metric_radius << endl;
    return calib;
}

cv::Mat undistorted(cv::Mat &image, _k4a_calibration_camera_t calib) {
    float cx = calib.intrinsics.parameters.param.cx;
    float cy = calib.intrinsics.parameters.param.cy;
    float fx = calib.intrinsics.parameters.param.fx;
    float fy = calib.intrinsics.parameters.param.fy;
    float k1 = calib.intrinsics.parameters.param.k1;
    float k2 = calib.intrinsics.parameters.param.k2;
    float k3 = calib.intrinsics.parameters.param.k3;
    float k4 = calib.intrinsics.parameters.param.k4;
    float k5 = calib.intrinsics.parameters.param.k5;
    float k6 = calib.intrinsics.parameters.param.k6;
    float codx = calib.intrinsics.parameters.param.codx; // center of distortion is set to 0 for Brown Conrady model
    float cody = calib.intrinsics.parameters.param.cody;
    float p1 = calib.intrinsics.parameters.param.p1;
    float p2 = calib.intrinsics.parameters.param.p2;
    cv::Mat K = (cv::Mat_<double>(3, 3) << fx, 0.0, cx, 0.0, fy, cy, 0.0, 0.0, 1.0);
    cv::Mat newK;
    const cv::Mat D = (cv::Mat_<double>(8, 1) << k1, k2, p1, p2, k3, k4, k5, k6);
//    k1,k2,p1,p2[,k3,[,k4,k5,k6]]

//    cv::Mat K = (cv::Mat_<double>(3, 3) << 6.2053103020797198e+02, 0.0, 6.3205198180998377e+02
//            , 0.0, 6.1656865116870870e+02, 3.5016213113500675e+02, 0.0, 0.0, 1.0);
//    cv::Mat newK;
//    const cv::Mat D = (cv::Mat_<double>(5, 1) << 6.8597090884417358e-02
//            , -2.1407702890670174e-02, -6.8662708745400904e-03, -1.4302754640278781e-03, -5.3270781408391145e-03);

    cv::Mat UndistortImage;
    cv::undistort(image, UndistortImage, K, D, newK);
//    cout<<K<<newK<<endl;
//    cv::Mat map1, map2;
//    const double alpha = 1;
//    cv::Mat NewCameraMatrix = getOptimalNewCameraMatrix(K, D, imageSize, alpha, imageSize, 0);
//    initUndistortRectifyMap(K, D, cv::Mat(), NewCameraMatrix, imageSize, CV_16SC2, map1, map2);
//    cv::Mat UndistortImage;
//    cv::remap(image, UndistortImage, map1, map2, cv::INTER_LINEAR);
    return UndistortImage;
}




int main(int argc, char *argv[]) {
    /*
        找到并打开 Azure Kinect 设备
    */
    // 发现已连接的设备数

    const uint32_t device_count = k4a::device::get_installed_count();
    if (0 == device_count) {
        std::cout << "Error: no K4A devices found. " << std::endl;
        return -1;
    } else {
        std::cout << "Found " << device_count << " connected devices. " << std::endl;


        if (1 != device_count)// 超过1个设备，也输出错误信息。
        {
            std::cout << "Error: more than one K4A devices found. " << std::endl;
            return -1;
        } else// 该示例代码仅限对1个设备操作
        {
            std::cout << "Done: found 1 K4A device. " << std::endl;
        }
    }
    // 打开（默认）设备
    k4a_device_t device_t = NULL;
    if (K4A_RESULT_SUCCEEDED != k4a_device_open(0, &device_t))
    {
        cout << ": Failed to open device" << endl;
        exit(-1);
    }
//    calibration_blob(device_t);



//    k4a::device device = k4a::device::open(K4A_DEVICE_DEFAULT);
    k4a::device device = k4a::device(device_t);
    std::cout << "Done: open device. " << std::endl;
    /*
        检索并保存 Azure Kinect 图像数据
    */
    // 配置并启动设备
    k4a_device_configuration_t config = K4A_DEVICE_CONFIG_INIT_DISABLE_ALL;
    config.camera_fps = K4A_FRAMES_PER_SECOND_15;
    config.color_format = K4A_IMAGE_FORMAT_COLOR_BGRA32;
    config.color_resolution = K4A_COLOR_RESOLUTION_720P;
    config.depth_mode = K4A_DEPTH_MODE_NFOV_UNBINNED;
//    config.depth_mode = K4A_DEPTH_MODE_NFOV_2X2BINNED;
    config.synchronized_images_only = true;// ensures that depth and color images are both available in the capture
    device.start_cameras(&config);
    std::cout << "Done: start camera." << std::endl;
//    auto calib=print_calibration(device_t,config);
    //写入txt文件流
    ofstream rgb_out;
    ofstream d_out;
    ofstream ir_out;

    rgb_out.open("./rgb.txt");
    d_out.open("./depth.txt");
    ir_out.open("./ir.txt");

    rgb_out<<"#  color images"<<endl;
    rgb_out<<"#  file: rgbd_dataset"<<endl;
    rgb_out<<"#  timestamp"<<"    "<<"filename"<<endl;

    d_out<<"#  depth images"<<endl;
    d_out<<"#  file: rgbd_dataset"<<endl;
    d_out<<"#  timestamp"<<"    "<<"filename"<<endl;

    ir_out<<"#  ir images"<<endl;
    ir_out<<"#  file: rgbd_dataset"<<endl;
    ir_out<<"#  timestamp"<<"    "<<"filename"<<endl;

    rgb_out<<flush;
    d_out<<flush;
    // 稳定化
    k4a::capture capture;
    int iAuto = 0;//用来稳定，类似自动曝光
    int iAutoError = 0;// 统计自动曝光的失败次数
    while (true) {
        if (device.get_capture(&capture)) {
            std::cout << iAuto << ". Capture several frames to give auto-exposure" << std::endl;

            // 跳过前 n 个（成功的数据采集）循环，用来稳定
            if (iAuto != 30) {
                iAuto++;
                continue;
            } else {
                std::cout << "Done: auto-exposure" << std::endl;
                break;// 跳出该循环，完成相机的稳定过程
            }

        } else {
            std::cout << iAutoError << ". K4A_WAIT_RESULT_TIMEOUT." << std::endl;
            if (iAutoError != 30) {
                iAutoError++;
                continue;
            } else {
                std::cout << "Error: failed to give auto-exposure. " << std::endl;
                return -1;
            }
        }
    }
    std::cout << "-----------------------------------" << std::endl;
    std::cout << "----- Have Started Kinect DK. -----" << std::endl;
    std::cout << "-----------------------------------" << std::endl;
    // 从设备获取捕获
    k4a::image rgbImage;
    k4a::image depthImage;
    k4a::image irImage;
    k4a::image transformed_rgbImage;

    cv::Mat cv_rgbImage_with_alpha;
    cv::Mat cv_rgbImage_no_alpha;
    cv::Mat cv_depth;
    cv::Mat cv_depth_8U;
    cv::Mat cv_irImage;
    cv::Mat cv_irImage_8U;
    k4a_image_t lut = NULL;
    k4a_image_t undistorted_rgb = NULL;
    k4a_image_t undistorted_depth = NULL;
    interpolation_t interpolation_type = INTERPOLATION_NEARESTNEIGHBOR;
    k4a::calibration k4aCalibration = device.get_calibration(config.depth_mode, config.color_resolution);// Get the camera calibration for the entire K4A device, which is used for all transformation functions.
    k4a::transformation k4aTransformation = k4a::transformation(k4aCalibration);
    pinhole_t pinhole;
    pinhole = create_pinhole_from_xy_range(&k4aCalibration, K4A_CALIBRATION_TYPE_COLOR);

    cout << "resolution width: " << pinhole.width << endl;
    cout << "resolution height: " << pinhole.height << endl;
    cout << "principal point x: " << pinhole.px << endl;
    cout << "principal point y: " << pinhole.py << endl;
    cout << "focal length x: " << pinhole.fx << endl;
    cout << "focal length y: " << pinhole.fy << endl;
    
    
    
    int count=0;
    while (true)
        // for (size_t i = 0; i < 100; i++)
    {
        // if (device.get_capture(&capture, std::chrono::milliseconds(0)))
        if (device.get_capture(&capture)) {
            // rgb
            // * Each pixel of BGRA32 data is four bytes. The first three bytes represent Blue, Green,
            // * and Red data. The fourth byte is the alpha channel and is unused in the Azure Kinect APIs.
            rgbImage = capture.get_color_image();
#if DEBUG_std_cout == 1
            std::cout << "[rgb] " << "\n"
                << "format: " << rgbImage.get_format() << "\n"
                << "device_timestamp: " << rgbImage.get_device_timestamp().count() << "\n"
                << "system_timestamp: " << rgbImage.get_system_timestamp().count() << "\n"
                << "height*width: " << rgbImage.get_height_pixels() << ", " << rgbImage.get_width_pixels()
                << std::endl;
#endif

            // depth
            // * Each pixel of DEPTH16 data is two bytes of little endian unsigned depth data. The unit of the data is in
            // * millimeters from the origin of the camera.
            depthImage = capture.get_depth_image();
#if DEBUG_std_cout == 1
            std::cout << "[depth] " << "\n"
                << "format: " << depthImage.get_format() << "\n"
                << "device_timestamp: " << depthImage.get_device_timestamp().count() << "\n"
                << "system_timestamp: " << depthImage.get_system_timestamp().count() << "\n"
                << "height*width: " << depthImage.get_height_pixels() << ", " << depthImage.get_width_pixels()
                << std::endl;
#endif

            // ir
            // * Each pixel of IR16 data is two bytes of little endian unsigned depth data. The value of the data represents
            // * brightness.
            irImage = capture.get_ir_image();
#if DEBUG_std_cout == 1
            std::cout << "[ir] " << "\n"
                << "format: " << irImage.get_format() << "\n"
                << "device_timestamp: " << irImage.get_device_timestamp().count() << "\n"
                << "system_timestamp: " << irImage.get_system_timestamp().count() << "\n"
                << "height*width: " << irImage.get_height_pixels() << ", " << irImage.get_width_pixels()
                << std::endl;
#endif
            //深度图和RGB图配准

            auto transformed_depthImage=k4aTransformation.depth_image_to_color_camera(depthImage);
            cv_irImage = cv::Mat(irImage.get_height_pixels(), irImage.get_width_pixels(), CV_16U,
                                 (void *) irImage.get_buffer(), static_cast<size_t>(irImage.get_stride_bytes()));
            cv_irImage.convertTo(cv_irImage_8U, CV_8U, 1);
            k4a_image_create(K4A_IMAGE_FORMAT_CUSTOM,
                             pinhole.width,
                             pinhole.height,
                             pinhole.width * (int)sizeof(coordinate_t),
                             &lut);

            create_undistortion_lut(&k4aCalibration, K4A_CALIBRATION_TYPE_COLOR, &pinhole, lut, interpolation_type);

            k4a_image_create(K4A_IMAGE_FORMAT_DEPTH16,
                             pinhole.width,
                             pinhole.height,
                             pinhole.width * (int)sizeof(uint16_t),
                             &undistorted_depth);
            k4a_image_create(K4A_IMAGE_FORMAT_COLOR_BGRA32,
                             pinhole.width,
                             pinhole.height,
                             pinhole.width * (int)sizeof(uint32_t),
                             &undistorted_rgb);
            remap_BGRA(rgbImage.handle(), lut, undistorted_rgb);
            remap(transformed_depthImage.handle(), lut, undistorted_depth, interpolation_type);

            transformed_depthImage=k4a::image(undistorted_depth);
            rgbImage=k4a::image(undistorted_rgb);
            cv_depth = cv::Mat(transformed_depthImage.get_height_pixels(), transformed_depthImage.get_width_pixels(), CV_16U,
                               (void *) transformed_depthImage.get_buffer(), static_cast<size_t>(transformed_depthImage.get_stride_bytes()));
//            cv_depth= cv::Mat(depthImage.get_height_pixels(), depthImage.get_width_pixels(), CV_16U,
//                               (void *) depthImage.get_buffer(), static_cast<size_t>(depthImage.get_stride_bytes()));
            cv_rgbImage_with_alpha = cv::Mat(rgbImage.get_height_pixels(), rgbImage.get_width_pixels(), CV_8UC4,
                                             (void *) rgbImage.get_buffer());
            cv::cvtColor(cv_rgbImage_with_alpha, cv_rgbImage_no_alpha, cv::COLOR_BGRA2BGR);
            cv_depth.convertTo(cv_depth_8U, CV_8U, 1);




//            auto cv_undistorted_rgb= undistorted(cv_rgbImage_no_alpha,calib);
//            auto cv_undistorted_depth= undistorted(cv_depth,calib);
//            auto cv_undistorted_rgb= cv_rgbImage_no_alpha;
//            auto cv_undistorted_depth= cv_depth;

            // show image
//            cv::imshow("color", cv_rgbImage_no_alpha);
//            cv::imshow("depth", cv_depth_8U);
//            cv::imshow("ir", cv_irImage_8U);
            // save image
            double time_rgb = static_cast<double >(std::chrono::duration_cast<std::chrono::microseconds>(
                    rgbImage.get_device_timestamp()).count());
            auto prefix=std::to_string(count);
            std::string filename_rgb = prefix+".png";
            double time_d = static_cast<double >(std::chrono::duration_cast<std::chrono::microseconds>(
                    depthImage.get_device_timestamp()).count());

            std::string filename_d_8u = prefix+"_8u.png";
            std::string filename_d = prefix+".png";

            double time_ir = static_cast<double >(std::chrono::duration_cast<std::chrono::microseconds>(
                    irImage.get_device_timestamp()).count());
            std::string filename_ir = prefix+".png";
            imwrite("./rgb/"+filename_rgb, cv_rgbImage_no_alpha);
            imwrite("./depth/"+filename_d, cv_depth);
            imwrite("./depth/"+filename_d_8u,cv_depth_8U);
//            imwrite("./ir/"+filename_ir, cv_irImage_8U);

            std::cout<<"Acquiring!"<<endl;

            //写入depth.txt,rgb.txt文件
            rgb_out<<std::to_string(time_rgb/1000000)<<"    "<<"rgb/"<<filename_rgb<<endl;
            d_out<<std::to_string(time_d/1000000)<<"    "<<"depth/"<<filename_d<<endl;
            ir_out<<std::to_string(time_ir/1000000)<<"    "<<"ir/"<<filename_ir<<endl;

            rgb_out<<flush;
            d_out<<flush;
            ir_out<<flush;
            cv_rgbImage_with_alpha.release();
            cv_rgbImage_no_alpha.release();
            cv_depth.release();
            cv_depth_8U.release();
            cv_irImage.release();
            cv_irImage_8U.release();

            capture.reset();
            count+=1;
            //if (cv::waitKey(0) == 'q') {//按键采集，用户按下'q',跳出循环,结束采集
            //  std::cout << "----------------------------------" << std::endl;
            //   std::cout << "------------- closed -------------" << std::endl;
            //  std::cout << "----------------------------------" << std::endl;
            // break;
            // }
        } else {
            std::cout << "false: K4A_WAIT_RESULT_TIMEOUT." << std::endl;
        }
    }
    cv::destroyAllWindows();
    rgb_out<<flush;
    d_out<<flush;
    ir_out<<flush;
    rgb_out.close();
    d_out.close();
    ir_out.close();

    // 释放，关闭设备
    rgbImage.reset();
    depthImage.reset();
    irImage.reset();
    capture.reset();
    device.close();

    return 1;
}
curry dog
关注
专栏目录
论文笔记_S2D.55_2019_SLAM综述_Huang B. A Survey of Simultaneous Localization and Mapping
惊鸿一博
12-12 1727
目录 基本情况 前言 一、概述 二、Lidar SLAM 激光雷达传感器 激光雷达SLAM系统（Lidar SLAM System） 2D SLAM 3D SLAM 深度学习与激光雷达 挑战与未来 成本和适应性 弱纹理和动态环境 敌对的传感器攻击 三、Visual SLAM 视觉传感器 视觉SLAM系统（Visual SLAM System） 稀疏视觉SLAM 半稠密视觉SLAM 稠密视觉SLAM 视觉惯性里程计SLAM 深度学习与视觉SLAM 挑战与未来 雷达
SLAM综述(2)-视觉SLAM
点云PCL
05-08 846
SLAM包含了两个主要的任务：定位与构图，在移动机器人或者自动驾驶中，这是一个十分重要的问题：机器人要精确的移动，就必须要有一个环境的地图，那么要构建环境的地图就需要知道机器人的位置。 本系列文章主要分成四个部分： 在第一部分中，将介绍Lidar SLAM，包括Lidar传感器，开源Lidar SLAM系统，Lidar中的深度学习以及挑战和未来。 第二部分重点介绍了Visual SLAM，包括相机传感器，不同稠密SLAM的开源视觉SLAM系统。 第三部分介绍视觉惯性里程法SLAM，视觉SLAM中的深度学习以
如何读取kinect生成的图像序列
zhongshan_c的专栏
11-11 3052
kinect图像序列名存储在文件 rgb.txt中，格式为 1305031102.175304 rgb/1305031102.175304.png 1305031102.211214 rgb/1305031102.211214.png 1305031102.243211 rgb/1305031102.243211.png 1305031102.275326 rgb/1305031102.2
Azure Kinect DK 点云和RGBD图的获取
weixin_41965898的博客
05-10 5317
Azure Kinect DK系列： Azure Kinect DK 深度相机sdk安装（Ubuntu+ARM64,Ubuntu+AMD64,Windows） Azure Kinect ROS Driver 安装 Azure Kinect DK 点云和RGBD图的获取 已在Ubuntu18.04上编译测试通过，需要自行装好opencv和pcl库。已将代码上传到github。 git clone https://github.com/luckyluckydad...
Azure Kinect DK 深度数据获取并使用opencv可视化
qq_40936780的博客
10-19 9538
Azure Kinect DK 深度数据获取 一.寻找设备 ，打开设备 我这里使用的是默认的参数，因为我只有一个相机。 二.设置好参数，打开相机 参数的设置要好好选择，因为极大程度的影响你后面使用的一些功效，通过查看官方的硬件文档，可以适当选取合适的参数，我们目前主要关心的应该是深度数据，并且深度数据还有工作范围，不处于正常工作范围内的，可能会导致深度信息检测不出来，我实验的时候太近了的时候，只能...
基于Kinect Azure的多相机数据采集（三）
GaryW666的博客
02-20 3744
基于Kinect Azure的多相机数据采集（三）     在基于Kinect Azure的多相机数据采集（一）和基于Kinect Azure的多相机数据采集（二）中，我们总结了用Kinect Azure相机采集三维彩色点云的方法以及相机之间的同步方法。这篇文章继续总结采集系统的下一部分——点云配准部分。如果说相机同步是实现多相机采集系统的基础，那么点云配准部分就是该系统的重点部分。最终的采集质量，全靠准确的点云配准结果来保证。 一、点云配准     何为点云配准？通俗来讲，就是将不同坐标系的点云全部搬移到
kinect1.0实现的rgbd-slam
shuishenbushui的博客
04-20 2231
这个rgbd-slam代码是根据高翔的代码改编过来的，具体可以参考创客制造的以下教程 https://www.ncnynl.com/category/rgbd-slam/ 下面我分为7步来介绍我的实现步骤以及中途可能遇到的bug和解决方案 1.硬件 这是淘宝上买的二手货，只要300多，用起来没什么问题，你可以先在windows下用它的sdk测试以下相机有没有什么问题 左边的圆孔为红外...
RGB-D相机（Azure Kinect DK）SDK安装
Zlp19970106的博客
07-04 2333
RGB-D相机（Azure Kinect DK）SDK安装 文章目录RGB-D相机（Azure Kinect DK）SDK安装1. Azure Kinect 传感器 SDK 下载安装1.1 官方apt安装1.2 SDK源码编译安装1.2.1 SDK源码下载1.2.2 下载依赖项1.2.3 编译1.2.4 连接kinect相机,打开k4aviewer1.2.5 Without Root2. 将 Azure Kinect 传感器流录制到文件中3. 参考 1. Azure Kinect 传感器 SDK 下载安装
服装人体的动态表面函数网络
21慕尼黑技术大学2德国图宾根马克斯·普朗克智能系统研究所图1：我们介绍了动态表面函数网络，该网络在穿着衣服的人的短RGB-D输入视频序列上进行训练。我们的连续表面表示允许建模的衣服，以及动态姿势依赖的变形。...
文件标题：KeyPose：透明物体的多视图3D标注和关键点
针对该问题的许多现有方法需要对象的深度图以用于训练和预测，这将它们限制为在RGBD传感器中产生良好回报的不透明朗伯对象。在本文中，我们放弃使用深度传感器，有利于原始立体声输入。我们解决了两个问题：第一，...
基于Open3D和Azure Kinect DK实现三维重建项目源码+说明（IMU传感器粗配准，彩色ICP精配准）.zip
最新发布
04-09
【资源说明】 1、该资源包括项目的全部源码，下载可以直接使用！ 2、本项目适合作为计算机、数学、电子信息等专业的课程设计、期末大作业和毕设项目，作为参考资料学习借鉴。 3、本资源作为“参考资料”如果需要实现其他功能，需要能看懂代码，并且热爱钻研，自行调试。 基于Open3D和Azure Kinect DK实现三维重建项目源码+说明（基于 IMU 传感器实现粗配准，基于彩色 ICP 算法实现精配准）.zip 此项目基于 Open3D 和 Azure Kinect DK 实现了三维重建。利用 Azure Kinect DK 捕获图像并记录 IMU 数据，利用 Open3D 实现三维重建。 # 依赖库 - Azure Kinect SDK - Eigen - Open3D # 创建数据存放文件夹 ```bash mkdir build cd build mkdir pcd ply ply-data reg ```
rgbd_kinect.rar人脸识别算法
06-29
人脸识别算法，在VS2010+opencv的平台上测试通过， 利用rgb彩色图像和深度信息，结合kinect。
Kinect与PCL搭配实现RGBD点云的实时显示
hljxh的博客
10-25 4774
刚刚学会了将彩色图像与深度图像的对齐方法。利用Kinect SDK里面的映射函数，可以将深度图的像素和彩色图对应，同时将深度图映射到相机空间上。在利用PCL将深度图像的的每一个像素和与其对应的颜色存到点云中，再进行显示。 代码如下：   #include &lt;Kinect.h&gt; #include &lt;opencv2\opencv.hpp&gt; #include &lt;pc...
学习Azure Kinect总结（windows）
ZHANruonan的博客
05-18 1787
对Azure Kinect相机的点云图学习，目标实现点云实时重建。
Kinect学习（三）：获取RGB颜色数据
hongbin_xu的博客
06-22 6287
前言 在前面的文章中介绍了如何搭建Kinect开发环境：Kinect学习（一）：开发环境搭建。搭建好环境后，首先要做的当然就是试着读取Kinect中的数据了。 Kinect有三个镜头，中间的是RGB摄像头，左边的是红外线发射器，右边的是红外线CMOS摄像头构成的3D结构光摄像头，用来采集深度数据。彩色摄像头最大支持1280*960分辨率成像，红外摄像头最大支持640*480成像。 接...
基于Kinect Azure的多相机数据采集（一）
GaryW666的博客
10-31 9512
基于Kinect Azure的多相机数据采集（一）     Kinect Azure相机是微软近几年推出的一款RGBD相机。相比于Kinect一代和二代，Kinect Azure相机采集的图像可达更高的分辨率，且在硬件方面设置了同步接口，更方便于多相机的同步采集。     具体的功能以及SDK所提供的函数接口可参考以下官方提供的文件：     https://docs.microsoft.com/zh-cn/azure/kinect-dk/     https://microsoft.github.io/A
基于多台azure kinects的点云采集、配准、相加
weixin_39880773的博客
05-30 3766
本文采用多台Azure kinect实现了对人体的动态捕捉 文章目录前言一、多台Azure kinect的配准1、硬件配准2、利用k4arecorder录制二、点云采集三、点云配准1.基于AprilTag的粗配准[1]2.基于彩色ICP的细配准[2]四、点云相加五、开源项目推荐总结参考文献 前言 如果你是刚接触kinect的小白，建议认真阅读Microsoft给出的官方文档 如果你打算自己开发azure kinect的程序，请参考官方的SDK手册 如果你想在win下配置azure kinect的开发.
基于Kinect Azure的多相机数据采集（二）
GaryW666的博客
11-22 3345
基于Kinect Azure的多相机数据采集（二）     在基于Kinect Azure的多相机数据采集(一)中介绍了Kinect Azure进行双相机数据采集的流程，并得到了每帧的深度图像和彩色图像，本篇进一步的通过深度和彩色图像获取该相机下的彩色点云数据。 ...
RGB-D相机（Azure Kinect DK）RGB图、深度图的获取，配准与保存
热门推荐
Zlp19970106的博客
07-04 1万+
前提：官方apt安装Azure Kinect 传感器 SDK 代码AcquiringImages将原始深度图转换到RGB摄像头坐标系下，得到的配准后的深度图，并将转换后的depth图，原始RGB图、原始IR图保存在本地，采集格式仿照TUM数据集，图片的命名格式为时间戳+.png后缀。 在这里插入代码片 ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值