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_ */