pcl colors源码剖析

于 2023-04-26 20:56:17 发布
阅读量184 收藏
点赞数
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/moneymyone/article/details/130394456
版权

pcl colors源码剖析

文章目录


显示点云时，会根据点云某个字段进行配色，那么具体怎么实现的呢？

调用

调用时，可能会这么编写代码：

#include <pcl/io/pcd_io.h>
 #include <pcl/point_types.h>
#include <pcl/visualization/cloud_viewer.h>
#include <pcl/filters/passthrough.h>

using namespace std;
using namespace pcl;
using namespace io;
 

int main() {
	PointCloud<PointXYZI>::Ptr cloud(new PointCloud<PointXYZI>);
 
	if (io::loadPCDFile("/home/randy/sesame.pcd", *cloud) == -1)
        { 
		cerr << "can't read pcd files." << endl;
		return -1;
	}
 
	shared_ptr<pcl::visualization::PCLVisualizer> viewer(new pcl::visualization::PCLVisualizer("3D Viewer"));
	viewer->setBackgroundColor(0, 0, 0);
	viewer->setWindowName("Point clouds are shown by intensity"); 
            // 按照intensity字段进行渲染
	pcl::visualization::PointCloudColorHandlerGenericField<pcl::PointXYZI> fieldColor(cloud,"intensity");
	viewer->addPointCloud<pcl::PointXYZI>(cloud,fieldColor,"sample cloud");

        viewer->addText("Point clouds are shown by intensity", 50, 50,0,1,0, "randy_text");
 
	while (!viewer->wasStopped())
	{
		viewer->spinOnce(100);
		boost::this_thread::sleep(boost::posix_time::microseconds(100000));
	}
 
	return 0;
}

主要代码是

pcl::visualization::PointCloudColorHandlerGenericField<pcl::PointXYZI> fieldColor(cloud,"intensity");

核心思想是设置一个显示颜色的 handler，父类是PointCloudColorHandler，其子类有

剖析一下源码

PointCloudColorHandlerGenericField

    //
    /** \brief Generic field handler class for colors. Uses an user given field to extract
      * 1D data and display the color at each point using a min-max lookup table.
      * \author Radu B. Rusu 
      * \ingroup visualization
      */
    template <typename PointT>
    class PointCloudColorHandlerGenericField : public PointCloudColorHandler<PointT>
    {
      using PointCloud = typename PointCloudColorHandler<PointT>::PointCloud;
      using PointCloudPtr = typename PointCloud::Ptr;
      using PointCloudConstPtr = typename PointCloud::ConstPtr;

      public:
        using Ptr = shared_ptr<PointCloudColorHandlerGenericField<PointT> >;
        using ConstPtr = shared_ptr<const PointCloudColorHandlerGenericField<PointT> >;

        /** \brief Constructor. */
        PointCloudColorHandlerGenericField (const std::string &field_name)
          : field_name_ (field_name)
        {
          capable_ = false;
        }

        /** \brief Constructor. */
        PointCloudColorHandlerGenericField (const PointCloudConstPtr &cloud,
                                            const std::string &field_name)
          : PointCloudColorHandler<PointT> (cloud)
          , field_name_ (field_name)
        {
          setInputCloud (cloud);
        }

        /** \brief Destructor. */
        virtual ~PointCloudColorHandlerGenericField () {}

        /** \brief Get the name of the field used. */
        virtual std::string getFieldName () const { return (field_name_); }

        vtkSmartPointer<vtkDataArray>
        getColor () const override;

        /** \brief Set the input cloud to be used.
          * \param[in] cloud the input cloud to be used by the handler
          */
        virtual void
        setInputCloud (const PointCloudConstPtr &cloud);

      protected:
        /** \brief Class getName method. */
        virtual std::string
        getName () const { return ("PointCloudColorHandlerGenericField"); }

      private:
        using PointCloudColorHandler<PointT>::cloud_;
        using PointCloudColorHandler<PointT>::capable_;
        using PointCloudColorHandler<PointT>::field_idx_;
        using PointCloudColorHandler<PointT>::fields_;

        /** \brief Name of the field used to create the color handler. */
        std::string field_name_;
    };

