测试libfreenect2在vs下环境配置是否完成 代码

在vs下环境配置

源代码所在文件夹：vs里你新建的项目

学习文章：slam for Windows -库安装及应用-libfreenect2-CSDN博客

测试libfreenect2在vs下环境配置是否完成 代码

学习文章：linux_libfreenect2_opencv3.4.2_kinect2.0获取各种视频图像-CSDN博客

Windows系统可以使用

#include <iostream>
#include <stdio.h>
#include <iomanip>
#include <time.h>
#include <signal.h>
#include <opencv2/opencv.hpp>
 
#include <libfreenect2/libfreenect2.hpp>
#include <libfreenect2/frame_listener_impl.h>
#include <libfreenect2/registration.h>
#include <libfreenect2/packet_pipeline.h>
#include <libfreenect2/logger.h>
 
using namespace std;
using namespace cv;
 
enum
{
   Processor_cl,
   Processor_gl,
   Processor_cpu
};
 
bool protonect_shutdown = false; // Whether the running application should shut down.
 
void sigint_handler(int s)
{
   protonect_shutdown = true;
}
 
 
// void drawText(Mat & image, const char* a );
 
 
 
int main()
{
//定义变量
   std::cout << "Hello World!" << std::endl;
   libfreenect2::Freenect2 freenect2;
   libfreenect2::Freenect2Device *dev = 0;
   libfreenect2::PacketPipeline  *pipeline = 0;
 
 
 
//搜寻并初始化传感器
   if(freenect2.enumerateDevices() == 0)
   {
       std::cout << "no device connected!" << std::endl;
       return -1;
   }
   string serial = freenect2.getDefaultDeviceSerialNumber();
   std::cout << "SERIAL: " << serial << std::endl;
 
//配置传输格式
#if 1 // sean
   int depthProcessor = Processor_cl;
   if(depthProcessor == Processor_cpu)
   {
       if(!pipeline)
           //! [pipeline]
           pipeline = new libfreenect2::CpuPacketPipeline();
       //! [pipeline]
   }
   else if (depthProcessor == Processor_gl) // if support gl
   {
#ifdef LIBFREENECT2_WITH_OPENGL_SUPPORT
       if(!pipeline)
       {
           pipeline = new libfreenect2::OpenGLPacketPipeline();
       }
#else
       std::cout << "OpenGL pipeline is not supported!" << std::endl;
#endif
   }
   else if (depthProcessor == Processor_cl) // if support cl
   {
#ifdef LIBFREENECT2_WITH_OPENCL_SUPPORT
       if(!pipeline)
           pipeline = new libfreenect2::OpenCLPacketPipeline();
#else
       std::cout << "OpenCL pipeline is not supported!" << std::endl;
#endif
   }
 
 
 
//启动设备
   if(pipeline)
   {
       dev = freenect2.openDevice(serial, pipeline);
   }
   else
   {
       dev = freenect2.openDevice(serial);
   }
   if(dev == 0)
   {
       std::cout << "failure opening device!" << std::endl;
       return -1;
   }
   signal(SIGINT, sigint_handler);
   protonect_shutdown = false;
   libfreenect2::SyncMultiFrameListener listener(
           libfreenect2::Frame::Color |
           libfreenect2::Frame::Depth |
           libfreenect2::Frame::Ir);
   libfreenect2::FrameMap frames;
   dev->setColorFrameListener(&listener);
   dev->setIrAndDepthFrameListener(&listener);
 
 
//启动数据传输
   dev->start();
 
   std::cout << "device serial: " << dev->getSerialNumber() << std::endl;
   std::cout << "device firmware: " << dev->getFirmwareVersion() << std::endl;
 
 
 
 
//循环接收
   libfreenect2::Registration* registration = new libfreenect2::Registration(dev->getIrCameraParams(), dev->getColorCameraParams());
   libfreenect2::Frame undistorted(512, 424, 4), registered(512, 424, 4), depth2rgb(1920, 1080 + 2, 4);
 
 
   Mat rgbmat, depthmat, depthmatUndistorted, irmat, rgbd, rgbd2;
 
   cv::namedWindow("rgb", WND_PROP_ASPECT_RATIO);
   cv::namedWindow("ir", WND_PROP_ASPECT_RATIO);
   cv::namedWindow("depth", WND_PROP_ASPECT_RATIO);
   //cv::namedWindow("undistorted", WND_PROP_ASPECT_RATIO);
   //cv::namedWindow("registered", WND_PROP_ASPECT_RATIO);
   cv::namedWindow("depth2RGB", WND_PROP_ASPECT_RATIO);
   
 
 
   while(!protonect_shutdown)
   {
       listener.waitForNewFrame(frames);
       libfreenect2::Frame *rgb = frames[libfreenect2::Frame::Color];
       libfreenect2::Frame *ir = frames[libfreenect2::Frame::Ir];
       libfreenect2::Frame *depth = frames[libfreenect2::Frame::Depth];
 
       cv::Mat(rgb->height, rgb->width, CV_8UC4, rgb->data).copyTo(rgbmat);
       cv::Mat(ir->height, ir->width, CV_32FC1, ir->data).copyTo(irmat);
       cv::Mat(depth->height, depth->width, CV_32FC1, depth->data).copyTo(depthmat);
       
       // drawText(rgbmat, "NIT");
       cv::imshow("rgb", rgbmat);
       cv::imshow("ir", irmat / 4500.0f);
       cv::imshow("depth", depthmat / 4500.0f);
 
       registration->apply(rgb, depth, &undistorted, &registered, true, &depth2rgb);
 
       cv::Mat(undistorted.height, undistorted.width, CV_32FC1, undistorted.data).copyTo(depthmatUndistorted);
       cv::Mat(registered.height, registered.width, CV_8UC4, registered.data).copyTo(rgbd);
       cv::Mat(depth2rgb.height, depth2rgb.width, CV_32FC1, depth2rgb.data).copyTo(rgbd2);
 
 
       cv::imshow("undistorted", depthmatUndistorted / 4500.0f);
       cv::imshow("registered", rgbd);
       cv::imshow("depth2RGB", rgbd2 / 4500.0f);
       
       
       int key = cv::waitKey(1);
       protonect_shutdown = protonect_shutdown || (key > 0 && ((key & 0xFF) == 27)); // shutdown on escape
 
       listener.release(frames);
   }
//关闭设备
   dev->stop();
   dev->close();
 
   delete registration;
 
#endif
 
   std::cout << "Goodbye World!" << std::endl;
   return 0;
}
 
 
 
/*
void drawText(Mat & image, const char* str)
{
   putText(image, str,
           Point(100, 100),
           FONT_HERSHEY_SIMPLEX, 3, // font face and scale
           Scalar(255, 255, 0), 
           3, LINE_AA); // line thickness and type
}
*/