PCL点云库学习笔记（可视化1）

最新推荐文章于 2024-04-19 11:33:19 发布
最新推荐文章于 2024-04-19 11:33:19 发布
阅读量1.3k 收藏 10
点赞数
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Catog/article/details/107599684
版权

PCL点云库学习笔记（可视化）

可视化

一、CloudViewer

1.1 用几行代码可视化应用程序中的某些内容

#include <pcl/visualization/cloud_viewer.h>
 //
 void foo ()
 {
   pcl::PointCloud<pcl::PointXYZRGB>::Ptr cloud;
   //..........填充点云
   //创建一个CloudViewer类的可视化的对象，进行简单的显示
   pcl::visualization::CloudViewer viewer ("Simple Cloud Viewer");
   viewer.showCloud (cloud);
   
   while (!viewer.wasStopped ())
   {
   }
 }

1.2 完整的可视化例子
例子中PCLVisualizer``是``CloudViewer的后端，但它在自己的线程中运行。要访问它，必须使用回调函数.

#include <pcl/visualization/cloud_viewer.h>
#include <iostream>
#include <pcl/io/io.h>
#include <pcl/io/pcd_io.h>
   
int user_data;
 
//下面的函数是回调函数，只执行一次，参数是PCLVisualizer可视化对象
//设置可视化背景的颜色，和添加一个圆球几何体
void viewerOneOff (pcl::visualization::PCLVisualizer& viewer)
{
   viewer.setBackgroundColor (1.0, 0.5, 1.0);//设置背景颜色
   pcl::PointXYZ o;//创建点云中的一个点
   o.x = 1.0;
   o.y = 0;
   o.z = 0;
   viewer.addSphere (o, 0.25, "sphere", 0);//以这个点为圆心创建一个球
   std::cout << "i only run once" << std::endl;
   
}
 
 //在可视化对象中，添加一个刷新显示字符串  
void viewerPsycho (pcl::visualization::PCLVisualizer& viewer)
{
   static unsigned count = 0;
   std::stringstream ss;
   ss << "Once per viewer loop: " << count++;
   viewer.removeShape ("text", 0);//从屏幕中删除添加的形状
   viewer.addText (ss.str(), 200, 300, "text", 0);//在屏幕上加一行文本
   
   //FIXME: possible race condition here:
   user_data++;
}
   
int main ()
{
   //创建点云，然后读取PCD文件
   pcl::PointCloud<pcl::PointXYZRGBA>::Ptr cloud (new pcl::PointCloud<pcl::PointXYZRGBA>);
   pcl::io::loadPCDFile ("my_point_cloud.pcd", *cloud);
   
   //可视化对象
   pcl::visualization::CloudViewer viewer("Cloud Viewer");
   
   //停在此处，直到渲染出点云
   viewer.showCloud(cloud);
   
   //use the following functions to get access to the underlying more advanced/powerful
   //PCLVisualizer
   
  //在可视化的时候，创建球的函数，只调用一次
   viewer.runOnVisualizationThreadOnce (viewerOneOff);
   
  //在渲染输出时每一次都调用
   viewer.runOnVisualizationThread (viewerPsycho);
   while (!viewer.wasStopped ())
   {
   //you can also do cool processing here
   //FIXME: Note that this is running in a separate thread from viewerPsycho
   //and you should guard against race conditions yourself...
   user_data++;
   }
   return 0;
}

1.3编译报错
1.编译警告

error C4996: 'std::uninitialized_copy::_Unchecked_iterators::_Deprecate': Call to 'std::uninitialized_copy' with parameters that may be unsafe - this call relies on the caller to check that the passed values are correct. To disable this warning, use -D_SCL_SECURE_NO_WARNINGS. See documentation on how to use Visual C++ 'Checked Iterators

解决：属性-> c/c++ -> 预处理器 -> 预处理器定义 里添加_SCL_SECURE_NO_WARNINGS
2.error LNK2019: 无法解析的外部符号，lib文件未引入，添加

#pragma comment(lib,"User32.lib")
#pragma comment(lib,"ws2_32.lib")
#pragma comment(lib, "gdi32.lib")

3.运行vtk文件库的时候出现错误,分别添加

#include "vtkAutoInit.h"  //vtk库
VTK_MODULE_INIT(vtkRenderingOpenGL); 
VTK_MODULE_INIT(vtkInteractionStyle);

二、可视化深度图像

#include <iostream>