可以看出，函数简介写的很清楚，根据给定字段对每个点使用 最小-最大查询表进行每个点颜色赋值

Generic field handler class for colors. Uses an user given field to extract 1D data and display the color at each point using a min-max lookup table.

查看getColor()函数

template <typename PointT> vtkSmartPointer<vtkDataArray>
PointCloudColorHandlerGenericField<PointT>::getColor () const
{
  if (!capable_ || !cloud_)
    return nullptr;

  auto scalars = vtkSmartPointer<vtkFloatArray>::New ();
  scalars->SetNumberOfComponents (1);

  vtkIdType nr_points = cloud_->size ();
  scalars->SetNumberOfTuples (nr_points);

  using FieldList = typename pcl::traits::fieldList<PointT>::type;

  float* colors = new float[nr_points];
  float field_data;

  int j = 0;
  // If XYZ present, check if the points are invalid
  int x_idx = -1;
  for (std::size_t d = 0; d < fields_.size (); ++d)
    if (fields_[d].name == "x")
      x_idx = static_cast<int> (d);

  if (x_idx != -1)
  {
    // Color every point
    for (vtkIdType cp = 0; cp < nr_points; ++cp)
    {
      // Copy the value at the specified field
      if (!std::isfinite ((*cloud_)[cp].x) || !std::isfinite ((*cloud_)[cp].y) || !std::isfinite ((*cloud_)[cp].z))
        continue;

      const std::uint8_t* pt_data = reinterpret_cast<const std::uint8_t*> (&(*cloud_)[cp]);
      memcpy (&field_data, pt_data + fields_[field_idx_].offset, pcl::getFieldSize (fields_[field_idx_].datatype));

      colors[j] = field_data;
      j++;
    }
  }
  else
  {
    // Color every point
    for (vtkIdType cp = 0; cp < nr_points; ++cp)
    {
      const std::uint8_t* pt_data = reinterpret_cast<const std::uint8_t*> (&(*cloud_)[cp]);
      memcpy (&field_data, pt_data + fields_[field_idx_].offset, pcl::getFieldSize (fields_[field_idx_].datatype));

      if (!std::isfinite (field_data))
        continue;

      colors[j] = field_data;
      j++;
    }
  }
  scalars->SetArray (colors, j, 0, vtkFloatArray::VTK_DATA_ARRAY_DELETE);
  return scalars;
}

核心是colors[j] = field_data;将filed的数值给 colors了

然后加入到点云中viewer->addPointCloud->再显示到屏幕fromHandlersToScreen

template <typename PointT> bool
pcl::visualization::PCLVisualizer::fromHandlersToScreen (
  const PointCloudGeometryHandler<PointT> &geometry_handler,
  const PointCloudColorHandler<PointT> &color_handler,
  const std::string &id,
  int viewport,
  const Eigen::Vector4f& sensor_origin,
  const Eigen::Quaternion<float>& sensor_orientation)
{
  if (!geometry_handler.isCapable ())
  {
    PCL_WARN ("[fromHandlersToScreen] PointCloud <%s> requested with an invalid geometry handler (%s)!\n", id.c_str (), geometry_handler.getName ().c_str ());
    return (false);
  }

  if (!color_handler.isCapable ())
  {
    PCL_WARN ("[fromHandlersToScreen] PointCloud <%s> requested with an invalid color handler (%s)!\n", id.c_str (), color_handler.getName ().c_str ());
    return (false);
  }

  vtkSmartPointer<vtkPolyData> polydata;
  vtkSmartPointer<vtkIdTypeArray> initcells;
  // Convert the PointCloud to VTK PolyData
  convertPointCloudToVTKPolyData<PointT> (geometry_handler, polydata, initcells);

  // Get the colors from the handler
  bool has_colors = false;
  double minmax[2];
  if (auto scalars = color_handler.getColor ())
  {
    polydata->GetPointData ()->SetScalars (scalars);
    scalars->GetRange (minmax);
    has_colors = true;
  }

  // Create an Actor
  vtkSmartPointer<vtkLODActor> actor;
  createActorFromVTKDataSet (polydata, actor);
  if (has_colors)
    actor->GetMapper ()->SetScalarRange (minmax);

  // Add it to all renderers
  addActorToRenderer (actor, viewport);

  // Save the pointer/ID pair to the global actor map
  CloudActor& cloud_actor = (*cloud_actor_map_)[id];
  cloud_actor.actor = actor;
  cloud_actor.cells = initcells;

  // Save the viewpoint transformation matrix to the global actor map
  vtkSmartPointer<vtkMatrix4x4> transformation = vtkSmartPointer<vtkMatrix4x4>::New();
  convertToVtkMatrix (sensor_origin, sensor_orientation, transformation);
  cloud_actor.viewpoint_transformation_ = transformation;
  cloud_actor.actor->SetUserMatrix (transformation);
  cloud_actor.actor->Modified ();

  return (true);
}

