CLRaycaster.hpp

Go to the documentation of this file.

 
/*
 * CLRaycaster.hpp
 *
 *  @date 25.01.2020
 *  @author Johan M. von Behren <johan@vonbehren.eu>
 *  @author Alexander Mock <amock@uos.de>
 */
 
#ifndef LVR2_ALGORITHM_RAYCASTING_CLRAYCASTER
#define LVR2_ALGORITHM_RAYCASTING_CLRAYCASTER
 
#include <chrono>
#include "lvr2/io/MeshBuffer.hpp"
#include "lvr2/types/MatrixTypes.hpp"
#include "lvr2/algorithm/raycasting/BVHRaycaster.hpp"
 
#define CL_HPP_ENABLE_EXCEPTIONS
#define CL_HPP_MINIMUM_OPENCL_VERSION 120 // Need to set to 120 on CUDA 8
#define CL_HPP_TARGET_OPENCL_VERSION 120 // Need to set to 120 on CUDA 8
 
// hard cl2 depencency
#include <CL/cl2.hpp>
 
// if your code can handle cl.hpp and cl2.hpp use:
// #if defined LVR2_USE_OPENCL_NEW_API
//     #include <CL/cl2.hpp>
// #else
//     #include <CL/cl.hpp>
// #endif
 
#include "lvr2/util/CLUtil.hpp"
#include "Intersection.hpp"
 
 
 
namespace lvr2
{
 
template<typename IntT>
class CLRaycaster : public BVHRaycaster<IntT> {
public:
 
    CLRaycaster(const MeshBufferPtr mesh,
                unsigned int stack_size = 32);
 
 
    bool castRay(
        const Vector3f& origin,
        const Vector3f& direction,
        IntT& intersection);
 
    using BVHRaycaster<IntT>::castRays;
 
    void castRays(
        const Vector3f& origin,
        const std::vector<Vector3f>& directions,
        std::vector<IntT>& intersections,
        std::vector<uint8_t>& hits) override;
 
    void castRays(
        const std::vector<Vector3f>& origins,
        const std::vector<Vector3f>& directions,
        std::vector<IntT>& intersections,
        std::vector<uint8_t>& hits) override;
 
    struct ClTriangleIntersectionResult {
        cl_uchar hit = 0;
        cl_uint pBestTriId;
        cl_float3 pointHit;
        cl_float hitDist;
    };
 
protected:
    using BVHRaycaster<IntT>::barycentric;
    using BVHRaycaster<IntT>::m_bvh;
    using BVHRaycaster<IntT>::m_vertices;
    using BVHRaycaster<IntT>::m_faces;
 
private:
    void initOpenCL();
 
    void getDeviceInformation();
 
    void initOpenCLTreeBuffer();
 
    // void initOpenCLRayBuffer(
    //     int num_origins,
    //     int num_rays);
 
    void initOpenCLBuffer(
        size_t num_origins,
        size_t num_dirs
    );
 
    void copyBVHToGPU();
 
    void createKernel();
 
    // /**
    //  * @brief TODO
    //  */
    // void copyRayDataToGPU(
    //     const vector<float>& origins,
    //     const vector<float>& rays
    // );
 
    // /**
    //  * @brief TODO
    //  */
    // void copyRayDataToGPU(
    //     const float* origin_buffer, size_t origin_buffer_size,
    //     const float* ray_buffer, size_t ray_buffer_size
    // );
 
    // Member vars
 
    // OpenCL Device information
    cl_uint m_mps;
    cl_uint m_threads_per_block;
    size_t m_max_work_group_size;
    size_t m_warp_size;
    cl_ulong m_device_global_memory;
    
    // OpenCL variables
    cl::Platform m_platform;
    cl::Device m_device;
    cl::Context m_context;
    cl::Program m_program;
    cl::CommandQueue m_queue;
    cl::Kernel m_kernel_one_one;
    cl::Kernel m_kernel_one_multi;
    cl::Kernel m_kernel_multi_multi;
 
    // buffer bvh tree
    cl::Buffer m_bvhIndicesOrTriListsBuffer;
    cl::Buffer m_bvhLimitsnBuffer;
    cl::Buffer m_bvhTriangleIntersectionDataBuffer;
    cl::Buffer m_bvhTriIdxListBuffer;
 
    // buffer rays
    cl::Buffer m_rayBuffer;
    cl::Buffer m_rayOriginBuffer;
 
    // buffer results
    cl::Buffer m_resultBuffer;
    // cl::Buffer m_resultHitsBuffer;
 
};
 
} // namespace lvr2
 
#include "CLRaycaster.tcc"
 
#endif // LVR2_ALGORITHM_RAYCASTING_CLRAYCASTER