PclPointCloudColorHandlerLUT.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// -                        CloudViewer: www.cloudViewer.org                  -
// ----------------------------------------------------------------------------
// Copyright (c) 2018-2024 www.cloudViewer.org
// SPDX-License-Identifier: MIT
// ----------------------------------------------------------------------------
 
#pragma once
 
#ifdef _MSC_VER
#pragma warning(disable : 4996)  // Use of [[deprecated]] feature
#endif
 
#include <pcl/point_cloud.h>
#include <pcl/point_types.h>
#include <pcl/visualization/point_cloud_color_handlers.h>
#include <vtkDataArray.h>
#include <vtkSmartPointer.h>
#include <vtkUnsignedCharArray.h>
 
#include "PclCloudLUT.h"
 
using pcl::visualization::PointCloudColorHandler;
 
template <typename PointT>
class PclPointCloudColorHandlerLUT : public PointCloudColorHandler<PointT> {
public:
    typedef pcl::PointCloud<PointT> PointCloud;
    typedef typename PointCloud::Ptr PointCloudPtr;
    typedef typename PointCloud::ConstPtr PointCloudConstPtr;
 
    typedef std::shared_ptr<PclPointCloudColorHandlerLUT<PointT>> Ptr;
    typedef std::shared_ptr<const PclPointCloudColorHandlerLUT<PointT>>
            ConstPtr;
 
    PclPointCloudColorHandlerLUT() : PointCloudColorHandler<PointT>() {
        capable_ = false;
    }
 
    PclPointCloudColorHandlerLUT(const PointCloudConstPtr& cloud)
        : PointCloudColorHandler<PointT>(cloud) {
        setInputCloud(cloud);
    }
 
    virtual ~PclPointCloudColorHandlerLUT() {}
 
    inline bool isCapable() const { return (capable_); }
 
    virtual std::string getName() const { return ""; };
 
    virtual std::string getFieldName() const { return ""; };
 
    virtual bool getColor(vtkSmartPointer<vtkDataArray>& scalars) const {
        if (!capable_ || !cloud_) return (false);
 
        if (!scalars) scalars = vtkSmartPointer<vtkUnsignedCharArray>::New();
        scalars->SetNumberOfComponents(3);
 
        vtkIdType nr_points = cloud_->points.size();
        reinterpret_cast<vtkUnsignedCharArray*>(&(*scalars))
                ->SetNumberOfTuples(nr_points);
        unsigned char* colors =
                reinterpret_cast<vtkUnsignedCharArray*>(&(*scalars))
                        ->GetPointer(0);
 
        int j = 0;
        for (vtkIdType cp = 0; cp < nr_points; ++cp) {
            if (pcl::isFinite(cloud_->points[cp])) {
                // const pcl::RGB& color = PclCloudLUT::at (label[cp] %
                // PclCloudLUT::size ());
                const pcl::RGB& color = PclCloudLUT::at(label[cp]);
                colors[j] = color.r;
                colors[j + 1] = color.g;
                colors[j + 2] = color.b;
                j += 3;
            }
        }
 
        return (true);
    };
 
    virtual vtkSmartPointer<vtkDataArray> getColor() const {
        if (!capable_ || !cloud_) return nullptr;
 
        vtkSmartPointer<vtkDataArray> scalars =
                vtkSmartPointer<vtkUnsignedCharArray>::New();
        scalars->SetNumberOfComponents(3);
 
        vtkIdType nr_points = cloud_->points.size();
        reinterpret_cast<vtkUnsignedCharArray*>(&(*scalars))
                ->SetNumberOfTuples(nr_points);
        unsigned char* colors =
                reinterpret_cast<vtkUnsignedCharArray*>(&(*scalars))
                        ->GetPointer(0);
 
        int j = 0;
        for (vtkIdType cp = 0; cp < nr_points; ++cp) {
            if (pcl::isFinite(cloud_->points[cp])) {
                // const pcl::RGB& color = PclCloudLUT::at (label[cp] %
                // PclCloudLUT::size ());
                const pcl::RGB& color = PclCloudLUT::at(label[cp]);
                colors[j] = color.r;
                colors[j + 1] = color.g;
                colors[j + 2] = color.b;
                j += 3;
            }
        }
        return scalars;
    }
 
    virtual void setInputCloud(const PointCloudConstPtr& cloud) {
        cloud_ = cloud;
    }
 
    void setLabel(int* value) {
        label = value;
        capable_ = true;
    };
 
private:
    int* label;
 
    // Members derived from the base class
    using PointCloudColorHandler<PointT>::cloud_;
    using PointCloudColorHandler<PointT>::capable_;
    using PointCloudColorHandler<PointT>::field_idx_;
    using PointCloudColorHandler<PointT>::fields_;
};