PCL：交互式ICP可视化

最新推荐文章于 2023-05-17 22:20:05 发布
最新推荐文章于 2023-05-17 22:20:05 发布
阅读量545 收藏 5
点赞数 1
原文链接：https://blog.csdn.net/zfjBIT/article/details/94559720
版权

该程序将加载点云并对其进行刚性变换。之后，使用ICP算法将变换后的点云与原来的点云对齐。每次用户按下“空格”，进行ICP迭代，刷新可视化界面。

#include <iostream>
#include <string>

#include <pcl/io/ply_io.h>
#include <pcl/point_types.h>
#include <pcl/registration/icp.h>
#include <pcl/visualization/pcl_visualizer.h>
#include <pcl/console/time.h>   // TicToc
#pragma comment(lib,"User32.lib")
#pragma comment(lib, "gdi32.lib")

typedef pcl::PointXYZ PointT;
typedef pcl::PointCloud<PointT> PointCloudT;

bool next_iteration = false;

void
print4x4Matrix(const Eigen::Matrix4d & matrix)
{
	printf("Rotation matrix :\n");
	printf("    | %6.3f %6.3f %6.3f | \n", matrix(0, 0), matrix(0, 1), matrix(0, 2));
	printf("R = | %6.3f %6.3f %6.3f | \n", matrix(1, 0), matrix(1, 1), matrix(1, 2));
	printf("    | %6.3f %6.3f %6.3f | \n", matrix(2, 0), matrix(2, 1), matrix(2, 2));
	printf("Translation vector :\n");
	printf("t = < %6.3f, %6.3f, %6.3f >\n\n", matrix(0, 3), matrix(1, 3), matrix(2, 3));
}

//当用户按下任何键，该函数被调用，判断是否是空格键
void
keyboardEventOccurred(const pcl::visualization::KeyboardEvent& event,
	void* nothing)
{
	if (event.getKeySym() == "space" && event.keyDown())
		next_iteration = true;
}

