void ofxffmv::initializeWithGUID(GUID cameraGuid,int cameraWidth,int cameraHeight,int cameraLeft,int cameraTop,bool useROI,unsigned char cameraDepth,int cameraFramerate,bool isPlaying)
{
FlyCaptureInfoEx* tempArInfo = new FlyCaptureInfoEx[_MAX_CAMERAS_];
unsigned int camNum = 0;
flycaptureBusEnumerateCamerasEx( tempArInfo, &camNum );
for (int i=0;i<camNum;i++)
{
if ((unsigned long)tempArInfo[i].SerialNumber == cameraGuid.Data1)
index = i;
}
arInfo = tempArInfo[index];
flycaptureCreateContext(&context);
flycaptureInitialize( context, index );
guid = cameraGuid;
width = cameraWidth;
height = cameraHeight;
framerate = cameraFramerate;
left = cameraLeft;
top = cameraTop;
roiMode = useROI;
depth = cameraDepth;
flycaptureStartCustomImage(context,0,left,top,width,height,100,FLYCAPTURE_MONO8);
flycaptureGrabImage2( context, &fcImage );
width = fcImage.iCols;
height = fcImage.iRows;
depth = (width*height!=0) ? fcImage.iRowInc/fcImage.iRows : 0;
flycaptureSetColorProcessingMethod( context,FLYCAPTURE_DISABLE);
isInitialized = true;
delete tempArInfo;
}
//======================================================================================
// implimetation of functions for IEEE1394 camera (for Point Gray Inc.)
//======================================================================================
// initialize camera
bool IEEE1394Cam::Opens() {
#ifdef WIN32
FlyCaptureError fe;
// Open the camera
fe = flycaptureCreateContext( &_flycapture );
if (fe != FLYCAPTURE_OK) {
return false;
}
// Initialize the WebIEEE1394Cam context
fe = flycaptureInitialize( _flycapture, 0 );
if (fe != FLYCAPTURE_OK) {
return false;
}
// Get camera information
fe = flycaptureGetCameraInfo( _flycapture, &_pInfo );
if (fe != FLYCAPTURE_OK) {
return false;
}
// set video mode
_videoMode = FLYCAPTURE_VIDEOMODE_ANY;
if ( _pInfo.CameraModel == FLYCAPTURE_BUMBLEBEE2 || _pInfo.CameraModel == FLYCAPTURE_FLEA2 || _pInfo.CameraModel == FLYCAPTURE_FLEA ) {
// start transfering the image from camera
if (!_use_stereo) {
// flea, flea2
fe = flycaptureStart( _flycapture, _videoMode, FLYCAPTURE_FRAMERATE_ANY);
} else {
// bumblebee2
fe = flycaptureStartCustomImage( _flycapture, 3, 0, 0, 640, 480, 100, FLYCAPTURE_RAW16);
}
if (fe != FLYCAPTURE_OK) {
return false;
}
} else {
// camera is not supported by this class
return false;
}
FlyCaptureImage flycaptureImage;
// Grab an image from the camera
fe = flycaptureGrabImage2( _flycapture, &flycaptureImage );
if (fe != FLYCAPTURE_OK) {
return false;
}
_height = flycaptureImage.iRows;
_width = flycaptureImage.iCols;
_row_size = flycaptureImage.iRowInc;
_activated = true;
return true;
#else
return false;
#endif //WIN32
}
int
main( int /* argc */, char** /* argv */ )
{
TriclopsContext triclops;
TriclopsImage disparityImage;
TriclopsImage refImage;
TriclopsInput triclopsInput;
TriclopsROI* pRois;
int nMaxRois;
TriclopsError te;
FlyCaptureContext flycapture;
FlyCaptureImage flycaptureImage;
FlyCaptureInfoEx pInfo;
FlyCapturePixelFormat pixelFormat;
FlyCaptureError fe;
int iMaxCols = 0;
int iMaxRows = 0;
// Create the camera context
fe = flycaptureCreateContext( &flycapture );
_HANDLE_FLYCAPTURE_ERROR( "flycaptureCreateContext()", fe );
// Initialize the camera
fe = flycaptureInitialize( flycapture, 0 );
_HANDLE_FLYCAPTURE_ERROR( "flycaptureInitialize()", fe );
// Get the camera configuration
char* szCalFile;
fe = flycaptureGetCalibrationFileFromCamera( flycapture, &szCalFile );
_HANDLE_FLYCAPTURE_ERROR( "flycaptureGetCalibrationFileFromCamera()", fe );
// Create a Triclops context from the cameras calibration file
te = triclopsGetDefaultContextFromFile( &triclops, szCalFile );
_HANDLE_TRICLOPS_ERROR( "triclopsGetDefaultContextFromFile()", te );
// Get camera information
fe = flycaptureGetCameraInfo( flycapture, &pInfo );
_HANDLE_FLYCAPTURE_ERROR( "flycatpureGetCameraInfo()", fe );
if (pInfo.CameraType == FLYCAPTURE_COLOR)
{
pixelFormat = FLYCAPTURE_RAW16;
}
else
{
pixelFormat = FLYCAPTURE_MONO16;
}
switch (pInfo.CameraModel)
{
case FLYCAPTURE_BUMBLEBEE2:
{
unsigned long ulValue;
flycaptureGetCameraRegister( flycapture, 0x1F28, &ulValue );
if ( ( ulValue & 0x2 ) == 0 )
{
// Hi-res BB2
iMaxCols = 1024;
iMaxRows = 768;
}
else
{
// Low-res BB2
iMaxCols = 640;
iMaxRows = 480;
}
}
break;
case FLYCAPTURE_BUMBLEBEEXB3:
iMaxCols = 1280;
iMaxRows = 960;
break;
default:
te = TriclopsErrorInvalidCamera;
_HANDLE_TRICLOPS_ERROR( "triclopsCheckCameraModel()", te );
break;
}
// Start grabbing
fe = flycaptureStartCustomImage(
flycapture, 3, 0, 0, iMaxCols, iMaxRows, 100, pixelFormat);
_HANDLE_FLYCAPTURE_ERROR( "flycaptureStart()", fe );
// Grab an image from the camera
fe = flycaptureGrabImage2( flycapture, &flycaptureImage );
_HANDLE_FLYCAPTURE_ERROR( "flycaptureGrabImage()", fe );
// Extract information from the FlycaptureImage
int imageCols = flycaptureImage.iCols;
int imageRows = flycaptureImage.iRows;
int imageRowInc = flycaptureImage.iRowInc;
int iSideBySideImages = flycaptureImage.iNumImages;
unsigned long timeStampSeconds = flycaptureImage.timeStamp.ulSeconds;
unsigned long timeStampMicroSeconds = flycaptureImage.timeStamp.ulMicroSeconds;
// Create buffers for holding the mono images
unsigned char* rowIntColor =
new unsigned char[ imageCols * imageRows * iSideBySideImages * 4];
unsigned char* rowIntMono =
new unsigned char[ imageCols * imageRows * iSideBySideImages ];
// Create a temporary FlyCaptureImage for preparing the stereo image
FlyCaptureImage tempColorImage;
FlyCaptureImage tempMonoImage;
tempColorImage.pData = rowIntColor;
tempMonoImage.pData = rowIntMono;
// Convert the pixel interleaved raw data to row interleaved format
fe = flycapturePrepareStereoImage(
flycapture, flycaptureImage, &tempMonoImage, &tempColorImage );
_HANDLE_FLYCAPTURE_ERROR( "flycapturePrepareStereoImage()", fe );
// Pointers to positions in the mono buffer that correspond to the beginning
// of the red, green and blue sections
unsigned char* redMono = NULL;
unsigned char* greenMono = NULL;
unsigned char* blueMono = NULL;
redMono = rowIntMono;
if (flycaptureImage.iNumImages == 2)
{
greenMono = redMono + imageCols;
blueMono = redMono + imageCols;
}
if (flycaptureImage.iNumImages == 3)
{
greenMono = redMono + imageCols;
blueMono = redMono + ( 2 * imageCols );
}
// Use the row interleaved images to build up an RGB TriclopsInput.
// An RGB triclops input will contain the 3 raw images (1 from each camera).
te = triclopsBuildRGBTriclopsInput(
imageCols,
imageRows,
imageRowInc,
timeStampSeconds,
timeStampMicroSeconds,
redMono,
greenMono,
blueMono,
&triclopsInput);
_HANDLE_TRICLOPS_ERROR( "triclopsBuildRGBTriclopsInput()", te );
// Set up some stereo parameters:
// Set to 640x480 output images
te = triclopsSetResolution( triclops, 480, 640 );
_HANDLE_TRICLOPS_ERROR( "triclopsSetResolution()", te );
// Set disparity range to be quite wide
te = triclopsSetDisparity( triclops, 0, 200 );
_HANDLE_TRICLOPS_ERROR( "triclopsSetDisparity()", te );
// Set subpixel interpolation off - so we know we don't need to use
// TriclopsImage16 structures when we access and save the disparity image
te = triclopsSetSubpixelInterpolation( triclops, 0 );
_HANDLE_TRICLOPS_ERROR( "triclopsSetSubpixelInterpolation()", te );
// Get the pointer to the regions of interest array
te = triclopsGetROIs( triclops, &pRois, &nMaxRois );
_HANDLE_TRICLOPS_ERROR( "triclopsGetROIs()", te );
if( nMaxRois >= 4 )
{
// Set up four regions of interest:
// Entire upper left quadrant of image
pRois[0].row = 0;
pRois[0].col = 0;
pRois[0].nrows = 240;
pRois[0].ncols = 320;
// Part of the lower right
pRois[1].row = 240;
pRois[1].col = 320;
pRois[1].nrows = 180;
pRois[1].ncols = 240;
// Centered in upper right quadrant
pRois[2].row = 60;
pRois[2].col = 400;
pRois[2].nrows = 120;
pRois[2].ncols = 160;
// Small section of lower left
pRois[3].row = 300;
pRois[3].col = 30;
pRois[3].nrows = 80;
pRois[3].ncols = 80;
// Tell the TriclopsContext how many ROIs we want to process
te = triclopsSetNumberOfROIs( triclops, 4 );
_HANDLE_TRICLOPS_ERROR( "triclopsSetNumberOfROIs()", te );
}
else
{
printf( "Only %d ROIs available in the TriclopsContext "
"- this should never happen!\n"
"Aborting!\n",
nMaxRois );
// Destroy the Triclops context
triclopsDestroyContext( triclops ) ;
// Close the camera and destroy the context
flycaptureStop( flycapture );
flycaptureDestroyContext( flycapture );
return 1;
}
// Rectify the images
te = triclopsRectify( triclops, &triclopsInput );
_HANDLE_TRICLOPS_ERROR( "triclopsRectify()", te );
// Do stereo processing
te = triclopsStereo( triclops );
_HANDLE_TRICLOPS_ERROR( "triclopsStereo()", te );
// Retrieve the disparity image from the Triclops context
te = triclopsGetImage( triclops,
TriImg_DISPARITY,
TriCam_REFERENCE,
&disparityImage );
_HANDLE_TRICLOPS_ERROR( "triclopsGetImage()", te );
// Retrieve the rectified image from the Triclops context
te = triclopsGetImage( triclops,
TriImg_RECTIFIED,
TriCam_REFERENCE,
&refImage );
_HANDLE_TRICLOPS_ERROR( "triclopsGetImage()", te );
// Save the disparity image
te = triclopsSaveImage( &disparityImage, "disparity.pgm" );
_HANDLE_TRICLOPS_ERROR( "triclopsSaveImage()", te );
// Save the rectified image
te = triclopsSaveImage( &refImage, "rectified.pgm" );
_HANDLE_TRICLOPS_ERROR( "triclopsSaveImage()", te );
// Delete the image buffer, it is not needed once the TriclopsInput
// has been built
delete [] rowIntMono;
redMono = NULL;
greenMono = NULL;
blueMono = NULL;
// Destroy the Triclops context
triclopsDestroyContext( triclops ) ;
// Close the camera and destroy the Flycapture context
flycaptureStop( flycapture );
flycaptureDestroyContext( flycapture );
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;
}
