CoCalc -- cap_ximea.cpp

GitHub Repository: Tetragramm/opencv
Path: blob/master/modules/videoio/src/cap_ximea.cpp
¹⁶³⁵⁴ views
1

2
#include "precomp.hpp"
3

4
#ifdef _WIN32
5
#include <xiApi.h>
6
#else
7
#include <m3api/xiApi.h>
8
#endif
9

10
using namespace std;
11

12
/**********************************************************************************/
13

14
class CvCaptureCAM_XIMEA : public CvCapture
15
{
16
public:
17
    CvCaptureCAM_XIMEA() { init(); }
18
    virtual ~CvCaptureCAM_XIMEA() { close(); }
19

20
    virtual bool open( int index );
21
    bool open( const char* deviceName );
22
    virtual void close();
23
    virtual double getProperty(int) const CV_OVERRIDE;
24
    virtual bool setProperty(int, double) CV_OVERRIDE;
25
    virtual bool grabFrame() CV_OVERRIDE;
26
    virtual IplImage* retrieveFrame(int) CV_OVERRIDE;
27
    virtual int getCaptureDomain() CV_OVERRIDE { return CV_CAP_XIAPI; }
28

29
private:
30
    bool _open();
31
    void init();
32
    void errMsg(const char* msg, int errNum) const;
33
    void resetCvImage();
34
    int  ocvParamtoXimeaParam(int value) const;
35
    IplImage* frame;
36

37
    HANDLE    hmv;
38
    DWORD     numDevices;
39
    int       timeout;
40
    XI_IMG    image;
41
};
42

43
/**********************************************************************************/
44

45
CvCapture* cvCreateCameraCapture_XIMEA( int index )
46
{
47
    CvCaptureCAM_XIMEA* capture = new CvCaptureCAM_XIMEA;
48

49
    if( capture->open( index ))
50
        return capture;
51

52
    delete capture;
53
    return 0;
54
}
55

56
CvCapture* cvCreateCameraCapture_XIMEA( const char* serialNumber )
57
{
58
    CvCaptureCAM_XIMEA* capture = new CvCaptureCAM_XIMEA;
59

60
    if( capture->open( serialNumber ))
61
        return capture;
62

63
    delete capture;
64
    return 0;
65
}
66

67
/**********************************************************************************/
68
// Enumerate connected devices
69
void CvCaptureCAM_XIMEA::init()
70
{
71
#if defined _WIN32
72
    xiGetNumberDevices( &numDevices);
73
#else
74
    // try second re-enumeration if first one fails
75
    if (xiGetNumberDevices( &numDevices) != XI_OK)
76
    {
77
        xiGetNumberDevices( &numDevices);
78
    }
79
#endif
80
    hmv = NULL;
81
    frame = NULL;
82
    timeout = 0;
83
    memset(&image, 0, sizeof(XI_IMG));
84
}
85

86

87
/**********************************************************************************/
88
// Initialize camera input
89
bool CvCaptureCAM_XIMEA::open( int wIndex )
90
{
91
    if(numDevices == 0)
92
        return false;
93

94
    int mvret = XI_OK;
95
    if((mvret = xiOpenDevice( wIndex, &hmv)) != XI_OK)
96
    {
97
#if defined _WIN32
98
        errMsg("Open XI_DEVICE failed", mvret);
99
        return false;
100
#else
101
        // try opening second time if first fails
102
        if((mvret = xiOpenDevice( wIndex, &hmv))  != XI_OK)
103
        {
104
            errMsg("Open XI_DEVICE failed", mvret);
105
            return false;
106
        }
107
#endif
108
    }
109

110
    return _open();
111
}
112

113
bool CvCaptureCAM_XIMEA::open( const char* serialNumber )
114
{
115
    if(numDevices == 0)
116
        return false;
117

118
    int mvret = XI_OK;
119
    if((mvret = xiOpenDeviceBy(XI_OPEN_BY_SN, serialNumber, &hmv)) != XI_OK)
120
    {
121
        errMsg("Open XI_DEVICE failed", mvret);
122
        return false;
123
    }
124

125
    return _open();
126
}
127

128
bool CvCaptureCAM_XIMEA::_open()
129
{
130
#define HandleXiResult(res) if (res!=XI_OK)  goto error;
131
    int width   = 0;
132
    int height  = 0;
133
    int isColor = 0;
134

135
    // always use auto exposure/gain
136
    int mvret = xiSetParamInt( hmv, XI_PRM_AEAG, 1);
137
    HandleXiResult(mvret);
138

139
    mvret = xiGetParamInt( hmv, XI_PRM_WIDTH, &width);
140
    HandleXiResult(mvret);
141

142
    mvret = xiGetParamInt( hmv, XI_PRM_HEIGHT, &height);
143
    HandleXiResult(mvret);
144

145
    mvret = xiGetParamInt(hmv, XI_PRM_IMAGE_IS_COLOR, &isColor);
146
    HandleXiResult(mvret);
147

148
    if(isColor) // for color cameras
149
    {
150
        // default image format RGB24
151
        mvret = xiSetParamInt( hmv, XI_PRM_IMAGE_DATA_FORMAT, XI_RGB24);
152
        HandleXiResult(mvret);
153

154
        // always use auto white balance for color cameras
155
        mvret = xiSetParamInt( hmv, XI_PRM_AUTO_WB, 1);
156
        HandleXiResult(mvret);
157

158
        // allocate frame buffer for RGB24 image
159
        frame = cvCreateImage(cvSize(width, height), IPL_DEPTH_8U, 3);
160
    }
161
    else // for mono cameras
162
    {
163
        // default image format MONO8
164
        mvret = xiSetParamInt( hmv, XI_PRM_IMAGE_DATA_FORMAT, XI_MONO8);
165
        HandleXiResult(mvret);
166

167
        // allocate frame buffer for MONO8 image
168
        frame = cvCreateImage(cvSize(width, height), IPL_DEPTH_8U, 1);
169
    }
170

171
    //default capture timeout 10s
172
    timeout = 10000;
173

174
    mvret = xiStartAcquisition(hmv);
175
    if(mvret != XI_OK)
176
    {
177
        errMsg("StartAcquisition XI_DEVICE failed", mvret);
178
        goto error;
179
    }
180
    return true;
181

182
error:
183
    errMsg("Open XI_DEVICE failed", mvret);
184
    xiCloseDevice(hmv);
185
    hmv = NULL;
186
    return false;
187
}
188

189
/**********************************************************************************/
190

191
void CvCaptureCAM_XIMEA::close()
192
{
193
    if(frame)
194
        cvReleaseImage(&frame);
195

196
    if(hmv)
197
    {
198
        xiStopAcquisition(hmv);
199
        xiCloseDevice(hmv);
200
    }
201
    hmv = NULL;
202
}
203

204
/**********************************************************************************/
205

206
bool CvCaptureCAM_XIMEA::grabFrame()
207
{
208
    memset(&image, 0, sizeof(XI_IMG));
209
    image.size = sizeof(XI_IMG);
210
    int mvret = xiGetImage( hmv, timeout, &image);
211

212
    if(mvret == XI_ACQUISITION_STOPED)
213
    {
214
        xiStartAcquisition(hmv);
215
        mvret = xiGetImage(hmv, timeout, &image);
216
    }
217

218
    if(mvret != XI_OK)
219
    {
220
        errMsg("Error during GetImage", mvret);
221
        return false;
222
    }
223

224
    return true;
225
}
226

227
/**********************************************************************************/
228

229
IplImage* CvCaptureCAM_XIMEA::retrieveFrame(int)
230
{
231
    // update cvImage after format has changed
232
    resetCvImage();
233

234
    // copy pixel data
235
    switch( image.frm)
236
    {
237
    case XI_MONO8       :
238
    case XI_RAW8        : memcpy( frame->imageData, image.bp, image.width*image.height); break;
239
    case XI_MONO16      :
240
    case XI_RAW16       : memcpy( frame->imageData, image.bp, image.width*image.height*sizeof(WORD)); break;
241
    case XI_RGB24       :
242
    case XI_RGB_PLANAR  : memcpy( frame->imageData, image.bp, image.width*image.height*3); break;
243
    case XI_RGB32       : memcpy( frame->imageData, image.bp, image.width*image.height*4); break;
244
    default: break;
245
    }
246
    return frame;
247
}
248

249
/**********************************************************************************/
250

251
void CvCaptureCAM_XIMEA::resetCvImage()
252
{
253
   bool do_reset = false;
254

255
    // first check basic image resolution
256
    if((int)image.width != frame->width || (int)image.height != frame->height)
257
        do_reset = true;
258

259
    // afterwards check image format
260
    switch( image.frm)
261
    {
262
    case XI_MONO8       :
263
    case XI_RAW8         :
264
        {
265
            if(frame->depth != IPL_DEPTH_8U || frame->nChannels != 1)
266
                do_reset = true;
267
        }
268
        break;
269
    case XI_MONO16      :
270
    case XI_RAW16        :
271
        {
272
            if(frame->depth != IPL_DEPTH_16U || frame->nChannels != 1)
273
                do_reset = true;
274
        }
275
        break;
276
    case XI_RGB24       :
277
    case XI_RGB_PLANAR  :
278
        {
279
            if(frame->depth != IPL_DEPTH_8U || frame->nChannels != 3)
280
                do_reset = true;
281
        }
282
        break;
283
    case XI_RGB32       :
284
        {
285
            if(frame->depth != IPL_DEPTH_8U || frame->nChannels != 4)
286
                do_reset = true;
287
        }
288
        break;
289
    default:
290
        errMsg("CvCaptureCAM_XIMEA::resetCvImage ERROR: Unknown format.", XI_NOT_SUPPORTED_DATA_FORMAT);
291
        return;
292
    }
293

294
    if(do_reset)
295
    {
296
        if(frame) cvReleaseImage(&frame);
297
        frame = NULL;
298

299
        switch( image.frm)
300
        {
301
        case XI_MONO8       :
302
        case XI_RAW8        : frame = cvCreateImage(cvSize( image.width, image.height), IPL_DEPTH_8U, 1); break;
303
        case XI_MONO16      :
304
        case XI_RAW16       : frame = cvCreateImage(cvSize( image.width, image.height), IPL_DEPTH_16U, 1); break;
305
        case XI_RGB24       :
306
        case XI_RGB_PLANAR  : frame = cvCreateImage(cvSize( image.width, image.height), IPL_DEPTH_8U, 3); break;
307
        case XI_RGB32       : frame = cvCreateImage(cvSize( image.width, image.height), IPL_DEPTH_8U, 4); break;
308
        default :
309
            errMsg("CvCaptureCAM_XIMEA::resetCvImage ERROR: Unknown format.", XI_NOT_SUPPORTED_DATA_FORMAT);
310
            return;
311
        }
312
    }
313
    cvZero(frame);
314
}
315

