IDS peak API Documentation

https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/
Admin
IDS peak is an API for controlling IDS imaging devices, providing functionalities for device...
Tokens:904,977
Snippets:4,617
Trust Score:8.8
Update:8 months ago
Show doc for...
Tokens:
Raw
### StartAcquisition

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/classpeak_1_1core_1_1_data_stream

Starts the acquisition engine on the host side. The acquisition on the remote device needs to be started separately.

```APIDOC
## StartAcquisition()

### Description
Starts the acquisition. Starts the acquisition engine on the host side. The acquisition on the remote device needs to be started separately using the "AcquisitionStart" command node.

The acquisition engine depends on the payload size value not changing between announcing the buffers to the data stream and while the acquisition is running. For information on how to ensure this can't happen, see AnnounceBuffer.

### Method
`void`

### Endpoint
`peak::core::DataStream::StartAcquisition`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **_mode** (`AcquisitionStartMode`) - Optional (default: `AcquisitionStartMode::Default`) - The mode being used to start the acquisition.
- **_numToAcquire** (`uint64_t`) - Optional (default: `INFINITE_NUMBER`) - The number of buffers to acquire.

### Request Example
```json
{
  "_mode": "AcquisitionStartMode::Default",
  "_numToAcquire": 1000
}
```

### Response
#### Success Response (void)
No explicit return value.

#### Response Example
N/A

### Exceptions
- **BadAccessException**: The acquisition is already running.
- **InternalErrorException**: An internal error has occurred.
```

--------------------------------

### BufferPartTo Example Usage

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/group__ids__peak__acquisition

Demonstrates how to use the `peak::BufferPartTo` function to convert a `peak::core::BufferPart` into a custom image type. This example highlights the template-based nature of the conversion.

```cpp
auto image = peak::BufferPartTo<CustomImageType>(bufferPart);
```

--------------------------------

### Start Acquisition and Wait for Buffer (C++)

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/classpeak_1_1core_1_1_data_stream

Demonstrates how to start data acquisition using StartAcquisition and then wait for a new buffer to become available using WaitForFinishedBuffer. This is a common workflow for receiving data frames from a device.

```C++
stream->StartAcquisition(peak::core::AcquisitionStartMode::Default);
remoteDevice->NodeMaps()[0]->FindNode<peak::core::nodes::CommandNode>("AcquisitionStart")->Execute();
remoteDevice->NodeMaps()[0]->FindNode<peak::core::nodes::CommandNode>("AcquisitionStart")->WaitUntilDone();

// Wait for a new buffer to be available
std::shared_ptr<Buffer> buffer = stream->WaitForFinishedBuffer();
```

--------------------------------

### Get Module Information - C++

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/classpeak_1_1core_1_1_port_u_r_l

Delivers information based on a given GenTL info command. This function allows querying extended information beyond predefined functions. It requires a GenTL info command as input and returns RawInformation. Error handling is omitted in the example. It may throw an InternalErrorException.

```cpp
#include <peak/thirdparty/GenTL.h>

auto info = object->Info(GenTL::XX_INFO_XX);
// Cast depending on the delivered data type
if (info.dataType == GenTL::INFO_DATATYPE_UINT64)
{
    uint64_t uint64Var = *reinterpret_cast<const uint64_t*>(info.data.data());
    // Do something with the information
}
else if (infoDataTypeVar == GenTL::INFO_DATATYPE_INT64)
{
    // ...
}
```

--------------------------------

### Get Started Buffers Count (C++)

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/peak__data__stream_8hpp_source

NumBuffersStarted() returns the count of buffers that have been started. It employs QueryNumericFromCInterfaceFunction to call PEAK_DataStream_GetNumBuffersStarted.

```cpp
inline uint64_t DataStream::NumBuffersStarted() const
{
 return QueryNumericFromCInterfaceFunction<uint64_t>([&](uint64_t* numBuffersStarted) {
 return PEAK_C_ABI_PREFIX PEAK_DataStream_GetNumBuffersStarted(m_backendHandle, numBuffersStarted);
 });
}
```

--------------------------------

### Get Started Buffer Count (C)

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/classpeak_1_1dynamic_1_1_dynamic_loader

Returns the number of buffers that have been started for acquisition by the data stream. This indicates the progress of data acquisition. It requires a data stream handle and outputs the count of started buffers.

```c
static PEAK_RETURN_CODE | PEAK_DataStream_GetNumBuffersStarted (PEAK_DATA_STREAM_HANDLE dataStreamHandle, uint64_t *numBuffersStarted)
```

--------------------------------

### Open Device with Automatic Resource Release (RAII)

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/index

Demonstrates opening a device using a descriptor and leveraging RAII (Resource Acquisition Is Initialization) for automatic resource management. The device is automatically closed when the smart pointer goes out of scope.

```c++
{
auto device = deviceDescriptors.at(0)->OpenDevice(peak::core::DeviceAccessType::Control);
// ...
} // Device closes here
```

```csharp
using (var device = deviceManager.Devices()[0].OpenDevice(peak.core.DeviceAccessType.Control))
{
// ...
} // Device closes here
```

```python
device = device_manager.Devices()[0].OpenDevice(ids_peak.DeviceAccessType_Control)
# ...
# Device closes when variable is destroyed
```

--------------------------------

### Get Number of Started Buffers (C++)

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/namespacepeak_1_1dynamic

Retrieves the count of buffers that have been started for processing or transfer by the data stream. This indicates active buffer usage. It takes the data stream handle and a pointer for the count. Returns a status code.

```C++
typedef PEAK_RETURN_CODE(* peak::dynamic::dyn_PEAK_DataStream_GetNumBuffersStarted) (PEAK_DATA_STREAM_HANDLE dataStreamHandle, uint64_t *numBuffersStarted)
```