获取到颜色范围minmax，然后设置显示区间SetScalerRange

  // Get the colors from the handler
  bool has_colors = false;
  double minmax[2];
  if (auto scalars = color_handler.getColor ())
  {
    polydata->GetPointData ()->SetScalars (scalars);
    scalars->GetRange (minmax);
    has_colors = true;
  }

  // Create an Actor
  vtkSmartPointer<vtkLODActor> actor;
  createActorFromVTKDataSet (polydata, actor);
  if (has_colors)
    actor->GetMapper ()->SetScalarRange (minmax);

PointCloudColorHandlerLabelField

template <typename PointT> vtkSmartPointer<vtkDataArray>
PointCloudColorHandlerLabelField<PointT>::getColor () const
{
  if (!capable_ || !cloud_)
    return nullptr;

  auto scalars = vtkSmartPointer<vtkUnsignedCharArray>::New ();
  scalars->SetNumberOfComponents (3);

  vtkIdType nr_points = cloud_->size ();
  scalars->SetNumberOfTuples (nr_points);
  unsigned char* colors = scalars->GetPointer (0);


  std::map<std::uint32_t, pcl::RGB> colormap;
  if (!static_mapping_)
  {
    std::set<std::uint32_t> labels;
    // First pass: find unique labels
    for (vtkIdType i = 0; i < nr_points; ++i)
      labels.insert ((*cloud_)[i].label);

    // Assign Glasbey colors in ascending order of labels
    std::size_t color = 0;
    for (std::set<std::uint32_t>::iterator iter = labels.begin (); iter != labels.end (); ++iter, ++color)
      colormap[*iter] = GlasbeyLUT::at (color % GlasbeyLUT::size ());
  }

  int j = 0;
  for (vtkIdType cp = 0; cp < nr_points; ++cp)
  {
    if (pcl::isFinite ((*cloud_)[cp]))
    {
      const pcl::RGB& color = static_mapping_ ? GlasbeyLUT::at ((*cloud_)[cp].label % GlasbeyLUT::size ()) : colormap[(*cloud_)[cp].label];
      colors[j    ] = color.r;
      colors[j + 1] = color.g;
      colors[j + 2] = color.b;
      j += 3;
    }
  }

  return scalars;
}

这段代码是根据label值查询 GlasbeyLUT 表，而GlasbeyLUT 在common/colors.cpp中

/// Number of colors in Glasbey lookup table
static constexpr std::size_t GLASBEY_LUT_SIZE = GLASBEY_LUT.size() / 3;

/// Number of colors in Viridis lookup table
static constexpr std::size_t VIRIDIS_LUT_SIZE = VIRIDIS_LUT.size() / 3;

static constexpr std::array<const std::array<unsigned char, 256 * 3>*, 2> LUTS = { &GLASBEY_LUT, &VIRIDIS_LUT };
static constexpr std::array<std::size_t, 2> LUT_SIZES = { GLASBEY_LUT_SIZE, VIRIDIS_LUT_SIZE };

template<typename pcl::ColorLUTName T> pcl::RGB
pcl::ColorLUT<T>::at (std::size_t color_id)
{
  assert (color_id < LUT_SIZES[T]);
  pcl::RGB color;
  color.r = (*LUTS[T])[color_id * 3 + 0];
  color.g = (*LUTS[T])[color_id * 3 + 1];
  color.b = (*LUTS[T])[color_id * 3 + 2];
  return color;
}

其中 GLASBEY_LUT与VIRIDIS_LUT 为 内置的 256 * 3 数组，每行为 RGB颜色值。

