KinectFusion中的ICP算法

原创 已于 2023-05-01 20:35:03 修改 · 872 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法 #c++ #点云配准 #ICP #KinectFusion

于 2023-05-01 18:23:27 首次发布
文章描述了一种利用Point-to-PlaneICP算法进行投影数据关联的方法，通过前一帧和当前帧的顶点及法向量匹配，寻找对应点。在每次迭代中，使用非线性最小二乘法优化相对位姿变化，以减小点到平面的误差。代码实现包括了Frame类和ICP类，用于处理深度图、计算顶点和法向量，并估计相机位姿。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

投影数据关联-求匹配点

利用算法projective data association对前一帧和当前帧的（Vertex、Normal）进行匹配，算法如下：

  1. 在当前帧 i 的深度图像上的每一个像素 U并行计算；
  2. 对于深度值大于0的像素，求该像素点对应的顶点在上一帧所处的相机坐标系下的位置Vi-1：方法是用上一帧的相机位姿Tg,k-1的逆矩阵左乘上一帧中该点对应的像素点的全局坐标Vi-1(g)；
  3. 将Vi-1投影到像素平面得到p；
  4. 对于p属于当前帧范围内的点（说明该顶点在上一帧中也在相机视口范围内），用上一帧的位姿Tg,k-1左乘该点 Vi§(注：这是本帧中像素p对应的Vertex) 将其投影到全局坐标中得V；
  5. 同上得全局坐标下法向量 N；
  6. 如果V和 Vi-1(g)的距离小于阈值，且 N 和 Ni-1(g) 的夹角小于阈值，则找到匹配点对。

Point-to-Plane ICP

使用点到平面（point-plane）误差度量的迭代最近点 (ICP) 算法已被证明比使用点到点（point-point）误差度量的算法收敛得更快。在 ICP 算法的每次迭代中，产生最小点到平面误差的相对位姿变化通常使用标准的非线性最小二乘法来解决。例如 Levenberg-Marquardt 方法。当使用点到平面误差度量时，最小化的对象是每个源点与其对应目标点的切平面之间的平方距离之和。在这里插入图片描述
详细介绍见点到面的ICP算法。

Frame.h

#pragma once


#include <Eigen/Dense>
#include <opencv2/opencv.hpp>


#define MINF -std::numeric_limits<float>::infinity()


class Frame
{
public:
    Frame(cv::Mat depthMap, cv::Mat colorMap, Eigen::Matrix3f& depthIntrinsics, Eigen::Matrix4f& depthExtrinsics);
    Eigen::Vector3f getVertexGlobal(size_t idx) const;
    Eigen::Vector3f getNormalGlobal(size_t idx) const;
    std::vector<Eigen::Vector3f>& getVertexMapGlobal();
    std::vector<Eigen::Vector3f>& getNormalMapGlobal();
    std::vector<Eigen::Vector3f>& getVertexMap();
    std::vector<Eigen::Vector3f>& getNormalMap();
    int getFrameHeight();
    int getFrameWidth();
    bool containsImgPoint(Eigen::Vector2i);
    Eigen::Vector3f projectPointIntoFrame(const Eigen::Vector3f& point);
    Eigen::Vector2i projectOntoImgPlane(const Eigen::Vector3f& point);

private:
	void computeVertexMap(cv::Mat depthMap, const Eigen::Matrix3f& depthIntrinsics);
    void computeNormalMap(cv::Mat depthMap);
    std::vector<Eigen::Vector3f> transformPoints(const std::vector<Eigen::Vector3f>& points, const Eigen::Matrix4f& transformation);
    std::vector<Eigen::Vector3f> rotatePoints(const std::vector<Eigen::Vector3f>& points, const Eigen::Matrix3f& rotation);

    int depthWidth;
    int depthHeight;
	cv::Mat depthMap;
	cv::Mat colorMap;
    std::shared_ptr<std::vector<Eigen::Vector3f>> mVertices;
    std::shared_ptr<std::vector<Eigen::Vector3f>> mNormals;
    std::shared_ptr<std::vector<Eigen::Vector3f>> mVerticesGlobal;
    std::shared_ptr<std::vector<Eigen::Vector3f>> mNormalsGlobal;
    Eigen::Matrix4f extrinsicMatrix;
    Eigen::Matrix3f intrinsicMatrix;
};

Frame.cpp

#include "Frame.h"


