executives.hpp

#ifndef VELODYNEUTILS_EXECUTIVES_HPP
#define VELODYNEUTILS_EXECUTIVES_HPP

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

#include <string>

#include <libregionMap.h>

#include <Eigen/Geometry>
#include <pcl/filters/passthrough.h>
#include <pcl/point_cloud.h>
#include <pcl/point_types.h>

#include "data.hpp"
#include "fileIO.hpp"
#include "filters.hpp"
#include "points.hpp"
#include "visualizers.hpp"

namespace jafar {
namespace velodyneutils {

class Executive {
public:
    virtual void update() = 0;
    virtual bool isId(const std::string& id) const = 0;
};

class ExecutiveReaderPosition : public Executive {
public:
    typedef ReaderPosition Filter;
    typedef jafar::velodyneutils::Data<Eigen::Affine3f> Data;

    ExecutiveReaderPosition(Filter* readerIn, Data* outputIn,
                            const std::string& idIn);
    ~ExecutiveReaderPosition();

    void setBaseFileName(const std::string& baseFileName);
    void setFileNumInput(void* fileNumInput);
    void setOutput(Data* output);
    virtual void update();
    virtual bool isId(const std::string& id) const;

private:
    Filter* reader;
    int* fileNumInput;
    Data* output;
    int time;
    bool updateNecessary;
    std::string id;
};

class ExecutiveReaderVelodyneImage3D : public Executive {
public:
    typedef ReaderVelodyneImage3D Filter;
    typedef jafar::velodyneutils::Data<pcl::PointCloud<pcl::PointXYZL> > Data;

    ExecutiveReaderVelodyneImage3D(Filter* readerIn, Data* outputIn,
                                   const std::string& idIn);
    ~ExecutiveReaderVelodyneImage3D();

    void setBaseFileName(const std::string& baseFileName);
    void setFileNumInput(void* fileNumInput);
    void setOutput(Data* output);
    virtual void update();
    virtual bool isId(const std::string& id) const;

private:
    Filter* reader;
    int* fileNumInput;
    Data* output;
    int time;
    bool updateNecessary;
    std::string id;
};

class ExecutiveReader3DImage : public Executive {
public:
    typedef Reader3DImage Filter;
    typedef jafar::velodyneutils::Data<pcl::PointCloud<PointXYZIL> > Data;

    ExecutiveReader3DImage(Filter* readerIn, Data* outputIn,
                           const std::string& idIn);
    ~ExecutiveReader3DImage();

    void setBaseFileName(const std::string& baseFileName);
    void setFileNumInput(void* fileNumInput);
    void setOutput(Data* output);
    virtual void update();
    virtual bool isId(const std::string& id) const;

private:
    Filter* reader;
    int* fileNumInput;
    Data* output;
    int time;
    bool updateNecessary;
    std::string id;
};

class ExecutiveReaderRegionMap : public Executive {
public:
    typedef ReaderRegionMap Reader;
    typedef jafar::velodyneutils::Data<pcl::PointCloud<PointRegionMap> >
            DataCloud;
    typedef jafar::velodyneutils::Data<REGION_MAP> DataRegionMap;

    ExecutiveReaderRegionMap(Reader* reader, DataCloud* output,
                             const std::string& id);
    ExecutiveReaderRegionMap(Reader* reader, DataRegionMap* output,
                             const std::string& id);
    ~ExecutiveReaderRegionMap();

    void setBaseFileName(const std::string& baseFileName);
    void setFileNum(int fileNum);
    void setInputFileNum(void* inputFileNum);
    void setOutputCloud(DataCloud* output);
    void setOutputRegionMap(DataRegionMap* output);
    virtual void update();
    virtual bool isId(const std::string& id) const;

private:
    Reader* mReader;
    int* mInputFileNum;
    DataCloud* mOutputCloud;
    DataRegionMap* mOutputRegionMap;
    int time;
    bool updateNecessary;
    std::string mId;
};

template<typename PointT>
class ExecutiveWriterPCD : public Executive {
public:
    typedef WriterPCD<PointT> Filter;
    typedef jafar::velodyneutils::Data<pcl::PointCloud<PointT> > Data;

