bool AcquireImages(CamInfo* cams, int numCams)
{
int i;
PvResult result;
// Initialize Camera System
PvSystem system;
system.SetDetectionTimeout(2000);
result = system.Find();
if(!result.IsOK()){
printf("PvSystem::Find Error: %s", result.GetCodeString().GetAscii());
return false;
}
PvDevice lDevice[numCams];
PvGenParameterArray *lDeviceParams[numCams];
PvStream lStream[numCams];
PvPipeline *lPipeline[numCams];
for(i=0; i < numCams; i++){
PvDeviceInfo* lDeviceInfo = NULL;
PvDeviceInfo* tempInfo;
// Get the number of GEV Interfaces that were found using GetInterfaceCount.
PvUInt32 lInterfaceCount = system.GetInterfaceCount();
// For each interface, check MAC Address against passed address
for( PvUInt32 x = 0; x < lInterfaceCount; x++ )
{
// get pointer to each of interface
PvInterface * lInterface = system.GetInterface( x );
// Get the number of GEV devices that were found using GetDeviceCount.
PvUInt32 lDeviceCount = lInterface->GetDeviceCount();
for( PvUInt32 y = 0; y < lDeviceCount ; y++ )
{
tempInfo = lInterface->GetDeviceInfo( y );
if(strlen(cams[i].MACAddress) == strlen(tempInfo->GetMACAddress().GetAscii()) && strncmp(cams[i].MACAddress,tempInfo->GetMACAddress().GetAscii(),strlen(cams[i].MACAddress)) == 0){
lDeviceInfo = tempInfo;
break;
}
}
}
// If no device is selected, abort
if( lDeviceInfo == NULL )
{
printf( "No device selected.\n" );
return false;
}
// Connect to the GEV Device
printf( "Connecting to %s\n", lDeviceInfo->GetMACAddress().GetAscii() );
if ( !lDevice[i].Connect( lDeviceInfo ).IsOK() )
{
printf( "Unable to connect to %s\n", lDeviceInfo->GetMACAddress().GetAscii() );
return false;
}
printf( "Successfully connected to %s\n", lDeviceInfo->GetMACAddress().GetAscii() );
printf( "\n" );
// Get device parameters need to control streaming
lDeviceParams[i] = lDevice[i].GetGenParameters();
// Negotiate streaming packet size
lDevice[i].NegotiatePacketSize();
// Open stream - have the PvDevice do it for us
printf( "Opening stream to device\n" );
lStream[i].Open( lDeviceInfo->GetIPAddress() );
// Create the PvPipeline object
lPipeline[i] = new PvPipeline( &lStream[i] );
// Reading payload size from device
PvInt64 lSize = 0;
lDeviceParams[i]->GetIntegerValue( "PayloadSize", lSize );
// Set the Buffer size and the Buffer count
lPipeline[i]->SetBufferSize( static_cast<PvUInt32>( lSize ) );
lPipeline[i]->SetBufferCount( 16 ); // Increase for high frame rate without missing block IDs
// Have to set the Device IP destination to the Stream
lDevice[i].SetStreamDestination( lStream[i].GetLocalIPAddress(), lStream[i].GetLocalPort() );
}
PvGenParameterArray *lStreamParams[numCams];
for(i=0; i < numCams; i++){
// IMPORTANT: the pipeline needs to be "armed", or started before
// we instruct the device to send us images
printf( "Starting pipeline %d\n",i);
lPipeline[i]->Start();
// Get stream parameters/stats
lStreamParams[i] = lStream[i].GetParameters();
// TLParamsLocked is optional but when present, it MUST be set to 1
// before sending the AcquisitionStart command
lDeviceParams[i]->SetIntegerValue( "TLParamsLocked", 1 );
printf( "Resetting timestamp counter...\n" );
lDeviceParams[i]->ExecuteCommand( "GevTimestampControlReset" );
// The pipeline is already "armed", we just have to tell the device
// to start sending us images
printf( "Sending StartAcquisition command to device\n" );
lDeviceParams[i]->ExecuteCommand( "AcquisitionStart" );
}
char lDoodle[] = "|\\-|-/";
int lDoodleIndex = 0;
PvInt64 lImageCountVal = 0;
double lFrameRateVal = 0.0;
double lBandwidthVal = 0.0;
PvInt64 lPipelineBlocksDropped = 0;
// Acquire images until the user instructs us to stop
printf( "\n<press the enter key to stop streaming>\n" );
//PvBufferWriter writer;
char filePath[MAXFILEPATH];
PvUInt32 lWidth = 4096, lHeight = 9250;
while ( running )
{
for(i=0; i < numCams; i++){
// Retrieve next buffer
PvBuffer *lBuffer = NULL;
PvResult lOperationResult;
PvResult lResult = lPipeline[i]->RetrieveNextBuffer( &lBuffer, 1000, &lOperationResult );
if ( lResult.IsOK() )
{
if ( lOperationResult.IsOK() )
{
lStreamParams[i]->GetIntegerValue( "ImagesCount", lImageCountVal );
lStreamParams[i]->GetFloatValue( "AcquisitionRateAverage", lFrameRateVal );
lStreamParams[i]->GetFloatValue( "BandwidthAverage", lBandwidthVal );
lStreamParams[i]->GetIntegerValue("PipelineBlocksDropped", lPipelineBlocksDropped);
filePath[0] = '\0';
sprintf(filePath,"%s/%s%04X.tif",cams[i].filename,cams[i].prefix,lBuffer->GetBlockID());
TIFF *out = TIFFOpen(filePath,"w");
TIFFSetField(out, TIFFTAG_IMAGEWIDTH, lWidth);
TIFFSetField(out, TIFFTAG_IMAGELENGTH, lHeight);
TIFFSetField(out, TIFFTAG_SAMPLESPERPIXEL, 1);
TIFFSetField(out, TIFFTAG_BITSPERSAMPLE, 8);
TIFFSetField(out, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
TIFFSetField(out, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
TIFFSetField(out, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISBLACK);
TIFFSetField(out, TIFFTAG_COMPRESSION, COMPRESSION_NONE);
TIFFWriteEncodedStrip(out,0,lBuffer->GetDataPointer(),lWidth*lHeight);
TIFFClose(out);
printf( "%d:%s%c Timestamp: %016llX BlockID: %04X %.01f FPS %d DROP %.01f Mb/s\r\n",i,
cams[i].prefix,
lDoodle[ lDoodleIndex ],
lBuffer->GetTimestamp(),
lBuffer->GetBlockID(),
lFrameRateVal,
lPipelineBlocksDropped,
lBandwidthVal / 1000000.0 );
} else {
printf("%d: ERROR Code: %s, Description: %s\r\n",i,lOperationResult.GetCodeString().GetAscii(),lOperationResult.GetDescription().GetAscii());
}
// We have an image - do some processing (...)
// VERY IMPORTANT:
// release the buffer back to the pipeline
lPipeline[i]->ReleaseBuffer( lBuffer );
usleep(200);
}
else
{
// Timeout
printf( "%d:%s%c Timeout\r\n",i, cams[i].prefix,lDoodle[ lDoodleIndex ]);
}
}
++lDoodleIndex %= 6;
}
//_getch(); // Flush key buffer for next stop
printf( "\n\n" );
for(i=0; i < numCams; i++){
// Tell the device to stop sending images
printf( "Sending AcquisitionStop command to the device\n" );
lDeviceParams[i]->ExecuteCommand( "AcquisitionStop" );
// If present reset TLParamsLocked to 0. Must be done AFTER the
// streaming has been stopped
lDeviceParams[i]->SetIntegerValue( "TLParamsLocked", 0 );
// We stop the pipeline - letting the object lapse out of
// scope would have had the destructor do the same, but we do it anyway
printf( "Stop pipeline\n" );
lPipeline[i]->Stop();
delete lPipeline[i];
// Now close the stream. Also optionnal but nice to have
printf( "Closing stream\n" );
lStream[i].Close();
// Finally disconnect the device. Optional, still nice to have
printf( "Disconnecting device\n" );
lDevice[i].Disconnect();
}
return true;
}
int ImperxStream::Connect(const std::string &IP)
{
PvResult lResult;
// Create an GEV system and an interface.
PvSystem lSystem;
// Find all GEV Devices on the network.
lSystem.SetDetectionTimeout( 2000 );
lResult = lSystem.Find();
if( !lResult.IsOK() )
{
//Failed to find PvAnything
printf( "PvSystem::Find Error: %s", lResult.GetCodeString().GetAscii() );
return -1;
}
// Get the number of GEV Interfaces that were found using GetInterfaceCount.
PvUInt32 lInterfaceCount = lSystem.GetInterfaceCount();
// Search through interfaces for any devices
// Check devices for correct target IP
for( PvUInt32 x = 0; x < lInterfaceCount; x++ )
{
// get pointer to each of interface
PvInterface * lInterface = lSystem.GetInterface( x );
// Get the number of GEV devices that were found using GetDeviceCount.
PvUInt32 lDeviceCount = lInterface->GetDeviceCount();
for( PvUInt32 y = 0; y < lDeviceCount ; y++ )
{
PvDeviceInfo *tDeviceInfo = lInterface->GetDeviceInfo( y );
std::string laddress(tDeviceInfo->GetIPAddress().GetAscii());
if (!laddress.compare(IP))
{
lDeviceInfo = tDeviceInfo;
printf( "Interface %i\nMAC Address: %s\nIP Address: %s\nSubnet Mask: %s\n\n",
x,
lInterface->GetMACAddress().GetAscii(),
lInterface->GetIPAddress().GetAscii(),
lInterface->GetSubnetMask().GetAscii() );
printf( "Device %i\nMAC Address: %s\nIP Address: %s\nSerial number: %s\n\n",
y,
tDeviceInfo->GetMACAddress().GetAscii(),
tDeviceInfo->GetIPAddress().GetAscii(),
tDeviceInfo->GetSerialNumber().GetAscii() );
}
}
}
// Connect to the last GEV Device found.
if( lDeviceInfo != NULL )
{
printf( "Connecting to %s\n",
lDeviceInfo->GetMACAddress().GetAscii() );
lResult = lDevice.Connect( lDeviceInfo );
if ( !lResult.IsOK() )
{
printf( "Unable to connect to %s\n",
lDeviceInfo->GetMACAddress().GetAscii() );
}
else
{
printf( "Successfully connected to %s\n",
lDeviceInfo->GetMACAddress().GetAscii() );
}
}
else
{
printf( "No device found\n" );
}
// Get device parameters need to control streaming
PvGenParameterArray *lDeviceParams = lDevice.GetGenParameters();
return 0;
}
bool AcquireImages()
{
// Create a GEV Device finder dialog
PvDeviceFinderWnd lDeviceFinderWnd;
// Prompt the user to select a GEV Device
lDeviceFinderWnd.ShowModal();
// Get the connectivity information for the selected GEV Device
PvDeviceInfo* lDeviceInfo = lDeviceFinderWnd.GetSelected();
// If no device is selected, abort
if( lDeviceInfo == NULL )
{
cout << "No device selected." << endl;
return false;
}
PvString lMACAddress = lDeviceInfo->GetMACAddress();
PvString lIPAddress = lDeviceInfo->GetIPAddress();
// Connect to the GEV Device
PvDevice lDevice;
cout << "Connecting to " << lMACAddress.GetAscii() << endl;
// if ( !lDevice.Connect( lDeviceInfo ).IsOK() )
if ( !lDevice.Connect( lDeviceInfo ).IsOK() )
{
cout << "Unable to connect to " << lMACAddress.GetAscii() << endl;
return false;
}
cout << "Successfully connected to " << lMACAddress.GetAscii() << endl;
cout << endl;
SourceList lSources;
// Get source selector
PvGenEnum *lSourceSelector = lDevice.GetGenParameters()->GetEnum( "SourceSelector" );
if ( lSourceSelector != NULL )
{
// Go through all sources, create source objects
PvInt64 lCount = 0;
lSourceSelector->GetEntriesCount( lCount );
for ( PvInt64 i = 0; i < lCount; i++ )
{
// Get source enum entry
const PvGenEnumEntry *lEE = NULL;
lSourceSelector->GetEntryByIndex( i, &lEE );
// If available, create source
if ( ( lEE != NULL ) && lEE->IsAvailable() )
{
// Get source name
PvString lSourceName;
lEE->GetName( lSourceName );
// Create source
Source *lSource = new Source( &lDevice, lIPAddress, lSourceName );
lSource->Open();
// Add to sources list
lSources.push_back( lSource );
cout << endl;
}
}
}
else
{
// If no source selector, just create a single source
Source *lSource = new Source( &lDevice, lIPAddress, "" );
lSource->Open();
// Add to sources list
lSources.push_back( lSource );
cout << endl;
}
// Start the acquisiton on all sources
SourceList::iterator lIt = lSources.begin();
while ( lIt != lSources.end() )
{
( *( lIt++ ) )->StartAcquisition();
cout << endl;
}
// Aggressive initial value, will be adjusted vs frame rate
PvUInt32 lTimeout = 1;
// Acquire images until the user instructs us to stop
cout << "<press a key to stop streaming>" << endl;
while ( !PvKbHit() )
{
double lNewTimeout = 1000.0;
lIt = lSources.begin();
while ( lIt != lSources.end() )
{
( *lIt )->RetrieveImages( lTimeout );
( *lIt )->PrintStatistics();
// Always use the smallest recommended timeout
double lRecommendedTimeout = ( *lIt )->GetRecommendedTimeout();
if ( lRecommendedTimeout < lNewTimeout )
{
lNewTimeout = lRecommendedTimeout;
}
lIt++;
}
// Update timeout for next round - smallest recommended divided by number of sources
lTimeout = static_cast<PvUInt32>( lNewTimeout / static_cast<double>( lSources.size() ) + 0.5 );
cout << "\r";
}
PvGetChar(); // Flush key buffer for next stop
cout << endl << endl;
// Stop the acquisiton on all sources
lIt = lSources.begin();
while ( lIt != lSources.end() )
{
( *( lIt++ ) )->StopAcquisition();
cout << endl;
}
// Close and delete sources
lIt = lSources.begin();
while ( lIt != lSources.end() )
{
( *lIt )->Close();
cout << endl;
delete *lIt;
lIt++;
}
// Finally disconnect the device. Optional, still nice to have
cout << "Disconnecting device" << endl;
lDevice.Disconnect();
return true;
}