PCL+kinect2.0实现点云数据的获取及储存

最新推荐文章于 2024-05-28 09:36:34 发布
最新推荐文章于 2024-05-28 09:36:34 发布
阅读量6.8k 收藏 82
点赞数 14
分类专栏： PCL学习 文章标签： PCL+Kinect2.0
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43622114/article/details/97815051
版权

说明

最近也是开始了PCL的学习之路，希望在与大家交流的过程中可以从小白一步步成长。这篇代码也是受一位学长和网上一些相关文章的启发写出来的，下面我会给出源码和一些容易掉进去的坑，希望有志同道合的朋友可以多多指正。那位学长也是很厉害的，大家可以去他的主页看看有没有自己一直想解决却解决不了的问题的方法。他的主页

点云显示+储存 代码：

#include"kinect2_grabber.h"
//---------------------------------
#include <kinect.h>
#include<pcl\io\pcd_io.h>
#include <pcl/filters/conditional_removal.h>
#include <pcl/visualization/cloud_viewer.h> 
#include <pcl/visualization/pcl_visualizer.h>
typedef pcl::PointXYZRGBA PointType;

int main()
{
	int c = 0;
	int total = 0;//文件名
	//pcl::PointCloud<PointType> cloud_filtered;// 按范围过滤后的点云

	boost::shared_ptr<pcl::visualization::PCLVisualizer> m_viewer;
	
	//显示窗口初始化
	m_viewer.reset(new pcl::visualization::PCLVisualizer("viewer", false));
	m_viewer->setBackgroundColor(0, 0, 0);//设置背景颜色
	m_viewer->initCameraParameters();
	//m_viewer->addCoordinateSystem();//添加红绿蓝坐标轴
	m_viewer->createInteractor();

	                                                                                                                                                                        
	// 获取Kinect设备	
	// Point Cloud
	pcl::PointCloud<PointType>::ConstPtr pointCloud_XYZRGBA;  //指针变量
															  
	// Retrieved Point Cloud Callback Function 检测到的点云回调函数
	boost::mutex mutex; //并发编程互斥锁
	boost::function<void(const pcl::PointCloud<PointType>::ConstPtr&)> function = [&pointCloud_XYZRGBA, &mutex](const pcl::PointCloud<PointType>::ConstPtr& ptr) { //只能用ConstPtr，不能用Ptr
		boost::mutex::scoped_lock lock(mutex);
		/* Point Cloud Processing */
		pointCloud_XYZRGBA = ptr->makeShared();
		//ptr->makeShared() = NULL;
	};

	boost::shared_ptr<pcl::Grabber> grabberForKinect = boost::shared_ptr<pcl::Grabber>(new pcl::Kinect2Grabber);// Kinect2Grabber
	boost::signals2::connection connection = grabberForKinect->registerCallback(function); // Register Callback Function
	grabberForKinect->start();  //Start Grabber

	while (!m_viewer->wasStopped()) {
		// Update Viewer

		c++;

		m_viewer->spinOnce(1); //调用交互程序并更新屏幕一次。
		boost::mutex::scoped_try_lock lock(mutex);

		//cloud_filtered = filterByScope(pointCloud_XYZRGBA, Z_nearby, Z_faraway, X_left, X_right, Y_bottom, Y_top);//截取对应范围图像

		if (lock.owns_lock() && pointCloud_XYZRGBA) {
			//cloud_filtered = filterByScope(pointCloud_XYZRGBA, Z_nearby, Z_faraway, X_left, X_right, Y_bottom, Y_top);
			//5 显示 Point Cloud
			if (!m_viewer->updatePointCloud(pointCloud_XYZRGBA->makeShared(), "cloud")) {//pointCloud_XYZRGBA是指针类型，不能用( . )运算符
				m_viewer->addPointCloud(pointCloud_XYZRGBA->makeShared(), "cloud");
			}
			if (c % 10 == 0) {//每隔一段时间保存一次图片
				//存储图片。
				char name[100];
				sprintf(name, "D:\\%d.pcd", total++);
				pcl::io::savePCDFileASCII(name, *pointCloud_XYZRGBA);//以.pcd的格式保存点云数据到磁盘
			}
		}
	}//while


}

关于代码，其中已经给注释了，还有几个比较容易出问题的地方。

