Intersection.hpp

Go to the documentation of this file.

#ifndef LVR2_RAYCASTING_INTERSECTION_HPP
#define LVR2_RAYCASTING_INTERSECTION_HPP
 
#include <string>
#include <sstream>
#include <tuple>
#include <type_traits>
#include <iostream>
#include "lvr2/types/MatrixTypes.hpp"
 
namespace lvr2 {
 
// Intersect flags
// weird intersection construction
 
namespace intelem {
 
struct Point {
    Vector3f point;
};
 
struct Distance {
    float dist;
};
 
struct Normal {
    Vector3f normal;
};
 
struct Face {
    unsigned int face_id;
};
 
struct Barycentrics {
    Vector2f b_uv;
};
 
struct Mesh {
    unsigned int mesh_id;
};
 
} // namespace intelem
 
template<typename ...Tp>
struct Intersection : public Tp... 
{
public:
    static constexpr std::size_t N = sizeof...(Tp);
    using elems = std::tuple<Tp...>;
 
private:
    template <typename T, typename Tuple>
    struct has_type;
 
    template <typename T>
    struct has_type<T, std::tuple<>> : std::false_type {};
 
    template <typename T, typename U, typename... Ts>
    struct has_type<T, std::tuple<U, Ts...>> : has_type<T, std::tuple<Ts...>> {};
 
 
    template <typename T, typename... Ts>
    struct has_type<T, std::tuple<T, Ts...>> : std::true_type {};    
 
    template<typename F> 
    struct has_elem {
        static constexpr bool value = has_type<F, elems>::type::value;
    };
 
public:
    template<typename F>
    static constexpr bool has() {
        return has_elem<F>::value;
    }
};
 
// Common types
using PointInt = Intersection<intelem::Point>;
using NormalInt = Intersection<intelem::Normal>;
using DistInt = Intersection<intelem::Distance>;
using FaceInt = Intersection<intelem::Face, intelem::Barycentrics>;
using AllInt = Intersection<
    intelem::Point, 
    intelem::Distance,
    intelem::Normal,
    intelem::Face,
    intelem::Barycentrics,
    intelem::Mesh>;
 
} // namespace lvr2
 
 
template<typename ...T>
std::ostream& operator<<(std::ostream& os, const lvr2::Intersection<T...>& intersection)
{
    using IntT = lvr2::Intersection<T...>;
    os << "Raycaster Intersection: \n";
 
    if constexpr(IntT::template has<lvr2::intelem::Point>())
    {
        os << "-- point: " << intersection.point.transpose() << "\n";
    }
 
    if constexpr(IntT::template has<lvr2::intelem::Distance>())
    {
        os << "-- dist: " << intersection.dist << "\n";  
    }
 
    if constexpr(IntT::template has<lvr2::intelem::Normal>())
    {
        os << "-- normal: " << intersection.normal.transpose() << "\n";
    }
 
    if constexpr(IntT::template has<lvr2::intelem::Face>())
    {
        os << "-- face: " << intersection.face_id << "\n";
    }
 
    if constexpr(IntT::template has<lvr2::intelem::Barycentrics>())
    {
        os << "-- barycentrics: " << intersection.b_uv.transpose() << "\n";
    }
 
    if constexpr(IntT::template has<lvr2::intelem::Mesh>())
    {
        os << "-- mesh: " << intersection.mesh_id << "\n";
    }
 
    return os;
}
 
#endif // LVR2_RAYCASTING_INTERSECTION_HPP