peak_ipl_backend.h

Go to the documentation of this file.

 
#pragma once
 
#include <peak_ipl/backend/peak_ipl_dll_defines.h>
 
#if __cplusplus >= 201703L || _MSVC_LANG >= 201703L
#    define PEAK_IPL_NO_DISCARD [[nodiscard]]
#    define PEAK_IPL_MAYBE_UNUSED [[maybe_unused]]
#else
#    ifdef _MSC_VER
#        define PEAK_IPL_NO_DISCARD _Check_return_
#        define PEAK_IPL_MAYBE_UNUSED
#    elif defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
#        define PEAK_IPL_NO_DISCARD __attribute__((warn_unused_result))
#        define PEAK_IPL_MAYBE_UNUSED __attribute__((unused))
#    else
#        define PEAK_IPL_NO_DISCARD
#        define PEAK_IPL_MAYBE_UNUSED
#    endif
#endif
 
#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
{
    LIMGTYPEIMAGE_TRANSFORMER_ROTATION_ANGLE_DEGREE_90_COUNTERCLOCKWISE = 90,
    LIMGTYPEIMAGE_TRANSFORMER_ROTATION_ANGLE_DEGREE_90_CLOCKWISE = 270,
    LIMGTYPEIMAGE_TRANSFORMER_ROTATION_ANGLE_DEGREE_180 = 180
};
typedef uint16_t PEAK_IPL_IMAGE_TRANSFORMER_ROTATION_ANGLE;
 
enum PEAK_IPL_BINNINGMODE_t
{
    Average = 0,
    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;
};
 
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;
 
#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_IPL_C_API PEAK_IPL_Library_GetVersionSubminor(uint32_t* libraryVersionSubminor);
 
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_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_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_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_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_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_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);
 
#    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