int
main(int argc,
	char* argv[])
{
	
	// 我们要使用的点云
	PointCloudT::Ptr cloud_in(new PointCloudT);  // 初始点云
	PointCloudT::Ptr cloud_tr(new PointCloudT);  // 转换点云
	PointCloudT::Ptr cloud_icp(new PointCloudT);  // 输出点云

												  // 检查输入参数
	// if (argc < 2)
	// {
		// printf("Usage :\n");
		// printf("\t\t%s file.ply number_of_ICP_iterations\n", argv[0]);
		// PCL_ERROR("Provide one ply file.\n");
		// return (-1);
	// }

	int iterations = 1;  // 默认ICP配准的迭代次数
	// if (argc > 2)
	// {

		// iterations = atoi(argv[2]);//将字符串变量转换为整数变量
		// if (iterations < 1)
		// {
			// PCL_ERROR("Number of initial iterations must be >= 1\n");
			// return (-1);
		// }
	// }

	pcl::console::TicToc time;
	time.tic();
	if (pcl::io::loadPLYFile("monkey.ply", *cloud_in) < 0)
	{
		PCL_ERROR("Error loading cloud %s.\n", argv[1]);
		return (-1);
	}
	std::cout << "\nLoaded file " <<"monkey.ply"<< " (" << cloud_in->size() << " points) in " << time.toc() << " ms\n" << std::endl;

	// 定义旋转矩阵和平移矩阵
	Eigen::Matrix4d transformation_matrix = Eigen::Matrix4d::Identity();

	// 旋转矩阵的具体定义 (请参考 https://en.wikipedia.org/wiki/Rotation_matrix)
	double theta = M_PI / 20;  // 设置旋转弧度的角度
	transformation_matrix(0, 0) = cos(theta);
	transformation_matrix(0, 1) = -sin(theta);
	transformation_matrix(1, 0) = sin(theta);
	transformation_matrix(1, 1) = cos(theta);

	// 设置平移矩阵
	transformation_matrix(0, 3) = 0.0;
	transformation_matrix(1, 3) = 0.0;
	transformation_matrix(2, 3) = 0.0;
	// 在终端输出转换矩阵
	std::cout << "Applying this rigid transformation to: cloud_in -> cloud_icp" << std::endl;
	print4x4Matrix(transformation_matrix);

	// 执行初始变换
	pcl::transformPointCloud(*cloud_in, *cloud_icp, transformation_matrix);//绕z轴旋转theta，无平移变换
	*cloud_tr = *cloud_icp;  // 将cloud_icp变量备份

							 // 设置ICP配准算法输入参数
	time.tic();
	pcl::IterativeClosestPoint<PointT, PointT> icp;
	icp.setMaximumIterations(iterations);//设置迭代次数
	icp.setInputSource(cloud_icp);
	icp.setInputTarget(cloud_in);
	icp.align(*cloud_icp);
	icp.setMaximumIterations(1);  //  当再次调用.align ()函数时，我们设置该变量为1。
	std::cout << "Applied " << iterations << " ICP iteration(s) in " << time.toc() << " ms" << std::endl;

	//检查icp算法是否收敛，如果不收敛，退出程序
	if (icp.hasConverged())
	{
		std::cout << "\nICP has converged, score is " << icp.getFitnessScore() << std::endl;
		std::cout << "\nICP transformation " << iterations << " : cloud_icp -> cloud_in" << std::endl;
		transformation_matrix = icp.getFinalTransformation().cast<double>();
		print4x4Matrix(transformation_matrix);
	}
	else
	{
		PCL_ERROR("\nICP has not converged.\n");
		return (-1);
	}

	// 可视化部分
	pcl::visualization::PCLVisualizer viewer("ICP demo");
	// 创建两个独立的视口
	int v1(0);
	int v2(1);
	viewer.createViewPort(0.0, 0.0, 0.5, 1.0, v1);
	viewer.createViewPort(0.5, 0.0, 1.0, 1.0, v2);

	// 我们将要使用的颜色
	float bckgr_gray_level = 0.0;  // 黑色
	float txt_gray_lvl = 1.0 - bckgr_gray_level;

	// 设置初始点云为白色
	pcl::visualization::PointCloudColorHandlerCustom<PointT> cloud_in_color_h(cloud_in, (int)255 * txt_gray_lvl, (int)255 * txt_gray_lvl,
		(int)255 * txt_gray_lvl);//赋予显示点云的颜色
	viewer.addPointCloud(cloud_in, cloud_in_color_h, "cloud_in_v1", v1);
	viewer.addPointCloud(cloud_in, cloud_in_color_h, "cloud_in_v2", v2);

	// 设置初始转换后的点云为绿色
	pcl::visualization::PointCloudColorHandlerCustom<PointT> cloud_tr_color_h(cloud_tr, 20, 180, 20);
	viewer.addPointCloud(cloud_tr, cloud_tr_color_h, "cloud_tr_v1", v1);

	//  设置ICP配准后的点云为绿色
	pcl::visualization::PointCloudColorHandlerCustom<PointT> cloud_icp_color_h(cloud_icp, 180, 20, 20);
	viewer.addPointCloud(cloud_icp, cloud_icp_color_h, "cloud_icp_v2", v2);

	//  在两个视口，分别添加文字描述
	viewer.addText("White: Original point cloud\nGreen: Matrix transformed point cloud", 10, 15, 16, txt_gray_lvl, txt_gray_lvl, txt_gray_lvl, "icp_info_1", v1);
	viewer.addText("White: Original point cloud\nRed: ICP aligned point cloud", 10, 15, 16, txt_gray_lvl, txt_gray_lvl, txt_gray_lvl, "icp_info_2", v2);

	std::stringstream ss;
	ss << iterations;
	std::string iterations_cnt = "ICP iterations = " + ss.str();
	viewer.addText(iterations_cnt, 10, 60, 16, txt_gray_lvl, txt_gray_lvl, txt_gray_lvl, "iterations_cnt", v2);

	// 设置背景颜色
	viewer.setBackgroundColor(bckgr_gray_level, bckgr_gray_level, bckgr_gray_level, v1);
	viewer.setBackgroundColor(bckgr_gray_level, bckgr_gray_level, bckgr_gray_level, v2);

	// 设置相机位置和方向
	viewer.setCameraPosition(-3.68332, 2.94092, 5.71266, 0.289847, 0.921947, -0.256907, 0);
	//viewer.setSize(1280, 1024);  // 设置可视化窗口的尺寸

								 // 通过键盘，调用回调函数
	viewer.registerKeyboardCallback(&keyboardEventOccurred, (void*)NULL);

	// 设置显示器
 	while (!viewer.wasStopped())
	{
		viewer.spinOnce();

		 //用户按下空格键
		 if (next_iteration)
		 {
			 // 配准算法开始迭代   
			 time.tic(); 
			 icp.align(*cloud_icp);
			 std::cout << "Applied 1 ICP iteration in " << time.toc() << " ms" << std::endl;

			 if (icp.hasConverged())
			 {
				 printf("\033[11A");
				 printf("\nICP has converged, score is %+.0e\n", icp.getFitnessScore());
				 std::cout << "\nICP transformation " << ++iterations << " : cloud_icp -> cloud_in" << std::endl;
				 transformation_matrix *= icp.getFinalTransformation().cast<double>();  // 
				 print4x4Matrix(transformation_matrix);  // 输出初始矩阵和当前矩阵的转换矩阵

				 ss.str("");
				 ss << iterations;
				 std::string iterations_cnt = "ICP iterations = " + ss.str();
				 viewer.updateText(iterations_cnt, 10, 60, 16, txt_gray_lvl, txt_gray_lvl, txt_gray_lvl, "iterations_cnt");
				 viewer.updatePointCloud(cloud_icp, cloud_icp_color_h, "cloud_icp_v2");
			 }
			 else
			 {
				 PCL_ERROR("\nICP has not converged.\n");
				 return (-1);
			 }
		 }
		next_iteration = false;
	}
	system("pause");
	return (0);
}



