added support for Ximea cameras (patch by Marian Zajko), fixed GCC warnings in MOG2 background subtractor.

CMakeLists.txt

@@ -428,6 +428,7 @@ set(WITH_EIGEN ON CACHE BOOL "Include Eigen2/Eigen3 support")
 set(WITH_CUDA ON CACHE BOOL "Include NVidia Cuda Runtime support")
 
 set(WITH_OPENNI OFF CACHE BOOL "Include OpenNI support")
+set(WITH_XIMEA OFF CACHE BOOL "Include XIMEA cameras support")
 
 # ===================================================
 # Macros that checks if module have been installed.
@@ -1025,6 +1026,17 @@ if(WITH_OPENNI)
     include(OpenCVFindOpenNI.cmake)
 endif()
 
+############################### XIMEA ################################
+set(HAVE_XIMEA FALSE)
+ 
+if(WITH_XIMEA)
+    include(OpenCVFindXimea.cmake)
+endif()
+
+if(XIMEA_FOUND)
+    set(HAVE_XIMEA TRUE)
+endif()
+
 ############################## Eigen ##############################
 
 if(WITH_EIGEN)
@@ -1632,6 +1644,7 @@ status("    OpenEXR:"   WITH_OPENEXR AND OPENEXR_FOUND     THEN YES
 status("    OpenNI:"    HAVE_OPENNI                        THEN YES             ELSE NO)
 status("    OpenNI PrimeSensor Modules:"
                         HAVE_OPENNI_PRIME_SENSOR_MODULE    THEN YES             ELSE NO)
+status("    XIMEA:"     HAVE_XIMEA  THEN YES ELSE NO)
 
 # video
 status("")

OpenCVFindXimea.cmake

@@ -0,0 +1,35 @@
+# - Find XIMEA
+# This module finds if XIMEA Software package is installed
+# and determines where the binaries and header files are.
+# This code sets the following variables:
+#  
+#  XIMEA_FOUND          - True if XIMEA API found
+#  XIMEA_PATH:          - Path to the XIMEA API folder
+#  XIMEA_LIBRARY_DIRS   - XIMEA libraries folder
+#
+# Created: 5 Aug 2011 by Marian Zajko (marian.zajko@ximea.com)
+#
+
+set(XIMEA_FOUND)
+set(XIMEA_PATH)
+set(XIMEA_LIBRARY_DIR)
+
+# Try to find the XIMEA API path in registry.
+GET_FILENAME_COMPONENT(XIMEA_PATH "[HKEY_CURRENT_USER\\Software\\XIMEA\\CamSupport\\API;Path]" ABSOLUTE)                                                
+
+if(XIMEA_PATH)
+  set(XIMEA_FOUND 1)
+  
+  # set LIB folders
+  set(XIMEA_LIBRARY_DIR "${XIMEA_PATH}\\x86")
+  
+else()
+  set(XIMEA_FOUND 0)
+endif()                                            
+
+mark_as_advanced(FORCE XIMEA_FOUND)
+mark_as_advanced(FORCE XIMEA_PATH)
+mark_as_advanced(FORCE XIMEA_LIBRARY_DIR)
+  
+   
+   

cvconfig.h.cmake

@@ -184,3 +184,5 @@
 /* VideoInput library */
 #cmakedefine HAVE_VIDEOINPUT
 
+/* XIMEA camera support */
+#cmakedefine HAVE_XIMEA

modules/highgui/include/opencv2/highgui/highgui_c.h

@@ -287,7 +287,9 @@ enum
 
     CV_CAP_OPENNI   =900,   // OpenNI (for Kinect)
 
-    CV_CAP_ANDROID  =1000   // Android
+    CV_CAP_ANDROID  =1000,  // Android
+    
+    CV_CAP_XIAPI    =1100   // XIMEA Camera API
 };
 
 /* start capturing frames from camera: index = camera_index + domain_offset (CV_CAP_*) */
