导 Kinect2库,opencv库,pcl库

墨蓝 2022-11-27 12:07 204阅读 0赞

##                                      导 Kinect2库,opencv库,pcl库 ##

Kinect2驱动安装:     [https://blog.csdn.net/qq\_15204179/article/details/107706758 ][https_blog.csdn.net_qq_15204179_article_details_107706758]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE1MjA0MTc5_size_16_color_FFFFFF_t_70][]

**ndfreenect2.cmake**   \[Kinect2\]

# 查找依赖库
    FIND_LIBRARY(freenect2_LIBRARY freenect2
            PATHS ~/freenect2/lib
            NO_DEFAULT_PATH
            )
    SET(freenect2_LIBRARIES ${freenect2_LIBRARY} pthread)
    
    # 查找路径
    FIND_PATH(freenect2_INCLUDE_DIR libfreenect2/libfreenect2.hpp
            PATHS ~/freenect2/include
            NO_DEFAULT_PATH
            )
    SET(freenect2_INCLUDE_DIRS ${freenect2_INCLUDE_DIR})

FindOpenCV.cmake   \[OpenCV\]

# once done, this will define
    #OpenCV_FOUND        -  whether there is OpenCV in the prebuilt libraries
    #OpenCV_INCLUDE_DIRS -  include directories for OpenCV
    #OpenCV_LIBRARY_DIRS -  library directories for OpenCV
    #OpenCV_LIBRARIES    -  link this to use OpenCV
    
    set(OpenCV_DIR ~/3rdparty/OpenCV-3.4.9)
    
    unset(OpenCV_FOUND)
    
    MESSAGE(STATUS "OpenCV_DIR TEST  ${PREBUILT_DIR}")
    
    set(OpenCV_INCLUDE_DIRS "${OpenCV_DIR}/include" "${OpenCV_DIR}/include/opencv")
    set(OpenCV_LIB_COMPONENTS opencv_core;opencv_ml;opencv_calib3d;opencv_highgui;opencv_superres;opencv_photo;
            opencv_imgcodecs;opencv_features2d;opencv_viz;opencv_flann;opencv_shape;opencv_stitching;opencv_dnn;
            opencv_videostab;opencv_imgproc;opencv_objdetect;opencv_video;opencv_videoio;opencv_reg;opencv_aruco;
            opencv_dpm;opencv_xobjdetect;opencv_xfeatures2d;opencv_surface_matching;opencv_plot;opencv_hfs;
            opencv_tracking;opencv_rgbd;opencv_text;opencv_dnn_objdetect;opencv_face;opencv_optflow;opencv_bgsegm;
            opencv_bioinspired;opencv_ximgproc;opencv_saliency;opencv_freetype;opencv_stereo;opencv_img_hash;
            opencv_fuzzy;opencv_ccalib;opencv_line_descriptor;opencv_hdf;opencv_datasets;opencv_phase_unwrapping;
            opencv_xphoto;opencv_structured_light)
    
    find_path(OpenCV_INCLUDE_DIRS NAMES opencv.h HINTS ${OpenCV_DIR}/include NO_SYSTEM_ENVIRONMENT_PATH)
    
    set(OpenCV_LIBRARY_DIRS ${OpenCV_DIR}/lib)
    
    FOREACH(cvcomponent ${OpenCV_LIB_COMPONENTS})
      find_library(lib_${cvcomponent} NAMES ${cvcomponent} HINTS ${OpenCV_DIR}/lib NO_DEFAULT_PATH)
    
      set(OpenCV_LIBRARIES ${OpenCV_LIBRARIES};${lib_${cvcomponent}})
    ENDFOREACH()
    
    set(OpenCV_LIBS ${OpenCV_LIBRARIES})
    
    set(OpenCV_INCLUDE_DIRS ${OpenCV_INCLUDE_DIRS};${OpenCV_INCLUDE_DIRS}/opencv)
    
    if (OpenCV_INCLUDE_DIRS AND OpenCV_LIBRARIES)
      set(OpenCV_FOUND TRUE)
    endif (OpenCV_INCLUDE_DIRS AND OpenCV_LIBRARIES)
    
    if (OpenCV_FOUND)
      if (NOT OpenCV_FIND_QUIETLY)
        message(STATUS "Found OpenCV: ${OpenCV_LIBRARIES}")
      endif (NOT OpenCV_FIND_QUIETLY)
    else(OpenCV_FOUND)
      if (OpenCV_FIND_REQUIRED)
        message(FATAL_ERROR "Could not find the OpenCV library")
      endif ()
    endif (OpenCV_FOUND)

CMakeLists.txt

cmake_minimum_required(VERSION 3.16)
    project(kinect2demo)
    
    set(CMAKE_CXX_STANDARD 14)
    
    set(OUTPUT_DIRECTORY_ROOT ${CMAKE_CURRENT_SOURCE_DIR}/build/debug)
    set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${OUTPUT_DIRECTORY_ROOT}/bin" CACHE PATH "Runtime directory" FORCE)
    set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${OUTPUT_DIRECTORY_ROOT}/lib" CACHE PATH "Library directory" FORCE)
    set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${OUTPUT_DIRECTORY_ROOT}/lib" CACHE PATH "Archive directory" FORCE)
    
    set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_SOURCE_DIR}/cmake)
    #set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ~/3rdparty/OpenCV-3.4.9/share/OpenCV)
    
    # -------------------------------------------------- 2
    find_package(freenect2 REQUIRED)
    find_package(OpenCV REQUIRED)
    find_package(PCL REQUIRED)
    
    include_directories(${freenect2_INCLUDE_DIR})
    include_directories(${OpenCV_INCLUDE_DIRS})
    include_directories(${PCL_INCLUDE_DIRS})
    
    link_directories(${OpenCV_LIBRARY_DIRS})
    link_directories(${PCL_LIBRARY_DIRS})
    
    add_definitions(${PCL_DEFINITIONS})
    
    add_subdirectory(src)
    add_subdirectory(src/camera)
    
    
    add_executable(kinect2demo main.cpp)

