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(), spinCameraListDestroy(), Spinnaker_C.spinError

spinInterfaceGetCamerasEx
```
public static Spinnaker_C.spinError spinInterfaceGetCamerasEx(spinInterface hInterface,
                                                              @Cast(value="bool8_t")
                                                              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

Parameters:

hInterface - The interface of the camera list to retrieve

bUpdateCameras - The boolean of whether or not to update the cameras

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(), spinCameraListDestroy(), Spinnaker_C.spinError

spinInterfaceGetTLNodeMap

public static Spinnaker_C.spinError spinInterfaceGetTLNodeMap(spinInterface hInterface,
                                                              @ByPtrPtr
                                                              spinNodeMapHandle phNodeMap)

Retrieves the transport layer nodemap from an interface

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

spinInterfaceRegisterDeviceArrivalEventHandler
```
public 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)

Parameters:

hInterface - The interface on which to register the device arrival event handler

hDeviceArrivalEventHandler - The device arrival event handler to register

Returns:

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

See Also:

Spinnaker_C.spinError

spinInterfaceRegisterDeviceRemovalEventHandler
```
public 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)

Parameters:

hInterface - the Interface on which to register the device removal event handler

hDeviceRemovalEventHandler - The device removal event handler to register

Returns:

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

See Also:

Spinnaker_C.spinError

spinInterfaceUnregisterDeviceArrivalEventHandler
```
public static Spinnaker_C.spinError spinInterfaceUnregisterDeviceArrivalEventHandler(spinInterface hInterface,
                                                                                     spinDeviceArrivalEventHandler hDeviceArrivalEventHandler)
```
Unregisters a device arrival event handler from an interface

Parameters:

hInterface - The interface from which to unregister the device arrival event handler

hDeviceArrivalEventHandler - The device arrival event handler to unregister

Returns:

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

See Also:

Spinnaker_C.spinError

spinInterfaceUnregisterDeviceRemovalEventHandler
```
public static Spinnaker_C.spinError spinInterfaceUnregisterDeviceRemovalEventHandler(spinInterface hInterface,
                                                                                     spinDeviceRemovalEventHandler hDeviceRemovalEventHandler)
```
Unregisters a device removal event handler from an interface

Parameters:

hInterface - The interface from which to unregister the device removal event handler

hDeviceRemovalEventHandler - The device removal event handler to unregister

Returns:

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

See Also:

Spinnaker_C.spinError

spinInterfaceRegisterInterfaceEventHandler
```
public static Spinnaker_C.spinError spinInterfaceRegisterInterfaceEventHandler(spinInterface hInterface,
                                                                               spinInterfaceEventHandler hInterfaceEventHandler)
```
Registers an interface event handler (both device arrival and device removal) on an interface

Parameters:

hInterface - The interface on which to register the interface event handler

hInterfaceEventHandler - The interface event handler to register

Returns:

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

See Also:

Spinnaker_C.spinError

spinInterfaceUnregisterInterfaceEventHandler
```
public static Spinnaker_C.spinError spinInterfaceUnregisterInterfaceEventHandler(spinInterface hInterface,
                                                                                 spinInterfaceEventHandler hInterfaceEventHandler)
```
Unregisters an interface event handler from an interface

Parameters:

hInterface - The interface from which to unregister the interface event handler

hInterfaceEventHandler - The interface event handler to unregister

Returns:

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

See Also:

Spinnaker_C.spinError

spinInterfaceRelease
```
public static Spinnaker_C.spinError spinInterfaceRelease(spinInterface hInterface)
```
Releases an interface

Parameters:

hInterface - The interface to release

Returns:

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

See Also:

Spinnaker_C.spinError

spinInterfaceIsInUse

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

Checks whether an interface is in use

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

spinInterfaceIsInUse

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

spinInterfaceIsInUse

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

spinCameraInit
```
public static Spinnaker_C.spinError spinCameraInit(spinCamera hCamera)
```
Initializes a camera, allowing for much more interaction

Parameters:

hCamera - The camera to initialize

Returns:

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

See Also:

Spinnaker_C.spinError

spinCameraDeInit
```
public static Spinnaker_C.spinError spinCameraDeInit(spinCamera hCamera)
```
Deinitializes a camera, greatly reducing functionality

Parameters:

hCamera - The camera to deinitialize

Returns:

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

See Also:

Spinnaker_C.spinError

spinCameraGetNodeMap

public static Spinnaker_C.spinError spinCameraGetNodeMap(spinCamera hCamera,
                                                         @ByPtrPtr
                                                         spinNodeMapHandle phNodeMap)

Retrieves the GenICam nodemap from a camera

Parameters:: hCamera - The camera from which the nodemap is retrieved; phNodeMap - The nodemap handle pointer in which the nodemap is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinCameraGetTLDeviceNodeMap

public static Spinnaker_C.spinError spinCameraGetTLDeviceNodeMap(spinCamera hCamera,
                                                                 @ByPtrPtr
                                                                 spinNodeMapHandle phNodeMap)

Retrieves the transport layer device nodemap from a camera

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

spinCameraGetTLStreamNodeMap

public static Spinnaker_C.spinError spinCameraGetTLStreamNodeMap(spinCamera hCamera,
                                                                 @ByPtrPtr
                                                                 spinNodeMapHandle phNodeMap)

Retrieves the transport layer stream nodemap from a camera

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

spinCameraGetAccessMode

public static Spinnaker_C.spinError spinCameraGetAccessMode(spinCamera hCamera,
                                                            @Cast(value="spinAccessMode*")
                                                            IntPointer pAccessMode)

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

Parameters:: hCamera - The camera 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

spinCameraGetAccessMode

@Cast(value="spinError")
public static int spinCameraGetAccessMode(spinCamera hCamera,
                                                                    @Cast(value="spinAccessMode*")
                                                                    IntBuffer pAccessMode)

spinCameraGetAccessMode

public static Spinnaker_C.spinError spinCameraGetAccessMode(spinCamera hCamera,
                                                            @Cast(value="spinAccessMode*")
                                                            int[] pAccessMode)

spinCameraReadPort

public static Spinnaker_C.spinError spinCameraReadPort(spinCamera hCamera,
                                                       @Cast(value="uint64_t")
                                                       long iAddress,
                                                       Pointer pBuffer,
                                                       @Cast(value="size_t")
                                                       long iSize)

spinCameraWritePort

public static Spinnaker_C.spinError spinCameraWritePort(spinCamera hCamera,
                                                        @Cast(value="uint64_t")
                                                        long iAddress,
                                                        Pointer pBuffer,
                                                        @Cast(value="size_t")
                                                        long iSize)

spinCameraBeginAcquisition
```
public static Spinnaker_C.spinError spinCameraBeginAcquisition(spinCamera hCamera)
```
Has a camera start acquiring images

Parameters:

hCamera - The camera to begin acquiring images

Returns:

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

See Also:

Spinnaker_C.spinError

spinCameraEndAcquisition
```
public static Spinnaker_C.spinError spinCameraEndAcquisition(spinCamera hCamera)
```
Has a camera stop acquiring images

Parameters:

hCamera - The camera to stop acquiring images

Returns:

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

See Also:

Spinnaker_C.spinError

spinCameraGetNextImage

public static Spinnaker_C.spinError spinCameraGetNextImage(spinCamera hCamera,
                                                           @ByPtrPtr
                                                           spinImage phImage)

Retrieves an image from a camera

Parameters:: hCamera - The camera 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

spinCameraGetNextImageEx

public static Spinnaker_C.spinError spinCameraGetNextImageEx(spinCamera hCamera,
                                                             @Cast(value="uint64_t")
                                                             long grabTimeout,
                                                             @ByPtrPtr
                                                             spinImage phImage)

Retrieves an image from a camera; manually set the timeout in milliseconds

Parameters:: hCamera - The camera of the image to retrieve; grabTimeout - A 64bit value that represents a timeout in milliseconds; 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

spinCameraGetNextImageSync

public static Spinnaker_C.spinError spinCameraGetNextImageSync(spinCamera hCamera,
                                                               @Cast(value="uint64_t")
                                                               long grabTimeout,
                                                               @ByPtrPtr
                                                               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. This function will block for the specified timeout period until an image arrives on all the streams.

Parameters:: hCamera - The camera of the image to retrieve; grabTimeout - A 64bit value that represents a timeout in milliseconds
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: spinCameraInit(), spinCameraBeginAcquisition(), spinCameraEndAcquisition()

spinCameraGetUniqueID

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

Retrieves a unique identifier for a camera

Parameters:: hCamera - The camera of the unique identifier; pBuf - The c-string character buffer in which the unique identifier 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

spinCameraGetUniqueID

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

spinCameraGetUniqueID

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

spinCameraIsStreaming

public static Spinnaker_C.spinError spinCameraIsStreaming(spinCamera hCamera,
                                                          @Cast(value="bool8_t*")
                                                          BytePointer pbIsStreaming)

Checks whether a camera is currently acquiring images

Parameters:: hCamera - The camera to check; pbIsStreaming - The boolean pointer to return whether or not the camera is currently streaming
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinCameraIsStreaming

@Cast(value="spinError")
public static int spinCameraIsStreaming(spinCamera hCamera,
                                                                  @Cast(value="bool8_t*")
                                                                  ByteBuffer pbIsStreaming)

spinCameraIsStreaming

public static Spinnaker_C.spinError spinCameraIsStreaming(spinCamera hCamera,
                                                          @Cast(value="bool8_t*")
                                                          byte[] pbIsStreaming)

spinCameraGetGuiXml

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

Retrieves the GUI XML from a camera

Parameters:: hCamera - The camera of the GUI XML to retrieve; pBuf - The c-string character buffer in which the GUI XML 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

spinCameraGetGuiXml

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

spinCameraGetGuiXml

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

spinCameraRegisterDeviceEventHandler
```
public static Spinnaker_C.spinError spinCameraRegisterDeviceEventHandler(spinCamera hCamera,
                                                                         spinDeviceEventHandler hDeviceEventHandler)
```
Registers a universal device event handler (every device event type) to a camera

Parameters:

hCamera - The camera on which to register the universal device event handler

hDeviceEventHandler - The device event handler to register

Returns:

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

See Also:

Spinnaker_C.spinError

spinCameraRegisterDeviceEventHandlerEx

public static Spinnaker_C.spinError spinCameraRegisterDeviceEventHandlerEx(spinCamera hCamera,
                                                                           spinDeviceEventHandler hDeviceEventHandler,
                                                                           @Cast(value="const char*")
                                                                           BytePointer pName)

Registers a specific device event handler (only one device event type) to a camera

Parameters:: hCamera - The camera on which to register the specific device event handler; hDeviceEventHandler - The device event handler to register; pName - The name of the device event handler to register
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinCameraRegisterDeviceEventHandlerEx

@Cast(value="spinError")
public static int spinCameraRegisterDeviceEventHandlerEx(spinCamera hCamera,
                                                                                   spinDeviceEventHandler hDeviceEventHandler,
                                                                                   String pName)

spinCameraUnregisterDeviceEventHandler
```
public static Spinnaker_C.spinError spinCameraUnregisterDeviceEventHandler(spinCamera hCamera,
                                                                           spinDeviceEventHandler hDeviceEventHandler)
```
Unregisters a device event handler from a camera

Parameters:

hCamera - The camera from which to unregister the device event handler

hDeviceEventHandler - The device event handler to unregister

Returns:

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

See Also:

Spinnaker_C.spinError

spinCameraRegisterImageEventHandler
```
public static Spinnaker_C.spinError spinCameraRegisterImageEventHandler(spinCamera hCamera,
                                                                        spinImageEventHandler hImageEventHandler)
```
Registers an image event handler to a camera

Parameters:

hCamera - The camera on which to register the image event handler

hImageEventHandler - The image event handler to register

Returns:

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

See Also:

Spinnaker_C.spinError

spinCameraRegisterImageEventHandlerEx
```
public static Spinnaker_C.spinError spinCameraRegisterImageEventHandlerEx(spinCamera hCamera,
                                                                          spinImageEventHandler hImageEventHandler,
                                                                          @Cast(value="uint64_t")
                                                                          long streamIndex)
