cap_ximea.cpp

Marian Zajko, 2012-06-15 02:59 pm

Download (10.5 kB)

 
1




2
#include "precomp.hpp"





3




4
#include "xiApi.h"





5
#include "xiExt.h"





6




7
/**********************************************************************************/





8




9
class CvCaptureCAM_XIMEA : public CvCapture





10
{





11
public:





12
    CvCaptureCAM_XIMEA() { init(); }





13
    virtual ~CvCaptureCAM_XIMEA() { close(); }





14




15
    virtual bool open( int index );





16
    virtual void close();





17
    virtual double getProperty(int);





18
    virtual bool setProperty(int, double);





19
    virtual bool grabFrame();





20
    virtual IplImage* retrieveFrame(int);





21
        virtual int getCaptureDomain() { return CV_CAP_XIAPI; } // Return the type of the capture object: CV_CAP_VFW, etc...





22




23
protected:





24
        void init();





25
        void errMsg(char* msg, int errNum);





26
    IplImage* frame;





27




28
        HANDLE    hmv;





29
        DWORD     numDevices;





30
        XI_IMG    image;





31
        int       width;





32
        int       height;





33
        int       format;





34
        int       timeout;





35
};





36




37
/**********************************************************************************/





38




39
CvCapture* cvCreateCameraCapture_XIMEA( int index )





40
{





41
     CvCaptureCAM_XIMEA* capture = new CvCaptureCAM_XIMEA;





42




43
    if( capture->open( index ))





44
        return capture;





45




46
        delete capture;





47
    return 0;





48
}





49




50
/**********************************************************************************/





51
// Enumerate connected devices





52
void CvCaptureCAM_XIMEA::init()





53
{





54
        xiGetNumberDevices( &numDevices);





55
        hmv = NULL;





56
        memset(&image, 0, sizeof(XI_IMG));





57
}





58




59




60
/**********************************************************************************/





61
// Initialize camera input





62
bool CvCaptureCAM_XIMEA::open( int wIndex )





63
{





64
        int mvret = XI_OK;





65




66
        if(numDevices == 0)





67
                return false;





68
        





69
        if((mvret = xiOpenDevice( wIndex, &hmv)) != XI_OK)





70
        {





71
                errMsg("Open XI_DEVICE failed", mvret);





72
                return false;





73
        }





74




75
        // always use auto exposure/gain





76
        mvret = xiSetParamInt( hmv, XI_PRM_AEAG, 1);





77
        if(mvret != XI_OK) goto error;





78




79
        // always use auto white ballance





80
        mvret = xiSetParamInt( hmv, XI_PRM_AUTO_WB, 1);





81
        if(mvret != XI_OK) goto error;





82




83
        mvret = xiGetParamInt( hmv, XI_PRM_WIDTH, &width);





84
        if(mvret != XI_OK) goto error;





85




86
        mvret = xiGetParamInt( hmv, XI_PRM_HEIGHT, &height);





87
        if(mvret != XI_OK) goto error;





88




89
        // default image format RGB24





90
        format = XI_MONO8;





91
        mvret = xiSetParamInt( hmv, XI_PRM_IMAGE_DATA_FORMAT, format);





92
        if(mvret != XI_OK) goto error;





93




94
        // allocate frame buffer for RGB24 image





95
        frame = cvCreateImage(cvSize( width, height), IPL_DEPTH_8U, 1); 





96




97
        //default capture timeout 10s





98
        timeout = 10000;





99




100
        mvret = xiStartAcquisition(hmv);





101
        if(mvret != XI_OK)





102
        {





103
                errMsg("StartAcquisition XI_DEVICE failed", mvret);





104
                goto error;





105
        }





106




107
        return true;





108




109
error:





110
        xiCloseDevice(hmv);





111
        hmv = NULL;





112
        return false;





113
}





114




115
/**********************************************************************************/





116




117
void CvCaptureCAM_XIMEA::close()





118
{





119
        xiStopAcquisition(hmv);





120
        xiCloseDevice(hmv);





121
        hmv = NULL;





122
}