#include <iostream>
#include <string>
 
#include <pcl/io/ply_io.h>
#include <pcl/point_types.h>
#include <pcl/registration/icp.h>
#include <pcl/visualization/pcl_visualizer.h>
#include <pcl/console/time.h>   // TicToc
 
typedef pcl::PointXYZ PointT;
typedef pcl::PointCloud<PointT> PointCloudT;
 
bool next_iteration = false;
 
void
print4x4Matrix (const Eigen::Matrix4d & matrix)
{
  printf ("Rotation matrix :\n");
  printf ("    | %6.3f %6.3f %6.3f | \n", matrix (0, 0), matrix (0, 1), matrix (0, 2));
  printf ("R = | %6.3f %6.3f %6.3f | \n", matrix (1, 0), matrix (1, 1), matrix (1, 2));
  printf ("    | %6.3f %6.3f %6.3f | \n", matrix (2, 0), matrix (2, 1), matrix (2, 2));
  printf ("Translation vector :\n");
  printf ("t = < %6.3f, %6.3f, %6.3f >\n\n", matrix (0, 3), matrix (1, 3), matrix (2, 3));
}
 
//当用户按下任何键，该函数被调用，判断是否是空格键
void
keyboardEventOccurred (const pcl::visualization::KeyboardEvent& event,
                       void* nothing)
{
  if (event.getKeySym () == "space" && event.keyDown ())
    next_iteration = true;
}
 