#include <pcl/common/common_headers.h>
#include <pcl/range_image/range_image.h>
#include <pcl/io/pcd_io.h>
#include <pcl/visualization/range_image_visualizer.h>
#include <pcl/visualization/pcl_visualizer.h>
#include <pcl/console/parse.h>
#include "vtkAutoInit.h"  //vtk库



typedef pcl::PointXYZ PointType;

//全局参数-
float angular_resolution_x = 0.5f,
angular_resolution_y = angular_resolution_x;
pcl::RangeImage::CoordinateFrame coordinate_frame = pcl::RangeImage::CAMERA_FRAME;
bool live_update = false;

// 打印帮助
void  printUsage(const char* progName)
{
	std::cout << "\n\nUsage: " << progName << " [options] <scene.pcd>\n\n"
		<< "Options:\n"
		<< "-------------------------------------------\n"
		<< "-rx <float>  angular resolution in degrees (default " << angular_resolution_x << ")\n"
		<< "-ry <float>  angular resolution in degrees (default " << angular_resolution_y << ")\n"
		<< "-c <int>     coordinate frame (default " << (int)coordinate_frame << ")\n"
		<< "-l           live update - update the range image according to the selected view in the 3D viewer.\n"
		<< "-h           this help\n"
		<< "\n\n";
}

//设置视点
void  setViewerPose(pcl::visualization::PCLVisualizer& viewer, const Eigen::Affine3f& viewer_pose)
{
	Eigen::Vector3f pos_vector = viewer_pose * Eigen::Vector3f(0, 0, 0);
	Eigen::Vector3f look_at_vector = viewer_pose.rotation() * Eigen::Vector3f(0, 0, 1) + pos_vector;
	Eigen::Vector3f up_vector = viewer_pose.rotation() * Eigen::Vector3f(0, -1, 0);
	viewer.setCameraPosition(pos_vector[0], pos_vector[1], pos_vector[2],
		look_at_vector[0], look_at_vector[1], look_at_vector[2],
		up_vector[0], up_vector[1], up_vector[2]);
}


// -----Main-----

