//=============================================================================
// Functions
//=============================================================================
//
// saveFinalImage()
// This function is responsible for saving the last image to disk. If the
// image is an unprocessed color image, this command processes it before
// saving it to disk. Otherwise, it simply stores it to disk.
//
FlyCaptureError
saveFinalImage(FlyCaptureContext context, FlyCaptureImage *pImage)
{
FlyCaptureError error = FLYCAPTURE_OK;
if(pImage->bStippled)
{
FlyCaptureImage colorImage;
colorImage.pData = new unsigned char[pImage->iRows*pImage->iCols*3];
colorImage.pixelFormat = FLYCAPTURE_BGR;
error = flycaptureConvertImage(context,
pImage,
&colorImage);
if(error != FLYCAPTURE_OK)
{
delete [] colorImage.pData;
return error;
}
error = flycaptureSaveImage(
context,
&colorImage,
"format7image.ppm",
FLYCAPTURE_FILEFORMAT_PPM);
CHECK_ERROR( "flycaptureSaveImage", error );
delete [] colorImage.pData;
if(error != FLYCAPTURE_OK)
{
return error;
}
}
else
{
error = flycaptureSaveImage(
context,
pImage,
"format7image.pgm",
FLYCAPTURE_FILEFORMAT_PGM );
if(error != FLYCAPTURE_OK)
{
return error;
}
}
return error;
}
// capture image
bool IEEE1394Cam::CaptureImages(unsigned char* buffer) {
if (!_activated){return false;}
#ifdef WIN32
FlyCaptureError fe;
FlyCaptureImage flycaptureImage;
// Grab an image from the camera
fe = flycaptureGrabImage2( _flycapture, &flycaptureImage );
if (fe != FLYCAPTURE_OK) {
return false;
}
if (flycaptureImage.pixelFormat != FLYCAPTURE_RAW16 && flycaptureImage.pixelFormat != FLYCAPTURE_RAW8) {
// RGB mode
if (_ptype == PIXEL_BGR) {
flycaptureInplaceRGB24toBGR24(flycaptureImage.pData, flycaptureImage.iRows*flycaptureImage.iCols*flycaptureImage.iNumImages);
}
memcpy(buffer, flycaptureImage.pData, flycaptureImage.iRowInc*flycaptureImage.iRows*flycaptureImage.iNumImages);
} else {
// convert pixel format raw8/16 to BGR
FlyCaptureImage destimg;
destimg.pData = buffer;
destimg.pixelFormat = FLYCAPTURE_BGR;
flycaptureConvertImage( _flycapture, &flycaptureImage, &destimg);
if (_ptype == PIXEL_RGB){
// BGR->RGB
unsigned char* src = buffer;
unsigned char tmp;
for(int i=0; i<destimg.iRows; ++i){
for(int j=0; j<destimg.iCols; ++j){
tmp = src[0];
src[0] = src[2];
src[2] = tmp;
src+=3;
}
}
}
}
return true;
#else
return false;
#endif //WIN32
}
int
main( int /* argc */, char** /* argv */ )
{
FlyCaptureError error;
FlyCaptureContext context;
FlyCaptureImage image;
unsigned long ulValue;
bool bPresent;
bool bOnOff;
bool bOnePush;
bool bAuto;
int iValueA;
int iValueB;
long lValueA;
long lValueB;
error = ::flycaptureCreateContext( &context );
HANDLE_ERROR( "flycaptureCreateContext()", error );
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 );
//
// Check if the camera implements the FRAME_RATE register
//
printf( "Checking for extended shutter via FRAME_RATE register 83Ch... " );
error = ::flycaptureGetCameraPropertyRangeEx(
context,
FLYCAPTURE_FRAME_RATE,
&bPresent,
NULL,
NULL,
&bOnOff,
NULL,
NULL,
NULL,
NULL );
HANDLE_ERROR( "flycaptureGetCameraPropertyRangeEx()", error );
if( bPresent )
{
//
// Camera implements the FRAME_RATE register so turn it off
printf( "supported.\nTurning off frame rate to enable extended shutter.\n" );
error = ::flycaptureGetCameraPropertyEx(
context,
FLYCAPTURE_FRAME_RATE,
&bOnePush,
&bOnOff,
&bAuto,
&iValueA,
&iValueB );
HANDLE_ERROR( "flycaptureGetCameraPropertyEx()", error );
//
// Turn frame rate off
//
error = ::flycaptureSetCameraPropertyEx(
context,
FLYCAPTURE_FRAME_RATE,
bOnePush,
false,
bAuto,
iValueA,
iValueB );
HANDLE_ERROR( "flycaptureSetCameraPropertyEx()", error );
}
//
// Camera doesn't use FRAME_RATE - check if it implements
// the EXTENDED_SHUTTER register
//
else
{
error = ::flycaptureGetCameraRegister(
context,
REGISTER_EXTENDED_GRAB_MODE,
&ulValue );
HANDLE_ERROR( "flycaptureGetCameraRegister()", error );
//
// Check if the extended shutter mode is present on this camera
//
if( ( ulValue & 0x80000000 ) == 0x80000000 )
{
//
// Go into extended shutter mode
//
printf( "using EXTENDED_SHUTTER register 1028h.\n" );
error = ::flycaptureSetCameraRegister(
context,
REGISTER_EXTENDED_GRAB_MODE,
VALUE_GRAB_MODE_SLOW );
HANDLE_ERROR( "flycaptureSetCameraRegister()", error );
}
else
{
printf( "extended shutter not available with this camera.\n" );
if( cleanUpCamera( context ) != 0 )
{
printf( "Failed to clean up camera.\n" );
}
return 0;
}
}
error = ::flycaptureGetCameraProperty(
context,
FLYCAPTURE_SHUTTER,
&lValueA,
&lValueB,
&bAuto );
HANDLE_ERROR( "flycaptureGetCameraProperty()", error );
error = ::flycaptureSetCameraProperty(
context,
FLYCAPTURE_SHUTTER,
lValueA,
lValueB,
false );
HANDLE_ERROR( "flycaptureSetCameraProperty()", error );
printf( "Using shutter time %dms\n", SHUTTER_TIME );
error = ::flycaptureSetCameraAbsProperty(
context,
FLYCAPTURE_SHUTTER,
SHUTTER_TIME );
HANDLE_ERROR( "flycaptureSetCameraAbsProperty()", error );
//
// The maximum shutter time for DCAM 1.31 cameras will vary according
// to the frame rate.
//
error = ::flycaptureStart(
context,
FLYCAPTURE_VIDEOMODE_ANY,
FLYCAPTURE_FRAMERATE_ANY );
HANDLE_ERROR( "flycaptureStart()", error );
//
// Do an image grab.
//
error = ::flycaptureGrabImage2( context, &image );
HANDLE_ERROR( "flycaptureGrabImage2()", error );
//
// Grab a few more images and print out their timestamps
//
for( int iImage = 0; iImage < IMAGES; iImage++ )
{
error = ::flycaptureGrabImage2( context, &image );
HANDLE_ERROR( "flycaptureGrabImage2()", error );
printf(
"Image %03d - system timestamp = %d.%d\n",
iImage,
image.timeStamp.ulSeconds,
image.timeStamp.ulMicroSeconds );
}
//
// Convert the last image and save it
//
FlyCaptureImage imageConverted;
imageConverted.pData = new unsigned char[ image.iCols * image.iRows * 4 ];
imageConverted.pixelFormat = FLYCAPTURE_BGRU;
printf( "Converting last image.\n" );
error = flycaptureConvertImage( context, &image, &imageConverted );
if( error == FLYCAPTURE_OK )
{
//
// Write out the image in PPM format.
//
printf( "Saving converted image.\n\n" );
error = flycaptureSaveImage(
context,
&imageConverted,
"extendedshutterdemoimage.ppm",
FLYCAPTURE_FILEFORMAT_PPM );
HANDLE_ERROR( "flycaptureSaveImage()", error );
}
HANDLE_ERROR( "flycaptureConvertImage()", error );
if( cleanUpCamera( context ) != 0 )
{
printf( "Failed to clean up camera.\n" );
}
delete imageConverted.pData;
return 0;
}
void
CTimeSliceDoc::grabAndCheckSync()
{
unsigned nCamera;
//
// Grab an image from each camera.
//
for( nCamera = 0; nCamera < m_uiNumCameras; nCamera++ )
{
CameraInfo& camera = m_arCameraInfo[ nCamera ];
camera.m_error = ::flycaptureLockNext( camera.m_context, &camera.m_image );
if( camera.m_error != FLYCAPTURE_OK )
{
TRACE(
"flycaptureLockNext() failed with %s",
::flycaptureErrorToString( camera.m_error ) );
}
camera.m_imageProcessed.pixelFormat = FLYCAPTURE_BGRU;
camera.m_error = flycaptureConvertImage(
camera.m_context,
&camera.m_image.image,
&camera.m_imageProcessed );
if( camera.m_error != FLYCAPTURE_OK )
{
TRACE(
"flycaptureConvertImage() returned an error (\"%s\")\n",
flycaptureErrorToString( camera.m_error ) );
continue;
}
}
//
// Check if the images are synchronized.
//
#ifdef COUNT_OUT_OF_SYNC
for( nCamera = 1; nCamera < m_uiNumCameras; nCamera++ )
{
int iDeltaFrom0 =
abs( (int)( (
m_arCameraInfo[ nCamera ].m_image.image.timeStamp.ulCycleSeconds * 8000 +
m_arCameraInfo[ nCamera ].m_image.image.timeStamp.ulCycleCount ) -
( m_arCameraInfo[ 0 ].m_image.image.timeStamp.ulCycleSeconds * 8000 +
m_arCameraInfo[ 0 ].m_image.image.timeStamp.ulCycleCount ) ) );
if( ( iDeltaFrom0 % ( 128 * 8000 - 1 ) ) > SYNC_TOLERANCE )
{
m_uiOutOfSyncImages++;
break;
}
}
#endif
//
// Check the sequence numbers to see if we have missed an image.
//
for( nCamera = 0; nCamera < m_uiNumCameras; nCamera++ )
{
CameraInfo& camera = m_arCameraInfo[ nCamera ];
if( camera.m_uiPrevSeqNum != 0 )
{
int iDelta = camera.m_image.uiSeqNum - camera.m_uiPrevSeqNum;
//ASSERT( iDelta > 0 );
if( iDelta > 1 )
{
m_uiMissedImages += ( iDelta - 1 );
}
}
camera.m_uiPrevSeqNum = camera.m_image.uiSeqNum;
}
}
// capture image
// for bumblebee2
bool IEEE1394Cam::CaptureImages(unsigned char* bufferL, unsigned char*bufferR) {
if (!_activated){return false;}
#ifdef WIN32
FlyCaptureError fe;
FlyCaptureImage flycaptureImage;
// Grab an image from the camera
fe = flycaptureGrabImage2( _flycapture, &flycaptureImage );
if (fe != FLYCAPTURE_OK) {
return false;
}
if (flycaptureImage.pixelFormat != FLYCAPTURE_RAW16) {
if (_ptype == PIXEL_BGR) {
flycaptureInplaceRGB24toBGR24(flycaptureImage.pData, flycaptureImage.iRows*flycaptureImage.iCols*flycaptureImage.iNumImages);
}
for (int i=0; i<flycaptureImage.iRows; ++i){
memcpy(&bufferR[flycaptureImage.iRowInc*flycaptureImage.iNumImages*i], &flycaptureImage.pData[flycaptureImage.iRowInc*flycaptureImage.iNumImages*i], flycaptureImage.iRowInc);
memcpy(&bufferL[flycaptureImage.iRowInc*(flycaptureImage.iNumImages*(i-1)+1)], &flycaptureImage.pData[flycaptureImage.iRowInc*(flycaptureImage.iNumImages*(i-1)+1)], flycaptureImage.iRowInc);
}
} else {
// convert pixel format to RGB or BGR
FlyCaptureImage rgb_image;
unsigned char* buf = new unsigned char[flycaptureImage.iRows*flycaptureImage.iCols*flycaptureImage.iNumImages*4];
rgb_image.pData = buf;
flycaptureSetColorProcessingMethod( _flycapture, FLYCAPTURE_EDGE_SENSING );
flycaptureConvertImage( _flycapture, &flycaptureImage, &rgb_image); // �x�C���[->BGRU
unsigned char* dstR = bufferR;
unsigned char* dstL = bufferL;
unsigned char* src = buf;
if (_ptype == PIXEL_BGR) {
for (int i=0; i<rgb_image.iRows; ++i) { // BGRU->BGR
// right image
for (int j=0; j< flycaptureImage.iCols; ++j) {
dstR[0] = src[0];//b
dstR[1] = src[1];//g
dstR[2] = src[2];//r
dstR+=3; src+=4;
}
// left image
for (int j=0; j< flycaptureImage.iCols; ++j) {
dstL[0] = src[0];//b
dstL[1] = src[1];//g
dstL[2] = src[2];//r
dstL+=3; src+=4;
}
}
} else {
for (int i=0; i<rgb_image.iRows; ++i) { // BGRU->RGB
// right image
for (int j=0; j< flycaptureImage.iCols; ++j) {
dstR[0] = src[2];//r
dstR[1] = src[1];//g
dstR[2] = src[0];//b
dstR+=3; src+=4;
}
// left iamge
for (int j=0; j< flycaptureImage.iCols; ++j) {
dstL[0] = src[2];//r
dstL[1] = src[1];//g
dstL[2] = src[0];//b
dstL+=3; src+=4;
}
}
}
delete [] buf;
}
return true;
#else
return false;
#endif //WIN32
}