一、

在这里插入图片描述
这里阴影部分的内容，一定要是 ConstPtr (参照第一篇源码） 否则就会出现下列的错误

在这里插入图片描述

二、

在这里插入图片描述
调试——>项目属性——>VC++ 目录——>包含目录 ，里不要出现这样一项，我就是因为配置的问题，搞了好几天，脑袋都大了，最后是这里有问题。如果带上这一项的话，会出现无法解析的外部符号。

另外可能有的朋友没有kinect2_grabber.h这个头文件的源码，下面给出：

#pragma once
#pragma once
// Kinect2Grabber is pcl::Grabber to retrieve the point cloud data from Kinect v2 using Kinect for Windows SDK 2.x.
// This source code is licensed under the MIT license. Please see the License in License.txt.

#ifndef KINECT2_GRABBER
#define KINECT2_GRABBER

#define NOMINMAX
#include <Windows.h>
#include <Kinect.h>

#include <pcl/io/boost.h>
#include <pcl/io/grabber.h>
#include <pcl/point_cloud.h>
#include <pcl/point_types.h>


namespace pcl
{
	struct pcl::PointXYZ;
	struct pcl::PointXYZI;
	struct pcl::PointXYZRGB;
	struct pcl::PointXYZRGBA;
	template <typename T> class pcl::PointCloud;

	template<class Interface>
	inline void SafeRelease(Interface *& IRelease)
	{
		if (IRelease != NULL) {
			IRelease->Release();
			IRelease = NULL;
		}
	}

	class Kinect2Grabber : public pcl::Grabber
	{
	public:
		Kinect2Grabber();
		virtual ~Kinect2Grabber() throw ();
		virtual void start();
		virtual void stop();
		virtual bool isRunning() const;
		virtual std::string getName() const;
		virtual float getFramesPerSecond() const;

		typedef void (signal_Kinect2_PointXYZ)(const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZ>>&);
		typedef void (signal_Kinect2_PointXYZI)(const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZI>>&);
		typedef void (signal_Kinect2_PointXYZRGB)(const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZRGB>>&);
		typedef void (signal_Kinect2_PointXYZRGBA)(const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZRGBA>>&);

	protected:
		boost::signals2::signal<signal_Kinect2_PointXYZ>* signal_PointXYZ;
		boost::signals2::signal<signal_Kinect2_PointXYZI>* signal_PointXYZI;
		boost::signals2::signal<signal_Kinect2_PointXYZRGB>* signal_PointXYZRGB;
		boost::signals2::signal<signal_Kinect2_PointXYZRGBA>* signal_PointXYZRGBA;

		pcl::PointCloud<pcl::PointXYZ>::Ptr convertDepthToPointXYZ(UINT16* depthBuffer);
		pcl::PointCloud<pcl::PointXYZI>::Ptr convertInfraredDepthToPointXYZI(UINT16* infraredBuffer, UINT16* depthBuffer);
		pcl::PointCloud<pcl::PointXYZRGB>::Ptr convertRGBDepthToPointXYZRGB(RGBQUAD* colorBuffer, UINT16* depthBuffer);
		pcl::PointCloud<pcl::PointXYZRGBA>::Ptr convertRGBADepthToPointXYZRGBA(RGBQUAD* colorBuffer, UINT16* depthBuffer);

		boost::thread thread;
		mutable boost::mutex mutex;

		void threadFunction();

		bool quit;
		bool running;

		HRESULT result;
		IKinectSensor* sensor;
		ICoordinateMapper* mapper;
		IColorFrameSource* colorSource;
		IColorFrameReader* colorReader;
		IDepthFrameSource* depthSource;
		IDepthFrameReader* depthReader;
		IInfraredFrameSource* infraredSource;
		IInfraredFrameReader* infraredReader;

		int colorWidth;
		int colorHeight;
		std::vector<RGBQUAD> colorBuffer;

		int depthWidth;
		int depthHeight;
		std::vector<UINT16> depthBuffer;

		int infraredWidth;
		int infraredHeight;
		std::vector<UINT16> infraredBuffer;
	};
	pcl::Kinect2Grabber::Kinect2Grabber()
		: sensor(nullptr)
		, mapper(nullptr)
		, colorSource(nullptr)
		, colorReader(nullptr)
		, depthSource(nullptr)
		, depthReader(nullptr)
		, infraredSource(nullptr)
		, infraredReader(nullptr)
		, result(S_OK)
		, colorWidth(1920)
		, colorHeight(1080)
		, colorBuffer()
		, depthWidth(512)
		, depthHeight(424)
		, depthBuffer()
		, infraredWidth(512)
		, infraredHeight(424)
		, infraredBuffer()
		, running(false)
		, quit(false)
		, signal_PointXYZ(nullptr)
		, signal_PointXYZI(nullptr)
		, signal_PointXYZRGB(nullptr)
		, signal_PointXYZRGBA(nullptr)
	{
		// Create Sensor Instance
		
		result = GetDefaultKinectSensor(&sensor);
		if (FAILED(result)) {
			throw std::exception("Exception : GetDefaultKinectSensor()");
		}

		// Open Sensor
		result = sensor->Open();
		if (FAILED(result)) {
			throw std::exception("Exception : IKinectSensor::Open()");
		}

		// Retrieved Coordinate Mapper
		result = sensor->get_CoordinateMapper(&mapper);
		if (FAILED(result)) {
			throw std::exception("Exception : IKinectSensor::get_CoordinateMapper()");
		}

		// Retrieved Color Frame Source
		result = sensor->get_ColorFrameSource(&colorSource);
		if (FAILED(result)) {
			throw std::exception("Exception : IKinectSensor::get_ColorFrameSource()");
		}

		// Retrieved Depth Frame Source
		result = sensor->get_DepthFrameSource(&depthSource);
		if (FAILED(result)) {
			throw std::exception("Exception : IKinectSensor::get_DepthFrameSource()");
		}

		// Retrieved Infrared Frame Source
		result = sensor->get_InfraredFrameSource(&infraredSource);
		if (FAILED(result)) {
			throw std::exception("Exception : IKinectSensor::get_InfraredFrameSource()");
		}

		// Retrieved Color Frame Size
		IFrameDescription* colorDescription;
		result = colorSource->get_FrameDescription(&colorDescription);
		if (FAILED(result)) {
			throw std::exception("Exception : IColorFrameSource::get_FrameDescription()");
		}

		result = colorDescription->get_Width(&colorWidth); // 1920
		if (FAILED(result)) {
			throw std::exception("Exception : IFrameDescription::get_Width()");
		}

		result = colorDescription->get_Height(&colorHeight); // 1080
		if (FAILED(result)) {
			throw std::exception("Exception : IFrameDescription::get_Height()");
		}

		SafeRelease(colorDescription);

		// To Reserve Color Frame Buffer
		colorBuffer.resize(colorWidth * colorHeight);

		// Retrieved Depth Frame Size
		IFrameDescription* depthDescription;
		result = depthSource->get_FrameDescription(&depthDescription);
		if (FAILED(result)) {
			throw std::exception("Exception : IDepthFrameSource::get_FrameDescription()");
		}

		result = depthDescription->get_Width(&depthWidth); // 512
		if (FAILED(result)) {
			throw std::exception("Exception : IFrameDescription::get_Width()");
		}

		result = depthDescription->get_Height(&depthHeight); // 424
		if (FAILED(result)) {
			throw std::exception("Exception : IFrameDescription::get_Height()");
		}

		SafeRelease(depthDescription);

		// To Reserve Depth Frame Buffer
		depthBuffer.resize(depthWidth * depthHeight);

		// Retrieved Infrared Frame Size
		IFrameDescription* infraredDescription;
		result = infraredSource->get_FrameDescription(&infraredDescription);
		if (FAILED(result)) {
			throw std::exception("Exception : IInfraredFrameSource::get_FrameDescription()");
		}

		result = infraredDescription->get_Width(&infraredWidth); // 512
		if (FAILED(result)) {
			throw std::exception("Exception : IFrameDescription::get_Width()");
		}

		result = infraredDescription->get_Height(&infraredHeight); // 424
		if (FAILED(result)) {
			throw std::exception("Exception : IFrameDescription::get_Height()");
		}

		SafeRelease(infraredDescription);

		// To Reserve Infrared Frame Buffer
		infraredBuffer.resize(infraredWidth * infraredHeight);

		signal_PointXYZ = createSignal<signal_Kinect2_PointXYZ>();
		signal_PointXYZI = createSignal<signal_Kinect2_PointXYZI>();
		signal_PointXYZRGB = createSignal<signal_Kinect2_PointXYZRGB>();
		signal_PointXYZRGBA = createSignal<signal_Kinect2_PointXYZRGBA>();
	}

	pcl::Kinect2Grabber::~Kinect2Grabber() throw()
	{
		stop();

		disconnect_all_slots<signal_Kinect2_PointXYZ>();
		disconnect_all_slots<signal_Kinect2_PointXYZI>();
		disconnect_all_slots<signal_Kinect2_PointXYZRGB>();
		disconnect_all_slots<signal_Kinect2_PointXYZRGBA>();

		thread.join();

		// End Processing
		if (sensor) {
			sensor->Close();
		}
		SafeRelease(sensor);
		SafeRelease(mapper);
		SafeRelease(colorSource);
		SafeRelease(colorReader);
		SafeRelease(depthSource);
		SafeRelease(depthReader);
		SafeRelease(infraredSource);
		SafeRelease(infraredReader);
	}

	void pcl::Kinect2Grabber::start()
	{
		// Open Color Frame Reader
		result = colorSource->OpenReader(&colorReader);
		if (FAILED(result)) {
			throw std::exception("Exception : IColorFrameSource::OpenReader()");
		}

		// Open Depth Frame Reader
		result = depthSource->OpenReader(&depthReader);
		if (FAILED(result)) {
			throw std::exception("Exception : IDepthFrameSource::OpenReader()");
		}

		// Open Infrared Frame Reader
		result = infraredSource->OpenReader(&infraredReader);
		if (FAILED(result)) {
			throw std::exception("Exception : IInfraredFrameSource::OpenReader()");
		}

		running = true;

		thread = boost::thread(&Kinect2Grabber::threadFunction, this);
	}

	void pcl::Kinect2Grabber::stop()
	{
		boost::unique_lock<boost::mutex> lock(mutex);

		quit = true;
		running = false;

		lock.unlock();
	}

	bool pcl::Kinect2Grabber::isRunning() const
	{
		boost::unique_lock<boost::mutex> lock(mutex);

		return running;

		lock.unlock();
	}

	std::string pcl::Kinect2Grabber::getName() const
	{
		return std::string("Kinect2Grabber");
	}

	float pcl::Kinect2Grabber::getFramesPerSecond() const
	{
		return 30.0f;
	}

	void pcl::Kinect2Grabber::threadFunction()
	{
		while (!quit) {
			boost::unique_lock<boost::mutex> lock(mutex);

			// Acquire Latest Color Frame
			IColorFrame* colorFrame = nullptr;
			result = colorReader->AcquireLatestFrame(&colorFrame);
			if (SUCCEEDED(result)) {
				// Retrieved Color Data
				result = colorFrame->CopyConvertedFrameDataToArray(colorBuffer.size() * sizeof(RGBQUAD), reinterpret_cast<BYTE*>(&colorBuffer[0]), ColorImageFormat::ColorImageFormat_Bgra);
				if (FAILED(result)) {
					throw std::exception("Exception : IColorFrame::CopyConvertedFrameDataToArray()");
				}
			}
			SafeRelease(colorFrame);

			// Acquire Latest Depth Frame
			IDepthFrame* depthFrame = nullptr;
			result = depthReader->AcquireLatestFrame(&depthFrame);
			if (SUCCEEDED(result)) {
				// Retrieved Depth Data
				result = depthFrame->CopyFrameDataToArray(depthBuffer.size(), &depthBuffer[0]);
				if (FAILED(result)) {
					throw std::exception("Exception : IDepthFrame::CopyFrameDataToArray()");
				}
			}
			SafeRelease(depthFrame);

			// Acquire Latest Infrared Frame
			IInfraredFrame* infraredFrame = nullptr;
			result = infraredReader->AcquireLatestFrame(&infraredFrame);
			if (SUCCEEDED(result)) {
				// Retrieved Infrared Data
				result = infraredFrame->CopyFrameDataToArray(infraredBuffer.size(), &infraredBuffer[0]);
				if (FAILED(result)) {
					throw std::exception("Exception : IInfraredFrame::CopyFrameDataToArray()");
				}
			}
			SafeRelease(infraredFrame);

			lock.unlock();

			if (signal_PointXYZ->num_slots() > 0) {
				signal_PointXYZ->operator()(convertDepthToPointXYZ(&depthBuffer[0]));
			}

			if (signal_PointXYZI->num_slots() > 0) {
				signal_PointXYZI->operator()(convertInfraredDepthToPointXYZI(&infraredBuffer[0], &depthBuffer[0]));
			}

			if (signal_PointXYZRGB->num_slots() > 0) {
				signal_PointXYZRGB->operator()(convertRGBDepthToPointXYZRGB(&colorBuffer[0], &depthBuffer[0]));
			}

			if (signal_PointXYZRGBA->num_slots() > 0) {
				signal_PointXYZRGBA->operator()(convertRGBADepthToPointXYZRGBA(&colorBuffer[0], &depthBuffer[0]));
			}
		}
	}

	pcl::PointCloud<pcl::PointXYZ>::Ptr pcl::Kinect2Grabber::convertDepthToPointXYZ(UINT16* depthBuffer)
	{
		pcl::PointCloud<pcl::PointXYZ>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZ>());

		cloud->width = static_cast<uint32_t>(depthWidth);
		cloud->height = static_cast<uint32_t>(depthHeight);
		cloud->is_dense = false;

		cloud->points.resize(cloud->height * cloud->width);

		pcl::PointXYZ* pt = &cloud->points[0];
		for (int y = 0; y < depthHeight; y++) {
			for (int x = 0; x < depthWidth; x++, pt++) {
				pcl::PointXYZ point;

				DepthSpacePoint depthSpacePoint = { static_cast<float>(x), static_cast<float>(y) };
				UINT16 depth = depthBuffer[y * depthWidth + x];

				// Coordinate Mapping Depth to Camera Space, and Setting PointCloud XYZ
				CameraSpacePoint cameraSpacePoint = { 0.0f, 0.0f, 0.0f };
				mapper->MapDepthPointToCameraSpace(depthSpacePoint, depth, &cameraSpacePoint);
				point.x = cameraSpacePoint.X;
				point.y = cameraSpacePoint.Y;
				point.z = cameraSpacePoint.Z;

				*pt = point;
			}
		}

		return cloud;
	}

	pcl::PointCloud<pcl::PointXYZI>::Ptr pcl::Kinect2Grabber::convertInfraredDepthToPointXYZI(UINT16* infraredBuffer, UINT16* depthBuffer)
	{
		pcl::PointCloud<pcl::PointXYZI>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZI>());

		cloud->width = static_cast<uint32_t>(depthWidth);
		cloud->height = static_cast<uint32_t>(depthHeight);
		cloud->is_dense = false;

		cloud->points.resize(cloud->height * cloud->width);

		pcl::PointXYZI* pt = &cloud->points[0];
		for (int y = 0; y < depthHeight; y++) {
			for (int x = 0; x < depthWidth; x++, pt++) {
				pcl::PointXYZI point;

				DepthSpacePoint depthSpacePoint = { static_cast<float>(x), static_cast<float>(y) };
				UINT16 depth = depthBuffer[y * depthWidth + x];

				// Setting PointCloud Intensity
				point.intensity = static_cast<float>(infraredBuffer[y * depthWidth + x]);

				// Coordinate Mapping Depth to Camera Space, and Setting PointCloud XYZ
				CameraSpacePoint cameraSpacePoint = { 0.0f, 0.0f, 0.0f };
				mapper->MapDepthPointToCameraSpace(depthSpacePoint, depth, &cameraSpacePoint);
				point.x = cameraSpacePoint.X;
				point.y = cameraSpacePoint.Y;
				point.z = cameraSpacePoint.Z;

				*pt = point;
			}
		}

		return cloud;
	}

	pcl::PointCloud<pcl::PointXYZRGB>::Ptr pcl::Kinect2Grabber::convertRGBDepthToPointXYZRGB(RGBQUAD* colorBuffer, UINT16* depthBuffer)
	{
		pcl::PointCloud<pcl::PointXYZRGB>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZRGB>());

		cloud->width = static_cast<uint32_t>(depthWidth);
		cloud->height = static_cast<uint32_t>(depthHeight);
		cloud->is_dense = false;

		cloud->points.resize(cloud->height * cloud->width);

		pcl::PointXYZRGB* pt = &cloud->points[0];
		for (int y = 0; y < depthHeight; y++) {
			for (int x = 0; x < depthWidth; x++, pt++) {
				pcl::PointXYZRGB point;

				DepthSpacePoint depthSpacePoint = { static_cast<float>(x), static_cast<float>(y) };
				UINT16 depth = depthBuffer[y * depthWidth + x];

				// Coordinate Mapping Depth to Color Space, and Setting PointCloud RGB
				ColorSpacePoint colorSpacePoint = { 0.0f, 0.0f };
				mapper->MapDepthPointToColorSpace(depthSpacePoint, depth, &colorSpacePoint);
				int colorX = static_cast<int>(std::floor(colorSpacePoint.X + 0.5f));
				int colorY = static_cast<int>(std::floor(colorSpacePoint.Y + 0.5f));
				if ((0 <= colorX) && (colorX < colorWidth) && (0 <= colorY) && (colorY < colorHeight)) {
					RGBQUAD color = colorBuffer[colorY * colorWidth + colorX];
					point.b = color.rgbBlue;
					point.g = color.rgbGreen;
					point.r = color.rgbRed;
				}

				// Coordinate Mapping Depth to Camera Space, and Setting PointCloud XYZ
				CameraSpacePoint cameraSpacePoint = { 0.0f, 0.0f, 0.0f };
				mapper->MapDepthPointToCameraSpace(depthSpacePoint, depth, &cameraSpacePoint);
				if ((0 <= colorX) && (colorX < colorWidth) && (0 <= colorY) && (colorY < colorHeight)) {
					point.x = cameraSpacePoint.X;
					point.y = cameraSpacePoint.Y;
					point.z = cameraSpacePoint.Z;
				}

				*pt = point;
			}
		}

		return cloud;
	}

	pcl::PointCloud<pcl::PointXYZRGBA>::Ptr pcl::Kinect2Grabber::convertRGBADepthToPointXYZRGBA(RGBQUAD* colorBuffer, UINT16* depthBuffer)
	{
		pcl::PointCloud<pcl::PointXYZRGBA>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZRGBA>());

		cloud->width = static_cast<uint32_t>(depthWidth);
		cloud->height = static_cast<uint32_t>(depthHeight);
		cloud->is_dense = false;

		cloud->points.resize(cloud->height * cloud->width);

		pcl::PointXYZRGBA* pt = &cloud->points[0];
		for (int y = 0; y < depthHeight; y++) {
			for (int x = 0; x < depthWidth; x++, pt++) {
				pcl::PointXYZRGBA point;

				DepthSpacePoint depthSpacePoint = { static_cast<float>(x), static_cast<float>(y) };
				UINT16 depth = depthBuffer[y * depthWidth + x];

				// Coordinate Mapping Depth to Color Space, and Setting PointCloud RGBA
				ColorSpacePoint colorSpacePoint = { 0.0f, 0.0f };
				mapper->MapDepthPointToColorSpace(depthSpacePoint, depth, &colorSpacePoint);
				int colorX = static_cast<int>(std::floor(colorSpacePoint.X + 0.5f));
				int colorY = static_cast<int>(std::floor(colorSpacePoint.Y + 0.5f));
				if ((0 <= colorX) && (colorX < colorWidth) && (0 <= colorY) && (colorY < colorHeight)) {
					RGBQUAD color = colorBuffer[colorY * colorWidth + colorX];
					point.b = color.rgbBlue;
					point.g = color.rgbGreen;
					point.r = color.rgbRed;
					point.a = color.rgbReserved;
				}

				// Coordinate Mapping Depth to Camera Space, and Setting PointCloud XYZ
				CameraSpacePoint cameraSpacePoint = { 0.0f, 0.0f, 0.0f };
				mapper->MapDepthPointToCameraSpace(depthSpacePoint, depth, &cameraSpacePoint);
				if ((0 <= colorX) && (colorX < colorWidth) && (0 <= colorY) && (colorY < colorHeight)) {
					point.x = cameraSpacePoint.X;
					point.y = cameraSpacePoint.Y;
					point.z = cameraSpacePoint.Z;
				}

				*pt = point;
			}
		}

		return cloud;
	}
}