    ExecutiveWriterPCD(Filter* writerIn, Data* inputIn,
                       const std::string& idIn);
    ~ExecutiveWriterPCD();

    void setInput(Data* input);
    void setBinary(bool binary);
    void setBaseFileName(const std::string& baseFileName);
    void setFileNumInput(void* fileNumInput);
    virtual void update();
    virtual bool isId(const std::string& id) const;

private:
    Filter* writer;
    Data* input;
    int* fileNumInput;
    int time;
    bool updateNecessary;
    std::string id;
};

template<typename PointT>
class ExecutiveFrameTransformer : public Executive {
public:
    typedef FrameTransformer<PointT> Filter;
    typedef jafar::velodyneutils::Data<pcl::PointCloud<PointT> > DataCloud;
    typedef jafar::velodyneutils::Data<Eigen::Affine3f> DataAffine;

    ExecutiveFrameTransformer(Filter* filterIn, DataCloud* inputCloudIn,
                              DataAffine* inputAffineIn, DataCloud* outputIn,
                              const std::string& idIn);
    ~ExecutiveFrameTransformer();

    void setInputCloud(DataCloud* input);
    void setInputAffine(DataAffine* input);
    void setOutput(DataCloud* output);
    virtual void update();
    virtual bool isId(const std::string& id) const;

private:
    Filter* filter;
    DataCloud* inputCloud;
    DataAffine* inputAffine;
    DataCloud* output;
    int timeCloud;
    int timeAffine;
    bool updateNecessary;
    std::string id;
};

template<typename PointInT>
class ExecutiveToHDL : public Executive {
public:
    typedef ToHDL<PointInT> Filter;
    typedef jafar::velodyneutils::Data<pcl::PointCloud<PointInT> > DataIn;
    typedef jafar::velodyneutils::Data<pcl::PointCloud<PointHDL> > DataOut;

    ExecutiveToHDL(Filter* filterIn, DataIn* inputIn, DataOut* outputIn,
                   const std::string& idIn);
    ~ExecutiveToHDL();

    void setInput(DataIn* input);
    void setOutput(DataOut* output);
    virtual void update();
    virtual bool isId(const std::string& id) const;

private:
    Filter* filter;
    DataIn* input;
    DataOut* output;
    int time;
    bool updateNecessary;
    std::string id;
};

template<typename PointInT, typename PointOutT>
class ExecutiveNormalEstimatorImages3D : public Executive {
public:
    typedef NormalEstimatorImages3D<PointInT, PointOutT> Filter;
    typedef jafar::velodyneutils::Data<pcl::PointCloud<PointInT> > DataIn;
    typedef jafar::velodyneutils::Data<pcl::PointCloud<PointOutT> > DataOut;

    ExecutiveNormalEstimatorImages3D(
            Filter* filterIn, DataIn* inputIn, DataOut* outputIn,
            const std::string& idIn);
    ~ExecutiveNormalEstimatorImages3D();

    void setInput(DataIn* input);
    void setOutput(DataOut* output);
    virtual void update();
    virtual bool isId(const std::string& id) const;

private:
    Filter* filter;
    DataIn* input;
    DataOut* output;
    int time;
    bool updateNecessary;
    std::string id;
};

template<typename PointInT>
class ExecutiveRegionMapEstimator : public Executive {
public:
    typedef RegionMapEstimator<PointInT> Filter;
    typedef jafar::velodyneutils::Data<pcl::PointCloud<PointInT> > DataIn;
    typedef jafar::velodyneutils::Data<pcl::PointCloud<PointRegionMap> >
            DataOut;

    ExecutiveRegionMapEstimator(Filter* filterIn,
                                DataIn* inputIn, DataOut* outputIn,
                                const std::string& idIn);
    ~ExecutiveRegionMapEstimator();

    void setInput(DataIn* input);
    void setOutput(DataOut* output);
    virtual void update();
    virtual bool isId(const std::string& id) const;

private:
    Filter* filter;
    DataIn* input;
    DataOut* output;
    int time;
    bool updateNecessary;
    std::string id;
};

template<typename PointT>
class ExecutivePassThrough : public Executive {
public:
    typedef pcl::PassThrough<PointT> Filter;
    typedef jafar::velodyneutils::Data<pcl::PointCloud<PointT> > Data;