```
Registers an image event handler to a camera Registers a specific stream handler for the camera given a stream index. The camera has to be initialized first with a call to spinCameraInit() before registering handlers for events.

Parameters:

hCamera - The camera on which to register the image event handler

hImageEventHandler - The image event handler to register

streamIndex - The index of the stream of where this handler will be registered to

Returns:

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

See Also:

Spinnaker_C.spinError

spinCameraUnregisterImageEventHandler
```
public static Spinnaker_C.spinError spinCameraUnregisterImageEventHandler(spinCamera hCamera,
                                                                          spinImageEventHandler hImageEventHandler)
```
Unregisters an image event handler from a camera

Parameters:

hCamera - The camera from which to unregister the image event handler

hImageEventHandler - The image event handler to unregister

Returns:

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

See Also:

Spinnaker_C.spinError

spinCameraRegisterImageListEventHandler
```
public static Spinnaker_C.spinError spinCameraRegisterImageListEventHandler(spinCamera hCamera,
                                                                            spinImageListEventHandler hImageListEventHandler)
```
Registers an image list event handler to a camera

Parameters:

hCamera - The camera on which to register the image event handler

hImageListEventHandler - The image list event handler to register

Returns:

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

See Also:

Spinnaker_C.spinError

spinCameraUnregisterImageListEventHandler
```
public static Spinnaker_C.spinError spinCameraUnregisterImageListEventHandler(spinCamera hCamera,
                                                                              spinImageListEventHandler hImageListEventHandler)
```
Unregisters an image list event handler from a camera

Parameters:

hCamera - The camera from which to unregister the image event handler

hImageEventHandler - The image event handler to unregister

Returns:

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

See Also:

Spinnaker_C.spinError

spinCameraRelease
```
public static Spinnaker_C.spinError spinCameraRelease(spinCamera hCamera)
```
Releases a camera

Parameters:

hCamera - The camera to release

Returns:

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

See Also:

Spinnaker_C.spinError

spinCameraIsValid

public static Spinnaker_C.spinError spinCameraIsValid(spinCamera hCamera,
                                                      @Cast(value="bool8_t*")
                                                      BytePointer pbValid)

Checks whether a camera is still valid for use

Parameters:: hCamera - The camera to check; pbValid - The boolean pointer to return whether or not the camera is valid
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinCameraIsValid

@Cast(value="spinError")
public static int spinCameraIsValid(spinCamera hCamera,
                                                              @Cast(value="bool8_t*")
                                                              ByteBuffer pbValid)

spinCameraIsValid

public static Spinnaker_C.spinError spinCameraIsValid(spinCamera hCamera,
                                                      @Cast(value="bool8_t*")
                                                      byte[] pbValid)

spinCameraIsInitialized

public static Spinnaker_C.spinError spinCameraIsInitialized(spinCamera hCamera,
                                                            @Cast(value="bool8_t*")
                                                            BytePointer pbInit)

Checks whether a camera is currently initialized

Parameters:: hCamera - The camera to check; pbInit - The boolean pointer to return whether or not the camera is initialized
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinCameraIsInitialized

@Cast(value="spinError")
public static int spinCameraIsInitialized(spinCamera hCamera,
                                                                    @Cast(value="bool8_t*")
                                                                    ByteBuffer pbInit)

spinCameraIsInitialized

public static Spinnaker_C.spinError spinCameraIsInitialized(spinCamera hCamera,
                                                            @Cast(value="bool8_t*")
                                                            byte[] pbInit)

spinCameraDiscoverMaxPacketSize

public static Spinnaker_C.spinError spinCameraDiscoverMaxPacketSize(spinCamera hCamera,
                                                                    @Cast(value="unsigned int*")
                                                                    IntPointer pMaxPacketSize)

Returns the largest packet size that can be safely used on the interface that device is connected to.

Parameters:: hCamera - The camera to check; pMaxPacketSize - The maximum packet size returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinCameraDiscoverMaxPacketSize

@Cast(value="spinError")
public static int spinCameraDiscoverMaxPacketSize(spinCamera hCamera,
                                                                            @Cast(value="unsigned int*")
                                                                            IntBuffer pMaxPacketSize)

spinCameraDiscoverMaxPacketSize

public static Spinnaker_C.spinError spinCameraDiscoverMaxPacketSize(spinCamera hCamera,
                                                                    @Cast(value="unsigned int*")
                                                                    int[] pMaxPacketSize)

spinImageCreateEmpty
```
public static Spinnaker_C.spinError spinImageCreateEmpty(@ByPtrPtr
                                                         spinImage phImage)
```
Creates an empty image; images created this way must be destroyed

Parameters:

phImage - The image handle pointer in which the empty image is returned

Returns:

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

See Also:

Spinnaker_C.spinError

spinImageCreate

public static Spinnaker_C.spinError spinImageCreate(spinImage hSrcImage,
                                                    @ByPtrPtr
                                                    spinImage phDestImage)

Creates an image from another; images created this way must be destroyed

Parameters:: hSrcImage - The image to be copied; phDestImage - The image handle pointer of the image to be created
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageCreateEx

public static Spinnaker_C.spinError spinImageCreateEx(@ByPtrPtr
                                                      spinImage phImage,
                                                      @Cast(value="size_t")
                                                      long width,
                                                      @Cast(value="size_t")
                                                      long height,
                                                      @Cast(value="size_t")
                                                      long offsetX,
                                                      @Cast(value="size_t")
                                                      long offsetY,
                                                      Spinnaker_C.spinPixelFormatEnums pixelFormat,
                                                      Pointer pData)

Creates an image with some set properties; images created this way must be destroyed

Parameters:: phImage - The image handle pointer in which the image is returned; width - The width to set; height - The height to set; offsetX - The offset along the X axis to set; offsetY - The offset along the Y axis to set; pixelFormat - The pixel format to set; pData - The image data to set; can be set to null
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageCreateEx

@Cast(value="spinError")
public static int spinImageCreateEx(@ByPtrPtr
                                                              spinImage phImage,
                                                              @Cast(value="size_t")
                                                              long width,
                                                              @Cast(value="size_t")
                                                              long height,
                                                              @Cast(value="size_t")
                                                              long offsetX,
                                                              @Cast(value="size_t")
                                                              long offsetY,
                                                              @Cast(value="spinPixelFormatEnums")
                                                              int pixelFormat,
                                                              Pointer pData)

spinImageCreateEx2

public static Spinnaker_C.spinError spinImageCreateEx2(@ByPtrPtr
                                                       spinImage phImage,
                                                       @Cast(value="size_t")
                                                       long width,
                                                       @Cast(value="size_t")
                                                       long height,
                                                       @Cast(value="size_t")
                                                       long offsetX,
                                                       @Cast(value="size_t")
                                                       long offsetY,
                                                       Spinnaker_C.spinPixelFormatEnums pixelFormat,
                                                       Pointer pData,
                                                       Spinnaker_C.spinTLPayloadType dataPayloadType,
                                                       @Cast(value="size_t")
                                                       long dataSize)

Creates an image with some set properties; images created this way must be destroyed

Parameters:: phImage - The image handle pointer in which the image is returned; width - The width to set; height - The height to set; offsetX - The offset along the X axis to set; offsetY - The offset along the Y axis to set; pixelFormat - The pixel format to set; pData - The image data to set; can be set to null; dataPayloadType - The payload type of the data. This value can be retrieved from an existing image by using the spinImageGetTLPayloadType() function call.; dataSize - The size of the provided data in bytes
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError, spinImageGetTLPayloadType

spinImageCreateEx2

@Cast(value="spinError")
public static int spinImageCreateEx2(@ByPtrPtr
                                                               spinImage phImage,
                                                               @Cast(value="size_t")
                                                               long width,
                                                               @Cast(value="size_t")
                                                               long height,
                                                               @Cast(value="size_t")
                                                               long offsetX,
                                                               @Cast(value="size_t")
                                                               long offsetY,
                                                               @Cast(value="spinPixelFormatEnums")
                                                               int pixelFormat,
                                                               Pointer pData,
                                                               @Cast(value="spinTLPayloadType")
                                                               int dataPayloadType,
                                                               @Cast(value="size_t")
                                                               long dataSize)

spinImageDestroy
```
public static Spinnaker_C.spinError spinImageDestroy(spinImage hImage)
```
Destroys an image

Parameters:

hImage - The image to destroy

Returns:

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

See Also:

Spinnaker_C.spinError

spinImageGetColorProcessing

public static Spinnaker_C.spinError spinImageGetColorProcessing(spinImage hImage,
                                                                @Cast(value="spinColorProcessingAlgorithm*")
                                                                IntPointer pAlgorithm)

Retrieves the color processing algorithm of a specific image

Parameters:: hImage - The image of the color processing algorithm to retrieve; pAlgorithm - The color processing algorithm pointer in which the color processing algorithm is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageGetColorProcessing

@Cast(value="spinError")
public static int spinImageGetColorProcessing(spinImage hImage,
                                                                        @Cast(value="spinColorProcessingAlgorithm*")
                                                                        IntBuffer pAlgorithm)

spinImageGetColorProcessing

public static Spinnaker_C.spinError spinImageGetColorProcessing(spinImage hImage,
                                                                @Cast(value="spinColorProcessingAlgorithm*")
                                                                int[] pAlgorithm)

spinImageReset

public static Spinnaker_C.spinError spinImageReset(spinImage hImage,
                                                   @Cast(value="size_t")
                                                   long width,
                                                   @Cast(value="size_t")
                                                   long height,
                                                   @Cast(value="size_t")
                                                   long offsetX,
                                                   @Cast(value="size_t")
                                                   long offsetY,
                                                   Spinnaker_C.spinPixelFormatEnums pixelFormat)

Resets an image with some set properties

Parameters:: hImage - The image to be reset; width - The width to be reset to; height - The height to be reset to; offsetX - The offset to be reset to along the X axis; offsetY - The offset to be reset to along the Y axis; pixelFormat - The pixel format to be reset to
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageReset

@Cast(value="spinError")
public static int spinImageReset(spinImage hImage,
                                                           @Cast(value="size_t")
                                                           long width,
                                                           @Cast(value="size_t")
                                                           long height,
                                                           @Cast(value="size_t")
                                                           long offsetX,
                                                           @Cast(value="size_t")
                                                           long offsetY,
                                                           @Cast(value="spinPixelFormatEnums")
                                                           int pixelFormat)

spinImageResetEx

public static Spinnaker_C.spinError spinImageResetEx(spinImage hImage,
                                                     @Cast(value="size_t")
                                                     long width,
                                                     @Cast(value="size_t")
                                                     long height,
                                                     @Cast(value="size_t")
                                                     long offsetX,
                                                     @Cast(value="size_t")
                                                     long offsetY,
                                                     Spinnaker_C.spinPixelFormatEnums pixelFormat,
                                                     Pointer pData)

Resets an image with some set properties and image data

Parameters:: hImage - The image to reset; width - The width to be reset to; height - The height to be reset to; offsetX - The offset to be reset to along the X axis; offsetY - The offset to be reset to along the Y axis; pixelFormat - The pixel format to be reset to; pData - The image data to reset to
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageResetEx

@Cast(value="spinError")
public static int spinImageResetEx(spinImage hImage,
                                                             @Cast(value="size_t")
                                                             long width,
                                                             @Cast(value="size_t")
                                                             long height,
                                                             @Cast(value="size_t")
                                                             long offsetX,
                                                             @Cast(value="size_t")
                                                             long offsetY,
                                                             @Cast(value="spinPixelFormatEnums")
                                                             int pixelFormat,
                                                             Pointer pData)

spinImageGetID

public static Spinnaker_C.spinError spinImageGetID(spinImage hImage,
                                                   @Cast(value="uint64_t*")
                                                   LongPointer pId)

Retrieves the ID of an image

Parameters:: hImage - The image of the ID to retrieve; pId - The unsigned integer pointer in which the ID is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageGetID

@Cast(value="spinError")
public static int spinImageGetID(spinImage hImage,
                                                           @Cast(value="uint64_t*")
                                                           LongBuffer pId)

spinImageGetID

public static Spinnaker_C.spinError spinImageGetID(spinImage hImage,
                                                   @Cast(value="uint64_t*")
                                                   long[] pId)

spinImageGetData

public static Spinnaker_C.spinError spinImageGetData(spinImage hImage,
                                                     @Cast(value="void**")
                                                     PointerPointer ppData)

Retrieves the image data of an image

Parameters:: hImage - The image of the image data to retrieve; ppData - The pointer to the void pointer in which the image data is retrieved
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageGetData

public static Spinnaker_C.spinError spinImageGetData(spinImage hImage,
                                                     @Cast(value="void**") @ByPtrPtr
                                                     Pointer ppData)

spinImageGetPrivateData

public static Spinnaker_C.spinError spinImageGetPrivateData(spinImage hImage,
                                                            @Cast(value="void**")
                                                            PointerPointer ppData)

Retrieves the private data of an image

Parameters:: hImage - The image of the private image data to retrieve; ppData - The pointer to the void pointer in which the private image data is retrieved
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageGetPrivateData

public static Spinnaker_C.spinError spinImageGetPrivateData(spinImage hImage,
                                                            @Cast(value="void**") @ByPtrPtr
                                                            Pointer ppData)

spinImageGetBufferSize

public static Spinnaker_C.spinError spinImageGetBufferSize(spinImage hImage,
                                                           @Cast(value="size_t*")
                                                           SizeTPointer pSize)

Retrieves the buffer size of an image

Parameters:: hImage - The image of image data buffer to retrieve; pSize - The unsigned integer pointer in which the size of the image data if returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageDeepCopy
```
public 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)