@@ -372,7 +374,30 @@ enum
     
     // Properties of cameras available through GStreamer interface
     CV_CAP_GSTREAMER_QUEUE_LENGTH   = 200, // default is 1
-    CV_CAP_PROP_PVAPI_MULTICASTIP   = 300  // ip for anable multicast master mode. 0 for disable multicast
+    CV_CAP_PROP_PVAPI_MULTICASTIP   = 300, // ip for anable multicast master mode. 0 for disable multicast
+    
+    // Properties of cameras available through XIMEA SDK interface
+    CV_CAP_PROP_XI_DOWNSAMPLING  = 400,      // Change image resolution by binning or skipping.  
+    CV_CAP_PROP_XI_DATA_FORMAT   = 401,       // Output data format.
+    CV_CAP_PROP_XI_OFFSET_X      = 402,      // Horizontal offset from the origin to the area of interest (in pixels).
+    CV_CAP_PROP_XI_OFFSET_Y      = 403,      // Vertical offset from the origin to the area of interest (in pixels).
+    CV_CAP_PROP_XI_TRG_SOURCE    = 404,      // Defines source of trigger.
+    CV_CAP_PROP_XI_TRG_SOFTWARE  = 405,      // Generates an internal trigger. PRM_TRG_SOURCE must be set to TRG_SOFTWARE.
+    CV_CAP_PROP_XI_GPI_SELECTOR  = 406,      // Selects general purpose input 
+    CV_CAP_PROP_XI_GPI_MODE      = 407,      // Set general purpose input mode
+    CV_CAP_PROP_XI_GPI_LEVEL     = 408,      // Get general purpose level
+    CV_CAP_PROP_XI_GPO_SELECTOR  = 409,      // Selects general purpose output 
+    CV_CAP_PROP_XI_GPO_MODE      = 410,      // Set general purpose output mode
+    CV_CAP_PROP_XI_LED_SELECTOR  = 411,      // Selects camera signalling LED 
+    CV_CAP_PROP_XI_LED_MODE      = 412,      // Define camera signalling LED functionality
+    CV_CAP_PROP_XI_MANUAL_WB     = 413,      // Calculates White Balance(must be called during acquisition)
+    CV_CAP_PROP_XI_AUTO_WB       = 414,      // Automatic white balance
+    CV_CAP_PROP_XI_AEAG          = 415,      // Automatic exposure/gain
+    CV_CAP_PROP_XI_EXP_PRIORITY  = 416,      // Exposure priority (0.5 - exposure 50%, gain 50%).
+    CV_CAP_PROP_XI_AE_MAX_LIMIT  = 417,      // Maximum limit of exposure in AEAG procedure
+    CV_CAP_PROP_XI_AG_MAX_LIMIT  = 418,      // Maximum limit of gain in AEAG procedure
+    CV_CAP_PROP_XI_AEAG_LEVEL    = 419,       // Average intensity of output signal AEAG should achieve(in %)
+    CV_CAP_PROP_XI_TIMEOUT       = 420       // Image capture timeout in milliseconds
 };
 
 enum

modules/highgui/src/cap.cpp

@@ -132,6 +132,9 @@ CV_IMPL CvCapture * cvCreateCameraCapture (int index)
 #endif
 #ifdef HAVE_ANDROID_NATIVE_CAMERA
         CV_CAP_ANDROID,
+#endif
+#ifdef HAVE_XIMEA
+        CV_CAP_XIAPI,
 #endif
         -1
     };
@@ -268,6 +271,13 @@ CV_IMPL CvCapture * cvCreateCameraCapture (int index)
         break;
         #endif
         
+        #ifdef HAVE_XIMEA
+        case CV_CAP_XIAPI:
+            capture = cvCreateCameraCapture_Ximea (index);
+            if (capture)
+                return capture;
+        break;
+        #endif
         }
     }
 

modules/highgui/src/cap_ximea.cpp