\------------------------------------------------------------------------------------------------------------------------------------------------

01-Kinect2Camera.cpp  Kinect2获取保存彩色图及深度图

//
    // Created by ty on 20-6-3.
    //
    
    
    #include <iostream>
    #include <libfreenect2/libfreenect2.hpp>
    #include <libfreenect2/packet_pipeline.h>
    #include <libfreenect2/frame_listener_impl.h>
    #include <libfreenect2/registration.h>
    
    #include <opencv2/opencv.hpp>
    
    using namespace std;
    using namespace cv;
    
    
    const int ACTION_ESC = 27;
    const int ACTION_SPACE = 32;
    
    
    // 图片的输出目录
    const string output_dir = "../output";
    
    /**
     * 获取Kinect2相机的内容
     *
     * in:
     *      Kinect2硬件设备
     * out:
     *      彩色图
     *      深度图
     *
     *  过滤深度值 去掉无限值|NAN
     *  水平翻转
     *  保存彩色图和深度图
     *  缩放为0.5倍
     */
    int main(int argc, char *argv[]) {
    
        // 创建libfreenect2对象
        libfreenect2::Freenect2 freenect2;
    
        if (freenect2.enumerateDevices() == 0) {
            std::cerr << "当前未发现Kinect2设备" << std::endl;
            return -1;
        }
    
        const string &serial = freenect2.getDefaultDeviceSerialNumber();
    
        if (serial.empty()) {
            std::cerr << "设备序列号不存在" << std::endl;
            return -1;
        }
    
        std::cout << "设备序列号：" << serial << std::endl;
    
        // 创建数据处理管道
    //    libfreenect2::OpenGLPacketPipeline *pipeline = new libfreenect2::CpuPacketPipeline();
        libfreenect2::OpenGLPacketPipeline *pipeline = new libfreenect2::OpenGLPacketPipeline();
    
        // 打开设备
        libfreenect2::Freenect2Device *device = freenect2.openDevice(serial, pipeline);
    
        // 创建数据接收监听器
        libfreenect2::SyncMultiFrameListener listener(libfreenect2::Frame::Color | libfreenect2::Frame::Depth);
    
        // 给设备设置数据监听器
        //颜色设备
        device->setColorFrameListener(&listener);
        //红外设备  红外与深度是一个相机
        device->setIrAndDepthFrameListener(&listener);
    
        // 启动设备
        device->start();
    
        // 创建对齐工具，帮我们把rgb和depth对齐(去畸变)
        libfreenect2::Registration *registration = new libfreenect2::Registration(device->getIrCameraParams(),//相机内参,相机中再带存了些;最好自己标定下数据会更准确些
                                                                                  device->getColorCameraParams());
    
        std::cout << "设备固件版本：" << device->getFirmwareVersion() << std::endl;
    
        libfreenect2::Frame undistorted(512, 424, 4),   // 创建对象接收：已经去畸变的深度图,第3个参数:浮点类型的字节数
                registered(512, 424, 4),    // 创建对象接收：已经对齐的彩色图 （可能会有孔洞）把彩色图对齐到深度图上,第3个参数:浮点类型的字节数
                bigdepth(1920, 1082, 4);    // 创建对象接收：将小深度图对齐到彩色图上得到的大深度图  1920*1082 float; 1082 第一行与最好一行多了两空像素需要过干掉,第3个参数:浮点类型的字节数
    
        // 创建一个容器，准备接收数据
        libfreenect2::FrameMap frames;
    
        int index = 0;
        while (true) {//用户按下空格保存图片 按下esc退出
            // 这里会阻塞，直到拿到最新的数据。阻塞才会被释放,必须先释放当前的数据:listener.release(frames);
            listener.waitForNewFrame(frames);
            //取颜色图片
            libfreenect2::Frame *rgb = frames[libfreenect2::Frame::Color];
            //取深度图片
            libfreenect2::Frame *depth = frames[libfreenect2::Frame::Depth];
    
    //        std::cout << "rgb->width: " << rgb->width << " rgb->height: " << rgb->height << std::endl;
    //        std::cout << "depth->width: " << depth->width << " depth->height: " << depth->height << std::endl;
            // 彩色图与深度图合并; 对原始数据进行对齐 彩色图映射到深度图上  rgb彩色图 ,undistorted去畸变的深度图,registered配准后的彩色图 把彩色图贴到深度图上了 ;是否允许过滤 把相机不可见的像素过滤掉;bigdepth 输出把深度映射到彩色图上的图 大的深度图
            // bigdepth 输出把深度映射到彩色图上的图 大的深度图 1920*1082 float; 1082 第一行与最好一行多了两空像素需要过干掉
            registration->apply(rgb, depth, &undistorted, &registered, true, &bigdepth);
    
            // 512x424 已和深度对齐的彩色图
    //        Mat registeredRgbMat = Mat(registered.height, registered.width, CV_8UC4, registered.data);
            // 512x424 已去畸变的深度图
    //        Mat undistortedDepthMat = Mat(undistorted.height, undistorted.width, CV_32FC1, undistorted.data);
            // 512x424 未去畸变的深度图
    //        Mat smallDepthMat = Mat(depth->height, depth->width, CV_32FC1, depth->data);
    
            // 将kinect类型的数据转成OpenCV的Mat
            //CV_8UC4 u代表无符号 c是通道 通道为4
            // 1920x1080
            // opencv提供Mat构造函数 帮我们把unsigned char* 转成 mat对象
            Mat rgbMat = Mat(rgb->height, rgb->width, CV_8UC4, rgb->data);
            // 1920x1082  CV_32FC1 32位精度浮点数 单通道  bigDepthMat_ 深度值单位毫米,接收的时候要用CV_32FC1数据类型
            Mat bigDepthMat_ = Mat(bigdepth.height, bigdepth.width, CV_32FC1, bigdepth.data);
    
    
             //过滤深度值 去掉无限值|NAN, 裁剪
            //       起始列   起始行       总列数       需要的行数
            //  Rect_(_Tp _x, _Tp _y, _Tp _width, _Tp _height); 1920*1082 float 截取深度图 获得1080的长度
           // 截取深度图 获得1080的长度 ,1920*1082 float
            Mat bigDepthMat = bigDepthMat_(Rect(0, 1, bigDepthMat_.cols, bigDepthMat_.rows - 2));
            //过滤深度值 去掉无限值|NAN
            for (int i = 0; i < bigDepthMat.rows; ++i) {
                for (int j = 0; j < bigDepthMat.cols; ++j) {
                    float &d = bigDepthMat.at<float>(i, j);
                    if (fpclassify(d) == FP_INFINITE || fpclassify(d) == NAN) {
                        d = 0;
                    }
                }
            }
    
            // *  水平翻转
            flip(rgbMat, rgbMat, 1);
            flip(bigDepthMat, bigDepthMat, 1);
    
    
            int action = waitKey(30) & 0xFF;
    
            if (action == ACTION_ESC || action == 'q' || action == 'Q') {//按下q 或 esc 27退出
                break;
            } else if (action == ACTION_SPACE) {//用户按下空格保存32图片
                std::cout << "保存rgb图和depth图" << std::endl;
    //            *  保存彩色图和深度图
    
                // 保存彩图
                stringstream rr;
                rr << output_dir << "/rgb_image_" << index << ".jpg";
                vector<int> params;
                params.push_back(CV_IMWRITE_JPEG_QUALITY);//图片格式
                params.push_back(100);//压缩的比例
                bool rst = imwrite(rr.str(), rgbMat, params);
                if (!rst) {
                    std::cerr << "目标目录不存在，请检查后再保存： " << output_dir << std::endl;
                    return -1;
                }
                std::cout << "保存彩色图成功：" << rr.str() << std::endl;
    
                // 保存深度图 深度图全是数字 不是可是的图片,要保存成文件
                // 将数据转成单通道16位UINT,CV_16UC1 整形16位的保存,接收的时候要用CV_32FC1数据类型
                bigDepthMat.convertTo(bigDepthMat, CV_16UC1);
                stringstream dd;
                dd << output_dir << "/depth_image_" << index << ".xml";
                FileStorage fs(dd.str(), FileStorage::WRITE);
                fs << "depth" << bigDepthMat;
                fs.release();
                std::cout << "保存深度值成功：" << dd.str() << std::endl;
    
            }
    //       *  缩放为0.5倍
            resize(rgbMat, rgbMat, Size(), 0.5, 0.5, INTER_LINEAR);
            resize(bigDepthMat, bigDepthMat, Size(), 0.5, 0.5, INTER_LINEAR);
    
            imshow("color", rgbMat);//彩色图显示
            imshow("depth", bigDepthMat / 4500.0f);//官方推荐显示深度图除4500
    
            //必须先释放当前的数据  waitForNewFrame才会拿到数据
            listener.release(frames);
        }
    
        device->stop();//停掉设备
        device->close();//后关闭设备
    
        delete registration;//回收数据
    }