Frame::Frame(cv::Mat depthMap, cv::Mat colorMap, Eigen::Matrix3f& depthIntrinsics, Eigen::Matrix4f& depthExtrinsics): depthMap(depthMap), colorMap(colorMap) 
{
	depthWidth = depthMap.cols;
	depthHeight = depthMap.rows;
    computeVertexMap(depthMap, depthIntrinsics);
    computeNormalMap(depthMap);

    intrinsicMatrix = depthIntrinsics;
	extrinsicMatrix = depthExtrinsics;
	Eigen::Matrix4f extrinsicMatrixInv = extrinsicMatrix.inverse();
	const auto rotation = extrinsicMatrixInv.block(0, 0, 3, 3);
	mVerticesGlobal = std::make_shared<std::vector<Eigen::Vector3f>>(transformPoints(*mVertices, extrinsicMatrixInv));
	mNormalsGlobal = std::make_shared<std::vector<Eigen::Vector3f>>(rotatePoints(*mNormals, rotation));
}

Eigen::Vector3f Frame::getVertexGlobal(size_t idx) const { return mVerticesGlobal->at(idx); }

Eigen::Vector3f Frame::getNormalGlobal(size_t idx) const { return mNormalsGlobal->at(idx); }

bool Frame::containsImgPoint(Eigen::Vector2i imgPoint) 
{
    return imgPoint[0] >= 0 && imgPoint[0] < depthWidth && imgPoint[1] >= 0 && imgPoint[1] < depthHeight;
}

int Frame::getFrameHeight() { return depthHeight; }
int Frame::getFrameWidth() { return depthWidth; }

std::vector<Eigen::Vector3f>& Frame::getVertexMap() { return *mVertices; }
std::vector<Eigen::Vector3f>& Frame::getNormalMap() { return *mNormals; }
std::vector<Eigen::Vector3f>& Frame::getVertexMapGlobal() { return *mVerticesGlobal; }
std::vector<Eigen::Vector3f>& Frame::getNormalMapGlobal() { return *mNormalsGlobal; }

Eigen::Vector3f Frame::projectPointIntoFrame(const Eigen::Vector3f& point) 
{
    const auto rotation = extrinsicMatrix.block(0, 0, 3, 3);
    const auto translation = extrinsicMatrix.block(0, 3, 3, 1);
    return rotation * point + translation;
}

Eigen::Vector2i Frame::projectOntoImgPlane(const Eigen::Vector3f& point)
{
    Eigen::Vector3f projected = intrinsicMatrix * point;
    if (projected[2] == 0) return Eigen::Vector2i(MINF, MINF);
    projected /= projected[2];
    return Eigen::Vector2i((int)round(projected.x()), (int)round(projected.y()));
}

std::vector<Eigen::Vector3f> Frame::transformPoints(const std::vector<Eigen::Vector3f>& points, const Eigen::Matrix4f& transformation) 
{
    const Eigen::Matrix3f rotation = transformation.block(0, 0, 3, 3);
    const Eigen::Vector3f translation = transformation.block(0, 3, 3, 1);
    std::vector<Eigen::Vector3f> transformed(points.size());
    for (size_t idx = 0; idx < points.size(); ++idx)
	{
        if (points[idx].allFinite())
            transformed[idx] = rotation * points[idx] + translation;
        else
            transformed[idx] = Eigen::Vector3f(MINF, MINF, MINF);
    }
    return transformed;
}

std::vector<Eigen::Vector3f> Frame::rotatePoints(const std::vector<Eigen::Vector3f>& points, const Eigen::Matrix3f& rotation) 
{
    std::vector<Eigen::Vector3f> transformed(points.size());
    for (size_t idx = 0; idx < points.size(); ++idx)
	{
        if (points[idx].allFinite())
            transformed[idx] = rotation * points[idx];
        else
            transformed[idx] = Eigen::Vector3f(MINF, MINF, MINF);
    }
    return transformed;
}