int  main(int argc, char** argv)
{
	VTK_MODULE_INIT(vtkRenderingOpenGL);
	VTK_MODULE_INIT(vtkInteractionStyle);
	
	//解析命令行参数
	if (pcl::console::find_argument(argc, argv, "-h") >= 0)
	{
		printUsage(argv[0]);
		return 0;
	}
	if (pcl::console::find_argument(argc, argv, "-l") >= 0)
	{
		live_update = true;
		std::cout << "Live update is on.\n";
	}
	if (pcl::console::parse(argc, argv, "-rx", angular_resolution_x) >= 0)
		std::cout << "Setting angular resolution in x-direction to " << angular_resolution_x << "deg.\n";
	if (pcl::console::parse(argc, argv, "-ry", angular_resolution_y) >= 0)
		std::cout << "Setting angular resolution in y-direction to " << angular_resolution_y << "deg.\n";
	int tmp_coordinate_frame;
	if (pcl::console::parse(argc, argv, "-c", tmp_coordinate_frame) >= 0)
	{
		coordinate_frame = pcl::RangeImage::CoordinateFrame(tmp_coordinate_frame);
		std::cout << "Using coordinate frame " << (int)coordinate_frame << ".\n";
	}
	angular_resolution_x = pcl::deg2rad(angular_resolution_x);
	angular_resolution_y = pcl::deg2rad(angular_resolution_y);

	// 读取给点的点云或自行创建随机点云
	pcl::PointCloud<PointType>::Ptr point_cloud_ptr(new pcl::PointCloud<PointType>);
	pcl::PointCloud<PointType>& point_cloud = *point_cloud_ptr;
	Eigen::Affine3f scene_sensor_pose(Eigen::Affine3f::Identity());
	std::vector<int> pcd_filename_indices = pcl::console::parse_file_extension_argument(argc, argv, "pcd");
	if (!pcd_filename_indices.empty())
	{
		std::string filename = argv[pcd_filename_indices[0]];
		if (pcl::io::loadPCDFile(filename, point_cloud) == -1)
		{
			std::cout << "Was not able to open file \"" << filename << "\".\n";
			printUsage(argv[0]);
			return 0;
		}
		scene_sensor_pose = Eigen::Affine3f(Eigen::Translation3f(point_cloud.sensor_origin_[0],
			point_cloud.sensor_origin_[1],
			point_cloud.sensor_origin_[2])) *
			Eigen::Affine3f(point_cloud.sensor_orientation_);
	}
	else
	{
		std::cout << "\nNo *.pcd file given => Generating example point cloud.\n\n";
		for (float x = -0.5f; x <= 0.5f; x += 0.01f)
		{
			for (float y = -0.5f; y <= 0.5f; y += 0.01f)
			{
				PointType point;  point.x = x;  point.y = y;  point.z = 2.0f - y;
				point_cloud.points.push_back(point);
			}
		}
		point_cloud.width = (int)point_cloud.points.size();  point_cloud.height = 1;
	}

	// 从点云创建深度图像对象
	float noise_level = 0.0;
	float min_range = 0.0f;
	int border_size = 1;
	pcl::RangeImage::Ptr range_image_ptr(new pcl::RangeImage);
	pcl::RangeImage& range_image = *range_image_ptr;
	range_image.createFromPointCloud(point_cloud, angular_resolution_x, angular_resolution_y,
	pcl::deg2rad(360.0f), pcl::deg2rad(180.0f),
	scene_sensor_pose, coordinate_frame, noise_level, min_range, border_size);


	
	//读取点云，并创建深度图像
	//创建了两个可视化窗口，第一个是点云的3D可视化窗口，没有颜色信息的
	pcl::visualization::PCLVisualizer viewer("3D Viewer");
	viewer.setBackgroundColor(1, 1, 1);//设置背景为白色

	//把上面从点云中创建的深度图像点云设置为黑色
	pcl::visualization::PointCloudColorHandlerCustom<pcl::PointWithRange> range_image_color_handler(range_image_ptr, 0, 0, 0);
	//添加深度图像点云，黑色，添加后的点云ID为range image
	viewer.addPointCloud(range_image_ptr, range_image_color_handler, "range image");
	//设置点云的大小为1
	viewer.setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 1, "range image");

	//注释的部分用于添加坐标系，对原始点进行可视化
	//viewer.addCoordinateSystem (1.0f, "global");
	//PointCloudColorHandlerCustom<PointType> point_cloud_color_handler (point_cloud_ptr, 150, 150, 150);
	//viewer.addPointCloud (point_cloud_ptr, point_cloud_color_handler, "original point cloud");

	viewer.initCameraParameters();
	setViewerPose(viewer, range_image.getTransformationToWorldSystem());//设置视点参数

    // 第二个是深度图像可视化窗口，把range image的深度信息通过颜色进行显示
	pcl::visualization::RangeImageVisualizer range_image_widget("Range image");
	range_image_widget.showRangeImage(range_image);

	//启动主循环以保证可视化代码的有效性，直到窗口关闭才结束循环
	while (!viewer.wasStopped())
	{
		range_image_widget.spinOnce();
		viewer.spinOnce();
		pcl_sleep(0.01);

		if (live_update)
		{
			scene_sensor_pose = viewer.getViewerPose();
			range_image.createFromPointCloud(point_cloud, angular_resolution_x, angular_resolution_y,
				pcl::deg2rad(360.0f), pcl::deg2rad(180.0f),
				scene_sensor_pose, pcl::RangeImage::LASER_FRAME, noise_level, min_range, border_size);
			range_image_widget.showRangeImage(range_image);
		}
	}
}

调试情况：没有输入点云，程序自行创建了点云
在这里插入图片描述

三、Visualizer

PCLVisualizer 是比CloudViewer功能更全的类，例子中示范了这个类的功能。
包括：最基本的点云可视化、带颜色字段的点云可视化、自定义颜色点云可视化、可视化特征、绘制图形、多视窗显示等

#include <iostream>
#include <thread>

#include <pcl/common/common_headers.h>
#include <pcl/features/normal_3d.h>
#include <pcl/io/pcd_io.h>
#include <pcl/visualization/pcl_visualizer.h>
#include <pcl/console/parse.h>
#include "vtkAutoInit.h"  //vtk库

using namespace std::chrono_literals;

// 帮助信息
void printUsage(const char* progName)
{
	std::cout << "\n\nUsage: " << progName << " [options]\n\n"
		<< "Options:\n"
		<< "-------------------------------------------\n"
		<< "-h           this help\n"
		<< "-s           Simple visualisation example\n"
		<< "-r           RGB colour visualisation example\n"
		<< "-c           Custom colour visualisation example\n"
		<< "-n           Normals visualisation example\n"
		<< "-a           Shapes visualisation example\n"
		<< "-v           Viewports example\n"
		<< "-i           Interaction Customization example\n"
		<< "\n\n";
}


