【PCL】根据点对，获取仿射变换矩阵及姿态

最新推荐文章于 2024-08-16 17:56:15 发布
最新推荐文章于 2024-08-16 17:56:15 发布
阅读量1.9k 收藏 15
点赞数 2
分类专栏： # PCL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhy29563/article/details/106992795
版权
  • CMAKE配置
cmake_minimum_required(VERSION 3.16)
project(FridayLibrary)

set(CMAKE_CXX_STANDARD 14)


SET(BOOST_INCLUDE_DIR C:/Program\ Files/PCL\ 1.11.0/3rdParty/Boost/include)
SET(BOOST_LIBRARY_DIR C:/Program\ Files/PCL\ 1.11.0/3rdParty/Boost/lib)

set(PLC_ROOT        C:/Program\ Files/PCL\ 1.11.0)
set(PLC_INCLUDE_DIR C:/Program\ Files/PCL\ 1.11.0/include)
set(PLC_LIBRARY_DIR C:/Program\ Files/PCL\ 1.11.0/lib)

find_package(PCL REQUIRED)
if(PCL_FOUND)
    message ("PCL found")
else()
    message (FATAL_ERROR "Cannot find PCL")
endif(PCL_FOUND)
include_directories(${PLC_INCLUDE_DIR} ${BOOST_INCLUDE_DIR})
link_directories(${PLC_LIBRARY_DIR} ${BOOST_LIBRARY_DIR})


add_library(FridayLibrary SHARED library.cpp library.h)
target_link_libraries( FridayLibrary PRIVATE
        ${PCL_LIBRARIES}
        ${BOOST_LIBRARIES}
        )
  • PCL + C++
pcl::PointCloud<pcl::PointXYZ>::Ptr srcCloud(new pcl::PointCloud<pcl::PointXYZ>());
pcl::PointCloud<pcl::PointXYZ>::Ptr dstCloud(new pcl::PointCloud<pcl::PointXYZ>());

srcCloud->width = 12;
srcCloud->height = 1;
srcCloud->is_dense = false;
srcCloud->resize(srcCloud->width * srcCloud->height);

dstCloud->width = 12;
dstCloud->height = 1;
dstCloud->is_dense = false;
dstCloud->resize(dstCloud->width * dstCloud->height);

srcCloud->points[0].x = 0.0625075, srcCloud->points[0].y = 0.0341182, srcCloud->points[0].z = -0.0291991;
srcCloud->points[1].x = 0.0466103, srcCloud->points[1].y = 0.0437115, srcCloud->points[1].z = 0.0275582;
srcCloud->points[2].x = 0.0702050, srcCloud->points[2].y = 0.0316673, srcCloud->points[2].z = -0.0269043;
srcCloud->points[3].x = 0.0527458, srcCloud->points[3].y = 0.0392645, srcCloud->points[3].z = 0.0298687;
srcCloud->points[4].x = 0.0670084, srcCloud->points[4].y = 0.0275866, srcCloud->points[4].z = -0.0272287;
srcCloud->points[5].x = 0.0514137, srcCloud->points[5].y = 0.0382540, srcCloud->points[5].z = 0.029152;
srcCloud->points[6].x = 0.0575101, srcCloud->points[6].y = 0.0254605, srcCloud->points[6].z = -0.0302174;
srcCloud->points[7].x = 0.0535772, srcCloud->points[7].y = 0.0332998, srcCloud->points[7].z = -0.0328697;
srcCloud->points[8].x = 0.0383195, srcCloud->points[8].y = 0.0486851, srcCloud->points[8].z = 0.0244912;
srcCloud->points[9].x = 0.0560232, srcCloud->points[9].y = 0.0385878, srcCloud->points[9].z = -0.0330957;
srcCloud->points[10].x = 0.0660206, srcCloud->points[10].y = 0.0425857, srcCloud->points[10].z = -0.0297611;
srcCloud->points[11].x = 0.0489257, srcCloud->points[11].y = 0.053031, srcCloud->points[11].z = 0.0257074;