int
main (int argc,
      char* argv[])
{
  // 我们要使用的点云
  PointCloudT::Ptr cloud_in (new PointCloudT);  // 初始点云
  PointCloudT::Ptr cloud_tr (new PointCloudT);  // 转换点云
  PointCloudT::Ptr cloud_icp (new PointCloudT);  // 输出点云
 
  // 检查输入参数
  if (argc < 2)
  {
    printf ("Usage :\n");
    printf ("\t\t%s file.ply number_of_ICP_iterations\n", argv[0]);
    PCL_ERROR ("Provide one ply file.\n");
    return (-1);
  }
 
  int iterations = 1;  // 默认ICP配准的迭代次数
  if (argc > 2)
  {
   
    iterations = atoi (argv[2]);//将字符串变量转换为整数变量
    if (iterations < 1)
    {
      PCL_ERROR ("Number of initial iterations must be >= 1\n");
      return (-1);
    }
  }
 
  pcl::console::TicToc time;
  time.tic ();
  if (pcl::io::loadPLYFile (argv[1], *cloud_in) < 0)
  {
    PCL_ERROR ("Error loading cloud %s.\n", argv[1]);
    return (-1);
  }
  std::cout << "\nLoaded file " << argv[1] << " (" << cloud_in->size () << " points) in " << time.toc () << " ms\n" << std::endl;
 
  // 定义旋转矩阵和平移矩阵
  Eigen::Matrix4d transformation_matrix = Eigen::Matrix4d::Identity ();
 
  // 旋转矩阵的具体定义 (请参考 https://en.wikipedia.org/wiki/Rotation_matrix)
  double theta = M_PI / 20;  // 设置旋转弧度的角度
  transformation_matrix (0, 0) = cos (theta);
  transformation_matrix (0, 1) = -sin (theta);
  transformation_matrix (1, 0) = sin (theta);
  transformation_matrix (1, 1) = cos (theta);
 
  // 设置平移矩阵
  transformation_matrix (0, 3) = 0.0;
  transformation_matrix (1, 3) = 0.0;
  transformation_matrix (2, 3) = 0.0;
  // 在终端输出转换矩阵
  std::cout << "Applying this rigid transformation to: cloud_in -> cloud_icp" << std::endl;
  print4x4Matrix (transformation_matrix);
 
  // 执行初始变换
  pcl::transformPointCloud (*cloud_in, *cloud_icp, transformation_matrix);//绕z轴旋转theta，无平移变换
 *cloud_tr = *cloud_icp;  // 将cloud_icp变量备份
 
  // 设置ICP配准算法输入参数
  time.tic ();
  pcl::IterativeClosestPoint<PointT, PointT> icp;
  icp.setMaximumIterations (iterations);//设置迭代次数
  icp.setInputSource (cloud_icp);
  icp.setInputTarget (cloud_in);
  icp.align (*cloud_icp);
  icp.setMaximumIterations (1);  //  当再次调用.align ()函数时，我们设置该变量为1。
  std::cout << "Applied " << iterations << " ICP iteration(s) in " << time.toc () << " ms" << std::endl;
 
  //检查icp算法是否收敛，如果不收敛，退出程序
  if (icp.hasConverged ())
  {
    std::cout << "\nICP has converged, score is " << icp.getFitnessScore () << std::endl;
    std::cout << "\nICP transformation " << iterations << " : cloud_icp -> cloud_in" << std::endl;
    transformation_matrix = icp.getFinalTransformation ().cast<double>();
    print4x4Matrix (transformation_matrix);
  }
  else
  {
    PCL_ERROR ("\nICP has not converged.\n");
    return (-1);
  }
 
  // 可视化部分
  pcl::visualization::PCLVisualizer viewer ("ICP demo");
  // 创建两个独立的视口
  int v1 (0);
  int v2 (1);
  viewer.createViewPort (0.0, 0.0, 0.5, 1.0, v1);
  viewer.createViewPort (0.5, 0.0, 1.0, 1.0, v2);
 
  // 我们将要使用的颜色
  float bckgr_gray_level = 0.0;  // 黑色
  float txt_gray_lvl = 1.0 - bckgr_gray_level;
 
  // 设置初始点云为白色
  pcl::visualization::PointCloudColorHandlerCustom<PointT> cloud_in_color_h (cloud_in, (int) 255 * txt_gray_lvl, (int) 255 * txt_gray_lvl,
                                                                             (int) 255 * txt_gray_lvl);//赋予显示点云的颜色
  viewer.addPointCloud (cloud_in, cloud_in_color_h, "cloud_in_v1", v1);
  viewer.addPointCloud (cloud_in, cloud_in_color_h, "cloud_in_v2", v2);
 
  // 设置初始转换后的点云为绿色
  pcl::visualization::PointCloudColorHandlerCustom<PointT> cloud_tr_color_h (cloud_tr, 20, 180, 20);
  viewer.addPointCloud (cloud_tr, cloud_tr_color_h, "cloud_tr_v1", v1);
 
  //  设置ICP配准后的点云为绿色
  pcl::visualization::PointCloudColorHandlerCustom<PointT> cloud_icp_color_h (cloud_icp, 180, 20, 20);
  viewer.addPointCloud (cloud_icp, cloud_icp_color_h, "cloud_icp_v2", v2);
 
  //  在两个视口，分别添加文字描述
  viewer.addText ("White: Original point cloud\nGreen: Matrix transformed point cloud", 10, 15, 16, txt_gray_lvl, txt_gray_lvl, txt_gray_lvl, "icp_info_1", v1);
  viewer.addText ("White: Original point cloud\nRed: ICP aligned point cloud", 10, 15, 16, txt_gray_lvl, txt_gray_lvl, txt_gray_lvl, "icp_info_2", v2);
 
  std::stringstream ss;
  ss << iterations;
  std::string iterations_cnt = "ICP iterations = " + ss.str ();
  viewer.addText (iterations_cnt, 10, 60, 16, txt_gray_lvl, txt_gray_lvl, txt_gray_lvl, "iterations_cnt", v2);
 
  // 设置背景颜色
  viewer.setBackgroundColor (bckgr_gray_level, bckgr_gray_level, bckgr_gray_level, v1);
  viewer.setBackgroundColor (bckgr_gray_level, bckgr_gray_level, bckgr_gray_level, v2);
 
  // 设置相机位置和方向
  viewer.setCameraPosition (-3.68332, 2.94092, 5.71266, 0.289847, 0.921947, -0.256907, 0);
  viewer.setSize (1280, 1024);  // 设置可视化窗口的尺寸
 
  // 通过键盘，调用回调函数
  viewer.registerKeyboardCallback (&keyboardEventOccurred, (void*) NULL);
 
  // 设置显示器
  while (!viewer.wasStopped ())
  {
    viewer.spinOnce ();
 
    // 用户按下空格键
    if (next_iteration)
    {
      // 配准算法开始迭代
      time.tic ();
      icp.align (*cloud_icp);
      std::cout << "Applied 1 ICP iteration in " << time.toc () << " ms" << std::endl;
 
      if (icp.hasConverged ())
      {
        printf ("\033[11A");  
        printf ("\nICP has converged, score is %+.0e\n", icp.getFitnessScore ());
        std::cout << "\nICP transformation " << ++iterations << " : cloud_icp -> cloud_in" << std::endl;
        transformation_matrix *= icp.getFinalTransformation ().cast<double>();  // 
        print4x4Matrix (transformation_matrix);  // 输出初始矩阵和当前矩阵的转换矩阵
 
        ss.str ("");
        ss << iterations;
        std::string iterations_cnt = "ICP iterations = " + ss.str ();
        viewer.updateText (iterations_cnt, 10, 60, 16, txt_gray_lvl, txt_gray_lvl, txt_gray_lvl, "iterations_cnt");
        viewer.updatePointCloud (cloud_icp, cloud_icp_color_h, "cloud_icp_v2");
      }
      else
      {
        PCL_ERROR ("\nICP has not converged.\n");
        return (-1);
      }
    }
    next_iteration = false;
  }
  return (0);
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

pcl_tutorials:很棒的交互式 PCL 教程
06-05
标签 "JavaScript" 提示我们，虽然PCL通常是用C++编写的，但这个教程可能结合了JavaScript，这可能是因为JavaScript在Web开发中广泛使用，可以用来创建交互式的3D可视化，或者可能有JavaScript的PCL绑定或WebGL实现...
PCL自定义交互
qq_41685265的博客
03-03 1461
鼠标事件 每次相应鼠标时间都会回调函数，需要从event实例提取事件信息，本例中演示鼠标左键的释放事件 void mouseEventOccurred (const pcl::visualization::MouseEvent &event, void* viewer_void) { pcl::visualization::PCL...
PCL点云库学习笔记（可视化2）
Catog的博客
08-01 551
PCL点云库学习笔记（五）可视化四、PCLPlotter五、MFC 开发实例 可视化 四、PCLPlotter 4.1 绘制多项式 PCLPlotter提供了一个非常简单明了的图形绘制界面，可以在库中可视化各种重要的图，从多项式函数到直方图。 #include<vector> #include<iostream> #include<utility> #include<pcl/visualization/pcl_plotter.h> using namespa
PCL实现点云框选功能
RSon的学习笔记
01-28 5674
前言 在进行PCL开发时，需要对点进行操作，如删除离群点、噪声点；获取点三维坐标等。单一的选点功能效率低下，掌握点云的框选功能有利于进一步提高应用的交互功能。本博文将一步步介绍如何在PCL中实现点云框选功能。 PCL函数说明： 点云的框选功能回调函数: pcl::visualization::AreaPickingEvent::AreaPickingEvent () 成员函数 bo...
PCL实现选框裁剪点云
weixin_44342705的博客
06-25 4528
需求：在屏幕上点击画出多边形，裁剪对应框内的点云。 实现：按"x" 绘制多边形 再按"x"裁剪
pcl为点云绘制包围盒
realjc的博客
12-02 1532
{ Eigen::Vector4f min, max; pcl::getMinMax3D(*vptr_clusters[i], min, max); visualization_msgs::Marker marker; marker.header.stamp = ros::Time::now(); marker.header.frame_id = frame_id_; marker.ns = "cluster_node"; marker.id = i; marker.type = vi.
点云库PCL1.12.1代码demo
08-04
8. **可视化**：PCL集成了VTK库，提供`pcl::visualization`模块用于点云的交互式可视化。通过`pcl::visualization::PCLVisualizer`类，可以创建窗口、添加点云、设置颜色和透明度，帮助用户理解和调试算法。 通过...
pcl-pcl-1.8.0.zip
10-11
7. **可视化**：PCL的`pcl::visualization`模块提供了强大的工具，可以方便地查看和交互式操作点云数据，这对于调试和理解算法结果非常有用。 8. **应用示例**：在源代码中，通常会有许多示例程序，这些示例展示了...
pcl官网文档配套点云例子
11-02
最后，PCL还支持点云的可视化，通过`pcl::visualization`模块，用户可以创建交互式的3D视图来展示和分析点云数据。这在调试和演示中十分有用。 综上所述，“pcl官网文档配套点云例子”是一个宝贵的资源，它可以帮助...
pcl_linux.zip
07-23
10. **Visualization**：利用VTK（Visualization Toolkit）进行交互式3D可视化。 在ARM Linux平台上，由于硬件和架构的差异，不能直接使用为x86架构编译的PCL库。因此，我们需要进行交叉编译，即在一台x86主机上...
PCL点云处理之区域选择的交互操作（一百六十八）
weixin_44329757的博客
05-17 815
点云可视化，交互选择区域，输出区域信息的操作
PCL点云处理之显示/隐藏点云的交互操作（一百六十六）
weixin_44329757的博客
05-15 411
显示点云是基本的可视化点云方法，但有时候我们可以更进一步的对显示界面进行交互操作，比如显示隐藏点云等处理，下面是实现方法和介绍。
ICP算法（仅供学习使用）
z377989129的博客
03-18 8010
ICP（Iterative Closest Point）细化是一种点云配准算法，用于将两个或多个点云数据集对齐，以便进行后续的三维重建、拓扑分析等操作。在ICP细化中，通过迭代计算最小化两个点云之间的距离，来优化一个点云到另一个点云的转换矩阵（旋转矩阵和平移向量）。通过反复迭代，ICP细化算法可以逐步地将两个点云对齐，使它们的误差越来越小，最终达到一个较好的配准效果。ICP细化算法常用于三维重建、医学图像处理、机器人视觉、自动驾驶等领域。
Python 手写实现梯度下降法，并进行迭代轨迹可视化详细教程（以单元线性回归为例）
go_with_the_wind的博客
04-04 3435
本文主要介绍梯度下降法可视化教程 １、读取数据 #read data from IPython.core.interactiveshell import InteractiveShell InteractiveShell.ast_node_interactivity = "all" import numpy as np import pandas as pd import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import Axes3D
三维点云配准 ICP 算法的python实现（仅仅依赖numpy）
三维点云技术探索
03-20 2684
ICP 算法实际上就是交替进行上述两个步骤，迭代进行计算，直到收敛。6. 最小化 loss，求解当前最优变换。7. 回到步骤 2. 进行迭代，直到收敛。- 应用上一步求解出的变换，找最近点。- 调整一些对应点对的权重。4. 剔除不合理的对应点对。- 滤波、清理数据等。5. 计算 loss。
基于PCL实现点云框选功能
热门推荐
wokaowokaowokao12345的专栏
05-07 1万+
前言点云的框选功能，可以进一步提高应用的交互功能，在前面博客里已经就基于PCL实现了三维点选点功能，在本篇博客里我将就如何基于PCL实现点云框选功能，并添加到应用中。下面将关键代码写出来与大家分享。代码说明点云的框选功能类似与点选功能，查阅pcl文档或源码可以看到： pcl::visualization::AreaPickingEvent::AreaPickingEvent 成员函数： boo
利用pcl的icp方法实现对两个点云的配准及可视化显示
HelloJinYe的博客
05-31 2317
利用pcl的icp方法实现对两个点云的配准 1.读取点云数据 pcl::PointCloud<pcl::PointXYZ>::Ptr cloud_in (new pcl::PointCloud<pcl::PointXYZ>); pcl::PointCloud<pcl::PointXYZ>::Ptr cloud_out (new pcl::PointCloud<pcl::PointXYZ>); if(argc != 3) { cerr<<"输
PCL可视化页面的鼠标交互选点事件
weixin_45616039的博客
08-03 1327
pcl的可视化模块是基于VTK库编写的，因此我们可以借助于pcl的VTK库实现鼠标交互选点的功能（PCL的可视化模块自带PointPicking功能，但是此功能经常选点不准以及失效）。获取当前pcl的viewer模块的render渲染器，使用vtk的Pointpick功能获取当前鼠标所选点的位置并显示。......
PCL库学习（14）_利用Qt中不同ui界面下的交互来可视化PCL中点云聚类
lzy6041的博客
08-15 766
目标：以PCL中集成的欧式聚类为例，通过触发主界面的“segmentation”->“EuclideanClustering” 然后调用出参数设置界面，最终将结果可视化到显示窗口中。 具体步骤如下： 1.新建.ui：右击“Form Files”->“添加”->“类”->“Qt5GuiClass”。 class name命名为qeuclideancluster,然后就会生成相应的.ui,.h,.cpp文件。 2.构建ui界面及对象名称修改 我这里设置了这样一个简单的参数设定界面 3.设
pcl::visualization::PCLVisualizer可视化点云
最新发布
07-15
是的，通过pcl::visualization::PCLVisualizer可以实现点云数据的可视化。下面是一个简单的示例代码，展示如何使用PCLVisualizer来可视化点云数据： ```cpp #include <pcl/visualization/pcl_visualizer.h> int ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值