Loading...
Searching...
No Matches
openni2_device.h
/*
* Copyright (c) 2013, Willow Garage, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the Willow Garage, Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
*/
#pragma once
#include <pcl/memory.h>
#include <pcl/pcl_exports.h>
// Template frame wrappers
#include <pcl/io/image.h>
#include <pcl/io/image_depth.h>
#include <pcl/io/image_ir.h>
#include <pcl/io/io_exception.h>
#include <pcl/io/openni2/openni2_video_mode.h>
#include "openni.h"
#include <cstdint>
#include <functional>
#include <memory>
#include <string>
#include <vector>
namespace openni
{
class Device;
class DeviceInfo;
class VideoStream;
class SensorInfo;
}
namespace pcl
{
namespace io
{
namespace openni2
{
using DepthImage = pcl::io::DepthImage;
using IRImage = pcl::io::IRImage;
using Image = pcl::io::Image;
class OpenNI2FrameListener;
class PCL_EXPORTS OpenNI2Device
{
public:
using Ptr = shared_ptr<OpenNI2Device>;
using ConstPtr = shared_ptr<const OpenNI2Device>;
using ImageCallbackFunction = std::function<void(Image::Ptr, void* cookie) >;
using DepthImageCallbackFunction = std::function<void(DepthImage::Ptr, void* cookie) >;
using IRImageCallbackFunction = std::function<void(IRImage::Ptr, void* cookie) >;
using CallbackHandle = unsigned;
using StreamCallbackFunction = std::function<void(openni::VideoStream& stream)>;
OpenNI2Device (const std::string& device_URI);
virtual ~OpenNI2Device ();
const std::string
getUri () const;
const std::string
getVendor () const;
const std::string
getName () const;
std::uint16_t
getUsbVendorId () const;
std::uint16_t
getUsbProductId () const;
const std::string
getStringID () const;
bool
isValid () const;
bool
hasIRSensor () const;
bool
hasColorSensor () const;
bool
hasDepthSensor () const;
void
startIRStream ();
void
startColorStream ();
void
startDepthStream ();
void
stopAllStreams ();
void
stopIRStream ();
void
stopColorStream ();
void
stopDepthStream ();
bool
isIRStreamStarted ();
bool
isColorStreamStarted ();
bool
isDepthStreamStarted ();
bool
isImageRegistrationModeSupported () const;
void
setImageRegistrationMode (bool enabled);
bool
isDepthRegistered () const;
const OpenNI2VideoMode
getIRVideoMode ();
const OpenNI2VideoMode
getColorVideoMode ();
const OpenNI2VideoMode
getDepthVideoMode ();
const std::vector<OpenNI2VideoMode>&
getSupportedIRVideoModes () const;
const std::vector<OpenNI2VideoMode>&
getSupportedColorVideoModes () const;
const std::vector<OpenNI2VideoMode>&
getSupportedDepthVideoModes () const;
bool
isIRVideoModeSupported (const OpenNI2VideoMode& video_mode) const;
bool
isColorVideoModeSupported (const OpenNI2VideoMode& video_mode) const;
bool
isDepthVideoModeSupported (const OpenNI2VideoMode& video_mode) const;
bool
findCompatibleIRMode (const OpenNI2VideoMode& requested_mode, OpenNI2VideoMode& actual_mode) const;
bool
findCompatibleColorMode (const OpenNI2VideoMode& requested_mode, OpenNI2VideoMode& actual_mode) const;
bool
findCompatibleDepthMode (const OpenNI2VideoMode& requested_mode, OpenNI2VideoMode& actual_mode) const;
void
setIRVideoMode (const OpenNI2VideoMode& video_mode);
void
setColorVideoMode (const OpenNI2VideoMode& video_mode);
void
setDepthVideoMode (const OpenNI2VideoMode& video_mode);
OpenNI2VideoMode
getDefaultIRMode () const;
OpenNI2VideoMode
getDefaultColorMode () const;
OpenNI2VideoMode
getDefaultDepthMode () const;
float
getIRFocalLength () const;
float
getColorFocalLength () const;
float
getDepthFocalLength () const;
// Baseline between sensors. Returns 0 if this value does not exist.
float
getBaseline();
// Value of pixels in shadow or that have no valid measurement
std::uint64_t
getShadowValue();
void
setAutoExposure (bool enable);
void
setAutoWhiteBalance (bool enable);
inline bool
isSynchronized ()
{
return (openni_device_->getDepthColorSyncEnabled ());
}
inline bool
isSynchronizationSupported ()
{
return (true); // Not sure how to query this from the hardware
}
inline bool
isFile()
{
return (openni_device_->isFile());
}
void
setSynchronization (bool enableSync);
bool
getAutoExposure () const;
bool
getAutoWhiteBalance () const;
void
setUseDeviceTimer (bool enable);
/** \brief Get absolute number of depth frames in the current stream.
* This function returns 0 if the current device is not a file stream or
* if the current mode has no depth stream.
*/
int
getDepthFrameCount ();
/** \brief Get absolute number of color frames in the current stream.
* This function returns 0 if the current device is not a file stream or
* if the current mode has no color stream.
*/
int
getColorFrameCount ();
/** \brief Get absolute number of ir frames in the current stream.
* This function returns 0 if the current device is not a file stream or
* if the current mode has no ir stream.
*/
int
getIRFrameCount ();
/** \brief Set the playback speed if the device is an recorded stream.
* If setting the device playback speed fails, because the device is no recorded stream or
* any other reason this function returns false. Otherwise true is returned.
* \param[in] speed The playback speed factor 1.0 means the same speed as recorded,
* 0.5 half the speed, 2.0 double speed and so on.
* \return True on success, false otherwise.
*/
bool
setPlaybackSpeed (double speed);
/************************************************************************************/
// Callbacks from openni::VideoStream to grabber. Internal interface
void
setColorCallback (StreamCallbackFunction color_callback);
void
setDepthCallback (StreamCallbackFunction depth_callback);
void
setIRCallback (StreamCallbackFunction ir_callback);
protected:
void shutdown ();
std::shared_ptr<openni::VideoStream>
getIRVideoStream () const;
std::shared_ptr<openni::VideoStream>
getColorVideoStream () const;
std::shared_ptr<openni::VideoStream>
getDepthVideoStream () const;
void
processColorFrame (openni::VideoStream& stream);
void
processDepthFrame (openni::VideoStream& stream);
void
processIRFrame (openni::VideoStream& stream);
bool
findCompatibleVideoMode (const std::vector<OpenNI2VideoMode>& supportedModes,
const OpenNI2VideoMode& output_mode, OpenNI2VideoMode& mode) const;
bool
resizingSupported (std::size_t input_width, std::size_t input_height, std::size_t output_width, std::size_t output_height) const;
// Members
std::shared_ptr<openni::Device> openni_device_;
std::shared_ptr<openni::DeviceInfo> device_info_;
std::shared_ptr<OpenNI2FrameListener> ir_frame_listener;
std::shared_ptr<OpenNI2FrameListener> color_frame_listener;
std::shared_ptr<OpenNI2FrameListener> depth_frame_listener;
mutable std::shared_ptr<openni::VideoStream> ir_video_stream_;
mutable std::shared_ptr<openni::VideoStream> color_video_stream_;
mutable std::shared_ptr<openni::VideoStream> depth_video_stream_;
mutable std::vector<OpenNI2VideoMode> ir_video_modes_;
mutable std::vector<OpenNI2VideoMode> color_video_modes_;
mutable std::vector<OpenNI2VideoMode> depth_video_modes_;
bool ir_video_started_{false};
bool color_video_started_{false};
bool depth_video_started_{false};
/** \brief distance between the projector and the IR camera in meters*/
float baseline_{0.0f};
/** the value for shadow (occluded pixels) */
std::uint64_t shadow_value_{0};
/** the value for pixels without a valid disparity measurement */
std::uint64_t no_sample_value_{0};
};
PCL_EXPORTS std::ostream& operator<< (std::ostream& stream, const OpenNI2Device& device);
} // namespace
}
}
pcl::io::DepthImage
This class provides methods to fill a depth or disparity image.
Definition image_depth.h:55
pcl::io::DepthImage::Ptr
shared_ptr< DepthImage > Ptr
Definition image_depth.h:57
pcl::io::IRImage
Class containing just a reference to IR meta data.
Definition image_ir.h:55
pcl::io::IRImage::Ptr
shared_ptr< IRImage > Ptr
Definition image_ir.h:57
pcl::io::Image
Image interface class providing an interface to fill a RGB or Grayscale image buffer.
Definition image.h:57
pcl::io::Image::Ptr
shared_ptr< Image > Ptr
Definition image.h:59
pcl::io::openni2::OpenNI2Device
Definition openni2_device.h:74
pcl::io::openni2::OpenNI2Device::getBaseline
float getBaseline()
pcl::io::openni2::OpenNI2Device::processColorFrame
void processColorFrame(openni::VideoStream &stream)
pcl::io::openni2::OpenNI2Device::stopColorStream
void stopColorStream()
pcl::io::openni2::OpenNI2Device::isIRStreamStarted
bool isIRStreamStarted()
pcl::io::openni2::OpenNI2Device::getUri
const std::string getUri() const
pcl::io::openni2::OpenNI2Device::baseline_
float baseline_
distance between the projector and the IR camera in meters
Definition openni2_device.h:323
pcl::io::openni2::OpenNI2Device::depth_frame_listener
std::shared_ptr< OpenNI2FrameListener > depth_frame_listener
Definition openni2_device.h:308
pcl::io::openni2::OpenNI2Device::depth_video_stream_
std::shared_ptr< openni::VideoStream > depth_video_stream_
Definition openni2_device.h:312
pcl::io::openni2::OpenNI2Device::getIRFocalLength
float getIRFocalLength() const
pcl::io::openni2::OpenNI2Device::processDepthFrame
void processDepthFrame(openni::VideoStream &stream)
pcl::io::openni2::OpenNI2Device::ConstPtr
shared_ptr< const OpenNI2Device > ConstPtr
Definition openni2_device.h:77
pcl::io::openni2::OpenNI2Device::no_sample_value_
std::uint64_t no_sample_value_
the value for pixels without a valid disparity measurement
Definition openni2_device.h:327
pcl::io::openni2::OpenNI2Device::getShadowValue
std::uint64_t getShadowValue()
pcl::io::openni2::OpenNI2Device::isColorVideoModeSupported
bool isColorVideoModeSupported(const OpenNI2VideoMode &video_mode) const
pcl::io::openni2::OpenNI2Device::getDepthVideoMode
const OpenNI2VideoMode getDepthVideoMode()
pcl::io::openni2::OpenNI2Device::depth_video_started_
bool depth_video_started_
Definition openni2_device.h:320
pcl::io::openni2::OpenNI2Device::isSynchronizationSupported
bool isSynchronizationSupported()
Definition openni2_device.h:213
pcl::io::openni2::OpenNI2Device::OpenNI2Device
OpenNI2Device(const std::string &device_URI)
pcl::io::openni2::OpenNI2Device::getColorVideoStream
std::shared_ptr< openni::VideoStream > getColorVideoStream() const
pcl::io::openni2::OpenNI2Device::getColorFrameCount
int getColorFrameCount()
Get absolute number of color frames in the current stream.
pcl::io::openni2::OpenNI2Device::depth_video_modes_
std::vector< OpenNI2VideoMode > depth_video_modes_
Definition openni2_device.h:316
pcl::io::openni2::OpenNI2Device::getIRFrameCount
int getIRFrameCount()
Get absolute number of ir frames in the current stream.
pcl::io::openni2::OpenNI2Device::isValid
bool isValid() const
pcl::io::openni2::OpenNI2Device::hasIRSensor
bool hasIRSensor() const
pcl::io::openni2::OpenNI2Device::findCompatibleDepthMode
bool findCompatibleDepthMode(const OpenNI2VideoMode &requested_mode, OpenNI2VideoMode &actual_mode) const
pcl::io::openni2::OpenNI2Device::isDepthStreamStarted
bool isDepthStreamStarted()
pcl::io::openni2::OpenNI2Device::setAutoWhiteBalance
void setAutoWhiteBalance(bool enable)
pcl::io::openni2::OpenNI2Device::shutdown
void shutdown()
pcl::io::openni2::OpenNI2Device::getName
const std::string getName() const
pcl::io::openni2::OpenNI2Device::Ptr
shared_ptr< OpenNI2Device > Ptr
Definition openni2_device.h:76
pcl::io::openni2::OpenNI2Device::getSupportedColorVideoModes
const std::vector< OpenNI2VideoMode > & getSupportedColorVideoModes() const
pcl::io::openni2::OpenNI2Device::IRImageCallbackFunction
std::function< void(IRImage::Ptr, void *cookie) > IRImageCallbackFunction
Definition openni2_device.h:81
pcl::io::openni2::OpenNI2Device::findCompatibleIRMode
bool findCompatibleIRMode(const OpenNI2VideoMode &requested_mode, OpenNI2VideoMode &actual_mode) const
pcl::io::openni2::OpenNI2Device::setIRVideoMode
void setIRVideoMode(const OpenNI2VideoMode &video_mode)
pcl::io::openni2::OpenNI2Device::setDepthCallback
void setDepthCallback(StreamCallbackFunction depth_callback)
pcl::io::openni2::OpenNI2Device::getUsbProductId
std::uint16_t getUsbProductId() const
pcl::io::openni2::OpenNI2Device::getDefaultColorMode
OpenNI2VideoMode getDefaultColorMode() const
pcl::io::openni2::OpenNI2Device::getColorFocalLength
float getColorFocalLength() const
pcl::io::openni2::OpenNI2Device::resizingSupported
bool resizingSupported(std::size_t input_width, std::size_t input_height, std::size_t output_width, std::size_t output_height) const
pcl::io::openni2::OpenNI2Device::setDepthVideoMode
void setDepthVideoMode(const OpenNI2VideoMode &video_mode)
pcl::io::openni2::OpenNI2Device::stopAllStreams
void stopAllStreams()
pcl::io::openni2::OpenNI2Device::getSupportedIRVideoModes
const std::vector< OpenNI2VideoMode > & getSupportedIRVideoModes() const
pcl::io::openni2::OpenNI2Device::getUsbVendorId
std::uint16_t getUsbVendorId() const
pcl::io::openni2::OpenNI2Device::findCompatibleColorMode
bool findCompatibleColorMode(const OpenNI2VideoMode &requested_mode, OpenNI2VideoMode &actual_mode) const
pcl::io::openni2::OpenNI2Device::color_video_stream_
std::shared_ptr< openni::VideoStream > color_video_stream_
Definition openni2_device.h:311
pcl::io::openni2::OpenNI2Device::ir_video_modes_
std::vector< OpenNI2VideoMode > ir_video_modes_
Definition openni2_device.h:314
pcl::io::openni2::OpenNI2Device::setColorVideoMode
void setColorVideoMode(const OpenNI2VideoMode &video_mode)
pcl::io::openni2::OpenNI2Device::setImageRegistrationMode
void setImageRegistrationMode(bool enabled)
pcl::io::openni2::OpenNI2Device::getDefaultDepthMode
OpenNI2VideoMode getDefaultDepthMode() const
pcl::io::openni2::OpenNI2Device::getAutoWhiteBalance
bool getAutoWhiteBalance() const
pcl::io::openni2::OpenNI2Device::device_info_
std::shared_ptr< openni::DeviceInfo > device_info_
Definition openni2_device.h:304
pcl::io::openni2::OpenNI2Device::shadow_value_
std::uint64_t shadow_value_
the value for shadow (occluded pixels)
Definition openni2_device.h:325
pcl::io::openni2::OpenNI2Device::isImageRegistrationModeSupported
bool isImageRegistrationModeSupported() const
pcl::io::openni2::OpenNI2Device::StreamCallbackFunction
std::function< void(openni::VideoStream &stream)> StreamCallbackFunction
Definition openni2_device.h:84
pcl::io::openni2::OpenNI2Device::setSynchronization
void setSynchronization(bool enableSync)
pcl::io::openni2::OpenNI2Device::ImageCallbackFunction
std::function< void(Image::Ptr, void *cookie) > ImageCallbackFunction
Definition openni2_device.h:79
pcl::io::openni2::OpenNI2Device::getColorVideoMode
const OpenNI2VideoMode getColorVideoMode()
pcl::io::openni2::OpenNI2Device::DepthImageCallbackFunction
std::function< void(DepthImage::Ptr, void *cookie) > DepthImageCallbackFunction
Definition openni2_device.h:80
pcl::io::openni2::OpenNI2Device::startDepthStream
void startDepthStream()
pcl::io::openni2::OpenNI2Device::setUseDeviceTimer
void setUseDeviceTimer(bool enable)
pcl::io::openni2::OpenNI2Device::stopIRStream
void stopIRStream()
pcl::io::openni2::OpenNI2Device::findCompatibleVideoMode
bool findCompatibleVideoMode(const std::vector< OpenNI2VideoMode > &supportedModes, const OpenNI2VideoMode &output_mode, OpenNI2VideoMode &mode) const
pcl::io::openni2::OpenNI2Device::isDepthVideoModeSupported
bool isDepthVideoModeSupported(const OpenNI2VideoMode &video_mode) const
pcl::io::openni2::OpenNI2Device::isDepthRegistered
bool isDepthRegistered() const
pcl::io::openni2::OpenNI2Device::color_video_modes_
std::vector< OpenNI2VideoMode > color_video_modes_
Definition openni2_device.h:315
pcl::io::openni2::OpenNI2Device::getDepthVideoStream
std::shared_ptr< openni::VideoStream > getDepthVideoStream() const
pcl::io::openni2::OpenNI2Device::isColorStreamStarted
bool isColorStreamStarted()
pcl::io::openni2::OpenNI2Device::setAutoExposure
void setAutoExposure(bool enable)
pcl::io::openni2::OpenNI2Device::getDepthFocalLength
float getDepthFocalLength() const
pcl::io::openni2::OpenNI2Device::processIRFrame
void processIRFrame(openni::VideoStream &stream)
pcl::io::openni2::OpenNI2Device::getAutoExposure
bool getAutoExposure() const
pcl::io::openni2::OpenNI2Device::getDefaultIRMode
OpenNI2VideoMode getDefaultIRMode() const
pcl::io::openni2::OpenNI2Device::setIRCallback
void setIRCallback(StreamCallbackFunction ir_callback)
pcl::io::openni2::OpenNI2Device::startColorStream
void startColorStream()
pcl::io::openni2::OpenNI2Device::stopDepthStream
void stopDepthStream()
pcl::io::openni2::OpenNI2Device::setColorCallback
void setColorCallback(StreamCallbackFunction color_callback)
pcl::io::openni2::OpenNI2Device::getSupportedDepthVideoModes
const std::vector< OpenNI2VideoMode > & getSupportedDepthVideoModes() const
pcl::io::openni2::OpenNI2Device::CallbackHandle
unsigned CallbackHandle
Definition openni2_device.h:82
pcl::io::openni2::OpenNI2Device::~OpenNI2Device
virtual ~OpenNI2Device()
pcl::io::openni2::OpenNI2Device::hasDepthSensor
bool hasDepthSensor() const
pcl::io::openni2::OpenNI2Device::ir_video_stream_
std::shared_ptr< openni::VideoStream > ir_video_stream_
Definition openni2_device.h:310
pcl::io::openni2::OpenNI2Device::isIRVideoModeSupported
bool isIRVideoModeSupported(const OpenNI2VideoMode &video_mode) const
pcl::io::openni2::OpenNI2Device::ir_video_started_
bool ir_video_started_
Definition openni2_device.h:318
pcl::io::openni2::OpenNI2Device::isFile
bool isFile()
Definition openni2_device.h:219
pcl::io::openni2::OpenNI2Device::color_video_started_
bool color_video_started_
Definition openni2_device.h:319
pcl::io::openni2::OpenNI2Device::setPlaybackSpeed
bool setPlaybackSpeed(double speed)
Set the playback speed if the device is an recorded stream.
pcl::io::openni2::OpenNI2Device::startIRStream
void startIRStream()
pcl::io::openni2::OpenNI2Device::openni_device_
std::shared_ptr< openni::Device > openni_device_
Definition openni2_device.h:303
pcl::io::openni2::OpenNI2Device::getDepthFrameCount
int getDepthFrameCount()
Get absolute number of depth frames in the current stream.
pcl::io::openni2::OpenNI2Device::getStringID
const std::string getStringID() const
pcl::io::openni2::OpenNI2Device::getIRVideoStream
std::shared_ptr< openni::VideoStream > getIRVideoStream() const
pcl::io::openni2::OpenNI2Device::isSynchronized
bool isSynchronized()
Definition openni2_device.h:207
pcl::io::openni2::OpenNI2Device::ir_frame_listener
std::shared_ptr< OpenNI2FrameListener > ir_frame_listener
Definition openni2_device.h:306
pcl::io::openni2::OpenNI2Device::hasColorSensor
bool hasColorSensor() const
pcl::io::openni2::OpenNI2Device::color_frame_listener
std::shared_ptr< OpenNI2FrameListener > color_frame_listener
Definition openni2_device.h:307
pcl::io::openni2::OpenNI2Device::getIRVideoMode
const OpenNI2VideoMode getIRVideoMode()
pcl::io::openni2::OpenNI2Device::getVendor
const std::string getVendor() const
pcl::io::openni2::OpenNI2FrameListener
Definition openni2_frame_listener.h:56
memory.h
Defines functions, macros and traits for allocating and using memory.
openni
Definition openni2_device.h:54
pcl::device
Definition device_array.h:315
pcl::io::openni2::IRImage
pcl::io::IRImage IRImage
Definition openni2_device.h:68
pcl::io::openni2::Image
pcl::io::Image Image
Definition openni2_device.h:69
pcl::io::openni2::DepthImage
pcl::io::DepthImage DepthImage
Definition openni2_device.h:67
pcl::io::openni2::operator<<
PCL_EXPORTS std::ostream & operator<<(std::ostream &stream, const OpenNI2Device &device)
pcl
Definition convolution.h:46
pcl::io::openni2::OpenNI2VideoMode
Definition openni2_video_mode.h:63