dstCloud->points[0].x = 5.299e-06, dstCloud->points[0].y = -7.164e-06, dstCloud->points[0].z = -0.0300047;
dstCloud->points[1].x = 5.299e-06, dstCloud->points[1].y = -7.164e-06, dstCloud->points[1].z = 0.0300047;
dstCloud->points[2].x = 0.00883181, dstCloud->points[2].y = 0.00174854, dstCloud->points[2].z = -0.0300047;
dstCloud->points[3].x = 0.0088318, dstCloud->points[3].y = -0.00176288, dstCloud->points[3].z = 0.0300047;
dstCloud->points[4].x = 0.00831968, dstCloud->points[4].y = -0.00345109, dstCloud->points[4].z = -0.0300047;
dstCloud->points[5].x = 0.00831968, dstCloud->points[5].y = -0.00345111, dstCloud->points[5].z = 0.0300047;
dstCloud->points[6].x = 5.297e-06, dstCloud->points[6].y = -0.00900659, dstCloud->points[6].z = -0.0300047;
dstCloud->points[7].x = -0.00747745, dstCloud->points[7].y = -0.00500697, dstCloud->points[7].z = -0.0300047;
dstCloud->points[8].x = -0.00899412, dstCloud->points[8].y = -7.2e-06,    dstCloud->points[8].z = 0.0300047;
dstCloud->points[9].x = -0.00882121, dstCloud->points[9].y = 0.00174855, dstCloud->points[9].z = -0.0300047;
dstCloud->points[10].x = -0.00175039, dstCloud->points[10].y = 0.00881934, dstCloud->points[10].z = -0.0300047;
dstCloud->points[11].x = -0.00175046, dstCloud->points[11].y = 0.00881932, dstCloud->points[11].z = 0.0300047;


//利用SVD方法求解变换矩阵  
pcl::registration::TransformationEstimationSVD<pcl::PointXYZ, pcl::PointXYZ> TESVD;
pcl::registration::TransformationEstimationSVD<pcl::PointXYZ, pcl::PointXYZ>::Matrix4 transformation2;
TESVD.estimateRigidTransformation(*srcCloud, *dstCloud, transformation2);
//输出变换矩阵信息  
std::cout << "The Estimated Rotation and translation matrices (using getTransformation function) are : \n" << std::endl;
printf("\n");
printf("    | %6.3f %6.3f %6.3f | \n", transformation2(0, 0), transformation2(0, 1), transformation2(0, 2));
printf("R = | %6.3f %6.3f %6.3f | \n", transformation2(1, 0), transformation2(1, 1), transformation2(1, 2));
printf("    | %6.3f %6.3f %6.3f | \n", transformation2(2, 0), transformation2(2, 1), transformation2(2, 2));
printf("\n");
printf("t = < %0.3f, %0.3f, %0.3f >\n", transformation2(0, 3), transformation2(1, 3), transformation2(2, 3));

//rpyMatrix();

Eigen::Matrix3d rotation_matrix;
rotation_matrix(0, 0) = transformation2(0, 0);
rotation_matrix(0, 1) = transformation2(0, 1);
rotation_matrix(0, 2) = transformation2(0, 2);
rotation_matrix(1, 0) = transformation2(1, 0);
rotation_matrix(1, 1) = transformation2(1, 1);
rotation_matrix(1, 2) = transformation2(1, 2);
rotation_matrix(2, 0) = transformation2(2, 0);
rotation_matrix(2, 1) = transformation2(2, 1);
rotation_matrix(2, 2) = transformation2(2, 2);

auto eulerAngle = rotation_matrix.eulerAngles(0, 1, 2);
std::cout << eulerAngle * 180 / 3.14 << std::endl;
  • C# 封装

头文件

#ifndef FRIDAYLIBRARY_LIBRARY_H
#define FRIDAYLIBRARY_LIBRARY_H
#include <pcl/io/pcd_io.h>
#include <pcl/point_types.h>
#include <pcl/sample_consensus/ransac.h>
#include <pcl/sample_consensus/sac_model_plane.h>
#include <pcl/visualization/pcl_visualizer.h>
#include <boost/thread/thread.hpp>
#include <pcl/point_cloud.h>
#include <pcl/registration/transformation_estimation_svd.h>
#include <vector>
#ifdef __DLL_BUILD
#define DLL_EXPORT __declspec(dllexport)
#else
#define DLL_EXPORT __declspec(dllimport)
#endif