--------------------------------

### Get User Defined Name

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/classpeak_1_1core_1_1_device

Retrieves the user-defined name assigned to the device. This allows for custom naming and easier identification in complex setups.

```cpp
std::string userDefinedName = device->UserDefinedName();
```

--------------------------------

### OpenSystem()

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/classpeak_1_1core_1_1_system_descriptor

Opens the system associated with this SystemDescriptor.

```APIDOC
## POST /system/descriptor/open_system

### Description
Opens the system.

### Method
POST

### Endpoint
/system/descriptor/open_system

### Parameters
#### Query Parameters
None

### Request Example
```
POST /system/descriptor/open_system
```

### Response
#### Success Response (200)
- **openedSystem** (shared_ptr<System>) - A shared pointer to the opened System object.

#### Response Example
```json
{
  "openedSystem": "<pointer_representation>"
}
```

### Exceptions
- **BadAccessException**: Access denied.
- **InternalErrorException**: An internal error has occurred.
```

--------------------------------

### Get Buffer Image Offset - C++

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/classpeak_1_1dynamic_1_1_dynamic_loader-members

Retrieves the starting offset of the image data within the buffer. Requires a valid PEAK_BUFFER_HANDLE. The offset is stored in a size_t pointer.

```cpp
PEAK_Buffer_GetImageOffset(PEAK_BUFFER_HANDLE bufferHandle, size_t *imageOffset);
```

--------------------------------

### Version()

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/classpeak_1_1core_1_1_system_descriptor

Retrieves the version of the system.

```APIDOC
## GET /system/descriptor/version

### Description
Returns the version.

### Method
GET

### Endpoint
/system/descriptor/version

### Parameters
#### Query Parameters
None

### Request Example
```
GET /system/descriptor/version
```

### Response
#### Success Response (200)
- **version** (string) - The version of the system.

#### Response Example
```json
{
  "version": "1.0.0"
}
```

### Exceptions
- **InternalErrorException**: An internal error has occurred.
```

--------------------------------

### Get Number of Started Buffers (C++)

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/peak__data__stream_8hpp_source

Returns the count of buffers that have been initiated for processing. This const method of the DataStream class returns a 64-bit unsigned integer.

```C++
uint64_t NumBuffersStarted() const
```

--------------------------------

### Import Pipeline Settings from File (C++)

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/classpeak_1_1pipeline_1_1_pipeline_base

Loads pipeline and module settings from a specified file. The function reads the file content and uses ImportSettingsFromString() to restore the pipeline's state.

```cpp
void peak::pipeline::PipelineBase::ImportSettingsFromFile(const std::string& _filePath_)
```

--------------------------------

### Get Minimum Required Announced Buffers (C++)

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/peak__data__stream_8hpp_source

Returns the minimum number of buffers that must be announced before starting the acquisition. This const method of the DataStream class returns a size_t.

```C++
size_t NumBuffersAnnouncedMinRequired() const
```

--------------------------------

### Utility Classes

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/namespaces

Documentation for utility classes such as `CFileAdapter`, `CMetadata`, and `CVersion`.

```APIDOC
## Utility Classes

### Description
Provides documentation for various utility classes within the IDS Peak library.

### Classes
- **`CFileAdapter`**: A utility class for accessing files stored in a RemoteDevice's persistent memory.
- **`CMetadata`**: A type-safe container for image acquisition metadata.
- **`CPixelFormatInfo`**: Provides information and utility functions for pixel formats.
- **`CVersion`**: Represents a structured version identifier with four components: major, minor, subminor, and patch.

### Usage
These classes offer helpful functionalities for file access, metadata management, pixel format information, and version handling.
```

--------------------------------

### Get Buffer Chunk Base Pointer (C)

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/peak__buffer__chunk_8hpp_source

Asks the given buffer chunk for its base pointer. This C API function returns the starting memory address of the buffer chunk.

```c
PEAK_C_API PEAK_BufferChunk_GetBasePtr(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle, void **basePtr);
```

--------------------------------

### Buffer and Persistence Management

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/functions_func_u

This section covers methods related to buffer user pointers and firmware update persistence settings.

```APIDOC
## UserPtr()

### Description
Retrieves the user pointer associated with a buffer.

### Method
GET

### Endpoint
`/buffers/{bufferId}/user-ptr`

### Parameters
#### Path Parameters
- **bufferId** (string) - Required - The unique identifier of the buffer.

### Response
#### Success Response (200)
- **userPtr** (string) - The user pointer of the buffer.

#### Response Example
```json
{
  "userPtr": "0x12345678"
}
```

## UserSetPersistence()

### Description
Sets the persistence mode for a firmware update.

### Method
PUT

### Endpoint
`/firmware/update/persistence`

### Parameters
#### Request Body
- **updateInformationId** (string) - Required - The ID of the firmware update information.
- **persistenceMode** (string) - Required - The desired persistence mode (e.g., 'persistent', 'non-persistent').

### Response
#### Success Response (200)
- **status** (string) - Indicates the success of setting the persistence mode.

#### Response Example
```json
{
  "status": "persistence_set"
}
```
```

--------------------------------

### Get Number of Delivered Buffers (C++)

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/peak__data__stream_8hpp_source

Retrieves the count of buffers delivered since the last acquisition start. This is a const method of the DataStream class, returning a 64-bit unsigned integer.

```C++
uint64_t NumBuffersDelivered() const
```

--------------------------------

### Version Constructor

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/classpeak_1_1common_1_1_version

Initializes a new Version object with specified major, minor, subminor, and patch components.

