Point Cloud Library (PCL) 1.12.0
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
43namespace 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 = shared_ptr<PointCloudImageExtractor<PointT> >;
84 using ConstPtr = shared_ptr<const PointCloudImageExtractor<PointT> >;
85
86 /** \brief Constructor. */
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 {
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 = shared_ptr<PointCloudImageExtractorWithScaling<PointT> >;
137 using ConstPtr = 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 {
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)
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 = shared_ptr<PointCloudImageExtractorFromNormalField<PointT> >;
209 using ConstPtr = 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 = shared_ptr<PointCloudImageExtractorFromRGBField<PointT> >;
236 using ConstPtr = 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 = shared_ptr<PointCloudImageExtractorFromLabelField<PointT> >;
265 using ConstPtr = 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. */
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 = shared_ptr<PointCloudImageExtractorFromZField<PointT> >;
323 using ConstPtr = 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 = shared_ptr<PointCloudImageExtractorFromCurvatureField<PointT> >;
365 using ConstPtr = 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 */
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 = shared_ptr<PointCloudImageExtractorFromIntensityField<PointT> >;
407 using ConstPtr = 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 */
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>
PointCloud represents the base class in PCL for storing collections of 3D points.
Definition: point_cloud.h:173
Image Extractor which uses the data present in the "curvature" field to produce a curvature map (as a...
PointCloudImageExtractorFromCurvatureField(const float scaling_factor)
Constructor.
PointCloudImageExtractorFromCurvatureField(const ScalingMethod scaling_method=PointCloudImageExtractorWithScaling< PointT >::SCALING_FULL_RANGE)
Constructor.
Image Extractor which uses the data present in the "intensity" field to produce a monochrome intensit...
PointCloudImageExtractorFromIntensityField(const float scaling_factor)
Constructor.
PointCloudImageExtractorFromIntensityField(const ScalingMethod scaling_method=PointCloudImageExtractorWithScaling< PointT >::SCALING_NO)
Constructor.
Image Extractor which uses the data present in the "label" field to produce either monochrome or RGB ...
@ COLORS_RGB_GLASBEY
Fixed RGB colors from the Glasbey lookup table, assigned in the ascending order of label id.
@ COLORS_MONO
Shades of gray (according to label id)
void setColorMode(const ColorMode color_mode)
Set color mapping mode.
PointCloudImageExtractorFromLabelField(const ColorMode color_mode=COLORS_MONO)
Constructor.
bool extractImpl(const PointCloud &cloud, pcl::PCLImage &img) const override
Implementation of the extract() function, has to be implemented in deriving classes.
Image Extractor which uses the data present in the "normal" field.
bool extractImpl(const PointCloud &cloud, pcl::PCLImage &img) const override
Implementation of the extract() function, has to be implemented in deriving classes.
Image Extractor which uses the data present in the "rgb" or "rgba" fields to produce a color image wi...
bool extractImpl(const PointCloud &cloud, pcl::PCLImage &img) const override
Implementation of the extract() function, has to be implemented in deriving classes.
Image Extractor which uses the data present in the "z" field to produce a depth map (as a monochrome ...
PointCloudImageExtractorFromZField(const float scaling_factor=10000)
Constructor.
PointCloudImageExtractorFromZField(const ScalingMethod scaling_method)
Constructor.
Base Image Extractor class for organized point clouds.
shared_ptr< PointCloudImageExtractor< PointT > > Ptr
virtual bool extractImpl(const PointCloud &cloud, pcl::PCLImage &image) const =0
Implementation of the extract() function, has to be implemented in deriving classes.
bool extract(const PointCloud &cloud, pcl::PCLImage &image) const
Obtain the image from the given cloud.
shared_ptr< const PointCloudImageExtractor< PointT > > ConstPtr
void setPaintNaNsWithBlack(bool flag)
Set a flag that controls if image pixels corresponding to NaN (infinite) points should be painted bla...
bool paint_nans_with_black_
A flag that controls if image pixels corresponding to NaN (infinite) points should be painted black.
Image Extractor extension which provides functionality to apply scaling to the values extracted from ...
void setScalingMethod(const ScalingMethod scaling_method)
Set scaling method.
bool extractImpl(const PointCloud &cloud, pcl::PCLImage &image) const override
Implementation of the extract() function, has to be implemented in deriving classes.
void setScalingFactor(const float scaling_factor)
Set fixed scaling factor.
PointCloudImageExtractorWithScaling(const std::string &field_name, const float scaling_factor)
Constructor.
PointCloudImageExtractorWithScaling(const std::string &field_name, const ScalingMethod scaling_method)
Constructor.
A point structure representing Euclidean xyz coordinates, and the RGB color.