PCL笔记

已于 2022-07-13 19:16:17 修改
阅读量511 收藏
点赞数
分类专栏： PCL Learn 文章标签： c++
于 2022-07-13 19:04:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_47989004/article/details/125770531
版权

PCL

PCD FILE文件格式概览

# unorganized
[In] 
head table_scene_lms400.pcd 

[Out]
# .PCD v0.7 - Point Cloud Data file format
VERSION 0.7
FIELDS x y z intensity distance sid
SIZE 4 4 4 4 4 4
TYPE F F F F F F
COUNT 1 1 1 1 1 1
WIDTH 460400
HEIGHT 1
VIEWPOINT 0 0 0 1 0 0 0  # sensor_orientation
POINTS 460400

# organized: cloud->isOrganized()
[In] 
head table_scene_mug_stereo_textured.pcd 

[Out]
# .PCD v0.7 - Point Cloud Data file format
VERSION 0.7
FIELDS x y z rgba
SIZE 4 4 4 4
TYPE F F F U
COUNT 1 1 1 1
WIDTH 640
HEIGHT 480
VIEWPOINT 0 0 0 0 1 0 0  # sensor_orientation
POINTS 307200

pcl cpp

CMakeLists.txt

cmake_minimum_required(VERSION 2.6 FATAL_ERROR)

project(pcl_visualizer_viewports)

find_package(PCL 1.2 REQUIRED)

include_directories(${PCL_INCLUDE_DIRS})
link_directories(${PCL_LIBRARY_DIRS})
add_definitions(${PCL_DEFINITIONS})

add_executable (pcl_visualizer_demo pcl_visualizer_demo.cpp)
target_link_libraries (pcl_visualizer_demo ${PCL_LIBRARIES})

设置sensor_orientation

point_cloud_ptr->sensor_orientation_=Eigen::Quaternionf(1, 0, 0, 0);

pcl sensor_orientation

Check fields

// fields: "rgb" "rgba"
template <typename T>
bool checkRGBFields(const std::string& fields)
{
    std::vector<pcl::PCLPointField> fields_;
    bool capable_=false;
    int field_idx_ = pcl::getFieldIndex<T> (fields, fields_);
    if (field_idx_ != -1)
    {
        capable_ = true;
    }
    return capable_;
}

//using 
bool capable=M_UTILITY::checkRGBFields<pcl::PointXYZ>("rgb");
std::cout<<capable<<'\n';
capable=M_UTILITY::checkRGBFields<pcl::PointXYZRGB>("rgb");
std::cout<<capable<<'\n';

# output
0
1

viewer for PointXYZ and PointXYZRGB

template <typename T>
typename pcl::visualization::PCLVisualizer::Ptr simpleViewer(typename pcl::PointCloud<T>::ConstPtr cloud,
                                                             pcl::PointCloud<pcl::Normal>::ConstPtr normals=nullptr)
{
    pcl::visualization::PCLVisualizer::Ptr viewer (new pcl::visualization::PCLVisualizer ("3D Viewer"));
    viewer->setBackgroundColor (0, 0, 0);
    bool capable_=false;
    capable_= checkRGBFields<T>("rgb") || checkRGBFields<T>("rgba");
    if(!capable_) // no rgb fields
    {
        viewer->addPointCloud<T> (cloud, "sample cloud");
    }
    else
    {
        pcl::visualization::PointCloudColorHandlerRGBField<T> rgb(cloud);
        viewer->addPointCloud<T> (cloud, rgb, "sample cloud");
    }
    viewer->setPointCloudRenderingProperties (pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 1, "sample cloud");
    if(normals)
        viewer->addPointCloudNormals<T, pcl::Normal> (cloud, normals, 10, 0.05, "normals");
    viewer->addCoordinateSystem (1.0);
    viewer->initCameraParameters ();
    return (viewer);
}