316
/**********************************************************************************/
317

318
int CvCaptureCAM_XIMEA::ocvParamtoXimeaParam(int property_id) const
319
{
320
    XI_RETURN stat = XI_OK;
321
    switch (property_id)
322
    {
323
        // OCV parameters
324
    case CV_CAP_PROP_POS_FRAMES:
325
        // Number of successfully transferred frames on transport layer.
326
        stat = xiSetParamInt(hmv, XI_PRM_COUNTER_SELECTOR, XI_CNT_SEL_TRANSPORT_TRANSFERRED_FRAMES);
327
        if (stat) errMsg("xiSetParamInt(XI_PRM_COUNTER_SELECTOR)", stat);
328
        return CV_CAP_PROP_XI_COUNTER_VALUE;
329
    case CV_CAP_PROP_FRAME_WIDTH: return CV_CAP_PROP_XI_WIDTH;
330
    case CV_CAP_PROP_FRAME_HEIGHT: return CV_CAP_PROP_XI_HEIGHT;
331
    case CV_CAP_PROP_FPS: return CV_CAP_PROP_XI_FRAMERATE;
332
    case CV_CAP_PROP_GAIN: return CV_CAP_PROP_XI_GAIN;
333
    case CV_CAP_PROP_EXPOSURE: return CV_CAP_PROP_XI_EXPOSURE;
334
    case CV_CAP_PROP_XI_DATA_FORMAT: return CV_CAP_PROP_XI_IMAGE_DATA_FORMAT;
335
    default:
336
        return property_id;
337
    }
338
}
339

340
/**********************************************************************************/
341

