Spinnaker_C (JavaCPP Presets for Spinnaker 1.27.0.48-1.5.3 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._actionCommandStatus` Possible Status Codes Returned from Action Command.
`static class`	`Spinnaker_C._spinAccessMode`
`static class`	`Spinnaker_C._spinAcquisitionModeEnums`
`static class`	`Spinnaker_C._spinAcquisitionStatusSelectorEnums`
`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._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._spinLogLevel` log levels
`static class`	`Spinnaker_C._spinLUTSelectorEnums` \brief The enum definitions for camera nodes.
`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._spinPayloadTypeInfoIDs`
`static class`	`Spinnaker_C._spinPixelColorFilterEnums`
`static class`	`Spinnaker_C._spinPixelFormatEnums`
`static class`	`Spinnaker_C._spinPixelFormatInfoSelectorEnums`
`static class`	`Spinnaker_C._spinPixelFormatNamespaceID` This enum represents the namespace in which the TL specific pixel format resides.
`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._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._spinTLPOEStatusEnums`
`static class`	`Spinnaker_C._spinTLStreamBufferCountModeEnums`
`static class`	`Spinnaker_C._spinTLStreamBufferHandlingModeEnums`
`static class`	`Spinnaker_C._spinTLStreamDefaultBufferCountModeEnums`
`static class`	`Spinnaker_C._spinTLStreamTypeEnums` \brief The enumeration definitions for transport layer nodes.
`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
`static class`	`Spinnaker_C.CompressionMethod` Compression method used in saving TIFF images in the spinTIFFOption struct.

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`	`spinArrivalEventCreate(spinArrivalEvent phArrivalEvent, spinArrivalEventFunction pFunction, Pointer pUserData)` Creates an arrival event
`static Spinnaker_C._spinError`	`spinArrivalEventDestroy(spinArrivalEvent hArrivalEvent)` Destroys an arrival event
`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, int grabTimeout, spinImage phImage)` Retrieves an image from a camera; manually set the timeout in milliseconds
`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, int iAddress, Pointer pBuffer, long iSize)`
`static Spinnaker_C._spinError`	`spinCameraRegisterDeviceEvent(spinCamera hCamera, spinDeviceEvent hDeviceEvent)` Registers a universal device event (every device event type) to a camera
`static Spinnaker_C._spinError`	`spinCameraRegisterDeviceEventEx(spinCamera hCamera, spinDeviceEvent hDeviceEvent, BytePointer pName)` Registers a specific device event (only one device event type) to a camera
`static int`	`spinCameraRegisterDeviceEventEx(spinCamera hCamera, spinDeviceEvent hDeviceEvent, String pName)`
`static Spinnaker_C._spinError`	`spinCameraRegisterImageEvent(spinCamera hCamera, spinImageEvent hImageEvent)` Registers an image event to a camera
`static Spinnaker_C._spinError`	`spinCameraRelease(spinCamera hCamera)` Releases a camera
`static Spinnaker_C._spinError`	`spinCameraUnregisterDeviceEvent(spinCamera hCamera, spinDeviceEvent hDeviceEvent)` Unregisters a device event from a camera
`static Spinnaker_C._spinError`	`spinCameraUnregisterImageEvent(spinCamera hCamera, spinImageEvent hImageEvent)` Unregisters an image event from a camera
`static Spinnaker_C._spinError`	`spinCameraWritePort(spinCamera hCamera, int iAddress, Pointer pBuffer, long iSize)`
`static Spinnaker_C._spinError`	`spinCategoryGetFeatureByIndex(spinNodeHandle hNode, long index, spinNodeHandle phFeature)` Retrieves a node from a category node using an index
`static Spinnaker_C._spinError`	`spinCategoryGetNumFeatures(spinNodeHandle hNode, SizeTPointer pValue)` Retrieves the number of a features (or child nodes) or a 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`	`spinDeviceEventCreate(spinDeviceEvent phDeviceEvent, spinDeviceEventFunction pFunction, Pointer pUserData)` Creates a device event
`static Spinnaker_C._spinError`	`spinDeviceEventDestroy(spinDeviceEvent hDeviceEvent)` Destroys a device event
`static Spinnaker_C._spinError`	`spinDeviceEventGetId(spinDeviceEventData hDeviceEventData, int[] pEventId)`
`static int`	`spinDeviceEventGetId(spinDeviceEventData hDeviceEventData, IntBuffer pEventId)`
`static Spinnaker_C._spinError`	`spinDeviceEventGetId(spinDeviceEventData hDeviceEventData, IntPointer 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`	`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 hNode, spinNodeHandle phEntry)` Retrieves the currently selected entry node from an enum node
`static Spinnaker_C._spinError`	`spinEnumerationGetEntryByIndex(spinNodeHandle hNode, long index, spinNodeHandle phEntry)` Retrieves an entry node from an enum node using an index
`static Spinnaker_C._spinError`	`spinEnumerationGetEntryByName(spinNodeHandle hNode, BytePointer pName, spinNodeHandle phEntry)` Retrieves an entry node from an enum node using the entry's symbolic
`static int`	`spinEnumerationGetEntryByName(spinNodeHandle hNode, String pName, spinNodeHandle phEntry)`
`static Spinnaker_C._spinError`	`spinEnumerationGetNumEntries(spinNodeHandle hNode, SizeTPointer pValue)` Retrieves the number of entries of an enum node
`static Spinnaker_C._spinError`	`spinEnumerationSetEnumValue(spinNodeHandle hNode, 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 hNode, 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`	`spinImageConvert(spinImage hSrcImage, int pixelFormat, spinImage hDestImage)` Converts the pixel format of one image into a new image
`static Spinnaker_C._spinError`	`spinImageConvertEx(spinImage hSrcImage, int pixelFormat, int algorithm, spinImage hDestImage)` Converts the pixel format and color processing algorithm of one image into a new image
`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 Spinnaker_C._spinError`	`spinImageCreateEx(spinImage phImage, long width, long height, long offsetX, long offsetY, int pixelFormat, Pointer pData)` 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`	`spinImageEventCreate(spinImageEvent phImageEvent, spinImageEventFunction pFunction, Pointer pUserData)` Creates an image event
`static Spinnaker_C._spinError`	`spinImageEventDestroy(spinImageEvent hImageEvent)` Destroys an image event
`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, int[] pId)`
`static int`	`spinImageGetChunkLayoutID(spinImage hImage, IntBuffer pId)`
`static Spinnaker_C._spinError`	`spinImageGetChunkLayoutID(spinImage hImage, IntPointer 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`	`spinImageGetDefaultColorProcessing(int[] pAlgorithm)`
`static int`	`spinImageGetDefaultColorProcessing(IntBuffer pAlgorithm)`
`static Spinnaker_C._spinError`	`spinImageGetDefaultColorProcessing(IntPointer pAlgorithm)` Retrieves the default color processing algorithm
`static Spinnaker_C._spinError`	`spinImageGetFrameID(spinImage hImage, int[] pFrameID)`
`static int`	`spinImageGetFrameID(spinImage hImage, IntBuffer pFrameID)`
`static Spinnaker_C._spinError`	`spinImageGetFrameID(spinImage hImage, IntPointer 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, int[] pId)`
`static int`	`spinImageGetID(spinImage hImage, IntBuffer pId)`
`static Spinnaker_C._spinError`	`spinImageGetID(spinImage hImage, IntPointer 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 Spinnaker_C._spinError`	`spinImageGetStatusDescription(int status, byte[] pBuf, SizeTPointer pBufLen)`
`static int`	`spinImageGetStatusDescription(int status, ByteBuffer pBuf, SizeTPointer pBufLen)`
`static Spinnaker_C._spinError`	`spinImageGetStatusDescription(int 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, int[] pTimeStamp)`
`static int`	`spinImageGetTimeStamp(spinImage hImage, IntBuffer pTimeStamp)`
`static Spinnaker_C._spinError`	`spinImageGetTimeStamp(spinImage hImage, IntPointer 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, int[] pPixelFormat)`
`static int`	`spinImageGetTLPixelFormat(spinImage hImage, IntBuffer pPixelFormat)`
`static Spinnaker_C._spinError`	`spinImageGetTLPixelFormat(spinImage hImage, IntPointer 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`	`spinImageRelease(spinImage hImage)` Releases an image
`static Spinnaker_C._spinError`	`spinImageReset(spinImage hImage, long width, long height, long offsetX, long offsetY, int pixelFormat)` Resets an image with some set properties
`static Spinnaker_C._spinError`	`spinImageResetEx(spinImage hImage, long width, long height, long offsetX, long offsetY, int pixelFormat, Pointer pData)` Resets an image with some set properties and image data
`static Spinnaker_C._spinError`	`spinImageSave(spinImage hImage, BytePointer pFilename, int 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`	`spinImageSetDefaultColorProcessing(int algorithm)` Sets the default color processing algorithm of all images (if not otherwise set)
`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 Spinnaker_C._spinError`	`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 Spinnaker_C._spinError`	`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, int 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 Spinnaker_C._spinError`	`spinImageStatisticsGetChannelStatus(spinImageStatistics hStatistics, int channel, byte[] pbEnabled)`
`static int`	`spinImageStatisticsGetChannelStatus(spinImageStatistics hStatistics, int channel, ByteBuffer pbEnabled)`
`static Spinnaker_C._spinError`	`spinImageStatisticsGetChannelStatus(spinImageStatistics hStatistics, int channel, BytePointer pbEnabled)` Checks whether an image statistics context is enabled
`static Spinnaker_C._spinError`	`spinImageStatisticsGetHistogram(spinImageStatistics hStatistics, int channel, int[] ppHistogram)`
`static int`	`spinImageStatisticsGetHistogram(spinImageStatistics hStatistics, int channel, IntBuffer ppHistogram)`
`static Spinnaker_C._spinError`	`spinImageStatisticsGetHistogram(spinImageStatistics hStatistics, int channel, IntPointer ppHistogram)`
`static Spinnaker_C._spinError`	`spinImageStatisticsGetHistogram(spinImageStatistics hStatistics, int channel, PointerPointer ppHistogram)` Retrieves a histogram of an image statistics channel
`static Spinnaker_C._spinError`	`spinImageStatisticsGetMean(spinImageStatistics hStatistics, int channel, float[] pMean)`
`static int`	`spinImageStatisticsGetMean(spinImageStatistics hStatistics, int channel, FloatBuffer pMean)`
`static Spinnaker_C._spinError`	`spinImageStatisticsGetMean(spinImageStatistics hStatistics, int channel, FloatPointer pMean)` Retrieves the mean of pixel values of an image statistics channel
`static Spinnaker_C._spinError`	`spinImageStatisticsGetNumPixelValues(spinImageStatistics hStatistics, int channel, int[] pNumValues)`
`static int`	`spinImageStatisticsGetNumPixelValues(spinImageStatistics hStatistics, int channel, IntBuffer pNumValues)`
`static Spinnaker_C._spinError`	`spinImageStatisticsGetNumPixelValues(spinImageStatistics hStatistics, int channel, IntPointer pNumValues)` Retrieves the number of pixel values of an image statistics channel
`static Spinnaker_C._spinError`	`spinImageStatisticsGetPixelValueRange(spinImageStatistics hStatistics, int channel, int[] pMin, int[] pMax)`
`static int`	`spinImageStatisticsGetPixelValueRange(spinImageStatistics hStatistics, int channel, IntBuffer pMin, IntBuffer pMax)`
`static Spinnaker_C._spinError`	`spinImageStatisticsGetPixelValueRange(spinImageStatistics hStatistics, int channel, IntPointer pMin, IntPointer pMax)` Retrieves the pixel value range of an image statistics channel
`static Spinnaker_C._spinError`	`spinImageStatisticsGetRange(spinImageStatistics hStatistics, int channel, int[] pMin, int[] pMax)`
`static int`	`spinImageStatisticsGetRange(spinImageStatistics hStatistics, int channel, IntBuffer pMin, IntBuffer pMax)`
`static Spinnaker_C._spinError`	`spinImageStatisticsGetRange(spinImageStatistics hStatistics, int channel, IntPointer pMin, IntPointer pMax)` Retrieves the range of an image statistics channel
`static Spinnaker_C._spinError`	`spinImageStatisticsSetChannelStatus(spinImageStatistics hStatistics, int 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`	`spinInterfaceEventCreate(spinInterfaceEvent phInterfaceEvent, spinArrivalEventFunction pArrivalFunction, spinRemovalEventFunction pRemovalFunction, Pointer pUserData)` Creates an interface event (both arrival and removal)
`static Spinnaker_C._spinError`	`spinInterfaceEventDestroy(spinInterfaceEvent hInterfaceEvent)` Destroys an interface event (both arrival and 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`	`spinInterfaceRegisterArrivalEvent(spinInterface hInterface, spinArrivalEvent hArrivalEvent)` Registers an arrival event on an interface (events registered in this way must be unregistered)
`static Spinnaker_C._spinError`	`spinInterfaceRegisterInterfaceEvent(spinInterface hInterface, spinInterfaceEvent hInterfaceEvent)` Registers an interface event (both arrival and removal) on an interface
`static Spinnaker_C._spinError`	`spinInterfaceRegisterRemovalEvent(spinInterface hInterface, spinRemovalEvent hRemovalEvent)` Registers a removal event on an interface (events registered in this way must be unregistered)
`static Spinnaker_C._spinError`	`spinInterfaceRelease(spinInterface hInterface)` Releases an interface
`static Spinnaker_C._spinError`	`spinInterfaceSendActionCommand(spinInterface hInterface, long iDeviceKey, long iGroupKey, long iGroupMask, long iActionTime, SizeTPointer piResultSize, actionCommandResult results)` Broadcast an Action Command to all devices on interface
`static Spinnaker_C._spinError`	`spinInterfaceUnregisterArrivalEvent(spinInterface hInterface, spinArrivalEvent hArrivalEvent)` Unregisters an arrival event from an interface
`static Spinnaker_C._spinError`	`spinInterfaceUnregisterInterfaceEvent(spinInterface hInterface, spinInterfaceEvent hInterfaceEvent)` Unregisters an interface event from an interface
`static Spinnaker_C._spinError`	`spinInterfaceUnregisterRemovalEvent(spinInterface hInterface, spinRemovalEvent hRemovalEvent)` Unregisters a removal event 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`	`spinLogEventCreate(spinLogEvent phLogEvent, spinLogEventFunction pFunction, Pointer pUserData)` Creates a log event
`static Spinnaker_C._spinError`	`spinLogEventDestroy(spinLogEvent hLogEvent)` Destroys a log event
`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 Spinnaker_C._spinError`	`spinNodeGetImposedAccessMode(spinNodeHandle hNode, int imposedAccessMode)` Retrieves the imposed access mode of a node
`static Spinnaker_C._spinError`	`spinNodeGetImposedVisibility(spinNodeHandle hNode, int 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`	`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`	`spinRemovalEventCreate(spinRemovalEvent phRemovalEvent, spinRemovalEventFunction pFunction, Pointer pUserData)` Creates a removal event
`static Spinnaker_C._spinError`	`spinRemovalEventDestroy(spinRemovalEvent hRemovalEvent)` Destroys a removal event
`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`	`spinSystemRegisterArrivalEvent(spinSystem hSystem, spinArrivalEvent hArrivalEvent)` Registers an arrival event to every interface on the system (events registered this way must be unregistered)
`static Spinnaker_C._spinError`	`spinSystemRegisterInterfaceEvent(spinSystem hSystem, spinInterfaceEvent hInterfaceEvent)` Registers an interface event (arrival and removal) to every interface on the system (interface events registered this way must be unregistered)
`static Spinnaker_C._spinError`	`spinSystemRegisterLogEvent(spinSystem hSystem, spinLogEvent hLogEvent)` Registers a logging event to the system (events registered in this way must be unregistered)
`static Spinnaker_C._spinError`	`spinSystemRegisterRemovalEvent(spinSystem hSystem, spinRemovalEvent hRemovalEvent)` Registers a removal event to the system to every interface on the system (events registered 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 Spinnaker_C._spinError`	`spinSystemSendActionCommand(spinSystem hSystem, long iDeviceKey, long iGroupKey, long iGroupMask, long iActionTime, SizeTPointer piResultSize, actionCommandResult results)` Broadcast an Action Command to all devices on system
`static Spinnaker_C._spinError`	`spinSystemSetLoggingLevel(spinSystem hSystem, int logLevel)` Sets the logging level for all logging events on the system
`static Spinnaker_C._spinError`	`spinSystemUnregisterAllLogEvents(spinSystem hSystem)` Unregisters all logging events from the system
`static Spinnaker_C._spinError`	`spinSystemUnregisterArrivalEvent(spinSystem hSystem, spinArrivalEvent hArrivalEvent)` Unregisters an arrival event from the system
`static Spinnaker_C._spinError`	`spinSystemUnregisterInterfaceEvent(spinSystem hSystem, spinInterfaceEvent hInterfaceEvent)` Unregisters an interface event from the system
`static Spinnaker_C._spinError`	`spinSystemUnregisterLogEvent(spinSystem hSystem, spinLogEvent hLogEvent)` Unregisters a selected logging event from the system
`static Spinnaker_C._spinError`	`spinSystemUnregisterRemovalEvent(spinSystem hSystem, spinRemovalEvent hRemovalEvent)` Unregisters a removal event 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:: 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:: 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:: 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:: 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:: 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:: 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:: 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:: 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:: 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:: spinError, 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:: 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:: spinError, 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:: spinError, 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:

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:: spinError, 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:: 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:: 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:: 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:: spinError, 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:: 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:: 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:

spinError

spinNodeGetImposedAccessMode

public static Spinnaker_C._spinError spinNodeGetImposedAccessMode(spinNodeHandle hNode,
                                                                  @Cast(value="spinAccessMode")
                                                                  int 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:: spinError

spinNodeGetImposedVisibility

public static Spinnaker_C._spinError spinNodeGetImposedVisibility(spinNodeHandle hNode,
                                                                  @Cast(value="spinVisibility")
                                                                  int 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:: spinError

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:: 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:: 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:: 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:: 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:: 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:: 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:: 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:: 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:: 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:: 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:: 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:: 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:: 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:

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:

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:: 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:

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:

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:: 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:

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:: 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:

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:

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:

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:: 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 hNode,
                                                                  @Cast(value="size_t*")
                                                                  SizeTPointer pValue)

Retrieves the number of entries of an enum node

Parameters:: hNode - 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:: spinError

spinEnumerationGetEntryByIndex

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

Retrieves an entry node from an enum node using an index

Parameters:: hNode - 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:: spinError

spinEnumerationGetEntryByName

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

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

Parameters:: hNode - 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:: spinError

spinEnumerationGetEntryByName

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

spinEnumerationGetCurrentEntry

public static Spinnaker_C._spinError spinEnumerationGetCurrentEntry(spinNodeHandle hNode,
                                                                    @ByPtrPtr
                                                                    spinNodeHandle phEntry)

Retrieves the currently selected entry node from an enum node

Parameters:: hNode - 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:: spinError

spinEnumerationSetIntValue
```
public static Spinnaker_C._spinError spinEnumerationSetIntValue(spinNodeHandle hNode,
                                                                @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:

hNode - 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(), spinError

spinEnumerationSetEnumValue
```
public static Spinnaker_C._spinError spinEnumerationSetEnumValue(spinNodeHandle hNode,
                                                                 @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:

hNode - 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(), 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(), 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(), 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:: 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:

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:: 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:

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:: 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 hNode,
                                                                @Cast(value="size_t*")
                                                                SizeTPointer pValue)

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

Parameters:: hNode - 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:: spinError

spinCategoryGetFeatureByIndex

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

Retrieves a node from a category node using an index

Parameters:: hNode - 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:: 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:: 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:: 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:: 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:: 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:: 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:

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:

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:: 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:: 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:: 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:: 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:: 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:: 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:

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

spinSystemSetLoggingLevel

public static Spinnaker_C._spinError spinSystemSetLoggingLevel(spinSystem hSystem,
                                                               @Cast(value="spinnakerLogLevel")
                                                               int 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:: spinError

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

spinSystemRegisterLogEvent
```
public static Spinnaker_C._spinError spinSystemRegisterLogEvent(spinSystem hSystem,
                                                                spinLogEvent hLogEvent)
```
Registers a logging event to the system (events registered in this way must be unregistered)

Parameters:

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

hLogEvent - The logging event to register on the system

Returns:

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

See Also:

spinError

spinSystemUnregisterLogEvent
```
public static Spinnaker_C._spinError spinSystemUnregisterLogEvent(spinSystem hSystem,
                                                                  spinLogEvent hLogEvent)
```
Unregisters a selected logging event from the system

Parameters:

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

hLogEvent - The logging event to unregister from the system

Returns:

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

See Also:

spinError

spinSystemUnregisterAllLogEvents
```
public static Spinnaker_C._spinError spinSystemUnregisterAllLogEvents(spinSystem hSystem)
```
Unregisters all logging events from the system

Parameters:

hSystem - The system, from which all logging events are unregistered

Returns:

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

See Also:

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

spinSystemRegisterArrivalEvent
```
public static Spinnaker_C._spinError spinSystemRegisterArrivalEvent(spinSystem hSystem,
                                                                    spinArrivalEvent hArrivalEvent)
```
Registers an arrival event to every interface on the system (events registered this way must be unregistered)

Parameters:

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

hArrivalEvent - The arrival event to register on the system

Returns:

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

See Also:

spinError

spinSystemRegisterRemovalEvent
```
public static Spinnaker_C._spinError spinSystemRegisterRemovalEvent(spinSystem hSystem,
                                                                    spinRemovalEvent hRemovalEvent)
```
Registers a removal event to the system to every interface on the system (events registered this way must be unregistered)

Parameters:

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

hRemovalEvent - The removal event to register on the system

Returns:

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

See Also:

spinError

spinSystemUnregisterArrivalEvent
```
public static Spinnaker_C._spinError spinSystemUnregisterArrivalEvent(spinSystem hSystem,
                                                                      spinArrivalEvent hArrivalEvent)
```
Unregisters an arrival event from the system

Parameters:

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

hArrivalEvent - The arrival event to unregister from the system

Returns:

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

See Also:

spinError

spinSystemUnregisterRemovalEvent
```
public static Spinnaker_C._spinError spinSystemUnregisterRemovalEvent(spinSystem hSystem,
                                                                      spinRemovalEvent hRemovalEvent)
```
Unregisters a removal event from the system

Parameters:

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

hRemovalEvent - The removal event to unregister from the system

Returns:

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

See Also:

spinError

spinSystemRegisterInterfaceEvent
```
public static Spinnaker_C._spinError spinSystemRegisterInterfaceEvent(spinSystem hSystem,
                                                                      spinInterfaceEvent hInterfaceEvent)
```
Registers an interface event (arrival and removal) to every interface on the system (interface events registered this way must be unregistered)

Parameters:

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

hInterfaceEvent - The interface event (arrival and removal) to register on the system

Returns:

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

See Also:

spinError

spinSystemUnregisterInterfaceEvent
```
public static Spinnaker_C._spinError spinSystemUnregisterInterfaceEvent(spinSystem hSystem,
                                                                        spinInterfaceEvent hInterfaceEvent)
```
Unregisters an interface event from the system

Parameters:

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

hInterfaceEvent - The interface event (arrival and removal) to unregister from the system

Returns:

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

See Also:

spinError

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:

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

spinSystemSendActionCommand

public static Spinnaker_C._spinError spinSystemSendActionCommand(spinSystem hSystem,
                                                                 @Cast(value="size_t")
                                                                 long iDeviceKey,
                                                                 @Cast(value="size_t")
                                                                 long iGroupKey,
                                                                 @Cast(value="size_t")
                                                                 long iGroupMask,
                                                                 @Cast(value="size_t")
                                                                 long iActionTime,
                                                                 @Cast(value="size_t*")
                                                                 SizeTPointer piResultSize,
                                                                 actionCommandResult results)

Broadcast an Action Command to all devices on system

Parameters:: hSystem - The system on which to send the action command to all devices.; iDeviceKey - The Action Command's device key; iGroupKey - The Action Command's group key; iGroupMask - The Action Command's group mask; iActionTime - (Optional) Time when to assert a future action. Zero means immediate action.; piResultSize - (Optional) The number of results in the results array. The value passed should be equal to the expected number of devices that acknowledge the command. Returns the number of received results.; results - (Optional) An Array with *piResultSize elements to hold the action command result status. The buffer is filled starting from index 0. If received results are less than expected number of devices that acknowledge the command, remaining results are not changed. If received results are more than expected number of devices that acknowledge the command, extra results are ignored and not appended to array. This parameter is ignored if piResultSize is 0. Thus this parameter can be NULL if pResultSize is 0 or NULL.
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: spinError

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:: 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:

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:

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:: spinError, 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:: 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:

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:

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:

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:: 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:: 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:

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:: 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:

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:: 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 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:: spinError

spinCameraListRemoveBySerial

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

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:: 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(), 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(), 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:: spinError

spinInterfaceRegisterArrivalEvent
```
public static Spinnaker_C._spinError spinInterfaceRegisterArrivalEvent(spinInterface hInterface,
                                                                       spinArrivalEvent hArrivalEvent)
```
Registers an arrival event on an interface (events registered in this way must be unregistered)

Parameters:

hInterface - The interface on which to register the arrival event

hArrivalEvent - The arrival event to register

Returns:

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

See Also:

spinError

spinInterfaceRegisterRemovalEvent
```
public static Spinnaker_C._spinError spinInterfaceRegisterRemovalEvent(spinInterface hInterface,
                                                                       spinRemovalEvent hRemovalEvent)
```
Registers a removal event on an interface (events registered in this way must be unregistered)

Parameters:

hInterface - the Interface on which to register the removal event

hRemovalEvent - The removal event to register

Returns:

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

See Also:

spinError

spinInterfaceUnregisterArrivalEvent
```
public static Spinnaker_C._spinError spinInterfaceUnregisterArrivalEvent(spinInterface hInterface,
                                                                         spinArrivalEvent hArrivalEvent)
```
Unregisters an arrival event from an interface

Parameters:

hInterface - The interface from which to unregister the arrival event

hArrivalEvent - The arrival event to unregister

Returns:

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

See Also:

spinError

spinInterfaceUnregisterRemovalEvent
```
public static Spinnaker_C._spinError spinInterfaceUnregisterRemovalEvent(spinInterface hInterface,
                                                                         spinRemovalEvent hRemovalEvent)
```
Unregisters a removal event from an interface

Parameters:

hInterface - The interface from which to unregister the removal event

hRemovalEvent - The removal event to unregister

Returns:

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

See Also:

spinError

spinInterfaceRegisterInterfaceEvent
```
public static Spinnaker_C._spinError spinInterfaceRegisterInterfaceEvent(spinInterface hInterface,
                                                                         spinInterfaceEvent hInterfaceEvent)
```
Registers an interface event (both arrival and removal) on an interface

Parameters:

hInterface - The interface on which to register the interface event

hInterfaceEvent - The interface event to register

Returns:

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

See Also:

spinError

spinInterfaceUnregisterInterfaceEvent
```
public static Spinnaker_C._spinError spinInterfaceUnregisterInterfaceEvent(spinInterface hInterface,
                                                                           spinInterfaceEvent hInterfaceEvent)
```
Unregisters an interface event from an interface

Parameters:

hInterface - The interface from which to unregister the interface event

hInterfaceEvent - The interface event to unregister

Returns:

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

See Also:

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:

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

spinInterfaceSendActionCommand

public static Spinnaker_C._spinError spinInterfaceSendActionCommand(spinInterface hInterface,
                                                                    @Cast(value="size_t")
                                                                    long iDeviceKey,
                                                                    @Cast(value="size_t")
                                                                    long iGroupKey,
                                                                    @Cast(value="size_t")
                                                                    long iGroupMask,
                                                                    @Cast(value="size_t")
                                                                    long iActionTime,
                                                                    @Cast(value="size_t*")
                                                                    SizeTPointer piResultSize,
                                                                    actionCommandResult results)

Broadcast an Action Command to all devices on interface

Parameters:: iDeviceKey - The Action Command's device key; iGroupKey - The Action Command's group key; iGroupMask - The Action Command's group mask; iActionTime - (Optional) Time when to assert a future action. Zero means immediate action.; piResultSize - (Optional) The number of results in the results array. The value passed should be equal to the expected number of devices that acknowledge the command. Returns the number of received results.; results - (Optional) An Array with *piResultSize elements to hold the action command result status. The buffer is filled starting from index 0. If received results are less than expected number of devices that acknowledge the command, remaining results are not changed. If received results are more than expected number of devices that acknowledge the command, extra results are ignored and not appended to array. This parameter is ignored if piResultSize is 0. Thus this parameter can be NULL if pResultSize is 0 or NULL.
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: spinError

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:

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:

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:: 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:: 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:: 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:: spinError, 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")
                                                        int iAddress,
                                                        Pointer pBuffer,
                                                        @Cast(value="size_t")
                                                        long iSize)

spinCameraWritePort

public static Spinnaker_C._spinError spinCameraWritePort(spinCamera hCamera,
                                                         @Cast(value="uint64_t")
                                                         int 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:

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:

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:: spinError

spinCameraGetNextImageEx

public static Spinnaker_C._spinError spinCameraGetNextImageEx(spinCamera hCamera,
                                                              @Cast(value="uint64_t")
                                                              int 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 - The timeout value for returned an 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:: spinError

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

spinCameraRegisterDeviceEvent
```
public static Spinnaker_C._spinError spinCameraRegisterDeviceEvent(spinCamera hCamera,
                                                                   spinDeviceEvent hDeviceEvent)
```
Registers a universal device event (every device event type) to a camera

Parameters:

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

hDeviceEvent - The device event to register

Returns:

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

See Also:

spinError

spinCameraRegisterDeviceEventEx

public static Spinnaker_C._spinError spinCameraRegisterDeviceEventEx(spinCamera hCamera,
                                                                     spinDeviceEvent hDeviceEvent,
                                                                     @Cast(value="const char*")
                                                                     BytePointer pName)

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

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

spinCameraRegisterDeviceEventEx

@Cast(value="_spinError")
public static int spinCameraRegisterDeviceEventEx(spinCamera hCamera,
                                                                             spinDeviceEvent hDeviceEvent,
                                                                             String pName)

spinCameraUnregisterDeviceEvent
```
public static Spinnaker_C._spinError spinCameraUnregisterDeviceEvent(spinCamera hCamera,
                                                                     spinDeviceEvent hDeviceEvent)
```
Unregisters a device event from a camera

Parameters:

hCamera - The camera from which to unregister the device event

hDeviceEvent - The device event to unregister

Returns:

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

See Also:

spinError

spinCameraRegisterImageEvent
```
public static Spinnaker_C._spinError spinCameraRegisterImageEvent(spinCamera hCamera,
                                                                  spinImageEvent hImageEvent)
```
Registers an image event to a camera

Parameters:

hCamera - The camera on which to register the image event

hImageEvent - The image event to register

Returns:

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

See Also:

spinError

spinCameraUnregisterImageEvent
```
public static Spinnaker_C._spinError spinCameraUnregisterImageEvent(spinCamera hCamera,
                                                                    spinImageEvent hImageEvent)
```
Unregisters an image event from a camera

Parameters:

hCamera - The camera from which to unregister the image event

hImageEvent - The image event to unregister

Returns:

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

See Also:

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:

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:: 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:: 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:: 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:

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:: 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,
                                                       @Cast(value="spinPixelFormatEnums")
                                                       int 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:: spinError

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:

spinError

spinImageSetDefaultColorProcessing
```
public static Spinnaker_C._spinError spinImageSetDefaultColorProcessing(@Cast(value="spinColorProcessingAlgorithm")
                                                                        int algorithm)
```
Sets the default color processing algorithm of all images (if not otherwise set)

Parameters:

algorithm - The color processing algorithm used by default

Returns:

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

See Also:

spinError

spinImageGetDefaultColorProcessing
```
public static Spinnaker_C._spinError spinImageGetDefaultColorProcessing(@Cast(value="spinColorProcessingAlgorithm*")
                                                                        IntPointer pAlgorithm)
```
Retrieves the default color processing algorithm

Parameters:

pAlgorithm - The color processing algorithm enum 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:

spinError

spinImageGetDefaultColorProcessing

@Cast(value="_spinError")
public static int spinImageGetDefaultColorProcessing(@Cast(value="spinColorProcessingAlgorithm*")
                                                                                IntBuffer pAlgorithm)

spinImageGetDefaultColorProcessing

public static Spinnaker_C._spinError spinImageGetDefaultColorProcessing(@Cast(value="spinColorProcessingAlgorithm*")
                                                                        int[] pAlgorithm)

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

spinImageConvert

public static Spinnaker_C._spinError spinImageConvert(spinImage hSrcImage,
                                                      @Cast(value="spinPixelFormatEnums")
                                                      int pixelFormat,
                                                      spinImage hDestImage)

Converts the pixel format of one image into a new image

Parameters:: hSrcImage - The image to be converted; pixelFormat - The pixel format to be converted to; hDestImage - The image handle pointer in which the converted image is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: spinError

spinImageConvertEx

public static Spinnaker_C._spinError spinImageConvertEx(spinImage hSrcImage,
                                                        @Cast(value="spinPixelFormatEnums")
                                                        int pixelFormat,
                                                        @Cast(value="spinColorProcessingAlgorithm")
                                                        int algorithm,
                                                        spinImage hDestImage)

Converts the pixel format and color processing algorithm of one image into a new image

Parameters:: hSrcImage - The image to be converted; pixelFormat - The pixel format to be converted to; algorithm - The color processing algorithm to use for conversion; hDestImage - The image handle pointer in which the converted image is returned
Returns:: spinError The error code; returns SPINNAKER_ERR_SUCCESS (or 0) for no error
See Also:: spinError

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,
                                                    @Cast(value="spinPixelFormatEnums")
                                                    int 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:: spinError

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,
                                                      @Cast(value="spinPixelFormatEnums")
                                                      int 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:: spinError

spinImageGetID

public static Spinnaker_C._spinError spinImageGetID(spinImage hImage,
                                                    @Cast(value="uint64_t*")
                                                    IntPointer 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:: spinError

spinImageGetID

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

spinImageGetID

public static Spinnaker_C._spinError spinImageGetID(spinImage hImage,
                                                    @Cast(value="uint64_t*")
                                                    int[] 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:: 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:: 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:: 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:

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:: 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:: 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:: 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:: 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:: 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:: spinError

spinImageGetFrameID

public static Spinnaker_C._spinError spinImageGetFrameID(spinImage hImage,
                                                         @Cast(value="uint64_t*")
                                                         IntPointer 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:: spinError

spinImageGetFrameID

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

spinImageGetFrameID

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

spinImageGetTimeStamp

public static Spinnaker_C._spinError spinImageGetTimeStamp(spinImage hImage,
                                                           @Cast(value="uint64_t*")
                                                           IntPointer 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:: spinError

spinImageGetTimeStamp

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

spinImageGetTimeStamp

public static Spinnaker_C._spinError spinImageGetTimeStamp(spinImage hImage,
                                                           @Cast(value="uint64_t*")
                                                           int[] 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:: spinError, spinPayloadTypeInfoIds

spinImageGetTLPayloadType

public static Spinnaker_C._spinError spinImageGetTLPayloadType(spinImage hImage,
                                                               @Cast(value="spinPayloadTypeInfoIDs*")
                                                               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:: spinError, spinPayloadTypeInfoIds

spinImageGetTLPayloadType

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

spinImageGetTLPayloadType

public static Spinnaker_C._spinError spinImageGetTLPayloadType(spinImage hImage,
                                                               @Cast(value="spinPayloadTypeInfoIDs*")
                                                               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:: spinError, 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*")
                                                               IntPointer 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:: spinError

spinImageGetTLPixelFormat

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

spinImageGetTLPixelFormat

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

spinImageGetTLPixelFormatNamespace

public static Spinnaker_C._spinError spinImageGetTLPixelFormatNamespace(spinImage hImage,
                                                                        @Cast(value="spinPixelFormatNamespaceID*")
                                                                        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:: spinError, spinPixelFormatNamespaceID

spinImageGetTLPixelFormatNamespace

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

spinImageGetTLPixelFormatNamespace

public static Spinnaker_C._spinError spinImageGetTLPixelFormatNamespace(spinImage hImage,
                                                                        @Cast(value="spinPixelFormatNamespaceID*")
                                                                        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:: 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:: 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:: spinError

spinImageSave

public static Spinnaker_C._spinError spinImageSave(spinImage hImage,
                                                   @Cast(value="const char*")
                                                   BytePointer pFilename,
                                                   @Cast(value="spinImageFileFormat")
                                                   int 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:: spinError, 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:: 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:: 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:: 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:: 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:: 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:: 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:: 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:: 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*")
                                                               IntPointer 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:: spinError

spinImageGetChunkLayoutID

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

spinImageGetChunkLayoutID

public static Spinnaker_C._spinError spinImageGetChunkLayoutID(spinImage hImage,
                                                               @Cast(value="uint64_t*")
                                                               int[] 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:

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:: 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(@Cast(value="spinImageStatus")
                                                                   int 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:: 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(@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:

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:: 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:: 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:: 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:: 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:: spinError

spinDeviceEventCreate

public static Spinnaker_C._spinError spinDeviceEventCreate(@ByPtrPtr
                                                           spinDeviceEvent phDeviceEvent,
                                                           spinDeviceEventFunction pFunction,
                                                           Pointer pUserData)

Creates a device event

Parameters:: phDeviceEvent - The device event handle 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:: spinError

spinDeviceEventDestroy
```
public static Spinnaker_C._spinError spinDeviceEventDestroy(spinDeviceEvent hDeviceEvent)
```
Destroys a device event

Parameters:

hDeviceEvent - The device event to destroy

Returns:

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

See Also:

spinError

spinImageEventCreate

public static Spinnaker_C._spinError spinImageEventCreate(@ByPtrPtr
                                                          spinImageEvent phImageEvent,
                                                          spinImageEventFunction pFunction,
                                                          Pointer pUserData)

Creates an image event

Parameters:: phImageEvent - The image event handle 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:: spinError

spinImageEventDestroy
```
public static Spinnaker_C._spinError spinImageEventDestroy(spinImageEvent hImageEvent)
```
Destroys an image event

Parameters:

hImageEvent - The image event to destroy

Returns:

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

See Also:

spinError

spinArrivalEventCreate

public static Spinnaker_C._spinError spinArrivalEventCreate(@ByPtrPtr
                                                            spinArrivalEvent phArrivalEvent,
                                                            spinArrivalEventFunction pFunction,
                                                            Pointer pUserData)

Creates an arrival event

Parameters:: phArrivalEvent - The arrival event handle pointer in which the 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:: spinError

spinArrivalEventDestroy
```
public static Spinnaker_C._spinError spinArrivalEventDestroy(spinArrivalEvent hArrivalEvent)
```
Destroys an arrival event

Parameters:

hArrivalEvent - The arrival event to destroy

Returns:

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

See Also:

spinError

spinRemovalEventCreate

public static Spinnaker_C._spinError spinRemovalEventCreate(@ByPtrPtr
                                                            spinRemovalEvent phRemovalEvent,
                                                            spinRemovalEventFunction pFunction,
                                                            Pointer pUserData)

Creates a removal event

Parameters:: phRemovalEvent - The removal event handle pointer in which the 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:: spinError

spinRemovalEventDestroy
```
public static Spinnaker_C._spinError spinRemovalEventDestroy(spinRemovalEvent hRemovalEvent)
```
Destroys a removal event

Parameters:

hRemovalEvent - The removal event to destroy

Returns:

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

See Also:

spinError

spinInterfaceEventCreate

public static Spinnaker_C._spinError spinInterfaceEventCreate(@ByPtrPtr
                                                              spinInterfaceEvent phInterfaceEvent,
                                                              spinArrivalEventFunction pArrivalFunction,
                                                              spinRemovalEventFunction pRemovalFunction,
                                                              Pointer pUserData)

Creates an interface event (both arrival and removal)

Parameters:: phInterfaceEvent - The interface event handle 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:: spinError

spinInterfaceEventDestroy
```
public static Spinnaker_C._spinError spinInterfaceEventDestroy(spinInterfaceEvent hInterfaceEvent)
```
Destroys an interface event (both arrival and removal)

Parameters:

hInterfaceEvent - The interface event to destroy

Returns:

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

See Also:

spinError

spinLogEventCreate

public static Spinnaker_C._spinError spinLogEventCreate(@ByPtrPtr
                                                        spinLogEvent phLogEvent,
                                                        spinLogEventFunction pFunction,
                                                        Pointer pUserData)

Creates a log event

Parameters:: phLogEvent - The log event handle 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:: spinError

spinLogEventDestroy
```
public static Spinnaker_C._spinError spinLogEventDestroy(spinLogEvent hLogEvent)
```
Destroys a log event

Parameters:

hLogEvent - The log event to destroy

Returns:

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

See Also:

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:

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:

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:

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:

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:

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:

spinError

spinImageStatisticsGetChannelStatus

public static Spinnaker_C._spinError spinImageStatisticsGetChannelStatus(spinImageStatistics hStatistics,
                                                                         @Cast(value="spinStatisticsChannel")
                                                                         int 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:: 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,
                                                                         @Cast(value="spinStatisticsChannel")
                                                                         int channel,
                                                                         @Cast(value="bool8_t*")
                                                                         byte[] pbEnabled)

spinImageStatisticsSetChannelStatus

public static Spinnaker_C._spinError spinImageStatisticsSetChannelStatus(spinImageStatistics hStatistics,
                                                                         @Cast(value="spinStatisticsChannel")
                                                                         int 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:: spinError

spinImageStatisticsGetRange

public static Spinnaker_C._spinError spinImageStatisticsGetRange(spinImageStatistics hStatistics,
                                                                 @Cast(value="spinStatisticsChannel")
                                                                 int 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:: 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,
                                                                 @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,
                                                                           @Cast(value="spinStatisticsChannel")
                                                                           int 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:: 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,
                                                                           @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,
                                                                          @Cast(value="spinStatisticsChannel")
                                                                          int 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:: 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,
                                                                          @Cast(value="spinStatisticsChannel")
                                                                          int channel,
                                                                          @Cast(value="unsigned int*")
                                                                          int[] pNumValues)

spinImageStatisticsGetMean

public static Spinnaker_C._spinError spinImageStatisticsGetMean(spinImageStatistics hStatistics,
                                                                @Cast(value="spinStatisticsChannel")
                                                                int 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:: 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,
                                                                @Cast(value="spinStatisticsChannel")
                                                                int channel,
                                                                float[] pMean)

spinImageStatisticsGetHistogram

public static Spinnaker_C._spinError spinImageStatisticsGetHistogram(spinImageStatistics hStatistics,
                                                                     @Cast(value="spinStatisticsChannel")
                                                                     int 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:: spinError

spinImageStatisticsGetHistogram

public static Spinnaker_C._spinError spinImageStatisticsGetHistogram(spinImageStatistics hStatistics,
                                                                     @Cast(value="spinStatisticsChannel")
                                                                     int 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,
                                                                     @Cast(value="spinStatisticsChannel")
                                                                     int channel,
                                                                     @ByPtrPtr
                                                                     int[] ppHistogram)

spinImageStatisticsGetAll

public static Spinnaker_C._spinError 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,
                                                               @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:: spinError

spinImageStatisticsGetAll

public static Spinnaker_C._spinError 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

@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,
                                                               @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:: 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:: 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:: 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:: 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:: 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:: 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:: 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*")
                                                          IntPointer 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:: spinError

spinDeviceEventGetId

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

spinDeviceEventGetId

public static Spinnaker_C._spinError spinDeviceEventGetId(spinDeviceEventData hDeviceEventData,
                                                          @Cast(value="uint64_t*")
                                                          int[] 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:: 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:: 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:: 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

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

spinNodeGetImposedVisibility

spinNodeToString

spinNodeToString

spinNodeToString

spinNodeToStringEx

spinNodeToStringEx

spinNodeToStringEx

spinNodeFromString

spinNodeFromString

spinNodeFromStringEx

spinNodeFromStringEx