PCL迭代最近点算法（ICP）的C++实现

最新推荐文章于 2024-06-27 20:39:16 发布
最新推荐文章于 2024-06-27 20:39:16 发布
阅读量4.9k 收藏 54
点赞数 8
分类专栏： PCL C++ 文章标签： ICP PCL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014801811/article/details/79801771
版权
C++ 同时被 2 个专栏收录
29 篇文章 4 订阅
订阅专栏
PCL
21 篇文章 10 订阅
订阅专栏

简介：
在维基百科中是这样介绍迭代最近点算法。迭代最近点（ICP）是一种用于最小化两点云之间差异的算法。给定P、Q两个点集，求解旋转矩阵R和平移矩阵T使得min{distance(P,Q)}.
C++算法流程图：
这里写图片描述
四元数求解方法
这里写图片描述
这里写图片描述
C++代码

/**

** Filename:icp.h

** Copyright (c) 2017-2018 

** Author:Rson

** Date:2018/04/03

** Modifier:

** Date:

** Description: 

**

** Version:

**/

#ifndef _ICP_H
#define _ICP_H

#include <vector>
#include <string>

#include <pcl\point_cloud.h>
#include <pcl\point_types.h>
#include <pcl\visualization\pcl_visualizer.h>

struct Vertex
{
	double coord[3];
};

struct Point
{
	float x;
	float y;
	float z;
};

class ICP
{
public:
	ICP();
	ICP(int controlnum=1000,double thre=0.01,int iter=100);
	virtual ~ICP();

	void readfile(std::string firstname, std::string secondname);
	void run();
	void writefile(std::string name);
	void showcloud(std::string firstname, std::string secondname,std::string thirdname);

private:
	void initransmat();//初始化旋转矩阵和平移矩阵
	void sample();//采样控制点
	double closest();//找出最近点并返回误差
	void getcenter();//获取两个控制点的中心
	void rmcontcenter();//移动两个控制点的中心
	void transform();//将四元数转换成矩阵并更新整个旋转矩阵
	void uprotate();// 更新变换矩阵
	void uptranslate();
	void updata();//更新控制点坐标
	void applyall();

private:
	double distance(Vertex a, Vertex b);
	void printTT();
	void printTR();
	

private:
	int conNum;//控制点数目
	int iterate;//迭代次数
	double threshold;//阈值
	std::vector<Vertex> VarrP;//起始点
	std::vector<Vertex> VarrQ;
	Vertex meanP;//控制点中心
	Vertex meanQ;
	Vertex *contP;//P控制点
	Vertex *contQ;
	Vertex *rmcoP;//移动后的控制点
	Vertex *rmcoQ;

	int *index; //在采样控制点和寻找相应的点索引时使用

	double TT[3];//平移向量
	double TR[3][3];//旋转矩阵
	double Rw[3][3];//旋转的步距
	double Tw[3];//平移的步距
	double quad[4];//四元数


};

#endif  /* ICP_H */

/**

** Filename:icp.cpp

** Copyright (c) 

** Author:Rson

** Date:2018/04/03

** Modifier:

** Date:

** Description:

**

** Version:

**/
#include "stdafx.h"
#include <iostream>
#include <sstream>
#include <fstream>
#include <cassert>
#include <math.h>
#include <time.h>
#include <newmat10/newmat.h>
#include <newmat10/newmatap.h>
#include "ICP.h"


ICP::ICP()
{
}

ICP::ICP(int controlnum, double thre, int iter)
{
	conNum = controlnum;
	threshold = thre;
	iterate = iter;

	contP = new Vertex[conNum];
	assert(contP != NULL);
	contQ = new Vertex[conNum];
	assert(contQ != NULL);
	rmcoP = new Vertex[conNum];
	assert(rmcoP != NULL);
	rmcoQ = new Vertex[conNum];
	assert(rmcoQ != NULL);
	index = new int[conNum];
	assert(index != NULL);
}