//这个函数实现最基本的点云可视化操作
//显示单个具有xyz信息的点云，改变背景颜色，显示坐标轴
pcl::visualization::PCLVisualizer::Ptr simpleVis(pcl::PointCloud<pcl::PointXYZ>::ConstPtr cloud)
{
	// 创建视窗对象，标题为3Dviewer
	//将其定义为共享指针，保证在全局中使用
	pcl::visualization::PCLVisualizer::Ptr viewer(new pcl::visualization::PCLVisualizer("3D Viewer"));
	viewer->setBackgroundColor(0, 0, 0);//背景为黑色

	//添加点云到视窗中，并且定义一个ID号，使得这个点云可以在其他函数中调用
	//更新点云使用UpdatePointCloud
	viewer->addPointCloud<pcl::PointXYZ>(cloud, "sample cloud");

	viewer->setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 1, "sample cloud");//显示点云的尺寸
	viewer->addCoordinateSystem(1.0);//添加一个圆柱体坐标轴，圆柱体大小为1
	viewer->initCameraParameters();
	return (viewer);
}

//实现彩色点云可视化
pcl::visualization::PCLVisualizer::Ptr rgbVis(pcl::PointCloud<pcl::PointXYZRGB>::ConstPtr cloud)
{
	//不同的是，创建带有RGB字段的点云类型
	pcl::visualization::PCLVisualizer::Ptr viewer(new pcl::visualization::PCLVisualizer("3D Viewer"));
	viewer->setBackgroundColor(0, 0, 0);

	//用hander rgb field得到点云的RGB颜色字段，对每个点赋予颜色
	pcl::visualization::PointCloudColorHandlerRGBField<pcl::PointXYZRGB> rgb(cloud);
	viewer->addPointCloud<pcl::PointXYZRGB>(cloud, rgb, "sample cloud");
	viewer->setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 3, "sample cloud");
	viewer->addCoordinateSystem(1.0);
	viewer->initCameraParameters();
	return (viewer);
}

//自定义点云颜色
pcl::visualization::PCLVisualizer::Ptr customColourVis(pcl::PointCloud<pcl::PointXYZ>::ConstPtr cloud)
{
	//窗口和背景色
	pcl::visualization::PCLVisualizer::Ptr viewer(new pcl::visualization::PCLVisualizer("3D Viewer"));
	viewer->setBackgroundColor(0, 0, 0);

	//用自定义颜色处理器hander custom设置颜色，不论什么类型的点云都是可以
	//与获取颜色字段不同，函数参数里还设置了颜色
	pcl::visualization::PointCloudColorHandlerCustom<pcl::PointXYZ> single_color(cloud, 0, 255, 0);

	//把颜色加到点云上
	viewer->addPointCloud<pcl::PointXYZ>(cloud, single_color, "sample cloud");
	viewer->setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 3, "sample cloud");
	viewer->addCoordinateSystem(1.0);
	viewer->initCameraParameters();
	return (viewer);
}

//可视化法线等特征
pcl::visualization::PCLVisualizer::Ptr normalsVis(
	pcl::PointCloud<pcl::PointXYZRGB>::ConstPtr cloud, pcl::PointCloud<pcl::Normal>::ConstPtr normals)
{
	
	pcl::visualization::PCLVisualizer::Ptr viewer(new pcl::visualization::PCLVisualizer("3D Viewer"));
	viewer->setBackgroundColor(0, 0, 0);

	pcl::visualization::PointCloudColorHandlerRGBField<pcl::PointXYZRGB> rgb(cloud);
	viewer->addPointCloud<pcl::PointXYZRGB>(cloud, rgb, "sample cloud");
	viewer->setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 3, "sample cloud");

	//得到法线之后，就可以显示法线，每10个点显示一个，法线的长度是0.05
	viewer->addPointCloudNormals<pcl::PointXYZRGB, pcl::Normal>(cloud, normals, 10, 0.05, "normals");
	viewer->addCoordinateSystem(1.0);
	viewer->initCameraParameters();
	return (viewer);
}