Parameters:

hSrcImage - The image to be copied

hDestImage - The image handle in which the image is copied

Returns:

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

See Also:

Spinnaker_C.spinError

spinImageGetWidth

public static Spinnaker_C.spinError spinImageGetWidth(spinImage hImage,
                                                      @Cast(value="size_t*")
                                                      SizeTPointer pWidth)

Retrieves the width of an image

Parameters:: hImage - The image of the width to retrieve; pWidth - The unsigned integer pointer in which the width is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageGetHeight

public static Spinnaker_C.spinError spinImageGetHeight(spinImage hImage,
                                                       @Cast(value="size_t*")
                                                       SizeTPointer pHeight)

Retrieves the height of an image

Parameters:: hImage - The image of the height to retrieve; pHeight - The unsigned integer pointer in which the height is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageGetOffsetX

public static Spinnaker_C.spinError spinImageGetOffsetX(spinImage hImage,
                                                        @Cast(value="size_t*")
                                                        SizeTPointer pOffsetX)

Retrieves the offset of an image along its X axis

Parameters:: hImage - The image of the offset along the X axis to retrieve; pOffsetX - The unsigned integer pointer in which the offset along the X axis is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageGetOffsetY

public static Spinnaker_C.spinError spinImageGetOffsetY(spinImage hImage,
                                                        @Cast(value="size_t*")
                                                        SizeTPointer pOffsetY)

Retrieves the offset of an image along its Y axis

Parameters:: hImage - The image of the offset along the Y axis to retrieve; pOffsetY - The unsigned integer pointer in which the offset along the Y axis is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageGetPaddingX

public static Spinnaker_C.spinError spinImageGetPaddingX(spinImage hImage,
                                                         @Cast(value="size_t*")
                                                         SizeTPointer pPaddingX)

Retrieves the padding of an image along its X axis

Parameters:: hImage - The image of the padding along the X axis to retrieve; pPaddingX - The unsigned integer pointer in which the padding along the X axis is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageGetPaddingY

public static Spinnaker_C.spinError spinImageGetPaddingY(spinImage hImage,
                                                         @Cast(value="size_t*")
                                                         SizeTPointer pPaddingY)

Retrieves the padding of an image along its Y axis

Parameters:: hImage - The image of the padding along the Y axis to retrieve; pPaddingY - The unsigned integer pointer in which the padding along the Y axis is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageGetFrameID

public static Spinnaker_C.spinError spinImageGetFrameID(spinImage hImage,
                                                        @Cast(value="uint64_t*")
                                                        LongPointer pFrameID)

Retrieves the frame ID of an image

Parameters:: hImage - The image of the frame ID to retrieve; pFrameID - The unsigned integer pointer in which the frame ID is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageGetFrameID

@Cast(value="spinError")
public static int spinImageGetFrameID(spinImage hImage,
                                                                @Cast(value="uint64_t*")
                                                                LongBuffer pFrameID)

spinImageGetFrameID

public static Spinnaker_C.spinError spinImageGetFrameID(spinImage hImage,
                                                        @Cast(value="uint64_t*")
                                                        long[] pFrameID)

spinImageGetTimeStamp

public static Spinnaker_C.spinError spinImageGetTimeStamp(spinImage hImage,
                                                          @Cast(value="uint64_t*")
                                                          LongPointer pTimeStamp)

Retrieves the timestamp of an image

Parameters:: hImage - The image of the timestamp to retrieve; pTimeStamp - The unsigned integer pointer om which the timestamp is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageGetTimeStamp

@Cast(value="spinError")
public static int spinImageGetTimeStamp(spinImage hImage,
                                                                  @Cast(value="uint64_t*")
                                                                  LongBuffer pTimeStamp)

spinImageGetTimeStamp

public static Spinnaker_C.spinError spinImageGetTimeStamp(spinImage hImage,
                                                          @Cast(value="uint64_t*")
                                                          long[] pTimeStamp)

spinImageGetPayloadType

public static Spinnaker_C.spinError spinImageGetPayloadType(spinImage hImage,
                                                            @Cast(value="size_t*")
                                                            SizeTPointer pPayloadType)

Retrieves the payload type of an image (as an enum, spinPayloadTypeInfoIds)

Parameters:: hImage - The image of the payload type to retrieve; pPayloadType - The payload type enum pointer in which the payload type is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError, spinPayloadTypeInfoIds

spinImageGetTLPayloadType

public static Spinnaker_C.spinError spinImageGetTLPayloadType(spinImage hImage,
                                                              @Cast(value="spinTLPayloadType*")
                                                              IntPointer pPayloadType)

Retrieves the transport layer payload type of an image (as an enum, spinPayloadTypeInfoIds)

Parameters:: hImage - The image of the TL payload type to retrieve; pPayloadType - The payload type enum pointer in which the TL payload type is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError, spinPayloadTypeInfoIds

spinImageGetTLPayloadType

@Cast(value="spinError")
public static int spinImageGetTLPayloadType(spinImage hImage,
                                                                      @Cast(value="spinTLPayloadType*")
                                                                      IntBuffer pPayloadType)

spinImageGetTLPayloadType

public static Spinnaker_C.spinError spinImageGetTLPayloadType(spinImage hImage,
                                                              @Cast(value="spinTLPayloadType*")
                                                              int[] pPayloadType)

spinImageGetPixelFormat

public static Spinnaker_C.spinError spinImageGetPixelFormat(spinImage hImage,
                                                            @Cast(value="spinPixelFormatEnums*")
                                                            IntPointer pPixelFormat)

Retrieves the pixel format of an image (as an enum, spinPixelFormatEnums)

Parameters:: hImage - The image of the pixel format to retrieve; pPixelFormat - The pixel format enum pointer in which the pixel format is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError, Spinnaker_C.spinPixelFormatEnums

spinImageGetPixelFormat

@Cast(value="spinError")
public static int spinImageGetPixelFormat(spinImage hImage,
                                                                    @Cast(value="spinPixelFormatEnums*")
                                                                    IntBuffer pPixelFormat)

spinImageGetPixelFormat

public static Spinnaker_C.spinError spinImageGetPixelFormat(spinImage hImage,
                                                            @Cast(value="spinPixelFormatEnums*")
                                                            int[] pPixelFormat)

spinImageGetTLPixelFormat

public static Spinnaker_C.spinError spinImageGetTLPixelFormat(spinImage hImage,
                                                              @Cast(value="uint64_t*")
                                                              LongPointer pPixelFormat)

Retrieves the transport layer pixel format of an image (as an unsigned integer)

Parameters:: hImage - The image of the TL pixel format to retrieve; pPixelFormat - The unsigned integer pointer in which the TL pixel format is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageGetTLPixelFormat

@Cast(value="spinError")
public static int spinImageGetTLPixelFormat(spinImage hImage,
                                                                      @Cast(value="uint64_t*")
                                                                      LongBuffer pPixelFormat)

spinImageGetTLPixelFormat

public static Spinnaker_C.spinError spinImageGetTLPixelFormat(spinImage hImage,
                                                              @Cast(value="uint64_t*")
                                                              long[] pPixelFormat)

spinImageGetTLPixelFormatNamespace

public static Spinnaker_C.spinError spinImageGetTLPixelFormatNamespace(spinImage hImage,
                                                                       @Cast(value="spinTLPixelFormatNamespace*")
                                                                       IntPointer pPixelFormatNamespace)

Retrieves the transport layer pixel format namespace of an image (as an enum, spinPixelFormatNamespaceID)

Parameters:: hImage - The image of the TL pixel format namespace to retrieve; pPixelFormatNamespace - The pixel format namespace pointer in which the pixel format namespace is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError, spinPixelFormatNamespaceID

spinImageGetTLPixelFormatNamespace

@Cast(value="spinError")
public static int spinImageGetTLPixelFormatNamespace(spinImage hImage,
                                                                               @Cast(value="spinTLPixelFormatNamespace*")
                                                                               IntBuffer pPixelFormatNamespace)

spinImageGetTLPixelFormatNamespace

public static Spinnaker_C.spinError spinImageGetTLPixelFormatNamespace(spinImage hImage,
                                                                       @Cast(value="spinTLPixelFormatNamespace*")
                                                                       int[] pPixelFormatNamespace)

spinImageGetPixelFormatName

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

Retrieves the pixel format of an image (as a symbolic)

Parameters:: hImage - The image of the pixel format to retrieve; pBuf - The c-string character buffer in which the pixel format symbolic 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

spinImageGetPixelFormatName

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

spinImageGetPixelFormatName

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

spinImageIsIncomplete

public static Spinnaker_C.spinError spinImageIsIncomplete(spinImage hImage,
                                                          @Cast(value="bool8_t*")
                                                          BytePointer pbIsIncomplete)

Checks whether an image is incomplete

Parameters:: hImage - The image to check; pbIsIncomplete - The boolean pointer to return whether or not the image is incomplete
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageIsIncomplete

@Cast(value="spinError")
public static int spinImageIsIncomplete(spinImage hImage,
                                                                  @Cast(value="bool8_t*")
                                                                  ByteBuffer pbIsIncomplete)

spinImageIsIncomplete

public static Spinnaker_C.spinError spinImageIsIncomplete(spinImage hImage,
                                                          @Cast(value="bool8_t*")
                                                          byte[] pbIsIncomplete)

spinImageGetValidPayloadSize

public static Spinnaker_C.spinError spinImageGetValidPayloadSize(spinImage hImage,
                                                                 @Cast(value="size_t*")
                                                                 SizeTPointer pSize)

Retrieves the valid payload size of an image

Parameters:: hImage - The image of the payload size to retrieve; pSize - The unsigned integer pointer in which the size of the valid payload is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageSave

public static Spinnaker_C.spinError spinImageSave(spinImage hImage,
                                                  @Cast(value="const char*")
                                                  BytePointer pFilename,
                                                  Spinnaker_C.spinImageFileFormat format)

Saves an image using a specified file format (using an enum, spinImageFileFormat)

Parameters:: hImage - The image to be saved; pFilename - The filename to use to save the image (with or without the appropriate file extension) \Param format The file format to use to save the image
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError, Spinnaker_C.spinImageFileFormat

spinImageSave

@Cast(value="spinError")
public static int spinImageSave(spinImage hImage,
                                                          String pFilename,
                                                          @Cast(value="spinImageFileFormat")
                                                          int format)