123




124
/**********************************************************************************/





125




126
bool CvCaptureCAM_XIMEA::grabFrame()





127
{





128
        int mvret = XI_OK;





129
        image.size = sizeof(XI_IMG);





130
        if((mvret = xiGetImage( hmv, timeout, &image)) != XI_OK)





131
        {





132
                errMsg("Error during GetImage", mvret);





133
                return false;





134
        }





135
    return true;





136
}





137




138
/**********************************************************************************/





139




140
IplImage* CvCaptureCAM_XIMEA::retrieveFrame(int)





141
{





142
        // update cvImage after format has changed





143
        if( image.width == width && image.height == height && image.frm == (XI_IMG_FORMAT) format)





144
        {





145
                cvReleaseImage(&frame);





146
                switch( image.frm)





147
                {





148
                case XI_RAW8   :





149
                case XI_MONO8  : frame = cvCreateImage(cvSize( image.width, image.height), IPL_DEPTH_8U, 1); break;





150
                case XI_RAW16  :





151
                case XI_MONO16 : frame = cvCreateImage(cvSize( image.width, image.height), IPL_DEPTH_16U, 1); break; 





152
                case XI_RGB24  : frame = cvCreateImage(cvSize( image.width, image.height), IPL_DEPTH_8U, 3); break;





153
                case XI_RGB32  : frame = cvCreateImage(cvSize( image.width, image.height), IPL_DEPTH_8U, 4); break;





154
                default :





155
                        return frame;





156
                }





157
                // update global image format





158
                format = image.frm;        





159
                width = image.width;





160
                height = image.height;





161




162
                // copy pixel data





163
                switch( image.frm)





164
                {





165
                case XI_RAW8   :





166
                case XI_MONO8  : memcpy( frame->imageData, image.bp, image.width*image.height); break;





167
                case XI_RAW16  :





168
                case XI_MONO16 : memcpy( frame->imageData, image.bp, image.width*image.height*sizeof(WORD)); break;





169
                case XI_RGB24  : memcpy( frame->imageData, image.bp, image.width*image.height*3); break;





170
                case XI_RGB32  : memcpy( frame->imageData, image.bp, image.width*image.height*sizeof(DWORD)); break;





171
                }





172
        }





173
        return frame;





174
}





175




176
/**********************************************************************************/





177




178
double CvCaptureCAM_XIMEA::getProperty( int property_id )