#endif KINECT2_GRABBER

最后希望大家有问题多多留言，我们共同进步。
转载注明出处，方便有问题的朋友交流，谢谢配合！

点云Amateur
关注
  • 14
    点赞
  • 踩
  • 82
    收藏
    觉得还不错? 一键收藏
  • 43
    评论
专栏目录
kinect 2.0生成点云，并用PCL存储
09-18
由kinect2.0的数据流来生成点云很容易实现，可是实用性不大，为了提高实用性，我写了一个通过读取kinect保存的jpg图片和其对应的深度txt文件，来生成点云的程序。生成的点云最终用pcl保存为ply或pcd格式的点云文件。我自己摸索的过程中走了很多弯路，分享出来帮助有相同需要的朋友们少走弯路。（注：碍于上传文件大小限制，我只上传了所有的代码以及一副实例图片和对应的深度txt文件，需自己正确配置opencv+pcl+kinect2.0）
KinectV2点云的获取与保存
一码当先
07-06 1万+
本实验是利用Kinect V2、PCL1.8、vs2013实现获取点云并显示，并在第100次刷新时将获取点云保存为pcd点云文件。实验开发所用的是Window10 操作系统，利用cmake配置项目，最后用vs2013打开，编译项目，运行程序。项目工程文件见：http://download.csdn.net/detail/cs2539263027/9891090，vs2013运行结果如下图所示：
使用 PCL 库将点云数据保存为 PCD 格式文件
最新发布
人人都懂物联网
05-28 1559
PCD 全称 Point Cloud Data，是一种存储三维点云数据的文件格式，本教程将介绍如何使用 PCL 点云库将点云数据写入 PCD 文件。由于 PCD 是一种开放数据格式，因此你可以使用各种点云处理工具来读取和写入 PCD 文件，并进一步对点云数据进行处理。本教程的示例代码和点云数据可在下载。
kinect+opengl 生成并显示点云
04-05
kinect+opengl 生成并显示点云 可查看博客http://blog.csdn.net/jiaojialulu/article/details/53089353
PCL——Kinect v2 保存点云数据
strongjay的博客
03-22 750
参考：https://www.cnblogs.com/yhlx125/p/6643821.html #include <vtkAutoInit.h> #include <Windows.h> #include <iostream> #include <kinect.h> #include <pcl/io/pcd_io.h> #include <pcl/point_types.h> #include <pcl/visualiza
基于ROS机器人的3D物体识别与三维重建(二) Kinect2相机标定与点云获取
Ray Home
11-20 1万+
（二）Kinect2相机标定与点云数据获取
使用kinect2获取点云数据，滤波保存转为octomap
愿万事胜意
12-11 3972
准备 硬件：Kinect v2 系统：Ubuntu 16.04 ROS kinetic 前期准备：安装Kinect相关驱动，参考博客：安装kinect驱动配置 在Rviz中查看Kinect采集到的点云信息 驱动安装完成以后，可以连接上设备，使用以下命令测试一下能否在Rviz中看到点云信息： roslaunch kinect2_bridge kinect2_bridge.laun...
PCL1.7.2+Kinect V 2.0获取并保存点云PCD数据程序
04-07
本文在VS2012开发平台上面配置PCL1.7.2+Kinect V 2.0SDK+opencv2.4.9 ，使用最新的Kinect V 2.0传感器设备获取场景中的深度图像和彩色图像，并将二者转换保存为PCL数据库所使用的PCD点云数据格式，然后借助编程算法...
基于深度相机Kinect2.0的点云获取方案实现（C++版），包含SDK和全部代码
07-17
总结来说，本项目提供了一个基于Kinect 2.0的C++点云获取方案，涵盖了从硬件连接、SDK使用到代码实现的全过程。通过学习和实践，开发者不仅可以掌握点云数据的获取，还能进一步了解C++在处理三维数据方面的潜力。这...
Kinect2.0+PCL实现点云显示
09-10
在vs2013平台下用c++实现的通过Kinect获取场景点云数据并显示的程序。获取线程从Kinect中读取深度数据与图像数据，经坐标映射与融合后生成目标点云数据，通过boost的信号槽机制传输到主线程中并将其使用PCL提供的...
KinectV2:使用Kinect V2的3D点云
05-18
KinectV2 使用Kinect V2的3D点云 libfreenect2用于与kinect点云库进行接口，该库用于从图像中获取点提示并使用点云库进行可视化 框架抓取器的功能在Kinect2Grabber类中存在。将抓取器/ Kinect2Grabber构建为 采集器/ Kinect2Grabber- $ mkdir构建采集器/ Kinect2Grabber- $ cd构建&& cmake ..采集器/ Kinect2Grabber- $ make install 然后通过使用grabber /目录中的CMakeLists.txt构建可执行文件。可执行文件链接到通过构建Kinect2Grabber生成的共享库libkinectgrabber.so。 跑步： 采集器-$ sudo ./grabber
kinect openni绘制点云
09-24
kinect 运用Openni2.0 产生点云 详情见我的博客： http://blog.csdn.net/jinshengtao/article/details/48718395
VS2013+KinectV2获取点云
07-06
利用Kinect sdk2.0和PCL1.8，在vs2013中使用cmake配置工程项目获取点云，并在第100次刷新时保存点云。 详见博文http://blog.csdn.net/cs2539263027， 内含cmake配置vs2013工程教程。
kinect生成pcl点云三维坐标txt
05-24
利用kinect深度信息,生成供pcl点云库使用的三维坐标
PCL+VS2015实现点云可视化
01-10
本文将深入探讨如何在Windows 10 x64环境下，利用Visual Studio 2015（VS2015）与Point Cloud Library（PCL 1.8.1）来实现点云数据的可视化。提供的压缩包文件包含了必要的解决方案文件（PointCloudVisualization....
三维视觉--基于Kinect2.0深度相机的点云获取方案实现（C++版）
低调猫熊的博客
07-17 1311
上一篇中使用的点云获取设备是Intel Realsense d455相机，这两天接触的相机不少，也发现很多点云检测和分割的论文中使用的都是Kinect相机，今天就再分享一篇使用Kinect2.0获取点云并使用C++实现。首先还是相机SDK的下载和安装：可以去官网下载，也可以到我之前分享的百度网盘获取。
Kinect开发遇到的问题
qq_40791099的博客
06-16 675
获取数据 首先说一下背景： 获取方法：用官方的SDK获取彩色图像和深度图像，同样用官方的对齐函数（m_pCoordinateMapper）将两幅图像对齐，然后生成点云（用自己对齐的方法也试了，虽然没有重影，但是能明显看到颜色移位，说明没有对齐，我用的别人的参数，没有自己标定，所以这个方法暂时放下。PS：去年用了这个方法就是别人的参数，效果也很好，不懂为啥过了一年啥都变了） 环境：正常屋内，白炽灯 去年做的时候没有问题（或者说问题不明显），今年拍的时候特别大的问题。 去年拍的：彩色图映射到深度图上，可以看到
Kinect v2.0原理介绍之六：Kinect深度图与彩色图的坐标校准
热门推荐
MachineLP的专栏
09-04 1万+
~~有兴趣的加kinect算法交流群：462964980 kinect的深度数据和彩色数据的分辨率以及视场大小都不一样，不能直接对应起来，想要把深度和彩色融合起来就要费一番周折了。 看了MSDN中kinectSDK的介绍，发现了一个ICoordinateMapper的类，看介绍知道里面有一个成员函数MapDepthFrameToColorSpace可以实现深度图和彩色图的坐标校
Kinect2.0之使用KinectSDK自带的KinectStudio进行数据采集
csuzhaoqinghui的博客
11-29 8734
去年一直摆弄Kinect2.0，发现二代Kinect和一代存在差别较大，采集程序也大致不一样了。 在这里我主要是介绍两种采集方法，一种是基于KinectSDK驱动直接采集的，能够采集到深度图和彩色图。第二种是采用OPENNI2间接驱动KinectSDK进行采集，能够采集到ONI格式的视频。这篇博文我主要介绍怎么采用KinectSDK Studio分别采集RGB信息和深度信息。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 43
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值