1 ////////////////////////////////////////////////////////////////////////////////////////
2 //
3 // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
4 //
5 // By downloading, copying, installing or using the software you agree to this license.
6 // If you do not agree to this license, do not download, install,
7 // copy or use the software.
8 //
9 //
10 // Intel License Agreement
11 // For Open Source Computer Vision Library
12 //
13 // Copyright (C) 2000, Intel Corporation, all rights reserved.
14 // Third party copyrights are property of their respective owners.
15 //
16 // Redistribution and use in source and binary forms, with or without modification,
17 // are permitted provided that the following conditions are met:
18 //
19 // * Redistribution's of source code must retain the above copyright notice,
20 // this list of conditions and the following disclaimer.
21 //
22 // * Redistribution's in binary form must reproduce the above copyright notice,
23 // this list of conditions and the following disclaimer in the documentation
24 // and/or other materials provided with the distribution.
25 //
26 // * The name of Intel Corporation may not be used to endorse or promote products
27 // derived from this software without specific prior written permission.
28 //
29 // This software is provided by the copyright holders and contributors "as is" and
30 // any express or implied warranties, including, but not limited to, the implied
31 // warranties of merchantability and fitness for a particular purpose are disclaimed.
32 // In no event shall the Intel Corporation or contributors be liable for any direct,
33 // indirect, incidental, special, exemplary, or consequential damages
34 // (including, but not limited to, procurement of substitute goods or services;
35 // loss of use, data, or profits; or business interruption) however caused
36 // and on any theory of liability, whether in contract, strict liability,
37 // or tort (including negligence or otherwise) arising in any way out of
38 // the use of this software, even if advised of the possibility of such damage.
39 //
40 //
41
42 //
43 // The code has been contributed by Vladimir N. Litvinenko on 2012 Jul
44 // mailto:vladimir.litvinenko@codepaint.ru
45 //
46
47 #include "precomp.hpp"
48 #include <GigEVisionSDK.h>
49 #include <GigEVisionSDK.cpp>
50
51 #ifdef WIN32
52 #include <io.h>
53 #else
54 #include <stdio.h>
55 #endif
56
57 #ifdef NDEBUG
58 #define CV_WARN(message)
59 #else
60 #define CV_WARN(message) fprintf(stderr, "warning: %s (%s:%d)\n", message, __FILE__, __LINE__)
61 #endif
62
63 #define QTGIG_HEARTBEAT_TIME (12000.0)
64 #define QTGIG_MAX_WAIT_TIME (2.0)
65 #define QTGIG_IMG_WAIT_TIME (3.0)
66
67 /*----------------------------------------------------------------------------*/
68 /**
69 \internal
70 \fn bool wrprInitGigEVisionAPI();
71 \brief Wrapper to GigEVisionAPI function gige::InitGigEVisionAPI ()
72 \return true -- success
73 See \a wrprExitGigEVisionAPI
74
75 */
76 bool
wrprInitGigEVisionAPI()77 wrprInitGigEVisionAPI()
78 {
79 CV_FUNCNAME("wrprInitGigEVisionAPI");
80 __BEGIN__;
81
82 try {
83 gige::InitGigEVisionAPI ();
84 } catch(...) {
85 CV_ERROR(CV_StsError, "GigEVisionAPI: initialization (InitGigEVisionAPI()) failed.\n");
86 }
87 __END__;
88 return true;
89 }
90
91 /*----------------------------------------------------------------------------*/
92 /**
93 \internal
94 \fn void wrprExitGigEVisionAPI()
95 \brief Wrapper to GigEVisionAPI function gige::ExitGigEVisionAPI ()
96 \return true -- success
97 See \a wrprInitGigEVisionAPI
98
99 */
100 bool
wrprExitGigEVisionAPI()101 wrprExitGigEVisionAPI()
102 {
103 CV_FUNCNAME("wrprExitGigEVisionAPI");
104 __BEGIN__;
105
106 try {
107 gige::ExitGigEVisionAPI ();
108 } catch(...) {
109 CV_ERROR(CV_StsError, "GigEVisionAPI: finalization (ExitGigEVisionAPI()) failed.\n");
110 return false;
111 }
112 __END__;
113 return true;
114 }
115
116
117 /*----------------------------------------------------------------------------*/
118 /**
119 \internal
120 \fn gige::IGigEVisionAPI wrprGetGigEVisionAPI()
121 \brief Wrapper to GigEVisionAPI function gige::GetGigEVisionAPI ()
122 \return item of gige::IGigEVisionAPI type
123 See \a wrprInitGigEVisionAPI, \a gige::IGigEVisionAPI
124 */
125 gige::IGigEVisionAPI
wrprGetGigEVisionAPI()126 wrprGetGigEVisionAPI()
127 {
128
129 gige::IGigEVisionAPI b_ret = 0;
130
131 CV_FUNCNAME("wrprGetGigEVisionAPI");
132 __BEGIN__;
133
134 try {
135 b_ret = gige::GetGigEVisionAPI ();
136 } catch(...) {
137 CV_ERROR(CV_StsError, "GigEVisionAPI: API instance (from GetGigEVisionAPI()) failed.\n");
138 }
139
140 __END__;
141
142 return b_ret;
143 }
144
145
146 /*----------------------------------------------------------------------------*/
147 /**
148 \internal
149 \fn bool wrprUnregisterCallback( const gige::IGigEVisionAPI* api, gige::ICallbackEvent* eventHandler)
150 \brief Wrapper to GigEVisionAPI function
151 \param api
152 \param eventHandler
153 \return true - succsess, else - false
154 See \a wrprInitGigEVisionAPI, \a gige::IGigEVisionAPI
155
156 */
157 bool
wrprUnregisterCallback(const gige::IGigEVisionAPI * api,gige::ICallbackEvent * eventHandler)158 wrprUnregisterCallback( const gige::IGigEVisionAPI* api, gige::ICallbackEvent* eventHandler)
159 {
160 bool b_ret = api != NULL;
161
162 if(b_ret) b_ret = api->IsValid ();
163
164 CV_FUNCNAME("wrprUnregisterCallback");
165 __BEGIN__;
166
167 if(b_ret)
168 {
169 if(eventHandler != NULL)
170 {
171 try {
172 b_ret = ((gige::IGigEVisionAPIInterface*)api)->UnregisterCallback (eventHandler);
173 } catch(...) {
174 CV_ERROR(CV_StsError, "GigEVisionAPI: API unregister callback function (from UnregisterCallback()) failed.\n");
175 b_ret = false;
176 }
177 }
178 }
179 __END__;
180
181 return (b_ret);
182 }
183
184
185 /*----------------------------------------------------------------------------*/
186 /**
187 \internal
188 \fn bool wrprDeviceIsConnect( gige::IDevice& device )
189 \brief Wrapper to GigEVisionAPI function IDevice::IsConnected()
190 \param device - selected device
191 \return true - device connected
192 */
193 bool
wrprDeviceIsConnect(gige::IDevice & device)194 wrprDeviceIsConnect( gige::IDevice& device )
195 {
196 bool b_ret = device != NULL;
197
198 CV_FUNCNAME("wrprDeviceIsConnect");
199 __BEGIN__;
200
201 if(b_ret)
202 {
203 try {
204 b_ret = device->IsConnected ();
205 } catch (...) {
206 CV_ERROR(CV_StsError, "GigEVisionAPI: API device connection state (from IsConnected()) failed.\n");
207 b_ret = false;
208 }
209 }
210 __END__;
211
212 return (b_ret);
213 }
214
215
216 /*----------------------------------------------------------------------------*/
217 /**
218 \internal
219 \fn bool wrprDeviceIsValid( gige::IDevice& device )
220 \brief Wrapper to GigEVisionAPI function IDevice::Connect()
221 \param device - selected device
222 \return true - device valid
223
224 */
225 bool
wrprDeviceIsValid(gige::IDevice & device)226 wrprDeviceIsValid( gige::IDevice& device )
227 {
228 bool b_ret = device != NULL;
229
230 CV_FUNCNAME("wrprDeviceIsConnect");
231 __BEGIN__;
232
233 if(b_ret)
234 {
235 try {
236 b_ret = device.IsValid ();
237 } catch (...) {
238 CV_ERROR(CV_StsError, "GigEVisionAPI: API device validation state (from IsValid()) failed.\n");
239 b_ret = false;
240 }
241 }
242 __END__;
243
244 return (b_ret);
245 }
246
247
248 /*----------------------------------------------------------------------------*/
249 /**
250 \internal
251 \fn bool wrprDeviceDisconnect ( gige::IDevice& device )
252 \brief Wrapper to GigEVisionAPI function IDevice::Disconnect()
253 \param device - selected device
254 \return true - device valid
255
256 */
257 bool
wrprDeviceDisconnect(gige::IDevice & device)258 wrprDeviceDisconnect ( gige::IDevice& device )
259 {
260 bool b_ret = device != NULL;
261
262 CV_FUNCNAME("wrprDeviceDisconnect");
263 __BEGIN__;
264
265 if(b_ret)
266 {
267 try {
268 device->Disconnect ();
269 } catch (...) {
270 CV_ERROR(CV_StsError, "GigEVisionAPI: API device disconnect (from Disconnect()) failed.\n");
271 b_ret = false;
272 }
273 }
274
275 __END__;
276
277 return (b_ret);
278 }
279
280
281 /*----------------------------------------------------------------------------*/
282 /*----------------------------------------------------------------------------*/
283 /**
284 \internal
285 \class CvCaptureCAM_Giganetix
286 \brief Capturing video from camera via Smartec Giganetix (use GigEVisualSDK library).
287 */
288
289 class CvCaptureCAM_Giganetix : public CvCapture
290 {
291 public:
292 CvCaptureCAM_Giganetix();
293 virtual ~CvCaptureCAM_Giganetix();
294
295 virtual bool open( int index );
296 virtual void close();
297 virtual double getProperty(int) const;
298 virtual bool setProperty(int, double);
299 virtual bool grabFrame();
300 virtual IplImage* retrieveFrame(int);
getCaptureDomain()301 virtual int getCaptureDomain()
302 {
303 return CV_CAP_GIGANETIX;
304 }
305
306 bool start ();
307 bool stop ();
308
309 protected:
310
311 void init ();
312 void grabImage ();
313
314 gige::IGigEVisionAPI m_api;
315 bool m_api_on;
316 gige::IDevice m_device;
317 bool m_active;
318
319 IplImage* m_raw_image;
320 UINT32 m_rawImagePixelType;
321 bool m_monocrome;
322
323 };
324 /*----------------------------------------------------------------------------*/
325 /*----------------------------------------------------------------------------*/
326 void
init()327 CvCaptureCAM_Giganetix::init ()
328 {
329 m_monocrome = m_active = m_api_on = false;
330 m_api = 0;
331 m_device = 0;
332 m_raw_image = 0;
333 m_rawImagePixelType = 0;
334 }
335
336 /*----------------------------------------------------------------------------*/
CvCaptureCAM_Giganetix()337 CvCaptureCAM_Giganetix::CvCaptureCAM_Giganetix()
338 {
339 init ();
340
341 m_api_on = wrprInitGigEVisionAPI ();
342
343 if(m_api_on)
344 {
345 if((m_api = wrprGetGigEVisionAPI ()) != NULL)
346 {
347 m_api->SetHeartbeatTime (QTGIG_HEARTBEAT_TIME);
348 }
349 }
350 }
351
352 /*----------------------------------------------------------------------------*/
~CvCaptureCAM_Giganetix()353 CvCaptureCAM_Giganetix::~CvCaptureCAM_Giganetix()
354 {
355 close();
356 }
357 /*----------------------------------------------------------------------------*/
358 void
close()359 CvCaptureCAM_Giganetix::close()
360 {
361 stop ();
362
363 (void)wrprDeviceDisconnect(m_device);
364
365 (void)wrprExitGigEVisionAPI ();
366
367 if(m_raw_image) cvReleaseImageHeader(&m_raw_image);
368
369 init ();
370 }
371
372 /*----------------------------------------------------------------------------*/
373 bool
open(int index)374 CvCaptureCAM_Giganetix::open( int index )
375 {
376 bool b_ret = m_api_on;
377
378 CV_FUNCNAME("CvCaptureCAM_Giganetix::open");
379 __BEGIN__;
380
381 if(b_ret)
382 b_ret = m_api.IsValid ();
383
384 if(b_ret )
385 {
386 m_api->FindAllDevices (QTGIG_MAX_WAIT_TIME);
387
388 //TODO - serch device as DevicesList member
389 gige::DevicesList DevicesList = m_api->GetAllDevices ();
390
391 m_device = 0;
392 b_ret = false;
393
394 for (int i = 0; i < (int) DevicesList.size() && !b_ret; i++)
395 {
396 b_ret = (i == index);
397 if(b_ret)
398 {
399 m_device = DevicesList[i];
400 b_ret = m_device->Connect ();
401
402 if(b_ret)
403 {
404 b_ret =
405 m_device->SetStringNodeValue("AcquisitionStatusSelector", "AcquisitionActive")
406 &&
407 m_device->SetStringNodeValue ("TriggerMode", "Off")
408 &&
409 m_device->SetStringNodeValue ("AcquisitionMode", "Continuous")
410 &&
411 m_device->SetIntegerNodeValue ("AcquisitionFrameCount", 20)
412 ;
413 }
414 }
415 } // for
416 }
417
418 if(!b_ret)
419 {
420 CV_ERROR(CV_StsError, "Giganetix: Error cannot find camera\n");
421 close ();
422 } else {
423 start ();
424 }
425
426 __END__;
427
428 return b_ret;
429 }
430
431 /*----------------------------------------------------------------------------*/
432 void
grabImage()433 CvCaptureCAM_Giganetix::grabImage ()
434 {
435 CV_FUNCNAME("CvCaptureCAM_Giganetix::grabImage");
436 __BEGIN__;
437
438 if(wrprDeviceIsValid(m_device) && wrprDeviceIsConnect(m_device))
439 {
440 if(!m_device->IsBufferEmpty ())
441 {
442 gige::IImageInfo imageInfo;
443 m_device->GetImageInfo (&imageInfo);
444 assert(imageInfo.IsValid());
445
446 if (m_device->GetPendingImagesCount() == 1)
447 {
448 UINT32 newPixelType;
449 UINT32 newWidth, newHeight;
450
451 imageInfo->GetPixelType(newPixelType);
452 imageInfo->GetSize(newWidth, newHeight);
453
454 //TODO - validation of image exists
455 bool b_validation = m_raw_image != NULL;
456 if(b_validation)
457 {
458 b_validation =
459 m_raw_image->imageSize == (int)(imageInfo->GetRawDataSize ())
460 &&
461 m_rawImagePixelType == newPixelType;
462 } else {
463 if(m_raw_image) cvReleaseImageHeader(&m_raw_image);
464 }
465
466 m_rawImagePixelType = newPixelType;
467 m_monocrome = GvspGetBitsPerPixel((GVSP_PIXEL_TYPES)newPixelType) == IPL_DEPTH_8U;
468
469 try {
470 if (m_monocrome)
471 {
472 //TODO - For Mono & Color BayerRGB raw pixel types
473 if (!b_validation)
474 {
475 m_raw_image = cvCreateImageHeader (cvSize((int)newWidth, (int)newHeight),IPL_DEPTH_8U,1);
476 m_raw_image->origin = IPL_ORIGIN_TL;
477 m_raw_image->dataOrder = IPL_DATA_ORDER_PIXEL;
478 m_raw_image->widthStep = newWidth;
479 }
480 // Copy image.
481 // ::memcpy(m_raw_image->imageData, imageInfo->GetRawData (), imageInfo->GetRawDataSize ());
482
483 //TODO - Set pointer to image !
484 m_raw_image->imageData = (char*)(imageInfo->GetRawData ());
485 }
486
487 if (!m_monocrome && newPixelType == GVSP_PIX_RGB8_PACKED)
488 {
489 //TODO - 24 bit RGB color image.
490 if (!b_validation)
491 {
492 m_raw_image = cvCreateImageHeader (cvSize((int)newWidth, (int)newHeight), IPL_DEPTH_32F, 3);
493 m_raw_image->origin = IPL_ORIGIN_TL;
494 m_raw_image->dataOrder = IPL_DATA_ORDER_PIXEL;
495 m_raw_image->widthStep = newWidth * 3;
496 }
497 m_raw_image->imageData = (char*)(imageInfo->GetRawData ());
498 }
499 } catch (...) {
500 CV_ERROR(CV_StsError, "Giganetix: failed to queue a buffer on device\n");
501 close ();
502 }
503 } else {
504 //TODO - all other pixel types
505 m_raw_image = 0;
506 CV_WARN("Giganetix: Undefined image pixel type\n");
507 }
508 m_device->PopImage (imageInfo);
509 m_device->ClearImageBuffer ();
510 }
511 }
512
513 __END__;
514 }
515
516 /*----------------------------------------------------------------------------*/
517 bool
start()518 CvCaptureCAM_Giganetix::start ()
519 {
520 CV_FUNCNAME("CvCaptureCAM_Giganetix::start");
521 __BEGIN__;
522
523 m_active = wrprDeviceIsValid(m_device) && wrprDeviceIsConnect(m_device);
524
525 if(m_active)
526 {
527 (void)m_device->SetIntegerNodeValue("TLParamsLocked", 1);
528 (void)m_device->CommandNodeExecute("AcquisitionStart");
529 m_active = m_device->GetBooleanNodeValue("AcquisitionStatus", m_active);
530 }
531
532 if(!m_active)
533 {
534 CV_ERROR(CV_StsError, "Giganetix: Cannot open camera\n");
535 close ();
536 }
537
538 __END__;
539
540 return m_active;
541 }
542
543 /*----------------------------------------------------------------------------*/
544 bool
stop()545 CvCaptureCAM_Giganetix::stop ()
546 {
547 if (!m_active) return true;
548
549 CV_FUNCNAME("CvCaptureCAM_Giganetix::stop");
550 __BEGIN__;
551
552 if(wrprDeviceIsValid(m_device) && wrprDeviceIsConnect(m_device))
553 {
554 (void)m_device->GetBooleanNodeValue("AcquisitionStatus", m_active);
555
556 if(m_active)
557 {
558 (void)m_device->CommandNodeExecute("AcquisitionStop");
559 (void)m_device->SetIntegerNodeValue("TLParamsLocked", 0);
560 m_device->ClearImageBuffer ();
561 (void)m_device->GetBooleanNodeValue("AcquisitionStatus", m_active);
562 }
563 }
564
565 if(m_active)
566 {
567 CV_ERROR(CV_StsError, "Giganetix: Improper closure of the camera\n");
568 close ();
569 }
570 __END__;
571
572 return !m_active;
573 }
574
575 /*----------------------------------------------------------------------------*/
576 bool
grabFrame()577 CvCaptureCAM_Giganetix::grabFrame()
578 {
579 bool b_ret =
580 wrprDeviceIsValid(m_device)
581 &&
582 wrprDeviceIsConnect(m_device);
583
584 if(b_ret) grabImage ();
585
586 return b_ret;
587 }
588
589
590 /*----------------------------------------------------------------------------*/
591 IplImage*
retrieveFrame(int)592 CvCaptureCAM_Giganetix::retrieveFrame(int)
593 {
594 return (
595 wrprDeviceIsValid(m_device) && wrprDeviceIsConnect(m_device) ?
596 m_raw_image :
597 NULL
598 );
599 }
600
601 /*----------------------------------------------------------------------------*/
602 double
getProperty(int property_id) const603 CvCaptureCAM_Giganetix::getProperty( int property_id ) const
604 {
605 double d_ret = -1.0;
606 INT64 i;
607
608 if(wrprDeviceIsConnect(m_device))
609 {
610 switch ( property_id )
611 {
612 case CV_CAP_PROP_FRAME_WIDTH:
613 m_device->GetIntegerNodeValue ("Width", i);
614 d_ret = i;
615 break;
616 case CV_CAP_PROP_FRAME_HEIGHT:
617 m_device->GetIntegerNodeValue ("Height", i);
618 d_ret = i;
619 break;
620 case CV_CAP_PROP_GIGA_FRAME_OFFSET_X:
621 m_device->GetIntegerNodeValue ("OffsetX", i);
622 d_ret = i;
623 break;
624 case CV_CAP_PROP_GIGA_FRAME_OFFSET_Y:
625 m_device->GetIntegerNodeValue ("OffsetY", i);
626 d_ret = i;
627 break;
628 case CV_CAP_PROP_GIGA_FRAME_WIDTH_MAX:
629 m_device->GetIntegerNodeValue ("WidthMax", i);
630 d_ret = i;
631 break;
632 case CV_CAP_PROP_GIGA_FRAME_HEIGH_MAX:
633 m_device->GetIntegerNodeValue ("HeightMax", i);
634 d_ret = i;
635 break;
636 case CV_CAP_PROP_GIGA_FRAME_SENS_WIDTH:
637 m_device->GetIntegerNodeValue ("SensorWidth", i);
638 d_ret = i;
639 break;
640 case CV_CAP_PROP_GIGA_FRAME_SENS_HEIGH:
641 m_device->GetIntegerNodeValue ("SensorHeight", i);
642 d_ret = i;
643 break;
644 case CV_CAP_PROP_FRAME_COUNT:
645 m_device->GetIntegerNodeValue ("AcquisitionFrameCount", i);
646 d_ret = i;
647 break;
648 case CV_CAP_PROP_EXPOSURE:
649 m_device->GetFloatNodeValue ("ExposureTime",d_ret);
650 break;
651 case CV_CAP_PROP_GAIN :
652 m_device->GetFloatNodeValue ("Gain",d_ret);
653 break;
654 case CV_CAP_PROP_TRIGGER :
655 bool b;
656 m_device->GetBooleanNodeValue ("TriggerMode",b);
657 d_ret = (double)b;
658 break;
659 case CV_CAP_PROP_TRIGGER_DELAY :
660 m_device->GetFloatNodeValue ("TriggerDelay",d_ret);
661 break;
662 default : ;
663 }
664 }
665
666 return d_ret;
667 }
668
669 /*----------------------------------------------------------------------------*/
670 bool
setProperty(int property_id,double value)671 CvCaptureCAM_Giganetix::setProperty( int property_id, double value )
672 {
673 bool b_ret = wrprDeviceIsConnect(m_device);
674
675 if(b_ret)
676 {
677 bool b_val = m_active;
678
679 switch ( property_id )
680 {
681 case CV_CAP_PROP_FRAME_WIDTH:
682 stop ();
683 b_ret = m_device->SetIntegerNodeValue ("Width", (INT64)value);
684 if(b_val) start ();
685 break;
686 case CV_CAP_PROP_GIGA_FRAME_WIDTH_MAX:
687 stop ();
688 b_ret = m_device->SetIntegerNodeValue ("WidthMax", (INT64)value);
689 if(b_val) start ();
690 break;
691 case CV_CAP_PROP_GIGA_FRAME_SENS_WIDTH:
692 stop ();
693 b_ret = m_device->SetIntegerNodeValue ("SensorWidth", (INT64)value);
694 if(b_val) start ();
695 break;
696 case CV_CAP_PROP_FRAME_HEIGHT:
697 stop ();
698 b_ret = m_device->SetIntegerNodeValue ("Height", (INT64)value);
699 if(b_val) start ();
700 break;
701 case CV_CAP_PROP_GIGA_FRAME_HEIGH_MAX:
702 stop ();
703 b_ret = m_device->SetIntegerNodeValue ("HeightMax", (INT64)value);
704 if(b_val) start ();
705 break;
706 case CV_CAP_PROP_GIGA_FRAME_SENS_HEIGH:
707 stop ();
708 b_ret = m_device->SetIntegerNodeValue ("SensorHeight", (INT64)value);
709 if(b_val) start ();
710 break;
711 case CV_CAP_PROP_GIGA_FRAME_OFFSET_X: {
712 INT64 w, wmax, val = (INT64)value;
713 if((b_ret = m_device->GetIntegerNodeValue ("Width", w)))
714 if((b_ret = m_device->GetIntegerNodeValue ("WidthMax", wmax)))
715 b_ret = m_device->SetIntegerNodeValue ("OffsetX", (val + w) > wmax ? (wmax - w) : val);
716 } break;
717 case CV_CAP_PROP_GIGA_FRAME_OFFSET_Y: {
718 INT64 h, hmax, val = (INT64)value;
719 if((b_ret = m_device->GetIntegerNodeValue ("Height", h)))
720 if((b_ret = m_device->GetIntegerNodeValue ("HeightMax", hmax)))
721 b_ret = m_device->SetIntegerNodeValue ("OffsetY", (val + h) > hmax ? (hmax - h) : val);
722 b_ret = m_device->SetIntegerNodeValue ("OffsetY", (INT64)value);
723 }
724 break;
725 case CV_CAP_PROP_EXPOSURE:
726 b_ret = m_device->SetFloatNodeValue ("ExposureTime",value);
727 break;
728 case CV_CAP_PROP_GAIN :
729 b_ret = m_device->SetFloatNodeValue ("Gain",value);
730 break;
731 case CV_CAP_PROP_TRIGGER :
732 b_ret = m_device->SetBooleanNodeValue ("TriggerMode",(bool)value);
733 break;
734 case CV_CAP_PROP_TRIGGER_DELAY :
735 stop ();
736 b_ret = m_device->SetFloatNodeValue ("TriggerDelay",value);
737 if(b_val) start ();
738 break;
739 default:
740 b_ret = false;
741 }
742 }
743
744 return b_ret;
745 }
746
747
748 /*----------------------------------------------------------------------------*/
749 /*----------------------------------------------------------------------------*/
750 CvCapture*
cvCreateCameraCapture_Giganetix(int index)751 cvCreateCameraCapture_Giganetix( int index )
752 {
753 CvCaptureCAM_Giganetix* capture = new CvCaptureCAM_Giganetix;
754
755 if (!(capture->open( index )))
756 {
757 delete capture;
758 capture = NULL;
759 }
760
761 return ((CvCapture*)capture);
762 }
763
764 /*----------------------------------------------------------------------------*/
765