Group Structs

group Structs

Structs passed to and received from LeapC functions.

Typedefs

typedef struct _LEAP_CALIBRATION *LEAP_CALIBRATION

Represents a calibration object.

Not currently of any particular use.

Since

3.0.0

typedef struct _LEAP_RECORDING *LEAP_RECORDING

A Leap recording.

Since

3.2.0

struct LEAP_DEVICE_REF
#include <LeapC.h>

A reference to a Leap device.

Get a LEAP_DEVICE_REF by calling LeapGetDeviceList(). Access a device by calling LeapOpenDevice() with this reference. LeapOpenDevice() provides a LEAP_DEVICE struct, which is a handle to an open device.

Public Members

void *handle

An opaque handle.

Since

3.0.0

uint32_t id

a generic identifier.

Since

3.0.0

struct LEAP_CONNECTION_CONFIG
#include <LeapC.h>

Specifies the configuration for a connection.

Since

3.0.0

Public Members

uint32_t size

Set to the final size of the structure.

Since

3.0.0

uint32_t flags

A combination of eLeapConnectionConfig flags.

Set to 0 to indicate no special flags.

Since

3.0.0

const char *server_namespace

Specifies the server namespace to be used.

Leave NULL to use the default namespace.

It is possible to launch the service with a different IPC connection namespace (using internal service functions). Clients wishing to connect to a different server namespace may specify that namespace here.

The default connection namespace is “Leap Service”. For internal use.

Since

3.0.0

struct LEAP_ALLOCATOR
#include <LeapC.h>

Specifies the allocator/deallocator functions to be used when the library needs to dynamically manage memory.

Since

4.0.0

Public Members

void *(*allocate)(uint32_t size, eLeapAllocatorType typeHint, void *state)

Function pointer to an allocator function that is expected to return a pointer to memory of at least the specified size in bytes.

This will be called when the library needs a block of memory that will be provided back to the client in a subsequent event or response. A type hint is provided in the case where the underlying buffer type needs to be known at allocation time.

void (*deallocate)(void *ptr, void *state)

Function pointer to a deallocator function.

The function receives the address of a previously allocated block of memory from the allocate function pointer. The caller is not required to deallocate the memory, but rather this call is used by the library to indicate to the client that it will no longer reference the memory at this address, and that the callee may deallocate the memory when it is ready to do so.

void *state

Pointer to state to be passed to the allocate and deallocate functions.

struct LEAP_CONNECTION_EVENT
#include <LeapC.h>

Received from LeapPollConnection() when a connection to the Ultraleap Tracking Service is established.

Since

3.0.0

Public Members

uint32_t flags

A combination of eLeapServiceDisposition flags.

Since

3.1.3

struct LEAP_CONNECTION_LOST_EVENT
#include <LeapC.h>

Received from LeapPollConnection() when a connection to the Ultraleap Tracking Service is lost.

If a LeapC function that performs a transaction with the Ultraleap Tracking Service is called after the connection is lost, the next call to LeapPollConnection() will return this event. Otherwise, it can take up to 5 seconds of polling the connection to receive this event.

Since

3.0.0

Public Members

uint32_t flags

Reserved for future use.

Since

3.0.0

struct LEAP_CONNECTION_INFO
#include <LeapC.h>

Information about a connection.

Call LeapCreateConnection() to generate the handle for the connection; call LeapOpenConnection() to establish the connection; then call LeapGetConnectionInfo(), which creates this struct, to check the connection status.

Since

3.0.0

Public Members

uint32_t size

The size of this structure.

Since

3.0.0

eLeapConnectionStatus status

The current status of this connection.

Since

3.0.0

struct LEAP_POLICY_EVENT
#include <LeapC.h>

The response from a request to get or set a policy.

LeapPollConnection() creates this struct when the response becomes available.

Since

3.0.0

Public Members

uint32_t reserved

Reserved for future use.

Since

3.0.0

uint32_t current_policy

A bitfield containing the policies effective at the time the policy event was processed.

Since

3.0.0

struct LEAP_TRACKING_MODE_EVENT
#include <LeapC.h>

The response from a request to get or set a policy.

