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