void Frame::computeVertexMap(cv::Mat depthMap, const Eigen::Matrix3f& depthIntrinsics)
{
	float fx = depthIntrinsics(0, 0);
	float fy = depthIntrinsics(1, 1);
	float cx = depthIntrinsics(0, 2);
	float cy = depthIntrinsics(1, 2);

	mVertices = std::make_shared<std::vector<Eigen::Vector3f>>(std::vector<Eigen::Vector3f>());
	mVertices->reserve(depthMap.rows * depthMap.cols);
	for (size_t i = 0; i < depthMap.rows; i++)
	{
		for (size_t j = 0; j < depthMap.cols; j++)
		{
			if (depthMap.at<ushort>(i, j) == 0)
				mVertices->emplace_back(Eigen::Vector3f(MINF, MINF, MINF));
			else
			{
				float depth = (float)depthMap.at<ushort>(i, j) / 5000.0f;
				mVertices->emplace_back(Eigen::Vector3f((j - cx) / fx * depth, (i - cy) / fy * depth, depth));
			}	
		}
	}
}

void Frame::computeNormalMap(cv::Mat depthMap)
{
    mNormals = std::make_shared<std::vector<Eigen::Vector3f>>(std::vector<Eigen::Vector3f>());
    mNormals->reserve(depthMap.rows * depthMap.cols);
    for (size_t i = 0; i < depthMap.rows; i++)
	{
        for (size_t j = 0; j < depthMap.cols; j++)
		{
            size_t idx = i * depthMap.cols + j;
            if (i == 0 || j == 0 || i == depthMap.rows - 1 || j == depthMap.cols - 1)
                mNormals->emplace_back(Eigen::Vector3f(MINF, MINF, MINF));
            else
			{
                Eigen::Vector3f du = mVertices->at(idx + 1) - mVertices->at(idx - 1);
                Eigen::Vector3f dv = mVertices->at(idx + depthMap.cols) - mVertices->at(idx - depthMap.cols);
                if (du.allFinite() && dv.allFinite()) 
                    mNormals->emplace_back(du.cross(dv).normalized());
                else 
                    mNormals->emplace_back(Eigen::Vector3f(MINF, MINF, MINF));
            }
        }
    }
}

ICP.h

#pragma once


#include <Eigen/Dense>
#include "Frame.h"


class ICP 
{
 public:
  ICP(Frame &_prevFrame, Frame &_curFrame, const double distanceThreshold, const double normalThreshold);
  Eigen::Matrix4f estimatePose(Eigen::Matrix4f& pose, int iterations = 10 );
  std::vector<std::pair<size_t, size_t>> findIndicesOfCorrespondingPoints(const Eigen::Matrix4f &pose);

 private:
  Frame &prevFrame;
  Frame &curFrame;
  const double distanceThreshold;
  const double normalThreshold;
};

ICP.cpp

#include "ICP.h"


ICP::ICP(Frame& _prevFrame, Frame& _curFrame, const double distanceThreshold, const double normalThreshold): 
	prevFrame(_prevFrame), curFrame(_curFrame), distanceThreshold(distanceThreshold), normalThreshold(normalThreshold) {}

Eigen::Matrix4f ICP::estimatePose(Eigen::Matrix4f& pose, int iterations) 
{
	for (size_t iteration = 0; iteration < iterations; iteration++)
	{
		const std::vector<std::pair<size_t, size_t>> correspondenceIds = findIndicesOfCorrespondingPoints(pose);
		std::cout <<"iteration: "<< iteration <<  "\t corresponding points: " << correspondenceIds.size() << std::endl;

		Eigen::Matrix3f rotationEP = pose.block(0, 0, 3, 3);
		Eigen::Vector3f translationEP = pose.block(0, 3, 3, 1);

		Eigen::MatrixXf A = Eigen::MatrixXf::Zero(correspondenceIds.size(), 6);
		Eigen::VectorXf b = Eigen::VectorXf::Zero(correspondenceIds.size());

		for (size_t i = 0; i < correspondenceIds.size(); i++)
		{
			const auto& x = rotationEP * curFrame.getVertexGlobal(correspondenceIds[i].second) + translationEP;
			const auto& y = prevFrame.getVertexGlobal(correspondenceIds[i].first);
			const auto& n = prevFrame.getNormalGlobal(correspondenceIds[i].first);

			A(i, 0) = n(2) * x(1) - n(1) * x(2);
			A(i, 1) = n(0) * x(2) - n(2) * x(0);
			A(i, 2) = n(1) * x(0) - n(0) * x(1);
			A(i, 3) = n(0);
			A(i, 4) = n(1);
			A(i, 5) = n(2);
			b(i) = n(0) * y(0) + n(1) * y(1) + n(2) * y(2) - n(0) * x(0) - n(1) * x(1) - n(2) * x(2);
		}

		Eigen::VectorXf x = A.bdcSvd(Eigen::ComputeThinU | Eigen::ComputeThinV).solve(b);

		float alpha = x(0), beta = x(1), gamma = x(2);
		Eigen::Vector3f translation = x.tail(3);
		Eigen::Matrix3f rotation = Eigen::AngleAxisf(alpha, Eigen::Vector3f::UnitX()).toRotationMatrix() *
			Eigen::AngleAxisf(beta, Eigen::Vector3f::UnitY()).toRotationMatrix() *
			Eigen::AngleAxisf(gamma, Eigen::Vector3f::UnitZ()).toRotationMatrix();

		Eigen::Matrix4f curentPose = Eigen::Matrix4f::Identity();
		curentPose.block<3, 3>(0, 0) = rotation;
		curentPose.block<3, 1>(0, 3) = translation;
		pose = curentPose * pose;
	}
	return pose;
}