ICP::~ICP()
{
	delete[] contP;
	delete[] contQ;
	delete[] rmcoP;
	delete[] rmcoQ;
	delete[] index;
}

void ICP::readfile(std::string firstname, std::string secondname)
{
	std::cout << "读取两个点云文件！！" <<std:: endl;
	ifstream in;
	in.open(firstname.c_str(), std::ios::in);
	if (!in.is_open())
	{
		std::cout << "error open!" <<std:: endl;
		system("pause");
	}
	Vertex v;
	while(in>>v.coord[0]>>v.coord[1]>>v.coord[2])
	{
		VarrP.push_back(v);
	}
	std::cout << "点云A的大小：" << VarrP.size() << std::endl;
	in.close();

	//
	in.open(secondname.c_str(), std::ios::in);
	if (!in.is_open())
	{
		cout << "error open!" << endl;
		system("pause");
	}
	
	//Vertex v;
	while (in >> v.coord[0] >> v.coord[1] >> v.coord[2])
	{
		VarrQ.push_back(v);
	}
	std::cout << "点云B的大小：" << VarrQ.size() << std::endl;
	in.close();
}
void ICP::run()
{
	initransmat();
	sample();
	//
	double err = closest();
	std::cout << "初始误差：error = " << err << std::endl;
	//
	for (int i = 0; i<iterate; i++)
	{
		getcenter();
		rmcontcenter();
		transform();
		uprotate();
		uptranslate();
		updata();
		double newerr = closest();
		std::cout << "迭代次数 times = " << i << std::endl;
		std::cout << "error = " << newerr << std::endl;
		double delta = fabs(err - newerr) / conNum;
		std::cout << "delta = " << delta << std::endl;
		if (delta<threshold)
			break;
		err = newerr;

	}
	printTR();
	printTT();
	applyall();
}
void ICP::writefile(std::string name)
{
	ofstream outobj;
	outobj.open(name.c_str());
	//outobj << "# Geomagic Studio" << endl;
	int num = 1;
	for (vector<Vertex>::const_iterator p = VarrP.begin(); p != VarrP.end(); p++)
	{
		Vertex v;
		v = *p;
		outobj << v.coord[0] << " " << v.coord[1] << " " << v.coord[2] << endl;
		//outobj << "p " << num++ << endl;

		//outobj << "v " << v.coord[0] << " " << v.coord[1] << " " << v.coord[2] << endl;
		//outobj << "p " << num++ << endl;
	}
	//
	outobj.close();
}

//初始化变换矩阵
//    -
//    | 1.0  0.0 0.0 | 0.0  |
//	  |	0.0  1.0 0.0 | 0.0  |
//	  | 0.0  0.0 1.0 | 0.0  |
//    | -------------|----- |
//    | 0.0 0.0 0.0  | 1.0  |
void ICP::initransmat()//初始化变换矩阵
{
	std::cout << "初始化变换矩阵" << endl;
	for (int i = 0; i < 3; i++)
		TT[i] = 0;
	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			if (i != j)
				TR[i][j] = 0.0;
			else
				TR[i][j] = 1.0;
		}
	}
}


//随机选取控制点,并存储在contP中

void ICP::sample()
{
	std::cout<<"随机选取控制点,并存储在contP中"<<std::endl;
	int N = VarrP.size();
	bool *flag = new bool[N];
	assert(flag != NULL);
	for (int i = 0; i < N; i++)
		flag[i] = false;
	//随机选择一个控制点，并记录其索引
	srand((unsigned)time(NULL));
	for (int i = 0; i < conNum; i++)
	{
		while (true)
		{
			int sam = rand() % N;
			if (!flag[sam])
			{
				index[i] = sam;
				flag[sam] = true;
				break;
			}
		}
	}
	//cout<<"store control points into contP"<<endl;
	for (int i = 0; i<conNum; i++)
	{
		Vertex v = VarrP[index[i]];//
		for (int j = 0; j<3; j++)
		{
			contP[i].coord[j] = v.coord[j];
		}
	}
	delete[] flag;
}

