Transitioning from FlyCapture2 to Spinnaker SDK

GenApi::INodeMap & nodeMap = cam.GetNodeMap();

CIntegerPtr width = nodeMap.GetNode("Width");

width->SetValue(new_width_val);

NodeMap map = cam.GetNodeMap();
IInteger width = map.GetNode<IInteger>("Width");
width.Value = 320;

spinCameraGetNodeMap(hCam,&hNodeMap); //spinCamera hCam

spinNodeHandle hNode;
int64_t value = 0;
error = spinNodeMapGetNode(hNodeMap,"Width",&hNode);
error = spinIntegerSetValue(hNode, 320);

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

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

INodeMap map = cam.GetNodeMap();
IFloat GainNode = map.GetNode<IFloat>( "Gain");

doublequickGainVal = cam.Gain.Value;

error = spinNodeMapGetNode(hNodeMap,"Gain",&hNode);
error = spinIntegerGetValue(hNode,&value);

class InterfaceEventsHandler : public InterfaceEvent
{

public :
InterfaceEventsHandler(){};
virtual ~InterfaceEventsHandler(){};

void OnDeviceArrival()
{

std::cout<< "A Camera Arrived" << std::endl;

};

void OnDeviceRemoval( uint64_tdeviceSerialNumber )
{

std::cout<< "A Camera was removed with serial number: " <<
deviceSerialNumber << std::endl;

};

};

InterfaceEventsHandler handler;
cam->RegisterEvent(handler);

class InterfaceEventListener : ManagedInterfaceEvent
{

protectedoverridevoid OnDeviceArrival()
{

Console .Out.WriteLine( "A new device has arrived!" );

}

protected override void OnDeviceRemoval( UInt64 serialNumber)
{

Console.Out.WriteLine( "A device with serial number {0} has been removed!" ,
serialNumber);

}

}

>Interface event (arrival and removal) handling for C is registered by using the below functions:

spinArrivalEventCreate()

spinRemovalEventCreate()

A detailed example for C interface event is included in Spinnaker source code example: EnumerationEvent_C.cpp

// Select the Exposure End event
Spinnaker::GenApi:: CEnumerationPtr pEnum = nodeMap .GetNode( "EventSelector" );
pEnum->SetIntValue(pEnum->GetEntryByName( "EventExposureEnd" )->GetValue());

// Turn on the Event notification for Exposure End Event
Spinnaker::GenApi:: CEnumerationPtr pBool = nodeMap .GetNode( "EventNotification" );
pBool->SetIntValue(1);

// Once Exposure End Event is detected, the OnDeviceEvent function will be called
classDeviceEventHandler : publicDeviceEvent
{

public :
DeviceEventHandler(){};
~DeviceEventHandler(){};

void OnDeviceEvent( GenICam::gcstring eventNameeventId )
{

std::cout << "Got Device Event with " << eventName << " and ID=" << GetDeviceEventId() << std::endl;

}

};

// Register event handler
DeviceEventHandler allDeviceEventHandler;
cam->RegisterEvent(allDeviceEventHandler);

// Set EventSelector to ExposureEnd
cam.EventSelector.Value = EventSelectorEnums .EventExposureEnd.ToString();

// Set EventNotification to true
cam.EventNotification.Value = EventNotificationEnums .On.ToString();

// After registering the below device event on the camera, OnDeviceEvent will be automatically called once ExposureEnd event is detected
classManagedDeviceEventHandler : ManagedDeviceEvent
{

protected override voidOnDeviceEvent( string eventName)
{

Console .Out.WriteLine( "Got Device Event with Name=" + eventName + " and ID= {0}" , GetDeviceEventId());

}

}

// Create and register ExposureEvent

spinEvent eventExposureEnd = NULL;

error = spinEventCreate(&eventExposureEnd, onSpecificDeviceEvent, NULL);

error = spinCameraRegisterEvent(hCam, eventExposureEnd, "EventExposureEnd");

