Spinnaker SDK

https://softwareservices.flir.com/spinnaker/latest/_programmer_guide.html
Admin
Spinnaker SDK is a GenICam-compliant software development kit providing a generic programming...
Tokens:3,785
Snippets:30
Trust Score:10
Update:1 year ago
Show doc for...
Tokens:
Raw
### Display Property Grid Window using C# GUI API

Source: https://softwareservices.flir.com/spinnaker/latest/_programmer_guide.html/_programmer_guide

This C# snippet illustrates how to display the property grid window, which allows users to view and modify camera properties. It uses the GUIFactory to connect to the camera, gets the property grid window, connects it, and then shows it as a modal dialog.

```C#
GUIFactory AcquisitionGUI = new GUIFactory ();
AcquisitionGUI.ConnectGUILibrary(cam);
PropertyGridWindow propWindow = AcquisitionGUI.GetPropertyGridWindow();
propWindow.Connect(cam);
propWindow.ShowModal();
```

--------------------------------

### Display Image Drawing Window using C# GUI API

Source: https://softwareservices.flir.com/spinnaker/latest/_programmer_guide.html/_programmer_guide

This C# snippet demonstrates how to initialize and display the image drawing window using Spinnaker's GUIFactory. It connects the GUI library to the camera, retrieves the image drawing window, connects it to the camera, starts it, and then shows it as a modal dialog.

```C#
GUIFactory AcquisitionGUI = new GUIFactory ();
AcquisitionGUI.ConnectGUILibrary(cam);
ImageDrawingWindow AcquisitionDrawing = AcquisitionGUI.GetImageDrawingWindow();
AcquisitionDrawing.Connect(cam);
AcquisitionDrawing.Start();
AcquisitionDrawing.ShowModal();
```

--------------------------------

### Spinnaker C++: Registering Custom Logging Callback

Source: https://softwareservices.flir.com/spinnaker/latest/_programmer_guide.html/_programmer_guide

Demonstrates how to register a custom logging callback class with the Spinnaker System. This allows for custom handling of log events based on a defined priority level, including an example of the OnLogEvent method.

```C++
SystemPtr system = System::GetInstance();
// Register logging callback class
LogCallback callBackClass; system->RegisterLoggingEvent((Spinnaker::LoggingEvent&)callBackClass);
// Set callback priority level
system->SetLoggingEventPriorityLevel(k_LoggingLevel);
class LogCallback : Spinnaker::LoggingEvent
{
void OnLogEvent(LoggingEventDataPtr loggingEventDataPtr)
{
...
}
};
```

--------------------------------

### Instantiate Multiple Cameras using C++

Source: https://softwareservices.flir.com/spinnaker/latest/_programmer_guide.html/_programmer_guide

This C++ snippet demonstrates how to instantiate multiple cameras connected to the system. It retrieves a list of cameras from the system object, iterates through them, and initializes each camera. It also highlights the need to release the system object at the end.

```C++
// Retrieve singleton reference to system object
CameraList camList = system->GetCameras();
for (unsigned int i = 0; i < numCameras; ++i)
	CameraPtr pCamera = camList.GetByIndex(i);
	pCamera->Init();
}
//	Release	system
```

--------------------------------

### Inquire Camera Gain using C++ GenAPI

Source: https://softwareservices.flir.com/spinnaker/latest/_programmer_guide.html/_programmer_guide

This snippet demonstrates how to retrieve the camera gain value using the GenAPI in C++. It involves getting the node map from the camera, then accessing the "Gain" node, and finally retrieving its value. GenAPI provides a generic interface for camera configuration.

```C++
Spinnaker::GenApi::INodeMap & nodeMap = cam->GetNodeMap(); CFloatPtr GainNode = nodeMap.GetNode("Gain"); Float GainVal = GainNode->GetValue();
```

--------------------------------

### Set Camera Image Width using C++ GenAPI

Source: https://softwareservices.flir.com/spinnaker/latest/_programmer_guide.html/_programmer_guide