//找出最近点并计算误差之和
double ICP::closest()
{
	//find closest points and error
	double error = 0.0;
	for (int i = 0; i < conNum; i++)
	{
		double mindist = 100.0;
		index[i] = 0;
		for (unsigned int j = 0; j < VarrQ.size(); j++)
		{
			double dist = distance(contP[i], VarrQ[j]);
			if (dist < mindist)
			{
				mindist = dist;
				index[i] = j;
			}
		}
		Vertex v = VarrQ[index[i]];
		for (int j = 0; j < 3; j++)
		{
			contQ[i].coord[j] = v.coord[j];
		}
		error += mindist;
	}
	return error;
}

//求取两个点云控制点的重心
void ICP::getcenter()
{
	//首先初始化重心坐标0，0，0
	for (int i = 0; i < 3; i++)
		meanP.coord[i] = 0.0;
	//求取每个分量之和
	for (int i = 0; i < conNum; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			meanP.coord[j] += contP[i].coord[j];
		}
	}
	//求取平均值
	for (int i = 0; i < 3; i++)
		meanP.coord[i] = meanP.coord[i] / conNum;

	//
	for (int i = 0; i < 3; i++)
		meanQ.coord[i] = 0.0;
	//求取每个分量之和
	for (int i = 0; i < conNum; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			meanQ.coord[j] += contQ[i].coord[j];
		}
	}
	//求取平均值
	for (int i = 0; i < 3; i++)
		meanQ.coord[i] = meanQ.coord[i] / conNum;
}

//点集中心化，生成新的点云数据
void ICP::rmcontcenter()
{
	std::cout << "点集中心化，生成新的点云数据" << std::endl;
	for (int i = 0; i < conNum; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			rmcoP[i].coord[j] = contP[i].coord[j] - meanP.coord[j];
			rmcoQ[i].coord[j] = contQ[i].coord[j] - meanQ.coord[j];
		}
	}
}

void ICP::transform()
{
	std::cout << "获取变换矩阵" << std::endl;
	Matrix B(4, 4);
	B = 0;
	double u[3];//di+di'
	double d[3];//di-di'
	//计算协方差
	for (int i = 0; i < conNum; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			u[j] = rmcoP[i].coord[j] + rmcoQ[i].coord[j];
			d[j] = rmcoP[i].coord[j] - rmcoQ[i].coord[j];
		}
		double uM[16] = { 
			   0, -d[0], -d[1], -d[2],
			d[0],     0, -u[2], -u[1],
			d[1], -u[2],     0,  u[0],
			d[2],  u[1], -u[0],    0 };

		Matrix Ai(4, 4);
		Ai << uM;
		B += Ai * Ai.t();
	}

	Matrix U;
	Matrix V;
	DiagonalMatrix D;
	SVD(B, D, U, V);

	for (int i = 0; i < 4; i++)
	{
		quad[i] = V.element(i, 3);
	}
	B.Release();
	U.Release();
	V.Release();
	D.Release();
}

void ICP::uprotate()
{
	//根据四元数求解选择矩阵
	Rw[0][0] = quad[0] * quad[0] + quad[1] * quad[1] - quad[2] * quad[2] - quad[3] * quad[3];
	Rw[0][1] = 2 * (-quad[0] * quad[3] + quad[1] * quad[2]);
	Rw[0][2] = 2 * (quad[0] * quad[2] + quad[1] * quad[3]);
	Rw[1][0] = 2 * (quad[0] * quad[3] + quad[1] * quad[2]);
	Rw[1][1] = quad[0] * quad[0] - quad[1] * quad[1] + quad[2] * quad[2] - quad[3] * quad[3];
	Rw[1][2] = 2 * (-quad[0] * quad[1] + quad[2] * quad[3]);
	Rw[2][0] = 2 * (-quad[0] * quad[2] + quad[1] * quad[3]);
	Rw[2][1] = 2 * (quad[0] * quad[1] + quad[2] * quad[3]);
	Rw[2][2] = quad[0] * quad[0] - quad[1] * quad[1] - quad[2] * quad[2] + quad[3] * quad[3];

	//Rn+1 = R * Rn
	double tmp[3][3];
	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			tmp[i][j] = 0;
		}
	}

	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			for (int k = 0; k < 3; k++)
			{
				tmp[i][j] += Rw[i][k] * TR[k][j];
			}
		}
	}

	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 3; j++)
			TR[i][j] = tmp[i][j];
	}
}