// Create a function to occur upon specific event occurrences;
//ensure exact same function signature is used

void onSpecificDeviceEvent(const char* pEventName, void* pUserData)
{
    printf("\t// Specific device event %s...\n", pEventName, (char*)pUserData);
}

Cam->ChunkSelector
ChunkSelector.SetValue(ChunkSelectorEnums ::ChunkSelector_ExposureTime) ;

Cam->ChunkEnable.SetValue(true);

Cam->ChunkModeActive.SetValue(true);

const ChunkData& chunkData = rawImage->GetChunkData();

float64_t currentExposure = chunkData.GetExposureTime();

cam.ChunkSelector.Value = ChunkSelectorEnums.ExposureTime.ToString();

cam.ChunkEnable.Value = true;

cam.ChunkModeActive.Value = true;

String currentExposure = rawImage.ChunkData.ExposureTime.ToString();

Static GUI Dialogs

//To show image drawing window

GUIFactory AcquisitionGUI = new GUIFactory ();

AcquisitionGUI.ConnectGUILibrary(cam);

ImageDrawingWindow AcquisitionDrawing = AcquisitionGUI.GetImageDrawingWindow();

AcquisitionDrawing.Connect(cam);

AcquisitionDrawing.Start();

AcquisitionDrawing.ShowModal();

//To show camera selection window

GUIFactory AcquisitionGUI = newGUIFactory ();

AcquisitionGUI.ConnectGUILibrary(cam);

CameraSelectionWindow camSelection = AcquisitionGUI.GetCameraSelectionWindow();

camSelection.ShowModal(true);

//To show property grid window

GUIFactory AcquisitionGUI = new GUIFactory ();

AcquisitionGUI.ConnectGUILibrary(cam);

PropertyGridWindow propWindow = AcquisitionGUI.GetPropertyGridWindow();

propWindow.Connect(cam);

propWindow.ShowModal();

Dynamic GUI Control

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();

IIDC register read and write

Source Code Example:
AsyncTriggerEx

GenICam node map get/set values

Source Code Example:
Acquisition

Embedded image info

Source Code Example:
MultipleCameraWriteToDiskEx

Chunk data

Source Code Example:
ChunkData

ImageEvents

Source Code Example:
ImageEventEx

GenICam message or event channel

Source Code Example:
DeviceEvents

FC2Config struct such as grab mode and num_buffer

Source Code Example:
RecordingDialog

Stream Node map

Source Code Example:
NodeMapInfo

Error return code

Source Code Example:
FlyCapture2Test

Exceptions

Source Code Example:
Acquisition

Format7 packet size to control bandwidth

Source Code Example:
GigEGrabEx

Imaging mode (i.e., Format7 mode 1)

Source Code Example:
CustomImageEx

Events callback

Source Code Example:
BusEventEx_CSharp

Register event class with overloaded functions

Source Code Example:
EnumerationEvents

GUID to identify and track cameras

Source Code Example:
FlyCapture2Test

Unique camera class

Source Code Example:
Acquisition

BusManager busMgr;
unsigned int numCameras;
Camera camera;
busMgr.GetNumOfCameras(&numCameras);
PGRGuid guid;
for ( unsigned int i = 0; i < numCameras; i++)
{
    busMgr.GetCameraFromIndex( i, &guid );
    camera.Connect(i);
}

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

TriggerMode mTrigger;

mTrigger.mode = 0;
mTrigger.source = 0;
mTrigger.parameter = 0;
mTrigger.onOff = true;
mTrigger.polarity = 1;

cam.SetTriggerMode(&mTrigger);

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

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());

//Declare a Property struct.
Property prop;

//Define the property to adjust.
prop.type = BRIGHTNESS;

//Ensure the property is set up to use absolute value control.
prop.absControl = true;

//Set the absolute value of brightness to 1.5%.
prop.absValue = 1.5;