// using: viewer cloud with rgb or without rgba
std::string filename="table_scene_mug_stereo_textured.pcd";
pcl::PointCloud<pcl::PointXYZRGBA>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZRGBA>);
pcl::PointCloud<pcl::PointXYZ>::Ptr cloud1(new pcl::PointCloud<pcl::PointXYZ>);
pcl::PCDReader reader;
reader.read(filename, *cloud);
reader.read(filename, *cloud1);
pcl::visualization::PCLVisualizer::Ptr viewer=M_UTILITY::simpleViewer<pcl::PointXYZRGBA>(cloud);
viewer->spin();

pcl::visualization::PCLVisualizer::Ptr viewer2=M_UTILITY::simpleViewer<pcl::PointXYZ>(cloud1);
viewer2->spin();

// using: viewer cloud and normals
#include "viewer.h"
#include <pcl/io/pcd_io.h>
#include <pcl/features/integral_image_normal.h>

int main ()
{
    // load point cloud
    pcl::PointCloud<pcl::PointXYZRGBA>::Ptr cloud (new pcl::PointCloud<pcl::PointXYZRGBA>);
    pcl::io::loadPCDFile ("table_scene_mug_stereo_textured.pcd", *cloud);

    // estimate normals
    pcl::PointCloud<pcl::Normal>::Ptr normals (new pcl::PointCloud<pcl::Normal>);

    pcl::IntegralImageNormalEstimation<pcl::PointXYZRGBA, pcl::Normal> ne;
    ne.setNormalEstimationMethod (ne.AVERAGE_3D_GRADIENT);
    ne.setMaxDepthChangeFactor(0.02f);
    ne.setNormalSmoothingSize(10.0f);
    ne.setInputCloud(cloud);
    ne.compute(*normals);

    // visualize normals
    pcl::visualization::PCLVisualizer::Ptr viewer=M_UTILITY::simpleViewer<pcl::PointXYZRGBA>(cloud, normals);
    viewer->spin();
    return 0;
}

IO

#include <pcl/io/pcd_io.h>
#include <pcl/io/io.h>
#include <pcl/point_types.h>

pcl::PointCloud<pcl::PointXYZ>::Ptr cloud (new pcl::PointCloud<pcl::PointXYZ>);
pcl::PCDReader reader;
reader.read<pcl::PointXYZ> (filename, *cloud);
// pcl::io::loadPCDFile (filename, *cloud);
pcl::PCDWriter writer;
writer.write<pcl::PointXYZ> ("table_scene_lms400_inliers.pcd", *cloud_filtered, false); // binary = false
// pcl::io::savePCDFileASCII (filename, *cloud);

Transform

#include <iostream>
#include <pcl/io/pcd_io.h>
#include <pcl/point_cloud.h>
#include <pcl/common/transforms.h>
#include <pcl/visualization/pcl_visualizer.h>