std::vector<std::pair<size_t, size_t>> ICP::findIndicesOfCorrespondingPoints(const Eigen::Matrix4f & pose) 
{
	Eigen::Matrix4f estimatedPose = pose;
	std::vector<std::pair<size_t, size_t>> indicesOfCorrespondingPoints;

	std::vector<Eigen::Vector3f> prevFrameVertexMapGlobal = prevFrame.getVertexMapGlobal();
	std::vector<Eigen::Vector3f> prevFrameNormalMapGlobal = prevFrame.getNormalMapGlobal();

	std::vector<Eigen::Vector3f> curFrameVertexMapGlobal = curFrame.getVertexMapGlobal();
	std::vector<Eigen::Vector3f> curFrameNormalMapGlobal = curFrame.getNormalMapGlobal();

	const auto rotation = estimatedPose.block(0, 0, 3, 3);
	const auto translation = estimatedPose.block(0, 3, 3, 1);

	const auto estimatedPoseInv = estimatedPose.inverse();
	const auto rotationInv = estimatedPoseInv.block(0, 0, 3, 3);
	const auto translationInv = estimatedPoseInv.block(0, 3, 3, 1);

	for (size_t idx = 0; idx < prevFrameVertexMapGlobal.size(); idx++)
	{
		Eigen::Vector3f prevPointGlobal = prevFrameVertexMapGlobal[idx];
		Eigen::Vector3f prevNormalGlobal = prevFrameNormalMapGlobal[idx];
		if (prevPointGlobal.allFinite() && prevNormalGlobal.allFinite())
		{
			Eigen::Vector3f prevPointCurCamera = rotationInv * prevPointGlobal + translationInv;
			Eigen::Vector3f prevNormalCurCamera = rotationInv * prevFrameNormalMapGlobal[idx];

			// project point from global camera system into camera system of the current frame
			const Eigen::Vector3f prevPointCurFrame = curFrame.projectPointIntoFrame(prevPointCurCamera);
			// project point from camera system of the previous frame onto the image plane of the current frame
			const Eigen::Vector2i prevPointImgCoordCurFrame = curFrame.projectOntoImgPlane(prevPointCurFrame);

			if (curFrame.containsImgPoint(prevPointImgCoordCurFrame))
			{
				size_t curIdx = prevPointImgCoordCurFrame[1] * curFrame.getFrameWidth() + prevPointImgCoordCurFrame[0];
				Eigen::Vector3f curFramePointGlobal = rotation * curFrameVertexMapGlobal[curIdx] + translation;
				Eigen::Vector3f curFrameNormalGlobal = rotation * curFrameNormalMapGlobal[curIdx];

				if (curFramePointGlobal.allFinite() &&  curFrameNormalGlobal.allFinite() && (curFramePointGlobal - prevPointGlobal).norm() < distanceThreshold &&
					std::abs(curFrameNormalGlobal.dot(prevNormalGlobal)) / curFrameNormalGlobal.norm() / prevNormalGlobal.norm() < normalThreshold)
					indicesOfCorrespondingPoints.push_back(std::make_pair(idx, curIdx));
			}
		}
	}
	return indicesOfCorrespondingPoints;
}

main.cpp

#include "ICP.h"
#include "Frame.h"


#define DISTANCE_THRESHOLD 0.05
#define ANGLE_THRESHOLD 1.05
#define ICP_ITERATIONS 20


