#include <CudaSurface.hpp>
|  | 
| 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 | 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) | 
|  | 
| template<typename T > | 
| void | generateDevicePointArray (LBPointArray< T > &D_m, int width, int dim) | 
|  | 
| void | getCudaInformation (int device) | 
|  | 
| void | GPU_NN () | 
|  | 
| void | init () | 
|  | 
| void | initKdTree () | 
|  | 
| void | printSettings () | 
|  | 
Definition at line 78 of file CudaSurface.hpp.
 
◆ CudaSurface() [1/2]
      
        
          | lvr2::CudaSurface::CudaSurface | ( | LBPointArray< float > & | points, | 
        
          |  |  | int | device = 0 | 
        
          |  | ) |  |  | 
      
 
Constructor. 
- Parameters
- 
  
    | points | Input Pointcloud for kd-tree construction |  
 
 
 
◆ CudaSurface() [2/2]
      
        
          | lvr2::CudaSurface::CudaSurface | ( | floatArr & | points, | 
        
          |  |  | size_t | num_points, | 
        
          |  |  | int | device = 0 | 
        
          |  | ) |  |  | 
      
 
 
◆ ~CudaSurface()
      
        
          | lvr2::CudaSurface::~CudaSurface | ( |  | ) |  | 
      
 
 
◆ calculateBlocksThreads()
  
  | 
        
          | void lvr2::CudaSurface::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 |  
          |  | ) |  |  |  | private | 
 
 
◆ calculateNormals()
      
        
          | void lvr2::CudaSurface::calculateNormals | ( |  | ) |  | 
      
 
Starts calculation the normals on GPU. 
 
 
◆ copyToDevicePointArray() [1/2]
◆ copyToDevicePointArray() [2/2]
◆ copyToHostPointArray()
◆ distances()
      
        
          | void lvr2::CudaSurface::distances | ( | std::vector< QueryPoint< Vec > > & | query_points, | 
        
          |  |  | float | voxel_size | 
        
          |  | ) |  |  | 
      
 
 
◆ freeGPU()
      
        
          | void lvr2::CudaSurface::freeGPU | ( |  | ) |  | 
      
 
 
◆ generateDevicePointArray()
template<typename T > 
  
  | 
        
          | void lvr2::CudaSurface::generateDevicePointArray | ( | LBPointArray< T > & | D_m, |  
          |  |  | int | width, |  
          |  |  | int | dim |  
          |  | ) |  |  |  | private | 
 
 
◆ getCudaInformation()
  
  | 
        
          | void lvr2::CudaSurface::getCudaInformation | ( | int | device | ) |  |  | private | 
 
 
◆ getNormals() [1/2]
      
        
          | void lvr2::CudaSurface::getNormals | ( | floatArr | output_normals | ) |  | 
      
 
 
◆ getNormals() [2/2]
      
        
          | void lvr2::CudaSurface::getNormals | ( | LBPointArray< float > & | output_normals | ) |  | 
      
 
Get the resulting normals of the normal calculation. After calling "start". 
- Parameters
- 
  
    | output_normals | PointArray as return value |  
 
 
 
◆ GPU_NN()
  
  | 
        
          | void lvr2::CudaSurface::GPU_NN | ( |  | ) |  |  | private | 
 
 
◆ init()
  
  | 
        
          | void lvr2::CudaSurface::init | ( |  | ) |  |  | private | 
 
 
◆ initKdTree()
  
  | 
        
          | void lvr2::CudaSurface::initKdTree | ( |  | ) |  |  | private | 
 
 
◆ interpolateNormals()
      
        
          | void lvr2::CudaSurface::interpolateNormals | ( |  | ) |  | 
      
 
 
◆ printSettings()
  
  | 
        
          | void lvr2::CudaSurface::printSettings | ( |  | ) |  |  | private | 
 
 
◆ setFlippoint()
      
        
          | void lvr2::CudaSurface::setFlippoint | ( | float | v_x, | 
        
          |  |  | float | v_y, | 
        
          |  |  | float | v_z | 
        
          |  | ) |  |  | 
      
 