    ExecutivePassThrough(Filter* filterIn, Data* inputIn, Data* outputIn,
                         const std::string& idIn);
    ~ExecutivePassThrough();

    void setInput(Data* input);
    void setFieldName(const std::string& fieldName);
    void setLimits(float limitMin, float limitMax);
    void setOutput(Data* output);
    virtual void update();
    virtual bool isId(const std::string& id) const;

private:
    Filter* filter;
    Data* input;
    Data* output;
    int time;
    bool updateNecessary;
    std::string id;
};

template<typename PointT>
class ExecutivePointCloudMapper : public Executive {
public:
    typedef PointCloudMapper<PointT> Filter;
    typedef jafar::velodyneutils::Data<pcl::PointCloud<PointT> > Data;

    ExecutivePointCloudMapper(Filter* filter, Data* input, Data* output,
                              const std::string& id);
    ~ExecutivePointCloudMapper();

    void setInput(Data* input);
    void setOutput(Data* output);
    virtual void update();
    virtual bool isId(const std::string& id) const;

private:
    Filter* mFilter;
    Data* mInput;
    Data* mOutput;
    int time;
    bool updateNecessary;
    std::string mId;
};

template<typename PointT>
class ExecutivePointCloudClassifier : public Executive {
public:
    typedef PointCloudClassifier<PointT> Filter;
    typedef jafar::velodyneutils::Data<pcl::PointCloud<PointT> > DataInCloud;
    typedef jafar::velodyneutils::Data<REGION_MAP> DataInRegionMap;
    typedef jafar::velodyneutils::Data<pcl::PointCloud<PointRegionMap> >
            DataOut;

    ExecutivePointCloudClassifier(
            Filter* filter,
            DataInCloud* inputCloud, DataInRegionMap* inputRegionMap,
            DataOut* output,
            const std::string& id);
    ~ExecutivePointCloudClassifier();

    void setInputCloud(DataInCloud* input);
    void setInputRegionMap(DataInRegionMap* input);
    void setOutput(DataOut* output);
    virtual void update();
    virtual bool isId(const std::string& id) const;

private:
    Filter* mFilter;
    DataInCloud* mInputCloud;
    DataInRegionMap* mInputRegionMap;
    DataOut* mOutput;
    int timeCloud;
    int timeRegionMap;
    bool updateNecessary;
    std::string mId;
};

template<typename PointT>
class ExecutiveVisualizerCloud : public Executive {
public:
    typedef VisualizerCloud<PointT> Filter;
    typedef jafar::velodyneutils::Data<pcl::PointCloud<PointT> > Data;

    ExecutiveVisualizerCloud(Filter* filterIn, Data* inputIn,
                             const std::string& idIn, int numIdIn);
    ~ExecutiveVisualizerCloud();

    void setInput(Data* input);
    void setNumIdInput(void* numIdInput);
    void setControlInput(bool* controlInput);
    void setHandlerControlInput(bool* handlerControlInput);
    void setHandlerNumInput(void* handlerNumInput);
    virtual void update();
    virtual bool isId(const std::string& id) const;

private:
    Filter* filter;
    Data* input;
    int* numIdInput;
    bool* controlInput;
    bool* handlerControlInput;
    int* handlerNumInput;
    int time;
    bool updateNecessary;
    std::string id;
    int numId;
};

template<typename PointT>
class ExecutiveVisualizerNormals : public Executive {
public:
    typedef VisualizerNormals<PointT> Filter;
    typedef jafar::velodyneutils::Data<pcl::PointCloud<PointT> > Data;

    ExecutiveVisualizerNormals(Filter* filterIn, Data* inputIn,
                               const std::string& idIn, int numIdIn);
    ~ExecutiveVisualizerNormals();

    void setInput(Data* input);
    void setNumIdInput(void* numIdInput);
    void setControlInput(bool* controlInput);
    virtual void update();
    virtual bool isId(const std::string& id) const;

private:
    Filter* filter;
    Data* input;
    int* numIdInput;
    bool* controlInput;
    int time;
    bool updateNecessary;
    std::string id;
    int numId;
};

} // namespace velodyneutils
} // namespace jafar

#endif // VELODYNEUTILS_EXECUTIVES_HPP