LeapPollConnection() creates this struct when the response becomes available.

Since

3.0.0

Public Members

uint32_t reserved

Reserved for future use.

Since

5.0.0

eLeapTrackingMode current_tracking_mode

An enum specifying the tracking mode effective at the time the tracking mode event was processed.

Since

5.0.0

struct LEAP_VARIANT
#include <LeapC.h>

A variant data type used to get and set service configuration values.

Since

3.0.0

Public Members

eLeapValueType type

The active data type in this instance.

Since

3.0.0

bool boolValue

A Boolean value.

Since

3.0.0

int32_t iValue

An integer value.

Since

3.0.0

float fValue

A floating point value.

Since

3.0.0

const char *strValue

A pointer to a string buffer.

Since

3.0.0

struct LEAP_CONFIG_RESPONSE_EVENT
#include <LeapC.h>

Contains the response to a configuration value request.

Call LeapRequestConfigValue() to request a service config value. The value is fetched asynchronously since it requires a service transaction. LeapPollConnection() returns this event structure when the request has been processed. Use the requestID value to correlate the response to the originating request.

Since

3.0.0

Public Members

uint32_t requestID

An identifier for correlating the request and response.

Since

3.0.0

LEAP_VARIANT value

The configuration value retrieved from the service.

Do not free any memory pointed to by this member. The value held is only valid until the next call to LeapPollConnection().

Since

3.0.0

struct LEAP_CONFIG_CHANGE_EVENT
#include <LeapC.h>

The result of a configuration change request.

Contains a status of true for a successful change. Call LeapSaveConfigValue() to request a service config change. The change is performed asynchronously and may fail. LeapPollConnection() returns this event structure when the request has been processed. Use the requestID value to correlate the response to the originating request.

Since

3.0.0

return

The operation result code, a member of the eLeapRS enumeration.

Public Members

uint32_t requestID

An identifier for correlating the request and response.

Since

3.0.0

bool status

The result of the change operation: true on success; false on failure.

Since

3.0.0

struct LEAP_DEVICE_INFO
#include <LeapC.h>

Properties of a Leap device.

Get a LEAP_DEVICE_INFO by calling LeapGetDeviceInfo() with the handle for device. The device must be open.

Since

3.0.0

Public Members

uint32_t size

Size of this structure.

Since

3.0.0

uint32_t status

A combination of eLeapDeviceStatus flags.

Since

3.0.0

uint32_t caps

A combination of eLeapDeviceCaps flags.

Since

3.0.0

eLeapDevicePID pid

One of the eLeapDevicePID members.

Since

3.0.0

uint32_t baseline

The device baseline, in micrometers.

The baseline is defined as the distance between the center axis of each lens in a stereo camera system. For other camera systems, this value is set to zero.

Since

3.0.0

uint32_t serial_length

The required length of the serial number char buffer including the null character.

Since

3.0.0

char *serial

A pointer to the null-terminated device serial number string.

Since

3.0.0

float h_fov

The horizontal field of view of this device in radians.

Since

3.0.0

float v_fov

The vertical field of view of this device in radians.

Since

3.0.0

uint32_t range

The maximum range for this device, in micrometers.

Since

3.0.0

struct LEAP_DEVICE_EVENT
#include <LeapC.h>

Device event information.

LeapPollConnection() produces a message containing this event when a new device is detected. You can use the handle provided by the device filed to open a device so that you can access its properties.

Since

3.0.0

Public Members

uint32_t flags

Reserved for future use.

Since

3.0.0

LEAP_DEVICE_REF device

The handle reference of to the newly attached device.

Since

3.0.0

uint32_t status

The status of the connected device.

A combination of flags from the eLeapDeviceStatus collection.

struct LEAP_DEVICE_FAILURE_EVENT
#include <LeapC.h>

Device failure information.

LeapPollConnection() produces a message containing this event when a device fails. Only partial information may be available. If hDevice is non-null, then you can use it to identify the failed device with a known, open device.

Since

3.0.0

Public Members

eLeapDeviceStatus status

The status of this failure event.

Since

3.0.0

LEAP_DEVICE hDevice