02-PointCloudMaker.cpp  Kinect2转点云图

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE1MjA0MTc5_size_16_color_FFFFFF_t_70 1][]

//
    // Created by ty on 20-6-3.
    //
    
    
    #include <iostream>
    
    #include <opencv2/opencv.hpp>
    
    #include <pcl/point_types.h>
    #include <pcl/io/pcd_io.h>
    #include <pcl/io/io.h>
    #include <pcl/visualization/cloud_viewer.h>
    
    using namespace std;
    using namespace cv;
    
    typedef pcl::PointXYZRGB PointT;
    typedef pcl::PointCloud<PointT> PointCloud;
    
    /**
     * OpenCV
     * PCL
     *
     * 输入：
     *      彩色图
     *      深度图
     *      相机的内参
     *
     * 输出：
     *      点云图
     *
     */
    int main(int argc, char *argv[]) {
    
        // 读取彩色图和深度图
        const Mat &rgbMat = imread("./output1/rgb_image_0.jpg", CV_LOAD_IMAGE_UNCHANGED);
        // 深度图
        Mat depthMat;
        FileStorage fs("./output1/depth_image_0.xml", FileStorage::READ);
        fs["depth"] >> depthMat;
        fs.release();
    
        // 读取相机内参
        Mat cameraMatrix = cv::Mat_<double>(3, 3);
        FileStorage camera_fs("./calib/calibration_in_params.yml", FileStorage::READ);
        camera_fs["cameraMatrix"] >> cameraMatrix;
        camera_fs.release();
    
        std::cout << cameraMatrix << std::endl;
    
        double fx = cameraMatrix.at<double>(0, 0);
        double fy = cameraMatrix.at<double>(1, 1);
        double cx = cameraMatrix.at<double>(0, 2);//u
        double cy = cameraMatrix.at<double>(1, 2);//v
    
        // 准备一个点云，接收数据
        PointCloud::Ptr cloud(new PointCloud);
    
        // 遍历每一个深度图的宽高，给点云的每个点指定其颜色值和深度值
        for (int v = 0; v < depthMat.rows; ++v) { // 所有行
            for (int u = 0; u < depthMat.cols; ++u) { // 所有
                // 取出每个像素对应的Z值
                ushort d = depthMat.at<ushort>(v, u);//单位毫米
                double depth_value = double(d) / 1000.0f;//变为米为单位,计算都是用米为单位,存储都是毫米为单位
    
                if (depth_value == 0 || isnan(depth_value) || abs(depth_value) < 0.0001) {//depth_value==0 或者不是数字 或者绝对值很小比1微米还小的值
                    continue;
                }
                // 创建一个点Point
                PointT p;
    
                // 根据内参计算出其X,Y -----------------------------------------
                p.z = depth_value;
                p.x = (u - cx) * p.z / fx;
                p.y = (v - cy) * p.z / fy;
    
                // 给其指定颜色
                Vec3b bgr = rgbMat.at<Vec3b>(v, u);
                p.b = bgr[0];
                p.g = bgr[1];
                p.r = bgr[2];
    
                // 添加到cloud中
                cloud->points.push_back(p);
            }
        }
    
        // 显示cloud点云
        cloud->width = cloud->points.size();//无序点云的宽即是cloud长度
        cloud->height = 1;
        cloud->is_dense = false;//是否是密集的
    
        pcl::visualization::CloudViewer viewer("cloud_viewer");
    
        viewer.showCloud(cloud);
        //保存成点云文件
    //    pcl::io::savePCDFileASCII("output/test_pcd.pcd", cloud);
    //    std::cerr << "Saved " << cloud.points.size() << " data points to test_pcd.pcd." << std::endl;
        while (!viewer.wasStopped()) {
            //
        }
    
    }