spinImageSaveFromExt

public static Spinnaker_C.spinError spinImageSaveFromExt(spinImage hImage,
                                                         @Cast(value="const char*")
                                                         BytePointer pFilename)

Saves an image using a specified file format (using the extension of the filename)

Parameters:: hImage - The image to be saved; pFilename - The filename to use to save the image (with or without the appropriate file extension)
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageSaveFromExt

@Cast(value="spinError")
public static int spinImageSaveFromExt(spinImage hImage,
                                                                 String pFilename)

spinImageSavePng

public static Spinnaker_C.spinError spinImageSavePng(spinImage hImage,
                                                     @Cast(value="const char*")
                                                     BytePointer pFilename,
                                                     @Const
                                                     spinPNGOption pOption)

Saves an image as a PNG image

Parameters:: hImage - The image to be saved; pFilename - The filename to use to save the image (with or without the appropriate file extension); pOption - The image options related to saving as PNG; includes compression level and whether to save as interlaced
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageSavePng

@Cast(value="spinError")
public static int spinImageSavePng(spinImage hImage,
                                                             String pFilename,
                                                             @Const
                                                             spinPNGOption pOption)

spinImageSavePpm

public static Spinnaker_C.spinError spinImageSavePpm(spinImage hImage,
                                                     @Cast(value="const char*")
                                                     BytePointer pFilename,
                                                     @Const
                                                     spinPPMOption pOption)

Saves an image as a PPM image

Parameters:: hImage - The image to be saved; pFilename - The filename to use to save the image (with or without the appropriate file extension); pOption - The image options related to saving as PPM; includes whether to save as binary
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageSavePpm

@Cast(value="spinError")
public static int spinImageSavePpm(spinImage hImage,
                                                             String pFilename,
                                                             @Const
                                                             spinPPMOption pOption)

spinImageSavePgm

public static Spinnaker_C.spinError spinImageSavePgm(spinImage hImage,
                                                     @Cast(value="const char*")
                                                     BytePointer pFilename,
                                                     @Const
                                                     spinPGMOption pOption)

Saves an image as an PGM image

Parameters:: hImage - The image to be saved; pFilename - The filename to use to save the image (with or without the appropriate file extension); pOption - The image options related to saving as PGM; includes whether to save as binary
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageSavePgm

@Cast(value="spinError")
public static int spinImageSavePgm(spinImage hImage,
                                                             String pFilename,
                                                             @Const
                                                             spinPGMOption pOption)

spinImageSaveTiff

public static Spinnaker_C.spinError spinImageSaveTiff(spinImage hImage,
                                                      @Cast(value="const char*")
                                                      BytePointer pFilename,
                                                      @Const
                                                      spinTIFFOption pOption)

Saves an image as a TIFF image

Parameters:: hImage - The image to be saved; pFilename - The filename to use to save the image (with or without the appropriate file extension); pOption - The image options related to saving as TIFF; includes compression method
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageSaveTiff

@Cast(value="spinError")
public static int spinImageSaveTiff(spinImage hImage,
                                                              String pFilename,
                                                              @Const
                                                              spinTIFFOption pOption)

spinImageSaveJpeg

public static Spinnaker_C.spinError spinImageSaveJpeg(spinImage hImage,
                                                      @Cast(value="const char*")
                                                      BytePointer pFilename,
                                                      @Const
                                                      spinJPEGOption pOption)

Saves an image as a JPEG image

Parameters:: hImage - The image to be saved; pFilename - The filename to use to save the image (with or without the appropriate file extension); pOption - The image options related to saving as JPEG; includes quality and whether to save as progressive
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageSaveJpeg

@Cast(value="spinError")
public static int spinImageSaveJpeg(spinImage hImage,
                                                              String pFilename,
                                                              @Const
                                                              spinJPEGOption pOption)

spinImageSaveJpg2

public static Spinnaker_C.spinError spinImageSaveJpg2(spinImage hImage,
                                                      @Cast(value="const char*")
                                                      BytePointer pFilename,
                                                      @Const
                                                      spinJPG2Option pOption)

Saves an image as a JPEG 2000 image

Parameters:: hImage - The image to be saved; pFilename - The filename to use to save the image (with or without the appropriate file extension); pOption - The image options related to saving as JPEG 2000; includes quality
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageSaveJpg2

@Cast(value="spinError")
public static int spinImageSaveJpg2(spinImage hImage,
                                                              String pFilename,
                                                              @Const
                                                              spinJPG2Option pOption)

spinImageSaveBmp

public static Spinnaker_C.spinError spinImageSaveBmp(spinImage hImage,
                                                     @Cast(value="const char*")
                                                     BytePointer pFilename,
                                                     @Const
                                                     spinBMPOption pOption)

Saves an image as a BMP image

Parameters:: hImage - The image to be saved; pFilename - The filename to use to save the image (with or without the appropriate file extension); pOption - The image options related to saving as BMP; includes whether to save as indexed 8-bit
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageSaveBmp

@Cast(value="spinError")
public static int spinImageSaveBmp(spinImage hImage,
                                                             String pFilename,
                                                             @Const
                                                             spinBMPOption pOption)

spinImageGetChunkLayoutID

public static Spinnaker_C.spinError spinImageGetChunkLayoutID(spinImage hImage,
                                                              @Cast(value="uint64_t*")
                                                              LongPointer pId)

Retrieves the chunk layout ID of an image

Parameters:: hImage - The image to be saved; pId - The unsigned integer pointer in which the chunk layout ID is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageGetChunkLayoutID

@Cast(value="spinError")
public static int spinImageGetChunkLayoutID(spinImage hImage,
                                                                      @Cast(value="uint64_t*")
                                                                      LongBuffer pId)

spinImageGetChunkLayoutID

public static Spinnaker_C.spinError spinImageGetChunkLayoutID(spinImage hImage,
                                                              @Cast(value="uint64_t*")
                                                              long[] pId)

spinImageCalculateStatistics
```
public static Spinnaker_C.spinError spinImageCalculateStatistics(spinImage hImage,
                                                                 spinImageStatistics hStatistics)
```
Calculates the image statistics of an image

Parameters:

hImage - The image to be saved

hStatistics - The image statistics context in which the calculated statistics are returned

Returns:

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

See Also:

Spinnaker_C.spinError

spinImageGetStatus

public static Spinnaker_C.spinError spinImageGetStatus(spinImage hImage,
                                                       @Cast(value="spinImageStatus*")
                                                       IntPointer pStatus)

Retrieves the image status of an image

Parameters:: hImage - The image to be saved; pStatus - The status enum pointer in which the image status is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageGetStatus

@Cast(value="spinError")
public static int spinImageGetStatus(spinImage hImage,
                                                               @Cast(value="spinImageStatus*")
                                                               IntBuffer pStatus)

spinImageGetStatus

public static Spinnaker_C.spinError spinImageGetStatus(spinImage hImage,
                                                       @Cast(value="spinImageStatus*")
                                                       int[] pStatus)

spinImageGetStatusDescription

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

Retrieves the description of image status

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

spinImageGetStatusDescription

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

spinImageGetStatusDescription

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

spinImageGetStatusDescription

@Cast(value="spinError")
public static int spinImageGetStatusDescription(@Cast(value="spinImageStatus")
                                                                          int status,
                                                                          @Cast(value="char*")
                                                                          BytePointer pBuf,
                                                                          @Cast(value="size_t*")
                                                                          SizeTPointer pBufLen)

spinImageGetStatusDescription

public static Spinnaker_C.spinError spinImageGetStatusDescription(Spinnaker_C.spinImageStatus status,
                                                                  @Cast(value="char*")
                                                                  ByteBuffer pBuf,
                                                                  @Cast(value="size_t*")
                                                                  SizeTPointer pBufLen)

spinImageGetStatusDescription

@Cast(value="spinError")
public static int spinImageGetStatusDescription(@Cast(value="spinImageStatus")
                                                                          int status,
                                                                          @Cast(value="char*")
                                                                          byte[] pBuf,
                                                                          @Cast(value="size_t*")
                                                                          SizeTPointer pBufLen)

spinImageRelease
```
public static Spinnaker_C.spinError spinImageRelease(spinImage hImage)
```
Releases an image

Parameters:

hImage - The image to be saved

Returns:

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

See Also:

Spinnaker_C.spinError

spinImageHasCRC

public static Spinnaker_C.spinError spinImageHasCRC(spinImage hImage,
                                                    @Cast(value="bool8_t*")
                                                    BytePointer pbHasCRC)

Checks whether an image has CRC

Parameters:: hImage - The image to be saved; pbHasCRC - The boolean pointer to return whether the image has CRC available
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageHasCRC

@Cast(value="spinError")
public static int spinImageHasCRC(spinImage hImage,
                                                            @Cast(value="bool8_t*")
                                                            ByteBuffer pbHasCRC)

spinImageHasCRC

public static Spinnaker_C.spinError spinImageHasCRC(spinImage hImage,
                                                    @Cast(value="bool8_t*")
                                                    byte[] pbHasCRC)

spinImageCheckCRC

public static Spinnaker_C.spinError spinImageCheckCRC(spinImage hImage,
                                                      @Cast(value="bool8_t*")
                                                      BytePointer pbCheckCRC)

Checks whether the CRC of an image is correct

Parameters:: hImage - The image to be saved; pbCheckCRC - The boolean pointer to return whether the image CRC passes
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageCheckCRC

@Cast(value="spinError")
public static int spinImageCheckCRC(spinImage hImage,
                                                              @Cast(value="bool8_t*")
                                                              ByteBuffer pbCheckCRC)

spinImageCheckCRC

public static Spinnaker_C.spinError spinImageCheckCRC(spinImage hImage,
                                                      @Cast(value="bool8_t*")
                                                      byte[] pbCheckCRC)

spinImageGetBitsPerPixel

public static Spinnaker_C.spinError spinImageGetBitsPerPixel(spinImage hImage,
                                                             @Cast(value="size_t*")
                                                             SizeTPointer pBitsPerPixel)

Retrieves the number of bits per pixel of an image

Parameters:: hImage - The image to be saved; pBitsPerPixel - The unsigned integer pointer in which the number of bits per pixel is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageGetSize

public static Spinnaker_C.spinError spinImageGetSize(spinImage hImage,
                                                     @Cast(value="size_t*")
                                                     SizeTPointer pImageSize)

Retrieves the size of an image

Parameters:: hImage - The image to be saved; pImageSize - The unsigned integer pointer in which the size of the image is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageGetStride

public static Spinnaker_C.spinError spinImageGetStride(spinImage hImage,
                                                       @Cast(value="size_t*")
                                                       SizeTPointer pStride)

Retrieves the stride of an image

Parameters:: hImage - The image to be saved; pStride - The unsigned integer pointer in which the stride is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageProcessorCreate
```
public static Spinnaker_C.spinError spinImageProcessorCreate(@ByPtrPtr
                                                             spinImageProcessor phImageProcessor)
```
Creates an image processor

Parameters:

phImageProcessor - The image processor handle pointer in which the image processor context is returned

Returns:

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

See Also:

Spinnaker_C.spinError

spinImageProcessorDestroy
```
public static Spinnaker_C.spinError spinImageProcessorDestroy(spinImageProcessor hImageProcessor)
```
Destroys a image list

Parameters:

hImageProcessor - The image processor context to destroy

Returns:

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

See Also:

Spinnaker_C.spinError