A handle to the device generating this failure event, if available, otherwise NULL.

You are not responsible for closing this handle.

Since

3.0.0

struct LEAP_FRAME_HEADER
#include <LeapC.h>

Identifying information for a frame of tracking data.

Since

3.0.0

Public Members

void *reserved

Reserved, set to zero.

Since

3.0.0

int64_t frame_id

A unique identifier for this frame.

All frames carrying this frame ID are part of the same unit of processing. This counter is generally an increasing counter, but may reset to another value if the user stops and restarts streaming.

For interpolated frames, this value corresponds to the identifier of the frame upper bound.

Since

3.0.0

int64_t timestamp

The timestamp for this image, in microseconds, referenced against LeapGetNow().

Since

3.0.0

struct LEAP_IMAGE_PROPERTIES
#include <LeapC.h>

Properties of a sensor image.

Since

3.0.0

Public Members

eLeapImageType type

The type of this image.

Since

3.0.0

eLeapImageFormat format

The format of this image.

Since

3.0.0

uint32_t bpp

The number of bytes per image pixel.

Since

3.0.0

uint32_t width

The number of horizontal pixels in the image.

Since

3.0.0

uint32_t height

The number of rows of pixels in the image.

Since

3.0.0

float x_scale

Reserved for future use.

Since

3.0.0

float y_scale

Reserved for future use.

Since

3.0.0

float x_offset

Reserved for future use.

Since

3.0.0

float y_offset

Reserved for future use.

Since

3.0.0

struct LEAP_DISTORTION_MATRIX
#include <LeapC.h>

A matrix containing lens distortion correction coordinates.

Each point in the grid contains the coordinates of the pixel in the image buffer that contains the data for the pixel in the undistorted image corresponding to that point in the grid. Interpolate between points in the matrix to correct image pixels that don’t fall directly underneath a point in the distortion grid.

Current devices use a 64x64 point distortion grid.

Since

3.0.0

Public Members

float x

The x-pixel coordinate.

Since

3.0.0

float y

The y-pixel coordinate.

Since

3.0.0

struct LEAP_DISTORTION_MATRIX::[anonymous] matrix[64][64]

A point in the distortion grid.

Since

3.0.0 A grid of 2D points.

Since

3.0.0

struct LEAP_IMAGE_FRAME_DESCRIPTION
#include <LeapC.h>

Describes the image to request.

Pass this struct to the LeapImageRequest() function.

Since

3.0.0

Public Members

int64_t frame_id

The ID of the frame corresponding to the desired image.

Since

3.0.0

eLeapImageType type

The type of the desired image.

Since

3.0.0

uint64_t buffer_len

Length of your image buffer.

The buffer must be large enough to hold the request image.

void *pBuffer

An allocated buffer large enough to contain the requested image.

The buffer must remain valid until the image request completes or fails.

Since

3.0.0

struct LEAP_VECTOR
#include <LeapC.h>

A three element, floating-point vector.

Since

3.0.0

Public Members

float v[3]

The vector as an array.

Since

3.0.0

float x

The x spatial coordinate.

Since

3.0.0

float y

The y spatial coordinate.

Since

3.0.0

float z

The z spatial coordinate.

Since

3.0.0

union LEAP_VECTOR::[anonymous] [anonymous]

You can access the vector members as either an array or individual float values.

struct LEAP_QUATERNION
#include <LeapC.h>

A four element, floating point quaternion.

Since

3.1.2

Public Members

float v[4]

The quaternion as an array.

Since

3.1.3

float x

The x coefficient of the vector portion of the quaternion.

Since

3.1.2

float y

The y coefficient of the vector portion of the quaternion.

Since

3.1.2

float z

The z coefficient of the vector portion of the quaternion.

Since

3.1.2

float w

The scalar portion of the quaternion.

Since

3.1.2

struct LEAP_BONE
#include <LeapC.h>

Describes a bone’s position and orientation.

Bones are members of the LEAP_DIGIT struct.

Since

3.0.0

Public Members

LEAP_VECTOR prev_joint

The base of the bone, closer to the heart.

The bones origin.

Since

3.0.0

LEAP_VECTOR next_joint