This C++ snippet demonstrates how to access and modify camera properties, specifically setting the image width, using the GenAPI node map. It retrieves the node map from the camera object, gets the 'Width' node, and then sets its value to a new width.

```C++
GenApi::INodeMap & nodeMap = cam.GetNodeMap();  CIntegerPtr width = nodeMap.GetNode("Width");  width->SetValue(new_width_val);
```

--------------------------------

### Implement Spinnaker C++ Exception Handling

Source: https://softwareservices.flir.com/spinnaker/latest/_programmer_guide.html/_programmer_guide

This snippet demonstrates the standard error handling mechanism in Spinnaker C++ using a try-catch block. It shows how to catch Spinnaker::Exception objects to manage and respond to errors that may occur during camera initialization or other operations.

```C++
//Assuming Camera& Cam
try
{
cam.Init();
} catch (Spinnaker:: Exception &e) { //Exception handling }
```

--------------------------------

### Spinnaker C++: Enabling Camera Chunk Data

Source: https://softwareservices.flir.com/spinnaker/latest/_programmer_guide.html/_programmer_guide

Illustrates how to enable specific chunk data, such as exposure time, on a Spinnaker camera. This involves setting the ChunkSelector, enabling the chunk, and activating chunk mode.

```C++
Cam->ChunkSelector.SetValue(Spinnaker::ChunkSelectorEnums::ChunkSelector_ExposureTime);
Cam->ChunkEnable.SetValue(true);
Cam->ChunkModeActive.SetValue(true);
```

--------------------------------

### Configure Asynchronous Hardware Triggering with Spinnaker C++

Source: https://softwareservices.flir.com/spinnaker/latest/_programmer_guide.html/_programmer_guide

This snippet demonstrates how to configure asynchronous hardware triggering for a camera. It enables trigger mode, sets GPIO0/Line0 as the trigger input source, and specifies the trigger signal polarity as an active high (rising edge) signal. This setup is crucial for precise external control over frame acquisition.

```Spinnaker C++ QuickSpin API
Cam->TriggerMode.SetValue(Spinnaker::TriggerModeEnums::TriggerMode_On);
Cam->TriggerSource.SetValue(Spinnaker::TriggerSourceEnums::TriggerSource_Line0);
Cam->TriggerSelector.SetValue(Spinnaker::TriggerSelectorEnums::TriggerSelector_FrameStart);
Cam->TriggerActivation.SetValue(Spinnaker::TriggerActivationEnums::TriggerActivation_RisingEdge);
```

```Spinnaker C++ GenAPI
CEnumerationPtr triggerMode = nodeMap.GetNode("TriggerMode");
triggerMode->SetIntValue(triggerMode->GetEntryByName("On")->GetValue());
CEnumerationPtr triggerSource = nodeMap.GetNode("TriggerSource");
triggerSource->SetIntValue(triggerSource->GetEntryByName("Line0")->GetValue());
CEnumerationPtr triggerSelector = nodeMap.GetNode("TriggerSelector");
triggerSelector->SetIntValue(triggerSelector->GetEntryByName("FrameStart")->GetValue());
CEnumerationPtr triggerActivation = nodeMap.GetNode("TriggerActivation");
triggerActivation->SetIntValue(triggerActivation->GetEntryByName("RisingEdge")->GetValue());
```

--------------------------------

### Enumerate Connected Cameras using Spinnaker C++ GenAPI

Source: https://softwareservices.flir.com/spinnaker/latest/_programmer_guide.html/_programmer_guide

This C++ snippet demonstrates how to detect and enumerate connected cameras using the Spinnaker GenAPI. It obtains a system instance, retrieves the list of cameras, determines the number of cameras, and then iterates through the list to initialize each camera.

```C++
SystemPtr system = System::GetInstance(); CameraList camList = system->GetCameras(); unsigned int numCameras = camList.GetSize(); CameraPtr pCam = NULL; for (int i = 0; i < numCameras; i++) {
		pCam = camList.GetByIndex(i);
			pCam->Init();
}
```

--------------------------------