spinImageProcessorSetColorProcessing
```
public 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. The DEFAULT algorithm is deprecated and should not be used in the ImageProcessor class.

Parameters:

hImageProcessor - The image processor context

colorAlgorithm - The color processing algorithm to set.

See Also:

spinImageProcessorGetColorProcessing()

spinImageProcessorSetColorProcessing

@Cast(value="spinError")
public static int spinImageProcessorSetColorProcessing(spinImageProcessor hImageProcessor,
                                                                                 @Cast(value="spinColorProcessingAlgorithm")
                                                                                 int colorAlgorithm)

spinImageProcessorGetColorProcessing

public static Spinnaker_C.spinError spinImageProcessorGetColorProcessing(spinImageProcessor hImageProcessor,
                                                                         @Cast(value="spinColorProcessingAlgorithm*")
                                                                         IntPointer pColorAlgorithm)

Gets the default color processing algorithm.

Parameters:: hImageProcessor - The image processor context; pColorAlgorithm - The color processing algorithm pointer in which the color processing algorithm is returned
See Also:: spinImageProcessorSetColorProcessing()

spinImageProcessorGetColorProcessing

@Cast(value="spinError")
public static int spinImageProcessorGetColorProcessing(spinImageProcessor hImageProcessor,
                                                                                 @Cast(value="spinColorProcessingAlgorithm*")
                                                                                 IntBuffer pColorAlgorithm)

spinImageProcessorGetColorProcessing

public static Spinnaker_C.spinError spinImageProcessorGetColorProcessing(spinImageProcessor hImageProcessor,
                                                                         @Cast(value="spinColorProcessingAlgorithm*")
                                                                         int[] pColorAlgorithm)

spinImageProcessorSetNumDecompressionThreads
```
public static Spinnaker_C.spinError spinImageProcessorSetNumDecompressionThreads(spinImageProcessor hImageProcessor,
                                                                                 @Cast(value="unsigned int")
                                                                                 int numThreads)
```
Sets the default number of threads used for image decompression during spinImageProcessorConvert(). The number of threads used is defaulted to be equal to one less than the number of concurrent threads supported by the system.

Parameters:

hImageProcessor - The image processor context

numThreads - Number of parallel image decompression threads set to run

See Also:

spinImageProcessorConvert()

spinImageProcessorGetNumDecompressionThreads

public static Spinnaker_C.spinError spinImageProcessorGetNumDecompressionThreads(spinImageProcessor hImageProcessor,
                                                                                 @Cast(value="unsigned int*")
                                                                                 IntPointer pNumThreads)

Gets the number of threads used for image decompression during spinImageProcessorConvert().

Parameters:: hImageProcessor - The image processor context; pNumThreads - The unsigned integer pointer in which the number of parallel image decompression threads is returned
See Also:: spinImageProcessorSetNumDecompressionThreads()

spinImageProcessorGetNumDecompressionThreads

@Cast(value="spinError")
public static int spinImageProcessorGetNumDecompressionThreads(spinImageProcessor hImageProcessor,
                                                                                         @Cast(value="unsigned int*")
                                                                                         IntBuffer pNumThreads)

spinImageProcessorGetNumDecompressionThreads

public static Spinnaker_C.spinError spinImageProcessorGetNumDecompressionThreads(spinImageProcessor hImageProcessor,
                                                                                 @Cast(value="unsigned int*")
                                                                                 int[] pNumThreads)

spinImageProcessorConvert
```
public 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. The destination image needs to be configured to have the correct buffer size before calling this function. See spinImageReset() to setup the correct buffer size according to specified pixel format. Note that compressed images are decompressed before any further color processing or conversion during this call. Decompression is multi-threaded and defaults to utilizing one less than the number of concurrent threads supported by the system. The default number of decompression threads can be set with spinImageProcessorSetNumDecompressionThreads().

Parameters:

hImageProcessor - The image processor context

srcImage - The source image from which to convert the image from.

destImage - The destination image in which the converted image data will be stored.

destFormat - Output format of the converted image.

See Also:

Spinnaker_C.spinPixelFormatEnums, spinImageReset, spinImageProcessorSetNumDecompressionThreads

spinImageProcessorConvert

@Cast(value="spinError")
public static int spinImageProcessorConvert(spinImageProcessor hImageProcessor,
                                                                      spinImage hSrcImage,
                                                                      spinImage hDestImage,
                                                                      @Cast(value="spinPixelFormatEnums")
                                                                      int destFormat)

spinImageProcessorConvertImageList
```
public 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. The conversion could encompasses decompression, interleaving and conversion of image data depending on the source pixel format of images in the source image list. The destination image needs to be configured to have the correct buffer size before calling this function. See spinImageReset() to setup the correct buffer size according to specified pixel format. Note that compressed images are decompressed before any further color processing, interleaving or conversion is performed. Decompression is multi-threaded and defaults to utilizing one less than the number of concurrent threads supported by the system. The default number of decompression threads can be set with SetNumDecompressionThreads(). Note not all the supported image pixel formats described in the class description are supported in this function. List of supported image pixel formats for the source image list:
- PixelFormat_R12
- PixelFormat_GR12
- PixelFormat_GB12
- PixelFormat_B12
- PixelFormat_R12_Jpeg
- PixelFormat_GR12_Jpeg
- PixelFormat_GB12_Jpeg
- PixelFormat_B12_Jpeg
Parameters:

hImageProcessor - The image processor context

hSrcImageList - List of images from which to convert the images from.

hDestImage - The destination image in which the converted image data will be stored.

destFormat - Output format of the converted image.

See Also:

Spinnaker_C.spinPixelFormatEnums, spinImageReset, spinImageProcessorSetNumDecompressionThreads

spinImageProcessorConvertImageList

@Cast(value="spinError")
public static int spinImageProcessorConvertImageList(spinImageProcessor hImageProcessor,
                                                                               spinImageList hSrcImageList,
                                                                               spinImage hDestImage,
                                                                               @Cast(value="spinPixelFormatEnums")
                                                                               int destFormat)

spinImageProcessorApplyGamma

public static Spinnaker_C.spinError spinImageProcessorApplyGamma(spinImageProcessor hImageProcessor,
                                                                 spinImage hSrcImage,
                                                                 spinImage hDestImage,
                                                                 float gamma,
                                                                 @Cast(value="bool8_t")
                                                                 byte applyGammaInverse)

Applies gamma correction to the source image and stores the result in the destination image.

Parameters:: hImageProcessor - The image processor context; hSrcImage - The source image from which to apply gamma on.; hDestImage - The destination image in which the gamma applied image data will be stored.; gamma - Gamma value to apply. A value between 0.5 and 4 is acceptable. (Default assuming image-to-screen); applyGammaInverse - Converts a gamma corrected source image back to the original image using the inverse of the gamma value (used for applying screen-to-image gamma)

spinDeviceEventHandlerCreate

public static Spinnaker_C.spinError spinDeviceEventHandlerCreate(@ByPtrPtr
                                                                 spinDeviceEventHandler phDeviceEventHandler,
                                                                 spinDeviceEventFunction pFunction,
                                                                 Pointer pUserData)

Creates a device event handler

Parameters:: phDeviceEventHandler - The device event handler pointer in which the device event context is created; pFunction - The function to be called at device event occurrences; signature to match: void(*spinDeviceEventFunction)(const spinDeviceEventData hEventData, const char* pEventName, void* pUserData); pUserData - Properties that can be passed into the event function
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinDeviceEventHandlerDestroy
```
public static Spinnaker_C.spinError spinDeviceEventHandlerDestroy(spinDeviceEventHandler hDeviceEventHandler)
```
Destroys a device event handler

Parameters:

hDeviceEventHandler - The device event handler to destroy

Returns:

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

See Also:

Spinnaker_C.spinError

spinImageEventHandlerCreate

public static Spinnaker_C.spinError spinImageEventHandlerCreate(@ByPtrPtr
                                                                spinImageEventHandler phImageEventHandler,
                                                                spinImageEventFunction pFunction,
                                                                Pointer pUserData)

Creates an image event handler

Parameters:: phImageEventHandler - The image event handler pointer in which the image event context is created; pFunction - The function to be called at image event occurrences; signature to match: void(*spinImageEventFunction)(const spinImage hImage, void* pUserData); pUserData - Properties that can be passed into the event function
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageEventHandlerDestroy
```
public static Spinnaker_C.spinError spinImageEventHandlerDestroy(spinImageEventHandler hImageEventHandler)
```
Destroys an image event handler

Parameters:

hImageEventHandler - The image event handler to destroy

Returns:

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

See Also:

Spinnaker_C.spinError

spinImageListEventHandlerCreate

public static Spinnaker_C.spinError spinImageListEventHandlerCreate(@ByPtrPtr
                                                                    spinImageListEventHandler phImageEventHandler,
                                                                    spinImageListEventFunction pFunction,
                                                                    Pointer pUserData)

Creates an image list event handler

Parameters:: phImageListEventHandler - The image list event handler pointer in which the image list event context is created; pFunction - The function to be called at image list event occurrences; signature to match: void(*spinImageListEventFunction)(const spinListImage hImage, void* pUserData); pUserData - Properties that can be passed into the event function
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageListEventHandlerDestroy
```
public static Spinnaker_C.spinError spinImageListEventHandlerDestroy(spinImageListEventHandler hImageListEventHandler)
```
Destroys an image list event handler

Parameters:

hImageListEventHandler - The image list event handler to destroy

Returns:

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

See Also:

Spinnaker_C.spinError

spinDeviceArrivalEventHandlerCreate

public static Spinnaker_C.spinError spinDeviceArrivalEventHandlerCreate(@ByPtrPtr
                                                                        spinDeviceArrivalEventHandler phDeviceArrivalEventHandler,
                                                                        spinArrivalEventFunction pFunction,
                                                                        Pointer pUserData)

Creates a device arrival event handler

Parameters:: phDeviceArrivalEventHandler - The device arrival event handler pointer in which the device arrival event context is created; pFunction - The function to be called at device event occurrences; signature to match: void(*spinArrivalEventFunction)(void* pUserData); pUserData - Properties that can be passed into the event function
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinDeviceArrivalEventHandlerDestroy
```
public static Spinnaker_C.spinError spinDeviceArrivalEventHandlerDestroy(spinDeviceArrivalEventHandler hDeviceArrivalEventHandler)
```
Destroys a device arrival event handler

Parameters:

hDeviceArrivalEventHandler - The device arrival event handler to destroy

Returns:

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

See Also:

Spinnaker_C.spinError

spinDeviceRemovalEventHandlerCreate

public static Spinnaker_C.spinError spinDeviceRemovalEventHandlerCreate(@ByPtrPtr
                                                                        spinDeviceRemovalEventHandler phDeviceRemovalEventHandler,
                                                                        spinRemovalEventFunction pFunction,
                                                                        Pointer pUserData)

Creates a device removal event handler

Parameters:: phDeviceRemovalEventHandler - The device removal event handler pointer in which the device removal event context is created; pFunction - The function to be called at device event occurrences; signature to match: void(*spinRemovalEventFunction)(uint64_t deviceSerialNumber, void* pUserData); pUserData - Properties that can be passed into the event function
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinDeviceRemovalEventHandlerDestroy
```
public static Spinnaker_C.spinError spinDeviceRemovalEventHandlerDestroy(spinDeviceRemovalEventHandler hDeviceRemovalEventHandler)
```
Destroys a device removal event handler

Parameters:

hDeviceRemovalEventHandler - The device removal event handler to destroy

Returns:

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

See Also:

Spinnaker_C.spinError

spinInterfaceEventHandlerCreate

public static Spinnaker_C.spinError spinInterfaceEventHandlerCreate(@ByPtrPtr
                                                                    spinInterfaceEventHandler phInterfaceEventHandler,
                                                                    spinArrivalEventFunction pArrivalFunction,
                                                                    spinRemovalEventFunction pRemovalFunction,
                                                                    Pointer pUserData)

Creates an interface event handler (both device arrival and device removal)

Parameters:: phInterfaceEventHandler - The interface event handler pointer in which the interface event context is created; pArrivalFunction - The function to be called at arrival event occurrences; signature to match: void(*spinArrivalEventFunction)(void* pUserData); hRemovalFunction - The function to be called at removal event occurrences; signature to match: void(*spinRemovalEventFunction)(uint64_t deviceSerialNumber, void* pUserData); pUserData - Properties that can be passed into the event function
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinInterfaceEventHandlerDestroy
```
public static Spinnaker_C.spinError spinInterfaceEventHandlerDestroy(spinInterfaceEventHandler hInterfaceEventHandler)
```
Destroys an interface event handler (both device arrival and device removal)

Parameters:

hInterfaceEventHandler - The interface event handler to destroy

Returns:

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

See Also:

Spinnaker_C.spinError

spinLogEventHandlerCreate

public static Spinnaker_C.spinError spinLogEventHandlerCreate(@ByPtrPtr
                                                              spinLogEventHandler phLogEventHandler,
                                                              spinLogEventFunction pFunction,
                                                              Pointer pUserData)

Creates a log event handler

Parameters:: phLogEventHandler - The log event handler pointer in which the log event context is created; pFunction - The function to be called at device event occurrences; signature to match: void(*spinLogEventFunction)(const spinLogEventData hEventData, void* pUserData); pUserData - Properties that can be passed into the event function
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinLogEventHandlerDestroy
```
public static Spinnaker_C.spinError spinLogEventHandlerDestroy(spinLogEventHandler hLogEventHandler)
```
Destroys a log event handler

Parameters:

hLogEventHandler - The log event handler to destroy

Returns:

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

See Also:

Spinnaker_C.spinError

spinImageStatisticsCreate
```
public static Spinnaker_C.spinError spinImageStatisticsCreate(@ByPtrPtr
                                                              spinImageStatistics phStatistics)