//绘制普通形状
pcl::visualization::PCLVisualizer::Ptr shapesVis(pcl::PointCloud<pcl::PointXYZRGB>::ConstPtr cloud)
{

	pcl::visualization::PCLVisualizer::Ptr viewer(new pcl::visualization::PCLVisualizer("3D Viewer"));
	viewer->setBackgroundColor(0, 0, 0);
	pcl::visualization::PointCloudColorHandlerRGBField<pcl::PointXYZRGB> rgb(cloud);
	viewer->addPointCloud<pcl::PointXYZRGB>(cloud, rgb, "sample cloud");
	viewer->setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 3, "sample cloud");
	viewer->addCoordinateSystem(1.0);
	viewer->initCameraParameters();

    //增加从点云第一个点到最后一个点的连线
	//以第一个点为中心，增加一个半径为0.2的球体，
	viewer->addLine<pcl::PointXYZRGB>(cloud->points[0],cloud->points[cloud->size() - 1], "line");
	viewer->addSphere(cloud->points[0], 0.2, 0.5, 0.5, 0.0, "sphere");

	//绘制一个平面，以平面标准方程来绘制，绘制一个以原点为中心，沿z轴方向的平面
	pcl::ModelCoefficients coeffs;
	coeffs.values.push_back(0.0);
	coeffs.values.push_back(0.0);
	coeffs.values.push_back(1.0);
	coeffs.values.push_back(0.0);
	viewer->addPlane(coeffs, "plane");

	//添加一个锥形
	coeffs.values.clear();
	coeffs.values.push_back(0.3);
	coeffs.values.push_back(0.3);
	coeffs.values.push_back(0.0);
	coeffs.values.push_back(0.0);
	coeffs.values.push_back(1.0);
	coeffs.values.push_back(0.0);
	coeffs.values.push_back(5.0);
	viewer->addCone(coeffs, "cone");

	return (viewer);
}

//多视口显示
pcl::visualization::PCLVisualizer::Ptr viewportsVis(
	pcl::PointCloud<pcl::PointXYZRGB>::ConstPtr cloud, pcl::PointCloud<pcl::Normal>::ConstPtr normals1, pcl::PointCloud<pcl::Normal>::ConstPtr normals2)
{
	//比较不同搜索半径的 法线显示

	pcl::visualization::PCLVisualizer::Ptr viewer(new pcl::visualization::PCLVisualizer("3D Viewer"));
	viewer->initCameraParameters();

	//创建新的窗口
	int v1(0);
	viewer->createViewPort(0.0, 0.0, 0.5, 1.0, v1);//x轴的最小最大值，y轴的最小最大值，标识号
	viewer->setBackgroundColor(0, 0, 0, v1);//设置背景颜色
	viewer->addText("Radius: 0.01", 10, 10, "v1 text", v1);//添加一行标签
	pcl::visualization::PointCloudColorHandlerRGBField<pcl::PointXYZRGB> rgb(cloud);
	viewer->addPointCloud<pcl::PointXYZRGB>(cloud, rgb, "sample cloud1", v1);//设置点云颜色

	int v2(0);
	viewer->createViewPort(0.5, 0.0, 1.0, 1.0, v2);
	viewer->setBackgroundColor(0.3, 0.3, 0.3, v2);
	viewer->addText("Radius: 0.1", 10, 10, "v2 text", v2);
	pcl::visualization::PointCloudColorHandlerCustom<pcl::PointXYZRGB> single_color(cloud, 0, 255, 0);
	viewer->addPointCloud<pcl::PointXYZRGB>(cloud, single_color, "sample cloud2", v2);

	viewer->setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 3, "sample cloud1");
	viewer->setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 3, "sample cloud2");
	viewer->addCoordinateSystem(1.0);

	viewer->addPointCloudNormals<pcl::PointXYZRGB, pcl::Normal>(cloud, normals1, 10, 0.05, "normals1", v1);
	viewer->addPointCloudNormals<pcl::PointXYZRGB, pcl::Normal>(cloud, normals2, 10, 0.05, "normals2", v2);

	return (viewer);
}


unsigned int text_id = 0;
void keyboardEventOccurred(const pcl::visualization::KeyboardEvent &event,
	void* viewer_void)
{
	pcl::visualization::PCLVisualizer *viewer = static_cast<pcl::visualization::PCLVisualizer *> (viewer_void);
	if (event.getKeySym() == "r" && event.keyDown())
	{
		std::cout << "r was pressed => removing all text" << std::endl;

		char str[512];
		for (unsigned int i = 0; i < text_id; ++i)
		{
			sprintf(str, "text#%03d", i);
			viewer->removeShape(str);
		}
		text_id = 0;
	}
}

void mouseEventOccurred(const pcl::visualization::MouseEvent &event,
	void* viewer_void)
{
	pcl::visualization::PCLVisualizer *viewer = static_cast<pcl::visualization::PCLVisualizer *> (viewer_void);
	if (event.getButton() == pcl::visualization::MouseEvent::LeftButton &&
		event.getType() == pcl::visualization::MouseEvent::MouseButtonRelease)
	{
		std::cout << "Left mouse button released at position (" << event.getX() << ", " << event.getY() << ")" << std::endl;

		char str[512];
		sprintf(str, "text#%03d", text_id++);
		viewer->addText("clicked here", event.getX(), event.getY(), str);
	}
}

