Point Cloud Library (PCL) 1.12.0
Loading...
Searching...
No Matches
openni_grabber.h
1/*
2 * Software License Agreement (BSD License)
3 *
4 * Point Cloud Library (PCL) - www.pointclouds.org
5 * Copyright (c) 2009-2011, Willow Garage, Inc.
6 * Copyright (c) 2012-, Open Perception, Inc.
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 */
38
39#pragma once
40
41#include <pcl/memory.h>
42#include <pcl/pcl_config.h>
43#include <pcl/pcl_macros.h>
44
45#ifdef HAVE_OPENNI
46
47#include <pcl/point_cloud.h>
48#include <pcl/io/grabber.h>
49#include <pcl/io/openni_camera/openni_driver.h>
50#include <pcl/io/openni_camera/openni_device_kinect.h>
51#include <pcl/io/openni_camera/openni_image.h>
52#include <pcl/io/openni_camera/openni_depth_image.h>
53#include <pcl/io/openni_camera/openni_ir_image.h>
54#include <string>
55#include <pcl/common/synchronizer.h>
56#include <boost/shared_array.hpp> // for shared_array
57
58namespace pcl
59{
60 struct PointXYZ;
61 struct PointXYZRGB;
62 struct PointXYZRGBA;
63 struct PointXYZI;
64
65 /** \brief Grabber for OpenNI devices (i.e., Primesense PSDK, Microsoft Kinect, Asus XTion Pro/Live)
66 * \author Nico Blodow <blodow@cs.tum.edu>, Suat Gedikli <gedikli@willowgarage.com>
67 * \ingroup io
68 */
69 class PCL_EXPORTS OpenNIGrabber : public Grabber
70 {
71 public:
74
75 enum Mode
76 {
77 OpenNI_Default_Mode = 0, // This can depend on the device. For now all devices (PSDK, Xtion, Kinect) its VGA@30Hz
78 OpenNI_SXGA_15Hz = 1, // Only supported by the Kinect
79 OpenNI_VGA_30Hz = 2, // Supported by PSDK, Xtion and Kinect
80 OpenNI_VGA_25Hz = 3, // Supportged by PSDK and Xtion
81 OpenNI_QVGA_25Hz = 4, // Supported by PSDK and Xtion
82 OpenNI_QVGA_30Hz = 5, // Supported by PSDK, Xtion and Kinect
83 OpenNI_QVGA_60Hz = 6, // Supported by PSDK and Xtion
84 OpenNI_QQVGA_25Hz = 7, // Not supported -> using software downsampling (only for integer scale factor and only NN)
85 OpenNI_QQVGA_30Hz = 8, // Not supported -> using software downsampling (only for integer scale factor and only NN)
86 OpenNI_QQVGA_60Hz = 9 // Not supported -> using software downsampling (only for integer scale factor and only NN)
87 };
88
89 //define callback signature typedefs
99
100 public:
101 /** \brief Constructor
102 * \param[in] device_id ID of the device, which might be a serial number, bus\@address or the index of the device.
103 * \param[in] depth_mode the mode of the depth stream
104 * \param[in] image_mode the mode of the image stream
105 */
106 OpenNIGrabber (const std::string& device_id = "",
107 const Mode& depth_mode = OpenNI_Default_Mode,
108 const Mode& image_mode = OpenNI_Default_Mode);
109
110 /** \brief virtual Destructor inherited from the Grabber interface. It never throws. */
112
113 /** \brief Start the data acquisition. */
114 void
115 start () override;
116
117 /** \brief Stop the data acquisition. */
118 void
119 stop () override;
120
121 /** \brief Check if the data acquisition is still running. */
122 bool
123 isRunning () const override;
124
125 std::string
126 getName () const override;
127
128 /** \brief Obtain the number of frames per second (FPS). */
129 float
130 getFramesPerSecond () const override;
131
132 /** \brief Get a pcl::shared pointer to the openni_wrapper::OpenNIDevice object. */
133 inline openni_wrapper::OpenNIDevice::Ptr
134 getDevice () const;
135
136 /** \brief Obtain a list of the available depth modes that this device supports. */
137 std::vector<std::pair<int, XnMapOutputMode> >
138 getAvailableDepthModes () const;
139
140 /** \brief Obtain a list of the available image modes that this device supports. */
141 std::vector<std::pair<int, XnMapOutputMode> >
142 getAvailableImageModes () const;
143
144 /** \brief Set the RGB camera parameters (fx, fy, cx, cy)
145 * \param[in] rgb_focal_length_x the RGB focal length (fx)
146 * \param[in] rgb_focal_length_y the RGB focal length (fy)
147 * \param[in] rgb_principal_point_x the RGB principal point (cx)
148 * \param[in] rgb_principal_point_y the RGB principal point (cy)
149 * Setting the parameters to non-finite values (e.g., NaN, Inf) invalidates them
150 * and the grabber will use the default values from the camera instead.
151 */
152 inline void
153 setRGBCameraIntrinsics (const double rgb_focal_length_x,
157 {
158 rgb_focal_length_x_ = rgb_focal_length_x;
159 rgb_focal_length_y_ = rgb_focal_length_y;
160 rgb_principal_point_x_ = rgb_principal_point_x;
161 rgb_principal_point_y_ = rgb_principal_point_y;
162 }
163
164 /** \brief Get the RGB camera parameters (fx, fy, cx, cy)
165 * \param[out] rgb_focal_length_x the RGB focal length (fx)
166 * \param[out] rgb_focal_length_y the RGB focal length (fy)
167 * \param[out] rgb_principal_point_x the RGB principal point (cx)
168 * \param[out] rgb_principal_point_y the RGB principal point (cy)
169 */
170 inline void
172 double &rgb_focal_length_y,
173 double &rgb_principal_point_x,
174 double &rgb_principal_point_y) const
175 {
176 rgb_focal_length_x = rgb_focal_length_x_;
177 rgb_focal_length_y = rgb_focal_length_y_;
178 rgb_principal_point_x = rgb_principal_point_x_;
179 rgb_principal_point_y = rgb_principal_point_y_;
180 }
181
182
183 /** \brief Set the RGB image focal length (fx = fy).
184 * \param[in] rgb_focal_length the RGB focal length (assumes fx = fy)
185 * Setting the parameter to a non-finite value (e.g., NaN, Inf) invalidates it
186 * and the grabber will use the default values from the camera instead.
187 * These parameters will be used for XYZRGBA clouds.
188 */
189 inline void
191 {
192 rgb_focal_length_x_ = rgb_focal_length_y_ = rgb_focal_length;
193 }
194
195 /** \brief Set the RGB image focal length
196 * \param[in] rgb_focal_length_x the RGB focal length (fx)
197 * \param[in] rgb_focal_length_y the RGB focal length (fy)
198 * Setting the parameters to non-finite values (e.g., NaN, Inf) invalidates them
199 * and the grabber will use the default values from the camera instead.
200 * These parameters will be used for XYZRGBA clouds.
201 */
202 inline void
204 {
205 rgb_focal_length_x_ = rgb_focal_length_x;
206 rgb_focal_length_y_ = rgb_focal_length_y;
207 }
208
209 /** \brief Return the RGB focal length parameters (fx, fy)
210 * \param[out] rgb_focal_length_x the RGB focal length (fx)
211 * \param[out] rgb_focal_length_y the RGB focal length (fy)
212 */
213 inline void
215 {
216 rgb_focal_length_x = rgb_focal_length_x_;
217 rgb_focal_length_y = rgb_focal_length_y_;
218 }
219
220 /** \brief Set the Depth camera parameters (fx, fy, cx, cy)
221 * \param[in] depth_focal_length_x the Depth focal length (fx)
222 * \param[in] depth_focal_length_y the Depth focal length (fy)
223 * \param[in] depth_principal_point_x the Depth principal point (cx)
224 * \param[in] depth_principal_point_y the Depth principal point (cy)
225 * Setting the parameters to non-finite values (e.g., NaN, Inf) invalidates them
226 * and the grabber will use the default values from the camera instead.
227 */
228 inline void
230 const double depth_focal_length_y,
231 const double depth_principal_point_x,
232 const double depth_principal_point_y)
233 {
234 depth_focal_length_x_ = depth_focal_length_x;
235 depth_focal_length_y_ = depth_focal_length_y;
236 depth_principal_point_x_ = depth_principal_point_x;
237 depth_principal_point_y_ = depth_principal_point_y;
238 }
239
240 /** \brief Get the Depth camera parameters (fx, fy, cx, cy)
241 * \param[out] depth_focal_length_x the Depth focal length (fx)
242 * \param[out] depth_focal_length_y the Depth focal length (fy)
243 * \param[out] depth_principal_point_x the Depth principal point (cx)
244 * \param[out] depth_principal_point_y the Depth principal point (cy)
245 */
246 inline void
248 double &depth_focal_length_y,
250 double &depth_principal_point_y) const
251 {
252 depth_focal_length_x = depth_focal_length_x_;
253 depth_focal_length_y = depth_focal_length_y_;
254 depth_principal_point_x = depth_principal_point_x_;
255 depth_principal_point_y = depth_principal_point_y_;
256 }
257
258 /** \brief Set the Depth image focal length (fx = fy).
259 * \param[in] depth_focal_length the Depth focal length (assumes fx = fy)
260 * Setting the parameter to a non-finite value (e.g., NaN, Inf) invalidates it
261 * and the grabber will use the default values from the camera instead.
262 */
263 inline void
265 {
266 depth_focal_length_x_ = depth_focal_length_y_ = depth_focal_length;
267 }
268
269
270 /** \brief Set the Depth image focal length
271 * \param[in] depth_focal_length_x the Depth focal length (fx)
272 * \param[in] depth_focal_length_y the Depth focal length (fy)
273 * Setting the parameter to non-finite values (e.g., NaN, Inf) invalidates them
274 * and the grabber will use the default values from the camera instead.
275 */
276 inline void
278 {
279 depth_focal_length_x_ = depth_focal_length_x;
280 depth_focal_length_y_ = depth_focal_length_y;
281 }
282
283 /** \brief Return the Depth focal length parameters (fx, fy)
284 * \param[out] depth_focal_length_x the Depth focal length (fx)
285 * \param[out] depth_focal_length_y the Depth focal length (fy)
286 */
287 inline void
289 {
290 depth_focal_length_x = depth_focal_length_x_;
291 depth_focal_length_y = depth_focal_length_y_;
292 }
293
294 /** \brief Convert vector of raw shift values to depth values
295 * \param[in] shift_data_ptr input shift data
296 * \param[out] depth_data_ptr generated depth data
297 * \param[in] size of shift and depth buffer
298 */
299 inline void
301 const std::uint16_t* shift_data_ptr,
302 std::uint16_t* depth_data_ptr,
303 std::size_t size) const
304 {
305 // get openni device instance
306 auto openni_device = this->getDevice ();
307
308 const std::uint16_t* shift_data_it = shift_data_ptr;
309 std::uint16_t* depth_data_it = depth_data_ptr;
310
311 // shift-to-depth lookup
312 for (std::size_t i=0; i<size; ++i)
313 {
314 *depth_data_it = openni_device->shiftToDepth(*shift_data_it);
315
318 }
319
320 }
321
322
323 protected:
324 /** \brief On initialization processing. */
325 void
326 onInit (const std::string& device_id, const Mode& depth_mode, const Mode& image_mode);
327
328 /** \brief Sets up an OpenNI device. */
329 void
330 setupDevice (const std::string& device_id, const Mode& depth_mode, const Mode& image_mode);
331
332 /** \brief Update mode maps. */
333 void
335
336 /** \brief Start synchronization. */
337 void
339
340 /** \brief Stop synchronization. */
341 void
343
344 /** \brief Map config modes. */
345 bool
347
348 // callback methods
349 /** \brief RGB image callback. */
350 virtual void
352
353 /** \brief Depth image callback. */
354 virtual void
356
357 /** \brief IR image callback. */
358 virtual void
360
361 /** \brief RGB + Depth image callback. */
362 virtual void
365
366 /** \brief IR + Depth image callback. */
367 virtual void
370
371 /** \brief Process changed signals. */
372 void
373 signalsChanged () override;
374
375 // helper methods
376
377 /** \brief Check if the RGB and Depth images are required to be synchronized or not. */
378 virtual void
380
381 /** \brief Check if the RGB image stream is required or not. */
382 virtual void
384
385 /** \brief Check if the depth stream is required or not. */
386 virtual void
388
389 /** \brief Check if the IR image stream is required or not. */
390 virtual void
392
393
394 /** \brief Convert a Depth image to a pcl::PointCloud<pcl::PointXYZ>
395 * \param[in] depth the depth image to convert
396 */
399
400 /** \brief Convert a Depth + RGB image pair to a pcl::PointCloud<PointT>
401 * \param[in] image the RGB image to convert
402 * \param[in] depth_image the depth image to convert
403 */
404 template <typename PointT> typename pcl::PointCloud<PointT>::Ptr
407
408 /** \brief Convert a Depth + Intensity image pair to a pcl::PointCloud<pcl::PointXYZI>
409 * \param[in] image the IR image to convert
410 * \param[in] depth_image the depth image to convert
411 */
415
416
419
420 /** \brief The actual openni device. */
422
423 std::string rgb_frame_id_;
424 std::string depth_frame_id_;
425 unsigned image_width_;
427 unsigned depth_width_;
429
434
435 boost::signals2::signal<sig_cb_openni_image>* image_signal_;
436 boost::signals2::signal<sig_cb_openni_depth_image>* depth_image_signal_;
437 boost::signals2::signal<sig_cb_openni_ir_image>* ir_image_signal_;
438 boost::signals2::signal<sig_cb_openni_image_depth_image>* image_depth_image_signal_;
439 boost::signals2::signal<sig_cb_openni_ir_depth_image>* ir_depth_image_signal_;
440 boost::signals2::signal<sig_cb_openni_point_cloud>* point_cloud_signal_;
441 boost::signals2::signal<sig_cb_openni_point_cloud_i>* point_cloud_i_signal_;
442 boost::signals2::signal<sig_cb_openni_point_cloud_rgb>* point_cloud_rgb_signal_;
443 boost::signals2::signal<sig_cb_openni_point_cloud_rgba>* point_cloud_rgba_signal_;
444
445 struct modeComp
446 {
447
449 {
450 if (mode1.nXRes < mode2.nXRes)
451 return true;
452 if (mode1.nXRes > mode2.nXRes)
453 return false;
454 if (mode1.nYRes < mode2.nYRes)
455 return true;
456 if (mode1.nYRes > mode2.nYRes)
457 return false;
458 return (mode1.nFPS < mode2.nFPS);
459 }
460 } ;
461 std::map<int, XnMapOutputMode> config2xn_map_;
462
467
468 mutable unsigned rgb_array_size_;
469 mutable unsigned depth_buffer_size_;
470 mutable boost::shared_array<unsigned char> rgb_array_;
471 mutable boost::shared_array<unsigned short> depth_buffer_;
472 mutable boost::shared_array<unsigned short> ir_buffer_;
473
474 /** \brief The RGB image focal length (fx). */
476 /** \brief The RGB image focal length (fy). */
478 /** \brief The RGB image principal point (cx). */
480 /** \brief The RGB image principal point (cy). */
482 /** \brief The depth image focal length (fx). */
484 /** \brief The depth image focal length (fy). */
486 /** \brief The depth image principal point (cx). */
488 /** \brief The depth image principal point (cy). */
490
491 public:
493 };
494
497 {
498 return device_;
499 }
500
501} // namespace pcl
502#endif // HAVE_OPENNI
pcl::shared_ptr< DepthImage > Ptr
pcl::shared_ptr< IRImage > Ptr
pcl::shared_ptr< Image > Ptr
pcl::shared_ptr< OpenNIDevice > Ptr
Iterator class for point clouds with or without given indices.
Grabber interface for PCL 1.x device drivers.
Definition grabber.h:60
Grabber for OpenNI devices (i.e., Primesense PSDK, Microsoft Kinect, Asus XTion Pro/Live)
void setDepthFocalLength(const double depth_focal_length_x, const double depth_focal_length_y)
Set the Depth image focal length.
virtual void imageDepthImageCallback(const openni_wrapper::Image::Ptr &image, const openni_wrapper::DepthImage::Ptr &depth_image)
RGB + Depth image callback.
boost::shared_array< unsigned short > depth_buffer_
boost::signals2::signal< sig_cb_openni_ir_image > * ir_image_signal_
void getRGBCameraIntrinsics(double &rgb_focal_length_x, double &rgb_focal_length_y, double &rgb_principal_point_x, double &rgb_principal_point_y) const
Get the RGB camera parameters (fx, fy, cx, cy)
void onInit(const std::string &device_id, const Mode &depth_mode, const Mode &image_mode)
On initialization processing.
void convertShiftToDepth(const std::uint16_t *shift_data_ptr, std::uint16_t *depth_data_ptr, std::size_t size) const
Convert vector of raw shift values to depth values.
openni_wrapper::OpenNIDevice::CallbackHandle depth_callback_handle
void setDepthFocalLength(const double depth_focal_length)
Set the Depth image focal length (fx = fy).
virtual void irCallback(openni_wrapper::IRImage::Ptr ir_image, void *cookie)
IR image callback.
openni_wrapper::OpenNIDevice::Ptr device_
The actual openni device.
void stopSynchronization()
Stop synchronization.
openni_wrapper::OpenNIDevice::CallbackHandle image_callback_handle
double depth_focal_length_x_
The depth image focal length (fx).
boost::signals2::signal< sig_cb_openni_point_cloud_rgb > * point_cloud_rgb_signal_
openni_wrapper::OpenNIDevice::CallbackHandle ir_callback_handle
void(const openni_wrapper::IRImage::Ptr &, const openni_wrapper::DepthImage::Ptr &, float) sig_cb_openni_ir_depth_image
double rgb_principal_point_x_
The RGB image principal point (cx).
void setRGBFocalLength(const double rgb_focal_length)
Set the RGB image focal length (fx = fy).
boost::signals2::signal< sig_cb_openni_point_cloud_rgba > * point_cloud_rgba_signal_
std::map< int, XnMapOutputMode > config2xn_map_
boost::shared_array< unsigned short > ir_buffer_
void(const pcl::PointCloud< pcl::PointXYZRGBA >::ConstPtr &) sig_cb_openni_point_cloud_rgba
boost::signals2::signal< sig_cb_openni_point_cloud > * point_cloud_signal_
void(const openni_wrapper::IRImage::Ptr &) sig_cb_openni_ir_image
OpenNIGrabber(const std::string &device_id="", const Mode &depth_mode=OpenNI_Default_Mode, const Mode &image_mode=OpenNI_Default_Mode)
Constructor.
void(const openni_wrapper::Image::Ptr &, const openni_wrapper::DepthImage::Ptr &, float) sig_cb_openni_image_depth_image
void setRGBFocalLength(const double rgb_focal_length_x, const double rgb_focal_length_y)
Set the RGB image focal length.
pcl::PointCloud< pcl::PointXYZ >::Ptr convertToXYZPointCloud(const openni_wrapper::DepthImage::Ptr &depth) const
Convert a Depth image to a pcl::PointCloud<pcl::PointXYZ>
void(const openni_wrapper::Image::Ptr &) sig_cb_openni_image
double rgb_principal_point_y_
The RGB image principal point (cy).
double rgb_focal_length_y_
The RGB image focal length (fy).
void(const openni_wrapper::DepthImage::Ptr &) sig_cb_openni_depth_image
bool mapConfigMode2XnMode(int mode, XnMapOutputMode &xnmode) const
Map config modes.
boost::signals2::signal< sig_cb_openni_image > * image_signal_
Synchronizer< openni_wrapper::Image::Ptr, openni_wrapper::DepthImage::Ptr > rgb_sync_
Synchronizer< openni_wrapper::IRImage::Ptr, openni_wrapper::DepthImage::Ptr > ir_sync_
void(const pcl::PointCloud< pcl::PointXYZRGB >::ConstPtr &) sig_cb_openni_point_cloud_rgb
boost::signals2::signal< sig_cb_openni_ir_depth_image > * ir_depth_image_signal_
boost::shared_array< unsigned char > rgb_array_
void setDepthCameraIntrinsics(const double depth_focal_length_x, const double depth_focal_length_y, const double depth_principal_point_x, const double depth_principal_point_y)
Set the Depth camera parameters (fx, fy, cx, cy)
double depth_principal_point_x_
The depth image principal point (cx).
void(const pcl::PointCloud< pcl::PointXYZ >::ConstPtr &) sig_cb_openni_point_cloud
virtual void checkImageStreamRequired()
Check if the RGB image stream is required or not.
virtual void checkDepthStreamRequired()
Check if the depth stream is required or not.
virtual void imageCallback(openni_wrapper::Image::Ptr image, void *cookie)
RGB image callback.
double depth_principal_point_y_
The depth image principal point (cy).
boost::signals2::signal< sig_cb_openni_depth_image > * depth_image_signal_
double depth_focal_length_y_
The depth image focal length (fy).
void getRGBFocalLength(double &rgb_focal_length_x, double &rgb_focal_length_y) const
Return the RGB focal length parameters (fx, fy)
virtual void irDepthImageCallback(const openni_wrapper::IRImage::Ptr &image, const openni_wrapper::DepthImage::Ptr &depth_image)
IR + Depth image callback.
boost::signals2::signal< sig_cb_openni_image_depth_image > * image_depth_image_signal_
openni_wrapper::OpenNIDevice::Ptr getDevice() const
Get a pcl::shared pointer to the openni_wrapper::OpenNIDevice object.
void startSynchronization()
Start synchronization.
virtual void depthCallback(openni_wrapper::DepthImage::Ptr depth_image, void *cookie)
Depth image callback.
virtual void checkIRStreamRequired()
Check if the IR image stream is required or not.
~OpenNIGrabber() noexcept
virtual Destructor inherited from the Grabber interface.
void setupDevice(const std::string &device_id, const Mode &depth_mode, const Mode &image_mode)
Sets up an OpenNI device.
virtual void checkImageAndDepthSynchronizationRequired()
Check if the RGB and Depth images are required to be synchronized or not.
void updateModeMaps()
Update mode maps.
void getDepthFocalLength(double &depth_focal_length_x, double &depth_focal_length_y) const
Return the Depth focal length parameters (fx, fy)
pcl::PointCloud< pcl::PointXYZI >::Ptr convertToXYZIPointCloud(const openni_wrapper::IRImage::Ptr &image, const openni_wrapper::DepthImage::Ptr &depth_image) const
Convert a Depth + Intensity image pair to a pcl::PointCloud<pcl::PointXYZI>
void signalsChanged() override
Process changed signals.
void getDepthCameraIntrinsics(double &depth_focal_length_x, double &depth_focal_length_y, double &depth_principal_point_x, double &depth_principal_point_y) const
Get the Depth camera parameters (fx, fy, cx, cy)
boost::signals2::signal< sig_cb_openni_point_cloud_i > * point_cloud_i_signal_
std::string depth_frame_id_
pcl::PointCloud< PointT >::Ptr convertToXYZRGBPointCloud(const openni_wrapper::Image::Ptr &image, const openni_wrapper::DepthImage::Ptr &depth_image) const
Convert a Depth + RGB image pair to a pcl::PointCloud<PointT>
std::string rgb_frame_id_
double rgb_focal_length_x_
The RGB image focal length (fx).
void(const pcl::PointCloud< pcl::PointXYZI >::ConstPtr &) sig_cb_openni_point_cloud_i
shared_ptr< PointCloud< PointT > > Ptr
shared_ptr< const PointCloud< PointT > > ConstPtr
#define PCL_MAKE_ALIGNED_OPERATOR_NEW
Macro to signal a class requires a custom allocator.
Definition memory.h:63
Defines functions, macros and traits for allocating and using memory.
float4 PointXYZRGB
Definition internal.hpp:60
Defines all the PCL and non-PCL macros used.