void ICP::uptranslate()
{
	//Tw = P'-Rw * P
	double tmp[3] = { 0, 0, 0 };
	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			tmp[i] += Rw[i][j] * meanP.coord[j];
		}
	}
	for (int i = 0; i < 3; i++)
	{
		Tw[i] = meanQ.coord[i] - tmp[i];
	}

	double temp[3] = { 0, 0, 0 };
	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			temp[i] += Rw[i][j] * TT[j];
		}
	}
	for (int i = 0; i < 3; i++)
	{
		TT[i] = temp[i] + Tw[i];
	}
}

void ICP::updata()
{
	for (int i = 0; i < conNum; i++)
	{
		double tmp[3] = { 0, 0, 0 };
		for (int j = 0; j < 3; j++)
		{
			for (int k = 0; k < 3; k++)
			{
				tmp[j] += Rw[j][k] * contP[i].coord[k];
			}
		}
		for (int j = 0; j < 3; j++)
			contP[i].coord[j] = tmp[j] + Tw[j];
	}
}

void ICP::applyall()
{
	for (vector<Vertex>::iterator p = VarrP.begin(); p != VarrP.end(); p++)
	{
		Vertex v = *p;
		double tmp[3] = { 0, 0, 0 };
		for (int i = 0; i < 3; i++)
		{
			for (int k = 0; k < 3; k++)
			{
				tmp[i] += TR[i][k] * v.coord[k];
			}
		}
		for (int i = 0; i < 3; i++)
		{
			v.coord[i] = tmp[i] + TT[i];
		}
		*p = v;
	}
}

double ICP::distance(Vertex a, Vertex b)
{
	double dist = 0.0;
	for (int i = 0; i < 3; i++)
	{
		dist += (a.coord[i] - b.coord[i])*(a.coord[i] - b.coord[i]);
	}
	return dist;
}

void ICP::printTT()
{
	std::cout << "Translate Matrix = " << std::endl;
	for (int i = 0; i < 3; i++)
	{
		std::cout << TT[i] << " ";
	}
	std::cout << std::endl;
}

void ICP::printTR()
{
	std::cout << "Rotate Matrix = " << std::endl;
	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			std::cout << TR[i][j] << " ";
		}
		std::cout << std::endl;
	}
}