pcl::visualization::PCLVisualizer::Ptr interactionCustomizationVis()
{
	pcl::visualization::PCLVisualizer::Ptr viewer(new pcl::visualization::PCLVisualizer("3D Viewer"));
	viewer->setBackgroundColor(0, 0, 0);
	viewer->addCoordinateSystem(1.0);

	viewer->registerKeyboardCallback(keyboardEventOccurred, (void*)viewer.get());
	viewer->registerMouseCallback(mouseEventOccurred, (void*)viewer.get());

	return (viewer);
}



int main(int argc, char** argv)
{
	VTK_MODULE_INIT(vtkRenderingOpenGL);
	VTK_MODULE_INIT(vtkInteractionStyle);
	
	// --------------------------------------
	// -----Parse Command Line Arguments-----
	// --------------------------------------
	if (pcl::console::find_argument(argc, argv, "-h") >= 0)
	{
		printUsage(argv[0]);
		return 0;
	}
    
	//布尔变量，每个例子都先false
	bool simple(false), rgb(false), custom_c(false), normals(false),
		shapes(false), viewports(false), interaction_customization(false);

	if (pcl::console::find_argument(argc, argv, "-s") >= 0)
	{
		simple = true;
		std::cout << "Simple visualisation example\n";
	}
	else if (pcl::console::find_argument(argc, argv, "-c") >= 0)
	{
		custom_c = true;
		std::cout << "Custom colour visualisation example\n";
	}
	else if (pcl::console::find_argument(argc, argv, "-r") >= 0)
	{
		rgb = true;
		std::cout << "RGB colour visualisation example\n";
	}
	else if (pcl::console::find_argument(argc, argv, "-n") >= 0)
	{
		normals = true;
		std::cout << "Normals visualisation example\n";
	}
	else if (pcl::console::find_argument(argc, argv, "-a") >= 0)
	{
		shapes = true;
		std::cout << "Shapes visualisation example\n";
	}
	else if (pcl::console::find_argument(argc, argv, "-v") >= 0)
	{
		viewports = true;
		std::cout << "Viewports example\n";
	}
	else if (pcl::console::find_argument(argc, argv, "-i") >= 0)
	{
		interaction_customization = true;
		std::cout << "Interaction Customization example\n";
	}
	else
	{
		printUsage(argv[0]);
		return 0;
	}

	// 创建基础的和颜色的点云
	pcl::PointCloud<pcl::PointXYZ>::Ptr basic_cloud_ptr(new pcl::PointCloud<pcl::PointXYZ>);
	pcl::PointCloud<pcl::PointXYZRGB>::Ptr point_cloud_ptr(new pcl::PointCloud<pcl::PointXYZRGB>);
	std::cout << "Generating example point clouds.\n\n";

	//创建一个沿z轴的圆柱，颜色红绿蓝渐变
	std::uint8_t r(255), g(15), b(15);
	for (float z(-1.0); z <= 1.0; z += 0.05)
	{
		for (float angle(0.0); angle <= 360.0; angle += 5.0)
		{
			//创建基本点basic point，存到点云basic cloud ptr里面
			pcl::PointXYZ basic_point;
			basic_point.x = 0.5 * std::cos(pcl::deg2rad(angle));
			basic_point.y = sinf(pcl::deg2rad(angle));
			basic_point.z = z;
			basic_cloud_ptr->points.push_back(basic_point);

			//创建带颜色字段的点point，存到点云point cloud ptr
			pcl::PointXYZRGB point;
			point.x = basic_point.x;
			point.y = basic_point.y;
			point.z = basic_point.z;
			std::uint32_t rgb = (static_cast<std::uint32_t>(r) << 16 |static_cast<std::uint32_t>(g) << 8 | static_cast<std::uint32_t>(b));
			point.rgb = *reinterpret_cast<float*>(&rgb);
			point_cloud_ptr->points.push_back(point);
		}

		if (z < 0.0)
		{
			r -= 12;
			g += 12;
		}
		else
		{
			g -= 12;
			b += 12;
		}
	}
	//设置点云个数
	basic_cloud_ptr->width = (int)basic_cloud_ptr->points.size();
	basic_cloud_ptr->height = 1;
	point_cloud_ptr->width = (int)point_cloud_ptr->points.size();
	point_cloud_ptr->height = 1;

	// 半径0.5邻域计算法线
	pcl::NormalEstimation<pcl::PointXYZRGB, pcl::Normal> ne;
	ne.setInputCloud(point_cloud_ptr);
	pcl::search::KdTree<pcl::PointXYZRGB>::Ptr tree(new pcl::search::KdTree<pcl::PointXYZRGB>());
	ne.setSearchMethod(tree);
	pcl::PointCloud<pcl::Normal>::Ptr cloud_normals1(new pcl::PointCloud<pcl::Normal>);
	ne.setRadiusSearch(0.05);
	ne.compute(*cloud_normals1);

	// 半径0.5邻域计算法线
	pcl::PointCloud<pcl::Normal>::Ptr cloud_normals2(new pcl::PointCloud<pcl::Normal>);
	ne.setRadiusSearch(0.1);
	ne.compute(*cloud_normals2);

	//看哪一个布尔变量生效了，就执行哪个例子
	pcl::visualization::PCLVisualizer::Ptr viewer;
	if (simple)
	{
		viewer = simpleVis(basic_cloud_ptr);
	}
	else if (rgb)
	{
		viewer = rgbVis(point_cloud_ptr);
	}
	else if (custom_c)
	{
		viewer = customColourVis(basic_cloud_ptr);
	}
	else if (normals)
	{
		viewer = normalsVis(point_cloud_ptr, cloud_normals2);
	}
	else if (shapes)
	{
		viewer = shapesVis(point_cloud_ptr);
	}
	else if (viewports)
	{
		viewer = viewportsVis(point_cloud_ptr, cloud_normals1, cloud_normals2);
	}
	else if (interaction_customization)
	{
		viewer = interactionCustomizationVis();
	}

	//--------------------
	// -----Main loop-----
	//--------------------
	while (!viewer->wasStopped())
	{
		viewer->spinOnce(100);
		std::this_thread::sleep_for(100ms);
	}
}

