Point Cloud Library (PCL)  1.14.1
fast_bilateral.h
1 /*
2  * Software License Agreement (BSD License)
3  *
4  * Point Cloud Library (PCL) - www.pointclouds.org
5  * Copyright (c) 2012-, Open Perception, Inc.
6  * Copyright (c) 2004, Sylvain Paris and Francois Sillion
7 
8  * All rights reserved.
9 
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  *
14  * * Redistributions of source code must retain the above copyright
15  * notice, this list of conditions and the following disclaimer.
16  * * Redistributions in binary form must reproduce the above
17  * copyright notice, this list of conditions and the following
18  * disclaimer in the documentation and/or other materials provided
19  * with the distribution.
20  * * Neither the name of the copyright holder(s) nor the names of its
21  * contributors may be used to endorse or promote products derived
22  * from this software without specific prior written permission.
23  *
24  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
25  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
26  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
27  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
28  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
29  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
30  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
31  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
32  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
33  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
34  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
35  * POSSIBILITY OF SUCH DAMAGE.
36  *
37  * $Id$
38  *
39  */
40 
41 #pragma once
42 
43 #include <pcl/filters/filter.h>
44 
45 namespace pcl
46 {
47  /** \brief Implementation of a fast bilateral filter for smoothing depth information in organized point clouds
48  * Based on the following paper:
49  * * Sylvain Paris and Fredo Durand
50  * "A Fast Approximation of the Bilateral Filter using a Signal Processing Approach"
51  * European Conference on Computer Vision (ECCV'06)
52  *
53  * More details on the webpage: http://people.csail.mit.edu/sparis/bf/
54  */
55  template<typename PointT>
56  class FastBilateralFilter : public Filter<PointT>
57  {
58  protected:
61 
62  public:
63 
64  using Ptr = shared_ptr<FastBilateralFilter<PointT> >;
65  using ConstPtr = shared_ptr<const FastBilateralFilter<PointT> >;
66 
67  /** \brief Empty constructor. */
68  FastBilateralFilter () = default;
69 
70  /** \brief Empty destructor */
71  ~FastBilateralFilter () override = default;
72 
73  /** \brief Set the standard deviation of the Gaussian used by the bilateral filter for
74  * the spatial neighborhood/window.
75  * \param[in] sigma_s the size of the Gaussian bilateral filter window to use
76  */
77  inline void
78  setSigmaS (float sigma_s)
79  { sigma_s_ = sigma_s; }
80 
81  /** \brief Get the size of the Gaussian bilateral filter window as set by the user. */
82  inline float
83  getSigmaS () const
84  { return sigma_s_; }
85 
86 
87  /** \brief Set the standard deviation of the Gaussian used to control how much an adjacent
88  * pixel is downweighted because of the intensity difference (depth in our case).
89  * \param[in] sigma_r the standard deviation of the Gaussian for the intensity difference
90  */
91  inline void
92  setSigmaR (float sigma_r)
93  { sigma_r_ = sigma_r; }
94 
95  /** \brief Get the standard deviation of the Gaussian for the intensity difference */
96  inline float
97  getSigmaR () const
98  { return sigma_r_; }
99 
100  /** \brief Filter the input data and store the results into output.
101  * \param[out] output the resultant point cloud
102  */
103  void
104  applyFilter (PointCloud &output) override;
105 
106  protected:
107  float sigma_s_{15.0f};
108  float sigma_r_{0.05f};
109  bool early_division_{false};
110 
111  class Array3D
112  {
113  public:
114  Array3D (const std::size_t width, const std::size_t height, const std::size_t depth)
115  : v_({(width*height*depth), Eigen::Vector2f (0.0f, 0.0f), Eigen::aligned_allocator<Eigen::Vector2f>()})
116  {
117  x_dim_ = width;
118  y_dim_ = height;
119  z_dim_ = depth;
120  }
121 
122  inline Eigen::Vector2f&
123  operator () (const std::size_t x, const std::size_t y, const std::size_t z)
124  { return v_[(x * y_dim_ + y) * z_dim_ + z]; }
125 
126  inline const Eigen::Vector2f&
127  operator () (const std::size_t x, const std::size_t y, const std::size_t z) const
128  { return v_[(x * y_dim_ + y) * z_dim_ + z]; }
129 
130  inline void
131  resize (const std::size_t width, const std::size_t height, const std::size_t depth)
132  {
133  x_dim_ = width;
134  y_dim_ = height;
135  z_dim_ = depth;
136  v_.resize (x_dim_ * y_dim_ * z_dim_);
137  }
138 
139  Eigen::Vector2f
140  trilinear_interpolation (const float x,
141  const float y,
142  const float z);
143 
144  static inline std::size_t
145  clamp (const std::size_t min_value,
146  const std::size_t max_value,
147  const std::size_t x);
148 
149  inline std::size_t
150  x_size () const
151  { return x_dim_; }
152 
153  inline std::size_t
154  y_size () const
155  { return y_dim_; }
156 
157  inline std::size_t
158  z_size () const
159  { return z_dim_; }
160 
161  inline std::vector<Eigen::Vector2f, Eigen::aligned_allocator<Eigen::Vector2f> >::iterator
162  begin ()
163  { return v_.begin (); }
164 
165  inline std::vector<Eigen::Vector2f, Eigen::aligned_allocator<Eigen::Vector2f> >::iterator
166  end ()
167  { return v_.end (); }
168 
169  inline std::vector<Eigen::Vector2f, Eigen::aligned_allocator<Eigen::Vector2f> >::const_iterator
170  begin () const
171  { return v_.begin (); }
172 
173  inline std::vector<Eigen::Vector2f, Eigen::aligned_allocator<Eigen::Vector2f> >::const_iterator
174  end () const
175  { return v_.end (); }
176 
177  private:
178  std::vector<Eigen::Vector2f, Eigen::aligned_allocator<Eigen::Vector2f> > v_;
179  std::size_t x_dim_, y_dim_, z_dim_;
180  };
181 
182 
183  };
184 }
185 
186 #ifdef PCL_NO_PRECOMPILE
187 #include <pcl/filters/impl/fast_bilateral.hpp>
188 #else
189 #define PCL_INSTANTIATE_FastBilateralFilter(T) template class PCL_EXPORTS pcl::FastBilateralFilter<T>;
190 #endif
Eigen::Vector2f trilinear_interpolation(const float x, const float y, const float z)
shared_ptr< const FastBilateralFilter< PointT > > ConstPtr
float getSigmaR() const
Get the standard deviation of the Gaussian for the intensity difference.
std::vector< Eigen::Vector2f, Eigen::aligned_allocator< Eigen::Vector2f > >::iterator end()
Filter represents the base filter class.
Definition: filter.h:80
FastBilateralFilter()=default
Empty constructor.
Eigen::Vector2f & operator()(const std::size_t x, const std::size_t y, const std::size_t z)
void setSigmaS(float sigma_s)
Set the standard deviation of the Gaussian used by the bilateral filter for the spatial neighborhood/...
PointCloud represents the base class in PCL for storing collections of 3D points. ...
Definition: distances.h:55
float getSigmaS() const
Get the size of the Gaussian bilateral filter window as set by the user.
std::vector< Eigen::Vector2f, Eigen::aligned_allocator< Eigen::Vector2f > >::const_iterator end() const
Array3D(const std::size_t width, const std::size_t height, const std::size_t depth)
std::vector< Eigen::Vector2f, Eigen::aligned_allocator< Eigen::Vector2f > >::iterator begin()
Implementation of a fast bilateral filter for smoothing depth information in organized point clouds B...
shared_ptr< FastBilateralFilter< PointT > > Ptr
void resize(const std::size_t width, const std::size_t height, const std::size_t depth)
void setSigmaR(float sigma_r)
Set the standard deviation of the Gaussian used to control how much an adjacent pixel is downweighted...
~FastBilateralFilter() override=default
Empty destructor.
void applyFilter(PointCloud &output) override
Filter the input data and store the results into output.
static std::size_t clamp(const std::size_t min_value, const std::size_t max_value, const std::size_t x)
std::vector< Eigen::Vector2f, Eigen::aligned_allocator< Eigen::Vector2f > >::const_iterator begin() const