int main()
{
	pcl::PointCloud<pcl::PointXYZ>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZ>);
	pcl::PointCloud<pcl::PointXYZ>::Ptr transformed_cloud(new pcl::PointCloud<pcl::PointXYZ>);

	if (pcl::io::loadPCDFile("1.pcd", *cloud) < 0)
	{
		PCL_ERROR("目标文件不存在！\n");
		return -1;
	}

	/// 方式1：Matrix4f
	// 创建矩阵对象transform_1，初始化为4×4单位阵
	Eigen::Matrix4f transform_1 = Eigen::Matrix4f::Identity();
	// 定义旋转矩阵，绕z轴
	float theta = M_PI / 4;		// 旋转弧度
	transform_1(0, 0) = cos(theta);
	transform_1(0, 1) = -sin(theta);
	transform_1(1, 0) = sin(theta);
	transform_1(1, 1) = cos(theta);
	// 定义在x轴上的平移，2.5m
	transform_1(0, 3) = 2.5;
	// 打印平移、旋转矩阵
	std::cout << "方式1: 使用Matrix4f\n";
	std::cout << transform_1 << std::endl;

	/// 方式2：Affine3f
	// 创建矩阵对象transform_2.matrix()，初始化为4×4单位阵
	Eigen::Affine3f transform_2 = Eigen::Affine3f::Identity();
	// 定义在x轴上的平移，2.5m
	transform_2.translation() << 2.5, 0.0, 0.0;	// 三个数分别对应X轴、Y轴、Z轴方向上的平移
	// 定义旋转矩阵，绕z轴
	transform_2.rotate(Eigen::AngleAxisf(theta, Eigen::Vector3f::UnitZ()));	//同理，UnitX(),绕X轴；UnitY(),绕Y轴.
	// 打印平移、旋转矩阵
	std::cout << "\n方式2: 使用Affine3f\n";
	std::cout << transform_2.matrix() << std::endl;	//注意：不是transform_2

	/// 执行转换
	// transform_1 或者 transform_2 都可以实现相同的转换
	pcl::transformPointCloud(*cloud, *transformed_cloud, transform_2);	//注意：不是transform_2.matrix()

	// Visualization可视化
	std::cout << "点云颜色：\n";
	std::cout << "原始点云：白色\n" << "平移、旋转后点云：红色\n";
	pcl::visualization::PCLVisualizer viewer("矩阵转换实例");

	/// 定义点云RGB颜色
	// 原始点云附色
	pcl::visualization::PointCloudColorHandlerCustom<pcl::PointXYZ> cloud_color(cloud, 255, 255, 255);
	viewer.addPointCloud(cloud, cloud_color, "original_cloud");
	// 变换后点云附色
	pcl::visualization::PointCloudColorHandlerCustom<pcl::PointXYZ> transformed_cloud_color(transformed_cloud, 250, 0, 0);
	viewer.addPointCloud(transformed_cloud, transformed_cloud_color, "transformed_cloud");

	viewer.addCoordinateSystem(1.0, "cloud", 0);	//定义坐标系
	viewer.setBackgroundColor(0.05, 0.05, 0.05, 0); // 设置背景颜色
	viewer.setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 2, "original_cloud");
	viewer.setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 2, "transformed_cloud");
	//viewer.setPosition(800, 400); // 设置可视化窗口位置

	while (!viewer.wasStopped())
	{ // Display the visualiser until 'q' key is pressed
		viewer.spinOnce();
	}

	return 0;
}

Filter

Extract the point cloud outside/inside the specified index

template <typename T>
void filterFromIndices(typename pcl::PointCloud<T>::Ptr cloud, pcl::PointIndices::ConstPtr indices)
{
    pcl::ExtractIndices<T> extract;
    extract.setInputCloud(cloud);
    extract.setIndices(indices);
    // set true to extract the point cloud outside the specified index
    // set false to extract the point cloud inside the specified index
    extract.setNegative(false);
    extract.filter(*cloud);
}

// using 
cloud_camera_->sampleAbovePlane();
std::vector<int> indices = cloud_camera_->getSampleIndices();
pcl::PointIndices::Ptr indices1(new pcl::PointIndices);
indices1->indices=indices;
M_UTILITY::filterFromIndices<pcl::PointXYZRGBA>(cloud_camera_->getCloudProcessed(), indices1);

Remove NAN

template <typename T>
void removeNans(typename pcl::PointCloud<T>::Ptr cloud_processed_)
{
    pcl::PointIndices::Ptr inliers(new pcl::PointIndices());
    pcl::removeNaNFromPointCloud(*cloud_processed_, *cloud_processed_, inliers->indices);
}

Filter

Removing outliers using a StatisticalOutlierRemoval filter

#include <pcl/filters/statistical_outlier_removal.h>