179
{





180
        if(hmv == NULL)





181
                return 0;





182




183
        int ival = 0;





184
        float fval = 0;





185




186
        switch( property_id )





187
        {





188
        // OCV parameters





189
        case CV_CAP_PROP_POS_FRAMES   : return (double) image.nframe;





190
        case CV_CAP_PROP_FRAME_WIDTH  : xiGetParamInt( hmv, XI_PRM_WIDTH, &ival); return ival;





191
        case CV_CAP_PROP_FRAME_HEIGHT : xiGetParamInt( hmv, XI_PRM_HEIGHT, &ival); return ival;





192
        case CV_CAP_PROP_FPS          : xiGetParamFloat( hmv, XI_PRM_FRAMERATE, &fval); return fval;





193
        case CV_CAP_PROP_GAIN         : xiGetParamFloat( hmv, XI_PRM_GAIN, &fval); return fval;





194
        case CV_CAP_PROP_EXPOSURE     : xiGetParamInt( hmv, XI_PRM_EXPOSURE, &ival); return ival;





195




196
        // XIMEA camera properties





197
        case CV_CAP_PROP_XI_DOWNSAMPLING  : xiGetParamInt( hmv, XI_PRM_DOWNSAMPLING, &ival); return ival;





198
        case CV_CAP_PROP_XI_DATA_FORMAT   : xiGetParamInt( hmv, XI_PRM_IMAGE_DATA_FORMAT, &ival); return ival;





199
        case CV_CAP_PROP_XI_OFFSET_X      : xiGetParamInt( hmv, XI_PRM_OFFSET_X, &ival); return ival;





200
        case CV_CAP_PROP_XI_OFFSET_Y      : xiGetParamInt( hmv, XI_PRM_OFFSET_Y, &ival); return ival;





201
        case CV_CAP_PROP_XI_TRG_SOURCE    : xiGetParamInt( hmv, XI_PRM_TRG_SOURCE, &ival); return ival;





202
        case CV_CAP_PROP_XI_GPI_SELECTOR  : xiGetParamInt( hmv, XI_PRM_GPI_SELECTOR, &ival); return ival;





203
        case CV_CAP_PROP_XI_GPI_MODE      : xiGetParamInt( hmv, XI_PRM_GPI_MODE, &ival); return ival;





204
        case CV_CAP_PROP_XI_GPI_LEVEL     : xiGetParamInt( hmv, XI_PRM_GPI_LEVEL, &ival); return ival;





205
        case CV_CAP_PROP_XI_GPO_SELECTOR  : xiGetParamInt( hmv, XI_PRM_GPO_SELECTOR, &ival); return ival;





206
        case CV_CAP_PROP_XI_GPO_MODE      : xiGetParamInt( hmv, XI_PRM_GPO_MODE, &ival); return ival;





207
        case CV_CAP_PROP_XI_LED_SELECTOR  : xiGetParamInt( hmv, XI_PRM_LED_SELECTOR, &ival); return ival;





208
        case CV_CAP_PROP_XI_LED_MODE      : xiGetParamInt( hmv, XI_PRM_LED_MODE, &ival); return ival;





209
        case CV_CAP_PROP_XI_AUTO_WB       : xiGetParamInt( hmv, XI_PRM_AUTO_WB, &ival); return ival;





210
        case CV_CAP_PROP_XI_AEAG          : xiGetParamInt( hmv, XI_PRM_AEAG, &ival); return ival;





211
        case CV_CAP_PROP_XI_EXP_PRIORITY  : xiGetParamFloat( hmv, XI_PRM_EXP_PRIORITY, &fval); return fval;





212
        case CV_CAP_PROP_XI_AE_MAX_LIMIT  : xiGetParamInt( hmv, XI_PRM_EXP_PRIORITY, &ival); return ival;





213
        case CV_CAP_PROP_XI_AG_MAX_LIMIT  : xiGetParamFloat( hmv, XI_PRM_AG_MAX_LIMIT, &fval); return fval;





214
        case CV_CAP_PROP_XI_AEAG_LEVEL    : xiGetParamInt( hmv, XI_PRM_AEAG_LEVEL, &ival); return ival;





215
        case CV_CAP_PROP_XI_TIMEOUT       : return timeout;





216




217
        }        





218
        return 0;





219
}





220




221
/**********************************************************************************/





222




223
bool CvCaptureCAM_XIMEA::setProperty( int property_id, double value )





