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