```APIDOC
## Constructor & Destructor Documentation
## ◆ Version()
| peak::common::Version::Version  | ( | uint32_t | _major_ ,   
---|---|---|---
|  | uint32_t | _minor_ ,   
|  | uint32_t | _subminor_ ,   
|  | uint32_t | _patch_ )  
inline
```

--------------------------------

### Get Buffer Y Offset - C

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/classpeak_1_1dynamic_1_1_dynamic_loader

Retrieves the vertical offset of the image data within the buffer. This is useful for handling images that are not aligned to the start of the buffer. It takes a buffer handle and a pointer to a size_t.

```c
static PEAK_RETURN_CODE | PEAK_Buffer_GetYOffset (PEAK_BUFFER_HANDLE bufferHandle, size_t *yOffset)
```

--------------------------------

### Get Image Data Offset (C++)

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/classpeak_1_1core_1_1_buffer

The ImageOffset() method returns the offset in bytes from the beginning of the buffer to the start of the image data. This const method is part of the peak::core::Buffer class and was introduced in version 1.0.

```cpp
size_t peak::core::Buffer::ImageOffset() const;
```

--------------------------------

### File Members - ACQ_START_FLAGS

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/globals

Documentation for the ACQ_START_FLAGS enumeration constant found in GenTL_v1_5.h.

```APIDOC
## Enumeration Constant: ACQ_START_FLAGS

### Description
Defines flags for starting an acquisition.

### Method
N/A

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
#### Success Response (200)
- **ACQ_START_FLAGS** (Enumeration Constant) - Represents the flags used to control the start of an acquisition.
```

--------------------------------

### Initialize and List Devices

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/csharp_dotnet

Demonstrates how to initialize the IDS peak genericAPI library and list all available devices using the DeviceManager singleton.

```APIDOC
## Initialize and List Devices

### Description
Initializes the IDS peak genericAPI library and retrieves a list of all available devices. The DeviceManager, implemented as a singleton, is used to discover and manage these devices.

### Method
```csharp
static void Initialize()
static DeviceManager Instance()
void Update()
DeviceDescriptor[] Devices()
```

### Endpoint
N/A (This is a library usage example)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```csharp
using peak;

try
{
    Library.Initialize();
    var deviceManager = DeviceManager.Instance();
    deviceManager.Update();
    var deviceDescriptors = deviceManager.Devices();
    foreach (var deviceDescriptor in deviceDescriptors)
    {
        Console.WriteLine(deviceDescriptor.DisplayName());
    }
}
catch (System.ApplicationException e)
{
    Console.WriteLine("Exception: " + e.Message);
}
```

### Response
#### Success Response (200)
Prints the display names of all detected devices to the console.

#### Response Example
```
Device 1 Name
Device 2 Name
```

### Warning
Avoid using `using` statements with `DeviceManager.Instance()` as it is a singleton and disposing it prematurely will lead to application crashes.
```

--------------------------------

### Get Buffer X Offset - C

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/classpeak_1_1dynamic_1_1_dynamic_loader

Retrieves the horizontal offset of the image data within the buffer. This is useful for handling images that are not aligned to the start of the buffer. It takes a buffer handle and a pointer to a size_t.

```c
static PEAK_RETURN_CODE | PEAK_Buffer_GetXOffset (PEAK_BUFFER_HANDLE bufferHandle, size_t *xOffset)
```

--------------------------------

### Get Event Information

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/classpeak_1_1core_1_1_event_controller

The Info function retrieves information based on a provided GenTL info command. It returns RawInformation and may throw InternalErrorException. An example demonstrates casting the returned data based on its dataType.

```cpp
#include <peak/thirdparty/GenTL.h>

RawInformation info = object->Info(GenTL::XX_INFO_XX);
if (info.dataType == GenTL::INFO_DATATYPE_UINT64) {
    uint64_t uint64Var = *reinterpret_cast<const uint64_t*>(info.data.data());
    // Process uint64Var
}
// Exception: InternalErrorException
```

--------------------------------

### IsOpened()

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/classpeak_1_1core_1_1_system_descriptor

Checks if the system is currently opened.

```APIDOC
## GET /system/descriptor/is_opened

### Description
Returns if the system is currently opened or not.

### Method
GET

### Endpoint
/system/descriptor/is_opened

### Parameters
#### Query Parameters
None

### Request Example
```
GET /system/descriptor/is_opened
```

### Response
#### Success Response (200)
- **isOpened** (boolean) - true if the system is open, false otherwise.

#### Response Example
```json
{
  "isOpened": true
}
```
```

--------------------------------

### File Members - ACQ_QUEUE_INPUT_TO_OUTPUT

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/globals

Documentation for the ACQ_QUEUE_INPUT_TO_OUTPUT enumeration constant found in GenTL_v1_5.h.

```APIDOC
## Enumeration Constant: ACQ_QUEUE_INPUT_TO_OUTPUT

### Description
Represents a queue type for acquiring data, moving items from input to output.

### Method
N/A

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
#### Success Response (200)
- **ACQ_QUEUE_INPUT_TO_OUTPUT** (Enumeration Constant) - Represents the queue type for moving acquired data from input to output.
```

--------------------------------

### Get Base Pointer of BufferChunk - C++

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/classpeak_1_1core_1_1_buffer_chunk

Retrieves the base memory address of the buffer chunk. This function is inline and returns a void pointer to the start of the buffer data. It requires no arguments and is available since API version 1.0.

```cpp
void * peak::core::BufferChunk::BasePtr() const;
```

--------------------------------

### Open System

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/classpeak_1_1core_1_1_system_descriptor

Opens the GenTL system module associated with the SystemDescriptor.