#ifdef __cplusplus
extern "C" {
#endif

/// <summary>
/// 通过对应点获取目标点云在原始点云坐标空间下的姿态
/// </summary>
/// <param name="p_src_x">原始点云的X坐标</param>
/// <param name="p_src_y">原始点云的Y坐标</param>
/// <param name="p_src_z">原始点云的Z坐标</param>
/// <param name="p_dst_x">目标点云的X坐标</param>
/// <param name="p_dst_y">目标点云的Y坐标</param>
/// <param name="p_dst_z">目标点云的Z坐标</param>
/// <param name="length">点云个数</param>
/// <param name="pose">返回的姿态[X, Y, Z, RX, RY, RZ ]</param>
DLL_EXPORT void get_plane_pose( const float* p_src_x,
								const float* p_src_y,
								const float* p_src_z,
								const float* p_dst_x,
								const float* p_dst_y,
								const float* p_dst_z,
								const size_t length, float* pose);
#ifdef __cplusplus
}
#endif
#endif //FRIDAYLIBRARY_LIBRARY_H

源文件

#define __DLL_BUILD
#include "library.h"

/// <summary>
/// 通过对应点获取目标点云在原始点云坐标空间下的姿态
/// </summary>
/// <param name="p_src_x">原始点云的X坐标</param>
/// <param name="p_src_y">原始点云的Y坐标</param>
/// <param name="p_src_z">原始点云的Z坐标</param>
/// <param name="p_dst_x">目标点云的X坐标</param>
/// <param name="p_dst_y">目标点云的Y坐标</param>
/// <param name="p_dst_z">目标点云的Z坐标</param>
/// <param name="length">点云个数</param>
/// <param name="pose">返回的姿态[X, Y, Z, RX, RY, RZ ]</param>
void get_plane_pose(const float* p_src_x,
					const float* p_src_y,
					const float* p_src_z,
					const float* p_dst_x,
					const float* p_dst_y,
					const float* p_dst_z,
					const size_t length, float* pose)
{
	pcl::PointCloud<pcl::PointXYZ>::Ptr src_cloud(new pcl::PointCloud<pcl::PointXYZ>());
	pcl::PointCloud<pcl::PointXYZ>::Ptr dst_cloud(new pcl::PointCloud<pcl::PointXYZ>());

	src_cloud->width = length;
	src_cloud->height = 1;
	src_cloud->is_dense = false;
	src_cloud->resize(src_cloud->width * src_cloud->height);

	dst_cloud->width = length;
	dst_cloud->height = 1;
	dst_cloud->is_dense = false;
	dst_cloud->resize(dst_cloud->width * dst_cloud->height);

	for (size_t i = 0; i < length; i++)
	{
		src_cloud->points[i].x = p_src_x[i];
		src_cloud->points[i].y = p_src_y[i];
		src_cloud->points[i].z = p_src_z[i];

		dst_cloud->points[i].x = p_dst_x[i];
		dst_cloud->points[i].y = p_dst_y[i];
		dst_cloud->points[i].z = p_dst_z[i];
	}


	const pcl::registration::TransformationEstimationSVD<pcl::PointXYZ, pcl::PointXYZ> estimation_svd;
	pcl::registration::TransformationEstimationSVD<pcl::PointXYZ, pcl::PointXYZ>::Matrix4 transformation_matrix;

	estimation_svd.estimateRigidTransformation(*src_cloud, *dst_cloud, transformation_matrix);

	Eigen::Matrix3d rotation_matrix;
	rotation_matrix(0, 0) = transformation_matrix(0, 0);
	rotation_matrix(0, 1) = transformation_matrix(0, 1);
	rotation_matrix(0, 2) = transformation_matrix(0, 2);
	rotation_matrix(1, 0) = transformation_matrix(1, 0);
	rotation_matrix(1, 1) = transformation_matrix(1, 1);
	rotation_matrix(1, 2) = transformation_matrix(1, 2);
	rotation_matrix(2, 0) = transformation_matrix(2, 0);
	rotation_matrix(2, 1) = transformation_matrix(2, 1);
	rotation_matrix(2, 2) = transformation_matrix(2, 2);

	const auto euler_angles = rotation_matrix.eulerAngles(0, 1, 2) * 180 / 3.1415926f;

	pose[0] = transformation_matrix(0, 3);
	pose[1] = transformation_matrix(1, 3);
	pose[2] = transformation_matrix(2, 3);
	pose[3] = static_cast<float>(euler_angles[0]);
	pose[4] = static_cast<float>(euler_angles[1]);
	pose[5] = static_cast<float>(euler_angles[2]);
}

