Subversion Repositories seema-scanner

#include "CameraIDSImaging.h"

#include <string.h>

// Note: library header conflicts, and should only be included in cpp files

#include <uEye.h>

std::vector<CameraInfo> CameraIDSImaging::getCameraList(){

    int err;

    int pnNumCams;

    err = is_GetNumberOfCameras(&pnNumCams);

    if(err == IS_NO_SUCCESS){

        std::cerr << "Could not get number of cameras!" << std::endl;

        std::vector<CameraInfo> ret;

        return ret;

    }

    // Allocate the required camera list size

    PUEYE_CAMERA_LIST m_pCamList;

    m_pCamList = (PUEYE_CAMERA_LIST)new char[sizeof(DWORD) + pnNumCams * sizeof(UEYE_CAMERA_INFO)];

    m_pCamList->dwCount = pnNumCams;

    // Get CameraList

    err = is_GetCameraList(m_pCamList);

    std::vector<CameraInfo> ret(pnNumCams);

    for(int i=0; i<pnNumCams; i++){

        CameraInfo info;

        info.vendor = "IDS Imaging";

        info.model = m_pCamList->uci[i].Model;

        info.busID = m_pCamList->uci[i].dwCameraID;

        ret[i] = info;

    }

    return ret;

}

CameraIDSImaging::CameraIDSImaging(unsigned int camNum) : frameWidth(0), frameHeight(0), frameMemory(NULL), memoryID(0){

    // Init Camera

    camera = (HIDS) camNum + 1;

    //open camera with null pointer, this defaults to DIB mode

    int ret = is_InitCamera(&camera, NULL);

    if(ret != IS_SUCCESS)

        std::cerr << "CameraIDSImaging: Could not open camera!" << std::endl << std::flush;

#ifndef _WIN32

    // Error reporting

    int err = is_SetErrorReport(camera, IS_ENABLE_ERR_REP);

    if (err != IS_SUCCESS)

        std::cerr << "CameraIDSImaging Error: Failed to set error reporting!";

#endif

    int image_down_scale=2;

    // Use 2x scaler to double attainable framerate

    is_SetSensorScaler(camera, IS_ENABLE_SENSOR_SCALER, image_down_scale);

    SENSORINFO sInfo;

    is_GetSensorInfo (camera, &sInfo);

    frameWidth = sInfo.nMaxWidth/image_down_scale;

    frameHeight = sInfo.nMaxHeight/image_down_scale;

//    // Set AOI to subframe

//    IS_RECT rectAOI;

//    is_AOI(camera, IS_AOI_IMAGE_GET_AOI, (void*)&rectAOI, sizeof(rectAOI));

//    // Decrease AOI a little to improve readout speed

//    rectAOI.s32Width /= 2;

//    rectAOI.s32Height /= 2;

//    rectAOI.s32Height -= 12;

//    rectAOI.s32X = rectAOI.s32Width/2;

//    rectAOI.s32Y = rectAOI.s32Height/2;

//    is_AOI(camera, IS_AOI_IMAGE_SET_AOI, (void*)&rectAOI, sizeof(rectAOI));

//    frameWidth = rectAOI.s32Width;

//    frameHeight = rectAOI.s32Height;

    // Set up 8bit monochrome color depth

    is_SetColorMode(camera, IS_CM_MONO8);

    int bitsPerPixel = 8;

//    // Memory initialization

//    is_ClearSequence(camera);

//    for(unsigned int i=0; i<1; i++){

//        frameMemory[i] = 0;

//        memoryID[i] = 0;

//        is_AllocImageMem(camera, frameWidth, frameHeight, bitsPerPixel, &frameMemory[i], &memoryID[i]);

//        is_AddToSequence(camera, frameMemory[i], memoryID[i]);

//    }

    // Set display mode - unecessary with InitCamera with NULL pointer to display

    is_SetDisplayMode(camera, IS_SET_DM_DIB);

    // Configure FIFO queue

    //is_InitImageQueue(camera, 0);

    // Single frame memory

    is_AllocImageMem(camera, frameWidth, frameHeight, bitsPerPixel, &frameMemory, &memoryID);

    is_SetImageMem(camera, frameMemory, memoryID);

    // Set max available pixel clock

    unsigned int pixelClockRange[3];

    is_PixelClock(camera, IS_PIXELCLOCK_CMD_GET_RANGE, (void*)pixelClockRange, sizeof(pixelClockRange));

    unsigned int nMax = pixelClockRange[1];

    is_PixelClock(camera, IS_PIXELCLOCK_CMD_SET,(void*)&nMax, sizeof(nMax));

    // Set low framerate to enable long exposure setting.

    // Note: framerate setting has no other effect in trigger mode.

    is_SetFrameRate(camera, 1.0, NULL);

    // Use global shutter

    //    is_SetGlobalShutter(camera, IS_SET_GLOBAL_SHUTTER_ON);

    int shutterMode = IS_DEVICE_FEATURE_CAP_SHUTTER_MODE_GLOBAL;

    is_DeviceFeature(camera, IS_DEVICE_FEATURE_CMD_SET_SHUTTER_MODE, (void*)&shutterMode, sizeof(shutterMode));

    // Enable gain boost

    is_SetGainBoost(camera, IS_SET_GAINBOOST_OFF);

    // Disable hardware gamma

    is_SetHardwareGamma(camera, IS_SET_HW_GAMMA_OFF);

    // Configure for no trigger mode as default

    is_SetExternalTrigger(camera, IS_SET_TRIGGER_SOFTWARE);

    // Choose starting settings

    CameraSettings settings;

    settings.shutter = 16.666/2;

    settings.gain = 0;

    setCameraSettings(settings);

    // Print current settings

    std::cout << "Camera IDS Imaging" << std::endl;

    double shutter;

    is_Exposure(camera, IS_EXPOSURE_CMD_GET_EXPOSURE, &shutter, sizeof(shutter));

    std::cout << "Shutter: " << shutter << " ms" << std::endl;

    std::cout << "Gain: " << is_SetHardwareGain(camera, IS_GET_MASTER_GAIN, IS_IGNORE_PARAMETER, IS_IGNORE_PARAMETER, IS_IGNORE_PARAMETER) << " %" << std::endl;

}