```APIDOC
## POST /system/open

### Description
Opens the GenTL system module. This action allows for further interaction with the system, such as acquiring images.

### Method
POST

### Endpoint
/system/open

### Parameters
#### Request Body
(No request body parameters are specified for this operation, it operates on the context of the SystemDescriptor)

### Response
#### Success Response (200)
- **system** (std::shared_ptr< System >) - A shared pointer to the opened System object, enabling further system operations.

#### Response Example
(The response would typically be an acknowledgement or a representation of the opened system, specific details depend on the API implementation)
```json
{
  "message": "System opened successfully."
}
```

### Error Handling
- **InternalErrorException**: An internal error has occurred during the system opening process.
```

--------------------------------

### Core Initialization and Opening Functions

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/functions_o

This section details the functions used to initialize and open various components of the IDS Peak system, including the producer library, data streams, devices, interfaces, and the system itself.

```APIDOC
## Core Initialization and Opening Functions

### Description
These functions are essential for establishing connections and accessing resources within the IDS Peak framework. They allow for the initialization of the producer library, opening data streams, devices, interfaces, and the overall system.

### Methods

- **Open()**
  - **Description**: Initializes the peak::core::ProducerLibrary.
  - **Method**: (Assumed to be a constructor or initialization method)
  - **Endpoint**: N/A

- **OpenDataStream()**
  - **Description**: Opens a data stream, returning a peak::core::DataStreamDescriptor.
  - **Method**: (Assumed to be a method)
  - **Endpoint**: N/A

- **OpenDevice()**
  - **Description**: Opens a device, returning a peak::core::DeviceDescriptor.
  - **Method**: (Assumed to be a method)
  - **Endpoint**: N/A

- **OpenedDataStream()**
  - **Description**: Retrieves a descriptor for an already opened data stream (peak::core::DataStreamDescriptor).
  - **Method**: (Assumed to be a getter method)
  - **Endpoint**: N/A

- **OpenedDevice()**
  - **Description**: Retrieves a descriptor for an already opened device (peak::core::DeviceDescriptor).
  - **Method**: (Assumed to be a getter method)
  - **Endpoint**: N/A

- **OpenInterface()**
  - **Description**: Opens an interface, returning a peak::core::InterfaceDescriptor.
  - **Method**: (Assumed to be a method)
  - **Endpoint**: N/A

- **OpenedInterface()**
  - **Description**: Retrieves a descriptor for an already opened interface (peak::core::InterfaceDescriptor).
  - **Method**: (Assumed to be a getter method)
  - **Endpoint**: N/A

- **OpenSystem()**
  - **Description**: Opens the system, returning a peak::core::SystemDescriptor.
  - **Method**: (Assumed to be a method)
  - **Endpoint**: N/A

- **OpenedSystem()**
  - **Description**: Retrieves a descriptor for an already opened system (peak::core::SystemDescriptor).
  - **Method**: (Assumed to be a getter method)
  - **Endpoint**: N/A

### Parameters
(Specific parameters for these methods are not detailed in the provided text, but would typically include device IDs, stream configurations, etc.)

### Request Example
(Not applicable for these initialization/opening functions as they are likely direct method calls within the SDK.)

### Response

#### Success Response
- **Return Value**: Varies based on the function, returning specific descriptor types (e.g., `peak::core::DataStreamDescriptor`, `peak::core::DeviceDescriptor`, `peak::core::InterfaceDescriptor`, `peak::core::SystemDescriptor`) or the `peak::core::ProducerLibrary` object.

#### Response Example
(Not applicable, as these are SDK method calls returning objects or descriptors.)
```

--------------------------------

### Install IDS peak Python Package

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/python

Installs the 'ids_peak' package from PyPI using pip. Requires pip version 20.3 or greater on Linux for Python wheel support. For offline installations, download the .whl file and install it using 'pip install <Path-To-Python-Wheel>'.

```bash
pip install ids_peak
```

--------------------------------

### File Members - ACQ_START_FLAGS_LIST

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/globals

Documentation for the ACQ_START_FLAGS_LIST enumeration constant found in GenTL_v1_5.h.

```APIDOC
## Enumeration Constant: ACQ_START_FLAGS_LIST

### Description
Represents a list of available start flags for an acquisition.

### Method
N/A

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
#### Success Response (200)
- **ACQ_START_FLAGS_LIST** (Enumeration Constant) - Represents a list containing various acquisition start flags.
```

--------------------------------

### Start Acquisition (C)

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/_gen_t_l__v1__5_8h_source

Starts the image acquisition process for a data stream. It accepts start flags and an optional number of images to acquire.

```c
GC_API DSStartAcquisition(DS_HANDLE hDataStream, ACQ_START_FLAGS iStartFlags, uint64_t iNumToAcquire)
```

--------------------------------

### Buffer Management: Queue Buffer (C++)

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/classpeak_1_1core_1_1_data_stream

Illustrates how to queue a buffer using QueueBuffer. After a buffer has been announced, this function moves it to the 'Input Buffer Pool', making it available for the device to fill with data.

```C++
dataStream->QueueBuffer(announcedBuffer);
```

--------------------------------

### Acquisition Start Flags (C++)

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/_gen_t_l__v1__5_8h_source

Defines flags for controlling the start of the acquisition engine. Currently, only a default behavior is specified, with a provision for custom start flags.

```c++
#define ACQ_START_FLAGS_DEFAULT 0
#define ACQ_START_FLAGS_CUSTOM_ID 1000
```

--------------------------------

### File Members - ACQ_QUEUE_ALL_TO_INPUT

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/globals

Documentation for the ACQ_QUEUE_ALL_TO_INPUT enumeration constant found in GenTL_v1_5.h.

```APIDOC
## Enumeration Constant: ACQ_QUEUE_ALL_TO_INPUT

### Description
Represents a queue type for acquiring data, moving all items to the input queue.

### Method
N/A

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
#### Success Response (200)
- **ACQ_QUEUE_ALL_TO_INPUT** (Enumeration Constant) - Represents the queue type for moving all acquired data to the input queue.
```