//Set the property.
error = cam.SetProperty ( &prop );

// 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);

CEnumerationPtr blackLevelSelector = nodeMap.GetNode("BlackLevelSelector");
blackLevelSelector->SetValue(SetIntValue(blackLevelSelector->GetEntryByName("True")->GetValue());

CFloatPtr blackLevel = nodeMap.GetNode("BlackLevel");
blackLevel->SetValue(1.5);

//Declare a Property struct.
Property prop;

//Define the property to adjust.
prop.type = SHUTTER;

//Ensure the property is on.
prop.onOff = true;

//Ensure auto-adjust mode is off.
prop.autoManualMode = false;

//Ensure the property is set up to use absolute value control.
prop.absControl = true;

//Set the absolute value of shutter to 20 ms.
prop.absValue = 20;

//Set the property.
error = cam.SetProperty( &prop );

// 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);

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

//Declare a Property struct.
Property prop;

//Define the property to adjust.
prop.type = GAIN;

//Ensure auto-adjust mode is off.
prop.autoManualMode = false;

//Ensure the property is set up to use absolute value control.
prop.absControl = true;

//Set the absolute value of gain to 10.5 dB.
prop.absValue = 10.5;

//Set the property.
error = cam.SetProperty( &prop );

//Turn auto gain off
cam->GainAuto.SetValue(Spinnaker::GainAutoEnums::GainAuto_Off);

//Set gain to 10.5 dB
cam->Gain.SetValue(10.5);

CEnumerationPtr gainAuto = nodeMap.GetNode("GainAuto");
gainAuto->SetIntValue(gainAuto->GetEntryByName("Off")->GetValue());

CFloatPtr gainValue = nodeMap.GetNode("Gain");
gainValue->SetValue(10.5);

//Declare a Property struct.
Property prop;

//Define the property to adjust.
prop.type = GAMMA;

//Ensure the property is on.
prop.onOff = true;

//Ensure the property is set up to use absolute value control.
prop.absControl = true;

//Set the absolute value of gamma to 1.5.
prop.absValue = 1.5;

//Set the property.
error = cam.SetProperty( &prop );

// Set the absolute value of gamma to 1.5
cam.Gamma.SetValue(1.5);

CFloatPtr gamma = nodeMap.GetNode("Gamma");
gamma->SetValue(1.5);

//Declare a Property struct.
Property prop;

//Define the property to adjust.
prop.type = WHITE_BALANCE;

//Ensure the property is on.
prop.onOff = true;

//Ensure auto-adjust mode is off.
prop.autoManualMode = false;

//Set the white balance red channel to 500.
prop.valueA = 500;

//Set the white balance blue channel to 850.
prop.valueB = 850;

//Set the property.
error = cam.SetProperty( &prop );

//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);

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

// Read the BAYER_TILE_MAPPING register 0x1040 to determine the current Bayer output format (RGGB, GRBG, and so on). Using a Bayer format of RGGB, for example, the getData method returns the following (assuming char* data = rawImage.GetData(); and an Image object rawImage):

// 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)

// 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();

// 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)

FC2Config BufferFrame;

Camera** ppCameras = newCamera*[numCameras];

ppCameras[0]->GetConfiguration(&BufferFrame);

BufferFrame.numBuffers = 11;

ppCameras[0]->SetConfiguration(&BufferFrame);

Spinnaker::GenApi::INodeMap & sNodeMap = cam->GetStreamNodeMap();
CEnumerationPtr ptrStreamBufferCountMode = sNodeMap.GetNode("StreamBufferCountMode");
CEnumEntryPtr ptrStreamBufferCountModeManual = ptrStreamBufferCountMode->GetEntryByName("Manual");
ptrStreamBufferCountMode->SetIntValue(ptrStreamBufferCountModeManual->GetValue());
CIntegerPtr StreamNode = sNodeMap.GetNode("StreamBufferCountManual");
StreamNode->SetValue(11);

ManagedBusManager busMgr = new ManagedBusManager();
uint numCameras = busMgr.GetNumOfCameras();
for (uint i = 0; i < numOfCameras; i++)
{
    ManagedPGRGuid guid = busMgr.GetCameraFromIndex(i);
      cameras[i].Connect(guid);
}

IList<IManagedCamera> camList = system.GetCameras();
foreach (IManagedCamera managedCamera in camList)
   using (managedCamera)
    {
        managedCamera.Init();
    }

// Get current trigger settings
TriggerMode triggerMode = cam.GetTriggerMode();

// Set camera to trigger mode 0
// A source of 7 means software trigger
triggerMode.onOff = true;
triggerMode.mode = 0;
triggerMode.parameter = 0;

// Set the trigger mode
cam.SetTriggerMode(triggerMode);

cam.TriggerMode.Value = TriggerModeEnums.On.ToString();
cam.TriggerSource.Value = TriggerSourceEnums.Line0.ToString();
cam.TriggerSelector.Value = TriggerSelectorEnums.FrameStart.ToString();
cam.TriggerActivation.Value = TriggerActivationEnums.RisingEdge.ToString();

IEnum triggerMode = nodeMap.GetNode<IEnum>("TriggerMode");
triggerMode.Value = "On";

IEnum triggerSource = nodeMap.GetNode<IEnum>("TriggerSource");
triggerSource.Value = "Line0";

IEnum triggerSelector = nodeMap.GetNode<IEnum>("TriggerSelector");
triggerSelector.Value = "FrameStart";

IEnum triggerActivation = nodeMap.GetNode<IEnum>("TriggerActivation");
triggerActivation.Value = "RisingEdge";

//Declare a Property struct.
CameraProperty prop = newCameraProperty();
prop.type = PropertyType.Brightness;
prop.absControl = true;
prop.absValue = 2;

// Assuming cam is a managedCamera that has been initialized
cam.SetProperty(prop);

// Black Level is also referred to as brightness
cam.BlackLevelSelector.Value = BlackLevelSelectorEnums.All.ToString();

// Set Black Level to an absolute value of 1.5%
cam.BlackLevel.Value = 1.5;

IEnum blackLevelSelector = nodeMap.GetNode<IEnum>("BlackLevelSelector");
blackLevelSelector.Value = "All";

IFloat blackLevel = nodeMap.GetNode<IFloat>("BlackLevel");
blackLevel.Value = 1.5;

//Declare a Property struct.
CameraProperty prop = new CameraProperty();
prop.type = PropertyType.Shutter;
prop.autoManualMode = false;
prop.absControl = true;
prop.absValue = 20;
prop.onOff = true;

// Assuming cam is a managedCamera that has been initialized
cam.SetProperty(prop);

// Turn off auto exposure
cam.ExposureAuto.Value = ExposureAutoEnums.Off.ToString();

// Set exposure mode to "Timed"
cam.ExposureMode.Value = ExposureModeEnums.Timed.ToString();

// Set exposure to 20000 microseconds
cam.ExposureTime.Value = 20000;

IEnum exposureAuto = nodeMap.GetNode<IEnum>("ExposureAuto");
exposureAuto.Value = "Off";

IEnum exposureMode = nodeMap.GetNode<IEnum>("ExposureMode");
exposureMode.Value = "Timed";

IFloat exposureTime = nodeMap.GetNode<IFloat>("ExposureTime");
exposureTime.Value = 20000;

//Declare a Property struct.
CameraProperty prop = new CameraProperty();
prop.type = PropertyType.Gain;
prop.autoManualMode = false;
prop.absControl = true;
prop.absValue = 10;
prop.onOff = true;

// Assuming cam is a managedCamera that has been initialized
cam.SetProperty(prop);

//Turn auto gain off
cam.GainAuto.Value = GainAutoEnums.Off.ToString();

//Set gain to 10.5 dB
cam.Gain.Value = 10.5;

IEnum gainAuto = nodeMap.GetNode<IEnum>("GainAuto");
gainAuto.Value = "Off";

IFloat gainValue = nodeMap.GetNode<IFloat>("Gain");
gainValue.Value = 10.5;

//Declare a Property struct.
CameraProperty prop = new CameraProperty();
prop.type = PropertyType.Gamma;
prop.autoManualMode = false;
prop.absControl = true;
prop.absValue = 2;
prop.onOff = true;

// Assuming cam is a managedCamera that has been initialized
cam.SetProperty(prop);

// Set the absolute value of gamma to 1.5
cam.Gamma.Value = 1.5;

IFloat gamma = nodeMap.GetNode<IFloat>("Gamma");
gamma.Value = 1.5;

//Declare a Property struct.
CameraProperty prop = new CameraProperty();
prop.type = PropertyType.WhiteBalance;
prop.autoManualMode = false;
prop.absControl = false;
prop.valueA = 500;
prop.onOff = true;

// Assuming cam is a managedCamera that has been initialized
cam.SetProperty(prop);

// Get current trigger settings
TriggerMode triggerMode = cam.GetTriggerMode();

// Set auto white balance to off
cam.BalanceWhiteAuto.Value = BalanceWhiteAutoEnums.Off.ToString();

// Select blue channel balance ratio
cam.BalanceRatioSelector.Value = BalanceRatioSelectorEnums.Blue.ToString();

// Set the white balance blue channel to 2
cam.BalanceRatio.Value = 2;

IEnum balanceWhiteAuto = nodeMap.GetNode<IEnum>("BalanceWhiteAuto");
balanceWhiteAuto.Value = "Off";

IEnum balanceRatioSelector = nodeMap.GetNode<IEnum>("BalanceRatioSelector");
balanceRatioSelector.Value = "Blue";

IFloat balanceRatio = nodeMap.GetNode<IFloat>("BalanceRatio");
balanceRatio.Value = 2;

// Read the BAYER_TILE_MAPPING register 0x1040 to determine the current Bayer output format (RGGB, GRBG, and so on). Using a Bayer format of RGGB, for example, the getData method returns the following (assuming byte* data = rawImage.data; and an Image object data):

// Assuming image is 640 x 480
data = 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)

