Point Cloud Library (PCL)  1.14.1-dev
uniform_sampling.h
1 /*
2  * Software License Agreement (BSD License)
3  *
4  * Point Cloud Library (PCL) - www.pointclouds.org
5  * Copyright (c) 2010-2011, Willow Garage, Inc.
6  *
7  * All rights reserved.
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  *
13  * * Redistributions of source code must retain the above copyright
14  * notice, this list of conditions and the following disclaimer.
15  * * Redistributions in binary form must reproduce the above
16  * copyright notice, this list of conditions and the following
17  * disclaimer in the documentation and/or other materials provided
18  * with the distribution.
19  * * Neither the name of Willow Garage, Inc. nor the names of its
20  * contributors may be used to endorse or promote products derived
21  * from this software without specific prior written permission.
22  *
23  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
24  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
25  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
26  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
27  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
28  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
29  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
30  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
31  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
33  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
34  * POSSIBILITY OF SUCH DAMAGE.
35  *
36  * $Id$
37  *
38  */
39 
40 #pragma once
41 
42 #include <pcl/filters/filter_indices.h>
43 
44 #include <unordered_map>
45 
46 namespace pcl
47 {
48  /** \brief @b UniformSampling assembles a local 3D grid over a given PointCloud, and downsamples + filters the data.
49  *
50  * The @b UniformSampling class creates a *3D voxel grid* (think about a voxel
51  * grid as a set of tiny 3D boxes in space) over the input point cloud data.
52  * Then, in each *voxel* (i.e., 3D box), all the points present will be
53  * approximated (i.e., *downsampled*) with the closest point to the center of the voxel.
54  *
55  * \sa VoxelGrid
56  * \author Radu Bogdan Rusu
57  * \ingroup filters
58  */
59  template <typename PointT>
60  class UniformSampling: public FilterIndices<PointT>
61  {
63 
65 
72 
73  public:
74  using Ptr = shared_ptr<UniformSampling<PointT> >;
75  using ConstPtr = shared_ptr<const UniformSampling<PointT> >;
76 
78 
79  /** \brief Empty constructor. */
80  UniformSampling (bool extract_removed_indices = false) :
81  FilterIndices<PointT>(extract_removed_indices),
82  leaves_ (),
83  leaf_size_ (Eigen::Vector4f::Zero ()),
84  inverse_leaf_size_ (Eigen::Vector4f::Zero ()),
85  min_b_ (Eigen::Vector4i::Zero ()),
86  max_b_ (Eigen::Vector4i::Zero ()),
87  div_b_ (Eigen::Vector4i::Zero ()),
88  divb_mul_ (Eigen::Vector4i::Zero ())
89  {
90  filter_name_ = "UniformSampling";
91  }
92 
93  /** \brief Destructor. */
94  ~UniformSampling () override
95  {
96  leaves_.clear();
97  }
98 
99  /** \brief Set the 3D grid leaf size.
100  * \param radius the 3D grid leaf size
101  */
102  virtual inline void
103  setRadiusSearch (double radius)
104  {
105  leaf_size_[0] = leaf_size_[1] = leaf_size_[2] = static_cast<float> (radius);
106  // Avoid division errors
107  if (leaf_size_[3] == 0)
108  leaf_size_[3] = 1;
109  // Use multiplications instead of divisions
110  inverse_leaf_size_ = Eigen::Array4f::Ones () / leaf_size_.array ();
111  search_radius_ = radius;
112  }
113 
114  /** \brief Set the minimum number of points required for a voxel to be used.
115  * \param[in] min_points_per_voxel the minimum number of points for required for a voxel to be used
116  */
117  inline void
118  setMinimumPointsNumberPerVoxel (unsigned int min_points_per_voxel) { min_points_per_voxel_ = min_points_per_voxel; }
119 
120  /** \brief Return the minimum number of points required for a voxel to be used.
121  */
122  inline unsigned int
124 
125 
126  protected:
127  /** \brief Simple structure to hold an nD centroid and the number of points in a leaf. */
128  struct Leaf
129  {
130  Leaf () = default;
131  int idx{-1};
132  unsigned int count{0};
133  };
134 
135  /** \brief The 3D grid leaves. */
136  std::unordered_map<std::size_t, Leaf> leaves_;
137 
138  /** \brief The size of a leaf. */
139  Eigen::Vector4f leaf_size_;
140 
141  /** \brief Internal leaf sizes stored as 1/leaf_size_ for efficiency reasons. */
142  Eigen::Array4f inverse_leaf_size_;
143 
144  /** \brief The minimum and maximum bin coordinates, the number of divisions, and the division multiplier. */
145  Eigen::Vector4i min_b_, max_b_, div_b_, divb_mul_;
146 
147  /** \brief The nearest neighbors search radius for each point. */
148  double search_radius_{0.0};
149 
150  /** \brief Minimum number of points per voxel. */
151  unsigned int min_points_per_voxel_{0};
152 
153  /** \brief Filtered results are indexed by an indices array.
154  * \param[out] indices The resultant indices.
155  */
156  void
157  applyFilter (Indices &indices) override;
158  };
159 }
160 
161 #ifdef PCL_NO_PRECOMPILE
162 #include <pcl/filters/impl/uniform_sampling.hpp>
163 #endif
Filter represents the base filter class.
Definition: filter.h:81
shared_ptr< Filter< PointT > > Ptr
Definition: filter.h:83
shared_ptr< const Filter< PointT > > ConstPtr
Definition: filter.h:84
std::string filter_name_
The filter name.
Definition: filter.h:158
FilterIndices represents the base class for filters that are about binary point removal.
PointCloud represents the base class in PCL for storing collections of 3D points.
Definition: point_cloud.h:173
UniformSampling assembles a local 3D grid over a given PointCloud, and downsamples + filters the data...
Eigen::Vector4i min_b_
The minimum and maximum bin coordinates, the number of divisions, and the division multiplier.
~UniformSampling() override
Destructor.
void applyFilter(Indices &indices) override
Filtered results are indexed by an indices array.
Eigen::Vector4f leaf_size_
The size of a leaf.
Eigen::Array4f inverse_leaf_size_
Internal leaf sizes stored as 1/leaf_size_ for efficiency reasons.
PCL_MAKE_ALIGNED_OPERATOR_NEW UniformSampling(bool extract_removed_indices=false)
Empty constructor.
double search_radius_
The nearest neighbors search radius for each point.
unsigned int min_points_per_voxel_
Minimum number of points per voxel.
unsigned int getMinimumPointsNumberPerVoxel() const
Return the minimum number of points required for a voxel to be used.
void setMinimumPointsNumberPerVoxel(unsigned int min_points_per_voxel)
Set the minimum number of points required for a voxel to be used.
std::unordered_map< std::size_t, Leaf > leaves_
The 3D grid leaves.
Eigen::Vector4i divb_mul_
virtual void setRadiusSearch(double radius)
Set the 3D grid leaf size.
Eigen::Vector4i div_b_
Eigen::Vector4i max_b_
#define PCL_MAKE_ALIGNED_OPERATOR_NEW
Macro to signal a class requires a custom allocator.
Definition: memory.h:63
Definition: bfgs.h:10
IndicesAllocator<> Indices
Type used for indices in PCL.
Definition: types.h:133
A point structure representing Euclidean xyz coordinates, and the RGB color.
Simple structure to hold an nD centroid and the number of points in a leaf.