224
{ 





225
        int ival = (int) value; 





226
        float fval = (float) value;





227
        





228
        int mvret = XI_OK;





229
        





230
        switch(property_id)





231
        {





232
        // OCV parameters





233
    case CV_CAP_PROP_FRAME_WIDTH  : mvret = xiSetParamInt( hmv, XI_PRM_WIDTH, ival); 





234
                if(mvret == XI_OK) width = ival;





235
                break;





236
    case CV_CAP_PROP_FRAME_HEIGHT : mvret = xiSetParamInt( hmv, XI_PRM_HEIGHT, ival); 





237
                if(mvret == XI_OK) height = ival;





238
                break;





239
    case CV_CAP_PROP_FPS          : mvret = xiSetParamFloat( hmv, XI_PRM_FRAMERATE, fval); break;





240
        case CV_CAP_PROP_GAIN         : mvret = xiSetParamFloat( hmv, XI_PRM_GAIN, fval); break;





241
        case CV_CAP_PROP_EXPOSURE     : mvret = xiSetParamInt( hmv, XI_PRM_EXPOSURE, ival); break;





242
        // XIMEA camera properties





243
        case CV_CAP_PROP_XI_DOWNSAMPLING  :  mvret = xiSetParamInt( hmv, XI_PRM_DOWNSAMPLING, ival); break;





244
        case CV_CAP_PROP_XI_DATA_FORMAT   : mvret = xiSetParamInt( hmv, XI_PRM_IMAGE_DATA_FORMAT, ival); 





245
                if(mvret == XI_OK) format = ival;





246
                break;





247
        case CV_CAP_PROP_XI_OFFSET_X      : mvret = xiSetParamInt( hmv, XI_PRM_OFFSET_X, ival); break;





248
        case CV_CAP_PROP_XI_OFFSET_Y      : mvret = xiSetParamInt( hmv, XI_PRM_OFFSET_Y, ival); break;





249
        case CV_CAP_PROP_XI_TRG_SOURCE    : mvret = xiSetParamInt( hmv, XI_PRM_TRG_SOURCE, ival); break;





250
        case CV_CAP_PROP_XI_GPI_SELECTOR  : mvret = xiSetParamInt( hmv, XI_PRM_GPI_SELECTOR, ival); break;





251
        case CV_CAP_PROP_XI_TRG_SOFTWARE  : mvret = xiSetParamInt( hmv, XI_PRM_TRG_SOURCE, 1); break;                





252
        case CV_CAP_PROP_XI_GPI_MODE      : mvret = xiSetParamInt( hmv, XI_PRM_GPI_MODE, ival); break; 





253
        case CV_CAP_PROP_XI_GPI_LEVEL     : mvret = xiSetParamInt( hmv, XI_PRM_GPI_LEVEL, ival); break;





254
        case CV_CAP_PROP_XI_GPO_SELECTOR  : mvret = xiSetParamInt( hmv, XI_PRM_GPO_SELECTOR, ival); break;





255
        case CV_CAP_PROP_XI_GPO_MODE      : mvret = xiSetParamInt( hmv, XI_PRM_GPO_MODE, ival); break; 





256
        case CV_CAP_PROP_XI_LED_SELECTOR  : mvret = xiSetParamInt( hmv, XI_PRM_LED_SELECTOR, ival); break;





257
        case CV_CAP_PROP_XI_LED_MODE      : mvret = xiSetParamInt( hmv, XI_PRM_LED_MODE, ival); break; 





258
        case CV_CAP_PROP_XI_AUTO_WB       : mvret = xiSetParamInt( hmv, XI_PRM_AUTO_WB, ival); break;





259
        case CV_CAP_PROP_XI_MANUAL_WB     : mvret = xiSetParamInt( hmv, XI_PRM_LED_MODE, ival); break;





260
        case CV_CAP_PROP_XI_AEAG          : mvret = xiSetParamInt( hmv, XI_PRM_AEAG, ival); break;





261
        case CV_CAP_PROP_XI_EXP_PRIORITY  : mvret = xiSetParamFloat( hmv, XI_PRM_EXP_PRIORITY, fval); break; 





262
        case CV_CAP_PROP_XI_AE_MAX_LIMIT  : mvret = xiSetParamInt( hmv, XI_PRM_EXP_PRIORITY, ival); break;





263
        case CV_CAP_PROP_XI_AG_MAX_LIMIT  : mvret = xiSetParamFloat( hmv, XI_PRM_AG_MAX_LIMIT, fval); break;





264
        case CV_CAP_PROP_XI_AEAG_LEVEL    : mvret = xiSetParamInt( hmv, XI_PRM_AEAG_LEVEL, ival); break; 





265
        case CV_CAP_PROP_XI_TIMEOUT       : timeout = ival; break;





266
        }





267




268
        if(mvret != XI_OK)





269
        {





270
                errMsg("Set parameter error", mvret);





271
                return false;





272
        } 





273
        else





274
                return true;         





275
                





276
}





277




278
/**********************************************************************************/





279




280
void CvCaptureCAM_XIMEA::errMsg(char* msg, int errNum)





281
{





282
        char buf[512];





283
        sprintf( buf, "%s : %d\n", msg, errNum);





284
        OutputDebugString(buf);





285
}





286




287
/**********************************************************************************/