03-PhotoCapture.cpp  Kinect2 实时获取点云图

#include <iostream>
    #include <opencv2/opencv.hpp>
    #include <sstream>
    #include <cstdlib>
    
    #include <pcl/io/pcd_io.h>
    #include <pcl/visualization/cloud_viewer.h>
    #include <KinectCamera.h>
    
    using namespace std;
    using namespace cv;
    
    float qnan_ = std::numeric_limits<float>::quiet_NaN();
    const char *cameraInCailFile = "./calib/calibration_in_params.yml";
    // 获取目标目录
    //const char *output_dir = "./scene";
    // 制作模板目录
    const char *output_dir = "./capture_temp";
    
    const int ACTION_ESC = 27;
    const int ACTION_SPACE = 32;
    
    
    Eigen::Matrix<float, 1920, 1> colmap;
    Eigen::Matrix<float, 1080, 1> rowmap;
    const short w = 1920, h = 1080;
    
    // 准备数据
    void prepareMake3D(const double cx, const double cy,
                       const double fx, const double fy) {
    //    const int w = 512;
    //    const int h = 424;
        float *pm1 = colmap.data();
        float *pm2 = rowmap.data();
        for (int i = 0; i < w; i++) {
            *pm1++ = (i - cx + 0.5) / fx;
        }
        for (int i = 0; i < h; i++) {
            *pm2++ = (i - cy + 0.5) / fy;
        }
    }
    
    /**
     * 根据内参，合并RGB彩色图和深度图到点云
     * @param cloud
     * @param depthMat
     * @param rgbMat
     */
    void getCloud(pcl::PointCloud<pcl::PointXYZRGB>::Ptr &cloud, Mat &depthMat, Mat &rgbMat) {
        const float *itD0 = (float *) depthMat.ptr();
        const char *itRGB0 = (char *) rgbMat.ptr();
    
        if (cloud->size() != w * h)
            cloud->resize(w * h);
    
        // 获取点云的点集合的指针
        pcl::PointXYZRGB *itP = &cloud->points[0];
        bool is_dense = true;
    
        // 遍历所有行
        for (size_t y = 0; y < h; ++y) {
    
            // 偏差个数, 跳过y行 y * 1920 个
            const unsigned int offset = y * w;
            // 深度图指针加上偏差
            const float *itD = itD0 + offset;
            // 彩色图指针加上偏差
            const char *itRGB = itRGB0 + offset * 4;
            // 获取指定行的系数
            const float dy = rowmap(y);
    
            // 遍历第y行的所有列
            for (size_t x = 0; x < w; ++x, ++itP, ++itD, itRGB += 4) {
                const float depth_value = *itD / 1000.0f;
    
                if (!isnan(depth_value) && abs(depth_value) >= 0.0001) {
    
                    const float rx = colmap(x) * depth_value;
                    const float ry = dy * depth_value;
                    itP->z = depth_value;
                    itP->x = rx;
                    itP->y = ry;
    
                    itP->b = itRGB[0];
                    itP->g = itRGB[1];
                    itP->r = itRGB[2];
                } else {
                    itP->z = qnan_;
                    itP->x = qnan_;
                    itP->y = qnan_;
    
                    itP->b = qnan_;
                    itP->g = qnan_;
                    itP->r = qnan_;
                    is_dense = false;
                }
            }
        }
        cloud->is_dense = is_dense;
    }
    
    
    /*
     * 保存Kenect相机的实时图片
     *  按enter键保存
     * */
    int main(int argc, char *argv[]) {
    
        // 显示RGB图
        // 显示深度图
        // 显示合成后的点云图
    
        auto *camera = new KinectCamera();
    //    cv::VideoCapture capture(0);
        if (!camera->isOpened()) {
            std::cout << "无法开启摄像头！" << std::endl;
            return -1;
        }
    
        Mat cameraMatrix = cv::Mat_<double>(3, 3);
        FileStorage paramFs(cameraInCailFile, FileStorage::READ);
        paramFs["cameraMatrix"] >> cameraMatrix;
        // 内参数据
        double fx = cameraMatrix.at<double>(0, 0);
        double fy = cameraMatrix.at<double>(1, 1);
        double cx = cameraMatrix.at<double>(0, 2);
        double cy = cameraMatrix.at<double>(1, 2);
    
        prepareMake3D(cx, cy, fx, fy);
    
        // 准备点云查看工具
        pcl::visualization::PCLVisualizer::Ptr viewer(new pcl::visualization::PCLVisualizer("3D Viewer"));
    
        // 创建智能指针点云
        pcl::PointCloud<pcl::PointXYZRGB>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZRGB>());
        viewer->setBackgroundColor(0, 0, 0);
    
        pcl::visualization::PointCloudColorHandlerRGBField<pcl::PointXYZRGB> rgbHandler(cloud);
        viewer->addPointCloud<pcl::PointXYZRGB>(cloud, rgbHandler, "sample cloud");
        viewer->setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 1, "sample cloud");
    
        int index = 0;
        while (true) {
            cv::Mat rgbMat, depthMat;
            camera->capture(rgbMat, depthMat);
    
    
            if (!viewer->wasStopped()) {
                // 将RGB和深度信息合成为一个点云图，保存到cloud中
                getCloud(cloud, depthMat, rgbMat);
    
                pcl::visualization::PointCloudColorHandlerRGBField<pcl::PointXYZRGB> rgbHandler(cloud);
                viewer->updatePointCloud<pcl::PointXYZRGB>(cloud, rgbHandler, "sample cloud");
    
                viewer->spinOnce();
            }
    
            int action = cv::waitKey(20) & 0xFF;
    
            if (action == ACTION_SPACE || action == 'q') {
                // 保存点云
                std::cout << "保存当前的点云" << std::endl;
    
    
                stringstream rr;
                rr << output_dir << "/camera_rgb_" << index << ".jpg";
                vector<int> compression_params;
                compression_params.push_back(CV_IMWRITE_JPEG_QUALITY);  //选择jpeg
                compression_params.push_back(100); //在这个填入你要的图片质量
                bool rst = cv::imwrite(rr.str(), rgbMat, compression_params);
                if (!rst) {
                    std::cerr << "保存失败，请检查该文件夹是否存在：" << output_dir << std::endl;
                    return -1;
                }
                cout << rr.str() << endl;
    
                depthMat.convertTo(depthMat, CV_16UC1);
    
                // 保存深度图
                stringstream ss;
                ss << output_dir << "/camera_depth_" << index << ".xml";
                FileStorage fs(ss.str(), FileStorage::WRITE);
                fs << "depth" << depthMat;
                fs.release();
    
                stringstream ss_pcd;
                ss_pcd << output_dir << "/table_scene_" << index << ".pcd";
                // 保存模板点云图
                pcl::io::savePCDFile(ss_pcd.str(), *cloud);
                index++;
                cout << "成功保存RGB, 深度图, 点云图" << endl;
    
            }else if(action == ACTION_ESC) {
                // 退出
                break;
    
            }
    
            cv::imshow("rgb", rgbMat);
            cv::imshow("depth", depthMat / 4500);
    
        }
        camera->release();
    
    
        return 0;
    }