int main()
{
	Eigen::Matrix3f depthIntrinsics;
	depthIntrinsics << 525, 0, 319.5, 0, 525, 239.5, 0, 0, 1;
	Eigen::Matrix4f depthExtrinsics = Eigen::Matrix4f::Identity();
	Eigen::Matrix4f init_pose = Eigen::Matrix4f::Identity(4, 4);
	cv::Mat colorMap, depthMap;

	colorMap = cv::imread("./color/1305031102.175304.png", 1);
	depthMap = cv::imread("./depth/1305031102.160407.png", -1);
	Frame prevFrame(depthMap, colorMap, depthIntrinsics, depthExtrinsics);

	colorMap = cv::imread("./color/1305031102.211214.png", 1);
	depthMap = cv::imread("./depth/1305031102.194330.png", -1);
	Frame curFrame(depthMap, colorMap, depthIntrinsics, depthExtrinsics);

	ICP icp(prevFrame, curFrame, DISTANCE_THRESHOLD, ANGLE_THRESHOLD);
	std::cout << icp.estimatePose(init_pose, ICP_ITERATIONS) << std::endl;

	return 0;
}

运行结果
在这里插入图片描述

KinectFusion: 位姿估计
minxuanjun的博客
01-31 1244
KinectFusion 中的相机的位姿估计使用了点到面的ICP算法，因为其假设算法运行的帧率很高，所以相邻两帧相机的位姿变化较小，使用点到面的ICP比点到点的ICP算法计算速度快，收敛速度快。 其使用的公式如下所示   （1）式中，p为当前帧的3d 点， q是TSDF中对应的3d点，求解的位姿是当前帧相对于TSDF坐标系的位姿。 （5）式子中，求解雅克比矩阵使用了链式求导...
KinectFusion：用运动的深度相机进行实时3D重建及交互
TODAY WAS A GOOD DAY
08-26 1万+
KinectFusion: Real-time 3D Reconstruction and Interaction Using a Moving Depth Camera KinectFusion的GPU Pipeline实现. 图文全来自原论文或本人翻译，如有不正，敬请指出。 摘要              KinectFusion使用户可以手持Kinect移动，仅用Kinect的
Kinect-Fusion解读
成长之路，不畏荆棘
09-12 1958
kinect-fusion解读（静态三维重建的开山之作）
KinectFusion原理介绍
Mr Qin的博客
08-06 3333
1 简介：   2011年所开源的KinectFusion是第一个使用RGBD相机进行实时稠密三维重建的系统（需要GPU，甚至多个GPU或者高性能GPU），当时具有重大的开创意义；其所用的地图为TSDF地图，也对后续稠密地图的发展有着重大的意义。目前很多动态环境下的实时三维重建系统都是在KinectFusion或者ElasticFusion基础上扩展的。   实时三维重建技术与SLAM有很大的相关性，不同之处在于三维重建更关注建图的完整性和精度，而SLAM技术更关注定位精度,建图是为了辅助定位，并不太关注地
KinectFusion与TSDF
m0_37870385的博客
06-25 1096
原文链接
KinectFusion 和 ElasticFusion 三维重建方法
04-27
KinectFusion是一种基于RGB-D相机的实时三维重建方法，由Microsoft Research在2011年提出，能够在动态或静态的环境中构建出详细、准确的三维模型。KinectFusion的核心在于使用了体素哈希（Voxel Hashing）技术和直接...
(KinectFusion)_Kintinuous Spatially Extended KinectFusion.pdf
10-16
- **ICP**：ICP算法通过寻找点云之间的最佳匹配来估计它们之间的相对位姿，但在缺乏明显几何特征的环境中效果不佳。 - **视觉里程计**：FOVIS等视觉里程计系统利用相机图像序列估计运动，更适合于低纹理环境。 **多...
kinect fusion 3D重建基本算法
热门推荐
小虎 的博客
06-05 2万+
kinectfusion是微软研究院利用kinect进行三维重建的项目，深入了解该算法及其实现可以为3D重建的kinect类应用提供一定的参考。该项目本身需要比较强大的CUDA显卡支持实现实时重建。
DynamicFusion：如何将KinectFusion算法扩展到动态的三维重建场景
最新发布
rlczddl的博客
10-10 748
本文对DynamicFusion[1]做个简介，注意需要结合笔者上一篇关于KinectFusion的文章共同食用[5]。如有错误，欢迎评论指正。
Kinect Fusion 算法实现设计文档1
08-08
1. **ICP算法**：使用迭代最近点(ICP)算法，通过比较当前帧的深度图和全局模型的对应关系，估计相机的精确位置和姿态。 2. **优化轨迹**：随着时间推移，通过对过去帧的优化，确保传感器轨迹的准确性，减少漂移。 ...
论文笔记：Modeling Kinect Sensor Noise for Improved 3D Reconstruction and Tracking
flow_specter的博客
01-29 1245
对相机进行噪声模型分析，主要目的是为了更好地处理kincet深度图。此外，噪声模型也可以更好地应用给kinectfusion系统pipeline中的滤波、体积融合以及位姿估计等动作。实验结果表示，这样做的好处是可以重建更为精细的细节以及thinner surface。定量结果进一步地表明，噪声模型的引入，亦可以提高姿态估计的精度。
单应性变换(Homography)
newxuyangcao
04-28 2万+
import cv2 import numpy as np import pylab as pl if __name__ == '__main__' : # Read source image. im_src = cv2.imread('book2.jpg') # Four corners of the book in source image p
详解kinectfusion之三位姿估计
m0_59578498的博客
12-16 1068
kinectfusion中使用的位姿估计方式是点到面的ICP。这个方法的选择主要是考虑到相机快速运动，相邻两帧之间位姿变化微小。该ICP方法的优势是可以快速收敛至最优解。
三维重建
yy1234568888的博客
03-22 415
http://blog.youkuaiyun.com/xiaohu50/article/details/51592503 每次迭代的基本思路就是： 筛选：点集或曲面的筛选（滤波）  有全选，随意筛选，均匀分布，特征筛选等多种方法，kinectFusion中使用的应该是最朴素的全选（由于使用了GPU，并行化增加的前提下简单的算法有无可比拟的优势） 匹配：两个点集之间的点进行配
目标检测后续处理之前后帧关联算法
qq_37116150的博客
01-06 3835
背景：使用SSD神经网络检测车辆与行人，由于汽车行走，视频采集不稳定等原因，会使得目标检测框发生抖动，所以使用前后帧关联算法，消弱目标框抖动程度。 设计思路：程序开始运行的第一帧做为下一帧的前一帧，后续程序运行，将前一帧的目标位置与后一帧的目标位置进行两辆匹配。匹配方式为目标的左上角距离与右下角距离之和，当两者之和小于阈值T时，则这两个目标（前一帧目标与当前帧目标）匹配成功。然后，将所有的匹配结...
KinectFusion: Real-Time Dense Surface Mapping and Tracking
成长之路，不畏荆棘
08-12 1504
Kinect-Fusion论文中英文对照，存在很多不妥之处，敬请谅解
Kinect的三维重建
潜龙勿用的专栏
02-24 1万+
有关Kinect应用开发正日新月异，稍有懈怠就会被远远甩在身后。不过，Kinect目前带给我们的仍只是一个充满无限可能的远景，正如App store能吸引年仅11岁的开发者一样，Kinect未来将对“全民开发者”产生重要推动作用。另一方面，一些基于Kinect的应用研究仍颇复杂，主要是因为一些关键环节的滞后而导致的。2011年的siggraph talks上，KinectFusion首次展示了实时
How Kinect and Kinect Fusion (Kinfu) Work
Tan
07-03 3798
1.    Grab the raw depth data from the Kinect infrared sensor  An infrared projector projects invisible light onto the scene. It is carefully designed to project the dots the way a laser does, so tha
KinectFusion三维重建过程
Kindy
07-29 1万+
       基于深度相机的三维重建是一个非常流行、低成本的重建方案。基于Kinect一代是一种低成本的重建方案，图1是Kinect一代结构图。红外发射器发射红外线模板，通过红外CMOS获取反射红外光，采用光编码方式获得深度图。（Kinect二代采用ToF飞行时间法）。 为了能对深度相机的三维重建技术有深入了解，现对算法过程进行详细描述： 深度数据获取---去躁； 生成点云---计算摄像...
实时三维重建：KinectFusion与ElasticFusion算法解析
KinectFusion的实现开创了实时三维重建的新篇章，其GPU加速的ICP算法大大提升了处理速度。然而，随着技术的发展，ElasticFusion等后续工作进一步优化了重建过程，以应对更复杂和变化的环境。这两种技术为机器人导航...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

给算法爸爸上香

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值