Point Cloud Library (PCL) 1.12.0
openni2_device.h
1/*
2 * Copyright (c) 2013, Willow Garage, Inc.
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 *
8 * * Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * * Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * * Neither the name of the Willow Garage, Inc. nor the names of its
14 * contributors may be used to endorse or promote products derived from
15 * this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
18 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
21 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
22 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
23 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
24 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
25 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
26 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
27 * POSSIBILITY OF SUCH DAMAGE.
28 *
29 */
30
31#pragma once
32
33#include <pcl/memory.h>
34#include <pcl/pcl_exports.h>
35
36// Template frame wrappers
37#include <pcl/io/image.h>
38#include <pcl/io/image_depth.h>
39#include <pcl/io/image_ir.h>
40
41#include <pcl/io/io_exception.h>
42#include <pcl/io/openni2/openni2_video_mode.h>
43
44#include "openni.h"
45
46#include <cstdint>
47#include <functional>
48#include <memory>
49#include <string>
50#include <vector>
51
52
53namespace openni
54{
55 class Device;
56 class DeviceInfo;
57 class VideoStream;
58 class SensorInfo;
59}
60
61namespace pcl
62{
63 namespace io
64 {
65 namespace openni2
66 {
70
72
74 {
75 public:
76 using Ptr = shared_ptr<OpenNI2Device>;
77 using ConstPtr = shared_ptr<const OpenNI2Device>;
78
79 using ImageCallbackFunction = std::function<void(Image::Ptr, void* cookie) >;
80 using DepthImageCallbackFunction = std::function<void(DepthImage::Ptr, void* cookie) >;
81 using IRImageCallbackFunction = std::function<void(IRImage::Ptr, void* cookie) >;
82 using CallbackHandle = unsigned;
83
84 using StreamCallbackFunction = std::function<void(openni::VideoStream& stream)>;
85
86 OpenNI2Device (const std::string& device_URI);
87 virtual ~OpenNI2Device ();
88
89 const std::string
90 getUri () const;
91 const std::string
92 getVendor () const;
93 const std::string
94 getName () const;
95 std::uint16_t
97 std::uint16_t
99
100 const std::string
101 getStringID () const;
102
103 bool
104 isValid () const;
105
106 bool
107 hasIRSensor () const;
108 bool
110 bool
112
113 void
115 void
117 void
119
120 void
122
123 void
125 void
127 void
129
130 bool
132 bool
134 bool
136
137 bool
139 void
141 bool
143
144 const OpenNI2VideoMode
146 const OpenNI2VideoMode
148 const OpenNI2VideoMode
150
151 const std::vector<OpenNI2VideoMode>&
153 const std::vector<OpenNI2VideoMode>&
155 const std::vector<OpenNI2VideoMode>&
157
158 bool
159 isIRVideoModeSupported (const OpenNI2VideoMode& video_mode) const;
160 bool
162 bool
164
165 bool
166 findCompatibleIRMode (const OpenNI2VideoMode& requested_mode, OpenNI2VideoMode& actual_mode) const;
167 bool
168 findCompatibleColorMode (const OpenNI2VideoMode& requested_mode, OpenNI2VideoMode& actual_mode) const;
169 bool
170 findCompatibleDepthMode (const OpenNI2VideoMode& requested_mode, OpenNI2VideoMode& actual_mode) const;
171
172 void
173 setIRVideoMode (const OpenNI2VideoMode& video_mode);
174 void
176 void
178
185
186 float
188 float
190 float
192
193 // Baseline between sensors. Returns 0 if this value does not exist.
194 float
196
197 // Value of pixels in shadow or that have no valid measurement
198 std::uint64_t
200
201 void
202 setAutoExposure (bool enable);
203 void
204 setAutoWhiteBalance (bool enable);
205
206 inline bool
208 {
209 return (openni_device_->getDepthColorSyncEnabled ());
210 }
211
212 inline bool
214 {
215 return (true); // Not sure how to query this from the hardware
216 }
217
218 inline bool
220 {
221 return (openni_device_->isFile());
222 }
223
224 void
225 setSynchronization (bool enableSync);
226
227 bool
229 bool
231
232 void
233 setUseDeviceTimer (bool enable);
234
235 /** \brief Get absolute number of depth frames in the current stream.
236 * This function returns 0 if the current device is not a file stream or
237 * if the current mode has no depth stream.
238 */
239 int
241
242 /** \brief Get absolute number of color frames in the current stream.
243 * This function returns 0 if the current device is not a file stream or
244 * if the current mode has no color stream.
245 */
246 int
248
249 /** \brief Get absolute number of ir frames in the current stream.
250 * This function returns 0 if the current device is not a file stream or
251 * if the current mode has no ir stream.
252 */
253 int
255
256 /** \brief Set the playback speed if the device is an recorded stream.
257 * If setting the device playback speed fails, because the device is no recorded stream or
258 * any other reason this function returns false. Otherwise true is returned.
259 * \param[in] speed The playback speed factor 1.0 means the same speed as recorded,
260 * 0.5 half the speed, 2.0 double speed and so on.
261 * \return True on success, false otherwise.
262 */
263 bool
264 setPlaybackSpeed (double speed);
265
266 /************************************************************************************/
267 // Callbacks from openni::VideoStream to grabber. Internal interface
268 void
270 void
272 void
274
275 protected:
276 void shutdown ();
277
278 std::shared_ptr<openni::VideoStream>
280 std::shared_ptr<openni::VideoStream>
282 std::shared_ptr<openni::VideoStream>
284
285
286 void
287 processColorFrame (openni::VideoStream& stream);
288 void
289 processDepthFrame (openni::VideoStream& stream);
290 void
291 processIRFrame (openni::VideoStream& stream);
292
293
294 bool
295 findCompatibleVideoMode (const std::vector<OpenNI2VideoMode>& supportedModes,
296 const OpenNI2VideoMode& output_mode, OpenNI2VideoMode& mode) const;
297
298 bool
299 resizingSupported (std::size_t input_width, std::size_t input_height, std::size_t output_width, std::size_t output_height) const;
300
301 // Members
302
303 std::shared_ptr<openni::Device> openni_device_;
304 std::shared_ptr<openni::DeviceInfo> device_info_;
305
306 std::shared_ptr<OpenNI2FrameListener> ir_frame_listener;
307 std::shared_ptr<OpenNI2FrameListener> color_frame_listener;
308 std::shared_ptr<OpenNI2FrameListener> depth_frame_listener;
309
310 mutable std::shared_ptr<openni::VideoStream> ir_video_stream_;
311 mutable std::shared_ptr<openni::VideoStream> color_video_stream_;
312 mutable std::shared_ptr<openni::VideoStream> depth_video_stream_;
313
314 mutable std::vector<OpenNI2VideoMode> ir_video_modes_;
315 mutable std::vector<OpenNI2VideoMode> color_video_modes_;
316 mutable std::vector<OpenNI2VideoMode> depth_video_modes_;
317
321
322 /** \brief distance between the projector and the IR camera in meters*/
324 /** the value for shadow (occluded pixels) */
325 std::uint64_t shadow_value_;
326 /** the value for pixels without a valid disparity measurement */
327 std::uint64_t no_sample_value_;
328 };
329
330 PCL_EXPORTS std::ostream& operator<< (std::ostream& stream, const OpenNI2Device& device);
331
332 } // namespace
333 }
334}
This class provides methods to fill a depth or disparity image.
Definition: image_depth.h:55
shared_ptr< DepthImage > Ptr
Definition: image_depth.h:57
Class containing just a reference to IR meta data.
Definition: image_ir.h:55
shared_ptr< IRImage > Ptr
Definition: image_ir.h:57
Image interface class providing an interface to fill a RGB or Grayscale image buffer.
Definition: image.h:57
shared_ptr< Image > Ptr
Definition: image.h:59
void processColorFrame(openni::VideoStream &stream)
const std::string getUri() const
float baseline_
distance between the projector and the IR camera in meters
std::shared_ptr< OpenNI2FrameListener > depth_frame_listener
std::shared_ptr< openni::VideoStream > depth_video_stream_
void processDepthFrame(openni::VideoStream &stream)
shared_ptr< const OpenNI2Device > ConstPtr
std::uint64_t no_sample_value_
the value for pixels without a valid disparity measurement
bool isColorVideoModeSupported(const OpenNI2VideoMode &video_mode) const
const OpenNI2VideoMode getDepthVideoMode()
OpenNI2Device(const std::string &device_URI)
std::shared_ptr< openni::VideoStream > getColorVideoStream() const
int getColorFrameCount()
Get absolute number of color frames in the current stream.
std::vector< OpenNI2VideoMode > depth_video_modes_
int getIRFrameCount()
Get absolute number of ir frames in the current stream.
bool findCompatibleDepthMode(const OpenNI2VideoMode &requested_mode, OpenNI2VideoMode &actual_mode) const
void setAutoWhiteBalance(bool enable)
const std::string getName() const
shared_ptr< OpenNI2Device > Ptr
const std::vector< OpenNI2VideoMode > & getSupportedColorVideoModes() const
std::function< void(IRImage::Ptr, void *cookie) > IRImageCallbackFunction
bool findCompatibleIRMode(const OpenNI2VideoMode &requested_mode, OpenNI2VideoMode &actual_mode) const
void setIRVideoMode(const OpenNI2VideoMode &video_mode)
void setDepthCallback(StreamCallbackFunction depth_callback)
std::uint16_t getUsbProductId() const
OpenNI2VideoMode getDefaultColorMode() const
bool resizingSupported(std::size_t input_width, std::size_t input_height, std::size_t output_width, std::size_t output_height) const
void setDepthVideoMode(const OpenNI2VideoMode &video_mode)
const std::vector< OpenNI2VideoMode > & getSupportedIRVideoModes() const
std::uint16_t getUsbVendorId() const
bool findCompatibleColorMode(const OpenNI2VideoMode &requested_mode, OpenNI2VideoMode &actual_mode) const
std::shared_ptr< openni::VideoStream > color_video_stream_
std::vector< OpenNI2VideoMode > ir_video_modes_
void setColorVideoMode(const OpenNI2VideoMode &video_mode)
void setImageRegistrationMode(bool enabled)
OpenNI2VideoMode getDefaultDepthMode() const
std::shared_ptr< openni::DeviceInfo > device_info_
std::uint64_t shadow_value_
the value for shadow (occluded pixels)
bool isImageRegistrationModeSupported() const
std::function< void(openni::VideoStream &stream)> StreamCallbackFunction
void setSynchronization(bool enableSync)
std::function< void(Image::Ptr, void *cookie) > ImageCallbackFunction
const OpenNI2VideoMode getColorVideoMode()
std::function< void(DepthImage::Ptr, void *cookie) > DepthImageCallbackFunction
void setUseDeviceTimer(bool enable)
bool findCompatibleVideoMode(const std::vector< OpenNI2VideoMode > &supportedModes, const OpenNI2VideoMode &output_mode, OpenNI2VideoMode &mode) const
bool isDepthVideoModeSupported(const OpenNI2VideoMode &video_mode) const
std::vector< OpenNI2VideoMode > color_video_modes_
std::shared_ptr< openni::VideoStream > getDepthVideoStream() const
void setAutoExposure(bool enable)
void processIRFrame(openni::VideoStream &stream)
OpenNI2VideoMode getDefaultIRMode() const
void setIRCallback(StreamCallbackFunction ir_callback)
void setColorCallback(StreamCallbackFunction color_callback)
const std::vector< OpenNI2VideoMode > & getSupportedDepthVideoModes() const
std::shared_ptr< openni::VideoStream > ir_video_stream_
bool isIRVideoModeSupported(const OpenNI2VideoMode &video_mode) const
bool setPlaybackSpeed(double speed)
Set the playback speed if the device is an recorded stream.
std::shared_ptr< openni::Device > openni_device_
int getDepthFrameCount()
Get absolute number of depth frames in the current stream.
const std::string getStringID() const
std::shared_ptr< openni::VideoStream > getIRVideoStream() const
std::shared_ptr< OpenNI2FrameListener > ir_frame_listener
std::shared_ptr< OpenNI2FrameListener > color_frame_listener
const OpenNI2VideoMode getIRVideoMode()
const std::string getVendor() const
Defines functions, macros and traits for allocating and using memory.
PCL_EXPORTS std::ostream & operator<<(std::ostream &stream, const OpenNI2Device &device)
#define PCL_EXPORTS
Definition: pcl_macros.h:323