导 Kinect2库,opencv库,pcl库
Kinect2驱动安装: https://blog.csdn.net/qq_15204179/article/details/107706758
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, ®istered, 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转点云图
//
// 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
扫一扫
2764
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
