WebSVN – seema-scanner – Diff – /src/camera/CameraIDSImaging.cpp

 #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){
+CameraIDSImaging::CameraIDSImaging(unsigned int camNum, CameraTriggerMode triggerMode):  Camera(triggerMode), 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
+    // Set up 16bit monochrome color depth
-    is_SetColorMode(camera, IS_CM_MONO8);
+    is_SetColorMode(camera, IS_CM_MONO16);
-    int bitsPerPixel = 8;
+    int bitsPerPixel = 16;
 //    // 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);
+}
+CameraSettings CameraIDSImaging::getCameraSettings(){
-    // Print current settings
+    // Get settings:
-    std::cout << "Camera IDS Imaging" << std::endl;
+    CameraSettings settings;
-    double shutter;
+    // Get settings:
+    double shutter = settings.shutter;
     is_Exposure(camera, IS_EXPOSURE_CMD_GET_EXPOSURE, &shutter, sizeof(shutter));
-    std::cout << "Shutter: " << shutter << " ms" << std::endl;
+    settings.shutter = shutter;
-    std::cout << "Gain: " << is_SetHardwareGain(camera, IS_GET_MASTER_GAIN, IS_IGNORE_PARAMETER, IS_IGNORE_PARAMETER, IS_IGNORE_PARAMETER) << " %" << std::endl;
+    settings.gain = is_SetHardwareGain(camera, IS_GET_MASTER_GAIN, IS_IGNORE_PARAMETER, IS_IGNORE_PARAMETER, IS_IGNORE_PARAMETER);
+    return settings;
+}
+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);
+}
 void CameraIDSImaging::startCapture(){
     if(capturing){
         std::cerr << "CameraIDSImaging: already capturing!" << std::endl;
         return;
+    }
-    // Configure for hardware triggered mode
+    if(triggerMode == triggerModeHardware){
-    is_SetExternalTrigger(camera, IS_SET_TRIGGER_LO_HI);
-    // Timeout for marking a trigger event as failed
+        // Configure for hardware triggered mode
-    is_SetTimeout(camera, IS_TRIGGER_TIMEOUT, 10000);
+        is_SetExternalTrigger(camera, IS_SET_TRIGGER_LO_HI);
-    // Create the Windows event
-    #ifdef WIN32
-        hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
-        //Enable frame event, start image capture and wait for event
+        // Timeout for marking a trigger event as failed
-        is_InitEvent(camera, hEvent, IS_SET_EVENT_FRAME);
+        is_SetTimeout(camera, IS_TRIGGER_TIMEOUT, 10000);
-    #endif
+        // 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
+        // Enable the frame event
-    is_EnableEvent(camera, IS_SET_EVENT_FRAME);
+        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;
-    // Begin transmission
+    } else if(triggerMode == triggerModeSoftware) {
-    is_CaptureVideo(camera, IS_DONT_WAIT);
+        // Configure for no trigger mode as default
-    if(is_CaptureVideo(camera, IS_GET_LIVE) == TRUE)
+        is_SetExternalTrigger(camera, IS_SET_TRIGGER_SOFTWARE);
+    }
-        capturing = true;
+    // Print current settings
+    std::cout << "Camera IDS Imaging" << std::endl;
-    else
+    double shutter;
+    is_Exposure(camera, IS_EXPOSURE_CMD_GET_EXPOSURE, &shutter, sizeof(shutter));
-        std::cerr << "CameraIDSImaging Error: could not start capture!" << std::endl;
+    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;
     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 CameraIDSImaging::getFrame(){
     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);
+    if(triggerMode == triggerModeHardware){
-        }
-    #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;
+        #ifdef __LINUX__
-    frame.width = imageInfo.dwImageWidth;
+            int stat = is_WaitEvent(camera, IS_SET_EVENT_FRAME, 1000);
-    frame.height = imageInfo.dwImageHeight;
+            if(stat == IS_TIMED_OUT){
-    frame.timeStamp = imageInfo.u64TimestampDevice;
+                std::cerr << "CameraIDSImaging: Frame timeout!" << std::endl << std::flush;
-    frame.sizeBytes = imageInfo.dwImageHeight * imageInfo.dwImageWidth;
+    //            is_ForceTrigger(camera);
-    return frame;
+            }
-}
-void CameraIDSImaging::unlockFrame(){
-//    if(capturing)
+        #elif WIN32
-//        is_UnlockSeqBuf(camera, currentFrameID, currentFrameMemory);
+            DWORD dwRet = WaitForSingleObject(hEvent, 1000);
-//    std::cout << currentFrameID << std::endl;
+            if (dwRet == WAIT_TIMEOUT){
-}
-CameraFrame CameraIDSImaging::getSingleFrame(){
+                std::cerr << "CameraIDSImaging: Frame timeout!" << std::endl << std::flush;
-    CameraFrame frame;
+            }
-//    if(capturing){
+        #endif
-//        std::cerr << "CameraIDSImaging: capturing! Call stopCapture() before getSingleFrame()!" << std::endl;
+        //is_GetActiveImageMem(camera, &frameMemory, &memoryID);
-//        return frame;
+    //    is_FreezeVideo(camera, IS_WAIT);
-//    }
+    } else {
-    is_GetActiveImageMem(camera, &frameMemory, &memoryID);
+        is_GetActiveImageMem(camera, &frameMemory, &memoryID);
-    is_FreezeVideo(camera, IS_WAIT);
+        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){
+unsigned int CameraIDSImaging::getFrameWidth(){
     //    Get image buffer info (only works after capture)
     //    UEYEIMAGEINFO imageInfo;
     //    is_GetImageInfo(camera, currentFrameID, &imageInfo, sizeof(imageInfo));
-    *width = frameWidth;
+    return frameWidth;
-    *height = frameHeight;
+}
+unsigned int CameraIDSImaging::getFrameWidthHeight(){
-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;
+    return frameHeight;
+}
 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;
+}

Subversion Repositories seema-scanner

(root)/src/camera/CameraIDSImaging.cpp – Rev 1 → 18