void CameraIDSImaging::startCapture(){

    if(capturing){

        std::cerr << "CameraIDSImaging: already capturing!" << std::endl;

        return;

    }

    // Configure for hardware triggered mode

    is_SetExternalTrigger(camera, IS_SET_TRIGGER_LO_HI);

    // Timeout for marking a trigger event as failed

    is_SetTimeout(camera, IS_TRIGGER_TIMEOUT, 10000);

    // Create the Windows event

    #ifdef WIN32

        hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);

        //Enable frame event, start image capture and wait for event

        is_InitEvent(camera, hEvent, IS_SET_EVENT_FRAME);

    #endif

    // Enable the frame event

    is_EnableEvent(camera, IS_SET_EVENT_FRAME);

    // Begin transmission

    is_CaptureVideo(camera, IS_DONT_WAIT);

    if(is_CaptureVideo(camera, IS_GET_LIVE) == TRUE)

        capturing = true;

    else

        std::cerr << "CameraIDSImaging Error: could not start capture!" << std::endl;

    capturing = true;

}

void CameraIDSImaging::stopCapture(){

    if(!capturing){

        std::cerr << "CameraIDSImaging: not capturing!" << std::endl;

        return;

    }

    // Disable the frame event

    is_DisableEvent(camera, IS_SET_EVENT_FRAME);

    // Exit Windows event

    #ifdef WIN32

        is_ExitEvent(camera, IS_SET_EVENT_FRAME);

        CloseHandle(hEvent);

    #endif

    // Configure for default software triggered mode

    is_SetExternalTrigger(camera, IS_SET_TRIGGER_SOFTWARE);

    // Stop live video

    int err = is_StopLiveVideo(camera, IS_FORCE_VIDEO_STOP);

    if(err != IS_SUCCESS)

        std::cerr << "CameraIDSImaging Error: could not stop capture!" << std::endl;

    else

        capturing = false;

}