342
bool CvCaptureCAM_XIMEA::setProperty( int property_id, double value )
343
{
344
    bool setProp_result = true;
345
    bool doAcqReset = false;
346
    string ximea_param = "";
347
    int ival = (int) value;
348
    float fval = (float) value;
349
    XI_PRM_TYPE value_type = xiTypeInteger;
350
    XI_RETURN stat = XI_OK;
351

352
    if(hmv == NULL)
353
    {
354
        errMsg("CvCaptureCAM_XIMEA::setProperty", XI_INVALID_HANDLE);
355
        return false;
356
    }
357

358
    // convert OCV property id to XIMEA id if necessary
359
    property_id = ocvParamtoXimeaParam(property_id);
360

361
    // decode OpenCV parameter to xiAPI parameter
362
    switch( property_id )
363
    {
364
    case CV_CAP_PROP_XI_TIMEOUT:
365
        timeout = (int) value;
366
        return true;
367
    case CV_CAP_PROP_XI_EXPOSURE:
368
        ximea_param = "exposure";
369
        value_type = xiTypeInteger;
370
        break;
371
    case CV_CAP_PROP_XI_EXPOSURE_BURST_COUNT:
372
        ximea_param = "exposure_burst_count";
373
        value_type = xiTypeInteger;
374
        break;
375
    case CV_CAP_PROP_XI_GAIN_SELECTOR:
376
        ximea_param = "gain_selector";
377
        value_type = xiTypeEnum;
378
        break;
379
    case CV_CAP_PROP_XI_GAIN:
380
        ximea_param = "gain";
381
        value_type = xiTypeFloat;
382
        break;
383
    case CV_CAP_PROP_XI_DOWNSAMPLING:
384
        ximea_param = "downsampling";
385
        value_type = xiTypeEnum;
386
        doAcqReset = true;
387
        break;
388
    case CV_CAP_PROP_XI_DOWNSAMPLING_TYPE:
389
        ximea_param = "downsampling_type";
390
        value_type = xiTypeEnum;
391
        doAcqReset = true;
392
        break;
393
    case CV_CAP_PROP_XI_BINNING_SELECTOR:
394
        ximea_param = "binning_selector";
395
        value_type = xiTypeEnum;
396
        doAcqReset = true;
397
        break;
398
    case CV_CAP_PROP_XI_BINNING_VERTICAL:
399
        ximea_param = "binning_vertical";
400
        value_type = xiTypeInteger;
401
        doAcqReset = true;
402
        break;
403
    case CV_CAP_PROP_XI_BINNING_HORIZONTAL:
404
        ximea_param = "binning_horizontal";
405
        value_type = xiTypeInteger;
406
        doAcqReset = true;
407
        break;
408
    case CV_CAP_PROP_XI_BINNING_PATTERN:
409
        ximea_param = "binning_pattern";
410
        value_type = xiTypeEnum;
411
        doAcqReset = true;
412
        break;
413
    case CV_CAP_PROP_XI_DECIMATION_SELECTOR:
414
        ximea_param = "decimation_selector";
415
        value_type = xiTypeEnum;
416
        doAcqReset = true;
417
        break;
418
    case CV_CAP_PROP_XI_DECIMATION_VERTICAL:
419
        ximea_param = "decimation_vertical";
420
        value_type = xiTypeInteger;
421
        doAcqReset = true;
422
        break;
423
    case CV_CAP_PROP_XI_DECIMATION_HORIZONTAL:
424
        ximea_param = "decimation_horizontal";
425
        value_type = xiTypeInteger;
426
        doAcqReset = true;
427
        break;
428
    case CV_CAP_PROP_XI_DECIMATION_PATTERN:
429
        ximea_param = "decimation_pattern";
430
        value_type = xiTypeEnum;
431
        doAcqReset = true;
432
        break;
433
    case CV_CAP_PROP_XI_TEST_PATTERN_GENERATOR_SELECTOR:
434
        ximea_param = "test_pattern_generator_selector";
435
        value_type = xiTypeEnum;
436
        doAcqReset = true;
437
        break;
438
    case CV_CAP_PROP_XI_TEST_PATTERN:
439
        ximea_param = "test_pattern";
440
        value_type = xiTypeEnum;
441
        doAcqReset = true;
442
        break;
443
    case CV_CAP_PROP_XI_IMAGE_DATA_FORMAT:
444
        ximea_param = "imgdataformat";
445
        value_type = xiTypeEnum;
446
        doAcqReset = true;
447
        break;
448
    case CV_CAP_PROP_XI_SHUTTER_TYPE:
449
        ximea_param = "shutter_type";
450
        value_type = xiTypeEnum;
451
        doAcqReset = true;
452
        break;
453
    case CV_CAP_PROP_XI_SENSOR_TAPS:
454
        ximea_param = "sensor_taps";
455
        value_type = xiTypeEnum;
456
        doAcqReset = true;
457
        break;
458
    case CV_CAP_PROP_XI_AEAG:
459
        ximea_param = "aeag";
460
        value_type = xiTypeBoolean;
461
        break;
462
    case CV_CAP_PROP_XI_AEAG_ROI_OFFSET_X:
463
        ximea_param = "aeag_roi_offset_x";
464
        value_type = xiTypeInteger;
465
        break;
466
    case CV_CAP_PROP_XI_AEAG_ROI_OFFSET_Y:
467
        ximea_param = "aeag_roi_offset_y";
468
        value_type = xiTypeInteger;
469
        break;
470
    case CV_CAP_PROP_XI_AEAG_ROI_WIDTH:
471
        ximea_param = "aeag_roi_width";
472
        value_type = xiTypeInteger;
473
        break;
474
    case CV_CAP_PROP_XI_AEAG_ROI_HEIGHT:
475
        ximea_param = "aeag_roi_height";
476
        value_type = xiTypeInteger;
477
        break;
478
    case CV_CAP_PROP_XI_BPC:
479
        ximea_param = "bpc";
480
        value_type = xiTypeBoolean;
481
        break;
482
    case CV_CAP_PROP_XI_AUTO_WB:
483
        ximea_param = "auto_wb";
484
        value_type = xiTypeBoolean;
485
        break;
486
    case CV_CAP_PROP_XI_MANUAL_WB:
487
        ximea_param = "manual_wb";
488
        value_type = xiTypeCommand;
489
        break;
490
    case CV_CAP_PROP_XI_WB_KR:
491
        ximea_param = "wb_kr";
492
        value_type = xiTypeFloat;
493
        break;
494
    case CV_CAP_PROP_XI_WB_KG:
495
        ximea_param = "wb_kg";
496
        value_type = xiTypeFloat;
497
        break;
498
    case CV_CAP_PROP_XI_WB_KB:
499
        ximea_param = "wb_kb";
500
        value_type = xiTypeFloat;
501
        break;
502
    case CV_CAP_PROP_XI_WIDTH:
503
        ximea_param = "width";
504
        value_type = xiTypeInteger;
505
        doAcqReset = true;
506
        break;
507
    case CV_CAP_PROP_XI_HEIGHT:
508
        ximea_param = "height";
509
        value_type = xiTypeInteger;
510
        doAcqReset = true;
511
        break;
512
    case CV_CAP_PROP_XI_OFFSET_X:
513
        ximea_param = "offsetX";
514
        value_type = xiTypeInteger;
515
        doAcqReset = true;
516
        break;
517
    case CV_CAP_PROP_XI_OFFSET_Y:
518
        ximea_param = "offsetY";
519
        value_type = xiTypeInteger;
520
        doAcqReset = true;
521
        break;
522
    case CV_CAP_PROP_XI_REGION_SELECTOR :
523
        ximea_param = "region_selector";
524
        value_type = xiTypeInteger;
525
        doAcqReset = true;
526
        break;
527
    case CV_CAP_PROP_XI_REGION_MODE :
528
        ximea_param = "region_mode";
529
        value_type = xiTypeInteger;
530
        doAcqReset = true;
531
        break;
532
    case CV_CAP_PROP_XI_EXP_PRIORITY:
533
        ximea_param = "exp_priority";
534
        value_type = xiTypeFloat;
535
        break;
536
    case CV_CAP_PROP_XI_AG_MAX_LIMIT:
537
        ximea_param = "ag_max_limit";
538
        value_type = xiTypeFloat;
539
        break;
540
    case CV_CAP_PROP_XI_AE_MAX_LIMIT:
541
        ximea_param = "ae_max_limit";
542
        value_type = xiTypeInteger;
543
        break;
544
    case CV_CAP_PROP_XI_AEAG_LEVEL:
545
        ximea_param = "aeag_level";
546
        value_type = xiTypeInteger;
547
        break;
548
    case CV_CAP_PROP_XI_LIMIT_BANDWIDTH:
549
        ximea_param = "limit_bandwidth";
550
        value_type = xiTypeInteger;
551
        doAcqReset = true;
552
        break;
553
    case CV_CAP_PROP_XI_SENSOR_DATA_BIT_DEPTH:
554
        ximea_param = "sensor_bit_depth";
555
        value_type = xiTypeEnum;
556
        doAcqReset = true;
557
        break;
558
    case CV_CAP_PROP_XI_OUTPUT_DATA_BIT_DEPTH:
559
        ximea_param = "output_bit_depth";
560
        value_type = xiTypeEnum;
561
        doAcqReset = true;
562
        break;
563
    case CV_CAP_PROP_XI_IMAGE_DATA_BIT_DEPTH:
564
        ximea_param = "image_data_bit_depth";
565
        value_type = xiTypeEnum;
566
        doAcqReset = true;
567
        break;
568
    case CV_CAP_PROP_XI_OUTPUT_DATA_PACKING:
569
        ximea_param = "output_bit_packing";
570
        value_type = xiTypeBoolean;
571
        doAcqReset = true;
572
        break;
573
    case CV_CAP_PROP_XI_OUTPUT_DATA_PACKING_TYPE:
574
        ximea_param = "output_bit_packing_type";
575
        value_type = xiTypeEnum;
576
        doAcqReset = true;
577
        break;
578
    case CV_CAP_PROP_XI_IS_COOLED:
579
        ximea_param = "iscooled";
580
        value_type = xiTypeBoolean;
581
        break;
582
    case CV_CAP_PROP_XI_COOLING:
583
        ximea_param = "cooling";
584
        value_type = xiTypeBoolean;
585
        break;
586
    case CV_CAP_PROP_XI_TARGET_TEMP:
587
        ximea_param = "target_temp";
588
        value_type = xiTypeFloat;
589
        break;
590
    case CV_CAP_PROP_XI_CHIP_TEMP:
591
        ximea_param = "chip_temp";
592
        value_type = xiTypeFloat;
593
        break;
594
    case CV_CAP_PROP_XI_HOUS_TEMP:
595
        ximea_param = "hous_temp";
596
        value_type = xiTypeFloat;
597
        break;
598
    case CV_CAP_PROP_XI_HOUS_BACK_SIDE_TEMP:
599
        ximea_param = "hous_back_side_temp";
600
        value_type = xiTypeFloat;
601
        break;
602
    case CV_CAP_PROP_XI_SENSOR_BOARD_TEMP:
603
        ximea_param = "sensor_board_temp";
604
        value_type = xiTypeFloat;
605
        break;
606
    case CV_CAP_PROP_XI_CMS:
607
        ximea_param = "cms";
608
        value_type = xiTypeEnum;
609
        break;
610
    case CV_CAP_PROP_XI_APPLY_CMS:
611
        ximea_param = "apply_cms";
612
        value_type = xiTypeBoolean;
613
        break;
614
    case CV_CAP_PROP_XI_IMAGE_IS_COLOR:
615
        ximea_param = "iscolor";
616
        value_type = xiTypeBoolean;
617
        break;
618
    case CV_CAP_PROP_XI_COLOR_FILTER_ARRAY:
619
        ximea_param = "cfa";
620
        value_type = xiTypeEnum;
621
        break;
622
    case CV_CAP_PROP_XI_GAMMAY:
623
        ximea_param = "gammaY";
624
        value_type = xiTypeFloat;
625
        break;
626
    case CV_CAP_PROP_XI_GAMMAC:
627
        ximea_param = "gammaC";
628
        value_type = xiTypeFloat;
629
        break;
630
    case CV_CAP_PROP_XI_SHARPNESS:
631
        ximea_param = "sharpness";
632
        value_type = xiTypeFloat;
633
        break;
634
    case CV_CAP_PROP_XI_CC_MATRIX_00:
635
        ximea_param = "ccMTX00";
636
        value_type = xiTypeFloat;
637
        break;
638
    case CV_CAP_PROP_XI_CC_MATRIX_01:
639
        ximea_param = "ccMTX01";
640
        value_type = xiTypeFloat;
641
        break;
642
    case CV_CAP_PROP_XI_CC_MATRIX_02:
643
        ximea_param = "ccMTX02";
644
        value_type = xiTypeFloat;
645
        break;
646
    case CV_CAP_PROP_XI_CC_MATRIX_03:
647
        ximea_param = "ccMTX03";
648
        value_type = xiTypeFloat;
649
        break;
650
    case CV_CAP_PROP_XI_CC_MATRIX_10:
651
        ximea_param = "ccMTX10";
652
        value_type = xiTypeFloat;
653
        break;
654
    case CV_CAP_PROP_XI_CC_MATRIX_11:
655
        ximea_param = "ccMTX11";
656
        value_type = xiTypeFloat;
657
        break;
658
    case CV_CAP_PROP_XI_CC_MATRIX_12:
659
        ximea_param = "ccMTX12";
660
        value_type = xiTypeFloat;
661
        break;
662
    case CV_CAP_PROP_XI_CC_MATRIX_13:
663
        ximea_param = "ccMTX13";
664
        value_type = xiTypeFloat;
665
        break;
666
    case CV_CAP_PROP_XI_CC_MATRIX_20:
667
        ximea_param = "ccMTX20";
668
        value_type = xiTypeFloat;
669
        break;
670
    case CV_CAP_PROP_XI_CC_MATRIX_21:
671
        ximea_param = "ccMTX21";
672
        value_type = xiTypeFloat;
673
        break;
674
    case CV_CAP_PROP_XI_CC_MATRIX_22:
675
        ximea_param = "ccMTX22";
676
        value_type = xiTypeFloat;
677
        break;
678
    case CV_CAP_PROP_XI_CC_MATRIX_23:
679
        ximea_param = "ccMTX23";
680
        value_type = xiTypeFloat;
681
        break;
682
    case CV_CAP_PROP_XI_CC_MATRIX_30:
683
        ximea_param = "ccMTX30";
684
        value_type = xiTypeFloat;
685
        break;
686
    case CV_CAP_PROP_XI_CC_MATRIX_31:
687
        ximea_param = "ccMTX31";
688
        value_type = xiTypeFloat;
689
        break;
690
    case CV_CAP_PROP_XI_CC_MATRIX_32:
691
        ximea_param = "ccMTX32";
692
        value_type = xiTypeFloat;
693
        break;
694
    case CV_CAP_PROP_XI_CC_MATRIX_33:
695
        ximea_param = "ccMTX33";
696
        value_type = xiTypeFloat;
697
        break;
698
    case CV_CAP_PROP_XI_DEFAULT_CC_MATRIX:
699
        ximea_param = "defccMTX";
700
        value_type = xiTypeCommand;
701
        break;
702
    case CV_CAP_PROP_XI_TRG_SOURCE:
703
        ximea_param = "trigger_source";
704
        value_type = xiTypeEnum;
705
        doAcqReset = true;
706
        break;
707
    case CV_CAP_PROP_XI_TRG_SOFTWARE:
708
        ximea_param = "trigger_software";
709
        value_type = xiTypeCommand;
710
        break;
711
    case CV_CAP_PROP_XI_TRG_SELECTOR:
712
        ximea_param = "trigger_selector";
713
        value_type = xiTypeEnum;
714
        doAcqReset = true;
715
        break;
716
    case CV_CAP_PROP_XI_ACQ_FRAME_BURST_COUNT:
717
        ximea_param = "acq_frame_burst_count";
718
        value_type = xiTypeInteger;
719
        break;
720
    case CV_CAP_PROP_XI_GPI_SELECTOR:
721
        ximea_param = "gpi_selector";
722
        value_type = xiTypeEnum;
723
        break;
724
    case CV_CAP_PROP_XI_GPI_MODE:
725
        ximea_param = "gpi_mode";
726
        value_type = xiTypeEnum;
727
        break;
728
    case CV_CAP_PROP_XI_GPI_LEVEL:
729
        ximea_param = "gpi_level";
730
        value_type = xiTypeInteger;
731
        break;
732
    case CV_CAP_PROP_XI_GPO_SELECTOR:
733
        ximea_param = "gpo_selector";
734
        value_type = xiTypeEnum;
735
        break;
736
    case CV_CAP_PROP_XI_GPO_MODE:
737
        ximea_param = "gpo_mode";
738
        value_type = xiTypeEnum;
739
        break;
740
    case CV_CAP_PROP_XI_LED_SELECTOR:
741
        ximea_param = "led_selector";
742
        value_type = xiTypeEnum;
743
        break;
744
    case CV_CAP_PROP_XI_LED_MODE:
745
        ximea_param = "led_mode";
746
        value_type = xiTypeEnum;
747
        break;
748
    case CV_CAP_PROP_XI_DEBOUNCE_EN:
749
        ximea_param = "dbnc_en";
750
        value_type = xiTypeBoolean;
751
        break;
752
    case CV_CAP_PROP_XI_DEBOUNCE_T0:
753
        ximea_param = "dbnc_t0";
754
        value_type = xiTypeInteger;
755
        break;
756
    case CV_CAP_PROP_XI_DEBOUNCE_T1:
757
        ximea_param = "dbnc_t1";
758
        value_type = xiTypeInteger;
759
        break;
760
    case CV_CAP_PROP_XI_DEBOUNCE_POL:
761
        ximea_param = "dbnc_pol";
762
        value_type = xiTypeInteger;
763
        break;
764
    case CV_CAP_PROP_XI_LENS_MODE:
765
        ximea_param = "lens_mode";
766
        value_type = xiTypeBoolean;
767
        break;
768
    case CV_CAP_PROP_XI_LENS_APERTURE_VALUE:
769
        ximea_param = "lens_aperture_value";
770
        value_type = xiTypeFloat;
771
        break;
772
    case CV_CAP_PROP_XI_LENS_FOCUS_MOVEMENT_VALUE:
773
        ximea_param = "lens_focus_movement_value";
774
        value_type = xiTypeInteger;
775
        break;
776
    case CV_CAP_PROP_XI_LENS_FOCUS_MOVE:
777
        ximea_param = "lens_focus_move";
778
        value_type = xiTypeCommand;
779
        break;
780
    case CV_CAP_PROP_XI_LENS_FOCUS_DISTANCE:
781
        ximea_param = "lens_focus_distance";
782
        value_type = xiTypeFloat;
783
        break;
784
    case CV_CAP_PROP_XI_LENS_FOCAL_LENGTH:
785
        ximea_param = "lens_focal_length";
786
        value_type = xiTypeFloat;
787
        break;
788
    case CV_CAP_PROP_XI_LENS_FEATURE_SELECTOR:
789
        ximea_param = "lens_feature_selector";
790
        value_type = xiTypeEnum;
791
        break;
792
    case CV_CAP_PROP_XI_LENS_FEATURE:
793
        ximea_param = "lens_feature";
794
        value_type = xiTypeFloat;
795
        break;
796
    case CV_CAP_PROP_XI_DEVICE_MODEL_ID:
797
        ximea_param = "device_model_id";
798
        value_type = xiTypeInteger;
799
        break;
800
    case CV_CAP_PROP_XI_DEVICE_SN:
801
        ximea_param = "device_sn";
802
        value_type = xiTypeInteger;
803
        break;
804
    case CV_CAP_PROP_XI_IMAGE_DATA_FORMAT_RGB32_ALPHA:
805
        ximea_param = "imgdataformatrgb32alpha";
806
        value_type = xiTypeInteger;
807
        break;
808
    case CV_CAP_PROP_XI_IMAGE_PAYLOAD_SIZE:
809
        ximea_param = "imgpayloadsize";
810
        value_type = xiTypeInteger;
811
        break;
812
    case CV_CAP_PROP_XI_TRANSPORT_PIXEL_FORMAT:
813
        ximea_param = "transport_pixel_format";
814
        value_type = xiTypeEnum;
815
        break;
816
    case CV_CAP_PROP_XI_SENSOR_CLOCK_FREQ_HZ:
817
        ximea_param = "sensor_clock_freq_hz";
818
        value_type = xiTypeFloat;
819
        doAcqReset = true;
820
        break;
821
    case CV_CAP_PROP_XI_SENSOR_CLOCK_FREQ_INDEX:
822
        ximea_param = "sensor_clock_freq_index";
823
        value_type = xiTypeInteger;
824
        doAcqReset = true;
825
        break;
826
    case CV_CAP_PROP_XI_SENSOR_OUTPUT_CHANNEL_COUNT:
827
        ximea_param = "sensor_output_channel_count";
828
        value_type = xiTypeEnum;
829
        doAcqReset = true;
830
        break;
831
    case CV_CAP_PROP_XI_FRAMERATE:
832
        ximea_param = "framerate";
833
        value_type = xiTypeFloat;
834
        break;
835
    case CV_CAP_PROP_XI_COUNTER_SELECTOR:
836
        ximea_param = "counter_selector";
837
        value_type = xiTypeEnum;
838
        break;
839
    case CV_CAP_PROP_XI_COUNTER_VALUE:
840
        ximea_param = "counter_value";
841
        value_type = xiTypeInteger;
842
        break;
843
    case CV_CAP_PROP_XI_ACQ_TIMING_MODE:
844
        ximea_param = "acq_timing_mode";
845
        value_type = xiTypeEnum;
846
        break;
847
    case CV_CAP_PROP_XI_AVAILABLE_BANDWIDTH:
848
        ximea_param = "available_bandwidth";
849
        value_type = xiTypeInteger;
850
        doAcqReset = true;
851
        break;
852
    case CV_CAP_PROP_XI_BUFFER_POLICY:
853
        ximea_param = "buffer_policy";
854
        value_type = xiTypeEnum;
855
        break;
856
    case CV_CAP_PROP_XI_LUT_EN:
857
        ximea_param = "LUTEnable";
858
        value_type = xiTypeBoolean;
859
        doAcqReset = true;
860
        break;
861
    case CV_CAP_PROP_XI_LUT_INDEX:
862
        ximea_param = "LUTIndex";
863
        value_type = xiTypeInteger;
864
        doAcqReset = true;
865
        break;
866
    case CV_CAP_PROP_XI_LUT_VALUE:
867
        ximea_param = "LUTValue";
868
        value_type = xiTypeInteger;
869
        doAcqReset = true;
870
        break;
871
    case CV_CAP_PROP_XI_TRG_DELAY:
872
        ximea_param = "trigger_delay";
873
        value_type = xiTypeEnum;
874
        break;
875
    case CV_CAP_PROP_XI_TS_RST_MODE:
876
        ximea_param = "ts_rst_mode";
877
        value_type = xiTypeEnum;
878
        break;
879
    case CV_CAP_PROP_XI_TS_RST_SOURCE:
880
        ximea_param = "ts_rst_source";
881
        value_type = xiTypeEnum;
882
        break;
883
    case CV_CAP_PROP_XI_IS_DEVICE_EXIST:
884
        ximea_param = "isexist";
885
        value_type = xiTypeBoolean;
886
        break;
887
    case CV_CAP_PROP_XI_ACQ_BUFFER_SIZE:
888
        ximea_param = "acq_buffer_size";
889
        value_type = xiTypeInteger;
890
        doAcqReset = true;
891
        break;
892
    case CV_CAP_PROP_XI_ACQ_BUFFER_SIZE_UNIT:
893
        ximea_param = "acq_buffer_size_unit";
894
        value_type = xiTypeInteger;
895
        doAcqReset = true;
896
        break;
897
    case CV_CAP_PROP_XI_ACQ_TRANSPORT_BUFFER_SIZE:
898
        ximea_param = "acq_transport_buffer_size";
899
        value_type = xiTypeInteger;
900
        doAcqReset = true;
901
        break;
902
    case CV_CAP_PROP_XI_BUFFERS_QUEUE_SIZE:
903
        ximea_param = "buffers_queue_size";
904
        value_type = xiTypeInteger;
905
        doAcqReset = true;
906
        break;
907
    case CV_CAP_PROP_XI_ACQ_TRANSPORT_BUFFER_COMMIT:
908
        ximea_param = "acq_transport_buffer_commit";
909
        value_type = xiTypeInteger;
910
        doAcqReset = true;
911
        break;
912
    case CV_CAP_PROP_XI_RECENT_FRAME:
913
        ximea_param = "recent_frame";
914
        value_type = xiTypeBoolean;
915
        break;
916
    case CV_CAP_PROP_XI_DEVICE_RESET:
917
        ximea_param = "device_reset";
918
        value_type = xiTypeCommand;
919
        doAcqReset = true;
920
        break;
921
    case CV_CAP_PROP_XI_COLUMN_FPN_CORRECTION:
922
        ximea_param = "column_fpn_correction";
923
        value_type = xiTypeEnum;
924
        break;
925
    case CV_CAP_PROP_XI_ROW_FPN_CORRECTION:
926
        ximea_param = "row_fpn_correction";
927
        value_type = xiTypeEnum;
928
        break;
929
    case CV_CAP_PROP_XI_SENSOR_MODE:
930
        ximea_param = "sensor_mode";
931
        value_type = xiTypeEnum;
932
        doAcqReset = true;
933
        break;
934
    case CV_CAP_PROP_XI_HDR:
935
        ximea_param = "hdr";
936
        value_type = xiTypeBoolean;
937
        break;
938
    case CV_CAP_PROP_XI_HDR_KNEEPOINT_COUNT:
939
        ximea_param = "hdr_kneepoint_count";
940
        value_type = xiTypeInteger;
941
        break;
942
    case CV_CAP_PROP_XI_HDR_T1:
943
        ximea_param = "hdr_t1";
944
        value_type = xiTypeInteger;
945
        break;
946
    case CV_CAP_PROP_XI_HDR_T2:
947
        ximea_param = "hdr_t2";
948
        value_type = xiTypeInteger;
949
        break;
950
    case CV_CAP_PROP_XI_KNEEPOINT1:
951
        ximea_param = "hdr_kneepoint1";
952
        value_type = xiTypeInteger;
953
        break;
954
    case CV_CAP_PROP_XI_KNEEPOINT2:
955
        ximea_param = "hdr_kneepoint2";
956
        value_type = xiTypeInteger;
957
        break;
958
    case CV_CAP_PROP_XI_IMAGE_BLACK_LEVEL:
959
        ximea_param = "image_black_level";
960
        value_type = xiTypeInteger;
961
        break;
962
    case CV_CAP_PROP_XI_HW_REVISION:
963
        ximea_param = "hw_revision";
964
        value_type = xiTypeInteger;
965
        break;
966
    case CV_CAP_PROP_XI_DEBUG_LEVEL:
967
        ximea_param = "debug_level";
968
        value_type = xiTypeEnum;
969
        break;
970
    case CV_CAP_PROP_XI_AUTO_BANDWIDTH_CALCULATION:
971
        ximea_param = "auto_bandwidth_calculation";
972
        value_type = xiTypeBoolean;
973
        break;
974
    case CV_CAP_PROP_XI_FFS_FILE_ID:
975
        ximea_param = "ffs_file_id";
976
        value_type = xiTypeInteger;
977
        break;
978
    case CV_CAP_PROP_XI_FFS_FILE_SIZE:
979
        ximea_param = "ffs_file_size";
980
        value_type = xiTypeInteger;
981
        break;
982
    case CV_CAP_PROP_XI_FREE_FFS_SIZE:
983
        ximea_param = "free_ffs_size";
984
        value_type = xiTypeInteger;
985
        break;
986
    case CV_CAP_PROP_XI_USED_FFS_SIZE:
987
        ximea_param = "used_ffs_size";
988
        value_type = xiTypeInteger;
989
        break;
990
    case CV_CAP_PROP_XI_FFS_ACCESS_KEY:
991
        ximea_param = "ffs_access_key";
992
        value_type = xiTypeInteger;
993
        break;
994
    case CV_CAP_PROP_XI_SENSOR_FEATURE_SELECTOR:
995
        ximea_param = "sensor_feature_selector";
996
        value_type = xiTypeEnum;
997
        break;
998
    case CV_CAP_PROP_XI_SENSOR_FEATURE_VALUE:
999
        ximea_param = "sensor_feature_value";
1000
        value_type = xiTypeInteger;
1001
        break;
1002
    default:
1003
        // report invalid parameter as it is not of numerical type
1004
        errMsg("CvCaptureCAM_XIMEA::setProperty", XI_UNKNOWN_PARAM);
1005
        return false;
1006
    }
1007

1008
    if(doAcqReset)
1009
    {
1010
        stat = xiStopAcquisition(hmv);
1011
        errMsg("CvCaptureCAM_XIMEA::setProperty, xiStopAcquisition", stat);
1012
        if(stat != XI_OK)
1013
            setProp_result = false;
1014
    }
1015

1016
    switch(value_type)
1017
    {
1018
    case xiTypeInteger :               // integer parameter type
1019
    case xiTypeEnum :                // enumerator parameter type
1020
    case xiTypeBoolean :             // boolean parameter type
1021
    case xiTypeCommand :          // command parameter type
1022
        stat = xiSetParamInt(hmv, ximea_param.c_str(), ival);
1023
        break;
1024
    case xiTypeFloat :                  // float parameter type
1025
        stat = xiSetParamFloat(hmv, ximea_param.c_str(), fval);
1026
        break;
1027
    default:
1028
        errMsg("CvCaptureCAM_XIMEA::setProperty", XI_WRONG_PARAM_TYPE);
1029
        setProp_result = false;
1030
    }
1031

1032
    if(stat != XI_OK)
1033
    {
1034
        // report error on parameter setting
1035
        errMsg("CvCaptureCAM_XIMEA::setProperty, xiSetParam", stat);
1036
        setProp_result = false;
1037
    }
1038

1039
    if(doAcqReset)
1040
    {
1041
        stat = xiStartAcquisition(hmv);
1042
        errMsg("xiStartAcquisition::setProperty, xiStartAcquisition", stat);
1043
        if(stat != XI_OK)
1044
            setProp_result = false;
1045
    }
1046
    return setProp_result;
1047
}
1048

