Spinnaker_C (JavaCPP Presets for Spinnaker 3.0.0.118-1.5.9 API)

java.lang.Object
- org.bytedeco.spinnaker.presets.Spinnaker_C
- - org.bytedeco.spinnaker.global.Spinnaker_C

All Implemented Interfaces:: InfoMapper

public class Spinnaker_C
extends Spinnaker_C

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`Spinnaker_C.spinAccessMode`
`static class`	`Spinnaker_C.spinAcquisitionModeEnums`
`static class`	`Spinnaker_C.spinAcquisitionStatusSelectorEnums`
`static class`	`Spinnaker_C.spinActionCommandStatus` Possible Status Codes Returned from Action Command.
`static class`	`Spinnaker_C.spinActionUnconditionalModeEnums`
`static class`	`Spinnaker_C.spinAdcBitDepthEnums`
`static class`	`Spinnaker_C.spinAutoAlgorithmSelectorEnums`
`static class`	`Spinnaker_C.spinAutoExposureControlPriorityEnums`
`static class`	`Spinnaker_C.spinAutoExposureLightingModeEnums`
`static class`	`Spinnaker_C.spinAutoExposureMeteringModeEnums`
`static class`	`Spinnaker_C.spinAutoExposureTargetGreyValueAutoEnums`
`static class`	`Spinnaker_C.spinBalanceRatioSelectorEnums`
`static class`	`Spinnaker_C.spinBalanceWhiteAutoEnums`
`static class`	`Spinnaker_C.spinBalanceWhiteAutoProfileEnums`
`static class`	`Spinnaker_C.spinBinningHorizontalModeEnums`
`static class`	`Spinnaker_C.spinBinningSelectorEnums`
`static class`	`Spinnaker_C.spinBinningVerticalModeEnums`
`static class`	`Spinnaker_C.spinBlackLevelAutoBalanceEnums`
`static class`	`Spinnaker_C.spinBlackLevelAutoEnums`
`static class`	`Spinnaker_C.spinBlackLevelSelectorEnums`
`static class`	`Spinnaker_C.spinCachingMode`
`static class`	`Spinnaker_C.spinChunkBlackLevelSelectorEnums`
`static class`	`Spinnaker_C.spinChunkCounterSelectorEnums`
`static class`	`Spinnaker_C.spinChunkEncoderSelectorEnums`
`static class`	`Spinnaker_C.spinChunkEncoderStatusEnums`
`static class`	`Spinnaker_C.spinChunkExposureTimeSelectorEnums`
`static class`	`Spinnaker_C.spinChunkGainSelectorEnums`
`static class`	`Spinnaker_C.spinChunkImageComponentEnums`
`static class`	`Spinnaker_C.spinChunkPixelFormatEnums`
`static class`	`Spinnaker_C.spinChunkRegionIDEnums`
`static class`	`Spinnaker_C.spinChunkScan3dCoordinateReferenceSelectorEnums`
`static class`	`Spinnaker_C.spinChunkScan3dCoordinateSelectorEnums`
`static class`	`Spinnaker_C.spinChunkScan3dCoordinateSystemEnums`
`static class`	`Spinnaker_C.spinChunkScan3dCoordinateSystemReferenceEnums`
`static class`	`Spinnaker_C.spinChunkScan3dCoordinateTransformSelectorEnums`
`static class`	`Spinnaker_C.spinChunkScan3dDistanceUnitEnums`
`static class`	`Spinnaker_C.spinChunkScan3dOutputModeEnums`
`static class`	`Spinnaker_C.spinChunkSelectorEnums`
`static class`	`Spinnaker_C.spinChunkSourceIDEnums`
`static class`	`Spinnaker_C.spinChunkTimerSelectorEnums`
`static class`	`Spinnaker_C.spinChunkTransferStreamIDEnums`
`static class`	`Spinnaker_C.spinClConfigurationEnums`
`static class`	`Spinnaker_C.spinClTimeSlotsCountEnums`
`static class`	`Spinnaker_C.spinColorProcessingAlgorithm` Color processing algorithms.
`static class`	`Spinnaker_C.spinColorTransformationSelectorEnums`
`static class`	`Spinnaker_C.spinColorTransformationValueSelectorEnums`
`static class`	`Spinnaker_C.spinCompressionSaturationPriorityEnums`
`static class`	`Spinnaker_C.spinCounterEventActivationEnums`
`static class`	`Spinnaker_C.spinCounterEventSourceEnums`
`static class`	`Spinnaker_C.spinCounterResetActivationEnums`
`static class`	`Spinnaker_C.spinCounterResetSourceEnums`
`static class`	`Spinnaker_C.spinCounterSelectorEnums`
`static class`	`Spinnaker_C.spinCounterStatusEnums`
`static class`	`Spinnaker_C.spinCounterTriggerActivationEnums`
`static class`	`Spinnaker_C.spinCounterTriggerSourceEnums`
`static class`	`Spinnaker_C.spinCxpConnectionTestModeEnums`
`static class`	`Spinnaker_C.spinCxpLinkConfigurationEnums`
`static class`	`Spinnaker_C.spinCxpLinkConfigurationPreferredEnums`
`static class`	`Spinnaker_C.spinCxpLinkConfigurationStatusEnums`
`static class`	`Spinnaker_C.spinCxpPoCxpStatusEnums`
`static class`	`Spinnaker_C.spinDecimationHorizontalModeEnums`
`static class`	`Spinnaker_C.spinDecimationSelectorEnums`
`static class`	`Spinnaker_C.spinDecimationVerticalModeEnums`
`static class`	`Spinnaker_C.spinDefectCorrectionModeEnums`
`static class`	`Spinnaker_C.spinDeinterlacingEnums`
`static class`	`Spinnaker_C.spinDeviceCharacterSetEnums`
`static class`	`Spinnaker_C.spinDeviceClockSelectorEnums`
`static class`	`Spinnaker_C.spinDeviceConnectionStatusEnums`
`static class`	`Spinnaker_C.spinDeviceIndicatorModeEnums`
`static class`	`Spinnaker_C.spinDeviceLinkHeartbeatModeEnums`
`static class`	`Spinnaker_C.spinDeviceLinkThroughputLimitModeEnums`
`static class`	`Spinnaker_C.spinDevicePowerSupplySelectorEnums`
`static class`	`Spinnaker_C.spinDeviceRegistersEndiannessEnums`
`static class`	`Spinnaker_C.spinDeviceScanTypeEnums`
`static class`	`Spinnaker_C.spinDeviceSerialPortBaudRateEnums`
`static class`	`Spinnaker_C.spinDeviceSerialPortSelectorEnums`
`static class`	`Spinnaker_C.spinDeviceStreamChannelEndiannessEnums`
`static class`	`Spinnaker_C.spinDeviceStreamChannelTypeEnums`
`static class`	`Spinnaker_C.spinDeviceTapGeometryEnums`
`static class`	`Spinnaker_C.spinDeviceTemperatureSelectorEnums`
`static class`	`Spinnaker_C.spinDeviceTLTypeEnums`
`static class`	`Spinnaker_C.spinDeviceTypeEnums`
`static class`	`Spinnaker_C.spinDisplayNotation` typedef for float notation
`static class`	`Spinnaker_C.spinEncoderModeEnums`
`static class`	`Spinnaker_C.spinEncoderOutputModeEnums`
`static class`	`Spinnaker_C.spinEncoderResetActivationEnums`
`static class`	`Spinnaker_C.spinEncoderResetSourceEnums`
`static class`	`Spinnaker_C.spinEncoderSelectorEnums`
`static class`	`Spinnaker_C.spinEncoderSourceAEnums`
`static class`	`Spinnaker_C.spinEncoderSourceBEnums`
`static class`	`Spinnaker_C.spinEncoderStatusEnums`
`static class`	`Spinnaker_C.spinEndianess` Endianess of a value in a register
`static class`	`Spinnaker_C.spinError` The error codes in the range of -2000 to -2999 are reserved for GenICam related errors.
`static class`	`Spinnaker_C.spinEventNotificationEnums`
`static class`	`Spinnaker_C.spinEventSelectorEnums`
`static class`	`Spinnaker_C.spinExposureActiveModeEnums`
`static class`	`Spinnaker_C.spinExposureAutoEnums`
`static class`	`Spinnaker_C.spinExposureModeEnums`
`static class`	`Spinnaker_C.spinExposureTimeModeEnums`
`static class`	`Spinnaker_C.spinExposureTimeSelectorEnums`
`static class`	`Spinnaker_C.spinFileOpenModeEnums`
`static class`	`Spinnaker_C.spinFileOperationSelectorEnums`
`static class`	`Spinnaker_C.spinFileOperationStatusEnums`
`static class`	`Spinnaker_C.spinFileSelectorEnums`
`static class`	`Spinnaker_C.spinGainAutoBalanceEnums`
`static class`	`Spinnaker_C.spinGainAutoEnums`
`static class`	`Spinnaker_C.spinGainSelectorEnums`
`static class`	`Spinnaker_C.spinGevCCPEnums`
`static class`	`Spinnaker_C.spinGevCurrentPhysicalLinkConfigurationEnums`
`static class`	`Spinnaker_C.spinGevGVCPExtendedStatusCodesSelectorEnums`
`static class`	`Spinnaker_C.spinGevGVSPExtendedIDModeEnums`
`static class`	`Spinnaker_C.spinGevIEEE1588ClockAccuracyEnums`
`static class`	`Spinnaker_C.spinGevIEEE1588ModeEnums`
`static class`	`Spinnaker_C.spinGevIEEE1588StatusEnums`
`static class`	`Spinnaker_C.spinGevIPConfigurationStatusEnums`
`static class`	`Spinnaker_C.spinGevPhysicalLinkConfigurationEnums`
`static class`	`Spinnaker_C.spinGevSupportedOptionSelectorEnums`
`static class`	`Spinnaker_C.spinImageComponentSelectorEnums`
`static class`	`Spinnaker_C.spinImageCompressionJPEGFormatOptionEnums`
`static class`	`Spinnaker_C.spinImageCompressionModeEnums`
`static class`	`Spinnaker_C.spinImageCompressionRateOptionEnums`
`static class`	`Spinnaker_C.spinImageFileFormat` File formats to be used for saving images to disk.
`static class`	`Spinnaker_C.spinImageStatus` Status of images returned from spinImageGetStatus() call.
`static class`	`Spinnaker_C.spinIncMode` typedef for increment mode
`static class`	`Spinnaker_C.spinInputDirection` typedef for link type
`static class`	`Spinnaker_C.spinInterfaceType` typedef for interface type
`static class`	`Spinnaker_C.spinLineFormatEnums`
`static class`	`Spinnaker_C.spinLineInputFilterSelectorEnums`
`static class`	`Spinnaker_C.spinLineModeEnums`
`static class`	`Spinnaker_C.spinLineSelectorEnums`
`static class`	`Spinnaker_C.spinLineSourceEnums`
`static class`	`Spinnaker_C.spinLinkType` typedef for link type
`static class`	`Spinnaker_C.spinLogicBlockLUTInputActivationEnums`
`static class`	`Spinnaker_C.spinLogicBlockLUTInputSelectorEnums`
`static class`	`Spinnaker_C.spinLogicBlockLUTInputSourceEnums`
`static class`	`Spinnaker_C.spinLogicBlockLUTSelectorEnums`
`static class`	`Spinnaker_C.spinLogicBlockSelectorEnums`
`static class`	`Spinnaker_C.spinLUTSelectorEnums` \brief The enum definitions for camera nodes.
`static class`	`Spinnaker_C.spinnakerLogLevel` log levels
`static class`	`Spinnaker_C.spinNameSpace` Defines if a node name is standard or custom
`static class`	`Spinnaker_C.spinNodeType` \defgroup SpinnakerGenApiEnumsC Spinnaker C GenICam Enumerations Enumeration definitions for Spinnaker C GenICam API
`static class`	`Spinnaker_C.spinPixelColorFilterEnums`
`static class`	`Spinnaker_C.spinPixelFormatEnums`
`static class`	`Spinnaker_C.spinPixelFormatInfoSelectorEnums`
`static class`	`Spinnaker_C.spinPixelSizeEnums`
`static class`	`Spinnaker_C.spinRegionDestinationEnums`
`static class`	`Spinnaker_C.spinRegionModeEnums`
`static class`	`Spinnaker_C.spinRegionSelectorEnums`
`static class`	`Spinnaker_C.spinRepresentation` recommended representation of a node value
`static class`	`Spinnaker_C.spinRgbTransformLightSourceEnums`
`static class`	`Spinnaker_C.spinScan3dCoordinateReferenceSelectorEnums`
`static class`	`Spinnaker_C.spinScan3dCoordinateSelectorEnums`
`static class`	`Spinnaker_C.spinScan3dCoordinateSystemEnums`
`static class`	`Spinnaker_C.spinScan3dCoordinateSystemReferenceEnums`
`static class`	`Spinnaker_C.spinScan3dCoordinateTransformSelectorEnums`
`static class`	`Spinnaker_C.spinScan3dDistanceUnitEnums`
`static class`	`Spinnaker_C.spinScan3dOutputModeEnums`
`static class`	`Spinnaker_C.spinSensorDigitizationTapsEnums`
`static class`	`Spinnaker_C.spinSensorShutterModeEnums`
`static class`	`Spinnaker_C.spinSensorTapsEnums`
`static class`	`Spinnaker_C.spinSequencerConfigurationModeEnums`
`static class`	`Spinnaker_C.spinSequencerConfigurationValidEnums`
`static class`	`Spinnaker_C.spinSequencerModeEnums`
`static class`	`Spinnaker_C.spinSequencerSetValidEnums`
`static class`	`Spinnaker_C.spinSequencerTriggerActivationEnums`
`static class`	`Spinnaker_C.spinSequencerTriggerSourceEnums`
`static class`	`Spinnaker_C.spinSerialPortBaudRateEnums`
`static class`	`Spinnaker_C.spinSerialPortParityEnums`
`static class`	`Spinnaker_C.spinSerialPortSelectorEnums`
`static class`	`Spinnaker_C.spinSerialPortSourceEnums`
`static class`	`Spinnaker_C.spinSerialPortStopBitsEnums`
`static class`	`Spinnaker_C.spinSign`
`static class`	`Spinnaker_C.spinSlope` typedef for fomula type
`static class`	`Spinnaker_C.spinSoftwareSignalSelectorEnums`
`static class`	`Spinnaker_C.spinSourceSelectorEnums`
`static class`	`Spinnaker_C.spinStandardNameSpace` Defines from which standard namespace a node name comes from
`static class`	`Spinnaker_C.spinStatisticsChannel` Channels that allow statistics to be calculated.
`static class`	`Spinnaker_C.spinTestPatternEnums`
`static class`	`Spinnaker_C.spinTestPatternGeneratorSelectorEnums`
`static class`	`Spinnaker_C.spinTIFFCompressionMethod` Compression method to use for encoding TIFF images.
`static class`	`Spinnaker_C.spinTimerSelectorEnums`
`static class`	`Spinnaker_C.spinTimerStatusEnums`
`static class`	`Spinnaker_C.spinTimerTriggerActivationEnums`
`static class`	`Spinnaker_C.spinTimerTriggerSourceEnums`
`static class`	`Spinnaker_C.spinTLDeviceAccessStatusEnums`
`static class`	`Spinnaker_C.spinTLDeviceCurrentSpeedEnums`
`static class`	`Spinnaker_C.spinTLDeviceEndianessMechanismEnums`
`static class`	`Spinnaker_C.spinTLDeviceTypeEnums`
`static class`	`Spinnaker_C.spinTLFilterDriverStatusEnums`
`static class`	`Spinnaker_C.spinTLGenICamXMLLocationEnums`
`static class`	`Spinnaker_C.spinTLGevCCPEnums`
`static class`	`Spinnaker_C.spinTLGUIXMLLocationEnums`
`static class`	`Spinnaker_C.spinTLInterfaceTypeEnums`
`static class`	`Spinnaker_C.spinTLPayloadType`
`static class`	`Spinnaker_C.spinTLPixelFormatNamespace` This enum represents the namespace in which the TL specific pixel format resides.
`static class`	`Spinnaker_C.spinTLPOEStatusEnums`
`static class`	`Spinnaker_C.spinTLStreamBufferCountModeEnums`
`static class`	`Spinnaker_C.spinTLStreamBufferHandlingModeEnums`
`static class`	`Spinnaker_C.spinTLStreamModeEnums`
`static class`	`Spinnaker_C.spinTLStreamTypeEnums` \brief The enumeration definitions for transport layer nodes.
`static class`	`Spinnaker_C.spinTLTLTypeEnums`
`static class`	`Spinnaker_C.spinTransferComponentSelectorEnums`
`static class`	`Spinnaker_C.spinTransferControlModeEnums`
`static class`	`Spinnaker_C.spinTransferOperationModeEnums`
`static class`	`Spinnaker_C.spinTransferQueueModeEnums`
`static class`	`Spinnaker_C.spinTransferSelectorEnums`
`static class`	`Spinnaker_C.spinTransferStatusSelectorEnums`
`static class`	`Spinnaker_C.spinTransferTriggerActivationEnums`
`static class`	`Spinnaker_C.spinTransferTriggerModeEnums`
`static class`	`Spinnaker_C.spinTransferTriggerSelectorEnums`
`static class`	`Spinnaker_C.spinTransferTriggerSourceEnums`
`static class`	`Spinnaker_C.spinTriggerActivationEnums`
`static class`	`Spinnaker_C.spinTriggerModeEnums`
`static class`	`Spinnaker_C.spinTriggerOverlapEnums`
`static class`	`Spinnaker_C.spinTriggerSelectorEnums`
`static class`	`Spinnaker_C.spinTriggerSourceEnums`
`static class`	`Spinnaker_C.spinUserOutputSelectorEnums`
`static class`	`Spinnaker_C.spinUserSetDefaultEnums`
`static class`	`Spinnaker_C.spinUserSetSelectorEnums`
`static class`	`Spinnaker_C.spinVisibility`
`static class`	`Spinnaker_C.spinWhiteClipSelectorEnums`
`static class`	`Spinnaker_C.spinXMLValidation` typedef describing the different validity checks which can be performed on an XML file /** The enum values for a bitfield of lenght uint32_t
`static class`	`Spinnaker_C.spinYesNo` Defines the chices of a Yes/No alternaitve

Field Summary

Fields
Modifier and Type Field and Description

static byte False

static byte True

Fields
Modifier and Type	Field and Description
`static byte`	`False`
`static byte`	`True`

Constructor Summary

Constructors
Constructor and Description

Spinnaker_C()

Constructors
Constructor and Description
`Spinnaker_C()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static byte`	`False()` \defgroup SpinnakerDefsC Spinnaker C Definitions \ingroup SpinnakerC Definitions for Spinnaker C API Holds enumerations, typedefs and structures that are used across the Spinnaker C API wrapper.
`static Spinnaker_C.spinError`	`quickSpinInit(spinCamera hCamera, quickSpin pQuickSpin)` \defgroup CQuickSpinAccess QuickSpin Access \brief The functions in this section initialize the various QuickSpin structs for the C API.
`static Spinnaker_C.spinError`	`quickSpinInitEx(spinCamera hCamera, quickSpin pQuickSpin, quickSpinTLDevice pQuickSpinTLDevice, quickSpinTLStream pQuickSpinTLStream)`
`static Spinnaker_C.spinError`	`quickSpinTLDeviceInit(spinCamera hCamera, quickSpinTLDevice pQuickSpinTLDevice)`
`static Spinnaker_C.spinError`	`quickSpinTLInterfaceInit(spinInterface hInterface, quickSpinTLInterface pQuickSpinTLInterface)`
`static Spinnaker_C.spinError`	`quickSpinTLStreamInit(spinCamera hCamera, quickSpinTLStream pQuickSpinTLStream)`
`static Spinnaker_C.spinError`	`quickSpinTLSystemInit(spinSystem hSystem, quickSpinTLSystem pQuickSpinTLSystem)`
`static Spinnaker_C.spinError`	`spinBooleanGetValue(spinNodeHandle hNode, byte[] pbValue)`
`static int`	`spinBooleanGetValue(spinNodeHandle hNode, ByteBuffer pbValue)`
`static Spinnaker_C.spinError`	`spinBooleanGetValue(spinNodeHandle hNode, BytePointer pbValue)` Retrieves the value of a boolean node; boolean values are represented by 'True' (which equals '0') and 'False' (which equals '1')
`static Spinnaker_C.spinError`	`spinBooleanSetValue(spinNodeHandle hNode, byte value)` Sets the value of a boolean node; boolean values are represented by 'True' (which equals '0') and 'False' (which equals '1')
`static Spinnaker_C.spinError`	`spinCameraBeginAcquisition(spinCamera hCamera)` Has a camera start acquiring images
`static Spinnaker_C.spinError`	`spinCameraDeInit(spinCamera hCamera)` Deinitializes a camera, greatly reducing functionality
`static Spinnaker_C.spinError`	`spinCameraDiscoverMaxPacketSize(spinCamera hCamera, int[] pMaxPacketSize)`
`static int`	`spinCameraDiscoverMaxPacketSize(spinCamera hCamera, IntBuffer pMaxPacketSize)`
`static Spinnaker_C.spinError`	`spinCameraDiscoverMaxPacketSize(spinCamera hCamera, IntPointer pMaxPacketSize)` Returns the largest packet size that can be safely used on the interface that device is connected to.
`static Spinnaker_C.spinError`	`spinCameraEndAcquisition(spinCamera hCamera)` Has a camera stop acquiring images
`static Spinnaker_C.spinError`	`spinCameraGetAccessMode(spinCamera hCamera, int[] pAccessMode)`
`static int`	`spinCameraGetAccessMode(spinCamera hCamera, IntBuffer pAccessMode)`
`static Spinnaker_C.spinError`	`spinCameraGetAccessMode(spinCamera hCamera, IntPointer pAccessMode)` Retrieves the access mode of a camera (as an enum, spinAccessMode)
`static Spinnaker_C.spinError`	`spinCameraGetGuiXml(spinCamera hCamera, byte[] pBuf, SizeTPointer pBufLen)`
`static int`	`spinCameraGetGuiXml(spinCamera hCamera, ByteBuffer pBuf, SizeTPointer pBufLen)`
`static Spinnaker_C.spinError`	`spinCameraGetGuiXml(spinCamera hCamera, BytePointer pBuf, SizeTPointer pBufLen)` Retrieves the GUI XML from a camera
`static Spinnaker_C.spinError`	`spinCameraGetNextImage(spinCamera hCamera, spinImage phImage)` Retrieves an image from a camera
`static Spinnaker_C.spinError`	`spinCameraGetNextImageEx(spinCamera hCamera, long grabTimeout, spinImage phImage)` Retrieves an image from a camera; manually set the timeout in milliseconds
`static Spinnaker_C.spinError`	`spinCameraGetNextImageSync(spinCamera hCamera, long grabTimeout, spinImageList phImageList)` If a camera supports one or more streams, this function gets one image from each of the camera's streams, and returns the images in a list.
`static Spinnaker_C.spinError`	`spinCameraGetNodeMap(spinCamera hCamera, spinNodeMapHandle phNodeMap)` Retrieves the GenICam nodemap from a camera
`static Spinnaker_C.spinError`	`spinCameraGetTLDeviceNodeMap(spinCamera hCamera, spinNodeMapHandle phNodeMap)` Retrieves the transport layer device nodemap from a camera
`static Spinnaker_C.spinError`	`spinCameraGetTLStreamNodeMap(spinCamera hCamera, spinNodeMapHandle phNodeMap)` Retrieves the transport layer stream nodemap from a camera
`static Spinnaker_C.spinError`	`spinCameraGetUniqueID(spinCamera hCamera, byte[] pBuf, SizeTPointer pBufLen)`
`static int`	`spinCameraGetUniqueID(spinCamera hCamera, ByteBuffer pBuf, SizeTPointer pBufLen)`
`static Spinnaker_C.spinError`	`spinCameraGetUniqueID(spinCamera hCamera, BytePointer pBuf, SizeTPointer pBufLen)` Retrieves a unique identifier for a camera
`static Spinnaker_C.spinError`	`spinCameraInit(spinCamera hCamera)` Initializes a camera, allowing for much more interaction
`static Spinnaker_C.spinError`	`spinCameraIsInitialized(spinCamera hCamera, byte[] pbInit)`
`static int`	`spinCameraIsInitialized(spinCamera hCamera, ByteBuffer pbInit)`
`static Spinnaker_C.spinError`	`spinCameraIsInitialized(spinCamera hCamera, BytePointer pbInit)` Checks whether a camera is currently initialized
`static Spinnaker_C.spinError`	`spinCameraIsStreaming(spinCamera hCamera, byte[] pbIsStreaming)`
`static int`	`spinCameraIsStreaming(spinCamera hCamera, ByteBuffer pbIsStreaming)`
`static Spinnaker_C.spinError`	`spinCameraIsStreaming(spinCamera hCamera, BytePointer pbIsStreaming)` Checks whether a camera is currently acquiring images
`static Spinnaker_C.spinError`	`spinCameraIsValid(spinCamera hCamera, byte[] pbValid)`
`static int`	`spinCameraIsValid(spinCamera hCamera, ByteBuffer pbValid)`
`static Spinnaker_C.spinError`	`spinCameraIsValid(spinCamera hCamera, BytePointer pbValid)` Checks whether a camera is still valid for use
`static Spinnaker_C.spinError`	`spinCameraListAppend(spinCameraList hCameraListBase, spinCameraList hCameraListToAppend)` Appends all the cameras from one camera list to another
`static Spinnaker_C.spinError`	`spinCameraListClear(spinCameraList hCameraList)` Clears a camera list
`static Spinnaker_C.spinError`	`spinCameraListCreateEmpty(spinCameraList phCameraList)` Creates an empty camera list (camera lists created this way must be destroyed)
`static Spinnaker_C.spinError`	`spinCameraListDestroy(spinCameraList hCameraList)` Destroys a camera list
`static Spinnaker_C.spinError`	`spinCameraListGet(spinCameraList hCameraList, long index, spinCamera phCamera)` Retrieves a camera from a camera list using an index.
`static Spinnaker_C.spinError`	`spinCameraListGetBySerial(spinCameraList hCameraList, BytePointer pSerial, spinCamera phCamera)` Retrieves a camera from a camera list using its serial number.
`static int`	`spinCameraListGetBySerial(spinCameraList hCameraList, String pSerial, spinCamera phCamera)`
`static Spinnaker_C.spinError`	`spinCameraListGetSize(spinCameraList hCameraList, SizeTPointer pSize)` Retrieves the number of cameras on a camera list
`static Spinnaker_C.spinError`	`spinCameraListRemove(spinCameraList hCameraList, long index)` Removes a camera from a camera list using its index
`static Spinnaker_C.spinError`	`spinCameraListRemoveBySerial(spinCameraList hCameraList, BytePointer pSerial)` Removes a camera from a camera list using its serial number
`static int`	`spinCameraListRemoveBySerial(spinCameraList hCameraList, String pSerial)`
`static Spinnaker_C.spinError`	`spinCameraReadPort(spinCamera hCamera, long iAddress, Pointer pBuffer, long iSize)`
`static Spinnaker_C.spinError`	`spinCameraRegisterDeviceEventHandler(spinCamera hCamera, spinDeviceEventHandler hDeviceEventHandler)` Registers a universal device event handler (every device event type) to a camera
`static Spinnaker_C.spinError`	`spinCameraRegisterDeviceEventHandlerEx(spinCamera hCamera, spinDeviceEventHandler hDeviceEventHandler, BytePointer pName)` Registers a specific device event handler (only one device event type) to a camera
`static int`	`spinCameraRegisterDeviceEventHandlerEx(spinCamera hCamera, spinDeviceEventHandler hDeviceEventHandler, String pName)`
`static Spinnaker_C.spinError`	`spinCameraRegisterImageEventHandler(spinCamera hCamera, spinImageEventHandler hImageEventHandler)` Registers an image event handler to a camera
`static Spinnaker_C.spinError`	`spinCameraRegisterImageEventHandlerEx(spinCamera hCamera, spinImageEventHandler hImageEventHandler, long streamIndex)` Registers an image event handler to a camera Registers a specific stream handler for the camera given a stream index.
`static Spinnaker_C.spinError`	`spinCameraRegisterImageListEventHandler(spinCamera hCamera, spinImageListEventHandler hImageListEventHandler)` Registers an image list event handler to a camera
`static Spinnaker_C.spinError`	`spinCameraRelease(spinCamera hCamera)` Releases a camera
`static Spinnaker_C.spinError`	`spinCameraUnregisterDeviceEventHandler(spinCamera hCamera, spinDeviceEventHandler hDeviceEventHandler)` Unregisters a device event handler from a camera
`static Spinnaker_C.spinError`	`spinCameraUnregisterImageEventHandler(spinCamera hCamera, spinImageEventHandler hImageEventHandler)` Unregisters an image event handler from a camera
`static Spinnaker_C.spinError`	`spinCameraUnregisterImageListEventHandler(spinCamera hCamera, spinImageListEventHandler hImageListEventHandler)` Unregisters an image list event handler from a camera
`static Spinnaker_C.spinError`	`spinCameraWritePort(spinCamera hCamera, long iAddress, Pointer pBuffer, long iSize)`
`static Spinnaker_C.spinError`	`spinCategoryGetFeatureByIndex(spinNodeHandle hCategoryNode, long index, spinNodeHandle phFeature)` Retrieves a node from a category node using an index
`static Spinnaker_C.spinError`	`spinCategoryGetNumFeatures(spinNodeHandle hCategoryNode, SizeTPointer pValue)` Retrieves the number of a features (or child nodes) or a category node
`static Spinnaker_C.spinError`	`spinCategoryReleaseNode(spinNodeHandle hCategoryNode, spinNodeHandle hFeature)` Releases the feature node from the category node.
`static Spinnaker_C.spinError`	`spinCommandExecute(spinNodeHandle hNode)` Executes the action associated to a command node
`static Spinnaker_C.spinError`	`spinCommandIsDone(spinNodeHandle hNode, byte[] pbValue)`
`static int`	`spinCommandIsDone(spinNodeHandle hNode, ByteBuffer pbValue)`
`static Spinnaker_C.spinError`	`spinCommandIsDone(spinNodeHandle hNode, BytePointer pbValue)` Retrieves whether or not the action of a command node has completed
`static Spinnaker_C.spinError`	`spinDeviceArrivalEventHandlerCreate(spinDeviceArrivalEventHandler phDeviceArrivalEventHandler, spinArrivalEventFunction pFunction, Pointer pUserData)` Creates a device arrival event handler
`static Spinnaker_C.spinError`	`spinDeviceArrivalEventHandlerDestroy(spinDeviceArrivalEventHandler hDeviceArrivalEventHandler)` Destroys a device arrival event handler
`static Spinnaker_C.spinError`	`spinDeviceEventGetId(spinDeviceEventData hDeviceEventData, long[] pEventId)`
`static int`	`spinDeviceEventGetId(spinDeviceEventData hDeviceEventData, LongBuffer pEventId)`
`static Spinnaker_C.spinError`	`spinDeviceEventGetId(spinDeviceEventData hDeviceEventData, LongPointer pEventId)` Retrieves the event ID of a device event
`static Spinnaker_C.spinError`	`spinDeviceEventGetName(spinDeviceEventData hDeviceEventData, byte[] pBuf, SizeTPointer pBufLen)`
`static int`	`spinDeviceEventGetName(spinDeviceEventData hDeviceEventData, ByteBuffer pBuf, SizeTPointer pBufLen)`
`static Spinnaker_C.spinError`	`spinDeviceEventGetName(spinDeviceEventData hDeviceEventData, BytePointer pBuf, SizeTPointer pBufLen)` Retrieves the event name of a device event
`static Spinnaker_C.spinError`	`spinDeviceEventGetPayloadData(spinDeviceEventData hDeviceEventData, byte[] pBuf, SizeTPointer pBufSize)`
`static int`	`spinDeviceEventGetPayloadData(spinDeviceEventData hDeviceEventData, ByteBuffer pBuf, SizeTPointer pBufSize)`
`static Spinnaker_C.spinError`	`spinDeviceEventGetPayloadData(spinDeviceEventData hDeviceEventData, BytePointer pBuf, SizeTPointer pBufSize)` Retrieves the payload data of a device event
`static Spinnaker_C.spinError`	`spinDeviceEventGetPayloadDataSize(spinDeviceEventData hDeviceEventData, SizeTPointer pBufSize)` Retrieves the payload data size of a device event
`static Spinnaker_C.spinError`	`spinDeviceEventHandlerCreate(spinDeviceEventHandler phDeviceEventHandler, spinDeviceEventFunction pFunction, Pointer pUserData)` Creates a device event handler
`static Spinnaker_C.spinError`	`spinDeviceEventHandlerDestroy(spinDeviceEventHandler hDeviceEventHandler)` Destroys a device event handler
`static Spinnaker_C.spinError`	`spinDeviceRemovalEventHandlerCreate(spinDeviceRemovalEventHandler phDeviceRemovalEventHandler, spinRemovalEventFunction pFunction, Pointer pUserData)` Creates a device removal event handler
`static Spinnaker_C.spinError`	`spinDeviceRemovalEventHandlerDestroy(spinDeviceRemovalEventHandler hDeviceRemovalEventHandler)` Destroys a device removal event handler
`static Spinnaker_C.spinError`	`spinEnumerationEntryGetEnumValue(spinNodeHandle hNode, SizeTPointer pValue)` Retrieves the enum value (as an integer) of an entry node; note that enumeraiton entry int and enum values are different - int values defined on camera, enum values found in SpinnakerDefsC.h
`static Spinnaker_C.spinError`	`spinEnumerationEntryGetIntValue(spinNodeHandle hNode, long[] pValue)`
`static int`	`spinEnumerationEntryGetIntValue(spinNodeHandle hNode, LongBuffer pValue)`
`static Spinnaker_C.spinError`	`spinEnumerationEntryGetIntValue(spinNodeHandle hNode, LongPointer pValue)` Retrieves the integer value of an entry node; note that enumeration entry int and enum values are different - int values defined on camera, enum values found in SpinnakerDefsC.h
`static Spinnaker_C.spinError`	`spinEnumerationEntryGetSymbolic(spinNodeHandle hNode, byte[] pBuf, SizeTPointer pBufLen)`
`static int`	`spinEnumerationEntryGetSymbolic(spinNodeHandle hNode, ByteBuffer pBuf, SizeTPointer pBufLen)`
`static Spinnaker_C.spinError`	`spinEnumerationEntryGetSymbolic(spinNodeHandle hNode, BytePointer pBuf, SizeTPointer pBufLen)` Retrieves the symbolic of an entry node as a c-string
`static Spinnaker_C.spinError`	`spinEnumerationGetCurrentEntry(spinNodeHandle hEnumNode, spinNodeHandle phEntry)` Retrieves the currently selected entry node from an enum node
`static Spinnaker_C.spinError`	`spinEnumerationGetEntryByIndex(spinNodeHandle hEnumNode, long index, spinNodeHandle phEntry)` Retrieves an entry node from an enum node using an index
`static Spinnaker_C.spinError`	`spinEnumerationGetEntryByName(spinNodeHandle hEnumNode, BytePointer pName, spinNodeHandle phEntry)` Retrieves an entry node from an enum node using the entry's symbolic
`static int`	`spinEnumerationGetEntryByName(spinNodeHandle hEnumNode, String pName, spinNodeHandle phEntry)`
`static Spinnaker_C.spinError`	`spinEnumerationGetNumEntries(spinNodeHandle hEnumNode, SizeTPointer pValue)` Retrieves the number of entries of an enum node
`static Spinnaker_C.spinError`	`spinEnumerationReleaseNode(spinNodeHandle hEnumNode, spinNodeHandle hEntry)` Releases the entry node from the enum node handle.
`static Spinnaker_C.spinError`	`spinEnumerationSetEnumValue(spinNodeHandle hEnumNode, long value)` Sets a new entry using its enum; note that enumeration entry int and enum values are different - int values defined on camera, enum values found in SpinnakerDefsC.h
`static Spinnaker_C.spinError`	`spinEnumerationSetIntValue(spinNodeHandle hEnumNode, long value)` Sets a new entry using its integer value retrieved from a call to spinEnumerationEntryGetIntValue(); note that enumeration entry int and enum values are different - int values defined on camera, enum values found in SpinnakerDefsC.h
`static Spinnaker_C.spinError`	`spinErrorGetLast(int[] pError)`
`static int`	`spinErrorGetLast(IntBuffer pError)`
`static Spinnaker_C.spinError`	`spinErrorGetLast(IntPointer pError)` Retrieves the error code of the last error
`static Spinnaker_C.spinError`	`spinErrorGetLastBuildDate(byte[] pBuf, SizeTPointer pBufLen)`
`static int`	`spinErrorGetLastBuildDate(ByteBuffer pBuf, SizeTPointer pBufLen)`
`static Spinnaker_C.spinError`	`spinErrorGetLastBuildDate(BytePointer pBuf, SizeTPointer pBufLen)` Retrieves the build date of the last error
`static Spinnaker_C.spinError`	`spinErrorGetLastBuildTime(byte[] pBuf, SizeTPointer pBufLen)`
`static int`	`spinErrorGetLastBuildTime(ByteBuffer pBuf, SizeTPointer pBufLen)`
`static Spinnaker_C.spinError`	`spinErrorGetLastBuildTime(BytePointer pBuf, SizeTPointer pBufLen)` Retrieves the build time of the last error
`static Spinnaker_C.spinError`	`spinErrorGetLastFileName(byte[] pBuf, SizeTPointer pBufLen)`
`static int`	`spinErrorGetLastFileName(ByteBuffer pBuf, SizeTPointer pBufLen)`
`static Spinnaker_C.spinError`	`spinErrorGetLastFileName(BytePointer pBuf, SizeTPointer pBufLen)` Retrieves the filename of the last error
`static Spinnaker_C.spinError`	`spinErrorGetLastFullMessage(byte[] pBuf, SizeTPointer pBufLen)`
`static int`	`spinErrorGetLastFullMessage(ByteBuffer pBuf, SizeTPointer pBufLen)`
`static Spinnaker_C.spinError`	`spinErrorGetLastFullMessage(BytePointer pBuf, SizeTPointer pBufLen)` Retrieves the full error message of the last error
`static Spinnaker_C.spinError`	`spinErrorGetLastFunctionName(byte[] pBuf, SizeTPointer pBufLen)`
`static int`	`spinErrorGetLastFunctionName(ByteBuffer pBuf, SizeTPointer pBufLen)`
`static Spinnaker_C.spinError`	`spinErrorGetLastFunctionName(BytePointer pBuf, SizeTPointer pBufLen)` Retrieves the function name of the last error
`static Spinnaker_C.spinError`	`spinErrorGetLastLineNumber(long[] pLineNum)`
`static int`	`spinErrorGetLastLineNumber(LongBuffer pLineNum)`
`static Spinnaker_C.spinError`	`spinErrorGetLastLineNumber(LongPointer pLineNum)` Retrieves the line number of the last error
`static Spinnaker_C.spinError`	`spinErrorGetLastMessage(byte[] pBuf, SizeTPointer pBufLen)`
`static int`	`spinErrorGetLastMessage(ByteBuffer pBuf, SizeTPointer pBufLen)`
`static Spinnaker_C.spinError`	`spinErrorGetLastMessage(BytePointer pBuf, SizeTPointer pBufLen)` Retrieves the error message of the last error
`static Spinnaker_C.spinError`	`spinFloatGetMax(spinNodeHandle hNode, double[] pValue)`
`static int`	`spinFloatGetMax(spinNodeHandle hNode, DoubleBuffer pValue)`
`static Spinnaker_C.spinError`	`spinFloatGetMax(spinNodeHandle hNode, DoublePointer pValue)` Retrieves the maximum value of a float node; all potential values must be lesser than or equal to the maximum
`static Spinnaker_C.spinError`	`spinFloatGetMin(spinNodeHandle hNode, double[] pValue)`
`static int`	`spinFloatGetMin(spinNodeHandle hNode, DoubleBuffer pValue)`
`static Spinnaker_C.spinError`	`spinFloatGetMin(spinNodeHandle hNode, DoublePointer pValue)` Retrieves the minimum value of a float node; all potential values must be greater than or equal to the minimum
`static Spinnaker_C.spinError`	`spinFloatGetRepresentation(spinNodeHandle hNode, int[] pValue)`
`static int`	`spinFloatGetRepresentation(spinNodeHandle hNode, IntBuffer pValue)`
`static Spinnaker_C.spinError`	`spinFloatGetRepresentation(spinNodeHandle hNode, IntPointer pValue)` Retrieves the numerical representation of the value of a node; i.e.
`static Spinnaker_C.spinError`	`spinFloatGetUnit(spinNodeHandle hNode, byte[] pBuf, SizeTPointer pBufLen)`
`static int`	`spinFloatGetUnit(spinNodeHandle hNode, ByteBuffer pBuf, SizeTPointer pBufLen)`
`static Spinnaker_C.spinError`	`spinFloatGetUnit(spinNodeHandle hNode, BytePointer pBuf, SizeTPointer pBufLen)` Retrieves the units of the float node value
`static Spinnaker_C.spinError`	`spinFloatGetValue(spinNodeHandle hNode, double[] pValue)`
`static int`	`spinFloatGetValue(spinNodeHandle hNode, DoubleBuffer pValue)`
`static Spinnaker_C.spinError`	`spinFloatGetValue(spinNodeHandle hNode, DoublePointer pValue)` Retrieves the value of a float node
`static Spinnaker_C.spinError`	`spinFloatGetValueEx(spinNodeHandle hNode, byte bVerify, double[] pValue)`
`static int`	`spinFloatGetValueEx(spinNodeHandle hNode, byte bVerify, DoubleBuffer pValue)`
`static Spinnaker_C.spinError`	`spinFloatGetValueEx(spinNodeHandle hNode, byte bVerify, DoublePointer pValue)` Retrieves the value of a float node; manually set whether to verify the node
`static Spinnaker_C.spinError`	`spinFloatSetValue(spinNodeHandle hNode, double value)` Sets the value of a float node
`static Spinnaker_C.spinError`	`spinFloatSetValueEx(spinNodeHandle hNode, byte bVerify, double value)` Sets the value of a float node; manually set whether to verify the node
`static Spinnaker_C.spinError`	`spinImageCalculateStatistics(spinImage hImage, spinImageStatistics hStatistics)` Calculates the image statistics of an image
`static Spinnaker_C.spinError`	`spinImageCheckCRC(spinImage hImage, byte[] pbCheckCRC)`
`static int`	`spinImageCheckCRC(spinImage hImage, ByteBuffer pbCheckCRC)`
`static Spinnaker_C.spinError`	`spinImageCheckCRC(spinImage hImage, BytePointer pbCheckCRC)` Checks whether the CRC of an image is correct
`static Spinnaker_C.spinError`	`spinImageChunkDataGetFloatValue(spinImage hImage, BytePointer pName, double[] pValue)`
`static Spinnaker_C.spinError`	`spinImageChunkDataGetFloatValue(spinImage hImage, BytePointer pName, DoubleBuffer pValue)`
`static Spinnaker_C.spinError`	`spinImageChunkDataGetFloatValue(spinImage hImage, BytePointer pName, DoublePointer pValue)`
`static int`	`spinImageChunkDataGetFloatValue(spinImage hImage, String pName, double[] pValue)`
`static int`	`spinImageChunkDataGetFloatValue(spinImage hImage, String pName, DoubleBuffer pValue)`
`static int`	`spinImageChunkDataGetFloatValue(spinImage hImage, String pName, DoublePointer pValue)`
`static Spinnaker_C.spinError`	`spinImageChunkDataGetIntValue(spinImage hImage, BytePointer pName, long[] pValue)`
`static Spinnaker_C.spinError`	`spinImageChunkDataGetIntValue(spinImage hImage, BytePointer pName, LongBuffer pValue)`
`static Spinnaker_C.spinError`	`spinImageChunkDataGetIntValue(spinImage hImage, BytePointer pName, LongPointer pValue)` \defgroup CChunkData Chunk data access \brief The functions in this section provide access to chunk data stored on images.
`static int`	`spinImageChunkDataGetIntValue(spinImage hImage, String pName, long[] pValue)`
`static int`	`spinImageChunkDataGetIntValue(spinImage hImage, String pName, LongBuffer pValue)`
`static int`	`spinImageChunkDataGetIntValue(spinImage hImage, String pName, LongPointer pValue)`
`static Spinnaker_C.spinError`	`spinImageCreate(spinImage hSrcImage, spinImage phDestImage)` Creates an image from another; images created this way must be destroyed
`static Spinnaker_C.spinError`	`spinImageCreateEmpty(spinImage phImage)` Creates an empty image; images created this way must be destroyed
`static int`	`spinImageCreateEx(spinImage phImage, long width, long height, long offsetX, long offsetY, int pixelFormat, Pointer pData)`
`static Spinnaker_C.spinError`	`spinImageCreateEx(spinImage phImage, long width, long height, long offsetX, long offsetY, Spinnaker_C.spinPixelFormatEnums pixelFormat, Pointer pData)` Creates an image with some set properties; images created this way must be destroyed
`static int`	`spinImageCreateEx2(spinImage phImage, long width, long height, long offsetX, long offsetY, int pixelFormat, Pointer pData, int dataPayloadType, long dataSize)`
`static Spinnaker_C.spinError`	`spinImageCreateEx2(spinImage phImage, long width, long height, long offsetX, long offsetY, Spinnaker_C.spinPixelFormatEnums pixelFormat, Pointer pData, Spinnaker_C.spinTLPayloadType dataPayloadType, long dataSize)` Creates an image with some set properties; images created this way must be destroyed
`static Spinnaker_C.spinError`	`spinImageDeepCopy(spinImage hSrcImage, spinImage hDestImage)` Creates a deep copy of an image (the destination image must be created as an empty image prior to the deep copy)
`static Spinnaker_C.spinError`	`spinImageDestroy(spinImage hImage)` Destroys an image
`static Spinnaker_C.spinError`	`spinImageEventHandlerCreate(spinImageEventHandler phImageEventHandler, spinImageEventFunction pFunction, Pointer pUserData)` Creates an image event handler
`static Spinnaker_C.spinError`	`spinImageEventHandlerDestroy(spinImageEventHandler hImageEventHandler)` Destroys an image event handler
`static Spinnaker_C.spinError`	`spinImageGetBitsPerPixel(spinImage hImage, SizeTPointer pBitsPerPixel)` Retrieves the number of bits per pixel of an image
`static Spinnaker_C.spinError`	`spinImageGetBufferSize(spinImage hImage, SizeTPointer pSize)` Retrieves the buffer size of an image
`static Spinnaker_C.spinError`	`spinImageGetChunkLayoutID(spinImage hImage, long[] pId)`
`static int`	`spinImageGetChunkLayoutID(spinImage hImage, LongBuffer pId)`
`static Spinnaker_C.spinError`	`spinImageGetChunkLayoutID(spinImage hImage, LongPointer pId)` Retrieves the chunk layout ID of an image
`static Spinnaker_C.spinError`	`spinImageGetColorProcessing(spinImage hImage, int[] pAlgorithm)`
`static int`	`spinImageGetColorProcessing(spinImage hImage, IntBuffer pAlgorithm)`
`static Spinnaker_C.spinError`	`spinImageGetColorProcessing(spinImage hImage, IntPointer pAlgorithm)` Retrieves the color processing algorithm of a specific image
`static Spinnaker_C.spinError`	`spinImageGetData(spinImage hImage, Pointer ppData)`
`static Spinnaker_C.spinError`	`spinImageGetData(spinImage hImage, PointerPointer ppData)` Retrieves the image data of an image
`static Spinnaker_C.spinError`	`spinImageGetFrameID(spinImage hImage, long[] pFrameID)`
`static int`	`spinImageGetFrameID(spinImage hImage, LongBuffer pFrameID)`
`static Spinnaker_C.spinError`	`spinImageGetFrameID(spinImage hImage, LongPointer pFrameID)` Retrieves the frame ID of an image
`static Spinnaker_C.spinError`	`spinImageGetHeight(spinImage hImage, SizeTPointer pHeight)` Retrieves the height of an image
`static Spinnaker_C.spinError`	`spinImageGetID(spinImage hImage, long[] pId)`
`static int`	`spinImageGetID(spinImage hImage, LongBuffer pId)`
`static Spinnaker_C.spinError`	`spinImageGetID(spinImage hImage, LongPointer pId)` Retrieves the ID of an image
`static Spinnaker_C.spinError`	`spinImageGetOffsetX(spinImage hImage, SizeTPointer pOffsetX)` Retrieves the offset of an image along its X axis
`static Spinnaker_C.spinError`	`spinImageGetOffsetY(spinImage hImage, SizeTPointer pOffsetY)` Retrieves the offset of an image along its Y axis
`static Spinnaker_C.spinError`	`spinImageGetPaddingX(spinImage hImage, SizeTPointer pPaddingX)` Retrieves the padding of an image along its X axis
`static Spinnaker_C.spinError`	`spinImageGetPaddingY(spinImage hImage, SizeTPointer pPaddingY)` Retrieves the padding of an image along its Y axis
`static Spinnaker_C.spinError`	`spinImageGetPayloadType(spinImage hImage, SizeTPointer pPayloadType)` Retrieves the payload type of an image (as an enum, spinPayloadTypeInfoIds)
`static Spinnaker_C.spinError`	`spinImageGetPixelFormat(spinImage hImage, int[] pPixelFormat)`
`static int`	`spinImageGetPixelFormat(spinImage hImage, IntBuffer pPixelFormat)`
`static Spinnaker_C.spinError`	`spinImageGetPixelFormat(spinImage hImage, IntPointer pPixelFormat)` Retrieves the pixel format of an image (as an enum, spinPixelFormatEnums)
`static Spinnaker_C.spinError`	`spinImageGetPixelFormatName(spinImage hImage, byte[] pBuf, SizeTPointer pBufLen)`
`static int`	`spinImageGetPixelFormatName(spinImage hImage, ByteBuffer pBuf, SizeTPointer pBufLen)`
`static Spinnaker_C.spinError`	`spinImageGetPixelFormatName(spinImage hImage, BytePointer pBuf, SizeTPointer pBufLen)` Retrieves the pixel format of an image (as a symbolic)
`static Spinnaker_C.spinError`	`spinImageGetPrivateData(spinImage hImage, Pointer ppData)`
`static Spinnaker_C.spinError`	`spinImageGetPrivateData(spinImage hImage, PointerPointer ppData)` Retrieves the private data of an image
`static Spinnaker_C.spinError`	`spinImageGetSize(spinImage hImage, SizeTPointer pImageSize)` Retrieves the size of an image
`static Spinnaker_C.spinError`	`spinImageGetStatus(spinImage hImage, int[] pStatus)`
`static int`	`spinImageGetStatus(spinImage hImage, IntBuffer pStatus)`
`static Spinnaker_C.spinError`	`spinImageGetStatus(spinImage hImage, IntPointer pStatus)` Retrieves the image status of an image
`static int`	`spinImageGetStatusDescription(int status, byte[] pBuf, SizeTPointer pBufLen)`
`static int`	`spinImageGetStatusDescription(int status, ByteBuffer pBuf, SizeTPointer pBufLen)`
`static int`	`spinImageGetStatusDescription(int status, BytePointer pBuf, SizeTPointer pBufLen)`
`static Spinnaker_C.spinError`	`spinImageGetStatusDescription(Spinnaker_C.spinImageStatus status, byte[] pBuf, SizeTPointer pBufLen)`
`static Spinnaker_C.spinError`	`spinImageGetStatusDescription(Spinnaker_C.spinImageStatus status, ByteBuffer pBuf, SizeTPointer pBufLen)`
`static Spinnaker_C.spinError`	`spinImageGetStatusDescription(Spinnaker_C.spinImageStatus status, BytePointer pBuf, SizeTPointer pBufLen)` Retrieves the description of image status
`static Spinnaker_C.spinError`	`spinImageGetStride(spinImage hImage, SizeTPointer pStride)` Retrieves the stride of an image
`static Spinnaker_C.spinError`	`spinImageGetTimeStamp(spinImage hImage, long[] pTimeStamp)`
`static int`	`spinImageGetTimeStamp(spinImage hImage, LongBuffer pTimeStamp)`
`static Spinnaker_C.spinError`	`spinImageGetTimeStamp(spinImage hImage, LongPointer pTimeStamp)` Retrieves the timestamp of an image
`static Spinnaker_C.spinError`	`spinImageGetTLPayloadType(spinImage hImage, int[] pPayloadType)`
`static int`	`spinImageGetTLPayloadType(spinImage hImage, IntBuffer pPayloadType)`
`static Spinnaker_C.spinError`	`spinImageGetTLPayloadType(spinImage hImage, IntPointer pPayloadType)` Retrieves the transport layer payload type of an image (as an enum, spinPayloadTypeInfoIds)
`static Spinnaker_C.spinError`	`spinImageGetTLPixelFormat(spinImage hImage, long[] pPixelFormat)`
`static int`	`spinImageGetTLPixelFormat(spinImage hImage, LongBuffer pPixelFormat)`
`static Spinnaker_C.spinError`	`spinImageGetTLPixelFormat(spinImage hImage, LongPointer pPixelFormat)` Retrieves the transport layer pixel format of an image (as an unsigned integer)
`static Spinnaker_C.spinError`	`spinImageGetTLPixelFormatNamespace(spinImage hImage, int[] pPixelFormatNamespace)`
`static int`	`spinImageGetTLPixelFormatNamespace(spinImage hImage, IntBuffer pPixelFormatNamespace)`
`static Spinnaker_C.spinError`	`spinImageGetTLPixelFormatNamespace(spinImage hImage, IntPointer pPixelFormatNamespace)` Retrieves the transport layer pixel format namespace of an image (as an enum, spinPixelFormatNamespaceID)
`static Spinnaker_C.spinError`	`spinImageGetValidPayloadSize(spinImage hImage, SizeTPointer pSize)` Retrieves the valid payload size of an image
`static Spinnaker_C.spinError`	`spinImageGetWidth(spinImage hImage, SizeTPointer pWidth)` Retrieves the width of an image
`static Spinnaker_C.spinError`	`spinImageHasCRC(spinImage hImage, byte[] pbHasCRC)`
`static int`	`spinImageHasCRC(spinImage hImage, ByteBuffer pbHasCRC)`
`static Spinnaker_C.spinError`	`spinImageHasCRC(spinImage hImage, BytePointer pbHasCRC)` Checks whether an image has CRC
`static Spinnaker_C.spinError`	`spinImageIsIncomplete(spinImage hImage, byte[] pbIsIncomplete)`
`static int`	`spinImageIsIncomplete(spinImage hImage, ByteBuffer pbIsIncomplete)`
`static Spinnaker_C.spinError`	`spinImageIsIncomplete(spinImage hImage, BytePointer pbIsIncomplete)` Checks whether an image is incomplete
`static Spinnaker_C.spinError`	`spinImageListAppend(spinImageList hImageListBase, spinImageList hImageListToAppend)` Appends all the images from one image list to another
`static Spinnaker_C.spinError`	`spinImageListClear(spinImageList hImageList)` Clears a image list
`static Spinnaker_C.spinError`	`spinImageListCreateEmpty(spinImageList phImageList)` Creates an empty image list (image lists created this way must be destroyed)
`static Spinnaker_C.spinError`	`spinImageListDestroy(spinImageList hImageList)` Destroys a image list
`static Spinnaker_C.spinError`	`spinImageListEventHandlerCreate(spinImageListEventHandler phImageEventHandler, spinImageListEventFunction pFunction, Pointer pUserData)` Creates an image list event handler
`static Spinnaker_C.spinError`	`spinImageListEventHandlerDestroy(spinImageListEventHandler hImageListEventHandler)` Destroys an image list event handler
`static Spinnaker_C.spinError`	`spinImageListGet(spinImageList hImageList, long index, spinImage phImage)` Retrieves a image from a image list using an index.
`static int`	`spinImageListGetByPixelFormat(spinImageList hImageList, int pixelFormat, spinImage phImage)`
`static Spinnaker_C.spinError`	`spinImageListGetByPixelFormat(spinImageList hImageList, Spinnaker_C.spinPixelFormatEnums pixelFormat, spinImage phImage)` Retrieves a image from a image list given its pixel format.
`static Spinnaker_C.spinError`	`spinImageListGetSize(spinImageList hImageList, SizeTPointer pSize)` Retrieves the number of images in an image list
`static Spinnaker_C.spinError`	`spinImageListLoad(spinImageList phImageList, BytePointer fileName)` Creates an image list object from file.
`static int`	`spinImageListLoad(spinImageList phImageList, String fileName)`
`static Spinnaker_C.spinError`	`spinImageListRelease(spinImageList hImageList)`
`static Spinnaker_C.spinError`	`spinImageListRemove(spinImageList hImageList, long index)` Removes a image from a image list using its index
`static int`	`spinImageListRemoveByPixelFormat(spinImageList hImageList, int pixelFormat)`
`static Spinnaker_C.spinError`	`spinImageListRemoveByPixelFormat(spinImageList hImageList, Spinnaker_C.spinPixelFormatEnums pixelFormat)` Removes a image from a image list using its pixel format
`static Spinnaker_C.spinError`	`spinImageListSave(spinImageList hImageList, BytePointer fileName)` Saves an image list as an object to a file.
`static int`	`spinImageListSave(spinImageList hImageList, String fileName)`
`static Spinnaker_C.spinError`	`spinImageProcessorApplyGamma(spinImageProcessor hImageProcessor, spinImage hSrcImage, spinImage hDestImage, float gamma, byte applyGammaInverse)` Applies gamma correction to the source image and stores the result in the destination image.
`static int`	`spinImageProcessorConvert(spinImageProcessor hImageProcessor, spinImage hSrcImage, spinImage hDestImage, int destFormat)`
`static Spinnaker_C.spinError`	`spinImageProcessorConvert(spinImageProcessor hImageProcessor, spinImage hSrcImage, spinImage hDestImage, Spinnaker_C.spinPixelFormatEnums destFormat)` Converts the source image buffer to the specified destination pixel format and stores the result in the destination image.
`static int`	`spinImageProcessorConvertImageList(spinImageProcessor hImageProcessor, spinImageList hSrcImageList, spinImage hDestImage, int destFormat)`
`static Spinnaker_C.spinError`	`spinImageProcessorConvertImageList(spinImageProcessor hImageProcessor, spinImageList hSrcImageList, spinImage hDestImage, Spinnaker_C.spinPixelFormatEnums destFormat)` Converts the source list of image buffers to the specified output pixel format and returns the result in a new image.
`static Spinnaker_C.spinError`	`spinImageProcessorCreate(spinImageProcessor phImageProcessor)` Creates an image processor
`static Spinnaker_C.spinError`	`spinImageProcessorDestroy(spinImageProcessor hImageProcessor)` Destroys a image list
`static Spinnaker_C.spinError`	`spinImageProcessorGetColorProcessing(spinImageProcessor hImageProcessor, int[] pColorAlgorithm)`
`static int`	`spinImageProcessorGetColorProcessing(spinImageProcessor hImageProcessor, IntBuffer pColorAlgorithm)`
`static Spinnaker_C.spinError`	`spinImageProcessorGetColorProcessing(spinImageProcessor hImageProcessor, IntPointer pColorAlgorithm)` Gets the default color processing algorithm.
`static Spinnaker_C.spinError`	`spinImageProcessorGetNumDecompressionThreads(spinImageProcessor hImageProcessor, int[] pNumThreads)`
`static int`	`spinImageProcessorGetNumDecompressionThreads(spinImageProcessor hImageProcessor, IntBuffer pNumThreads)`
`static Spinnaker_C.spinError`	`spinImageProcessorGetNumDecompressionThreads(spinImageProcessor hImageProcessor, IntPointer pNumThreads)` Gets the number of threads used for image decompression during spinImageProcessorConvert().
`static int`	`spinImageProcessorSetColorProcessing(spinImageProcessor hImageProcessor, int colorAlgorithm)`
`static Spinnaker_C.spinError`	`spinImageProcessorSetColorProcessing(spinImageProcessor hImageProcessor, Spinnaker_C.spinColorProcessingAlgorithm colorAlgorithm)` Sets the color processing algorithm used at the time of the spinImageProcessorConvert() call, therefore the most recent execution of this function will take precedence.
`static Spinnaker_C.spinError`	`spinImageProcessorSetNumDecompressionThreads(spinImageProcessor hImageProcessor, int numThreads)` Sets the default number of threads used for image decompression during spinImageProcessorConvert().
`static Spinnaker_C.spinError`	`spinImageRelease(spinImage hImage)` Releases an image
`static int`	`spinImageReset(spinImage hImage, long width, long height, long offsetX, long offsetY, int pixelFormat)`
`static Spinnaker_C.spinError`	`spinImageReset(spinImage hImage, long width, long height, long offsetX, long offsetY, Spinnaker_C.spinPixelFormatEnums pixelFormat)` Resets an image with some set properties
`static int`	`spinImageResetEx(spinImage hImage, long width, long height, long offsetX, long offsetY, int pixelFormat, Pointer pData)`
`static Spinnaker_C.spinError`	`spinImageResetEx(spinImage hImage, long width, long height, long offsetX, long offsetY, Spinnaker_C.spinPixelFormatEnums pixelFormat, Pointer pData)` Resets an image with some set properties and image data
`static Spinnaker_C.spinError`	`spinImageSave(spinImage hImage, BytePointer pFilename, Spinnaker_C.spinImageFileFormat format)` Saves an image using a specified file format (using an enum, spinImageFileFormat)
`static int`	`spinImageSave(spinImage hImage, String pFilename, int format)`
`static Spinnaker_C.spinError`	`spinImageSaveBmp(spinImage hImage, BytePointer pFilename, spinBMPOption pOption)` Saves an image as a BMP image
`static int`	`spinImageSaveBmp(spinImage hImage, String pFilename, spinBMPOption pOption)`
`static Spinnaker_C.spinError`	`spinImageSaveFromExt(spinImage hImage, BytePointer pFilename)` Saves an image using a specified file format (using the extension of the filename)
`static int`	`spinImageSaveFromExt(spinImage hImage, String pFilename)`
`static Spinnaker_C.spinError`	`spinImageSaveJpeg(spinImage hImage, BytePointer pFilename, spinJPEGOption pOption)` Saves an image as a JPEG image
`static int`	`spinImageSaveJpeg(spinImage hImage, String pFilename, spinJPEGOption pOption)`
`static Spinnaker_C.spinError`	`spinImageSaveJpg2(spinImage hImage, BytePointer pFilename, spinJPG2Option pOption)` Saves an image as a JPEG 2000 image
`static int`	`spinImageSaveJpg2(spinImage hImage, String pFilename, spinJPG2Option pOption)`
`static Spinnaker_C.spinError`	`spinImageSavePgm(spinImage hImage, BytePointer pFilename, spinPGMOption pOption)` Saves an image as an PGM image
`static int`	`spinImageSavePgm(spinImage hImage, String pFilename, spinPGMOption pOption)`
`static Spinnaker_C.spinError`	`spinImageSavePng(spinImage hImage, BytePointer pFilename, spinPNGOption pOption)` Saves an image as a PNG image
`static int`	`spinImageSavePng(spinImage hImage, String pFilename, spinPNGOption pOption)`
`static Spinnaker_C.spinError`	`spinImageSavePpm(spinImage hImage, BytePointer pFilename, spinPPMOption pOption)` Saves an image as a PPM image
`static int`	`spinImageSavePpm(spinImage hImage, String pFilename, spinPPMOption pOption)`
`static Spinnaker_C.spinError`	`spinImageSaveTiff(spinImage hImage, BytePointer pFilename, spinTIFFOption pOption)` Saves an image as a TIFF image
`static int`	`spinImageSaveTiff(spinImage hImage, String pFilename, spinTIFFOption pOption)`
`static Spinnaker_C.spinError`	`spinImageStatisticsCreate(spinImageStatistics phStatistics)` Creates an image statistics context
`static Spinnaker_C.spinError`	`spinImageStatisticsDestroy(spinImageStatistics hStatistics)` Destroys an image statistics context
`static Spinnaker_C.spinError`	`spinImageStatisticsDisableAll(spinImageStatistics hStatistics)` Disables all channels of an image statistics context
`static Spinnaker_C.spinError`	`spinImageStatisticsEnableAll(spinImageStatistics hStatistics)` Enables all channels of an image statistics context
`static Spinnaker_C.spinError`	`spinImageStatisticsEnableGreyOnly(spinImageStatistics hStatistics)` Disables all channels of an image statistics context except grey-scale
`static Spinnaker_C.spinError`	`spinImageStatisticsEnableHslOnly(spinImageStatistics hStatistics)` Disables all channels of an image statistics context except hue, saturation, and lightness
`static Spinnaker_C.spinError`	`spinImageStatisticsEnableRgbOnly(spinImageStatistics hStatistics)` Disables all channels of an image statistics context except red, blue, and green
`static int`	`spinImageStatisticsGetAll(spinImageStatistics hStatistics, int channel, int[] pRangeMin, int[] pRangeMax, int[] pPixelValueMin, int[] pPixelValueMax, int[] pNumPixelValues, float[] pPixelValueMean, int[] ppHistogram)`
`static int`	`spinImageStatisticsGetAll(spinImageStatistics hStatistics, int channel, IntBuffer pRangeMin, IntBuffer pRangeMax, IntBuffer pPixelValueMin, IntBuffer pPixelValueMax, IntBuffer pNumPixelValues, FloatBuffer pPixelValueMean, IntBuffer ppHistogram)`
`static int`	`spinImageStatisticsGetAll(spinImageStatistics hStatistics, int channel, IntPointer pRangeMin, IntPointer pRangeMax, IntPointer pPixelValueMin, IntPointer pPixelValueMax, IntPointer pNumPixelValues, FloatPointer pPixelValueMean, IntPointer ppHistogram)`
`static Spinnaker_C.spinError`	`spinImageStatisticsGetAll(spinImageStatistics hStatistics, Spinnaker_C.spinStatisticsChannel channel, int[] pRangeMin, int[] pRangeMax, int[] pPixelValueMin, int[] pPixelValueMax, int[] pNumPixelValues, float[] pPixelValueMean, int[] ppHistogram)`
`static Spinnaker_C.spinError`	`spinImageStatisticsGetAll(spinImageStatistics hStatistics, Spinnaker_C.spinStatisticsChannel channel, IntBuffer pRangeMin, IntBuffer pRangeMax, IntBuffer pPixelValueMin, IntBuffer pPixelValueMax, IntBuffer pNumPixelValues, FloatBuffer pPixelValueMean, IntBuffer ppHistogram)`
`static Spinnaker_C.spinError`	`spinImageStatisticsGetAll(spinImageStatistics hStatistics, Spinnaker_C.spinStatisticsChannel channel, IntPointer pRangeMin, IntPointer pRangeMax, IntPointer pPixelValueMin, IntPointer pPixelValueMax, IntPointer pNumPixelValues, FloatPointer pPixelValueMean, IntPointer ppHistogram)`
`static Spinnaker_C.spinError`	`spinImageStatisticsGetAll(spinImageStatistics hStatistics, Spinnaker_C.spinStatisticsChannel channel, IntPointer pRangeMin, IntPointer pRangeMax, IntPointer pPixelValueMin, IntPointer pPixelValueMax, IntPointer pNumPixelValues, FloatPointer pPixelValueMean, PointerPointer ppHistogram)` Retrieves all available information of an image statistics channel
`static int`	`spinImageStatisticsGetChannelStatus(spinImageStatistics hStatistics, int channel, byte[] pbEnabled)`
`static int`	`spinImageStatisticsGetChannelStatus(spinImageStatistics hStatistics, int channel, ByteBuffer pbEnabled)`
`static int`	`spinImageStatisticsGetChannelStatus(spinImageStatistics hStatistics, int channel, BytePointer pbEnabled)`
`static Spinnaker_C.spinError`	`spinImageStatisticsGetChannelStatus(spinImageStatistics hStatistics, Spinnaker_C.spinStatisticsChannel channel, byte[] pbEnabled)`
`static Spinnaker_C.spinError`	`spinImageStatisticsGetChannelStatus(spinImageStatistics hStatistics, Spinnaker_C.spinStatisticsChannel channel, ByteBuffer pbEnabled)`
`static Spinnaker_C.spinError`	`spinImageStatisticsGetChannelStatus(spinImageStatistics hStatistics, Spinnaker_C.spinStatisticsChannel channel, BytePointer pbEnabled)` Checks whether an image statistics context is enabled
`static int`	`spinImageStatisticsGetHistogram(spinImageStatistics hStatistics, int channel, int[] ppHistogram)`
`static int`	`spinImageStatisticsGetHistogram(spinImageStatistics hStatistics, int channel, IntBuffer ppHistogram)`
`static int`	`spinImageStatisticsGetHistogram(spinImageStatistics hStatistics, int channel, IntPointer ppHistogram)`
`static Spinnaker_C.spinError`	`spinImageStatisticsGetHistogram(spinImageStatistics hStatistics, Spinnaker_C.spinStatisticsChannel channel, int[] ppHistogram)`
`static Spinnaker_C.spinError`	`spinImageStatisticsGetHistogram(spinImageStatistics hStatistics, Spinnaker_C.spinStatisticsChannel channel, IntBuffer ppHistogram)`
`static Spinnaker_C.spinError`	`spinImageStatisticsGetHistogram(spinImageStatistics hStatistics, Spinnaker_C.spinStatisticsChannel channel, IntPointer ppHistogram)`
`static Spinnaker_C.spinError`	`spinImageStatisticsGetHistogram(spinImageStatistics hStatistics, Spinnaker_C.spinStatisticsChannel channel, PointerPointer ppHistogram)` Retrieves a histogram of an image statistics channel
`static int`	`spinImageStatisticsGetMean(spinImageStatistics hStatistics, int channel, float[] pMean)`
`static int`	`spinImageStatisticsGetMean(spinImageStatistics hStatistics, int channel, FloatBuffer pMean)`
`static int`	`spinImageStatisticsGetMean(spinImageStatistics hStatistics, int channel, FloatPointer pMean)`
`static Spinnaker_C.spinError`	`spinImageStatisticsGetMean(spinImageStatistics hStatistics, Spinnaker_C.spinStatisticsChannel channel, float[] pMean)`
`static Spinnaker_C.spinError`	`spinImageStatisticsGetMean(spinImageStatistics hStatistics, Spinnaker_C.spinStatisticsChannel channel, FloatBuffer pMean)`
`static Spinnaker_C.spinError`	`spinImageStatisticsGetMean(spinImageStatistics hStatistics, Spinnaker_C.spinStatisticsChannel channel, FloatPointer pMean)` Retrieves the mean of pixel values of an image statistics channel
`static int`	`spinImageStatisticsGetNumPixelValues(spinImageStatistics hStatistics, int channel, int[] pNumValues)`
`static int`	`spinImageStatisticsGetNumPixelValues(spinImageStatistics hStatistics, int channel, IntBuffer pNumValues)`
`static int`	`spinImageStatisticsGetNumPixelValues(spinImageStatistics hStatistics, int channel, IntPointer pNumValues)`
`static Spinnaker_C.spinError`	`spinImageStatisticsGetNumPixelValues(spinImageStatistics hStatistics, Spinnaker_C.spinStatisticsChannel channel, int[] pNumValues)`
`static Spinnaker_C.spinError`	`spinImageStatisticsGetNumPixelValues(spinImageStatistics hStatistics, Spinnaker_C.spinStatisticsChannel channel, IntBuffer pNumValues)`
`static Spinnaker_C.spinError`	`spinImageStatisticsGetNumPixelValues(spinImageStatistics hStatistics, Spinnaker_C.spinStatisticsChannel channel, IntPointer pNumValues)` Retrieves the number of pixel values of an image statistics channel
`static int`	`spinImageStatisticsGetPixelValueRange(spinImageStatistics hStatistics, int channel, int[] pMin, int[] pMax)`
`static int`	`spinImageStatisticsGetPixelValueRange(spinImageStatistics hStatistics, int channel, IntBuffer pMin, IntBuffer pMax)`
`static int`	`spinImageStatisticsGetPixelValueRange(spinImageStatistics hStatistics, int channel, IntPointer pMin, IntPointer pMax)`
`static Spinnaker_C.spinError`	`spinImageStatisticsGetPixelValueRange(spinImageStatistics hStatistics, Spinnaker_C.spinStatisticsChannel channel, int[] pMin, int[] pMax)`
`static Spinnaker_C.spinError`	`spinImageStatisticsGetPixelValueRange(spinImageStatistics hStatistics, Spinnaker_C.spinStatisticsChannel channel, IntBuffer pMin, IntBuffer pMax)`
`static Spinnaker_C.spinError`	`spinImageStatisticsGetPixelValueRange(spinImageStatistics hStatistics, Spinnaker_C.spinStatisticsChannel channel, IntPointer pMin, IntPointer pMax)` Retrieves the pixel value range of an image statistics channel
`static int`	`spinImageStatisticsGetRange(spinImageStatistics hStatistics, int channel, int[] pMin, int[] pMax)`
`static int`	`spinImageStatisticsGetRange(spinImageStatistics hStatistics, int channel, IntBuffer pMin, IntBuffer pMax)`
`static int`	`spinImageStatisticsGetRange(spinImageStatistics hStatistics, int channel, IntPointer pMin, IntPointer pMax)`
`static Spinnaker_C.spinError`	`spinImageStatisticsGetRange(spinImageStatistics hStatistics, Spinnaker_C.spinStatisticsChannel channel, int[] pMin, int[] pMax)`
`static Spinnaker_C.spinError`	`spinImageStatisticsGetRange(spinImageStatistics hStatistics, Spinnaker_C.spinStatisticsChannel channel, IntBuffer pMin, IntBuffer pMax)`
`static Spinnaker_C.spinError`	`spinImageStatisticsGetRange(spinImageStatistics hStatistics, Spinnaker_C.spinStatisticsChannel channel, IntPointer pMin, IntPointer pMax)` Retrieves the range of an image statistics channel
`static int`	`spinImageStatisticsSetChannelStatus(spinImageStatistics hStatistics, int channel, byte bEnable)`
`static Spinnaker_C.spinError`	`spinImageStatisticsSetChannelStatus(spinImageStatistics hStatistics, Spinnaker_C.spinStatisticsChannel channel, byte bEnable)` Sets the status of an image statistics channel
`static Spinnaker_C.spinError`	`spinIntegerGetInc(spinNodeHandle hNode, long[] pValue)`
`static int`	`spinIntegerGetInc(spinNodeHandle hNode, LongBuffer pValue)`
`static Spinnaker_C.spinError`	`spinIntegerGetInc(spinNodeHandle hNode, LongPointer pValue)` Retrieves the increment of an integer node; all possible values must be divisible by the increment
`static Spinnaker_C.spinError`	`spinIntegerGetMax(spinNodeHandle hNode, long[] pValue)`
`static int`	`spinIntegerGetMax(spinNodeHandle hNode, LongBuffer pValue)`
`static Spinnaker_C.spinError`	`spinIntegerGetMax(spinNodeHandle hNode, LongPointer pValue)` Retrieves the maximum value of an integer node; all potential values must be lesser than or equal to the maximum
`static Spinnaker_C.spinError`	`spinIntegerGetMin(spinNodeHandle hNode, long[] pValue)`
`static int`	`spinIntegerGetMin(spinNodeHandle hNode, LongBuffer pValue)`
`static Spinnaker_C.spinError`	`spinIntegerGetMin(spinNodeHandle hNode, LongPointer pValue)` Retrieves the minimum value of an integer node; all potential values must be greater than or equal to the minimum
`static Spinnaker_C.spinError`	`spinIntegerGetRepresentation(spinNodeHandle hNode, int[] pValue)`
`static int`	`spinIntegerGetRepresentation(spinNodeHandle hNode, IntBuffer pValue)`
`static Spinnaker_C.spinError`	`spinIntegerGetRepresentation(spinNodeHandle hNode, IntPointer pValue)` Retrieves the numerical representation of the value of a node; i.e.
`static Spinnaker_C.spinError`	`spinIntegerGetValue(spinNodeHandle hNode, long[] pValue)`
`static int`	`spinIntegerGetValue(spinNodeHandle hNode, LongBuffer pValue)`
`static Spinnaker_C.spinError`	`spinIntegerGetValue(spinNodeHandle hNode, LongPointer pValue)` Retrieves the value of an integer node
`static Spinnaker_C.spinError`	`spinIntegerGetValueEx(spinNodeHandle hNode, byte bVerify, long[] pValue)`
`static int`	`spinIntegerGetValueEx(spinNodeHandle hNode, byte bVerify, LongBuffer pValue)`
`static Spinnaker_C.spinError`	`spinIntegerGetValueEx(spinNodeHandle hNode, byte bVerify, LongPointer pValue)` Retrieves the value of an integer node; manually set whether to verify the node
`static Spinnaker_C.spinError`	`spinIntegerSetValue(spinNodeHandle hNode, long value)` Sets the value of an integer node
`static Spinnaker_C.spinError`	`spinIntegerSetValueEx(spinNodeHandle hNode, byte bVerify, long value)` Sets the value of an integer node; manually set whether to verify the node
`static Spinnaker_C.spinError`	`spinInterfaceEventHandlerCreate(spinInterfaceEventHandler phInterfaceEventHandler, spinArrivalEventFunction pArrivalFunction, spinRemovalEventFunction pRemovalFunction, Pointer pUserData)` Creates an interface event handler (both device arrival and device removal)
`static Spinnaker_C.spinError`	`spinInterfaceEventHandlerDestroy(spinInterfaceEventHandler hInterfaceEventHandler)` Destroys an interface event handler (both device arrival and device removal)
`static Spinnaker_C.spinError`	`spinInterfaceGetCameras(spinInterface hInterface, spinCameraList hCameraList)` Retrieves a camera list from an interface; camera lists must be created and destroy
`static Spinnaker_C.spinError`	`spinInterfaceGetCamerasEx(spinInterface hInterface, byte bUpdateCameras, spinCameraList hCameraList)` Retrieves a camera list from an interface; manually set whether to update the cameras; camera lists must be created and destroyed
`static Spinnaker_C.spinError`	`spinInterfaceGetTLNodeMap(spinInterface hInterface, spinNodeMapHandle phNodeMap)` Retrieves the transport layer nodemap from an interface
`static Spinnaker_C.spinError`	`spinInterfaceIsInUse(spinInterface hInterface, byte[] pbIsInUse)`
`static int`	`spinInterfaceIsInUse(spinInterface hInterface, ByteBuffer pbIsInUse)`
`static Spinnaker_C.spinError`	`spinInterfaceIsInUse(spinInterface hInterface, BytePointer pbIsInUse)` Checks whether an interface is in use
`static Spinnaker_C.spinError`	`spinInterfaceListClear(spinInterfaceList hInterfaceList)` Clears an interface list
`static Spinnaker_C.spinError`	`spinInterfaceListCreateEmpty(spinInterfaceList phInterfaceList)` Creates an empty interface list (interface lists created this way must be destroyed)
`static Spinnaker_C.spinError`	`spinInterfaceListDestroy(spinInterfaceList hInterfaceList)` Destroys an interface list
`static Spinnaker_C.spinError`	`spinInterfaceListGet(spinInterfaceList hInterfaceList, long index, spinInterface phInterface)` Retrieves an interface from an interface list using an index (interfaces retrieved this way must be released)
`static Spinnaker_C.spinError`	`spinInterfaceListGetSize(spinInterfaceList hInterfaceList, SizeTPointer pSize)` Retrieves the number of interfaces in an interface list
`static Spinnaker_C.spinError`	`spinInterfaceRegisterDeviceArrivalEventHandler(spinInterface hInterface, spinDeviceArrivalEventHandler hDeviceArrivalEventHandler)` Registers a device arrival event handler on an interface (event handlers registered in this way must be unregistered)
`static Spinnaker_C.spinError`	`spinInterfaceRegisterDeviceRemovalEventHandler(spinInterface hInterface, spinDeviceRemovalEventHandler hDeviceRemovalEventHandler)` Registers a device removal event handler on an interface (event handlers registered in this way must be unregistered)
`static Spinnaker_C.spinError`	`spinInterfaceRegisterInterfaceEventHandler(spinInterface hInterface, spinInterfaceEventHandler hInterfaceEventHandler)` Registers an interface event handler (both device arrival and device removal) on an interface
`static Spinnaker_C.spinError`	`spinInterfaceRelease(spinInterface hInterface)` Releases an interface
`static Spinnaker_C.spinError`	`spinInterfaceUnregisterDeviceArrivalEventHandler(spinInterface hInterface, spinDeviceArrivalEventHandler hDeviceArrivalEventHandler)` Unregisters a device arrival event handler from an interface
`static Spinnaker_C.spinError`	`spinInterfaceUnregisterDeviceRemovalEventHandler(spinInterface hInterface, spinDeviceRemovalEventHandler hDeviceRemovalEventHandler)` Unregisters a device removal event handler from an interface
`static Spinnaker_C.spinError`	`spinInterfaceUnregisterInterfaceEventHandler(spinInterface hInterface, spinInterfaceEventHandler hInterfaceEventHandler)` Unregisters an interface event handler from an interface
`static Spinnaker_C.spinError`	`spinInterfaceUpdateCameras(spinInterface hInterface, byte[] pbChanged)`
`static int`	`spinInterfaceUpdateCameras(spinInterface hInterface, ByteBuffer pbChanged)`
`static Spinnaker_C.spinError`	`spinInterfaceUpdateCameras(spinInterface hInterface, BytePointer pbChanged)` Checks whether any cameras have been connected or disconnected on an interface
`static Spinnaker_C.spinError`	`spinLogDataGetCategoryName(spinLogEventData hLogEventData, byte[] pBuf, SizeTPointer pBufLen)`
`static int`	`spinLogDataGetCategoryName(spinLogEventData hLogEventData, ByteBuffer pBuf, SizeTPointer pBufLen)`
`static Spinnaker_C.spinError`	`spinLogDataGetCategoryName(spinLogEventData hLogEventData, BytePointer pBuf, SizeTPointer pBufLen)` Retrieves the category name of a log event
`static Spinnaker_C.spinError`	`spinLogDataGetLogMessage(spinLogEventData hLogEventData, byte[] pBuf, SizeTPointer pBufLen)`
`static int`	`spinLogDataGetLogMessage(spinLogEventData hLogEventData, ByteBuffer pBuf, SizeTPointer pBufLen)`
`static Spinnaker_C.spinError`	`spinLogDataGetLogMessage(spinLogEventData hLogEventData, BytePointer pBuf, SizeTPointer pBufLen)` Retrieves the log message of a log event
`static Spinnaker_C.spinError`	`spinLogDataGetNDC(spinLogEventData hLogEventData, byte[] pBuf, SizeTPointer pBufLen)`
`static int`	`spinLogDataGetNDC(spinLogEventData hLogEventData, ByteBuffer pBuf, SizeTPointer pBufLen)`
`static Spinnaker_C.spinError`	`spinLogDataGetNDC(spinLogEventData hLogEventData, BytePointer pBuf, SizeTPointer pBufLen)` Retrieves the NDC of a log event
`static Spinnaker_C.spinError`	`spinLogDataGetPriority(spinLogEventData hLogEventData, long[] pValue)`
`static int`	`spinLogDataGetPriority(spinLogEventData hLogEventData, LongBuffer pValue)`
`static Spinnaker_C.spinError`	`spinLogDataGetPriority(spinLogEventData hLogEventData, LongPointer pValue)` Retrieves the priority of a log event
`static Spinnaker_C.spinError`	`spinLogDataGetPriorityName(spinLogEventData hLogEventData, byte[] pBuf, SizeTPointer pBufLen)`
`static int`	`spinLogDataGetPriorityName(spinLogEventData hLogEventData, ByteBuffer pBuf, SizeTPointer pBufLen)`
`static Spinnaker_C.spinError`	`spinLogDataGetPriorityName(spinLogEventData hLogEventData, BytePointer pBuf, SizeTPointer pBufLen)` Retrieves the priority name of a log event
`static Spinnaker_C.spinError`	`spinLogDataGetThreadName(spinLogEventData hLogEventData, byte[] pBuf, SizeTPointer pBufLen)`
`static int`	`spinLogDataGetThreadName(spinLogEventData hLogEventData, ByteBuffer pBuf, SizeTPointer pBufLen)`
`static Spinnaker_C.spinError`	`spinLogDataGetThreadName(spinLogEventData hLogEventData, BytePointer pBuf, SizeTPointer pBufLen)` Retrieves the thread name of a log event
`static Spinnaker_C.spinError`	`spinLogDataGetTimestamp(spinLogEventData hLogEventData, byte[] pBuf, SizeTPointer pBufLen)`
`static int`	`spinLogDataGetTimestamp(spinLogEventData hLogEventData, ByteBuffer pBuf, SizeTPointer pBufLen)`
`static Spinnaker_C.spinError`	`spinLogDataGetTimestamp(spinLogEventData hLogEventData, BytePointer pBuf, SizeTPointer pBufLen)` Retrieves the timestamp of a log event
`static Spinnaker_C.spinError`	`spinLogEventHandlerCreate(spinLogEventHandler phLogEventHandler, spinLogEventFunction pFunction, Pointer pUserData)` Creates a log event handler
`static Spinnaker_C.spinError`	`spinLogEventHandlerDestroy(spinLogEventHandler hLogEventHandler)` Destroys a log event handler
`static Spinnaker_C.spinError`	`spinNodeDeregisterCallback(spinNodeHandle hNode, spinNodeCallbackHandle hCb)` Unregisters a callback from a node
`static Spinnaker_C.spinError`	`spinNodeFromString(spinNodeHandle hNode, BytePointer pBuf)` Sets the value of any node type from a c-string; it is important to ensure that the value of the c-string is appropriate to the node type
`static int`	`spinNodeFromString(spinNodeHandle hNode, String pBuf)`
`static Spinnaker_C.spinError`	`spinNodeFromStringEx(spinNodeHandle hNode, byte bVerify, BytePointer pBuf)` Sets the value of any node type from a c-string; manually set whether to verify the node; ensure the value of the c-string is appropriate to the node type
`static int`	`spinNodeFromStringEx(spinNodeHandle hNode, byte bVerify, String pBuf)`
`static Spinnaker_C.spinError`	`spinNodeGetAccessMode(spinNodeHandle hNode, int[] pAccessMode)`
`static int`	`spinNodeGetAccessMode(spinNodeHandle hNode, IntBuffer pAccessMode)`
`static Spinnaker_C.spinError`	`spinNodeGetAccessMode(spinNodeHandle hNode, IntPointer pAccessMode)` Retrieves the access mode of a node (as an enum, spinAccessMode)
`static Spinnaker_C.spinError`	`spinNodeGetCachingMode(spinNodeHandle hNode, int[] pCachingMode)`
`static int`	`spinNodeGetCachingMode(spinNodeHandle hNode, IntBuffer pCachingMode)`
`static Spinnaker_C.spinError`	`spinNodeGetCachingMode(spinNodeHandle hNode, IntPointer pCachingMode)` Retrieves the caching mode of a node (as an enum, spinCachingMode)
`static Spinnaker_C.spinError`	`spinNodeGetDescription(spinNodeHandle hNode, byte[] pBuf, SizeTPointer pBufLen)`
`static int`	`spinNodeGetDescription(spinNodeHandle hNode, ByteBuffer pBuf, SizeTPointer pBufLen)`
`static Spinnaker_C.spinError`	`spinNodeGetDescription(spinNodeHandle hNode, BytePointer pBuf, SizeTPointer pBufLen)` Retrieves a longer description of a node
`static Spinnaker_C.spinError`	`spinNodeGetDisplayName(spinNodeHandle hNode, byte[] pBuf, SizeTPointer pBufLen)`
`static int`	`spinNodeGetDisplayName(spinNodeHandle hNode, ByteBuffer pBuf, SizeTPointer pBufLen)`
`static Spinnaker_C.spinError`	`spinNodeGetDisplayName(spinNodeHandle hNode, BytePointer pBuf, SizeTPointer pBufLen)` Retrieves the display name of a node (whitespace possible)
`static int`	`spinNodeGetImposedAccessMode(spinNodeHandle hNode, int imposedAccessMode)`
`static Spinnaker_C.spinError`	`spinNodeGetImposedAccessMode(spinNodeHandle hNode, Spinnaker_C.spinAccessMode imposedAccessMode)` Retrieves the imposed access mode of a node
`static int`	`spinNodeGetImposedVisibility(spinNodeHandle hNode, int imposedVisibility)`
`static Spinnaker_C.spinError`	`spinNodeGetImposedVisibility(spinNodeHandle hNode, Spinnaker_C.spinVisibility imposedVisibility)` Retrieves the imposed visibility of a node
`static Spinnaker_C.spinError`	`spinNodeGetName(spinNodeHandle hNode, byte[] pBuf, SizeTPointer pBufLen)`
`static int`	`spinNodeGetName(spinNodeHandle hNode, ByteBuffer pBuf, SizeTPointer pBufLen)`
`static Spinnaker_C.spinError`	`spinNodeGetName(spinNodeHandle hNode, BytePointer pBuf, SizeTPointer pBufLen)` Retrieves the name of a node (no whitespace)
`static Spinnaker_C.spinError`	`spinNodeGetNameSpace(spinNodeHandle hNode, int[] pNamespace)`
`static int`	`spinNodeGetNameSpace(spinNodeHandle hNode, IntBuffer pNamespace)`
`static Spinnaker_C.spinError`	`spinNodeGetNameSpace(spinNodeHandle hNode, IntPointer pNamespace)` Retrieve the namespace of a node (as an enum, spinNameSpace)
`static Spinnaker_C.spinError`	`spinNodeGetPollingTime(spinNodeHandle hNode, long[] pPollingTime)`
`static int`	`spinNodeGetPollingTime(spinNodeHandle hNode, LongBuffer pPollingTime)`
`static Spinnaker_C.spinError`	`spinNodeGetPollingTime(spinNodeHandle hNode, LongPointer pPollingTime)` Retrieve the polling time of a node
`static Spinnaker_C.spinError`	`spinNodeGetToolTip(spinNodeHandle hNode, byte[] pBuf, SizeTPointer pBufLen)`
`static int`	`spinNodeGetToolTip(spinNodeHandle hNode, ByteBuffer pBuf, SizeTPointer pBufLen)`
`static Spinnaker_C.spinError`	`spinNodeGetToolTip(spinNodeHandle hNode, BytePointer pBuf, SizeTPointer pBufLen)` Retrieves a short description of a node
`static Spinnaker_C.spinError`	`spinNodeGetType(spinNodeHandle hNode, int[] pType)`
`static int`	`spinNodeGetType(spinNodeHandle hNode, IntBuffer pType)`
`static Spinnaker_C.spinError`	`spinNodeGetType(spinNodeHandle hNode, IntPointer pType)` Retrieves the type of a node (as an enum, spinNodeType)
`static Spinnaker_C.spinError`	`spinNodeGetVisibility(spinNodeHandle hNode, int[] pVisibility)`
`static int`	`spinNodeGetVisibility(spinNodeHandle hNode, IntBuffer pVisibility)`
`static Spinnaker_C.spinError`	`spinNodeGetVisibility(spinNodeHandle hNode, IntPointer pVisibility)` Retrieves the recommended visibility of a node (as an enum, spinVisibility)
`static Spinnaker_C.spinError`	`spinNodeInvalidateNode(spinNodeHandle hNode)` Invalidates a node in case its values may have changed, rendering it no longer valid
`static Spinnaker_C.spinError`	`spinNodeIsAvailable(spinNodeHandle hNode, byte[] pbResult)`
`static int`	`spinNodeIsAvailable(spinNodeHandle hNode, ByteBuffer pbResult)`
`static Spinnaker_C.spinError`	`spinNodeIsAvailable(spinNodeHandle hNode, BytePointer pbResult)` Checks whether a node is available
`static Spinnaker_C.spinError`	`spinNodeIsEqual(spinNodeHandle hNodeFirst, spinNodeHandle hNodeSecond, byte[] pbResult)`
`static int`	`spinNodeIsEqual(spinNodeHandle hNodeFirst, spinNodeHandle hNodeSecond, ByteBuffer pbResult)`
`static Spinnaker_C.spinError`	`spinNodeIsEqual(spinNodeHandle hNodeFirst, spinNodeHandle hNodeSecond, BytePointer pbResult)` Checks whether two nodes are equal
`static Spinnaker_C.spinError`	`spinNodeIsImplemented(spinNodeHandle hNode, byte[] pbResult)`
`static int`	`spinNodeIsImplemented(spinNodeHandle hNode, ByteBuffer pbResult)`
`static Spinnaker_C.spinError`	`spinNodeIsImplemented(spinNodeHandle hNode, BytePointer pbResult)` Checks whether a node is implemented
`static Spinnaker_C.spinError`	`spinNodeIsReadable(spinNodeHandle hNode, byte[] pbResult)`
`static int`	`spinNodeIsReadable(spinNodeHandle hNode, ByteBuffer pbResult)`
`static Spinnaker_C.spinError`	`spinNodeIsReadable(spinNodeHandle hNode, BytePointer pbResult)` Checks whether a node is readable
`static Spinnaker_C.spinError`	`spinNodeIsWritable(spinNodeHandle hNode, byte[] pbResult)`
`static int`	`spinNodeIsWritable(spinNodeHandle hNode, ByteBuffer pbResult)`
`static Spinnaker_C.spinError`	`spinNodeIsWritable(spinNodeHandle hNode, BytePointer pbResult)` Checks whether a node is writable
`static Spinnaker_C.spinError`	`spinNodeMapGetNode(spinNodeMapHandle hNodeMap, BytePointer pName, spinNodeHandle phNode)` Retrieves a node from the nodemap by name
`static int`	`spinNodeMapGetNode(spinNodeMapHandle hNodeMap, String pName, spinNodeHandle phNode)`
`static Spinnaker_C.spinError`	`spinNodeMapGetNodeByIndex(spinNodeMapHandle hNodeMap, long index, spinNodeHandle phNode)` Retrieves a node from the nodemap by index
`static Spinnaker_C.spinError`	`spinNodeMapGetNumNodes(spinNodeMapHandle hNodeMap, SizeTPointer pValue)` Gets the number of nodes in the map
`static Spinnaker_C.spinError`	`spinNodeMapPoll(spinNodeMapHandle hNodeMap, long timestamp)` Fires nodes which have a polling time
`static Spinnaker_C.spinError`	`spinNodeMapReleaseNode(spinNodeMapHandle hNodeMap, spinNodeHandle hNode)` Releases the entry node handle.
`static Spinnaker_C.spinError`	`spinNodeRegisterCallback(spinNodeHandle hNode, spinNodeCallbackFunction pCbFunction, spinNodeCallbackHandle phCb)` Registers a callback to a node
`static Spinnaker_C.spinError`	`spinNodeToString(spinNodeHandle hNode, byte[] pBuf, SizeTPointer pBufLen)`
`static int`	`spinNodeToString(spinNodeHandle hNode, ByteBuffer pBuf, SizeTPointer pBufLen)`
`static Spinnaker_C.spinError`	`spinNodeToString(spinNodeHandle hNode, BytePointer pBuf, SizeTPointer pBufLen)` Retrieves the value of any node type as a c-string
`static Spinnaker_C.spinError`	`spinNodeToStringEx(spinNodeHandle hNode, byte bVerify, byte[] pBuf, SizeTPointer pBufLen)`
`static int`	`spinNodeToStringEx(spinNodeHandle hNode, byte bVerify, ByteBuffer pBuf, SizeTPointer pBufLen)`
`static Spinnaker_C.spinError`	`spinNodeToStringEx(spinNodeHandle hNode, byte bVerify, BytePointer pBuf, SizeTPointer pBufLen)` Retrieves the value of any node type as a c-string; manually set whether to verify the node
`static Spinnaker_C.spinError`	`spinRegisterGet(spinNodeHandle hNode, byte[] pBuf, long length)`
`static int`	`spinRegisterGet(spinNodeHandle hNode, ByteBuffer pBuf, long length)`
`static Spinnaker_C.spinError`	`spinRegisterGet(spinNodeHandle hNode, BytePointer pBuf, long length)` Retrieves the value of a register node
`static Spinnaker_C.spinError`	`spinRegisterGetAddress(spinNodeHandle hNode, long[] pAddress)`
`static int`	`spinRegisterGetAddress(spinNodeHandle hNode, LongBuffer pAddress)`
`static Spinnaker_C.spinError`	`spinRegisterGetAddress(spinNodeHandle hNode, LongPointer pAddress)` Retrieves the address of a register node
`static Spinnaker_C.spinError`	`spinRegisterGetEx(spinNodeHandle hNode, byte bVerify, byte bIgnoreCache, byte[] pBuf, long length)`
`static int`	`spinRegisterGetEx(spinNodeHandle hNode, byte bVerify, byte bIgnoreCache, ByteBuffer pBuf, long length)`
`static Spinnaker_C.spinError`	`spinRegisterGetEx(spinNodeHandle hNode, byte bVerify, byte bIgnoreCache, BytePointer pBuf, long length)` Retrieves the value of a register node; manually set whether to verify the node and whether to ignore the cache
`static Spinnaker_C.spinError`	`spinRegisterGetLength(spinNodeHandle hNode, long[] pLength)`
`static int`	`spinRegisterGetLength(spinNodeHandle hNode, LongBuffer pLength)`
`static Spinnaker_C.spinError`	`spinRegisterGetLength(spinNodeHandle hNode, LongPointer pLength)` Retrieves the length (in bytes) of the value of a register node
`static Spinnaker_C.spinError`	`spinRegisterSet(spinNodeHandle hNode, byte[] pBuf, long length)`
`static int`	`spinRegisterSet(spinNodeHandle hNode, ByteBuffer pBuf, long length)`
`static Spinnaker_C.spinError`	`spinRegisterSet(spinNodeHandle hNode, BytePointer pBuf, long length)` Sets the value of a register node
`static Spinnaker_C.spinError`	`spinRegisterSetReference(spinNodeHandle hNode, spinNodeHandle hRef)` Uses a second node as a reference for a register node
`static Spinnaker_C.spinError`	`spinStringGetMaxLength(spinNodeHandle hNode, long[] pValue)`
`static int`	`spinStringGetMaxLength(spinNodeHandle hNode, LongBuffer pValue)`
`static Spinnaker_C.spinError`	`spinStringGetMaxLength(spinNodeHandle hNode, LongPointer pValue)` Retrieves the maximum length of the c-string to be returned
`static Spinnaker_C.spinError`	`spinStringGetValue(spinNodeHandle hNode, byte[] pBuf, SizeTPointer pBufLen)`
`static int`	`spinStringGetValue(spinNodeHandle hNode, ByteBuffer pBuf, SizeTPointer pBufLen)`
`static Spinnaker_C.spinError`	`spinStringGetValue(spinNodeHandle hNode, BytePointer pBuf, SizeTPointer pBufLen)` Retrieves the value of a string node as a c-string
`static Spinnaker_C.spinError`	`spinStringGetValueEx(spinNodeHandle hNode, byte bVerify, byte[] pBuf, SizeTPointer pBufLen)`
`static int`	`spinStringGetValueEx(spinNodeHandle hNode, byte bVerify, ByteBuffer pBuf, SizeTPointer pBufLen)`
`static Spinnaker_C.spinError`	`spinStringGetValueEx(spinNodeHandle hNode, byte bVerify, BytePointer pBuf, SizeTPointer pBufLen)` Retrieves the value of a string node as a cstring; manually set whether to verify the node
`static Spinnaker_C.spinError`	`spinStringSetValue(spinNodeHandle hNode, BytePointer pBuf)` Sets the value of a string node
`static int`	`spinStringSetValue(spinNodeHandle hNode, String pBuf)`
`static Spinnaker_C.spinError`	`spinStringSetValueEx(spinNodeHandle hNode, byte bVerify, BytePointer pBuf)` Sets the value of a string node; manually set whether to verify the node
`static int`	`spinStringSetValueEx(spinNodeHandle hNode, byte bVerify, String pBuf)`
`static Spinnaker_C.spinError`	`spinSystemGetCameras(spinSystem hSystem, spinCameraList hCameraList)` Retrieves a list of detected (and enumerable) cameras on the system; camera lists must be created and destroyed
`static Spinnaker_C.spinError`	`spinSystemGetCamerasEx(spinSystem hSystem, byte bUpdateInterfaces, byte bUpdateCameras, spinCameraList hCameraList)` Retrieves a list of detected (and enumerable) cameras on the system; manually set whether to update the current interface and camera lists; camera lists must be created and destroyed
`static Spinnaker_C.spinError`	`spinSystemGetInstance(spinSystem phSystem)` Retrieves an instance of the system object; the system is a singleton, so there will only ever be one instance; system instance must be destroyed by calling spinSystemReleaseInstance
`static Spinnaker_C.spinError`	`spinSystemGetInterfaces(spinSystem hSystem, spinInterfaceList hInterfaceList)` Retrieves a list of detected (and enumerable) interfaces on the system; interface lists must be created and destroyed
`static Spinnaker_C.spinError`	`spinSystemGetLibraryVersion(spinSystem hSystem, spinLibraryVersion hLibraryVersion)` Get current library version of Spinnaker.
`static Spinnaker_C.spinError`	`spinSystemGetLoggingLevel(spinSystem hSystem, int[] pLogLevel)`
`static int`	`spinSystemGetLoggingLevel(spinSystem hSystem, IntBuffer pLogLevel)`
`static Spinnaker_C.spinError`	`spinSystemGetLoggingLevel(spinSystem hSystem, IntPointer pLogLevel)` Retrieves the logging level for all logging events on the system
`static Spinnaker_C.spinError`	`spinSystemGetTLNodeMap(spinSystem hSystem, spinNodeMapHandle phNodeMap)` Retrieves the transport layer nodemap from the system.
`static Spinnaker_C.spinError`	`spinSystemIsInUse(spinSystem hSystem, byte[] pbIsInUse)`
`static int`	`spinSystemIsInUse(spinSystem hSystem, ByteBuffer pbIsInUse)`
`static Spinnaker_C.spinError`	`spinSystemIsInUse(spinSystem hSystem, BytePointer pbIsInUse)` Checks whether a system is currently in use
`static Spinnaker_C.spinError`	`spinSystemRegisterDeviceArrivalEventHandler(spinSystem hSystem, spinDeviceArrivalEventHandler hDeviceArrivalEventHandler)` Registers a device arrival event handler to every interface on the system (event handlers registered this way must be unregistered)
`static Spinnaker_C.spinError`	`spinSystemRegisterDeviceRemovalEventHandler(spinSystem hSystem, spinDeviceRemovalEventHandler hDeviceRemovalEventHandler)` Registers a device removal event handler to the system to every interface on the system (event handlers registered this way must be unregistered)
`static Spinnaker_C.spinError`	`spinSystemRegisterInterfaceEventHandler(spinSystem hSystem, spinInterfaceEventHandler hInterfaceEventHandler)` Registers an interface event handler (device arrival and device removal) to every interface on the system (interface events registered this way must be unregistered) If new interfaces are detected by the system after spinSystemRegisterInterfaceEventHandler() is called, those interfaces will be automatically registered with this event.
`static Spinnaker_C.spinError`	`spinSystemRegisterLogEventHandler(spinSystem hSystem, spinLogEventHandler hLogEventHandler)` Registers a logging event handler to the system (event handlers registered in this way must be unregistered)
`static Spinnaker_C.spinError`	`spinSystemReleaseInstance(spinSystem hSystem)` Releases the system; make sure handle is cleaned up properly by setting it to NULL after system is released; the handle can only be used again after calling spinSystemGetInstance
`static int`	`spinSystemSetLoggingLevel(spinSystem hSystem, int logLevel)`
`static Spinnaker_C.spinError`	`spinSystemSetLoggingLevel(spinSystem hSystem, Spinnaker_C.spinnakerLogLevel logLevel)` Sets the logging level for all logging events on the system
`static Spinnaker_C.spinError`	`spinSystemUnregisterAllLogEventHandlers(spinSystem hSystem)` Unregisters all logging event handlers from the system
`static Spinnaker_C.spinError`	`spinSystemUnregisterDeviceArrivalEventHandler(spinSystem hSystem, spinDeviceArrivalEventHandler hDeviceArrivalEventHandler)` Unregisters a device arrival event handler from the system
`static Spinnaker_C.spinError`	`spinSystemUnregisterDeviceRemovalEventHandler(spinSystem hSystem, spinDeviceRemovalEventHandler hDeviceRemovalEventHandler)` Unregisters a device removal event handler from the system
`static Spinnaker_C.spinError`	`spinSystemUnregisterInterfaceEventHandler(spinSystem hSystem, spinInterfaceEventHandler hInterfaceEventHandler)` Unregisters an interface event handler from the system
`static Spinnaker_C.spinError`	`spinSystemUnregisterLogEventHandler(spinSystem hSystem, spinLogEventHandler hLogEventHandler)` Unregisters a selected logging event handler from the system
`static Spinnaker_C.spinError`	`spinSystemUpdateCameras(spinSystem hSystem, byte[] pbChanged)`
`static int`	`spinSystemUpdateCameras(spinSystem hSystem, ByteBuffer pbChanged)`
`static Spinnaker_C.spinError`	`spinSystemUpdateCameras(spinSystem hSystem, BytePointer pbChanged)` Updates the list of cameras on the system, informing whether there has been any changes
`static Spinnaker_C.spinError`	`spinSystemUpdateCamerasEx(spinSystem hSystem, byte bUpdateInterfaces, byte[] pbChanged)`
`static int`	`spinSystemUpdateCamerasEx(spinSystem hSystem, byte bUpdateInterfaces, ByteBuffer pbChanged)`
`static Spinnaker_C.spinError`	`spinSystemUpdateCamerasEx(spinSystem hSystem, byte bUpdateInterfaces, BytePointer pbChanged)` Updates the list of cameras on the system, informing whether there has been any changes; manually set whether to update the current interface lists
`static Spinnaker_C.spinError`	`spinVideoAppend(spinVideo hSpinVideo, spinImage hImage)`
`static Spinnaker_C.spinError`	`spinVideoClose(spinVideo hSpinVideo)`
`static Spinnaker_C.spinError`	`spinVideoOpenH264(spinVideo phSpinVideo, BytePointer pName, spinH264Option option)`
`static int`	`spinVideoOpenH264(spinVideo phSpinVideo, String pName, spinH264Option option)`
`static Spinnaker_C.spinError`	`spinVideoOpenMJPG(spinVideo phSpinVideo, BytePointer pName, spinMJPGOption option)`
`static int`	`spinVideoOpenMJPG(spinVideo phSpinVideo, String pName, spinMJPGOption option)`
`static Spinnaker_C.spinError`	`spinVideoOpenUncompressed(spinVideo phSpinVideo, BytePointer pName, spinAVIOption option)` \defgroup CSpinVideo SpinVideo Recording Access \brief The functions in this section provide access to video recording capabilities, which include opening, building, and closing video files.
`static int`	`spinVideoOpenUncompressed(spinVideo phSpinVideo, String pName, spinAVIOption option)`
`static Spinnaker_C.spinError`	`spinVideoSetMaximumFileSize(spinVideo hSpinVideo, int size)` Set the maximum file size (in megabytes) of a AVI/MP4 file.
`static byte`	`True()`

Methods inherited from class org.bytedeco.spinnaker.presets.Spinnaker_C
map

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

False
```
public static final byte False
```

True
```
public static final byte True
```

Constructor Detail
- Spinnaker_C
```
public Spinnaker_C()
```

Method Detail

False
```
@MemberGetter
 @Cast(value="const bool8_t")
public static byte False()
```
\defgroup SpinnakerDefsC Spinnaker C Definitions \ingroup SpinnakerC Definitions for Spinnaker C API Holds enumerations, typedefs and structures that are used across the Spinnaker C API wrapper.

True

@MemberGetter
 @Cast(value="const bool8_t")
public static byte True()

spinNodeMapGetNode

public static Spinnaker_C.spinError spinNodeMapGetNode(spinNodeMapHandle hNodeMap,
                                                       @Cast(value="const char*")
                                                       BytePointer pName,
                                                       @ByPtrPtr
                                                       spinNodeHandle phNode)

Retrieves a node from the nodemap by name

Parameters:: hNodeMap - The node map where the node is; pName - The name of the node; phNode - The node handle pointer in which the node is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinNodeMapGetNode

@Cast(value="spinError")
public static int spinNodeMapGetNode(spinNodeMapHandle hNodeMap,
                                                               String pName,
                                                               @ByPtrPtr
                                                               spinNodeHandle phNode)

spinNodeMapGetNumNodes

public static Spinnaker_C.spinError spinNodeMapGetNumNodes(spinNodeMapHandle hNodeMap,
                                                           @Cast(value="size_t*")
                                                           SizeTPointer pValue)

Gets the number of nodes in the map

Parameters:: hNodeMap - The node map where the nodes to be counted are; pValue - The unsigned integer pointer in which the number of nodes is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinNodeMapGetNodeByIndex

public static Spinnaker_C.spinError spinNodeMapGetNodeByIndex(spinNodeMapHandle hNodeMap,
                                                              @Cast(value="size_t")
                                                              long index,
                                                              @ByPtrPtr
                                                              spinNodeHandle phNode)

Retrieves a node from the nodemap by index

Parameters:: hNodeMap - The node map where the node is; index - The index of the node; phNode - The node handle pointer in which the node is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinNodeMapReleaseNode
```
public static Spinnaker_C.spinError spinNodeMapReleaseNode(spinNodeMapHandle hNodeMap,
                                                           spinNodeHandle hNode)
```
Releases the entry node handle. Make sure node handle is cleaned up properly by setting it to NULL after the node is released. If this function is not explicitly called, the handle will be released upon the release of the camera handle.

Parameters:

hNodeMap - The node map from which the node handle is retrieved

hNode - The node handle to be released

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

spinCameraRelease, Spinnaker_C.spinError

spinNodeMapPoll

public static Spinnaker_C.spinError spinNodeMapPoll(spinNodeMapHandle hNodeMap,
                                                    @Cast(value="int64_t")
                                                    long timestamp)

Fires nodes which have a polling time

Parameters:: hNodeMap - The nodemap to poll; timestamp - The timestamp
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinNodeIsImplemented

public static Spinnaker_C.spinError spinNodeIsImplemented(spinNodeHandle hNode,
                                                          @Cast(value="bool8_t*")
                                                          BytePointer pbResult)

Checks whether a node is implemented

Parameters:: hNode - The node to check; pbResult - The boolean pointer to return whether or not the node is implemented
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinNodeIsImplemented

@Cast(value="spinError")
public static int spinNodeIsImplemented(spinNodeHandle hNode,
                                                                  @Cast(value="bool8_t*")
                                                                  ByteBuffer pbResult)

spinNodeIsImplemented

public static Spinnaker_C.spinError spinNodeIsImplemented(spinNodeHandle hNode,
                                                          @Cast(value="bool8_t*")
                                                          byte[] pbResult)

spinNodeIsReadable

public static Spinnaker_C.spinError spinNodeIsReadable(spinNodeHandle hNode,
                                                       @Cast(value="bool8_t*")
                                                       BytePointer pbResult)

Checks whether a node is readable

Parameters:: hNode - The node to check; pbResult - The boolean pointer to return whether or not the node is readable
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinNodeIsReadable

@Cast(value="spinError")
public static int spinNodeIsReadable(spinNodeHandle hNode,
                                                               @Cast(value="bool8_t*")
                                                               ByteBuffer pbResult)

spinNodeIsReadable

public static Spinnaker_C.spinError spinNodeIsReadable(spinNodeHandle hNode,
                                                       @Cast(value="bool8_t*")
                                                       byte[] pbResult)

spinNodeIsWritable

public static Spinnaker_C.spinError spinNodeIsWritable(spinNodeHandle hNode,
                                                       @Cast(value="bool8_t*")
                                                       BytePointer pbResult)

Checks whether a node is writable

Parameters:: hNode - The node to check; pbResult - The boolean pointer to return whether or not the node is writable
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinNodeIsWritable

@Cast(value="spinError")
public static int spinNodeIsWritable(spinNodeHandle hNode,
                                                               @Cast(value="bool8_t*")
                                                               ByteBuffer pbResult)

spinNodeIsWritable

public static Spinnaker_C.spinError spinNodeIsWritable(spinNodeHandle hNode,
                                                       @Cast(value="bool8_t*")
                                                       byte[] pbResult)

spinNodeIsAvailable

public static Spinnaker_C.spinError spinNodeIsAvailable(spinNodeHandle hNode,
                                                        @Cast(value="bool8_t*")
                                                        BytePointer pbResult)

Checks whether a node is available

Parameters:: hNode - The node to check; pbResult - The boolean pointer to return whether or not the node is available
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinNodeIsAvailable

@Cast(value="spinError")
public static int spinNodeIsAvailable(spinNodeHandle hNode,
                                                                @Cast(value="bool8_t*")
                                                                ByteBuffer pbResult)

spinNodeIsAvailable

public static Spinnaker_C.spinError spinNodeIsAvailable(spinNodeHandle hNode,
                                                        @Cast(value="bool8_t*")
                                                        byte[] pbResult)

spinNodeIsEqual

public static Spinnaker_C.spinError spinNodeIsEqual(spinNodeHandle hNodeFirst,
                                                    spinNodeHandle hNodeSecond,
                                                    @Cast(value="bool8_t*")
                                                    BytePointer pbResult)

Checks whether two nodes are equal

Parameters:: hNodeFirst - The first node to check; hNodeSecond - The second node to check; pbResult - The boolean pointer to return whether or not the two nodes are equal
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinNodeIsEqual

@Cast(value="spinError")
public static int spinNodeIsEqual(spinNodeHandle hNodeFirst,
                                                            spinNodeHandle hNodeSecond,
                                                            @Cast(value="bool8_t*")
                                                            ByteBuffer pbResult)

spinNodeIsEqual

public static Spinnaker_C.spinError spinNodeIsEqual(spinNodeHandle hNodeFirst,
                                                    spinNodeHandle hNodeSecond,
                                                    @Cast(value="bool8_t*")
                                                    byte[] pbResult)

spinNodeGetAccessMode

public static Spinnaker_C.spinError spinNodeGetAccessMode(spinNodeHandle hNode,
                                                          @Cast(value="spinAccessMode*")
                                                          IntPointer pAccessMode)

Retrieves the access mode of a node (as an enum, spinAccessMode)

Parameters:: hNode - The node of the access mode to retrieve; pAccessMode - The access mode enum pointer in which the access mode is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError, Spinnaker_C.spinAccessMode

spinNodeGetAccessMode

@Cast(value="spinError")
public static int spinNodeGetAccessMode(spinNodeHandle hNode,
                                                                  @Cast(value="spinAccessMode*")
                                                                  IntBuffer pAccessMode)

spinNodeGetAccessMode

public static Spinnaker_C.spinError spinNodeGetAccessMode(spinNodeHandle hNode,
                                                          @Cast(value="spinAccessMode*")
                                                          int[] pAccessMode)

spinNodeGetName

public static Spinnaker_C.spinError spinNodeGetName(spinNodeHandle hNode,
                                                    @Cast(value="char*")
                                                    BytePointer pBuf,
                                                    @Cast(value="size_t*")
                                                    SizeTPointer pBufLen)

Retrieves the name of a node (no whitespace)

Parameters:: hNode - The node of the name to retrieve; pBuf - The c-string character buffer in which the name of the node is returned; pBufLen - The unsigned integer pointer in which the length of the c-string is returned; the input value is the maximum length
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinNodeGetName

@Cast(value="spinError")
public static int spinNodeGetName(spinNodeHandle hNode,
                                                            @Cast(value="char*")
                                                            ByteBuffer pBuf,
                                                            @Cast(value="size_t*")
                                                            SizeTPointer pBufLen)

spinNodeGetName

public static Spinnaker_C.spinError spinNodeGetName(spinNodeHandle hNode,
                                                    @Cast(value="char*")
                                                    byte[] pBuf,
                                                    @Cast(value="size_t*")
                                                    SizeTPointer pBufLen)

spinNodeGetNameSpace

public static Spinnaker_C.spinError spinNodeGetNameSpace(spinNodeHandle hNode,
                                                         @Cast(value="spinNameSpace*")
                                                         IntPointer pNamespace)

Retrieve the namespace of a node (as an enum, spinNameSpace)

Parameters:: hNode - The node of the namespace to retrieve; pNamespace - The namespace enum pointer in which the namespace is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError, Spinnaker_C.spinNameSpace

spinNodeGetNameSpace

@Cast(value="spinError")
public static int spinNodeGetNameSpace(spinNodeHandle hNode,
                                                                 @Cast(value="spinNameSpace*")
                                                                 IntBuffer pNamespace)

spinNodeGetNameSpace

public static Spinnaker_C.spinError spinNodeGetNameSpace(spinNodeHandle hNode,
                                                         @Cast(value="spinNameSpace*")
                                                         int[] pNamespace)

spinNodeGetVisibility

public static Spinnaker_C.spinError spinNodeGetVisibility(spinNodeHandle hNode,
                                                          @Cast(value="spinVisibility*")
                                                          IntPointer pVisibility)

Retrieves the recommended visibility of a node (as an enum, spinVisibility)

Parameters:: hNode - The node of the visibility to retrieve; pVisibility - The visibility enum pointer in which the visibility is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError, Spinnaker_C.spinVisibility

spinNodeGetVisibility

@Cast(value="spinError")
public static int spinNodeGetVisibility(spinNodeHandle hNode,
                                                                  @Cast(value="spinVisibility*")
                                                                  IntBuffer pVisibility)

spinNodeGetVisibility

public static Spinnaker_C.spinError spinNodeGetVisibility(spinNodeHandle hNode,
                                                          @Cast(value="spinVisibility*")
                                                          int[] pVisibility)

spinNodeInvalidateNode
```
public static Spinnaker_C.spinError spinNodeInvalidateNode(spinNodeHandle hNode)
```
Invalidates a node in case its values may have changed, rendering it no longer valid

Parameters:

hNode - The node whose values may have changed

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

Spinnaker_C.spinError

spinNodeGetCachingMode

public static Spinnaker_C.spinError spinNodeGetCachingMode(spinNodeHandle hNode,
                                                           @Cast(value="spinCachingMode*")
                                                           IntPointer pCachingMode)

Retrieves the caching mode of a node (as an enum, spinCachingMode)

Parameters:: hNode - The node of the caching mode to retrieve; pCachingMode - The caching mode enum pointer in which the caching mode is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError, Spinnaker_C.spinCachingMode

spinNodeGetCachingMode

@Cast(value="spinError")
public static int spinNodeGetCachingMode(spinNodeHandle hNode,
                                                                   @Cast(value="spinCachingMode*")
                                                                   IntBuffer pCachingMode)

spinNodeGetCachingMode

public static Spinnaker_C.spinError spinNodeGetCachingMode(spinNodeHandle hNode,
                                                           @Cast(value="spinCachingMode*")
                                                           int[] pCachingMode)

spinNodeGetToolTip

public static Spinnaker_C.spinError spinNodeGetToolTip(spinNodeHandle hNode,
                                                       @Cast(value="char*")
                                                       BytePointer pBuf,
                                                       @Cast(value="size_t*")
                                                       SizeTPointer pBufLen)

Retrieves a short description of a node

Parameters:: hNode - The node of the tooltip to retrieve; pBuf - The c-string character buffer in which the short description of the node is returned; pBufLen - The unsigned integer pointer in which the length of the c-string is returned; the input value is the maximum length
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinNodeGetToolTip

@Cast(value="spinError")
public static int spinNodeGetToolTip(spinNodeHandle hNode,
                                                               @Cast(value="char*")
                                                               ByteBuffer pBuf,
                                                               @Cast(value="size_t*")
                                                               SizeTPointer pBufLen)

spinNodeGetToolTip

public static Spinnaker_C.spinError spinNodeGetToolTip(spinNodeHandle hNode,
                                                       @Cast(value="char*")
                                                       byte[] pBuf,
                                                       @Cast(value="size_t*")
                                                       SizeTPointer pBufLen)

spinNodeGetDescription

public static Spinnaker_C.spinError spinNodeGetDescription(spinNodeHandle hNode,
                                                           @Cast(value="char*")
                                                           BytePointer pBuf,
                                                           @Cast(value="size_t*")
                                                           SizeTPointer pBufLen)

Retrieves a longer description of a node

Parameters:: hNode - The node of the description to retrieve; pBuf - The c-string character buffer in which the longer descrition of the node is returned; pBufLen - The unsigned integer pointer in which the length of the c-string is returned; the input value is the maximum length
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinNodeGetDescription

@Cast(value="spinError")
public static int spinNodeGetDescription(spinNodeHandle hNode,
                                                                   @Cast(value="char*")
                                                                   ByteBuffer pBuf,
                                                                   @Cast(value="size_t*")
                                                                   SizeTPointer pBufLen)

spinNodeGetDescription

public static Spinnaker_C.spinError spinNodeGetDescription(spinNodeHandle hNode,
                                                           @Cast(value="char*")
                                                           byte[] pBuf,
                                                           @Cast(value="size_t*")
                                                           SizeTPointer pBufLen)

spinNodeGetDisplayName

public static Spinnaker_C.spinError spinNodeGetDisplayName(spinNodeHandle hNode,
                                                           @Cast(value="char*")
                                                           BytePointer pBuf,
                                                           @Cast(value="size_t*")
                                                           SizeTPointer pBufLen)

Retrieves the display name of a node (whitespace possible)

Parameters:: hNode - The node of the display name to retrieve; pBuf - The c-string character buffer in which the display name of the node is returned; pBufLen - The unsigned integer pointer in which the length of the c-string is returned; the input value is the maximum length
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinNodeGetDisplayName

@Cast(value="spinError")
public static int spinNodeGetDisplayName(spinNodeHandle hNode,
                                                                   @Cast(value="char*")
                                                                   ByteBuffer pBuf,
                                                                   @Cast(value="size_t*")
                                                                   SizeTPointer pBufLen)

spinNodeGetDisplayName

public static Spinnaker_C.spinError spinNodeGetDisplayName(spinNodeHandle hNode,
                                                           @Cast(value="char*")
                                                           byte[] pBuf,
                                                           @Cast(value="size_t*")
                                                           SizeTPointer pBufLen)

spinNodeGetType

public static Spinnaker_C.spinError spinNodeGetType(spinNodeHandle hNode,
                                                    @Cast(value="spinNodeType*")
                                                    IntPointer pType)

Retrieves the type of a node (as an enum, spinNodeType)

Parameters:: hNode - The node of the node type to retrieve; pType - The node type enum pointer in which the type of node is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError, Spinnaker_C.spinNodeType

spinNodeGetType

@Cast(value="spinError")
public static int spinNodeGetType(spinNodeHandle hNode,
                                                            @Cast(value="spinNodeType*")
                                                            IntBuffer pType)

spinNodeGetType

public static Spinnaker_C.spinError spinNodeGetType(spinNodeHandle hNode,
                                                    @Cast(value="spinNodeType*")
                                                    int[] pType)

spinNodeGetPollingTime

public static Spinnaker_C.spinError spinNodeGetPollingTime(spinNodeHandle hNode,
                                                           @Cast(value="int64_t*")
                                                           LongPointer pPollingTime)

Retrieve the polling time of a node

Parameters:: hNode - The node of the polling time to retrieve; pPollingTime - The integer pointer in which the polling time is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinNodeGetPollingTime

@Cast(value="spinError")
public static int spinNodeGetPollingTime(spinNodeHandle hNode,
                                                                   @Cast(value="int64_t*")
                                                                   LongBuffer pPollingTime)

spinNodeGetPollingTime

public static Spinnaker_C.spinError spinNodeGetPollingTime(spinNodeHandle hNode,
                                                           @Cast(value="int64_t*")
                                                           long[] pPollingTime)

spinNodeRegisterCallback

public static Spinnaker_C.spinError spinNodeRegisterCallback(spinNodeHandle hNode,
                                                             spinNodeCallbackFunction pCbFunction,
                                                             @ByPtrPtr
                                                             spinNodeCallbackHandle phCb)

Registers a callback to a node

Parameters:: hNode - The node on which to register the callback; pCbFunction - The function pointer of the function that will execute when the callback is triggered; must match signature "void spinNodeCallbackFunction(spinNodeHandle hNode)"; phCb - The callback handle pointer in which the callback is returned; used to unregister callbacks
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinNodeDeregisterCallback
```
public static Spinnaker_C.spinError spinNodeDeregisterCallback(spinNodeHandle hNode,
                                                               spinNodeCallbackHandle hCb)
```
Unregisters a callback from a node

Parameters:

hNode - The node from which to unregister the callback

hCb - The callback handle to unregister

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

Spinnaker_C.spinError

spinNodeGetImposedAccessMode
```
public static Spinnaker_C.spinError spinNodeGetImposedAccessMode(spinNodeHandle hNode,
                                                                 Spinnaker_C.spinAccessMode imposedAccessMode)
```
Retrieves the imposed access mode of a node

Parameters:

hNode - The node of the imposed access mode to retrieve

imposedAccessMode - The access mode enum pointer in which the imposed access mode is returned

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

Spinnaker_C.spinError

spinNodeGetImposedAccessMode

@Cast(value="spinError")
public static int spinNodeGetImposedAccessMode(spinNodeHandle hNode,
                                                                         @Cast(value="spinAccessMode")
                                                                         int imposedAccessMode)

spinNodeGetImposedVisibility
```
public static Spinnaker_C.spinError spinNodeGetImposedVisibility(spinNodeHandle hNode,
                                                                 Spinnaker_C.spinVisibility imposedVisibility)
```
Retrieves the imposed visibility of a node

Parameters:

hNode - The node of the visibility to impose

imposedVisibility - The visibility enum pointer in which the imposed visibility is returned

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

Spinnaker_C.spinError

spinNodeGetImposedVisibility

@Cast(value="spinError")
public static int spinNodeGetImposedVisibility(spinNodeHandle hNode,
                                                                         @Cast(value="spinVisibility")
                                                                         int imposedVisibility)

spinNodeToString

public static Spinnaker_C.spinError spinNodeToString(spinNodeHandle hNode,
                                                     @Cast(value="char*")
                                                     BytePointer pBuf,
                                                     @Cast(value="size_t*")
                                                     SizeTPointer pBufLen)

Retrieves the value of any node type as a c-string

Parameters:: hNode - The node of the value to read; pBuf - The c-string character buffer in which the value of the node is returned; pBufLen - The unsigned integer pointer in which the length of the c-string is returned; the input value is the maximum length
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinNodeToString

@Cast(value="spinError")
public static int spinNodeToString(spinNodeHandle hNode,
                                                             @Cast(value="char*")
                                                             ByteBuffer pBuf,
                                                             @Cast(value="size_t*")
                                                             SizeTPointer pBufLen)

spinNodeToString

public static Spinnaker_C.spinError spinNodeToString(spinNodeHandle hNode,
                                                     @Cast(value="char*")
                                                     byte[] pBuf,
                                                     @Cast(value="size_t*")
                                                     SizeTPointer pBufLen)

spinNodeToStringEx

public static Spinnaker_C.spinError spinNodeToStringEx(spinNodeHandle hNode,
                                                       @Cast(value="bool8_t")
                                                       byte bVerify,
                                                       @Cast(value="char*")
                                                       BytePointer pBuf,
                                                       @Cast(value="size_t*")
                                                       SizeTPointer pBufLen)

Retrieves the value of any node type as a c-string; manually set whether to verify the node

Parameters:: hNode - The node of the value to read; bVerify - The boolean of whether to verify the node; pBuf - The c-string character buffer in which the value of the node is returned; pBufLen - The unsigned integer pointer in which the length of the c-string is returned; the input value is the maximum length
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinNodeToStringEx

@Cast(value="spinError")
public static int spinNodeToStringEx(spinNodeHandle hNode,
                                                               @Cast(value="bool8_t")
                                                               byte bVerify,
                                                               @Cast(value="char*")
                                                               ByteBuffer pBuf,
                                                               @Cast(value="size_t*")
                                                               SizeTPointer pBufLen)

spinNodeToStringEx

public static Spinnaker_C.spinError spinNodeToStringEx(spinNodeHandle hNode,
                                                       @Cast(value="bool8_t")
                                                       byte bVerify,
                                                       @Cast(value="char*")
                                                       byte[] pBuf,
                                                       @Cast(value="size_t*")
                                                       SizeTPointer pBufLen)

spinNodeFromString
```
public static Spinnaker_C.spinError spinNodeFromString(spinNodeHandle hNode,
                                                       @Cast(value="const char*")
                                                       BytePointer pBuf)
```
Sets the value of any node type from a c-string; it is important to ensure that the value of the c-string is appropriate to the node type

Parameters:

hNode - The node having its value changed

pBuf - The c-string of the value to set

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

Spinnaker_C.spinError

spinNodeFromString

@Cast(value="spinError")
public static int spinNodeFromString(spinNodeHandle hNode,
                                                               String pBuf)

spinNodeFromStringEx

public static Spinnaker_C.spinError spinNodeFromStringEx(spinNodeHandle hNode,
                                                         @Cast(value="bool8_t")
                                                         byte bVerify,
                                                         @Cast(value="const char*")
                                                         BytePointer pBuf)

Sets the value of any node type from a c-string; manually set whether to verify the node; ensure the value of the c-string is appropriate to the node type

Parameters:: hNode - The node having its value changed; bVerify - The boolean of whether to verify the node; pBuf - The c-string of the value to set
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinNodeFromStringEx

@Cast(value="spinError")
public static int spinNodeFromStringEx(spinNodeHandle hNode,
                                                                 @Cast(value="bool8_t")
                                                                 byte bVerify,
                                                                 String pBuf)

spinStringSetValue

public static Spinnaker_C.spinError spinStringSetValue(spinNodeHandle hNode,
                                                       @Cast(value="const char*")
                                                       BytePointer pBuf)

Sets the value of a string node

Parameters:: hNode - The string node having its value changed; pBuf - The c-string of the value to set
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinStringSetValue

@Cast(value="spinError")
public static int spinStringSetValue(spinNodeHandle hNode,
                                                               String pBuf)

spinStringSetValueEx

public static Spinnaker_C.spinError spinStringSetValueEx(spinNodeHandle hNode,
                                                         @Cast(value="bool8_t")
                                                         byte bVerify,
                                                         @Cast(value="const char*")
                                                         BytePointer pBuf)

Sets the value of a string node; manually set whether to verify the node

Parameters:: hNode - The string node having its value changed; bVerify - The boolean of whether to verify the node; pBuf - The c-string of the value to set
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinStringSetValueEx

@Cast(value="spinError")
public static int spinStringSetValueEx(spinNodeHandle hNode,
                                                                 @Cast(value="bool8_t")
                                                                 byte bVerify,
                                                                 String pBuf)

spinStringGetValue

public static Spinnaker_C.spinError spinStringGetValue(spinNodeHandle hNode,
                                                       @Cast(value="char*")
                                                       BytePointer pBuf,
                                                       @Cast(value="size_t*")
                                                       SizeTPointer pBufLen)

Retrieves the value of a string node as a c-string

Parameters:: hNode - The string node of the value to read; pBuf - The c-string character buffer in which the value of the node is returned; pBufLen - The unsigned integer pointer in which the length of the c-string is returned; the input value is the maximum length
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinStringGetValue

@Cast(value="spinError")
public static int spinStringGetValue(spinNodeHandle hNode,
                                                               @Cast(value="char*")
                                                               ByteBuffer pBuf,
                                                               @Cast(value="size_t*")
                                                               SizeTPointer pBufLen)

spinStringGetValue

public static Spinnaker_C.spinError spinStringGetValue(spinNodeHandle hNode,
                                                       @Cast(value="char*")
                                                       byte[] pBuf,
                                                       @Cast(value="size_t*")
                                                       SizeTPointer pBufLen)

spinStringGetValueEx

public static Spinnaker_C.spinError spinStringGetValueEx(spinNodeHandle hNode,
                                                         @Cast(value="bool8_t")
                                                         byte bVerify,
                                                         @Cast(value="char*")
                                                         BytePointer pBuf,
                                                         @Cast(value="size_t*")
                                                         SizeTPointer pBufLen)

Retrieves the value of a string node as a cstring; manually set whether to verify the node

Parameters:: hNode - The string node of the value to read; bVerify - The boolean of whether to verify the node; pBuf - The c-string character buffer in which the value of the node is returned; pBufLen - The unsigned integer pointer in which the length of the c-string is returned; the input value is the maximum length
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinStringGetValueEx

@Cast(value="spinError")
public static int spinStringGetValueEx(spinNodeHandle hNode,
                                                                 @Cast(value="bool8_t")
                                                                 byte bVerify,
                                                                 @Cast(value="char*")
                                                                 ByteBuffer pBuf,
                                                                 @Cast(value="size_t*")
                                                                 SizeTPointer pBufLen)

spinStringGetValueEx

public static Spinnaker_C.spinError spinStringGetValueEx(spinNodeHandle hNode,
                                                         @Cast(value="bool8_t")
                                                         byte bVerify,
                                                         @Cast(value="char*")
                                                         byte[] pBuf,
                                                         @Cast(value="size_t*")
                                                         SizeTPointer pBufLen)

spinStringGetMaxLength

public static Spinnaker_C.spinError spinStringGetMaxLength(spinNodeHandle hNode,
                                                           @Cast(value="int64_t*")
                                                           LongPointer pValue)

Retrieves the maximum length of the c-string to be returned

Parameters:: hNode - The string node of the length to retrieve; pValue - The integer pointer in which the maximum length of the c-string is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinStringGetMaxLength

@Cast(value="spinError")
public static int spinStringGetMaxLength(spinNodeHandle hNode,
                                                                   @Cast(value="int64_t*")
                                                                   LongBuffer pValue)

spinStringGetMaxLength

public static Spinnaker_C.spinError spinStringGetMaxLength(spinNodeHandle hNode,
                                                           @Cast(value="int64_t*")
                                                           long[] pValue)

spinIntegerSetValue

public static Spinnaker_C.spinError spinIntegerSetValue(spinNodeHandle hNode,
                                                        @Cast(value="int64_t")
                                                        long value)

Sets the value of an integer node

Parameters:: hNode - The integer node having its value changed; value - The integer value to set
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinIntegerSetValueEx

public static Spinnaker_C.spinError spinIntegerSetValueEx(spinNodeHandle hNode,
                                                          @Cast(value="bool8_t")
                                                          byte bVerify,
                                                          @Cast(value="int64_t")
                                                          long value)

Sets the value of an integer node; manually set whether to verify the node

Parameters:: hNode - The integer node having its value changed; bVerify - The boolean of whether to verify the node; value - The integer value to set
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinIntegerGetValue

public static Spinnaker_C.spinError spinIntegerGetValue(spinNodeHandle hNode,
                                                        @Cast(value="int64_t*")
                                                        LongPointer pValue)

Retrieves the value of an integer node

Parameters:: hNode - The integer node of the value to read; pValue - The integer pointer in which the value is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinIntegerGetValue

@Cast(value="spinError")
public static int spinIntegerGetValue(spinNodeHandle hNode,
                                                                @Cast(value="int64_t*")
                                                                LongBuffer pValue)

spinIntegerGetValue

public static Spinnaker_C.spinError spinIntegerGetValue(spinNodeHandle hNode,
                                                        @Cast(value="int64_t*")
                                                        long[] pValue)

spinIntegerGetValueEx

public static Spinnaker_C.spinError spinIntegerGetValueEx(spinNodeHandle hNode,
                                                          @Cast(value="bool8_t")
                                                          byte bVerify,
                                                          @Cast(value="int64_t*")
                                                          LongPointer pValue)

Retrieves the value of an integer node; manually set whether to verify the node

Parameters:: hNode - The integer node of the value to read; bVerify - The boolean of whether to verify the node; pValue - The integer pointer in which the value is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinIntegerGetValueEx

@Cast(value="spinError")
public static int spinIntegerGetValueEx(spinNodeHandle hNode,
                                                                  @Cast(value="bool8_t")
                                                                  byte bVerify,
                                                                  @Cast(value="int64_t*")
                                                                  LongBuffer pValue)

spinIntegerGetValueEx

public static Spinnaker_C.spinError spinIntegerGetValueEx(spinNodeHandle hNode,
                                                          @Cast(value="bool8_t")
                                                          byte bVerify,
                                                          @Cast(value="int64_t*")
                                                          long[] pValue)

spinIntegerGetMin
```
public static Spinnaker_C.spinError spinIntegerGetMin(spinNodeHandle hNode,
                                                      @Cast(value="int64_t*")
                                                      LongPointer pValue)
```
Retrieves the minimum value of an integer node; all potential values must be greater than or equal to the minimum

Parameters:

hNode - The integer node of the minimum value to retrieve

pValue - The integer pointer in which the minimum value is returned

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

Spinnaker_C.spinError

spinIntegerGetMin

@Cast(value="spinError")
public static int spinIntegerGetMin(spinNodeHandle hNode,
                                                              @Cast(value="int64_t*")
                                                              LongBuffer pValue)

spinIntegerGetMin

public static Spinnaker_C.spinError spinIntegerGetMin(spinNodeHandle hNode,
                                                      @Cast(value="int64_t*")
                                                      long[] pValue)

spinIntegerGetMax
```
public static Spinnaker_C.spinError spinIntegerGetMax(spinNodeHandle hNode,
                                                      @Cast(value="int64_t*")
                                                      LongPointer pValue)
```
Retrieves the maximum value of an integer node; all potential values must be lesser than or equal to the maximum

Parameters:

hNode - The integer node of the maximum value to retrieve

pValue - The integer pointer in which the maximum value is returned

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

Spinnaker_C.spinError

spinIntegerGetMax

@Cast(value="spinError")
public static int spinIntegerGetMax(spinNodeHandle hNode,
                                                              @Cast(value="int64_t*")
                                                              LongBuffer pValue)

spinIntegerGetMax

public static Spinnaker_C.spinError spinIntegerGetMax(spinNodeHandle hNode,
                                                      @Cast(value="int64_t*")
                                                      long[] pValue)

spinIntegerGetInc
```
public static Spinnaker_C.spinError spinIntegerGetInc(spinNodeHandle hNode,
                                                      @Cast(value="int64_t*")
                                                      LongPointer pValue)
```
Retrieves the increment of an integer node; all possible values must be divisible by the increment

Parameters:

hNode - The integer node of the increment to retrieve

pValue - The integer pointer in which the increment is returned

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

Spinnaker_C.spinError

spinIntegerGetInc

@Cast(value="spinError")
public static int spinIntegerGetInc(spinNodeHandle hNode,
                                                              @Cast(value="int64_t*")
                                                              LongBuffer pValue)

spinIntegerGetInc

public static Spinnaker_C.spinError spinIntegerGetInc(spinNodeHandle hNode,
                                                      @Cast(value="int64_t*")
                                                      long[] pValue)

spinIntegerGetRepresentation
```
public static Spinnaker_C.spinError spinIntegerGetRepresentation(spinNodeHandle hNode,
                                                                 @Cast(value="spinRepresentation*")
                                                                 IntPointer pValue)
```
Retrieves the numerical representation of the value of a node; i.e. linear, logarithmic, hexidecimal, MAC address, etc.

Parameters:

hNode - The integer node of the numerical representation to retrieve

pValue - The representation enum pointer in which the type of numerical representation is returned

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

Spinnaker_C.spinError

spinIntegerGetRepresentation

@Cast(value="spinError")
public static int spinIntegerGetRepresentation(spinNodeHandle hNode,
                                                                         @Cast(value="spinRepresentation*")
                                                                         IntBuffer pValue)

spinIntegerGetRepresentation

public static Spinnaker_C.spinError spinIntegerGetRepresentation(spinNodeHandle hNode,
                                                                 @Cast(value="spinRepresentation*")
                                                                 int[] pValue)

spinFloatSetValue
```
public static Spinnaker_C.spinError spinFloatSetValue(spinNodeHandle hNode,
                                                      double value)
```
Sets the value of a float node

Parameters:

hNode - The float node having its value changed

value - The float value to set

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

Spinnaker_C.spinError

spinFloatSetValueEx

public static Spinnaker_C.spinError spinFloatSetValueEx(spinNodeHandle hNode,
                                                        @Cast(value="bool8_t")
                                                        byte bVerify,
                                                        double value)

Sets the value of a float node; manually set whether to verify the node

Parameters:: hNode - The float node having its value changed; bVerify - The boolean of whether to verify the node; value - The float value to set
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinFloatGetValue
```
public static Spinnaker_C.spinError spinFloatGetValue(spinNodeHandle hNode,
                                                      DoublePointer pValue)
```
Retrieves the value of a float node

Parameters:

hNode - The float node of the value to read

pValue - The double pointer in which the value is returned

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

Spinnaker_C.spinError

spinFloatGetValue

@Cast(value="spinError")
public static int spinFloatGetValue(spinNodeHandle hNode,
                                                              DoubleBuffer pValue)

spinFloatGetValue

public static Spinnaker_C.spinError spinFloatGetValue(spinNodeHandle hNode,
                                                      double[] pValue)

spinFloatGetValueEx

public static Spinnaker_C.spinError spinFloatGetValueEx(spinNodeHandle hNode,
                                                        @Cast(value="bool8_t")
                                                        byte bVerify,
                                                        DoublePointer pValue)

Retrieves the value of a float node; manually set whether to verify the node

Parameters:: hNode - The float node of the value to read; pValue - The double pointer in which the value is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinFloatGetValueEx

@Cast(value="spinError")
public static int spinFloatGetValueEx(spinNodeHandle hNode,
                                                                @Cast(value="bool8_t")
                                                                byte bVerify,
                                                                DoubleBuffer pValue)

spinFloatGetValueEx

public static Spinnaker_C.spinError spinFloatGetValueEx(spinNodeHandle hNode,
                                                        @Cast(value="bool8_t")
                                                        byte bVerify,
                                                        double[] pValue)

spinFloatGetMin
```
public static Spinnaker_C.spinError spinFloatGetMin(spinNodeHandle hNode,
                                                    DoublePointer pValue)
```
Retrieves the minimum value of a float node; all potential values must be greater than or equal to the minimum

Parameters:

hNode - The float node of the minimum value to retrieve

pValue - The double pointer in which the minimum value is returned

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

Spinnaker_C.spinError

spinFloatGetMin

@Cast(value="spinError")
public static int spinFloatGetMin(spinNodeHandle hNode,
                                                            DoubleBuffer pValue)

spinFloatGetMin

public static Spinnaker_C.spinError spinFloatGetMin(spinNodeHandle hNode,
                                                    double[] pValue)

spinFloatGetMax
```
public static Spinnaker_C.spinError spinFloatGetMax(spinNodeHandle hNode,
                                                    DoublePointer pValue)
```
Retrieves the maximum value of a float node; all potential values must be lesser than or equal to the maximum

Parameters:

hNode - The float node of the maximum value to retrieve

pValue - The double pointer in which the maximum value is returned

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

Spinnaker_C.spinError

spinFloatGetMax

@Cast(value="spinError")
public static int spinFloatGetMax(spinNodeHandle hNode,
                                                            DoubleBuffer pValue)

spinFloatGetMax

public static Spinnaker_C.spinError spinFloatGetMax(spinNodeHandle hNode,
                                                    double[] pValue)

spinFloatGetRepresentation
```
public static Spinnaker_C.spinError spinFloatGetRepresentation(spinNodeHandle hNode,
                                                               @Cast(value="spinRepresentation*")
                                                               IntPointer pValue)
```
Retrieves the numerical representation of the value of a node; i.e. linear, logarithmic, hexidecimal, MAC address, etc.

Parameters:

hNode - The float node of the numerical representation to retrieve

pValue - The representation enum pointer in which the type of numerical representation is returned

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

Spinnaker_C.spinError

spinFloatGetRepresentation

@Cast(value="spinError")
public static int spinFloatGetRepresentation(spinNodeHandle hNode,
                                                                       @Cast(value="spinRepresentation*")
                                                                       IntBuffer pValue)

spinFloatGetRepresentation

public static Spinnaker_C.spinError spinFloatGetRepresentation(spinNodeHandle hNode,
                                                               @Cast(value="spinRepresentation*")
                                                               int[] pValue)

spinFloatGetUnit

public static Spinnaker_C.spinError spinFloatGetUnit(spinNodeHandle hNode,
                                                     @Cast(value="char*")
                                                     BytePointer pBuf,
                                                     @Cast(value="size_t*")
                                                     SizeTPointer pBufLen)

Retrieves the units of the float node value

Parameters:: hNode - The float node of the units to retrieve; pBuf - The c-string character buffer in which the value units are returned; pBufLen - The unsigned integer pointer in which the length of the c-string is returned; the input value is the maximum length
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinFloatGetUnit

@Cast(value="spinError")
public static int spinFloatGetUnit(spinNodeHandle hNode,
                                                             @Cast(value="char*")
                                                             ByteBuffer pBuf,
                                                             @Cast(value="size_t*")
                                                             SizeTPointer pBufLen)

spinFloatGetUnit

public static Spinnaker_C.spinError spinFloatGetUnit(spinNodeHandle hNode,
                                                     @Cast(value="char*")
                                                     byte[] pBuf,
                                                     @Cast(value="size_t*")
                                                     SizeTPointer pBufLen)

spinEnumerationGetNumEntries

public static Spinnaker_C.spinError spinEnumerationGetNumEntries(spinNodeHandle hEnumNode,
                                                                 @Cast(value="size_t*")
                                                                 SizeTPointer pValue)

Retrieves the number of entries of an enum node

Parameters:: hEnumNode - The enum node where the entries to be counted are; pValue - The unsigned integer pointer in which the number of entries is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinEnumerationGetEntryByIndex

public static Spinnaker_C.spinError spinEnumerationGetEntryByIndex(spinNodeHandle hEnumNode,
                                                                   @Cast(value="size_t")
                                                                   long index,
                                                                   @ByPtrPtr
                                                                   spinNodeHandle phEntry)

Retrieves an entry node from an enum node using an index

Parameters:: hEnumNode - The enum node from which the entry node is retrieved; index - The index of the entry node; phEntry - The node handle pointer in which the entry node is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinEnumerationGetEntryByName

public static Spinnaker_C.spinError spinEnumerationGetEntryByName(spinNodeHandle hEnumNode,
                                                                  @Cast(value="const char*")
                                                                  BytePointer pName,
                                                                  @ByPtrPtr
                                                                  spinNodeHandle phEntry)

Retrieves an entry node from an enum node using the entry's symbolic

Parameters:: hEnumNode - The enum node from which the entry node is retrieved; pName - The name of the entry node; phEntry - The node handle pointer in which the entry node is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinEnumerationGetEntryByName

@Cast(value="spinError")
public static int spinEnumerationGetEntryByName(spinNodeHandle hEnumNode,
                                                                          String pName,
                                                                          @ByPtrPtr
                                                                          spinNodeHandle phEntry)

spinEnumerationGetCurrentEntry

public static Spinnaker_C.spinError spinEnumerationGetCurrentEntry(spinNodeHandle hEnumNode,
                                                                   @ByPtrPtr
                                                                   spinNodeHandle phEntry)

Retrieves the currently selected entry node from an enum node

Parameters:: hEnumNode - The enum node from which the current entry node is retrieved; phEntry - The node handle pointer in which the current entry node is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinEnumerationReleaseNode
```
public static Spinnaker_C.spinError spinEnumerationReleaseNode(spinNodeHandle hEnumNode,
                                                               spinNodeHandle hEntry)
```
Releases the entry node from the enum node handle. Make sure node handle is cleaned up properly by setting it to NULL after the node is released If this function is not explicitly called, the handle will be released upon the release of the camera handle.

Parameters:

hEnumNode - The enum node from which the current entry node is retrieved

hEntry - The entry node handle to be released

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

spinCameraRelease, Spinnaker_C.spinError

spinEnumerationSetIntValue
```
public static Spinnaker_C.spinError spinEnumerationSetIntValue(spinNodeHandle hEnumNode,
                                                               @Cast(value="int64_t")
                                                               long value)
```
Sets a new entry using its integer value retrieved from a call to spinEnumerationEntryGetIntValue(); note that enumeration entry int and enum values are different - int values defined on camera, enum values found in SpinnakerDefsC.h

Parameters:

hEnumNode - The enum node having its entry changed

value - The integer value of the entry node to set; this corresponds to the integer value internal to the camera

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

spinEnumerationEntryGetIntValue(), Spinnaker_C.spinError

spinEnumerationSetEnumValue
```
public static Spinnaker_C.spinError spinEnumerationSetEnumValue(spinNodeHandle hEnumNode,
                                                                @Cast(value="size_t")
                                                                long value)
```
Sets a new entry using its enum; note that enumeration entry int and enum values are different - int values defined on camera, enum values found in SpinnakerDefsC.h

Parameters:

hEnumNode - The enum node have its entry changed

value - The enum value of the entry node to set; this corresponds to its integer value created in the library

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

spinEnumerationEntryGetEnumValue(), Spinnaker_C.spinError

spinEnumerationEntryGetIntValue
```
public static Spinnaker_C.spinError spinEnumerationEntryGetIntValue(spinNodeHandle hNode,
                                                                    @Cast(value="int64_t*")
                                                                    LongPointer pValue)
```
Retrieves the integer value of an entry node; note that enumeration entry int and enum values are different - int values defined on camera, enum values found in SpinnakerDefsC.h

Parameters:

hNode - The entry node of the integer value to retrieve

pValue - The integer pointer in which the integer value of the entry is returned

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

spinEnumerationSetIntValue(), Spinnaker_C.spinError

spinEnumerationEntryGetIntValue

@Cast(value="spinError")
public static int spinEnumerationEntryGetIntValue(spinNodeHandle hNode,
                                                                            @Cast(value="int64_t*")
                                                                            LongBuffer pValue)

spinEnumerationEntryGetIntValue

public static Spinnaker_C.spinError spinEnumerationEntryGetIntValue(spinNodeHandle hNode,
                                                                    @Cast(value="int64_t*")
                                                                    long[] pValue)

spinEnumerationEntryGetEnumValue
```
public static Spinnaker_C.spinError spinEnumerationEntryGetEnumValue(spinNodeHandle hNode,
                                                                     @Cast(value="size_t*")
                                                                     SizeTPointer pValue)
```
Retrieves the enum value (as an integer) of an entry node; note that enumeraiton entry int and enum values are different - int values defined on camera, enum values found in SpinnakerDefsC.h

Parameters:

hNode - The entry node of the enum value to retrieve

pValue - The unsigned integer pointer in which the enum value of the entry is returned

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

spinEnumerationSetEnumValue(), Spinnaker_C.spinError

spinEnumerationEntryGetSymbolic

public static Spinnaker_C.spinError spinEnumerationEntryGetSymbolic(spinNodeHandle hNode,
                                                                    @Cast(value="char*")
                                                                    BytePointer pBuf,
                                                                    @Cast(value="size_t*")
                                                                    SizeTPointer pBufLen)

Retrieves the symbolic of an entry node as a c-string

Parameters:: hNode - The entry node of the symbolic to retrieve; pBuf - The c-string character buffer in which the symbolic of the entry node is returned; pBufLen - The unsigned integer pointer in which the length of the c-string is returned; the input value is the maximum length
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinEnumerationEntryGetSymbolic

@Cast(value="spinError")
public static int spinEnumerationEntryGetSymbolic(spinNodeHandle hNode,
                                                                            @Cast(value="char*")
                                                                            ByteBuffer pBuf,
                                                                            @Cast(value="size_t*")
                                                                            SizeTPointer pBufLen)

spinEnumerationEntryGetSymbolic

public static Spinnaker_C.spinError spinEnumerationEntryGetSymbolic(spinNodeHandle hNode,
                                                                    @Cast(value="char*")
                                                                    byte[] pBuf,
                                                                    @Cast(value="size_t*")
                                                                    SizeTPointer pBufLen)

spinBooleanSetValue
```
public static Spinnaker_C.spinError spinBooleanSetValue(spinNodeHandle hNode,
                                                        @Cast(value="bool8_t")
                                                        byte value)
```
Sets the value of a boolean node; boolean values are represented by 'True' (which equals '0') and 'False' (which equals '1')

Parameters:

hNode - The boolean node having its value changed

value - The boolean value to set

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

Spinnaker_C.spinError

spinBooleanGetValue
```
public static Spinnaker_C.spinError spinBooleanGetValue(spinNodeHandle hNode,
                                                        @Cast(value="bool8_t*")
                                                        BytePointer pbValue)
```
Retrieves the value of a boolean node; boolean values are represented by 'True' (which equals '0') and 'False' (which equals '1')

Parameters:

hNode - The boolean node of the value to read

pValue - The boolean pointer in which the value is returned

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

Spinnaker_C.spinError

spinBooleanGetValue

@Cast(value="spinError")
public static int spinBooleanGetValue(spinNodeHandle hNode,
                                                                @Cast(value="bool8_t*")
                                                                ByteBuffer pbValue)

spinBooleanGetValue

public static Spinnaker_C.spinError spinBooleanGetValue(spinNodeHandle hNode,
                                                        @Cast(value="bool8_t*")
                                                        byte[] pbValue)

spinCommandExecute
```
public static Spinnaker_C.spinError spinCommandExecute(spinNodeHandle hNode)
```
Executes the action associated to a command node

Parameters:

hNode - The command node to execute

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

Spinnaker_C.spinError

spinCommandIsDone

public static Spinnaker_C.spinError spinCommandIsDone(spinNodeHandle hNode,
                                                      @Cast(value="bool8_t*")
                                                      BytePointer pbValue)

Retrieves whether or not the action of a command node has completed

Parameters:: hNode - The command node to check; pValue - The boolean pointer to return whether or not the command has completed
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinCommandIsDone

@Cast(value="spinError")
public static int spinCommandIsDone(spinNodeHandle hNode,
                                                              @Cast(value="bool8_t*")
                                                              ByteBuffer pbValue)

spinCommandIsDone

public static Spinnaker_C.spinError spinCommandIsDone(spinNodeHandle hNode,
                                                      @Cast(value="bool8_t*")
                                                      byte[] pbValue)

spinCategoryGetNumFeatures

public static Spinnaker_C.spinError spinCategoryGetNumFeatures(spinNodeHandle hCategoryNode,
                                                               @Cast(value="size_t*")
                                                               SizeTPointer pValue)

Retrieves the number of a features (or child nodes) or a category node

Parameters:: hCategoryNode - The category node where the features to be counted are; pValue - The unsigned integer pointer in which the number of features is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinCategoryGetFeatureByIndex

public static Spinnaker_C.spinError spinCategoryGetFeatureByIndex(spinNodeHandle hCategoryNode,
                                                                  @Cast(value="size_t")
                                                                  long index,
                                                                  @ByPtrPtr
                                                                  spinNodeHandle phFeature)

Retrieves a node from a category node using an index

Parameters:: hCategoryNode - The category node of the node to retrieve; index - The index of the feature node; phFeature - The node handle pointer in which the feature node is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinCategoryReleaseNode
```
public static Spinnaker_C.spinError spinCategoryReleaseNode(spinNodeHandle hCategoryNode,
                                                            spinNodeHandle hFeature)
```
Releases the feature node from the category node. Make sure node handle is cleaned up properly by setting it to NULL after the node is released If this function is not explicitly called, the handle will be released upon the release of the camera handle.

Parameters:

hCategoryNode - The category node handle from which the feature node is retrieved

hFeature - The feature node handle to be released

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

spinCameraRelease, Spinnaker_C.spinError

spinRegisterGet

public static Spinnaker_C.spinError spinRegisterGet(spinNodeHandle hNode,
                                                    @Cast(value="uint8_t*")
                                                    BytePointer pBuf,
                                                    @Cast(value="int64_t")
                                                    long length)

Retrieves the value of a register node

Parameters:: hNode - The register node of the value to retrieve; pBuf - The unsigned integer buffer in which the value is returned; length - The integer pointer in which the length of the register array is returned; the input value is the maximum length
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinRegisterGet

@Cast(value="spinError")
public static int spinRegisterGet(spinNodeHandle hNode,
                                                            @Cast(value="uint8_t*")
                                                            ByteBuffer pBuf,
                                                            @Cast(value="int64_t")
                                                            long length)

spinRegisterGet

public static Spinnaker_C.spinError spinRegisterGet(spinNodeHandle hNode,
                                                    @Cast(value="uint8_t*")
                                                    byte[] pBuf,
                                                    @Cast(value="int64_t")
                                                    long length)

spinRegisterGetEx

public static Spinnaker_C.spinError spinRegisterGetEx(spinNodeHandle hNode,
                                                      @Cast(value="bool8_t")
                                                      byte bVerify,
                                                      @Cast(value="bool8_t")
                                                      byte bIgnoreCache,
                                                      @Cast(value="uint8_t*")
                                                      BytePointer pBuf,
                                                      @Cast(value="int64_t")
                                                      long length)

Retrieves the value of a register node; manually set whether to verify the node and whether to ignore the cache

Parameters:: hNode - The register node of the value to retrieve; bVerify - The boolean of whether to verify the node; IgnoreCache - The boolean of whether to ignore the cache; pBuf - The unsigned integer buffer in which the value is returned; length - The integer pointer in which the length of the register array is returned; the input value is the maximum length
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinRegisterGetEx

@Cast(value="spinError")
public static int spinRegisterGetEx(spinNodeHandle hNode,
                                                              @Cast(value="bool8_t")
                                                              byte bVerify,
                                                              @Cast(value="bool8_t")
                                                              byte bIgnoreCache,
                                                              @Cast(value="uint8_t*")
                                                              ByteBuffer pBuf,
                                                              @Cast(value="int64_t")
                                                              long length)

spinRegisterGetEx

public static Spinnaker_C.spinError spinRegisterGetEx(spinNodeHandle hNode,
                                                      @Cast(value="bool8_t")
                                                      byte bVerify,
                                                      @Cast(value="bool8_t")
                                                      byte bIgnoreCache,
                                                      @Cast(value="uint8_t*")
                                                      byte[] pBuf,
                                                      @Cast(value="int64_t")
                                                      long length)

spinRegisterGetAddress

public static Spinnaker_C.spinError spinRegisterGetAddress(spinNodeHandle hNode,
                                                           @Cast(value="int64_t*")
                                                           LongPointer pAddress)

Retrieves the address of a register node

Parameters:: hNode - The register node of the address to retrieve; pAddress - The integer pointer in which the address is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinRegisterGetAddress

@Cast(value="spinError")
public static int spinRegisterGetAddress(spinNodeHandle hNode,
                                                                   @Cast(value="int64_t*")
                                                                   LongBuffer pAddress)

spinRegisterGetAddress

public static Spinnaker_C.spinError spinRegisterGetAddress(spinNodeHandle hNode,
                                                           @Cast(value="int64_t*")
                                                           long[] pAddress)

spinRegisterGetLength

public static Spinnaker_C.spinError spinRegisterGetLength(spinNodeHandle hNode,
                                                          @Cast(value="int64_t*")
                                                          LongPointer pLength)

Retrieves the length (in bytes) of the value of a register node

Parameters:: hNode - The register node of the length to retrieve; plength - The integer in which the number of bytes is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinRegisterGetLength

@Cast(value="spinError")
public static int spinRegisterGetLength(spinNodeHandle hNode,
                                                                  @Cast(value="int64_t*")
                                                                  LongBuffer pLength)

spinRegisterGetLength

public static Spinnaker_C.spinError spinRegisterGetLength(spinNodeHandle hNode,
                                                          @Cast(value="int64_t*")
                                                          long[] pLength)

spinRegisterSet

public static Spinnaker_C.spinError spinRegisterSet(spinNodeHandle hNode,
                                                    @Cast(value="const uint8_t*")
                                                    BytePointer pBuf,
                                                    @Cast(value="int64_t")
                                                    long length)

Sets the value of a register node

Parameters:: hNode - The register node of the value to set; pBuf - The unsigned integer buffer of the value to set; length - The number of bytes of the value to set
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinRegisterSet

@Cast(value="spinError")
public static int spinRegisterSet(spinNodeHandle hNode,
                                                            @Cast(value="const uint8_t*")
                                                            ByteBuffer pBuf,
                                                            @Cast(value="int64_t")
                                                            long length)

spinRegisterSet

public static Spinnaker_C.spinError spinRegisterSet(spinNodeHandle hNode,
                                                    @Cast(value="const uint8_t*")
                                                    byte[] pBuf,
                                                    @Cast(value="int64_t")
                                                    long length)

spinRegisterSetReference
```
public static Spinnaker_C.spinError spinRegisterSetReference(spinNodeHandle hNode,
                                                             spinNodeHandle hRef)
```
Uses a second node as a reference for a register node

Parameters:

hNode - The register node that houses the reference

hRef - The reference node

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

Spinnaker_C.spinError

spinErrorGetLast
```
public static Spinnaker_C.spinError spinErrorGetLast(@Cast(value="spinError*")
                                                     IntPointer pError)
```
Retrieves the error code of the last error

Parameters:

pError - The error enum pointer in which the error message is returned

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

Spinnaker_C.spinError

spinErrorGetLast

@Cast(value="spinError")
public static int spinErrorGetLast(@Cast(value="spinError*")
                                                             IntBuffer pError)

spinErrorGetLast

public static Spinnaker_C.spinError spinErrorGetLast(@Cast(value="spinError*")
                                                     int[] pError)

spinErrorGetLastMessage

public static Spinnaker_C.spinError spinErrorGetLastMessage(@Cast(value="char*")
                                                            BytePointer pBuf,
                                                            @Cast(value="size_t*")
                                                            SizeTPointer pBufLen)

Retrieves the error message of the last error

Parameters:: pBuf - The c-string character buffer in which the error message is returned; pBufLen - The unsigned integer pointer in which the length of the c-string is returned; the input value is the maximum length
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinErrorGetLastMessage

@Cast(value="spinError")
public static int spinErrorGetLastMessage(@Cast(value="char*")
                                                                    ByteBuffer pBuf,
                                                                    @Cast(value="size_t*")
                                                                    SizeTPointer pBufLen)

spinErrorGetLastMessage

public static Spinnaker_C.spinError spinErrorGetLastMessage(@Cast(value="char*")
                                                            byte[] pBuf,
                                                            @Cast(value="size_t*")
                                                            SizeTPointer pBufLen)

spinErrorGetLastBuildDate

public static Spinnaker_C.spinError spinErrorGetLastBuildDate(@Cast(value="char*")
                                                              BytePointer pBuf,
                                                              @Cast(value="size_t*")
                                                              SizeTPointer pBufLen)

Retrieves the build date of the last error

Parameters:: pBuf - The c-string character buffer in which the build date is returned; pBufLen - The unsigned integer pointer in which the length of the c-string is returned; the input value is the maximum length
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinErrorGetLastBuildDate

@Cast(value="spinError")
public static int spinErrorGetLastBuildDate(@Cast(value="char*")
                                                                      ByteBuffer pBuf,
                                                                      @Cast(value="size_t*")
                                                                      SizeTPointer pBufLen)

spinErrorGetLastBuildDate

public static Spinnaker_C.spinError spinErrorGetLastBuildDate(@Cast(value="char*")
                                                              byte[] pBuf,
                                                              @Cast(value="size_t*")
                                                              SizeTPointer pBufLen)

spinErrorGetLastBuildTime

public static Spinnaker_C.spinError spinErrorGetLastBuildTime(@Cast(value="char*")
                                                              BytePointer pBuf,
                                                              @Cast(value="size_t*")
                                                              SizeTPointer pBufLen)

Retrieves the build time of the last error

Parameters:: pBuf - The c-string character buffer in which the build time is returned; pBufLen - The unsigned integer pointer in which the length of the c-string is returned; the input value is the maximum length
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinErrorGetLastBuildTime

@Cast(value="spinError")
public static int spinErrorGetLastBuildTime(@Cast(value="char*")
                                                                      ByteBuffer pBuf,
                                                                      @Cast(value="size_t*")
                                                                      SizeTPointer pBufLen)

spinErrorGetLastBuildTime

public static Spinnaker_C.spinError spinErrorGetLastBuildTime(@Cast(value="char*")
                                                              byte[] pBuf,
                                                              @Cast(value="size_t*")
                                                              SizeTPointer pBufLen)

spinErrorGetLastFileName

public static Spinnaker_C.spinError spinErrorGetLastFileName(@Cast(value="char*")
                                                             BytePointer pBuf,
                                                             @Cast(value="size_t*")
                                                             SizeTPointer pBufLen)

Retrieves the filename of the last error

Parameters:: pBuf - The c-string character buffer in which the file name is returned; pBufLen - The unsigned integer pointer in which the length of the c-string is returned; the input value is the maximum length
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinErrorGetLastFileName

@Cast(value="spinError")
public static int spinErrorGetLastFileName(@Cast(value="char*")
                                                                     ByteBuffer pBuf,
                                                                     @Cast(value="size_t*")
                                                                     SizeTPointer pBufLen)

spinErrorGetLastFileName

public static Spinnaker_C.spinError spinErrorGetLastFileName(@Cast(value="char*")
                                                             byte[] pBuf,
                                                             @Cast(value="size_t*")
                                                             SizeTPointer pBufLen)

spinErrorGetLastFullMessage

public static Spinnaker_C.spinError spinErrorGetLastFullMessage(@Cast(value="char*")
                                                                BytePointer pBuf,
                                                                @Cast(value="size_t*")
                                                                SizeTPointer pBufLen)

Retrieves the full error message of the last error

Parameters:: pBuf - The c-string character buffer in which the full error message is returned; pBufLen - The unsigned integer pointer in which the length of the c-string is returned; the input value is the maximum length
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinErrorGetLastFullMessage

@Cast(value="spinError")
public static int spinErrorGetLastFullMessage(@Cast(value="char*")
                                                                        ByteBuffer pBuf,
                                                                        @Cast(value="size_t*")
                                                                        SizeTPointer pBufLen)

spinErrorGetLastFullMessage

public static Spinnaker_C.spinError spinErrorGetLastFullMessage(@Cast(value="char*")
                                                                byte[] pBuf,
                                                                @Cast(value="size_t*")
                                                                SizeTPointer pBufLen)

spinErrorGetLastFunctionName

public static Spinnaker_C.spinError spinErrorGetLastFunctionName(@Cast(value="char*")
                                                                 BytePointer pBuf,
                                                                 @Cast(value="size_t*")
                                                                 SizeTPointer pBufLen)

Retrieves the function name of the last error

Parameters:: pBuf - The c-string character buffer in which the function name is returned; pBufLen - The unsigned integer pointer in which the length of the c-string is returned; the input value is the maximum length
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinErrorGetLastFunctionName

@Cast(value="spinError")
public static int spinErrorGetLastFunctionName(@Cast(value="char*")
                                                                         ByteBuffer pBuf,
                                                                         @Cast(value="size_t*")
                                                                         SizeTPointer pBufLen)

spinErrorGetLastFunctionName

public static Spinnaker_C.spinError spinErrorGetLastFunctionName(@Cast(value="char*")
                                                                 byte[] pBuf,
                                                                 @Cast(value="size_t*")
                                                                 SizeTPointer pBufLen)

spinErrorGetLastLineNumber
```
public static Spinnaker_C.spinError spinErrorGetLastLineNumber(@Cast(value="int64_t*")
                                                               LongPointer pLineNum)
```
Retrieves the line number of the last error

Parameters:

pBuf - The c-string character buffer in which the line number is returned

pBufLen - The unsigned integer pointer in which the length of the c-string is returned; the input value is the maximum length

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

Spinnaker_C.spinError

spinErrorGetLastLineNumber

@Cast(value="spinError")
public static int spinErrorGetLastLineNumber(@Cast(value="int64_t*")
                                                                       LongBuffer pLineNum)

spinErrorGetLastLineNumber

public static Spinnaker_C.spinError spinErrorGetLastLineNumber(@Cast(value="int64_t*")
                                                               long[] pLineNum)

spinSystemGetInstance
```
public static Spinnaker_C.spinError spinSystemGetInstance(@ByPtrPtr
                                                          spinSystem phSystem)
```
Retrieves an instance of the system object; the system is a singleton, so there will only ever be one instance; system instance must be destroyed by calling spinSystemReleaseInstance

Parameters:

phSystem - The system handle pointer in which the system instance is returned

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

spinSystemReleaseInstance, Spinnaker_C.spinError

spinSystemReleaseInstance
```
public static Spinnaker_C.spinError spinSystemReleaseInstance(spinSystem hSystem)
```
Releases the system; make sure handle is cleaned up properly by setting it to NULL after system is released; the handle can only be used again after calling spinSystemGetInstance

Parameters:

hSystem - The system handle

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

spinSystemGetInstance, Spinnaker_C.spinError

spinSystemGetInterfaces
```
public static Spinnaker_C.spinError spinSystemGetInterfaces(spinSystem hSystem,
                                                            spinInterfaceList hInterfaceList)
```
Retrieves a list of detected (and enumerable) interfaces on the system; interface lists must be created and destroyed

Parameters:

hSystem - The system, from which the interface list is retrieved

hInterfaceList - The interface list to house the interfaces from the system

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

spinInterfaceListCreateEmpty(), spinInterfaceListDestroy(), Spinnaker_C.spinError

spinSystemGetCameras
```
public static Spinnaker_C.spinError spinSystemGetCameras(spinSystem hSystem,
                                                         spinCameraList hCameraList)
```
Retrieves a list of detected (and enumerable) cameras on the system; camera lists must be created and destroyed

Parameters:

hSystem - The system, from which the camera list is retrieved

hCameraList - The camera list to house the cameras from the system

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

spinCameraListCreateEmpty(), spinCameraListDestroy(), Spinnaker_C.spinError

spinSystemGetCamerasEx

public static Spinnaker_C.spinError spinSystemGetCamerasEx(spinSystem hSystem,
                                                           @Cast(value="bool8_t")
                                                           byte bUpdateInterfaces,
                                                           @Cast(value="bool8_t")
                                                           byte bUpdateCameras,
                                                           spinCameraList hCameraList)

Retrieves a list of detected (and enumerable) cameras on the system; manually set whether to update the current interface and camera lists; camera lists must be created and destroyed

Parameters:: hSystem - The system, from which the camera list is retrieved; bUpdateInterfaces - The boolean of whether to update the interface list; bUpdateCameras - The boolean of whether to update the camera list; hCameraList - The camera list to house the cameras from the system
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: spinCameraListCreateEmpty(), spinCameraListDestroy(), Spinnaker_C.spinError

spinSystemSetLoggingLevel
```
public static Spinnaker_C.spinError spinSystemSetLoggingLevel(spinSystem hSystem,
                                                              Spinnaker_C.spinnakerLogLevel logLevel)
```
Sets the logging level for all logging events on the system

Parameters:

hSystem - The system, on which the logging level is set

logLevel - The logging level to set

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

Spinnaker_C.spinError

spinSystemSetLoggingLevel

@Cast(value="spinError")
public static int spinSystemSetLoggingLevel(spinSystem hSystem,
                                                                      @Cast(value="spinnakerLogLevel")
                                                                      int logLevel)

spinSystemGetLoggingLevel

public static Spinnaker_C.spinError spinSystemGetLoggingLevel(spinSystem hSystem,
                                                              @Cast(value="spinnakerLogLevel*")
                                                              IntPointer pLogLevel)

Retrieves the logging level for all logging events on the system

Parameters:: hSystem - The system, from which the logging level is retrieved; logLevel - The logging level enum pointer in which the current logging level is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinSystemGetLoggingLevel

@Cast(value="spinError")
public static int spinSystemGetLoggingLevel(spinSystem hSystem,
                                                                      @Cast(value="spinnakerLogLevel*")
                                                                      IntBuffer pLogLevel)

spinSystemGetLoggingLevel

public static Spinnaker_C.spinError spinSystemGetLoggingLevel(spinSystem hSystem,
                                                              @Cast(value="spinnakerLogLevel*")
                                                              int[] pLogLevel)

spinSystemRegisterLogEventHandler
```
public static Spinnaker_C.spinError spinSystemRegisterLogEventHandler(spinSystem hSystem,
                                                                      spinLogEventHandler hLogEventHandler)
```
Registers a logging event handler to the system (event handlers registered in this way must be unregistered)

Parameters:

hSystem - The system, on which the logging event handler is registered

hLogEventHandler - The logging event handler to register on the system

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

Spinnaker_C.spinError

spinSystemUnregisterLogEventHandler
```
public static Spinnaker_C.spinError spinSystemUnregisterLogEventHandler(spinSystem hSystem,
                                                                        spinLogEventHandler hLogEventHandler)
```
Unregisters a selected logging event handler from the system

Parameters:

hSystem - The system, from which the logging event handler is unregistered

hLogEventHandler - The logging event handler to unregister from the system

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

Spinnaker_C.spinError

spinSystemUnregisterAllLogEventHandlers
```
public static Spinnaker_C.spinError spinSystemUnregisterAllLogEventHandlers(spinSystem hSystem)
```
Unregisters all logging event handlers from the system

Parameters:

hSystem - The system, from which all logging event handlers are unregistered

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

Spinnaker_C.spinError

spinSystemIsInUse

public static Spinnaker_C.spinError spinSystemIsInUse(spinSystem hSystem,
                                                      @Cast(value="bool8_t*")
                                                      BytePointer pbIsInUse)

Checks whether a system is currently in use

Parameters:: hSystem - The system to check; pbIsInUse - The boolean pointer to return whether the system is currently in use
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinSystemIsInUse

@Cast(value="spinError")
public static int spinSystemIsInUse(spinSystem hSystem,
                                                              @Cast(value="bool8_t*")
                                                              ByteBuffer pbIsInUse)

spinSystemIsInUse

public static Spinnaker_C.spinError spinSystemIsInUse(spinSystem hSystem,
                                                      @Cast(value="bool8_t*")
                                                      byte[] pbIsInUse)

spinSystemRegisterDeviceArrivalEventHandler
```
public static Spinnaker_C.spinError spinSystemRegisterDeviceArrivalEventHandler(spinSystem hSystem,
                                                                                spinDeviceArrivalEventHandler hDeviceArrivalEventHandler)
```
Registers a device arrival event handler to every interface on the system (event handlers registered this way must be unregistered)

Parameters:

hSystem - The system, on which the device arrival event handler is registered

hDeviceArrivalEventHandler - The device arrival event handler to register on the system

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

Spinnaker_C.spinError

spinSystemRegisterDeviceRemovalEventHandler
```
public static Spinnaker_C.spinError spinSystemRegisterDeviceRemovalEventHandler(spinSystem hSystem,
                                                                                spinDeviceRemovalEventHandler hDeviceRemovalEventHandler)
```
Registers a device removal event handler to the system to every interface on the system (event handlers registered this way must be unregistered)

Parameters:

hSystem - The system, on which the device removal event handler is registered

hDeviceRemovalEventHandler - The device removal event handler to register on the system

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

Spinnaker_C.spinError

spinSystemUnregisterDeviceArrivalEventHandler
```
public static Spinnaker_C.spinError spinSystemUnregisterDeviceArrivalEventHandler(spinSystem hSystem,
                                                                                  spinDeviceArrivalEventHandler hDeviceArrivalEventHandler)
```
Unregisters a device arrival event handler from the system

Parameters:

hSystem - The system, from which the device arrival event handler is unregistered

hDeviceArrivalEventHandler - The device arrival event handler to unregister from the system

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

Spinnaker_C.spinError, spinDeviceArrivalEventHandler

spinSystemUnregisterDeviceRemovalEventHandler
```
public static Spinnaker_C.spinError spinSystemUnregisterDeviceRemovalEventHandler(spinSystem hSystem,
                                                                                  spinDeviceRemovalEventHandler hDeviceRemovalEventHandler)
```
Unregisters a device removal event handler from the system

Parameters:

hSystem - The system, from which the device removal event handler is unregistered

hDeviceRemovalEventHandler - The device removal event handler to unregister from the system

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

Spinnaker_C.spinError, spinDeviceRemovalEventHandler

spinSystemRegisterInterfaceEventHandler
```
public static Spinnaker_C.spinError spinSystemRegisterInterfaceEventHandler(spinSystem hSystem,
                                                                            spinInterfaceEventHandler hInterfaceEventHandler)
```
Registers an interface event handler (device arrival and device removal) to every interface on the system (interface events registered this way must be unregistered) If new interfaces are detected by the system after spinSystemRegisterInterfaceEventHandler() is called, those interfaces will be automatically registered with this event.

Parameters:

hSystem - The system, on which the interface event handler is registered

hInterfaceEventHandler - The interface event handler (device arrival and device removal) to register on the system

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

Spinnaker_C.spinError, spinInterfaceEventHandler

spinSystemUnregisterInterfaceEventHandler
```
public static Spinnaker_C.spinError spinSystemUnregisterInterfaceEventHandler(spinSystem hSystem,
                                                                              spinInterfaceEventHandler hInterfaceEventHandler)
```
Unregisters an interface event handler from the system

Parameters:

hSystem - The system, from which the interface event handler is unregistered

hInterfaceEventHandler - The interface event handler (device arrival and device removal) to unregister from the system

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

Spinnaker_C.spinError, spinInterfaceEventHandler

spinSystemUpdateCameras
```
public static Spinnaker_C.spinError spinSystemUpdateCameras(spinSystem hSystem,
                                                            @Cast(value="bool8_t*")
                                                            BytePointer pbChanged)
```
Updates the list of cameras on the system, informing whether there has been any changes

Parameters:

hSystem - The system, on which the list of attached cameras is updated

pbChanged - The boolean pointer to return whether cameras have arrived on or been removed from the system

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

Spinnaker_C.spinError

spinSystemUpdateCameras

@Cast(value="spinError")
public static int spinSystemUpdateCameras(spinSystem hSystem,
                                                                    @Cast(value="bool8_t*")
                                                                    ByteBuffer pbChanged)

spinSystemUpdateCameras

public static Spinnaker_C.spinError spinSystemUpdateCameras(spinSystem hSystem,
                                                            @Cast(value="bool8_t*")
                                                            byte[] pbChanged)

spinSystemUpdateCamerasEx

public static Spinnaker_C.spinError spinSystemUpdateCamerasEx(spinSystem hSystem,
                                                              @Cast(value="bool8_t")
                                                              byte bUpdateInterfaces,
                                                              @Cast(value="bool8_t*")
                                                              BytePointer pbChanged)

Updates the list of cameras on the system, informing whether there has been any changes; manually set whether to update the current interface lists

Parameters:: hSystem - The system, on which the list of attached cameras is updated; bUpdateInterfaces - The boolean of whether to update the interface list; pbChanged - The boolean pointer to return whether cameras have arrived or been removed from the system
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinSystemUpdateCamerasEx

@Cast(value="spinError")
public static int spinSystemUpdateCamerasEx(spinSystem hSystem,
                                                                      @Cast(value="bool8_t")
                                                                      byte bUpdateInterfaces,
                                                                      @Cast(value="bool8_t*")
                                                                      ByteBuffer pbChanged)

spinSystemUpdateCamerasEx

public static Spinnaker_C.spinError spinSystemUpdateCamerasEx(spinSystem hSystem,
                                                              @Cast(value="bool8_t")
                                                              byte bUpdateInterfaces,
                                                              @Cast(value="bool8_t*")
                                                              byte[] pbChanged)

spinSystemGetLibraryVersion

public static Spinnaker_C.spinError spinSystemGetLibraryVersion(spinSystem hSystem,
                                                                spinLibraryVersion hLibraryVersion)

Get current library version of Spinnaker.

Returns:: A struct containing the current version of Spinnaker(major, minor, type, build).

spinSystemGetTLNodeMap

public static Spinnaker_C.spinError spinSystemGetTLNodeMap(spinSystem hSystem,
                                                           @ByPtrPtr
                                                           spinNodeMapHandle phNodeMap)

Retrieves the transport layer nodemap from the system.

Parameters:: hSystem - The system handle.; phNodeMap - The nodemap handle pointer in which the transport layer system nodemap is returned.
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinInterfaceListCreateEmpty
```
public static Spinnaker_C.spinError spinInterfaceListCreateEmpty(@ByPtrPtr
                                                                 spinInterfaceList phInterfaceList)
```
Creates an empty interface list (interface lists created this way must be destroyed)

Parameters:

phInterfaceList - The interface list handle pointer in which the empty interface list is returned

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

Spinnaker_C.spinError

spinInterfaceListDestroy
```
public static Spinnaker_C.spinError spinInterfaceListDestroy(spinInterfaceList hInterfaceList)
```
Destroys an interface list

Parameters:

hInterfaceList - The interface list to destroy

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

Spinnaker_C.spinError

spinInterfaceListGetSize

public static Spinnaker_C.spinError spinInterfaceListGetSize(spinInterfaceList hInterfaceList,
                                                             @Cast(value="size_t*")
                                                             SizeTPointer pSize)

Retrieves the number of interfaces in an interface list

Parameters:: hInterfaceList - The interface list where the interfaces to be counted are; pSize - The unsigned integer pointer in which the number of interfaces is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError, Spinnaker_C.spinError

spinInterfaceListGet

public static Spinnaker_C.spinError spinInterfaceListGet(spinInterfaceList hInterfaceList,
                                                         @Cast(value="size_t")
                                                         long index,
                                                         @ByPtrPtr
                                                         spinInterface phInterface)

Retrieves an interface from an interface list using an index (interfaces retrieved this way must be released)

Parameters:: hInterfaceList - The interface list of the interface to be retrieved; index - The index of the interface; phInterface - The interface handle pointer in which the interface is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinInterfaceListClear
```
public static Spinnaker_C.spinError spinInterfaceListClear(spinInterfaceList hInterfaceList)
```
Clears an interface list

Parameters:

hInterfaceList - The interface list to clear

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

Spinnaker_C.spinError

spinCameraListCreateEmpty
```
public static Spinnaker_C.spinError spinCameraListCreateEmpty(@ByPtrPtr
                                                              spinCameraList phCameraList)
```
Creates an empty camera list (camera lists created this way must be destroyed)

Parameters:

phCameraList - The camera list handle pointer in which the empty camera list is returned

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

Spinnaker_C.spinError

spinCameraListDestroy
```
public static Spinnaker_C.spinError spinCameraListDestroy(spinCameraList hCameraList)
```
Destroys a camera list

Parameters:

hCameraList - The camera list to destroy

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

Spinnaker_C.spinError

spinCameraListGetSize

public static Spinnaker_C.spinError spinCameraListGetSize(spinCameraList hCameraList,
                                                          @Cast(value="size_t*")
                                                          SizeTPointer pSize)

Retrieves the number of cameras on a camera list

Parameters:: hCameraList - The camera list where the cameras to be counted are; pSize - The unsigned integer pointer in which the number of cameras is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinCameraListGet

public static Spinnaker_C.spinError spinCameraListGet(spinCameraList hCameraList,
                                                      @Cast(value="size_t")
                                                      long index,
                                                      @ByPtrPtr
                                                      spinCamera phCamera)

Retrieves a camera from a camera list using an index. This function will return a SPINNAKER_ERR_INVALID_PARAMETER error if the input index is out of range.

Parameters:: hCameraList - The camera list of the camera to retrieve; index - The index of the camera; phCamera - The camera handle pointer in which the camera is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinCameraListClear
```
public static Spinnaker_C.spinError spinCameraListClear(spinCameraList hCameraList)
```
Clears a camera list

Parameters:

hCameraList - The camera list to clear

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

Spinnaker_C.spinError

spinCameraListRemove

public static Spinnaker_C.spinError spinCameraListRemove(spinCameraList hCameraList,
                                                         @Cast(value="size_t")
                                                         long index)

Removes a camera from a camera list using its index

Parameters:: hCameraList - The camera list of the camera to remove; index - The index of the camera to remove
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinCameraListAppend
```
public static Spinnaker_C.spinError spinCameraListAppend(spinCameraList hCameraListBase,
                                                         spinCameraList hCameraListToAppend)
```
Appends all the cameras from one camera list to another

Parameters:

hCameraListBase - The camera list to receive the other

hCameraListToAppend - The camera list to add to the other

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

Spinnaker_C.spinError

spinCameraListGetBySerial

public static Spinnaker_C.spinError spinCameraListGetBySerial(spinCameraList hCameraList,
                                                              @Cast(value="const char*")
                                                              BytePointer pSerial,
                                                              @ByPtrPtr
                                                              spinCamera phCamera)

Retrieves a camera from a camera list using its serial number. This function will return a NULL spinCamera pointer if no matching camera serial is found.

Parameters:: hCameraList - The camera list of the camera to retrieve; serial - The serial number of the camera to retrieve; phCamera - The camera handle pointer in which the camera is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinCameraListGetBySerial

@Cast(value="spinError")
public static int spinCameraListGetBySerial(spinCameraList hCameraList,
                                                                      String pSerial,
                                                                      @ByPtrPtr
                                                                      spinCamera phCamera)

spinCameraListRemoveBySerial

public static Spinnaker_C.spinError spinCameraListRemoveBySerial(spinCameraList hCameraList,
                                                                 @Cast(value="const char*")
                                                                 BytePointer pSerial)

Removes a camera from a camera list using its serial number

Parameters:: hCameraList - The camera list of the camera to remove; pSerial - The serial number of the camera to remove
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinCameraListRemoveBySerial

@Cast(value="spinError")
public static int spinCameraListRemoveBySerial(spinCameraList hCameraList,
                                                                         String pSerial)

spinImageListCreateEmpty
```
public static Spinnaker_C.spinError spinImageListCreateEmpty(@ByPtrPtr
                                                             spinImageList phImageList)
```
Creates an empty image list (image lists created this way must be destroyed)

Parameters:

phImageList - The image list handle pointer in which the empty image list is returned

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

Spinnaker_C.spinError

spinImageListDestroy
```
public static Spinnaker_C.spinError spinImageListDestroy(spinImageList hImageList)
```
Destroys a image list

Parameters:

hImageList - The image list to destroy

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

Spinnaker_C.spinError

spinImageListGetSize

public static Spinnaker_C.spinError spinImageListGetSize(spinImageList hImageList,
                                                         @Cast(value="size_t*")
                                                         SizeTPointer pSize)

Retrieves the number of images in an image list

Parameters:: hImageList - The image list where the images to be counted are; pSize - The unsigned integer pointer in which the number of images is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageListGet

public static Spinnaker_C.spinError spinImageListGet(spinImageList hImageList,
                                                     @Cast(value="size_t")
                                                     long index,
                                                     @ByPtrPtr
                                                     spinImage phImage)

Retrieves a image from a image list using an index. This function will return a SPINNAKER_ERR_INVALID_PARAMETER error if the input index is out of range.

Parameters:: hImageList - The image list of the image to retrieve; index - The index of the image; phImage - The image handle pointer in which the image is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageListClear
```
public static Spinnaker_C.spinError spinImageListClear(spinImageList hImageList)
```
Clears a image list

Parameters:

hImageList - The image list to clear

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

Spinnaker_C.spinError

spinImageListRemove

public static Spinnaker_C.spinError spinImageListRemove(spinImageList hImageList,
                                                        @Cast(value="size_t")
                                                        long index)

Removes a image from a image list using its index

Parameters:: hImageList - The image list of the camera to remove; index - The index of the image to remove
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageListAppend
```
public static Spinnaker_C.spinError spinImageListAppend(spinImageList hImageListBase,
                                                        spinImageList hImageListToAppend)
```
Appends all the images from one image list to another

Parameters:

hImageListBase - The image list to receive the other

hImageListToAppend - The image list to add to the other

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

Spinnaker_C.spinError

spinImageListGetByPixelFormat

public static Spinnaker_C.spinError spinImageListGetByPixelFormat(spinImageList hImageList,
                                                                  Spinnaker_C.spinPixelFormatEnums pixelFormat,
                                                                  @ByPtrPtr
                                                                  spinImage phImage)

Retrieves a image from a image list given its pixel format. This function will return a NULL spinImage pointer if no matching image pixel format is found.

Parameters:: hImageList - The image list of the image to retrieve; pixelFormat - The pixel format of the image to retrieve; phImage - The image handle pointer in which the image is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageListGetByPixelFormat

@Cast(value="spinError")
public static int spinImageListGetByPixelFormat(spinImageList hImageList,
                                                                          @Cast(value="spinPixelFormatEnums")
                                                                          int pixelFormat,
                                                                          @ByPtrPtr
                                                                          spinImage phImage)

spinImageListRemoveByPixelFormat
```
public static Spinnaker_C.spinError spinImageListRemoveByPixelFormat(spinImageList hImageList,
                                                                     Spinnaker_C.spinPixelFormatEnums pixelFormat)
```
Removes a image from a image list using its pixel format

Parameters:

hImageList - The image list of the image to remove

pixelFormat - The pixel format of the image to remove

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

Spinnaker_C.spinError

spinImageListRemoveByPixelFormat

@Cast(value="spinError")
public static int spinImageListRemoveByPixelFormat(spinImageList hImageList,
                                                                             @Cast(value="spinPixelFormatEnums")
                                                                             int pixelFormat)

spinImageListRelease

public static Spinnaker_C.spinError spinImageListRelease(spinImageList hImageList)

spinImageListSave
```
public static Spinnaker_C.spinError spinImageListSave(spinImageList hImageList,
                                                      @Cast(value="const char*")
                                                      BytePointer fileName)
```
Saves an image list as an object to a file.

Parameters:

hImageList - The image list of the image to remove

fileName - Name of the file to save the current image list object to. It is recommended to use the file extension 'sil'.

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

spinImageListLoad(), Spinnaker_C.spinError

spinImageListSave

@Cast(value="spinError")
public static int spinImageListSave(spinImageList hImageList,
                                                              String fileName)

spinImageListLoad

public static Spinnaker_C.spinError spinImageListLoad(@ByPtrPtr
                                                      spinImageList phImageList,
                                                      @Cast(value="const char*")
                                                      BytePointer fileName)

Creates an image list object from file.

Parameters:: phImageList - The image list handle pointer in which the empty image list is returned; fileName - Name of the file to load an image object from.
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: spinImageListSave(), Spinnaker_C.spinError

spinImageListLoad

@Cast(value="spinError")
public static int spinImageListLoad(@ByPtrPtr
                                                              spinImageList phImageList,
                                                              String fileName)

spinInterfaceUpdateCameras

public static Spinnaker_C.spinError spinInterfaceUpdateCameras(spinInterface hInterface,
                                                               @Cast(value="bool8_t*")
                                                               BytePointer pbChanged)

Checks whether any cameras have been connected or disconnected on an interface

Parameters:: hInterface - The interface of the list of attached cameras to update; pbChanged - The boolean pointer to return whether or not the cameras have changed
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinInterfaceUpdateCameras

@Cast(value="spinError")
public static int spinInterfaceUpdateCameras(spinInterface hInterface,
                                                                       @Cast(value="bool8_t*")
                                                                       ByteBuffer pbChanged)

spinInterfaceUpdateCameras

public static Spinnaker_C.spinError spinInterfaceUpdateCameras(spinInterface hInterface,
                                                               @Cast(value="bool8_t*")
                                                               byte[] pbChanged)

spinInterfaceGetCameras
```
public static Spinnaker_C.spinError spinInterfaceGetCameras(spinInterface hInterface,
                                                            spinCameraList hCameraList)
```
Retrieves a camera list from an interface; camera lists must be created and destroy

Parameters:

hInterface - The interface of the camera list to retrieve

hCameraList - The camera list to house the cameras from the interface

Returns:

spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error

See Also:

spinCameraListCreateEmpty()

Class Spinnaker_C

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.bytedeco.spinnaker.presets.Spinnaker_C

Methods inherited from class java.lang.Object

Field Detail

False

True

Constructor Detail

Spinnaker_C

Method Detail

False

True

spinNodeMapGetNode

spinNodeMapGetNode

spinNodeMapGetNumNodes

spinNodeMapGetNodeByIndex

spinNodeMapReleaseNode

spinNodeMapPoll

spinNodeIsImplemented

spinNodeIsImplemented

spinNodeIsImplemented

spinNodeIsReadable

spinNodeIsReadable

spinNodeIsReadable

spinNodeIsWritable

spinNodeIsWritable

spinNodeIsWritable

spinNodeIsAvailable

spinNodeIsAvailable

spinNodeIsAvailable

spinNodeIsEqual

spinNodeIsEqual

spinNodeIsEqual

spinNodeGetAccessMode

spinNodeGetAccessMode

spinNodeGetAccessMode

spinNodeGetName

spinNodeGetName

spinNodeGetName

spinNodeGetNameSpace

spinNodeGetNameSpace

spinNodeGetNameSpace

spinNodeGetVisibility

spinNodeGetVisibility

spinNodeGetVisibility

spinNodeInvalidateNode

spinNodeGetCachingMode

spinNodeGetCachingMode

spinNodeGetCachingMode

spinNodeGetToolTip

spinNodeGetToolTip

spinNodeGetToolTip

spinNodeGetDescription

spinNodeGetDescription

spinNodeGetDescription

spinNodeGetDisplayName

spinNodeGetDisplayName

spinNodeGetDisplayName

spinNodeGetType

spinNodeGetType

spinNodeGetType

spinNodeGetPollingTime

spinNodeGetPollingTime

spinNodeGetPollingTime

spinNodeRegisterCallback

spinNodeDeregisterCallback

spinNodeGetImposedAccessMode

spinNodeGetImposedAccessMode

spinNodeGetImposedVisibility

spinNodeGetImposedVisibility

spinNodeToString

spinNodeToString

spinNodeToString

spinNodeToStringEx

spinNodeToStringEx

spinNodeToStringEx

spinNodeFromString