// Create the filtering object
/*
The number of neighbors to analyze for each point is set to 50, and the standard deviation multiplier to 1. What this means is that all points who have a distance larger than 1 standard deviation of the mean distance to the query point will be marked as outliers and removed.
*/
pcl::StatisticalOutlierRemoval<pcl::PointXYZ> sor;
sor.setInputCloud (cloud);
sor.setMeanK (50);
sor.setStddevMulThresh (1.0);
sor.filter (*cloud_filtered);

// utility.h
namespace M_UTILITY{
    pcl::visualization::PCLVisualizer::Ptr simpleVis (pcl::PointCloud<pcl::PointXYZ>::ConstPtr cloud);
    
    template <typename T>
    typename pcl::PointCloud<T>::Ptr filter(typename pcl::PointCloud<T>::Ptr cloud)
    {
        pcl::StatisticalOutlierRemoval<T> sor;
        sor.setInputCloud (cloud);
        sor.setMeanK (50);
        sor.setStddevMulThresh (1.0);
        typename pcl::PointCloud<T>::Ptr cloud_filtered(new pcl::PointCloud<T>);
        sor.filter (*cloud_filtered);
        return cloud_filtered;
    }
}
// utility.cpp
namespace M_UTILITY{
    pcl::visualization::PCLVisualizer::Ptr simpleVis (pcl::PointCloud<pcl::PointXYZ>::ConstPtr cloud)
    {
        // --------------------------------------------
        // -----Open 3D viewer and add point cloud-----
        // --------------------------------------------
        pcl::visualization::PCLVisualizer::Ptr viewer (new pcl::visualization::PCLVisualizer ("3D Viewer"));
        viewer->setBackgroundColor (0, 0, 0);
        viewer->addPointCloud<pcl::PointXYZ> (cloud, "sample cloud");
        viewer->setPointCloudRenderingProperties (pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 1, "sample cloud");
        viewer->addCoordinateSystem (1.0);
        viewer->initCameraParameters ();
        return (viewer);
    }
}
// using test pcl.cpp
std::string filename="table_scene_lms400.pcd";

pcl::PointCloud<pcl::PointXYZ>::Ptr cloud (new pcl::PointCloud<pcl::PointXYZ>);
pcl::PCDReader reader;
reader.read<pcl::PointXYZ> (filename, *cloud);
pcl::PointCloud<pcl::PointXYZ>::Ptr cloud1=M_UTILITY::filter<pcl::PointXYZ>(cloud);

pcl::visualization::PCLVisualizer::Ptr viewer = M_UTILITY::simpleVis(cloud);
viewer->spin();

pcl::visualization::PCLVisualizer::Ptr viewer1 = M_UTILITY::simpleVis(cloud1);
viewer1->spin();

// using CMakeLists.txt
add_library(${PROJECT_NAME}_viewer src/viewer.cpp)
target_link_libraries(${PROJECT_NAME}_viewer
                      ${PCL_LIBRARIES})

add_executable(testpcl src/testpcl.cpp)
target_link_libraries(testpcl ${PCL_LIBRARIES} ${PROJECT_NAME}_viewer)

[ 98%] Linking CXX shared library /home/zhao/catkin_ws/devel/lib/libgpd_ros_viewer.so
[ 98%] Built target gpd_ros_viewer
Scanning dependencies of target testpcl
[ 98%] Building CXX object gpd_ros/CMakeFiles/testpcl.dir/src/testpcl.cpp.o
[100%] Linking CXX executable /home/zhao/catkin_ws/devel/lib/gpd_ros/testpcl
[100%] Built target testpcl

Calculate surface normals

Normals

Linking CXX shared library /home/zhao/catkin_ws/devel/lib/libgpd_ros_viewer.so#include <pcl/features/normal_3d.h>

// ----------------------------------------------------------------
// -----Calculate surface normals with a search radius of 0.05-----
// ----------------------------------------------------------------
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);

Normal Estimation Using Integral Images

Organized

#include <pcl/visualization/cloud_viewer.h>
#include <iostream>
#include <pcl/io/io.h>
#include <pcl/io/pcd_io.h>
#include <pcl/features/integral_image_normal.h>
    
