//=============================================================================
// Main Program
//=============================================================================
int
main( )
{
FlyCaptureContext context;
FlyCaptureImage fwImage;
FlyCaptureError error;
// Create the context.
error = flycaptureCreateContext( &context );
_HANDLE_ERROR(error, "flycaptureCreateContext()" );
configureExternalTriggerCamera(context);
//
// Start camera. This is done after setting the trigger so that
// excess images isochronously streamed from the camera don't fill up
// the internal buffers.
//
//printf( "Starting camera.\n" );
int width=400;
int height=300;
// error = flycaptureStartCustomImage(context,0, (1024-width)/2,(1024-height)/2, width,height,100,FlyCapturePixelFormat::FLYCAPTURE_MONO8 );
error = flycaptureStart(
context,
FLYCAPTURE_VIDEOMODE_ANY,
FLYCAPTURE_FRAMERATE_ANY );
_HANDLE_ERROR(error, "flycaptureStart()" );
//
// Set the grab timeout so that calls to flycaptureGrabImage2 will return
// after TIMEOUT milliseconds if the trigger hasn't fired.
//
error = flycaptureSetGrabTimeoutEx( context, TIMEOUT );
_HANDLE_ERROR(error, "flycaptureSetGrabTimeoutEx()" );
printf( "This program will quit after %d images are grabbed.\n", IMAGES );
for( int iImage = 0; iImage < IMAGES; iImage++ )
{
#ifdef SOFTWARE_TRIGGER_CAMERA
#ifdef USE_SOFT_ASYNC_TRIGGER
//
// Check that the camera actually supports the PGR SOFT_ASYNC_TRIGGER
// method of software triggering
//
error = checkSoftwareTriggerPresence( context, SOFT_ASYNC_TRIGGER );
if( error == FLYCAPTURE_OK )
{
checkTriggerReady( context );
//
// Camera is now ready to be triggered, so generate software trigger
// by writing a '0' to bit 31
//
printf( "Press the Enter key to initiate a software trigger.\n" );
getchar();
error = flycaptureSetCameraRegister(
context, SOFT_ASYNC_TRIGGER, 0x80000000 );
_HANDLE_ERROR( "flycaptureSetCameraRegister()", error );
}
else
{
printf( "SOFT_ASYNC_TRIGGER not implemented! Grab will timeout.\n" );
}
#else
//
// Check that the camera actually supports the DCAM SOFTWARE_TRIGGER
// method of software triggering
//
error = checkSoftwareTriggerPresence( context, SOFTWARE_TRIGGER );
if( error == FLYCAPTURE_OK )
{
error = checkTriggerReady( context );
//
// Camera is now ready to be triggered, so generate software trigger
// by writing a '1' to bit 0
//
printf( "Press the Enter key to initiate a software trigger.\n" );
getchar();
error = flycaptureSetCameraRegister(
context, SOFTWARE_TRIGGER, 0x80000000 );
_HANDLE_ERROR( "flycaptureSetCameraRegister()", error );
}
else
{
printf( "SOFTWARE_TRIGGER not implemented! Grab will timeout.\n" );
}
#endif
#endif
//
// Do an image grab. This call will block until the camera
// is externally triggered.
//
error = flycaptureGrabImage2( context, &fwImage );
if( error == FLYCAPTURE_TIMEOUT )
{
printf( "Grab #%d timed out after %d milliseconds.\n", iImage, TIMEOUT );
}
else if( error != FLYCAPTURE_OK )
{
_HANDLE_ERROR(error, "flycaptureGrabImage2()" );
}
else
{
if(iImage%60==0)printf( "Grab %d !\n", iImage );
}
}
//
// Stop the camera and destroy the context.
//
flycaptureStop( context );
flycaptureDestroyContext( context );
printf( "Done! (hit enter)" );
getchar();
return 0;
}
void configureExternalTriggerCamera(FlyCaptureContext context){
FlyCaptureError error;
FlyCaptureImage image;
//printf( "Initializing camera.\n" );
//
// Initialize the first camera on the bus.
//
error = flycaptureInitialize( context, 0 );
_HANDLE_ERROR(error, "flycaptureInitialize()" );
/* //
// Reset the camera to default factory settings by asserting bit 0
//
error = flycaptureSetCameraRegister( context, INITIALIZE, 0x80000000 );
_HANDLE_ERROR(error, "flycaptureSetCameraRegister()" );*/
//
// Power-up the camera (for cameras that support this feature)
//
error = flycaptureSetCameraRegister( context, CAMERA_POWER, 0x80000000 );
_HANDLE_ERROR(error, "flycaptureSetCameraRegister()" );
//
// Determine whether or not the camera supports external trigger mode.
// If it does, put the camera into external trigger mode and otherwise
// exit.
//
bool bTriggerPresent;
error = flycaptureQueryTrigger(
context, &bTriggerPresent, NULL, NULL, NULL, NULL, NULL, NULL, NULL );
_HANDLE_ERROR(error, "flycaptureQueryTrigger()" );
if( !bTriggerPresent)
{
printf("This camera does not support external trigger... exiting\n");
}
int iPolarity;
int iSource;
int iRawValue;
int iMode;
error = flycaptureGetTrigger(
context, NULL, &iPolarity, &iSource, &iRawValue, &iMode, NULL );
_HANDLE_ERROR(error, "flycaptureGetTrigger()" );
//printf( "Going into asynchronous Trigger_Mode_0.\n" );
//
// Ensure the camera is in Trigger Mode 0 by explicitly setting it,
// as the camera could have a different default trigger mode
//
#ifdef SOFTWARE_TRIGGER_CAMERA
//
// We are triggering the camera using the internal software trigger.
// If we are using the DCAM SOFTWARE_TRIGGER functionality, we must
// change the Trigger_Source to reflect the Software Trigger ID = 7.
//
error = flycaptureSetTrigger(
context, true, iPolarity, 7, 0, 0 );
_HANDLE_ERROR( "flycaptureSetCameraTrigger()", error );
#else
//
// We are triggering the camera using an external hardware trigger.
//
error = flycaptureSetTrigger(
context, true, iPolarity, iSource, 0, 0 );
_HANDLE_ERROR(error, "flycaptureSetCameraTrigger()" );
#endif
//
// Poll the camera to make sure the camera is actually in trigger mode
// before we start it (avoids timeouts due to the trigger not being armed)
//
checkTriggerReady( context );
//
// Start the camera and grab any excess images that are already in the pipe.
// Although it is extremely rare for spurious images to occur, it is
// possible for the grab call to return an image that is not a result of a
// user-generated trigger. To grab excess images, set a zero-length timeout.
// A value of zero makes the grab call non-blocking.
//
//printf( "Checking for any buffered images..." );
error = flycaptureSetGrabTimeoutEx( context, 0 );
_HANDLE_ERROR(error, "flycaptureSetGrabTimeoutEx()" );
error = flycaptureStart(
context, FLYCAPTURE_VIDEOMODE_ANY, FLYCAPTURE_FRAMERATE_ANY );
_HANDLE_ERROR(error, "flycaptureStart()" );
//
// Grab the image immediately whether or not trigger present
//
error = flycaptureGrabImage2( context, &image );
if( error == FLYCAPTURE_OK )
{
;//printf( "buffered image found. Flush successful.\n" );
}
else if( error == FLYCAPTURE_TIMEOUT )
{
;//printf( "no flush required! (normal behaviour)\n" );
}
else
{
_HANDLE_ERROR(error, "flycaptureGrabImage2()" );
}
error = flycaptureStop( context );
_HANDLE_ERROR(error, "flycaptureStop()" );
}
//=============================================================================
// Main Program
//=============================================================================
int
main( int /* argc */, char* /* argv[] */ )
{
FlyCaptureError error;
FlyCaptureContext context;
FlyCaptureImage image;
printf( "Initializing camera.\n" );
//
// Create the context.
//
error = flycaptureCreateContext( &context );
HANDLE_ERROR( "flycaptureCreateContext()", error );
//
// Initialize the first camera on the bus.
//
error = flycaptureInitialize( context, 0 );
HANDLE_ERROR( "flycaptureInitialize()", error );
//
// Reset the camera to default factory settings by asserting bit 0
//
error = flycaptureSetCameraRegister( context, INITIALIZE, 0x80000000 );
HANDLE_ERROR( "flycaptureSetCameraRegister()", error );
//
// Power-up the camera (for cameras that support this feature)
//
error = flycaptureSetCameraRegister( context, CAMERA_POWER, 0x80000000 );
HANDLE_ERROR( "flycaptureSetCameraRegister()", error );
//
// Determine whether or not the camera supports external trigger mode.
// If it does, put the camera into external trigger mode and otherwise
// exit.
//
bool bTriggerPresent;
error = flycaptureQueryTrigger(
context, &bTriggerPresent, NULL, NULL, NULL, NULL, NULL, NULL, NULL );
HANDLE_ERROR( "flycaptureQueryTrigger()", error );
if( !bTriggerPresent)
{
printf("This camera does not support external trigger... exiting\n");
return 1;
}
int iPolarity;
int iSource;
int iRawValue;
int iMode;
error = flycaptureGetTrigger(
context, NULL, &iPolarity, &iSource, &iRawValue, &iMode, NULL );
HANDLE_ERROR( "flycaptureGetTrigger()", error );
printf( "Going into asynchronous Trigger_Mode_0.\n" );
//
// Ensure the camera is in Trigger Mode 0 by explicitly setting it,
// as the camera could have a different default trigger mode
//
#ifdef SOFTWARE_TRIGGER_CAMERA
//
// We are triggering the camera using the internal software trigger.
// If we are using the DCAM SOFTWARE_TRIGGER functionality, we must
// change the Trigger_Source to reflect the Software Trigger ID = 7.
//
error = flycaptureSetTrigger(
context, true, iPolarity, 7, 0, 0 );
HANDLE_ERROR( "flycaptureSetCameraTrigger()", error );
#else
//
// We are triggering the camera using an external hardware trigger.
//
error = flycaptureSetTrigger(
context, true, iPolarity, iSource, 0, 0 );
HANDLE_ERROR( "flycaptureSetCameraTrigger()", error );
#endif
//
// Poll the camera to make sure the camera is actually in trigger mode
// before we start it (avoids timeouts due to the trigger not being armed)
//
checkTriggerReady( context );
//
// Start the camera and grab any excess images that are already in the pipe.
// Although it is extremely rare for spurious images to occur, it is
// possible for the grab call to return an image that is not a result of a
// user-generated trigger. To grab excess images, set a zero-length timeout.
// A value of zero makes the grab call non-blocking.
//
printf( "Checking for any buffered images..." );
error = flycaptureSetGrabTimeoutEx( context, 0 );
HANDLE_ERROR( "flycaptureSetGrabTimeoutEx()", error );
error = flycaptureStart(
context, FLYCAPTURE_VIDEOMODE_ANY, FLYCAPTURE_FRAMERATE_ANY );
HANDLE_ERROR( "flycaptureStart()", error );
//
// Grab the image immediately whether or not trigger present
//
error = flycaptureGrabImage2( context, &image );
if( error == FLYCAPTURE_OK )
{
printf( "buffered image found. Flush successful.\n" );
}
else if( error == FLYCAPTURE_TIMEOUT )
{
printf( "no flush required! (normal behaviour)\n" );
}
else
{
HANDLE_ERROR( "flycaptureGrabImage2()", error );
}
error = flycaptureStop( context );
HANDLE_ERROR( "flycaptureStop()", error );
//
// Start camera. This is done after setting the trigger so that
// excess images isochronously streamed from the camera don't fill up
// the internal buffers.
//
printf( "Starting camera.\n" );
error = flycaptureStart(
context,
FLYCAPTURE_VIDEOMODE_ANY,
FLYCAPTURE_FRAMERATE_ANY );
HANDLE_ERROR( "flycaptureStart()", error );
//
// Set the grab timeout so that calls to flycaptureGrabImage2 will return
// after TIMEOUT milliseconds if the trigger hasn't fired.
//
error = flycaptureSetGrabTimeoutEx( context, TIMEOUT );
HANDLE_ERROR( "flycaptureSetGrabTimeoutEx()", error );
printf( "This program will quit after %d images are grabbed.\n", IMAGES );
#ifndef SOFTWARE_TRIGGER_CAMERA
printf( "Trigger the camera by sending a trigger pulse to GPIO%d.\n",
iSource );
#endif
for( int iImage = 0; iImage < IMAGES; iImage++ )
{
#ifdef SOFTWARE_TRIGGER_CAMERA
#ifdef USE_SOFT_ASYNC_TRIGGER
//
// Check that the camera actually supports the PGR SOFT_ASYNC_TRIGGER
// method of software triggering
//
error = checkSoftwareTriggerPresence( context, SOFT_ASYNC_TRIGGER );
if( error == FLYCAPTURE_OK )
{
checkTriggerReady( context );
//
// Camera is now ready to be triggered, so generate software trigger
// by writing a '0' to bit 31
//
printf( "Press the Enter key to initiate a software trigger.\n" );
getchar();
error = flycaptureSetCameraRegister(
context, SOFT_ASYNC_TRIGGER, 0x80000000 );
HANDLE_ERROR( "flycaptureSetCameraRegister()", error );
}
else
{
printf( "SOFT_ASYNC_TRIGGER not implemented! Grab will timeout.\n" );
}
#else
//
// Check that the camera actually supports the DCAM SOFTWARE_TRIGGER
// method of software triggering
//
error = checkSoftwareTriggerPresence( context, SOFTWARE_TRIGGER );
if( error == FLYCAPTURE_OK )
{
error = checkTriggerReady( context );
//
// Camera is now ready to be triggered, so generate software trigger
// by writing a '1' to bit 0
//
printf( "Press the Enter key to initiate a software trigger.\n" );
getchar();
error = flycaptureSetCameraRegister(
context, SOFTWARE_TRIGGER, 0x80000000 );
HANDLE_ERROR( "flycaptureSetCameraRegister()", error );
}
else
{
printf( "SOFTWARE_TRIGGER not implemented! Grab will timeout.\n" );
}
#endif
#endif
//
// Do an image grab. This call will block until the camera
// is externally triggered.
//
error = flycaptureGrabImage2( context, &image );
if( error == FLYCAPTURE_TIMEOUT )
{
printf( "Grab #%d timed out after %d milliseconds.\n", iImage, TIMEOUT );
}
else if( error != FLYCAPTURE_OK )
{
HANDLE_ERROR( "flycaptureGrabImage2()", error );
}
else
{
printf( "Grab %d successful!\n", iImage );
}
}
//
// Stop the camera and destroy the context.
//
flycaptureStop( context );
flycaptureDestroyContext( context );
printf( "Done! (hit enter)" );
getchar();
return 0;
}
int
main( int argc, char* argv[] )
{
FlyCaptureError error;
FlyCaptureContext context;
// check the arguments of the call to make sure the utility is being called properly.
if (argc != 2){
PrintUsage();
printf( "Done! (hit enter)" );
getchar();
return 0;
} else {
if (!((strcmp(argv[1], "-retrieve") == 0) || (strcmp(argv[1], "-capture") == 0)))
{
PrintUsage();
printf( "Done! (hit enter)" );
getchar();
return 0;
}
}
//
// Enumerate the cameras on the bus.
//
FlyCaptureInfoEx arInfo[ _MAX_CAMS ];
unsigned int uiSize = _MAX_CAMS;
error = flycaptureBusEnumerateCamerasEx( arInfo, &uiSize );
_HANDLE_ERROR( error, "flycaptureBusEnumerateCameras()" );
for( unsigned int uiBusIndex = 0; uiBusIndex < uiSize; uiBusIndex++ )
{
FlyCaptureInfoEx* pinfo = &arInfo[ uiBusIndex ];
printf(
"Index %u: %s (%u)\n",
uiBusIndex,
pinfo->pszModelName,
pinfo->SerialNumber );
}
//
// Create the context.
//
error = flycaptureCreateContext( &context );
_HANDLE_ERROR( error, "flycaptureCreateContext()" );
//
// Initialize the camera.
//
printf( "Initializing camera %u.\n", _CAMERA_INDEX );
error = flycaptureInitialize( context, _CAMERA_INDEX );
_HANDLE_ERROR( error, "flycaptureInitialize()" );
//
// Reset the camera to default factory settings by asserting bit 0
//
error = flycaptureSetCameraRegister( context, INITIALIZE, 0x80000000 );
_HANDLE_ERROR( error, "flycaptureSetCameraRegister()" );
//
// Power-up the camera (for cameras that support this feature)
//
error = flycaptureSetCameraRegister( context, CAMERA_POWER, 0x80000000 );
_HANDLE_ERROR( error, "flycaptureSetCameraRegister()" );
//
// Report camera info.
//
FlyCaptureInfoEx info;
error = flycaptureGetCameraInfo( context, &info );
_HANDLE_ERROR( error, "flycaptureGetCameraInfo()" );
printf( "Camera info:\n" );
reportCameraInfo( &info );
//
// Query and report on the camera's ability to handle custom image modes.
// We use the maximum and unit values to determine the size of the image
// which can be saved to flash.
//
bool bAvailable;
unsigned int uiMaxImageSizeCols;
unsigned int uiMaxImageSizeRows;
unsigned int uiImageUnitSizeHorz;
unsigned int uiImageUnitSizeVert;
unsigned int uiOffsetUnitSizeHorz;
unsigned int uiOffsetUnitSizeVert;
unsigned int uiPixelFormats;
error = ::flycaptureQueryCustomImageEx(
context,
MODE,
&bAvailable,
&uiMaxImageSizeCols,
&uiMaxImageSizeRows,
&uiImageUnitSizeHorz,
&uiImageUnitSizeVert,
&uiOffsetUnitSizeHorz,
&uiOffsetUnitSizeVert,
&uiPixelFormats );
_HANDLE_ERROR( error, "flycaptureQueryCustomImageEx()" );
//
// Check to see if Flash Reading/Writing is supported by the camera
//
unsigned long ulRegVal;
error = flycaptureGetCameraRegister(context, DATA_FLASH_CTRL, &ulRegVal);
printf( "Data control register = %x\n", ulRegVal );
if((0x80000000 & ulRegVal) == 0)
{
printf("This camera does not support the user data area feature. Exiting...\n");
//
// Destroy the context
//
flycaptureDestroyContext(context);
printf( "Done! (hit enter)" );
getchar();
return 0;
}
// Determine the available size of the Flash from the DATA_FLASH_CTRL register
int iPageSize = (int)pow(2.0, (int)(ulRegVal & 0x00FFF000) >> 12);
int iNumPages = (int)pow(2.0, (int)(ulRegVal & 0x00000FFF));
unsigned int uiAvailableFlashSize = iPageSize * iNumPages;
unsigned int uiHeight = uiMaxImageSizeCols;
unsigned int uiWidth = uiMaxImageSizeRows;
// If the Flash is not large enough to hold a full, high-res image, determine the
// maximum image with a 4:3 aspect ration which can fit in the flash and use those
// dimensions.
if (uiMaxImageSizeCols*uiMaxImageSizeRows > uiAvailableFlashSize)
{
uiHeight = (int)sqrt(uiAvailableFlashSize*3.0/4);
uiWidth = uiHeight*4/3;
uiHeight -= (uiHeight % uiImageUnitSizeVert);
uiWidth -= (uiWidth % uiImageUnitSizeHorz);
}
//
// Determine the quadlet offset of the Flash area
//
unsigned long ulLUTLoc;
error = flycaptureGetCameraRegister(context, DATA_FLASH_DATA, &ulLUTLoc);
_HANDLE_ERROR( error, "flycaptureGetCameraRegister()" );
//
// Start grabbing images in the current videomode and framerate.
//
printf( "Starting camera.\n\n" );
error = flycaptureStartCustomImage(context, 0, 0, 0, uiWidth, uiHeight, 40, FLYCAPTURE_MONO8);
_HANDLE_ERROR( error, "flycaptureStart()" );
FlyCaptureImage image;
memset( &image, 0x0, sizeof( FlyCaptureImage ) );
// Here, we grab 10 images and only look at the last one, since after starting the camera,
// it takes a few images for the the auto settings to stabilize (ie. exposure, gain, etc)
for ( int iImage = 0; iImage < _IMAGES_TO_GRAB; iImage++ )
{
error = flycaptureGrabImage2( context, &image );
_HANDLE_ERROR( error, "flycaptureGrabImage2()" );
}
// Check to see if we are capturing or retrieving
if (strcmp(argv[1], "-capture") == 0)
{
printf( "Saving raw image to camera FLASH.\n\n" );
//
// Write the image to the cameras flash
//
error = flycaptureWriteRegisterBlock(
context,
0xFFFF,
0xF0000000+ulLUTLoc*4,
(const unsigned long*)&(image.pData[0]),
(image.iRowInc*image.iRows/4));
_HANDLE_ERROR( error, "flycaptureWriteRegisterBlock()" );
} else if (strcmp(argv[1], "-retrieve") == 0){ // if we are not capturing (we are retrieving).
printf( "Grabbing image from FLASH and saving it to disk as %s.\n\n", FILENAME_RAW_FROM_FLASH );
// Create a flycapture image to save
FlyCaptureImage savedImage;
memset( &savedImage, 0x0, sizeof( FlyCaptureImage ) );
// Fill in the savedImage structure
savedImage.iCols = image.iCols;
savedImage.iRows = image.iRows;
savedImage.iRowInc = image.iRowInc;
savedImage.videoMode = image.videoMode;
savedImage.timeStamp = image.timeStamp;
savedImage.bStippled = image.bStippled;
savedImage.pixelFormat = image.pixelFormat;
savedImage.iNumImages = image.iNumImages;
savedImage.pData = (unsigned char*)malloc(savedImage.iRowInc*savedImage.iRows);
// Read data from the flash into the SavedImage structure
error = flycaptureReadRegisterBlock(
context,
0xFFFF,
0xF0000000+ulLUTLoc*4,
(unsigned long*)&(savedImage.pData[0]),
(savedImage.iRowInc*savedImage.iRows/4));
_HANDLE_ERROR( error, "flycaptureReadRegisterBlock()" );
// Save the image to disk
error = flycaptureSaveImage(
context,
&savedImage,
FILENAME_RAW_FROM_FLASH,
FLYCAPTURE_FILEFORMAT_PGM );
_HANDLE_ERROR( error, "flycaptureSaveImage()" );
free(savedImage.pData);
} else {
// We should never get here since the check at the top should catch this,
// but this is here for completeness.
PrintUsage();
}
//
// Stop the camera
//
error = flycaptureStop( context );
_HANDLE_ERROR( error, "flycaptureStop()" );
//
// Destroy the context.
//
error = flycaptureDestroyContext( context );
_HANDLE_ERROR( error, "flycaptureDestroyContext()" );
printf( "Done! (hit enter)" );
getchar();
return 0;
}
//=============================================================================
// Main Function
//=============================================================================
int
main( int /* argc */, char* /* argv[] */ )
{
FlyCaptureError error;
FlyCaptureContext context;
bool bOn;
unsigned int uiCurTime = 0;
unsigned int uiLastTime = 0;
unsigned int uiTotalTime = 0;
unsigned int uiSeconds = 0;
unsigned int uiCount = 0;
unsigned int uiOffset = 0;
double dGrabTime = 0.0;
//
// Create context
//
error = ::flycaptureCreateContext( &context );
CHECK_ERROR( "flycaptureCreateContext()", error );
//
// Initialize first camera on the bus.
//
error = ::flycaptureInitialize( context, 0 );
CHECK_ERROR( "flycaptureInitialize()", error );
//
// Reset the camera to default factory settings by asserting bit 0
//
error = flycaptureSetCameraRegister( context, INITIALIZE, 0x80000000 );
CHECK_ERROR( "flycaptureSetCameraRegister()", error );
//
// Power-up the camera (for cameras that support this feature)
//
error = flycaptureSetCameraRegister( context, CAMERA_POWER, 0x80000000 );
CHECK_ERROR( "flycaptureSetCameraRegister()", error );
//
// Enable image timestamping
//
error = ::flycaptureGetImageTimestamping( context, &bOn );
CHECK_ERROR( "flycaptureGetImageTimestamping()", error );
if( !bOn )
{
error = ::flycaptureSetImageTimestamping( context, true );
CHECK_ERROR( "flycaptureSetImageTimestamping()", error );
}
//
// Query and report on the camera's ability to handle custom image modes.
//
bool bAvailable;
unsigned int uiMaxImageSizeCols;
unsigned int uiMaxImageSizeRows;
unsigned int uiImageUnitSizeHorz;
unsigned int uiImageUnitSizeVert;
unsigned int uiOffsetUnitSizeHorz;
unsigned int uiOffsetUnitSizeVert;
unsigned int uiPixelFormats;
error = ::flycaptureQueryCustomImageEx(
context,
MODE,
&bAvailable,
&uiMaxImageSizeCols,
&uiMaxImageSizeRows,
&uiImageUnitSizeHorz,
&uiImageUnitSizeVert,
&uiOffsetUnitSizeHorz,
&uiOffsetUnitSizeVert,
&uiPixelFormats );
CHECK_ERROR( "flycaptureQueryCustomImage()", error );
if( !bAvailable )
{
printf(
"Warning! Camera reports that mode %u is not available.\n",
MODE );
}
printf(
"Max image pizels: (%u, %u)\n"
"Image Unit size: (%u, %u)\n"
"Offset Unit size: (%u, %u)\n"
"Pixel format bitfield: 0x%08x\n",
uiMaxImageSizeCols,
uiMaxImageSizeRows,
uiImageUnitSizeHorz,
uiImageUnitSizeVert,
uiOffsetUnitSizeHorz,
uiOffsetUnitSizeVert,
uiPixelFormats );
if( ( PIXEL_FORMAT & uiPixelFormats ) == 0 )
{
printf(
"Warning! "
"Camera reports that the requested pixel format is not supported!.\n",
MODE );
}
//
// Start camera using custom image size mode.
//
error = ::flycaptureStartCustomImage(
context,
MODE,
START_COL,
START_ROW,
COLS,
ROWS,
SPEED,
PIXEL_FORMAT );
CHECK_ERROR( "flycaptureStartCustomImage()", error );
//
// Grab a series of images, computing the time difference
// between consecutive images.
//
FlyCaptureImage image = { 0 };
for( int iImage = 0; iImage < IMAGES_TO_GRAB; iImage++ )
{
//
// Grab an image
//
error = ::flycaptureGrabImage2( context, &image );
CHECK_ERROR( "flycaptureGrabImage2()", error );
//
// Calculate the time difference between current and last image
// in order to calculate actual frame rate
//
error = ::flycaptureParseImageTimestamp( context,
image.pData,
&uiSeconds,
&uiCount,
&uiOffset );
CHECK_ERROR( "flycaptureParseImageTimestamp()", error );
uiCurTime = (uiSeconds * 8000) + uiCount;
if( iImage == 0 )
{
uiLastTime = uiCurTime;
uiTotalTime = 0;
}
else
{
uiTotalTime = uiTotalTime + (uiCurTime - uiLastTime);
uiLastTime = uiCurTime;
}
//
// Print info.
//
printf(
"Image %03d: %d x %d %d %d %d %d\n",
iImage,
image.iCols,
image.iRows,
image.timeStamp.ulSeconds,
image.timeStamp.ulMicroSeconds,
image.timeStamp.ulCycleSeconds,
image.timeStamp.ulCycleCount );
}
//
// Convert to a frames per second number
//
dGrabTime = (double)(1 / ( ((double)uiTotalTime / (double)8000)
/ IMAGES_TO_GRAB ));
printf("Frame rate: %lfHz\n", dGrabTime );
//
// Save the last image to disk
//
printf( "Saving last image..." );
saveFinalImage(context, &image);
printf( "done\n" );
//
// stop the camera and destroy the context.
//
::flycaptureStop( context );
::flycaptureDestroyContext( context );
return 0;
}