### Spinnaker C++: Loading and Saving Raw Images

Source: https://softwareservices.flir.com/spinnaker/latest/_programmer_guide.html/_programmer_guide

Demonstrates the process of loading and saving raw image files (.raw) from disk using the Spinnaker Image class's smart pointer. This snippet outlines the steps for buffer allocation, image creation, disk loading, format conversion, and saving.

```C++
int offlineImageWidth = 1280;  // Allocate buffer for image
// Create empty image
FILE* inFile;  // Load image from disk into buffer (offlineData)
// Convert image to mono8 data format
// Save image
```

--------------------------------

### Implement Spinnaker C++ Interface Event Handler

Source: https://softwareservices.flir.com/spinnaker/latest/_programmer_guide.html/_programmer_guide

This snippet defines a C++ class InterfaceEventHandlerImpl that inherits from InterfaceEventHandler to handle interface-level events. It demonstrates how to implement OnDeviceArrival and OnDeviceRemoval methods to respond to camera connection and disconnection events.

```C++
class InterfaceEventHandlerImpl : public InterfaceEventHandler
public :
void OnDeviceArrival(CameraPtr pCamera)
std::cout<< "A Camera Arrived" << std::endl;
};
void OnDeviceRemoval(CameraPtr pCamera)
std::cout<< "A Camera was removed with serial number: " <<
};
};
InterfaceEventHandlerImpl handler;
```

--------------------------------

### Spinnaker C++ ImagePtr Smart Pointer Correct Creation

Source: https://softwareservices.flir.com/spinnaker/latest/_programmer_guide.html/_programmer_guide

This snippet provides the correct method for creating and assigning an ImagePtr in Spinnaker C++. It shows that ImagePtr should be assigned from a static Image::Create method, ensuring proper initialization before use.

```C++
// Correct usage
ImagePtr goodImage;
goodImage = Image::Create(...);
```

--------------------------------

### Display Camera Selection Window using C# GUI API

Source: https://softwareservices.flir.com/spinnaker/latest/_programmer_guide.html/_programmer_guide

This C# snippet shows how to open the camera selection window using Spinnaker's GUIFactory. It initializes the GUIFactory, connects it to the camera, retrieves the camera selection window, and then displays it as a modal dialog, allowing the user to select a camera.

```C#
GUIFactory AcquisitionGUI = newGUIFactory ();
AcquisitionGUI.ConnectGUILibrary(cam);
CameraSelectionWindow camSelection = AcquisitionGUI.GetCameraSelectionWindow();
camSelection.ShowModal(true);
```

--------------------------------

### Set Black Level (Brightness) in Spinnaker C++

Source: https://softwareservices.flir.com/spinnaker/latest/_programmer_guide.html/_programmer_guide

This example demonstrates how to set the BlackLevel, a GenICam feature representing the DC offset applied to the video signal. It illustrates the mechanism for adjusting this feature in both Spinnaker C++ QuickSpin API and GenAPI environments. Setting the black level helps in controlling the overall brightness and contrast of the image.

```Spinnaker C++ QuickSpin API
// Brightness is called black level in GenICam pCam->BlackLevelSelector.SetValue(Spinnaker::BlackLevelSelectorEnums::BlackLevelSelector_All);
//Set the absolute value of brightness to 1.5%. pCam->BlackLevel.SetValue(1.5);
```

```Spinnaker C++ GenAPI
CEnumerationPtr blackLevelSelector = nodeMap.GetNode("BlackLevelSelector");
CFloatPtr blackLevel = nodeMap.GetNode("BlackLevel");
```

--------------------------------

### Inquire Camera Gain using C++ QuickSpin API

Source: https://softwareservices.flir.com/spinnaker/latest/_programmer_guide.html/_programmer_guide

This snippet shows a more concise way to retrieve the camera gain value using the QuickSpin API in C++. QuickSpin simplifies access to common camera parameters, requiring fewer lines of code and supporting auto-completion.

```C++
float quickGainVal = cam->Gain.GetValue();
```

--------------------------------

