avgdvc.cpp

#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <windows.h>
#include <math.h>

#include <dvcAPI.h>             
#include <dvcImage.h>   
int main(int argc, char* argv[])
{       
        HANDLE hDevice ;
        HANDLE hEvent ;
        int i ;
        int nFrames = 8 ;
        int nWidth, nHeight ;
        int nWaitMsec ;
        BOOL bRC ;
        BOOL bSaveAsRGB = FALSE ;
        BOOL bVerbose = FALSE ;
        char fname[256] = "\0" ;

        CDVCImage sumImage ;            
        CDVCImage captureImage ;        
        CDVCImage averageImage ;        
        hDevice = dvcOpenCamera(1) ;

        if(hDevice == INVALID_HANDLE_VALUE)
        {
                fprintf(stderr,"Error opening DVC Camera!\n");
                return -1 ;
        }

        for( i = 1 ; i < argc ; i++ )
        {
                if(i+1 < argc && !strcmp(argv[i],"-b")) // Set binning -b 0|1|2|3|4
                {
                        int nBin = atoi(argv[++i]) ;
                        bRC = dvcSetBinning(hDevice, nBin) ;
                        if(!bRC)
                                dvcPrintf(0,"%s: Error setting binning %d\n", argv[0],nBin);
                }
                else if(i+1 < argc && !strcmp(argv[i], "-g"))
                {
                        int nGain = atoi(argv[++i]) ;
                        bRC = dvcSetGain(hDevice, nGain) ;
                        if(!bRC)
                                dvcPrintf(0,"%s: Error setting gain %d\n", argv[0],nGain);
                }
                else if(i+1 < argc && !strcmp(argv[i], "-o"))
                {
                        int nOffset = atoi(argv[++i]) ;
                        bRC = dvcSetOffset(hDevice, nOffset) ;
                        if(!bRC)
                                dvcPrintf(0,"%s: Error setting offset %d\n", argv[0],nOffset);
                }
                else if(i+1 < argc && !strcmp(argv[i], "-e"))
                {
                        double dExposeMsec = atof(argv[++i]) ;
                        double dReturnExp =     dvcSetExposeMsec(hDevice, dExposeMsec) ;

                        if(dReturnExp != dExposeMsec)
                                dvcPrintf(0,"%s: Set expose to %g [ Not %g ]\n",
                                                                argv[0], dReturnExp, dExposeMsec);
                        
                }
                else if(i+1 < argc && !strcmp(argv[i], "-n"))
                {
                        nFrames = atoi(argv[++i]);
                        if(nFrames < 1) nFrames = 1 ;
                }
                else if(i+1 < argc && !strcmp(argv[i], "-f"))
                {
                        sprintf(fname,"%s",argv[++i]) ;
                }
                else if(!strcmp(argv[i], "-rgb"))
                        bSaveAsRGB = TRUE ;
                else if(!strcmp(argv[i], "-v"))
                        bVerbose = TRUE ;
        }


        // If no file name to save the data,  use the default..
        if(fname[0] == '\0') sprintf(fname,"dvcAvg%d.tif",nFrames);

        nWidth = dvcGetXDim(hDevice) ;
        nHeight = dvcGetYDim(hDevice) ;

        // 16 bit buffer to capture the raw data
        captureImage.Create(nWidth,nHeight,2) ;
        
        if( nFrames >= 16 )     // Create a 32 bit summation buffer
                sumImage.Create(nWidth, nHeight,  4 ) ;
        else
                sumImage.Create(nWidth, nHeight,  2 ) ;

        // 16 bit buffer to save the averaged data
        averageImage.Create(nWidth,nHeight,2) ;


        // Create an event handle to wait for captures..
        hEvent = CreateEvent(NULL,FALSE,FALSE,NULL) ;
        dvcSetReadCompleteEvent(hDevice, hEvent) ;
        // How long in milliseconds too wait before timing out ..
        nWaitMsec  = (int) dvcGetTimeToReadImage(hDevice) + 1000 ;

        bRC = dvcStartSequence(hDevice, 0) ;
        if(!bRC)
        {
                dvcPrintf(0,"%s: Error starting video capture..\n", argv[0] );
                dvcSetReadCompleteEvent(hDevice, NULL) ;
                dvcCloseCamera(hDevice);
                return -1 ;
        }

        for( i=0 ; bRC && i < nFrames; i++ )
        {
                if(bVerbose) dvcPrintf(0,"Waiting for Frame %d\n", i+1) ;
                bRC = WaitForSingleObject(hEvent, nWaitMsec) == WAIT_OBJECT_0 ;
                if(bRC){
                        if(bVerbose) dvcPrintf(0,"Read Event rec'd %d\n", i+1) ;
                        captureImage.ReadCamera(hDevice,0, 0, nWidth, nHeight) ;
                        if(bVerbose) dvcPrintf(0,"Captured %d\n", i+1) ;
                        sumImage.Add(&captureImage) ;
                        if(bVerbose) dvcPrintf(0,"Summed %d\n", i+1) ;
                }
                else dvcPrintf(0,"Waiting for read complete failed!\n");
        }

        dvcStopSequence(hDevice) ;

        if(bRC) {

                // Divided the summed data in sumImage by nFrames and
                // copy the results to the averageImage buffer
                if(bVerbose) dvcPrintf(0,"Averaging %d\n", nFrames) ;
                averageImage.DivideCopy(&sumImage, nFrames) ;

                RECT rect ;
                rect.top = 0 ;
                rect.left = 0 ;
                rect.right = nWidth ;
                rect.bottom = nHeight ;

                int nRenderBits = dvcGetNBits(hDevice) ;
                if(bSaveAsRGB) nRenderBits = 24 ;       // Save as 24-bit RGB 

                if(bVerbose) dvcPrintf(0,"Saveing data in %s ( %d bits/pixel )\n", 
                                                fname, nRenderBits ) ;

                // Write the averageImage buffer as a TIFF file name fname
                averageImage.Render(fname,
                                                        &rect,
                                                        nRenderBits,    
                                                        0) ;

                averageImage.CloseFile();
                
        }else dvcPrintf(0,"%s: Failed!\n", argv[0]) ;

        dvcSetReadCompleteEvent(hDevice, NULL) ;
        CloseHandle(hEvent) ;

        dvcCloseCamera(hDevice) ;
        return bRC ? 0 : -1 ;
}

---