pcl::device Namespace Reference

## Namespaces

| kinfuLS

## Classes

struct | Eigen33
struct | Histogram
struct | PPFSignature
struct | PPFRGBSignature
struct | PrincipalCurvatures
struct | VFHEstimationImpl
struct | Block
struct | Warp
struct | Emulation
struct | Intr
| Camera intrinsics structure. More...
struct | Mat33
| 3x3 Matrix for device code More...
struct | LightSource
| Light source collection. More...
struct | float8
struct | float12
struct | OctreeIteratorDevice
struct | OctreeIteratorDeviceNS
struct | OctreeGlobal
struct | OctreeGlobalWithBox
class | OctreeImpl
struct | Morton
struct | CalcMorton
struct | CompareByLevelCode
struct | OctreePriorityIteratorDevice
struct | prob_histogram
struct | ConnectedComponents
struct | Dilatation
struct | CUDATree
| Struct that holds a single RDF tree in GPU. More...
class | MultiTreeLiveProc
| Processor using multiple trees. More...
class | ProbabilityProc
| Implementation Class to process probability histograms on GPU. More...
struct | LessThanByFacet
struct | InitalSimplex
struct | FacetStream
struct | PointStream
struct | NonCachedLoad
struct | bit_not
struct | plusWeighted
struct | Static
struct | Static< true >

## Typedefs

using | PointType = float4
using | NormalType = float4
using | PointXYZRGB = float4
using | PointCloud = DeviceArray< PointType >
using | Normals = DeviceArray< NormalType >
using | Indices = DeviceArray< int >
using | PointXYZRGBCloud = DeviceArray< PointType >
using | PFHSignature125 = Histogram< 125 >
using | PFHRGBSignature250 = Histogram< 250 >
using | FPFHSignature33 = Histogram< 33 >
using | VFHSignature308 = Histogram< 308 >
using | ushort = unsigned short
using | MapArr = DeviceArray2D< float >
using | DepthMap = DeviceArray2D< ushort >
using | LabelProbability = DeviceArray2D< prob_histogram >
using | Cloud = DeviceArray2D< float4 >
using | Image = DeviceArray2D< uchar4 >
using | Depth = DeviceArray2D< unsigned short >
using | Labels = DeviceArray2D< unsigned char >
using | HueImage = DeviceArray2D< float >
using | Mask = DeviceArray2D< unsigned char >
using | MultiLabels = DeviceArray2D< char4 >
using | FacetsDists = DeviceArray< std::uint64_t >
using | Perm = DeviceArray< int >
using | StateType = float8
using | PixelRGB = uchar4

## Enumerations

enum | ScanKind { exclusive , inclusive , exclusive , inclusive }
enum | ScanKind { exclusive , inclusive , exclusive , inclusive }

## Functions