===========================================================================================

Kinect_封装好的驱动

只能获取彩色图

workspas/HandEyeCalibration/cmake/Findfreenect2.cmake

# 查找依赖库
    # 头文件include: freenect2_INCLUDE_DIRS
    # 依赖库：       freenect2_LIBRARIES
    
    FIND_LIBRARY(freenect2_LIBRARY freenect2
            PATHS ~/freenect2/lib
            NO_DEFAULT_PATH
            )
    SET(freenect2_LIBRARIES ${freenect2_LIBRARY} pthread)
    
    # 查找路径
    FIND_PATH(freenect2_INCLUDE_DIR libfreenect2/libfreenect2.hpp
            PATHS ~/freenect2/include
            NO_DEFAULT_PATH
            )
    SET(freenect2_INCLUDE_DIRS ${freenect2_INCLUDE_DIR})

workspas/HandEyeCalibration/src/camera/CMakeLists.txt

add_library(kinect_camera KinectCamera.cpp KinectCamera.h)
    target_link_libraries(kinect_camera ${OpenCV_LIBRARIES} ${freenect2_LIBRARIES})

workspas/HandEyeCalibration/src/camera/KinectCamera.cpp

//
    // Created by ty on 20-9-26.
    //
    
    #include "KinectCamera.h"
    
    
    int KinectCamera::init() {
    
    
        // 判断已连接的设备个数
        if (freenect2.enumerateDevices() == 0) {
            std::cerr << "未发现Kinect2设备" << std::endl;
            return -1;
        }
    
        const string &serial = freenect2.getDefaultDeviceSerialNumber();
    
        if (serial.empty()) {
            std::cerr << "设备序列号不存在" << std::endl;
            return -1;
        }
    
        std::cout << "设备序列号: " << serial << std::endl;
    
        // 创建pipeline接收并处理数据
    //    auto *pipeline = new libfreenect2::CpuPacketPipeline();
        auto pipeline = new libfreenect2::OpenGLPacketPipeline();
    
        // 根据序列号开启设备，并设定数据处理通道
        device = freenect2.openDevice(serial, pipeline);
    
        // 创建数据接收器（监听器），给设备执行监听;
        device->setColorFrameListener(&listener);
        device->setIrAndDepthFrameListener(&listener);
    
        device->start();
    
        return 0;
    }
    
    void KinectCamera::capture(Mat& outputMat) {
    
        listener.waitForNewFrame(frames);
    
        libfreenect2::Frame *rgb = frames[libfreenect2::Frame::Color];
        libfreenect2::Frame *depth = frames[libfreenect2::Frame::Depth];
    
        Mat colorMat = Mat(rgb->height, rgb->width, CV_8UC4, rgb->data);
        // 图像进行镜像处理
        flip(colorMat, colorMat, 1);
    
        colorMat.copyTo(outputMat);
    
        listener.release(frames);
    
    }
    
    
    void KinectCamera::release() {
        device->stop();
        device->close();
    }
    
    KinectCamera::~KinectCamera() {
    
    }