```
Creates an image statistics context

Parameters:

phStatistics - The statistics handle pointer in which the image statistics context is returned

Returns:

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

spinImageStatisticsDestroy
```
public static Spinnaker_C.spinError spinImageStatisticsDestroy(spinImageStatistics hStatistics)
```
Destroys an image statistics context

Parameters:

hStatistics - The image statistics context to destroy

Returns:

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

See Also:

Spinnaker_C.spinError

spinImageStatisticsEnableAll
```
public static Spinnaker_C.spinError spinImageStatisticsEnableAll(spinImageStatistics hStatistics)
```
Enables all channels of an image statistics context

Parameters:

hStatistics - The image statistics context to enable all channels

Returns:

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

See Also:

Spinnaker_C.spinError

spinImageStatisticsDisableAll
```
public static Spinnaker_C.spinError spinImageStatisticsDisableAll(spinImageStatistics hStatistics)
```
Disables all channels of an image statistics context

Parameters:

hStatistics - The image statistics context to disable all channels

Returns:

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

See Also:

Spinnaker_C.spinError

spinImageStatisticsEnableGreyOnly
```
public static Spinnaker_C.spinError spinImageStatisticsEnableGreyOnly(spinImageStatistics hStatistics)
```
Disables all channels of an image statistics context except grey-scale

Parameters:

hStatistics - The image statistics context to enable only grey

Returns:

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

See Also:

Spinnaker_C.spinError

spinImageStatisticsEnableRgbOnly
```
public static Spinnaker_C.spinError spinImageStatisticsEnableRgbOnly(spinImageStatistics hStatistics)
```
Disables all channels of an image statistics context except red, blue, and green

Parameters:

hStatistics - The image statistics context to enable only RGB

Returns:

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

See Also:

Spinnaker_C.spinError

spinImageStatisticsEnableHslOnly
```
public static Spinnaker_C.spinError spinImageStatisticsEnableHslOnly(spinImageStatistics hStatistics)
```
Disables all channels of an image statistics context except hue, saturation, and lightness

Parameters:

hStatistics - The image statistics context to enable only HSL

Returns:

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

See Also:

Spinnaker_C.spinError

spinImageStatisticsGetChannelStatus

public static Spinnaker_C.spinError spinImageStatisticsGetChannelStatus(spinImageStatistics hStatistics,
                                                                        Spinnaker_C.spinStatisticsChannel channel,
                                                                        @Cast(value="bool8_t*")
                                                                        BytePointer pbEnabled)

Checks whether an image statistics context is enabled

Parameters:: hStatistics - The image statistics context of the channel; channel - The channel to check; pbEnabled - The boolean pointer to return whether or not the channel is enabled
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageStatisticsGetChannelStatus

@Cast(value="spinError")
public static int spinImageStatisticsGetChannelStatus(spinImageStatistics hStatistics,
                                                                                @Cast(value="spinStatisticsChannel")
                                                                                int channel,
                                                                                @Cast(value="bool8_t*")
                                                                                ByteBuffer pbEnabled)

spinImageStatisticsGetChannelStatus

public static Spinnaker_C.spinError spinImageStatisticsGetChannelStatus(spinImageStatistics hStatistics,
                                                                        Spinnaker_C.spinStatisticsChannel channel,
                                                                        @Cast(value="bool8_t*")
                                                                        byte[] pbEnabled)

spinImageStatisticsGetChannelStatus

@Cast(value="spinError")
public static int spinImageStatisticsGetChannelStatus(spinImageStatistics hStatistics,
                                                                                @Cast(value="spinStatisticsChannel")
                                                                                int channel,
                                                                                @Cast(value="bool8_t*")
                                                                                BytePointer pbEnabled)

spinImageStatisticsGetChannelStatus

public static Spinnaker_C.spinError spinImageStatisticsGetChannelStatus(spinImageStatistics hStatistics,
                                                                        Spinnaker_C.spinStatisticsChannel channel,
                                                                        @Cast(value="bool8_t*")
                                                                        ByteBuffer pbEnabled)

spinImageStatisticsGetChannelStatus

@Cast(value="spinError")
public static int spinImageStatisticsGetChannelStatus(spinImageStatistics hStatistics,
                                                                                @Cast(value="spinStatisticsChannel")
                                                                                int channel,
                                                                                @Cast(value="bool8_t*")
                                                                                byte[] pbEnabled)

spinImageStatisticsSetChannelStatus

public static Spinnaker_C.spinError spinImageStatisticsSetChannelStatus(spinImageStatistics hStatistics,
                                                                        Spinnaker_C.spinStatisticsChannel channel,
                                                                        @Cast(value="bool8_t")
                                                                        byte bEnable)

Sets the status of an image statistics channel

Parameters:: hStatistics - The image statistics context of the channel; channel - The channel to enable/disable; bEnable - The boolean value to set; true enables, false disables
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageStatisticsSetChannelStatus

@Cast(value="spinError")
public static int spinImageStatisticsSetChannelStatus(spinImageStatistics hStatistics,
                                                                                @Cast(value="spinStatisticsChannel")
                                                                                int channel,
                                                                                @Cast(value="bool8_t")
                                                                                byte bEnable)

spinImageStatisticsGetRange

public static Spinnaker_C.spinError spinImageStatisticsGetRange(spinImageStatistics hStatistics,
                                                                Spinnaker_C.spinStatisticsChannel channel,
                                                                @Cast(value="unsigned int*")
                                                                IntPointer pMin,
                                                                @Cast(value="unsigned int*")
                                                                IntPointer pMax)

Retrieves the range of an image statistics channel

Parameters:: hStatistics - The image statistics context of the channel; channel - The channel of the range to retrieve; pMin - The unsigned integer pointer in which the minimum value of the range is returned; pMax - The unsigned integer pointer in which the maximum value of the range is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageStatisticsGetRange

@Cast(value="spinError")
public static int spinImageStatisticsGetRange(spinImageStatistics hStatistics,
                                                                        @Cast(value="spinStatisticsChannel")
                                                                        int channel,
                                                                        @Cast(value="unsigned int*")
                                                                        IntBuffer pMin,
                                                                        @Cast(value="unsigned int*")
                                                                        IntBuffer pMax)

spinImageStatisticsGetRange

public static Spinnaker_C.spinError spinImageStatisticsGetRange(spinImageStatistics hStatistics,
                                                                Spinnaker_C.spinStatisticsChannel channel,
                                                                @Cast(value="unsigned int*")
                                                                int[] pMin,
                                                                @Cast(value="unsigned int*")
                                                                int[] pMax)

spinImageStatisticsGetRange

@Cast(value="spinError")
public static int spinImageStatisticsGetRange(spinImageStatistics hStatistics,
                                                                        @Cast(value="spinStatisticsChannel")
                                                                        int channel,
                                                                        @Cast(value="unsigned int*")
                                                                        IntPointer pMin,
                                                                        @Cast(value="unsigned int*")
                                                                        IntPointer pMax)

spinImageStatisticsGetRange

public static Spinnaker_C.spinError spinImageStatisticsGetRange(spinImageStatistics hStatistics,
                                                                Spinnaker_C.spinStatisticsChannel channel,
                                                                @Cast(value="unsigned int*")
                                                                IntBuffer pMin,
                                                                @Cast(value="unsigned int*")
                                                                IntBuffer pMax)

spinImageStatisticsGetRange

@Cast(value="spinError")
public static int spinImageStatisticsGetRange(spinImageStatistics hStatistics,
                                                                        @Cast(value="spinStatisticsChannel")
                                                                        int channel,
                                                                        @Cast(value="unsigned int*")
                                                                        int[] pMin,
                                                                        @Cast(value="unsigned int*")
                                                                        int[] pMax)

spinImageStatisticsGetPixelValueRange

public static Spinnaker_C.spinError spinImageStatisticsGetPixelValueRange(spinImageStatistics hStatistics,
                                                                          Spinnaker_C.spinStatisticsChannel channel,
                                                                          @Cast(value="unsigned int*")
                                                                          IntPointer pMin,
                                                                          @Cast(value="unsigned int*")
                                                                          IntPointer pMax)

Retrieves the pixel value range of an image statistics channel

Parameters:: hStatistics - The image statistics context of the channel; channel - The channel of the pixel value range to retrieve; pMin - The unsigned integer pointer in which the minimum value of the pixel value range is returned; pMax - The unsigned integer pointer in which the maximum value of the pixel value range is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageStatisticsGetPixelValueRange

@Cast(value="spinError")
public static int spinImageStatisticsGetPixelValueRange(spinImageStatistics hStatistics,
                                                                                  @Cast(value="spinStatisticsChannel")
                                                                                  int channel,
                                                                                  @Cast(value="unsigned int*")
                                                                                  IntBuffer pMin,
                                                                                  @Cast(value="unsigned int*")
                                                                                  IntBuffer pMax)

spinImageStatisticsGetPixelValueRange

public static Spinnaker_C.spinError spinImageStatisticsGetPixelValueRange(spinImageStatistics hStatistics,
                                                                          Spinnaker_C.spinStatisticsChannel channel,
                                                                          @Cast(value="unsigned int*")
                                                                          int[] pMin,
                                                                          @Cast(value="unsigned int*")
                                                                          int[] pMax)

spinImageStatisticsGetPixelValueRange

@Cast(value="spinError")
public static int spinImageStatisticsGetPixelValueRange(spinImageStatistics hStatistics,
                                                                                  @Cast(value="spinStatisticsChannel")
                                                                                  int channel,
                                                                                  @Cast(value="unsigned int*")
                                                                                  IntPointer pMin,
                                                                                  @Cast(value="unsigned int*")
                                                                                  IntPointer pMax)

spinImageStatisticsGetPixelValueRange

public static Spinnaker_C.spinError spinImageStatisticsGetPixelValueRange(spinImageStatistics hStatistics,
                                                                          Spinnaker_C.spinStatisticsChannel channel,
                                                                          @Cast(value="unsigned int*")
                                                                          IntBuffer pMin,
                                                                          @Cast(value="unsigned int*")
                                                                          IntBuffer pMax)

spinImageStatisticsGetPixelValueRange

@Cast(value="spinError")
public static int spinImageStatisticsGetPixelValueRange(spinImageStatistics hStatistics,
                                                                                  @Cast(value="spinStatisticsChannel")
                                                                                  int channel,
                                                                                  @Cast(value="unsigned int*")
                                                                                  int[] pMin,
                                                                                  @Cast(value="unsigned int*")
                                                                                  int[] pMax)

spinImageStatisticsGetNumPixelValues

public static Spinnaker_C.spinError spinImageStatisticsGetNumPixelValues(spinImageStatistics hStatistics,
                                                                         Spinnaker_C.spinStatisticsChannel channel,
                                                                         @Cast(value="unsigned int*")
                                                                         IntPointer pNumValues)

Retrieves the number of pixel values of an image statistics channel

Parameters:: hStatistics - The image statistics context of the channel; channel - The channel where the pixel values to be counted are; iNumValues - The unsigned integer pointer in which the number of pixel values is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageStatisticsGetNumPixelValues

@Cast(value="spinError")
public static int spinImageStatisticsGetNumPixelValues(spinImageStatistics hStatistics,
                                                                                 @Cast(value="spinStatisticsChannel")
                                                                                 int channel,
                                                                                 @Cast(value="unsigned int*")
                                                                                 IntBuffer pNumValues)

spinImageStatisticsGetNumPixelValues

public static Spinnaker_C.spinError spinImageStatisticsGetNumPixelValues(spinImageStatistics hStatistics,
                                                                         Spinnaker_C.spinStatisticsChannel channel,
                                                                         @Cast(value="unsigned int*")
                                                                         int[] pNumValues)

spinImageStatisticsGetNumPixelValues

@Cast(value="spinError")
public static int spinImageStatisticsGetNumPixelValues(spinImageStatistics hStatistics,
                                                                                 @Cast(value="spinStatisticsChannel")
                                                                                 int channel,
                                                                                 @Cast(value="unsigned int*")
                                                                                 IntPointer pNumValues)

spinImageStatisticsGetNumPixelValues

public static Spinnaker_C.spinError spinImageStatisticsGetNumPixelValues(spinImageStatistics hStatistics,
                                                                         Spinnaker_C.spinStatisticsChannel channel,
                                                                         @Cast(value="unsigned int*")
                                                                         IntBuffer pNumValues)

spinImageStatisticsGetNumPixelValues

@Cast(value="spinError")
public static int spinImageStatisticsGetNumPixelValues(spinImageStatistics hStatistics,
                                                                                 @Cast(value="spinStatisticsChannel")
                                                                                 int channel,
                                                                                 @Cast(value="unsigned int*")
                                                                                 int[] pNumValues)

spinImageStatisticsGetMean

public static Spinnaker_C.spinError spinImageStatisticsGetMean(spinImageStatistics hStatistics,
                                                               Spinnaker_C.spinStatisticsChannel channel,
                                                               FloatPointer pMean)

Retrieves the mean of pixel values of an image statistics channel

Parameters:: hStatistics - The image statistics context of the channel; channel - The channel of the mean pixel value to be retrieved; pMean - The float pointer in which the mean pixel value is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageStatisticsGetMean

@Cast(value="spinError")
public static int spinImageStatisticsGetMean(spinImageStatistics hStatistics,
                                                                       @Cast(value="spinStatisticsChannel")
                                                                       int channel,
                                                                       FloatBuffer pMean)

spinImageStatisticsGetMean

public static Spinnaker_C.spinError spinImageStatisticsGetMean(spinImageStatistics hStatistics,
                                                               Spinnaker_C.spinStatisticsChannel channel,
                                                               float[] pMean)

spinImageStatisticsGetMean

@Cast(value="spinError")
public static int spinImageStatisticsGetMean(spinImageStatistics hStatistics,
                                                                       @Cast(value="spinStatisticsChannel")
                                                                       int channel,
                                                                       FloatPointer pMean)

spinImageStatisticsGetMean

public static Spinnaker_C.spinError spinImageStatisticsGetMean(spinImageStatistics hStatistics,
                                                               Spinnaker_C.spinStatisticsChannel channel,
                                                               FloatBuffer pMean)

spinImageStatisticsGetMean

@Cast(value="spinError")
public static int spinImageStatisticsGetMean(spinImageStatistics hStatistics,
                                                                       @Cast(value="spinStatisticsChannel")
                                                                       int channel,
                                                                       float[] pMean)

spinImageStatisticsGetHistogram

public static Spinnaker_C.spinError spinImageStatisticsGetHistogram(spinImageStatistics hStatistics,
                                                                    Spinnaker_C.spinStatisticsChannel channel,
                                                                    @Cast(value="int**")
                                                                    PointerPointer ppHistogram)

Retrieves a histogram of an image statistics channel

Parameters:: hStatistics - The image statistics context of the channel; channel - The channel of the histogram to be returned; pHistogram - The pointer to the integer pointer in which the histogram data is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageStatisticsGetHistogram

public static Spinnaker_C.spinError spinImageStatisticsGetHistogram(spinImageStatistics hStatistics,
                                                                    Spinnaker_C.spinStatisticsChannel channel,
                                                                    @ByPtrPtr
                                                                    IntPointer ppHistogram)

spinImageStatisticsGetHistogram

@Cast(value="spinError")
public static int spinImageStatisticsGetHistogram(spinImageStatistics hStatistics,
                                                                            @Cast(value="spinStatisticsChannel")
                                                                            int channel,
                                                                            @ByPtrPtr
                                                                            IntBuffer ppHistogram)

spinImageStatisticsGetHistogram

public static Spinnaker_C.spinError spinImageStatisticsGetHistogram(spinImageStatistics hStatistics,
                                                                    Spinnaker_C.spinStatisticsChannel channel,
                                                                    @ByPtrPtr
                                                                    int[] ppHistogram)

spinImageStatisticsGetHistogram

@Cast(value="spinError")
public static int spinImageStatisticsGetHistogram(spinImageStatistics hStatistics,
                                                                            @Cast(value="spinStatisticsChannel")
                                                                            int channel,
                                                                            @ByPtrPtr
                                                                            IntPointer ppHistogram)

spinImageStatisticsGetHistogram

public static Spinnaker_C.spinError spinImageStatisticsGetHistogram(spinImageStatistics hStatistics,
                                                                    Spinnaker_C.spinStatisticsChannel channel,
                                                                    @ByPtrPtr
                                                                    IntBuffer ppHistogram)

spinImageStatisticsGetHistogram

@Cast(value="spinError")
public static int spinImageStatisticsGetHistogram(spinImageStatistics hStatistics,
                                                                            @Cast(value="spinStatisticsChannel")
                                                                            int channel,
                                                                            @ByPtrPtr
                                                                            int[] ppHistogram)

spinImageStatisticsGetAll

public static Spinnaker_C.spinError spinImageStatisticsGetAll(spinImageStatistics hStatistics,
                                                              Spinnaker_C.spinStatisticsChannel channel,
                                                              @Cast(value="unsigned int*")
                                                              IntPointer pRangeMin,
                                                              @Cast(value="unsigned int*")
                                                              IntPointer pRangeMax,
                                                              @Cast(value="unsigned int*")
                                                              IntPointer pPixelValueMin,
                                                              @Cast(value="unsigned int*")
                                                              IntPointer pPixelValueMax,
                                                              @Cast(value="unsigned int*")
                                                              IntPointer pNumPixelValues,
                                                              FloatPointer pPixelValueMean,
                                                              @Cast(value="int**")
                                                              PointerPointer ppHistogram)

Retrieves all available information of an image statistics channel

Parameters:: hStatistics - The image statistics context of the channel; channel - The channel of the information to retrieve; pRangeMin - The unsigned integer pointer in which the minimum value of the range is returned; pRangeMax - The unsigned integer pointer in which the maximum value of the range is returned; pPixelValueMin - The unsigned integer pointer in which the minimum pixel value of the range is returned; pPixelValueMax - The unsigned integer pointer in which the maximum pixel value of the range is returned; pNumPixelValues - The unsigned integer pointer in which the number of pixel values is returned; pPixelValueMean - The float pointer in which the mean pixel value is returned; ppiHistogram - The pointer to the pointer in which the histogram data is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinImageStatisticsGetAll

public static Spinnaker_C.spinError spinImageStatisticsGetAll(spinImageStatistics hStatistics,
                                                              Spinnaker_C.spinStatisticsChannel channel,
                                                              @Cast(value="unsigned int*")
                                                              IntPointer pRangeMin,
                                                              @Cast(value="unsigned int*")
                                                              IntPointer pRangeMax,
                                                              @Cast(value="unsigned int*")
                                                              IntPointer pPixelValueMin,
                                                              @Cast(value="unsigned int*")
                                                              IntPointer pPixelValueMax,
                                                              @Cast(value="unsigned int*")
                                                              IntPointer pNumPixelValues,
                                                              FloatPointer pPixelValueMean,
                                                              @ByPtrPtr
                                                              IntPointer ppHistogram)

spinImageStatisticsGetAll

@Cast(value="spinError")
public static int spinImageStatisticsGetAll(spinImageStatistics hStatistics,
                                                                      @Cast(value="spinStatisticsChannel")
                                                                      int channel,
                                                                      @Cast(value="unsigned int*")
                                                                      IntBuffer pRangeMin,
                                                                      @Cast(value="unsigned int*")
                                                                      IntBuffer pRangeMax,
                                                                      @Cast(value="unsigned int*")
                                                                      IntBuffer pPixelValueMin,
                                                                      @Cast(value="unsigned int*")
                                                                      IntBuffer pPixelValueMax,
                                                                      @Cast(value="unsigned int*")
                                                                      IntBuffer pNumPixelValues,
                                                                      FloatBuffer pPixelValueMean,
                                                                      @ByPtrPtr
                                                                      IntBuffer ppHistogram)

spinImageStatisticsGetAll

public static Spinnaker_C.spinError spinImageStatisticsGetAll(spinImageStatistics hStatistics,
                                                              Spinnaker_C.spinStatisticsChannel channel,
                                                              @Cast(value="unsigned int*")
                                                              int[] pRangeMin,
                                                              @Cast(value="unsigned int*")
                                                              int[] pRangeMax,
                                                              @Cast(value="unsigned int*")
                                                              int[] pPixelValueMin,
                                                              @Cast(value="unsigned int*")
                                                              int[] pPixelValueMax,
                                                              @Cast(value="unsigned int*")
                                                              int[] pNumPixelValues,
                                                              float[] pPixelValueMean,
                                                              @ByPtrPtr
                                                              int[] ppHistogram)

spinImageStatisticsGetAll

@Cast(value="spinError")
public static int spinImageStatisticsGetAll(spinImageStatistics hStatistics,
                                                                      @Cast(value="spinStatisticsChannel")
                                                                      int channel,
                                                                      @Cast(value="unsigned int*")
                                                                      IntPointer pRangeMin,
                                                                      @Cast(value="unsigned int*")
                                                                      IntPointer pRangeMax,
                                                                      @Cast(value="unsigned int*")
                                                                      IntPointer pPixelValueMin,
                                                                      @Cast(value="unsigned int*")
                                                                      IntPointer pPixelValueMax,
                                                                      @Cast(value="unsigned int*")
                                                                      IntPointer pNumPixelValues,
                                                                      FloatPointer pPixelValueMean,
                                                                      @ByPtrPtr
                                                                      IntPointer ppHistogram)

spinImageStatisticsGetAll

public static Spinnaker_C.spinError spinImageStatisticsGetAll(spinImageStatistics hStatistics,
                                                              Spinnaker_C.spinStatisticsChannel channel,
                                                              @Cast(value="unsigned int*")
                                                              IntBuffer pRangeMin,
                                                              @Cast(value="unsigned int*")
                                                              IntBuffer pRangeMax,
                                                              @Cast(value="unsigned int*")
                                                              IntBuffer pPixelValueMin,
                                                              @Cast(value="unsigned int*")
                                                              IntBuffer pPixelValueMax,
                                                              @Cast(value="unsigned int*")
                                                              IntBuffer pNumPixelValues,
                                                              FloatBuffer pPixelValueMean,
                                                              @ByPtrPtr
                                                              IntBuffer ppHistogram)

spinImageStatisticsGetAll

@Cast(value="spinError")
public static int spinImageStatisticsGetAll(spinImageStatistics hStatistics,
                                                                      @Cast(value="spinStatisticsChannel")
                                                                      int channel,
                                                                      @Cast(value="unsigned int*")
                                                                      int[] pRangeMin,
                                                                      @Cast(value="unsigned int*")
                                                                      int[] pRangeMax,
                                                                      @Cast(value="unsigned int*")
                                                                      int[] pPixelValueMin,
                                                                      @Cast(value="unsigned int*")
                                                                      int[] pPixelValueMax,
                                                                      @Cast(value="unsigned int*")
                                                                      int[] pNumPixelValues,
                                                                      float[] pPixelValueMean,
                                                                      @ByPtrPtr
                                                                      int[] ppHistogram)

spinLogDataGetCategoryName

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

Retrieves the category name of a log event

Parameters:: hLogEventData - The log event data received from the log event; pBuf - The c-string character buffer in which the category name of the log event 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

spinLogDataGetCategoryName

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

spinLogDataGetCategoryName

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

spinLogDataGetPriority

public static Spinnaker_C.spinError spinLogDataGetPriority(spinLogEventData hLogEventData,
                                                           @Cast(value="int64_t*")
                                                           LongPointer pValue)

Retrieves the priority of a log event

Parameters:: hLogEventData - The log event data received from the log event; pValue - The integer pointer in which the priority value is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinLogDataGetPriority

@Cast(value="spinError")
public static int spinLogDataGetPriority(spinLogEventData hLogEventData,
                                                                   @Cast(value="int64_t*")
                                                                   LongBuffer pValue)

spinLogDataGetPriority

public static Spinnaker_C.spinError spinLogDataGetPriority(spinLogEventData hLogEventData,
                                                           @Cast(value="int64_t*")
                                                           long[] pValue)

spinLogDataGetPriorityName

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

Retrieves the priority name of a log event

Parameters:: hLogEventData - The log event data received from the log event; pBuf - The c-string character buffer in which the priority name of the log event 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

spinLogDataGetPriorityName

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

spinLogDataGetPriorityName

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

spinLogDataGetTimestamp

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

Retrieves the timestamp of a log event

Parameters:: hLogEventData - The log event data received from the log event; pBuf - The c-string character buffer in which the timestamp of the log event 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

spinLogDataGetTimestamp

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

spinLogDataGetTimestamp

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

spinLogDataGetNDC

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

Retrieves the NDC of a log event

Parameters:: hLogEventData - The log event data received from the log event; pBuf - The c-string character buffer in which the NDC of the log event 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

spinLogDataGetNDC

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

spinLogDataGetNDC

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

spinLogDataGetThreadName

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

Retrieves the thread name of a log event

Parameters:: hLogEventData - The log event data received from the log event; pBuf - The c-string character buffer in which the thread name of the log event 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

spinLogDataGetThreadName

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

spinLogDataGetThreadName

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

spinLogDataGetLogMessage

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

Retrieves the log message of a log event

Parameters:: hLogEventData - The log event data received from the log event; pBuf - The c-string character buffer in which the log message of the log event 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

spinLogDataGetLogMessage

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

spinLogDataGetLogMessage

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

spinDeviceEventGetId

public static Spinnaker_C.spinError spinDeviceEventGetId(spinDeviceEventData hDeviceEventData,
                                                         @Cast(value="uint64_t*")
                                                         LongPointer pEventId)

Retrieves the event ID of a device event

Parameters:: hDeviceEventData - The log event data received from the log event; pEventId - The unsigned integer pointer in which the event ID is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinDeviceEventGetId

@Cast(value="spinError")
public static int spinDeviceEventGetId(spinDeviceEventData hDeviceEventData,
                                                                 @Cast(value="uint64_t*")
                                                                 LongBuffer pEventId)

spinDeviceEventGetId

public static Spinnaker_C.spinError spinDeviceEventGetId(spinDeviceEventData hDeviceEventData,
                                                         @Cast(value="uint64_t*")
                                                         long[] pEventId)

spinDeviceEventGetPayloadData

public static Spinnaker_C.spinError spinDeviceEventGetPayloadData(spinDeviceEventData hDeviceEventData,
                                                                  @Cast(value="const uint8_t*")
                                                                  BytePointer pBuf,
                                                                  @Cast(value="size_t*")
                                                                  SizeTPointer pBufSize)

Retrieves the payload data of a device event

Parameters:: hDeviceEventData - The log event data received from the log event; pBuf - The unsigned integer pointer in which the event payload is returned; pBufSize - The unsigned integer pointer in which the size of the payload is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinDeviceEventGetPayloadData

@Cast(value="spinError")
public static int spinDeviceEventGetPayloadData(spinDeviceEventData hDeviceEventData,
                                                                          @Cast(value="const uint8_t*")
                                                                          ByteBuffer pBuf,
                                                                          @Cast(value="size_t*")
                                                                          SizeTPointer pBufSize)

spinDeviceEventGetPayloadData

public static Spinnaker_C.spinError spinDeviceEventGetPayloadData(spinDeviceEventData hDeviceEventData,
                                                                  @Cast(value="const uint8_t*")
                                                                  byte[] pBuf,
                                                                  @Cast(value="size_t*")
                                                                  SizeTPointer pBufSize)

spinDeviceEventGetPayloadDataSize

public static Spinnaker_C.spinError spinDeviceEventGetPayloadDataSize(spinDeviceEventData hDeviceEventData,
                                                                      @Cast(value="size_t*")
                                                                      SizeTPointer pBufSize)

Retrieves the payload data size of a device event

Parameters:: hDeviceEventData - The log event data received from the log event; pBufSize - The unsigned integer pointer in which the size of the payload is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: Spinnaker_C.spinError

spinDeviceEventGetName

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

Retrieves the event name of a device event

Parameters:: hDeviceEventData - The log event data received from the log event; pBuf - The c-string character buffer in which the name of the device event 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

spinDeviceEventGetName

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

spinDeviceEventGetName

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

spinImageChunkDataGetIntValue

public static Spinnaker_C.spinError spinImageChunkDataGetIntValue(spinImage hImage,
                                                                  @Cast(value="const char*")
                                                                  BytePointer pName,
                                                                  @Cast(value="int64_t*")
                                                                  LongPointer pValue)

\defgroup CChunkData Chunk data access \brief The functions in this section provide access to chunk data stored on images.

spinImageChunkDataGetIntValue

@Cast(value="spinError")
public static int spinImageChunkDataGetIntValue(spinImage hImage,
                                                                          String pName,
                                                                          @Cast(value="int64_t*")
                                                                          LongBuffer pValue)

spinImageChunkDataGetIntValue

public static Spinnaker_C.spinError spinImageChunkDataGetIntValue(spinImage hImage,
                                                                  @Cast(value="const char*")
                                                                  BytePointer pName,
                                                                  @Cast(value="int64_t*")
                                                                  long[] pValue)

spinImageChunkDataGetIntValue

@Cast(value="spinError")
public static int spinImageChunkDataGetIntValue(spinImage hImage,
                                                                          String pName,
                                                                          @Cast(value="int64_t*")
                                                                          LongPointer pValue)

spinImageChunkDataGetIntValue

public static Spinnaker_C.spinError spinImageChunkDataGetIntValue(spinImage hImage,
                                                                  @Cast(value="const char*")
                                                                  BytePointer pName,
                                                                  @Cast(value="int64_t*")
                                                                  LongBuffer pValue)

spinImageChunkDataGetIntValue

@Cast(value="spinError")
public static int spinImageChunkDataGetIntValue(spinImage hImage,
                                                                          String pName,
                                                                          @Cast(value="int64_t*")
                                                                          long[] pValue)

spinImageChunkDataGetFloatValue

public static Spinnaker_C.spinError spinImageChunkDataGetFloatValue(spinImage hImage,
                                                                    @Cast(value="const char*")
                                                                    BytePointer pName,
                                                                    DoublePointer pValue)

spinImageChunkDataGetFloatValue

@Cast(value="spinError")
public static int spinImageChunkDataGetFloatValue(spinImage hImage,
                                                                            String pName,
                                                                            DoubleBuffer pValue)

spinImageChunkDataGetFloatValue

public static Spinnaker_C.spinError spinImageChunkDataGetFloatValue(spinImage hImage,
                                                                    @Cast(value="const char*")
                                                                    BytePointer pName,
                                                                    double[] pValue)

spinImageChunkDataGetFloatValue

@Cast(value="spinError")
public static int spinImageChunkDataGetFloatValue(spinImage hImage,
                                                                            String pName,
                                                                            DoublePointer pValue)

spinImageChunkDataGetFloatValue

public static Spinnaker_C.spinError spinImageChunkDataGetFloatValue(spinImage hImage,
                                                                    @Cast(value="const char*")
                                                                    BytePointer pName,
                                                                    DoubleBuffer pValue)

spinImageChunkDataGetFloatValue

@Cast(value="spinError")
public static int spinImageChunkDataGetFloatValue(spinImage hImage,
                                                                            String pName,
                                                                            double[] pValue)

spinVideoOpenUncompressed

public static Spinnaker_C.spinError spinVideoOpenUncompressed(@ByPtrPtr
                                                              spinVideo phSpinVideo,
                                                              @Cast(value="const char*")
                                                              BytePointer pName,
                                                              @ByVal
                                                              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.

spinVideoOpenUncompressed

@Cast(value="spinError")
public static int spinVideoOpenUncompressed(@ByPtrPtr
                                                                      spinVideo phSpinVideo,
                                                                      String pName,
                                                                      @ByVal
                                                                      spinAVIOption option)

spinVideoOpenMJPG

public static Spinnaker_C.spinError spinVideoOpenMJPG(@ByPtrPtr
                                                      spinVideo phSpinVideo,
                                                      @Cast(value="const char*")
                                                      BytePointer pName,
                                                      @ByVal
                                                      spinMJPGOption option)

spinVideoOpenMJPG

@Cast(value="spinError")
public static int spinVideoOpenMJPG(@ByPtrPtr
                                                              spinVideo phSpinVideo,
                                                              String pName,
                                                              @ByVal
                                                              spinMJPGOption option)

spinVideoOpenH264

public static Spinnaker_C.spinError spinVideoOpenH264(@ByPtrPtr
                                                      spinVideo phSpinVideo,
                                                      @Cast(value="const char*")
                                                      BytePointer pName,
                                                      @ByVal
                                                      spinH264Option option)

spinVideoOpenH264

@Cast(value="spinError")
public static int spinVideoOpenH264(@ByPtrPtr
                                                              spinVideo phSpinVideo,
                                                              String pName,
                                                              @ByVal
                                                              spinH264Option option)

spinVideoAppend

public static Spinnaker_C.spinError spinVideoAppend(spinVideo hSpinVideo,
                                                    spinImage hImage)

spinVideoSetMaximumFileSize
```
public static Spinnaker_C.spinError spinVideoSetMaximumFileSize(spinVideo hSpinVideo,
                                                                @Cast(value="unsigned int")
                                                                int size)