void ICP::showcloud(std::string firstname, std::string secondname,std::string thirdname)
{
	pcl::PointCloud<pcl::PointXYZ>::Ptr cloud_Target(new pcl::PointCloud<pcl::PointXYZ>);
	pcl::PointCloud<pcl::PointXYZ>::Ptr cloud_Source(new pcl::PointCloud<pcl::PointXYZ>);
	pcl::PointCloud<pcl::PointXYZ>::Ptr cloudOut(new pcl::PointCloud<pcl::PointXYZ>);

	std::cout << "显示两个点云：" << std::endl;
	//第一个点云数据
	ifstream in;
	in.open(firstname.c_str(), std::ios::in);
	if (!in.is_open())
	{
		std::cout << "error open!" << std::endl;
		system("pause");
	}
	vector<Point> points;
	points.clear();
	Point tmp;
	while (in >> tmp.x >> tmp.y >> tmp.z)
	{
		points.push_back(tmp);
	}
	pcl::PointXYZ cltmp;

	for (size_t i = 0; i != points.size();i++)
	{
		cltmp.x = points[i].x;
		cltmp.y = points[i].y;
		cltmp.z = points[i].z;
		cloud_Target->points.push_back(cltmp);
	}
	std::cout << "点云A的大小：" << cloud_Target->size() << std::endl;
	in.close();

	//第二个点云数据
	in.open(secondname.c_str(), std::ios::in);
	if (!in.is_open())
	{
		std::cout << "error open!" << std::endl;
		system("pause");
	}
	points.clear();
	while (in >> tmp.x >> tmp.y >> tmp.z)
	{
		points.push_back(tmp);
	}
	//pcl::PointXYZ cltmp;

	for (size_t i = 0; i != points.size(); i++)
	{
		cltmp.x = points[i].x;
		cltmp.y = points[i].y;
		cltmp.z = points[i].z;
		cloud_Source->points.push_back(cltmp);
	}
	std::cout << "点云B的大小：" << cloud_Source->size() << std::endl;
	in.close();

	//第三个点云数据
	in.open(thirdname.c_str(), std::ios::in);
	if (!in.is_open())
	{
		std::cout << "error open!" << std::endl;
		system("pause");
	}
	points.clear();
	while (in >> tmp.x >> tmp.y >> tmp.z)
	{
		points.push_back(tmp);
	}
	//pcl::PointXYZ cltmp;

	for (size_t i = 0; i != points.size(); i++)
	{
		cltmp.x = points[i].x;
		cltmp.y = points[i].y;
		cltmp.z = points[i].z;
		cloudOut->points.push_back(cltmp);
	}
	std::cout << "点云C的大小：" << cloudOut->size() << std::endl;
	in.close();


	//可视化初始化
	pcl::visualization::PCLVisualizer viewer;
	viewer.setCameraFieldOfView(0.785398);//fov 45°  视场角
	viewer.setBackgroundColor(0.2, 0.2, 0.2);
	viewer.setCameraPosition(
		0, 0, 0,
		0, 0, -1,
		0, 0, 0);
	//点云可视化
	pcl::visualization::PointCloudColorHandlerCustom<pcl::PointXYZ> TargetHandler(cloud_Target, 255, 0, 0);
	pcl::visualization::PointCloudColorHandlerCustom<pcl::PointXYZ> SourceHandler(cloud_Source, 0, 0, 255);
	pcl::visualization::PointCloudColorHandlerCustom<pcl::PointXYZ> OutHandler(cloudOut, 0, 255, 0);
	viewer.addPointCloud(cloud_Target, TargetHandler, "cloud_Target");
	viewer.addPointCloud(cloud_Source, SourceHandler, "cloud_Source");
	viewer.addCoordinateSystem(0.1, "cloud", 0);


	int v2 = 1;
	viewer.createViewPort(0.5, 0, 1, 1, v2);
	viewer.createViewPortCamera(v2);
	viewer.setCameraFieldOfView(0.785398, v2);//fov 45°
	viewer.setBackgroundColor(0.2, 0.2, 0.2,v2);
	viewer.setCameraPosition(
		0, 0, 0,
		0, 0, -1,
		0, 0, 0,v2);
	//点云可视化
	viewer.addPointCloud(cloud_Target, TargetHandler, "cloud222", v2);
	viewer.addPointCloud(cloudOut, OutHandler, "cloudOut",v2);
	viewer.addCoordinateSystem(0.1, "cloud1", v2);
	while(!viewer.wasStopped())
	{
		viewer.spinOnce();
	}
}


