cap_ximea.cpp

Marian Zajko, 2012-07-10 01:33 pm

Download (10.6 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 = INVALID_HANDLE_VALUE;





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 = INVALID_HANDLE_VALUE;





112
        return false;





113
}





114




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





116




117
void CvCaptureCAM_XIMEA::close()





118
{





119
        if(hmv)





120
        {





121
                xiStopAcquisition(hmv);





122
                xiCloseDevice(hmv);





123
                hmv = INVALID_HANDLE_VALUE;





124
        }





125
}





126




127
/**********************************************************************************/





128




129
bool CvCaptureCAM_XIMEA::grabFrame()





130
{





131
        int mvret = XI_OK;





132
        image.size = sizeof(XI_IMG);





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





134
        {





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





136
                return false;





137
        }





138
    return true;





139
}





140




141
/**********************************************************************************/





142




143
IplImage* CvCaptureCAM_XIMEA::retrieveFrame(int)





144
{





145
        // update cvImage after format has changed





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





147
        {





148
                cvReleaseImage(&frame);





149
                switch( image.frm)





150
                {





151
                case XI_RAW8   :





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





153
                case XI_RAW16  :





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





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





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





157
                default :





158
                        return frame;





159
                }





160
                // update global image format





161
                format = image.frm;        





162
                width = image.width;





163
                height = image.height;





164




165
                // copy pixel data





166
                switch( image.frm)





167
                {





168
                case XI_RAW8   :





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





170
                case XI_RAW16  :





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





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





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





174
                }





175
        }





176
        return frame;





177
}





178




179
/**********************************************************************************/





180




181
double CvCaptureCAM_XIMEA::getProperty( int property_id )





182
{





183
        if(hmv == NULL)





184
                return 0;





185




186
        int ival = 0;





187
        float fval = 0;





188




189
        switch( property_id )





190
        {





191
        // OCV parameters





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





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





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





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





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





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





198




199
        // XIMEA camera properties





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





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





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





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





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





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





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





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





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





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





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





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





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





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





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





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





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





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





218
        case CV_CAP_PROP_XI_TIMEOUT       : return timeout;





219




220
        }        





221
        return 0;





222
}





223




224
/**********************************************************************************/





225




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





227
{ 





228
        int ival = (int) value; 





229
        float fval = (float) value;





230
        





231
        int mvret = XI_OK;





232
        





233
        switch(property_id)





234
        {





235
        // OCV parameters





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





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





238
                break;





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





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





241
                break;





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





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





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





245
        // XIMEA camera properties





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





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





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





249
                break;





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





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





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





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





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





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





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





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





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





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





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





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





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





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





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





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





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





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





268
        case CV_CAP_PROP_XI_TIMEOUT       : timeout = ival; break;





269
        }





270




271
        if(mvret != XI_OK)





272
        {





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





274
                return false;





275
        } 





276
        else





277
                return true;         





278
                





279
}





280




281
/**********************************************************************************/





282




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





284
{





285
        char buf[512];





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





287
        OutputDebugString(buf);





288
}





289




290
/**********************************************************************************/