peak_ipl_backend.h

Go to the documentation of this file.

 
#pragma once
 
#include <peak_ipl/backend/peak_ipl_dll_defines.h>
#include <peak_ipl/backend/peak_ipl_attribute_defines.h>
 
#include "peak_common_c/detail/peak_common_defines.h"
 
#ifdef __cplusplus
#    include <cstddef>
#    include <cstdint>
 
extern "C" {
#else
#    include <stddef.h>
#    include <stdint.h>
#endif
 
typedef int8_t PEAK_IPL_BOOL8;

enum PEAK_IPL_RETURN_CODE_t
{
    PEAK_IPL_RETURN_CODE_SUCCESS = 0,
    PEAK_IPL_RETURN_CODE_ERROR = 1,
    PEAK_IPL_RETURN_CODE_INVALID_HANDLE = 2,
    PEAK_IPL_RETURN_CODE_IO_ERROR = 3,
    PEAK_IPL_RETURN_CODE_BUFFER_TOO_SMALL = 4,
    PEAK_IPL_RETURN_CODE_INVALID_ARGUMENT = 5,
    PEAK_IPL_RETURN_CODE_OUT_OF_RANGE = 6,
    PEAK_IPL_RETURN_CODE_IMAGE_FORMAT_NOT_SUPPORTED = 7,
    PEAK_IPL_RETURN_CODE_FORMAT_INTERPRETATION_ERROR = 8,
    PEAK_IPL_RETURN_CODE_NOT_SUPPORTED = 9,
    PEAK_IPL_RETURN_CODE_NOT_PERMITTED = 10,
    PEAK_IPL_RETURN_CODE_BUSY = 11,
    PEAK_IPL_RETURN_CODE_TIMEOUT = 12
 
};
typedef int32_t PEAK_IPL_RETURN_CODE;

enum PEAK_IPL_CONVERSION_MODE_t
{
    PEAK_IPL_CONVERSION_MODE_FAST = 1,
    PEAK_IPL_CONVERSION_MODE_HIGH_QUALITY = 2,
    PEAK_IPL_CONVERSION_MODE_CLASSIC = 3,
};
typedef int32_t PEAK_IPL_CONVERSION_MODE;

enum PEAK_IPL_PIXEL_FORMAT_t
{
    PEAK_IPL_PIXEL_FORMAT_INVALID = 0,
 
    PEAK_IPL_PIXEL_FORMAT_BAYER_GR_8 = 0x01080008,
    PEAK_IPL_PIXEL_FORMAT_BAYER_GR_10 = 0x0110000C,
    PEAK_IPL_PIXEL_FORMAT_BAYER_GR_12 = 0x01100010,
 
    PEAK_IPL_PIXEL_FORMAT_BAYER_RG_8 = 0x01080009,
    PEAK_IPL_PIXEL_FORMAT_BAYER_RG_10 = 0x0110000D,
    PEAK_IPL_PIXEL_FORMAT_BAYER_RG_12 = 0x01100011,
 
    PEAK_IPL_PIXEL_FORMAT_BAYER_GB_8 = 0x0108000A,
    PEAK_IPL_PIXEL_FORMAT_BAYER_GB_10 = 0x0110000E,
    PEAK_IPL_PIXEL_FORMAT_BAYER_GB_12 = 0x01100012,
 
    PEAK_IPL_PIXEL_FORMAT_BAYER_BG_8 = 0x0108000B,
    PEAK_IPL_PIXEL_FORMAT_BAYER_BG_10 = 0x0110000F,
    PEAK_IPL_PIXEL_FORMAT_BAYER_BG_12 = 0x01100013,
 
    PEAK_IPL_PIXEL_FORMAT_MONO_8 = 0x01080001,
    PEAK_IPL_PIXEL_FORMAT_MONO_10 = 0x01100003,
    PEAK_IPL_PIXEL_FORMAT_MONO_12 = 0x01100005,
    PEAK_IPL_PIXEL_FORMAT_MONO_16 = 0x01100007,
 
    PEAK_IPL_PIXEL_FORMAT_CONFIDENCE_8 = 0x010800C6,
    PEAK_IPL_PIXEL_FORMAT_CONFIDENCE_16 = 0x011000C7,
 
    PEAK_IPL_PIXEL_FORMAT_COORD3D_C8 = 0x010800B1,
    PEAK_IPL_PIXEL_FORMAT_COORD3D_C16 = 0x011000B8,
    PEAK_IPL_PIXEL_FORMAT_COORD3D_C32F = 0x012000BF,
 
    PEAK_IPL_PIXEL_FORMAT_COORD3D_ABC32F = 0x026000C0,
 
    PEAK_IPL_PIXEL_FORMAT_YUV420_8_YY_UV_SemiplanarIDS = 0x420C0001,
    PEAK_IPL_PIXEL_FORMAT_YUV420_8_YY_VU_SemiplanarIDS = 0x420C0002,
 
    PEAK_IPL_PIXEL_FORMAT_YUV422_8_UYVY = 0x0210001F,
 
    PEAK_IPL_PIXEL_FORMAT_RGB_8 = 0x02180014,
    PEAK_IPL_PIXEL_FORMAT_RGB_10 = 0x02300018,
    PEAK_IPL_PIXEL_FORMAT_RGB_12 = 0x0230001A,
 
    PEAK_IPL_PIXEL_FORMAT_BGR_8 = 0x02180015,
    PEAK_IPL_PIXEL_FORMAT_BGR_10 = 0x02300019,
    PEAK_IPL_PIXEL_FORMAT_BGR_12 = 0x0230001B,
 
    PEAK_IPL_PIXEL_FORMAT_RGBA_8 = 0x02200016,
    PEAK_IPL_PIXEL_FORMAT_RGBA_10 = 0x0240005F,
    PEAK_IPL_PIXEL_FORMAT_RGBA_12 = 0x02400061,
 
    PEAK_IPL_PIXEL_FORMAT_BGRA_8 = 0x02200017,
    PEAK_IPL_PIXEL_FORMAT_BGRA_10 = 0x0240004C,
    PEAK_IPL_PIXEL_FORMAT_BGRA_12 = 0x0240004E,
 
    PEAK_IPL_PIXEL_FORMAT_BAYER_BG_10_PACKED = 0x010A0052,
    PEAK_IPL_PIXEL_FORMAT_BAYER_BG_12_PACKED = 0x010C0053,
 
    PEAK_IPL_PIXEL_FORMAT_BAYER_GB_10_PACKED = 0x010A0054,
    PEAK_IPL_PIXEL_FORMAT_BAYER_GB_12_PACKED = 0x010C0055,
 
    PEAK_IPL_PIXEL_FORMAT_BAYER_GR_10_PACKED = 0x010A0056,
    PEAK_IPL_PIXEL_FORMAT_BAYER_GR_12_PACKED = 0x010C0057,
 
    PEAK_IPL_PIXEL_FORMAT_BAYER_RG_10_PACKED = 0x010A0058,
    PEAK_IPL_PIXEL_FORMAT_BAYER_RG_12_PACKED = 0x010C0059,
 
    PEAK_IPL_PIXEL_FORMAT_MONO_10_PACKED = 0x010A0046,
    PEAK_IPL_PIXEL_FORMAT_MONO_12_PACKED = 0x010C0047,
 
    PEAK_IPL_PIXEL_FORMAT_RGB_10_PACKED_32 = 0x0220001D,
 
    PEAK_IPL_PIXEL_FORMAT_BGR_10_PACKED_32 = 0x0220001E,

    PEAK_IPL_PIXEL_FORMAT_BAYER_RG_10_GROUPED_40_IDS = 0x40000001,
    PEAK_IPL_PIXEL_FORMAT_BAYER_GB_10_GROUPED_40_IDS = 0x40000002,
    PEAK_IPL_PIXEL_FORMAT_BAYER_GR_10_GROUPED_40_IDS = 0x40000003,
    PEAK_IPL_PIXEL_FORMAT_BAYER_BG_10_GROUPED_40_IDS = 0x40000004,
    PEAK_IPL_PIXEL_FORMAT_BAYER_RG_12_GROUPED_24_IDS = 0x40000011,
    PEAK_IPL_PIXEL_FORMAT_BAYER_GB_12_GROUPED_24_IDS = 0x40000012,
    PEAK_IPL_PIXEL_FORMAT_BAYER_GR_12_GROUPED_24_IDS = 0x40000013,
    PEAK_IPL_PIXEL_FORMAT_BAYER_BG_12_GROUPED_24_IDS = 0x40000014,
    PEAK_IPL_PIXEL_FORMAT_MONO_10_GROUPED_40_IDS = 0x4000000f,
    PEAK_IPL_PIXEL_FORMAT_MONO_12_GROUPED_24_IDS = 0x4000001f,
};
typedef int32_t PEAK_IPL_PIXEL_FORMAT;

enum PEAK_IPL_BAYER_PATTERN_t
{
    PEAK_IPL_BAYER_PATTERN_UNKNOWN,
    PEAK_IPL_BAYER_PATTERN_NONE,
    PEAK_IPL_BAYER_PATTERN_BAYER_GR,
    PEAK_IPL_BAYER_PATTERN_BAYER_RG,
    PEAK_IPL_BAYER_PATTERN_BAYER_GB,
    PEAK_IPL_BAYER_PATTERN_BAYER_BG
};
typedef int32_t PEAK_IPL_BAYER_PATTERN;

enum PEAK_IPL_ENDIANNESS_t
{
    PEAK_IPL_ENDIANNESS_UNKNOWN,
    PEAK_IPL_ENDIANNESS_LITTLE_ENDIAN,
    PEAK_IPL_ENDIANNESS_BIG_ENDIAN
};
typedef int32_t PEAK_IPL_ENDIANNESS;

enum PEAK_IPL_ORIENTATION_t
{
    PEAK_IPL_ORIENTATION_HORIZONTAL,
    PEAK_IPL_ORIENTATION_VERTICAL
};
typedef int32_t PEAK_IPL_ORIENTATION;

enum PEAK_IPL_HOTPIXELCORRECTION_SENSITIVITY_t
{
    PEAK_IPL_HOTPIXELCORRECTION_SENSITIVITY_INVALID,
    PEAK_IPL_HOTPIXELCORRECTION_SENSITIVITY_LEVEL1,
    PEAK_IPL_HOTPIXELCORRECTION_SENSITIVITY_LEVEL2,
    PEAK_IPL_HOTPIXELCORRECTION_SENSITIVITY_LEVEL3,
    PEAK_IPL_HOTPIXELCORRECTION_SENSITIVITY_LEVEL4,
    PEAK_IPL_HOTPIXELCORRECTION_SENSITIVITY_LEVEL5
};
typedef int32_t PEAK_IPL_HOTPIXELCORRECTION_SENSITIVITY;

enum PEAK_IPL_IMAGE_TRANSFORMER_ROTATION_ANGLE_t
{
    PEAK_IPL_IMAGE_TRANSFORMER_ROTATION_ANGLE_DEGREE_90_COUNTERCLOCKWISE = 90,
    PEAK_IPL_IMAGE_TRANSFORMER_ROTATION_ANGLE_DEGREE_90_CLOCKWISE = 270,
    PEAK_IPL_IMAGE_TRANSFORMER_ROTATION_ANGLE_DEGREE_180 = 180
};
typedef uint16_t PEAK_IPL_IMAGE_TRANSFORMER_ROTATION_ANGLE;
 
enum PEAK_IPL_BINNINGMODE_t
{
    PEAK_IPL_BINNINGMODE_AVERAGE = 0,
    PEAK_IPL_BINNINGMODE_SUM = 1
};
typedef uint16_t PEAK_IPL_BINNINGMODE;
 
enum PEAK_IPL_VIDEO_CONTAINER_t
{
    PEAK_IPL_VIDEO_CONTAINER_AVI = 0
};
typedef uint16_t PEAK_IPL_VIDEO_CONTAINER;
 
enum PEAK_IPL_VIDEO_ENCODER_t
{
    PEAK_IPL_VIDEO_ENCODER_RAW = 0,
    PEAK_IPL_VIDEO_ENCODER_MJPEG = 1
};
typedef uint16_t PEAK_IPL_VIDEO_ENCODER;
 
enum PEAK_IPL_VIDEO_ENCODER_OPTION_t
{
    PEAK_IPL_VIDEO_ENCODER_OPTION_QUALITY = 0
};
typedef uint16_t PEAK_IPL_VIDEO_ENCODER_OPTION;
 
enum PEAK_IPL_VIDEO_CONTAINER_OPTION_t
{
    PEAK_IPL_VIDEO_CONTAINER_OPTION_FRAMERATE = 0
};
typedef uint16_t PEAK_IPL_VIDEO_CONTAINER_OPTION;

struct PEAK_IPL_POINT_2D
{
    size_t x;
    size_t y;
};
 
struct PEAK_IPL_SIZE_2D
{
    size_t width;
    size_t height;
};
 
struct PEAK_IPL_RECT_2D
{
    struct PEAK_IPL_POINT_2D position;
    struct PEAK_IPL_SIZE_2D size;
};
 
enum PEAK_IPL_SHARPNESS_ALGORITHM_t
{
    PEAK_IPL_SHARPNESS_ALGORITHM_TENENGRAD,
    PEAK_IPL_SHARPNESS_ALGORITHM_MEAN_SCORE,
    PEAK_IPL_SHARPNESS_ALGORITHM_HISTOGRAM_VARIANCE,
    PEAK_IPL_SHARPNESS_ALGORITHM_SOBEL
};
typedef uint16_t PEAK_IPL_SHARPNESS_ALGORITHM;
 
enum PEAK_IPL_SHARPNESS_ROI_WEIGHT_t
{
    PEAK_IPL_SHARPNESS_ROI_WEIGHT_WEAK = 0x0021,
    PEAK_IPL_SHARPNESS_ROI_WEIGHT_MEDIUM = 0x0042,
    PEAK_IPL_SHARPNESS_ROI_WEIGHT_STRONG = 0x0063
};
typedef uint16_t PEAK_IPL_SHARPNESS_ROI_WEIGHT;
 
enum PEAK_IPL_INTERPOLATION_ALGORITHM_t
{
    PEAK_IPL_INTERPOLATION_NEAREST,
    PEAK_IPL_INTERPOLATION_LINEAR,
    PEAK_IPL_INTERPOLATION_CUBIC,
    PEAK_IPL_INTERPOLATION_AREA,
    PEAK_IPL_INTERPOLATION_LANCZOS4,
    PEAK_IPL_INTERPOLATION_LINEAR_EXACT,
    PEAK_IPL_INTERPOLATION_NEAREST_EXACT
};
typedef int32_t PEAK_IPL_INTERPOLATION_ALGORITHM;
 
struct PEAK_IPL_SHARPNESS_ROI
{
    struct PEAK_IPL_RECT_2D rect;
    uint8_t xSamplingInterval;
    uint8_t ySamplingInterval;
    PEAK_IPL_SHARPNESS_ROI_WEIGHT weight;
};
 
struct PEAK_IPL_RANGE
{
    uint32_t min;
    uint32_t max;
    uint32_t inc;
};
 
enum PEAK_IPL_LUT_CHANNEL_t
{
    PEAK_IPL_LUT_CHANNEL_RED = 0,
    PEAK_IPL_LUT_CHANNEL_GREEN = 1,
    PEAK_IPL_LUT_CHANNEL_BLUE = 2,
    PEAK_IPL_LUT_CHANNEL_ALL = 3
};
typedef int32_t PEAK_IPL_LUT_CHANNEL;
 
enum PEAK_IPL_LUT_SELECTOR_t
{
    PEAK_IPL_LUT_8BIT = 0,
    PEAK_IPL_LUT_10BIT = 1,
    PEAK_IPL_LUT_12BIT = 2,
    PEAK_IPL_LUT_16BIT = 3
};
typedef int32_t PEAK_IPL_LUT_SELECTOR;
 
enum PEAK_IPL_LUT_PRESET_t
{
    PEAK_IPL_LUT_PRESET_IDENTITY = 0,
    PEAK_IPL_LUT_PRESET_INVERSE = 1,
    PEAK_IPL_LUT_PRESET_JET = 2,
    PEAK_IPL_LUT_PRESET_HOT = 3,
    PEAK_IPL_LUT_PRESET_RAINBOW = 4,
    PEAK_IPL_LUT_PRESET_ONLY_RED = 5,
    PEAK_IPL_LUT_PRESET_ONLY_GREEN = 6,
    PEAK_IPL_LUT_PRESET_ONLY_BLUE = 7,
    PEAK_IPL_LUT_PRESET_DIGITAL_GAIN2 = 8,
    PEAK_IPL_LUT_PRESET_DIGITAL_BLACK_25_PERCENT = 9, 
    PEAK_IPL_LUT_PRESET_BINARIZE = 10
};
typedef int32_t PEAK_IPL_LUT_PRESET;
 
enum PEAK_IPL_CHROMATIC_ADAPTER_COLOR_SPACE_t
{
    PEAK_IPL_CHROMATIC_ADAPTER_COLOR_SPACE_SRGB_D50 = 1,
    PEAK_IPL_CHROMATIC_ADAPTER_COLOR_SPACE_SRGB_D65 = 2,
    PEAK_IPL_CHROMATIC_ADAPTER_COLOR_SPACE_CIE_RGB_E = 3,
    PEAK_IPL_CHROMATIC_ADAPTER_COLOR_SPACE_ECI_RGB_D50 = 4,
    PEAK_IPL_CHROMATIC_ADAPTER_COLOR_SPACE_ADOBE_RGB_D65 = 5
};
typedef uint16_t PEAK_IPL_CHROMATIC_ADAPTER_COLOR_SPACE;
 
enum PEAK_IPL_CHROMATIC_ADAPTER_ALGORITHM_t
{
    PEAK_IPL_CHROMATIC_ADAPTER_ALGORITHM_LEGACY = 1,
    PEAK_IPL_CHROMATIC_ADAPTER_ALGORITHM_BRADFORD = 2,
};
typedef uint16_t PEAK_IPL_CHROMATIC_ADAPTER_ALGORITHM;
 
struct PEAK_IPL_IMAGE_CONVERTER;
typedef struct PEAK_IPL_IMAGE_CONVERTER* PEAK_IPL_IMAGE_CONVERTER_HANDLE;
 
struct PEAK_IPL_IMAGE_transformer;
typedef struct PEAK_IPL_IMAGE_transformer* PEAK_IPL_IMAGE_TRANSFORMER_HANDLE;
 
struct PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR;
typedef struct PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR* PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE;
 
struct PEAK_IPL_BINNING;
typedef struct PEAK_IPL_BINNING* PEAK_IPL_BINNING_HANDLE;
 
struct PEAK_IPL_DECIMATION;
typedef struct PEAK_IPL_DECIMATION* PEAK_IPL_DECIMATION_HANDLE;
 
struct PEAK_IPL_COLOR_CORRECTOR;
typedef struct PEAK_IPL_COLOR_CORRECTOR* PEAK_IPL_COLOR_CORRECTOR_HANDLE;
 
struct PEAK_IPL_GAIN;
typedef struct PEAK_IPL_GAIN* PEAK_IPL_GAIN_HANDLE;
 
struct PEAK_IPL_GAMMA_CORRECTOR;
typedef struct PEAK_IPL_GAMMA_CORRECTOR* PEAK_IPL_GAMMA_CORRECTOR_HANDLE;
 
struct PEAK_IPL_IMAGE;
typedef struct PEAK_IPL_IMAGE* PEAK_IPL_IMAGE_HANDLE;
 
struct PEAK_IPL_HISTOGRAM;
typedef struct PEAK_IPL_HISTOGRAM* PEAK_IPL_HISTOGRAM_HANDLE;
 
struct PEAK_IPL_PIXEL_LINE;
typedef struct PEAK_IPL_PIXEL_LINE* PEAK_IPL_PIXEL_LINE_HANDLE;
 
struct PEAK_IPL_VIDEO;
typedef struct PEAK_IPL_VIDEO* PEAK_IPL_VIDEO_HANDLE;
 
struct PEAK_IPL_SHARPNESS;
typedef struct PEAK_IPL_SHARPNESS* PEAK_IPL_SHARPNESS_HANDLE;
 
struct PEAK_IPL_EDGE_ENHANCEMENT;
typedef struct PEAK_IPL_EDGE_ENHANCEMENT* PEAK_IPL_EDGE_ENHANCEMENT_HANDLE;
 
struct PEAK_IPL_LUT;
typedef struct PEAK_IPL_LUT* PEAK_IPL_LUT_HANDLE;
 
struct PEAK_IPL_CHROMATIC_ADAPTER;
typedef struct PEAK_IPL_CHROMATIC_ADAPTER* PEAK_IPL_CHROMATIC_ADAPTER_HANDLE;
 
#ifdef PEAK_IPL_DYNAMIC_LOADING
#   define PEAK_IPL_C_API PEAK_IPL_PUBLIC PEAK_IPL_RETURN_CODE PEAK_IPL_CALL_CONV
#else
#   define PEAK_IPL_C_API PEAK_IPL_NO_DISCARD PEAK_IPL_PUBLIC PEAK_IPL_RETURN_CODE PEAK_IPL_CALL_CONV
#endif
 
#ifndef PEAK_IPL_DYNAMIC_LOADING
PEAK_IPL_C_API PEAK_IPL_Library_GetVersionMajor(uint32_t* libraryVersionMajor);

PEAK_IPL_C_API PEAK_IPL_Library_GetVersionMinor(uint32_t* libraryVersionMinor);
 
PEAK_COMMON_DEPRECATED_MSG("Deprecated due to SemVer 2.0 migration. Use PEAK_IPL_Library_GetVersionPatch() instead.")
PEAK_IPL_C_API PEAK_IPL_Library_GetVersionSubminor(uint32_t* libraryVersionSubminor);

PEAK_IPL_C_API PEAK_IPL_Library_GetVersionPatch(uint32_t* libraryVersionPatch);

PEAK_IPL_C_API PEAK_IPL_Library_GetMaxConcurrentThreads(size_t* concurrentThreads);

PEAK_IPL_C_API PEAK_IPL_Library_SetMaxConcurrentThreads(size_t concurrentThreads);

PEAK_IPL_C_API PEAK_IPL_Library_GetMultiThreadingEnabled(PEAK_IPL_BOOL8* enabled);

PEAK_IPL_C_API PEAK_IPL_Library_SetMultiThreadingEnabled(PEAK_IPL_BOOL8 enabled);

PEAK_IPL_C_API PEAK_IPL_Library_GetSIMDEnabled(PEAK_IPL_BOOL8* enabled);

PEAK_IPL_C_API PEAK_IPL_Library_SetSIMDEnabled(PEAK_IPL_BOOL8 enabled);

PEAK_IPL_C_API PEAK_IPL_Library_GetLastError(
    PEAK_IPL_RETURN_CODE* lastErrorCode, char* lastErrorDescription, size_t* lastErrorDescriptionSize);

PEAK_IPL_C_API PEAK_IPL_ImageConverter_Construct(PEAK_IPL_IMAGE_CONVERTER_HANDLE* imageConverterHandle);

PEAK_IPL_C_API PEAK_IPL_ImageConverter_Acquire(PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle);

PEAK_IPL_C_API PEAK_IPL_ImageConverter_PreAllocateConversion(PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle,
    PEAK_IPL_PIXEL_FORMAT inputPixelFormat, PEAK_IPL_PIXEL_FORMAT outputPixelFormat, size_t width, size_t height,
    size_t imageCount);

PEAK_IPL_C_API PEAK_IPL_ImageConverter_GetConversionMode(
    PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle, PEAK_IPL_CONVERSION_MODE* conversionMode);

PEAK_IPL_C_API PEAK_IPL_ImageConverter_SetConversionMode(
    PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle, PEAK_IPL_CONVERSION_MODE conversionMode);

PEAK_IPL_C_API PEAK_IPL_ImageConverter_GetSupportedOutputPixelFormats(PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle,
    PEAK_IPL_PIXEL_FORMAT inputPixelFormat, PEAK_IPL_PIXEL_FORMAT* outputPixelFormats, size_t* outputPixelFormatsSize);

PEAK_IPL_C_API PEAK_IPL_ImageConverter_Convert(PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle,
    PEAK_IPL_IMAGE_HANDLE inputImageHandle, PEAK_IPL_PIXEL_FORMAT outputPixelFormat,
    PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_ImageConverter_ConvertToBuffer(PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle,
    PEAK_IPL_IMAGE_HANDLE inputImageHandle, PEAK_IPL_PIXEL_FORMAT outputPixelFormat, uint8_t* outputImageBuffer,
    size_t outputImageBufferSize, PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_ImageConverter_ConvertWithFactorAndOffset(PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle,
    PEAK_IPL_IMAGE_HANDLE inputImageHandle, PEAK_IPL_PIXEL_FORMAT outputPixelFormat, double factor, double offset,
    PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_ImageConverter_ConvertToBufferWithFactorAndOffset(
    PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle, PEAK_IPL_IMAGE_HANDLE inputImageHandle, double factor,
    double offset, PEAK_IPL_PIXEL_FORMAT outputPixelFormat, uint8_t* outputImageBuffer, size_t outputImageBufferSize,
    PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_ImageConverter_ConvertFromInterval(PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle,
    PEAK_IPL_IMAGE_HANDLE inputImageHandle, PEAK_IPL_PIXEL_FORMAT outputPixelFormat, double start, double end,
    PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_ImageConverter_ConvertToBufferFromInterval(PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle,
    PEAK_IPL_IMAGE_HANDLE inputImageHandle, double start, double end, PEAK_IPL_PIXEL_FORMAT outputPixelFormat,
    uint8_t* outputImageBuffer, size_t outputImageBufferSize, PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_ImageConverter_Destruct(PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle);

PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_Construct(
    PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE* adaptiveHotpixelCorrectorHandle);

PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_Acquire(
    PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle);

PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_SetSensitivity(
    PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle,
    PEAK_IPL_HOTPIXELCORRECTION_SENSITIVITY sensitivityLevel);
PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_GetSensitivity(
    PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle,
    PEAK_IPL_HOTPIXELCORRECTION_SENSITIVITY* sensitivityLevel);

PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_SetGainFactorPercent(
    PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, uint32_t gainFactorPercent);

PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_GetGainFactorPercent(
    PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, uint32_t* gainFactorPercent);

PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_Detect(
    PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_IMAGE_HANDLE inputImageHandle);

PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_GetHotpixels(
    PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, struct PEAK_IPL_POINT_2D* hotpixels,
    size_t* hotpixelsSize);

PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_Correct(
    PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_IMAGE_HANDLE inputImageHandle,
    const struct PEAK_IPL_POINT_2D* hotpixels, size_t hotpixelsSize, PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_CorrectInPlace(
    PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_IMAGE_HANDLE inputImageHandle,
    const struct PEAK_IPL_POINT_2D* hotpixels, size_t hotpixelsSize);

PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_CorrectAdaptive(
    PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_IMAGE_HANDLE inputImageHandle,
    PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_CorrectAdaptiveInPlace(
    PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_IMAGE_HANDLE inputImageHandle);

PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_Destruct(
    PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle);

PEAK_IPL_C_API PEAK_IPL_ColorCorrector_Construct(PEAK_IPL_COLOR_CORRECTOR_HANDLE* colorCorrectorHandle);

PEAK_IPL_C_API PEAK_IPL_ColorCorrector_Acquire(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle);

PEAK_IPL_C_API PEAK_IPL_ColorCorrector_SetColorCorrectionFactors(
    PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, float* colorCorrectorFactors);

PEAK_IPL_C_API PEAK_IPL_ColorCorrector_GetColorCorrectionFactors(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle,
    float* colorCorrectorFactors, size_t* colorCorrectorFactorsSize);

PEAK_IPL_C_API PEAK_IPL_ColorCorrector_GetIsPixelFormatSupported(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle,
    PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8* isPixelFormatSupported);

PEAK_IPL_C_API PEAK_IPL_ColorCorrector_Process(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle,
    PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_ColorCorrector_ProcessInPlace(
    PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, PEAK_IPL_IMAGE_HANDLE imageHandle);

PEAK_IPL_C_API PEAK_IPL_ColorCorrector_Destruct(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle);

PEAK_IPL_C_API PEAK_IPL_ColorCorrector_GetSaturation(
    PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, float* saturation);

PEAK_IPL_C_API PEAK_IPL_ColorCorrector_GetSaturationMin(
    PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, float* saturationMin);

PEAK_IPL_C_API PEAK_IPL_ColorCorrector_GetSaturationMax(
    PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, float* saturationMax);

PEAK_IPL_C_API PEAK_IPL_ColorCorrector_SetSaturation(
    PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, float saturation);

PEAK_IPL_C_API PEAK_IPL_Binning_Construct(PEAK_IPL_BINNING_HANDLE* binningHandle);

PEAK_IPL_C_API PEAK_IPL_Binning_Acquire(PEAK_IPL_BINNING_HANDLE binningHandle);

PEAK_IPL_C_API PEAK_IPL_Binning_SetBinningX(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t* binningXValue);

PEAK_IPL_C_API PEAK_IPL_Binning_GetBinningX(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t* binningXValue);

PEAK_IPL_C_API PEAK_IPL_Binning_SetBinningY(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t* binningYValue);

PEAK_IPL_C_API PEAK_IPL_Binning_GetBinningY(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t* binningYValue);

PEAK_IPL_C_API PEAK_IPL_Binning_GetBinningMin(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t* binningMin);

PEAK_IPL_C_API PEAK_IPL_Binning_GetBinningMax(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t* binningMax);

PEAK_IPL_C_API PEAK_IPL_Binning_ExpectedOutputSize(PEAK_IPL_BINNING_HANDLE binningHandle, size_t* outputWidth,
    size_t* outputHeight, size_t inputWidth, size_t inputHeight, PEAK_IPL_PIXEL_FORMAT pixelFormat);

PEAK_IPL_C_API PEAK_IPL_Binning_IsPixelformatSupported(
    PEAK_IPL_BINNING_HANDLE binningHandle, PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8* isPixelFormatSupported);

PEAK_IPL_C_API PEAK_IPL_Binning_SetBinningMode(PEAK_IPL_BINNING_HANDLE binningHandle, PEAK_IPL_BINNINGMODE* mode);

PEAK_IPL_C_API PEAK_IPL_Binning_GetBinningMode(PEAK_IPL_BINNING_HANDLE binningHandle, PEAK_IPL_BINNINGMODE* mode);

PEAK_IPL_C_API PEAK_IPL_Binning_Process(
    PEAK_IPL_BINNING_HANDLE binningHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_Binning_Destruct(PEAK_IPL_BINNING_HANDLE binningHandle);

PEAK_IPL_C_API PEAK_IPL_Decimation_Construct(PEAK_IPL_DECIMATION_HANDLE* decimationHandle);

PEAK_IPL_C_API PEAK_IPL_Decimation_Acquire(PEAK_IPL_DECIMATION_HANDLE decimationHandle);

PEAK_IPL_C_API PEAK_IPL_Decimation_SetDecimationX(PEAK_IPL_DECIMATION_HANDLE decimationHandle, uint8_t* decimationXValue);

PEAK_IPL_C_API PEAK_IPL_Decimation_GetDecimationX(PEAK_IPL_DECIMATION_HANDLE decimationHandle, uint8_t* decimationXValue);

PEAK_IPL_C_API PEAK_IPL_Decimation_SetDecimationY(PEAK_IPL_DECIMATION_HANDLE decimationHandle, uint8_t* decimationYValue);

PEAK_IPL_C_API PEAK_IPL_Decimation_GetDecimationY(PEAK_IPL_DECIMATION_HANDLE decimationHandle, uint8_t* decimationYValue);

PEAK_IPL_C_API PEAK_IPL_Decimation_GetDecimationMin(PEAK_IPL_DECIMATION_HANDLE decimationHandle, uint8_t* decimationMin);

PEAK_IPL_C_API PEAK_IPL_Decimation_GetDecimationMax(PEAK_IPL_DECIMATION_HANDLE decimationHandle, uint8_t* decimationMax);

PEAK_IPL_C_API PEAK_IPL_Decimation_ExpectedOutputSize(PEAK_IPL_DECIMATION_HANDLE decimationHandle, size_t* outputWidth,
    size_t* outputHeight, size_t inputWidth, size_t inputHeight, PEAK_IPL_PIXEL_FORMAT pixelFormat);

PEAK_IPL_C_API PEAK_IPL_Decimation_IsPixelformatSupported(PEAK_IPL_DECIMATION_HANDLE decimationHandle,
    PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8* isPixelFormatSupported);

PEAK_IPL_C_API PEAK_IPL_Decimation_Process(PEAK_IPL_DECIMATION_HANDLE decimationHandle, PEAK_IPL_IMAGE_HANDLE imageHandle,
    PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_Decimation_Destruct(PEAK_IPL_DECIMATION_HANDLE decimationHandle);

 
PEAK_IPL_C_API PEAK_IPL_Gain_Construct(PEAK_IPL_GAIN_HANDLE* gainHandle);

PEAK_IPL_C_API PEAK_IPL_Gain_Acquire(PEAK_IPL_GAIN_HANDLE gainHandle);

PEAK_IPL_C_API PEAK_IPL_Gain_SetMasterGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float* masterGainValue);

PEAK_IPL_C_API PEAK_IPL_Gain_GetMasterGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float* masterGainValue);

PEAK_IPL_C_API PEAK_IPL_Gain_GetMasterGainMax(PEAK_IPL_GAIN_HANDLE gainHandle, float* masterGainMax);

PEAK_IPL_C_API PEAK_IPL_Gain_GetMasterGainMin(PEAK_IPL_GAIN_HANDLE gainHandle, float* masterGainMin);

PEAK_IPL_C_API PEAK_IPL_Gain_SetRedGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float* redGainValue);

PEAK_IPL_C_API PEAK_IPL_Gain_GetRedGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float* redGainValue);

PEAK_IPL_C_API PEAK_IPL_Gain_GetRedGainMax(PEAK_IPL_GAIN_HANDLE gainHandle, float* redGainMax);

PEAK_IPL_C_API PEAK_IPL_Gain_GetRedGainMin(PEAK_IPL_GAIN_HANDLE gainHandle, float* redGainMin);

PEAK_IPL_C_API PEAK_IPL_Gain_SetGreenGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float* greenGainValue);

PEAK_IPL_C_API PEAK_IPL_Gain_GetGreenGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float* greenGainValue);

PEAK_IPL_C_API PEAK_IPL_Gain_GetGreenGainMax(PEAK_IPL_GAIN_HANDLE gainHandle, float* greenGainMax);

PEAK_IPL_C_API PEAK_IPL_Gain_GetGreenGainMin(PEAK_IPL_GAIN_HANDLE gainHandle, float* greenGainMin);

PEAK_IPL_C_API PEAK_IPL_Gain_SetBlueGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float* blueGainValue);

PEAK_IPL_C_API PEAK_IPL_Gain_GetBlueGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float* blueGainValue);

PEAK_IPL_C_API PEAK_IPL_Gain_GetBlueGainMax(PEAK_IPL_GAIN_HANDLE gainHandle, float* blueGainMax);

PEAK_IPL_C_API PEAK_IPL_Gain_GetBlueGainMin(PEAK_IPL_GAIN_HANDLE gainHandle, float* blueGainMin);

PEAK_IPL_C_API PEAK_IPL_Gain_GetIsPixelFormatSupported(
    PEAK_IPL_GAIN_HANDLE gainHandle, PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8* isPixelFormatSupported);

PEAK_IPL_C_API PEAK_IPL_Gain_Process(
    PEAK_IPL_GAIN_HANDLE gainHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_Gain_ProcessInPlace(PEAK_IPL_GAIN_HANDLE gainHandle, PEAK_IPL_IMAGE_HANDLE imageHandle);

PEAK_IPL_C_API PEAK_IPL_Gain_Destruct(PEAK_IPL_GAIN_HANDLE gainHandle);

PEAK_IPL_C_API PEAK_IPL_GammaCorrector_Construct(PEAK_IPL_GAMMA_CORRECTOR_HANDLE* gammaCorrectorHandle);

PEAK_IPL_C_API PEAK_IPL_GammaCorrector_Acquire(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle);

PEAK_IPL_C_API PEAK_IPL_GammaCorrector_SetGammaCorrectionValue(
    PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float* gammaValue);

PEAK_IPL_C_API PEAK_IPL_GammaCorrector_GetGammaCorrectionValue(
    PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float* gammaValue);

PEAK_IPL_C_API PEAK_IPL_GammaCorrector_GetGammaCorrectionMax(
    PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float* gammaMax);

PEAK_IPL_C_API PEAK_IPL_GammaCorrector_GetGammaCorrectionMin(
    PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float* gammaMin);

PEAK_IPL_C_API PEAK_IPL_GammaCorrector_SetDigitalBlack(
    PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float* digitalBlackValue);

PEAK_IPL_C_API PEAK_IPL_GammaCorrector_GetDigitalBlack(
    PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float* digitalBlackValue);

PEAK_IPL_C_API PEAK_IPL_GammaCorrector_GetDigitalBlackMax(
    PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float* digitalBlackMax);

PEAK_IPL_C_API PEAK_IPL_GammaCorrector_GetDigitalBlackMin(
    PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float* digitalBlackMin);

PEAK_IPL_C_API PEAK_IPL_GammaCorrector_GetIsPixelFormatSupported(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle,
    PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8* isPixelFormatSupported);

PEAK_IPL_C_API PEAK_IPL_GammaCorrector_Process(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle,
    PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_GammaCorrector_ProcessInPlace(
    PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, PEAK_IPL_IMAGE_HANDLE imageHandle);

PEAK_IPL_C_API PEAK_IPL_GammaCorrector_Destruct(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle);

PEAK_IPL_C_API PEAK_IPL_Image_Construct(
    PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t width, size_t height, PEAK_IPL_IMAGE_HANDLE* imageHandle);

PEAK_IPL_C_API PEAK_IPL_Image_Acquire(PEAK_IPL_IMAGE_HANDLE imageHandle);

PEAK_IPL_C_API PEAK_IPL_Image_ConstructFromBuffer(PEAK_IPL_PIXEL_FORMAT pixelFormat, uint8_t* buffer, uint64_t bufferSize,
    size_t width, size_t height, PEAK_IPL_IMAGE_HANDLE* imageHandle);

PEAK_IPL_C_API PEAK_IPL_Image_GetWidth(PEAK_IPL_IMAGE_HANDLE imageHandle, size_t* width);

PEAK_IPL_C_API PEAK_IPL_Image_GetHeight(PEAK_IPL_IMAGE_HANDLE imageHandle, size_t* height);

PEAK_IPL_C_API PEAK_IPL_Image_GetPixelPointer(
    PEAK_IPL_IMAGE_HANDLE imageHandle, size_t xPos, size_t yPos, uint8_t** pixelPointer);

PEAK_IPL_C_API PEAK_IPL_Image_GetByteCount(PEAK_IPL_IMAGE_HANDLE imageHandle, size_t* byteCount);

PEAK_IPL_C_API PEAK_IPL_Image_GetPixelFormat(PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_PIXEL_FORMAT* pixelFormat);

PEAK_IPL_C_API PEAK_IPL_Image_GetData(PEAK_IPL_IMAGE_HANDLE imageHandle, uint8_t** data);

PEAK_IPL_C_API PEAK_IPL_Image_Clone(PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_Image_ConvertTo(PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_PIXEL_FORMAT outputPixelFormat,
    PEAK_IPL_CONVERSION_MODE conversionMode, PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_Image_ConvertToBuffer(PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_PIXEL_FORMAT outputPixelFormat,
    uint8_t* outputImageBuffer, size_t outputImageBufferSize, PEAK_IPL_CONVERSION_MODE conversionMode,
    PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_Image_ConvertToWithFactor(PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_PIXEL_FORMAT outputPixelFormat,
    double factor, PEAK_IPL_CONVERSION_MODE conversionMode, PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_Image_ConvertToWithFactorAndOffset(PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_PIXEL_FORMAT outputPixelFormat,
    double factor, double offset, PEAK_IPL_CONVERSION_MODE conversionMode, PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_Image_ConvertToBufferWithFactorAndOffset(PEAK_IPL_IMAGE_HANDLE imageHandle,
    PEAK_IPL_PIXEL_FORMAT outputPixelFormat, double factor, double offset, uint8_t* outputImageBuffer,
    size_t outputImageBufferSize, PEAK_IPL_CONVERSION_MODE conversionMode, PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_Image_ConvertToFromInterval(PEAK_IPL_IMAGE_HANDLE imageHandle,
    PEAK_IPL_PIXEL_FORMAT outputPixelFormat, double start, double end, PEAK_IPL_CONVERSION_MODE conversionMode,
    PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_Image_ConvertToBufferFromInterval(PEAK_IPL_IMAGE_HANDLE imageHandle,
    PEAK_IPL_PIXEL_FORMAT outputPixelFormat, double start, double end, uint8_t* outputImageBuffer,
    size_t outputImageBufferSize, PEAK_IPL_CONVERSION_MODE conversionMode, PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_Image_Scale(PEAK_IPL_IMAGE_HANDLE imageHandle, const struct PEAK_IPL_SIZE_2D* size,
    PEAK_IPL_INTERPOLATION_ALGORITHM algorithm, PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_Image_ScaleInto(PEAK_IPL_IMAGE_HANDLE imageHandle, const struct PEAK_IPL_SIZE_2D* size,
    uint8_t* buffer, size_t bufferSize, PEAK_IPL_INTERPOLATION_ALGORITHM algorithm);
 

PEAK_IPL_C_API PEAK_IPL_Image_Crop(PEAK_IPL_IMAGE_HANDLE imageHandle, const struct PEAK_IPL_POINT_2D* pos,
    const struct PEAK_IPL_SIZE_2D* size, PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_Image_Destruct(PEAK_IPL_IMAGE_HANDLE imageHandle);

PEAK_IPL_C_API PEAK_IPL_ImageTransformer_Construct(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE* imageTransformerHandle);

PEAK_IPL_C_API PEAK_IPL_ImageTransformer_Acquire(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle);

PEAK_IPL_C_API PEAK_IPL_Image_SetTimestamp(PEAK_IPL_IMAGE_HANDLE imageHandle, uint64_t timestamp_ns);

PEAK_IPL_C_API PEAK_IPL_Image_GetTimestamp(PEAK_IPL_IMAGE_HANDLE imageHandle, uint64_t* timestamp_ns);

PEAK_IPL_C_API PEAK_IPL_ImageTransformer_MirrorUpDown(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle,
    PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_ImageTransformer_MirrorLeftRight(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle,
    PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_ImageTransformer_MirrorUpDownLeftRight(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle,
    PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_ImageTransformer_MirrorUpDownInPlace(
    PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle, PEAK_IPL_IMAGE_HANDLE imageHandle);

PEAK_IPL_C_API PEAK_IPL_ImageTransformer_MirrorLeftRightInPlace(
    PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle, PEAK_IPL_IMAGE_HANDLE imageHandle);

PEAK_IPL_C_API PEAK_IPL_ImageTransformer_MirrorUpDownLeftRightInPlace(
    PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle, PEAK_IPL_IMAGE_HANDLE imageHandle);

PEAK_IPL_C_API PEAK_IPL_ImageTransformer_Rotate(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle,
    PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE* outputImageHandle,
    enum PEAK_IPL_IMAGE_TRANSFORMER_ROTATION_ANGLE_t rotationAngle);

PEAK_IPL_C_API PEAK_IPL_ImageTransformer_RotateInPlace(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle,
    PEAK_IPL_IMAGE_HANDLE imageHandle, enum PEAK_IPL_IMAGE_TRANSFORMER_ROTATION_ANGLE_t rotationAngle);

PEAK_IPL_C_API PEAK_IPL_ImageTransformer_Destruct(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle);

PEAK_IPL_C_API PEAK_IPL_Histogram_Construct(PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_HISTOGRAM_HANDLE* histogramHandle);

PEAK_IPL_C_API PEAK_IPL_Histogram_Acquire(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle);

PEAK_IPL_C_API PEAK_IPL_Histogram_GetPixelFormat(
    PEAK_IPL_HISTOGRAM_HANDLE histogramHandle, PEAK_IPL_PIXEL_FORMAT* pixelFormat);

PEAK_IPL_C_API PEAK_IPL_Histogram_GetNumChannels(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle, size_t* numChannels);

PEAK_IPL_C_API PEAK_IPL_Histogram_GetPixelSumForChannel(
    PEAK_IPL_HISTOGRAM_HANDLE histogramHandle, size_t channelIndex, uint64_t* pixelSum);

PEAK_IPL_C_API PEAK_IPL_Histogram_GetPixelCountForChannel(
    PEAK_IPL_HISTOGRAM_HANDLE histogramHandle, size_t channelIndex, uint64_t* pixelCount);

PEAK_IPL_C_API PEAK_IPL_Histogram_GetBinsForChannel(
    PEAK_IPL_HISTOGRAM_HANDLE histogramHandle, size_t channelIndex, uint64_t* bins, size_t* binsSize);

PEAK_IPL_C_API PEAK_IPL_Histogram_Destruct(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle);

PEAK_IPL_C_API PEAK_IPL_PixelLine_Construct(PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_ORIENTATION orientation,
    size_t offset, PEAK_IPL_PIXEL_LINE_HANDLE* pixelLineHandle);

PEAK_IPL_C_API PEAK_IPL_PixelLine_Acquire(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle);

PEAK_IPL_C_API PEAK_IPL_PixelLine_GetPixelFormat(
    PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle, PEAK_IPL_PIXEL_FORMAT* pixelFormat);

PEAK_IPL_C_API PEAK_IPL_PixelLine_GetOrientation(
    PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle, PEAK_IPL_ORIENTATION* orientation);

PEAK_IPL_C_API PEAK_IPL_PixelLine_GetOffset(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle, size_t* offset);

PEAK_IPL_C_API PEAK_IPL_PixelLine_GetNumChannels(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle, size_t* numChannels);

PEAK_IPL_C_API PEAK_IPL_PixelLine_GetValuesForChannel(
    PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle, size_t channelIndex, uint32_t* values, size_t* valuesSize);

PEAK_IPL_C_API PEAK_IPL_PixelLine_Destruct(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle);

PEAK_IPL_C_API PEAK_IPL_PixelFormat_GetNumChannels(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t* numChannels);

PEAK_IPL_C_API PEAK_IPL_PixelFormat_GetNumSignificantBitsPerChannel(
    PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t* numSignificantBits);

PEAK_IPL_C_API PEAK_IPL_PixelFormat_GetNumStorageBitsPerChannel(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t* numStorageBits);

PEAK_IPL_C_API PEAK_IPL_PixelFormat_GetMaximumValuePerChannel(
    PEAK_IPL_PIXEL_FORMAT pixelFormat, uint32_t* channelMaximumValue);

PEAK_IPL_C_API PEAK_IPL_PixelFormat_GetNumSignificantBitsPerPixel(
    PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t* numSignificantBits);

PEAK_IPL_C_API PEAK_IPL_PixelFormat_GetNumStorageBitsPerPixel(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t* numStorageBits);

PEAK_IPL_C_API PEAK_IPL_PixelFormat_GetEndianness(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_ENDIANNESS* endianness);

PEAK_IPL_C_API PEAK_IPL_PixelFormat_CalculateStorageSizeOfPixels(
    PEAK_IPL_PIXEL_FORMAT pixelFormat, uint64_t numPixels, uint64_t* size);

PEAK_IPL_C_API PEAK_IPL_PixelFormat_IsPacked(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8* isPacked);

PEAK_IPL_C_API PEAK_IPL_PixelFormat_IsBayered(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8* isBayered);

PEAK_IPL_C_API PEAK_IPL_PixelFormat_IsYUV(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8* isYUV);

PEAK_IPL_C_API PEAK_IPL_PixelFormat_IsCoord3D(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8* isCoord3D);

PEAK_IPL_C_API PEAK_IPL_PixelFormat_IsFloat(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8* isFloat);

PEAK_IPL_C_API PEAK_IPL_PixelFormat_GetBayerPattern(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BAYER_PATTERN* pattern);

PEAK_IPL_C_API PEAK_IPL_ImageWriter_WriteAsRAW(
    PEAK_IPL_IMAGE_HANDLE inputImageHandle, const char* filePath, size_t filePathSize);

PEAK_IPL_C_API PEAK_IPL_ImageWriter_WriteAsBMP(
    PEAK_IPL_IMAGE_HANDLE inputImageHandle, const char* filePath, size_t filePathSize);

PEAK_IPL_C_API PEAK_IPL_ImageWriter_WriteAsPNG(
    PEAK_IPL_IMAGE_HANDLE inputImageHandle, uint32_t quality, const char* filePath, size_t filePathSize);

PEAK_IPL_C_API PEAK_IPL_ImageWriter_WriteAsJPG(
    PEAK_IPL_IMAGE_HANDLE inputImageHandle, uint32_t quality, const char* filePath, size_t filePathSize);

PEAK_IPL_C_API PEAK_IPL_ImageWriter_Write(
    PEAK_IPL_IMAGE_HANDLE inputImageHandle, const char* filePath, size_t filePathSize);

PEAK_IPL_C_API PEAK_IPL_ImageReader_Read(
    const char* filePath, size_t filePathSize, PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_ImageReaderRead_ReadAsPixelFormat(const char* filePath, size_t filePathSize,
    PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_VideoWriter_Video_Open(PEAK_IPL_VIDEO_HANDLE* videoHandle, const char* filePath,
    PEAK_IPL_VIDEO_CONTAINER container, PEAK_IPL_VIDEO_ENCODER encoder);

PEAK_IPL_C_API PEAK_IPL_VideoWriter_Video_IsOpen(PEAK_IPL_VIDEO_HANDLE videoHandle, PEAK_IPL_BOOL8* isOpen);

PEAK_IPL_C_API PEAK_IPL_VideoWriter_Video_Close(PEAK_IPL_VIDEO_HANDLE videoHandle);

PEAK_IPL_C_API PEAK_IPL_VideoWriter_Video_Append(PEAK_IPL_VIDEO_HANDLE videoHandle, PEAK_IPL_IMAGE_HANDLE imageHandle);

PEAK_IPL_C_API PEAK_IPL_VideoWriter_Encoder_SetOption(
    PEAK_IPL_VIDEO_HANDLE videoHandle, PEAK_IPL_VIDEO_ENCODER_OPTION option, const void* value, size_t count);

PEAK_IPL_C_API PEAK_IPL_VideoWriter_Encoder_GetOption(
    PEAK_IPL_VIDEO_HANDLE videoHandle, PEAK_IPL_VIDEO_ENCODER_OPTION option, void* value, size_t count, size_t* outCount);

PEAK_IPL_C_API PEAK_IPL_VideoWriter_Encoder_OptionRange(
    PEAK_IPL_VIDEO_HANDLE videoHandle, PEAK_IPL_VIDEO_ENCODER_OPTION option, void* min, void* max, void* inc);

PEAK_IPL_C_API PEAK_IPL_VideoWriter_GetSupportedEncodersForAContainer(
    PEAK_IPL_VIDEO_CONTAINER container, PEAK_IPL_VIDEO_ENCODER* encoders, size_t* size);

PEAK_IPL_C_API PEAK_IPL_VideoWriter_Container_SetOption(
    PEAK_IPL_VIDEO_HANDLE videoHandle, PEAK_IPL_VIDEO_CONTAINER_OPTION option, const void* value, size_t count);

PEAK_IPL_C_API PEAK_IPL_VideoWriter_Container_GetOption(
    PEAK_IPL_VIDEO_HANDLE videoHandle, PEAK_IPL_VIDEO_ENCODER_OPTION option, void* value, size_t count, size_t* outCount);

PEAK_IPL_C_API PEAK_IPL_VideoWriter_Container_OptionRange(
    PEAK_IPL_VIDEO_HANDLE videoHandle, PEAK_IPL_VIDEO_ENCODER_OPTION option, void* min, void* max, void* inc);

PEAK_IPL_C_API PEAK_IPL_VideoWriter_GetSupportedContainersForAnEncoder(
    PEAK_IPL_VIDEO_ENCODER encoder, PEAK_IPL_VIDEO_CONTAINER* containers, size_t* size);

PEAK_IPL_C_API PEAK_IPL_VideoWriter_Encoder_GetSupportedPixelFormats(
    PEAK_IPL_VIDEO_ENCODER encoder, PEAK_IPL_PIXEL_FORMAT* pixelFormatList, size_t* pixelFormatListSize);

PEAK_IPL_C_API PEAK_IPL_VideoWriter_Video_GetEncodedFrames(PEAK_IPL_VIDEO_HANDLE videoHandle, uint64_t* numFrames);

PEAK_IPL_C_API PEAK_IPL_VideoWriter_Video_GetDroppedFrames(PEAK_IPL_VIDEO_HANDLE videoHandle, uint64_t* numFrames);

PEAK_IPL_C_API PEAK_IPL_VideoWriter_Video_GetFileSize(PEAK_IPL_VIDEO_HANDLE videoHandle, uint64_t* fileSize);

PEAK_IPL_C_API PEAK_IPL_VideoWriter_Video_ResetFrameCounters(PEAK_IPL_VIDEO_HANDLE videoHandle);

PEAK_IPL_C_API PEAK_IPL_VideoWriter_Queue_SetSize(PEAK_IPL_VIDEO_HANDLE videoHandle, int32_t size);

PEAK_IPL_C_API PEAK_IPL_VideoWriter_Queue_GetSize(PEAK_IPL_VIDEO_HANDLE videoHandle, int32_t* size);

PEAK_IPL_C_API PEAK_IPL_VideoWriter_Queue_GetRange(PEAK_IPL_VIDEO_HANDLE videoHandle, int32_t* minSize, int32_t* maxSize);

PEAK_IPL_C_API PEAK_IPL_VideoWriter_Queue_GetQueued(PEAK_IPL_VIDEO_HANDLE videoHandle, int32_t* queued);

PEAK_IPL_C_API PEAK_IPL_VideoWriter_Video_WaitUntilFrameDone(PEAK_IPL_VIDEO_HANDLE videoHandle, int32_t timeout_ms);

PEAK_IPL_C_API PEAK_IPL_VideoWriter_Video_WaitUntilQueueEmpty(PEAK_IPL_VIDEO_HANDLE videoHandle, int32_t timeout_ms);

PEAK_IPL_C_API PEAK_IPL_ImageSharpness_Construct(PEAK_IPL_SHARPNESS_HANDLE* handle);

PEAK_IPL_C_API PEAK_IPL_ImageSharpness_Acquire(PEAK_IPL_SHARPNESS_HANDLE handle);

PEAK_IPL_C_API PEAK_IPL_ImageSharpness_Destruct(PEAK_IPL_SHARPNESS_HANDLE handle);

PEAK_IPL_C_API PEAK_IPL_ImageSharpness_Measure(
    PEAK_IPL_SHARPNESS_HANDLE handle, PEAK_IPL_IMAGE_HANDLE imageHandle, double* calculated_value);

PEAK_IPL_C_API PEAK_IPL_ImageSharpness_GetIsPixelFormatSupported(
    PEAK_IPL_SHARPNESS_HANDLE handle, PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8* isPixelFormatSupported);

PEAK_IPL_C_API PEAK_IPL_ImageSharpness_GetSupportedPixelFormatList(
    PEAK_IPL_SHARPNESS_HANDLE handle, PEAK_IPL_PIXEL_FORMAT* pixelFormatList, size_t* pixelFormatListSize);

PEAK_IPL_C_API PEAK_IPL_ImageSharpness_SetAlgorithm(
    PEAK_IPL_SHARPNESS_HANDLE handle, PEAK_IPL_SHARPNESS_ALGORITHM algorithm);

PEAK_IPL_C_API PEAK_IPL_ImageSharpness_GetAlgorithm(
    PEAK_IPL_SHARPNESS_HANDLE handle, PEAK_IPL_SHARPNESS_ALGORITHM* algorithm);

PEAK_IPL_C_API PEAK_IPL_ImageSharpness_GetROIMinimumSize(
    PEAK_IPL_SHARPNESS_HANDLE handle, struct PEAK_IPL_SIZE_2D* min_size);

PEAK_IPL_C_API PEAK_IPL_ImageSharpness_SetROIs(
    PEAK_IPL_SHARPNESS_HANDLE handle, struct PEAK_IPL_SHARPNESS_ROI* roiList, size_t roiListSize);

PEAK_IPL_C_API PEAK_IPL_ImageSharpness_GetROIs(
    PEAK_IPL_SHARPNESS_HANDLE handle, struct PEAK_IPL_SHARPNESS_ROI* roiList, size_t* roiListSize);

PEAK_IPL_C_API PEAK_IPL_EdgeEnhancement_Construct(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE* handle);

PEAK_IPL_C_API PEAK_IPL_EdgeEnhancement_Acquire(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle);

PEAK_IPL_C_API PEAK_IPL_EdgeEnhancement_Destruct(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle);

PEAK_IPL_C_API PEAK_IPL_EdgeEnhancement_ProcessInPlace(
    PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle, PEAK_IPL_IMAGE_HANDLE imageHandle);

PEAK_IPL_C_API PEAK_IPL_EdgeEnhancement_Process(
    PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_EdgeEnhancement_GetFactorRange(
    PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle, struct PEAK_IPL_RANGE* range);

PEAK_IPL_C_API PEAK_IPL_EdgeEnhancement_SetFactor(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle, uint32_t factor);

PEAK_IPL_C_API PEAK_IPL_EdgeEnhancement_GetFactor(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle, uint32_t* factor);

PEAK_IPL_C_API PEAK_IPL_EdgeEnhancement_GetDefaultFactor(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle, uint32_t* factor);

PEAK_IPL_C_API PEAK_IPL_EdgeEnhancement_IsPixelFormatSupported(
    PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle, PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8* isPixelFormatSupported);

PEAK_IPL_C_API PEAK_IPL_Lut_Construct(PEAK_IPL_LUT_HANDLE* lutHandle);

PEAK_IPL_C_API PEAK_IPL_Lut_Acquire(PEAK_IPL_LUT_HANDLE lutHandle);

PEAK_IPL_C_API PEAK_IPL_Lut_GetLutValue(PEAK_IPL_LUT_HANDLE lutHandle, PEAK_IPL_LUT_SELECTOR lutSelector, PEAK_IPL_LUT_CHANNEL channel, uint32_t index, uint32_t* value);

PEAK_IPL_C_API PEAK_IPL_Lut_SetLutValue(PEAK_IPL_LUT_HANDLE lutHandle, PEAK_IPL_LUT_SELECTOR lutSelector, PEAK_IPL_LUT_CHANNEL channel, uint32_t index, uint32_t value);

PEAK_IPL_C_API PEAK_IPL_Lut_GetAllLutValues(PEAK_IPL_LUT_HANDLE lutHandle, PEAK_IPL_LUT_SELECTOR lutSelector, PEAK_IPL_LUT_CHANNEL channel, uint32_t* values, size_t* sizeValues);

PEAK_IPL_C_API PEAK_IPL_Lut_SetAllLutValues(PEAK_IPL_LUT_HANDLE lutHandle, PEAK_IPL_LUT_SELECTOR lutSelector, PEAK_IPL_LUT_CHANNEL channel, const uint32_t* values, size_t sizeValues);

PEAK_IPL_C_API PEAK_IPL_Lut_SetLutPreset(PEAK_IPL_LUT_HANDLE lutHandle, PEAK_IPL_LUT_SELECTOR lutSelector, PEAK_IPL_LUT_PRESET preset);

PEAK_IPL_C_API PEAK_IPL_Lut_IsPixelFormatSupported(PEAK_IPL_LUT_HANDLE lutHandle, PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8* isPixelFormatSupported);

PEAK_IPL_C_API PEAK_IPL_Lut_Process(PEAK_IPL_LUT_HANDLE lutHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_Lut_ProcessInPlace(PEAK_IPL_LUT_HANDLE lutHandle, PEAK_IPL_IMAGE_HANDLE imageHandle);

PEAK_IPL_C_API PEAK_IPL_Lut_Destruct(PEAK_IPL_LUT_HANDLE lutHandle);

PEAK_IPL_C_API PEAK_IPL_ChromaticAdapter_Construct(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE* handle);

PEAK_IPL_C_API PEAK_IPL_ChromaticAdapter_Acquire(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE handle);

PEAK_IPL_C_API PEAK_IPL_ChromaticAdapter_Destruct(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE handle);

PEAK_IPL_C_API PEAK_IPL_ChromaticAdapter_GetTargetColorSpace(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE handle, PEAK_IPL_CHROMATIC_ADAPTER_COLOR_SPACE* colorSpace);

PEAK_IPL_C_API PEAK_IPL_ChromaticAdapter_SetTargetColorSpace(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE handle, PEAK_IPL_CHROMATIC_ADAPTER_COLOR_SPACE colorSpace);

PEAK_IPL_C_API PEAK_IPL_ChromaticAdapter_GetAdaptionAlgorithm(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE handle, PEAK_IPL_CHROMATIC_ADAPTER_ALGORITHM* algorithm);

PEAK_IPL_C_API PEAK_IPL_ChromaticAdapter_SetAdaptionAlgorithm(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE handle, PEAK_IPL_CHROMATIC_ADAPTER_ALGORITHM model);

PEAK_IPL_C_API PEAK_IPL_ChromaticAdapter_CalculateColorCorrectionMatrix(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE handle, uint32_t temperature,
    const float* colorCorrectionMatrixInput, float* colorCorrectionMatrixOutput);

PEAK_IPL_C_API PEAK_IPL_ChromaticAdapter_GetTemperatureRange(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE handle,
    uint32_t* minTemperature, uint32_t* maxTemperature, uint32_t* incTemperature);
 
#    ifdef __cplusplus
} // extern "C"
#    endif
 
#else
#    ifdef __cplusplus
} // extern "C"
#    endif
 
#    include <peak_ipl/backend/peak_ipl_dynamic_loader.h>
#endif // !PEAK_IPL_DYNAMIC_LOADING