### Set Camera Exposure Time in Spinnaker C++

Source: https://softwareservices.flir.com/spinnaker/latest/_programmer_guide.html/_programmer_guide

This example demonstrates how to manually set the camera's exposure time, which controls how long the electronic shutter remains open. It first disables auto exposure and sets the exposure mode to 'Timed'. Finally, it sets the absolute shutter exposure time to 20,000 microseconds (20 milliseconds) using both Spinnaker C++ QuickSpin API and GenAPI.

```Spinnaker C++ QuickSpin API
// Turn off auto exposure cam->ExposureAuto.SetValue(Spinnaker::ExposureAutoEnums::ExposureAuto_Off);
//Set exposure mode to "Timed" cam->ExposureMode.SetValue(Spinnaker::ExposureModeEnums::ExposureMode_Timed);
//Set absolute value of shutter exposure time to 20000 microseconds cam->ExposureTime.SetValue(20000);
```

```Spinnaker C++ GenAPI
CEnumerationPtr exposureAuto = nodeMap.GetNode("ExposureAuto"); exposureAuto->SetIntValue(exposureAuto->GetEntryByName("Off")->GetValue());
CEnumerationPtr exposureMode = nodeMap.GetNode("ExposureMode"); exposureMode->SetIntValue(exposureMode->GetEntryByName("Timed")->GetValue());
CFloatPtr exposureTime = nodeMap.GetNode("ExposureTime");
exposureTime->SetValue(20000);
```

--------------------------------

### Acquire Images with Spinnaker C++

Source: https://softwareservices.flir.com/spinnaker/latest/_programmer_guide.html/_programmer_guide

This snippet demonstrates how to acquire images using the GetNextImage() function in Spinnaker C++. It highlights the use of ImagePtr, a smart pointer, and the importance of releasing the image pointer when no longer needed, although smart pointers handle this automatically when out of scope or set to null.

```C++
// Begin acquiring images
ImagePtr pResultImage = cam->GetNextImage();
pResultImage->Release();
```

--------------------------------

### Spinnaker C++: Retrieving Camera Chunk Data

Source: https://softwareservices.flir.com/spinnaker/latest/_programmer_guide.html/_programmer_guide

Shows how to retrieve chunk data, specifically the exposure time, from an acquired raw image. This snippet accesses the ChunkData object from the image and extracts the desired information.

```C++
const ChunkData& chunkData = rawImage->GetChunkData();
float64_t currentExposure = chunkData.GetExposureTime();
```

--------------------------------

### Configure Spinnaker Image Buffers in C++

Source: https://softwareservices.flir.com/spinnaker/latest/_programmer_guide.html/_programmer_guide

This code snippet shows how to adjust the number of image buffers initialized by the Spinnaker driver. It accesses the TLStreamNodeMap to modify stream properties, allowing for custom buffer configurations beyond the default.

```C++
Spinnaker::GenApi::INodeMap & sNodeMap = cam->GetTLStreamNodeMap();
```

--------------------------------

### Access Dynamic GUI Control by Name using C#

Source: https://softwareservices.flir.com/spinnaker/latest/_programmer_guide.html/_programmer_guide

This C# snippet demonstrates how to access a dynamic GUI dialog by its name. It initializes the GUIFactory, connects it to the camera, retrieves a dialog using GetDialogByName, sets its owner, and then displays it. Dialog names can be retrieved via GetDialogNameList().

```C#
GUIFactory dynamicGUI = new GUIFactory ();
dynamicGUI.ConnectGUILibrary(cam);
// Get dialog name via dynamicGUI.GetDialogNameList()
Window dlg = dynamicGUI.GetDialogByName(dialogName);
dlg.Owner = Window .GetWindow(this );
dlg.Show();
```

--------------------------------

### Implement Spinnaker C++ Device Event Handler

Source: https://softwareservices.flir.com/spinnaker/latest/_programmer_guide.html/_programmer_guide

This snippet illustrates how to create a device event handler in C++ for Spinnaker. It shows the structure for handling specific device events, such as 'Exposure End', by implementing the OnDeviceEvent function which is called upon event detection.