```
Set the maximum file size (in megabytes) of a AVI/MP4 file. A new AVI/MP4 file is created automatically when file size limit is reached. Setting a maximum size of 0 indicates no limit on file size.

Parameters:

hSpinVideo - The spin video recorder to append the image to

size - The maximum video file size in MB.

Returns:

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

spinVideoClose

public static Spinnaker_C.spinError spinVideoClose(spinVideo hSpinVideo)

quickSpinInit

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

quickSpinInitEx

public static Spinnaker_C.spinError quickSpinInitEx(spinCamera hCamera,
                                                    quickSpin pQuickSpin,
                                                    quickSpinTLDevice pQuickSpinTLDevice,
                                                    quickSpinTLStream pQuickSpinTLStream)

quickSpinTLDeviceInit

public static Spinnaker_C.spinError quickSpinTLDeviceInit(spinCamera hCamera,
                                                          quickSpinTLDevice pQuickSpinTLDevice)

quickSpinTLStreamInit

public static Spinnaker_C.spinError quickSpinTLStreamInit(spinCamera hCamera,
                                                          quickSpinTLStream pQuickSpinTLStream)

quickSpinTLInterfaceInit

public static Spinnaker_C.spinError quickSpinTLInterfaceInit(spinInterface hInterface,
                                                             quickSpinTLInterface pQuickSpinTLInterface)

quickSpinTLSystemInit

public static Spinnaker_C.spinError quickSpinTLSystemInit(spinSystem hSystem,
                                                          quickSpinTLSystem pQuickSpinTLSystem)

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