workspas/HandEyeCalibration/src/camera/KinectCamera.h

//
    // Created by ty on 20-9-26.
    //
    
    #ifndef HANDEYECALIBRATION_KINECTCAMERA_H
    #define HANDEYECALIBRATION_KINECTCAMERA_H
    
    
    #include <iostream>
    #include <opencv2/opencv.hpp>
    #include <libfreenect2/libfreenect2.hpp>
    #include <libfreenect2/packet_pipeline.h>
    #include <libfreenect2/frame_listener_impl.h>
    
    using namespace std;
    using namespace cv;
    
    
    class KinectCamera {
    
    private:
        int status = -2; // -2 初始状态， -1 出现错误， 0 正常可用
    
        // 1. 初始化Kinect2相机对象
        libfreenect2::Freenect2 freenect2;
    
        libfreenect2::Freenect2Device *device = nullptr;
    
        libfreenect2::SyncMultiFrameListener listener;
    
        libfreenect2::FrameMap frames;
    
    public:
        KinectCamera(): listener(libfreenect2::Frame::Color | libfreenect2::Frame::Depth) {
            status = init();
        }
    
        virtual ~KinectCamera();
    
        // 判断设备是否开启
        bool isOpened() {
            return status == 0;
        }
    
        virtual int init();
    
        virtual void release();
    
        void capture(Mat& colorMat);
    
        void capture(Mat& colorMat, Mat& depthMat);
    };
    
    
    #endif //HANDEYECALIBRATION_KINECTCAMERA_H

