It can also be helpful to familiarize yourself with the NodeMapCallback example, as nodemap callbacks follow the same general procedure as events, but with a few less steps.
#include <iostream>
#include <sstream>
#if _MSC_VER != 1600
#include <mutex>
#endif
using namespace Spinnaker;
using namespace Spinnaker::GenApi;
using namespace Spinnaker::GenICam;
using namespace std;
{
public:
: m_system(system), m_interface(nullptr), m_interfaceID(""), m_registerToSystem(true){};
: m_system(nullptr), m_interface(iface), m_interfaceID(interfaceID), m_registerToSystem(false){};
void PrintGenericHandlerMessage(const unsigned long long deviceCount)
{
cout << "Generic interface event handler:\n";
const bool singular = deviceCount == 1;
const string genericMsg = "\tThere " + string(singular ? "is " : "are ") + to_string(deviceCount) +
string(singular ? " device " : " devices ") + "on the system.\n";
cout << genericMsg << endl;
}
{
if (m_registerToSystem)
{
const auto deviceCount = static_cast<unsigned long long>(m_system->GetCameras().GetSize());
PrintGenericHandlerMessage(deviceCount);
}
else
{
cout << "Interface event handler:\n";
const std::string arrivalMsg = "\tDevice " + std::string(pCamera->TLDevice.DeviceSerialNumber.ToString()) +
" has arrived on interface '" + m_interfaceID + "'.\n";
cout << arrivalMsg << endl;
}
}
{
if (m_registerToSystem)
{
try
{
const auto deviceCount = static_cast<unsigned long long>(m_system->GetCameras().GetSize());
PrintGenericHandlerMessage(deviceCount);
}
{
cout <<
"Error updating cameras: " << e.
what() << endl;
}
}
else
{
cout << "Interface event handler:\n";
const std::string removalMsg = "\tDevice " + std::string(pCamera->TLDevice.DeviceSerialNumber.ToString()) +
" was removed from interface '" + m_interfaceID + "'.\n";
cout << removalMsg << endl;
}
}
std::string GetInterfaceId()
{
return m_interfaceID;
}
private:
std::string m_interfaceID;
bool m_registerToSystem;
};
{
public:
{
};
void LockEventHandlerMutex()
{
eventHandlersMutex.lock();
}
void UnlockEventHandlerMutex()
{
eventHandlersMutex.unlock();
}
{
cout << "System event handler:\n";
cout << "\tInterface '" << pInterface->TLInterface.InterfaceID.ToString() << "' has arrived on the system." << endl;
m_system->UpdateInterfaceList();
const unsigned int numCameras = cameraList.
GetSize();
for (unsigned int camIdx = 0; camIdx < numCameras; camIdx++)
{
INodeMap& nodeMapTLDevice = pCam->GetTLDeviceNodeMap();
CStringPtr ptrStringSerial = nodeMapTLDevice.GetNode(
"DeviceSerialNumber");
{
const gcstring deviceSerialNumber = ptrStringSerial->GetValue();
cout << "\tDevice " << string(deviceSerialNumber) << " is connected to interface '" << pInterface->TLInterface.InterfaceID.ToString() << "'." << endl;
}
}
{
LockEventHandlerMutex();
try
{
shared_ptr<InterfaceEventHandlerImpl> interfaceEventHandler =
shared_ptr<InterfaceEventHandlerImpl>(
new InterfaceEventHandlerImpl(pInterface, pInterface->TLInterface.InterfaceID.ToString().c_str()));
m_interfaceEventHandlers.push_back(interfaceEventHandler);
pInterface->RegisterEventHandler(*interfaceEventHandler);
cout << "Event handler registered to interface '" << pInterface->TLInterface.InterfaceID.ToString() << "'..." << endl;
}
catch (exception& e)
{
cout << "Error registering interface event handler to '" << pInterface->TLInterface.InterfaceID.ToString() << "' :" << e.what()
<< endl;
}
UnlockEventHandlerMutex();
}
}
{
cout << "System event handler:" << endl;
cout << "\tInterface '"<< pInterface->TLInterface.InterfaceID.ToString() << "' was removed from the system." << endl;
m_system->UpdateInterfaceList();
{
LockEventHandlerMutex();
try
{
unsigned int handlerIdx = 0;
for (handlerIdx = 0; handlerIdx < m_interfaceEventHandlers.size(); handlerIdx++)
{
if (m_interfaceEventHandlers[handlerIdx]->GetInterfaceId() == pInterface->TLInterface.InterfaceID.ToString().c_str())
{
m_interfaceEventHandlers.erase(m_interfaceEventHandlers.begin() + handlerIdx);
break;
}
}
}
catch (exception& e)
{
cout << "Error erasing event handler from interface '" << pInterface->TLInterface.InterfaceID.ToString() << "' :" << e.what() << endl;
}
UnlockEventHandlerMutex();
}
}
void RegisterInterfaceEventToSystem()
{
if (!m_interfaceEventHandlerOnSystem)
{
m_interfaceEventHandlerOnSystem =
}
m_system->RegisterEventHandler(*m_interfaceEventHandlerOnSystem);
cout << "Interface event handler registered on the system..." << endl;
}
void UnregisterInterfaceEventFromSystem()
{
if (m_interfaceEventHandlerOnSystem)
{
m_system->UnregisterEventHandler(*m_interfaceEventHandlerOnSystem);
cout << "Interface event handler unregistered from system..." << endl;
m_interfaceEventHandlerOnSystem = shared_ptr<InterfaceEventHandlerImpl>();
}
}
void RegisterAllInterfaceEvents()
{
{
LockEventHandlerMutex();
if (!m_interfaceEventHandlers.empty())
{
m_interfaceEventHandlers.clear();
}
UnlockEventHandlerMutex();
}
unsigned int numInterfaces = interfaceList.
GetSize();
for (unsigned int i = 0; i < numInterfaces; i++)
{
INodeMap& nodeMap = pInterface->GetTLNodeMap();
const CStringPtr interfaceIDNode = nodeMap.GetNode(
"InterfaceID");
{
continue;
}
std::string interfaceID = std::string(interfaceIDNode->GetValue().c_str());
{
LockEventHandlerMutex();
try
{
shared_ptr<InterfaceEventHandlerImpl> interfaceEventHandler =
m_interfaceEventHandlers.push_back(interfaceEventHandler);
pInterface->RegisterEventHandler(*m_interfaceEventHandlers[i]);
cout << "Event handler registered to interface '" << interfaceID << "'..." << endl;
}
catch (exception& e)
{
cout << "Error registering event handler to interface '" << interfaceID << "' :" << e.what() << endl;
}
UnlockEventHandlerMutex();
}
}
cout << endl;
}
void UnregisterAllInterfaceEvents()
{
unsigned int numInterfaces = interfaceList.
GetSize();
for (unsigned int i = 0; i < numInterfaces; i++)
{
INodeMap& nodeMap = pInterface->GetTLNodeMap();
const CStringPtr interfaceIDNode = nodeMap.GetNode(
"InterfaceID");
{
continue;
}
std::string interfaceID = std::string(interfaceIDNode->GetValue().c_str());
{
LockEventHandlerMutex();
try
{
for (unsigned int j = 0; j < m_interfaceEventHandlers.size(); j++)
{
if (interfaceID == m_interfaceEventHandlers[j]->GetInterfaceId())
{
pInterface->UnregisterEventHandler(*m_interfaceEventHandlers[j]);
}
}
}
catch (exception& e)
{
cout << "Error unreigstering event handler to interface '" << interfaceID << "' :" << e.what()
<< endl;
}
UnlockEventHandlerMutex();
}
}
{
LockEventHandlerMutex();
m_interfaceEventHandlers.clear();
cout << "Event handler unregistered from interfaces..." << endl;
UnlockEventHandlerMutex();
}
}
private:
shared_ptr<InterfaceEventHandlerImpl> m_interfaceEventHandlerOnSystem;
vector<shared_ptr<InterfaceEventHandlerImpl>> m_interfaceEventHandlers;
std::mutex eventHandlersMutex;
};
{
INodeMap& nodeMap = pSystem->GetTLNodeMap();
const CBooleanPtr enumerateGevInterfacesNode = nodeMap.GetNode(
"EnumerateGEVInterfaces");
{
const bool gevEnabled = enumerateGevInterfacesNode->GetValue();
if (!gevEnabled)
{
cout << endl
<< "WARNING: GEV Enumeration is disabled." << endl
<< "If you intend to use GigE cameras please run the EnableGEVInterfaces shortcut" << endl
<< "or set EnumerateGEVInterfaces to true and relaunch your application." << endl
<< endl;
}
else
{
cout << "EnumerateGEVInterfaces is enabled. Continuing.." << endl;
}
}
else
{
cout << "EnumerateGEVInterfaces node is not readable" << endl;
}
}
{
cout << "Application build date: " << __DATE__ << " " << __TIME__ << endl << endl;
const LibraryVersion spinnakerLibraryVersion = system->GetLibraryVersion();
cout <<
"Spinnaker library version: " << spinnakerLibraryVersion.
major <<
"." << spinnakerLibraryVersion.
minor
<<
"." << spinnakerLibraryVersion.
type <<
"." << spinnakerLibraryVersion.
build << endl
<< endl;
unsigned int numCameras = camList.
GetSize();
cout << "Number of cameras detected: " << numCameras << endl << endl;
unsigned int numInterfaces = interfaceList.
GetSize();
cout << "Number of interfaces detected: " << numInterfaces << endl << endl;
cout << endl << "*** CONFIGURING ENUMERATION EVENTS ***" << endl << endl;
system->RegisterEventHandler(systemEventHandler);
systemEventHandler.RegisterInterfaceEventToSystem();
systemEventHandler.RegisterAllInterfaceEvents();
cout << endl << "Ready! Remove/Plug in cameras to test or press Enter to exit..." << endl << endl;
getchar();
systemEventHandler.UnregisterAllInterfaceEvents();
systemEventHandler.UnregisterInterfaceEventFromSystem();
system->UnregisterEventHandler(systemEventHandler);
cout << "System event handler unregistered from system..." << endl;
system->ReleaseInstance();
cout << endl << "Done! Press Enter to exit..." << endl;
getchar();
return 0;
}