--------------------------------

### Node Configuration and Metadata Access (C++)

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/classpeak_1_1core_1_1nodes_1_1_boolean_node

Provides methods for retrieving advanced node configuration and metadata. CachingMode() returns the node's caching strategy, while PollingTime() indicates its update frequency. ToolTip() and Description() offer user-facing information, and Type() returns the node's specific type identifier. ParentNodeMap() returns a reference to the node's containing map.

```C++
NodeCachingMode CachingMode () const
// Returns the caching mode.

int64_t PollingTime () const
// Returns the polling time.

std::string ToolTip () const
// Returns the tool tip.

std::string Description () const
// Returns the description.

NodeType Type () const
// Returns the type.

std::shared_ptr< NodeMap > ParentNodeMap () const
// Returns the parent node map.
```

--------------------------------

### Start Data Stream Acquisition (C)

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/_gen_t_l__v1__5_8h

Starts the acquisition process for a data stream. Requires a data stream handle, flags to control acquisition start, and the number of images to acquire.

```c
GC_API DSStartAcquisition(
    DS_HANDLE _hDataStream_,
    ACQ_START_FLAGS _iStartFlags_,
    uint64_t _iNumToAcquire_
);
```

--------------------------------

### Acquisition Start Flags

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/_gen_t_l__v1__5_8h_source

Defines flags to control the starting behavior of the acquisition engine.

```APIDOC
## Acquisition Start Flags

### Description
Enumeration defining special start flags for the acquisition engine when using `DSStartAcquisition`.

### Method
POST (Implied, as these are flags for an action)

### Endpoint
N/A (These are flags used in API calls)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```json
{
  "command": "DSStartAcquisition",
  "flags": "ACQ_START_FLAGS_DEFAULT"
}
```

### Response
#### Success Response (200)
Indicates successful execution of the start command.

#### Response Example
```json
{
  "status": "success"
}
```

### Flags
- **ACQ_START_FLAGS_DEFAULT**: Default behavior for starting acquisition.
- **ACQ_START_FLAGS_CUSTOM_ID**: Starting value for GenTL Producer custom IDs.
```

--------------------------------

### Buffer Management: Allocate and Announce (C++)

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/classpeak_1_1core_1_1_data_stream

Shows how to allocate and announce a buffer using AllocAndAnnounceBuffer. This method allocates memory for the buffer and adds it to the 'Announced Buffer Pool'. The buffer size must match the 'PayloadSize' node, and it's recommended to lock parameters during acquisition.

```C++
size_t bufferSize = dataStream->＇PayloadSize＇(); // Assuming PayloadSize is accessible
void* userPtr = nullptr; // Optional user data pointer
std::shared_ptr<Buffer> announcedBuffer = dataStream->AllocAndAnnounceBuffer(bufferSize, userPtr);
```

--------------------------------

### Start Infinite Acquisition (C)

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/classpeak_1_1dynamic_1_1_dynamic_loader

Starts data acquisition indefinitely for the data stream. This is typically used for continuous data capture. It requires the data stream handle and a start mode parameter.

```c
static PEAK_RETURN_CODE | PEAK_DataStream_StartAcquisitionInfinite (PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_ACQUISITION_START_MODE startMode)
```

--------------------------------

### Import Pipeline Settings from File (C++)

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/classpeak_1_1pipeline_1_1_i_pipeline

Loads and applies pipeline and module settings from a specified file. This function allows for the restoration of previously saved pipeline states. It requires the path to the settings file as an argument.

```cpp
virtual void peak::pipeline::IPipeline::ImportSettingsFromFile(const std::string& _filePath_) = 0;
```

--------------------------------

### Start Acquisition with Count (C)

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/classpeak_1_1dynamic_1_1_dynamic_loader

Starts data acquisition for a specified number of images or buffers. This function allows for controlled acquisition. It requires the data stream handle, a start mode, and the number of acquisitions.

```c
static PEAK_RETURN_CODE | PEAK_DataStream_StartAcquisition (PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_ACQUISITION_START_MODE startMode, uint64_t numToAcquire)
```

--------------------------------

### Import Pipeline Settings from String (C++)

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/classpeak_1_1pipeline_1_1_i_pipeline

Loads and applies pipeline and module settings from a provided string. This is useful for dynamic configuration or when settings are received in a serialized format. The string should contain the serialized pipeline configuration.

```cpp
virtual void peak::pipeline::IPipeline::ImportSettingsFromString(const std::string& _settings_) = 0;
```

--------------------------------

### Acquisition Start Mode Enumeration

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/namespacepeak_1_1core

Specifies the possible acquisition start modes for DataStream::StartAcquisition().

```APIDOC
## Enumeration: AcquisitionStartMode

### Description
The enum holding the possible acquisition start modes, for DataStream::StartAcquisition().

### Values
- **Default**
- **Custom** (1000)
```

--------------------------------

### Register Firmware Update Callbacks (C++)

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/peak__dynamic__loader_8h

Allows registration of callback functions for different stages of the firmware update process. This includes callbacks for when a step finishes, when the entire update is finished, or when the update fails. It requires a handle to the firmware update progress observer and a context pointer for the callback.

```cpp
typedef PEAK_RETURN_CODE(* | peak::dynamic::dyn_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepFinishedCallback) (PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_STEP_FINISHED_CALLBACK callback, void *callbackContext, PEAK_FIRMWARE_UPDATE_STEP_FINISHED_CALLBACK_HANDLE *callbackHandle);
typedef PEAK_RETURN_CODE(* | peak::dynamic::dyn_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateFinishedCallback) (PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_FINISHED_CALLBACK callback, void *callbackContext, PEAK_FIRMWARE_UPDATE_FINISHED_CALLBACK_HANDLE *callbackHandle);
typedef PEAK_RETURN_CODE(* | peak::dynamic::dyn_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateFailedCallback) (PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_FAILED_CALLBACK callback, void *callbackContext, PEAK_FIRMWARE_UPDATE_FAILED_CALLBACK_HANDLE *callbackHandle);
```