@@ -0,0 +1,253 @@
+
+#include "precomp.hpp"
+
+#include "xiApi.h"
+#include "xiExt.h"
+
+/**********************************************************************************/
+
+class CvCaptureCAM_XIMEA : public CvCapture
+{
+public:
+    CvCaptureCAM_XIMEA() { init(); }
+    virtual ~CvCaptureCAM_XIMEA() { close(); }
+
+    virtual bool open( int index );
+    virtual void close();
+    virtual double getProperty(int);
+    virtual bool setProperty(int, double);
+    virtual bool grabFrame();
+    virtual IplImage* retrieveFrame(int);
+	virtual int getCaptureDomain() { return CV_CAP_XIAPI; } // Return the type of the capture object: CV_CAP_VFW, etc...
+
+protected:
+	void init();
+	void errMsg(char* msg, int errNum);
+    IplImage* frame;
+
+	HANDLE    hmv;
+	DWORD     numDevices;
+	XI_IMG    image;
+	int       width;
+	int       height;
+	int       format;
+	int       timeout;
+};
+
+/**********************************************************************************/
+
+CvCapture* cvCreateCameraCapture_XIMEA( int index )
+{
+     CvCaptureCAM_XIMEA* capture = new CvCaptureCAM_XIMEA;
+
+    if( capture->open( index ))
+        return capture;
+
+	delete capture;
+    return 0;
+}
+
+/**********************************************************************************/
+// Enumerate connected devices
+void CvCaptureCAM_XIMEA::init()
+{
+	xiGetNumberDevices( &numDevices);
+	hmv = NULL;
+}
+
+
+/**********************************************************************************/
+// Initialize camera input
+bool CvCaptureCAM_XIMEA::open( int wIndex )
+{
+	int mvret = XI_OK;
+
+	if(numDevices == 0)
+		return false;
+	
+	if((mvret = xiOpenDevice( wIndex, &hmv)) != XI_OK)
+  {
+		errMsg("Open XI_DEVICE failed", mvret);
+		return false;
+	}
+
+	// always use auto exposure/gain
+	xiSetParamInt( hmv, XI_PRM_AEAG, 1);
+
+	// always use auto white ballance
+	xiSetParamInt( hmv, XI_PRM_AUTO_WB, 1);
+
+	xiGetParamInt( hmv, XI_PRM_WIDTH, &width);
+	xiGetParamInt( hmv, XI_PRM_HEIGHT, &height);
+	
+	// default image format RGB24
+	xiSetParamInt( hmv, XI_PRM_IMAGE_DATA_FORMAT, XI_RGB24);
+	format = XI_RGB24;
+	// allocate frame buffer for RGB24 image
+	frame = cvCreateImage(cvSize( width, height), IPL_DEPTH_8U, 3); 
+
+	//default capture timeout 10s
+	timeout = 10000;
+
+	return true;
+}
+
+/**********************************************************************************/
+
+void CvCaptureCAM_XIMEA::close()
+{
+	xiCloseDevice(hmv);
+	hmv = NULL;
+}
+
+/**********************************************************************************/
+
+bool CvCaptureCAM_XIMEA::grabFrame()
+{
+	int mvret = XI_OK;
+	image.size = sizeof(XI_IMG);
+	if((mvret = xiGetImage( hmv, timeout, &image)) != XI_OK)
+  {
+		errMsg("Error during GetImage", mvret);
+		return false;
+	}
+    return true;
+}
+
+/**********************************************************************************/
+
+IplImage* CvCaptureCAM_XIMEA::retrieveFrame(int)
+{
+	// update cvImage after format has changed
+	if( image.width != width || image.height != height || image.frm != format)
+	{
+		cvReleaseImage(&frame);
+		switch( image.frm)
+		{
+		case XI_MONO8  : frame = cvCreateImage(cvSize( image.width, image.height), IPL_DEPTH_8U, 1); break;
+		case XI_MONO16 : frame = cvCreateImage(cvSize( image.width, image.height), IPL_DEPTH_16U, 1); break; 
+		case XI_RGB24  : frame = cvCreateImage(cvSize( image.width, image.height), IPL_DEPTH_8U, 3); break;
+		case XI_RGB32  : frame = cvCreateImage(cvSize( image.width, image.height), IPL_DEPTH_8U, 4); break;
+		}
+		// update global image format
+		format = image.frm;	
+		width = image.width;
+		height = image.height;
+	}
+
+	// copy pixel data
+	switch( image.frm)
+	{
+	case XI_MONO8  : memcpy( frame->imageData, image.bp, image.width*image.height); break;
+	case XI_MONO16 : memcpy( frame->imageData, image.bp, image.width*image.height*sizeof(WORD)); break;
+	case XI_RGB24  : memcpy( frame->imageData, image.bp, image.width*image.height*3); break;
+	case XI_RGB32  : memcpy( frame->imageData, image.bp, image.width*image.height*sizeof(DWORD)); break;
+	}
+	return frame;
+}
+
+/**********************************************************************************/
+
+double CvCaptureCAM_XIMEA::getProperty( int property_id )
+{
+	if(hmv == NULL)
+		return 0;
+
+	int ival = 0;
+	float fval = 0;
+
+	switch( property_id )
+  {
+	// OCV parameters
+  case CV_CAP_PROP_POS_FRAMES   : return (double) image.nframe;
+  case CV_CAP_PROP_FRAME_WIDTH  : xiGetParamInt( hmv, XI_PRM_WIDTH, &ival); return ival;
+  case CV_CAP_PROP_FRAME_HEIGHT : xiGetParamInt( hmv, XI_PRM_HEIGHT, &ival); return ival;
+  case CV_CAP_PROP_FPS          : xiGetParamFloat( hmv, XI_PRM_FRAMERATE, &fval); return fval;
+  case CV_CAP_PROP_GAIN         : xiGetParamFloat( hmv, XI_PRM_GAIN, &fval); return fval;
+  case CV_CAP_PROP_EXPOSURE     : xiGetParamInt( hmv, XI_PRM_EXPOSURE, &ival); return ival;
+
+	// XIMEA camera properties
+	case CV_CAP_PROP_XI_DOWNSAMPLING  : xiGetParamInt( hmv, XI_PRM_DOWNSAMPLING, &ival); return ival;
+	case CV_CAP_PROP_XI_DATA_FORMAT   : xiGetParamInt( hmv, XI_PRM_IMAGE_DATA_FORMAT, &ival); return ival;
+	case CV_CAP_PROP_XI_OFFSET_X      : xiGetParamInt( hmv, XI_PRM_OFFSET_X, &ival); return ival;
+	case CV_CAP_PROP_XI_OFFSET_Y      : xiGetParamInt( hmv, XI_PRM_OFFSET_Y, &ival); return ival;
+	case CV_CAP_PROP_XI_TRG_SOURCE    : xiGetParamInt( hmv, XI_PRM_TRG_SOURCE, &ival); return ival;
+	case CV_CAP_PROP_XI_GPI_SELECTOR  : xiGetParamInt( hmv, XI_PRM_GPI_SELECTOR, &ival); return ival;
+	case CV_CAP_PROP_XI_GPI_MODE      : xiGetParamInt( hmv, XI_PRM_GPI_MODE, &ival); return ival;
+	case CV_CAP_PROP_XI_GPI_LEVEL     : xiGetParamInt( hmv, XI_PRM_GPI_LEVEL, &ival); return ival;
+	case CV_CAP_PROP_XI_GPO_SELECTOR  : xiGetParamInt( hmv, XI_PRM_GPO_SELECTOR, &ival); return ival;
+	case CV_CAP_PROP_XI_GPO_MODE      : xiGetParamInt( hmv, XI_PRM_GPO_MODE, &ival); return ival;
+	case CV_CAP_PROP_XI_LED_SELECTOR  : xiGetParamInt( hmv, XI_PRM_LED_SELECTOR, &ival); return ival;
+	case CV_CAP_PROP_XI_LED_MODE      : xiGetParamInt( hmv, XI_PRM_LED_MODE, &ival); return ival;
+	case CV_CAP_PROP_XI_AUTO_WB       : xiGetParamInt( hmv, XI_PRM_AUTO_WB, &ival); return ival;
+	case CV_CAP_PROP_XI_AEAG          : xiGetParamInt( hmv, XI_PRM_AEAG, &ival); return ival;
+	case CV_CAP_PROP_XI_EXP_PRIORITY  : xiGetParamFloat( hmv, XI_PRM_EXP_PRIORITY, &fval); return fval;
+	case CV_CAP_PROP_XI_AE_MAX_LIMIT  : xiGetParamInt( hmv, XI_PRM_EXP_PRIORITY, &ival); return ival;
+	case CV_CAP_PROP_XI_AG_MAX_LIMIT  : xiGetParamFloat( hmv, XI_PRM_AG_MAX_LIMIT, &fval); return fval;
+	case CV_CAP_PROP_XI_AEAG_LEVEL    : xiGetParamInt( hmv, XI_PRM_AEAG_LEVEL, &ival); return ival;
+	case CV_CAP_PROP_XI_TIMEOUT       : return timeout;
+  }
+	return 0;
+}
+
+/**********************************************************************************/
+
+bool CvCaptureCAM_XIMEA::setProperty( int property_id, double value )
+{ 
+	int ival = (int) value; 
+	float fval = (float) value;
+	
+	int mvret = XI_OK;
+	
+	switch(property_id)
+	{
+	// OCV parameters
+    case CV_CAP_PROP_FRAME_WIDTH  : mvret = xiSetParamInt( hmv, XI_PRM_WIDTH, ival); break;
+    case CV_CAP_PROP_FRAME_HEIGHT : mvret = xiSetParamInt( hmv, XI_PRM_HEIGHT, ival); break;
+    case CV_CAP_PROP_FPS          : mvret = xiSetParamFloat( hmv, XI_PRM_FRAMERATE, fval); break;
+	case CV_CAP_PROP_GAIN         : mvret = xiSetParamFloat( hmv, XI_PRM_GAIN, fval); break;
+	case CV_CAP_PROP_EXPOSURE     : mvret = xiSetParamInt( hmv, XI_PRM_EXPOSURE, ival); break;
+	// XIMEA camera properties
+	case CV_CAP_PROP_XI_DOWNSAMPLING  :  mvret = xiSetParamInt( hmv, XI_PRM_DOWNSAMPLING, ival); break;
+	case CV_CAP_PROP_XI_DATA_FORMAT   : mvret = xiSetParamInt( hmv, XI_PRM_IMAGE_DATA_FORMAT, ival); break;
+	case CV_CAP_PROP_XI_OFFSET_X      : mvret = xiSetParamInt( hmv, XI_PRM_OFFSET_X, ival); break;
+	case CV_CAP_PROP_XI_OFFSET_Y      : mvret = xiSetParamInt( hmv, XI_PRM_OFFSET_Y, ival); break;
+	case CV_CAP_PROP_XI_TRG_SOURCE    : mvret = xiSetParamInt( hmv, XI_PRM_TRG_SOURCE, ival); break;
+	case CV_CAP_PROP_XI_GPI_SELECTOR  : mvret = xiSetParamInt( hmv, XI_PRM_GPI_SELECTOR, ival); break;
+	case CV_CAP_PROP_XI_TRG_SOFTWARE  : mvret = xiSetParamInt( hmv, XI_PRM_TRG_SOURCE, 1); break;		
+	case CV_CAP_PROP_XI_GPI_MODE      : mvret = xiSetParamInt( hmv, XI_PRM_GPI_MODE, ival); break; 
+	case CV_CAP_PROP_XI_GPI_LEVEL     : mvret = xiSetParamInt( hmv, XI_PRM_GPI_LEVEL, ival); break;
+	case CV_CAP_PROP_XI_GPO_SELECTOR  : mvret = xiSetParamInt( hmv, XI_PRM_GPO_SELECTOR, ival); break;
+	case CV_CAP_PROP_XI_GPO_MODE      : mvret = xiSetParamInt( hmv, XI_PRM_GPO_MODE, ival); break; 
+	case CV_CAP_PROP_XI_LED_SELECTOR  : mvret = xiSetParamInt( hmv, XI_PRM_LED_SELECTOR, ival); break;
+	case CV_CAP_PROP_XI_LED_MODE      : mvret = xiSetParamInt( hmv, XI_PRM_LED_MODE, ival); break; 
+	case CV_CAP_PROP_XI_AUTO_WB       : mvret = xiSetParamInt( hmv, XI_PRM_AUTO_WB, ival); break;
+	case CV_CAP_PROP_XI_MANUAL_WB     : mvret = xiSetParamInt( hmv, XI_PRM_LED_MODE, ival); break;
+	case CV_CAP_PROP_XI_AEAG          : mvret = xiSetParamInt( hmv, XI_PRM_AEAG, ival); break;
+	case CV_CAP_PROP_XI_EXP_PRIORITY  : mvret = xiSetParamFloat( hmv, XI_PRM_EXP_PRIORITY, fval); break; 
+	case CV_CAP_PROP_XI_AE_MAX_LIMIT  : mvret = xiSetParamInt( hmv, XI_PRM_EXP_PRIORITY, ival); break;
+	case CV_CAP_PROP_XI_AG_MAX_LIMIT  : mvret = xiSetParamFloat( hmv, XI_PRM_AG_MAX_LIMIT, fval); break;
+	case CV_CAP_PROP_XI_AEAG_LEVEL    : mvret = xiSetParamInt( hmv, XI_PRM_AEAG_LEVEL, ival); break; 
+	case CV_CAP_PROP_XI_TIMEOUT       : timeout = ival; break;
+	}
+
+	if(mvret != XI_OK)
+  {
+		errMsg("Set parameter error", mvret);
+		return false;
+	} 
+  else
+		return true; 
+		
+}
+
+/**********************************************************************************/
+
+void CvCaptureCAM_XIMEA::errMsg(char* msg, int errNum)
+{
+	char buf[512];
+	sprintf( buf, "%s : %d\n", msg, errNum);
+	OutputDebugString(buf);
+}
+
+/**********************************************************************************/