Unsafe
{
    byte* data = rawImage.data;

    // Assuming image is 640 x 480 resolution with bayer tile RGGB
    // data represents row 0 column 0, red pixel (R)
    // data + 1 represents row 0 column 1, green pixel (G)
    // data + 640 represents row 1 column 0, green pixel (G)
    // data + 641 represents row 1 column 1, blue pixel (G)
}

FC2Config bufferSetting;
bufferSetting = cam.GetConfiguration();
bufferSetting.numBuffers = 11;
cam.SetConfiguration(bufferSetting);

INodeMap sNodeMap = cam.GetTLStreamNodeMap();
IInteger streamNode = sNodeMap.GetNode<IInteger>("StreamBufferCountManual");
long bufferCount = streamNode.Value;
streamNode.Value = 11;

fc2PGRGuid guid;
fc2GetNumOfCameras( context, &numCameras );
for (i = 0; i < numCameras; i++)
{
    fc2GetCameraFromIndex( context, i, &guid );
    fc2Connect( context, &guid );
}

spinCamera hCamera = NULL;
spinCameraListGetSize(hCameraList, &numCameras);
for (i = 0; i < numCameras; i++)
{
    spinCameraListGet(hCameraList, i, &hCamera);
    spinCameraInit(hCam);
}

fc2TriggerMode mTrigger;