编译情况
在这里插入图片描述

catog
关注
  • 0
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
pcl_viewer的使用小记
非晚非晚的博客
05-23 9677
虽然有很多查看点云的方式，但是要说在linux系统下，最简单快捷的方式还得说是pcl_viewer，在此记录一下自己觉得还挺好用的几点pcl_viewer操作。 1. pcl_viewer安装2. 查看点云以及相应的快捷键3. 查看点云的坐标4. 启用xyz轴5. 一次打开多个pcd文件
PCL点云库(1) — 简介与数据类型
几度春风里的博客
04-20 2778
PCL（点云库）_百度百科PCL（Point Cloud Library）是在吸收了前人点云相关研究基础上建立起来的大型跨平台开源C++编程库，它实现了大量点云相关的通用算法和高效数据结构，涉及到点云获取、滤波、分割、配准、检索、特征提取、识别、追踪、曲面重建、可视化等。支持多种操作系统平台，可在Windows、Linux、Android、Mac OS X、部分嵌入式实时系统上运行。如果说OpenCV是2D信息获取与处理的结晶，那么PCL就在3D信息获取与处理上具有同等地位。
【PCL】教程 concatenate_clouds 点云的创建、数据填充、拼接合并和字段的合并
最新发布
cxyhjl的博客
04-19 472
命令行参数 -f, 合并字段 点+法向量Cloud A: 1.28125 577.094 197.938 828.125 599.031 491.375 358.688 917.438 842.562 764.5 178.281 879.531 727.531 525.844 311.281 Cloud B: 15.3438 93.5938 373....
Open3D：读写点云与可视化（C++）
累了就要打游戏
08-30 9708
迭代 //Open3D #include "Open3D/Open3D.h" //Eigen #include "Eigen/Dense" void testOpen3D::xjGetInformation(const QString &pcPath) { /* read PC */ auto cloud_ptr = std::make_shared<open3d::geometry::PointCloud>(); if (!open3d::io::ReadPointCl
CloudCompare——计算点云的八叉树并可视化
点云侠的博客
11-19 6528
使用CloudCompare软件计算点云的八叉树并可视化
pcl1.12+vtk9.1显示点云QVTKOpenGLNativeWidget
ooyyee的专栏
09-08 3036
pcl1.12+vtk9.1显示点云QVTKOpenGLNativeWidget
pcd格式点云归一化的C++实现，借助PCL点云库
03-20
PCL（Point Cloud Library）是一个常用的点云处理库，提供了许多点云处理的功能，其中包括点云归一化。 点云归一化是将点云数据转换为统一的坐标系，使得不同点云之间可以进行有效的比较和配准。点云归一化的意义...
pcl库实现点云的压缩并可视化
08-23
pcl库实现点云的压缩并可视化
PCL点云模型文件，可以用PCL库读取学习
03-06
最后，PCL还提供了可视化工具`pcl::visualization::PCLVisualizer`，可以方便地将点云及其特征显示出来，帮助我们理解和分析数据。 通过学习和实践使用PCL库，你可以深入理解点云数据，进行高级的3D处理任务，如...
PCL点云库中的模版匹配测试点云
05-14
用于PCL中模版匹配算法的测试点云，用于PCL中模版匹配算法的测试点云，用于PCL中模版匹配算法的测试点云用于PCL中模版匹配算法的测试点云，用于PCL中模版匹配算法的测试点云，用于PCL中模版匹配算法的测试点云，用于...
点云库PCL学习教程 13.3.3官方中文文档
03-02
点云库PCL学习教程 朱德海 主编 第13章使用正态分布变换进行配准(normal_distributions_transform)例子官方中文文档
三维点云的可视化
07-20
基于PCL的三维点云的可视化代码
PCL点云曲面重建--重采样
a_222850215的专栏
08-15 2336
  测量较小的对象时产生一些误差,直接重建会使曲面不光滑或者有漏洞,为了建立完整的模型需要对表面进行平滑处理和漏洞修复.可通过数据重建来解决这一问题,重采样算法通过对周围数据点进行高阶多项式插值来重建表面缺少的部分. 由多个扫描配准后得到的数据直接拿来重建可能产生 "双墙"等重影,即拼接的区域出现重叠的两个曲面,重采样算法可以对此问题进行处理. pcl库文件中 resampling.cpp代...