使用:

#include <libfreenect2/libfreenect2.hpp>
    #include <libfreenect2/packet_pipeline.h>
    #include <libfreenect2/frame_listener_impl.h>
    #include <opencv2/opencv.hpp>
    
    
    int main(int argc, char *argv[]) {
       KinectCamera* camera = new KinectCamera();
    
        if (!camera->isOpened()) {
            std::cerr << "相机打开失败" << std::endl;
            return -1;
        }
    
        while (true) {
        //  2. 循环接收相机数据rgb，depth (一定要在下次wait之前释放掉frames.   
            //listener.release(frames);)
    
            Mat colorMat, srcMat, gray;
    
            camera->capture(colorMat);
    
            // 备份一份原图
            colorMat.copyTo(srcMat);
    
         // 3. 在rgb彩色图里查找角点
            cvtColor(colorMat, gray, COLOR_BGR2GRAY);
    
            imageSize = gray.size();
    
        }
    
     cv::destroyAllWindows();
        // 设备使用完毕后，及时关闭
        camera->release();
    
    
    }

\------------------------------------------------------------------------------------------------------------------------------------

**控制台命令启动相机**

cd ~/3rdparty/source/libfreenect2-master/build/bin
    ./Protonect

[https_blog.csdn.net_qq_15204179_article_details_107706758]: https://blog.csdn.net/qq_15204179/article/details/107706758
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE1MjA0MTc5_size_16_color_FFFFFF_t_70]: /images/20221124/3db0e8db699b42679be3412317cdbada.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE1MjA0MTc5_size_16_color_FFFFFF_t_70 1]: /images/20221124/b2d9310970c24d68ad1c06e0e3f04209.png