mTrigger.mode = 0;
mTrigger.source = 0;
mTrigger.parameter = 0;
mTrigger.onOff = true;
mTrigger.polarity = 1;

fc2SetTriggerMode( context, & mTrigger);

spinNodeHandle hTriggerMode = NULL;
spinNodeHandle hTriggerModeOn = NULL;
int64_t triggerModeOn = 0;

err = spinNodeMapGetNode(hNodeMap, "TriggerMode", &hTriggerMode);
err = spinEnumerationGetEntryByName(hTriggerMode, "On", &hTriggerModeOn);
err = spinEnumerationEntryGetValue(hTriggerModeOn, &triggerModeOn);
err = spinEnumerationSetIntValue(hTriggerMode, triggerModeOn);

spinNodeHandle hTriggerSource = NULL;
spinNodeHandle hTriggerSourceChoice = NULL;
int64_t triggerSourceChoice = 0;

err = spinNodeMapGetNode(hNodeMap, "TriggerSource", &hTriggerSource);
err = spinEnumerationGetEntryByName(hTriggerSource, "Line0", &hTriggerSourceChoice);
err = spinEnumerationEntryGetValue(hTriggerSourceChoice, &triggerSourceChoice);
err = spinEnumerationSetIntValue(hTriggerSource, triggerSourceChoice);

