BVHRaycaster.hpp

Go to the documentation of this file.

/*
 * BVHRaycaster.hpp
 *
 *  @date 25.01.2019
 *  @author Johan M. von Behren <johan@vonbehren.eu>
 *  @author Alexander Mock <amock@uos.de>
 */

#pragma once
#ifndef LVR2_ALGORITHM_RAYCASTING_BVHRAYCASTER
#define LVR2_ALGORITHM_RAYCASTING_BVHRAYCASTER

#include "lvr2/io/MeshBuffer.hpp"
#include "lvr2/types/MatrixTypes.hpp"
#include "lvr2/geometry/BVH.hpp"
#include "lvr2/algorithm/raycasting/RaycasterBase.hpp"
#include "Intersection.hpp"

#define EPSILON 0.0000001
#define PI 3.14159265

namespace lvr2
{

template<typename IntT>
class BVHRaycaster : public RaycasterBase<IntT> {
public:
    BVHRaycaster(const MeshBufferPtr mesh, unsigned int stack_size = 64);

    bool castRay(
        const Vector3f& origin,
        const Vector3f& direction,
        IntT& intersection);

    struct Ray {
        Vector3f dir;
        Vector3f invDir;
        Vector3i rayDirSign;
    };

    struct TriangleIntersectionResult {
        bool hit;
        unsigned int pBestTriId;
        Vector3f pointHit;
        float hitDist;
    };
    
protected:

    inline Vector3f barycentric(
        const Vector3f& p, 
        const Vector3f& a, 
        const Vector3f& b,
        const Vector3f& c) const
    {
        Vector3f v0 = b - a;
        Vector3f v1 = c - a;
        Vector3f v2 = p - a;
        float d00 = v0.dot(v0);
        float d01 = v0.dot(v1);
        float d11 = v1.dot(v1);
        float d20 = v2.dot(v0);
        float d21 = v2.dot(v1);
        float denom = d00 * d11 - d01 * d01;
        
        float u = (d11 * d20 - d01 * d21) / denom;
        float v = (d00 * d21 - d01 * d20) / denom;
        float w = 1.0 - v - u;
        
        return Vector3f(u, v, w);
    }

    BVHTree<BaseVector<float> > m_bvh;

    indexArray m_faces;
    floatArr m_vertices;

    const unsigned int* m_BVHindicesOrTriLists;
    const float* m_BVHlimits;
    const float* m_TriangleIntersectionData;
    const unsigned int* m_TriIdxList;
    const unsigned int m_stack_size;

private:

    inline float distanceSquare(const Vector3f& a, const Vector3f& b) const
    {
        return (a - b).squaredNorm();
    }


    bool rayIntersectsBox(Vector3f origin, Ray ray, const float* boxPtr);

    TriangleIntersectionResult intersectTrianglesBVH(
        const unsigned int* clBVHindicesOrTriLists,
        Vector3f origin,
        Ray ray,
        const float* clBVHlimits,
        const float* clTriangleIntersectionData,
        const unsigned int* clTriIdxList
    );

};

} // namespace lvr2

#include "BVHRaycaster.tcc"

#endif // LVR2_ALGORITHM_RAYCASTING_BVHRAYCASTER