int 
main ()
{
    // load point cloud
    pcl::PointCloud<pcl::PointXYZ>::Ptr cloud (new pcl::PointCloud<pcl::PointXYZ>);
    pcl::io::loadPCDFile ("table_scene_mug_stereo_textured.pcd", *cloud);
    
    // estimate normals
    pcl::PointCloud<pcl::Normal>::Ptr normals (new pcl::PointCloud<pcl::Normal>);

    pcl::IntegralImageNormalEstimation<pcl::PointXYZ, pcl::Normal> ne;
    ne.setNormalEstimationMethod (ne.AVERAGE_3D_GRADIENT);
    ne.setMaxDepthChangeFactor(0.02f);
    ne.setNormalSmoothingSize(10.0f);
    ne.setInputCloud(cloud);
    ne.compute(*normals);

    // visualize normals
    pcl::visualization::PCLVisualizer viewer("PCL Viewer");
    viewer.setBackgroundColor (0.0, 0.0, 0.5);
    viewer.addPointCloudNormals<pcl::PointXYZ,pcl::Normal>(cloud, normals);
    
    while (!viewer.wasStopped ())
    {
      viewer.spinOnce ();
    }
    return 0;
}

visualizer

Visualizer

#include <pcl/visualization/pcl_visualizer.h>

pcl::visualization::PCLVisualizer::Ptr simpleVis (pcl::PointCloud<pcl::PointXYZ>::ConstPtr cloud)
{
    // --------------------------------------------
    // -----Open 3D viewer and add point cloud-----
    // --------------------------------------------
    pcl::visualization::PCLVisualizer::Ptr viewer (new pcl::visualization::PCLVisualizer ("3D Viewer"));
    viewer->setBackgroundColor (0, 0, 0);
    viewer->addPointCloud<pcl::PointXYZ> (cloud, "sample cloud");
    viewer->setPointCloudRenderingProperties (pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 1, "sample cloud");
    viewer->addCoordinateSystem (1.0);
    viewer->initCameraParameters ();
    return (viewer);
}

pcl::visualization::PCLVisualizer::Ptr rgbVis (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 ();
    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);
    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)
{
    // --------------------------------------------------------
    // -----Open 3D viewer and add point cloud and 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");
    viewer->addPointCloudNormals<pcl::PointXYZRGB, pcl::Normal> (cloud, normals, 10, 0.05, "normals");
    viewer->addCoordinateSystem (1.0);
    viewer->initCameraParameters ();
    return (viewer);
}

Other

Acquire the max/min point

#include <pcl/common/common.h>

pcl::PointXYZRGBA min_pt_pcl, max_pt_pcl;
pcl::getMinMax3D(*cloud_camera_->getCloudProcessed(), min_pt_pcl, max_pt_pcl);
const Eigen::Vector3f min_pt = min_pt_pcl.getVector3fMap();
const Eigen::Vector3f max_pt = max_pt_pcl.getVector3fMap();

ros PointCloud2 PointCloud

Convert PointCloud2 to PointCloud

#include <ros/ros.h>
#include <tf/transform_listener.h>

#include <pcl/io/pcd_io.h>
#include <pcl/io/io.h>
#include <pcl/point_types.h>

#include <pcl_conversions/pcl_conversions.h>
#include <pcl/point_types.h>
#include <pcl/PCLPointCloud2.h>
#include <pcl/conversions.h>