The end of the bone, further from the heart.

Since

3.0.0

float width

The average width of the flesh around the bone in millimeters.

Since

3.0.0

LEAP_QUATERNION rotation

Rotation in world space from the forward direction.

Convert the quaternion to a matrix to derive the basis vectors.

Since

3.1.2

struct LEAP_DIGIT
#include <LeapC.h>

Describes the digit of a hand.

Digits are members of the LEAP_HAND struct.

Since

3.0.0

Public Members

int32_t finger_id

The Leap identifier of this finger.

Since

3.0.0

LEAP_BONE bones[4]

All the bones of a digit as an iterable collection.

Since

3.0.0

LEAP_BONE metacarpal

The finger bone wholly inside the hand.

For thumbs, this bone is set to have zero length and width, an identity basis matrix, and its joint positions are equal. Note that this is anatomically incorrect; in anatomical terms, the intermediate phalange is absent in a real thumb, rather than the metacarpal bone. In the Ultraleap Tracking model, however, we use a “zero” metacarpal bone instead for ease of programming.

Since

3.0.0

LEAP_BONE proximal

The phalange extending from the knuckle.

Since

3.0.0

LEAP_BONE intermediate

The bone between the proximal phalange and the distal phalange.

Since

3.0.0

LEAP_BONE distal

The distal phalange terminating at the finger tip.

Since

3.0.0

uint32_t is_extended

Reports whether the finger is more or less straight.

Since

3.0.0

struct LEAP_PALM
#include <LeapC.h>

Properties associated with the palm of the hand.

The Palm is a member of the LEAP_HAND struct.

Since

3.0.0

Public Members

LEAP_VECTOR position

The center position of the palm in millimeters from the Ultraleap Tracking camera device origin.

Since

3.0.0

LEAP_VECTOR stabilized_position

The time-filtered and stabilized position of the palm.

Smoothing and stabilization is performed in order to make this value more suitable for interaction with 2D content. The stabilized position lags behind the palm position by a variable amount, depending primarily on the speed of movement.

Since

3.0.0

LEAP_VECTOR velocity

The rate of change of the palm position in millimeters per second.

Since

3.0.0

LEAP_VECTOR normal

The normal vector to the palm.

If your hand is flat, this vector will point downward, or “out” of the front surface of your palm.

Since

3.0.0

float width

The estimated width of the palm when the hand is in a flat position.

Since

3.0.0

LEAP_VECTOR direction

The unit direction vector pointing from the palm position toward the fingers.

Since

3.0.0

LEAP_QUATERNION orientation

The quaternion representing the palm’s orientation corresponding to the basis {normal x direction, -normal, -direction}.

Since

3.1.3

struct LEAP_HAND
#include <LeapC.h>

Describes a tracked hand.

Since

3.0.0

Public Members

uint32_t id

A unique ID for a hand tracked across frames.

If tracking of a physical hand is lost, a new ID is assigned when tracking is reacquired.

Since

3.0.0

uint32_t flags

Reserved for future use.

Since

3.0.0

eLeapHandType type

Identifies the chirality of this hand.

Since

3.0.0

float confidence

How confident we are with a given hand pose.

Not currently used (always 1.0).

Since

3.0.0

uint64_t visible_time

The total amount of time this hand has been tracked, in microseconds.

Since

3.0.0

float pinch_distance

The distance between index finger and thumb.

Since

3.0.0

float grab_angle

The average angle of fingers to palm.

Since

3.0.0

float pinch_strength

The normalized estimate of the pinch pose.

Zero is not pinching; one is fully pinched.

Since

3.0.0

float grab_strength

The normalized estimate of the grab hand pose.

Zero is not grabbing; one is fully grabbing.

Since

3.0.0

LEAP_PALM palm

Additional information associated with the palm.

Since

3.0.0

LEAP_DIGIT thumb

The thumb.

Since

3.0.0

LEAP_DIGIT index

The index finger.

Since

3.0.0

LEAP_DIGIT middle

The middle finger.

Since

3.0.0

LEAP_DIGIT ring

The ring finger.

Since

3.0.0

LEAP_DIGIT pinky

