From ff8b8ef24cab7e77fe46010802823e74ff4cc61f Mon Sep 17 00:00:00 2001 From: vbystricky Date: Mon, 17 Feb 2014 17:50:15 +0400 Subject: [PATCH] Remove implementation of CvCapture interface for Intel PerC camera. Add IVideoCapture interface and implementation of this one for Intel PerC camera --- modules/highgui/include/opencv2/highgui.hpp | 16 +- modules/highgui/src/cap.cpp | 72 +- modules/highgui/src/cap_intelperc.cpp | 1154 +++++++++++++-------------- modules/highgui/src/cap_intelperc.hpp | 145 ++++ modules/highgui/src/precomp.hpp | 2 - 5 files changed, 760 insertions(+), 629 deletions(-) create mode 100644 modules/highgui/src/cap_intelperc.hpp diff --git a/modules/highgui/include/opencv2/highgui.hpp b/modules/highgui/include/opencv2/highgui.hpp index 275d12e..39f0ebe 100644 --- a/modules/highgui/include/opencv2/highgui.hpp +++ b/modules/highgui/include/opencv2/highgui.hpp @@ -530,6 +530,18 @@ enum { CAP_INTELPERC_DEPTH_MAP = 0, // Each pixel is a 16-bit integ CAP_INTELPERC_IMAGE = 3 }; + +class IVideoCapture +{ +public: + virtual ~IVideoCapture() {} + virtual double getProperty(int) { return 0; } + virtual bool setProperty(int, double) { return 0; } + virtual bool grabFrame() { return true; } + virtual bool retrieveFrame(int, cv::OutputArray) { return 0; } + virtual int getCaptureDomain() { return CAP_ANY; } // Return the type of the capture object: CAP_VFW, etc... +}; + class CV_EXPORTS_W VideoCapture { public: @@ -554,9 +566,11 @@ public: protected: Ptr cap; + Ptr icap; +private: + static Ptr createCameraCapture(int index); }; - class CV_EXPORTS_W VideoWriter { public: diff --git a/modules/highgui/src/cap.cpp b/modules/highgui/src/cap.cpp index 105f92e..9311694 100644 --- a/modules/highgui/src/cap.cpp +++ b/modules/highgui/src/cap.cpp @@ -40,6 +40,7 @@ //M*/ #include "precomp.hpp" +#include "cap_intelperc.hpp" #if defined _M_X64 && defined _MSC_VER && !defined CV_ICC #pragma optimize("",off) @@ -345,14 +346,6 @@ CV_IMPL CvCapture * cvCreateCameraCapture (int index) return capture; break; // CV_CAP_GIGANETIX #endif - -#ifdef HAVE_INTELPERC - case CV_CAP_INTELPERC: - capture = cvCreateCameraCapture_IntelPerC(index); - if (capture) - return capture; - break; // CV_CAP_INTEL_PERC -#endif } } @@ -497,6 +490,7 @@ VideoCapture::VideoCapture(int device) VideoCapture::~VideoCapture() { + icap.release(); cap.release(); } @@ -510,24 +504,36 @@ bool VideoCapture::open(const String& filename) bool VideoCapture::open(int device) { if (isOpened()) release(); + icap = createCameraCapture(device); + if (!icap.empty()) + return true; cap.reset(cvCreateCameraCapture(device)); return isOpened(); } -bool VideoCapture::isOpened() const { return !cap.empty(); } +bool VideoCapture::isOpened() const +{ + return (!cap.empty() || !icap.empty()); +} void VideoCapture::release() { + icap.release(); cap.release(); } bool VideoCapture::grab() { + if (!icap.empty()) + return icap->grabFrame(); return cvGrabFrame(cap) != 0; } bool VideoCapture::retrieve(OutputArray image, int channel) { + if (!icap.empty()) + return icap->retrieveFrame(channel, image); + IplImage* _img = cvRetrieveFrame(cap, channel); if( !_img ) { @@ -567,14 +573,62 @@ VideoCapture& VideoCapture::operator >> (UMat& image) bool VideoCapture::set(int propId, double value) { + if (!icap.empty()) + return icap->setProperty(propId, value); return cvSetCaptureProperty(cap, propId, value) != 0; } double VideoCapture::get(int propId) { + if (!icap.empty()) + return icap->getProperty(propId); return cvGetCaptureProperty(cap, propId); } +Ptr VideoCapture::createCameraCapture(int index) +{ + int domains[] = + { +#ifdef HAVE_INTELPERC + CV_CAP_INTELPERC, +#endif + -1, -1 + }; + + // interpret preferred interface (0 = autodetect) + int pref = (index / 100) * 100; + if (pref) + { + domains[0]=pref; + index %= 100; + domains[1]=-1; + } + + // try every possibly installed camera API + for (int i = 0; domains[i] >= 0; i++) + { +#if defined(HAVE_INTELPERC) || \ + (0) + Ptr capture; + + switch (domains[i]) + { +#ifdef HAVE_INTELPERC + case CV_CAP_INTELPERC: + capture = Ptr(new cv::VideoCapture_IntelPerC()); + if (capture) + return capture; + break; // CV_CAP_INTEL_PERC +#endif + } +#endif + } + + // failed open a camera + return Ptr(); +} + + VideoWriter::VideoWriter() {} diff --git a/modules/highgui/src/cap_intelperc.cpp b/modules/highgui/src/cap_intelperc.cpp index 368f4fd..7eef06c 100644 --- a/modules/highgui/src/cap_intelperc.cpp +++ b/modules/highgui/src/cap_intelperc.cpp @@ -1,714 +1,634 @@ -#include "precomp.hpp" - #ifdef HAVE_INTELPERC -#include "pxcsession.h" -#include "pxcsmartptr.h" -#include "pxccapture.h" +#include "cap_intelperc.hpp" -class CvIntelPerCStreamBase +namespace cv { -protected: - struct FrameInternal - { - IplImage* retrieveFrame() - { - if (m_mat.empty()) - return NULL; - m_iplHeader = IplImage(m_mat); - return &m_iplHeader; - } - cv::Mat m_mat; - private: - IplImage m_iplHeader; - }; -public: - CvIntelPerCStreamBase() - : m_profileIdx(-1) - , m_frameIdx(0) - , m_timeStampStartNS(0) - { - } - virtual ~CvIntelPerCStreamBase() - { - } - bool isValid() - { - return (m_device.IsValid() && m_stream.IsValid()); - } - bool grabFrame() +///////////////// IntelPerCStreamBase ////////////////// + +IntelPerCStreamBase::IntelPerCStreamBase() + : m_profileIdx(-1) + , m_frameIdx(0) + , m_timeStampStartNS(0) +{ +} +IntelPerCStreamBase::~IntelPerCStreamBase() +{ +} + +bool IntelPerCStreamBase::isValid() +{ + return (m_device.IsValid() && m_stream.IsValid()); +} +bool IntelPerCStreamBase::grabFrame() +{ + if (!m_stream.IsValid()) + return false; + if (-1 == m_profileIdx) { - if (!m_stream.IsValid()) + if (!setProperty(CV_CAP_PROP_INTELPERC_PROFILE_IDX, 0)) return false; - if (-1 == m_profileIdx) + } + PXCSmartSP sp; + m_pxcImage.ReleaseRef(); + if (PXC_STATUS_NO_ERROR > m_stream->ReadStreamAsync(&m_pxcImage, &sp)) + return false; + if (PXC_STATUS_NO_ERROR > sp->Synchronize()) + return false; + if (0 == m_timeStampStartNS) + m_timeStampStartNS = m_pxcImage->QueryTimeStamp(); + m_timeStamp = (double)((m_pxcImage->QueryTimeStamp() - m_timeStampStartNS) / 10000); + m_frameIdx++; + return true; +} +int IntelPerCStreamBase::getProfileIDX() const +{ + return m_profileIdx; +} +double IntelPerCStreamBase::getProperty(int propIdx) +{ + double ret = 0.0; + switch (propIdx) + { + case CV_CAP_PROP_INTELPERC_PROFILE_COUNT: + ret = (double)m_profiles.size(); + break; + case CV_CAP_PROP_FRAME_WIDTH : + if ((0 <= m_profileIdx) && (m_profileIdx < m_profiles.size())) + ret = (double)m_profiles[m_profileIdx].imageInfo.width; + break; + case CV_CAP_PROP_FRAME_HEIGHT : + if ((0 <= m_profileIdx) && (m_profileIdx < m_profiles.size())) + ret = (double)m_profiles[m_profileIdx].imageInfo.height; + break; + case CV_CAP_PROP_FPS : + if ((0 <= m_profileIdx) && (m_profileIdx < m_profiles.size())) { - if (!setProperty(CV_CAP_PROP_INTELPERC_PROFILE_IDX, 0)) - return false; + ret = ((double)m_profiles[m_profileIdx].frameRateMin.numerator / (double)m_profiles[m_profileIdx].frameRateMin.denominator + + (double)m_profiles[m_profileIdx].frameRateMax.numerator / (double)m_profiles[m_profileIdx].frameRateMax.denominator) / 2.0; } - PXCSmartPtr pxcImage; PXCSmartSP sp; - if (PXC_STATUS_NO_ERROR > m_stream->ReadStreamAsync(&pxcImage, &sp)) - return false; - if (PXC_STATUS_NO_ERROR > sp->Synchronize()) - return false; - if (0 == m_timeStampStartNS) - m_timeStampStartNS = pxcImage->QueryTimeStamp(); - m_timeStamp = (double)((pxcImage->QueryTimeStamp() - m_timeStampStartNS) / 10000); - m_frameIdx++; - return prepareIplImage(pxcImage); - } - int getProfileIDX() const - { - return m_profileIdx; - } -public: - virtual bool initStream(PXCSession *session) = 0; - virtual double getProperty(int propIdx) + break; + case CV_CAP_PROP_POS_FRAMES: + ret = (double)m_frameIdx; + break; + case CV_CAP_PROP_POS_MSEC: + ret = m_timeStamp; + break; + }; + return ret; +} +bool IntelPerCStreamBase::setProperty(int propIdx, double propVal) +{ + bool isSet = false; + switch (propIdx) { - double ret = 0.0; - switch (propIdx) + case CV_CAP_PROP_INTELPERC_PROFILE_IDX: { - case CV_CAP_PROP_INTELPERC_PROFILE_COUNT: - ret = (double)m_profiles.size(); - break; - case CV_CAP_PROP_FRAME_WIDTH : - if ((0 <= m_profileIdx) && (m_profileIdx < m_profiles.size())) - ret = (double)m_profiles[m_profileIdx].imageInfo.width; - break; - case CV_CAP_PROP_FRAME_HEIGHT : - if ((0 <= m_profileIdx) && (m_profileIdx < m_profiles.size())) - ret = (double)m_profiles[m_profileIdx].imageInfo.height; - break; - case CV_CAP_PROP_FPS : - if ((0 <= m_profileIdx) && (m_profileIdx < m_profiles.size())) + int propValInt = (int)propVal; + if (0 > propValInt) { - ret = ((double)m_profiles[m_profileIdx].frameRateMin.numerator / (double)m_profiles[m_profileIdx].frameRateMin.denominator - + (double)m_profiles[m_profileIdx].frameRateMax.numerator / (double)m_profiles[m_profileIdx].frameRateMax.denominator) / 2.0; + m_profileIdx = propValInt; + isSet = true; } - break; - case CV_CAP_PROP_POS_FRAMES: - ret = (double)m_frameIdx; - break; - case CV_CAP_PROP_POS_MSEC: - ret = m_timeStamp; - break; - }; - return ret; - } - virtual bool setProperty(int propIdx, double propVal) - { - bool isSet = false; - switch (propIdx) - { - case CV_CAP_PROP_INTELPERC_PROFILE_IDX: + else if (propValInt < m_profiles.size()) { - int propValInt = (int)propVal; - if ((0 <= propValInt) && (propValInt < m_profiles.size())) + if (m_profileIdx != propValInt) { - if (m_profileIdx != propValInt) - { - m_profileIdx = propValInt; - if (m_stream.IsValid()) - m_stream->SetProfile(&m_profiles[m_profileIdx]); - m_frameIdx = 0; - m_timeStampStartNS = 0; - } - isSet = true; + m_profileIdx = propValInt; + if (m_stream.IsValid()) + m_stream->SetProfile(&m_profiles[m_profileIdx]); + m_frameIdx = 0; + m_timeStampStartNS = 0; } + isSet = true; } - break; - }; - return isSet; - } -protected: - PXCSmartPtr m_device; - bool initDevice(PXCSession *session) + } + break; + }; + return isSet; +} +bool IntelPerCStreamBase::initDevice(PXCSession *session) +{ + if (NULL == session) + return false; + + pxcStatus sts = PXC_STATUS_NO_ERROR; + PXCSession::ImplDesc templat; + memset(&templat,0,sizeof(templat)); + templat.group = PXCSession::IMPL_GROUP_SENSOR; + templat.subgroup= PXCSession::IMPL_SUBGROUP_VIDEO_CAPTURE; + + for (int modidx = 0; PXC_STATUS_NO_ERROR <= sts; modidx++) { - if (NULL == session) - return false; + PXCSession::ImplDesc desc; + sts = session->QueryImpl(&templat, modidx, &desc); + if (PXC_STATUS_NO_ERROR > sts) + break; - pxcStatus sts = PXC_STATUS_NO_ERROR; - PXCSession::ImplDesc templat; - memset(&templat,0,sizeof(templat)); - templat.group = PXCSession::IMPL_GROUP_SENSOR; - templat.subgroup= PXCSession::IMPL_SUBGROUP_VIDEO_CAPTURE; + PXCSmartPtr capture; + sts = session->CreateImpl(&desc, &capture); + if (!capture.IsValid()) + continue; - for (int modidx = 0; PXC_STATUS_NO_ERROR <= sts; modidx++) + /* enumerate devices */ + for (int devidx = 0; PXC_STATUS_NO_ERROR <= sts; devidx++) { - PXCSession::ImplDesc desc; - sts = session->QueryImpl(&templat, modidx, &desc); - if (PXC_STATUS_NO_ERROR > sts) - break; - - PXCSmartPtr capture; - sts = session->CreateImpl(&desc, &capture); - if (!capture.IsValid()) - continue; - - /* enumerate devices */ - for (int devidx = 0; PXC_STATUS_NO_ERROR <= sts; devidx++) + PXCSmartPtr device; + sts = capture->CreateDevice(devidx, &device); + if (PXC_STATUS_NO_ERROR <= sts) { - PXCSmartPtr device; - sts = capture->CreateDevice(devidx, &device); - if (PXC_STATUS_NO_ERROR <= sts) - { - m_device = device.ReleasePtr(); - return true; - } + m_device = device.ReleasePtr(); + return true; } } - return false; } + return false; +} - PXCSmartPtr m_stream; - void initStreamImpl(PXCImage::ImageType type) - { - if (!m_device.IsValid()) - return; +void IntelPerCStreamBase::initStreamImpl(PXCImage::ImageType type) +{ + if (!m_device.IsValid()) + return; - pxcStatus sts = PXC_STATUS_NO_ERROR; - /* enumerate streams */ - for (int streamidx = 0; PXC_STATUS_NO_ERROR <= sts; streamidx++) - { - PXCCapture::Device::StreamInfo sinfo; - sts = m_device->QueryStream(streamidx, &sinfo); - if (PXC_STATUS_NO_ERROR > sts) - break; - if (PXCCapture::VideoStream::CUID != sinfo.cuid) - continue; - if (type != sinfo.imageType) - continue; - - sts = m_device->CreateStream(streamidx, &m_stream); - if (PXC_STATUS_NO_ERROR == sts) - break; - m_stream.ReleaseRef(); - } - } -protected: - std::vector m_profiles; - int m_profileIdx; - int m_frameIdx; - pxcU64 m_timeStampStartNS; - double m_timeStamp; - - virtual bool validProfile(const PXCCapture::VideoStream::ProfileInfo& /*pinfo*/) + pxcStatus sts = PXC_STATUS_NO_ERROR; + /* enumerate streams */ + for (int streamidx = 0; PXC_STATUS_NO_ERROR <= sts; streamidx++) { - return true; + PXCCapture::Device::StreamInfo sinfo; + sts = m_device->QueryStream(streamidx, &sinfo); + if (PXC_STATUS_NO_ERROR > sts) + break; + if (PXCCapture::VideoStream::CUID != sinfo.cuid) + continue; + if (type != sinfo.imageType) + continue; + + sts = m_device->CreateStream(streamidx, &m_stream); + if (PXC_STATUS_NO_ERROR == sts) + break; + m_stream.ReleaseRef(); } - void enumProfiles() - { - m_profiles.clear(); - if (!m_stream.IsValid()) - return; - pxcStatus sts = PXC_STATUS_NO_ERROR; - for (int profidx = 0; PXC_STATUS_NO_ERROR <= sts; profidx++) - { - PXCCapture::VideoStream::ProfileInfo pinfo; - sts = m_stream->QueryProfile(profidx, &pinfo); - if (PXC_STATUS_NO_ERROR > sts) - break; - if (validProfile(pinfo)) - m_profiles.push_back(pinfo); - } +} +bool IntelPerCStreamBase::validProfile(const PXCCapture::VideoStream::ProfileInfo& /*pinfo*/) +{ + return true; +} +void IntelPerCStreamBase::enumProfiles() +{ + m_profiles.clear(); + if (!m_stream.IsValid()) + return; + pxcStatus sts = PXC_STATUS_NO_ERROR; + for (int profidx = 0; PXC_STATUS_NO_ERROR <= sts; profidx++) + { + PXCCapture::VideoStream::ProfileInfo pinfo; + sts = m_stream->QueryProfile(profidx, &pinfo); + if (PXC_STATUS_NO_ERROR > sts) + break; + if (validProfile(pinfo)) + m_profiles.push_back(pinfo); } - virtual bool prepareIplImage(PXCImage *pxcImage) = 0; -}; +} + +///////////////// IntelPerCStreamImage ////////////////// -class CvIntelPerCStreamImage - : public CvIntelPerCStreamBase +IntelPerCStreamImage::IntelPerCStreamImage() { -public: - CvIntelPerCStreamImage() - { - } - virtual ~CvIntelPerCStreamImage() - { - } +} +IntelPerCStreamImage::~IntelPerCStreamImage() +{ +} - virtual bool initStream(PXCSession *session) - { - if (!initDevice(session)) - return false; - initStreamImpl(PXCImage::IMAGE_TYPE_COLOR); - if (!m_stream.IsValid()) - return false; - enumProfiles(); - return true; - } - virtual double getProperty(int propIdx) +bool IntelPerCStreamImage::initStream(PXCSession *session) +{ + if (!initDevice(session)) + return false; + initStreamImpl(PXCImage::IMAGE_TYPE_COLOR); + if (!m_stream.IsValid()) + return false; + enumProfiles(); + return true; +} +double IntelPerCStreamImage::getProperty(int propIdx) +{ + switch (propIdx) { - switch (propIdx) + case CV_CAP_PROP_BRIGHTNESS: { - case CV_CAP_PROP_BRIGHTNESS: - { - if (!m_device.IsValid()) - return 0.0; - float fret = 0.0f; - if (PXC_STATUS_NO_ERROR == m_device->QueryProperty(PXCCapture::Device::PROPERTY_COLOR_BRIGHTNESS, &fret)) - return (double)fret; + if (!m_device.IsValid()) return 0.0; - } - break; - case CV_CAP_PROP_CONTRAST: - { - if (!m_device.IsValid()) - return 0.0; - float fret = 0.0f; - if (PXC_STATUS_NO_ERROR == m_device->QueryProperty(PXCCapture::Device::PROPERTY_COLOR_CONTRAST, &fret)) - return (double)fret; + float fret = 0.0f; + if (PXC_STATUS_NO_ERROR == m_device->QueryProperty(PXCCapture::Device::PROPERTY_COLOR_BRIGHTNESS, &fret)) + return (double)fret; + return 0.0; + } + break; + case CV_CAP_PROP_CONTRAST: + { + if (!m_device.IsValid()) return 0.0; - } - break; - case CV_CAP_PROP_SATURATION: - { - if (!m_device.IsValid()) - return 0.0; - float fret = 0.0f; - if (PXC_STATUS_NO_ERROR == m_device->QueryProperty(PXCCapture::Device::PROPERTY_COLOR_SATURATION, &fret)) - return (double)fret; + float fret = 0.0f; + if (PXC_STATUS_NO_ERROR == m_device->QueryProperty(PXCCapture::Device::PROPERTY_COLOR_CONTRAST, &fret)) + return (double)fret; + return 0.0; + } + break; + case CV_CAP_PROP_SATURATION: + { + if (!m_device.IsValid()) return 0.0; - } - break; - case CV_CAP_PROP_HUE: - { - if (!m_device.IsValid()) - return 0.0; - float fret = 0.0f; - if (PXC_STATUS_NO_ERROR == m_device->QueryProperty(PXCCapture::Device::PROPERTY_COLOR_HUE, &fret)) - return (double)fret; + float fret = 0.0f; + if (PXC_STATUS_NO_ERROR == m_device->QueryProperty(PXCCapture::Device::PROPERTY_COLOR_SATURATION, &fret)) + return (double)fret; + return 0.0; + } + break; + case CV_CAP_PROP_HUE: + { + if (!m_device.IsValid()) return 0.0; - } - break; - case CV_CAP_PROP_GAMMA: - { - if (!m_device.IsValid()) - return 0.0; - float fret = 0.0f; - if (PXC_STATUS_NO_ERROR == m_device->QueryProperty(PXCCapture::Device::PROPERTY_COLOR_GAMMA, &fret)) - return (double)fret; + float fret = 0.0f; + if (PXC_STATUS_NO_ERROR == m_device->QueryProperty(PXCCapture::Device::PROPERTY_COLOR_HUE, &fret)) + return (double)fret; + return 0.0; + } + break; + case CV_CAP_PROP_GAMMA: + { + if (!m_device.IsValid()) return 0.0; - } - break; - case CV_CAP_PROP_SHARPNESS: - { - if (!m_device.IsValid()) - return 0.0; - float fret = 0.0f; - if (PXC_STATUS_NO_ERROR == m_device->QueryProperty(PXCCapture::Device::PROPERTY_COLOR_SHARPNESS, &fret)) - return (double)fret; + float fret = 0.0f; + if (PXC_STATUS_NO_ERROR == m_device->QueryProperty(PXCCapture::Device::PROPERTY_COLOR_GAMMA, &fret)) + return (double)fret; + return 0.0; + } + break; + case CV_CAP_PROP_SHARPNESS: + { + if (!m_device.IsValid()) return 0.0; - } - break; - case CV_CAP_PROP_GAIN: - { - if (!m_device.IsValid()) - return 0.0; - float fret = 0.0f; - if (PXC_STATUS_NO_ERROR == m_device->QueryProperty(PXCCapture::Device::PROPERTY_COLOR_GAIN, &fret)) - return (double)fret; + float fret = 0.0f; + if (PXC_STATUS_NO_ERROR == m_device->QueryProperty(PXCCapture::Device::PROPERTY_COLOR_SHARPNESS, &fret)) + return (double)fret; + return 0.0; + } + break; + case CV_CAP_PROP_GAIN: + { + if (!m_device.IsValid()) return 0.0; - } - break; - case CV_CAP_PROP_BACKLIGHT: - { - if (!m_device.IsValid()) - return 0.0; - float fret = 0.0f; - if (PXC_STATUS_NO_ERROR == m_device->QueryProperty(PXCCapture::Device::PROPERTY_COLOR_BACK_LIGHT_COMPENSATION, &fret)) - return (double)fret; + float fret = 0.0f; + if (PXC_STATUS_NO_ERROR == m_device->QueryProperty(PXCCapture::Device::PROPERTY_COLOR_GAIN, &fret)) + return (double)fret; + return 0.0; + } + break; + case CV_CAP_PROP_BACKLIGHT: + { + if (!m_device.IsValid()) return 0.0; - } - break; - case CV_CAP_PROP_EXPOSURE: - { - if (!m_device.IsValid()) - return 0.0; - float fret = 0.0f; - if (PXC_STATUS_NO_ERROR == m_device->QueryProperty(PXCCapture::Device::PROPERTY_COLOR_EXPOSURE, &fret)) - return (double)fret; + float fret = 0.0f; + if (PXC_STATUS_NO_ERROR == m_device->QueryProperty(PXCCapture::Device::PROPERTY_COLOR_BACK_LIGHT_COMPENSATION, &fret)) + return (double)fret; + return 0.0; + } + break; + case CV_CAP_PROP_EXPOSURE: + { + if (!m_device.IsValid()) return 0.0; - } - break; - //Add image stream specific properties + float fret = 0.0f; + if (PXC_STATUS_NO_ERROR == m_device->QueryProperty(PXCCapture::Device::PROPERTY_COLOR_EXPOSURE, &fret)) + return (double)fret; + return 0.0; } - return CvIntelPerCStreamBase::getProperty(propIdx); + break; + //Add image stream specific properties } - virtual bool setProperty(int propIdx, double propVal) + return IntelPerCStreamBase::getProperty(propIdx); +} +bool IntelPerCStreamImage::setProperty(int propIdx, double propVal) +{ + switch (propIdx) { - switch (propIdx) + case CV_CAP_PROP_BRIGHTNESS: { - case CV_CAP_PROP_BRIGHTNESS: - { - if (!m_device.IsValid()) - return false; - return (PXC_STATUS_NO_ERROR == m_device->SetProperty(PXCCapture::Device::PROPERTY_COLOR_BRIGHTNESS, (float)propVal)); - } - break; - case CV_CAP_PROP_CONTRAST: - { - if (!m_device.IsValid()) - return false; - return (PXC_STATUS_NO_ERROR == m_device->SetProperty(PXCCapture::Device::PROPERTY_COLOR_CONTRAST, (float)propVal)); - } - break; - case CV_CAP_PROP_SATURATION: - { - if (!m_device.IsValid()) - return false; - return (PXC_STATUS_NO_ERROR == m_device->SetProperty(PXCCapture::Device::PROPERTY_COLOR_SATURATION, (float)propVal)); - } - break; - case CV_CAP_PROP_HUE: - { - if (!m_device.IsValid()) - return false; - return (PXC_STATUS_NO_ERROR == m_device->SetProperty(PXCCapture::Device::PROPERTY_COLOR_HUE, (float)propVal)); - } - break; - case CV_CAP_PROP_GAMMA: - { - if (!m_device.IsValid()) - return false; - return (PXC_STATUS_NO_ERROR == m_device->SetProperty(PXCCapture::Device::PROPERTY_COLOR_GAMMA, (float)propVal)); - } - break; - case CV_CAP_PROP_SHARPNESS: - { - if (!m_device.IsValid()) - return false; - return (PXC_STATUS_NO_ERROR == m_device->SetProperty(PXCCapture::Device::PROPERTY_COLOR_SHARPNESS, (float)propVal)); - } - break; - case CV_CAP_PROP_GAIN: - { - if (!m_device.IsValid()) - return false; - return (PXC_STATUS_NO_ERROR == m_device->SetProperty(PXCCapture::Device::PROPERTY_COLOR_GAIN, (float)propVal)); - } - break; - case CV_CAP_PROP_BACKLIGHT: - { - if (!m_device.IsValid()) - return false; - return (PXC_STATUS_NO_ERROR == m_device->SetProperty(PXCCapture::Device::PROPERTY_COLOR_BACK_LIGHT_COMPENSATION, (float)propVal)); - } - break; - case CV_CAP_PROP_EXPOSURE: - { - if (!m_device.IsValid()) - return false; - return (PXC_STATUS_NO_ERROR == m_device->SetProperty(PXCCapture::Device::PROPERTY_COLOR_EXPOSURE, (float)propVal)); - } - break; - //Add image stream specific properties + if (!m_device.IsValid()) + return false; + return (PXC_STATUS_NO_ERROR == m_device->SetProperty(PXCCapture::Device::PROPERTY_COLOR_BRIGHTNESS, (float)propVal)); } - return CvIntelPerCStreamBase::setProperty(propIdx, propVal); - } -public: - IplImage* retrieveFrame() - { - return m_frame.retrieveFrame(); + break; + case CV_CAP_PROP_CONTRAST: + { + if (!m_device.IsValid()) + return false; + return (PXC_STATUS_NO_ERROR == m_device->SetProperty(PXCCapture::Device::PROPERTY_COLOR_CONTRAST, (float)propVal)); + } + break; + case CV_CAP_PROP_SATURATION: + { + if (!m_device.IsValid()) + return false; + return (PXC_STATUS_NO_ERROR == m_device->SetProperty(PXCCapture::Device::PROPERTY_COLOR_SATURATION, (float)propVal)); + } + break; + case CV_CAP_PROP_HUE: + { + if (!m_device.IsValid()) + return false; + return (PXC_STATUS_NO_ERROR == m_device->SetProperty(PXCCapture::Device::PROPERTY_COLOR_HUE, (float)propVal)); + } + break; + case CV_CAP_PROP_GAMMA: + { + if (!m_device.IsValid()) + return false; + return (PXC_STATUS_NO_ERROR == m_device->SetProperty(PXCCapture::Device::PROPERTY_COLOR_GAMMA, (float)propVal)); + } + break; + case CV_CAP_PROP_SHARPNESS: + { + if (!m_device.IsValid()) + return false; + return (PXC_STATUS_NO_ERROR == m_device->SetProperty(PXCCapture::Device::PROPERTY_COLOR_SHARPNESS, (float)propVal)); + } + break; + case CV_CAP_PROP_GAIN: + { + if (!m_device.IsValid()) + return false; + return (PXC_STATUS_NO_ERROR == m_device->SetProperty(PXCCapture::Device::PROPERTY_COLOR_GAIN, (float)propVal)); + } + break; + case CV_CAP_PROP_BACKLIGHT: + { + if (!m_device.IsValid()) + return false; + return (PXC_STATUS_NO_ERROR == m_device->SetProperty(PXCCapture::Device::PROPERTY_COLOR_BACK_LIGHT_COMPENSATION, (float)propVal)); + } + break; + case CV_CAP_PROP_EXPOSURE: + { + if (!m_device.IsValid()) + return false; + return (PXC_STATUS_NO_ERROR == m_device->SetProperty(PXCCapture::Device::PROPERTY_COLOR_EXPOSURE, (float)propVal)); + } + break; + //Add image stream specific properties } -protected: - FrameInternal m_frame; - bool prepareIplImage(PXCImage *pxcImage) - { - if (NULL == pxcImage) - return false; - PXCImage::ImageInfo info; - pxcImage->QueryInfo(&info); + return IntelPerCStreamBase::setProperty(propIdx, propVal); +} +bool IntelPerCStreamImage::retrieveAsOutputArray(cv::OutputArray image) +{ + if (!m_pxcImage.IsValid()) + return false; + PXCImage::ImageInfo info; + m_pxcImage->QueryInfo(&info); - PXCImage::ImageData data; - pxcImage->AcquireAccess(PXCImage::ACCESS_READ, PXCImage::COLOR_FORMAT_RGB24, &data); + PXCImage::ImageData data; + m_pxcImage->AcquireAccess(PXCImage::ACCESS_READ, PXCImage::COLOR_FORMAT_RGB24, &data); - if (PXCImage::SURFACE_TYPE_SYSTEM_MEMORY != data.type) - return false; + if (PXCImage::SURFACE_TYPE_SYSTEM_MEMORY != data.type) + return false; - cv::Mat temp(info.height, info.width, CV_8UC3, data.planes[0], data.pitches[0]); - temp.copyTo(m_frame.m_mat); + cv::Mat temp(info.height, info.width, CV_8UC3, data.planes[0], data.pitches[0]); + temp.copyTo(image); - pxcImage->ReleaseAccess(&data); - return true; - } -}; + m_pxcImage->ReleaseAccess(&data); + return true; +} -class CvIntelPerCStreamDepth - : public CvIntelPerCStreamBase +///////////////// IntelPerCStreamDepth ////////////////// + +IntelPerCStreamDepth::IntelPerCStreamDepth() { -public: - CvIntelPerCStreamDepth() - { - } - virtual ~CvIntelPerCStreamDepth() - { - } +} +IntelPerCStreamDepth::~IntelPerCStreamDepth() +{ +} - virtual bool initStream(PXCSession *session) - { - if (!initDevice(session)) - return false; - initStreamImpl(PXCImage::IMAGE_TYPE_DEPTH); - if (!m_stream.IsValid()) - return false; - enumProfiles(); - return true; - } - virtual double getProperty(int propIdx) +bool IntelPerCStreamDepth::initStream(PXCSession *session) +{ + if (!initDevice(session)) + return false; + initStreamImpl(PXCImage::IMAGE_TYPE_DEPTH); + if (!m_stream.IsValid()) + return false; + enumProfiles(); + return true; +} +double IntelPerCStreamDepth::getProperty(int propIdx) +{ + switch (propIdx) { - switch (propIdx) + case CV_CAP_PROP_INTELPERC_DEPTH_LOW_CONFIDENCE_VALUE: { - case CV_CAP_PROP_INTELPERC_DEPTH_LOW_CONFIDENCE_VALUE: - { - if (!m_device.IsValid()) - return 0.0; - float fret = 0.0f; - if (PXC_STATUS_NO_ERROR == m_device->QueryProperty(PXCCapture::Device::PROPERTY_DEPTH_LOW_CONFIDENCE_VALUE, &fret)) - return (double)fret; + if (!m_device.IsValid()) return 0.0; - } - break; - case CV_CAP_PROP_INTELPERC_DEPTH_SATURATION_VALUE: - { - if (!m_device.IsValid()) - return 0.0; - float fret = 0.0f; - if (PXC_STATUS_NO_ERROR == m_device->QueryProperty(PXCCapture::Device::PROPERTY_DEPTH_SATURATION_VALUE, &fret)) - return (double)fret; - return 0.0; - } - break; - case CV_CAP_PROP_INTELPERC_DEPTH_CONFIDENCE_THRESHOLD: - { - if (!m_device.IsValid()) - return 0.0; - float fret = 0.0f; - if (PXC_STATUS_NO_ERROR == m_device->QueryProperty(PXCCapture::Device::PROPERTY_DEPTH_CONFIDENCE_THRESHOLD, &fret)) - return (double)fret; - return 0.0; - } - break; - case CV_CAP_PROP_INTELPERC_DEPTH_FOCAL_LENGTH_HORZ: - { - if (!m_device.IsValid()) - return 0.0f; - PXCPointF32 ptf; - if (PXC_STATUS_NO_ERROR == m_device->QueryPropertyAsPoint(PXCCapture::Device::PROPERTY_DEPTH_FOCAL_LENGTH, &ptf)) - return (double)ptf.x; + float fret = 0.0f; + if (PXC_STATUS_NO_ERROR == m_device->QueryProperty(PXCCapture::Device::PROPERTY_DEPTH_LOW_CONFIDENCE_VALUE, &fret)) + return (double)fret; + return 0.0; + } + break; + case CV_CAP_PROP_INTELPERC_DEPTH_SATURATION_VALUE: + { + if (!m_device.IsValid()) return 0.0; - } - break; - case CV_CAP_PROP_INTELPERC_DEPTH_FOCAL_LENGTH_VERT: - { - if (!m_device.IsValid()) - return 0.0f; - PXCPointF32 ptf; - if (PXC_STATUS_NO_ERROR == m_device->QueryPropertyAsPoint(PXCCapture::Device::PROPERTY_DEPTH_FOCAL_LENGTH, &ptf)) - return (double)ptf.y; + float fret = 0.0f; + if (PXC_STATUS_NO_ERROR == m_device->QueryProperty(PXCCapture::Device::PROPERTY_DEPTH_SATURATION_VALUE, &fret)) + return (double)fret; + return 0.0; + } + break; + case CV_CAP_PROP_INTELPERC_DEPTH_CONFIDENCE_THRESHOLD: + { + if (!m_device.IsValid()) return 0.0; - } - break; - //Add depth stream sepcific properties + float fret = 0.0f; + if (PXC_STATUS_NO_ERROR == m_device->QueryProperty(PXCCapture::Device::PROPERTY_DEPTH_CONFIDENCE_THRESHOLD, &fret)) + return (double)fret; + return 0.0; } - return CvIntelPerCStreamBase::getProperty(propIdx); - } - virtual bool setProperty(int propIdx, double propVal) - { - switch (propIdx) + break; + case CV_CAP_PROP_INTELPERC_DEPTH_FOCAL_LENGTH_HORZ: { - case CV_CAP_PROP_INTELPERC_DEPTH_LOW_CONFIDENCE_VALUE: - { - if (!m_device.IsValid()) - return false; - return (PXC_STATUS_NO_ERROR == m_device->SetProperty(PXCCapture::Device::PROPERTY_DEPTH_LOW_CONFIDENCE_VALUE, (float)propVal)); - } - break; - case CV_CAP_PROP_INTELPERC_DEPTH_SATURATION_VALUE: - { - if (!m_device.IsValid()) - return false; - return (PXC_STATUS_NO_ERROR == m_device->SetProperty(PXCCapture::Device::PROPERTY_DEPTH_SATURATION_VALUE, (float)propVal)); - } - break; - case CV_CAP_PROP_INTELPERC_DEPTH_CONFIDENCE_THRESHOLD: - { - if (!m_device.IsValid()) - return false; - return (PXC_STATUS_NO_ERROR == m_device->SetProperty(PXCCapture::Device::PROPERTY_DEPTH_CONFIDENCE_THRESHOLD, (float)propVal)); - } - break; - //Add depth stream sepcific properties + if (!m_device.IsValid()) + return 0.0f; + PXCPointF32 ptf; + if (PXC_STATUS_NO_ERROR == m_device->QueryPropertyAsPoint(PXCCapture::Device::PROPERTY_DEPTH_FOCAL_LENGTH, &ptf)) + return (double)ptf.x; + return 0.0; } - return CvIntelPerCStreamBase::setProperty(propIdx, propVal); - } -public: - IplImage* retrieveDepthFrame() - { - return m_frameDepth.retrieveFrame(); - } - IplImage* retrieveIRFrame() - { - return m_frameIR.retrieveFrame(); - } - IplImage* retrieveUVFrame() - { - return m_frameUV.retrieveFrame(); - } -protected: - virtual bool validProfile(const PXCCapture::VideoStream::ProfileInfo& pinfo) - { - return (PXCImage::COLOR_FORMAT_DEPTH == pinfo.imageInfo.format); + break; + case CV_CAP_PROP_INTELPERC_DEPTH_FOCAL_LENGTH_VERT: + { + if (!m_device.IsValid()) + return 0.0f; + PXCPointF32 ptf; + if (PXC_STATUS_NO_ERROR == m_device->QueryPropertyAsPoint(PXCCapture::Device::PROPERTY_DEPTH_FOCAL_LENGTH, &ptf)) + return (double)ptf.y; + return 0.0; + } + break; + //Add depth stream sepcific properties } -protected: - FrameInternal m_frameDepth; - FrameInternal m_frameIR; - FrameInternal m_frameUV; - - bool prepareIplImage(PXCImage *pxcImage) + return IntelPerCStreamBase::getProperty(propIdx); +} +bool IntelPerCStreamDepth::setProperty(int propIdx, double propVal) +{ + switch (propIdx) { - if (NULL == pxcImage) - return false; - PXCImage::ImageInfo info; - pxcImage->QueryInfo(&info); - - PXCImage::ImageData data; - pxcImage->AcquireAccess(PXCImage::ACCESS_READ, &data); - - if (PXCImage::SURFACE_TYPE_SYSTEM_MEMORY != data.type) - return false; - - if (PXCImage::COLOR_FORMAT_DEPTH != data.format) - return false; - + case CV_CAP_PROP_INTELPERC_DEPTH_LOW_CONFIDENCE_VALUE: { - cv::Mat temp(info.height, info.width, CV_16SC1, data.planes[0], data.pitches[0]); - temp.copyTo(m_frameDepth.m_mat); + if (!m_device.IsValid()) + return false; + return (PXC_STATUS_NO_ERROR == m_device->SetProperty(PXCCapture::Device::PROPERTY_DEPTH_LOW_CONFIDENCE_VALUE, (float)propVal)); } + break; + case CV_CAP_PROP_INTELPERC_DEPTH_SATURATION_VALUE: { - cv::Mat temp(info.height, info.width, CV_16SC1, data.planes[1], data.pitches[1]); - temp.copyTo(m_frameIR.m_mat); + if (!m_device.IsValid()) + return false; + return (PXC_STATUS_NO_ERROR == m_device->SetProperty(PXCCapture::Device::PROPERTY_DEPTH_SATURATION_VALUE, (float)propVal)); } + break; + case CV_CAP_PROP_INTELPERC_DEPTH_CONFIDENCE_THRESHOLD: { - cv::Mat temp(info.height, info.width, CV_32FC2, data.planes[2], data.pitches[2]); - temp.copyTo(m_frameUV.m_mat); + if (!m_device.IsValid()) + return false; + return (PXC_STATUS_NO_ERROR == m_device->SetProperty(PXCCapture::Device::PROPERTY_DEPTH_CONFIDENCE_THRESHOLD, (float)propVal)); } - - pxcImage->ReleaseAccess(&data); - return true; + break; + //Add depth stream sepcific properties } -}; + return IntelPerCStreamBase::setProperty(propIdx, propVal); +} +bool IntelPerCStreamDepth::retrieveDepthAsOutputArray(cv::OutputArray image) +{ + return retriveFrame(CV_16SC1, 0, image); +} +bool IntelPerCStreamDepth::retrieveIRAsOutputArray(cv::OutputArray image) +{ + return retriveFrame(CV_16SC1, 1, image); +} +bool IntelPerCStreamDepth::retrieveUVAsOutputArray(cv::OutputArray image) +{ + return retriveFrame(CV_32FC2, 2, image); +} +bool IntelPerCStreamDepth::validProfile(const PXCCapture::VideoStream::ProfileInfo& pinfo) +{ + return (PXCImage::COLOR_FORMAT_DEPTH == pinfo.imageInfo.format); +} +bool IntelPerCStreamDepth::retriveFrame(int type, int planeIdx, cv::OutputArray frame) +{ + if (!m_pxcImage.IsValid()) + return false; + PXCImage::ImageInfo info; + m_pxcImage->QueryInfo(&info); + + PXCImage::ImageData data; + m_pxcImage->AcquireAccess(PXCImage::ACCESS_READ, &data); + + if (PXCImage::SURFACE_TYPE_SYSTEM_MEMORY != data.type) + return false; + + cv::Mat temp(info.height, info.width, type, data.planes[planeIdx], data.pitches[planeIdx]); + temp.copyTo(frame); + + m_pxcImage->ReleaseAccess(&data); + return true; +} -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -class CvCapture_IntelPerC : public CvCapture +///////////////// VideoCapture_IntelPerC ////////////////// + +VideoCapture_IntelPerC::VideoCapture_IntelPerC() + : m_contextOpened(false) +{ + pxcStatus sts = PXCSession_Create(&m_session); + if (PXC_STATUS_NO_ERROR > sts) + return; + m_contextOpened = m_imageStream.initStream(m_session); + m_contextOpened &= m_depthStream.initStream(m_session); +} +VideoCapture_IntelPerC::~VideoCapture_IntelPerC(){} + +double VideoCapture_IntelPerC::getProperty(int propIdx) { -public: - CvCapture_IntelPerC(int /*index*/) - : m_contextOpened(false) + double propValue = 0; + int purePropIdx = propIdx & ~CV_CAP_INTELPERC_GENERATORS_MASK; + if (CV_CAP_INTELPERC_IMAGE_GENERATOR == (propIdx & CV_CAP_INTELPERC_GENERATORS_MASK)) { - pxcStatus sts = PXCSession_Create(&m_session); - if (PXC_STATUS_NO_ERROR > sts) - return; - m_contextOpened = m_imageStream.initStream(m_session); - m_contextOpened &= m_depthStream.initStream(m_session); + propValue = m_imageStream.getProperty(purePropIdx); } - virtual ~CvCapture_IntelPerC(){} - - virtual double getProperty(int propIdx) + else if (CV_CAP_INTELPERC_DEPTH_GENERATOR == (propIdx & CV_CAP_INTELPERC_GENERATORS_MASK)) { - double propValue = 0; - int purePropIdx = propIdx & ~CV_CAP_INTELPERC_GENERATORS_MASK; - if (CV_CAP_INTELPERC_IMAGE_GENERATOR == (propIdx & CV_CAP_INTELPERC_GENERATORS_MASK)) - { - propValue = m_imageStream.getProperty(purePropIdx); - } - else if (CV_CAP_INTELPERC_DEPTH_GENERATOR == (propIdx & CV_CAP_INTELPERC_GENERATORS_MASK)) - { - propValue = m_depthStream.getProperty(purePropIdx); - } - else - { - propValue = m_depthStream.getProperty(purePropIdx); - } - return propValue; + propValue = m_depthStream.getProperty(purePropIdx); } - virtual bool setProperty(int propIdx, double propVal) + else { - bool isSet = false; - int purePropIdx = propIdx & ~CV_CAP_INTELPERC_GENERATORS_MASK; - if (CV_CAP_INTELPERC_IMAGE_GENERATOR == (propIdx & CV_CAP_INTELPERC_GENERATORS_MASK)) - { - isSet = m_imageStream.setProperty(purePropIdx, propVal); - } - else if (CV_CAP_INTELPERC_DEPTH_GENERATOR == (propIdx & CV_CAP_INTELPERC_GENERATORS_MASK)) - { - isSet = m_depthStream.setProperty(purePropIdx, propVal); - } - else - { - isSet = m_depthStream.setProperty(purePropIdx, propVal); - } - return isSet; + propValue = m_depthStream.getProperty(purePropIdx); } - - bool grabFrame() + return propValue; +} +bool VideoCapture_IntelPerC::setProperty(int propIdx, double propVal) +{ + bool isSet = false; + int purePropIdx = propIdx & ~CV_CAP_INTELPERC_GENERATORS_MASK; + if (CV_CAP_INTELPERC_IMAGE_GENERATOR == (propIdx & CV_CAP_INTELPERC_GENERATORS_MASK)) { - if (!isOpened()) - return false; - - bool isGrabbed = false; - if (m_depthStream.isValid()) - isGrabbed = m_depthStream.grabFrame(); - if ((m_imageStream.isValid()) && (-1 != m_imageStream.getProfileIDX())) - isGrabbed &= m_imageStream.grabFrame(); - - return isGrabbed; + isSet = m_imageStream.setProperty(purePropIdx, propVal); } - - virtual IplImage* retrieveFrame(int outputType) + else if (CV_CAP_INTELPERC_DEPTH_GENERATOR == (propIdx & CV_CAP_INTELPERC_GENERATORS_MASK)) { - IplImage* image = 0; - switch (outputType) - { - case CV_CAP_INTELPERC_DEPTH_MAP: - image = m_depthStream.retrieveDepthFrame(); - break; - case CV_CAP_INTELPERC_UVDEPTH_MAP: - image = m_depthStream.retrieveUVFrame(); - break; - case CV_CAP_INTELPERC_IR_MAP: - image = m_depthStream.retrieveIRFrame(); - break; - case CV_CAP_INTELPERC_IMAGE: - image = m_imageStream.retrieveFrame(); - break; - } - CV_Assert(NULL != image); - return image; + isSet = m_depthStream.setProperty(purePropIdx, propVal); } - - bool isOpened() const + else { - return m_contextOpened; + isSet = m_depthStream.setProperty(purePropIdx, propVal); } -protected: - bool m_contextOpened; + return isSet; +} - PXCSmartPtr m_session; - CvIntelPerCStreamImage m_imageStream; - CvIntelPerCStreamDepth m_depthStream; -}; +bool VideoCapture_IntelPerC::grabFrame() +{ + if (!isOpened()) + return false; + bool isGrabbed = false; + if (m_depthStream.isValid()) + isGrabbed = m_depthStream.grabFrame(); + if ((m_imageStream.isValid()) && (-1 != m_imageStream.getProfileIDX())) + isGrabbed &= m_imageStream.grabFrame(); -CvCapture* cvCreateCameraCapture_IntelPerC(int index) + return isGrabbed; +} +bool VideoCapture_IntelPerC::retrieveFrame(int outputType, cv::OutputArray frame) { - CvCapture_IntelPerC* capture = new CvCapture_IntelPerC(index); - - if( capture->isOpened() ) - return capture; + switch (outputType) + { + case CV_CAP_INTELPERC_DEPTH_MAP: + return m_depthStream.retrieveDepthAsOutputArray(frame); + case CV_CAP_INTELPERC_UVDEPTH_MAP: + return m_depthStream.retrieveUVAsOutputArray(frame); + case CV_CAP_INTELPERC_IR_MAP: + return m_depthStream.retrieveIRAsOutputArray(frame); + case CV_CAP_INTELPERC_IMAGE: + return m_imageStream.retrieveAsOutputArray(frame); + } + return false; +} +int VideoCapture_IntelPerC::getCaptureDomain() +{ + return CV_CAP_INTELPERC; +} - delete capture; - return 0; +bool VideoCapture_IntelPerC::isOpened() const +{ + return m_contextOpened; } +} #endif //HAVE_INTELPERC diff --git a/modules/highgui/src/cap_intelperc.hpp b/modules/highgui/src/cap_intelperc.hpp new file mode 100644 index 0000000..73ba516 --- /dev/null +++ b/modules/highgui/src/cap_intelperc.hpp @@ -0,0 +1,145 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// Intel License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2000, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's 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. +// +// * The name of Intel Corporation may not 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 Intel Corporation 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. +// +//M*/ + +#ifndef _CAP_INTELPERC_HPP_ +#define _CAP_INTELPERC_HPP_ + +#include "precomp.hpp" + +#ifdef HAVE_INTELPERC + +#include "pxcsession.h" +#include "pxcsmartptr.h" +#include "pxccapture.h" + +namespace cv +{ + +class IntelPerCStreamBase +{ +public: + IntelPerCStreamBase(); + virtual ~IntelPerCStreamBase(); + + bool isValid(); + bool grabFrame(); + int getProfileIDX() const; +public: + virtual bool initStream(PXCSession *session) = 0; + virtual double getProperty(int propIdx); + virtual bool setProperty(int propIdx, double propVal); +protected: + PXCSmartPtr m_device; + bool initDevice(PXCSession *session); + + PXCSmartPtr m_stream; + void initStreamImpl(PXCImage::ImageType type); +protected: + std::vector m_profiles; + int m_profileIdx; + int m_frameIdx; + pxcU64 m_timeStampStartNS; + double m_timeStamp; + PXCSmartPtr m_pxcImage; + + virtual bool validProfile(const PXCCapture::VideoStream::ProfileInfo& /*pinfo*/); + void enumProfiles(); +}; + +class IntelPerCStreamImage + : public IntelPerCStreamBase +{ +public: + IntelPerCStreamImage(); + virtual ~IntelPerCStreamImage(); + + virtual bool initStream(PXCSession *session); + virtual double getProperty(int propIdx); + virtual bool setProperty(int propIdx, double propVal); +public: + bool retrieveAsOutputArray(OutputArray image); +}; + +class IntelPerCStreamDepth + : public IntelPerCStreamBase +{ +public: + IntelPerCStreamDepth(); + virtual ~IntelPerCStreamDepth(); + + virtual bool initStream(PXCSession *session); + virtual double getProperty(int propIdx); + virtual bool setProperty(int propIdx, double propVal); +public: + bool retrieveDepthAsOutputArray(OutputArray image); + bool retrieveIRAsOutputArray(OutputArray image); + bool retrieveUVAsOutputArray(OutputArray image); +protected: + virtual bool validProfile(const PXCCapture::VideoStream::ProfileInfo& pinfo); +protected: + bool retriveFrame(int type, int planeIdx, OutputArray frame); +}; + +class VideoCapture_IntelPerC : public IVideoCapture +{ +public: + VideoCapture_IntelPerC(); + virtual ~VideoCapture_IntelPerC(); + + virtual double getProperty(int propIdx); + virtual bool setProperty(int propIdx, double propVal); + + virtual bool grabFrame(); + virtual bool retrieveFrame(int outputType, OutputArray frame); + virtual int getCaptureDomain(); + bool isOpened() const; +protected: + bool m_contextOpened; + + PXCSmartPtr m_session; + IntelPerCStreamImage m_imageStream; + IntelPerCStreamDepth m_depthStream; +}; + +} + +#endif //HAVE_INTELPERC +#endif //_CAP_INTELPERC_HPP_ \ No newline at end of file diff --git a/modules/highgui/src/precomp.hpp b/modules/highgui/src/precomp.hpp index fbd0640..5c0ed6e 100644 --- a/modules/highgui/src/precomp.hpp +++ b/modules/highgui/src/precomp.hpp @@ -136,8 +136,6 @@ CvCapture* cvCreateFileCapture_OpenNI( const char* filename ); CvCapture* cvCreateCameraCapture_Android( int index ); CvCapture* cvCreateCameraCapture_XIMEA( int index ); CvCapture* cvCreateCameraCapture_AVFoundation(int index); -CvCapture* cvCreateCameraCapture_IntelPerC(int index); - CVAPI(int) cvHaveImageReader(const char* filename); CVAPI(int) cvHaveImageWriter(const char* filename); -- 2.7.4