void cloud_cb(const boost::shared_ptr<const sensor_msgs::PointCloud2>& input){
    pcl::PCLPointCloud2 pcl_pc2;
    pcl_conversions::toPCL(*input,pcl_pc2);
    pcl::PointCloud<pcl::PointXYZ>::Ptr temp_cloud(new pcl::PointCloud<pcl::PointXYZ>);
    // or 
    // pcl::PointCloud<pcl::PointXYZRGBA>::Ptr temp_cloud(new pcl::PointCloud<pcl::PointXYZRGBA>);
    pcl::fromPCLPointCloud2(pcl_pc2,*temp_cloud);
    //do stuff with temp_cloud here
    static bool bsave=true;
    if(bsave)
    {
        bsave=false;
        pcl::PCDWriter writer;
        writer.write<pcl::PointXYZ> ("/home/zhao/table_scene.pcd", *temp_cloud, false); // binary = false
        // writer.write<pcl::PointXYZRGBA> ("/home/zhao/table_scene_rgba.pcd", *temp_cloud, false);
        // pcl::io::savePCDFileASCII (filename, *cloud);
        ROS_INFO("Done");
    }
}

int main(int argc, char** argv){
    ros::init(argc, argv, "pc2_listener");

    ros::NodeHandle node;
    ros::Subscriber sub_handler=node.subscribe("/kinect_V2/depth_registered/points", 10, cloud_cb);
    ROS_INFO("wait for msg...");

    ros::spin();
    return 0;
};

pcl python

fps using python pcl

import torch
import torch.nn as nn
import torch.nn.parallel
import torch.utils.data
from torch.autograd import Variable
import numpy as np
import torch.nn.functional as F

import pcl
import pcl.pcl_visualization


def index_points(points, idx):
    """
    Input:
        points: input points data, [B, N, C]
        idx: sample index data, [B, S]
    Return:
        new_points:, indexed points data, [B, S, C]
    """
    device = points.device
    B = points.shape[0]
    view_shape = list(idx.shape)
    view_shape[1:] = [1] * (len(view_shape) - 1)
    repeat_shape = list(idx.shape)
    repeat_shape[0] = 1
    batch_indices = torch.arange(B, dtype=torch.long).to(device).view(view_shape).repeat(repeat_shape)
    new_points = points[batch_indices, idx, :]
    return new_points


def farthest_point_sample(xyz, npoint):
    """
    Input:
        xyz: pointcloud data, [B, N, 3]
        npoint: number of samples
    Return:
        centroids: sampled pointcloud index, [B, npoint]
    """
    device = xyz.device
    B, N, C = xyz.shape
    centroids = torch.zeros(B, npoint, dtype=torch.long).to(device)
    distance = torch.ones(B, N).to(device) * 1e10
    farthest = torch.randint(0, N, (B,), dtype=torch.long).to(device)
    batch_indices = torch.arange(B, dtype=torch.long).to(device)
    for i in range(npoint):
        centroids[:, i] = farthest
        centroid = xyz[batch_indices, farthest, :].view(B, 1, 3)
        dist = torch.sum((xyz - centroid) ** 2, -1)
        mask = dist < distance
        distance[mask] = dist[mask]
        farthest = torch.max(distance, -1)[1]
    return centroids


def main():
    cloud = pcl.load("/home/zhao/processed.pcd")
    np_points = cloud.to_array()
    t_points = torch.from_numpy(np_points)
    t_points = t_points.repeat(1, 1, 1)
    num_sample = 1000
    idx = farthest_point_sample(t_points, num_sample)
    sample_pts = index_points(t_points, idx)
    sample_pts = sample_pts.squeeze(0)
    np_sample_pts = sample_pts.numpy()
    pc_sample = pcl.PointCloud(np_sample_pts)

    viewer = pcl.pcl_visualization.PCLVisualizering()
    viewer.AddPointCloud(pc_sample, b'scene_cloud', 0)
    viewer.AddCoordinateSystem(0.1)
    # viewer.RemovePointCloud(b'scene_cloud', 0)
    while not viewer.WasStopped():
        viewer.Spin()


if __name__ == '__main__':
    main()

sample_and_group in pointnet2