__device__ __forceinline__ void | computeRoots2 (const float &b, const float &c, float3 &roots)
__device__ __forceinline__ void | computeRoots3 (float c0, float c1, float c2, float3 &roots)
__device__ __host__ __forceinline__ bool | computePairFeatures (const float3 &p1, const float3 &n1, const float3 &p2, const float3 &n2, float &f1, float &f2, float &f3, float &f4)
__device__ __host__ __forceinline__ bool | computeRGBPairFeatures (const float3 &p1, const float3 &n1, const int &colors1, const float3 &p2, const float3 &n2, const int &colors2, float &f1, float &f2, float &f3, float &f4, float &f5, float &f6, float &f7)
__device__ __host__ __forceinline__ void | computeRGBPairFeatures_RGBOnly (const int &colors1, const int &colors2, float &f5, float &f6, float &f7)
__device__ __host__ __forceinline__ bool | computePPFPairFeature (const float3 &p1, const float3 &n1, const float3 &p2, const float3 &n2, float &f1, float &f2, float &f3, float &f4)
__device__ __host__ __forceinline__ void | computeAlfaM (const float3 &model_reference_point, const float3 &model_reference_normal, const float3 &model_point, float &alpha_m)
__device__ __host__ __forceinline__ void | AngleAxisf (float angle, const float3 &r, float3 &row1, float3 &row2, float3 &row3)
__device__ __host__ __forceinline__ void | Rodrigues (const float3 &rvec, float3 &row1, float3 &row2, float3 &row3)
void | computeNormals (const PointCloud &cloud, const NeighborIndices &nn_indices, Normals &normals)
void | flipNormalTowardsViewpoint (const PointCloud &cloud, const float3 &vp, Normals &normals)
void | flipNormalTowardsViewpoint (const PointCloud &cloud, const Indices &indices, const float3 &vp, Normals &normals)
void | repackToAosForPfh (const PointCloud &cloud, const Normals &normals, const NeighborIndices &neighbours, DeviceArray2D< float > &data_rpk, int &max_elems_rpk)
void | computePfh125 (const DeviceArray2D< float > &data_rpk, int max_elems_rpk, const NeighborIndices &neighbours, DeviceArray2D< PFHSignature125 > &features)
void | repackToAosForPfhRgb (const PointCloud &cloud, const Normals &normals, const NeighborIndices &neighbours, DeviceArray2D< float > &data_rpk, int &max_elems_rpk)
void | computePfhRgb250 (const DeviceArray2D< float > &data_rpk, int max_elems_rpk, const NeighborIndices &neighbours, DeviceArray2D< PFHRGBSignature250 > &features)
void | computeSPFH (const PointCloud &surface, const Normals &normals, const Indices &indices, const NeighborIndices &neighbours, DeviceArray2D< FPFHSignature33 > &spfh33)
void | computeFPFH (const PointCloud &cloud, const NeighborIndices &neighbours, const DeviceArray2D< FPFHSignature33 > &spfh, DeviceArray2D< FPFHSignature33 > &features)
void | computeFPFH (const PointCloud &cloud, const Indices &indices, const PointCloud &surface, const NeighborIndices &neighbours, DeviceArray< int > &lookup, const DeviceArray2D< FPFHSignature33 > &spfh, DeviceArray2D< FPFHSignature33 > &features)
int | computeUniqueIndices (std::size_t surface_size, const NeighborIndices &neighbours, DeviceArray< int > &unique_indices, DeviceArray< int > &lookup)
void | computePPF (const PointCloud &input, const Normals &normals, const Indices &indices, DeviceArray< PPFSignature > &output)
void | computePPFRGB (const PointXYZRGBCloud &input, const Normals &normals, const Indices &indices, DeviceArray< PPFRGBSignature > &output)
void | computePPFRGBRegion (const PointXYZRGBCloud &cloud, const Normals &normals, const Indices &indices, const NeighborIndices &nn_indices, DeviceArray< PPFRGBSignature > &output)
void | computePointPrincipalCurvatures (const Normals &normals, const Indices &indices, const NeighborIndices &neighbours, DeviceArray< PrincipalCurvatures > &output, DeviceArray2D< float > &proj_normals_buf)
template<typename PointT >
void | compute3DCentroid (const DeviceArray< PointT > &cloud, float3 &centroid)
template<typename PointT >
void | compute3DCentroid (const DeviceArray< PointT > &cloud, const Indices &indices, float3 &centroid)
template<typename PointT >
float3 | getMaxDistance (const DeviceArray< PointT > &cloud, const float3 &pivot)
template<typename PointT >
float3 | getMaxDistance (const DeviceArray< PointT > &cloud, const Indices &indices, const float3 &pivot)
void | computeSpinImagesOrigigNormal (bool radial, bool angular, float support_angle_cos, const Indices &indices, const PointCloud &input_cloud, const Normals &input_normals, const PointCloud &surface, const Normals &normals, const NeighborIndices &neighbours, int min_neighb, int image_width, float bin_size, PtrStep< float > output)
void | computeSpinImagesCustomAxes (bool radial, bool angular, float support_angle_cos, const Indices &indices, const PointCloud &input_cloud, const Normals &input_normals, const PointCloud &surface, const Normals &normals, const NeighborIndices &neighbours, int min_neighb, int image_width, float bin_size, const float3 &rotation_axis, PtrStep< float > output)
void | computeSpinImagesCustomAxesCloud (bool radial, bool angular, float support_angle_cos, const Indices &indices, const PointCloud &input_cloud, const Normals &input_normals, const PointCloud &surface, const Normals &normals, const NeighborIndices &neighbours, int min_neighb, int image_width, float bin_size, const Normals &rotation_axes_cloud, PtrStep< float > output)
void | computeMask (const NeighborIndices &neighbours, int min_neighb, DeviceArray< unsigned char > &mask)
__forceinline__ __device__ __host__ float3 | operator/ (const float3 &vec, float val)
__device__ __host__ __forceinline__ float3 & | operator/= (float3 &v, const float &value)
__device__ __host__ __forceinline__ float | norm (const float3 &v1, const float3 &v2)
template<typename T >
__device__ __forceinline__ float3 | tr (const T &v)
__host__ __device__ float3 | normalize (const float3 &v)
__device__ __forceinline__ void | pack_tsdf (float tsdf, int weight, short2 &value)
__device__ __forceinline__ void | unpack_tsdf (short2 value, float &tsdf, int &weight)
__device__ __forceinline__ float | unpack_tsdf (short2 value)
__device__ __forceinline__ float3 | operator* (const Mat33 &m, const float3 &vec)
template<ScanKind Kind, class T >
__device__ __forceinline__ T | scan_warp (volatile T *ptr, const unsigned int idx=threadIdx.x)
template<class T >
__device__ __host__ __forceinline__ void | swap (T &a, T &b)
__device__ __forceinline__ float | dot (const float3 &v1, const float3 &v2)
__device__ __forceinline__ float3 & | operator+= (float3 &vec, const float &v)
__device__ __forceinline__ float3 | operator+ (const float3 &v1, const float3 &v2)
__device__ __forceinline__ float3 & | operator*= (float3 &vec, const float &v)
__device__ __forceinline__ float3 | operator- (const float3 &v1, const float3 &v2)
__device__ __forceinline__ float3 | operator* (const float3 &v1, const float &v)
__device__ __forceinline__ float | norm (const float3 &v)
__device__ __forceinline__ float3 | normalized (const float3 &v)
__device__ __host__ __forceinline__ float3 | cross (const float3 &v1, const float3 &v2)
void | bilateralFilter (const DepthMap &src, DepthMap &dst)
| Performs bilateral filtering of disparity map. More...
void | pyrDown (const DepthMap &src, DepthMap &dst)
| Computes depth pyramid. More...
void | createVMap (const Intr &intr, const DepthMap &depth, MapArr &vmap)
| Computes vertex map. More...
void | createNMap (const MapArr &vmap, MapArr &nmap)
| Computes normal map using cross product. More...
void | computeNormalsEigen (const MapArr &vmap, MapArr &nmap)
| Computes normal map using Eigen/PCA approach. More...
void | tranformMaps (const MapArr &vmap_src, const MapArr &nmap_src, const Mat33 &Rmat, const float3 &tvec, MapArr &vmap_dst, MapArr &nmap_dst)
| Performs affine transform of vertex and normal maps. More...
void | truncateDepth (DepthMap &depth, float max_distance)
| Performs depth truncation. More...
void | findCoresp (const MapArr &vmap_g_curr, const MapArr &nmap_g_curr, const Mat33 &Rprev_inv, const float3 &tprev, const Intr &intr, const MapArr &vmap_g_prev, const MapArr &nmap_g_prev, float distThres, float angleThres, PtrStepSz< short2 > coresp)
| (now it's extra code) Computes corespondances map More...
void | estimateTransform (const MapArr &v_dst, const MapArr &n_dst, const MapArr &v_src, const PtrStepSz< short2 > &coresp, DeviceArray2D< float > &gbuf, DeviceArray< float > &mbuf, float *matrixA_host, float *vectorB_host)
| (now it's extra code) Computation Ax=b for ICP iteration More...
void | estimateCombined (const Mat33 &Rcurr, const float3 &tcurr, const MapArr &vmap_curr, const MapArr &nmap_curr, const Mat33 &Rprev_inv, const float3 &tprev, const Intr &intr, const MapArr &vmap_g_prev, const MapArr &nmap_g_prev, float distThres, float angleThres, DeviceArray2D< float > &gbuf, DeviceArray< float > &mbuf, float *matrixA_host, float *vectorB_host)
| Computation Ax=b for ICP iteration. More...
void | estimateCombined (const Mat33 &Rcurr, const float3 &tcurr, const MapArr &vmap_curr, const MapArr &nmap_curr, const Mat33 &Rprev_inv, const float3 &tprev, const Intr &intr, const MapArr &vmap_g_prev, const MapArr &nmap_g_prev, float distThres, float angleThres, DeviceArray2D< double > &gbuf, DeviceArray< double > &mbuf, double *matrixA_host, double *vectorB_host)
PCL_EXPORTS void | initVolume (PtrStep< short2 > array)
| Perform tsdf volume initialization. More...
void | integrateTsdfVolume (const PtrStepSz< ushort > &depth_raw, const Intr &intr, const float3 &volume_size, const Mat33 &Rcurr_inv, const float3 &tcurr, float tranc_dist, PtrStep< short2 > volume)
| Performs Tsfg volume uptation (extra obsolete now) More...
PCL_EXPORTS void | integrateTsdfVolume (const PtrStepSz< ushort > &depth_raw, const Intr &intr, const float3 &volume_size, const Mat33 &Rcurr_inv, const float3 &tcurr, float tranc_dist, PtrStep< short2 > volume, DeviceArray2D< float > &depthRawScaled)
| Function that integrates volume if volume element contains: 2 bytes for round(tsdf*SHORT_MAX) and 2 bytes for integer weight. More...
void | initColorVolume (PtrStep< uchar4 > color_volume)
| Initialzied color volume. More...
void | updateColorVolume (const Intr &intr, float tranc_dist, const Mat33 &R_inv, const float3 &t, const MapArr &vmap, const PtrStepSz< uchar3 > &colors, const float3 &volume_size, PtrStep< uchar4 > color_volume, int max_weight=1)
| Performs integration in color volume. More...
void | raycast (const Intr &intr, const Mat33 &Rcurr, const float3 &tcurr, float tranc_dist, const float3 &volume_size, const PtrStep< short2 > &volume, MapArr &vmap, MapArr &nmap)
| Generation vertex and normal maps from volume for current camera pose. More...
void | generateImage (const MapArr &vmap, const MapArr &nmap, const LightSource &light, PtrStepSz< uchar3 > dst)
| Renders 3D image of the scene. More...
void | generateDepth (const Mat33 &R_inv, const float3 &t, const MapArr &vmap, DepthMap &dst)
| Renders depth image from give pose. More...
void | paint3DView (const PtrStep< uchar3 > &colors, PtrStepSz< uchar3 > dst, float colors_weight=0.5f)
| Paints 3D view with color map. More...
void | resizeVMap (const MapArr &input, MapArr &output)
| Performs resize of vertex map to next pyramid level by averaging each four points. More...
void | resizeNMap (const MapArr &input, MapArr &output)
| Performs resize of vertex map to next pyramid level by averaging each four normals. More...
PCL_EXPORTS std::size_t | extractCloud (const PtrStep< short2 > &volume, const float3 &volume_size, PtrSz< PointType > output)
| Perform point cloud extraction from tsdf volume. More...
template<typename NormalType >
void | extractNormals (const PtrStep< short2 > &volume, const float3 &volume_size, const PtrSz< PointType > &input, NormalType *output)
| Performs normals computation for given points using tsdf volume. More...
void | exctractColors (const PtrStep< uchar4 > &color_volume, const float3 &volume_size, const PtrSz< PointType > &points, uchar4 *colors)
| Performs colors exctraction from color volume. More...
template<typename T >
void | convert (const MapArr &vmap, DeviceArray2D< T > &output)
| Conversion from SOA to AOS. More...
void | mergePointNormal (const DeviceArray< float4 > &cloud, const DeviceArray< float8 > &normals, const DeviceArray< float12 > &output)
| Merges pcl::PointXYZ and pcl::Normal to PointNormal. More...
bool | valid_host (float value)
| Check for qnan (unused now) More...
void | sync ()
| synchronizes CUDA execution More...
template<class D , class Matx >
D & | device_cast (Matx &matx)
void | bindTextures (const int *edgeBuf, const int *triBuf, const int *numVertsBuf)
| Binds marching cubes tables to texture references. More...
void | unbindTextures ()
| Unbinds. More...
int | getOccupiedVoxels (const PtrStep< short2 > &volume, DeviceArray2D< int > &occupied_voxels)
| Scans tsdf volume and retrieves occupied voxels. More...
int | computeOffsetsAndTotalVertexes (DeviceArray2D< int > &occupied_voxels)
| Computes total number of vertexes for all voxels and offsets of vertexes in final triangle array. More...
void | generateTriangles (const PtrStep< short2 > &volume, const DeviceArray2D< int > &occupied_voxels, const float3 &volume_size, DeviceArray< PointType > &output)
| Generates final triangle array. More...
void | bruteForceRadiusSearch (const OctreeImpl::PointCloud &cloud, const OctreeImpl::PointType &query, float radius, DeviceArray< int > &result, DeviceArray< int > &buffer)
__device__ __host__ __forceinline__ unsigned | getBitsNum (const unsigned integer)
__host__ __device__ __forceinline__ std::pair< uint3, std::uint8_t > | nearestVoxel (const float3 query, const unsigned &level, const std::uint8_t &mask, const float3 &minp, const float3 &maxp, const uint3 &index)
template<typename T >
__device__ __host__ int | findNode (const float3 minp, const float3 maxp, const float3 query, const T nodes)
template<typename T >
__device__ __forceinline__ void | swap (T &a, T &b)
template<typename V , typename K >
__device__ __forceinline__ void | bitonicSortWarp (volatile K *keys, volatile V *vals, unsigned int dir=1)
__device__ __host__ static __forceinline__ bool | checkIfNodeInsideSphere (const float3 &minp, const float3 &maxp, const float3 &c, float r)
__device__ __host__ static __forceinline__ bool | checkIfNodeOutsideSphere (const float3 &minp, const float3 &maxp, const float3 &c, float r)
__device__ __host__ static __forceinline__ void | calcBoundingBox (int level, int code, float3 &res_minp, float3 &res_maxp)
template<typename T >
__device__ void | CopyKernel (const T *in, T *out, int length)
template<typename T >
__device__ void | GenerateKernel (T *out, int beg, int end)
template<typename T >
__device__ void | GenerateTasksKernel (T *out, int beg, int end, int level)
template<ScanKind Kind, class T >
__device__ __forceinline__ T | scan_block (volatile T *ptr, const unsigned int idx=threadIdx.x)
template<class T >
__device__ __forceinline__ T | warp_reduce (volatile T *ptr, const unsigned int tid=threadIdx.x)
template<typename Point >
__device__ __forceinline__ float | sqnorm (const Point &p1, const Point &p2)
__device__ __forceinline__ float3 | computePoint (unsigned short depth, int x, int y, const Intr &intr)
__device__ __forceinline__ bool | isFinite (const float3 &p)
void | smoothLabelImage (const Labels &src, const Depth &depth, Labels &dst, int num_parts, int patch_size, int depthThres)
void | colorLMap (const Labels &labels, const DeviceArray< uchar4 > &cmap, Image &rgb)
void | mixedColorMap (const Labels &labels, const DeviceArray< uchar4 > &map, const Image &rgba, Image &output)
void | computeCloud (const Depth &depth, const Intr &intr, Cloud &cloud)
void | setZero (Mask &mask)
void | prepareForeGroundDepth (const Depth &depth1, Mask &inverse_mask, Depth &depth2)
float | computeHue (int rgba)
void | computeHueWithNans (const Image &image, const Depth &depth, HueImage &hue)
__device__ __host__ __forceinline__ float4 | compute_plane (const float3 &v, const float3 &v1, const float3 &v2, const float3 &p)
| Computers plane from 3 points (v, v1, v2), ensures that point P lies positive subspace. More...
__device__ __host__ __forceinline__ float3 | tr (const PointType &p)
__device__ __host__ __forceinline__ float | compue_inv_normal_norm (const float4 &p)
__device__ __host__ __forceinline__ float4 & | operator*= (float4 &p, float v)
std::size_t | remove_duplicates (DeviceArray< int > &indeces)
void | pack_hull (const DeviceArray< PointType > &points, const DeviceArray< int > &indeces, DeviceArray< PointType > &output)
__device__ __forceinline__ float | getSampleNormal (const float mean, const float cov, curandState *rng_state)
void | initParticles (PtrSz< curandState > rng_states, DeviceArray< float > &initial_noise_mean, DeviceArray< float > &initial_noise_covariance, const StateType &representative_state, DeviceArray< StateType > &particles)
void | computeTracking (const DeviceArray2D< PointType > &ref, const DeviceArray2D< PixelRGB > &ref_color, const DeviceArray2D< PointType > &input, const DeviceArray2D< PixelRGB > &input_color, PtrSz< curandState > rng_states, const DeviceArray< float > &step_noise_covariance, DeviceArray< StateType > &particles, StateType &representative_state, StateType &motion, float motion_ratio)
template<typename Iterator , typename T , typename BinaryPredicate >
__host__ __device__ Iterator | lower_bound (Iterator first, Iterator last, const T &val, BinaryPredicate comp)
template<class Func >
void | printFuncAttrib (Func &func)
template<unsigned int CTA_SIZE, typename T , typename BinaryFunction >
__device__ __forceinline__ void | reduce_block (volatile T *data, BinaryFunction op, unsigned int tid=threadIdx.x)
__device__ __host__ __forceinline__ float | dot (const float4 &v1, const float4 &v2)
template<typename T >
__device__ __host__ __forceinline__ float | norm (const T &val)
template<typename T >
__host__ __device__ __forceinline__ float | inverse_norm (const T &v)
template<typename T >
__host__ __device__ __forceinline__ T | normalized (const T &v)
template<typename T >
__host__ __device__ __forceinline__ T | normalized_safe (const T &v)
void | copyFields (int in_size, int out_size, int info[4], int size, const void *input, void *output)

## Variables

constexpr int | DIVISOR = std::numeric_limits<short>::max()
constexpr int | VOLUME_X = 512
constexpr int | VOLUME_Y = 512
constexpr int | VOLUME_Z = 512
constexpr float | VOLUME_SIZE = 3.0f

## Typedef Documentation

## Cloud

typedef pcl::gpu::DeviceArray< PointType > pcl::device::Cloud

Definition at line 52 of file internal.h.

## Depth

using pcl::device::Depth = typedef DeviceArray2D<unsigned short>

Definition at line 55 of file internal.h.

## DepthMap

using pcl::device::DepthMap = typedef DeviceArray2D<ushort>

Definition at line 52 of file internal.h.

## FacetsDists

using pcl::device::FacetsDists = typedef DeviceArray<std::uint64_t>

Definition at line 52 of file internal.h.

## FPFHSignature33

using pcl::device::FPFHSignature33 = typedef Histogram<33>

Definition at line 75 of file internal.hpp.

## HueImage

using pcl::device::HueImage = typedef DeviceArray2D<float>

Definition at line 57 of file internal.h.

## Image

using pcl::device::Image = typedef DeviceArray2D<uchar4>

Definition at line 53 of file internal.h.

## Indices

using pcl::device::Indices = typedef DeviceArray<int>

Definition at line 64 of file internal.hpp.

## LabelProbability

using pcl::device::LabelProbability = typedef DeviceArray2D<prob_histogram>

Definition at line 264 of file label_common.h.

## Labels

using pcl::device::Labels = typedef DeviceArray2D<unsigned char>

Definition at line 56 of file internal.h.

## MapArr

using pcl::device::MapArr = typedef DeviceArray2D<float>

Definition at line 51 of file internal.h.

## Mask

using pcl::device::Mask = typedef DeviceArray2D<unsigned char>

Definition at line 58 of file internal.h.

## MultiLabels

using pcl::device::MultiLabels = typedef DeviceArray2D<char4>

Definition at line 60 of file internal.h.

## Normals

using pcl::device::Normals = typedef DeviceArray<NormalType>

Definition at line 63 of file internal.hpp.

## NormalType

typedef float4 pcl::device::NormalType

Definition at line 59 of file internal.hpp.

## Perm

using pcl::device::Perm = typedef DeviceArray<int>

Definition at line 53 of file internal.h.

## PFHRGBSignature250

using pcl::device::PFHRGBSignature250 = typedef Histogram<250>

Definition at line 74 of file internal.hpp.

## PFHSignature125

using pcl::device::PFHSignature125 = typedef Histogram<125>

Definition at line 73 of file internal.hpp.

## PixelRGB

using pcl::device::PixelRGB = typedef uchar4

Definition at line 18 of file internal.h.

## PointCloud

using pcl::device::PointCloud = typedef DeviceArray<PointType>

Definition at line 62 of file internal.hpp.

## PointType

typedef float4 pcl::device::PointType

Definition at line 58 of file internal.hpp.

## PointXYZRGB

using pcl::device::PointXYZRGB = typedef float4

Definition at line 60 of file internal.hpp.

## PointXYZRGBCloud

using pcl::device::PointXYZRGBCloud = typedef DeviceArray<PointType>

Definition at line 66 of file internal.hpp.

## StateType

using pcl::device::StateType = typedef float8

Definition at line 15 of file internal.h.

## ushort

using pcl::device::ushort = typedef unsigned short

Definition at line 50 of file internal.h.

## VFHSignature308

using pcl::device::VFHSignature308 = typedef Histogram<308>

Definition at line 76 of file internal.hpp.

## Enumeration Type Documentation

## ScanKind [1/2]

enum pcl::device::ScanKind

Enumerator
exclusive |
inclusive |
exclusive |
inclusive |

Definition at line 83 of file device.hpp.

## ScanKind [2/2]

enum pcl::device::ScanKind

Enumerator
exclusive |
inclusive |
exclusive |
inclusive |

Definition at line 45 of file scan_block.hpp.

## Function Documentation

## AngleAxisf()

__device__ __host__ __forceinline__ void pcl::device::AngleAxisf | ( | float | angle,
|  | const float3 & | r,
|  | float3 & | row1,
|  | float3 & | row2,
|  | float3 & | row3
| ) |  |

Definition at line 47 of file rodrigues.hpp.

Referenced by computeAlfaM(), and Rodrigues().

## bilateralFilter()

void pcl::device::bilateralFilter | ( | const DepthMap & | src,
|  | DepthMap & | dst
| ) |  |

Performs bilateral filtering of disparity map.

Parameters

  [in] | src | source map
  [out] | dst | output map

## bindTextures()

void pcl::device::bindTextures | ( | const int * | edgeBuf,
|  | const int * | triBuf,
|  | const int * | numVertsBuf
| ) |  |

Binds marching cubes tables to texture references.

## bitonicSortWarp()

template<typename V , typename K >

__device__ __forceinline__ void pcl::device::bitonicSortWarp | ( | volatile K * | keys,
|  | volatile V * | vals,
|  | unsigned int | dir = `1`
| ) |  |

Definition at line 48 of file bitonic_sort.hpp.

References swap().

## bruteForceRadiusSearch()

void pcl::device::bruteForceRadiusSearch | ( | const OctreeImpl::PointCloud & | cloud,
|  | const OctreeImpl::PointType & | query,
|  | float | radius,
|  | DeviceArray< int > & | result,
|  | DeviceArray< int > & | buffer
| ) |  |

## calcBoundingBox()

__device__ __host__ static __forceinline__ void pcl::device::calcBoundingBox | ( | int | level,
|  | int | code,
|  | float3 & | res_minp,
|  | float3 & | res_maxp
| ) |  |

static

Definition at line 101 of file boxutils.hpp.

References pcl::device::Morton::decomposeCode().

## checkIfNodeInsideSphere()

__device__ __host__ static __forceinline__ bool pcl::device::checkIfNodeInsideSphere | ( | const float3 & | minp,
|  | const float3 & | maxp,
|  | const float3 & | c,
|  | float | r
| ) |  |

static

Definition at line 47 of file boxutils.hpp.

## checkIfNodeOutsideSphere()

__device__ __host__ static __forceinline__ bool pcl::device::checkIfNodeOutsideSphere | ( | const float3 & | minp,
|  | const float3 & | maxp,
|  | const float3 & | c,
|  | float | r
| ) |  |

static

Definition at line 89 of file boxutils.hpp.

## colorLMap()

void pcl::device::colorLMap | ( | const Labels & | labels,
|  | const DeviceArray< uchar4 > & | cmap,
|  | Image & | rgb
| ) |  |

## compue_inv_normal_norm()

__device__ __host__ __forceinline__ float pcl::device::compue_inv_normal_norm | ( | const float4 & | p | ) |

Definition at line 81 of file device.h.

## compute3DCentroid() [1/2]

template<typename PointT >

void pcl::device::compute3DCentroid | ( | const DeviceArray< PointT > & | cloud,
|  | const Indices & | indices,
|  | float3 & | centroid
| ) |  |

## compute3DCentroid() [2/2]

template<typename PointT >

void pcl::device::compute3DCentroid | ( | const DeviceArray< PointT > & | cloud,
|  | float3 & | centroid
| ) |  |

## compute_plane()

__device__ __host__ __forceinline__ float4 pcl::device::compute_plane | ( | const float3 & | v,
|  | const float3 & | v1,
|  | const float3 & | v2,
|  | const float3 & | p
| ) |  |

Computers plane from 3 points (v, v1, v2), ensures that point P lies positive subspace.

Parameters

  [in] | v | 3D point volume tsdf volume container
  [in] | v1 | 3D point volume tsdf volume container
  [in] | v2 | 3D point volume tsdf volume container
  [in] | p | point for sign check of plane coefs (should lie in positive subspace)

Returns
  a,b,c,d coefs vector

Definition at line 55 of file device.h.

References cross(), and dot().

## computeAlfaM()

__device__ __host__ __forceinline__ void pcl::device::computeAlfaM | ( | const float3 & | model_reference_point,
|  | const float3 & | model_reference_normal,
|  | const float3 & | model_point,
|  | float & | alpha_m
| ) |  |

Definition at line 179 of file pair_features.hpp.

References AngleAxisf(), and normalized().

## computeCloud()

void pcl::device::computeCloud | ( | const Depth & | depth,
|  | const Intr & | intr,
|  | Cloud & | cloud
| ) |  |

## computeFPFH() [1/2]

void pcl::device::computeFPFH | ( | const PointCloud & | cloud,
|  | const Indices & | indices,
|  | const PointCloud & | surface,
|  | const NeighborIndices & | neighbours,
|  | DeviceArray< int > & | lookup,
|  | const DeviceArray2D< FPFHSignature33 > & | spfh,
|  | DeviceArray2D< FPFHSignature33 > & | features
| ) |  |

## computeFPFH() [2/2]

void pcl::device::computeFPFH | ( | const PointCloud & | cloud,
|  | const NeighborIndices & | neighbours,
|  | const DeviceArray2D< FPFHSignature33 > & | spfh,
|  | DeviceArray2D< FPFHSignature33 > & | features
| ) |  |

## computeHue()

float pcl::device::computeHue | ( | int | rgba | ) |

## computeHueWithNans()

void pcl::device::computeHueWithNans | ( | const Image & | image,
|  | const Depth & | depth,
|  | HueImage & | hue
| ) |  |

## computeMask()

void pcl::device::computeMask | ( | const NeighborIndices & | neighbours,
|  | int | min_neighb,
|  | DeviceArray< unsigned char > & | mask
| ) |  |

## computeNormals()

void pcl::device::computeNormals | ( | const PointCloud & | cloud,
|  | const NeighborIndices & | nn_indices,
|  | Normals & | normals
| ) |  |

## computeNormalsEigen()

void pcl::device::computeNormalsEigen | ( | const MapArr & | vmap,
|  | MapArr & | nmap
| ) |  |

Computes normal map using Eigen/PCA approach.

Parameters

  [in] | vmap | vertex map
  [out] | nmap | normal map

## computeOffsetsAndTotalVertexes()

int pcl::device::computeOffsetsAndTotalVertexes | ( | DeviceArray2D< int > & | occupied_voxels | ) |

Computes total number of vertexes for all voxels and offsets of vertexes in final triangle array.

Parameters

  [out] | occupied_voxels | buffer with occupied voxels. The function fulfills 3nd only with offsets

Returns
  total number of vertexes

## computePairFeatures()

__device__ __host__ __forceinline__ bool pcl::device::computePairFeatures | ( | const float3 & | p1,
|  | const float3 & | n1,
|  | const float3 & | p2,
|  | const float3 & | n2,
|  | float & | f1,
|  | float & | f2,
|  | float & | f3,
|  | float & | f4
| ) |  |

Definition at line 48 of file pair_features.hpp.

References cross(), dot(), and norm().

## computePfh125()

void pcl::device::computePfh125 | ( | const DeviceArray2D< float > & | data_rpk,
|  | int | max_elems_rpk,
|  | const NeighborIndices & | neighbours,
|  | DeviceArray2D< PFHSignature125 > & | features
| ) |  |

## computePfhRgb250()

void pcl::device::computePfhRgb250 | ( | const DeviceArray2D< float > & | data_rpk,
|  | int | max_elems_rpk,
|  | const NeighborIndices & | neighbours,
|  | DeviceArray2D< PFHRGBSignature250 > & | features
| ) |  |

## computePoint()

__device__ __forceinline__ float3 pcl::device::computePoint | ( | unsigned short | depth,
|  | int | x,
|  | int | y,
|  | const Intr & | intr
| ) |  |

Definition at line 58 of file device.h.

References pcl::device::Intr::cx, pcl::device::Intr::cy, pcl::device::Intr::fx, and pcl::device::Intr::fy.

## computePointPrincipalCurvatures()

void pcl::device::computePointPrincipalCurvatures | ( | const Normals & | normals,
|  | const Indices & | indices,
|  | const NeighborIndices & | neighbours,
|  | DeviceArray< PrincipalCurvatures > & | output,
|  | DeviceArray2D< float > & | proj_normals_buf
| ) |  |

## computePPF()

void pcl::device::computePPF | ( | const PointCloud & | input,
|  | const Normals & | normals,
|  | const Indices & | indices,
|  | DeviceArray< PPFSignature > & | output
| ) |  |

## computePPFPairFeature()

__device__ __host__ __forceinline__ bool pcl::device::computePPFPairFeature | ( | const float3 & | p1,
|  | const float3 & | n1,
|  | const float3 & | p2,
|  | const float3 & | n2,
|  | float & | f1,
|  | float & | f2,
|  | float & | f3,
|  | float & | f4
| ) |  |

Definition at line 160 of file pair_features.hpp.

References dot(), and norm().

## computePPFRGB()

void pcl::device::computePPFRGB | ( | const PointXYZRGBCloud & | input,
|  | const Normals & | normals,
|  | const Indices & | indices,
|  | DeviceArray< PPFRGBSignature > & | output
| ) |  |

## computePPFRGBRegion()

void pcl::device::computePPFRGBRegion | ( | const PointXYZRGBCloud & | cloud,
|  | const Normals & | normals,
|  | const Indices & | indices,
|  | const NeighborIndices & | nn_indices,
|  | DeviceArray< PPFRGBSignature > & | output
| ) |  |

## computeRGBPairFeatures()

__device__ __host__ __forceinline__ bool pcl::device::computeRGBPairFeatures | ( | const float3 & | p1,
|  | const float3 & | n1,
|  | const int & | colors1,
|  | const float3 & | p2,
|  | const float3 & | n2,
|  | const int & | colors2,
|  | float & | f1,
|  | float & | f2,
|  | float & | f3,
|  | float & | f4,
|  | float & | f5,
|  | float & | f6,
|  | float & | f7
| ) |  |

Definition at line 95 of file pair_features.hpp.

References cross(), dot(), and norm().

## computeRGBPairFeatures_RGBOnly()

__device__ __host__ __forceinline__ void pcl::device::computeRGBPairFeatures_RGBOnly | ( | const int & | colors1,
|  | const int & | colors2,
|  | float & | f5,
|  | float & | f6,
|  | float & | f7
| ) |  |

Definition at line 148 of file pair_features.hpp.

## computeRoots2()

__device__ __forceinline__ void pcl::device::computeRoots2 | ( | const float & | b,
|  | const float & | c,
|  | float3 & | roots
| ) |  |

Definition at line 102 of file eigen.hpp.

Referenced by computeRoots3().

## computeRoots3()

__device__ __forceinline__ void pcl::device::computeRoots3 | ( | float | c0,
|  | float | c1,
|  | float | c2,
|  | float3 & | roots
| ) |  |

Definition at line 115 of file eigen.hpp.

References computeRoots2(), and swap().

Referenced by pcl::device::Eigen33::compute().

## computeSPFH()

void pcl::device::computeSPFH | ( | const PointCloud & | surface,
|  | const Normals & | normals,
|  | const Indices & | indices,
|  | const NeighborIndices & | neighbours,
|  | DeviceArray2D< FPFHSignature33 > & | spfh33
| ) |  |

## computeSpinImagesCustomAxes()

void pcl::device::computeSpinImagesCustomAxes | ( | bool | radial,
|  | bool | angular,
|  | float | support_angle_cos,
|  | const Indices & | indices,
|  | const PointCloud & | input_cloud,
|  | const Normals & | input_normals,
|  | const PointCloud & | surface,
|  | const Normals & | normals,
|  | const NeighborIndices & | neighbours,
|  | int | min_neighb,
|  | int | image_width,
|  | float | bin_size,
|  | const float3 & | rotation_axis,
|  | PtrStep< float > | output
| ) |  |

## computeSpinImagesCustomAxesCloud()

void pcl::device::computeSpinImagesCustomAxesCloud | ( | bool | radial,
|  | bool | angular,
|  | float | support_angle_cos,
|  | const Indices & | indices,
|  | const PointCloud & | input_cloud,
|  | const Normals & | input_normals,
|  | const PointCloud & | surface,
|  | const Normals & | normals,
|  | const NeighborIndices & | neighbours,
|  | int | min_neighb,
|  | int | image_width,
|  | float | bin_size,
|  | const Normals & | rotation_axes_cloud,
|  | PtrStep< float > | output
| ) |  |

## computeSpinImagesOrigigNormal()

void pcl::device::computeSpinImagesOrigigNormal | ( | bool | radial,
|  | bool | angular,
|  | float | support_angle_cos,
|  | const Indices & | indices,
|  | const PointCloud & | input_cloud,
|  | const Normals & | input_normals,
|  | const PointCloud & | surface,
|  | const Normals & | normals,
|  | const NeighborIndices & | neighbours,
|  | int | min_neighb,
|  | int | image_width,
|  | float | bin_size,
|  | PtrStep< float > | output
| ) |  |

## computeTracking()

void pcl::device::computeTracking | ( | const DeviceArray2D< PointType > & | ref,
|  | const DeviceArray2D< PixelRGB > & | ref_color,
|  | const DeviceArray2D< PointType > & | input,
|  | const DeviceArray2D< PixelRGB > & | input_color,
|  | PtrSz< curandState > | rng_states,
|  | const DeviceArray< float > & | step_noise_covariance,
|  | DeviceArray< StateType > & | particles,
|  | StateType & | representative_state,
|  | StateType & | motion,
|  | float | motion_ratio
| ) |  |

## computeUniqueIndices()

int pcl::device::computeUniqueIndices | ( | std::size_t | surface_size,
|  | const NeighborIndices & | neighbours,
|  | DeviceArray< int > & | unique_indices,
|  | DeviceArray< int > & | lookup
| ) |  |

## convert()

template<typename T >

void pcl::device::convert | ( | const MapArr & | vmap,
|  | DeviceArray2D< T > & | output
| ) |  |

Conversion from SOA to AOS.

Parameters

  [in] | vmap | SOA map
  [out] | output | Array of 3D points. Can be float4 or float8.

## copyFields()

void pcl::device::copyFields | ( | int | in_size,
|  | int | out_size,
|  | int | info[4],
|  | int | size,
|  | const void * | input,
|  | void * | output
| ) |  |

## CopyKernel()

template<typename T >

__device__ void pcl::device::CopyKernel | ( | const T * | in,
|  | T * | out,
|  | int | length
| ) |  |

Definition at line 48 of file copygen.hpp.

## createNMap()

void pcl::device::createNMap | ( | const MapArr & | vmap,
|  | MapArr & | nmap
| ) |  |

Computes normal map using cross product.

Parameters

  [in] | vmap | vertex map
  [out] | nmap | normal map

## createVMap()

void pcl::device::createVMap | ( | const Intr & | intr,
|  | const DepthMap & | depth,
|  | MapArr & | vmap
| ) |  |

Computes vertex map.

Parameters

  [in] | intr | depth camera intrinsics
  [in] | depth | depth
  [out] | vmap | vertex map

## cross()

__device__ __host__ __forceinline__ float3 pcl::device::cross | ( | const float3 & | v1,
|  | const float3 & | v2
| ) |  |

Definition at line 107 of file utils.hpp.

Referenced by pcl::device::Eigen33::compute(), compute_plane(), computePairFeatures(), and computeRGBPairFeatures().

## device_cast()

template<class D , class Matx >

D& pcl::device::device_cast | ( | Matx & | matx | ) |

Definition at line 401 of file internal.h.

## dot() [1/2]

__device__ __host__ __forceinline__ float pcl::device::dot | ( | const float3 & | v1,
|  | const float3 & | v2
| ) |  |

Definition at line 59 of file utils.hpp.

Referenced by pcl::device::Eigen33::compute(), compute_plane(), computePairFeatures(), computePPFPairFeature(), computeRGBPairFeatures(), inverse_norm(), norm(), normalized(), normalized_safe(), and operator*().

## dot() [2/2]

__device__ __host__ __forceinline__ float pcl::device::dot | ( | const float4 & | v1,
|  | const float4 & | v2
| ) |  |

Definition at line 82 of file vector_math.hpp.

## estimateCombined() [1/2]

void pcl::device::estimateCombined | ( | const Mat33 & | Rcurr,
|  | const float3 & | tcurr,
|  | const MapArr & | vmap_curr,
|  | const MapArr & | nmap_curr,
|  | const Mat33 & | Rprev_inv,
|  | const float3 & | tprev,
|  | const Intr & | intr,
|  | const MapArr & | vmap_g_prev,
|  | const MapArr & | nmap_g_prev,
|  | float | distThres,
|  | float | angleThres,
|  | DeviceArray2D< double > & | gbuf,
|  | DeviceArray< double > & | mbuf,
|  | double * | matrixA_host,
|  | double * | vectorB_host
| ) |  |

## estimateCombined() [2/2]

void pcl::device::estimateCombined | ( | const Mat33 & | Rcurr,
|  | const float3 & | tcurr,
|  | const MapArr & | vmap_curr,
|  | const MapArr & | nmap_curr,
|  | const Mat33 & | Rprev_inv,
|  | const float3 & | tprev,
|  | const Intr & | intr,
|  | const MapArr & | vmap_g_prev,
|  | const MapArr & | nmap_g_prev,
|  | float | distThres,
|  | float | angleThres,
|  | DeviceArray2D< float > & | gbuf,
|  | DeviceArray< float > & | mbuf,
|  | float * | matrixA_host,
|  | float * | vectorB_host
| ) |  |

Computation Ax=b for ICP iteration.

Parameters

  [in] | Rcurr | Rotation of current camera pose guess
  [in] | tcurr | translation of current camera pose guess
  [in] | vmap_curr | current vertex map in camera coo space
  [in] | nmap_curr | current vertex map in camera coo space
  [in] | Rprev_inv | inverse camera rotation at previous pose
  [in] | tprev | camera translation at previous pose
  [in] | intr | camera intrinsics
  [in] | vmap_g_prev | previous vertex map in global coo space
  [in] | nmap_g_prev | previous vertex map in global coo space
  [in] | distThres | distance filtering threshold
  [in] | angleThres | angle filtering threshold. Represents sine of angle between normals
  [out] | gbuf | temp buffer for GPU reduction
  [out] | mbuf | output GPU buffer for matrix computed
  [out] | matrixA_host | A
  [out] | vectorB_host | b

## estimateTransform()

void pcl::device::estimateTransform | ( | const MapArr & | v_dst,
|  | const MapArr & | n_dst,
|  | const MapArr & | v_src,
|  | const PtrStepSz< short2 > & | coresp,
|  | DeviceArray2D< float > & | gbuf,
|  | DeviceArray< float > & | mbuf,
|  | float * | matrixA_host,
|  | float * | vectorB_host
| ) |  |

(now it's extra code) Computation Ax=b for ICP iteration

Parameters

  [in] | v_dst | destination vertex map (previous frame cloud)
  [in] | n_dst | destination normal map (previous frame normals)
  [in] | v_src | source normal map (current frame cloud)
  [in] | coresp | Corespondances
  [out] | gbuf | temp buffer for GPU reduction
  [out] | mbuf | output GPU buffer for matrix computed
  [out] | matrixA_host | A
  [out] | vectorB_host | b

## exctractColors()

void pcl::device::exctractColors | ( | const PtrStep< uchar4 > & | color_volume,
|  | const float3 & | volume_size,
|  | const PtrSz< PointType > & | points,
|  | uchar4 * | colors
| ) |  |

Performs colors exctraction from color volume.

Parameters

  [in] | color_volume | color volume
  [in] | volume_size | volume size
  [in] | points | points for which color are computed
  [out] | colors | output array with colors.

## extractCloud()

PCL_EXPORTS std::size_t pcl::device::extractCloud | ( | const PtrStep< short2 > & | volume,
|  | const float3 & | volume_size,
|  | PtrSz< PointType > | output
| ) |  |

Perform point cloud extraction from tsdf volume.

Parameters

  [in] | volume | tsdf volume
  [in] | volume_size | size of the volume
  [out] | output | buffer large enough to store point cloud

Returns
  number of point stored to passed buffer

## extractNormals()

template<typename NormalType >

void pcl::device::extractNormals | ( | const PtrStep< short2 > & | volume,
|  | const float3 & | volume_size,
|  | const PtrSz< PointType > & | input,
|  | NormalType * | output
| ) |  |

Performs normals computation for given points using tsdf volume.

Parameters

  [in] | volume | tsdf volume
  [in] | volume_size | volume size
  [in] | input | points where normals are computed
  [out] | output | normals. Could be float4 or float8. If for a point normal can't be computed, such normal is marked as nan.

## findCoresp()

void pcl::device::findCoresp | ( | const MapArr & | vmap_g_curr,
|  | const MapArr & | nmap_g_curr,
|  | const Mat33 & | Rprev_inv,
|  | const float3 & | tprev,
|  | const Intr & | intr,
|  | const MapArr & | vmap_g_prev,
|  | const MapArr & | nmap_g_prev,
|  | float | distThres,
|  | float | angleThres,
|  | PtrStepSz< short2 > | coresp
| ) |  |

(now it's extra code) Computes corespondances map

Parameters

  [in] | vmap_g_curr | current vertex map in global coo space
  [in] | nmap_g_curr | current normals map in global coo space
  [in] | Rprev_inv | inverse camera rotation at previous pose
  [in] | tprev | camera translation at previous pose
  [in] | intr | camera intrinsics
  [in] | vmap_g_prev | previous vertex map in global coo space
  [in] | nmap_g_prev | previous vertex map in global coo space
  [in] | distThres | distance filtering threshold
  [in] | angleThres | angle filtering threshold. Represents sine of angle between normals
  [out] | coresp |

## findNode()

template<typename T >

__device__ __host__ int pcl::device::findNode | ( | const float3 | minp,
|  | const float3 | maxp,
|  | const float3 | query,
|  | const T | nodes
| ) |  |

Definition at line 81 of file approx_nearest_utils.hpp.

References pcl::device::Morton::decomposeCode(), pcl::device::Morton::extractLevelCode(), getBitsNum(), pcl::device::Morton::levels, and nearestVoxel().

## flipNormalTowardsViewpoint() [1/2]

void pcl::device::flipNormalTowardsViewpoint | ( | const PointCloud & | cloud,
|  | const float3 & | vp,
|  | Normals & | normals
| ) |  |

## flipNormalTowardsViewpoint() [2/2]

void pcl::device::flipNormalTowardsViewpoint | ( | const PointCloud & | cloud,
|  | const Indices & | indices,
|  | const float3 & | vp,
|  | Normals & | normals
| ) |  |

## generateDepth()

void pcl::device::generateDepth | ( | const Mat33 & | R_inv,
|  | const float3 & | t,
|  | const MapArr & | vmap,
|  | DepthMap & | dst
| ) |  |

Renders depth image from give pose.

Parameters

  [in] | R_inv | inverse camera rotation
  [in] | t | camera translation
  [in] | vmap | vertex map
  [out] | dst | buffer where depth is generated

## generateImage()

void pcl::device::generateImage | ( | const MapArr & | vmap,
|  | const MapArr & | nmap,
|  | const LightSource & | light,
|  | PtrStepSz< uchar3 > | dst
| ) |  |

Renders 3D image of the scene.

Parameters

  [in] | vmap | vertex map
  [in] | nmap | normals map
  [in] | light | poase of light source
  [out] | dst | buffer where image is generated

## GenerateKernel()

template<typename T >

__device__ void pcl::device::GenerateKernel | ( | T * | out,
|  | int | beg,
|  | int | end
| ) |  |

Definition at line 58 of file copygen.hpp.

## GenerateTasksKernel()

template<typename T >

__device__ void pcl::device::GenerateTasksKernel | ( | T * | out,
|  | int | beg,
|  | int | end,
|  | int | level
| ) |  |

Definition at line 71 of file copygen.hpp.

## generateTriangles()

void pcl::device::generateTriangles | ( | const PtrStep< short2 > & | volume,
|  | const DeviceArray2D< int > & | occupied_voxels,
|  | const float3 & | volume_size,
|  | DeviceArray< PointType > & | output
| ) |  |

Generates final triangle array.

Parameters

  [in] | volume | tsdf volume
  [in] | occupied_voxels | occupied voxel ids (first row), number of vertexes(second row), offsets(third row).
  [in] | volume_size | volume size in meters
  [out] | output | triangle array

## getBitsNum()

__device__ __host__ __forceinline__ unsigned pcl::device::getBitsNum | ( | const unsigned | integer | ) |

Definition at line 23 of file approx_nearest_utils.hpp.

Referenced by findNode().

## getMaxDistance() [1/2]

template<typename PointT >

float3 pcl::device::getMaxDistance | ( | const DeviceArray< PointT > & | cloud,
|  | const float3 & | pivot
| ) |  |

## getMaxDistance() [2/2]

template<typename PointT >

float3 pcl::device::getMaxDistance | ( | const DeviceArray< PointT > & | cloud,
|  | const Indices & | indices,
|  | const float3 & | pivot
| ) |  |

## getOccupiedVoxels()

int pcl::device::getOccupiedVoxels | ( | const PtrStep< short2 > & | volume,
|  | DeviceArray2D< int > & | occupied_voxels
| ) |  |

Scans tsdf volume and retrieves occupied voxels.

Parameters

  [in] | volume | tsdf volume
  [out] | occupied_voxels | buffer for occupied voxels. The function fulfills first row with voxel ids and second row with number of vertices.

Returns
  number of voxels in the buffer

## getSampleNormal()

__device__ __forceinline__ float pcl::device::getSampleNormal | ( | const float | mean,
|  | const float | cov,
|  | curandState * | rng_state
| ) |  |

Definition at line 11 of file device.hpp.

## initColorVolume()

void pcl::device::initColorVolume | ( | PtrStep< uchar4 > | color_volume | ) |

Initialzied color volume.

Parameters

  [out] | color_volume | color volume for initialization

## initParticles()

void pcl::device::initParticles | ( | PtrSz< curandState > | rng_states,
|  | DeviceArray< float > & | initial_noise_mean,
|  | DeviceArray< float > & | initial_noise_covariance,
|  | const StateType & | representative_state,
|  | DeviceArray< StateType > & | particles
| ) |  |

## initVolume()

PCL_EXPORTS void pcl::device::initVolume | ( | PtrStep< short2 > | array | ) |

Perform tsdf volume initialization.

Parameters

  [out] | array | volume to be initialized

## integrateTsdfVolume() [1/2]

void pcl::device::integrateTsdfVolume | ( | const PtrStepSz< ushort > & | depth_raw,
|  | const Intr & | intr,
|  | const float3 & | volume_size,
|  | const Mat33 & | Rcurr_inv,
|  | const float3 & | tcurr,
|  | float | tranc_dist,
|  | PtrStep< short2 > | volume
| ) |  |

Performs Tsfg volume uptation (extra obsolete now)

Parameters

  [in] | depth_raw | Kinect depth image
  [in] | intr | camera intrinsics
  [in] | volume_size | size of volume in mm
  [in] | Rcurr_inv | inverse rotation for current camera pose
  [in] | tcurr | translation for current camera pose
  [in] | tranc_dist | tsdf truncation distance
  [in] | volume | tsdf volume to be updated

## integrateTsdfVolume() [2/2]

PCL_EXPORTS void pcl::device::integrateTsdfVolume | ( | const PtrStepSz< ushort > & | depth_raw,
|  | const Intr & | intr,
|  | const float3 & | volume_size,
|  | const Mat33 & | Rcurr_inv,
|  | const float3 & | tcurr,
|  | float | tranc_dist,
|  | PtrStep< short2 > | volume,
|  | DeviceArray2D< float > & | depthRawScaled
| ) |  |

Function that integrates volume if volume element contains: 2 bytes for round(tsdf*SHORT_MAX) and 2 bytes for integer weight.

Parameters

  [in] | depth_raw | Kinect depth image
  [in] | intr | camera intrinsics
  [in] | volume_size | size of volume in mm
  [in] | Rcurr_inv | inverse rotation for current camera pose
  [in] | tcurr | translation for current camera pose
  [in] | tranc_dist | tsdf truncation distance
  [in] | volume | tsdf volume to be updated
  [out] | depthRawScaled | Buffer for scaled depth along ray

## inverse_norm()

template<typename T >

__host__ __device__ __forceinline__ float pcl::device::inverse_norm | ( | const T & | v | ) |

Definition at line 113 of file vector_math.hpp.

References dot().

Referenced by normalize(), and normalized().

## isFinite()

__device__ __forceinline__ bool pcl::device::isFinite | ( | const float3 & | p | ) |

Definition at line 71 of file device.h.

## lower_bound()

template<typename Iterator , typename T , typename BinaryPredicate >

__host__ __device__ Iterator pcl::device::lower_bound | ( | Iterator | first,
|  | Iterator | last,
|  | const T & | val,
|  | BinaryPredicate | comp
| ) |  |

Definition at line 51 of file algorithm.hpp.

## mergePointNormal()

void pcl::device::mergePointNormal | ( | const DeviceArray< float4 > & | cloud,
|  | const DeviceArray< float8 > & | normals,
|  | const DeviceArray< float12 > & | output
| ) |  |

Merges pcl::PointXYZ and pcl::Normal to PointNormal.

Parameters

  [in] | cloud | points cloud
  [in] | normals | normals cloud
  [out] | output | array of PointNomals.

## mixedColorMap()

void pcl::device::mixedColorMap | ( | const Labels & | labels,
|  | const DeviceArray< uchar4 > & | map,
|  | const Image & | rgba,
|  | Image & | output
| ) |  |

## nearestVoxel()

__host__ __device__ __forceinline__ std::pair<uint3, std::uint8_t> pcl::device::nearestVoxel | ( | const float3 | query,
|  | const unsigned & | level,
|  | const std::uint8_t & | mask,
|  | const float3 & | minp,
|  | const float3 & | maxp,
|  | const uint3 & | index
| ) |  |

Definition at line 33 of file approx_nearest_utils.hpp.

Referenced by findNode().

## norm() [1/3]

__device__ __forceinline__ float pcl::device::norm | ( | const float3 & | v | ) |

Definition at line 95 of file utils.hpp.

References dot().

## norm() [2/3]

__device__ __host__ __forceinline__ float pcl::device::norm | ( | const float3 & | v1,
|  | const float3 & | v2
| ) |  |

Definition at line 60 of file vector_operations.hpp.

Referenced by computePairFeatures(), computePPFPairFeature(), computeRGBPairFeatures(), and Rodrigues().

## norm() [3/3]

template<typename T >

__device__ __host__ __forceinline__ float pcl::device::norm | ( | const T & | val | ) |

Definition at line 108 of file vector_math.hpp.

References dot().

## normalize()

__host__ __device__ float3 pcl::device::normalize | ( | const float3 & | v | ) |

inline

Definition at line 73 of file vector_operations.hpp.

References inverse_norm().

## normalized() [1/2]

__device__ __forceinline__ float3 pcl::device::normalized | ( | const float3 & | v | ) |

Definition at line 101 of file utils.hpp.

References dot().

Referenced by pcl::device::Eigen33::compute(), and computeAlfaM().

## normalized() [2/2]

template<typename T >

__host__ __device__ __forceinline__ T pcl::device::normalized | ( | const T & | v | ) |

Definition at line 118 of file vector_math.hpp.

References inverse_norm().

## normalized_safe()

template<typename T >

__host__ __device__ __forceinline__ T pcl::device::normalized_safe | ( | const T & | v | ) |

Definition at line 123 of file vector_math.hpp.

References dot().

## operator*() [1/2]

__device__ __forceinline__ float3 pcl::device::operator* | ( | const float3 & | v1,
|  | const float & | v
| ) |  |

Definition at line 89 of file utils.hpp.

## operator*() [2/2]

__device__ __forceinline__ float3 pcl::device::operator* | ( | const Mat33 & | m,
|  | const float3 & | vec
| ) |  |

Definition at line 74 of file device.hpp.

References pcl::device::Mat33::data, and dot().

## operator*=() [1/2]

__device__ __forceinline__ float3& pcl::device::operator*= | ( | float3 & | vec,
|  | const float & | v
| ) |  |

Definition at line 77 of file utils.hpp.

## operator*=() [2/2]

__device__ __host__ __forceinline__ float4& pcl::device::operator*= | ( | float4 & | p,
|  | float | v
| ) |  |

Definition at line 84 of file device.h.

## operator+()

__device__ __forceinline__ float3 pcl::device::operator+ | ( | const float3 & | v1,
|  | const float3 & | v2
| ) |  |

Definition at line 71 of file utils.hpp.

## operator+=()

__device__ __forceinline__ float3& pcl::device::operator+= | ( | float3 & | vec,
|  | const float & | v
| ) |  |

Definition at line 65 of file utils.hpp.

## operator-()

__device__ __forceinline__ float3 pcl::device::operator- | ( | const float3 & | v1,
|  | const float3 & | v2
| ) |  |

Definition at line 83 of file utils.hpp.

## operator/()

__forceinline__ __device__ __host__ float3 pcl::device::operator/ | ( | const float3 & | vec,
|  | float | val
| ) |  |

Definition at line 47 of file vector_operations.hpp.

## operator/=()

__device__ __host__ __forceinline__ float3& pcl::device::operator/= | ( | float3 & | v,
|  | const float & | value
| ) |  |

Definition at line 52 of file vector_operations.hpp.

## pack_hull()

void pcl::device::pack_hull | ( | const DeviceArray< PointType > & | points,
|  | const DeviceArray< int > & | indeces,
|  | DeviceArray< PointType > & | output
| ) |  |

## pack_tsdf()

__device__ __forceinline__ void pcl::device::pack_tsdf | ( | float | tsdf,
|  | int | weight,
|  | short2 & | value
| ) |  |

Definition at line 52 of file device.hpp.

References DIVISOR.

## paint3DView()

void pcl::device::paint3DView | ( | const PtrStep< uchar3 > & | colors,
|  | PtrStepSz< uchar3 > | dst,
|  | float | colors_weight = `0.5f`
| ) |  |

Paints 3D view with color map.

Parameters

  [in] | colors | rgb color frame from OpenNI
  [out] | dst | output 3D view
  [in] | colors_weight | weight for colors

## prepareForeGroundDepth()

void pcl::device::prepareForeGroundDepth | ( | const Depth & | depth1,
|  | Mask & | inverse_mask,
|  | Depth & | depth2
| ) |  |

## printFuncAttrib()

template<class Func >

void pcl::device::printFuncAttrib | ( | Func & | func | ) |

Definition at line 47 of file funcattrib.hpp.

## pyrDown()

void pcl::device::pyrDown | ( | const DepthMap & | src,
|  | DepthMap & | dst
| ) |  |

Computes depth pyramid.

Parameters

  [in] | src | source
  [out] | dst | destination

## raycast()

void pcl::device::raycast | ( | const Intr & | intr,
|  | const Mat33 & | Rcurr,
|  | const float3 & | tcurr,
|  | float | tranc_dist,
|  | const float3 & | volume_size,
|  | const PtrStep< short2 > & | volume,
|  | MapArr & | vmap,
|  | MapArr & | nmap
| ) |  |

Generation vertex and normal maps from volume for current camera pose.

Parameters

  [in] | intr | camera intrinsices
  [in] | Rcurr | current rotation
  [in] | tcurr | current translation
  [in] | tranc_dist | volume truncation distance
  [in] | volume_size | volume size in mm
  [in] | volume | tsdf volume
  [out] | vmap | output vertex map
  [out] | nmap | output normals map

## reduce_block()

template<unsigned int CTA_SIZE, typename T , typename BinaryFunction >

__device__ __forceinline__ void pcl::device::reduce_block | ( | volatile T * | data,
|  | BinaryFunction | op,
|  | unsigned int | tid = `threadIdx.x`
| ) |  |

Definition at line 45 of file reduce.hpp.

## remove_duplicates()

std::size_t pcl::device::remove_duplicates | ( | DeviceArray< int > & | indeces | ) |

## repackToAosForPfh()

void pcl::device::repackToAosForPfh | ( | const PointCloud & | cloud,
|  | const Normals & | normals,
|  | const NeighborIndices & | neighbours,
|  | DeviceArray2D< float > & | data_rpk,
|  | int & | max_elems_rpk
| ) |  |

## repackToAosForPfhRgb()

void pcl::device::repackToAosForPfhRgb | ( | const PointCloud & | cloud,
|  | const Normals & | normals,
|  | const NeighborIndices & | neighbours,
|  | DeviceArray2D< float > & | data_rpk,
|  | int & | max_elems_rpk
| ) |  |

## resizeNMap()

void pcl::device::resizeNMap | ( | const MapArr & | input,
|  | MapArr & | output
| ) |  |

Performs resize of vertex map to next pyramid level by averaging each four normals.

Parameters

  [in] | input | normal map
  [out] | output | vertex map

## resizeVMap()

void pcl::device::resizeVMap | ( | const MapArr & | input,
|  | MapArr & | output
| ) |  |

Performs resize of vertex map to next pyramid level by averaging each four points.

Parameters

  [in] | input | vertext map
  [out] | output | resized vertex map

## Rodrigues()

__device__ __host__ __forceinline__ void pcl::device::Rodrigues | ( | const float3 & | rvec,
|  | float3 & | row1,
|  | float3 & | row2,
|  | float3 & | row3
| ) |  |

Definition at line 65 of file rodrigues.hpp.

References AngleAxisf(), and norm().

## scan_block()

template<ScanKind Kind, class T >

__device__ __forceinline__ T pcl::device::scan_block | ( | volatile T * | ptr,
|  | const unsigned int | idx = `threadIdx.x`
| ) |  |

Definition at line 65 of file scan_block.hpp.

## scan_warp()

template<ScanKind Kind, class T >

__device__ __forceinline__ T pcl::device::scan_warp | ( | volatile T * | ptr,
|  | const unsigned int | idx = `threadIdx.x`
| ) |  |

Definition at line 87 of file device.hpp.

References inclusive.

## setZero()

void pcl::device::setZero | ( | Mask & | mask | ) |

## smoothLabelImage()

void pcl::device::smoothLabelImage | ( | const Labels & | src,
|  | const Depth & | depth,
|  | Labels & | dst,
|  | int | num_parts,
|  | int | patch_size,
|  | int | depthThres
| ) |  |

## sqnorm()

template<typename Point >

__device__ __forceinline__ float pcl::device::sqnorm | ( | const Point & | p1,
|  | const Point & | p2
| ) |  |

Definition at line 50 of file device.h.

## swap() [1/2]

template<class T >

__device__ __host__ __forceinline__ void pcl::device::swap | ( | T & | a,
|  | T & | b
| ) |  |

Definition at line 53 of file utils.hpp.

Referenced by bitonicSortWarp(), and computeRoots3().

## swap() [2/2]

template<typename T >

__device__ __forceinline__ void pcl::device::swap | ( | T & | a,
|  | T & | b
| ) |  |

Definition at line 45 of file bitonic_sort.hpp.

## sync()

void pcl::device::sync | ( |  | ) |

inline

synchronizes CUDA execution

Definition at line 397 of file internal.h.

## tr() [1/2]

__device__ __host__ __forceinline__ float3 pcl::device::tr | ( | const PointType & | p | ) |

Definition at line 69 of file device.h.

## tr() [2/2]

template<typename T >

__device__ __forceinline__ float3 pcl::device::tr | ( | const T & | v | ) |

Definition at line 68 of file vector_operations.hpp.

## tranformMaps()

void pcl::device::tranformMaps | ( | const MapArr & | vmap_src,
|  | const MapArr & | nmap_src,
|  | const Mat33 & | Rmat,
|  | const float3 & | tvec,
|  | MapArr & | vmap_dst,
|  | MapArr & | nmap_dst
| ) |  |

Performs affine transform of vertex and normal maps.

Parameters

  [in] | vmap_src | source vertex map
  [in] | nmap_src | source vertex map
  [in] | Rmat | Rotation mat
  [in] | tvec | translation
  [out] | vmap_dst | destination vertex map
  [out] | nmap_dst | destination vertex map

## truncateDepth()

void pcl::device::truncateDepth | ( | DepthMap & | depth,
|  | float | max_distance
| ) |  |

Performs depth truncation.

Parameters

  [out] | depth | depth map to truncation
  [in] | max_distance | truncation threshold, values that are higher than the threshold are reset to zero (means not measurement)

## unbindTextures()

void pcl::device::unbindTextures | ( |  | ) |

Unbinds.

## unpack_tsdf() [1/2]

__device__ __forceinline__ float pcl::device::unpack_tsdf | ( | short2 | value | ) |

Definition at line 67 of file device.hpp.

References DIVISOR.

## unpack_tsdf() [2/2]

__device__ __forceinline__ void pcl::device::unpack_tsdf | ( | short2 | value,
|  | float & | tsdf,
|  | int & | weight
| ) |  |

Definition at line 60 of file device.hpp.

References DIVISOR.

## updateColorVolume()

void pcl::device::updateColorVolume | ( | const Intr & | intr,
|  | float | tranc_dist,
|  | const Mat33 & | R_inv,
|  | const float3 & | t,
|  | const MapArr & | vmap,
|  | const PtrStepSz< uchar3 > & | colors,
|  | const float3 & | volume_size,
|  | PtrStep< uchar4 > | color_volume,
|  | int | max_weight = `1`
| ) |  |

Performs integration in color volume.

Parameters

  [in] | intr | Depth camera intrionsics structure
  [in] | tranc_dist | tsdf truncation distance
  [in] | R_inv | Inverse camera rotation
  [in] | t | camera translation
  [in] | vmap | Raycasted vertex map
  [in] | colors | RGB colors for current frame
  [in] | volume_size | volume size in meters
  [in] | color_volume | color volume to be integrated
  [in] | max_weight | max weight for running color average. Zero means not average, one means average with prev value, etc.

## valid_host()

bool pcl::device::valid_host | ( | float | value | ) |

inline

Check for qnan (unused now)

Parameters

  [in] | value |

Definition at line 389 of file internal.h.

## warp_reduce()

template<class T >

__device__ __forceinline__ T pcl::device::warp_reduce | ( | volatile T * | ptr,
|  | const unsigned int | tid = `threadIdx.x`
| ) |  |

Definition at line 46 of file warp_reduce.hpp.

## Variable Documentation

## DIVISOR

constexpr int pcl::device::DIVISOR = std::numeric_limits<short>::max()

constexpr

Definition at line 56 of file internal.h.

Referenced by pack_tsdf(), and unpack_tsdf().

## VOLUME_SIZE

constexpr float pcl::device::VOLUME_SIZE = 3.0f

constexpr

Definition at line 64 of file internal.h.

## VOLUME_X

constexpr int pcl::device::VOLUME_X = 512

constexpr

Definition at line 59 of file internal.h.

## VOLUME_Y

constexpr int pcl::device::VOLUME_Y = 512

constexpr

Definition at line 60 of file internal.h.

## VOLUME_Z

constexpr int pcl::device::VOLUME_Z = 512

constexpr

Definition at line 61 of file internal.h.