--------------------------------

### Get Device Stream and Remote Device Information (C API)

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/peak__backend_8h_source

Functions to retrieve information about data streams associated with a device and to get a handle to a remote device. This includes getting the number of data streams and accessing individual data stream descriptors.

```c
PEAK_C_API PEAK_Device_GetNumDataStreams(PEAK_DEVICE_HANDLE deviceHandle, size_t* numDataStreams);

PEAK_C_API PEAK_Device_GetDataStream(PEAK_DEVICE_HANDLE deviceHandle, size_t index,
    PEAK_DATA_STREAM_DESCRIPTOR_HANDLE* dataStreamDescriptorHandle
);

PEAK_C_API PEAK_Device_GetRemoteDevice(
    PEAK_DEVICE_HANDLE deviceHandle,
    PEAK_REMOTE_DEVICE_HANDLE* remoteDeviceHandle
);
```

--------------------------------

### Start Device Update

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/peak__device__manager_8hpp_source

Initiates a device update process. This method can optionally take an update policy and an error callback function to handle any errors during the update.

```cpp
void Update(UpdatePolicy updatePolicy = UpdatePolicy::ScanEnvironmentForProducerLibraries, const UpdateErrorCallback &errorCallback = UpdateErrorCallback());

```

--------------------------------

### Get System Version

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/classpeak_1_1core_1_1_system_descriptor

Returns the version of the system. This const method returns a std::string. It may throw an InternalErrorException.

```cpp
std::string Version() const;
```

--------------------------------

### Functions starting with 't'

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/functions_func_t

This section lists functions in the IDS Peak API whose names start with the letter 't'. It includes the function name and the classes it belongs to.

```APIDOC
## Functions starting with 't'

### Description
Lists functions in the IDS Peak API whose names start with the letter 't'. It includes the function name and the classes it belongs to.

### Method
N/A (Documentation of functions)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
#### Success Response (200)
- **function_name** (string) - The name of the function.
- **class_name** (string) - The name of the class the function belongs to.

#### Response Example
```json
{
  "functions": [
    {
      "name": "Timeout()",
      "classes": ["peak::core::Timeout"]
    },
    {
      "name": "TimeoutException()",
      "classes": ["peak::core::TimeoutException"]
    },
    {
      "name": "Timestamp_ns()",
      "classes": ["peak::core::Buffer"]
    },
    {
      "name": "Timestamp_ticks()",
      "classes": ["peak::core::Buffer"]
    },
    {
      "name": "TimestampTickFrequency()",
      "classes": ["peak::core::Device", "peak::core::DeviceDescriptor"]
    },
    {
      "name": "TLType()",
      "classes": [
        "peak::core::Buffer",
        "peak::core::DataStream",
        "peak::core::Device",
        "peak::core::DeviceDescriptor",
        "peak::core::Interface",
        "peak::core::InterfaceDescriptor",
        "peak::core::Port",
        "peak::core::System",
        "peak::core::SystemDescriptor"
      ]
    },
    {
      "name": "ToImageView()",
      "classes": ["peak::core::Buffer", "peak::core::BufferPart"]
    },
    {
      "name": "ToolTip()",
      "classes": ["peak::core::nodes::Node"]
    },
    {
      "name": "ToString()",
      "classes": [
        "peak::common::detail::IntervalT< T >",
        "peak::common::detail::PointT< T >",
        "peak::common::detail::RectangleT< PointType, SizeType >",
        "peak::common::detail::SizeT< T >",
        "peak::common::Metadata",
        "peak::common::Version",
        "peak::core::Version"
      ]
    },
    {
      "name": "Transposed()",
      "classes": ["peak::common::detail::SizeT< T >"]
    },
    {
      "name": "TryFindEntry()",
      "classes": ["peak::core::nodes::EnumerationNode"]
    },
    {
      "name": "TryFindNode()",
      "classes": ["peak::core::NodeMap"]
    },
    {
      "name": "TryGetValueByName()",
      "classes": ["peak::common::Metadata"]
    },
    {
      "name": "TryLock()",
      "classes": ["peak::core::NodeMap"]
    },
    {
      "name": "Type()",
      "classes": ["peak::core::BufferPart", "peak::core::Event", "peak::core::nodes::Node"]
    }
  ]
}
```
```

--------------------------------

### String Node Operations

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/peak__backend_8h

Functions for casting, getting maximum length, getting, and setting values of string nodes.