The pinky finger.

Since

3.0.0

LEAP_DIGIT digits[5]

The fingers of the hand as an array.

Since

3.0.0

union LEAP_HAND::[anonymous] [anonymous]

The fingers of this hand.

Since

3.0.0

LEAP_BONE arm

The arm to which this hand is attached.

An arm consists of a single LEAP_BONE struct.

Since

3.0.0

struct LEAP_TRACKING_EVENT
#include <LeapC.h>

A snapshot, or frame of data, containing the tracking data for a single moment in time.

The LEAP_FRAME struct is the container for all the tracking data.

Since

3.0.0

Public Members

LEAP_FRAME_HEADER info

A universal frame identification header.

Since

3.0.0

int64_t tracking_frame_id

An identifier for this tracking frame.

This identifier is meant to be monotonically increasing, but values may be skipped if the client application does not poll for messages fast enough. This number also generally increases at the same rate as info.frame_id, but if the server cannot process every image received from the device cameras, the info.frame_id identifier may increase faster.

Since

3.0.0

uint32_t nHands

The number of hands tracked in this frame, i.e.

the number of elements in the pHands array.

Since

3.0.0

LEAP_HAND *pHands

A pointer to the array of hands tracked in this frame.

Since

3.0.0

float framerate

Current tracking frame rate in hertz.

This frame rate is distinct from the image frame rate, which is the rate that images are being read from the device. Depending on host CPU limitations, the tracking frame rate may be substantially less than the device frame rate.

This number is generally equal to or less than the device frame rate, but there is one case where this number may be higher than the device frame rate: When the device rate drops. In this case, the device frame rate will fall sooner than the tracking frame rate.

This number is equal to zero if there are not enough frames to estimate frame rate.

This number cannot be negative.

Since

3.0.0

struct LEAP_LOG_EVENT
#include <LeapC.h>

A system log message.

Since

3.0.0

Public Members

eLeapLogSeverity severity

The type of message.

Since

4.0.0

int64_t timestamp

The timestamp of the message in microseconds.

Compare with the current values of LeapGetNow() and the system clock to calculate the absolute time of the message.

Since

4.0.0

const char *message

A pointer to a null-terminated string containing the current log message.

Since

4.0.0

struct LEAP_DEVICE_STATUS_CHANGE_EVENT
#include <LeapC.h>

A notification that a device’s status has changed.

One of these messages is received by the client as soon as the service is connected, or when a new device is attached.

Since

3.1.3

Public Members

LEAP_DEVICE_REF device

A reference to the device whose status has changed.

uint32_t last_status

The last known status of the device.

This is a combination of eLeapDeviceStatus flags.

Since

3.1.3

uint32_t status

The current status of the device.

This is a combination of eLeapDeviceStatus flags.

Since

3.1.3

struct LEAP_IMAGE
#include <LeapC.h>

An image associated with a frame of data.

Since

4.0.0

Public Members

LEAP_IMAGE_PROPERTIES properties

The properties of the received image.

uint64_t matrix_version

A version number for the distortion matrix.

When the distortion matrix changes, this number is updated. This number is guaranteed not to repeat for the lifetime of the connection. This version number is also guaranteed to be distinct for each perspective of an image.

This value is guaranteed to be nonzero if it is valid.

The distortion matrix only changes when the streaming device changes or when the device orientation flips inverting the image and the distortion grid. Since building a matrix to undistort an image can be a time-consuming task, you can optimize the process by only rebuilding this matrix (or whatever data type you use to correct image distortion) when the grid actually changes.

LEAP_DISTORTION_MATRIX *distortion_matrix

Pointers to the camera’s distortion matrix.

void *data

A pointer to the image data.

uint32_t offset

Offset, in bytes, from the beginning of the data ptr to the actual beginning of the image data.

struct LEAP_IMAGE_EVENT
#include <LeapC.h>

Streaming stereo image pairs from the device.

LeapPollConnection() produces this message when an image is available. The struct contains image properties, the distortion grid, and a pointer to the buffer containing the image data which was allocated using the allocator function passed to LeapC using the LeapSetAllocator.

Since

4.0.0

