Point Cloud Library (PCL)  1.9.1-dev
point_cloud_image_extractors.h
1 /*
2  * Software License Agreement (BSD License)
3  *
4  * Point Cloud Library (PCL) - www.pointclouds.org
5  * Copyright (c) 2013-, Open Perception, 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 the copyright holder(s) 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  */
37 
38 #pragma once
39 
40 #include <pcl/point_cloud.h>
41 #include <pcl/PCLImage.h>
42 
43 namespace pcl
44 {
45  namespace io
46  {
47  //////////////////////////////////////////////////////////////////////////////////////
48  /** \brief Base Image Extractor class for organized point clouds.
49  *
50  * This is an abstract class that declares an interface for image extraction from
51  * organized point clouds. The family of its subclasses provide functionality to
52  * extract images from particular fields.
53  *
54  * The following piece of code demonstrates typical usage of a PointCloudImageExtractor
55  * subclass. Here the data are extracted from the "label" field and are saved as a
56  * PNG image file.
57  *
58  * \code
59  * // Source point cloud (needs to be filled with data of course)
60  * pcl::PointCloud<pcl::PointXYZLabel> cloud;
61  * // Target image
62  * pcl::PCLImage image;
63  * // Create PointCloudImageExtractor subclass that can handle "label" field
64  * pcl::io::PointCloudImageExtractorFromLabelField<pcl::XYZLabel> pcie;
65  * // Set it up if not happy with the defaults
66  * pcie.setColorMode(pcie.COLORS_RGB_RANDOM);
67  * // Try to extract an image
68  * bool success = pcie.extract(cloud, image);
69  * // Save to file if succeeded
70  * if (success)
71  * pcl::io::saveImage ("filename.png", image);
72  * \endcode
73  *
74  * \author Sergey Alexandrov
75  * \ingroup io
76  */
77  template <typename PointT>
79  {
80  public:
82 
83  using Ptr = boost::shared_ptr<PointCloudImageExtractor<PointT> >;
84  using ConstPtr = boost::shared_ptr<const PointCloudImageExtractor<PointT> >;
85 
86  /** \brief Constructor. */
88  : paint_nans_with_black_ (false)
89  {}
90 
91  /** \brief Destructor. */
93 
94  /** \brief Obtain the image from the given cloud.
95  * \param[in] cloud organized point cloud to extract image from
96  * \param[out] image the output image
97  * \return true if the operation was successful, false otherwise
98  */
99  bool
100  extract (const PointCloud& cloud, pcl::PCLImage& image) const;
101 
102  /** \brief Set a flag that controls if image pixels corresponding to
103  * NaN (infinite) points should be painted black.
104  */
105  inline void
107  {
108  paint_nans_with_black_ = flag;
109  }
110 
111  protected:
112 
113  /** \brief Implementation of the extract() function, has to be
114  * implemented in deriving classes.
115  */
116  virtual bool
117  extractImpl (const PointCloud& cloud, pcl::PCLImage& image) const = 0;
118 
119  /// A flag that controls if image pixels corresponding to NaN (infinite)
120  /// points should be painted black.
122  };
123 
124  //////////////////////////////////////////////////////////////////////////////////////
125  /** \brief Image Extractor extension which provides functionality to apply scaling to
126  * the values extracted from a field.
127  * \author Sergey Alexandrov
128  * \ingroup io
129  */
130  template <typename PointT>
132  {
134 
135  public:
136  using Ptr = boost::shared_ptr<PointCloudImageExtractorWithScaling<PointT> >;
137  using ConstPtr = boost::shared_ptr<const PointCloudImageExtractorWithScaling<PointT> >;
138 
139  /** \brief Different scaling methods.
140  * <ul>
141  * <li><b>SCALING_NO</b> - no scaling.</li>
142  * <li><b>SCALING_FULL_RANGE</b> - scales to full range of the output value.</li>
143  * <li><b>SCASING_FIXED_FACTOR</b> - scales by a given fixed factor.</li>
144  * </ul>
145  */
147  {
150  SCALING_FIXED_FACTOR
151  };
152 
153  /** \brief Constructor. */
154  PointCloudImageExtractorWithScaling (const std::string& field_name, const ScalingMethod scaling_method)
155  : field_name_ (field_name)
156  , scaling_method_ (scaling_method)
157  , scaling_factor_ (1.0f)
158  {
159  }
160 
161  /** \brief Constructor. */
162  PointCloudImageExtractorWithScaling (const std::string& field_name, const float scaling_factor)
163  : field_name_ (field_name)
164  , scaling_method_ (SCALING_FIXED_FACTOR)
165  , scaling_factor_ (scaling_factor)
166  {
167  }
168 
169  /** \brief Destructor. */
171 
172  /** \brief Set scaling method. */
173  inline void
174  setScalingMethod (const ScalingMethod scaling_method)
175  {
176  scaling_method_ = scaling_method;
177  }
178 
179  /** \brief Set fixed scaling factor. */
180  inline void
181  setScalingFactor (const float scaling_factor)
182  {
183  scaling_factor_ = scaling_factor;
184  }
185 
186  protected:
187 
188  bool
189  extractImpl (const PointCloud& cloud, pcl::PCLImage& image) const override;
190 
191  std::string field_name_;
194  };
195 
196  //////////////////////////////////////////////////////////////////////////////////////
197  /** \brief Image Extractor which uses the data present in the "normal" field. Normal
198  * vector components (x, y, z) are mapped to color channels (r, g, b respectively).
199  * \author Sergey Alexandrov
200  * \ingroup io
201  */
202  template <typename PointT>
204  {
206 
207  public:
208  using Ptr = boost::shared_ptr<PointCloudImageExtractorFromNormalField<PointT> >;
209  using ConstPtr = boost::shared_ptr<const PointCloudImageExtractorFromNormalField<PointT> >;
210 
211  /** \brief Constructor. */
213 
214  /** \brief Destructor. */
216 
217  protected:
218 
219  bool
220  extractImpl (const PointCloud& cloud, pcl::PCLImage& img) const override;
221  };
222 
223  //////////////////////////////////////////////////////////////////////////////////////
224  /** \brief Image Extractor which uses the data present in the "rgb" or "rgba" fields
225  * to produce a color image with rgb8 encoding.
226  * \author Sergey Alexandrov
227  * \ingroup io
228  */
229  template <typename PointT>
231  {
233 
234  public:
235  using Ptr = boost::shared_ptr<PointCloudImageExtractorFromRGBField<PointT> >;
236  using ConstPtr = boost::shared_ptr<const PointCloudImageExtractorFromRGBField<PointT> >;
237 
238  /** \brief Constructor. */
240 
241  /** \brief Destructor. */
243 
244  protected:
245 
246  bool
247  extractImpl (const PointCloud& cloud, pcl::PCLImage& img) const override;
248  };
249 
250  //////////////////////////////////////////////////////////////////////////////////////
251  /** \brief Image Extractor which uses the data present in the "label" field to produce
252  * either monochrome or RGB image where different labels correspond to different
253  * colors.
254  * See the documentation for ColorMode to learn about available coloring options.
255  * \author Sergey Alexandrov
256  * \ingroup io
257  */
258  template <typename PointT>
260  {
262 
263  public:
264  using Ptr = boost::shared_ptr<PointCloudImageExtractorFromLabelField<PointT> >;
265  using ConstPtr = boost::shared_ptr<const PointCloudImageExtractorFromLabelField<PointT> >;
266 
267  /** \brief Different modes for color mapping. */
269  {
270  /// Shades of gray (according to label id)
271  /// \note Labels using more than 16 bits will cause problems
273  /// Randomly generated RGB colors
275  /// Fixed RGB colors from the [Glasbey lookup table](http://fiji.sc/Glasbey),
276  /// assigned in the ascending order of label id
278  };
279 
280  /** \brief Constructor. */
281  PointCloudImageExtractorFromLabelField (const ColorMode color_mode = COLORS_MONO)
282  : color_mode_ (color_mode)
283  {
284  }
285 
286  /** \brief Destructor. */
288 
289  /** \brief Set color mapping mode. */
290  inline void
291  setColorMode (const ColorMode color_mode)
292  {
293  color_mode_ = color_mode;
294  }
295 
296  protected:
297 
298  bool
299  extractImpl (const PointCloud& cloud, pcl::PCLImage& img) const override;
300 
301  // Members derived from the base class
303 
304  private:
305 
306  ColorMode color_mode_;
307  };
308 
309  //////////////////////////////////////////////////////////////////////////////////////
310  /** \brief Image Extractor which uses the data present in the "z" field to produce a
311  * depth map (as a monochrome image with mono16 encoding).
312  * \author Sergey Alexandrov
313  * \ingroup io
314  */
315  template <typename PointT>
317  {
320 
321  public:
322  using Ptr = boost::shared_ptr<PointCloudImageExtractorFromZField<PointT> >;
323  using ConstPtr = boost::shared_ptr<const PointCloudImageExtractorFromZField<PointT> >;
324 
325  /** \brief Constructor.
326  * \param[in] scaling_factor a scaling factor to apply to each depth value (default 10000)
327  */
328  PointCloudImageExtractorFromZField (const float scaling_factor = 10000)
329  : PointCloudImageExtractorWithScaling<PointT> ("z", scaling_factor)
330  {
331  }
332 
333  /** \brief Constructor.
334  * \param[in] scaling_method a scaling method to use
335  */
337  : PointCloudImageExtractorWithScaling<PointT> ("z", scaling_method)
338  {
339  }
340 
341  /** \brief Destructor. */
343 
344  protected:
345  // Members derived from the base class
349  };
350 
351  //////////////////////////////////////////////////////////////////////////////////////
352  /** \brief Image Extractor which uses the data present in the "curvature" field to
353  * produce a curvature map (as a monochrome image with mono16 encoding).
354  * \author Sergey Alexandrov
355  * \ingroup io
356  */
357  template <typename PointT>
359  {
362 
363  public:
364  using Ptr = boost::shared_ptr<PointCloudImageExtractorFromCurvatureField<PointT> >;
365  using ConstPtr = boost::shared_ptr<const PointCloudImageExtractorFromCurvatureField<PointT> >;
366 
367  /** \brief Constructor.
368  * \param[in] scaling_method a scaling method to use (default SCALING_FULL_RANGE)
369  */
371  : PointCloudImageExtractorWithScaling<PointT> ("curvature", scaling_method)
372  {
373  }
374 
375  /** \brief Constructor.
376  * \param[in] scaling_factor a scaling factor to apply to each curvature value
377  */
378  PointCloudImageExtractorFromCurvatureField (const float scaling_factor)
379  : PointCloudImageExtractorWithScaling<PointT> ("curvature", scaling_factor)
380  {
381  }
382 
383  /** \brief Destructor. */
385 
386  protected:
387  // Members derived from the base class
391  };
392 
393  //////////////////////////////////////////////////////////////////////////////////////
394  /** \brief Image Extractor which uses the data present in the "intensity" field to produce a
395  * monochrome intensity image (with mono16 encoding).
396  * \author Sergey Alexandrov
397  * \ingroup io
398  */
399  template <typename PointT>
401  {
404 
405  public:
406  using Ptr = boost::shared_ptr<PointCloudImageExtractorFromIntensityField<PointT> >;
407  using ConstPtr = boost::shared_ptr<const PointCloudImageExtractorFromIntensityField<PointT> >;
408 
409  /** \brief Constructor.
410  * \param[in] scaling_method a scaling method to use (default SCALING_NO)
411  */
413  : PointCloudImageExtractorWithScaling<PointT> ("intensity", scaling_method)
414  {
415  }
416 
417  /** \brief Constructor.
418  * \param[in] scaling_factor a scaling factor to apply to each intensity value
419  */
420  PointCloudImageExtractorFromIntensityField (const float scaling_factor)
421  : PointCloudImageExtractorWithScaling<PointT> ("intensity", scaling_factor)
422  {
423  }
424 
425  /** \brief Destructor. */
427 
428  protected:
429  // Members derived from the base class
433  };
434 
435  }
436 }
437 
438 #include <pcl/io/impl/point_cloud_image_extractors.hpp>
Image Extractor which uses the data present in the "curvature" field to produce a curvature map (as a...
boost::shared_ptr< PointCloudImageExtractor< PointT > > Ptr
void setScalingMethod(const ScalingMethod scaling_method)
Set scaling method.
PointCloudImageExtractorFromIntensityField(const float scaling_factor)
Constructor.
This file defines compatibility wrappers for low level I/O functions.
Definition: convolution.h:45
boost::shared_ptr< const PointCloudImageExtractor< PointT > > ConstPtr
PointCloudImageExtractorFromCurvatureField(const float scaling_factor)
Constructor.
Image Extractor extension which provides functionality to apply scaling to the values extracted from ...
PointCloudImageExtractorFromLabelField(const ColorMode color_mode=COLORS_MONO)
Constructor.
Image Extractor which uses the data present in the "rgb" or "rgba" fields to produce a color image wi...
Fixed RGB colors from the Glasbey lookup table, assigned in the ascending order of label id...
bool extract(const PointCloud &cloud, pcl::PCLImage &image) const
Obtain the image from the given cloud.
PointCloudImageExtractorWithScaling(const std::string &field_name, const float scaling_factor)
Constructor.
Image Extractor which uses the data present in the "normal" field.
PointCloudImageExtractorFromIntensityField(const ScalingMethod scaling_method=PointCloudImageExtractorWithScaling< PointT >::SCALING_NO)
Constructor.
void setPaintNaNsWithBlack(bool flag)
Set a flag that controls if image pixels corresponding to NaN (infinite) points should be painted bla...
PointCloudImageExtractorFromZField(const float scaling_factor=10000)
Constructor.
PointCloudImageExtractorFromCurvatureField(const ScalingMethod scaling_method=PointCloudImageExtractorWithScaling< PointT >::SCALING_FULL_RANGE)
Constructor.
PointCloud represents the base class in PCL for storing collections of 3D points. ...
Image Extractor which uses the data present in the "intensity" field to produce a monochrome intensit...
void setColorMode(const ColorMode color_mode)
Set color mapping mode.
PointCloudImageExtractorWithScaling(const std::string &field_name, const ScalingMethod scaling_method)
Constructor.
void setScalingFactor(const float scaling_factor)
Set fixed scaling factor.
A point structure representing Euclidean xyz coordinates, and the RGB color.
PointCloudImageExtractorFromZField(const ScalingMethod scaling_method)
Constructor.
virtual bool extractImpl(const PointCloud &cloud, pcl::PCLImage &image) const =0
Implementation of the extract() function, has to be implemented in deriving classes.
bool paint_nans_with_black_
A flag that controls if image pixels corresponding to NaN (infinite) points should be painted black...
Image Extractor which uses the data present in the "label" field to produce either monochrome or RGB ...
Image Extractor which uses the data present in the "z" field to produce a depth map (as a monochrome ...
Base Image Extractor class for organized point clouds.