spinNodeHandle hTriggerSelector = NULL;
spinNodeHandle hTriggerSelectorChoice = NULL;
int64_t triggerSelectorChoice = 0;

err = spinNodeMapGetNode(hNodeMap, "TriggerSelector", &hTriggerSelector);
err = spinEnumerationGetEntryByName(hTriggerSource, "FrameStart", &hTriggerSelectorChoice);
err = spinEnumerationEntryGetValue(hTriggerSelectorChoice, &triggerSourceChoice);
err = spinEnumerationSetIntValue(hTriggerSelector, triggerSelectorChoice);

spinNodeHandle hTriggerActivation = NULL;
spinNodeHandle hTriggerActivationChoice = NULL;
int64_t triggerActivationChoice = 0;

err = spinNodeMapGetNode(hNodeMap, "TriggerActivation", &hTriggerActivation);
err = spinEnumerationGetEntryByName(hTriggerActivation, "RisingEdge", &hTriggerActivationChoice);
err = spinEnumerationEntryGetValue(hTriggerActivationChoice, &triggerSourceChoice);
err = spinEnumerationSetIntValue(hTriggerActivation, triggerActivationChoice);

//Declare a Property struct.
fc2Property, prop;

//Define the property to adjust.
prop.type = BRIGHTNESS;

//Ensure the property is set up to use absolute value control.
prop.absControl = true;

//Set the absolute value of brightness to 1.5%.
prop.absValue = 1.5;

//Set the property.
error = fc2SetProperty ( context, &prop );

// Black Level is also referred to as brightness
spinNodeHandle hBlackLevelSelector = NULL;
spinNodeHandle hBlackLevelSelectorChoice = NULL;
int64_t blackLevelSelectorChoice = 0;

err = spinNodeMapGetNode(hNodeMap, "BlackLevelSelector", &hBlackLevelSelector);
err = spinEnumerationGetEntryByName(hBlackLevelSelector, "All", &hBlackLevelSelectorChoice);
err = spinEnumerationEntryGetIntValue(hBlackLevelSelectorChoice, &blackLevelSelectorChoice);
err = spinEnumerationSetIntValue(hBlackLevelSelectorChoice, blackLevelSelectorChoice);

//Set the absolute value of brightness to 1.5%.
spinNodeHandle hBlackLevel;
err = spinNodeMapGetNode(hNodeMap, "BlackLevel", &hBlackLevel);
err = spinFloatSetValue(hBlackLevel, 1.5);

//Declare a Property struct.
fc2Property prop;

//Define the property to adjust.
prop.type = SHUTTER;

//Ensure the property is on.
prop.onOff = true;

//Ensure auto-adjust mode is off.
prop.autoManualMode = false;

//Ensure the property is set up to use absolute value control.
prop.absControl = true;

