CoCalc -- cap_intelperc.cpp

GitHub Repository: Tetragramm/opencv
Path: blob/master/modules/videoio/src/cap_intelperc.cpp
¹⁶³⁵⁴ views
1
#ifdef HAVE_INTELPERC
2

3
#include "cap_intelperc.hpp"
4

5
namespace cv
6
{
7

8
///////////////// IntelPerCStreamBase //////////////////
9

10
IntelPerCStreamBase::IntelPerCStreamBase()
11
    : m_profileIdx(-1)
12
    , m_frameIdx(0)
13
    , m_timeStampStartNS(0)
14
{
15
}
16
IntelPerCStreamBase::~IntelPerCStreamBase()
17
{
18
}
19

20
bool IntelPerCStreamBase::isValid()
21
{
22
    return (m_device.IsValid() && m_stream.IsValid());
23
}
24
bool IntelPerCStreamBase::grabFrame()
25
{
26
    if (!m_stream.IsValid())
27
        return false;
28
    if (-1 == m_profileIdx)
29
    {
30
        if (!setProperty(CV_CAP_PROP_INTELPERC_PROFILE_IDX, 0))
31
            return false;
32
    }
33
    PXCSmartSP sp;
34
    m_pxcImage.ReleaseRef();
35
    if (PXC_STATUS_NO_ERROR > m_stream->ReadStreamAsync(&m_pxcImage, &sp))
36
        return false;
37
    if (PXC_STATUS_NO_ERROR > sp->Synchronize())
38
        return false;
39
    if (0 == m_timeStampStartNS)
40
        m_timeStampStartNS = m_pxcImage->QueryTimeStamp();
41
    m_timeStamp = (double)((m_pxcImage->QueryTimeStamp() - m_timeStampStartNS) / 10000);
42
    m_frameIdx++;
43
    return true;
44
}
45
int IntelPerCStreamBase::getProfileIDX() const
46
{
47
    return m_profileIdx;
48
}
49
double IntelPerCStreamBase::getProperty(int propIdx) const
50
{
51
    double ret = 0.0;
52
    switch (propIdx)
53
    {
54
    case CV_CAP_PROP_INTELPERC_PROFILE_COUNT:
55
        ret = (double)m_profiles.size();
56
        break;
57
    case CV_CAP_PROP_FRAME_WIDTH :
58
        if ((0 <= m_profileIdx) && (m_profileIdx < m_profiles.size()))
59
            ret = (double)m_profiles[m_profileIdx].imageInfo.width;
60
        break;
61
    case CV_CAP_PROP_FRAME_HEIGHT :
62
        if ((0 <= m_profileIdx) && (m_profileIdx < m_profiles.size()))
63
            ret = (double)m_profiles[m_profileIdx].imageInfo.height;
64
        break;
65
    case CV_CAP_PROP_FPS :
66
        if ((0 <= m_profileIdx) && (m_profileIdx < m_profiles.size()))
67
        {
68
            ret = ((double)m_profiles[m_profileIdx].frameRateMin.numerator / (double)m_profiles[m_profileIdx].frameRateMin.denominator
69
                    + (double)m_profiles[m_profileIdx].frameRateMax.numerator / (double)m_profiles[m_profileIdx].frameRateMax.denominator) / 2.0;
70
        }
71
        break;
72
    case CV_CAP_PROP_POS_FRAMES:
73
        ret  = (double)m_frameIdx;
74
        break;
75
    case CV_CAP_PROP_POS_MSEC:
76
        ret  = m_timeStamp;
77
        break;
78
    };
79
    return ret;
80
}
81
bool IntelPerCStreamBase::setProperty(int propIdx, double propVal)
82
{
83
    bool isSet = false;
84
    switch (propIdx)
85
    {
86
    case CV_CAP_PROP_INTELPERC_PROFILE_IDX:
87
        {
88
            int propValInt = (int)propVal;
89
            if (0 > propValInt)
90
            {
91
                m_profileIdx = propValInt;
92
                isSet = true;
93
            }
94
            else if (propValInt < m_profiles.size())
95
            {
96
                if (m_profileIdx != propValInt)
97
                {
98
                    m_profileIdx = propValInt;
99
                    if (m_stream.IsValid())
100
                        m_stream->SetProfile(&m_profiles[m_profileIdx]);
101
                    m_frameIdx = 0;
102
                    m_timeStampStartNS = 0;
103
                }
104
                isSet = true;
105
            }
106
        }
107
        break;
108
    };
109
    return isSet;
110
}
111
bool IntelPerCStreamBase::initDevice(PXCSession *session)
112
{
113
    if (NULL == session)
114
        return false;
115

116
    pxcStatus sts = PXC_STATUS_NO_ERROR;
117
    PXCSession::ImplDesc templat;
118
    memset(&templat,0,sizeof(templat));
119
    templat.group   = PXCSession::IMPL_GROUP_SENSOR;
120
    templat.subgroup= PXCSession::IMPL_SUBGROUP_VIDEO_CAPTURE;
121

122
    for (int modidx = 0; PXC_STATUS_NO_ERROR <= sts; modidx++)
123
    {
124
        PXCSession::ImplDesc desc;
125
        sts = session->QueryImpl(&templat, modidx, &desc);
126
        if (PXC_STATUS_NO_ERROR > sts)
127
            break;
128

129
        PXCSmartPtr<PXCCapture> capture;
130
        sts = session->CreateImpl<PXCCapture>(&desc, &capture);
131
        if (!capture.IsValid())
132
            continue;
133

134
        /* enumerate devices */
135
        for (int devidx = 0; PXC_STATUS_NO_ERROR <= sts; devidx++)
136
        {
137
            PXCSmartPtr<PXCCapture::Device> device;
138
            sts = capture->CreateDevice(devidx, &device);
139
            if (PXC_STATUS_NO_ERROR <= sts)
140
            {
141
                m_device = device.ReleasePtr();
142
                return true;
143
            }
144
        }
145
    }
146
    return false;
147
}
148

149
void IntelPerCStreamBase::initStreamImpl(PXCImage::ImageType type)
150
{
151
    if (!m_device.IsValid())
152
        return;
153

154
    pxcStatus sts = PXC_STATUS_NO_ERROR;
155
    /* enumerate streams */
156
    for (int streamidx = 0; PXC_STATUS_NO_ERROR <= sts; streamidx++)
157
    {
158
        PXCCapture::Device::StreamInfo sinfo;
159
        sts = m_device->QueryStream(streamidx, &sinfo);
160
        if (PXC_STATUS_NO_ERROR > sts)
161
            break;
162
        if (PXCCapture::VideoStream::CUID != sinfo.cuid)
163
            continue;
164
        if (type != sinfo.imageType)
165
            continue;
166

167
        sts = m_device->CreateStream<PXCCapture::VideoStream>(streamidx, &m_stream);
168
        if (PXC_STATUS_NO_ERROR == sts)
169
            break;
170
        m_stream.ReleaseRef();
171
    }
172
}
173
bool IntelPerCStreamBase::validProfile(const PXCCapture::VideoStream::ProfileInfo& /*pinfo*/)
174
{
175
    return true;
176
}
177
void IntelPerCStreamBase::enumProfiles()
178
{
179
    m_profiles.clear();
180
    if (!m_stream.IsValid())
181
        return;
182
    pxcStatus sts = PXC_STATUS_NO_ERROR;
183
    for (int profidx = 0; PXC_STATUS_NO_ERROR <= sts; profidx++)
184
    {
185
        PXCCapture::VideoStream::ProfileInfo pinfo;
186
        sts = m_stream->QueryProfile(profidx, &pinfo);
187
        if (PXC_STATUS_NO_ERROR > sts)
188
            break;
189
        if (validProfile(pinfo))
190
            m_profiles.push_back(pinfo);
191
    }
192
}
193

194
///////////////// IntelPerCStreamImage //////////////////
195

196
IntelPerCStreamImage::IntelPerCStreamImage()
197
{
198
}
199
IntelPerCStreamImage::~IntelPerCStreamImage()
200
{
201
}
202

203
bool IntelPerCStreamImage::initStream(PXCSession *session)
204
{
205
    if (!initDevice(session))
206
        return false;
207
    initStreamImpl(PXCImage::IMAGE_TYPE_COLOR);
208
    if (!m_stream.IsValid())
209
        return false;
210
    enumProfiles();
211
    return true;
212
}
213
double IntelPerCStreamImage::getProperty(int propIdx) const
214
{
215
    switch (propIdx)
216
    {
217
    case CV_CAP_PROP_BRIGHTNESS:
218
        {
219
            if (!m_device.IsValid())
220
                return 0.0;
221
            float fret = 0.0f;
222
            if (PXC_STATUS_NO_ERROR == m_device->QueryProperty(PXCCapture::Device::PROPERTY_COLOR_BRIGHTNESS, &fret))
223
                return (double)fret;
224
            return 0.0;
225
        }
226
        break;
227
    case CV_CAP_PROP_CONTRAST:
228
        {
229
            if (!m_device.IsValid())
230
                return 0.0;
231
            float fret = 0.0f;
232
            if (PXC_STATUS_NO_ERROR == m_device->QueryProperty(PXCCapture::Device::PROPERTY_COLOR_CONTRAST, &fret))
233
                return (double)fret;
234
            return 0.0;
235
        }
236
        break;
237
    case CV_CAP_PROP_SATURATION:
238
        {
239
            if (!m_device.IsValid())
240
                return 0.0;
241
            float fret = 0.0f;
242
            if (PXC_STATUS_NO_ERROR == m_device->QueryProperty(PXCCapture::Device::PROPERTY_COLOR_SATURATION, &fret))
243
                return (double)fret;
244
            return 0.0;
245
        }
246
        break;
247
    case CV_CAP_PROP_HUE:
248
        {
249
            if (!m_device.IsValid())
250
                return 0.0;
251
            float fret = 0.0f;
252
            if (PXC_STATUS_NO_ERROR == m_device->QueryProperty(PXCCapture::Device::PROPERTY_COLOR_HUE, &fret))
253
                return (double)fret;
254
            return 0.0;
255
        }
256
        break;
257
    case CV_CAP_PROP_GAMMA:
258
        {
259
            if (!m_device.IsValid())
260
                return 0.0;
261
            float fret = 0.0f;
262
            if (PXC_STATUS_NO_ERROR == m_device->QueryProperty(PXCCapture::Device::PROPERTY_COLOR_GAMMA, &fret))
263
                return (double)fret;
264
            return 0.0;
265
        }
266
        break;
267
    case CV_CAP_PROP_SHARPNESS:
268
        {
269
            if (!m_device.IsValid())
270
                return 0.0;
271
            float fret = 0.0f;
272
            if (PXC_STATUS_NO_ERROR == m_device->QueryProperty(PXCCapture::Device::PROPERTY_COLOR_SHARPNESS, &fret))
273
                return (double)fret;
274
            return 0.0;
275
        }
276
        break;
277
    case CV_CAP_PROP_GAIN:
278
        {
279
            if (!m_device.IsValid())
280
                return 0.0;
281
            float fret = 0.0f;
282
            if (PXC_STATUS_NO_ERROR == m_device->QueryProperty(PXCCapture::Device::PROPERTY_COLOR_GAIN, &fret))
283
                return (double)fret;
284
            return 0.0;
285
        }
286
        break;
287
    case CV_CAP_PROP_BACKLIGHT:
288
        {
289
            if (!m_device.IsValid())
290
                return 0.0;
291
            float fret = 0.0f;
292
            if (PXC_STATUS_NO_ERROR == m_device->QueryProperty(PXCCapture::Device::PROPERTY_COLOR_BACK_LIGHT_COMPENSATION, &fret))
293
                return (double)fret;
294
            return 0.0;
295
        }
296
        break;
297
    case CV_CAP_PROP_EXPOSURE:
298
        {
299
            if (!m_device.IsValid())
300
                return 0.0;
301
            float fret = 0.0f;
302
            if (PXC_STATUS_NO_ERROR == m_device->QueryProperty(PXCCapture::Device::PROPERTY_COLOR_EXPOSURE, &fret))
303
                return (double)fret;
304
            return 0.0;
305
        }
306
        break;
307
    //Add image stream specific properties
308
    }
309
    return IntelPerCStreamBase::getProperty(propIdx);
310
}
311
bool IntelPerCStreamImage::setProperty(int propIdx, double propVal)
312
{
313
    switch (propIdx)
314
    {
315
    case CV_CAP_PROP_BRIGHTNESS:
316
        {
317
            if (!m_device.IsValid())
318
                return false;
319
            return (PXC_STATUS_NO_ERROR == m_device->SetProperty(PXCCapture::Device::PROPERTY_COLOR_BRIGHTNESS, (float)propVal));
320
        }
321
        break;
322
    case CV_CAP_PROP_CONTRAST:
323
        {
324
            if (!m_device.IsValid())
325
                return false;
326
            return (PXC_STATUS_NO_ERROR == m_device->SetProperty(PXCCapture::Device::PROPERTY_COLOR_CONTRAST, (float)propVal));
327
        }
328
        break;
329
    case CV_CAP_PROP_SATURATION:
330
        {
331
            if (!m_device.IsValid())
332
                return false;
333
            return (PXC_STATUS_NO_ERROR == m_device->SetProperty(PXCCapture::Device::PROPERTY_COLOR_SATURATION, (float)propVal));
334
        }
335
        break;
336
    case CV_CAP_PROP_HUE:
337
        {
338
            if (!m_device.IsValid())
339
                return false;
340
            return (PXC_STATUS_NO_ERROR == m_device->SetProperty(PXCCapture::Device::PROPERTY_COLOR_HUE, (float)propVal));
341
        }
342
        break;
343
    case CV_CAP_PROP_GAMMA:
344
        {
345
            if (!m_device.IsValid())
346
                return false;
347
            return (PXC_STATUS_NO_ERROR == m_device->SetProperty(PXCCapture::Device::PROPERTY_COLOR_GAMMA, (float)propVal));
348
        }
349
        break;
350
    case CV_CAP_PROP_SHARPNESS:
351
        {
352
            if (!m_device.IsValid())
353
                return false;
354
            return (PXC_STATUS_NO_ERROR == m_device->SetProperty(PXCCapture::Device::PROPERTY_COLOR_SHARPNESS, (float)propVal));
355
        }
356
        break;
357
    case CV_CAP_PROP_GAIN:
358
        {
359
            if (!m_device.IsValid())
360
                return false;
361
            return (PXC_STATUS_NO_ERROR == m_device->SetProperty(PXCCapture::Device::PROPERTY_COLOR_GAIN, (float)propVal));
362
        }
363
        break;
364
    case CV_CAP_PROP_BACKLIGHT:
365
        {
366
            if (!m_device.IsValid())
367
                return false;
368
            return (PXC_STATUS_NO_ERROR == m_device->SetProperty(PXCCapture::Device::PROPERTY_COLOR_BACK_LIGHT_COMPENSATION, (float)propVal));
369
        }
370
        break;
371
    case CV_CAP_PROP_EXPOSURE:
372
        {
373
            if (!m_device.IsValid())
374
                return false;
375
            return (PXC_STATUS_NO_ERROR == m_device->SetProperty(PXCCapture::Device::PROPERTY_COLOR_EXPOSURE, (float)propVal));
376
        }
377
        break;
378
    //Add image stream specific properties
379
    }
380
    return IntelPerCStreamBase::setProperty(propIdx, propVal);
381
}
382
bool IntelPerCStreamImage::retrieveAsOutputArray(cv::OutputArray image)
383
{
384
    if (!m_pxcImage.IsValid())
385
        return false;
386
    PXCImage::ImageInfo info;
387
    m_pxcImage->QueryInfo(&info);
388

389
    PXCImage::ImageData data;
390
    m_pxcImage->AcquireAccess(PXCImage::ACCESS_READ, PXCImage::COLOR_FORMAT_RGB24, &data);
391

392
    if (PXCImage::SURFACE_TYPE_SYSTEM_MEMORY != data.type)
393
        return false;
394

395
    cv::Mat temp(info.height, info.width, CV_8UC3, data.planes[0], data.pitches[0]);
396
    temp.copyTo(image);
397

398
    m_pxcImage->ReleaseAccess(&data);
399
    return true;
400
}
401

402
///////////////// IntelPerCStreamDepth //////////////////
403

404
IntelPerCStreamDepth::IntelPerCStreamDepth()
405
{
406
}
407
IntelPerCStreamDepth::~IntelPerCStreamDepth()
408
{
409
}
410

411
bool IntelPerCStreamDepth::initStream(PXCSession *session)
412
{
413
    if (!initDevice(session))
414
        return false;
415
    initStreamImpl(PXCImage::IMAGE_TYPE_DEPTH);
416
    if (!m_stream.IsValid())
417
        return false;
418
    enumProfiles();
419
    return true;
420
}
421
double IntelPerCStreamDepth::getProperty(int propIdx) const
422
{
423
    switch (propIdx)
424
    {
425
    case CV_CAP_PROP_INTELPERC_DEPTH_LOW_CONFIDENCE_VALUE:
426
        {
427
            if (!m_device.IsValid())
428
                return 0.0;
429
            float fret = 0.0f;
430
            if (PXC_STATUS_NO_ERROR == m_device->QueryProperty(PXCCapture::Device::PROPERTY_DEPTH_LOW_CONFIDENCE_VALUE, &fret))
431
                return (double)fret;
432
            return 0.0;
433
        }
434
        break;
435
    case CV_CAP_PROP_INTELPERC_DEPTH_SATURATION_VALUE:
436
        {
437
            if (!m_device.IsValid())
438
                return 0.0;
439
            float fret = 0.0f;
440
            if (PXC_STATUS_NO_ERROR == m_device->QueryProperty(PXCCapture::Device::PROPERTY_DEPTH_SATURATION_VALUE, &fret))
441
                return (double)fret;
442
            return 0.0;
443
        }
444
        break;
445
    case CV_CAP_PROP_INTELPERC_DEPTH_CONFIDENCE_THRESHOLD:
446
        {
447
            if (!m_device.IsValid())
448
                return 0.0;
449
            float fret = 0.0f;
450
            if (PXC_STATUS_NO_ERROR == m_device->QueryProperty(PXCCapture::Device::PROPERTY_DEPTH_CONFIDENCE_THRESHOLD, &fret))
451
                return (double)fret;
452
            return 0.0;
453
        }
454
        break;
455
    case CV_CAP_PROP_INTELPERC_DEPTH_FOCAL_LENGTH_HORZ:
456
        {
457
            if (!m_device.IsValid())
458
                return 0.0f;
459
            PXCPointF32 ptf;
460
            if (PXC_STATUS_NO_ERROR == m_device->QueryPropertyAsPoint(PXCCapture::Device::PROPERTY_DEPTH_FOCAL_LENGTH, &ptf))
461
                return (double)ptf.x;
462
            return 0.0;
463
        }
464
        break;
465
    case CV_CAP_PROP_INTELPERC_DEPTH_FOCAL_LENGTH_VERT:
466
        {
467
            if (!m_device.IsValid())
468
                return 0.0f;
469
            PXCPointF32 ptf;
470
            if (PXC_STATUS_NO_ERROR == m_device->QueryPropertyAsPoint(PXCCapture::Device::PROPERTY_DEPTH_FOCAL_LENGTH, &ptf))
471
                return (double)ptf.y;
472
            return 0.0;
473
        }
474
        break;
475
        //Add depth stream sepcific properties
476
    }
477
    return IntelPerCStreamBase::getProperty(propIdx);
478
}
479
bool IntelPerCStreamDepth::setProperty(int propIdx, double propVal)
480
{
481
    switch (propIdx)
482
    {
483
    case CV_CAP_PROP_INTELPERC_DEPTH_LOW_CONFIDENCE_VALUE:
484
        {
485
            if (!m_device.IsValid())
486
                return false;
487
            return (PXC_STATUS_NO_ERROR == m_device->SetProperty(PXCCapture::Device::PROPERTY_DEPTH_LOW_CONFIDENCE_VALUE, (float)propVal));
488
        }
489
        break;
490
    case CV_CAP_PROP_INTELPERC_DEPTH_SATURATION_VALUE:
491
        {
492
            if (!m_device.IsValid())
493
                return false;
494
            return (PXC_STATUS_NO_ERROR == m_device->SetProperty(PXCCapture::Device::PROPERTY_DEPTH_SATURATION_VALUE, (float)propVal));
495
        }
496
        break;
497
    case CV_CAP_PROP_INTELPERC_DEPTH_CONFIDENCE_THRESHOLD:
498
        {
499
            if (!m_device.IsValid())
500
                return false;
501
            return (PXC_STATUS_NO_ERROR == m_device->SetProperty(PXCCapture::Device::PROPERTY_DEPTH_CONFIDENCE_THRESHOLD, (float)propVal));
502
        }
503
        break;
504
    //Add depth stream sepcific properties
505
    }
506
    return IntelPerCStreamBase::setProperty(propIdx, propVal);
507
}
508
bool IntelPerCStreamDepth::retrieveDepthAsOutputArray(cv::OutputArray image)
509
{
510
    return retriveFrame(CV_16SC1, 0, image);
511
}
512
bool IntelPerCStreamDepth::retrieveIRAsOutputArray(cv::OutputArray image)
513
{
514
    return retriveFrame(CV_16SC1, 1, image);
515
}
516
bool IntelPerCStreamDepth::retrieveUVAsOutputArray(cv::OutputArray image)
517
{
518
    return retriveFrame(CV_32FC2, 2, image);
519
}
520
bool IntelPerCStreamDepth::validProfile(const PXCCapture::VideoStream::ProfileInfo& pinfo)
521
{
522
    return (PXCImage::COLOR_FORMAT_DEPTH == pinfo.imageInfo.format);
523
}
524
bool IntelPerCStreamDepth::retriveFrame(int type, int planeIdx, cv::OutputArray frame)
525
{
526
    if (!m_pxcImage.IsValid())
527
        return false;
528
    PXCImage::ImageInfo info;
529
    m_pxcImage->QueryInfo(&info);
530

531
    PXCImage::ImageData data;
532
    m_pxcImage->AcquireAccess(PXCImage::ACCESS_READ, &data);
533

534
    if (PXCImage::SURFACE_TYPE_SYSTEM_MEMORY != data.type)
535
        return false;
536

537
    cv::Mat temp(info.height, info.width, type, data.planes[planeIdx], data.pitches[planeIdx]);
538
    temp.copyTo(frame);
539

540
    m_pxcImage->ReleaseAccess(&data);
541
    return true;
542
}
543

544
///////////////// VideoCapture_IntelPerC //////////////////
545

546
VideoCapture_IntelPerC::VideoCapture_IntelPerC()
547
    : m_contextOpened(false)
548
{
549
    pxcStatus sts = PXCSession_Create(&m_session);
550
    if (PXC_STATUS_NO_ERROR > sts)
551
        return;
552
    m_contextOpened = m_imageStream.initStream(m_session);
553
    m_contextOpened &= m_depthStream.initStream(m_session);
554
}
555
VideoCapture_IntelPerC::~VideoCapture_IntelPerC(){}
556

557
double VideoCapture_IntelPerC::getProperty(int propIdx) const
558
{
559
    double propValue = 0;
560
    int purePropIdx = propIdx & ~CV_CAP_INTELPERC_GENERATORS_MASK;
561
    if (CV_CAP_INTELPERC_IMAGE_GENERATOR == (propIdx & CV_CAP_INTELPERC_GENERATORS_MASK))
562
    {
563
        propValue = m_imageStream.getProperty(purePropIdx);
564
    }
565
    else if (CV_CAP_INTELPERC_DEPTH_GENERATOR == (propIdx & CV_CAP_INTELPERC_GENERATORS_MASK))
566
    {
567
        propValue = m_depthStream.getProperty(purePropIdx);
568
    }
569
    else
570
    {
571
        propValue = m_depthStream.getProperty(purePropIdx);
572
    }
573
    return propValue;
574
}
575
bool VideoCapture_IntelPerC::setProperty(int propIdx, double propVal)
576
{
577
    bool isSet = false;
578
    int purePropIdx = propIdx & ~CV_CAP_INTELPERC_GENERATORS_MASK;
579
    if (CV_CAP_INTELPERC_IMAGE_GENERATOR == (propIdx & CV_CAP_INTELPERC_GENERATORS_MASK))
580
    {
581
        isSet = m_imageStream.setProperty(purePropIdx, propVal);
582
    }
583
    else if (CV_CAP_INTELPERC_DEPTH_GENERATOR == (propIdx & CV_CAP_INTELPERC_GENERATORS_MASK))
584
    {
585
        isSet = m_depthStream.setProperty(purePropIdx, propVal);
586
    }
587
    else
588
    {
589
        isSet = m_depthStream.setProperty(purePropIdx, propVal);
590
    }
591
    return isSet;
592
}
593

594
bool VideoCapture_IntelPerC::grabFrame()
595
{
596
    if (!isOpened())
597
        return false;
598

599
    bool isGrabbed = false;
600
    if (m_depthStream.isValid())
601
        isGrabbed = m_depthStream.grabFrame();
602
    if ((m_imageStream.isValid()) && (-1 != m_imageStream.getProfileIDX()))
603
        isGrabbed &= m_imageStream.grabFrame();
604

605
    return isGrabbed;
606
}
607
bool VideoCapture_IntelPerC::retrieveFrame(int outputType, cv::OutputArray frame)
608
{
609
    switch (outputType)
610
    {
611
    case CV_CAP_INTELPERC_DEPTH_MAP:
612
        return m_depthStream.retrieveDepthAsOutputArray(frame);
613
    case CV_CAP_INTELPERC_UVDEPTH_MAP:
614
        return m_depthStream.retrieveUVAsOutputArray(frame);
615
    case CV_CAP_INTELPERC_IR_MAP:
616
        return m_depthStream.retrieveIRAsOutputArray(frame);
617
    case CV_CAP_INTELPERC_IMAGE:
618
        return m_imageStream.retrieveAsOutputArray(frame);
619
    }
620
    return false;
621
}
622
int VideoCapture_IntelPerC::getCaptureDomain()
623
{
624
    return CV_CAP_INTELPERC;
625
}
626

627
bool VideoCapture_IntelPerC::isOpened() const
628
{
629
    return m_contextOpened;
630
}
631

632
}
633

634
#endif //HAVE_INTELPERC
635

636
Product

Resources

Company
