FastBox.hpp

Go to the documentation of this file.

 
 /*
 * FastBox.h
 *
 *  Created on: 03.03.2011
 *      Author: Thomas Wiemann
 */
 
#ifndef _LVR2_RECONSTRUCTION_FASTBOX_H_
#define _LVR2_RECONSTRUCTION_FASTBOX_H_
 
#include "lvr2/reconstruction/MCTable.hpp"
#include "lvr2/reconstruction/FastBoxTables.hpp"
 
#include "lvr2/geometry/Normal.hpp"
 
#include "QueryPoint.hpp"
 
#include <vector>
#include <limits>
 
using std::vector;
using std::numeric_limits;
 
namespace lvr2
{
 
template<typename BoxT>
struct BoxTraits
{
    const static string type;
};
 
template<typename BaseVecT>
class FastBox
{
public:
 
    FastBox(BaseVecT center);
 
    virtual ~FastBox() {};
 
    void setVertex(int index, uint value);
 
    void setNeighbor(int index, FastBox<BaseVecT>* cell);
 
    uint getVertex(int index);
 
 
    FastBox<BaseVecT>*     getNeighbor(int index);
 
    inline BaseVecT getCenter() { return m_center; }
 
 
    virtual void getSurface(
        BaseMesh<BaseVecT>& mesh,
        vector<QueryPoint<BaseVecT>>& query_points,
        uint &globalIndex
    );
 
    virtual void getSurface(
        BaseMesh<BaseVecT>& mesh,
        vector<QueryPoint<BaseVecT>>& query_points,
        uint& globalIndex,
        BoundingBox<BaseVecT>& bb,
        vector<unsigned int>& duplicates,
        float comparePrecision
    );
 
    static float             m_voxelsize;
 
    static uint             INVALID_INDEX;
 
    OptionalVertexHandle        m_intersections[12];
    bool                        m_extruded;
    bool                        m_duplicate;
 
    BaseVecT m_center;
 
    FastBox<BaseVecT>*  m_neighbors[27];
 
protected:
 
 
    inline bool compareFloat(double num1, double num2)
    {
        if(fabs(num1 - num2) < std::numeric_limits<double>::epsilon())
            return true;
        else
            return false;
    }
 
    int  getIndex(vector<QueryPoint<BaseVecT>>& query_points);
 
    void getIntersections(BaseVecT* corners, float* distance, BaseVecT* positions);
 
    void getCorners(BaseVecT corners[], vector<QueryPoint<BaseVecT>>& query_points);
 
    void getDistances(float distances[], vector<QueryPoint<BaseVecT>>& query_points);
 
    /***
     * @brief Interpolates the intersection between x1 and x1.
     *
     * @param x1            The first coordinate
     * @param x2            The second coordinate
     * @param d1            The distance value for the first coordinate
     * @param d2            The distance value for the second coordinate
     * @return The interpolated distance.
     */
    float calcIntersection(float x1, float x2, float d1, float d2);
 
    float distanceToBB(const BaseVecT& v, const BoundingBox<BaseVecT>& bb) const;
 
 
    uint                        m_vertices[8];
 
    template <typename T> friend class BilinearFastBox;
 
    typedef FastBox<BaseVecT> BoxType;
};
 
} // namespace lvr2
 
#include "lvr2/reconstruction/FastBox.tcc"
 
#endif /* _LVR2_RECONSTRUCTION_FASTBOX_H_ */