CameraFrame CameraIDSImaging::lockFrame(){

    CameraFrame frame;

    if(!capturing){

        std::cerr << "CameraIDSImaging: capturing. Call startCapture() before lockFrame()" << std::endl;

        return frame;

    }

    #ifdef __LINUX__

        int stat = is_WaitEvent(camera, IS_SET_EVENT_FRAME, 1000);

        if(stat == IS_TIMED_OUT){

            std::cerr << "CameraIDSImaging: Frame timeout!" << std::endl << std::flush;

//            is_ForceTrigger(camera);

        }

    #elif WIN32

        DWORD dwRet = WaitForSingleObject(hEvent, 1000);

        if (dwRet == WAIT_TIMEOUT){

            std::cerr << "CameraIDSImaging: Frame timeout!" << std::endl << std::flush;

        }

    #endif

    //is_GetActiveImageMem(camera, &frameMemory, &memoryID);

//    is_FreezeVideo(camera, IS_WAIT);

    UEYEIMAGEINFO imageInfo;

    is_GetImageInfo(camera, memoryID, &imageInfo, sizeof(imageInfo));

    frame.memory = (unsigned char*)frameMemory;

    frame.width = imageInfo.dwImageWidth;

    frame.height = imageInfo.dwImageHeight;

    frame.timeStamp = imageInfo.u64TimestampDevice;

    frame.sizeBytes = imageInfo.dwImageHeight * imageInfo.dwImageWidth;

    return frame;

}

void CameraIDSImaging::unlockFrame(){

//    if(capturing)

//        is_UnlockSeqBuf(camera, currentFrameID, currentFrameMemory);

//    std::cout << currentFrameID << std::endl;

}

CameraFrame CameraIDSImaging::getSingleFrame(){

    CameraFrame frame;

//    if(capturing){

//        std::cerr << "CameraIDSImaging: capturing! Call stopCapture() before getSingleFrame()!" << std::endl;

//        return frame;

//    }

    is_GetActiveImageMem(camera, &frameMemory, &memoryID);

    is_FreezeVideo(camera, IS_WAIT);

    UEYEIMAGEINFO imageInfo;

    is_GetImageInfo(camera, memoryID, &imageInfo, sizeof(imageInfo));

    frame.memory = (unsigned char*)frameMemory;

    frame.width = imageInfo.dwImageWidth;

    frame.height = imageInfo.dwImageHeight;

    frame.timeStamp = imageInfo.u64TimestampDevice;

    frame.sizeBytes = imageInfo.dwImageHeight * imageInfo.dwImageWidth;

    return frame;

}

size_t CameraIDSImaging::getFrameSizeBytes(){

    if (!capturing) {

        std::cerr << "ERROR: Cannot get frame size before capturing." << std::endl;

        return 0;

    }

    UEYEIMAGEINFO imageInfo;

    is_GetImageInfo(camera, memoryID, &imageInfo, sizeof(imageInfo));

    return imageInfo.dwImageHeight * imageInfo.dwImageWidth;

}

void CameraIDSImaging::getFrameWidthHeight(unsigned int *width, unsigned int *height){

    //    Get image buffer info (only works after capture)

    //    UEYEIMAGEINFO imageInfo;

    //    is_GetImageInfo(camera, currentFrameID, &imageInfo, sizeof(imageInfo));

    *width = frameWidth;

    *height = frameHeight;

}

void CameraIDSImaging::setCameraSettings(CameraSettings settings){

    // Set settings:

    double shutter = settings.shutter;

    is_Exposure(camera, IS_EXPOSURE_CMD_SET_EXPOSURE, &shutter, sizeof(shutter));

    is_SetHardwareGain(camera, settings.gain, IS_IGNORE_PARAMETER, IS_IGNORE_PARAMETER, IS_IGNORE_PARAMETER);

}

CameraSettings CameraIDSImaging::getCameraSettings(){

    // Get settings:

    CameraSettings settings;

    // Get settings:

    double shutter = settings.shutter;

    is_Exposure(camera, IS_EXPOSURE_CMD_GET_EXPOSURE, &shutter, sizeof(shutter));

    settings.shutter = shutter;

    settings.gain = is_SetHardwareGain(camera, IS_GET_MASTER_GAIN, IS_IGNORE_PARAMETER, IS_IGNORE_PARAMETER, IS_IGNORE_PARAMETER);

    return settings;

}

CameraIDSImaging::~CameraIDSImaging(){

    std::cout<<"Closing camera\n"<<std::flush;

    if(capturing)

        stopCapture();

    is_FreeImageMem(camera, frameMemory, memoryID);

    // Exit and free memories

    // Note: IDS defines an OpenGLContext too, which might collide with our own class

    int err = is_ExitCamera(camera);

    if(err != IS_SUCCESS)

        std::cerr << "CameraIDSImaging: Could not exit camera!" << std::endl << std::flush;

    std::cout<<"Camera closed\n"<<std::flush;

}