gmBVHAcceleration.h

Go to the documentation of this file.

 
#ifndef _GEMA_BVHACCELERATION_H_
#define _GEMA_BVHACCELERATION_H_
 
// BVH includes
#include <bvh.h>
#include <vec.h>
#include <ray.h>
#include <node.h>
#include <default_builder.h>
#include <thread_pool.h>
#include <stack.h>
#include <tri.h>
#include <seg.h>
 
 
#include <vector>
#include <gmValueAccessor.h>
#include <gmSurfaceCellIntersection.h>
#include <gmSegmentCellIntersection.h>
 
class GmDiscontinuity;
 
struct RayIntersection {
    double point[3];
    double normal[3];
    bool isExtension;
    bool zeroSign;
};
 
 
class GmBVHAcceleration
{
public:
    //BVH aliases for double and 3D geometry
    using Scalar = double;
    using Vec3 = bvh::Vec<Scalar, 3>;
    using BBox = bvh::BBox<Scalar, 3>;
    using Tri = bvh::Tri<Scalar, 3>;
    using Node = bvh::Node<Scalar, 3>;
    using Bvh = bvh::Bvh<Node>;
    using Ray = bvh::Ray<Scalar, 3>;
    using PrecomputedTri = bvh::PrecomputedTri<Scalar>;
 
 
private:
 
    Bvh bvh;
    int validTriIdEnd;
    std::vector<PrecomputedTri> preTri;
 
public:
    /*
    *  Constructor for BVH acceleration structure
    * 
    *    triCoords - [x1, y1, z1, .., xn, yn, zn]
    *    triIndex - [ t1_v1, t1_v2, t1_v3, ..., tm_v1, tm_v2, tm_v3]
    *    numPoints - N
    *    numTriangles - M
    *    numValidTriangles - K <= M
    *    threadPool - default (inefficient)
    */
    GmBVHAcceleration(const double* triCoords, const int* triIndex, int numPoints, int numTriangles, int  numValidTriangles, bvh::ThreadPool threadPool = bvh::ThreadPool());
 
    /*
     * Return true if the the segment given by 'start' and 'end' 
     * intersects any of the triangles and stores the intersection
     * point at 'intersection' and if start, end sign test is zero.
     */
    std::tuple<size_t, size_t, bool, bool, bool> segIntersection(const double* start, const double* end, RayIntersection& ri, double repelTol = 0, double repelDistance = 0, double eps = 1e-5);
 
 
    /*
     * Used for globally consistency intersection when the sign test
     * of a node is near zero.
     * 
     * The solutio is to get all edges with that node and compute
     * their sign once and consistently.
     * 
     */
    void zeroIntersection(const int zeroId, const size_t triId, const QVector<int>& nodeIds, const GmValueAccessor* coordAc, QVector<std::tuple<RayIntersection, int, bool>>& outIntersect, double repelTol = 0, double repelDistance = 0, double eps = 1e-5);
 
private:
    
    void computeLinePoint(Vec3 p0, Vec3 dir, double t, double* out);
};
 
 
class GmBVHVisibility {
public:
    /*
     * Checks if point src is visible from dst, in other words, if a
     * the line connecting src-dst does not cross any discontinuity.
     * The 'eps' parameter is used for testing how near any of the 
     * points is from the discontinuity. Anything lower than 'eps'
     * is considered to lie on the discontinuity, and hence, is
     * always visible for points in both sides.
     * 
     */
    virtual bool isVisibleInclusive(const double* src, const double* dst, double eps = 5e-3) const = 0;
 
    /*
     * Checks if point src is visible from dst, in other words, if a
     * the line connecting src-dst does not cross any discontinuity.
     * The 'eps' parameter is used for testing how near any of the 
     * points is from the discontinuity. Anything lower than 'eps'
     * is considered to lie on the discontinuity, and hence, is
     * always NOT visible for points in both sides.
     * 
     * IMPORTANT:
     * Test for 'near' is done only at the 'dst'. Correctly setting
     * the source (reference) and destine point is a must.
     */
    virtual bool isVisibleExclusive(const double* src, const double* dst, double eps = 5e-3) const = 0;
        virtual ~GmBVHVisibility() {}
};
 
class GmBVHVisibility3D : public GmBVHVisibility
{
public:
    //BVH aliases for double and 3D geometry
    using Scalar = double;
    using Vec3 = bvh::Vec<Scalar, 3>;
    using BBox = bvh::BBox<Scalar, 3>;
    using Tri = bvh::Tri<Scalar, 3>;
    using Node = bvh::Node<Scalar, 3>;
    using Bvh = bvh::Bvh<Node>;
    using Ray = bvh::Ray<Scalar, 3>;
    using PrecomputedTri = bvh::PrecomputedTri<Scalar>;
 
 
private:
 
    Bvh bvh;
    std::vector<PrecomputedTri> preTri;
 
public:
    GmBVHVisibility3D(const QMap<int, Gm3DSurfaceCellIntersection>& cellMap, const QVector<GmVector3>& points, bvh::ThreadPool threadPool = bvh::ThreadPool());
    GmBVHVisibility3D(const QVector<GmDiscontinuity*>& data, bvh::ThreadPool threadPool = bvh::ThreadPool());
 
 
    bool isVisibleInclusive(const double* src, const double* dst, double eps) const final {
        return isVisible<true>(src, dst, eps);
    }
 
    bool isVisibleExclusive(const double* src, const double* dst, double eps) const final {
        return isVisible<false>(src, dst, eps);
    }
 
private:
    template<bool inclusive>
    bool isVisible(const double* src, const double* dst, double eps) const;
};
 
 
class GmBVHVisibility2D : public GmBVHVisibility
{
public:
    //BVH aliases for double and 2D geometry
    using Scalar = double;
    using Vec2 = bvh::Vec<Scalar, 2>;
    using BBox = bvh::BBox<Scalar, 2>;
    using Seg = bvh::Seg<Scalar, 2>;
    using Node = bvh::Node<Scalar,2>;
    using Bvh = bvh::Bvh<Node>;
    using Ray = bvh::Ray<Scalar, 2>;
    using PrecomputedSeg = bvh::PrecomputedSeg<Scalar>;
 
 
private:
 
    Bvh bvh;
    std::vector<PrecomputedSeg> preSeg;
 
public:
    //Using the same def as GmDiscontinuitySet::SegmentCell2DIntersectionList
    //to avoid the need of including GmDiscontinuitySet
    using Gm2DSegmentCellIntersection = QVarLengthArray<GmCompact2DSegmentCellIntersection*, 1>;
    GmBVHVisibility2D(const QMap<int, Gm2DSegmentCellIntersection>& cellMap, bvh::ThreadPool threadPool = bvh::ThreadPool());
    GmBVHVisibility2D(const QVector<GmDiscontinuity*>& data, bvh::ThreadPool threadPool = bvh::ThreadPool());
 
    bool isVisibleInclusive(const double* src, const double* dst, double eps) const final {
        return isVisible<true>(src, dst, eps);
    }
 
    bool isVisibleExclusive(const double* src, const double* dst, double eps) const final {
        return isVisible<false>(src, dst, eps);
    }
 
private:
    template<bool inclusive>
    bool isVisible(const double* src, const double* dst, double eps) const;
};
#endif