Loading...
Searching...
No Matches
sac_model_1point_plane.h
/*
* Software License Agreement (BSD License)
*
* Copyright (c) 2009, Willow Garage, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Willow Garage, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Author: Nico Blodow (blodow@cs.tum.edu)
*
* $Id$
*
*/
#pragma once
#include <pcl/cuda/sample_consensus/sac_model.h>
#include <thrust/random.h>
namespace pcl
{
namespace cuda
{
/** \brief Check if a certain tuple is a point inlier. */
struct CountPlanarInlier
{
float4 coefficients;
float threshold;
CountPlanarInlier (float4 coeff, float thresh) :
coefficients(coeff), threshold(thresh)
{}
template <typename Tuple> __inline__ __host__ __device__ bool
operator () (const Tuple &t);
};
/** \brief Check if a certain tuple is a point inlier. */
template <template <typename> class Storage>
struct NewCheckPlanarInlier
{
float4 coefficients;
float threshold;
const typename Storage<PointXYZRGB>::type &input_;
NewCheckPlanarInlier (float4 coeff, float thresh, const typename Storage<PointXYZRGB>::type &input) :
coefficients(coeff), threshold(thresh), input_(input)
{}
__inline__ __host__ __device__ int
operator () (const int &idx);
};
/** \brief Check if a certain tuple is a point inlier. */
struct CheckPlanarInlier
{
float4 coefficients;
float threshold;
CheckPlanarInlier (float4 coeff, float thresh) :
coefficients(coeff), threshold(thresh)
{}
template <typename Tuple> __inline__ __host__ __device__ int
operator () (const Tuple &t);
};
/** \brief Check if a certain tuple is a point inlier. */
struct CheckPlanarInlierIndices
{
float4 coefficients;
float threshold;
CheckPlanarInlierIndices (float4 coeff, float thresh) :
coefficients(coeff), threshold(thresh)
{}
__inline__ __host__ __device__ int
operator () (const PointXYZRGB &pt, const int &idx);
};
/** \brief Check if a certain tuple is a point inlier. */
struct CheckPlanarInlierKinectNormalIndices
{
float4 coefficients;
float threshold;
float angle_threshold;
CheckPlanarInlierKinectNormalIndices (float4 coeff, float thresh, float angle_thresh) :
coefficients(coeff), threshold(thresh), angle_threshold (angle_thresh)
{}
template <typename Tuple> __inline__ __host__ __device__ int
operator () (const Tuple &t, const int &idx);
};
/** \brief Check if a certain tuple is a point inlier. */
struct CheckPlanarInlierKinectIndices
{
float4 coefficients;
float threshold;
float angle_threshold;
CheckPlanarInlierKinectIndices (float4 coeff, float thresh, float angle_thresh) :
coefficients(coeff), threshold(thresh), angle_threshold (angle_thresh)
{}
__inline__ __host__ __device__ int
operator () (const PointXYZRGB &pt, const int &idx);
};
/** \brief Check if a certain tuple is a point inlier. */
struct CheckPlanarInlierNormalIndices
{
float4 coefficients;
float threshold;
float angle_threshold;
CheckPlanarInlierNormalIndices (float4 coeff, float thresh, float angle_thresh) :
coefficients(coeff), threshold(thresh), angle_threshold (angle_thresh)
{}
template <typename Tuple>
__inline__ __host__ __device__ int
operator () (const Tuple &pt, const int &idx);
};
////////////////////////////////////////////////////////////////////////////////////////////
/** \brief @b SampleConsensusModel1PointPlane defines a model for 3D plane segmentation.
*/
template <template <typename> class Storage>
class SampleConsensusModel1PointPlane : public SampleConsensusModel<Storage>
{
public:
using SampleConsensusModel<Storage>::input_;
using SampleConsensusModel<Storage>::normals_;
using SampleConsensusModel<Storage>::indices_;
using SampleConsensusModel<Storage>::indices_stencil_;
using SampleConsensusModel<Storage>::rngl_;
using PointCloud = typename SampleConsensusModel<Storage>::PointCloud;
using PointCloudPtr = typename PointCloud::Ptr;
using PointCloudConstPtr = typename PointCloud::ConstPtr;
using Indices = typename SampleConsensusModel<Storage>::Indices;
using IndicesPtr = typename SampleConsensusModel<Storage>::IndicesPtr;
using IndicesConstPtr = typename SampleConsensusModel<Storage>::IndicesConstPtr;
using Coefficients = typename SampleConsensusModel<Storage>::Coefficients;
using Hypotheses = typename SampleConsensusModel<Storage>::Hypotheses;
using Samples = typename SampleConsensusModel<Storage>::Samples;
using Ptr = shared_ptr<SampleConsensusModel1PointPlane>;
using ConstPtr = shared_ptr<const SampleConsensusModel1PointPlane>;
/** \brief Constructor for base SampleConsensusModel1PointPlane.
* \param cloud the input point cloud dataset
*/
SampleConsensusModel1PointPlane (const PointCloudConstPtr &cloud);
/** \brief Get 3 random non-collinear points as data samples and return them as point indices.
* \param iterations the internal number of iterations used by SAC methods
* \param samples the resultant model samples
* \note assumes unique points!
*/
void
getSamples (int &iterations, Indices &samples);
/** \brief Check whether the given index samples can form a valid plane model, compute the model coefficients from
* these samples and store them in model_coefficients. The plane coefficients are:
* a, b, c, d (ax+by+cz+d=0)
* \param samples the point indices found as possible good candidates for creating a valid model
* \param model_coefficients the resultant model coefficients
*/
bool
computeModelCoefficients (const Indices &samples, Coefficients &model_coefficients);
bool
generateModelHypotheses (Hypotheses &h, int max_iterations);
bool
generateModelHypotheses (Hypotheses &h, Samples &s, int max_iterations);
/** \brief Select all the points which respect the given model coefficients as inliers.
* \param model_coefficients the coefficients of a plane model that we need to
* compute distances to
* \param threshold a maximum admissible distance threshold for determining the
* inliers from the outliers
* \param inliers the resultant model inliers
* \param inliers_stencil
*/
int
selectWithinDistance (const Coefficients &model_coefficients,
float threshold, IndicesPtr &inliers, IndicesPtr &inliers_stencil);
int
selectWithinDistance (const Hypotheses &h, int idx,
float threshold,
IndicesPtr &inliers, IndicesPtr &inliers_stencil);
int
selectWithinDistance (Hypotheses &h, int idx,
float threshold,
IndicesPtr &inliers_stencil,
float3 &centroid);
int
countWithinDistance (const Coefficients &model_coefficients, float threshold);
int
countWithinDistance (const Hypotheses &h, int idx, float threshold);
// private:
// /** \brief Define the maximum number of iterations for collinearity checks */
const static int MAX_ITERATIONS_COLLINEAR = 1000;
};
/** \brief Check if a certain tuple is a point inlier. */
template <template <typename> class Storage>
struct Create1PointPlaneHypothesis
{
using PointCloud = typename SampleConsensusModel<Storage>::PointCloud;
using PointCloudConstPtr = typename PointCloud::ConstPtr;
using Indices = typename SampleConsensusModel<Storage>::Indices;
using IndicesConstPtr = typename SampleConsensusModel<Storage>::IndicesConstPtr;
const PointXYZRGB *input;
const int *indices;
int nr_indices;
float bad_value;
Create1PointPlaneHypothesis (const PointXYZRGB *_input, const int *_indices, int _nr_indices, float bad) :
input(_input), indices(_indices), nr_indices(_nr_indices), bad_value(bad)
{}
//template <typename Tuple>
__inline__ __host__ __device__ float4
//operator () (const Tuple &t);
operator () (int t);
};
/** \brief Check if a certain tuple is a point inlier. */
template <template <typename> class Storage>
struct Create1PointPlaneSampleHypothesis
{
using PointCloud = typename SampleConsensusModel<Storage>::PointCloud;
using PointCloudConstPtr = typename PointCloud::ConstPtr;
using Indices = typename SampleConsensusModel<Storage>::Indices;
using IndicesConstPtr = typename SampleConsensusModel<Storage>::IndicesConstPtr;
const PointXYZRGB *input;
const float4 *normals_;
const int *indices;
int width_;
int height_;
int nr_indices;
float bad_value;
thrust::default_random_engine rng;
Create1PointPlaneSampleHypothesis (const PointXYZRGB *_input, const float4* normals, const int *_indices, int width, int height, int _nr_indices, float bad) :
input(_input), normals_(normals), indices(_indices), width_(width), height_(height), nr_indices(_nr_indices), bad_value(bad)
{
}
//template <typename Tuple>
__inline__ __host__ __device__ thrust::tuple<int,float4>
//operator () (const Tuple &t);
operator () (int t);
};
struct parallel_random_generator
{
__inline__ __host__ __device__
parallel_random_generator(unsigned int seed)
{
m_seed = seed;
}
__inline__ __host__ __device__
unsigned int operator()(const unsigned int n) const
{
thrust::default_random_engine rng(m_seed);
// discard n numbers to avoid correlation
rng.discard(n);
// return a random number
return rng();
}
unsigned int m_seed;
};
} // namespace
} // namespace
pcl::PointCloud::Ptr
shared_ptr< PointCloud< PointT > > Ptr
Definition point_cloud.h:414
pcl::PointCloud::ConstPtr
shared_ptr< const PointCloud< PointT > > ConstPtr
Definition point_cloud.h:415
pcl::cuda::SampleConsensusModel1PointPlane::MAX_ITERATIONS_COLLINEAR
static const int MAX_ITERATIONS_COLLINEAR
Define the maximum number of iterations for collinearity checks.
Definition sac_model_1point_plane.h:238
pcl::cuda::SampleConsensusModel1PointPlane::IndicesConstPtr
typename SampleConsensusModel< Storage >::IndicesConstPtr IndicesConstPtr
Definition sac_model_1point_plane.h:172
pcl::cuda::SampleConsensusModel1PointPlane::getSamples
void getSamples(int &iterations, Indices &samples)
Get 3 random non-collinear points as data samples and return them as point indices.
pcl::cuda::SampleConsensusModel1PointPlane::computeModelCoefficients
bool computeModelCoefficients(const Indices &samples, Coefficients &model_coefficients)
Check whether the given index samples can form a valid plane model, compute the model coefficients fr...
pcl::cuda::SampleConsensusModel1PointPlane::PointCloud
typename SampleConsensusModel< Storage >::PointCloud PointCloud
Definition sac_model_1point_plane.h:166
pcl::cuda::SampleConsensusModel1PointPlane::countWithinDistance
int countWithinDistance(const Coefficients &model_coefficients, float threshold)
pcl::cuda::SampleConsensusModel1PointPlane::IndicesPtr
typename SampleConsensusModel< Storage >::IndicesPtr IndicesPtr
Definition sac_model_1point_plane.h:171
pcl::cuda::SampleConsensusModel1PointPlane::Samples
typename SampleConsensusModel< Storage >::Samples Samples
Definition sac_model_1point_plane.h:176
pcl::cuda::SampleConsensusModel1PointPlane::countWithinDistance
int countWithinDistance(const Hypotheses &h, int idx, float threshold)
pcl::cuda::SampleConsensusModel1PointPlane::generateModelHypotheses
bool generateModelHypotheses(Hypotheses &h, Samples &s, int max_iterations)
pcl::cuda::SampleConsensusModel1PointPlane::Coefficients
typename SampleConsensusModel< Storage >::Coefficients Coefficients
Definition sac_model_1point_plane.h:174
pcl::cuda::SampleConsensusModel1PointPlane::selectWithinDistance
int selectWithinDistance(const Coefficients &model_coefficients, float threshold, IndicesPtr &inliers, IndicesPtr &inliers_stencil)
Select all the points which respect the given model coefficients as inliers.
pcl::cuda::SampleConsensusModel1PointPlane::SampleConsensusModel1PointPlane
SampleConsensusModel1PointPlane(const PointCloudConstPtr &cloud)
Constructor for base SampleConsensusModel1PointPlane.
pcl::cuda::SampleConsensusModel1PointPlane::Ptr
shared_ptr< SampleConsensusModel1PointPlane > Ptr
Definition sac_model_1point_plane.h:179
pcl::cuda::SampleConsensusModel1PointPlane::Hypotheses
typename SampleConsensusModel< Storage >::Hypotheses Hypotheses
Definition sac_model_1point_plane.h:175
pcl::cuda::SampleConsensusModel1PointPlane::Indices
typename SampleConsensusModel< Storage >::Indices Indices
Definition sac_model_1point_plane.h:170
pcl::cuda::SampleConsensusModel1PointPlane::selectWithinDistance
int selectWithinDistance(Hypotheses &h, int idx, float threshold, IndicesPtr &inliers_stencil, float3 &centroid)
pcl::cuda::SampleConsensusModel1PointPlane::ConstPtr
shared_ptr< const SampleConsensusModel1PointPlane > ConstPtr
Definition sac_model_1point_plane.h:180
pcl::cuda::SampleConsensusModel1PointPlane::PointCloudConstPtr
typename PointCloud::ConstPtr PointCloudConstPtr
Definition sac_model_1point_plane.h:168
pcl::cuda::SampleConsensusModel1PointPlane::generateModelHypotheses
bool generateModelHypotheses(Hypotheses &h, int max_iterations)
pcl::cuda::SampleConsensusModel1PointPlane::PointCloudPtr
typename PointCloud::Ptr PointCloudPtr
Definition sac_model_1point_plane.h:167
pcl::cuda::SampleConsensusModel1PointPlane::selectWithinDistance
int selectWithinDistance(const Hypotheses &h, int idx, float threshold, IndicesPtr &inliers, IndicesPtr &inliers_stencil)
pcl::cuda::SampleConsensusModel::indices_stencil_
IndicesPtr indices_stencil_
A pointer to the vector of point indices (stencil) to use.
Definition sac_model.h:359
pcl::cuda::SampleConsensusModel::indices_
IndicesPtr indices_
A pointer to the vector of point indices to use.
Definition sac_model.h:357
pcl::cuda::SampleConsensusModel::Hypotheses
typename Storage< float4 >::type Hypotheses
Definition sac_model.h:105
pcl::cuda::SampleConsensusModel::normals_
shared_ptr< typename Storage< float4 >::type > normals_
Definition sac_model.h:354
pcl::cuda::SampleConsensusModel::IndicesConstPtr
shared_ptr< const typename Storage< int >::type > IndicesConstPtr
Definition sac_model.h:99
pcl::cuda::SampleConsensusModel::rngl_
thrust::minstd_rand rngl_
Linear-Congruent random number generator engine.
Definition sac_model.h:369
pcl::cuda::SampleConsensusModel::PointCloud
PointCloudAOS< Storage > PointCloud
Definition sac_model.h:90
pcl::cuda::SampleConsensusModel::IndicesPtr
shared_ptr< typename Storage< int >::type > IndicesPtr
Definition sac_model.h:98
pcl::cuda::SampleConsensusModel::Coefficients
typename Storage< float >::type Coefficients
Definition sac_model.h:101
pcl::cuda::SampleConsensusModel::Indices
typename Storage< int >::type Indices
Definition sac_model.h:97
pcl::cuda::SampleConsensusModel::input_
PointCloudConstPtr input_
A boost shared pointer to the point cloud data array.
Definition sac_model.h:353
pcl::cuda::SampleConsensusModel::Samples
typename Storage< int >::type Samples
Definition sac_model.h:107
pcl::cuda
Definition eigen.h:100
pcl
Definition convolution.h:46
pcl::cuda::CheckPlanarInlier::CheckPlanarInlier
CheckPlanarInlier(float4 coeff, float thresh)
Definition sac_model_1point_plane.h:85
pcl::cuda::CheckPlanarInlier::coefficients
float4 coefficients
Definition sac_model_1point_plane.h:82
pcl::cuda::CheckPlanarInlier::operator()
__inline__ __host__ __device__ int operator()(const Tuple &t)
pcl::cuda::CheckPlanarInlier::threshold
float threshold
Definition sac_model_1point_plane.h:83
pcl::cuda::CheckPlanarInlierIndices::coefficients
float4 coefficients
Definition sac_model_1point_plane.h:96
pcl::cuda::CheckPlanarInlierIndices::operator()
__inline__ __host__ __device__ int operator()(const PointXYZRGB &pt, const int &idx)
pcl::cuda::CheckPlanarInlierIndices::threshold
float threshold
Definition sac_model_1point_plane.h:97
pcl::cuda::CheckPlanarInlierIndices::CheckPlanarInlierIndices
CheckPlanarInlierIndices(float4 coeff, float thresh)
Definition sac_model_1point_plane.h:99
pcl::cuda::CheckPlanarInlierKinectIndices::coefficients
float4 coefficients
Definition sac_model_1point_plane.h:125
pcl::cuda::CheckPlanarInlierKinectIndices::angle_threshold
float angle_threshold
Definition sac_model_1point_plane.h:127
pcl::cuda::CheckPlanarInlierKinectIndices::CheckPlanarInlierKinectIndices
CheckPlanarInlierKinectIndices(float4 coeff, float thresh, float angle_thresh)
Definition sac_model_1point_plane.h:129
pcl::cuda::CheckPlanarInlierKinectIndices::threshold
float threshold
Definition sac_model_1point_plane.h:126
pcl::cuda::CheckPlanarInlierKinectIndices::operator()
__inline__ __host__ __device__ int operator()(const PointXYZRGB &pt, const int &idx)
pcl::cuda::CheckPlanarInlierKinectNormalIndices::operator()
__inline__ __host__ __device__ int operator()(const Tuple &t, const int &idx)
pcl::cuda::CheckPlanarInlierKinectNormalIndices::CheckPlanarInlierKinectNormalIndices
CheckPlanarInlierKinectNormalIndices(float4 coeff, float thresh, float angle_thresh)
Definition sac_model_1point_plane.h:114
pcl::cuda::CheckPlanarInlierKinectNormalIndices::threshold
float threshold
Definition sac_model_1point_plane.h:111
pcl::cuda::CheckPlanarInlierKinectNormalIndices::angle_threshold
float angle_threshold
Definition sac_model_1point_plane.h:112
pcl::cuda::CheckPlanarInlierKinectNormalIndices::coefficients
float4 coefficients
Definition sac_model_1point_plane.h:110
pcl::cuda::CheckPlanarInlierNormalIndices::angle_threshold
float angle_threshold
Definition sac_model_1point_plane.h:142
pcl::cuda::CheckPlanarInlierNormalIndices::threshold
float threshold
Definition sac_model_1point_plane.h:141
pcl::cuda::CheckPlanarInlierNormalIndices::coefficients
float4 coefficients
Definition sac_model_1point_plane.h:140
pcl::cuda::CheckPlanarInlierNormalIndices::operator()
__inline__ __host__ __device__ int operator()(const Tuple &pt, const int &idx)
pcl::cuda::CheckPlanarInlierNormalIndices::CheckPlanarInlierNormalIndices
CheckPlanarInlierNormalIndices(float4 coeff, float thresh, float angle_thresh)
Definition sac_model_1point_plane.h:144
pcl::cuda::CountPlanarInlier::operator()
__inline__ __host__ __device__ bool operator()(const Tuple &t)
pcl::cuda::CountPlanarInlier::CountPlanarInlier
CountPlanarInlier(float4 coeff, float thresh)
Definition sac_model_1point_plane.h:55
pcl::cuda::CountPlanarInlier::threshold
float threshold
Definition sac_model_1point_plane.h:53
pcl::cuda::CountPlanarInlier::coefficients
float4 coefficients
Definition sac_model_1point_plane.h:52
pcl::cuda::Create1PointPlaneHypothesis::PointCloudConstPtr
typename PointCloud::ConstPtr PointCloudConstPtr
Definition sac_model_1point_plane.h:246
pcl::cuda::Create1PointPlaneHypothesis::PointCloud
typename SampleConsensusModel< Storage >::PointCloud PointCloud
Definition sac_model_1point_plane.h:245
pcl::cuda::Create1PointPlaneHypothesis::Create1PointPlaneHypothesis
Create1PointPlaneHypothesis(const PointXYZRGB *_input, const int *_indices, int _nr_indices, float bad)
Definition sac_model_1point_plane.h:255
pcl::cuda::Create1PointPlaneHypothesis::indices
const int * indices
Definition sac_model_1point_plane.h:251
pcl::cuda::Create1PointPlaneHypothesis::bad_value
float bad_value
Definition sac_model_1point_plane.h:253
pcl::cuda::Create1PointPlaneHypothesis::operator()
__inline__ __host__ __device__ float4 operator()(int t)
pcl::cuda::Create1PointPlaneHypothesis::input
const PointXYZRGB * input
Definition sac_model_1point_plane.h:250
pcl::cuda::Create1PointPlaneHypothesis::nr_indices
int nr_indices
Definition sac_model_1point_plane.h:252
pcl::cuda::Create1PointPlaneHypothesis::IndicesConstPtr
typename SampleConsensusModel< Storage >::IndicesConstPtr IndicesConstPtr
Definition sac_model_1point_plane.h:248
pcl::cuda::Create1PointPlaneHypothesis::Indices
typename SampleConsensusModel< Storage >::Indices Indices
Definition sac_model_1point_plane.h:247
pcl::cuda::Create1PointPlaneSampleHypothesis::Create1PointPlaneSampleHypothesis
Create1PointPlaneSampleHypothesis(const PointXYZRGB *_input, const float4 *normals, const int *_indices, int width, int height, int _nr_indices, float bad)
Definition sac_model_1point_plane.h:283
pcl::cuda::Create1PointPlaneSampleHypothesis::bad_value
float bad_value
Definition sac_model_1point_plane.h:280
pcl::cuda::Create1PointPlaneSampleHypothesis::input
const PointXYZRGB * input
Definition sac_model_1point_plane.h:274
pcl::cuda::Create1PointPlaneSampleHypothesis::nr_indices
int nr_indices
Definition sac_model_1point_plane.h:279
pcl::cuda::Create1PointPlaneSampleHypothesis::indices
const int * indices
Definition sac_model_1point_plane.h:276
pcl::cuda::Create1PointPlaneSampleHypothesis::normals_
const float4 * normals_
Definition sac_model_1point_plane.h:275
pcl::cuda::Create1PointPlaneSampleHypothesis::operator()
__inline__ __host__ __device__ thrust::tuple< int, float4 > operator()(int t)
pcl::cuda::Create1PointPlaneSampleHypothesis::Indices
typename SampleConsensusModel< Storage >::Indices Indices
Definition sac_model_1point_plane.h:271
pcl::cuda::Create1PointPlaneSampleHypothesis::IndicesConstPtr
typename SampleConsensusModel< Storage >::IndicesConstPtr IndicesConstPtr
Definition sac_model_1point_plane.h:272
pcl::cuda::Create1PointPlaneSampleHypothesis::height_
int height_
Definition sac_model_1point_plane.h:278
pcl::cuda::Create1PointPlaneSampleHypothesis::PointCloud
typename SampleConsensusModel< Storage >::PointCloud PointCloud
Definition sac_model_1point_plane.h:269
pcl::cuda::Create1PointPlaneSampleHypothesis::rng
thrust::default_random_engine rng
Definition sac_model_1point_plane.h:281
pcl::cuda::Create1PointPlaneSampleHypothesis::PointCloudConstPtr
typename PointCloud::ConstPtr PointCloudConstPtr
Definition sac_model_1point_plane.h:270
pcl::cuda::Create1PointPlaneSampleHypothesis::width_
int width_
Definition sac_model_1point_plane.h:277
pcl::cuda::NewCheckPlanarInlier::input_
const Storage< PointXYZRGB >::type & input_
Definition sac_model_1point_plane.h:69
pcl::cuda::NewCheckPlanarInlier::operator()
__inline__ __host__ __device__ int operator()(const int &idx)
pcl::cuda::NewCheckPlanarInlier::NewCheckPlanarInlier
NewCheckPlanarInlier(float4 coeff, float thresh, const typename Storage< PointXYZRGB >::type &input)
Definition sac_model_1point_plane.h:71
pcl::cuda::NewCheckPlanarInlier::coefficients
float4 coefficients
Definition sac_model_1point_plane.h:67
pcl::cuda::NewCheckPlanarInlier::threshold
float threshold
Definition sac_model_1point_plane.h:68
pcl::cuda::PointXYZRGB
Default point xyz-rgb structure.
Definition point_types.h:49
pcl::cuda::parallel_random_generator::m_seed
unsigned int m_seed
Definition sac_model_1point_plane.h:312
pcl::cuda::parallel_random_generator::parallel_random_generator
__inline__ __host__ __device__ parallel_random_generator(unsigned int seed)
Definition sac_model_1point_plane.h:298
pcl::cuda::parallel_random_generator::operator()
__inline__ __host__ __device__ unsigned int operator()(const unsigned int n) const
Definition sac_model_1point_plane.h:304