1908 lines
52 KiB
C++
1908 lines
52 KiB
C++
//=============================================================================
|
||
// Copyright ?2017 FLIR Integrated Imaging Solutions, Inc. All Rights Reserved.
|
||
//
|
||
// This software is the confidential and proprietary information of FLIR
|
||
// Integrated Imaging Solutions, Inc. ("Confidential Information"). You
|
||
// shall not disclose such Confidential Information and shall use it only in
|
||
// accordance with the terms of the license agreement you entered into
|
||
// with FLIR Integrated Imaging Solutions, Inc. (FLIR).
|
||
//
|
||
// FLIR MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
|
||
// SOFTWARE, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
|
||
// IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
|
||
// PURPOSE, OR NON-INFRINGEMENT. FLIR SHALL NOT BE LIABLE FOR ANY DAMAGES
|
||
// SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
|
||
// THIS SOFTWARE OR ITS DERIVATIVES.
|
||
//=============================================================================
|
||
|
||
//=============================================================================
|
||
// $Id: FlyCapture2Defs.h 318533 2017-03-09 22:41:16Z corinal $
|
||
//=============================================================================
|
||
|
||
#ifndef PGR_FC2_FLYCAPTURE2DEFS_H
|
||
#define PGR_FC2_FLYCAPTURE2DEFS_H
|
||
|
||
#include <memory.h>
|
||
|
||
//=============================================================================
|
||
// Definitions file for FlyCapture2.
|
||
//
|
||
// Holds structures, enumerations and other global definitions that are used
|
||
// across the entire FlyCapture2 API.
|
||
//=============================================================================
|
||
|
||
#ifndef NULL
|
||
#define NULL 0
|
||
#endif
|
||
|
||
#ifndef FULL_32BIT_VALUE
|
||
#define FULL_32BIT_VALUE 0x7FFFFFFF
|
||
#endif
|
||
|
||
|
||
namespace FlyCapture2
|
||
{
|
||
/**
|
||
* @defgroup GlobalConstants Global constants
|
||
*/
|
||
|
||
/*@{*/
|
||
|
||
/** The maximum length that is allocated for a string. */
|
||
static const unsigned int sk_maxStringLength = 512;
|
||
|
||
/** The maximum number of ports one device can have. */
|
||
static const unsigned int sk_maxNumPorts = 32;
|
||
|
||
/*@}*/
|
||
|
||
/**
|
||
* @defgroup Enumerations Enumerations
|
||
*/
|
||
|
||
/*@{*/
|
||
|
||
/** The error types returned by functions. */
|
||
enum ErrorType
|
||
{
|
||
PGRERROR_UNDEFINED = -1, /**< Undefined */
|
||
PGRERROR_OK, /**< Function returned with no errors. */
|
||
PGRERROR_FAILED, /**< General failure. */
|
||
PGRERROR_NOT_IMPLEMENTED, /**< Function has not been implemented. */
|
||
PGRERROR_FAILED_BUS_MASTER_CONNECTION, /**< Could not connect to Bus Master. */
|
||
PGRERROR_NOT_CONNECTED, /**< Camera has not been connected. */
|
||
PGRERROR_INIT_FAILED, /**< Initialization failed. */
|
||
PGRERROR_NOT_INTITIALIZED, /**< Camera has not been initialized. */
|
||
PGRERROR_INVALID_PARAMETER, /**< Invalid parameter passed to function. */
|
||
PGRERROR_INVALID_SETTINGS, /**< Setting set to camera is invalid. */
|
||
PGRERROR_INVALID_BUS_MANAGER, /**< Invalid Bus Manager object. */
|
||
PGRERROR_MEMORY_ALLOCATION_FAILED, /**< Could not allocate memory. */
|
||
PGRERROR_LOW_LEVEL_FAILURE, /**< Low level error. */
|
||
PGRERROR_NOT_FOUND, /**< Device not found. */
|
||
PGRERROR_FAILED_GUID, /**< GUID failure. */
|
||
PGRERROR_INVALID_PACKET_SIZE, /**< Packet size set to camera is invalid. */
|
||
PGRERROR_INVALID_MODE, /**< Invalid mode has been passed to function. */
|
||
PGRERROR_NOT_IN_FORMAT7, /**< Error due to not being in Format7. */
|
||
PGRERROR_NOT_SUPPORTED, /**< This feature is unsupported. */
|
||
PGRERROR_TIMEOUT, /**< Timeout error. */
|
||
PGRERROR_BUS_MASTER_FAILED, /**< Bus Master Failure. */
|
||
PGRERROR_INVALID_GENERATION, /**< Generation Count Mismatch. */
|
||
PGRERROR_LUT_FAILED, /**< Look Up Table failure. */
|
||
PGRERROR_IIDC_FAILED, /**< IIDC failure. */
|
||
PGRERROR_STROBE_FAILED, /**< Strobe failure. */
|
||
PGRERROR_TRIGGER_FAILED, /**< Trigger failure. */
|
||
PGRERROR_PROPERTY_FAILED, /**< Property failure. */
|
||
PGRERROR_PROPERTY_NOT_PRESENT, /**< Property is not present. */
|
||
PGRERROR_REGISTER_FAILED, /**< Register access failed. */
|
||
PGRERROR_READ_REGISTER_FAILED, /**< Register read failed. */
|
||
PGRERROR_WRITE_REGISTER_FAILED, /**< Register write failed. */
|
||
PGRERROR_ISOCH_FAILED, /**< Isochronous failure. */
|
||
PGRERROR_ISOCH_ALREADY_STARTED, /**< Isochronous transfer has already been started. */
|
||
PGRERROR_ISOCH_NOT_STARTED, /**< Isochronous transfer has not been started. */
|
||
PGRERROR_ISOCH_START_FAILED, /**< Isochronous start failed. */
|
||
PGRERROR_ISOCH_RETRIEVE_BUFFER_FAILED, /**< Isochronous retrieve buffer failed. */
|
||
PGRERROR_ISOCH_STOP_FAILED, /**< Isochronous stop failed. */
|
||
PGRERROR_ISOCH_SYNC_FAILED, /**< Isochronous image synchronization failed. */
|
||
PGRERROR_ISOCH_BANDWIDTH_EXCEEDED, /**< Isochronous bandwidth exceeded. */
|
||
PGRERROR_IMAGE_CONVERSION_FAILED, /**< Image conversion failed. */
|
||
PGRERROR_IMAGE_LIBRARY_FAILURE, /**< Image library failure. */
|
||
PGRERROR_BUFFER_TOO_SMALL, /**< Buffer is too small. */
|
||
PGRERROR_IMAGE_CONSISTENCY_ERROR, /**< There is an image consistency error. */
|
||
PGRERROR_INCOMPATIBLE_DRIVER, /**< The installed driver is not compatible with the library. */
|
||
PGRERROR_FORCE_32BITS = FULL_32BIT_VALUE
|
||
};
|
||
|
||
/** The type of bus callback to register a callback function for. */
|
||
enum BusCallbackType
|
||
{
|
||
BUS_RESET, /**< Register for all bus events. */
|
||
ARRIVAL, /**< Register for arrivals only. */
|
||
REMOVAL, /**< Register for removals only. */
|
||
CALLBACK_TYPE_FORCE_32BITS = FULL_32BIT_VALUE
|
||
};
|
||
|
||
/**
|
||
* The grab strategy employed during image transfer. This type controls
|
||
* how images that stream off the camera accumulate in a user buffer
|
||
* for handling.
|
||
*/
|
||
/*
|
||
@remark Unlike earlier versions of the FlyCapture SDK, it is no longer
|
||
* necessary to explicitly start the image grabbing process before
|
||
* specifying an image grabbing mode.
|
||
*/
|
||
enum GrabMode
|
||
{
|
||
/**
|
||
* Grabs the newest image in the user buffer each time the
|
||
* RetrieveBuffer() function is called. Older images are dropped
|
||
* instead of accumulating in the user buffer. Grabbing blocks if the
|
||
* camera has not finished transmitting the next available image. If
|
||
* the camera is transmitting images faster than the application can
|
||
* grab them, images may be dropped and only the most recent image
|
||
* is stored for grabbing. Note that this mode is the equivalent of
|
||
* flycaptureLockLatest in earlier versions of the FlyCapture SDK.
|
||
*/
|
||
DROP_FRAMES,
|
||
|
||
/**
|
||
* Images accumulate in the user buffer, and the oldest image is
|
||
* grabbed for handling before being discarded. This member can be
|
||
* used to guarantee that each image is seen. However, image processing
|
||
* time must not exceed transmission time from the camera to the
|
||
* buffer. Grabbing blocks if the camera has not finished transmitting
|
||
* the next available image. The buffer size is controlled by the
|
||
* numBuffers parameter in the FC2Config struct. Note that this mode is
|
||
* the equivalent of flycaptureLockNext in earlier versions of the
|
||
* FlyCapture SDK.
|
||
*/
|
||
BUFFER_FRAMES,
|
||
|
||
/**
|
||
* Unspecified grab mode.
|
||
*/
|
||
UNSPECIFIED_GRAB_MODE,
|
||
GRAB_MODE_FORCE_32BITS = FULL_32BIT_VALUE
|
||
};
|
||
|
||
/** Timeout options for grabbing images. */
|
||
enum GrabTimeout
|
||
{
|
||
TIMEOUT_NONE = 0, /**< Non-blocking wait. */
|
||
TIMEOUT_INFINITE = -1, /**< Wait indefinitely. */
|
||
TIMEOUT_UNSPECIFIED = -2, /**< Unspecified timeout setting. */
|
||
GRAB_TIMEOUT_FORCE_32BITS = FULL_32BIT_VALUE
|
||
};
|
||
|
||
/** Bandwidth allocation options for 1394 devices. */
|
||
enum BandwidthAllocation
|
||
{
|
||
/** Do not allocate bandwidth. */
|
||
BANDWIDTH_ALLOCATION_OFF = 0,
|
||
/** Allocate bandwidth. This is the default setting. */
|
||
BANDWIDTH_ALLOCATION_ON = 1,
|
||
/**
|
||
* Bandwidth allocation is not supported by either the camera or
|
||
* operating system.
|
||
*/
|
||
BANDWIDTH_ALLOCATION_UNSUPPORTED = 2,
|
||
/** Not specified. This leaves the current setting unchanged. */
|
||
BANDWIDTH_ALLOCATION_UNSPECIFIED = 3,
|
||
BANDWIDTH_ALLOCATION_FORCE_32BITS = FULL_32BIT_VALUE
|
||
|
||
};
|
||
|
||
/** Interfaces that a camera may use to communicate with a host. */
|
||
enum InterfaceType
|
||
{
|
||
INTERFACE_IEEE1394, /**< IEEE-1394 (Includes 1394a and 1394b). */
|
||
INTERFACE_USB2, /**< USB 2.0. */
|
||
INTERFACE_USB3, /**< USB 3.0. */
|
||
INTERFACE_GIGE, /**< GigE. */
|
||
INTERFACE_UNKNOWN, /**< Unknown interface. */
|
||
INTERFACE_TYPE_FORCE_32BITS = FULL_32BIT_VALUE
|
||
|
||
};
|
||
|
||
/**
|
||
* Camera properties. Not all properties may be supported, depending
|
||
* on the camera model.
|
||
*/
|
||
enum PropertyType
|
||
{
|
||
BRIGHTNESS, /**< Brightness. */
|
||
AUTO_EXPOSURE, /**< Auto exposure. */
|
||
SHARPNESS, /**< Sharpness */
|
||
WHITE_BALANCE, /**< White balance. */
|
||
HUE, /**< Hue. */
|
||
SATURATION, /**< Saturation. */
|
||
GAMMA, /**< Gamma. */
|
||
IRIS, /**< Iris. */
|
||
FOCUS, /**< Focus. */
|
||
ZOOM, /**< Zoom. */
|
||
PAN, /**< Pan. */
|
||
TILT, /**< Tilt. */
|
||
SHUTTER, /**< Shutter. */
|
||
GAIN, /**< Gain. */
|
||
TRIGGER_MODE, /**< Trigger mode. */
|
||
TRIGGER_DELAY, /**< Trigger delay. */
|
||
FRAME_RATE, /**< Frame rate. */
|
||
TEMPERATURE, /**< Temperature. */
|
||
UNSPECIFIED_PROPERTY_TYPE, /**< Unspecified property type. */
|
||
PROPERTY_TYPE_FORCE_32BITS = FULL_32BIT_VALUE
|
||
|
||
};
|
||
|
||
/** Frame rates in frames per second. */
|
||
enum FrameRate
|
||
{
|
||
FRAMERATE_1_875, /**< 1.875 fps. */
|
||
FRAMERATE_3_75, /**< 3.75 fps. */
|
||
FRAMERATE_7_5, /**< 7.5 fps. */
|
||
FRAMERATE_15, /**< 15 fps. */
|
||
FRAMERATE_30, /**< 30 fps. */
|
||
FRAMERATE_60, /**< 60 fps. */
|
||
FRAMERATE_120, /**< 120 fps. */
|
||
FRAMERATE_240, /**< 240 fps. */
|
||
FRAMERATE_FORMAT7, /**< Custom frame rate for Format7 functionality. */
|
||
NUM_FRAMERATES, /**< Number of possible camera frame rates. */
|
||
FRAMERATE_FORCE_32BITS = FULL_32BIT_VALUE
|
||
|
||
};
|
||
|
||
/** DCAM video modes. */
|
||
enum VideoMode
|
||
{
|
||
VIDEOMODE_160x120YUV444, /**< 160x120 YUV444. */
|
||
VIDEOMODE_320x240YUV422, /**< 320x240 YUV422. */
|
||
VIDEOMODE_640x480YUV411, /**< 640x480 YUV411. */
|
||
VIDEOMODE_640x480YUV422, /**< 640x480 YUV422. */
|
||
VIDEOMODE_640x480RGB, /**< 640x480 24-bit RGB. */
|
||
VIDEOMODE_640x480Y8, /**< 640x480 8-bit. */
|
||
VIDEOMODE_640x480Y16, /**< 640x480 16-bit. */
|
||
VIDEOMODE_800x600YUV422, /**< 800x600 YUV422. */
|
||
VIDEOMODE_800x600RGB, /**< 800x600 RGB. */
|
||
VIDEOMODE_800x600Y8, /**< 800x600 8-bit. */
|
||
VIDEOMODE_800x600Y16, /**< 800x600 16-bit. */
|
||
VIDEOMODE_1024x768YUV422, /**< 1024x768 YUV422. */
|
||
VIDEOMODE_1024x768RGB, /**< 1024x768 RGB. */
|
||
VIDEOMODE_1024x768Y8, /**< 1024x768 8-bit. */
|
||
VIDEOMODE_1024x768Y16, /**< 1024x768 16-bit. */
|
||
VIDEOMODE_1280x960YUV422, /**< 1280x960 YUV422. */
|
||
VIDEOMODE_1280x960RGB, /**< 1280x960 RGB. */
|
||
VIDEOMODE_1280x960Y8, /**< 1280x960 8-bit. */
|
||
VIDEOMODE_1280x960Y16, /**< 1280x960 16-bit. */
|
||
VIDEOMODE_1600x1200YUV422, /**< 1600x1200 YUV422. */
|
||
VIDEOMODE_1600x1200RGB, /**< 1600x1200 RGB. */
|
||
VIDEOMODE_1600x1200Y8, /**< 1600x1200 8-bit. */
|
||
VIDEOMODE_1600x1200Y16, /**< 1600x1200 16-bit. */
|
||
VIDEOMODE_FORMAT7, /**< Custom video mode for Format7 functionality. */
|
||
NUM_VIDEOMODES, /**< Number of possible video modes. */
|
||
VIDEOMODE_FORCE_32BITS = FULL_32BIT_VALUE
|
||
};
|
||
|
||
/** Camera modes for DCAM formats as well as Format7. */
|
||
enum Mode
|
||
{
|
||
MODE_0 = 0,
|
||
MODE_1,
|
||
MODE_2,
|
||
MODE_3,
|
||
MODE_4,
|
||
MODE_5,
|
||
MODE_6,
|
||
MODE_7,
|
||
MODE_8,
|
||
MODE_9,
|
||
MODE_10,
|
||
MODE_11,
|
||
MODE_12,
|
||
MODE_13,
|
||
MODE_14,
|
||
MODE_15,
|
||
MODE_16,
|
||
MODE_17,
|
||
MODE_18,
|
||
MODE_19,
|
||
MODE_20,
|
||
MODE_21,
|
||
MODE_22,
|
||
MODE_23,
|
||
MODE_24,
|
||
MODE_25,
|
||
MODE_26,
|
||
MODE_27,
|
||
MODE_28,
|
||
MODE_29,
|
||
MODE_30,
|
||
MODE_31,
|
||
NUM_MODES, /**< Number of modes */
|
||
MODE_FORCE_32BITS = FULL_32BIT_VALUE
|
||
};
|
||
|
||
/** Pixel formats available for Format7 modes. */
|
||
enum PixelFormat
|
||
{
|
||
PIXEL_FORMAT_MONO8 = 0x80000000, /**< 8 bits of mono information. */
|
||
PIXEL_FORMAT_411YUV8 = 0x40000000, /**< YUV 4:1:1. */
|
||
PIXEL_FORMAT_422YUV8 = 0x20000000, /**< YUV 4:2:2. */
|
||
PIXEL_FORMAT_444YUV8 = 0x10000000, /**< YUV 4:4:4. */
|
||
PIXEL_FORMAT_RGB8 = 0x08000000, /**< R = G = B = 8 bits. */
|
||
PIXEL_FORMAT_MONO16 = 0x04000000, /**< 16 bits of mono information. */
|
||
PIXEL_FORMAT_RGB16 = 0x02000000, /**< R = G = B = 16 bits. */
|
||
PIXEL_FORMAT_S_MONO16 = 0x01000000, /**< 16 bits of signed mono information. */
|
||
PIXEL_FORMAT_S_RGB16 = 0x00800000, /**< R = G = B = 16 bits signed. */
|
||
PIXEL_FORMAT_RAW8 = 0x00400000, /**< 8 bit raw data output of sensor. */
|
||
PIXEL_FORMAT_RAW16 = 0x00200000, /**< 16 bit raw data output of sensor. */
|
||
PIXEL_FORMAT_MONO12 = 0x00100000, /**< 12 bits of mono information. */
|
||
PIXEL_FORMAT_RAW12 = 0x00080000, /**< 12 bit raw data output of sensor. */
|
||
PIXEL_FORMAT_BGR = 0x80000008, /**< 24 bit BGR. */
|
||
PIXEL_FORMAT_BGRU = 0x40000008, /**< 32 bit BGRU. */
|
||
PIXEL_FORMAT_RGB = PIXEL_FORMAT_RGB8, /**< 24 bit RGB. */
|
||
PIXEL_FORMAT_RGBU = 0x40000002, /**< 32 bit RGBU. */
|
||
PIXEL_FORMAT_BGR16 = 0x02000001, /**< R = G = B = 16 bits. */
|
||
PIXEL_FORMAT_BGRU16 = 0x02000002, /**< 64 bit BGRU. */
|
||
PIXEL_FORMAT_422YUV8_JPEG = 0x40000001, /**< JPEG compressed stream. */
|
||
NUM_PIXEL_FORMATS = 20, /**< Number of pixel formats. */
|
||
UNSPECIFIED_PIXEL_FORMAT = 0 /**< Unspecified pixel format. */
|
||
};
|
||
|
||
/** Bus speeds. */
|
||
enum BusSpeed
|
||
{
|
||
BUSSPEED_S100, /**< 100Mbits/sec. */
|
||
BUSSPEED_S200, /**< 200Mbits/sec. */
|
||
BUSSPEED_S400, /**< 400Mbits/sec. */
|
||
BUSSPEED_S480, /**< 480Mbits/sec. Only for USB2 cameras. */
|
||
BUSSPEED_S800, /**< 800Mbits/sec. */
|
||
BUSSPEED_S1600, /**< 1600Mbits/sec. */
|
||
BUSSPEED_S3200, /**< 3200Mbits/sec. */
|
||
BUSSPEED_S5000, /**< 5000Mbits/sec. Only for USB3 cameras. */
|
||
BUSSPEED_10BASE_T, /**< 10Base-T. Only for GigE Vision cameras. */
|
||
BUSSPEED_100BASE_T, /**< 100Base-T. Only for GigE Vision cameras.*/
|
||
BUSSPEED_1000BASE_T, /**< 1000Base-T (Gigabit Ethernet). Only for GigE Vision cameras. */
|
||
BUSSPEED_10000BASE_T, /**< 10000Base-T. Only for GigE Vision cameras. */
|
||
BUSSPEED_S_FASTEST, /**< The fastest speed available. */
|
||
BUSSPEED_ANY, /**< Any speed that is available. */
|
||
BUSSPEED_SPEED_UNKNOWN = -1, /**< Unknown bus speed. */
|
||
BUSSPEED_FORCE_32BITS = FULL_32BIT_VALUE
|
||
};
|
||
|
||
enum PCIeBusSpeed
|
||
{
|
||
PCIE_BUSSPEED_2_5, /** 2.5 Gb/s */
|
||
PCIE_BUSSPEED_5_0, /** 5.0 Gb/s */
|
||
PCIE_BUSSPEED_UNKNOWN = -1, /** Speed is unknown */
|
||
PCIE_BUSSPEED_FORCE_32BITS = FULL_32BIT_VALUE
|
||
};
|
||
|
||
/** Types of low level drivers that flycapture uses. */
|
||
enum DriverType
|
||
{
|
||
DRIVER_1394_CAM, /**< PGRCam.sys. */
|
||
DRIVER_1394_PRO, /**< PGR1394.sys. */
|
||
DRIVER_1394_JUJU, /**< firewire_core. */
|
||
DRIVER_1394_VIDEO1394, /**< video1394. */
|
||
DRIVER_1394_RAW1394, /**< raw1394. */
|
||
DRIVER_USB_NONE, /**< No usb driver used just BSD stack. (Linux only) */
|
||
DRIVER_USB_CAM, /**< PGRUsbCam.sys. */
|
||
DRIVER_USB3_PRO, /**< PGRXHCI.sys. */
|
||
DRIVER_GIGE_NONE, /**< no gige drivers used,MS/BSD stack. */
|
||
DRIVER_GIGE_FILTER, /**< PGRGigE.sys. */
|
||
DRIVER_GIGE_PRO, /**< PGRGigEPro.sys. */
|
||
DRIVER_GIGE_LWF, /**< PgrLwf.sys. */
|
||
DRIVER_UNKNOWN = -1, /**< Unknown driver type. */
|
||
DRIVER_FORCE_32BITS = FULL_32BIT_VALUE
|
||
};
|
||
|
||
/**
|
||
* Color processing algorithms. Please refer to our knowledge base at
|
||
* article at http://www.ptgrey.com/support/kb/index.asp?a=4&q=33 for
|
||
* complete details for each algorithm.
|
||
*/
|
||
enum ColorProcessingAlgorithm
|
||
{
|
||
/** Default method. */
|
||
DEFAULT,
|
||
/** No color processing. */
|
||
NO_COLOR_PROCESSING,
|
||
/**
|
||
* Fastest but lowest quality. Equivalent to
|
||
* FLYCAPTURE_NEAREST_NEIGHBOR_FAST in FlyCapture.
|
||
*/
|
||
NEAREST_NEIGHBOR,
|
||
/** Weights surrounding pixels based on localized edge orientation. */
|
||
EDGE_SENSING,
|
||
/** Well-balanced speed and quality. */
|
||
HQ_LINEAR,
|
||
/** Slowest but produces good results. */
|
||
RIGOROUS,
|
||
/** Multithreaded with similar results to edge sensing. */
|
||
IPP,
|
||
/** Best quality but much faster than rigorous. */
|
||
DIRECTIONAL_FILTER,
|
||
/** Weighted pixel average from different directions*/
|
||
WEIGHTED_DIRECTIONAL_FILTER,
|
||
|
||
COLOR_PROCESSING_ALGORITHM_FORCE_32BITS = FULL_32BIT_VALUE
|
||
};
|
||
|
||
/** Bayer tile formats. */
|
||
enum BayerTileFormat
|
||
{
|
||
NONE, /**< No bayer tile format. */
|
||
RGGB, /**< Red-Green-Green-Blue. */
|
||
GRBG, /**< Green-Red-Blue-Green. */
|
||
GBRG, /**< Green-Blue-Red-Green. */
|
||
BGGR, /**< Blue-Green-Green-Red. */
|
||
BT_FORCE_32BITS = FULL_32BIT_VALUE
|
||
};
|
||
|
||
/** File formats to be used for saving images to disk. */
|
||
enum ImageFileFormat
|
||
{
|
||
FROM_FILE_EXT = -1, /**< Determine file format from file extension. */
|
||
PGM, /**< Portable gray map. */
|
||
PPM, /**< Portable pixmap. */
|
||
BMP, /**< Bitmap. */
|
||
JPEG, /**< JPEG. */
|
||
JPEG2000, /**< JPEG 2000. */
|
||
TIFF, /**< Tagged image file format. */
|
||
PNG, /**< Portable network graphics. */
|
||
RAW, /**< Raw data. */
|
||
IMAGE_FILE_FORMAT_FORCE_32BITS = FULL_32BIT_VALUE
|
||
};
|
||
|
||
/*@}*/
|
||
|
||
/**
|
||
* @defgroup GigEEnums GigE specific enumerations
|
||
*
|
||
* These enumerations are specific to GigE camera operation only.
|
||
*/
|
||
|
||
/*@{*/
|
||
|
||
/** Possible properties that can be queried from the camera. */
|
||
enum GigEPropertyType
|
||
{
|
||
HEARTBEAT,
|
||
HEARTBEAT_TIMEOUT,
|
||
PACKET_SIZE,
|
||
PACKET_DELAY
|
||
};
|
||
|
||
/*@}*/
|
||
|
||
/**
|
||
* @defgroup Structures Structures
|
||
*/
|
||
|
||
/*@{*/
|
||
|
||
/** The current version of the library. */
|
||
struct FC2Version
|
||
{
|
||
unsigned int major; /**< Major version number. */
|
||
unsigned int minor; /**< Minor version number. */
|
||
unsigned int type; /**< Type version number. */
|
||
unsigned int build; /**< Build version number. */
|
||
};
|
||
|
||
/** A GUID to the camera. It is used to uniquely identify a camera. */
|
||
class PGRGuid
|
||
{
|
||
public:
|
||
unsigned int value[4];
|
||
|
||
/** Constructor. */
|
||
PGRGuid() { memset( value, 0x0, 4 * sizeof(unsigned int) ); }
|
||
|
||
/** Equality operator. */
|
||
bool operator==( const PGRGuid& guid ) const
|
||
{
|
||
if ( this->value[0] == guid.value[0] &&
|
||
this->value[1] == guid.value[1] &&
|
||
this->value[2] == guid.value[2] &&
|
||
this->value[3] == guid.value[3] )
|
||
{
|
||
return true;
|
||
}
|
||
else
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
|
||
/** Inequality operator. */
|
||
bool operator!=( const PGRGuid& guid )
|
||
{
|
||
return !(operator==( guid ));
|
||
}
|
||
};
|
||
|
||
/**
|
||
* @defgroup GigEStructures GigE specific structures
|
||
*
|
||
* These structures are specific to GigE camera operation only.
|
||
*/
|
||
|
||
/*@{*/
|
||
|
||
/** IPv4 address. */
|
||
struct IPAddress
|
||
{
|
||
unsigned char octets[4];
|
||
|
||
IPAddress() { memset(octets, 0x0, 4 * sizeof(unsigned char) ); }
|
||
|
||
IPAddress( unsigned int ipAddressVal )
|
||
{
|
||
this->octets[0] = (unsigned char)(ipAddressVal >> 24) & 0xFF;
|
||
this->octets[1] = (unsigned char)(ipAddressVal >> 16) & 0xFF;
|
||
this->octets[2] = (unsigned char)(ipAddressVal >> 8) & 0xFF;
|
||
this->octets[3] = (unsigned char)(ipAddressVal >> 0) & 0xFF;
|
||
}
|
||
|
||
/** Equality operator. */
|
||
bool operator==( const IPAddress& address ) const
|
||
{
|
||
if ( this->octets[0] == address.octets[0] &&
|
||
this->octets[1] == address.octets[1] &&
|
||
this->octets[2] == address.octets[2] &&
|
||
this->octets[3] == address.octets[3] )
|
||
{
|
||
return true;
|
||
}
|
||
else
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
|
||
/** Inequality operator. */
|
||
bool operator!=( const IPAddress& address )
|
||
{
|
||
return !(operator==( address ));
|
||
}
|
||
};
|
||
|
||
/** MAC address. */
|
||
struct MACAddress
|
||
{
|
||
unsigned char octets[6];
|
||
|
||
MACAddress() { memset(octets, 0x0, 6 * sizeof(unsigned char) ); }
|
||
|
||
MACAddress( unsigned int macAddressValHigh, unsigned int macAddressValLow )
|
||
{
|
||
this->octets[0] = (unsigned char)(macAddressValHigh >> 8) & 0xFF;
|
||
this->octets[1] = (unsigned char)(macAddressValHigh >> 0) & 0xFF;
|
||
this->octets[2] = (unsigned char)(macAddressValLow >> 24) & 0xFF;
|
||
this->octets[3] = (unsigned char)(macAddressValLow >> 16) & 0xFF;
|
||
this->octets[4] = (unsigned char)(macAddressValLow >> 8) & 0xFF;
|
||
this->octets[5] = (unsigned char)(macAddressValLow >> 0) & 0xFF;
|
||
}
|
||
|
||
/** Equality operator. */
|
||
bool operator==( const MACAddress& address ) const
|
||
{
|
||
if ( this->octets[0] == address.octets[0] &&
|
||
this->octets[1] == address.octets[1] &&
|
||
this->octets[2] == address.octets[2] &&
|
||
this->octets[3] == address.octets[3] &&
|
||
this->octets[4] == address.octets[4] &&
|
||
this->octets[5] == address.octets[5] )
|
||
{
|
||
return true;
|
||
}
|
||
else
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
|
||
/** Inequality operator. */
|
||
bool operator!=( const MACAddress& address )
|
||
{
|
||
return !(operator==( address ));
|
||
}
|
||
};
|
||
|
||
/** A GigE property. */
|
||
struct GigEProperty
|
||
{
|
||
/** The type of property. */
|
||
GigEPropertyType propType;
|
||
/**
|
||
* Whether the property is readable. If this is false, then
|
||
* no other value in this structure is valid.
|
||
*/
|
||
bool isReadable;
|
||
/** Whether the property is writable. */
|
||
bool isWritable;
|
||
/** Minimum value. */
|
||
unsigned int min;
|
||
/** Maximum value. */
|
||
unsigned int max;
|
||
/** Current value. */
|
||
unsigned int value;
|
||
};
|
||
|
||
/** Information about a single GigE stream channel. */
|
||
struct GigEStreamChannel
|
||
{
|
||
/** Network interface index used (or to use). */
|
||
unsigned int networkInterfaceIndex;
|
||
/** Host port on the PC where the camera will send the data stream. */
|
||
unsigned int hostPort;
|
||
/** Disable IP fragmentation of packets. */
|
||
bool doNotFragment;
|
||
/** Packet size, in bytes. */
|
||
unsigned int packetSize;
|
||
/** Inter packet delay, in timestamp counter units. */
|
||
unsigned int interPacketDelay;
|
||
/** Destination IP address. It can be a multicast or unicast address. */
|
||
IPAddress destinationIpAddress;
|
||
/** Source UDP port of the stream channel. Read only. */
|
||
unsigned int sourcePort;
|
||
|
||
GigEStreamChannel()
|
||
{
|
||
networkInterfaceIndex = 0;
|
||
hostPort = 0;
|
||
doNotFragment = false;
|
||
packetSize = 0;
|
||
interPacketDelay = 0;
|
||
sourcePort = 0;
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Configuration for a GigE camera. These options are options that are
|
||
* generally should be set before starting isochronous transfer.
|
||
*/
|
||
struct GigEConfig
|
||
{
|
||
/** Turn on/off packet resend functionality */
|
||
bool enablePacketResend;
|
||
|
||
/**
|
||
* Number of retries to perform when a register read/write timeout
|
||
* is received by the library. The default value is 0.
|
||
*/
|
||
unsigned int registerTimeoutRetries;
|
||
|
||
/**
|
||
* Register read/write timeout value, in microseconds.
|
||
* The default value is dependent on the interface type.
|
||
*/
|
||
unsigned int registerTimeout;
|
||
|
||
GigEConfig()
|
||
{
|
||
enablePacketResend = false;
|
||
registerTimeoutRetries = 3;
|
||
registerTimeout = 20000;
|
||
}
|
||
};
|
||
|
||
/** Format 7 information for a single mode. */
|
||
struct GigEImageSettingsInfo
|
||
{
|
||
/** Maximum image width. */
|
||
unsigned int maxWidth;
|
||
/** Maximum image height. */
|
||
unsigned int maxHeight;
|
||
/** Horizontal step size for the offset. */
|
||
unsigned int offsetHStepSize;
|
||
/** Vertical step size for the offset. */
|
||
unsigned int offsetVStepSize;
|
||
/** Horizontal step size for the image. */
|
||
unsigned int imageHStepSize;
|
||
/** Vertical step size for the image. */
|
||
unsigned int imageVStepSize;
|
||
/** Supported pixel formats in a bit field. */
|
||
unsigned int pixelFormatBitField;
|
||
/** Vendor unique pixel formats in a bit field. */
|
||
unsigned int vendorPixelFormatBitField;
|
||
/** Reserved for future use. */
|
||
unsigned int reserved[16];
|
||
|
||
GigEImageSettingsInfo()
|
||
{
|
||
maxWidth = 0;
|
||
maxHeight = 0;
|
||
offsetHStepSize = 0;
|
||
offsetVStepSize = 0;
|
||
imageHStepSize = 0;
|
||
imageVStepSize = 0;
|
||
pixelFormatBitField = 0;
|
||
vendorPixelFormatBitField = 0;
|
||
memset( reserved, 0, sizeof(reserved) );
|
||
}
|
||
};
|
||
|
||
/** Image settings for a GigE camera. */
|
||
struct GigEImageSettings
|
||
{
|
||
/** Horizontal image offset. */
|
||
unsigned int offsetX;
|
||
/** Vertical image offset. */
|
||
unsigned int offsetY;
|
||
/** Width of image. */
|
||
unsigned int width;
|
||
/** Height of image. */
|
||
unsigned int height;
|
||
/** Pixel format of image. */
|
||
PixelFormat pixelFormat;
|
||
/** Reserved for future use. */
|
||
unsigned int reserved[8];
|
||
|
||
GigEImageSettings()
|
||
{
|
||
offsetX = 0;
|
||
offsetY = 0;
|
||
width = 0;
|
||
height = 0;
|
||
pixelFormat = UNSPECIFIED_PIXEL_FORMAT;
|
||
memset( reserved, 0, sizeof(reserved) );
|
||
}
|
||
};
|
||
|
||
/*@}*/
|
||
|
||
/**
|
||
* @defgroup IIDCStructures IIDC specific structures
|
||
*
|
||
* These structures are specific to IIDC camera operation only.
|
||
*/
|
||
|
||
/*@{*/
|
||
|
||
/** Format 7 image settings. */
|
||
struct Format7ImageSettings
|
||
{
|
||
/** Format 7 mode. */
|
||
Mode mode;
|
||
/** Horizontal image offset. */
|
||
unsigned int offsetX;
|
||
/** Vertical image offset. */
|
||
unsigned int offsetY;
|
||
/** Width of image. */
|
||
unsigned int width;
|
||
/** Height of image. */
|
||
unsigned int height;
|
||
/** Pixel format of image. */
|
||
PixelFormat pixelFormat;
|
||
/** Reserved for future use. */
|
||
unsigned int reserved[8];
|
||
|
||
Format7ImageSettings()
|
||
{
|
||
mode = MODE_0;
|
||
offsetX = 0;
|
||
offsetY = 0;
|
||
width = 0;
|
||
height = 0;
|
||
pixelFormat = UNSPECIFIED_PIXEL_FORMAT;
|
||
memset( reserved, 0, sizeof(reserved) );
|
||
}
|
||
};
|
||
|
||
/** Format 7 information for a single mode. */
|
||
struct Format7Info
|
||
{
|
||
/** Format 7 mode. */
|
||
Mode mode;
|
||
|
||
/** Maximum image width. */
|
||
unsigned int maxWidth;
|
||
/** Maximum image height. */
|
||
unsigned int maxHeight;
|
||
/** Horizontal step size for the offset. */
|
||
unsigned int offsetHStepSize;
|
||
/** Vertical step size for the offset. */
|
||
unsigned int offsetVStepSize;
|
||
/** Horizontal step size for the image. */
|
||
unsigned int imageHStepSize;
|
||
/** Vertical step size for the image. */
|
||
unsigned int imageVStepSize;
|
||
/** Supported pixel formats in a bit field. */
|
||
unsigned int pixelFormatBitField;
|
||
/** Vendor unique pixel formats in a bit field. */
|
||
unsigned int vendorPixelFormatBitField;
|
||
|
||
/** Current packet size in bytes. */
|
||
unsigned int packetSize;
|
||
/** Minimum packet size in bytes for current mode. */
|
||
unsigned int minPacketSize;
|
||
/** Maximum packet size in bytes for current mode. */
|
||
unsigned int maxPacketSize;
|
||
/** Current packet size as a percentage of maximum packet size. */
|
||
float percentage;
|
||
/** Reserved for future use. */
|
||
unsigned int reserved[16];
|
||
|
||
Format7Info()
|
||
{
|
||
mode = MODE_0;
|
||
maxWidth = 0;
|
||
maxHeight = 0;
|
||
offsetHStepSize = 0;
|
||
offsetVStepSize = 0;
|
||
imageHStepSize = 0;
|
||
imageVStepSize = 0;
|
||
pixelFormatBitField = 0;
|
||
vendorPixelFormatBitField = 0;
|
||
packetSize = 0;
|
||
minPacketSize = 0;
|
||
maxPacketSize = 0;
|
||
percentage = 0.0f;
|
||
memset( reserved, 0, sizeof(reserved) );
|
||
}
|
||
};
|
||
|
||
/** Format 7 packet information. */
|
||
struct Format7PacketInfo
|
||
{
|
||
/** Recommended bytes per packet. */
|
||
unsigned int recommendedBytesPerPacket;
|
||
/** Maximum bytes per packet. */
|
||
unsigned int maxBytesPerPacket;
|
||
/** Minimum bytes per packet. */
|
||
unsigned int unitBytesPerPacket;
|
||
/** Reserved for future use. */
|
||
unsigned int reserved[8];
|
||
|
||
Format7PacketInfo()
|
||
{
|
||
recommendedBytesPerPacket = 0;
|
||
maxBytesPerPacket = 0;
|
||
unitBytesPerPacket = 0;
|
||
memset( reserved, 0, sizeof(reserved) );
|
||
}
|
||
};
|
||
|
||
/*@}*/
|
||
|
||
/**
|
||
* Configuration for a camera. These options are options that are
|
||
* generally should be set before starting isochronous transfer.
|
||
*/
|
||
struct FC2Config
|
||
{
|
||
/** Number of buffers used by the FlyCapture2 library to grab images. */
|
||
unsigned int numBuffers;
|
||
|
||
/**
|
||
* Number of notifications per image. This value should only be set
|
||
* after the image settings to be used is set to the camera.
|
||
* The default number of notifications is 1.
|
||
*
|
||
* There are 4 general scenarios:
|
||
* - 1 notification - End of image
|
||
* - 2 notifications - After first packet and end of image
|
||
* - 3 notifications - After first packet, middle of image, end of image
|
||
* - x notifications - After first packet, (x -2) spread evenly, end of image
|
||
*
|
||
* Specifying zero for the number of notifications will be ignored (the current value
|
||
* will not be modified).
|
||
*
|
||
* Note that the event numbers start at 0. Ex. when 3 notifications are
|
||
* used, the three events will be 0, 1 and 2.
|
||
*/
|
||
unsigned int numImageNotifications;
|
||
|
||
/**
|
||
* Minimum number of notifications needed for the current image
|
||
* settings on the camera. Read-only value.
|
||
*/
|
||
unsigned int minNumImageNotifications;
|
||
|
||
/**
|
||
* Time in milliseconds that RetrieveBuffer() and WaitForBufferEvent()
|
||
* will wait for an image before timing out and returning.
|
||
*/
|
||
int grabTimeout;
|
||
|
||
/** Grab mode for the camera. The default is DROP_FRAMES. */
|
||
GrabMode grabMode;
|
||
|
||
/** This parameter enables RetrieveBuffer to run in high
|
||
* performance mode. This means that any interaction
|
||
* with the camera, other then grabbing the image is disabled.
|
||
* Currently Retrieve buffer reads registers on the camera to
|
||
* determine which embedded image information settings have been
|
||
* enabled, and it reads what the bayer tile is currently set to.
|
||
* When High Performance mode is on, these reads are disabled. This
|
||
* means that any changes to the Bayer Tile or to the Embedded image
|
||
* info after StartCapture() will not be tracked when made using
|
||
* direct register writes. If the corresponding SetEmbededImageInfo()
|
||
* and GetEmbededImageInfo() calls are used then the changes will be
|
||
* appropriately reflected. This also means that changes to embedded
|
||
* image info from other processes will not be updated either.*/
|
||
bool highPerformanceRetrieveBuffer;
|
||
|
||
/** Isochronous bus speed. */
|
||
BusSpeed isochBusSpeed;
|
||
|
||
/** Asynchronous bus speed. */
|
||
BusSpeed asyncBusSpeed;
|
||
|
||
/**
|
||
* Bandwidth allocation flag that tells the camera the bandwidth
|
||
* allocation strategy to employ.
|
||
*/
|
||
BandwidthAllocation bandwidthAllocation;
|
||
|
||
/**
|
||
* Number of retries to perform when a register read/write timeout
|
||
* is received by the library. The default value is 0.
|
||
*/
|
||
unsigned int registerTimeoutRetries;
|
||
|
||
/**
|
||
* Register read/write timeout value, in microseconds.
|
||
* The default value is dependent on the interface type.
|
||
*/
|
||
unsigned int registerTimeout;
|
||
|
||
/** Reserved for future use */
|
||
unsigned int reserved[16];
|
||
|
||
FC2Config()
|
||
{
|
||
numBuffers = 0;
|
||
numImageNotifications = 0;
|
||
minNumImageNotifications = 0;
|
||
grabTimeout = TIMEOUT_UNSPECIFIED;
|
||
grabMode = UNSPECIFIED_GRAB_MODE;
|
||
isochBusSpeed = BUSSPEED_ANY;
|
||
asyncBusSpeed = BUSSPEED_ANY;
|
||
bandwidthAllocation = BANDWIDTH_ALLOCATION_UNSPECIFIED;
|
||
registerTimeoutRetries = 0;
|
||
registerTimeout = 0;
|
||
highPerformanceRetrieveBuffer = false;
|
||
memset( reserved, 0, sizeof(reserved) );
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Information about a specific camera property. This structure is also
|
||
* also used as the TriggerDelayInfo structure.
|
||
*/
|
||
struct PropertyInfo
|
||
{
|
||
/** Property info type. */
|
||
PropertyType type;
|
||
/** Flag indicating if the property is present. */
|
||
bool present;
|
||
/** Flag indicating if auto is supported. */
|
||
bool autoSupported;
|
||
/** Flag indicating if manual is supported. */
|
||
bool manualSupported;
|
||
/** Flag indicating if on/off is supported. */
|
||
bool onOffSupported;
|
||
/** Flag indicating if one push is supported. */
|
||
bool onePushSupported;
|
||
/** Flag indicating if absolute mode is supported. */
|
||
bool absValSupported;
|
||
/** Flag indicating if property value can be read out. */
|
||
bool readOutSupported;
|
||
/** Minimum value (as an integer). */
|
||
unsigned int min;
|
||
/** Maximum value (as an integer). */
|
||
unsigned int max;
|
||
/** Minimum value (as a floating point value). */
|
||
float absMin;
|
||
/** Maximum value (as a floating point value). */
|
||
float absMax;
|
||
/** Textual description of units. */
|
||
char pUnits[sk_maxStringLength];
|
||
/** Abbreviated textual description of units. */
|
||
char pUnitAbbr[sk_maxStringLength];
|
||
/** Reserved for future use. */
|
||
unsigned int reserved[8];
|
||
|
||
PropertyInfo()
|
||
{
|
||
type = UNSPECIFIED_PROPERTY_TYPE;
|
||
present = false;
|
||
autoSupported = false;
|
||
manualSupported = false;
|
||
onOffSupported = false;
|
||
onePushSupported = false;
|
||
absValSupported = false;
|
||
readOutSupported = false;
|
||
min = 0;
|
||
max = 0;
|
||
absMin = 0.0f;
|
||
absMax = 0.0f;
|
||
memset( pUnits, 0, sk_maxStringLength );
|
||
memset( pUnitAbbr, 0, sk_maxStringLength );
|
||
memset( reserved, 0, sizeof(reserved) );
|
||
}
|
||
|
||
PropertyInfo( PropertyType propType )
|
||
{
|
||
type = propType;
|
||
present = false;
|
||
autoSupported = false;
|
||
manualSupported = false;
|
||
onOffSupported = false;
|
||
onePushSupported = false;
|
||
absValSupported = false;
|
||
readOutSupported = false;
|
||
min = 0;
|
||
max = 0;
|
||
absMin = 0.0f;
|
||
absMax = 0.0f;
|
||
memset( pUnits, 0, sk_maxStringLength );
|
||
memset( pUnitAbbr, 0, sk_maxStringLength );
|
||
memset( reserved, 0, sizeof(reserved) );
|
||
}
|
||
};
|
||
|
||
/** The TriggerDelayInfo structure is identical to PropertyInfo. */
|
||
typedef PropertyInfo TriggerDelayInfo;
|
||
|
||
/**
|
||
* A specific camera property. \n
|
||
* For example, to set the gain to 12dB, set the following values:
|
||
* - \a type - \c GAIN
|
||
* - \a absControl - \c true
|
||
* - \a onePush - \c false
|
||
* - \a onOff - \c true
|
||
* - \a autoManualMode - \c false
|
||
* - \a absValue - \c 12.0
|
||
*/
|
||
struct Property
|
||
{
|
||
/** Property info type. */
|
||
PropertyType type;
|
||
/** Flag indicating if the property is present. */
|
||
bool present;
|
||
/**
|
||
* Flag controlling absolute mode (real world units)
|
||
* or non-absolute mode (camera internal units).
|
||
*/
|
||
bool absControl;
|
||
/** Flag controlling one push. */
|
||
bool onePush;
|
||
/** Flag controlling on/off. */
|
||
bool onOff;
|
||
/** Flag controlling auto. */
|
||
bool autoManualMode;
|
||
/**
|
||
* Value A (integer).
|
||
* Used to configure properties in non-absolute mode.
|
||
*/
|
||
unsigned int valueA;
|
||
/**
|
||
* Value B (integer). For white balance, value B applies to the blue value and
|
||
* value A applies to the red value.
|
||
*/
|
||
unsigned int valueB;
|
||
/**
|
||
* Floating point value.
|
||
* Used to configure properties in absolute mode.
|
||
*/
|
||
float absValue;
|
||
/** Reserved for future use. */
|
||
unsigned int reserved[8];
|
||
|
||
Property()
|
||
{
|
||
type = UNSPECIFIED_PROPERTY_TYPE;
|
||
present = false;
|
||
absControl = false;
|
||
onePush = false;
|
||
onOff = false;
|
||
autoManualMode = false;
|
||
valueA = 0;
|
||
valueB = 0;
|
||
absValue = 0.0f;
|
||
memset( reserved, 0, sizeof(reserved) );
|
||
}
|
||
|
||
Property( PropertyType propType )
|
||
{
|
||
type = propType;
|
||
present = false;
|
||
absControl = false;
|
||
onePush = false;
|
||
onOff = false;
|
||
autoManualMode = false;
|
||
valueA = 0;
|
||
valueB = 0;
|
||
absValue = 0.0f;
|
||
memset( reserved, 0, sizeof(reserved) );
|
||
}
|
||
};
|
||
|
||
/** The TriggerDelay structure is identical to Property. */
|
||
typedef Property TriggerDelay;
|
||
|
||
/** Information about a camera trigger property. */
|
||
struct TriggerModeInfo
|
||
{
|
||
/** Presence of trigger mode. */
|
||
bool present;
|
||
/** Flag indicating if trigger value can be read out. */
|
||
bool readOutSupported;
|
||
/** Flag indicating if on/off is supported. */
|
||
bool onOffSupported;
|
||
/** Flag indicating if polarity is supported. */
|
||
bool polaritySupported;
|
||
/** Flag indicating if the value is readable. */
|
||
bool valueReadable;
|
||
/** Source mask. */
|
||
unsigned int sourceMask;
|
||
/** Flag indicating if software trigger is supported. */
|
||
bool softwareTriggerSupported;
|
||
/** Mode mask. */
|
||
unsigned int modeMask;
|
||
/** Reserved for future use. */
|
||
unsigned int reserved[8];
|
||
|
||
TriggerModeInfo()
|
||
{
|
||
present = false;
|
||
readOutSupported = false;
|
||
onOffSupported = false;
|
||
polaritySupported = false;
|
||
valueReadable = false;
|
||
sourceMask = 0;
|
||
softwareTriggerSupported = false;
|
||
modeMask = 0;
|
||
memset( reserved, 0, sizeof(reserved) );
|
||
}
|
||
};
|
||
|
||
/** A camera trigger. */
|
||
struct TriggerMode
|
||
{
|
||
/** Flag controlling on/off. */
|
||
bool onOff;
|
||
/** Polarity value. */
|
||
unsigned int polarity;
|
||
/** Source value. */
|
||
unsigned int source;
|
||
/** Mode value. */
|
||
unsigned int mode;
|
||
/** Parameter value. */
|
||
unsigned int parameter;
|
||
/** Reserved for future use. */
|
||
unsigned int reserved[8];
|
||
|
||
TriggerMode()
|
||
{
|
||
onOff = false;
|
||
polarity = 0;
|
||
source = 0;
|
||
mode = 0;
|
||
parameter = 0;
|
||
memset( reserved, 0, sizeof(reserved) );
|
||
}
|
||
};
|
||
|
||
/** A camera strobe property. */
|
||
struct StrobeInfo
|
||
{
|
||
/** Source value. */
|
||
unsigned int source;
|
||
/** Presence of strobe. */
|
||
bool present;
|
||
/** Flag indicating if strobe value can be read out. */
|
||
bool readOutSupported;
|
||
/** Flag indicating if on/off is supported. */
|
||
bool onOffSupported;
|
||
/** Flag indicating if polarity is supported. */
|
||
bool polaritySupported;
|
||
/** Minimum value. */
|
||
float minValue;
|
||
/** Maximum value. */
|
||
float maxValue;
|
||
/** Reserved for future use. */
|
||
unsigned int reserved[8];
|
||
|
||
StrobeInfo()
|
||
{
|
||
source = 0;
|
||
present = false;
|
||
readOutSupported = false;
|
||
onOffSupported = false;
|
||
polaritySupported = false;
|
||
minValue = 0.0f;
|
||
maxValue = 0.0f;
|
||
memset( reserved, 0, sizeof(reserved) );
|
||
}
|
||
};
|
||
|
||
/** A camera strobe. */
|
||
struct StrobeControl
|
||
{
|
||
/** Source value. */
|
||
unsigned int source;
|
||
/** Flag controlling on/off. */
|
||
bool onOff;
|
||
/** Signal polarity. */
|
||
unsigned int polarity;
|
||
/** Signal delay (in ms). */
|
||
float delay;
|
||
/** Signal duration (in ms). */
|
||
float duration;
|
||
/** Reserved for future use. */
|
||
unsigned int reserved[8];
|
||
|
||
StrobeControl()
|
||
{
|
||
source = 0;
|
||
onOff = false;
|
||
polarity = 0;
|
||
delay = 0.0f;
|
||
duration = 0.0f;
|
||
memset( reserved, 0, sizeof(reserved) );
|
||
}
|
||
};
|
||
|
||
/** Timestamp information. */
|
||
struct TimeStamp
|
||
{
|
||
/** Seconds. */
|
||
long long seconds;
|
||
/** Microseconds. */
|
||
unsigned int microSeconds;
|
||
/** 1394 cycle time seconds. */
|
||
unsigned int cycleSeconds;
|
||
/** 1394 cycle time count. */
|
||
unsigned int cycleCount;
|
||
/** 1394 cycle time offset. */
|
||
unsigned int cycleOffset;
|
||
/** Reserved for future use. */
|
||
unsigned int reserved[8];
|
||
|
||
TimeStamp()
|
||
{
|
||
seconds = 0;
|
||
microSeconds = 0;
|
||
cycleSeconds = 0;
|
||
cycleCount = 0;
|
||
cycleOffset = 0;
|
||
memset( reserved, 0, sizeof(reserved) );
|
||
}
|
||
};
|
||
|
||
/** Camera configuration ROM. */
|
||
struct ConfigROM
|
||
{
|
||
/** Vendor ID of a node. */
|
||
unsigned int nodeVendorId;
|
||
/** Chip ID (high part). */
|
||
unsigned int chipIdHi;
|
||
/** Chip ID (low part). */
|
||
unsigned int chipIdLo;
|
||
/** Unit Spec ID, usually 0xa02d. */
|
||
unsigned int unitSpecId;
|
||
/** Unit software version. */
|
||
unsigned int unitSWVer;
|
||
/** Unit sub software version. */
|
||
unsigned int unitSubSWVer;
|
||
/** Vendor unique info 0. */
|
||
unsigned int vendorUniqueInfo_0;
|
||
/** Vendor unique info 1. */
|
||
unsigned int vendorUniqueInfo_1;
|
||
/** Vendor unique info 2. */
|
||
unsigned int vendorUniqueInfo_2;
|
||
/** Vendor unique info 3. */
|
||
unsigned int vendorUniqueInfo_3;
|
||
/** Keyword. */
|
||
char pszKeyword[ sk_maxStringLength ];
|
||
/** Reserved for future use. */
|
||
unsigned int reserved[16];
|
||
|
||
ConfigROM()
|
||
{
|
||
nodeVendorId = 0;
|
||
chipIdHi = 0;
|
||
chipIdLo = 0;
|
||
unitSpecId = 0;
|
||
unitSWVer = 0;
|
||
unitSubSWVer = 0;
|
||
vendorUniqueInfo_0 = 0;
|
||
vendorUniqueInfo_1 = 0;
|
||
vendorUniqueInfo_2 = 0;
|
||
vendorUniqueInfo_3 = 0;
|
||
memset( pszKeyword, 0, sizeof ( pszKeyword ) );
|
||
memset( reserved, 0, sizeof(reserved) );
|
||
}
|
||
};
|
||
|
||
/** Camera information. */
|
||
struct CameraInfo
|
||
{
|
||
/** Device serial number. */
|
||
unsigned int serialNumber;
|
||
/** Interface type. */
|
||
InterfaceType interfaceType;
|
||
/** Driver type. */
|
||
DriverType driverType;
|
||
/** Flag indicating if this is a color camera. */
|
||
bool isColorCamera;
|
||
/** Device model name. */
|
||
char modelName[sk_maxStringLength];
|
||
/** Device vendor name. */
|
||
char vendorName[sk_maxStringLength];
|
||
/** String detailing the sensor information. */
|
||
char sensorInfo[sk_maxStringLength];
|
||
/** String providing the sensor resolution. */
|
||
char sensorResolution[sk_maxStringLength];
|
||
/** Driver name of driver being used. */
|
||
char driverName[sk_maxStringLength];
|
||
/** Firmware version of camera. */
|
||
char firmwareVersion[sk_maxStringLength];
|
||
/** Firmware build time. */
|
||
char firmwareBuildTime[sk_maxStringLength];
|
||
/** Maximum bus speed. */
|
||
BusSpeed maximumBusSpeed;
|
||
/** Bayer tile format. */
|
||
BayerTileFormat bayerTileFormat;
|
||
/** Bus number, set to 0 for GigE and USB cameras **/
|
||
unsigned short busNumber;
|
||
/** ieee1394 Node number, set to 0 for GigE and USB cameras **/
|
||
unsigned short nodeNumber;
|
||
/** PCIe Bus Speed, set to PCIE_BUSSPEED_UNKNOWN for unsupported drivers **/
|
||
PCIeBusSpeed pcieBusSpeed;
|
||
|
||
/** @name IIDC specific information */
|
||
/*@{*/
|
||
|
||
/** DCAM version. */
|
||
unsigned int iidcVer;
|
||
/** Configuration ROM data. */
|
||
ConfigROM configROM;
|
||
|
||
/*@}*/
|
||
|
||
/** @name GigE specific information */
|
||
/*@{*/
|
||
|
||
/** GigE Vision version. */
|
||
unsigned int gigEMajorVersion;
|
||
/** GigE Vision minor version. */
|
||
unsigned int gigEMinorVersion;
|
||
/** User defined name. */
|
||
char userDefinedName[sk_maxStringLength];
|
||
/** XML URL 1. */
|
||
char xmlURL1[sk_maxStringLength];
|
||
/** XML URL 2. */
|
||
char xmlURL2[sk_maxStringLength];
|
||
/** MAC address */
|
||
MACAddress macAddress;
|
||
/** IP address. */
|
||
IPAddress ipAddress;
|
||
/** Subnet mask. */
|
||
IPAddress subnetMask;
|
||
/** Default gateway. */
|
||
IPAddress defaultGateway;
|
||
/** Status/Content of CCP register */
|
||
unsigned int ccpStatus;
|
||
/** Local Application IP Address. */
|
||
unsigned int applicationIPAddress;
|
||
/** Local Application port. */
|
||
unsigned int applicationPort;
|
||
/*@}*/
|
||
|
||
/** Reserved for future use. */
|
||
unsigned int reserved[16];
|
||
|
||
CameraInfo()
|
||
{
|
||
serialNumber = 0;
|
||
interfaceType = INTERFACE_UNKNOWN;
|
||
driverType = DRIVER_UNKNOWN;
|
||
isColorCamera = false;
|
||
memset( modelName, 0, sizeof( modelName ) );
|
||
memset( vendorName, 0, sizeof( vendorName ) );
|
||
memset( sensorInfo, 0, sizeof( sensorInfo ) );
|
||
memset( sensorResolution, 0, sizeof( sensorResolution ) );
|
||
memset( driverName, 0, sizeof(driverName) );
|
||
memset( firmwareVersion, 0, sizeof( firmwareVersion ) );
|
||
memset( firmwareBuildTime, 0, sizeof( firmwareBuildTime ) );
|
||
maximumBusSpeed = BUSSPEED_SPEED_UNKNOWN;
|
||
bayerTileFormat = NONE;
|
||
busNumber = 0;
|
||
nodeNumber = 0;
|
||
pcieBusSpeed = PCIE_BUSSPEED_UNKNOWN;
|
||
|
||
// IIDC
|
||
iidcVer = 0;
|
||
|
||
// GigE
|
||
gigEMajorVersion = 0;
|
||
gigEMinorVersion = 0;
|
||
|
||
ccpStatus = 0;
|
||
applicationIPAddress = 0;
|
||
applicationPort = 0;
|
||
|
||
memset( userDefinedName, 0x0, sizeof(userDefinedName) );
|
||
memset( xmlURL1, 0x0, sizeof(xmlURL1) );
|
||
memset( xmlURL2, 0x0, sizeof(xmlURL2) );
|
||
|
||
memset( reserved, 0, sizeof(reserved) );
|
||
}
|
||
};
|
||
|
||
/** Properties of a single embedded image info property. */
|
||
struct EmbeddedImageInfoProperty
|
||
{
|
||
/** Whether this property is available. */
|
||
bool available;
|
||
/** Whether this property is on or off. */
|
||
bool onOff;
|
||
|
||
EmbeddedImageInfoProperty()
|
||
{
|
||
available = false;
|
||
onOff = false;
|
||
}
|
||
};
|
||
|
||
/** Properties of the possible embedded image information. */
|
||
struct EmbeddedImageInfo
|
||
{
|
||
EmbeddedImageInfoProperty timestamp;
|
||
EmbeddedImageInfoProperty gain;
|
||
EmbeddedImageInfoProperty shutter;
|
||
EmbeddedImageInfoProperty brightness;
|
||
EmbeddedImageInfoProperty exposure;
|
||
EmbeddedImageInfoProperty whiteBalance;
|
||
EmbeddedImageInfoProperty frameCounter;
|
||
EmbeddedImageInfoProperty strobePattern;
|
||
EmbeddedImageInfoProperty GPIOPinState;
|
||
EmbeddedImageInfoProperty ROIPosition;
|
||
};
|
||
|
||
/** Metadata related to an image. */
|
||
struct ImageMetadata
|
||
{
|
||
/** Embedded timestamp. */
|
||
unsigned int embeddedTimeStamp;
|
||
/** Embedded gain. */
|
||
unsigned int embeddedGain;
|
||
/** Embedded shutter. */
|
||
unsigned int embeddedShutter;
|
||
/** Embedded brightness. */
|
||
unsigned int embeddedBrightness;
|
||
/** Embedded exposure. */
|
||
unsigned int embeddedExposure;
|
||
/** Embedded white balance. */
|
||
unsigned int embeddedWhiteBalance;
|
||
/** Embedded frame counter. */
|
||
unsigned int embeddedFrameCounter;
|
||
/** Embedded strobe pattern. */
|
||
unsigned int embeddedStrobePattern;
|
||
/** Embedded GPIO pin state. */
|
||
unsigned int embeddedGPIOPinState;
|
||
/** Embedded ROI position. */
|
||
unsigned int embeddedROIPosition;
|
||
|
||
/** Reserved for future use. */
|
||
unsigned int reserved[31];
|
||
|
||
ImageMetadata()
|
||
{
|
||
embeddedTimeStamp = 0;
|
||
embeddedGain = 0;
|
||
embeddedShutter = 0;
|
||
embeddedBrightness = 0;
|
||
embeddedExposure = 0;
|
||
embeddedWhiteBalance = 0;
|
||
embeddedFrameCounter = 0;
|
||
embeddedStrobePattern = 0;
|
||
embeddedGPIOPinState = 0;
|
||
embeddedROIPosition = 0;
|
||
memset( reserved, 0, sizeof(reserved));
|
||
}
|
||
};
|
||
|
||
/** Information about the camera's look up table. */
|
||
struct LUTData
|
||
{
|
||
/** Flag indicating if LUT is supported. */
|
||
bool supported;
|
||
/** Flag indicating if LUT is enabled. */
|
||
bool enabled;
|
||
/** The number of LUT banks available (Always 1 for PGR LUT). */
|
||
unsigned int numBanks;
|
||
/** The number of LUT channels per bank available. */
|
||
unsigned int numChannels;
|
||
/** The input bit depth of the LUT. */
|
||
unsigned int inputBitDepth;
|
||
/** The output bit depth of the LUT. */
|
||
unsigned int outputBitDepth;
|
||
/** The number of entries in the LUT. */
|
||
unsigned int numEntries;
|
||
/** Reserved for future use. */
|
||
unsigned int reserved[8];
|
||
|
||
LUTData()
|
||
{
|
||
supported = false;
|
||
enabled = false;
|
||
numBanks = 0;
|
||
numChannels = 0;
|
||
inputBitDepth = 0;
|
||
outputBitDepth = 0;
|
||
numEntries = 0;
|
||
memset( reserved, 0, sizeof(reserved) );
|
||
}
|
||
};
|
||
|
||
/** Camera diagnostic information. */
|
||
struct CameraStats
|
||
{
|
||
/* Number of dropped images in DROP_IMAGE mode */
|
||
unsigned int imageDropped;
|
||
/* Number of corrupt images, such as missing packet, zero packet */
|
||
unsigned int imageCorrupt;
|
||
/* Number of transmissions failed of camera */
|
||
unsigned int imageXmitFailed;
|
||
/* Number of images dropped in driver */
|
||
unsigned int imageDriverDropped;
|
||
/* Errors of register reading */
|
||
unsigned int regReadFailed;
|
||
/* Errors of register writing */
|
||
unsigned int regWriteFailed;
|
||
/* Port errors */
|
||
unsigned int portErrors;
|
||
/* The value of the camera power register.
|
||
* false: Camera is powered down.
|
||
* true: Camera is powered up.
|
||
*/
|
||
bool cameraPowerUp;
|
||
|
||
/* The voltage values of the various voltage registers
|
||
* supported by the camera.
|
||
*/
|
||
float cameraVoltages[8];
|
||
/** The number of voltage registers available.
|
||
* 0: the values in cameraVoltages[] are invalid.
|
||
*/
|
||
unsigned int numVoltages;
|
||
|
||
/* The current values of the various current registers
|
||
* supported by the camera.
|
||
*/
|
||
float cameraCurrents[8];
|
||
/** The number of current registers available.
|
||
* 0: the values in cameraCurrents[] are invalid.
|
||
*/
|
||
unsigned int numCurrents;
|
||
/* The temperature of the camera board-level components. The value is
|
||
* in kelvins (0<>C = 273.15K) and are in one-tenths (0.1) of a kelvin.
|
||
*/
|
||
unsigned int temperature;
|
||
/* Time in seconds since the camera was initialized. */
|
||
unsigned int timeSinceInitialization;
|
||
/* Time in seconds since the camera detected a bus reset. */
|
||
unsigned int timeSinceBusReset;
|
||
/* Time stamp */
|
||
TimeStamp timeStamp;
|
||
/* Number of packets requested for resend */
|
||
unsigned int numResendPacketsRequested;
|
||
/* Number of packet-resend packets received */
|
||
unsigned int numResendPacketsReceived;
|
||
/** Reserved for future use. */
|
||
unsigned int reserved[16];
|
||
|
||
CameraStats()
|
||
{
|
||
imageDropped = 0;
|
||
imageCorrupt = 0;
|
||
imageXmitFailed = 0;
|
||
imageDriverDropped = 0;
|
||
regReadFailed = 0;
|
||
regWriteFailed = 0;
|
||
portErrors = 0;
|
||
cameraPowerUp = false;
|
||
memset( cameraVoltages, 0, sizeof(cameraVoltages) );
|
||
numVoltages = 0;
|
||
memset( cameraCurrents, 0, sizeof(cameraCurrents) );
|
||
numCurrents = 0;
|
||
temperature = 0;
|
||
timeSinceInitialization = 0;
|
||
timeSinceBusReset = 0;
|
||
memset( reserved, 0, sizeof(reserved) );
|
||
}
|
||
};
|
||
|
||
|
||
/**
|
||
* @defgroup ImageSaveStructures Image saving structures.
|
||
*
|
||
* These structures define various parameters used for saving images.
|
||
*/
|
||
|
||
/*@{*/
|
||
|
||
/** Options for saving PNG images. */
|
||
struct PNGOption
|
||
{
|
||
/** Whether to save the PNG as interlaced. */
|
||
bool interlaced;
|
||
/** Compression level (0-9). 0 is no compression, 9 is best compression. */
|
||
unsigned int compressionLevel;
|
||
/** Reserved for future use. */
|
||
unsigned int reserved[16];
|
||
|
||
PNGOption()
|
||
{
|
||
interlaced = false;
|
||
compressionLevel = 6;
|
||
memset(reserved, 0, sizeof (reserved));
|
||
}
|
||
};
|
||
|
||
/** Options for saving PPM images. */
|
||
struct PPMOption
|
||
{
|
||
/** Whether to save the PPM as a binary file. */
|
||
bool binaryFile;
|
||
/** Reserved for future use. */
|
||
unsigned int reserved[16];
|
||
|
||
PPMOption()
|
||
{
|
||
binaryFile = true;
|
||
memset(reserved, 0, sizeof (reserved));
|
||
}
|
||
};
|
||
|
||
/** Options for saving PGM images. */
|
||
struct PGMOption
|
||
{
|
||
/** Whether to save the PPM as a binary file. */
|
||
bool binaryFile;
|
||
/** Reserved for future use. */
|
||
unsigned int reserved[16];
|
||
|
||
PGMOption()
|
||
{
|
||
binaryFile = true;
|
||
memset(reserved, 0, sizeof (reserved));
|
||
}
|
||
};
|
||
|
||
/** Options for saving TIFF images. */
|
||
struct TIFFOption
|
||
{
|
||
enum CompressionMethod
|
||
{
|
||
NONE = 1, /**< Save without any compression. */
|
||
PACKBITS, /**< Save using PACKBITS compression. */
|
||
DEFLATE, /**< Save using DEFLATE compression (ZLIB compression). */
|
||
ADOBE_DEFLATE, /**< Save using ADOBE DEFLATE compression */
|
||
/**
|
||
* Save using CCITT Group 3 fax encoding. This is only valid for
|
||
* 1-bit images only. Default to LZW for other bit depths.
|
||
*/
|
||
CCITTFAX3,
|
||
/**
|
||
* Save using CCITT Group 4 fax encoding. This is only valid for
|
||
* 1-bit images only. Default to LZW for other bit depths.
|
||
*/
|
||
CCITTFAX4,
|
||
LZW, /**< Save using LZW compression. */
|
||
/**
|
||
* Save using JPEG compression. This is only valid for 8-bit
|
||
* greyscale and 24-bit only. Default to LZW for other bit depths.
|
||
*/
|
||
JPEG
|
||
};
|
||
|
||
/** Compression method to use for encoding TIFF images. */
|
||
CompressionMethod compression;
|
||
/** Reserved for future use. */
|
||
unsigned int reserved[16];
|
||
|
||
TIFFOption()
|
||
{
|
||
compression = LZW;
|
||
memset(reserved, 0, sizeof (reserved));
|
||
}
|
||
};
|
||
|
||
/** Options for saving JPEG image. */
|
||
struct JPEGOption
|
||
{
|
||
/** Whether to save as a progressive JPEG file. */
|
||
bool progressive;
|
||
/**
|
||
* JPEG image quality in range (0-100).
|
||
* - 100 - Superb quality.
|
||
* - 75 - Good quality.
|
||
* - 50 - Normal quality.
|
||
* - 10 - Poor quality.
|
||
*/
|
||
unsigned int quality;
|
||
/** Reserved for future use. */
|
||
unsigned int reserved[16];
|
||
|
||
JPEGOption()
|
||
{
|
||
progressive = false;
|
||
quality = 75;
|
||
memset(reserved, 0, sizeof (reserved));
|
||
}
|
||
};
|
||
|
||
/** Options for saving JPEG2000 image. */
|
||
struct JPG2Option
|
||
{
|
||
/** JPEG saving quality in range (1-512). */
|
||
unsigned int quality;
|
||
/** Reserved for future use. */
|
||
unsigned int reserved[16];
|
||
|
||
JPG2Option()
|
||
{
|
||
quality = 16;
|
||
memset(reserved, 0, sizeof (reserved));
|
||
}
|
||
};
|
||
|
||
/** Options for saving Bitmap image. */
|
||
struct BMPOption
|
||
{
|
||
bool indexedColor_8bit;
|
||
/** Reserved for future use. */
|
||
unsigned int reserved[16];
|
||
|
||
BMPOption()
|
||
{
|
||
indexedColor_8bit = false;
|
||
memset(reserved, 0, sizeof(reserved));
|
||
}
|
||
};
|
||
|
||
/** Options for saving MJPG files. */
|
||
struct MJPGOption
|
||
{
|
||
/** Frame rate of the stream */
|
||
float frameRate;
|
||
|
||
/** Image quality (1-100) */
|
||
unsigned int quality;
|
||
|
||
unsigned int reserved[256];
|
||
|
||
MJPGOption()
|
||
{
|
||
frameRate = 15.0;
|
||
quality = 75;
|
||
memset(reserved, 0, sizeof (reserved));
|
||
}
|
||
};
|
||
|
||
/** Options for saving H264 files. */
|
||
struct H264Option
|
||
{
|
||
/** Frame rate of the stream */
|
||
float frameRate;
|
||
|
||
/** Width of source image */
|
||
unsigned int width;
|
||
|
||
/** Height of source image */
|
||
unsigned int height;
|
||
|
||
/** Bitrate to encode at */
|
||
unsigned int bitrate;
|
||
|
||
/** Reserved for future use */
|
||
unsigned int reserved[256];
|
||
|
||
H264Option()
|
||
{
|
||
frameRate = 15.0;
|
||
width = 0;
|
||
height = 0;
|
||
bitrate = 1000000;
|
||
memset(reserved, 0, sizeof (reserved));
|
||
}
|
||
};
|
||
|
||
/** Options for saving AVI files. */
|
||
struct AVIOption
|
||
{
|
||
/** Frame rate of the stream */
|
||
float frameRate;
|
||
|
||
/** Reserved for future use */
|
||
unsigned int reserved[256];
|
||
|
||
AVIOption()
|
||
{
|
||
frameRate = 15.0;
|
||
memset(reserved, 0, sizeof (reserved));
|
||
}
|
||
};
|
||
|
||
/* Callback function typedef: a function accepting pointer-to-void input as its sole
|
||
* argument, and returns void (ie: nothing).
|
||
*/
|
||
typedef void (*CameraEventCallback)(void* data);
|
||
|
||
/** Options for enabling device event registration. */
|
||
struct EventOptions
|
||
{
|
||
/** Callback function pointer */
|
||
CameraEventCallback EventCallbackFcn;
|
||
|
||
/** Event name to register */
|
||
const char* EventName;
|
||
|
||
/** Pointer to callback data to be passed to the callback function */
|
||
const void* EventUserData;
|
||
|
||
/** Size of the underlying struct passed as eventCallbackData for sanity checks */
|
||
size_t EventUserDataSize;
|
||
};
|
||
|
||
|
||
/* Callback data passed to the callback function provided when using
|
||
* RegisterEvent() or RegisterAllEvents().
|
||
*/
|
||
struct EventCallbackData
|
||
{
|
||
/** Pointer to the user-supplied data struct */
|
||
void* EventUserData;
|
||
|
||
/** Size of the user data data supplied to the RegisterEvent()
|
||
* function.
|
||
*/
|
||
size_t EventUserDataSize;
|
||
|
||
/** The event name used to register the event. Provided so the user
|
||
* knows which event triggered the callback.
|
||
*/
|
||
const char* EventName;
|
||
|
||
/** The device register which EventName maps to. Provides an alternate
|
||
* means of indexing into different event types.
|
||
*/
|
||
long long unsigned EventID;
|
||
|
||
/** Timestamp indicated the time (as reported by the camera) at which
|
||
* the camera exposure operation completed. This can be compared with
|
||
* image stimestamps if there is a need to map event timestamps to
|
||
* specific images, if applicable.
|
||
*/
|
||
long long unsigned EventTimestamp;
|
||
|
||
/** A pointer to additional data pertaining to the event which just
|
||
* trigger the callback function. The data may be of difference sizes
|
||
* or may not even be allocated, depending on the type of event which
|
||
* triggered the callback.
|
||
*/
|
||
void* EventData;
|
||
|
||
/** The size of the structure pointed to by EventData. This value should
|
||
* be checked, especially if there are events which can trigger variable-
|
||
* length event data to be returned to the user when the callback function
|
||
* is issued.
|
||
*/
|
||
size_t EventDataSize;
|
||
};
|
||
/*@}*/
|
||
|
||
/*@}*/
|
||
|
||
}
|
||
|
||
#endif // PGR_FC2_FLYCAPTURE2DEFS_H
|
||
|