C# 调用

using System;
using System.IO;
using System.Runtime.InteropServices;

namespace ConsoleApp1
{
    internal class Program
    {
        public struct Buffer
        {
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 128)]
            public byte[] DstAddr;
        }


        [DllImport("./FridayLibrary", CallingConvention = CallingConvention.Cdecl, EntryPoint = "get_plane_pose")]
        internal static extern void GetPose(float[] srcX, float[] srcY, float[] srcZ, float[] dstX, float[] dstY, float[] dstZ, int length, ref Buffer buf);

        static void Main(string[] args)
        {
            var srcX = new float[]
            {
                0.0625075f, 0.0466103f, 0.0702050f, 0.0527458f, 0.0670084f, 0.0514137f, 0.0575101f, 0.0535772f, 0.0383195f, 0.0560232f, 0.0660206f, 0.0489257f
            };
            var srcY = new float[]
            {
                0.0341182f, 0.0437115f, 0.0316673f, 0.0392645f, 0.0275866f, 0.0382540f, 0.0254605f, 0.0332998f, 0.0486851f, 0.0385878f, 0.0425857f, 0.053031f
            };
            var srcZ = new float[]
            {
                -0.0291991f, 0.0275582f, -0.0269043f, 0.0298687f, -0.0272287f, 0.029152f, -0.0302174f, -0.0328697f, 0.0244912f, -0.0330957f, -0.0297611f, 0.0257074f
            };

            var dstX = new float[]
            {
                5.299e-06f, 5.299e-06f, 0.00883181f, 0.0088318f, 0.00831968f, 0.00831968f, 5.297e-06f, -0.00747745f, -0.00899412f, -0.00882121f, -0.00175039f, -0.00175046f
            };
            var dstY = new float[]
            {
                -7.164e-06f, -7.164e-06f, 0.00174854f, -0.00176288f, -0.00345109f, -0.00345111f, -0.00900659f, -0.00500697f, -7.2e-06f, 0.00174855f, 0.00881934f, 0.00881932f
            };
            var dstZ = new float[]
            {
                -0.0300047f, 0.0300047f, -0.0300047f, 0.0300047f, -0.0300047f, 0.0300047f, -0.0300047f, -0.0300047f, 0.0300047f, -0.0300047f, -0.0300047f, 0.0300047f
            };

            GetPose(srcX, srcY, srcZ,dstX,dstY,dstZ,9,ref buf);
            using (var stream = new MemoryStream(buf.DstAddr))
            {
                using (var reader = new BinaryReader(stream))
                {
                    var tx = reader.ReadSingle();
                    var ty = reader.ReadSingle();
                    var tz = reader.ReadSingle();
                    var rx = reader.ReadSingle();
                    var ry = reader.ReadSingle();
                    var rz = reader.ReadSingle();

                    Console.WriteLine($"{tx}, {ty}, {tz}, {rx}, {ry}, {rz}");
                }
            }

            Console.ReadKey();
        }
    }
}

 

 