GLASBEY颜色值可参考：https://github.com/taketwo/glasbey

PointCloudColorHandlerRGBAField

template <typename PointT> vtkSmartPointer<vtkDataArray>
PointCloudColorHandlerRGBAField<PointT>::getColor () const
{
  if (!capable_ || !cloud_)
    return nullptr;

  auto scalars = vtkSmartPointer<vtkUnsignedCharArray>::New ();
  scalars->SetNumberOfComponents (4);

  vtkIdType nr_points = cloud_->size ();
  scalars->SetNumberOfTuples (nr_points);
  unsigned char* colors = scalars->GetPointer (0);

  // If XYZ present, check if the points are invalid
  int x_idx = -1;
  for (std::size_t d = 0; d < fields_.size (); ++d)
    if (fields_[d].name == "x")
      x_idx = static_cast<int> (d);

  if (x_idx != -1)
  {
    int j = 0;
    // Color every point
    for (vtkIdType cp = 0; cp < nr_points; ++cp)
    {
      // Copy the value at the specified field
      if (!std::isfinite ((*cloud_)[cp].x) ||
          !std::isfinite ((*cloud_)[cp].y) ||
          !std::isfinite ((*cloud_)[cp].z))
        continue;

      colors[j    ] = (*cloud_)[cp].r;
      colors[j + 1] = (*cloud_)[cp].g;
      colors[j + 2] = (*cloud_)[cp].b;
      colors[j + 3] = (*cloud_)[cp].a;
      j += 4;
    }
  }
  else
  {
    // Color every point
    for (vtkIdType cp = 0; cp < nr_points; ++cp)
    {
      int idx = static_cast<int> (cp) * 4;
      colors[idx    ] = (*cloud_)[cp].r;
      colors[idx + 1] = (*cloud_)[cp].g;
      colors[idx + 2] = (*cloud_)[cp].b;
      colors[idx + 3] = (*cloud_)[cp].a;
    }
  }
  return scalars;
}

采用 PointCloudColorHandlerRGBAField字段的，就是默认点云字段包含rgb的，直接读取每个点的rgb即可。

欢迎关注公众号【三戒纪元】

