HashGrid.hpp

Go to the documentation of this file.

 
/*
 * HashGrid.hpp
 *
 *  Created on: Nov 27, 2014
 *      Author: twiemann
 */
 
#ifndef _LVR2_RECONSTRUCTION_HASHGRID_H_
#define _LVR2_RECONSTRUCTION_HASHGRID_H_
 
#include <unordered_map>
#include <vector>
#include <string>
 
#include "QueryPoint.hpp"
 
#include "lvr2/geometry/BoundingBox.hpp"
#include "lvr2/reconstruction/QueryPoint.hpp"
 
using std::string;
using std::vector;
using std::unordered_map;
 
namespace lvr2
{
 
class GridBase
{
public:
 
    GridBase(bool extrude = true) : m_extrude(extrude) {}
 
    virtual ~GridBase() {}
 
    virtual void addLatticePoint(int i, int j, int k, float distance = 0.0) = 0;
 
    virtual void saveGrid(string file) = 0;
 
    /***
     * @brief   Is extrude is set to true, additional cells within the
     *          grid will be create to fill up holes consisting of single
     *          cells.
     *
     * @param extrude   If set to true, additional cells will be created.
     *                  Default value is true.
     */
    virtual void setExtrusion(bool extrude) { m_extrude = extrude; }
 
protected:
    bool m_extrude;
};
 
template<typename BaseVecT, typename BoxT>
class HashGrid : public GridBase
{
public:
 
    BoundingBox<BaseVecT> qp_bb;
 
    typedef unordered_map<size_t, BoxT*> box_map;
 
    typedef unordered_map<size_t, size_t> qp_map;
 
    typedef typename unordered_map<size_t, BoxT*>::iterator  box_map_it;
 
    typedef typename vector<QueryPoint<BaseVecT>>::iterator query_point_it;
 
    /***
     * @brief   Constructor
     *
     * If set to true, cell size is interpreted as
     * absolute voxel size (default). Otherwise \ref cellSize
     * is interpreted as number of intersections along the
     * longest size of the given bounding box to estimate a suitable
     * resolution.
     *
     * @param   cellSize        Voxel size of the grid cells
     * @param   isVoxelSize     Whether to interpret \ref cellSize as voxelsize or intersections
     */
    HashGrid(float cellSize, BoundingBox<BaseVecT> boundingBox, bool isVoxelSize = true, bool extrude = true);
 
 
    /***
     * @brief   Constructor
     *
     * Construcs a HashGrid from a file
     *
     * @param   file        File representing the HashGrid (See HashGrid::serialize(string file) )
     */
    HashGrid(string file);
 
    /***
     * @brief Construct a new Hash Grid object
     *
     * @param files
     * @param boundingBox
     * @param voxelsize
     */
    HashGrid(std::vector<string>& files, BoundingBox<BaseVecT>& boundingBox, float voxelsize);
 
 
    /***
     * @brief Construct a new Hash Grid object
     *
     * @param files vector of strings to the files which contain the voxel-grid data for the chunks
     * @param innerBoxes vector of BoundingBoxes. Each chunk is only used for the BoundingBox.
     *                          This is important because the data in the chunks may overlap.
     * @param boundingBox bounding box of the complete grid
     * @param voxelsize the voxelsize of the grid
     */
    HashGrid(std::vector<string>& files, std::vector<BoundingBox<BaseVecT>> innerBoxes, BoundingBox<BaseVecT>& boundingBox, float voxelsize);
 
    /***
     * Constructs a new Hash Grid object from multiple PointBufferPtr,
     * where the HashGrid attributes are saved in the PointBuffer-Channels.
     *
     * @param chunks vector with the voxel-grid data for the chunks
     * @param innerBoxes vector of BoundingBoxes. Each chunk is only used for the BoundingBox.
     *                          This is important because the data in the chunks may overlap.
     * @param boundingBox bounding box of the complete grid
     * @param voxelSize the voxelsize of the grid
     */
    HashGrid(std::vector<PointBufferPtr> chunks,
            std::vector<BoundingBox<BaseVecT>> innerBoxes,
            BoundingBox<BaseVecT>& boundingBox,
            float voxelSize);
 
    virtual void addLatticePoint(int i, int j, int k, float distance = 0.0);
 
    virtual void saveGrid(string file);
 
    void saveCells(string file);
 
    virtual void serialize(string file);
 
    /***
     * @brief   Returns the number of generated cells.
     */
    size_t getNumberOfCells() { return m_cells.size(); }
 
    box_map_it  firstCell() { return m_cells.begin(); }
 
    box_map_it  lastCell() { return m_cells.end(); }
 
    query_point_it firstQueryPoint() { return m_queryPoints.begin(); }
 
    /***
     * @return  Returns an iterator to the last query point
     */
    query_point_it lastQueryPoint() { return m_queryPoints.end(); }
 
    vector<QueryPoint<BaseVecT>>& getQueryPoints() { return m_queryPoints; }
 
    box_map getCells() { return m_cells; }
 
    /***
     * @brief   Destructor
     */
    virtual ~HashGrid();
 
    void setCoordinateScaling(float x, float y, float z);
 
    size_t getMaxIndex() { return m_maxIndex; }
 
    size_t getMaxIndexX() { return m_maxIndexX; }
 
    size_t getMaxIndexY() { return m_maxIndexY; }
 
    size_t getMaxIndexZ() { return m_maxIndexZ; }
 
    void setBB(BoundingBox<BaseVecT>& bb);
 
    BoundingBox<BaseVecT> & getBoundingBox() { return m_boundingBox; }
 
    inline size_t hashValue(int i, int j, int k) const
    {
        return i * m_maxIndexSquare + j * m_maxIndex + k;
    }
 
    unsigned int findQueryPoint(
        int position,
        int x,
        int y,
        int z
    );
 
    void calcIndices();
 
 
protected:
 
    inline int calcIndex(float f)
    {
        return f < 0 ? f - .5 : f + .5;
    }
 
    box_map         m_cells;
 
    qp_map          m_qpIndices;
 
    float                       m_voxelsize;
 
    size_t                      m_maxIndex;
 
    size_t                      m_maxIndexSquare;
 
    size_t                      m_maxIndexX;
 
    size_t                      m_maxIndexY;
 
    size_t                      m_maxIndexZ;
 
    vector<QueryPoint<BaseVecT>> m_queryPoints;
 
    string                      m_boxType;
 
    BoundingBox<BaseVecT>       m_boundingBox;
 
    unsigned int                m_globalIndex;
 
    BaseVecT                  m_coordinateScales;
};
 
} /* namespace lvr */
 
#include "HashGrid.tcc"
 
#endif /* _LVR2_RECONSTRUCTION_HASHGRID_H_ */