```APIDOC
## PEAK_StringNode_ToNode

### Description
Casts the given string node to a generic node.

### Method
Not Applicable (C API function)

### Endpoint
Not Applicable (C API function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```c
PEAK_STRING_NODE_HANDLE stringNodeHandle;
PEAK_NODE_HANDLE nodeHandle;
PEAK_StringNode_ToNode(stringNodeHandle, &nodeHandle);
```

### Response
#### Success Response
- **nodeHandle** (PEAK_NODE_HANDLE *) - Pointer to the resulting generic node handle.

#### Response Example
None (output is via pointer)

## PEAK_StringNode_GetMaximumLength

### Description
Asks the given string node for its maximum allowed length.

### Method
Not Applicable (C API function)

### Endpoint
Not Applicable (C API function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```c
PEAK_STRING_NODE_HANDLE stringNodeHandle;
int64_t maximumLength;
PEAK_StringNode_GetMaximumLength(stringNodeHandle, &maximumLength);
```

### Response
#### Success Response
- **maximumLength** (int64_t *) - Pointer to store the maximum length.

#### Response Example
```json
{
  "maximumLength": 255
}
```

## PEAK_StringNode_GetValue

### Description
Asks the given string node for its current value.

### Method
Not Applicable (C API function)

### Endpoint
Not Applicable (C API function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```c
PEAK_STRING_NODE_HANDLE stringNodeHandle;
char value[1024];
size_t valueSize = 1024;
PEAK_StringNode_GetValue(stringNodeHandle, PEAK_NODE_CACHE_USE_POLICY_NEVER, value, &valueSize);
```

### Response
#### Success Response
- **value** (char *) - Buffer to store the string value.
- **valueSize** (size_t *) - Pointer to store the actual size of the string value.

#### Response Example
```json
{
  "value": "Example String",
  "valueSize": 14
}
```

## PEAK_StringNode_SetValue

### Description
Tells the given string node to set the given value.

### Method
Not Applicable (C API function)

### Endpoint
Not Applicable (C API function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```c
PEAK_STRING_NODE_HANDLE stringNodeHandle;
const char* newValue = "New Value";
size_t newValueSize = strlen(newValue);
PEAK_StringNode_SetValue(stringNodeHandle, newValue, newValueSize);
```

### Response
#### Success Response
None (operation is synchronous)

#### Response Example
None
```

--------------------------------

### System Information

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/functions_c

Retrieve file names and full paths related to the system and system descriptor.

```APIDOC
## GET /system/info

### Description
Retrieves the CTI file name and full path associated with the system and system descriptor.

### Method
GET

### Endpoint
/system/info

### Parameters
#### Query Parameters
None

### Request Example
```
GET /system/info
```

### Response
#### Success Response (200)
- **ctiFileName** (string) - The CTI file name of the system.
- **ctiFullPath** (string) - The full path to the CTI file of the system.

#### Response Example
```json
{
  "ctiFileName": "idspeak.cti",
  "ctiFullPath": "/opt/ids/peak/config/idspeak.cti"
}
```
```

--------------------------------

### Define Acquisition Start Modes (C++)

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/peak__backend_8h

Defines the possible modes for starting an acquisition. Includes default and custom options.

```C++
enum | PEAK_ACQUISITION_START_MODE_t {
PEAK_ACQUISITION_START_MODE_DEFAULT = 0 ,
PEAK_ACQUISITION_START_MODE_CUSTOM = 1000
}
```

--------------------------------

### PortURL Constructor and Info Retrieval (C++)

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/peak__port__url_8hpp_source

This snippet shows the constructor for the PortURL class and its method for retrieving raw information using a command identifier. It utilizes C interface functions for data retrieval.

```cpp
inline PortURL::PortURL(PEAK_PORT_URL_HANDLE portUrlHandle, const std::weak_ptr<Port>& parentPort)
: m_backendHandle(portUrlHandle)
, m_parentPort(parentPort)
{}

inline RawInformation PortURL::Info(int32_t infoCommand) const
{
 return QueryRawInformationFromCInterfaceFunction([&](int32_t* dataType, uint8_t* buffer, size_t* bufferSize) {
 return PEAK_C_ABI_PREFIX PEAK_PortURL_GetInfo(m_backendHandle, infoCommand, dataType, buffer, bufferSize);
 });
}
```

--------------------------------

### System Initialization and Deletion Prevention (C++)

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/classpeak_1_1core_1_1_system-members

Demonstrates the explicit deletion of the default, copy, and move constructors for the `System` class. This enforces a singleton-like pattern or prevents direct instantiation, ensuring controlled system management.

```C++
peak::core::System()=delete;
peak::core::System(const System &other)=delete;
peak::core::System(System &&other)=delete;
```

--------------------------------

### Start Acquisition Infinite (C++)

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/classpeak_1_1dynamic_1_1_dynamic_loader

Starts an infinite acquisition process for a data stream. Requires a valid PEAK_DATA_STREAM_HANDLE and PEAK_ACQUISITION_START_MODE.

```cpp
PEAK_RETURN_CODE PEAK_DataStream_StartAcquisitionInfinite(PEAK_DATA_STREAM_HANDLE _dataStreamHandle_, PEAK_ACQUISITION_START_MODE _startMode_)
```

--------------------------------

### Manage Firmware Update Progress Observer (C++)

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/peak__dynamic__loader_8h

Provides functions to manage the lifecycle of the firmware update progress observer. This includes destructing the observer to release resources. It requires a handle to the observer to be destructed.

```cpp
typedef PEAK_RETURN_CODE(* | peak::dynamic::dyn_PEAK_FirmwareUpdateProgressObserver_Destruct) (PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle);
```

--------------------------------

### Querying Interface Information using Info Command (C++)

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/classpeak_1_1core_1_1_interface_descriptor

This snippet demonstrates how to retrieve raw information from an InterfaceDescriptor using a GenTL info command. It includes an example of casting the returned data based on its data type, such as uint64_t or int64_t. Error handling is omitted for brevity.

```cpp
#include <peak/thirdparty/GenTL.h>

// Assuming 'object' is a pointer to an InterfaceDescriptor instance
auto info = object->Info(GenTL::XX_INFO_XX);

// Cast depending on the delivered data type
if (info.dataType == GenTL::INFO_DATATYPE_UINT64)
{
    uint64_t uint64Var = *reinterpret_cast<const uint64_t*>(info.data.data());
    // Do something with the information
}
else if (infoDataTypeVar == GenTL::INFO_DATATYPE_INT64)
{
    // Handle INT64 data type
    ...
}
...
```

--------------------------------

### Functions starting with 'M'

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/functions_func_m