//主程序
#include "stdafx.h"
#include <iostream>
#include <pcl\common\transforms.h>
#include <pcl\io\pcd_io.h>
#include <pcl\visualization\pcl_visualizer.h>
#include <pcl\registration\icp.h>
#include "ICP.h">
#include <iostream>
#include <time.h>
int main()
{
	clock_t start, finish;
	start = clock();
	ICP myicp(1000, 0.00001, 50);
	myicp.readfile("bunny_0.asc", "bunny_1.asc");
	myicp.run();
	myicp.writefile("out.asc");
	finish = clock();
	std::cout << "运行时间：" << (finish - start) / 1000 << "s" << std::endl;
	myicp.showcloud("bunny_0.asc", "bunny_1.asc", "out.asc");
	system("pause");
	return 0;
}
Rson的学习笔记
关注
专栏目录
PCL ICP算法实现点云配准（C++详细过程版）
点云侠的博客
06-20 2220
ICP算法实现点云精确配准的C++详细过程版代码实现。
C++实现ICP点云匹配
zfjBIT的专栏
06-27 5711
代码流程说明： 1. 读取源点云SC； 2. 构造目标点云TC； 3. 初始化旋转矩阵和平移矩阵； 4. 根据旋转矩阵和平移矩阵，变换目标点云，得到新的目标点云TC_1； 5. 查找近邻点对，得到重排序的源点云SC_1； 6. 分别去中心得到SC_2,TC_2： 7. 对应点对矩阵和，SVD分解得到新的旋转矩阵和平移矩阵； 重复4-7步骤，直到对应点对位置差小于预设阈值； #...
基于PCL开源库ndt+icp算法实现点云配准实例测试代码
03-27
利用PCL开源库编写代码NDT+ICP算法实现点云高精度配准，包括粗配准+精配准，并计算配准误差！基于PCL库版本1.9！
二维ICP配准算法-C++ 直接法实现
最新发布
我爱调试
06-27 1855
2D的ICP算法的原理与3D的一致，区别在于其SO(2)的自由度只有1。因此并不需要借用SVD来进行求解，只需要直接求导即可。由于第一项和第三项为常量，则目标函数可以转化为。上述目标函数包含两个变量比较难以求解。可以通过对点集进行归一化，不考虑T。,根据SO(2)的形式就可求出R。则目标函数G可以表达为如下形式。这时目标函数可以简化为。对目标函数进行展开可得。因SO(2)有如下定义。
VS中用C++实现PCL调用ICP和NDT算法，带代码注释及点云数据
09-05
资源内包含一个VS2013工程项目，在Windows下用C++实现ICP和NDT两种配准算法，代码修改自PCL官网例程，并配有中文注释，内含点云文件，可直接运行，不懂的地方可以阅读readme文件。
PCL之ICP算法
我的blog屋
10-22 9264
转自：https://blog.csdn.net/u010696366/article/details/8941938?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-2.channel_param&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-2.chan
ICP算法手写实现（C++和python）
taifyang的博客
02-20 1万+
采用C++实现ICP（Iterative Closest Point，迭代最近点）算法，借助了PCL库实现点云基本变换、KD-tree以及可视化部分，核心迭代部分没有调用PCL的api。代码在KD-tree搜索部分采用了openmp加速优化，在适当的数据集下运行速度能超过PCL自带的ICP算法配准api。 ICP算法的原理和推导，网上有很多，在此不赘述。下面链接是我觉得讲的比较详细的，可以参考： 三维点云配准 – ICP 算法原理及推导 ICP算法公式推导和PCL源码解析 另外，本文的代码实现过程还参考了：
PCL 体素化广义迭代最近点配准算法VGICP,C++/PYTHON程序
05-19
体素化广义迭代最近点配准算法（Voxel Grid Generalized Iterative Closest Point, VGICP）是Point Cloud Library (PCL) 中的一种高级3D点云配准方法。PCL是一个开源的C++点云处理库，它提供了广泛的工具和算法，...
PCL ICP算法实现点云精配准【2024最新版】
点云侠的博客
04-28 31万+
PCL1.14.1 及之前版本所实现的迭代最近点ICP算法。博客长期更新，本文最新更新时间为：2024年7月24日。
PCL 点到面的ICP算法实现点云配准（C++详细过程版）
点云侠的博客
06-29 1758
[1] Low K L. Linear least-squares optimization for point-to-plane icp surface registration[J]. Chapel Hill, University of North Carolina, 2004, 4(10): 1-3 计算方法详细过程复现
迭代最近点 ICP 详细推导（C++实现）
A_L_A_N
07-20 1万+
一、简介 迭代最近点算法（Iterated Closest Points, ICP），顾名思义，就是采用迭代优化的思想以空间距离作为匹配点的选择依据，通过不断调整点云的位姿使得匹配点之间距离累计最小。假设有两组点云，其中一个目标点云A另一个为参考点云B，ICP算法的目的是为了算出一个最优的旋转矩阵R和平移向量t使得变换后的点云A能与B达到最精确的匹配。ICP算法因为其思想简单，精度高等特点成为了局部配准的主流算法。 ICP需要反复执行以下两步直至收敛：第一步，计算A点集与...
ICP算法实现（C++）
04-10
一个关于坐标转换的算法，ICP迭代算法实现。VC++ 6.0
PCL 之 ICP 算法实现
weixin_34280237的博客
07-11 634
ICP是什么？ ICP（Iterative Closest Point），即最近点迭代算法，是最为经典的数据配准算法。其特征在于，通过求取源点云和目标点云之间的对应点对，基于对应点对构造旋转平移矩阵，并利用所求矩阵，将源点云变换到目标点云的坐标系下，估计变换后源点云与目标点云的误差函数，若误差函数值大于阀值，则迭代进行上述运算直到满足给定...
pcl库的icp算法使用
hdfidfdslfdfsd的博客
09-08 934
现在需要对一组连续点云数据进行配准，之前尝试过使用libicp库，但是这个库太久不更新了，听人建议改为使用pcl库提供的icp方法。 一、配置pcl环境 安装。在pcl的官方github页面下载对应自己vs版本和操作系统位数的pcl安装包，我使用的是vs2017，所以下载了PCL-1.9.1-AllInOne-msvc2017-win64.exe和pcl-1.9.1-pdb-msvc2017-win64.zip两个文件，安装exe文件，过程中会提示是否要安装三方库boost，eigen，flann，ope
使用PCL进行ICP点云配准
gls_nuaa的博客
09-23 337
使用PCL进行ICP点云配准
Open3D(C++) 点到平面的ICP算法实现点云精配准
点云侠的博客
08-19 1405
使用C++版本的Open3D实现点到平面的ICP算法实现点云精配准
PCL 点到面的ICP算法（LM非线性最小二乘优化）
热门推荐
点云侠的博客
12-04 39万+
非线性优化的点到面的ICP算法
迭代最近点ICP推导（C++实现）
鬼技的博客
03-22 5030
1、算法介绍 ICP（Iterative Closest Point迭代最近点）算法是一种点集对点集配准方法。用数学语言描述如下，即ICP算法的实质是基于最小二乘法的最优匹配，它重复进行“确定对应关系的点集→计算最优刚体变换”的过程，直到某个表示正确匹配的收敛准则得到满足。 ICP算法基本思想： 　　如果知道正确的点对应，那么两个点集之间的相对变换（旋转、平移）就可以求得封闭解。 　　首先计算...
PCL :实现点到面的ICP算法（附完整源码）
希望我的博客，能帮上你解决学习中工作中所遇到的问题
09-25 287
PCL :实现点到面的ICP算法（附完整源码）
pcl配准的四元数算法c++实现
07-04
pcl配准的四元数算法C++实现包含以下几步骤： 1. 导入所需库文件。导入pcl/point_types.h头文件来定义点云类型，导入pcl/registration/icp.h头文件来实现ICP配准算法，导入pcl/filters/voxel_grid.h头文件用来进行...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值