zhy29563
关注
专栏目录
基于ICP算法计算点集之间的变换矩阵（旋转、平移）
黎国溥
11-19 5271
前言 本文主要是计算两个激光雷达之间的变换矩阵，即计算两组点云之间的变换矩阵。其中处理的点云数据主要是由x,y,z,intensity组成的，代表空间位置x,ry,z 和每个点云对应的反射强度intensity； 这里计算点集之间的变换矩阵，用到每个点云的x,y,z信息，可表示为n*3的数组；两组激光雷达点云，可以表示为2和n*3的数组。 首先使用ICP点云匹配算法，计算两组点云之n*3的数组间对应的点；然后基于SVD算法求出两个对应点集合的旋转矩阵R和转移矩阵t。 一、基于ICP匹配对应点
CloudCompare&PCL 根据匹配点计算变换矩阵
dayuhaitang1的博客
06-21 641
根据匹配点计算变换矩阵
2D坐标系下的点的转换矩阵（平移、缩放、旋转、错切）
关注工业机器人应用
10-17 2032
有了以上平移、旋转、缩放和错切矩阵后，我们就可以通过矩阵乘法求得二维平面上点P任意变换后坐标。帮助理解反向计算转换矩阵，该问描述的是正向的变换。
PCL 点云位姿变换（Transforms）
最新发布
xhm01291212的博客
08-16 362
矩阵变换。
opencv仿射变换之获取变换矩阵
小淼淼的博客
03-19 624
opencv仿射变换之获取变换矩阵
PCL中仿射变换Affine3f(四维)矩阵与Matrix4f(四维)矩阵之间的转换
WillWinston的博客
05-02 1万+
Affine3f中有rotation和translation分量，但Matrix4f中没有。1、Matrix4f到Affine3f：--------------------------------------Matrix4f m4f_transform;Eigen::Transform&lt;float, 3, Eigen::Affine&gt; a3f_transform (m4f_transf...
仿射变换（AffineTransform）与仿射矩阵
TracelessLe的专栏
02-09 2万+
前言 仿射变换（Affine transformation），又称仿射映射，是指在几何中，对一个向量空间进行一次线性变换并接上一个平移，变换为另一个向量空间。 它是一种二维坐标到二维坐标间的线性变换，保持了二维图形的“平直性”（直线经过变换之后依然是直线）和“平行性”（二维图形之间的相对位置关系保持不变，平行线依然是平行线，且直线上点的位置顺序不变）。 任意的仿射变换都能表示成“乘以一个矩阵(线性变换)，再加上一个向量 (平移) 的形式”。 仿射变换 仿射矩阵 逆仿射变换与其矩阵 参考资料 [1] 仿射变
【2024最新版】PCL点云处理算法汇总（C++长期更新版）
热门推荐
点云侠的博客
02-27 57万+
PCL学习目录。博客长期更新，最近一次更新时间为：2024年9月4日。
利用PCL库从点云数据生成深度图像及关键点提取
KLNSDFHUASF的博客
11-19 3442
利用PCL库从点云数据生成生成深度图像及关键点提取 利用PCL库从点云数据生成深度图像及关键点提取 本想利用标准点云数据库分割成若干块，利用标准点云数据生成深度图像作为数据库用来验证算法，目前效果不是很好。不过作为一种特征点提取方法还是有参考价值。 1.点云–深度图像 可视化深度图像： 在3D viewer中以点云的方式显示。 另一种方式是作为一幅图像显示（以不同的颜色表示不同的深度值） 定义...
在PCL(Point Cloud Library,点云库)下导入PLY和OBJ格式文件
qq_32454557的博客
03-30 2270
简介 PCL全称Point Cloud Library，官方网站为(https://pointclouds.org)，是一个专门用于点云处理的C++开源库。其功能包括了点云数据的基本操作，如保存、读取、显示；包括了点云的进阶操作，如空间刚体变换（旋转、平移）、仿射变换（旋转、平移、缩放）等；包括了点云的更进阶操作，如ICP(Iterative Closest Point)点云配准、3D特征描述子的计算、3D物体识别等。 本工作的背景是人体躯干姿态识别，采用ICP(Iterative Closest Poin
PCL中的3D特征描述子
Julie Liang的博客
02-20 2697
一. PCL中的特征点提取原则 1. 3D特征，在PCL中即：局部特征描述子，只有这一种。 3D feature，就是为了区分不同的表面几何特征而提取的特征值和测度值。 通常的描述方法是Local descriptor，局部描述子，用于表现局部点所代表的表面几何特征。好的点特征描述子通常具备下面的特征： 1）转换不变性，也就是旋转、平移不会影响到特征向量的描述； 2）采样密度变化不变性，即不同采样频率下的特征矢量基本一致； 3）噪声不变性，即，数据中不同噪声含量条件下不会影响到特征向量的相...
汇总！三维点云配准算法，包括4PCS、K-4PCS、SAC-IA、ICP、PCA、深度学习方法等
3D视觉工坊
07-10 628
作者：PCIPG-Jing | 来源：3DCV，投稿入口添加微信：cv3d007,备注：三维点云，拉你入群。文末附行业细分群。1 什么是点云配准点云配准指的是输入两幅点云 Ps (source) 和 Pt (target)，输出一个变换矩阵T（即旋转R和平移t）使得 T(Ps)和Pt的重合程度尽可能高。我们可以把点云想象成由无数个三维点组成的云彩，而点云配准就是要把这些云彩按照它们实际的位置和姿...
求解空间两个三维坐标系之间的变换矩阵
thequitesunshine007的博客
05-14 1万+
三维刚体变换模型（即旋转/平移矩阵，RT矩阵）的估计方法 话不多说，上代码。亲写亲测有效。 cv::Mat Get3DR_TransMatrix(const std::vector<cv::Point3f>& srcPoints, const std::vector<cv::Point3f>& dstPoints) { double srcSumX = 0.0f; double srcSumY = 0.0f; double srcSumZ = 0.0f;
【OpenCV】仿射变换
iefenghao的博客
02-28 2457
一 仿射变换 仿射变换是一种二维坐标之间的变换，变换前后保持图形的平直性和平行性。仿射变换可以理解为是向量经过一次线性变换和一次平移变换。 Opencv中有封装好的仿射变换函数： void warpAffine(InputArray src, OutputArray dst, InputArray M, Size dsize, int flags=INTER_LINEAR, int bord...
opencv仿射变换
qq_44771627的博客
12-08 3390
API函数 1、获取仿射矩阵 （1）getAffineTransform //设置原图像与目标图像上三点计算矩阵 Mat A=getAffineTransform(const Point2f* src, const Point2f* dst) 参数const Point2f* src：原图的三个固定顶点 参数const Point2f* dst：目标图像的三个固定顶点 返回值：Mat型变换矩阵，可直接用于warpAffine()函数 注意，顶点...
仿射变换
u010096608的博客
12-01 2756
图像几何变换之仿射变换 1. 原理   仿射变换（Affine Transformation 或Affine Map）是一种二维坐标（x, y）到二维坐标（u, v）的线性变换，其数学表达式形式如下：      对应的齐次坐标矩阵表示形式为：      仿射变换保持了二维图形的“平直性”（直线经仿射变换后依然为直线）和“平行性”（直线之间的相对位置关系保持不变，平行线经仿射变换后依然...
仿射变换，根据点求变换矩阵以及根据角度和缩放因子求变换矩阵
gaocui883的博客
12-25 1724
//仿射变换，根据点求变换矩阵以及根据角度和缩放因子求变换矩阵 Mat mapx; Mat mapy; Mat src; Mat dst; int main() { //1.原图像。 src = imread("马车2.jpg"); resize(src, src, Size(), 0.1, 0.1); imshow("效果图",src); //2.确定两组点，每组点3个。 ...
PCL：实现SVD分解求变换矩阵（附完整源码）
希望我的博客，能帮上你解决学习中工作中所遇到的问题
10-07 144
PCL：实现SVD分解求变换矩阵（附完整源码）
PCL 点云点对点映射关系计算
weixin_39354845的博客
04-11 285
计算3对点之间的矩阵变换
用pcl获取一点矩阵范围内的点
06-02
要使用 PCL（点云库）获取一定范围内的点，你可以使用 PCL 中的 PassThrough 滤波器来实现。该滤波器可以剪切点云数据，只保留位于指定范围内的点。以下是示例代码： ```cpp #include <pcl/filters/passthrough.h> #include <pcl/point_types.h> #include <pcl/io/pcd_io.h> int main(int argc, char** argv) { // 读取点云数据 pcl::PointCloud<pcl::PointXYZ>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZ>); pcl::io::loadPCDFile<pcl::PointXYZ>("input_cloud.pcd", *cloud); // 定义 PassThrough 滤波器 pcl::PassThrough<pcl::PointXYZ> pass; pass.setInputCloud(cloud); pass.setFilterFieldName("x"); // 设置过滤的维度为 x pass.setFilterLimits(0.0, 1.0); // 设置 x 范围为 [0.0, 1.0] pass.filter(*cloud); // 过滤点云数据 // 保存过滤后的点云数据 pcl::io::savePCDFile<pcl::PointXYZ>("output_cloud.pcd", *cloud); return 0; } ``` 上述代码将读取一个名为 "input_cloud.pcd" 的点云文件，然后使用 PassThrough 滤波器过滤这些点，只保留 x 坐标在 [0.0, 1.0] 范围内的点，并将过滤后的点云数据保存为 "output_cloud.pcd" 文件。 你可以根据自己的需求修改示例代码中的过滤维度和范围，并使用 PassThrough 滤波器获取一定范围内的点。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

zhy29563

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

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

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

打赏作者

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

抵扣说明：

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

余额充值