This section lists functions in the IDS peak genericC++ library whose names start with the letter 'M'. It includes the function name and the class(es) it belongs to.

```APIDOC
## Functions starting with 'M'

### Description
Lists functions in the IDS peak genericC++ library whose names start with 'M'.

### Method
N/A (Documentation Reference)

### Endpoint
N/A (Documentation Reference)

### Parameters
N/A

### Request Example
N/A

### Response
#### Success Response (N/A)
- **Function Name** (string) - The name of the function.
- **Class** (string) - The class the function belongs to.

#### Response Example
```json
{
  "functions": [
    {
      "name": "Major()",
      "class": "peak::core::Version"
    },
    {
      "name": "Maximum()",
      "class": "peak::core::nodes::FloatNode, peak::core::nodes::IntegerNode"
    },
    {
      "name": "MaximumLength()",
      "class": "peak::core::nodes::StringNode"
    },
    {
      "name": "MaxSize()",
      "class": "peak::core::file::FileAdapter"
    },
    {
      "name": "Minimum()",
      "class": "peak::core::nodes::FloatNode, peak::core::nodes::IntegerNode"
    },
    {
      "name": "Minor()",
      "class": "peak::core::Version"
    },
    {
      "name": "ModelName()",
      "class": "peak::core::Device, peak::core::DeviceDescriptor, peak::core::Port, peak::core::System, peak::core::SystemDescriptor"
    },
    {
      "name": "Module()",
      "class": "peak::core::Module"
    },
    {
      "name": "ModuleDescriptor()",
      "class": "peak::core::ModuleDescriptor"
    },
    {
      "name": "ModuleDescriptorHandle()",
      "class": "peak::core::ModuleDescriptor"
    },
    {
      "name": "ModuleHandle()",
      "class": "peak::core::Module"
    },
    {
      "name": "ModuleName()",
      "class": "peak::core::Port"
    },
    {
      "name": "MonitoringUpdateInterval()",
      "class": "peak::core::DeviceDescriptor"
    }
  ]
}
```
```

--------------------------------

### Firmware Information Access Functions - C++

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/peak__dynamic__loader_8h

Provides function pointers for retrieving various details about the firmware update. This includes checking if the firmware information is valid, and accessing its file name, description, version, version extraction pattern, version style, release notes, release notes URL, and persistence settings.

```cpp
typedef PEAK_RETURN_CODE(* | peak::dynamic::dyn_PEAK_FirmwareUpdateInformation_GetIsValid) (PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_BOOL8 *isValid)
typedef PEAK_RETURN_CODE(* | peak::dynamic::dyn_PEAK_FirmwareUpdateInformation_GetFileName) (PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *fileName, size_t *fileNameSize)
typedef PEAK_RETURN_CODE(* | peak::dynamic::dyn_PEAK_FirmwareUpdateInformation_GetDescription) (PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *description, size_t *descriptionSize)
typedef PEAK_RETURN_CODE(* | peak::dynamic::dyn_PEAK_FirmwareUpdateInformation_GetVersion) (PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *version, size_t *versionSize)
typedef PEAK_RETURN_CODE(* | peak::dynamic::dyn_PEAK_FirmwareUpdateInformation_GetVersionExtractionPattern) (PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *versionExtractionPattern, size_t *versionExtractionPatternSize)
typedef PEAK_RETURN_CODE(* | peak::dynamic::dyn_PEAK_FirmwareUpdateInformation_GetVersionStyle) (PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_FIRMWARE_UPDATE_VERSION_STYLE *versionStyle)
typedef PEAK_RETURN_CODE(* | peak::dynamic::dyn_PEAK_FirmwareUpdateInformation_GetReleaseNotes) (PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *releaseNotes, size_t *releaseNotesSize)
typedef PEAK_RETURN_CODE(* | peak::dynamic::dyn_PEAK_FirmwareUpdateInformation_GetReleaseNotesURL) (PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *releaseNotesUrl, size_t *releaseNotesUrlSize)
typedef PEAK_RETURN_CODE(* | peak::dynamic::dyn_PEAK_FirmwareUpdateInformation_GetUserSetPersistence) (PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_FIRMWARE_UPDATE_PERSISTENCE *userSetPersistence)
typedef PEAK_RETURN_CODE(* | peak::dynamic::dyn_PEAK_FirmwareUpdateInformation_GetSequencerSetPersistence) (PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_FIRMWARE_UPDATE_PERSISTENCE *sequencerSetPersistence)
```

--------------------------------

### Acquisition Start Modes Enum

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/peak__backend_8h

Defines the possible modes for starting an image acquisition. This enum is used to control how the acquisition process is initiated.

```c++
enum PEAK_ACQUISITION_START_MODE_t {
  PEAK_ACQUISITION_START_MODE_DEFAULT,
  PEAK_ACQUISITION_START_MODE_CUSTOM
};
```

--------------------------------

### File Members - ACQ_START_FLAGS_DEFAULT

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/globals

Documentation for the ACQ_START_FLAGS_DEFAULT enumeration constant found in GenTL_v1_5.h.

```APIDOC
## Enumeration Constant: ACQ_START_FLAGS_DEFAULT

### Description
Represents the default start flags for an acquisition.

### Method
N/A

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
#### Success Response (200)
- **ACQ_START_FLAGS_DEFAULT** (Enumeration Constant) - Represents the default configuration for starting an acquisition.
```

--------------------------------

### Acquisition Start Mode Enumeration

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-api-documentation/2.19/en/namespacepeak_1_1core

Specifies the possible acquisition start modes for DataStream::StartAcquisition(). This enumeration allows for different strategies when initiating an acquisition.

```cpp
enum class AcquisitionStartMode {
  Default,
  Custom = 1000
}
```
Tokens:
Raw