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