点云可视化方法——PCLVisualizer
LordofRobots的博客
05-18 3746
3D点云可视化可以通过rviz，cloud_viewer或者PCLVisualizer等方法进行可视化，这些介绍PCLVisualizer的方法。 首先是加载点云并显示： #include #include int main(int argc, char **argv) { int showpoint = 0; pcl::visualization::PCLVisual
PCL 部分点云视点问题
热门推荐
点云侠的博客
01-02 35万+
针对CloudCompare软件处理过的pcd格式点云，在使用PCL进行特征点提取、配准等实验中最终显示结果出现点云位置偏差较大，位置不一致的问题，本博客给出解决方案。
PCL系列——拼接两个点云
张学志の博客
03-30 4万+
PCL系列 PCL系列——读入PCD格式文件操作 PCL系列——将点云数据写入PCD格式文件 PCL系列——拼接两个点云 说明通过本教程，我们将会学会： * 如何拼接两个不同的点云的点，约束条件是两个数据集中的域的数量和类型必须相等。* 如何拼接两个不同点云的域，约束条件是连个数据集中的点的数量必须相等。操作 在VS2010 中新建一个文件 concatenate_clouds.cpp，然后将下面
3D点云学习（1）——配置点云库 PCL1.11.1
bigData1994pb的博客
04-20 914
为了学习3D视觉，首先我们需要配置点云库。我是参考下面的博客进行的，但是出现了报错，因此对于配置环境模块需要对此进行修改。 Win10 系统下 VisualStudio2019 配置点云库 PCL1.11.1_点云侠的博客-CSDN博客 其他只要按照这个博客配置即可，但是环境变量需要对此修改： 然后测试： #include <iostream> #include <vector> #include <ctime> #include <pcl/po.
PCL点云库安装教程
Christo的博客
09-14 5644
1，库文件下载 安装PCL首先需要下载对应的安装包，主要有两个，这里推荐在GitHub上下载 PCL安装包下载 2，安装教程 安装步骤： 双击PCL-1.8.1-AllInOne-msvc2015-win64.exe文件 按照提示点击下一步 勾选 Add PCL to the system Path for all users 在弹出安装OpenNI时将安装路径修改为D:\3D\PCL 1.8.1\3rdParty\OpenNI2 点击下一步，如果弹出警告说路径太长添加失败，点击确认继续安装。 点
PCL学习笔记：点云数据处理与过滤技术解析
"PCL学习笔记提供了对PCL库中常见函数的详细说明，包括图形和文字解释，适合点云库的学习者。" PCL（Point Cloud Library）是一个开源的C++点云处理库，广泛应用于3D计算机视觉、机器人、自动驾驶等领域。本学习...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值