1049
/**********************************************************************************/
1050

1051
double CvCaptureCAM_XIMEA::getProperty( int property_id ) const
1052
{
1053
    XI_RETURN stat = XI_OK;
1054
    double getPropVal = 0;
1055
    int ival = 0;
1056
    float fval = 0;
1057
    string ximea_param = "";
1058
    XI_PRM_TYPE value_type = xiTypeInteger;
1059

1060
    if(hmv == NULL)
1061
    {
1062
        errMsg("CvCaptureCAM_XIMEA::getProperty", XI_INVALID_HANDLE);
1063
        return 0;
1064
    }
1065

1066
    // convert OCV property id to XIMEA id if necessary
1067
    property_id = ocvParamtoXimeaParam(property_id);
1068

1069
    // decode OpenCV parameter to xiAPI parameter
1070
    switch( property_id )
1071
    {
1072
    case CV_CAP_PROP_XI_TIMEOUT:
1073
        return (double) timeout;
1074
    case CV_CAP_PROP_XI_EXPOSURE:
1075
        ximea_param = "exposure";
1076
        value_type = xiTypeInteger;
1077
        break;
1078
    case CV_CAP_PROP_XI_EXPOSURE_BURST_COUNT:
1079
        ximea_param = "exposure_burst_count";
1080
        value_type = xiTypeInteger;
1081
        break;
1082
    case CV_CAP_PROP_XI_GAIN_SELECTOR:
1083
        ximea_param = "gain_selector";
1084
        value_type = xiTypeEnum;
1085
        break;
1086
    case CV_CAP_PROP_XI_GAIN:
1087
        ximea_param = "gain";
1088
        value_type = xiTypeFloat;
1089
        break;
1090
    case CV_CAP_PROP_XI_DOWNSAMPLING:
1091
        ximea_param = "downsampling";
1092
        value_type = xiTypeEnum;
1093
        break;
1094
    case CV_CAP_PROP_XI_DOWNSAMPLING_TYPE:
1095
        ximea_param = "downsampling_type";
1096
        value_type = xiTypeEnum;
1097
        break;
1098
    case CV_CAP_PROP_XI_BINNING_SELECTOR:
1099
        ximea_param = "binning_selector";
1100
        value_type = xiTypeEnum;
1101
        break;
1102
    case CV_CAP_PROP_XI_BINNING_VERTICAL:
1103
        ximea_param = "binning_vertical";
1104
        value_type = xiTypeInteger;
1105
        break;
1106
    case CV_CAP_PROP_XI_BINNING_HORIZONTAL:
1107
        ximea_param = "binning_horizontal";
1108
        value_type = xiTypeInteger;
1109
        break;
1110
    case CV_CAP_PROP_XI_BINNING_PATTERN:
1111
        ximea_param = "binning_pattern";
1112
        value_type = xiTypeEnum;
1113
        break;
1114
    case CV_CAP_PROP_XI_DECIMATION_SELECTOR:
1115
        ximea_param = "decimation_selector";
1116
        value_type = xiTypeEnum;
1117
        break;
1118
    case CV_CAP_PROP_XI_DECIMATION_VERTICAL:
1119
        ximea_param = "decimation_vertical";
1120
        value_type = xiTypeInteger;
1121
        break;
1122
    case CV_CAP_PROP_XI_DECIMATION_HORIZONTAL:
1123
        ximea_param = "decimation_horizontal";
1124
        value_type = xiTypeInteger;
1125
        break;
1126
    case CV_CAP_PROP_XI_DECIMATION_PATTERN:
1127
        ximea_param = "decimation_pattern";
1128
        value_type = xiTypeEnum;
1129
        break;
1130
    case CV_CAP_PROP_XI_TEST_PATTERN_GENERATOR_SELECTOR:
1131
        ximea_param = "test_pattern_generator_selector";
1132
        value_type = xiTypeEnum;
1133
        break;
1134
    case CV_CAP_PROP_XI_TEST_PATTERN:
1135
        ximea_param = "test_pattern";
1136
        value_type = xiTypeEnum;
1137
        break;
1138
    case CV_CAP_PROP_XI_IMAGE_DATA_FORMAT:
1139
        ximea_param = "imgdataformat";
1140
        value_type = xiTypeEnum;
1141
        break;
1142
    case CV_CAP_PROP_XI_SHUTTER_TYPE:
1143
        ximea_param = "shutter_type";
1144
        value_type = xiTypeEnum;
1145
        break;
1146
    case CV_CAP_PROP_XI_SENSOR_TAPS:
1147
        ximea_param = "sensor_taps";
1148
        value_type = xiTypeEnum;
1149
        break;
1150
    case CV_CAP_PROP_XI_AEAG:
1151
        ximea_param = "aeag";
1152
        value_type = xiTypeBoolean;
1153
        break;
1154
    case CV_CAP_PROP_XI_AEAG_ROI_OFFSET_X:
1155
        ximea_param = "aeag_roi_offset_x";
1156
        value_type = xiTypeInteger;
1157
        break;
1158
    case CV_CAP_PROP_XI_AEAG_ROI_OFFSET_Y:
1159
        ximea_param = "aeag_roi_offset_y";
1160
        value_type = xiTypeInteger;
1161
        break;
1162
    case CV_CAP_PROP_XI_AEAG_ROI_WIDTH:
1163
        ximea_param = "aeag_roi_width";
1164
        value_type = xiTypeInteger;
1165
        break;
1166
    case CV_CAP_PROP_XI_AEAG_ROI_HEIGHT:
1167
        ximea_param = "aeag_roi_height";
1168
        value_type = xiTypeInteger;
1169
        break;
1170
    case CV_CAP_PROP_XI_BPC:
1171
        ximea_param = "bpc";
1172
        value_type = xiTypeBoolean;
1173
        break;
1174
    case CV_CAP_PROP_XI_AUTO_WB:
1175
        ximea_param = "auto_wb";
1176
        value_type = xiTypeBoolean;
1177
        break;
1178
    case CV_CAP_PROP_XI_MANUAL_WB:
1179
        ximea_param = "manual_wb";
1180
        value_type = xiTypeCommand;
1181
        break;
1182
    case CV_CAP_PROP_XI_WB_KR:
1183
        ximea_param = "wb_kr";
1184
        value_type = xiTypeFloat;
1185
        break;
1186
    case CV_CAP_PROP_XI_WB_KG:
1187
        ximea_param = "wb_kg";
1188
        value_type = xiTypeFloat;
1189
        break;
1190
    case CV_CAP_PROP_XI_WB_KB:
1191
        ximea_param = "wb_kb";
1192
        value_type = xiTypeFloat;
1193
        break;
1194
    case CV_CAP_PROP_XI_WIDTH:
1195
        ximea_param = "width";
1196
        value_type = xiTypeInteger;
1197
        break;
1198
    case CV_CAP_PROP_XI_HEIGHT:
1199
        ximea_param = "height";
1200
        value_type = xiTypeInteger;
1201
        break;
1202
    case CV_CAP_PROP_XI_OFFSET_X:
1203
        ximea_param = "offsetX";
1204
        value_type = xiTypeInteger;
1205
        break;
1206
    case CV_CAP_PROP_XI_OFFSET_Y:
1207
        ximea_param = "offsetY";
1208
        value_type = xiTypeInteger;
1209
        break;
1210
    case CV_CAP_PROP_XI_REGION_SELECTOR :
1211
        ximea_param = "region_selector";
1212
        value_type = xiTypeInteger;
1213
        break;
1214
    case CV_CAP_PROP_XI_REGION_MODE :
1215
        ximea_param = "region_mode";
1216
        value_type = xiTypeInteger;
1217
        break;
1218
    case CV_CAP_PROP_XI_EXP_PRIORITY:
1219
        ximea_param = "exp_priority";
1220
        value_type = xiTypeFloat;
1221
        break;
1222
    case CV_CAP_PROP_XI_AG_MAX_LIMIT:
1223
        ximea_param = "ag_max_limit";
1224
        value_type = xiTypeFloat;
1225
        break;
1226
    case CV_CAP_PROP_XI_AE_MAX_LIMIT:
1227
        ximea_param = "ae_max_limit";
1228
        value_type = xiTypeInteger;
1229
        break;
1230
    case CV_CAP_PROP_XI_AEAG_LEVEL:
1231
        ximea_param = "aeag_level";
1232
        value_type = xiTypeInteger;
1233
        break;
1234
    case CV_CAP_PROP_XI_LIMIT_BANDWIDTH:
1235
        ximea_param = "limit_bandwidth";
1236
        value_type = xiTypeInteger;
1237
        break;
1238
    case CV_CAP_PROP_XI_SENSOR_DATA_BIT_DEPTH:
1239
        ximea_param = "sensor_bit_depth";
1240
        value_type = xiTypeEnum;
1241
        break;
1242
    case CV_CAP_PROP_XI_OUTPUT_DATA_BIT_DEPTH:
1243
        ximea_param = "output_bit_depth";
1244
        value_type = xiTypeEnum;
1245
        break;
1246
    case CV_CAP_PROP_XI_IMAGE_DATA_BIT_DEPTH:
1247
        ximea_param = "image_data_bit_depth";
1248
        value_type = xiTypeEnum;
1249
        break;
1250
    case CV_CAP_PROP_XI_OUTPUT_DATA_PACKING:
1251
        ximea_param = "output_bit_packing";
1252
        value_type = xiTypeBoolean;
1253
        break;
1254
    case CV_CAP_PROP_XI_OUTPUT_DATA_PACKING_TYPE:
1255
        ximea_param = "output_bit_packing_type";
1256
        value_type = xiTypeEnum;
1257
        break;
1258
    case CV_CAP_PROP_XI_IS_COOLED:
1259
        ximea_param = "iscooled";
1260
        value_type = xiTypeBoolean;
1261
        break;
1262
    case CV_CAP_PROP_XI_COOLING:
1263
        ximea_param = "cooling";
1264
        value_type = xiTypeBoolean;
1265
        break;
1266
    case CV_CAP_PROP_XI_TARGET_TEMP:
1267
        ximea_param = "target_temp";
1268
        value_type = xiTypeFloat;
1269
        break;
1270
    case CV_CAP_PROP_XI_CHIP_TEMP:
1271
        ximea_param = "chip_temp";
1272
        value_type = xiTypeFloat;
1273
        break;
1274
    case CV_CAP_PROP_XI_HOUS_TEMP:
1275
        ximea_param = "hous_temp";
1276
        value_type = xiTypeFloat;
1277
        break;
1278
    case CV_CAP_PROP_XI_HOUS_BACK_SIDE_TEMP:
1279
        ximea_param = "hous_back_side_temp";
1280
        value_type = xiTypeFloat;
1281
        break;
1282
    case CV_CAP_PROP_XI_SENSOR_BOARD_TEMP:
1283
        ximea_param = "sensor_board_temp";
1284
        value_type = xiTypeFloat;
1285
        break;
1286
    case CV_CAP_PROP_XI_CMS:
1287
        ximea_param = "cms";
1288
        value_type = xiTypeEnum;
1289
        break;
1290
    case CV_CAP_PROP_XI_APPLY_CMS:
1291
        ximea_param = "apply_cms";
1292
        value_type = xiTypeBoolean;
1293
        break;
1294
    case CV_CAP_PROP_XI_IMAGE_IS_COLOR:
1295
        ximea_param = "iscolor";
1296
        value_type = xiTypeBoolean;
1297
        break;
1298
    case CV_CAP_PROP_XI_COLOR_FILTER_ARRAY:
1299
        ximea_param = "cfa";
1300
        value_type = xiTypeEnum;
1301
        break;
1302
    case CV_CAP_PROP_XI_GAMMAY:
1303
        ximea_param = "gammaY";
1304
        value_type = xiTypeFloat;
1305
        break;
1306
    case CV_CAP_PROP_XI_GAMMAC:
1307
        ximea_param = "gammaC";
1308
        value_type = xiTypeFloat;
1309
        break;
1310
    case CV_CAP_PROP_XI_SHARPNESS:
1311
        ximea_param = "sharpness";
1312
        value_type = xiTypeFloat;
1313
        break;
1314
    case CV_CAP_PROP_XI_CC_MATRIX_00:
1315
        ximea_param = "ccMTX00";
1316
        value_type = xiTypeFloat;
1317
        break;
1318
    case CV_CAP_PROP_XI_CC_MATRIX_01:
1319
        ximea_param = "ccMTX01";
1320
        value_type = xiTypeFloat;
1321
        break;
1322
    case CV_CAP_PROP_XI_CC_MATRIX_02:
1323
        ximea_param = "ccMTX02";
1324
        value_type = xiTypeFloat;
1325
        break;
1326
    case CV_CAP_PROP_XI_CC_MATRIX_03:
1327
        ximea_param = "ccMTX03";
1328
        value_type = xiTypeFloat;
1329
        break;
1330
    case CV_CAP_PROP_XI_CC_MATRIX_10:
1331
        ximea_param = "ccMTX10";
1332
        value_type = xiTypeFloat;
1333
        break;
1334
    case CV_CAP_PROP_XI_CC_MATRIX_11:
1335
        ximea_param = "ccMTX11";
1336
        value_type = xiTypeFloat;
1337
        break;
1338
    case CV_CAP_PROP_XI_CC_MATRIX_12:
1339
        ximea_param = "ccMTX12";
1340
        value_type = xiTypeFloat;
1341
        break;
1342
    case CV_CAP_PROP_XI_CC_MATRIX_13:
1343
        ximea_param = "ccMTX13";
1344
        value_type = xiTypeFloat;
1345
        break;
1346
    case CV_CAP_PROP_XI_CC_MATRIX_20:
1347
        ximea_param = "ccMTX20";
1348
        value_type = xiTypeFloat;
1349
        break;
1350
    case CV_CAP_PROP_XI_CC_MATRIX_21:
1351
        ximea_param = "ccMTX21";
1352
        value_type = xiTypeFloat;
1353
        break;
1354
    case CV_CAP_PROP_XI_CC_MATRIX_22:
1355
        ximea_param = "ccMTX22";
1356
        value_type = xiTypeFloat;
1357
        break;
1358
    case CV_CAP_PROP_XI_CC_MATRIX_23:
1359
        ximea_param = "ccMTX23";
1360
        value_type = xiTypeFloat;
1361
        break;
1362
    case CV_CAP_PROP_XI_CC_MATRIX_30:
1363
        ximea_param = "ccMTX30";
1364
        value_type = xiTypeFloat;
1365
        break;
1366
    case CV_CAP_PROP_XI_CC_MATRIX_31:
1367
        ximea_param = "ccMTX31";
1368
        value_type = xiTypeFloat;
1369
        break;
1370
    case CV_CAP_PROP_XI_CC_MATRIX_32:
1371
        ximea_param = "ccMTX32";
1372
        value_type = xiTypeFloat;
1373
        break;
1374
    case CV_CAP_PROP_XI_CC_MATRIX_33:
1375
        ximea_param = "ccMTX33";
1376
        value_type = xiTypeFloat;
1377
        break;
1378
    case CV_CAP_PROP_XI_DEFAULT_CC_MATRIX:
1379
        ximea_param = "defccMTX";
1380
        value_type = xiTypeCommand;
1381
        break;
1382
    case CV_CAP_PROP_XI_TRG_SOURCE:
1383
        ximea_param = "trigger_source";
1384
        value_type = xiTypeEnum;
1385
        break;
1386
    case CV_CAP_PROP_XI_TRG_SOFTWARE:
1387
        ximea_param = "trigger_software";
1388
        value_type = xiTypeCommand;
1389
        break;
1390
    case CV_CAP_PROP_XI_TRG_SELECTOR:
1391
        ximea_param = "trigger_selector";
1392
        value_type = xiTypeEnum;
1393
        break;
1394
    case CV_CAP_PROP_XI_ACQ_FRAME_BURST_COUNT:
1395
        ximea_param = "acq_frame_burst_count";
1396
        value_type = xiTypeInteger;
1397
        break;
1398
    case CV_CAP_PROP_XI_GPI_SELECTOR:
1399
        ximea_param = "gpi_selector";
1400
        value_type = xiTypeEnum;
1401
        break;
1402
    case CV_CAP_PROP_XI_GPI_MODE:
1403
        ximea_param = "gpi_mode";
1404
        value_type = xiTypeEnum;
1405
        break;
1406
    case CV_CAP_PROP_XI_GPI_LEVEL:
1407
        ximea_param = "gpi_level";
1408
        value_type = xiTypeInteger;
1409
        break;
1410
    case CV_CAP_PROP_XI_GPO_SELECTOR:
1411
        ximea_param = "gpo_selector";
1412
        value_type = xiTypeEnum;
1413
        break;
1414
    case CV_CAP_PROP_XI_GPO_MODE:
1415
        ximea_param = "gpo_mode";
1416
        value_type = xiTypeEnum;
1417
        break;
1418
    case CV_CAP_PROP_XI_LED_SELECTOR:
1419
        ximea_param = "led_selector";
1420
        value_type = xiTypeEnum;
1421
        break;
1422
    case CV_CAP_PROP_XI_LED_MODE:
1423
        ximea_param = "led_mode";
1424
        value_type = xiTypeEnum;
1425
        break;
1426
    case CV_CAP_PROP_XI_DEBOUNCE_EN:
1427
        ximea_param = "dbnc_en";
1428
        value_type = xiTypeBoolean;
1429
        break;
1430
    case CV_CAP_PROP_XI_DEBOUNCE_T0:
1431
        ximea_param = "dbnc_t0";
1432
        value_type = xiTypeInteger;
1433
        break;
1434
    case CV_CAP_PROP_XI_DEBOUNCE_T1:
1435
        ximea_param = "dbnc_t1";
1436
        value_type = xiTypeInteger;
1437
        break;
1438
    case CV_CAP_PROP_XI_DEBOUNCE_POL:
1439
        ximea_param = "dbnc_pol";
1440
        value_type = xiTypeInteger;
1441
        break;
1442
    case CV_CAP_PROP_XI_LENS_MODE:
1443
        ximea_param = "lens_mode";
1444
        value_type = xiTypeBoolean;
1445
        break;
1446
    case CV_CAP_PROP_XI_LENS_APERTURE_VALUE:
1447
        ximea_param = "lens_aperture_value";
1448
        value_type = xiTypeFloat;
1449
        break;
1450
    case CV_CAP_PROP_XI_LENS_FOCUS_MOVEMENT_VALUE:
1451
        ximea_param = "lens_focus_movement_value";
1452
        value_type = xiTypeInteger;
1453
        break;
1454
    case CV_CAP_PROP_XI_LENS_FOCUS_MOVE:
1455
        ximea_param = "lens_focus_move";
1456
        value_type = xiTypeCommand;
1457
        break;
1458
    case CV_CAP_PROP_XI_LENS_FOCUS_DISTANCE:
1459
        ximea_param = "lens_focus_distance";
1460
        value_type = xiTypeFloat;
1461
        break;
1462
    case CV_CAP_PROP_XI_LENS_FOCAL_LENGTH:
1463
        ximea_param = "lens_focal_length";
1464
        value_type = xiTypeFloat;
1465
        break;
1466
    case CV_CAP_PROP_XI_LENS_FEATURE_SELECTOR:
1467
        ximea_param = "lens_feature_selector";
1468
        value_type = xiTypeEnum;
1469
        break;
1470
    case CV_CAP_PROP_XI_LENS_FEATURE:
1471
        ximea_param = "lens_feature";
1472
        value_type = xiTypeFloat;
1473
        break;
1474
    case CV_CAP_PROP_XI_DEVICE_MODEL_ID:
1475
        ximea_param = "device_model_id";
1476
        value_type = xiTypeInteger;
1477
        break;
1478
    case CV_CAP_PROP_XI_DEVICE_SN:
1479
        ximea_param = "device_sn";
1480
        value_type = xiTypeInteger;
1481
        break;
1482
    case CV_CAP_PROP_XI_IMAGE_DATA_FORMAT_RGB32_ALPHA:
1483
        ximea_param = "imgdataformatrgb32alpha";
1484
        value_type = xiTypeInteger;
1485
        break;
1486
    case CV_CAP_PROP_XI_IMAGE_PAYLOAD_SIZE:
1487
        ximea_param = "imgpayloadsize";
1488
        value_type = xiTypeInteger;
1489
        break;
1490
    case CV_CAP_PROP_XI_TRANSPORT_PIXEL_FORMAT:
1491
        ximea_param = "transport_pixel_format";
1492
        value_type = xiTypeEnum;
1493
        break;
1494
    case CV_CAP_PROP_XI_SENSOR_CLOCK_FREQ_HZ:
1495
        ximea_param = "sensor_clock_freq_hz";
1496
        value_type = xiTypeFloat;
1497
        break;
1498
    case CV_CAP_PROP_XI_SENSOR_CLOCK_FREQ_INDEX:
1499
        ximea_param = "sensor_clock_freq_index";
1500
        value_type = xiTypeInteger;
1501
        break;
1502
    case CV_CAP_PROP_XI_SENSOR_OUTPUT_CHANNEL_COUNT:
1503
        ximea_param = "sensor_output_channel_count";
1504
        value_type = xiTypeEnum;
1505
        break;
1506
    case CV_CAP_PROP_XI_FRAMERATE:
1507
        ximea_param = "framerate";
1508
        value_type = xiTypeFloat;
1509
        break;
1510
    case CV_CAP_PROP_XI_COUNTER_SELECTOR:
1511
        ximea_param = "counter_selector";
1512
        value_type = xiTypeEnum;
1513
        break;
1514
    case CV_CAP_PROP_XI_COUNTER_VALUE:
1515
        ximea_param = "counter_value";
1516
        value_type = xiTypeInteger;
1517
        break;
1518
    case CV_CAP_PROP_XI_ACQ_TIMING_MODE:
1519
        ximea_param = "acq_timing_mode";
1520
        value_type = xiTypeEnum;
1521
        break;
1522
    case CV_CAP_PROP_XI_AVAILABLE_BANDWIDTH:
1523
        ximea_param = "available_bandwidth";
1524
        value_type = xiTypeInteger;
1525
        break;
1526
    case CV_CAP_PROP_XI_BUFFER_POLICY:
1527
        ximea_param = "buffer_policy";
1528
        value_type = xiTypeEnum;
1529
        break;
1530
    case CV_CAP_PROP_XI_LUT_EN:
1531
        ximea_param = "LUTEnable";
1532
        value_type = xiTypeBoolean;
1533
        break;
1534
    case CV_CAP_PROP_XI_LUT_INDEX:
1535
        ximea_param = "LUTIndex";
1536
        value_type = xiTypeInteger;
1537
        break;
1538
    case CV_CAP_PROP_XI_LUT_VALUE:
1539
        ximea_param = "LUTValue";
1540
        value_type = xiTypeInteger;
1541
        break;
1542
    case CV_CAP_PROP_XI_TRG_DELAY:
1543
        ximea_param = "trigger_delay";
1544
        value_type = xiTypeEnum;
1545
        break;
1546
    case CV_CAP_PROP_XI_TS_RST_MODE:
1547
        ximea_param = "ts_rst_mode";
1548
        value_type = xiTypeEnum;
1549
        break;
1550
    case CV_CAP_PROP_XI_TS_RST_SOURCE:
1551
        ximea_param = "ts_rst_source";
1552
        value_type = xiTypeEnum;
1553
        break;
1554
    case CV_CAP_PROP_XI_IS_DEVICE_EXIST:
1555
        ximea_param = "isexist";
1556
        value_type = xiTypeBoolean;
1557
        break;
1558
    case CV_CAP_PROP_XI_ACQ_BUFFER_SIZE:
1559
        ximea_param = "acq_buffer_size";
1560
        value_type = xiTypeInteger;
1561
        break;
1562
    case CV_CAP_PROP_XI_ACQ_BUFFER_SIZE_UNIT:
1563
        ximea_param = "acq_buffer_size_unit";
1564
        value_type = xiTypeInteger;
1565
        break;
1566
    case CV_CAP_PROP_XI_ACQ_TRANSPORT_BUFFER_SIZE:
1567
        ximea_param = "acq_transport_buffer_size";
1568
        value_type = xiTypeInteger;
1569
        break;
1570
    case CV_CAP_PROP_XI_BUFFERS_QUEUE_SIZE:
1571
        ximea_param = "buffers_queue_size";
1572
        value_type = xiTypeInteger;
1573
        break;
1574
    case CV_CAP_PROP_XI_ACQ_TRANSPORT_BUFFER_COMMIT:
1575
        ximea_param = "acq_transport_buffer_commit";
1576
        value_type = xiTypeInteger;
1577
        break;
1578
    case CV_CAP_PROP_XI_RECENT_FRAME:
1579
        ximea_param = "recent_frame";
1580
        value_type = xiTypeBoolean;
1581
        break;
1582
    case CV_CAP_PROP_XI_DEVICE_RESET:
1583
        ximea_param = "device_reset";
1584
        value_type = xiTypeCommand;
1585
        break;
1586
    case CV_CAP_PROP_XI_COLUMN_FPN_CORRECTION:
1587
        ximea_param = "column_fpn_correction";
1588
        value_type = xiTypeEnum;
1589
        break;
1590
    case CV_CAP_PROP_XI_ROW_FPN_CORRECTION:
1591
        ximea_param = "row_fpn_correction";
1592
        value_type = xiTypeEnum;
1593
        break;
1594
    case CV_CAP_PROP_XI_SENSOR_MODE:
1595
        ximea_param = "sensor_mode";
1596
        value_type = xiTypeEnum;
1597
        break;
1598
    case CV_CAP_PROP_XI_HDR:
1599
        ximea_param = "hdr";
1600
        value_type = xiTypeBoolean;
1601
        break;
1602
    case CV_CAP_PROP_XI_HDR_KNEEPOINT_COUNT:
1603
        ximea_param = "hdr_kneepoint_count";
1604
        value_type = xiTypeInteger;
1605
        break;
1606
    case CV_CAP_PROP_XI_HDR_T1:
1607
        ximea_param = "hdr_t1";
1608
        value_type = xiTypeInteger;
1609
        break;
1610
    case CV_CAP_PROP_XI_HDR_T2:
1611
        ximea_param = "hdr_t2";
1612
        value_type = xiTypeInteger;
1613
        break;
1614
    case CV_CAP_PROP_XI_KNEEPOINT1:
1615
        ximea_param = "hdr_kneepoint1";
1616
        value_type = xiTypeInteger;
1617
        break;
1618
    case CV_CAP_PROP_XI_KNEEPOINT2:
1619
        ximea_param = "hdr_kneepoint2";
1620
        value_type = xiTypeInteger;
1621
        break;
1622
    case CV_CAP_PROP_XI_IMAGE_BLACK_LEVEL:
1623
        ximea_param = "image_black_level";
1624
        value_type = xiTypeInteger;
1625
        break;
1626
    case CV_CAP_PROP_XI_HW_REVISION:
1627
        ximea_param = "hw_revision";
1628
        value_type = xiTypeInteger;
1629
        break;
1630
    case CV_CAP_PROP_XI_DEBUG_LEVEL:
1631
        ximea_param = "debug_level";
1632
        value_type = xiTypeEnum;
1633
        break;
1634
    case CV_CAP_PROP_XI_AUTO_BANDWIDTH_CALCULATION:
1635
        ximea_param = "auto_bandwidth_calculation";
1636
        value_type = xiTypeBoolean;
1637
        break;
1638
    case CV_CAP_PROP_XI_FFS_FILE_ID:
1639
        ximea_param = "ffs_file_id";
1640
        value_type = xiTypeInteger;
1641
        break;
1642
    case CV_CAP_PROP_XI_FFS_FILE_SIZE:
1643
        ximea_param = "ffs_file_size";
1644
        value_type = xiTypeInteger;
1645
        break;
1646
    case CV_CAP_PROP_XI_FREE_FFS_SIZE:
1647
        ximea_param = "free_ffs_size";
1648
        value_type = xiTypeInteger;
1649
        break;
1650
    case CV_CAP_PROP_XI_USED_FFS_SIZE:
1651
        ximea_param = "used_ffs_size";
1652
        value_type = xiTypeInteger;
1653
        break;
1654
    case CV_CAP_PROP_XI_FFS_ACCESS_KEY:
1655
        ximea_param = "ffs_access_key";
1656
        value_type = xiTypeInteger;
1657
        break;
1658
    case CV_CAP_PROP_XI_SENSOR_FEATURE_SELECTOR:
1659
        ximea_param = "sensor_feature_selector";
1660
        value_type = xiTypeEnum;
1661
        break;
1662
    case CV_CAP_PROP_XI_SENSOR_FEATURE_VALUE:
1663
        ximea_param = "sensor_feature_value";
1664
        value_type = xiTypeInteger;
1665
        break;
1666
    default:
1667
        // report invalid parameter as it is not of string type
1668
        errMsg("CvCaptureCAM_XIMEA::getProperty", XI_UNKNOWN_PARAM);
1669
        return 0;
1670
    }
1671

1672
    switch(value_type)
1673
    {
1674
    case xiTypeInteger :               // integer parameter type
1675
    case xiTypeEnum :                // enumerator parameter type
1676
    case xiTypeBoolean :             // boolean parameter type
1677
    case xiTypeCommand :          // command parameter type
1678
        stat = xiGetParamInt(hmv, ximea_param.c_str(), &ival);
1679
        if(stat == XI_OK) getPropVal = ival;
1680
        else errMsg("CvCaptureCAM_XIMEA::getProperty, xiGetParamInt", stat);
1681
        break;
1682
    case xiTypeFloat :                  // float parameter type
1683
        stat = xiGetParamFloat(hmv, ximea_param.c_str(), &fval);
1684
        if(stat == XI_OK) getPropVal = fval;
1685
        else errMsg("CvCaptureCAM_XIMEA::getProperty, xiGetParamFloat", stat);
1686
        break;
1687
    default:
1688
        // unknown value type selected
1689
        errMsg("CvCaptureCAM_XIMEA::getProperty", XI_WRONG_PARAM_TYPE);
1690
    }
1691
    return getPropVal;
1692
}
1693

