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; }