id3 Devices API¶
id3 Finger SDK provides an easy to use programming interface available in various languages.
It consists of several components providing easy access to advanced biometric functionalities.
It includes:
Classes¶
Augments DeviceChannel with functionalities for capturing data from devices, including state monitoring and data retrieval mechanisms.
|
|
Expands upon DeviceChannel to focus on camera data capture, including live feed management and snapshot functionalities, alongside maintaining a list of supported video formats.
|
|
This class is designed to encapsulate the entirety of data captured by a device, ranging from multimedia streams to sensor data.
It not only stores the raw data but also maintains metadata like the number of frames captured and precise timestamps, thereby offering a comprehensive view of the capture context.
Its design is geared towards ensuring ease of data manipulation and accessibility, supporting a wide range of applications from video processing to data logging and analysis.
|
|
Represent images captured by devices, incorporating metadata like the total number of frames captured and the timestamp of the capture.
This class is pivotal for applications that process or analyze sequences of images over time, requiring context on the timing and sequence of captures.
|
|
(C++) Provides functionality for tracking and calculating the bandwidth and data transfer rates of a system or application component.
Intended for use in performance analysis, this class allows for detailed monitoring of data throughput over time.
|
|
(C++) Calculates the moving average of data points to provide a smoothed analysis of data trends over time, specifically designed for use in C++ environments.
|
|
Virtual class representing a channel of a device, facilitating the handling of device events, execution of commands, and management of device parameters and filters.
|
|
Manages a collection of device channel configurations, encapsulating a list of DeviceChannel objects.
This class facilitates operations on groups of channels, such as enumeration, searching, and manipulation, making it easier to handle complex device configurations that involve multiple channels.
It extends generic list functionalities specifically for DeviceChannel objects, providing a tailored interface for channel management.
|
|
Represents a device.
|
|
Represents a device info list.
|
|
Central management entity for devices, facilitating plug-and-play functionality, device tracking, and interaction through a unified interface.
|
|
Defines a specific model of a device, including its identifiable name and a descriptive summary of its capabilities or features
Additionally, it incorporates a callback function for handling device-specific commands, enabling responsive and adaptable device operations within software applications.
|
|
A container that holds a series of DeviceModel objects, providing a structured way to handle multiple device models
This list enables applications to manage a diverse range of device models, supporting functionalities like device discovery, categorization, and selection based on model-specific characteristics.
|
|
Centralizes information related to a single device parameter, including its name, type, value, and mode of operation (automatic or manual).
It serves as a flexible structure for representing device configurations, enabling applications to interact with and manipulate device settings in a consistent and type-safe manner.
|
|
Enhances the basic DeviceParameter with additional details that describe the parameter’s expected behavior, allowable values, and how it interacts with the device’s capabilities.
It’s designed to provide a full specification for a device parameter, aiding in both validation and UI generation for device configuration.
|
|
Designed to hold and manage a collection of DeviceParameter objects, this class allows for the aggregation, manipulation, and query of device parameters.
It supports operations beyond simple list management, including the ability to find parameters based on specific criteria such as integer values, thereby facilitating efficient parameter management in complex device configurations.
|
|
Serves as a dynamic container for a range of device_type entities, enabling efficient organization, search, and management of different device types
It leverages list-based functionalities to offer a flexible and scalable means of cataloging device types, essential for applications that interact with multiple kinds of devices or require device type differentiation for operational purposes.
|
|
Specializes in parsing strings in JSON format and generating JSON strings from its contents, serving as a utility for JSON data handling.
|
|
Initialises the SDK library.
|
|
Handles the license to use this SDK.
|
|
Enhances Camera with functionalities for detailed stream management, supporting operations to query available streams, control stream states, and access live framesets.
|
|
Manages a set of frames captured from a device, incorporating mechanisms for command execution, frame retrieval, processing, and option management.
|
|
Represents an image buffer.
|
|
Manages a collection of measurement data, allowing for the storage and retrieval of measurements in various data types.
This class supports operations to set and get measurement values, facilitating the handling of diverse measurement metrics within applications.
|
|
Encapsulates metadata and operational details about a plugin, including its name, version, and capabilities.
|
|
Manages a collection of plugin_info objects, facilitating operations like addition, removal, and enumeration of plugins within an application.
|
|
Represents a point list.
|
|
Extends ‘DeviceChannel’ to to provide specialized functionalities for handling signature pads.
This class manages the state and operations specific to signature capture devices, enabling the initiation and termination of capture processes, handling callbacks for various events, and retrieving capture data.
|
|
A utility class for managing dynamic strings, allowing for the storage, manipulation, and retrieval of string data.
It serves as a wrapper around traditional string types, offering additional control over string operations and memory management.
|
|
Facilitates the management of collections of strings, enabling operations such as adding strings to the list.
It acts as a dynamic array of strings, offering functionality that extends beyond basic array operations by allowing for specific manipulations of string collections.
|
|
(C++) Represents a thread command in C/C++ environments, equipped with callback mechanisms for worker, command, and process operations, alongside methods for detailed thread management.
|
|
Provides functionality for handling video files and streams.
It extends DeviceChannel to support operations like loading files, streaming, and managing playback.
|
|
Defines a specific video format, including its resolution, frame rate, internal representation, and codec
This class is essential for applications that interact with video capturing devices, as it allows for the precise specification and selection of video formats based on the device’s capabilities and the application’s requirements.
|
|
Manages a list of video_format objects, allowing applications to query and select from the available video formats offered by a device
This class supports operations to find the video format that best matches desired specifications, facilitating optimal video capture and playback configurations.
|
Enumerations¶
Details the various statuses a device can be in, especially in relation to capture processes, aligning closely with the general operational states defined in device_state.
|
|
Categorizes the operational states of a device, reflecting its readiness, activity, and any error conditions.
|
|
Defines a set of possible types of devices that can be managed by the system, facilitating type-specific operations and interactions.
|
|
Defines a range of error codes that the SDK might return during its operation
These codes help identify specific errors that occur within the SDK’s scope, facilitating debugging and error handling.
|
|
Enumerates possible error codes related to image management.
|
|
Enumerates supported image formats.
|
|
Enumerates the error codes related to license management.
|
|
Enumerates the types of hardware codes.
|
|
Enumerates the license types.
|
|
Defines a set of flags representing the various capabilities and properties of device parameters, allowing for detailed parameter configuration and control.
|
|
Defines the variety of data types that a parameter can represent, providing a framework for parameter value specification and validation within the system.
|
|
Enumerates supported pixel formats.
|
|
The play_mode enumeration defines the different states of video playback.
This is used to manage and represent the current playback state of a video file or stream.
|
|
Defines the lifecycle states of a thread’s process, from initiation through active operation to cessation.
|
Structures¶
Specifies the permissible range of values for a device parameter, including the minimum, maximum, and step increment.
|
|
Defines the versioning scheme for the library, using semantic versioning to detail major, minor, and build identifiers.
|
|
Represents a point.
|
|
Represents a rectangle.
|
|
(C++) Encapsulates data related to a command being executed by a thread, including command identifiers and parameters.
|
Callbacks¶
Callback invoked during capture operations, for both ongoing captures and snapshots.
|
|
Specifies a callback for handling changes in the capture status of a device, including errors.
|
|
(C++) Callback for executing commands directly on a device, facilitating device control.
|
|
(C++) Facilitates callbacks related to generic device events, supporting broad event handling.
|
|
(C++) Callback for sending commands to a device model, typically used within device plugins.
|
|
Defines a callback for when a device is selected or unselected within a channel.
|
|
(C++,dotnet) Handles callbacks for frameset operations, suitable for video or image capture devices.
|
|
Defines a callback for handling plug-and-play events, such as device connection or disconnection.
|
|
(C++) Callback for processing individual commands within a thread, supporting complex thread-based operations.
|
|
(C++) Designates the main callback for thread processing, handling specific thread states.
|
|
(C++) Represents the primary function executed by a worker thread, encapsulating thread logic.
|
Exceptions¶
This exception is thrown when an error occurs in the id3 Devices library. |