mvIMPACT Acquire SDK C++

The GenICamCallbackOnEvent program is a simple example which illustrates how GenICam events can be used to inform an application about a certain event via a callback.

How it works:
  1. Open the device by calling
  2. Enable GenICam events.
  3. Attach a custom callback to the ExposureEndTimestamp property that gets called whenever a property is modified.
  4. Start the image acquisition in order to cause the callbacks to get triggered.

The full explanation regarding the callback usage can be found at the chapter Callbacks Triggered By GenICam Events .

Source code
#ifdef _MSC_VER // is Microsoft compiler?
# if _MSC_VER < 1300 // is 'old' VC 6 compiler?
# pragma warning( disable : 4786 ) // 'identifier was truncated to '255' characters in the debug information'
# endif // #if _MSC_VER < 1300
#endif // #ifdef _MSC_VER
#include <apps/Common/exampleHelper.h>
#include <iostream>
#include <mvIMPACT_CPP/mvIMPACT_acquire_GenICam.h>
#ifdef _WIN32
# include <process.h>
# include <mvDisplay/Include/mvIMPACT_acquire_display.h>
# define USE_DISPLAY
#endif // #ifdef _WIN32
using namespace mvIMPACT::acquire;
using namespace std;
static bool s_boTerminated = false;
//================= Data type definitions =====================================
struct ThreadParameter
Device* pDev;
#ifdef _WIN32
ImageDisplayWindow displayWindow;
explicit ThreadParameter( Device* p ) : pDev( p ), displayWindow( "mvIMPACT_acquire sample, Device " + pDev-> ) {}
explicit ThreadParameter( Device* p ) : pDev( p ) {}
#endif // #ifdef _WIN32
//================= Camera's property callback ================================
class EventCallback : public ComponentCallback
explicit EventCallback( void* pUserData = 0 ) : ComponentCallback( pUserData ) {}
virtual void execute( Component& c, void* pUserData )
// re-generating the object/data previously attached to the callback object. This could now be used to call a certain member function e.g. to update a class instance about this event!
EventControl* ec = reinterpret_cast<EventControl*>( pUserData );
// Execute the followings if the component is a property.
if ( c.isProp() )
Property p( c );
// Show the property value in console when the property value changes due to the occurrence of the event.
cout << "Component " << << " has changed. Its current value: " << p.readS() << "us. FrameID is: " << ec->eventExposureEndFrameID.readS() << endl;
catch ( const ImpactAcquireException& e )
cout << "An error occurred while retrieving the callback value. Error code: " << e.getErrorCodeAsString() << ")." << endl;
unsigned int __stdcall liveThread( void* pData )
ThreadParameter* pThreadParameter = reinterpret_cast<ThreadParameter*>( pData );
cout << "Initialising the device. This might take some time..." << endl;
pThreadParameter->pDev->interfaceLayout.write( dilGenICam );
catch( const ImpactAcquireException& e )
// this e.g. might happen if the same device is already opened in another process...
cout << "An error occurred while opening the device " << pThreadParameter->pDev->
<< "(error code: " << e.getErrorCodeAsString() << ")." << endl
<< "Press [ENTER] to end the application..." << endl;
return 0;
EventControl ec( pThreadParameter->pDev );
ec.eventSelector.writeS( "ExposureEnd" );
catch ( const ImpactAcquireException& e )
cout << "An error occurred while setting up event control to the device " << pThreadParameter->pDev->
<< "(error code: " << e.getErrorCodeAsString() << ").";
ImageDisplay& display = pThreadParameter->displayWindow.GetImageDisplay();
// create an interface to the device found
mvIMPACT::acquire::FunctionInterface fi( pThreadParameter->pDev );
while( ( result = static_cast<TDMR_ERROR>( fi.imageRequestSingle() ) ) == DMR_NO_ERROR ) {};
cout << "'FunctionInterface.imageRequestSingle' returned with an unexpected result: " << result
manuallyStartAcquisitionIfNeeded( pThreadParameter->pDev, fi );
// run thread loop
// we always have to keep at least 2 images as the displayWindow module might want to repaint the image, thus we
// can free it unless we have a assigned the displayWindow to a new buffer.
mvIMPACT::acquire::Request* pPreviousRequest = 0;
const unsigned int timeout_ms = 500;
EventCallback eventCallback( &ec );
// register a callback to eventExposureEndTimestamp
eventCallback.registerComponent( ec.eventExposureEndTimestamp );
while( !s_boTerminated )
// wait for results from the default capture queue
int requestNr = fi.imageRequestWaitFor( timeout_ms );
pRequest = fi.isRequestNrValid( requestNr ) ? fi.getRequest( requestNr ) : 0;
if( pRequest )
if( pRequest->isOK() )
display.SetImage( pRequest );
cout << "Error: " << pRequest->requestResult.readS() << endl;
if( pPreviousRequest )
// this image has been displayed thus the buffer is no longer needed...
pPreviousRequest = pRequest;
// send a new image request into the capture queue
// Please note that slow systems or interface technologies in combination with high resolution sensors
// might need more time to transmit an image than the timeout value which has been passed to imageRequestWaitFor().
// If this is the case simply wait multiple times OR increase the timeout(not recommended as usually not necessary
// and potentially makes the capture thread less responsive) and rebuild this application.
// Once the device is configured for triggered image acquisition and the timeout elapsed before
// the device has been triggered this might happen as well.
// The return code would be -2119(DEV_WAIT_FOR_REQUEST_FAILED) in that case, the documentation will provide
// additional information under TDMR_ERROR in the interface reference.
// If waiting with an infinite timeout(-1) it will be necessary to call 'imageRequestReset' from another thread
// to force 'imageRequestWaitFor' to return when no data is coming from the device/can be captured.
// cout << "imageRequestWaitFor failed (" << requestNr << ", " << ImpactAcquireException::getErrorCodeAsString( requestNr ) << ")"
// << ", timeout value too small?" << endl;
manuallyStopAcquisitionIfNeeded( pThreadParameter->pDev, fi );
// stop the displayWindow from showing freed memory
// In this sample all the next lines are redundant as the device driver will be
// closed now, but in a real world application a thread like this might be started
// several times an then it becomes crucial to clean up correctly.
// free the last potentially locked request
if( pRequest )
// clear all queues
fi.imageRequestReset( 0, 0 );
// clean up
eventCallback.unregisterComponent( ec.eventExposureEndTimestamp );
return 0;
//================= Main thread ===============================================
int main( void )
DeviceManager devMgr;
Device* pDev = getDeviceFromUserInput( devMgr );
if( !pDev )
cout << "Unable to continue! Press [ENTER] to end the application" << endl;
return 1;
cout << "Press [ENTER] to stop the acquisition thread" << endl << endl;
ThreadParameter threadParam( pDev );
#ifdef _WIN32
unsigned int dwThreadID;
HANDLE hThread = ( HANDLE )_beginthreadex( 0, 0, liveThread, ( LPVOID )( &threadParam ), 0, &dwThreadID );
s_boTerminated = true;
WaitForSingleObject( hThread, INFINITE );
CloseHandle( hThread );
liveThread( &threadParam );
s_boTerminated = true;
#endif // #ifdef _WIN32
return 0;
std::string name(void) const
Returns the name of the component referenced by this object.
Definition: mvIMPACT_acquire.h:1089
A simple helper class to wrap the creation of a callback object.
Definition: mvIMPACT_acquire.h:1983
A base class to implement access to internal driver components.
Definition: mvIMPACT_acquire.h:1321
bool isProp(void) const
Checks if this component is of type mvIMPACT::acquire::Property or a derived type.
Definition: mvIMPACT_acquire.h:1588
Grants access to devices that can be operated by this software interface.
Definition: mvIMPACT_acquire.h:6964
This class and its functions represent an actual device detected by this interface in the current sys...
Definition: mvIMPACT_acquire.h:5948
PropertyS serial
A string property (read-only) containing the serial number of this device.
Definition: mvIMPACT_acquire.h:6351
The function interface to devices supported by this interface.
Definition: mvIMPACT_acquire.h:10443
Category that contains Event control features.
Definition: mvIMPACT_acquire_GenICam.h:5617
PropertyI64 eventExposureEndFrameID
An integer property. Returns the unique Identifier of the Frame (or image) that generated the Exposur...
Definition: mvIMPACT_acquire_GenICam.h:7236
PropertyI64 eventNotification
An enumerated integer property. Activate or deactivate the notification to the host application of th...
Definition: mvIMPACT_acquire_GenICam.h:6921
PropertyI64 eventSelector
An enumerated integer property. Selects which Event to signal to the host application.
Definition: mvIMPACT_acquire_GenICam.h:6907
PropertyI64 eventExposureEndTimestamp
An integer property. Returns the Timestamp of the Exposure End Event.
Definition: mvIMPACT_acquire_GenICam.h:7231
A base class for exceptions generated by mvIMPACT Acquire.
Definition: mvIMPACT_acquire.h:248
std::string getErrorCodeAsString(void) const
Returns a string representation of the error associated with the exception.
Definition: mvIMPACT_acquire.h:280
std::string read(int index=0) const
Reads a value from a property.
Definition: mvIMPACT_acquire.h:5159
A base class for properties.
Definition: mvIMPACT_acquire.h:3007
std::string readS(int index=0, const std::string &format="") const
Reads data from this property as a string.
Definition: mvIMPACT_acquire.h:3213
const Property & writeS(const std::string &value, int index=0) const
Assigns a new value to this property.
Definition: mvIMPACT_acquire.h:3423
Contains information about a captured buffer.
Definition: mvIMPACT_acquire.h:8408
bool isOK(void) const
Convenience function to check if a request has been processed successfully.
Definition: mvIMPACT_acquire.h:9197
PropertyIRequestResult requestResult
An enumerated integer property (read-only) defining the result of this request.
Definition: mvIMPACT_acquire.h:9500
int unlock(void)
Unlocks the request for the driver again.
Definition: mvIMPACT_acquire.h:9337
A class that can be used to display images in a window.
Definition: mvIMPACT_acquire_display.h:582
A class that can be used for displaying images within existing windows or GUI elements that can provi...
Definition: mvIMPACT_acquire_display.h:172
void RemoveImage(void)
Removes the current image from the display.
Definition: mvIMPACT_acquire_display.h:371
void SetImage(const void *pData, int width, int height, int bitsPerPixel, int pitch)
Sets the next image to display.
Definition: mvIMPACT_acquire_display.h:292
void Update(void) const
Immediately redraws the current image.
Definition: mvIMPACT_acquire_display.h:381
Errors reported by the device manager.
Definition: mvDriverBaseEnums.h:2260
The function call was executed successfully.
Definition: mvDriverBaseEnums.h:2265
This namespace contains classes and functions belonging to the GenICam specific part of the image acq...
Definition: mvIMPACT_acquire.h:23307
This namespace contains classes and functions that can be used to display images.
This namespace contains classes and functions belonging to the image acquisition module of this SDK.
Definition: mvImageBuffer.h:42