//Set the absolute value of shutter to 20 ms.
prop.absValue = 20;

//Set the property.
error = fc2.SetProperty( &prop );

// Turn off auto exposure
spinNodeHandle hExposureAutoSelector = NULL;
spinNodeHandle hExposureAutoSelectorChoice = NULL;
int64_t exposureAutoSelectorChoice = 0;

err = spinNodeMapGetNode(hNodeMap, "ExposureAuto", &hExposureAutoSelector);
err = spinEnumerationGetEntryByName(hExposureAutoSelector, "Off", &hExposureAutoSelectorChoice);
err = spinEnumerationEntryGetValue(hExposureAutoSelectorChoice, &exposureAutoSelectorChoice);
err = spinEnumerationSetIntValue(hExposureAutoSelectorChoice, exposureAutoSelectorChoice);

//Set exposure mode to "Timed"
spinNodeHandle hExposureModeSelector = NULL;
spinNodeHandle hExposureModeSelectorChoice = NULL;
int64_t exposureModeSelectorChoice = 0;

err = spinNodeMapGetNode(hNodeMap, "ExposureAuto", &hExposureModeSelector);
err = spinEnumerationGetEntryByName(hExposureModeSelector, "Timed", &hExposureModeSelectorChoice);
err = spinEnumerationEntryGetValue(hExposureModeSelectorChoice, &exposureModeSelectorChoice);
err = spinEnumerationSetIntValue(hExposureModeSelectorChoice, exposureModeSelectorChoice);

//Set absolute value of shutter exposure time to 20000 microseconds
spinNodeHandle hExposureTime;
err = spinNodeMapGetNode(hNodeMap, "ExposureTime", &hExposureTime);
err = spinIntegerSetValue(hExposureTime, 20000);

//Declare a Property struct.
fc2Property prop;

//Define the property to adjust.
prop.type = GAIN;

//Ensure auto-adjust mode is off.
prop.autoManualMode = false;

//Ensure the property is set up to use absolute value control.
prop.absControl = true;

//Set the absolute value of shutter to 20 ms.
prop.absValue = 10.5;

//Set the property.
error = fc2.SetProperty( &prop );

//Turn auto gain off
spinNodeHandle hGainAutoSelector = NULL;
spinNodeHandle hGainAutoSelectorChoice = NULL;
int64_t gainAutoSelectorChoice = 0;

err = spinNodeMapGetNode(hNodeMap, "GainAuto", &hGainAutoSelector);
err = spinEnumerationGetEntryByName(hGainAutoSelector, "Off", &hGainAutoSelectorChoice);
err = spinEnumerationEntryGetValue(hGainAutoSelectorChoice, &gainAutoSelectorChoice);
err = spinEnumerationSetIntValue(hGainAutoSelectorChoice, gainAutoSelectorChoice);

//Set gain to 10.5 dB
spinNodeHandle hGain;
err = spinNodeMapGetNode(hNodeMap, "Gain", &hGain);
err = spinIntegerSetValue(hGain, 10.5);

//Declare a Property struct.
fc2Property prop;

//Define the property to adjust.
prop.type = GAMMA;

//Ensure the property is on.
prop.onOff = true;

//Ensure the property is set up to use absolute value control.
prop.absControl = true;

//Set the absolute value of gamma to 1.5.
prop.absValue = 1.5;

//Set the property.
error = fc2.SetProperty( &prop );

// Enable Gamma
spinNodeHandle hGammaEnable = NULL;

err = spinNodeMapGetNode(hNodeMap, "GammaEnable", &hGammaEnable);
err = spinBooleanSetValue(hGammaEnable, false);

// Set the absolute value of gamma to 1.5
spinNodeHandle hGamma;
err = spinNodeMapGetNode(hNodeMap, "Gamma", &hGamma);
err = spinIntegerSetValue(hGamma, 1.5);

//Declare a Property struct.
fc2Property prop;