modules/highgui/src/precomp.hpp

@@ -133,6 +133,7 @@ CvVideoWriter* cvCreateVideoWriter_VFW( const char* filename, int fourcc,
 CvCapture* cvCreateCameraCapture_DShow( int index );
 CvCapture* cvCreateCameraCapture_OpenNI( int index );
 CvCapture* cvCreateCameraCapture_Android( int index );
+CvCapture* cvCreateCameraCapture_XIMEA( int index );
 
 CVAPI(int) cvHaveImageReader(const char* filename);
 CVAPI(int) cvHaveImageWriter(const char* filename);

modules/video/src/bgfg_gaussmix2.cpp

@@ -204,8 +204,7 @@ typedef struct CvGaussBGModel2
     CvGaussBGStatModel2Params params;
     CvGaussBGStatModel2Data   data;
     int                       countFrames;
-}
+} CvGaussBGModel2;
-CvGaussBGModel2;
 
 CVAPI(CvBGStatModel*) cvCreateGaussianBGModel2( IplImage* first_frame,
                                                 CvGaussBGStatModel2Params* params CV_DEFAULT(NULL) );
@@ -977,6 +976,8 @@ cvCreateGaussianBGModel2( IplImage* first_frame, CvGaussBGStatModel2Params* para
     //init parameters   
     if( parameters == NULL )
     {                        
+        memset(&params, 0, sizeof(params));
+        
         /* These constants are defined in cvaux/include/cvaux.h: */
         params.bShadowDetection = 1;
         params.bPostFiltering=0;