CudaSurface.hpp

Go to the documentation of this file.

 
#ifndef __CudaSurface_H
#define __CudaSurface_H
 
#include "lvr2/reconstruction/QueryPoint.hpp"
#include "lvr2/reconstruction/LBKdTree.hpp"
#include "lvr2/geometry/LBPointArray.hpp"
#include "lvr2/geometry/ColorVertex.hpp"
#include "lvr2/geometry/BaseVector.hpp"
 
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
#include <math.h>
#include <float.h>
#include <stdint.h>
 
#include <cuda_runtime.h>
#include <driver_types.h>
 
#include <boost/shared_array.hpp>
 
namespace lvr2
{
 
static void HandleError( cudaError_t err,
                         const char *file,
                         int line ) {
    if (err != cudaSuccess) {
        printf( "%s in %s at line %d\n", cudaGetErrorString( err ),
                file, line );
        exit( EXIT_FAILURE );
    }
}
#define HANDLE_ERROR( err ) (HandleError( err, __FILE__, __LINE__ ))
 
using Vec = BaseVector<float>;
typedef boost::shared_array<float> floatArr;
typedef ColorVertex<float, unsigned char> cVertex ;
typedef QueryPoint<Vec> QueryPointC;
 
 
class CudaSurface {
 
public:
    CudaSurface(LBPointArray<float>& points, int device = 0);
 
    CudaSurface(floatArr& points, size_t num_points, int device=0 );
 
    ~CudaSurface();
 
    void calculateNormals();
 
    void interpolateNormals();
 
    void getNormals(LBPointArray<float>& output_normals);
 
    void getNormals(floatArr output_normals);
 
    void setKn(int kn);
 
    void setKi(int ki);
 
    void setKd(int kd);
 
    void setFlippoint(float v_x, float v_y, float v_z);
 
    void setMethod(std::string& method);
 
    void setReconstructionMode(bool mode = true);
 
    void distances(std::vector<QueryPoint<Vec> >& query_points, float voxel_size);
 
    void freeGPU();
 
private:
    //~ Hostfunctions
    void init();
 
    void printSettings();
 
    void getCudaInformation(int device);
 
    void calculateBlocksThreads(int n, int elements, int element_size,
            int max_mem_shared, int max_threads_per_block,
            int& out_blocks_per_grid, int& out_threads_per_block, int& needed_shared_memory);
 
    template <typename T>
    void generateDevicePointArray(LBPointArray<T>& D_m, int width, int dim);
 
    template <typename T>
    void copyToDevicePointArray(LBPointArray<T>* m, LBPointArray<T>& D_m);
 
    template <typename T>
    void copyToDevicePointArray(LBPointArray<T>& m, LBPointArray<T>& D_m);
 
 
    void copyToHostPointArray(LBPointArray<float>& D_m, LBPointArray<float>* m);
 
    // Divice Function
    void GPU_NN();
 
    void initKdTree();
 
    // V->points and normals
    LBPointArray<float> V;
    LBPointArray<float>* kd_tree_values;
    LBPointArray<unsigned char>* kd_tree_splits;
 
    LBPointArray<float> Result_Normals;
    boost::shared_ptr<LBKdTree> kd_tree_gen;
 
    float m_vx, m_vy, m_vz;
    int m_k, m_ki, m_kd;
 
 
    int m_calc_method;
    bool m_reconstruction_mode;
 
    // Device Information
    int m_device;
    int m_mps;
    int m_threads_per_mp;
    int m_threads_per_block;
    int* m_size_thread_block;
    int* m_size_grid;
    unsigned long long m_device_global_memory;
 
    LBPointArray<float> D_V;
    LBPointArray<float> D_kd_tree_values;
    LBPointArray<unsigned char> D_kd_tree_splits;
    LBPointArray<float> D_Normals;
 
};
 
} /* namespace lvr2 */
 
#endif // !__CudaSurface_H