//Define the property to adjust.
prop.type = WHITE_BALANCE;

//Ensure the property is on.
prop.onOff = true;

//Ensure auto-adjust mode is off.
prop.autoManualMode = false;

//Set the white balance red channel to 500.
prop.valueA = 500;

//Set the white balance blue channel to 850.
prop.valueB = 850;

//Set the property.
error = fc2.SetProperty( &prop );

//Set auto white balance to off
spinNodeHandle hBalanceWhiteAutoSelector = NULL;
spinNodeHandle hBalanceWhiteAutoSelectorChoice = NULL;
int64_t balanceWhiteAutoSelector = 0;

err = spinNodeMapGetNode(hNodeMap, "BalanceWhiteAuto", &hBalanceWhiteAutoSelector);
err = spinEnumerationGetEntryByName(hBalanceWhiteAutoSelector, "Off", &hBalanceWhiteAutoSelectorChoice);
err = spinEnumerationEntryGetValue(hBalanceWhiteAutoSelectorChoice, &balanceWhiteAutoSelector);
err = spinEnumerationSetIntValue(hBalanceWhiteAutoSelectorChoice, balanceWhiteAutoSelector);

//Select blue channel balance ratio
spinNodeHandle hBalanceRatioSelector = NULL;
spinNodeHandle hBalanceRatioSelectorChoice = NULL;
int64_t balanceRatioSelector = 0;

err = spinNodeMapGetNode(hNodeMap, "BalanceRatioSelector", &hBalanceRatioSelector);
err = spinEnumerationGetEntryByName(hBalanceRatioSelector, "Blue", &hBalanceRatioSelectorChoice);
err = spinEnumerationEntryGetValue(hBalanceRatioSelectorChoice, &balanceRatioSelector);
err = spinEnumerationSetIntValue(hBalanceRatioSelectorChoice, balanceRatioSelector);

//Set the white balance blue channel to 2
spinNodeHandle hBlueRatio;
err = spinNodeMapGetNode(hNodeMap, "BalanceRatio", &hGain);
err = spinIntegerSetValue(hBlueRatio, 2);

//Set the white balance red channel to 2
err = spinNodeMapGetNode(hNodeMap, "BalanceRatioSelector", &hBalanceRatioSelector);
err = spinEnumerationGetEntryByName(hBalanceRatioSelector, "Red", &hBalanceRatioSelectorChoice);
err = spinEnumerationEntryGetValue(hBalanceRatioSelectorChoice, &balanceRatioSelector);
err = spinEnumerationSetIntValue(hBalanceRatioSelectorChoice, balanceRatioSelector);

spinNodeHandle hRedRatio;
err = spinNodeMapGetNode(hNodeMap, "BalanceRatio", &hRedRatio);
err = spinIntegerSetValue(hRedRatio, 2);

// Read the BAYER_TILE_MAPPING register 0x1040 to determine the current Bayer output format (RGGB, GRBG, and so on). Using a Bayer format of RGGB, for example, the fc2GetImageData method returns the following:

// 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)

// 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.

err = spinCameraGetNextImage(hCam, &hResultImage);
size_t imageSize;
spinImageGetBufferSize(hResultImage, &imageSize);

void **data;
data = (void**)malloc(imageSize * sizeof(void*));

spinImageGetData(hResultImage, data);

// 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)

FC2Config BufferFrame;
error = fc2GetConfiguration( context, &BufferFrame);
BufferFrame.numBuffers = 11;
error = fc2SetConfiguration( context, &BufferFrame);

spinNodeHandle hGenTLNode = NULL;
int64_t bufferValue;
err = spinNodeMapGetNode(hNodeMapGenTL, "StreamBufferCountManual", &hGenTLNode);
err = spinEnumerationEntryGetValue(hNodeMapGenTL, &bufferValue);
err = spinEnumerationSetIntValue(hNodeMapGenTL, 11);