moneymyone
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
PCL点云显示带颜色变换窗体工具实例源码
alicema1111的博客
01-28 521
PCL点云显示带颜色变换窗体工具实例源码 如需安装运行环境或远程调试，可加QQ905733049由专业技术人员远程协助！ 运行结果如下： 代码如下： #include "PoPoints.h" PoPoints::PoPoints(QWidget *parent) : QMainWindow(parent) { ui.setupUi(this); /***** Slots connection of dataTree(QTreeWidget) widget *****/ // It
PCL点云上色
weixin_43850909的博客
10-22 349
核心代码： 效果：核心代码： 效果：核心代码： 效果：核心代码： 效果：
点云渲染及可视化 (pcl::visualization)
A_L_A_N
08-17 9479
可PCLVisualizer视化类是PCL中功能最全的可视化类，与CloudViewer可视化类相比，PCLVisualizer更为复杂，具有更全面的功能，如显示法线、点云着色、绘制多种形状和开辟多个视口。 点云素材：bunny.txt 1、按照点云坐标x、y、z坐标值中字段给点云进行赋值渲染 void visualization(pcl::PointCloud<pcl::PointXYZ>::Ptr cloud) { pcl::visualization::PCLVisualiz.
PCL中点云可视化：坐标字段、随机、单一颜色、某一属性值设置颜色、带RGB数据、法向量显示
09-26 1万+
点云各类属性可视化
PCL 1.8.0 源码
05-06
PCL（Point Cloud Library）1.8.0是开源的三维点云...通过对PCL 1.8.0源码的深入学习和实践，开发者可以掌握点云处理的各个方面，实现复杂三维环境的感知和理解。无论是研究还是开发，PCL都是一个强大而全面的工具。
pcl1.9.1源码
05-08
PCL（Point Cloud Library）是在吸收了前人点云相关研究基础上建立起来的大型跨平台开源C++编程库，它实现了大量点云相关的通用算法和高效数据结构，涉及到点云获取、滤波、分割、配准、检索、特征提取、识别、追踪...
pcl1.8.1源码
05-08
PCL（Point Cloud Library）是在吸收了前人点云相关研究基础上建立起来的大型跨平台开源C++编程库，它实现了大量点云相关的通用算法和高效数据结构，涉及到点云获取、滤波、分割、配准、检索、特征提取、识别、追踪...
pcl-1.9.0源码(点云库源码)
09-09
在"pcl-1.9.0源码"这个压缩包中，包含了PCL库的完整源代码，是研究、学习和开发点云相关应用的重要资源。下面将详细介绍PCL库的主要功能、核心模块以及源码结构。 PCL库的核心功能主要包括以下几个方面： 1. **...
pcl-1.8.0源码
12-04
PCL（Point Cloud Library）是在吸收了前人点云相关研究基础上建立起来的大型跨平台开源C++编程库，它实现了大量点云相关的通用算法和高效数据结构，涉及到点云获取、滤波、分割...pcl-1.8.0源码提供pcl1.8.0的资源库。
PCL库学习笔记（为点云上色的几种方法详解）
热门推荐
SGL_LGS的博客
05-23 1万+
近段时间在学习PCL库，在点云上色的问题中进行了一个小总结。分别实现了一下几个功能： 1. 显示点云自带的颜色信息； 2. 根据点云的某个属性进行上色（例如：X,Y,Z等方向上不同颜色）； 3. 自定义单一颜色（给某个点云显示同一个颜色）； 4. 随机上色（由编译器随机给点云分配单一颜色）； 5. 显示点云的法线方向和法向量； 下文会分别介绍上述功能的实现，并提供代码示例： 1、显示点云自带的颜色信息（PointCloudColorHandlerRGBField） boost::shared_ptr<
PCL：基于颜色的区域生长分割
孙悟空
09-24 3252
本文介绍了PCL中基于颜色的区域生长分割，并给出对比试验。
PCL添加指定高度和切片数的圆柱
李昊的专栏
11-14 3546
最近在做项目中遇到用pcl画一个指定高度的
使用VoxelGrid滤波器对点云降采样，并使用PCLVisulizer进行显示
Bryan要加油
10-14 5115
#include #include #include #include #include #include #include int user_data; void viewerOneOff(pcl::visualization::PCLVisualizer& viewer) { viewer.setBackgroundColor(1.0, 0.5, 1.0); pcl::Po
PCL学习之点云可视化：坐标字段、随机、单一颜色、法向量
weixin_30905981的博客
09-23 1554
pcl中几种常见的点云渲染方式 （1）颜色区别深度 此方法在PointCloudColorHandlerGenericField类中实现，该将不同的深度值显示为不同的颜色，实现以颜色区分深度的目的，PointCloudColorHandlerGenericField方法是将点云按深度值(“x”、“y”、"z"均可)的差异着以不同的颜色进行渲染。 #include <pcl...
如何逐步匹配多幅点云
Bryan要加油
10-21 3380
/* \author Radu Bogdan Rusu * adaptation Raphael Favier*/ #include #include #include #include #include #include #include #include #include #include #include #include using pcl::visualizati
4 如何依次对准多个点云图像(未完待续)
hxshine的博客
12-02 973
参考:How to incrementally register pairs of clouds1 原理2 代码解析3 最终代码/* * Software License Agreement (BSD License) * * Copyright (c) 2010, Willow Garage, Inc. * All rights reserved. * * Redistribution an
PCL小知识点：copyPointCloud()的使用
qq_43407445的博客
07-01 4361
原博客地址：https://blog.csdn.net/h287850870/article/details/81184397 本文就自己在pcl中碰到过的copyPointCloud两种使用方法进行了总结: Part 1： 完全拷贝到新的点云之中：pcl::copyPointCloud (const pcl::PointCloud &cloud_in,pcl::PointCloud &a...
pcl1.10.1源码
最新发布
12-14
PCL（Point Cloud Library） 是一个开发和处理三维点云数据的开源库...总之，PCL 1.10.1 的源码是 PCL 库的核心，通过学习和理解源码，你可以更好地掌握 PCL 的功能和使用方法，从而更加高效地开发和处理三维点云数据。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值