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