def main():
    begin_time = time.time()
    cloud = pcl.load("/home/zhao/pcd_filepath/bunny.pcd")
    np_points = cloud.to_array()
    # np_points = pc_normalize(np_points)
    t_points = torch.from_numpy(np_points)
    t_points = t_points.repeat(1, 1, 1)
    num_sample = 1000

    new_xyz, new_points = sample_and_group(num_sample, 0.1, 40, t_points, None)
    new_points = new_points.squeeze(0)
    new_xyz = new_xyz.squeeze(0)
    xyz_sample = pcl.PointCloud(new_xyz.numpy())
    print(cloud.size, xyz_sample.size)

    viewer = pcl.pcl_visualization.PCLVisualizering()

    color = [(255, 0, 0), (0, 255, 0), (0, 0, 255), (255, 255, 0)]
    color_w = (255, 255, 255)
    color_handler = pcl.pcl_visualization.PointCloudColorHandleringCustom(xyz_sample, *color_w)
    viewer.AddPointCloud_ColorHandler(xyz_sample, color_handler, b'cloud')
    for i in range(len(color)):
        id_str = 'pc_sample'+str(i)
        pc_sample = pcl.PointCloud(new_points[i, :, :].numpy())
        color_handler = pcl.pcl_visualization.PointCloudColorHandleringCustom(pc_sample, *color[i])
        viewer.AddPointCloud_ColorHandler(pc_sample, color_handler, id_str)

    viewer.AddCoordinateSystem(0.1)
    timeit("runtime", begin_time)
    while not viewer.WasStopped():
        viewer.Spin()

sample_and_group
new_xyz, new_points = sample_and_group
其中new_xyz为采样得到的点，new_points 为基于采样点分组得到的点集合