1694
/**********************************************************************************/
1695

1696
void CvCaptureCAM_XIMEA::errMsg(const char* msg, int errNum) const
1697
{
1698
    // with XI_OK there is nothing to report
1699
    if(errNum == XI_OK) return;
1700
    string error_message = "";
1701
    switch(errNum)
1702
    {
1703

1704
    case XI_OK : error_message = "Function call succeeded"; break;
1705
    case XI_INVALID_HANDLE : error_message = "Invalid handle"; break;
1706
    case XI_READREG : error_message = "Register read error"; break;
1707
    case XI_WRITEREG : error_message = "Register write error"; break;
1708
    case XI_FREE_RESOURCES : error_message = "Freeing resiurces error"; break;
1709
    case XI_FREE_CHANNEL : error_message = "Freeing channel error"; break;
1710
    case XI_FREE_BANDWIDTH : error_message = "Freeing bandwidth error"; break;
1711
    case XI_READBLK : error_message = "Read block error"; break;
1712
    case XI_WRITEBLK : error_message = "Write block error"; break;
1713
    case XI_NO_IMAGE : error_message = "No image"; break;
1714
    case XI_TIMEOUT : error_message = "Timeout"; break;
1715
    case XI_INVALID_ARG : error_message = "Invalid arguments supplied"; break;
1716
    case XI_NOT_SUPPORTED : error_message = "Not supported"; break;
1717
    case XI_ISOCH_ATTACH_BUFFERS : error_message = "Attach buffers error"; break;
1718
    case XI_GET_OVERLAPPED_RESULT : error_message = "Overlapped result"; break;
1719
    case XI_MEMORY_ALLOCATION : error_message = "Memory allocation error"; break;
1720
    case XI_DLLCONTEXTISNULL : error_message = "DLL context is NULL"; break;
1721
    case XI_DLLCONTEXTISNONZERO : error_message = "DLL context is non zero"; break;
1722
    case XI_DLLCONTEXTEXIST : error_message = "DLL context exists"; break;
1723
    case XI_TOOMANYDEVICES : error_message = "Too many devices connected"; break;
1724
    case XI_ERRORCAMCONTEXT : error_message = "Camera context error"; break;
1725
    case XI_UNKNOWN_HARDWARE : error_message = "Unknown hardware"; break;
1726
    case XI_INVALID_TM_FILE : error_message = "Invalid TM file"; break;
1727
    case XI_INVALID_TM_TAG : error_message = "Invalid TM tag"; break;
1728
    case XI_INCOMPLETE_TM : error_message = "Incomplete TM"; break;
1729
    case XI_BUS_RESET_FAILED : error_message = "Bus reset error"; break;
1730
    case XI_NOT_IMPLEMENTED : error_message = "Not implemented"; break;
1731
    case XI_SHADING_TOOBRIGHT : error_message = "Shading too bright"; break;
1732
    case XI_SHADING_TOODARK : error_message = "Shading too dark"; break;
1733
    case XI_TOO_LOW_GAIN : error_message = "Gain is too low"; break;
1734
    case XI_INVALID_BPL : error_message = "Invalid bad pixel list"; break;
1735
    case XI_BPL_REALLOC : error_message = "Bad pixel list realloc error"; break;
1736
    case XI_INVALID_PIXEL_LIST : error_message = "Invalid pixel list"; break;
1737
    case XI_INVALID_FFS : error_message = "Invalid Flash File System"; break;
1738
    case XI_INVALID_PROFILE : error_message = "Invalid profile"; break;
1739
    case XI_INVALID_CALIBRATION : error_message = "Invalid calibration"; break;
1740
    case XI_INVALID_BUFFER : error_message = "Invalid buffer"; break;
1741
    case XI_INVALID_DATA : error_message = "Invalid data"; break;
1742
    case XI_TGBUSY : error_message = "Timing generator is busy"; break;
1743
    case XI_IO_WRONG : error_message = "Wrong operation open/write/read/close"; break;
1744
    case XI_ACQUISITION_ALREADY_UP : error_message = "Acquisition already started"; break;
1745
    case XI_OLD_DRIVER_VERSION : error_message = "Old version of device driver installed to the system."; break;
1746
    case XI_GET_LAST_ERROR : error_message = "To get error code please call GetLastError function."; break;
1747
    case XI_CANT_PROCESS : error_message = "Data can't be processed"; break;
1748
    case XI_ACQUISITION_STOPED : error_message = "Acquisition has been stopped. It should be started before GetImage."; break;
1749
    case XI_ACQUISITION_STOPED_WERR : error_message = "Acquisition has been stopped with error."; break;
1750
    case XI_INVALID_INPUT_ICC_PROFILE : error_message = "Input ICC profile missed or corrupted"; break;
1751
    case XI_INVALID_OUTPUT_ICC_PROFILE : error_message = "Output ICC profile missed or corrupted"; break;
1752
    case XI_DEVICE_NOT_READY : error_message = "Device not ready to operate"; break;
1753
    case XI_SHADING_TOOCONTRAST : error_message = "Shading too contrast"; break;
1754
    case XI_ALREADY_INITIALIZED : error_message = "Module already initialized"; break;
1755
    case XI_NOT_ENOUGH_PRIVILEGES : error_message = "Application doesn't enough privileges(one or more app"; break;
1756
    case XI_NOT_COMPATIBLE_DRIVER : error_message = "Installed driver not compatible with current software"; break;
1757
    case XI_TM_INVALID_RESOURCE : error_message = "TM file was not loaded successfully from resources"; break;
1758
    case XI_DEVICE_HAS_BEEN_RESETED : error_message = "Device has been reset, abnormal initial state"; break;
1759
    case XI_NO_DEVICES_FOUND : error_message = "No Devices Found"; break;
1760
    case XI_RESOURCE_OR_FUNCTION_LOCKED : error_message = "Resource(device) or function locked by mutex"; break;
1761
    case XI_BUFFER_SIZE_TOO_SMALL : error_message = "Buffer provided by user is too small"; break;
1762
    case XI_COULDNT_INIT_PROCESSOR : error_message = "Couldn't initialize processor."; break;
1763
    case XI_NOT_INITIALIZED : error_message = "The object/module/procedure/process being referred to has not been started."; break;
1764
    case XI_RESOURCE_NOT_FOUND : error_message = "Resource not found(could be processor, file, item..)."; break;
1765
    case XI_UNKNOWN_PARAM : error_message = "Unknown parameter"; break;
1766
    case XI_WRONG_PARAM_VALUE : error_message = "Wrong parameter value"; break;
1767
    case XI_WRONG_PARAM_TYPE : error_message = "Wrong parameter type"; break;
1768
    case XI_WRONG_PARAM_SIZE : error_message = "Wrong parameter size"; break;
1769
    case XI_BUFFER_TOO_SMALL : error_message = "Input buffer too small"; break;
1770
    case XI_NOT_SUPPORTED_PARAM : error_message = "Parameter info not supported"; break;
1771
    case XI_NOT_SUPPORTED_PARAM_INFO : error_message = "Parameter info not supported"; break;
1772
    case XI_NOT_SUPPORTED_DATA_FORMAT : error_message = "Data format not supported"; break;
1773
    case XI_READ_ONLY_PARAM : error_message = "Read only parameter"; break;
1774
    case XI_BANDWIDTH_NOT_SUPPORTED : error_message = "This camera does not support currently available bandwidth"; break;
1775
    case XI_INVALID_FFS_FILE_NAME : error_message = "FFS file selector is invalid or NULL"; break;
1776
    case XI_FFS_FILE_NOT_FOUND : error_message = "FFS file not found"; break;
1777
    case XI_PROC_OTHER_ERROR : error_message = "Processing error - other"; break;
1778
    case XI_PROC_PROCESSING_ERROR : error_message = "Error while image processing."; break;
1779
    case XI_PROC_INPUT_FORMAT_UNSUPPORTED : error_message = "Input format is not supported for processing."; break;
1780
    case XI_PROC_OUTPUT_FORMAT_UNSUPPORTED : error_message = "Output format is not supported for processing."; break;
1781
    default:
1782
        error_message = "Unknown error value";
1783
    }
1784

1785
    #if defined _WIN32
1786
    char buf[512]="";
1787
    sprintf( buf, "%s : %d, %s\n", msg, errNum, error_message.c_str());
1788
    OutputDebugString(buf);
1789
    #else
1790
    fprintf(stderr, "%s : %d, %s\n", msg, errNum, error_message.c_str());
1791
    #endif
1792
}
1793

1794
/**********************************************************************************/
1795
Product

Resources

Company
