filters.hpp

#ifndef VELODYNEUTILS_FILTERS_HPP
#define VELODYNEUTILS_FILTERS_HPP

#include <sys/types.h> // Necessary for libregionMap.h

#include <libregionMap.h>

#include <boost/shared_ptr.hpp>
#include <Eigen/Geometry>
#include <pcl/pcl_base.h>
#include <pcl/point_cloud.h>

#include "points.hpp"

extern "C" {
typedef struct data_im3d DATA_IM3D;
typedef struct REGION_MAP REGION_MAP;
}

namespace jafar {
namespace velodyneutils {

template<typename PointT>
class FrameTransformer : public pcl::PCLBase<PointT> {
public:
    typedef pcl::PCLBase<PointT> BaseClass;
    typedef pcl::PointCloud<PointT> PointCloud;
    typedef boost::shared_ptr<const Eigen::Affine3f> AffineConstPtr;
    typedef boost::shared_ptr<FrameTransformer<PointT> > Ptr;
    typedef boost::shared_ptr<const FrameTransformer<PointT> > ConstPtr;

    FrameTransformer();
    ~FrameTransformer();

    int setInputAffine(const AffineConstPtr& affine);
    int compute(PointCloud& output);

private:
    AffineConstPtr affine;

    bool initCompute();
};

template<typename PointInT>
class ToHDL : public pcl::PCLBase<PointInT> {
public:
    typedef pcl::PCLBase<PointInT> BaseClass;
    typedef typename BaseClass::PointCloud PointCloudIn;
    typedef pcl::PointCloud<PointHDL> PointCloudOut;
    typedef boost::shared_ptr<ToHDL<PointInT> > Ptr;
    typedef boost::shared_ptr<const ToHDL<PointInT> > ConstPtr;

    ToHDL();
    ~ToHDL();

    void compute(PointCloudOut& output);

private:
    bool initCompute();
};

template<typename PointInT, typename PointOutT>
class NormalEstimatorImages3D : public pcl::PCLBase<PointInT> {
public:
    typedef pcl::PCLBase<PointInT> BaseClass;
    typedef pcl::PointCloud<PointOutT> PointCloudOut;
    typedef boost::shared_ptr<NormalEstimatorImages3D<PointInT, PointOutT> >
            Ptr;
    typedef boost::shared_ptr<const NormalEstimatorImages3D<PointInT, PointOutT> >
            ConstPtr;

    NormalEstimatorImages3D();
    ~NormalEstimatorImages3D();

    void init();
    void compute(PointCloudOut& output);

private:
    DATA_IM3D* im3D;
    pcl::PointCloud<NormalPure> normals;

    bool initCompute();
};

template<typename PointInT>
class RegionMapEstimator : public pcl::PCLBase<PointInT> {
public:
    typedef pcl::PCLBase<PointInT> BaseClass;
    typedef pcl::PointCloud<PointRegionMap> PointCloudOut;
    typedef boost::shared_ptr<RegionMapEstimator<PointInT> > Ptr;
    typedef boost::shared_ptr<const RegionMapEstimator<PointInT> > ConstPtr;

    RegionMapEstimator();
    ~RegionMapEstimator();

    void init();
    void compute(PointCloudOut& output);

private:
    REGION_MAP* regionMap;
    DATA_IM3D* im3D;

    bool initCompute();
};

template<typename PointT>
class PointCloudMapper {
public:
    typedef typename pcl::PointCloud<PointT> PointCloud;
    typedef typename PointCloud::Ptr PointCloudPtr;
    typedef typename PointCloud::ConstPtr PointCloudConstPtr;
    typedef boost::shared_ptr<PointCloudMapper<PointT> > Ptr;
    typedef boost::shared_ptr<const PointCloudMapper<PointT> > ConstPtr;

    PointCloudMapper();
    ~PointCloudMapper();

    int setCloudIn(const PointCloudConstPtr& cloud);
    int setCloudOut(const PointCloudPtr& cloud);
    int compute();

private:
    PointCloudConstPtr mCloudIn;
    PointCloudPtr mCloudInDense;
    PointCloudPtr mCloudOut;
    int numClouds;

    bool initCompute();
};

template<typename PointT>
class PointCloudClassifier {
public:
    typedef typename pcl::PointCloud<PointT> PointCloudIn;
    typedef typename PointCloudIn::ConstPtr PointCloudInConstPtr;
    typedef typename boost::shared_ptr<const REGION_MAP> RegionMapConstPtr;
    typedef typename pcl::PointCloud<PointRegionMap> PointCloudOut;
    typedef typename PointCloudOut::Ptr PointCloudOutPtr;
    typedef boost::shared_ptr<PointCloudClassifier<PointT> > Ptr;
    typedef boost::shared_ptr<const PointCloudClassifier<PointT> > ConstPtr;

    PointCloudClassifier();
    ~PointCloudClassifier();

    int setCloudIn(const PointCloudInConstPtr& cloud);
    int setRegionMap(const RegionMapConstPtr& regionMap);
    int setCloudOut(const PointCloudOutPtr& cloud);
    int compute();

private:
    PointCloudInConstPtr mCloudIn;
    RegionMapConstPtr mRegionMap;
    PointCloudOutPtr mCloudOut;

    bool initCompute();
};

} // namespace velodyneutils
} // namespace jafar

#endif // VELODYNEUTILS_FILTERS_HPP