Set the viewpoint to orientate the normals. 
- Parameters
- 
  
    | v_x | Coordinate X axis |  | v_y | Coordinate Y axis |  | v_z | Coordinate Z axis |  
 
 
 
◆ setKd()
      
        
          | void lvr2::CudaSurface::setKd | ( | int | kd | ) |  | 
      
 
Set the number of k nearest neighbors k-neighborhood for distance. 
- Parameters
- 
  
    | k | The size of the used k-neighborhood |  
 
 
 
◆ setKi()
      
        
          | void lvr2::CudaSurface::setKi | ( | int | ki | ) |  | 
      
 
Set the number of k nearest neighbors k-neighborhood for interpolation. 
- Parameters
- 
  
    | k | The size of the used k-neighborhood |  
 
 
 
◆ setKn()
      
        
          | void lvr2::CudaSurface::setKn | ( | int | kn | ) |  | 
      
 
Set the number of k nearest neighbors k-neighborhood. 
- Parameters
- 
  
    | k | The size of the used k-neighborhood |  
 
 
 
◆ setMethod()
      
        
          | void lvr2::CudaSurface::setMethod | ( | std::string & | method | ) |  | 
      
 
Set Method for normal calculation. 
- Parameters
- 
  
  
 
 
◆ setReconstructionMode()
      
        
          | void lvr2::CudaSurface::setReconstructionMode | ( | bool | mode = true | ) |  | 
      
 
Reconstuction Mode: Points stay in gpu until reconstruction is finished 
 
 
◆ D_kd_tree_splits
  
  | 
        
          | LBPointArray<unsigned char> lvr2::CudaSurface::D_kd_tree_splits |  | private | 
 
 
◆ D_kd_tree_values
◆ D_Normals
◆ D_V
◆ kd_tree_gen
  
  | 
        
          | boost::shared_ptr<LBKdTree> lvr2::CudaSurface::kd_tree_gen |  | private | 
 
 
◆ kd_tree_splits
  
  | 
        
          | LBPointArray<unsigned char>* lvr2::CudaSurface::kd_tree_splits |  | private | 
 
 
◆ kd_tree_values
◆ m_calc_method
  
  | 
        
          | int lvr2::CudaSurface::m_calc_method |  | private | 
 
 
◆ m_device
  
  | 
        
          | int lvr2::CudaSurface::m_device |  | private | 
 
 
◆ m_device_global_memory
  
  | 
        
          | unsigned long long lvr2::CudaSurface::m_device_global_memory |  | private | 
 
 
◆ m_k
  
  | 
        
          | int lvr2::CudaSurface::m_k |  | private | 
 
 
◆ m_kd
  
  | 
        
          | int lvr2::CudaSurface::m_kd |  | private | 
 
 
◆ m_ki
  
  | 
        
          | int lvr2::CudaSurface::m_ki |  | private | 
 
 
◆ m_mps
  
  | 
        
          | int lvr2::CudaSurface::m_mps |  | private | 
 
 
◆ m_reconstruction_mode
  
  | 
        
          | bool lvr2::CudaSurface::m_reconstruction_mode |  | private | 
 
 
◆ m_size_grid
  
  | 
        
          | int* lvr2::CudaSurface::m_size_grid |  | private | 
 
 
◆ m_size_thread_block
  
  | 
        
          | int* lvr2::CudaSurface::m_size_thread_block |  | private | 
 
 
◆ m_threads_per_block
  
  | 
        
          | int lvr2::CudaSurface::m_threads_per_block |  | private | 
 
 
◆ m_threads_per_mp
  
  | 
        
          | int lvr2::CudaSurface::m_threads_per_mp |  | private | 
 
 
◆ m_vx
  
  | 
        
          | float lvr2::CudaSurface::m_vx |  | private | 
 
 
◆ m_vy
  
  | 
        
          | float lvr2::CudaSurface::m_vy |  | private | 
 
 
◆ m_vz
  
  | 
        
          | float lvr2::CudaSurface::m_vz |  | private | 
 
 
◆ Result_Normals
The documentation for this class was generated from the following file: