BigGrid.hpp

Go to the documentation of this file.

 
/*
 * BigGrid.hpp
 *
 *  Created on: Jul 17, 2017
 *      Author: Isaak Mitschke
 */
 
#ifndef LAS_VEGAS_BIGGRID_HPP
#define LAS_VEGAS_BIGGRID_HPP
 
#include "lvr2/geometry/BoundingBox.hpp"
#include "lvr2/io/DataStruct.hpp"
 
#include <boost/archive/binary_iarchive.hpp>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/iostreams/device/mapped_file.hpp>
#include <string>
#include <unordered_map>
#include <utility>
 
#ifndef __APPLE__
#include <omp.h>
#endif
 
 
namespace lvr2
{
 
using Vec = BaseVector<float>;
 
struct CellInfo
{
    CellInfo() : size(0), offset(0), inserted(0), dist_offset(0) {}
    size_t size;
    size_t offset;
    size_t inserted;
    size_t dist_offset;
    size_t ix;
    size_t iy;
    size_t iz;
};
 
template <typename BaseVecT>
class BigGrid
{
  public:
    BigGrid(std::vector<std::string> cloudPath, float voxelsize, float scale = 0, size_t bufferSize = 1024);
 
    BigGrid(float voxelsize,ScanProjectEditMarkPtr project, float scale = 0);
 
    BigGrid(std::string path);
 
    size_t size();
 
    size_t pointSize();
 
    size_t pointSize(int i, int j, int k);
 
    lvr2::floatArr points(int i, int j, int k, size_t& numPoints);
 
    lvr2::floatArr points(
        float minx, float miny, float minz, float maxx, float maxy, float maxz, size_t& numPoints);
 
    lvr2::floatArr normals(
        float minx, float miny, float minz, float maxx, float maxy, float maxz, size_t& numPoints);
 
    lvr2::ucharArr colors(
        float minx, float miny, float minz, float maxx, float maxy, float maxz, size_t& numPoints);
    size_t getSizeofBox(float minx, float miny, float minz, float maxx, float maxy, float maxz);
 
    void serialize(std::string path = "serinfo.ls");
 
    lvr2::floatArr getPointCloud(size_t& numPoints);
 
    BoundingBox<BaseVecT>& getBB() { return m_bb; }
 
    BoundingBox<BaseVecT>& getpartialBB() { return m_partialbb; }
 
 
    virtual ~BigGrid();
 
    inline size_t hashValue(size_t i, size_t j, size_t k)
    {
        return i * m_maxIndexSquare + j * m_maxIndex + k;
    }
 
    inline size_t getDistanceFileOffset(size_t hash)
    {
        if (exists(hash))
        {
            return m_gridNumPoints[hash].dist_offset;
        }
        else
            return 0;
    }
    inline bool exists(size_t hash)
    {
        auto it = m_gridNumPoints.find(hash);
        return it != m_gridNumPoints.end();
    }
 
    inline bool hasColors() { return m_has_color; }
    inline bool hasNormals() { return m_has_normal; }
 
  private:
    inline int calcIndex(float f) { return f < 0 ? f - .5 : f + .5; }
 
    bool exists(int i, int j, int k);
    void insert(float x, float y, float z);
 
    size_t m_maxIndexSquare;
    size_t m_maxIndex;
    size_t m_maxIndexX;
    size_t m_maxIndexY;
    size_t m_maxIndexZ;
    size_t m_numPoints;
 
    size_t m_pointBufferSize;
 
    float m_voxelSize;
    bool m_extrude;
#ifdef LVR2_USE_OPEN_MP
    omp_lock_t m_lock;
#endif
    bool m_has_normal;
    bool m_has_color;
 
    boost::iostreams::mapped_file m_PointFile;
    boost::iostreams::mapped_file m_NomralFile;
    boost::iostreams::mapped_file m_ColorFile;
    BoundingBox<BaseVecT> m_bb;
 
    //BoundingBox, of unreconstructed scans
    BoundingBox<BaseVecT> m_partialbb;
 
    std::vector<shared_ptr<Scan>> m_scans;
 
    std::unordered_map<size_t, CellInfo> m_gridNumPoints;
    float m_scale;
};
 
} // namespace lvr2
 
#include "lvr2/reconstruction/BigGrid.tcc"
 
#endif // LAS_VEGAS_BIGGRID_HPP