```C++
// Select the Exposure End event
// Turn on the Event notification for Exposure End Event
// Once Exposure End Event is detected, the OnDeviceEvent function will be called
public :
void OnDeviceEvent(Spinnaker::GenICam::gcstring eventName)
std::cout << "Got Device Event with " << eventName << " and ID=" << GetDeviceEventId() << std::endl;
}
};
// Register event handler
```

--------------------------------

### Spinnaker C++ ImagePtr Smart Pointer Usage

Source: https://softwareservices.flir.com/spinnaker/latest/_programmer_guide.html/_programmer_guide

This snippet demonstrates the correct usage of ImagePtr, a smart pointer in Spinnaker C++. It shows how to assign an image pointer by retrieving the next image and how multiple pointers can refer to the same image object, with automatic memory management.

```C++
ImagePtr pResultImage;
// Retrieve the next received image
pResultImage = cam->GetNextImage();
ImagePtr duplicateImagePtr = pResultImage;
```

--------------------------------

### Adjust Camera Gamma in Spinnaker C++

Source: https://softwareservices.flir.com/spinnaker/latest/_programmer_guide.html/_programmer_guide

This code snippet demonstrates how to adjust the camera's gamma correction. It sets the absolute gamma value to 1.5. Gamma correction modifies the brightness of mid-tones in an image, affecting its overall perceived lightness and contrast.

```Spinnaker C++ QuickSpin API
// Set the absolute value of gamma to 1.5
cam.Gamma.SetValue(1.5);
```

```Spinnaker C++ GenAPI
CFloatPtr gamma = nodeMap.GetNode("Gamma"); gamma->SetValue(1.5);
```

--------------------------------

### Spinnaker C++ ImagePtr Smart Pointer Incorrect Usage

Source: https://softwareservices.flir.com/spinnaker/latest/_programmer_guide.html/_programmer_guide

This snippet illustrates an incorrect way to use the ImagePtr smart pointer in Spinnaker C++. It highlights that ImagePtr should always be assigned a valid image object before attempting to call methods like Create directly on an uninitialized pointer.

```C++
// Incorrect usage
ImagePtr illegalImage; illegalImgae->Create( ... );
```

--------------------------------

### Check Spinnaker Image Grab Status in C++

Source: https://softwareservices.flir.com/spinnaker/latest/_programmer_guide.html/_programmer_guide

This snippet shows how to check the status of a grabbed image using getImageStatus() in Spinnaker C++. It is crucial for error handling to ensure the acquired image is valid and free of issues like CRC failures or missing packets.

```C++
ImageStatus imageStatus = pResultImage->GetImageStatus();
```

--------------------------------

### Spinnaker C++ ImageStatus Enum Reference

Source: https://softwareservices.flir.com/spinnaker/latest/_programmer_guide.html/_programmer_guide

This section provides the API definition for the ImageStatus enumeration in Spinnaker C++. It lists various possible statuses for images returned from GetNextImage(), including success and different error conditions like CRC failures, insufficient size, or missing packets.

```APIDOC
/** Status of images returned from GetNextImage() call. */
enum ImageStatus {
	IMAGE_NO_ERROR = 0, /**< Image is returned from GetNextImage() call without any errors. */
	IMAGE_CRC_CHECK_FAILED, /**< Image failed CRC check. */
	IMAGE_INSUFFICIENT_SIZE, /**< Image size is smaller than expected. */
	IMAGE_MISSING_PACKETS, /**< Image has missing packets */
	IMAGE_LEADER_BUFFER_SIZE_INCONSISTENT, /**< Image leader is incomplete. */
	IMAGE_TRAILER_BUFFER_SIZE_INCONSISTENT, /**< Image trailer is incomplete. */
	IMAGE_PACKETID_INCONSISTENT, /**< Image has an inconsistent packet id. */
	IMAGE_DATA_INCOMPLETE, /**< Image data is incomplete. */
	IMAGE_UNKNOWN_ERROR /**< Image has an unknown error. */
};
```