Public Members

LEAP_FRAME_HEADER info

The information header identifying the images tracking frame.

LEAP_IMAGE image[2]

The left and right images.

LEAP_CALIBRATION calib

For internal use only.

struct LEAP_CONNECTION_MESSAGE
#include <LeapC.h>

Defines a basic message from the LeapC message queue.

Set by calling LeapPollConnection().

Since

3.0.0

Public Members

uint32_t size

The size of this message struct.

Since

3.0.0

eLeapEventType type

The message type.

Since

3.0.0

const void *pointer

An untyped pointer.

Since

3.0.0

const LEAP_CONNECTION_EVENT *connection_event

A connection message.

Since

3.0.0

const LEAP_CONNECTION_LOST_EVENT *connection_lost_event

A connection lost.

Since

3.0.0

const LEAP_DEVICE_EVENT *device_event

A device detected message.

Since

3.0.0

const LEAP_DEVICE_STATUS_CHANGE_EVENT *device_status_change_event

A device’s status has changed.

Since

3.1.3

const LEAP_POLICY_EVENT *policy_event

A policy message.

Since

3.0.0

const LEAP_DEVICE_FAILURE_EVENT *device_failure_event

A device failure message.

Since

3.0.0

const LEAP_TRACKING_EVENT *tracking_event

A tracking message.

Since

3.0.0

const LEAP_TRACKING_MODE_EVENT *tracking_mode_event

A tracking mode message.

Since

5.0.0

const LEAP_LOG_EVENT *log_event

A log message.

Since

3.0.0

const LEAP_LOG_EVENTS *log_events

A log messages.

Since

4.0.0

const LEAP_CONFIG_RESPONSE_EVENT *config_response_event

A get config value message.

Since

3.0.0

const LEAP_CONFIG_CHANGE_EVENT *config_change_event

A set config value message.

Since

3.0.0

const LEAP_IMAGE_EVENT *image_event

A streaming image message.

Since

4.0.0

const LEAP_POINT_MAPPING_CHANGE_EVENT *point_mapping_change_event

A point mapping message.

Since

4.0.0

const LEAP_HEAD_POSE_EVENT *head_pose_event

A head pose message.

Since

4.1.0

const LEAP_EYE_EVENT *eye_event

An eye positions message for both the left and right eyes.

Since

4.1.0

const LEAP_IMU_EVENT *imu_event

An IMU message.

Since

4.1.0

union LEAP_CONNECTION_MESSAGE::[anonymous] [anonymous]

A pointer to the event data for the current type of message.

Since

3.0.0

uint32_t device_id

A unique ID for the attached device that sent this message.

A value of 0 indicates that it was a system-wide message, and not device specific. Use this ID to distinguish messages sent from multiple attached devices.

Since

4.1.0

struct LEAP_RECORDING_PARAMETERS
#include <LeapC.h>

Read/Write mode for opening a LEAP_RECORDING.

since 3.2.0

Public Members

uint32_t mode

A combination of eLeapRecordingFlags indicating the desired operations.

Since

3.2.0

struct LEAP_RECORDING_STATUS
#include <LeapC.h>

Information about a current LEAP_RECORDING.

Filled in by a call to LeapRecordingGetStatus().

Since

3.2.0

Public Members

uint32_t mode

Some combination of eLeapRecordingFlags indicating the status of the recording.

Since

3.2.0

struct LEAP_VERSION
#include <LeapC.h>

Version information.

The members can be converted to a version string using the format:

major.minor.patch.build

Since

5.2.0

Public Members

int32_t major

The major version.

Since

5.2.0

int32_t minor

The minor version.

Since

5.2.0

int32_t patch

The patch version.

Since

5.2.0

struct LEAP_CONNECTION
#include <LeapC.h>

A handle to the Leap connection object.

Use this handle to specify the connection for an operation.

Since

3.0.0

struct LEAP_DEVICE
#include <LeapC.h>

A handle to a Leap device object.

Use this handle to specify the device for an operation.

Since

3.0.0

struct LEAP_CLOCK_REBASER
#include <LeapC.h>

An opaque clock rebase state structure.

Since

3.1.2