m_zhaoguangbao
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
PCL使用滤波器去除异常值
m0_50046535的博客
06-21 790
激光扫描通常会生成不同点密度的点云数据集。此外，测量误差会导致稀疏异常值，从而进一步破坏结果。这会使局部点云特征（例如表面法线或曲率变化）的估计复杂化，从而导致错误的值，进而可能导致点云配准失败。其中一些不规则性可以通过对每个点的邻域进行统计分析并修剪不符合特定标准的那些来解决。我们的稀疏异常值去除基于输入数据集中点到邻居距离分布的计算。对于每个点，我们计算从它到所有邻居的平均距离。通过假设结果分布是具有均值和标准偏差的高斯分布。首先，下载数据集table_scene_lms400.pcd 一、Statis
table_scene_lms400.rar
03-26
table_scene_lms400.pcd数据
4.PCD格式数据集合
05-05
本文件是本人在学习使用PCL过程中逐渐收集而来的.pcd文件的集合，放在这里共需要的同仁们学习是使用，本想全部放於一块，受上传权限限制，分开传於此，本文为4.pcd集合
table_scene_mug_stereo_textured.pcd
12-12
table_scene_mug_stereo_textured.pcd
PCL学习笔记.pdf
06-21
详细的对PCL学习过程中常见函数说明，有详细的图形和文字说明
pcl学习笔记整理收集
02-09
pcl学习笔记整理收集
pcl-notes pcl相关笔记
11-22
pcl-notes pcl相关笔记
PCL——Kinfu配置成功笔记
02-11
配置pcl_kinfu耗费了太多时间，特把我的配置过程告诉大家，亲测可用，相关的库文件对应的版本号在网上可以下载。
《《《总结》》》PCL的42个实例整理：1～24
为了梦想
08-19 4314
PCL官网：https://pointclouds.org/ turtorials：https://pcl.readthedocs.io/projects/tutorials/en/latest/ PCL官方提供了一系列案例，方便用户对点云数据进行处理： 点云库（PCL）是一个独立的、大规模的、开放的项目，用于2D/3D图像和点云处理。PCL是根据BSD许可的条款发布的，因此可以免费用于商业和研究。 无论你是刚刚发现了PCL还是你是一个长期的老手，这个页面包含了一组资源的链接，这些资源将有助于巩固.
table-scene-mug-stereo-textured.pcd
06-06
pcl教程所需的PCD文件，有组织点云文件
pcd_read.rar
03-26
采用C++编写的点云处理节点。基于ubuntu1604的PCD点云读取，切割，可自由选择点云截取的最大高度和最小高度，同时将截取的点云通过话题的形式发布，并保存截取的点云PCD文件。
圆柱模型分割
m0_50046535的博客
06-26 387
本教程举例说明了如何为圆柱模型运行样本共识分割。为了使示例更实用，对输入数据集进行以下操作（按顺序）：超过 1.5 米的数据点被过滤估计每个点的表面法线平面模型（描述我们演示数据集中的表）被分割并保存到磁盘一个圆柱形模型（描述我们演示数据集中的杯子）被分割并保存到磁盘下载数据集 https://raw.github.com/PointCloudLibrary/data/master/tutorials/table_scene_mug_stereo_textured.pcd创建cylinder_segment
PCL教程-点云分割之圆柱体分割
热门推荐
DayDayUp
09-08 1万+
原文链接：https://pcl.readthedocs.io/projects/tutorials/en/latest/cylinder_segmentation.html#cylinder-segmentation
pointclouds 点云 demo 中的资源文件如pcd找不到的问题
wyj372的专栏
06-29 245
pointclouds 点云demo tuturial 中的资源文件 pcd等如何找不到怎么解决
【PCL】教程don_segmentation.cpp 使用差异法线（DoN）技术来分割和分析点云
最新发布
cxyhjl的博客
04-21 743
测试程序table_scene_mug_stereo_textured.pcd差异法线特征文件don.pcd过滤掉差异法线强度小于threshold的点don_filtered.pcddon_cluster_0.pcddon_cluster_1.pcd[pcl::NormalEstimationOMP::setNumberOfThreads]Parallelizationisrequest...
使用积分图像估计法向量
machismo的博客
05-25 239
1.代码 下载数据集table_scene_mug_stereo_textured.pcd并存到磁盘中。 创建一个文件，比如，normal_estimation_using_integral_images.cpp将下面的代码放入其中： #include <pcl/visualization/cloud_viewer.h> #include <iostream> #include <pcl/io/io.h> #include <pcl/io/pcd_io.h>
使用VoxelGrid体素化网格对点云进行下采样
m0_50046535的博客
06-21 548
首先，下载数据集table_scene_lms400.pcd 创建voxel_grid.cpp文件源码： 说明：1、相关的头文件，创建点云对象 2、读取数据 3、创建体素大小为一厘米的pcl::VoxelGrid过滤器 4、 最后，将数据写入文件 编译和运行1、将以下行添加到 CMakeLists.txt 文件中： 2、运行3、 输出：......
三维重建工具——pclpy教程之Surface（完结）
图像处理、SLAM、PCL、OpenCV爱好者
10-10 2971
本教程代码开源：GitHub 欢迎star 文章目录一、最小二乘法 (MLS) 表面重建1. 代码2. 说明3. 运行二、为平面模型构造凹包或凸包多边形1. 代码：2. 说明3. 运行三、无序点云的快速三角剖分1. 算法原理2. 代码3. 说明4. 运行 一、最小二乘法 (MLS) 表面重建 本教程解释了如何使用移动最小二乘法 (MLS) 表面重建方法来平滑和重新采样噪声数据。请查看以下视频中的示例： 视频：基于多项式重构的平滑和法线估计 使用统计分析很难消除某些数据不规则性（由小的距离测量误差引起）。.
PCL根据颜色保存点云
09-03
根据引用中提到的PCL库学习笔记，PCL可以根据颜色信息保存点云。其中一种方法是通过使用PointCloudColorHandlerRGBField类来显示点云的自带颜色信息。这个类可以从点云数据中提取RGB颜色字段，并将其应用于点云可视...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值