ModelToImage.hpp

Go to the documentation of this file.

/*
 * ModelToImage.h
 *
 *  Created on: Jan 25, 2017
 *      Author: Thomas Wiemann (twiemann@uos.de)
 */

#ifndef SRC_LIBLVR2_RECONSTRUCTION_MODELTOIMAGE_HPP_
#define SRC_LIBLVR2_RECONSTRUCTION_MODELTOIMAGE_HPP_

#include "lvr2/io/Model.hpp"
#include <opencv2/core.hpp>
#include <algorithm>
#include <vector>
#include <tuple>
using std::vector;
using std::tuple;

namespace lvr2
{

class Projection;

class ModelToImage {
public:

    typedef struct
    {
        int i;
        int j;
        float depth;
    } DepthPixel;

    typedef struct PanoPoint
    {
        PanoPoint(size_t index_) : index(index_) {}
        size_t index;
    } PanoramaPoint;

    typedef struct DI
    {
        vector<vector<float> > pixels;
        float   maxRange;
        float   minRange;
        DI() :
            maxRange(std::numeric_limits<float>::lowest()),
            minRange(std::numeric_limits<float>::max()) {}

    } DepthImage;

    typedef struct PLI
    {
        vector<vector<vector<PanoramaPoint> > > pixels;
        float   maxRange;
        float   minRange;
        PLI() :
            maxRange(std::numeric_limits<float>::lowest()),
            minRange(std::numeric_limits<float>::max()) {}
    } DepthListMatrix;


    enum ProjectionType {
        CYLINDRICAL, CONICAL, EQUALAREACYLINDRICAL,
        RECTILINEAR, PANNINI, STEREOGRAPHIC,
        ZAXIS, AZIMUTHAL
    };

    enum ProjectionPolicy
    {
        FIRST, LAST, MINRANGE, MAXRANGE, AVERAGE, COLOR, INTENSITY
    };

    enum CoordinateSystem
    {
        NATIVE, SLAM6D, UOS
    };


    ModelToImage(
            PointBufferPtr buffer,
            ProjectionType projection,
            int width, int height,
            float minZ, float maxZ,
            int minHorizontenAngle, int maxHorizontalAngle,
            int mainVerticalAngle, int maxVerticalAngle,
            bool imageOptimization = true,
            CoordinateSystem system = NATIVE);

    void writePGM(string filename, float cutoff);

    virtual ~ModelToImage();

    void getCVMatrix(cv::Mat& image);


    void computeDepthImage(DepthImage& img, ProjectionPolicy policy = LAST);

    void computeDepthListMatrix(DepthListMatrix& mat);


    PointBufferPtr pointBuffer() { return m_points;}

private:


    Projection*         m_projection;

    PointBufferPtr      m_points;

    int                 m_width;

    int                 m_height;

    int                 m_minHAngle;

    int                 m_maxHAngle;

    int                 m_minVAngle;

    int                 m_maxVAngle;

    bool                m_optimize;

    CoordinateSystem    m_coordinateSystem;

    float               m_maxZ;

    float               m_minZ;


};

} /* namespace lvr2 */

#endif /* SRC_LIBLVR2_RECONSTRUCTION_MODELTOIMAGE_HPP_ */