--------------------------------

### Access Raw Bayer Image Data with Spinnaker C++

Source: https://softwareservices.flir.com/spinnaker/latest/_programmer_guide.html/_programmer_guide

This snippet demonstrates how to access raw Bayer image data using the getData method of the Spinnaker Image class in C++. It explains the byte order for 8-bit per pixel modes like BayerRG8, where the first byte corresponds to [row 0, column 0].

```C++
// Assuming image is 640 x 480 resolution. The current pixel format as well as PixelColorFilter indicate the Bayer Tile Mapping for the camera. For example, BayerRG8 is RGGB.  ImagePtr pResultImage = cam.GetNextImage(); char* data = (char*)pResultImage->GetData();  // Assuming image is 640 x 480  // data[0] = Row 0, Column 0 = red pixel (R)
// data[1] = Row 0, Column 1 = green pixel (G)
// data[640] = Row 1, Column 0 = green pixel (G)
// data[641] = Row 1, Column 1 = blue pixel (B)
```

--------------------------------

### Adjust Camera Gain in Spinnaker C++

Source: https://softwareservices.flir.com/spinnaker/latest/_programmer_guide.html/_programmer_guide

This code snippet demonstrates how to manually adjust the camera's gain. It first disables auto gain and then sets the absolute gain value to 10.5 dB. Adjusting gain can increase the brightness of an image, especially in low-light conditions, but may also introduce noise.

```Spinnaker C++ QuickSpin API
//Turn auto gain off
cam->GainAuto.SetValue(Spinnaker::GainAutoEnums::GainAuto_Off);
//Set gain to 10.5 dB
cam->Gain.SetValue(10.5);
```

```Spinnaker C++ GenAPI
CEnumerationPtr gainAuto = nodeMap.GetNode("GainAuto"); gainAuto->SetIntValue(gainAuto->GetEntryByName("Off")->GetValue());
CFloatPtr gainValue = nodeMap.GetNode("Gain"); gainValue->SetValue(10.5);
```

--------------------------------

### Adjust Camera White Balance in Spinnaker C++

Source: https://softwareservices.flir.com/spinnaker/latest/_programmer_guide.html/_programmer_guide

This code snippet demonstrates how to manually adjust the camera's white balance for specific color channels. It first disables auto white balance and then sets the balance ratios for both the blue and red channels to 2. Manual white balance adjustment is essential for accurate color reproduction under varying lighting conditions.

```Spinnaker C++ QuickSpin API
//Set auto white balance to off
cam->BalanceWhiteAuto.SetValue(Spinnaker::BalanceWhiteAutoEnums::BalanceWhiteAuto_Off);
//Select blue channel balance ratio
cam->BalanceRatioSelector.SetValue(Spinnaker::BalanceRatioSelectorEnums::BalanceRatioSelector_Blue);
//Set the white balance blue channel to 2
CFloatPtr BalanceRatio = nodeMap.GetNode("BalanceRatio"); BalanceRatio->SetValue(2);
//Set the white balance red channel to 2
cam->BalanceRatioSelector.SetValue(Spinnaker::BalanceRatioSelectorEnums::BalanceRatioSelector_Red); BalanceRatio->SetValue(2);
```

```Spinnaker C++ GenAPI
CEnumerationPtr balanceWhiteAuto = nodeMap.GetNode("BalanceWhiteAuto"); balanceWhiteAuto->SetIntValue(balanceWhiteAuto->GetEntryByName("Off")->GetValue());
CEnumerationPtr balanceRatioSelector = nodeMap.GetNode("BalanceRatioSelector"); balanceRatioSelector->SetIntValue(balanceRatioSelector->GetEntryByName("Blue")->GetValue());
CFloatPtr balanceRatio = nodeMap.GetNode("BalanceRatio"); balanceRatio->SetValue(2);
balanceRatioSelector->SetIntValue(balanceRatioSelector->GetEntryByName("Red")->GetValue()); balanceRatio->SetValue(2);
```
Tokens:
Raw