idspeak/21700/ids-peak_2.17.0.0-488_i386.deb

#pragma once


#include "peak_ipl_backend.h"


#include <string>

#include <cstdint>


#ifdef __linux__

    #include <dlfcn.h>

#else

    #include <vector>

    #include <windows.h>

    #include <tchar.h>

#endif


#include <stdexcept>


#undef PEAK_IPL_PUBLIC

#define PEAK_IPL_PUBLIC

#undef PEAK_IPL_CALL_CONV

#define PEAK_IPL_CALL_CONV

#undef PEAK_IPL_NO_DISCARD

#define PEAK_IPL_NO_DISCARD


namespace peak

{

namespace ipl

{


namespace dynamic

{


typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Library_GetVersionMajor)(uint32_t * libraryVersionMajor);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Library_GetVersionMinor)(uint32_t * libraryVersionMinor);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Library_GetVersionSubminor)(uint32_t * libraryVersionSubminor);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Library_GetMaxConcurrentThreads)(size_t * concurrentThreads);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Library_SetMaxConcurrentThreads)(size_t concurrentThreads);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Library_GetMultiThreadingEnabled)(PEAK_IPL_BOOL8 * enabled);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Library_SetMultiThreadingEnabled)(PEAK_IPL_BOOL8 enabled);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Library_GetSIMDEnabled)(PEAK_IPL_BOOL8 * enabled);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Library_SetSIMDEnabled)(PEAK_IPL_BOOL8 enabled);

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

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ImageConverter_Construct)(PEAK_IPL_IMAGE_CONVERTER_HANDLE * imageConverterHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ImageConverter_Acquire)(PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle);

typedef PEAK_IPL_C_API (*dyn_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);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ImageConverter_GetConversionMode)(PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle, PEAK_IPL_CONVERSION_MODE * conversionMode);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ImageConverter_SetConversionMode)(PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle, PEAK_IPL_CONVERSION_MODE conversionMode);

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

typedef PEAK_IPL_C_API (*dyn_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);

typedef PEAK_IPL_C_API (*dyn_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);

typedef PEAK_IPL_C_API (*dyn_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);

typedef PEAK_IPL_C_API (*dyn_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);

typedef PEAK_IPL_C_API (*dyn_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);

typedef PEAK_IPL_C_API (*dyn_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);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ImageConverter_Destruct)(PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_AdaptiveHotpixelCorrector_Construct)(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE * adaptiveHotpixelCorrectorHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_AdaptiveHotpixelCorrector_Acquire)(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_AdaptiveHotpixelCorrector_SetSensitivity)(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_HOTPIXELCORRECTION_SENSITIVITY sensitivityLevel);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_AdaptiveHotpixelCorrector_GetSensitivity)(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_HOTPIXELCORRECTION_SENSITIVITY * sensitivityLevel);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_AdaptiveHotpixelCorrector_SetGainFactorPercent)(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, uint32_t gainFactorPercent);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_AdaptiveHotpixelCorrector_GetGainFactorPercent)(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, uint32_t * gainFactorPercent);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_AdaptiveHotpixelCorrector_Detect)(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_IMAGE_HANDLE inputImageHandle);

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

typedef PEAK_IPL_C_API (*dyn_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);

typedef PEAK_IPL_C_API (*dyn_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);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_AdaptiveHotpixelCorrector_CorrectAdaptive)(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_IMAGE_HANDLE inputImageHandle, PEAK_IPL_IMAGE_HANDLE * outputImageHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_AdaptiveHotpixelCorrector_CorrectAdaptiveInPlace)(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_IMAGE_HANDLE inputImageHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_AdaptiveHotpixelCorrector_Destruct)(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ColorCorrector_Construct)(PEAK_IPL_COLOR_CORRECTOR_HANDLE * colorCorrectorHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ColorCorrector_Acquire)(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ColorCorrector_SetColorCorrectionFactors)(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, float * colorCorrectorFactors);

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

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

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ColorCorrector_Process)(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE * outputImageHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ColorCorrector_ProcessInPlace)(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, PEAK_IPL_IMAGE_HANDLE imageHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ColorCorrector_Destruct)(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ColorCorrector_GetSaturation)(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, float * saturation);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ColorCorrector_GetSaturationMin)(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, float * saturationMin);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ColorCorrector_GetSaturationMax)(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, float * saturationMax);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ColorCorrector_SetSaturation)(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, float saturation);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Binning_Construct)(PEAK_IPL_BINNING_HANDLE * binningHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Binning_Acquire)(PEAK_IPL_BINNING_HANDLE binningHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Binning_SetBinningX)(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t * binningXValue);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Binning_GetBinningX)(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t * binningXValue);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Binning_SetBinningY)(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t * binningYValue);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Binning_GetBinningY)(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t * binningYValue);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Binning_GetBinningMin)(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t * binningMin);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Binning_GetBinningMax)(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t * binningMax);

typedef PEAK_IPL_C_API (*dyn_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);

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

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Binning_SetBinningMode)(PEAK_IPL_BINNING_HANDLE binningHandle, PEAK_IPL_BINNINGMODE * mode);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Binning_GetBinningMode)(PEAK_IPL_BINNING_HANDLE binningHandle, PEAK_IPL_BINNINGMODE * mode);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Binning_Process)(PEAK_IPL_BINNING_HANDLE binningHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE * outputImageHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Binning_Destruct)(PEAK_IPL_BINNING_HANDLE binningHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Decimation_Construct)(PEAK_IPL_DECIMATION_HANDLE * decimationHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Decimation_Acquire)(PEAK_IPL_DECIMATION_HANDLE decimationHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Decimation_SetDecimationX)(PEAK_IPL_DECIMATION_HANDLE decimationHandle, uint8_t * decimationXValue);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Decimation_GetDecimationX)(PEAK_IPL_DECIMATION_HANDLE decimationHandle, uint8_t * decimationXValue);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Decimation_SetDecimationY)(PEAK_IPL_DECIMATION_HANDLE decimationHandle, uint8_t * decimationYValue);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Decimation_GetDecimationY)(PEAK_IPL_DECIMATION_HANDLE decimationHandle, uint8_t * decimationYValue);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Decimation_GetDecimationMin)(PEAK_IPL_DECIMATION_HANDLE decimationHandle, uint8_t * decimationMin);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Decimation_GetDecimationMax)(PEAK_IPL_DECIMATION_HANDLE decimationHandle, uint8_t * decimationMax);

typedef PEAK_IPL_C_API (*dyn_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);

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

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Decimation_Process)(PEAK_IPL_DECIMATION_HANDLE decimationHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE * outputImageHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Decimation_Destruct)(PEAK_IPL_DECIMATION_HANDLE decimationHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Gain_Construct)(PEAK_IPL_GAIN_HANDLE * gainHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Gain_Acquire)(PEAK_IPL_GAIN_HANDLE gainHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Gain_SetMasterGainValue)(PEAK_IPL_GAIN_HANDLE gainHandle, float * masterGainValue);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Gain_GetMasterGainValue)(PEAK_IPL_GAIN_HANDLE gainHandle, float * masterGainValue);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Gain_GetMasterGainMax)(PEAK_IPL_GAIN_HANDLE gainHandle, float * masterGainMax);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Gain_GetMasterGainMin)(PEAK_IPL_GAIN_HANDLE gainHandle, float * masterGainMin);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Gain_SetRedGainValue)(PEAK_IPL_GAIN_HANDLE gainHandle, float * redGainValue);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Gain_GetRedGainValue)(PEAK_IPL_GAIN_HANDLE gainHandle, float * redGainValue);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Gain_GetRedGainMax)(PEAK_IPL_GAIN_HANDLE gainHandle, float * redGainMax);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Gain_GetRedGainMin)(PEAK_IPL_GAIN_HANDLE gainHandle, float * redGainMin);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Gain_SetGreenGainValue)(PEAK_IPL_GAIN_HANDLE gainHandle, float * greenGainValue);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Gain_GetGreenGainValue)(PEAK_IPL_GAIN_HANDLE gainHandle, float * greenGainValue);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Gain_GetGreenGainMax)(PEAK_IPL_GAIN_HANDLE gainHandle, float * greenGainMax);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Gain_GetGreenGainMin)(PEAK_IPL_GAIN_HANDLE gainHandle, float * greenGainMin);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Gain_SetBlueGainValue)(PEAK_IPL_GAIN_HANDLE gainHandle, float * blueGainValue);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Gain_GetBlueGainValue)(PEAK_IPL_GAIN_HANDLE gainHandle, float * blueGainValue);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Gain_GetBlueGainMax)(PEAK_IPL_GAIN_HANDLE gainHandle, float * blueGainMax);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Gain_GetBlueGainMin)(PEAK_IPL_GAIN_HANDLE gainHandle, float * blueGainMin);

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

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Gain_Process)(PEAK_IPL_GAIN_HANDLE gainHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE * outputImageHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Gain_ProcessInPlace)(PEAK_IPL_GAIN_HANDLE gainHandle, PEAK_IPL_IMAGE_HANDLE imageHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Gain_Destruct)(PEAK_IPL_GAIN_HANDLE gainHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_GammaCorrector_Construct)(PEAK_IPL_GAMMA_CORRECTOR_HANDLE * gammaCorrectorHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_GammaCorrector_Acquire)(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_GammaCorrector_SetGammaCorrectionValue)(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float * gammaValue);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_GammaCorrector_GetGammaCorrectionValue)(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float * gammaValue);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_GammaCorrector_GetGammaCorrectionMax)(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float * gammaMax);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_GammaCorrector_GetGammaCorrectionMin)(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float * gammaMin);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_GammaCorrector_SetDigitalBlack)(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float * digitalBlackValue);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_GammaCorrector_GetDigitalBlack)(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float * digitalBlackValue);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_GammaCorrector_GetDigitalBlackMax)(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float * digitalBlackMax);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_GammaCorrector_GetDigitalBlackMin)(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float * digitalBlackMin);

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

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_GammaCorrector_Process)(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE * outputImageHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_GammaCorrector_ProcessInPlace)(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, PEAK_IPL_IMAGE_HANDLE imageHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_GammaCorrector_Destruct)(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle);

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

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Image_Acquire)(PEAK_IPL_IMAGE_HANDLE imageHandle);

typedef PEAK_IPL_C_API (*dyn_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);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Image_GetWidth)(PEAK_IPL_IMAGE_HANDLE imageHandle, size_t * width);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Image_GetHeight)(PEAK_IPL_IMAGE_HANDLE imageHandle, size_t * height);

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

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Image_GetByteCount)(PEAK_IPL_IMAGE_HANDLE imageHandle, size_t * byteCount);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Image_GetPixelFormat)(PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_PIXEL_FORMAT * pixelFormat);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Image_GetData)(PEAK_IPL_IMAGE_HANDLE imageHandle, uint8_t * * data);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Image_Clone)(PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE * outputImageHandle);

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

typedef PEAK_IPL_C_API (*dyn_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);

typedef PEAK_IPL_C_API (*dyn_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);

typedef PEAK_IPL_C_API (*dyn_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);

typedef PEAK_IPL_C_API (*dyn_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);

typedef PEAK_IPL_C_API (*dyn_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);

typedef PEAK_IPL_C_API (*dyn_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);

typedef PEAK_IPL_C_API (*dyn_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);

typedef PEAK_IPL_C_API (*dyn_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);

typedef PEAK_IPL_C_API (*dyn_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);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Image_Destruct)(PEAK_IPL_IMAGE_HANDLE imageHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ImageTransformer_Construct)(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE * imageTransformerHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ImageTransformer_Acquire)(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Image_SetTimestamp)(PEAK_IPL_IMAGE_HANDLE imageHandle, uint64_t timestamp_ns);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Image_GetTimestamp)(PEAK_IPL_IMAGE_HANDLE imageHandle, uint64_t * timestamp_ns);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ImageTransformer_MirrorUpDown)(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE * outputImageHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ImageTransformer_MirrorLeftRight)(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE * outputImageHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ImageTransformer_MirrorUpDownLeftRight)(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE * outputImageHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ImageTransformer_MirrorUpDownInPlace)(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle, PEAK_IPL_IMAGE_HANDLE imageHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ImageTransformer_MirrorLeftRightInPlace)(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle, PEAK_IPL_IMAGE_HANDLE imageHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ImageTransformer_MirrorUpDownLeftRightInPlace)(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle, PEAK_IPL_IMAGE_HANDLE imageHandle);

typedef PEAK_IPL_C_API (*dyn_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);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ImageTransformer_RotateInPlace)(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, enum PEAK_IPL_IMAGE_TRANSFORMER_ROTATION_ANGLE_t rotationAngle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ImageTransformer_Destruct)(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Histogram_Construct)(PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_HISTOGRAM_HANDLE * histogramHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Histogram_Acquire)(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Histogram_GetPixelFormat)(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle, PEAK_IPL_PIXEL_FORMAT * pixelFormat);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Histogram_GetNumChannels)(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle, size_t * numChannels);

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

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

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

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Histogram_Destruct)(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle);

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

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_PixelLine_Acquire)(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_PixelLine_GetPixelFormat)(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle, PEAK_IPL_PIXEL_FORMAT * pixelFormat);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_PixelLine_GetOrientation)(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle, PEAK_IPL_ORIENTATION * orientation);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_PixelLine_GetOffset)(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle, size_t * offset);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_PixelLine_GetNumChannels)(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle, size_t * numChannels);

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

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_PixelLine_Destruct)(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_PixelFormat_GetNumChannels)(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t * numChannels);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_PixelFormat_GetNumSignificantBitsPerChannel)(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t * numSignificantBits);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_PixelFormat_GetNumStorageBitsPerChannel)(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t * numStorageBits);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_PixelFormat_GetMaximumValuePerChannel)(PEAK_IPL_PIXEL_FORMAT pixelFormat, uint32_t * channelMaximumValue);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_PixelFormat_GetNumSignificantBitsPerPixel)(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t * numSignificantBits);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_PixelFormat_GetNumStorageBitsPerPixel)(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t * numStorageBits);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_PixelFormat_GetEndianness)(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_ENDIANNESS * endianness);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_PixelFormat_CalculateStorageSizeOfPixels)(PEAK_IPL_PIXEL_FORMAT pixelFormat, uint64_t numPixels, uint64_t * size);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_PixelFormat_IsPacked)(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 * isPacked);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_PixelFormat_IsBayered)(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 * isBayered);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_PixelFormat_IsYUV)(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 * isYUV);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_PixelFormat_IsCoord3D)(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 * isCoord3D);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_PixelFormat_IsFloat)(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 * isFloat);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_PixelFormat_GetBayerPattern)(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BAYER_PATTERN * pattern);

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

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

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

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

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

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

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

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

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_VideoWriter_Video_IsOpen)(PEAK_IPL_VIDEO_HANDLE videoHandle, PEAK_IPL_BOOL8 * isOpen);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_VideoWriter_Video_Close)(PEAK_IPL_VIDEO_HANDLE videoHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_VideoWriter_Video_Append)(PEAK_IPL_VIDEO_HANDLE videoHandle, PEAK_IPL_IMAGE_HANDLE imageHandle);

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

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

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

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

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

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

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

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

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

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_VideoWriter_Video_GetEncodedFrames)(PEAK_IPL_VIDEO_HANDLE videoHandle, uint64_t * numFrames);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_VideoWriter_Video_GetDroppedFrames)(PEAK_IPL_VIDEO_HANDLE videoHandle, uint64_t * numFrames);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_VideoWriter_Video_GetFileSize)(PEAK_IPL_VIDEO_HANDLE videoHandle, uint64_t * fileSize);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_VideoWriter_Video_ResetFrameCounters)(PEAK_IPL_VIDEO_HANDLE videoHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_VideoWriter_Queue_SetSize)(PEAK_IPL_VIDEO_HANDLE videoHandle, int32_t size);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_VideoWriter_Queue_GetSize)(PEAK_IPL_VIDEO_HANDLE videoHandle, int32_t * size);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_VideoWriter_Queue_GetRange)(PEAK_IPL_VIDEO_HANDLE videoHandle, int32_t * minSize, int32_t * maxSize);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_VideoWriter_Queue_GetQueued)(PEAK_IPL_VIDEO_HANDLE videoHandle, int32_t * queued);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_VideoWriter_Video_WaitUntilFrameDone)(PEAK_IPL_VIDEO_HANDLE videoHandle, int32_t timeout_ms);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_VideoWriter_Video_WaitUntilQueueEmpty)(PEAK_IPL_VIDEO_HANDLE videoHandle, int32_t timeout_ms);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ImageSharpness_Construct)(PEAK_IPL_SHARPNESS_HANDLE * handle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ImageSharpness_Acquire)(PEAK_IPL_SHARPNESS_HANDLE handle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ImageSharpness_Destruct)(PEAK_IPL_SHARPNESS_HANDLE handle);

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

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

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

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ImageSharpness_SetAlgorithm)(PEAK_IPL_SHARPNESS_HANDLE handle, PEAK_IPL_SHARPNESS_ALGORITHM algorithm);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ImageSharpness_GetAlgorithm)(PEAK_IPL_SHARPNESS_HANDLE handle, PEAK_IPL_SHARPNESS_ALGORITHM * algorithm);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ImageSharpness_GetROIMinimumSize)(PEAK_IPL_SHARPNESS_HANDLE handle, struct PEAK_IPL_SIZE_2D * min_size);

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

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

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_EdgeEnhancement_Construct)(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE * handle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_EdgeEnhancement_Acquire)(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_EdgeEnhancement_Destruct)(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_EdgeEnhancement_ProcessInPlace)(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle, PEAK_IPL_IMAGE_HANDLE imageHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_EdgeEnhancement_Process)(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE * outputImageHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_EdgeEnhancement_GetFactorRange)(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle, struct PEAK_IPL_RANGE * range);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_EdgeEnhancement_SetFactor)(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle, uint32_t factor);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_EdgeEnhancement_GetFactor)(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle, uint32_t * factor);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_EdgeEnhancement_GetDefaultFactor)(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle, uint32_t * factor);

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

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Lut_Construct)(PEAK_IPL_LUT_HANDLE * lutHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Lut_Acquire)(PEAK_IPL_LUT_HANDLE lutHandle);

typedef PEAK_IPL_C_API (*dyn_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);

typedef PEAK_IPL_C_API (*dyn_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);

typedef PEAK_IPL_C_API (*dyn_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);

typedef PEAK_IPL_C_API (*dyn_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);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Lut_SetLutPreset)(PEAK_IPL_LUT_HANDLE lutHandle, PEAK_IPL_LUT_SELECTOR lutSelector, PEAK_IPL_LUT_PRESET preset);

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

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Lut_Process)(PEAK_IPL_LUT_HANDLE lutHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE * outputImageHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Lut_ProcessInPlace)(PEAK_IPL_LUT_HANDLE lutHandle, PEAK_IPL_IMAGE_HANDLE imageHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Lut_Destruct)(PEAK_IPL_LUT_HANDLE lutHandle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ChromaticAdapter_Construct)(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE * handle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ChromaticAdapter_Acquire)(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE handle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ChromaticAdapter_Destruct)(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE handle);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ChromaticAdapter_GetTargetColorSpace)(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE handle, PEAK_IPL_CHROMATIC_ADAPTER_COLOR_SPACE * colorSpace);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ChromaticAdapter_SetTargetColorSpace)(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE handle, PEAK_IPL_CHROMATIC_ADAPTER_COLOR_SPACE colorSpace);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ChromaticAdapter_GetAdaptionAlgorithm)(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE handle, PEAK_IPL_CHROMATIC_ADAPTER_ALGORITHM * algorithm);

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ChromaticAdapter_SetAdaptionAlgorithm)(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE handle, PEAK_IPL_CHROMATIC_ADAPTER_ALGORITHM model);

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

typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ChromaticAdapter_GetTemperatureRange)(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE handle, uint32_t * minTemperature, uint32_t * maxTemperature, uint32_t * incTemperature);


class LoadLibraryException : public std::runtime_error {

    using std::runtime_error::runtime_error;

};


class DynamicLoader

{

private:

    DynamicLoader();


    static DynamicLoader& instance()

    {

        static DynamicLoader dynamicLoader{};

        return dynamicLoader;

    }

    bool loadLib(const char* file);

    void unload();

    bool setPointers(bool load);


public:

    ~DynamicLoader();


    static bool isLoaded();


    static PEAK_IPL_C_API PEAK_IPL_Library_GetVersionMajor(uint32_t * libraryVersionMajor);

    static PEAK_IPL_C_API PEAK_IPL_Library_GetVersionMinor(uint32_t * libraryVersionMinor);

    static PEAK_IPL_C_API PEAK_IPL_Library_GetVersionSubminor(uint32_t * libraryVersionSubminor);

    static PEAK_IPL_C_API PEAK_IPL_Library_GetMaxConcurrentThreads(size_t * concurrentThreads);

    static PEAK_IPL_C_API PEAK_IPL_Library_SetMaxConcurrentThreads(size_t concurrentThreads);

    static PEAK_IPL_C_API PEAK_IPL_Library_GetMultiThreadingEnabled(PEAK_IPL_BOOL8 * enabled);

    static PEAK_IPL_C_API PEAK_IPL_Library_SetMultiThreadingEnabled(PEAK_IPL_BOOL8 enabled);

    static PEAK_IPL_C_API PEAK_IPL_Library_GetSIMDEnabled(PEAK_IPL_BOOL8 * enabled);

    static PEAK_IPL_C_API PEAK_IPL_Library_SetSIMDEnabled(PEAK_IPL_BOOL8 enabled);

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

    static PEAK_IPL_C_API PEAK_IPL_ImageConverter_Construct(PEAK_IPL_IMAGE_CONVERTER_HANDLE * imageConverterHandle);

    static PEAK_IPL_C_API PEAK_IPL_ImageConverter_Acquire(PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle);

    static 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);

    static PEAK_IPL_C_API PEAK_IPL_ImageConverter_GetConversionMode(PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle, PEAK_IPL_CONVERSION_MODE * conversionMode);

    static PEAK_IPL_C_API PEAK_IPL_ImageConverter_SetConversionMode(PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle, PEAK_IPL_CONVERSION_MODE conversionMode);

    static 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);

    static 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);

    static 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);

    static 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);

    static 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);

    static 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);

    static 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);

    static PEAK_IPL_C_API PEAK_IPL_ImageConverter_Destruct(PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle);

    static PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_Construct(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE * adaptiveHotpixelCorrectorHandle);

    static PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_Acquire(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle);

    static PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_SetSensitivity(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_HOTPIXELCORRECTION_SENSITIVITY sensitivityLevel);

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

    static PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_SetGainFactorPercent(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, uint32_t gainFactorPercent);

    static PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_GetGainFactorPercent(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, uint32_t * gainFactorPercent);

    static PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_Detect(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_IMAGE_HANDLE inputImageHandle);

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

    static 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);

    static 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);

    static 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);

    static PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_CorrectAdaptiveInPlace(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_IMAGE_HANDLE inputImageHandle);

    static PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_Destruct(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle);

    static PEAK_IPL_C_API PEAK_IPL_ColorCorrector_Construct(PEAK_IPL_COLOR_CORRECTOR_HANDLE * colorCorrectorHandle);

    static PEAK_IPL_C_API PEAK_IPL_ColorCorrector_Acquire(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle);

    static PEAK_IPL_C_API PEAK_IPL_ColorCorrector_SetColorCorrectionFactors(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, float * colorCorrectorFactors);

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

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

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

    static PEAK_IPL_C_API PEAK_IPL_ColorCorrector_ProcessInPlace(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, PEAK_IPL_IMAGE_HANDLE imageHandle);

    static PEAK_IPL_C_API PEAK_IPL_ColorCorrector_Destruct(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle);

    static PEAK_IPL_C_API PEAK_IPL_ColorCorrector_GetSaturation(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, float * saturation);

    static PEAK_IPL_C_API PEAK_IPL_ColorCorrector_GetSaturationMin(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, float * saturationMin);

    static PEAK_IPL_C_API PEAK_IPL_ColorCorrector_GetSaturationMax(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, float * saturationMax);

    static PEAK_IPL_C_API PEAK_IPL_ColorCorrector_SetSaturation(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, float saturation);

    static PEAK_IPL_C_API PEAK_IPL_Binning_Construct(PEAK_IPL_BINNING_HANDLE * binningHandle);

    static PEAK_IPL_C_API PEAK_IPL_Binning_Acquire(PEAK_IPL_BINNING_HANDLE binningHandle);

    static PEAK_IPL_C_API PEAK_IPL_Binning_SetBinningX(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t * binningXValue);

    static PEAK_IPL_C_API PEAK_IPL_Binning_GetBinningX(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t * binningXValue);

    static PEAK_IPL_C_API PEAK_IPL_Binning_SetBinningY(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t * binningYValue);

    static PEAK_IPL_C_API PEAK_IPL_Binning_GetBinningY(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t * binningYValue);

    static PEAK_IPL_C_API PEAK_IPL_Binning_GetBinningMin(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t * binningMin);

    static PEAK_IPL_C_API PEAK_IPL_Binning_GetBinningMax(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t * binningMax);

    static 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);

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

    static PEAK_IPL_C_API PEAK_IPL_Binning_SetBinningMode(PEAK_IPL_BINNING_HANDLE binningHandle, PEAK_IPL_BINNINGMODE * mode);

    static PEAK_IPL_C_API PEAK_IPL_Binning_GetBinningMode(PEAK_IPL_BINNING_HANDLE binningHandle, PEAK_IPL_BINNINGMODE * mode);

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

    static PEAK_IPL_C_API PEAK_IPL_Binning_Destruct(PEAK_IPL_BINNING_HANDLE binningHandle);

    static PEAK_IPL_C_API PEAK_IPL_Decimation_Construct(PEAK_IPL_DECIMATION_HANDLE * decimationHandle);

    static PEAK_IPL_C_API PEAK_IPL_Decimation_Acquire(PEAK_IPL_DECIMATION_HANDLE decimationHandle);

    static PEAK_IPL_C_API PEAK_IPL_Decimation_SetDecimationX(PEAK_IPL_DECIMATION_HANDLE decimationHandle, uint8_t * decimationXValue);

    static PEAK_IPL_C_API PEAK_IPL_Decimation_GetDecimationX(PEAK_IPL_DECIMATION_HANDLE decimationHandle, uint8_t * decimationXValue);

    static PEAK_IPL_C_API PEAK_IPL_Decimation_SetDecimationY(PEAK_IPL_DECIMATION_HANDLE decimationHandle, uint8_t * decimationYValue);

    static PEAK_IPL_C_API PEAK_IPL_Decimation_GetDecimationY(PEAK_IPL_DECIMATION_HANDLE decimationHandle, uint8_t * decimationYValue);

    static PEAK_IPL_C_API PEAK_IPL_Decimation_GetDecimationMin(PEAK_IPL_DECIMATION_HANDLE decimationHandle, uint8_t * decimationMin);

    static PEAK_IPL_C_API PEAK_IPL_Decimation_GetDecimationMax(PEAK_IPL_DECIMATION_HANDLE decimationHandle, uint8_t * decimationMax);

    static 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);

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

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

    static PEAK_IPL_C_API PEAK_IPL_Decimation_Destruct(PEAK_IPL_DECIMATION_HANDLE decimationHandle);

    static PEAK_IPL_C_API PEAK_IPL_Gain_Construct(PEAK_IPL_GAIN_HANDLE * gainHandle);

    static PEAK_IPL_C_API PEAK_IPL_Gain_Acquire(PEAK_IPL_GAIN_HANDLE gainHandle);

    static PEAK_IPL_C_API PEAK_IPL_Gain_SetMasterGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float * masterGainValue);

    static PEAK_IPL_C_API PEAK_IPL_Gain_GetMasterGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float * masterGainValue);

    static PEAK_IPL_C_API PEAK_IPL_Gain_GetMasterGainMax(PEAK_IPL_GAIN_HANDLE gainHandle, float * masterGainMax);

    static PEAK_IPL_C_API PEAK_IPL_Gain_GetMasterGainMin(PEAK_IPL_GAIN_HANDLE gainHandle, float * masterGainMin);

    static PEAK_IPL_C_API PEAK_IPL_Gain_SetRedGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float * redGainValue);

    static PEAK_IPL_C_API PEAK_IPL_Gain_GetRedGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float * redGainValue);

    static PEAK_IPL_C_API PEAK_IPL_Gain_GetRedGainMax(PEAK_IPL_GAIN_HANDLE gainHandle, float * redGainMax);

    static PEAK_IPL_C_API PEAK_IPL_Gain_GetRedGainMin(PEAK_IPL_GAIN_HANDLE gainHandle, float * redGainMin);

    static PEAK_IPL_C_API PEAK_IPL_Gain_SetGreenGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float * greenGainValue);

    static PEAK_IPL_C_API PEAK_IPL_Gain_GetGreenGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float * greenGainValue);

    static PEAK_IPL_C_API PEAK_IPL_Gain_GetGreenGainMax(PEAK_IPL_GAIN_HANDLE gainHandle, float * greenGainMax);

    static PEAK_IPL_C_API PEAK_IPL_Gain_GetGreenGainMin(PEAK_IPL_GAIN_HANDLE gainHandle, float * greenGainMin);

    static PEAK_IPL_C_API PEAK_IPL_Gain_SetBlueGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float * blueGainValue);

    static PEAK_IPL_C_API PEAK_IPL_Gain_GetBlueGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float * blueGainValue);

    static PEAK_IPL_C_API PEAK_IPL_Gain_GetBlueGainMax(PEAK_IPL_GAIN_HANDLE gainHandle, float * blueGainMax);

    static PEAK_IPL_C_API PEAK_IPL_Gain_GetBlueGainMin(PEAK_IPL_GAIN_HANDLE gainHandle, float * blueGainMin);

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

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

    static PEAK_IPL_C_API PEAK_IPL_Gain_ProcessInPlace(PEAK_IPL_GAIN_HANDLE gainHandle, PEAK_IPL_IMAGE_HANDLE imageHandle);

    static PEAK_IPL_C_API PEAK_IPL_Gain_Destruct(PEAK_IPL_GAIN_HANDLE gainHandle);

    static PEAK_IPL_C_API PEAK_IPL_GammaCorrector_Construct(PEAK_IPL_GAMMA_CORRECTOR_HANDLE * gammaCorrectorHandle);

    static PEAK_IPL_C_API PEAK_IPL_GammaCorrector_Acquire(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle);

    static PEAK_IPL_C_API PEAK_IPL_GammaCorrector_SetGammaCorrectionValue(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float * gammaValue);

    static PEAK_IPL_C_API PEAK_IPL_GammaCorrector_GetGammaCorrectionValue(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float * gammaValue);

    static PEAK_IPL_C_API PEAK_IPL_GammaCorrector_GetGammaCorrectionMax(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float * gammaMax);

    static PEAK_IPL_C_API PEAK_IPL_GammaCorrector_GetGammaCorrectionMin(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float * gammaMin);

    static PEAK_IPL_C_API PEAK_IPL_GammaCorrector_SetDigitalBlack(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float * digitalBlackValue);

    static PEAK_IPL_C_API PEAK_IPL_GammaCorrector_GetDigitalBlack(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float * digitalBlackValue);

    static PEAK_IPL_C_API PEAK_IPL_GammaCorrector_GetDigitalBlackMax(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float * digitalBlackMax);

    static PEAK_IPL_C_API PEAK_IPL_GammaCorrector_GetDigitalBlackMin(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float * digitalBlackMin);

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

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

    static PEAK_IPL_C_API PEAK_IPL_GammaCorrector_ProcessInPlace(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, PEAK_IPL_IMAGE_HANDLE imageHandle);

    static PEAK_IPL_C_API PEAK_IPL_GammaCorrector_Destruct(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle);

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

    static PEAK_IPL_C_API PEAK_IPL_Image_Acquire(PEAK_IPL_IMAGE_HANDLE imageHandle);

    static 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);

    static PEAK_IPL_C_API PEAK_IPL_Image_GetWidth(PEAK_IPL_IMAGE_HANDLE imageHandle, size_t * width);

    static PEAK_IPL_C_API PEAK_IPL_Image_GetHeight(PEAK_IPL_IMAGE_HANDLE imageHandle, size_t * height);

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

    static PEAK_IPL_C_API PEAK_IPL_Image_GetByteCount(PEAK_IPL_IMAGE_HANDLE imageHandle, size_t * byteCount);

    static PEAK_IPL_C_API PEAK_IPL_Image_GetPixelFormat(PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_PIXEL_FORMAT * pixelFormat);

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

    static PEAK_IPL_C_API PEAK_IPL_Image_Clone(PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE * outputImageHandle);

    static 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);

    static 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);

    static 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);

    static 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);

    static 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);

    static 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);

    static 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);

    static 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);

    static 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);

    static 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);

    static PEAK_IPL_C_API PEAK_IPL_Image_Destruct(PEAK_IPL_IMAGE_HANDLE imageHandle);

    static PEAK_IPL_C_API PEAK_IPL_ImageTransformer_Construct(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE * imageTransformerHandle);

    static PEAK_IPL_C_API PEAK_IPL_ImageTransformer_Acquire(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle);

    static PEAK_IPL_C_API PEAK_IPL_Image_SetTimestamp(PEAK_IPL_IMAGE_HANDLE imageHandle, uint64_t timestamp_ns);

    static PEAK_IPL_C_API PEAK_IPL_Image_GetTimestamp(PEAK_IPL_IMAGE_HANDLE imageHandle, uint64_t * timestamp_ns);

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

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

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

    static PEAK_IPL_C_API PEAK_IPL_ImageTransformer_MirrorUpDownInPlace(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle, PEAK_IPL_IMAGE_HANDLE imageHandle);

    static PEAK_IPL_C_API PEAK_IPL_ImageTransformer_MirrorLeftRightInPlace(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle, PEAK_IPL_IMAGE_HANDLE imageHandle);

    static PEAK_IPL_C_API PEAK_IPL_ImageTransformer_MirrorUpDownLeftRightInPlace(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle, PEAK_IPL_IMAGE_HANDLE imageHandle);

    static 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);

    static 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);

    static PEAK_IPL_C_API PEAK_IPL_ImageTransformer_Destruct(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle);

    static PEAK_IPL_C_API PEAK_IPL_Histogram_Construct(PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_HISTOGRAM_HANDLE * histogramHandle);

    static PEAK_IPL_C_API PEAK_IPL_Histogram_Acquire(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle);

    static PEAK_IPL_C_API PEAK_IPL_Histogram_GetPixelFormat(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle, PEAK_IPL_PIXEL_FORMAT * pixelFormat);

    static PEAK_IPL_C_API PEAK_IPL_Histogram_GetNumChannels(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle, size_t * numChannels);

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

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

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

    static PEAK_IPL_C_API PEAK_IPL_Histogram_Destruct(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle);

    static 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);

    static PEAK_IPL_C_API PEAK_IPL_PixelLine_Acquire(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle);

    static PEAK_IPL_C_API PEAK_IPL_PixelLine_GetPixelFormat(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle, PEAK_IPL_PIXEL_FORMAT * pixelFormat);

    static PEAK_IPL_C_API PEAK_IPL_PixelLine_GetOrientation(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle, PEAK_IPL_ORIENTATION * orientation);

    static PEAK_IPL_C_API PEAK_IPL_PixelLine_GetOffset(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle, size_t * offset);

    static PEAK_IPL_C_API PEAK_IPL_PixelLine_GetNumChannels(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle, size_t * numChannels);

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

    static PEAK_IPL_C_API PEAK_IPL_PixelLine_Destruct(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle);

    static PEAK_IPL_C_API PEAK_IPL_PixelFormat_GetNumChannels(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t * numChannels);

    static PEAK_IPL_C_API PEAK_IPL_PixelFormat_GetNumSignificantBitsPerChannel(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t * numSignificantBits);

    static PEAK_IPL_C_API PEAK_IPL_PixelFormat_GetNumStorageBitsPerChannel(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t * numStorageBits);

    static PEAK_IPL_C_API PEAK_IPL_PixelFormat_GetMaximumValuePerChannel(PEAK_IPL_PIXEL_FORMAT pixelFormat, uint32_t * channelMaximumValue);

    static PEAK_IPL_C_API PEAK_IPL_PixelFormat_GetNumSignificantBitsPerPixel(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t * numSignificantBits);

    static PEAK_IPL_C_API PEAK_IPL_PixelFormat_GetNumStorageBitsPerPixel(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t * numStorageBits);

    static PEAK_IPL_C_API PEAK_IPL_PixelFormat_GetEndianness(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_ENDIANNESS * endianness);

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

    static PEAK_IPL_C_API PEAK_IPL_PixelFormat_IsPacked(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 * isPacked);

    static PEAK_IPL_C_API PEAK_IPL_PixelFormat_IsBayered(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 * isBayered);

    static PEAK_IPL_C_API PEAK_IPL_PixelFormat_IsYUV(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 * isYUV);

    static PEAK_IPL_C_API PEAK_IPL_PixelFormat_IsCoord3D(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 * isCoord3D);

    static PEAK_IPL_C_API PEAK_IPL_PixelFormat_IsFloat(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 * isFloat);

    static PEAK_IPL_C_API PEAK_IPL_PixelFormat_GetBayerPattern(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BAYER_PATTERN * pattern);

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

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

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

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

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

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

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

    static 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);

    static PEAK_IPL_C_API PEAK_IPL_VideoWriter_Video_IsOpen(PEAK_IPL_VIDEO_HANDLE videoHandle, PEAK_IPL_BOOL8 * isOpen);

    static PEAK_IPL_C_API PEAK_IPL_VideoWriter_Video_Close(PEAK_IPL_VIDEO_HANDLE videoHandle);

    static PEAK_IPL_C_API PEAK_IPL_VideoWriter_Video_Append(PEAK_IPL_VIDEO_HANDLE videoHandle, PEAK_IPL_IMAGE_HANDLE imageHandle);

    static 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);

    static 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);

    static 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);

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

    static 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);

    static 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);

    static 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);

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

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

    static PEAK_IPL_C_API PEAK_IPL_VideoWriter_Video_GetEncodedFrames(PEAK_IPL_VIDEO_HANDLE videoHandle, uint64_t * numFrames);

    static PEAK_IPL_C_API PEAK_IPL_VideoWriter_Video_GetDroppedFrames(PEAK_IPL_VIDEO_HANDLE videoHandle, uint64_t * numFrames);

    static PEAK_IPL_C_API PEAK_IPL_VideoWriter_Video_GetFileSize(PEAK_IPL_VIDEO_HANDLE videoHandle, uint64_t * fileSize);

    static PEAK_IPL_C_API PEAK_IPL_VideoWriter_Video_ResetFrameCounters(PEAK_IPL_VIDEO_HANDLE videoHandle);

    static PEAK_IPL_C_API PEAK_IPL_VideoWriter_Queue_SetSize(PEAK_IPL_VIDEO_HANDLE videoHandle, int32_t size);

    static PEAK_IPL_C_API PEAK_IPL_VideoWriter_Queue_GetSize(PEAK_IPL_VIDEO_HANDLE videoHandle, int32_t * size);

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

    static PEAK_IPL_C_API PEAK_IPL_VideoWriter_Queue_GetQueued(PEAK_IPL_VIDEO_HANDLE videoHandle, int32_t * queued);

    static PEAK_IPL_C_API PEAK_IPL_VideoWriter_Video_WaitUntilFrameDone(PEAK_IPL_VIDEO_HANDLE videoHandle, int32_t timeout_ms);

    static PEAK_IPL_C_API PEAK_IPL_VideoWriter_Video_WaitUntilQueueEmpty(PEAK_IPL_VIDEO_HANDLE videoHandle, int32_t timeout_ms);

    static PEAK_IPL_C_API PEAK_IPL_ImageSharpness_Construct(PEAK_IPL_SHARPNESS_HANDLE * handle);

    static PEAK_IPL_C_API PEAK_IPL_ImageSharpness_Acquire(PEAK_IPL_SHARPNESS_HANDLE handle);

    static PEAK_IPL_C_API PEAK_IPL_ImageSharpness_Destruct(PEAK_IPL_SHARPNESS_HANDLE handle);

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

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

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

    static PEAK_IPL_C_API PEAK_IPL_ImageSharpness_SetAlgorithm(PEAK_IPL_SHARPNESS_HANDLE handle, PEAK_IPL_SHARPNESS_ALGORITHM algorithm);

    static PEAK_IPL_C_API PEAK_IPL_ImageSharpness_GetAlgorithm(PEAK_IPL_SHARPNESS_HANDLE handle, PEAK_IPL_SHARPNESS_ALGORITHM * algorithm);

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

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

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

    static PEAK_IPL_C_API PEAK_IPL_EdgeEnhancement_Construct(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE * handle);

    static PEAK_IPL_C_API PEAK_IPL_EdgeEnhancement_Acquire(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle);

    static PEAK_IPL_C_API PEAK_IPL_EdgeEnhancement_Destruct(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle);

    static PEAK_IPL_C_API PEAK_IPL_EdgeEnhancement_ProcessInPlace(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle, PEAK_IPL_IMAGE_HANDLE imageHandle);

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

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

    static PEAK_IPL_C_API PEAK_IPL_EdgeEnhancement_SetFactor(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle, uint32_t factor);

    static PEAK_IPL_C_API PEAK_IPL_EdgeEnhancement_GetFactor(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle, uint32_t * factor);

    static PEAK_IPL_C_API PEAK_IPL_EdgeEnhancement_GetDefaultFactor(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle, uint32_t * factor);

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

    static PEAK_IPL_C_API PEAK_IPL_Lut_Construct(PEAK_IPL_LUT_HANDLE * lutHandle);

    static PEAK_IPL_C_API PEAK_IPL_Lut_Acquire(PEAK_IPL_LUT_HANDLE lutHandle);

    static 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);

    static 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);

    static 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);

    static 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);

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

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

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

    static PEAK_IPL_C_API PEAK_IPL_Lut_ProcessInPlace(PEAK_IPL_LUT_HANDLE lutHandle, PEAK_IPL_IMAGE_HANDLE imageHandle);

    static PEAK_IPL_C_API PEAK_IPL_Lut_Destruct(PEAK_IPL_LUT_HANDLE lutHandle);

    static PEAK_IPL_C_API PEAK_IPL_ChromaticAdapter_Construct(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE * handle);

    static PEAK_IPL_C_API PEAK_IPL_ChromaticAdapter_Acquire(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE handle);

    static PEAK_IPL_C_API PEAK_IPL_ChromaticAdapter_Destruct(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE handle);

    static PEAK_IPL_C_API PEAK_IPL_ChromaticAdapter_GetTargetColorSpace(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE handle, PEAK_IPL_CHROMATIC_ADAPTER_COLOR_SPACE * colorSpace);

    static PEAK_IPL_C_API PEAK_IPL_ChromaticAdapter_SetTargetColorSpace(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE handle, PEAK_IPL_CHROMATIC_ADAPTER_COLOR_SPACE colorSpace);

    static PEAK_IPL_C_API PEAK_IPL_ChromaticAdapter_GetAdaptionAlgorithm(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE handle, PEAK_IPL_CHROMATIC_ADAPTER_ALGORITHM * algorithm);

    static PEAK_IPL_C_API PEAK_IPL_ChromaticAdapter_SetAdaptionAlgorithm(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE handle, PEAK_IPL_CHROMATIC_ADAPTER_ALGORITHM model);

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

    static PEAK_IPL_C_API PEAK_IPL_ChromaticAdapter_GetTemperatureRange(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE handle, uint32_t * minTemperature, uint32_t * maxTemperature, uint32_t * incTemperature);


private:

    void* m_handle = nullptr;

    dyn_PEAK_IPL_Library_GetVersionMajor m_PEAK_IPL_Library_GetVersionMajor{};

    dyn_PEAK_IPL_Library_GetVersionMinor m_PEAK_IPL_Library_GetVersionMinor{};

    dyn_PEAK_IPL_Library_GetVersionSubminor m_PEAK_IPL_Library_GetVersionSubminor{};

    dyn_PEAK_IPL_Library_GetMaxConcurrentThreads m_PEAK_IPL_Library_GetMaxConcurrentThreads{};

    dyn_PEAK_IPL_Library_SetMaxConcurrentThreads m_PEAK_IPL_Library_SetMaxConcurrentThreads{};

    dyn_PEAK_IPL_Library_GetMultiThreadingEnabled m_PEAK_IPL_Library_GetMultiThreadingEnabled{};

    dyn_PEAK_IPL_Library_SetMultiThreadingEnabled m_PEAK_IPL_Library_SetMultiThreadingEnabled{};

    dyn_PEAK_IPL_Library_GetSIMDEnabled m_PEAK_IPL_Library_GetSIMDEnabled{};

    dyn_PEAK_IPL_Library_SetSIMDEnabled m_PEAK_IPL_Library_SetSIMDEnabled{};

    dyn_PEAK_IPL_Library_GetLastError m_PEAK_IPL_Library_GetLastError{};

    dyn_PEAK_IPL_ImageConverter_Construct m_PEAK_IPL_ImageConverter_Construct{};

    dyn_PEAK_IPL_ImageConverter_Acquire m_PEAK_IPL_ImageConverter_Acquire{};

    dyn_PEAK_IPL_ImageConverter_PreAllocateConversion m_PEAK_IPL_ImageConverter_PreAllocateConversion{};

    dyn_PEAK_IPL_ImageConverter_GetConversionMode m_PEAK_IPL_ImageConverter_GetConversionMode{};

    dyn_PEAK_IPL_ImageConverter_SetConversionMode m_PEAK_IPL_ImageConverter_SetConversionMode{};

    dyn_PEAK_IPL_ImageConverter_GetSupportedOutputPixelFormats m_PEAK_IPL_ImageConverter_GetSupportedOutputPixelFormats{};

    dyn_PEAK_IPL_ImageConverter_Convert m_PEAK_IPL_ImageConverter_Convert{};

    dyn_PEAK_IPL_ImageConverter_ConvertToBuffer m_PEAK_IPL_ImageConverter_ConvertToBuffer{};

    dyn_PEAK_IPL_ImageConverter_ConvertWithFactorAndOffset m_PEAK_IPL_ImageConverter_ConvertWithFactorAndOffset{};

    dyn_PEAK_IPL_ImageConverter_ConvertToBufferWithFactorAndOffset m_PEAK_IPL_ImageConverter_ConvertToBufferWithFactorAndOffset{};

    dyn_PEAK_IPL_ImageConverter_ConvertFromInterval m_PEAK_IPL_ImageConverter_ConvertFromInterval{};

    dyn_PEAK_IPL_ImageConverter_ConvertToBufferFromInterval m_PEAK_IPL_ImageConverter_ConvertToBufferFromInterval{};

    dyn_PEAK_IPL_ImageConverter_Destruct m_PEAK_IPL_ImageConverter_Destruct{};

    dyn_PEAK_IPL_AdaptiveHotpixelCorrector_Construct m_PEAK_IPL_AdaptiveHotpixelCorrector_Construct{};

    dyn_PEAK_IPL_AdaptiveHotpixelCorrector_Acquire m_PEAK_IPL_AdaptiveHotpixelCorrector_Acquire{};

    dyn_PEAK_IPL_AdaptiveHotpixelCorrector_SetSensitivity m_PEAK_IPL_AdaptiveHotpixelCorrector_SetSensitivity{};

    dyn_PEAK_IPL_AdaptiveHotpixelCorrector_GetSensitivity m_PEAK_IPL_AdaptiveHotpixelCorrector_GetSensitivity{};

    dyn_PEAK_IPL_AdaptiveHotpixelCorrector_SetGainFactorPercent m_PEAK_IPL_AdaptiveHotpixelCorrector_SetGainFactorPercent{};

    dyn_PEAK_IPL_AdaptiveHotpixelCorrector_GetGainFactorPercent m_PEAK_IPL_AdaptiveHotpixelCorrector_GetGainFactorPercent{};

    dyn_PEAK_IPL_AdaptiveHotpixelCorrector_Detect m_PEAK_IPL_AdaptiveHotpixelCorrector_Detect{};

    dyn_PEAK_IPL_AdaptiveHotpixelCorrector_GetHotpixels m_PEAK_IPL_AdaptiveHotpixelCorrector_GetHotpixels{};

    dyn_PEAK_IPL_AdaptiveHotpixelCorrector_Correct m_PEAK_IPL_AdaptiveHotpixelCorrector_Correct{};

    dyn_PEAK_IPL_AdaptiveHotpixelCorrector_CorrectInPlace m_PEAK_IPL_AdaptiveHotpixelCorrector_CorrectInPlace{};

    dyn_PEAK_IPL_AdaptiveHotpixelCorrector_CorrectAdaptive m_PEAK_IPL_AdaptiveHotpixelCorrector_CorrectAdaptive{};

    dyn_PEAK_IPL_AdaptiveHotpixelCorrector_CorrectAdaptiveInPlace m_PEAK_IPL_AdaptiveHotpixelCorrector_CorrectAdaptiveInPlace{};

    dyn_PEAK_IPL_AdaptiveHotpixelCorrector_Destruct m_PEAK_IPL_AdaptiveHotpixelCorrector_Destruct{};

    dyn_PEAK_IPL_ColorCorrector_Construct m_PEAK_IPL_ColorCorrector_Construct{};

    dyn_PEAK_IPL_ColorCorrector_Acquire m_PEAK_IPL_ColorCorrector_Acquire{};

    dyn_PEAK_IPL_ColorCorrector_SetColorCorrectionFactors m_PEAK_IPL_ColorCorrector_SetColorCorrectionFactors{};

    dyn_PEAK_IPL_ColorCorrector_GetColorCorrectionFactors m_PEAK_IPL_ColorCorrector_GetColorCorrectionFactors{};

    dyn_PEAK_IPL_ColorCorrector_GetIsPixelFormatSupported m_PEAK_IPL_ColorCorrector_GetIsPixelFormatSupported{};

    dyn_PEAK_IPL_ColorCorrector_Process m_PEAK_IPL_ColorCorrector_Process{};

    dyn_PEAK_IPL_ColorCorrector_ProcessInPlace m_PEAK_IPL_ColorCorrector_ProcessInPlace{};

    dyn_PEAK_IPL_ColorCorrector_Destruct m_PEAK_IPL_ColorCorrector_Destruct{};

    dyn_PEAK_IPL_ColorCorrector_GetSaturation m_PEAK_IPL_ColorCorrector_GetSaturation{};

    dyn_PEAK_IPL_ColorCorrector_GetSaturationMin m_PEAK_IPL_ColorCorrector_GetSaturationMin{};

    dyn_PEAK_IPL_ColorCorrector_GetSaturationMax m_PEAK_IPL_ColorCorrector_GetSaturationMax{};

    dyn_PEAK_IPL_ColorCorrector_SetSaturation m_PEAK_IPL_ColorCorrector_SetSaturation{};

    dyn_PEAK_IPL_Binning_Construct m_PEAK_IPL_Binning_Construct{};

    dyn_PEAK_IPL_Binning_Acquire m_PEAK_IPL_Binning_Acquire{};

    dyn_PEAK_IPL_Binning_SetBinningX m_PEAK_IPL_Binning_SetBinningX{};

    dyn_PEAK_IPL_Binning_GetBinningX m_PEAK_IPL_Binning_GetBinningX{};

    dyn_PEAK_IPL_Binning_SetBinningY m_PEAK_IPL_Binning_SetBinningY{};

    dyn_PEAK_IPL_Binning_GetBinningY m_PEAK_IPL_Binning_GetBinningY{};

    dyn_PEAK_IPL_Binning_GetBinningMin m_PEAK_IPL_Binning_GetBinningMin{};

    dyn_PEAK_IPL_Binning_GetBinningMax m_PEAK_IPL_Binning_GetBinningMax{};

    dyn_PEAK_IPL_Binning_ExpectedOutputSize m_PEAK_IPL_Binning_ExpectedOutputSize{};

    dyn_PEAK_IPL_Binning_IsPixelformatSupported m_PEAK_IPL_Binning_IsPixelformatSupported{};

    dyn_PEAK_IPL_Binning_SetBinningMode m_PEAK_IPL_Binning_SetBinningMode{};

    dyn_PEAK_IPL_Binning_GetBinningMode m_PEAK_IPL_Binning_GetBinningMode{};

    dyn_PEAK_IPL_Binning_Process m_PEAK_IPL_Binning_Process{};

    dyn_PEAK_IPL_Binning_Destruct m_PEAK_IPL_Binning_Destruct{};

    dyn_PEAK_IPL_Decimation_Construct m_PEAK_IPL_Decimation_Construct{};

    dyn_PEAK_IPL_Decimation_Acquire m_PEAK_IPL_Decimation_Acquire{};

    dyn_PEAK_IPL_Decimation_SetDecimationX m_PEAK_IPL_Decimation_SetDecimationX{};

    dyn_PEAK_IPL_Decimation_GetDecimationX m_PEAK_IPL_Decimation_GetDecimationX{};

    dyn_PEAK_IPL_Decimation_SetDecimationY m_PEAK_IPL_Decimation_SetDecimationY{};

    dyn_PEAK_IPL_Decimation_GetDecimationY m_PEAK_IPL_Decimation_GetDecimationY{};

    dyn_PEAK_IPL_Decimation_GetDecimationMin m_PEAK_IPL_Decimation_GetDecimationMin{};

    dyn_PEAK_IPL_Decimation_GetDecimationMax m_PEAK_IPL_Decimation_GetDecimationMax{};

    dyn_PEAK_IPL_Decimation_ExpectedOutputSize m_PEAK_IPL_Decimation_ExpectedOutputSize{};

    dyn_PEAK_IPL_Decimation_IsPixelformatSupported m_PEAK_IPL_Decimation_IsPixelformatSupported{};

    dyn_PEAK_IPL_Decimation_Process m_PEAK_IPL_Decimation_Process{};

    dyn_PEAK_IPL_Decimation_Destruct m_PEAK_IPL_Decimation_Destruct{};

    dyn_PEAK_IPL_Gain_Construct m_PEAK_IPL_Gain_Construct{};

    dyn_PEAK_IPL_Gain_Acquire m_PEAK_IPL_Gain_Acquire{};

    dyn_PEAK_IPL_Gain_SetMasterGainValue m_PEAK_IPL_Gain_SetMasterGainValue{};

    dyn_PEAK_IPL_Gain_GetMasterGainValue m_PEAK_IPL_Gain_GetMasterGainValue{};

    dyn_PEAK_IPL_Gain_GetMasterGainMax m_PEAK_IPL_Gain_GetMasterGainMax{};

    dyn_PEAK_IPL_Gain_GetMasterGainMin m_PEAK_IPL_Gain_GetMasterGainMin{};

    dyn_PEAK_IPL_Gain_SetRedGainValue m_PEAK_IPL_Gain_SetRedGainValue{};

    dyn_PEAK_IPL_Gain_GetRedGainValue m_PEAK_IPL_Gain_GetRedGainValue{};

    dyn_PEAK_IPL_Gain_GetRedGainMax m_PEAK_IPL_Gain_GetRedGainMax{};

    dyn_PEAK_IPL_Gain_GetRedGainMin m_PEAK_IPL_Gain_GetRedGainMin{};

    dyn_PEAK_IPL_Gain_SetGreenGainValue m_PEAK_IPL_Gain_SetGreenGainValue{};

    dyn_PEAK_IPL_Gain_GetGreenGainValue m_PEAK_IPL_Gain_GetGreenGainValue{};

    dyn_PEAK_IPL_Gain_GetGreenGainMax m_PEAK_IPL_Gain_GetGreenGainMax{};

    dyn_PEAK_IPL_Gain_GetGreenGainMin m_PEAK_IPL_Gain_GetGreenGainMin{};

    dyn_PEAK_IPL_Gain_SetBlueGainValue m_PEAK_IPL_Gain_SetBlueGainValue{};

    dyn_PEAK_IPL_Gain_GetBlueGainValue m_PEAK_IPL_Gain_GetBlueGainValue{};

    dyn_PEAK_IPL_Gain_GetBlueGainMax m_PEAK_IPL_Gain_GetBlueGainMax{};

    dyn_PEAK_IPL_Gain_GetBlueGainMin m_PEAK_IPL_Gain_GetBlueGainMin{};

    dyn_PEAK_IPL_Gain_GetIsPixelFormatSupported m_PEAK_IPL_Gain_GetIsPixelFormatSupported{};

    dyn_PEAK_IPL_Gain_Process m_PEAK_IPL_Gain_Process{};

    dyn_PEAK_IPL_Gain_ProcessInPlace m_PEAK_IPL_Gain_ProcessInPlace{};

    dyn_PEAK_IPL_Gain_Destruct m_PEAK_IPL_Gain_Destruct{};

    dyn_PEAK_IPL_GammaCorrector_Construct m_PEAK_IPL_GammaCorrector_Construct{};

    dyn_PEAK_IPL_GammaCorrector_Acquire m_PEAK_IPL_GammaCorrector_Acquire{};

    dyn_PEAK_IPL_GammaCorrector_SetGammaCorrectionValue m_PEAK_IPL_GammaCorrector_SetGammaCorrectionValue{};

    dyn_PEAK_IPL_GammaCorrector_GetGammaCorrectionValue m_PEAK_IPL_GammaCorrector_GetGammaCorrectionValue{};

    dyn_PEAK_IPL_GammaCorrector_GetGammaCorrectionMax m_PEAK_IPL_GammaCorrector_GetGammaCorrectionMax{};

    dyn_PEAK_IPL_GammaCorrector_GetGammaCorrectionMin m_PEAK_IPL_GammaCorrector_GetGammaCorrectionMin{};

    dyn_PEAK_IPL_GammaCorrector_SetDigitalBlack m_PEAK_IPL_GammaCorrector_SetDigitalBlack{};

    dyn_PEAK_IPL_GammaCorrector_GetDigitalBlack m_PEAK_IPL_GammaCorrector_GetDigitalBlack{};

    dyn_PEAK_IPL_GammaCorrector_GetDigitalBlackMax m_PEAK_IPL_GammaCorrector_GetDigitalBlackMax{};

    dyn_PEAK_IPL_GammaCorrector_GetDigitalBlackMin m_PEAK_IPL_GammaCorrector_GetDigitalBlackMin{};

    dyn_PEAK_IPL_GammaCorrector_GetIsPixelFormatSupported m_PEAK_IPL_GammaCorrector_GetIsPixelFormatSupported{};

    dyn_PEAK_IPL_GammaCorrector_Process m_PEAK_IPL_GammaCorrector_Process{};

    dyn_PEAK_IPL_GammaCorrector_ProcessInPlace m_PEAK_IPL_GammaCorrector_ProcessInPlace{};

    dyn_PEAK_IPL_GammaCorrector_Destruct m_PEAK_IPL_GammaCorrector_Destruct{};

    dyn_PEAK_IPL_Image_Construct m_PEAK_IPL_Image_Construct{};

    dyn_PEAK_IPL_Image_Acquire m_PEAK_IPL_Image_Acquire{};

    dyn_PEAK_IPL_Image_ConstructFromBuffer m_PEAK_IPL_Image_ConstructFromBuffer{};

    dyn_PEAK_IPL_Image_GetWidth m_PEAK_IPL_Image_GetWidth{};

    dyn_PEAK_IPL_Image_GetHeight m_PEAK_IPL_Image_GetHeight{};

    dyn_PEAK_IPL_Image_GetPixelPointer m_PEAK_IPL_Image_GetPixelPointer{};

    dyn_PEAK_IPL_Image_GetByteCount m_PEAK_IPL_Image_GetByteCount{};

    dyn_PEAK_IPL_Image_GetPixelFormat m_PEAK_IPL_Image_GetPixelFormat{};

    dyn_PEAK_IPL_Image_GetData m_PEAK_IPL_Image_GetData{};

    dyn_PEAK_IPL_Image_Clone m_PEAK_IPL_Image_Clone{};

    dyn_PEAK_IPL_Image_ConvertTo m_PEAK_IPL_Image_ConvertTo{};

    dyn_PEAK_IPL_Image_ConvertToBuffer m_PEAK_IPL_Image_ConvertToBuffer{};

    dyn_PEAK_IPL_Image_ConvertToWithFactor m_PEAK_IPL_Image_ConvertToWithFactor{};

    dyn_PEAK_IPL_Image_ConvertToWithFactorAndOffset m_PEAK_IPL_Image_ConvertToWithFactorAndOffset{};

    dyn_PEAK_IPL_Image_ConvertToBufferWithFactorAndOffset m_PEAK_IPL_Image_ConvertToBufferWithFactorAndOffset{};

    dyn_PEAK_IPL_Image_ConvertToFromInterval m_PEAK_IPL_Image_ConvertToFromInterval{};

    dyn_PEAK_IPL_Image_ConvertToBufferFromInterval m_PEAK_IPL_Image_ConvertToBufferFromInterval{};

    dyn_PEAK_IPL_Image_Scale m_PEAK_IPL_Image_Scale{};

    dyn_PEAK_IPL_Image_ScaleInto m_PEAK_IPL_Image_ScaleInto{};

    dyn_PEAK_IPL_Image_Crop m_PEAK_IPL_Image_Crop{};

    dyn_PEAK_IPL_Image_Destruct m_PEAK_IPL_Image_Destruct{};

    dyn_PEAK_IPL_ImageTransformer_Construct m_PEAK_IPL_ImageTransformer_Construct{};

    dyn_PEAK_IPL_ImageTransformer_Acquire m_PEAK_IPL_ImageTransformer_Acquire{};

    dyn_PEAK_IPL_Image_SetTimestamp m_PEAK_IPL_Image_SetTimestamp{};

    dyn_PEAK_IPL_Image_GetTimestamp m_PEAK_IPL_Image_GetTimestamp{};

    dyn_PEAK_IPL_ImageTransformer_MirrorUpDown m_PEAK_IPL_ImageTransformer_MirrorUpDown{};

    dyn_PEAK_IPL_ImageTransformer_MirrorLeftRight m_PEAK_IPL_ImageTransformer_MirrorLeftRight{};

    dyn_PEAK_IPL_ImageTransformer_MirrorUpDownLeftRight m_PEAK_IPL_ImageTransformer_MirrorUpDownLeftRight{};

    dyn_PEAK_IPL_ImageTransformer_MirrorUpDownInPlace m_PEAK_IPL_ImageTransformer_MirrorUpDownInPlace{};

    dyn_PEAK_IPL_ImageTransformer_MirrorLeftRightInPlace m_PEAK_IPL_ImageTransformer_MirrorLeftRightInPlace{};

    dyn_PEAK_IPL_ImageTransformer_MirrorUpDownLeftRightInPlace m_PEAK_IPL_ImageTransformer_MirrorUpDownLeftRightInPlace{};

    dyn_PEAK_IPL_ImageTransformer_Rotate m_PEAK_IPL_ImageTransformer_Rotate{};

    dyn_PEAK_IPL_ImageTransformer_RotateInPlace m_PEAK_IPL_ImageTransformer_RotateInPlace{};

    dyn_PEAK_IPL_ImageTransformer_Destruct m_PEAK_IPL_ImageTransformer_Destruct{};

    dyn_PEAK_IPL_Histogram_Construct m_PEAK_IPL_Histogram_Construct{};

    dyn_PEAK_IPL_Histogram_Acquire m_PEAK_IPL_Histogram_Acquire{};

    dyn_PEAK_IPL_Histogram_GetPixelFormat m_PEAK_IPL_Histogram_GetPixelFormat{};

    dyn_PEAK_IPL_Histogram_GetNumChannels m_PEAK_IPL_Histogram_GetNumChannels{};

    dyn_PEAK_IPL_Histogram_GetPixelSumForChannel m_PEAK_IPL_Histogram_GetPixelSumForChannel{};

    dyn_PEAK_IPL_Histogram_GetPixelCountForChannel m_PEAK_IPL_Histogram_GetPixelCountForChannel{};

    dyn_PEAK_IPL_Histogram_GetBinsForChannel m_PEAK_IPL_Histogram_GetBinsForChannel{};

    dyn_PEAK_IPL_Histogram_Destruct m_PEAK_IPL_Histogram_Destruct{};

    dyn_PEAK_IPL_PixelLine_Construct m_PEAK_IPL_PixelLine_Construct{};

    dyn_PEAK_IPL_PixelLine_Acquire m_PEAK_IPL_PixelLine_Acquire{};

    dyn_PEAK_IPL_PixelLine_GetPixelFormat m_PEAK_IPL_PixelLine_GetPixelFormat{};

    dyn_PEAK_IPL_PixelLine_GetOrientation m_PEAK_IPL_PixelLine_GetOrientation{};

    dyn_PEAK_IPL_PixelLine_GetOffset m_PEAK_IPL_PixelLine_GetOffset{};

    dyn_PEAK_IPL_PixelLine_GetNumChannels m_PEAK_IPL_PixelLine_GetNumChannels{};

    dyn_PEAK_IPL_PixelLine_GetValuesForChannel m_PEAK_IPL_PixelLine_GetValuesForChannel{};

    dyn_PEAK_IPL_PixelLine_Destruct m_PEAK_IPL_PixelLine_Destruct{};

    dyn_PEAK_IPL_PixelFormat_GetNumChannels m_PEAK_IPL_PixelFormat_GetNumChannels{};

    dyn_PEAK_IPL_PixelFormat_GetNumSignificantBitsPerChannel m_PEAK_IPL_PixelFormat_GetNumSignificantBitsPerChannel{};

    dyn_PEAK_IPL_PixelFormat_GetNumStorageBitsPerChannel m_PEAK_IPL_PixelFormat_GetNumStorageBitsPerChannel{};

    dyn_PEAK_IPL_PixelFormat_GetMaximumValuePerChannel m_PEAK_IPL_PixelFormat_GetMaximumValuePerChannel{};

    dyn_PEAK_IPL_PixelFormat_GetNumSignificantBitsPerPixel m_PEAK_IPL_PixelFormat_GetNumSignificantBitsPerPixel{};

    dyn_PEAK_IPL_PixelFormat_GetNumStorageBitsPerPixel m_PEAK_IPL_PixelFormat_GetNumStorageBitsPerPixel{};

    dyn_PEAK_IPL_PixelFormat_GetEndianness m_PEAK_IPL_PixelFormat_GetEndianness{};

    dyn_PEAK_IPL_PixelFormat_CalculateStorageSizeOfPixels m_PEAK_IPL_PixelFormat_CalculateStorageSizeOfPixels{};

    dyn_PEAK_IPL_PixelFormat_IsPacked m_PEAK_IPL_PixelFormat_IsPacked{};

    dyn_PEAK_IPL_PixelFormat_IsBayered m_PEAK_IPL_PixelFormat_IsBayered{};

    dyn_PEAK_IPL_PixelFormat_IsYUV m_PEAK_IPL_PixelFormat_IsYUV{};

    dyn_PEAK_IPL_PixelFormat_IsCoord3D m_PEAK_IPL_PixelFormat_IsCoord3D{};

    dyn_PEAK_IPL_PixelFormat_IsFloat m_PEAK_IPL_PixelFormat_IsFloat{};

    dyn_PEAK_IPL_PixelFormat_GetBayerPattern m_PEAK_IPL_PixelFormat_GetBayerPattern{};

    dyn_PEAK_IPL_ImageWriter_WriteAsRAW m_PEAK_IPL_ImageWriter_WriteAsRAW{};

    dyn_PEAK_IPL_ImageWriter_WriteAsBMP m_PEAK_IPL_ImageWriter_WriteAsBMP{};

    dyn_PEAK_IPL_ImageWriter_WriteAsPNG m_PEAK_IPL_ImageWriter_WriteAsPNG{};

    dyn_PEAK_IPL_ImageWriter_WriteAsJPG m_PEAK_IPL_ImageWriter_WriteAsJPG{};

    dyn_PEAK_IPL_ImageWriter_Write m_PEAK_IPL_ImageWriter_Write{};

    dyn_PEAK_IPL_ImageReader_Read m_PEAK_IPL_ImageReader_Read{};

    dyn_PEAK_IPL_ImageReaderRead_ReadAsPixelFormat m_PEAK_IPL_ImageReaderRead_ReadAsPixelFormat{};

    dyn_PEAK_IPL_VideoWriter_Video_Open m_PEAK_IPL_VideoWriter_Video_Open{};

    dyn_PEAK_IPL_VideoWriter_Video_IsOpen m_PEAK_IPL_VideoWriter_Video_IsOpen{};

    dyn_PEAK_IPL_VideoWriter_Video_Close m_PEAK_IPL_VideoWriter_Video_Close{};

    dyn_PEAK_IPL_VideoWriter_Video_Append m_PEAK_IPL_VideoWriter_Video_Append{};

    dyn_PEAK_IPL_VideoWriter_Encoder_SetOption m_PEAK_IPL_VideoWriter_Encoder_SetOption{};

    dyn_PEAK_IPL_VideoWriter_Encoder_GetOption m_PEAK_IPL_VideoWriter_Encoder_GetOption{};

    dyn_PEAK_IPL_VideoWriter_Encoder_OptionRange m_PEAK_IPL_VideoWriter_Encoder_OptionRange{};

    dyn_PEAK_IPL_VideoWriter_GetSupportedEncodersForAContainer m_PEAK_IPL_VideoWriter_GetSupportedEncodersForAContainer{};

    dyn_PEAK_IPL_VideoWriter_Container_SetOption m_PEAK_IPL_VideoWriter_Container_SetOption{};

    dyn_PEAK_IPL_VideoWriter_Container_GetOption m_PEAK_IPL_VideoWriter_Container_GetOption{};

    dyn_PEAK_IPL_VideoWriter_Container_OptionRange m_PEAK_IPL_VideoWriter_Container_OptionRange{};

    dyn_PEAK_IPL_VideoWriter_GetSupportedContainersForAnEncoder m_PEAK_IPL_VideoWriter_GetSupportedContainersForAnEncoder{};

    dyn_PEAK_IPL_VideoWriter_Encoder_GetSupportedPixelFormats m_PEAK_IPL_VideoWriter_Encoder_GetSupportedPixelFormats{};

    dyn_PEAK_IPL_VideoWriter_Video_GetEncodedFrames m_PEAK_IPL_VideoWriter_Video_GetEncodedFrames{};

    dyn_PEAK_IPL_VideoWriter_Video_GetDroppedFrames m_PEAK_IPL_VideoWriter_Video_GetDroppedFrames{};

    dyn_PEAK_IPL_VideoWriter_Video_GetFileSize m_PEAK_IPL_VideoWriter_Video_GetFileSize{};

    dyn_PEAK_IPL_VideoWriter_Video_ResetFrameCounters m_PEAK_IPL_VideoWriter_Video_ResetFrameCounters{};

    dyn_PEAK_IPL_VideoWriter_Queue_SetSize m_PEAK_IPL_VideoWriter_Queue_SetSize{};

    dyn_PEAK_IPL_VideoWriter_Queue_GetSize m_PEAK_IPL_VideoWriter_Queue_GetSize{};

    dyn_PEAK_IPL_VideoWriter_Queue_GetRange m_PEAK_IPL_VideoWriter_Queue_GetRange{};

    dyn_PEAK_IPL_VideoWriter_Queue_GetQueued m_PEAK_IPL_VideoWriter_Queue_GetQueued{};

    dyn_PEAK_IPL_VideoWriter_Video_WaitUntilFrameDone m_PEAK_IPL_VideoWriter_Video_WaitUntilFrameDone{};

    dyn_PEAK_IPL_VideoWriter_Video_WaitUntilQueueEmpty m_PEAK_IPL_VideoWriter_Video_WaitUntilQueueEmpty{};

    dyn_PEAK_IPL_ImageSharpness_Construct m_PEAK_IPL_ImageSharpness_Construct{};

    dyn_PEAK_IPL_ImageSharpness_Acquire m_PEAK_IPL_ImageSharpness_Acquire{};

    dyn_PEAK_IPL_ImageSharpness_Destruct m_PEAK_IPL_ImageSharpness_Destruct{};

    dyn_PEAK_IPL_ImageSharpness_Measure m_PEAK_IPL_ImageSharpness_Measure{};

    dyn_PEAK_IPL_ImageSharpness_GetIsPixelFormatSupported m_PEAK_IPL_ImageSharpness_GetIsPixelFormatSupported{};

    dyn_PEAK_IPL_ImageSharpness_GetSupportedPixelFormatList m_PEAK_IPL_ImageSharpness_GetSupportedPixelFormatList{};

    dyn_PEAK_IPL_ImageSharpness_SetAlgorithm m_PEAK_IPL_ImageSharpness_SetAlgorithm{};

    dyn_PEAK_IPL_ImageSharpness_GetAlgorithm m_PEAK_IPL_ImageSharpness_GetAlgorithm{};

    dyn_PEAK_IPL_ImageSharpness_GetROIMinimumSize m_PEAK_IPL_ImageSharpness_GetROIMinimumSize{};

    dyn_PEAK_IPL_ImageSharpness_SetROIs m_PEAK_IPL_ImageSharpness_SetROIs{};

    dyn_PEAK_IPL_ImageSharpness_GetROIs m_PEAK_IPL_ImageSharpness_GetROIs{};

    dyn_PEAK_IPL_EdgeEnhancement_Construct m_PEAK_IPL_EdgeEnhancement_Construct{};

    dyn_PEAK_IPL_EdgeEnhancement_Acquire m_PEAK_IPL_EdgeEnhancement_Acquire{};

    dyn_PEAK_IPL_EdgeEnhancement_Destruct m_PEAK_IPL_EdgeEnhancement_Destruct{};

    dyn_PEAK_IPL_EdgeEnhancement_ProcessInPlace m_PEAK_IPL_EdgeEnhancement_ProcessInPlace{};

    dyn_PEAK_IPL_EdgeEnhancement_Process m_PEAK_IPL_EdgeEnhancement_Process{};

    dyn_PEAK_IPL_EdgeEnhancement_GetFactorRange m_PEAK_IPL_EdgeEnhancement_GetFactorRange{};

    dyn_PEAK_IPL_EdgeEnhancement_SetFactor m_PEAK_IPL_EdgeEnhancement_SetFactor{};

    dyn_PEAK_IPL_EdgeEnhancement_GetFactor m_PEAK_IPL_EdgeEnhancement_GetFactor{};

    dyn_PEAK_IPL_EdgeEnhancement_GetDefaultFactor m_PEAK_IPL_EdgeEnhancement_GetDefaultFactor{};

    dyn_PEAK_IPL_EdgeEnhancement_IsPixelFormatSupported m_PEAK_IPL_EdgeEnhancement_IsPixelFormatSupported{};

    dyn_PEAK_IPL_Lut_Construct m_PEAK_IPL_Lut_Construct{};

    dyn_PEAK_IPL_Lut_Acquire m_PEAK_IPL_Lut_Acquire{};

    dyn_PEAK_IPL_Lut_GetLutValue m_PEAK_IPL_Lut_GetLutValue{};

    dyn_PEAK_IPL_Lut_SetLutValue m_PEAK_IPL_Lut_SetLutValue{};

    dyn_PEAK_IPL_Lut_GetAllLutValues m_PEAK_IPL_Lut_GetAllLutValues{};

    dyn_PEAK_IPL_Lut_SetAllLutValues m_PEAK_IPL_Lut_SetAllLutValues{};

    dyn_PEAK_IPL_Lut_SetLutPreset m_PEAK_IPL_Lut_SetLutPreset{};

    dyn_PEAK_IPL_Lut_IsPixelFormatSupported m_PEAK_IPL_Lut_IsPixelFormatSupported{};

    dyn_PEAK_IPL_Lut_Process m_PEAK_IPL_Lut_Process{};

    dyn_PEAK_IPL_Lut_ProcessInPlace m_PEAK_IPL_Lut_ProcessInPlace{};

    dyn_PEAK_IPL_Lut_Destruct m_PEAK_IPL_Lut_Destruct{};

    dyn_PEAK_IPL_ChromaticAdapter_Construct m_PEAK_IPL_ChromaticAdapter_Construct{};

    dyn_PEAK_IPL_ChromaticAdapter_Acquire m_PEAK_IPL_ChromaticAdapter_Acquire{};

    dyn_PEAK_IPL_ChromaticAdapter_Destruct m_PEAK_IPL_ChromaticAdapter_Destruct{};

    dyn_PEAK_IPL_ChromaticAdapter_GetTargetColorSpace m_PEAK_IPL_ChromaticAdapter_GetTargetColorSpace{};

    dyn_PEAK_IPL_ChromaticAdapter_SetTargetColorSpace m_PEAK_IPL_ChromaticAdapter_SetTargetColorSpace{};

    dyn_PEAK_IPL_ChromaticAdapter_GetAdaptionAlgorithm m_PEAK_IPL_ChromaticAdapter_GetAdaptionAlgorithm{};

    dyn_PEAK_IPL_ChromaticAdapter_SetAdaptionAlgorithm m_PEAK_IPL_ChromaticAdapter_SetAdaptionAlgorithm{};

    dyn_PEAK_IPL_ChromaticAdapter_CalculateColorCorrectionMatrix m_PEAK_IPL_ChromaticAdapter_CalculateColorCorrectionMatrix{};

    dyn_PEAK_IPL_ChromaticAdapter_GetTemperatureRange m_PEAK_IPL_ChromaticAdapter_GetTemperatureRange{};


};


inline void* import_function(void *module, const char* proc_name)

{

#ifdef __linux__

    return dlsym(module, proc_name);

#else

    return reinterpret_cast<void*>(GetProcAddress(static_cast<HMODULE>(module), proc_name));

#endif

}


inline DynamicLoader::DynamicLoader()

{

#if defined _WIN32 || defined _WIN64

    size_t sz = 0;

    if (_wgetenv_s(&sz, NULL, 0, L"IDS_PEAK_GENERIC_SDK_PATH") == 0

        && sz > 0)

    {

        std::vector<wchar_t> env_ids_peak_ipl(sz);

        if (_wgetenv_s(&sz, env_ids_peak_ipl.data(), sz, L"IDS_PEAK_GENERIC_SDK_PATH") == 0)

        {

            if (_wgetenv_s(&sz, NULL, 0, L"PATH") == 0

                && sz > 0)

            {

                std::vector<wchar_t> env_path(sz);

                if (_wgetenv_s(&sz, env_path.data(), sz, L"PATH") == 0)

                {

                    std::wstring ids_peak_ipl_path(env_ids_peak_ipl.data());

#ifdef _WIN64

                    ids_peak_ipl_path.append(L"\\ipl\\lib\\x86_64");

#else

                    ids_peak_ipl_path.append(L"\\ipl\\lib\\x86_32");

#endif

                    AddDllDirectory(ids_peak_ipl_path.c_str());

                }

            }

        }

    }


    loadLib("ids_peak_ipl.dll");

#else

    loadLib("libids_peak_ipl.so");

#endif

}


inline DynamicLoader::~DynamicLoader()

{

    if(m_handle != nullptr)

    {

        unload();

    }

}


inline bool DynamicLoader::isLoaded()

{

    auto&& inst = instance();

    return inst.m_handle != nullptr;

}


inline void DynamicLoader::unload()

{

    setPointers(false);


    if (m_handle != nullptr)

    {

#ifdef __linux__

        dlclose(m_handle);

#else

        FreeLibrary(static_cast<HMODULE>(m_handle));

#endif

    }

    m_handle = nullptr;

}


inline bool DynamicLoader::loadLib(const char* file)

{

    bool ret = false;


    if (file)

    {

#ifdef __linux__

        m_handle = dlopen(file, RTLD_NOW);

#else

        m_handle = LoadLibraryExA(file, nullptr, LOAD_LIBRARY_SEARCH_DEFAULT_DIRS);

#endif

        if (m_handle != nullptr)

        {

            try {

                setPointers(true);

                ret = true;

            } catch (const std::exception&) {

                unload();

                throw;

            }

        }

        else

        {

            throw LoadLibraryException(std::string("Lib load failed: ") + file);

        }

    }

    else

    {

        throw LoadLibraryException("Filename empty");

    }


    return ret;

}


inline bool DynamicLoader::setPointers(bool load)

{


    m_PEAK_IPL_Library_GetVersionMajor = (dyn_PEAK_IPL_Library_GetVersionMajor) (load ?  import_function(m_handle, "PEAK_IPL_Library_GetVersionMajor") : nullptr);

    if(m_PEAK_IPL_Library_GetVersionMajor == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Library_GetVersionMajor");

    }


    m_PEAK_IPL_Library_GetVersionMinor = (dyn_PEAK_IPL_Library_GetVersionMinor) (load ?  import_function(m_handle, "PEAK_IPL_Library_GetVersionMinor") : nullptr);

    if(m_PEAK_IPL_Library_GetVersionMinor == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Library_GetVersionMinor");

    }


    m_PEAK_IPL_Library_GetVersionSubminor = (dyn_PEAK_IPL_Library_GetVersionSubminor) (load ?  import_function(m_handle, "PEAK_IPL_Library_GetVersionSubminor") : nullptr);

    if(m_PEAK_IPL_Library_GetVersionSubminor == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Library_GetVersionSubminor");

    }


    m_PEAK_IPL_Library_GetMaxConcurrentThreads = (dyn_PEAK_IPL_Library_GetMaxConcurrentThreads) (load ?  import_function(m_handle, "PEAK_IPL_Library_GetMaxConcurrentThreads") : nullptr);

    if(m_PEAK_IPL_Library_GetMaxConcurrentThreads == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Library_GetMaxConcurrentThreads");

    }


    m_PEAK_IPL_Library_SetMaxConcurrentThreads = (dyn_PEAK_IPL_Library_SetMaxConcurrentThreads) (load ?  import_function(m_handle, "PEAK_IPL_Library_SetMaxConcurrentThreads") : nullptr);

    if(m_PEAK_IPL_Library_SetMaxConcurrentThreads == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Library_SetMaxConcurrentThreads");

    }


    m_PEAK_IPL_Library_GetMultiThreadingEnabled = (dyn_PEAK_IPL_Library_GetMultiThreadingEnabled) (load ?  import_function(m_handle, "PEAK_IPL_Library_GetMultiThreadingEnabled") : nullptr);

    if(m_PEAK_IPL_Library_GetMultiThreadingEnabled == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Library_GetMultiThreadingEnabled");

    }


    m_PEAK_IPL_Library_SetMultiThreadingEnabled = (dyn_PEAK_IPL_Library_SetMultiThreadingEnabled) (load ?  import_function(m_handle, "PEAK_IPL_Library_SetMultiThreadingEnabled") : nullptr);

    if(m_PEAK_IPL_Library_SetMultiThreadingEnabled == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Library_SetMultiThreadingEnabled");

    }


    m_PEAK_IPL_Library_GetSIMDEnabled = (dyn_PEAK_IPL_Library_GetSIMDEnabled) (load ?  import_function(m_handle, "PEAK_IPL_Library_GetSIMDEnabled") : nullptr);

    if(m_PEAK_IPL_Library_GetSIMDEnabled == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Library_GetSIMDEnabled");

    }


    m_PEAK_IPL_Library_SetSIMDEnabled = (dyn_PEAK_IPL_Library_SetSIMDEnabled) (load ?  import_function(m_handle, "PEAK_IPL_Library_SetSIMDEnabled") : nullptr);

    if(m_PEAK_IPL_Library_SetSIMDEnabled == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Library_SetSIMDEnabled");

    }


    m_PEAK_IPL_Library_GetLastError = (dyn_PEAK_IPL_Library_GetLastError) (load ?  import_function(m_handle, "PEAK_IPL_Library_GetLastError") : nullptr);

    if(m_PEAK_IPL_Library_GetLastError == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Library_GetLastError");

    }


    m_PEAK_IPL_ImageConverter_Construct = (dyn_PEAK_IPL_ImageConverter_Construct) (load ?  import_function(m_handle, "PEAK_IPL_ImageConverter_Construct") : nullptr);

    if(m_PEAK_IPL_ImageConverter_Construct == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ImageConverter_Construct");

    }


    m_PEAK_IPL_ImageConverter_Acquire = (dyn_PEAK_IPL_ImageConverter_Acquire) (load ?  import_function(m_handle, "PEAK_IPL_ImageConverter_Acquire") : nullptr);

    if(m_PEAK_IPL_ImageConverter_Acquire == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ImageConverter_Acquire");

    }


    m_PEAK_IPL_ImageConverter_PreAllocateConversion = (dyn_PEAK_IPL_ImageConverter_PreAllocateConversion) (load ?  import_function(m_handle, "PEAK_IPL_ImageConverter_PreAllocateConversion") : nullptr);

    if(m_PEAK_IPL_ImageConverter_PreAllocateConversion == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ImageConverter_PreAllocateConversion");

    }


    m_PEAK_IPL_ImageConverter_GetConversionMode = (dyn_PEAK_IPL_ImageConverter_GetConversionMode) (load ?  import_function(m_handle, "PEAK_IPL_ImageConverter_GetConversionMode") : nullptr);

    if(m_PEAK_IPL_ImageConverter_GetConversionMode == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ImageConverter_GetConversionMode");

    }


    m_PEAK_IPL_ImageConverter_SetConversionMode = (dyn_PEAK_IPL_ImageConverter_SetConversionMode) (load ?  import_function(m_handle, "PEAK_IPL_ImageConverter_SetConversionMode") : nullptr);

    if(m_PEAK_IPL_ImageConverter_SetConversionMode == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ImageConverter_SetConversionMode");

    }


    m_PEAK_IPL_ImageConverter_GetSupportedOutputPixelFormats = (dyn_PEAK_IPL_ImageConverter_GetSupportedOutputPixelFormats) (load ?  import_function(m_handle, "PEAK_IPL_ImageConverter_GetSupportedOutputPixelFormats") : nullptr);

    if(m_PEAK_IPL_ImageConverter_GetSupportedOutputPixelFormats == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ImageConverter_GetSupportedOutputPixelFormats");

    }


    m_PEAK_IPL_ImageConverter_Convert = (dyn_PEAK_IPL_ImageConverter_Convert) (load ?  import_function(m_handle, "PEAK_IPL_ImageConverter_Convert") : nullptr);

    if(m_PEAK_IPL_ImageConverter_Convert == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ImageConverter_Convert");

    }


    m_PEAK_IPL_ImageConverter_ConvertToBuffer = (dyn_PEAK_IPL_ImageConverter_ConvertToBuffer) (load ?  import_function(m_handle, "PEAK_IPL_ImageConverter_ConvertToBuffer") : nullptr);

    if(m_PEAK_IPL_ImageConverter_ConvertToBuffer == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ImageConverter_ConvertToBuffer");

    }


    m_PEAK_IPL_ImageConverter_ConvertWithFactorAndOffset = (dyn_PEAK_IPL_ImageConverter_ConvertWithFactorAndOffset) (load ?  import_function(m_handle, "PEAK_IPL_ImageConverter_ConvertWithFactorAndOffset") : nullptr);

    if(m_PEAK_IPL_ImageConverter_ConvertWithFactorAndOffset == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ImageConverter_ConvertWithFactorAndOffset");

    }


    m_PEAK_IPL_ImageConverter_ConvertToBufferWithFactorAndOffset = (dyn_PEAK_IPL_ImageConverter_ConvertToBufferWithFactorAndOffset) (load ?  import_function(m_handle, "PEAK_IPL_ImageConverter_ConvertToBufferWithFactorAndOffset") : nullptr);

    if(m_PEAK_IPL_ImageConverter_ConvertToBufferWithFactorAndOffset == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ImageConverter_ConvertToBufferWithFactorAndOffset");

    }


    m_PEAK_IPL_ImageConverter_ConvertFromInterval = (dyn_PEAK_IPL_ImageConverter_ConvertFromInterval) (load ?  import_function(m_handle, "PEAK_IPL_ImageConverter_ConvertFromInterval") : nullptr);

    if(m_PEAK_IPL_ImageConverter_ConvertFromInterval == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ImageConverter_ConvertFromInterval");

    }


    m_PEAK_IPL_ImageConverter_ConvertToBufferFromInterval = (dyn_PEAK_IPL_ImageConverter_ConvertToBufferFromInterval) (load ?  import_function(m_handle, "PEAK_IPL_ImageConverter_ConvertToBufferFromInterval") : nullptr);

    if(m_PEAK_IPL_ImageConverter_ConvertToBufferFromInterval == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ImageConverter_ConvertToBufferFromInterval");

    }


    m_PEAK_IPL_ImageConverter_Destruct = (dyn_PEAK_IPL_ImageConverter_Destruct) (load ?  import_function(m_handle, "PEAK_IPL_ImageConverter_Destruct") : nullptr);

    if(m_PEAK_IPL_ImageConverter_Destruct == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ImageConverter_Destruct");

    }


    m_PEAK_IPL_AdaptiveHotpixelCorrector_Construct = (dyn_PEAK_IPL_AdaptiveHotpixelCorrector_Construct) (load ?  import_function(m_handle, "PEAK_IPL_AdaptiveHotpixelCorrector_Construct") : nullptr);

    if(m_PEAK_IPL_AdaptiveHotpixelCorrector_Construct == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_AdaptiveHotpixelCorrector_Construct");

    }


    m_PEAK_IPL_AdaptiveHotpixelCorrector_Acquire = (dyn_PEAK_IPL_AdaptiveHotpixelCorrector_Acquire) (load ?  import_function(m_handle, "PEAK_IPL_AdaptiveHotpixelCorrector_Acquire") : nullptr);

    if(m_PEAK_IPL_AdaptiveHotpixelCorrector_Acquire == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_AdaptiveHotpixelCorrector_Acquire");

    }


    m_PEAK_IPL_AdaptiveHotpixelCorrector_SetSensitivity = (dyn_PEAK_IPL_AdaptiveHotpixelCorrector_SetSensitivity) (load ?  import_function(m_handle, "PEAK_IPL_AdaptiveHotpixelCorrector_SetSensitivity") : nullptr);

    if(m_PEAK_IPL_AdaptiveHotpixelCorrector_SetSensitivity == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_AdaptiveHotpixelCorrector_SetSensitivity");

    }


    m_PEAK_IPL_AdaptiveHotpixelCorrector_GetSensitivity = (dyn_PEAK_IPL_AdaptiveHotpixelCorrector_GetSensitivity) (load ?  import_function(m_handle, "PEAK_IPL_AdaptiveHotpixelCorrector_GetSensitivity") : nullptr);

    if(m_PEAK_IPL_AdaptiveHotpixelCorrector_GetSensitivity == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_AdaptiveHotpixelCorrector_GetSensitivity");

    }


    m_PEAK_IPL_AdaptiveHotpixelCorrector_SetGainFactorPercent = (dyn_PEAK_IPL_AdaptiveHotpixelCorrector_SetGainFactorPercent) (load ?  import_function(m_handle, "PEAK_IPL_AdaptiveHotpixelCorrector_SetGainFactorPercent") : nullptr);

    if(m_PEAK_IPL_AdaptiveHotpixelCorrector_SetGainFactorPercent == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_AdaptiveHotpixelCorrector_SetGainFactorPercent");

    }


    m_PEAK_IPL_AdaptiveHotpixelCorrector_GetGainFactorPercent = (dyn_PEAK_IPL_AdaptiveHotpixelCorrector_GetGainFactorPercent) (load ?  import_function(m_handle, "PEAK_IPL_AdaptiveHotpixelCorrector_GetGainFactorPercent") : nullptr);

    if(m_PEAK_IPL_AdaptiveHotpixelCorrector_GetGainFactorPercent == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_AdaptiveHotpixelCorrector_GetGainFactorPercent");

    }


    m_PEAK_IPL_AdaptiveHotpixelCorrector_Detect = (dyn_PEAK_IPL_AdaptiveHotpixelCorrector_Detect) (load ?  import_function(m_handle, "PEAK_IPL_AdaptiveHotpixelCorrector_Detect") : nullptr);

    if(m_PEAK_IPL_AdaptiveHotpixelCorrector_Detect == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_AdaptiveHotpixelCorrector_Detect");

    }


    m_PEAK_IPL_AdaptiveHotpixelCorrector_GetHotpixels = (dyn_PEAK_IPL_AdaptiveHotpixelCorrector_GetHotpixels) (load ?  import_function(m_handle, "PEAK_IPL_AdaptiveHotpixelCorrector_GetHotpixels") : nullptr);

    if(m_PEAK_IPL_AdaptiveHotpixelCorrector_GetHotpixels == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_AdaptiveHotpixelCorrector_GetHotpixels");

    }


    m_PEAK_IPL_AdaptiveHotpixelCorrector_Correct = (dyn_PEAK_IPL_AdaptiveHotpixelCorrector_Correct) (load ?  import_function(m_handle, "PEAK_IPL_AdaptiveHotpixelCorrector_Correct") : nullptr);

    if(m_PEAK_IPL_AdaptiveHotpixelCorrector_Correct == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_AdaptiveHotpixelCorrector_Correct");

    }


    m_PEAK_IPL_AdaptiveHotpixelCorrector_CorrectInPlace = (dyn_PEAK_IPL_AdaptiveHotpixelCorrector_CorrectInPlace) (load ?  import_function(m_handle, "PEAK_IPL_AdaptiveHotpixelCorrector_CorrectInPlace") : nullptr);

    if(m_PEAK_IPL_AdaptiveHotpixelCorrector_CorrectInPlace == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_AdaptiveHotpixelCorrector_CorrectInPlace");

    }


    m_PEAK_IPL_AdaptiveHotpixelCorrector_CorrectAdaptive = (dyn_PEAK_IPL_AdaptiveHotpixelCorrector_CorrectAdaptive) (load ?  import_function(m_handle, "PEAK_IPL_AdaptiveHotpixelCorrector_CorrectAdaptive") : nullptr);

    if(m_PEAK_IPL_AdaptiveHotpixelCorrector_CorrectAdaptive == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_AdaptiveHotpixelCorrector_CorrectAdaptive");

    }


    m_PEAK_IPL_AdaptiveHotpixelCorrector_CorrectAdaptiveInPlace = (dyn_PEAK_IPL_AdaptiveHotpixelCorrector_CorrectAdaptiveInPlace) (load ?  import_function(m_handle, "PEAK_IPL_AdaptiveHotpixelCorrector_CorrectAdaptiveInPlace") : nullptr);

    if(m_PEAK_IPL_AdaptiveHotpixelCorrector_CorrectAdaptiveInPlace == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_AdaptiveHotpixelCorrector_CorrectAdaptiveInPlace");

    }


    m_PEAK_IPL_AdaptiveHotpixelCorrector_Destruct = (dyn_PEAK_IPL_AdaptiveHotpixelCorrector_Destruct) (load ?  import_function(m_handle, "PEAK_IPL_AdaptiveHotpixelCorrector_Destruct") : nullptr);

    if(m_PEAK_IPL_AdaptiveHotpixelCorrector_Destruct == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_AdaptiveHotpixelCorrector_Destruct");

    }


    m_PEAK_IPL_ColorCorrector_Construct = (dyn_PEAK_IPL_ColorCorrector_Construct) (load ?  import_function(m_handle, "PEAK_IPL_ColorCorrector_Construct") : nullptr);

    if(m_PEAK_IPL_ColorCorrector_Construct == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ColorCorrector_Construct");

    }


    m_PEAK_IPL_ColorCorrector_Acquire = (dyn_PEAK_IPL_ColorCorrector_Acquire) (load ?  import_function(m_handle, "PEAK_IPL_ColorCorrector_Acquire") : nullptr);

    if(m_PEAK_IPL_ColorCorrector_Acquire == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ColorCorrector_Acquire");

    }


    m_PEAK_IPL_ColorCorrector_SetColorCorrectionFactors = (dyn_PEAK_IPL_ColorCorrector_SetColorCorrectionFactors) (load ?  import_function(m_handle, "PEAK_IPL_ColorCorrector_SetColorCorrectionFactors") : nullptr);

    if(m_PEAK_IPL_ColorCorrector_SetColorCorrectionFactors == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ColorCorrector_SetColorCorrectionFactors");

    }


    m_PEAK_IPL_ColorCorrector_GetColorCorrectionFactors = (dyn_PEAK_IPL_ColorCorrector_GetColorCorrectionFactors) (load ?  import_function(m_handle, "PEAK_IPL_ColorCorrector_GetColorCorrectionFactors") : nullptr);

    if(m_PEAK_IPL_ColorCorrector_GetColorCorrectionFactors == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ColorCorrector_GetColorCorrectionFactors");

    }


    m_PEAK_IPL_ColorCorrector_GetIsPixelFormatSupported = (dyn_PEAK_IPL_ColorCorrector_GetIsPixelFormatSupported) (load ?  import_function(m_handle, "PEAK_IPL_ColorCorrector_GetIsPixelFormatSupported") : nullptr);

    if(m_PEAK_IPL_ColorCorrector_GetIsPixelFormatSupported == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ColorCorrector_GetIsPixelFormatSupported");

    }


    m_PEAK_IPL_ColorCorrector_Process = (dyn_PEAK_IPL_ColorCorrector_Process) (load ?  import_function(m_handle, "PEAK_IPL_ColorCorrector_Process") : nullptr);

    if(m_PEAK_IPL_ColorCorrector_Process == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ColorCorrector_Process");

    }


    m_PEAK_IPL_ColorCorrector_ProcessInPlace = (dyn_PEAK_IPL_ColorCorrector_ProcessInPlace) (load ?  import_function(m_handle, "PEAK_IPL_ColorCorrector_ProcessInPlace") : nullptr);

    if(m_PEAK_IPL_ColorCorrector_ProcessInPlace == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ColorCorrector_ProcessInPlace");

    }


    m_PEAK_IPL_ColorCorrector_Destruct = (dyn_PEAK_IPL_ColorCorrector_Destruct) (load ?  import_function(m_handle, "PEAK_IPL_ColorCorrector_Destruct") : nullptr);

    if(m_PEAK_IPL_ColorCorrector_Destruct == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ColorCorrector_Destruct");

    }


    m_PEAK_IPL_ColorCorrector_GetSaturation = (dyn_PEAK_IPL_ColorCorrector_GetSaturation) (load ?  import_function(m_handle, "PEAK_IPL_ColorCorrector_GetSaturation") : nullptr);

    if(m_PEAK_IPL_ColorCorrector_GetSaturation == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ColorCorrector_GetSaturation");

    }


    m_PEAK_IPL_ColorCorrector_GetSaturationMin = (dyn_PEAK_IPL_ColorCorrector_GetSaturationMin) (load ?  import_function(m_handle, "PEAK_IPL_ColorCorrector_GetSaturationMin") : nullptr);

    if(m_PEAK_IPL_ColorCorrector_GetSaturationMin == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ColorCorrector_GetSaturationMin");

    }


    m_PEAK_IPL_ColorCorrector_GetSaturationMax = (dyn_PEAK_IPL_ColorCorrector_GetSaturationMax) (load ?  import_function(m_handle, "PEAK_IPL_ColorCorrector_GetSaturationMax") : nullptr);

    if(m_PEAK_IPL_ColorCorrector_GetSaturationMax == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ColorCorrector_GetSaturationMax");

    }


    m_PEAK_IPL_ColorCorrector_SetSaturation = (dyn_PEAK_IPL_ColorCorrector_SetSaturation) (load ?  import_function(m_handle, "PEAK_IPL_ColorCorrector_SetSaturation") : nullptr);

    if(m_PEAK_IPL_ColorCorrector_SetSaturation == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ColorCorrector_SetSaturation");

    }


    m_PEAK_IPL_Binning_Construct = (dyn_PEAK_IPL_Binning_Construct) (load ?  import_function(m_handle, "PEAK_IPL_Binning_Construct") : nullptr);

    if(m_PEAK_IPL_Binning_Construct == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Binning_Construct");

    }


    m_PEAK_IPL_Binning_Acquire = (dyn_PEAK_IPL_Binning_Acquire) (load ?  import_function(m_handle, "PEAK_IPL_Binning_Acquire") : nullptr);

    if(m_PEAK_IPL_Binning_Acquire == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Binning_Acquire");

    }


    m_PEAK_IPL_Binning_SetBinningX = (dyn_PEAK_IPL_Binning_SetBinningX) (load ?  import_function(m_handle, "PEAK_IPL_Binning_SetBinningX") : nullptr);

    if(m_PEAK_IPL_Binning_SetBinningX == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Binning_SetBinningX");

    }


    m_PEAK_IPL_Binning_GetBinningX = (dyn_PEAK_IPL_Binning_GetBinningX) (load ?  import_function(m_handle, "PEAK_IPL_Binning_GetBinningX") : nullptr);

    if(m_PEAK_IPL_Binning_GetBinningX == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Binning_GetBinningX");

    }


    m_PEAK_IPL_Binning_SetBinningY = (dyn_PEAK_IPL_Binning_SetBinningY) (load ?  import_function(m_handle, "PEAK_IPL_Binning_SetBinningY") : nullptr);

    if(m_PEAK_IPL_Binning_SetBinningY == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Binning_SetBinningY");

    }


    m_PEAK_IPL_Binning_GetBinningY = (dyn_PEAK_IPL_Binning_GetBinningY) (load ?  import_function(m_handle, "PEAK_IPL_Binning_GetBinningY") : nullptr);

    if(m_PEAK_IPL_Binning_GetBinningY == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Binning_GetBinningY");

    }


    m_PEAK_IPL_Binning_GetBinningMin = (dyn_PEAK_IPL_Binning_GetBinningMin) (load ?  import_function(m_handle, "PEAK_IPL_Binning_GetBinningMin") : nullptr);

    if(m_PEAK_IPL_Binning_GetBinningMin == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Binning_GetBinningMin");

    }


    m_PEAK_IPL_Binning_GetBinningMax = (dyn_PEAK_IPL_Binning_GetBinningMax) (load ?  import_function(m_handle, "PEAK_IPL_Binning_GetBinningMax") : nullptr);

    if(m_PEAK_IPL_Binning_GetBinningMax == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Binning_GetBinningMax");

    }


    m_PEAK_IPL_Binning_ExpectedOutputSize = (dyn_PEAK_IPL_Binning_ExpectedOutputSize) (load ?  import_function(m_handle, "PEAK_IPL_Binning_ExpectedOutputSize") : nullptr);

    if(m_PEAK_IPL_Binning_ExpectedOutputSize == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Binning_ExpectedOutputSize");

    }


    m_PEAK_IPL_Binning_IsPixelformatSupported = (dyn_PEAK_IPL_Binning_IsPixelformatSupported) (load ?  import_function(m_handle, "PEAK_IPL_Binning_IsPixelformatSupported") : nullptr);

    if(m_PEAK_IPL_Binning_IsPixelformatSupported == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Binning_IsPixelformatSupported");

    }


    m_PEAK_IPL_Binning_SetBinningMode = (dyn_PEAK_IPL_Binning_SetBinningMode) (load ?  import_function(m_handle, "PEAK_IPL_Binning_SetBinningMode") : nullptr);

    if(m_PEAK_IPL_Binning_SetBinningMode == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Binning_SetBinningMode");

    }


    m_PEAK_IPL_Binning_GetBinningMode = (dyn_PEAK_IPL_Binning_GetBinningMode) (load ?  import_function(m_handle, "PEAK_IPL_Binning_GetBinningMode") : nullptr);

    if(m_PEAK_IPL_Binning_GetBinningMode == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Binning_GetBinningMode");

    }


    m_PEAK_IPL_Binning_Process = (dyn_PEAK_IPL_Binning_Process) (load ?  import_function(m_handle, "PEAK_IPL_Binning_Process") : nullptr);

    if(m_PEAK_IPL_Binning_Process == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Binning_Process");

    }


    m_PEAK_IPL_Binning_Destruct = (dyn_PEAK_IPL_Binning_Destruct) (load ?  import_function(m_handle, "PEAK_IPL_Binning_Destruct") : nullptr);

    if(m_PEAK_IPL_Binning_Destruct == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Binning_Destruct");

    }


    m_PEAK_IPL_Decimation_Construct = (dyn_PEAK_IPL_Decimation_Construct) (load ?  import_function(m_handle, "PEAK_IPL_Decimation_Construct") : nullptr);

    if(m_PEAK_IPL_Decimation_Construct == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Decimation_Construct");

    }


    m_PEAK_IPL_Decimation_Acquire = (dyn_PEAK_IPL_Decimation_Acquire) (load ?  import_function(m_handle, "PEAK_IPL_Decimation_Acquire") : nullptr);

    if(m_PEAK_IPL_Decimation_Acquire == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Decimation_Acquire");

    }


    m_PEAK_IPL_Decimation_SetDecimationX = (dyn_PEAK_IPL_Decimation_SetDecimationX) (load ?  import_function(m_handle, "PEAK_IPL_Decimation_SetDecimationX") : nullptr);

    if(m_PEAK_IPL_Decimation_SetDecimationX == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Decimation_SetDecimationX");

    }


    m_PEAK_IPL_Decimation_GetDecimationX = (dyn_PEAK_IPL_Decimation_GetDecimationX) (load ?  import_function(m_handle, "PEAK_IPL_Decimation_GetDecimationX") : nullptr);

    if(m_PEAK_IPL_Decimation_GetDecimationX == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Decimation_GetDecimationX");

    }


    m_PEAK_IPL_Decimation_SetDecimationY = (dyn_PEAK_IPL_Decimation_SetDecimationY) (load ?  import_function(m_handle, "PEAK_IPL_Decimation_SetDecimationY") : nullptr);

    if(m_PEAK_IPL_Decimation_SetDecimationY == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Decimation_SetDecimationY");

    }


    m_PEAK_IPL_Decimation_GetDecimationY = (dyn_PEAK_IPL_Decimation_GetDecimationY) (load ?  import_function(m_handle, "PEAK_IPL_Decimation_GetDecimationY") : nullptr);

    if(m_PEAK_IPL_Decimation_GetDecimationY == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Decimation_GetDecimationY");

    }


    m_PEAK_IPL_Decimation_GetDecimationMin = (dyn_PEAK_IPL_Decimation_GetDecimationMin) (load ?  import_function(m_handle, "PEAK_IPL_Decimation_GetDecimationMin") : nullptr);

    if(m_PEAK_IPL_Decimation_GetDecimationMin == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Decimation_GetDecimationMin");

    }


    m_PEAK_IPL_Decimation_GetDecimationMax = (dyn_PEAK_IPL_Decimation_GetDecimationMax) (load ?  import_function(m_handle, "PEAK_IPL_Decimation_GetDecimationMax") : nullptr);

    if(m_PEAK_IPL_Decimation_GetDecimationMax == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Decimation_GetDecimationMax");

    }


    m_PEAK_IPL_Decimation_ExpectedOutputSize = (dyn_PEAK_IPL_Decimation_ExpectedOutputSize) (load ?  import_function(m_handle, "PEAK_IPL_Decimation_ExpectedOutputSize") : nullptr);

    if(m_PEAK_IPL_Decimation_ExpectedOutputSize == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Decimation_ExpectedOutputSize");

    }


    m_PEAK_IPL_Decimation_IsPixelformatSupported = (dyn_PEAK_IPL_Decimation_IsPixelformatSupported) (load ?  import_function(m_handle, "PEAK_IPL_Decimation_IsPixelformatSupported") : nullptr);

    if(m_PEAK_IPL_Decimation_IsPixelformatSupported == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Decimation_IsPixelformatSupported");

    }


    m_PEAK_IPL_Decimation_Process = (dyn_PEAK_IPL_Decimation_Process) (load ?  import_function(m_handle, "PEAK_IPL_Decimation_Process") : nullptr);

    if(m_PEAK_IPL_Decimation_Process == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Decimation_Process");

    }


    m_PEAK_IPL_Decimation_Destruct = (dyn_PEAK_IPL_Decimation_Destruct) (load ?  import_function(m_handle, "PEAK_IPL_Decimation_Destruct") : nullptr);

    if(m_PEAK_IPL_Decimation_Destruct == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Decimation_Destruct");

    }


    m_PEAK_IPL_Gain_Construct = (dyn_PEAK_IPL_Gain_Construct) (load ?  import_function(m_handle, "PEAK_IPL_Gain_Construct") : nullptr);

    if(m_PEAK_IPL_Gain_Construct == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Gain_Construct");

    }


    m_PEAK_IPL_Gain_Acquire = (dyn_PEAK_IPL_Gain_Acquire) (load ?  import_function(m_handle, "PEAK_IPL_Gain_Acquire") : nullptr);

    if(m_PEAK_IPL_Gain_Acquire == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Gain_Acquire");

    }


    m_PEAK_IPL_Gain_SetMasterGainValue = (dyn_PEAK_IPL_Gain_SetMasterGainValue) (load ?  import_function(m_handle, "PEAK_IPL_Gain_SetMasterGainValue") : nullptr);

    if(m_PEAK_IPL_Gain_SetMasterGainValue == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Gain_SetMasterGainValue");

    }


    m_PEAK_IPL_Gain_GetMasterGainValue = (dyn_PEAK_IPL_Gain_GetMasterGainValue) (load ?  import_function(m_handle, "PEAK_IPL_Gain_GetMasterGainValue") : nullptr);

    if(m_PEAK_IPL_Gain_GetMasterGainValue == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Gain_GetMasterGainValue");

    }


    m_PEAK_IPL_Gain_GetMasterGainMax = (dyn_PEAK_IPL_Gain_GetMasterGainMax) (load ?  import_function(m_handle, "PEAK_IPL_Gain_GetMasterGainMax") : nullptr);

    if(m_PEAK_IPL_Gain_GetMasterGainMax == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Gain_GetMasterGainMax");

    }


    m_PEAK_IPL_Gain_GetMasterGainMin = (dyn_PEAK_IPL_Gain_GetMasterGainMin) (load ?  import_function(m_handle, "PEAK_IPL_Gain_GetMasterGainMin") : nullptr);

    if(m_PEAK_IPL_Gain_GetMasterGainMin == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Gain_GetMasterGainMin");

    }


    m_PEAK_IPL_Gain_SetRedGainValue = (dyn_PEAK_IPL_Gain_SetRedGainValue) (load ?  import_function(m_handle, "PEAK_IPL_Gain_SetRedGainValue") : nullptr);

    if(m_PEAK_IPL_Gain_SetRedGainValue == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Gain_SetRedGainValue");

    }


    m_PEAK_IPL_Gain_GetRedGainValue = (dyn_PEAK_IPL_Gain_GetRedGainValue) (load ?  import_function(m_handle, "PEAK_IPL_Gain_GetRedGainValue") : nullptr);

    if(m_PEAK_IPL_Gain_GetRedGainValue == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Gain_GetRedGainValue");

    }


    m_PEAK_IPL_Gain_GetRedGainMax = (dyn_PEAK_IPL_Gain_GetRedGainMax) (load ?  import_function(m_handle, "PEAK_IPL_Gain_GetRedGainMax") : nullptr);

    if(m_PEAK_IPL_Gain_GetRedGainMax == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Gain_GetRedGainMax");

    }


    m_PEAK_IPL_Gain_GetRedGainMin = (dyn_PEAK_IPL_Gain_GetRedGainMin) (load ?  import_function(m_handle, "PEAK_IPL_Gain_GetRedGainMin") : nullptr);

    if(m_PEAK_IPL_Gain_GetRedGainMin == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Gain_GetRedGainMin");

    }


    m_PEAK_IPL_Gain_SetGreenGainValue = (dyn_PEAK_IPL_Gain_SetGreenGainValue) (load ?  import_function(m_handle, "PEAK_IPL_Gain_SetGreenGainValue") : nullptr);

    if(m_PEAK_IPL_Gain_SetGreenGainValue == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Gain_SetGreenGainValue");

    }


    m_PEAK_IPL_Gain_GetGreenGainValue = (dyn_PEAK_IPL_Gain_GetGreenGainValue) (load ?  import_function(m_handle, "PEAK_IPL_Gain_GetGreenGainValue") : nullptr);

    if(m_PEAK_IPL_Gain_GetGreenGainValue == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Gain_GetGreenGainValue");

    }


    m_PEAK_IPL_Gain_GetGreenGainMax = (dyn_PEAK_IPL_Gain_GetGreenGainMax) (load ?  import_function(m_handle, "PEAK_IPL_Gain_GetGreenGainMax") : nullptr);

    if(m_PEAK_IPL_Gain_GetGreenGainMax == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Gain_GetGreenGainMax");

    }


    m_PEAK_IPL_Gain_GetGreenGainMin = (dyn_PEAK_IPL_Gain_GetGreenGainMin) (load ?  import_function(m_handle, "PEAK_IPL_Gain_GetGreenGainMin") : nullptr);

    if(m_PEAK_IPL_Gain_GetGreenGainMin == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Gain_GetGreenGainMin");

    }


    m_PEAK_IPL_Gain_SetBlueGainValue = (dyn_PEAK_IPL_Gain_SetBlueGainValue) (load ?  import_function(m_handle, "PEAK_IPL_Gain_SetBlueGainValue") : nullptr);

    if(m_PEAK_IPL_Gain_SetBlueGainValue == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Gain_SetBlueGainValue");

    }


    m_PEAK_IPL_Gain_GetBlueGainValue = (dyn_PEAK_IPL_Gain_GetBlueGainValue) (load ?  import_function(m_handle, "PEAK_IPL_Gain_GetBlueGainValue") : nullptr);

    if(m_PEAK_IPL_Gain_GetBlueGainValue == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Gain_GetBlueGainValue");

    }


    m_PEAK_IPL_Gain_GetBlueGainMax = (dyn_PEAK_IPL_Gain_GetBlueGainMax) (load ?  import_function(m_handle, "PEAK_IPL_Gain_GetBlueGainMax") : nullptr);

    if(m_PEAK_IPL_Gain_GetBlueGainMax == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Gain_GetBlueGainMax");

    }


    m_PEAK_IPL_Gain_GetBlueGainMin = (dyn_PEAK_IPL_Gain_GetBlueGainMin) (load ?  import_function(m_handle, "PEAK_IPL_Gain_GetBlueGainMin") : nullptr);

    if(m_PEAK_IPL_Gain_GetBlueGainMin == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Gain_GetBlueGainMin");

    }


    m_PEAK_IPL_Gain_GetIsPixelFormatSupported = (dyn_PEAK_IPL_Gain_GetIsPixelFormatSupported) (load ?  import_function(m_handle, "PEAK_IPL_Gain_GetIsPixelFormatSupported") : nullptr);

    if(m_PEAK_IPL_Gain_GetIsPixelFormatSupported == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Gain_GetIsPixelFormatSupported");

    }


    m_PEAK_IPL_Gain_Process = (dyn_PEAK_IPL_Gain_Process) (load ?  import_function(m_handle, "PEAK_IPL_Gain_Process") : nullptr);

    if(m_PEAK_IPL_Gain_Process == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Gain_Process");

    }


    m_PEAK_IPL_Gain_ProcessInPlace = (dyn_PEAK_IPL_Gain_ProcessInPlace) (load ?  import_function(m_handle, "PEAK_IPL_Gain_ProcessInPlace") : nullptr);

    if(m_PEAK_IPL_Gain_ProcessInPlace == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Gain_ProcessInPlace");

    }


    m_PEAK_IPL_Gain_Destruct = (dyn_PEAK_IPL_Gain_Destruct) (load ?  import_function(m_handle, "PEAK_IPL_Gain_Destruct") : nullptr);

    if(m_PEAK_IPL_Gain_Destruct == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Gain_Destruct");

    }


    m_PEAK_IPL_GammaCorrector_Construct = (dyn_PEAK_IPL_GammaCorrector_Construct) (load ?  import_function(m_handle, "PEAK_IPL_GammaCorrector_Construct") : nullptr);

    if(m_PEAK_IPL_GammaCorrector_Construct == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_GammaCorrector_Construct");

    }


    m_PEAK_IPL_GammaCorrector_Acquire = (dyn_PEAK_IPL_GammaCorrector_Acquire) (load ?  import_function(m_handle, "PEAK_IPL_GammaCorrector_Acquire") : nullptr);

    if(m_PEAK_IPL_GammaCorrector_Acquire == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_GammaCorrector_Acquire");

    }


    m_PEAK_IPL_GammaCorrector_SetGammaCorrectionValue = (dyn_PEAK_IPL_GammaCorrector_SetGammaCorrectionValue) (load ?  import_function(m_handle, "PEAK_IPL_GammaCorrector_SetGammaCorrectionValue") : nullptr);

    if(m_PEAK_IPL_GammaCorrector_SetGammaCorrectionValue == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_GammaCorrector_SetGammaCorrectionValue");

    }


    m_PEAK_IPL_GammaCorrector_GetGammaCorrectionValue = (dyn_PEAK_IPL_GammaCorrector_GetGammaCorrectionValue) (load ?  import_function(m_handle, "PEAK_IPL_GammaCorrector_GetGammaCorrectionValue") : nullptr);

    if(m_PEAK_IPL_GammaCorrector_GetGammaCorrectionValue == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_GammaCorrector_GetGammaCorrectionValue");

    }


    m_PEAK_IPL_GammaCorrector_GetGammaCorrectionMax = (dyn_PEAK_IPL_GammaCorrector_GetGammaCorrectionMax) (load ?  import_function(m_handle, "PEAK_IPL_GammaCorrector_GetGammaCorrectionMax") : nullptr);

    if(m_PEAK_IPL_GammaCorrector_GetGammaCorrectionMax == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_GammaCorrector_GetGammaCorrectionMax");

    }


    m_PEAK_IPL_GammaCorrector_GetGammaCorrectionMin = (dyn_PEAK_IPL_GammaCorrector_GetGammaCorrectionMin) (load ?  import_function(m_handle, "PEAK_IPL_GammaCorrector_GetGammaCorrectionMin") : nullptr);

    if(m_PEAK_IPL_GammaCorrector_GetGammaCorrectionMin == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_GammaCorrector_GetGammaCorrectionMin");

    }


    m_PEAK_IPL_GammaCorrector_SetDigitalBlack = (dyn_PEAK_IPL_GammaCorrector_SetDigitalBlack) (load ?  import_function(m_handle, "PEAK_IPL_GammaCorrector_SetDigitalBlack") : nullptr);

    if(m_PEAK_IPL_GammaCorrector_SetDigitalBlack == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_GammaCorrector_SetDigitalBlack");

    }


    m_PEAK_IPL_GammaCorrector_GetDigitalBlack = (dyn_PEAK_IPL_GammaCorrector_GetDigitalBlack) (load ?  import_function(m_handle, "PEAK_IPL_GammaCorrector_GetDigitalBlack") : nullptr);

    if(m_PEAK_IPL_GammaCorrector_GetDigitalBlack == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_GammaCorrector_GetDigitalBlack");

    }


    m_PEAK_IPL_GammaCorrector_GetDigitalBlackMax = (dyn_PEAK_IPL_GammaCorrector_GetDigitalBlackMax) (load ?  import_function(m_handle, "PEAK_IPL_GammaCorrector_GetDigitalBlackMax") : nullptr);

    if(m_PEAK_IPL_GammaCorrector_GetDigitalBlackMax == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_GammaCorrector_GetDigitalBlackMax");

    }


    m_PEAK_IPL_GammaCorrector_GetDigitalBlackMin = (dyn_PEAK_IPL_GammaCorrector_GetDigitalBlackMin) (load ?  import_function(m_handle, "PEAK_IPL_GammaCorrector_GetDigitalBlackMin") : nullptr);

    if(m_PEAK_IPL_GammaCorrector_GetDigitalBlackMin == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_GammaCorrector_GetDigitalBlackMin");

    }


    m_PEAK_IPL_GammaCorrector_GetIsPixelFormatSupported = (dyn_PEAK_IPL_GammaCorrector_GetIsPixelFormatSupported) (load ?  import_function(m_handle, "PEAK_IPL_GammaCorrector_GetIsPixelFormatSupported") : nullptr);

    if(m_PEAK_IPL_GammaCorrector_GetIsPixelFormatSupported == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_GammaCorrector_GetIsPixelFormatSupported");

    }


    m_PEAK_IPL_GammaCorrector_Process = (dyn_PEAK_IPL_GammaCorrector_Process) (load ?  import_function(m_handle, "PEAK_IPL_GammaCorrector_Process") : nullptr);

    if(m_PEAK_IPL_GammaCorrector_Process == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_GammaCorrector_Process");

    }


    m_PEAK_IPL_GammaCorrector_ProcessInPlace = (dyn_PEAK_IPL_GammaCorrector_ProcessInPlace) (load ?  import_function(m_handle, "PEAK_IPL_GammaCorrector_ProcessInPlace") : nullptr);

    if(m_PEAK_IPL_GammaCorrector_ProcessInPlace == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_GammaCorrector_ProcessInPlace");

    }


    m_PEAK_IPL_GammaCorrector_Destruct = (dyn_PEAK_IPL_GammaCorrector_Destruct) (load ?  import_function(m_handle, "PEAK_IPL_GammaCorrector_Destruct") : nullptr);

    if(m_PEAK_IPL_GammaCorrector_Destruct == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_GammaCorrector_Destruct");

    }


    m_PEAK_IPL_Image_Construct = (dyn_PEAK_IPL_Image_Construct) (load ?  import_function(m_handle, "PEAK_IPL_Image_Construct") : nullptr);

    if(m_PEAK_IPL_Image_Construct == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Image_Construct");

    }


    m_PEAK_IPL_Image_Acquire = (dyn_PEAK_IPL_Image_Acquire) (load ?  import_function(m_handle, "PEAK_IPL_Image_Acquire") : nullptr);

    if(m_PEAK_IPL_Image_Acquire == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Image_Acquire");

    }


    m_PEAK_IPL_Image_ConstructFromBuffer = (dyn_PEAK_IPL_Image_ConstructFromBuffer) (load ?  import_function(m_handle, "PEAK_IPL_Image_ConstructFromBuffer") : nullptr);

    if(m_PEAK_IPL_Image_ConstructFromBuffer == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Image_ConstructFromBuffer");

    }


    m_PEAK_IPL_Image_GetWidth = (dyn_PEAK_IPL_Image_GetWidth) (load ?  import_function(m_handle, "PEAK_IPL_Image_GetWidth") : nullptr);

    if(m_PEAK_IPL_Image_GetWidth == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Image_GetWidth");

    }


    m_PEAK_IPL_Image_GetHeight = (dyn_PEAK_IPL_Image_GetHeight) (load ?  import_function(m_handle, "PEAK_IPL_Image_GetHeight") : nullptr);

    if(m_PEAK_IPL_Image_GetHeight == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Image_GetHeight");

    }


    m_PEAK_IPL_Image_GetPixelPointer = (dyn_PEAK_IPL_Image_GetPixelPointer) (load ?  import_function(m_handle, "PEAK_IPL_Image_GetPixelPointer") : nullptr);

    if(m_PEAK_IPL_Image_GetPixelPointer == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Image_GetPixelPointer");

    }


    m_PEAK_IPL_Image_GetByteCount = (dyn_PEAK_IPL_Image_GetByteCount) (load ?  import_function(m_handle, "PEAK_IPL_Image_GetByteCount") : nullptr);

    if(m_PEAK_IPL_Image_GetByteCount == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Image_GetByteCount");

    }


    m_PEAK_IPL_Image_GetPixelFormat = (dyn_PEAK_IPL_Image_GetPixelFormat) (load ?  import_function(m_handle, "PEAK_IPL_Image_GetPixelFormat") : nullptr);

    if(m_PEAK_IPL_Image_GetPixelFormat == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Image_GetPixelFormat");

    }


    m_PEAK_IPL_Image_GetData = (dyn_PEAK_IPL_Image_GetData) (load ?  import_function(m_handle, "PEAK_IPL_Image_GetData") : nullptr);

    if(m_PEAK_IPL_Image_GetData == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Image_GetData");

    }


    m_PEAK_IPL_Image_Clone = (dyn_PEAK_IPL_Image_Clone) (load ?  import_function(m_handle, "PEAK_IPL_Image_Clone") : nullptr);

    if(m_PEAK_IPL_Image_Clone == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Image_Clone");

    }


    m_PEAK_IPL_Image_ConvertTo = (dyn_PEAK_IPL_Image_ConvertTo) (load ?  import_function(m_handle, "PEAK_IPL_Image_ConvertTo") : nullptr);

    if(m_PEAK_IPL_Image_ConvertTo == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Image_ConvertTo");

    }


    m_PEAK_IPL_Image_ConvertToBuffer = (dyn_PEAK_IPL_Image_ConvertToBuffer) (load ?  import_function(m_handle, "PEAK_IPL_Image_ConvertToBuffer") : nullptr);

    if(m_PEAK_IPL_Image_ConvertToBuffer == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Image_ConvertToBuffer");

    }


    m_PEAK_IPL_Image_ConvertToWithFactor = (dyn_PEAK_IPL_Image_ConvertToWithFactor) (load ?  import_function(m_handle, "PEAK_IPL_Image_ConvertToWithFactor") : nullptr);

    if(m_PEAK_IPL_Image_ConvertToWithFactor == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Image_ConvertToWithFactor");

    }


    m_PEAK_IPL_Image_ConvertToWithFactorAndOffset = (dyn_PEAK_IPL_Image_ConvertToWithFactorAndOffset) (load ?  import_function(m_handle, "PEAK_IPL_Image_ConvertToWithFactorAndOffset") : nullptr);

    if(m_PEAK_IPL_Image_ConvertToWithFactorAndOffset == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Image_ConvertToWithFactorAndOffset");

    }


    m_PEAK_IPL_Image_ConvertToBufferWithFactorAndOffset = (dyn_PEAK_IPL_Image_ConvertToBufferWithFactorAndOffset) (load ?  import_function(m_handle, "PEAK_IPL_Image_ConvertToBufferWithFactorAndOffset") : nullptr);

    if(m_PEAK_IPL_Image_ConvertToBufferWithFactorAndOffset == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Image_ConvertToBufferWithFactorAndOffset");

    }


    m_PEAK_IPL_Image_ConvertToFromInterval = (dyn_PEAK_IPL_Image_ConvertToFromInterval) (load ?  import_function(m_handle, "PEAK_IPL_Image_ConvertToFromInterval") : nullptr);

    if(m_PEAK_IPL_Image_ConvertToFromInterval == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Image_ConvertToFromInterval");

    }


    m_PEAK_IPL_Image_ConvertToBufferFromInterval = (dyn_PEAK_IPL_Image_ConvertToBufferFromInterval) (load ?  import_function(m_handle, "PEAK_IPL_Image_ConvertToBufferFromInterval") : nullptr);

    if(m_PEAK_IPL_Image_ConvertToBufferFromInterval == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Image_ConvertToBufferFromInterval");

    }


    m_PEAK_IPL_Image_Scale = (dyn_PEAK_IPL_Image_Scale) (load ?  import_function(m_handle, "PEAK_IPL_Image_Scale") : nullptr);

    if(m_PEAK_IPL_Image_Scale == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Image_Scale");

    }


    m_PEAK_IPL_Image_ScaleInto = (dyn_PEAK_IPL_Image_ScaleInto) (load ?  import_function(m_handle, "PEAK_IPL_Image_ScaleInto") : nullptr);

    if(m_PEAK_IPL_Image_ScaleInto == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Image_ScaleInto");

    }


    m_PEAK_IPL_Image_Crop = (dyn_PEAK_IPL_Image_Crop) (load ?  import_function(m_handle, "PEAK_IPL_Image_Crop") : nullptr);

    if(m_PEAK_IPL_Image_Crop == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Image_Crop");

    }


    m_PEAK_IPL_Image_Destruct = (dyn_PEAK_IPL_Image_Destruct) (load ?  import_function(m_handle, "PEAK_IPL_Image_Destruct") : nullptr);

    if(m_PEAK_IPL_Image_Destruct == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Image_Destruct");

    }


    m_PEAK_IPL_ImageTransformer_Construct = (dyn_PEAK_IPL_ImageTransformer_Construct) (load ?  import_function(m_handle, "PEAK_IPL_ImageTransformer_Construct") : nullptr);

    if(m_PEAK_IPL_ImageTransformer_Construct == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ImageTransformer_Construct");

    }


    m_PEAK_IPL_ImageTransformer_Acquire = (dyn_PEAK_IPL_ImageTransformer_Acquire) (load ?  import_function(m_handle, "PEAK_IPL_ImageTransformer_Acquire") : nullptr);

    if(m_PEAK_IPL_ImageTransformer_Acquire == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ImageTransformer_Acquire");

    }


    m_PEAK_IPL_Image_SetTimestamp = (dyn_PEAK_IPL_Image_SetTimestamp) (load ?  import_function(m_handle, "PEAK_IPL_Image_SetTimestamp") : nullptr);

    if(m_PEAK_IPL_Image_SetTimestamp == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Image_SetTimestamp");

    }


    m_PEAK_IPL_Image_GetTimestamp = (dyn_PEAK_IPL_Image_GetTimestamp) (load ?  import_function(m_handle, "PEAK_IPL_Image_GetTimestamp") : nullptr);

    if(m_PEAK_IPL_Image_GetTimestamp == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Image_GetTimestamp");

    }


    m_PEAK_IPL_ImageTransformer_MirrorUpDown = (dyn_PEAK_IPL_ImageTransformer_MirrorUpDown) (load ?  import_function(m_handle, "PEAK_IPL_ImageTransformer_MirrorUpDown") : nullptr);

    if(m_PEAK_IPL_ImageTransformer_MirrorUpDown == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ImageTransformer_MirrorUpDown");

    }


    m_PEAK_IPL_ImageTransformer_MirrorLeftRight = (dyn_PEAK_IPL_ImageTransformer_MirrorLeftRight) (load ?  import_function(m_handle, "PEAK_IPL_ImageTransformer_MirrorLeftRight") : nullptr);

    if(m_PEAK_IPL_ImageTransformer_MirrorLeftRight == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ImageTransformer_MirrorLeftRight");

    }


    m_PEAK_IPL_ImageTransformer_MirrorUpDownLeftRight = (dyn_PEAK_IPL_ImageTransformer_MirrorUpDownLeftRight) (load ?  import_function(m_handle, "PEAK_IPL_ImageTransformer_MirrorUpDownLeftRight") : nullptr);

    if(m_PEAK_IPL_ImageTransformer_MirrorUpDownLeftRight == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ImageTransformer_MirrorUpDownLeftRight");

    }


    m_PEAK_IPL_ImageTransformer_MirrorUpDownInPlace = (dyn_PEAK_IPL_ImageTransformer_MirrorUpDownInPlace) (load ?  import_function(m_handle, "PEAK_IPL_ImageTransformer_MirrorUpDownInPlace") : nullptr);

    if(m_PEAK_IPL_ImageTransformer_MirrorUpDownInPlace == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ImageTransformer_MirrorUpDownInPlace");

    }


    m_PEAK_IPL_ImageTransformer_MirrorLeftRightInPlace = (dyn_PEAK_IPL_ImageTransformer_MirrorLeftRightInPlace) (load ?  import_function(m_handle, "PEAK_IPL_ImageTransformer_MirrorLeftRightInPlace") : nullptr);

    if(m_PEAK_IPL_ImageTransformer_MirrorLeftRightInPlace == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ImageTransformer_MirrorLeftRightInPlace");

    }


    m_PEAK_IPL_ImageTransformer_MirrorUpDownLeftRightInPlace = (dyn_PEAK_IPL_ImageTransformer_MirrorUpDownLeftRightInPlace) (load ?  import_function(m_handle, "PEAK_IPL_ImageTransformer_MirrorUpDownLeftRightInPlace") : nullptr);

    if(m_PEAK_IPL_ImageTransformer_MirrorUpDownLeftRightInPlace == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ImageTransformer_MirrorUpDownLeftRightInPlace");

    }


    m_PEAK_IPL_ImageTransformer_Rotate = (dyn_PEAK_IPL_ImageTransformer_Rotate) (load ?  import_function(m_handle, "PEAK_IPL_ImageTransformer_Rotate") : nullptr);

    if(m_PEAK_IPL_ImageTransformer_Rotate == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ImageTransformer_Rotate");

    }


    m_PEAK_IPL_ImageTransformer_RotateInPlace = (dyn_PEAK_IPL_ImageTransformer_RotateInPlace) (load ?  import_function(m_handle, "PEAK_IPL_ImageTransformer_RotateInPlace") : nullptr);

    if(m_PEAK_IPL_ImageTransformer_RotateInPlace == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ImageTransformer_RotateInPlace");

    }


    m_PEAK_IPL_ImageTransformer_Destruct = (dyn_PEAK_IPL_ImageTransformer_Destruct) (load ?  import_function(m_handle, "PEAK_IPL_ImageTransformer_Destruct") : nullptr);

    if(m_PEAK_IPL_ImageTransformer_Destruct == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ImageTransformer_Destruct");

    }


    m_PEAK_IPL_Histogram_Construct = (dyn_PEAK_IPL_Histogram_Construct) (load ?  import_function(m_handle, "PEAK_IPL_Histogram_Construct") : nullptr);

    if(m_PEAK_IPL_Histogram_Construct == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Histogram_Construct");

    }


    m_PEAK_IPL_Histogram_Acquire = (dyn_PEAK_IPL_Histogram_Acquire) (load ?  import_function(m_handle, "PEAK_IPL_Histogram_Acquire") : nullptr);

    if(m_PEAK_IPL_Histogram_Acquire == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Histogram_Acquire");

    }


    m_PEAK_IPL_Histogram_GetPixelFormat = (dyn_PEAK_IPL_Histogram_GetPixelFormat) (load ?  import_function(m_handle, "PEAK_IPL_Histogram_GetPixelFormat") : nullptr);

    if(m_PEAK_IPL_Histogram_GetPixelFormat == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Histogram_GetPixelFormat");

    }


    m_PEAK_IPL_Histogram_GetNumChannels = (dyn_PEAK_IPL_Histogram_GetNumChannels) (load ?  import_function(m_handle, "PEAK_IPL_Histogram_GetNumChannels") : nullptr);

    if(m_PEAK_IPL_Histogram_GetNumChannels == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Histogram_GetNumChannels");

    }


    m_PEAK_IPL_Histogram_GetPixelSumForChannel = (dyn_PEAK_IPL_Histogram_GetPixelSumForChannel) (load ?  import_function(m_handle, "PEAK_IPL_Histogram_GetPixelSumForChannel") : nullptr);

    if(m_PEAK_IPL_Histogram_GetPixelSumForChannel == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Histogram_GetPixelSumForChannel");

    }


    m_PEAK_IPL_Histogram_GetPixelCountForChannel = (dyn_PEAK_IPL_Histogram_GetPixelCountForChannel) (load ?  import_function(m_handle, "PEAK_IPL_Histogram_GetPixelCountForChannel") : nullptr);

    if(m_PEAK_IPL_Histogram_GetPixelCountForChannel == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Histogram_GetPixelCountForChannel");

    }


    m_PEAK_IPL_Histogram_GetBinsForChannel = (dyn_PEAK_IPL_Histogram_GetBinsForChannel) (load ?  import_function(m_handle, "PEAK_IPL_Histogram_GetBinsForChannel") : nullptr);

    if(m_PEAK_IPL_Histogram_GetBinsForChannel == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Histogram_GetBinsForChannel");

    }


    m_PEAK_IPL_Histogram_Destruct = (dyn_PEAK_IPL_Histogram_Destruct) (load ?  import_function(m_handle, "PEAK_IPL_Histogram_Destruct") : nullptr);

    if(m_PEAK_IPL_Histogram_Destruct == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Histogram_Destruct");

    }


    m_PEAK_IPL_PixelLine_Construct = (dyn_PEAK_IPL_PixelLine_Construct) (load ?  import_function(m_handle, "PEAK_IPL_PixelLine_Construct") : nullptr);

    if(m_PEAK_IPL_PixelLine_Construct == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_PixelLine_Construct");

    }


    m_PEAK_IPL_PixelLine_Acquire = (dyn_PEAK_IPL_PixelLine_Acquire) (load ?  import_function(m_handle, "PEAK_IPL_PixelLine_Acquire") : nullptr);

    if(m_PEAK_IPL_PixelLine_Acquire == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_PixelLine_Acquire");

    }


    m_PEAK_IPL_PixelLine_GetPixelFormat = (dyn_PEAK_IPL_PixelLine_GetPixelFormat) (load ?  import_function(m_handle, "PEAK_IPL_PixelLine_GetPixelFormat") : nullptr);

    if(m_PEAK_IPL_PixelLine_GetPixelFormat == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_PixelLine_GetPixelFormat");

    }


    m_PEAK_IPL_PixelLine_GetOrientation = (dyn_PEAK_IPL_PixelLine_GetOrientation) (load ?  import_function(m_handle, "PEAK_IPL_PixelLine_GetOrientation") : nullptr);

    if(m_PEAK_IPL_PixelLine_GetOrientation == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_PixelLine_GetOrientation");

    }


    m_PEAK_IPL_PixelLine_GetOffset = (dyn_PEAK_IPL_PixelLine_GetOffset) (load ?  import_function(m_handle, "PEAK_IPL_PixelLine_GetOffset") : nullptr);

    if(m_PEAK_IPL_PixelLine_GetOffset == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_PixelLine_GetOffset");

    }


    m_PEAK_IPL_PixelLine_GetNumChannels = (dyn_PEAK_IPL_PixelLine_GetNumChannels) (load ?  import_function(m_handle, "PEAK_IPL_PixelLine_GetNumChannels") : nullptr);

    if(m_PEAK_IPL_PixelLine_GetNumChannels == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_PixelLine_GetNumChannels");

    }


    m_PEAK_IPL_PixelLine_GetValuesForChannel = (dyn_PEAK_IPL_PixelLine_GetValuesForChannel) (load ?  import_function(m_handle, "PEAK_IPL_PixelLine_GetValuesForChannel") : nullptr);

    if(m_PEAK_IPL_PixelLine_GetValuesForChannel == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_PixelLine_GetValuesForChannel");

    }


    m_PEAK_IPL_PixelLine_Destruct = (dyn_PEAK_IPL_PixelLine_Destruct) (load ?  import_function(m_handle, "PEAK_IPL_PixelLine_Destruct") : nullptr);

    if(m_PEAK_IPL_PixelLine_Destruct == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_PixelLine_Destruct");

    }


    m_PEAK_IPL_PixelFormat_GetNumChannels = (dyn_PEAK_IPL_PixelFormat_GetNumChannels) (load ?  import_function(m_handle, "PEAK_IPL_PixelFormat_GetNumChannels") : nullptr);

    if(m_PEAK_IPL_PixelFormat_GetNumChannels == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_PixelFormat_GetNumChannels");

    }


    m_PEAK_IPL_PixelFormat_GetNumSignificantBitsPerChannel = (dyn_PEAK_IPL_PixelFormat_GetNumSignificantBitsPerChannel) (load ?  import_function(m_handle, "PEAK_IPL_PixelFormat_GetNumSignificantBitsPerChannel") : nullptr);

    if(m_PEAK_IPL_PixelFormat_GetNumSignificantBitsPerChannel == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_PixelFormat_GetNumSignificantBitsPerChannel");

    }


    m_PEAK_IPL_PixelFormat_GetNumStorageBitsPerChannel = (dyn_PEAK_IPL_PixelFormat_GetNumStorageBitsPerChannel) (load ?  import_function(m_handle, "PEAK_IPL_PixelFormat_GetNumStorageBitsPerChannel") : nullptr);

    if(m_PEAK_IPL_PixelFormat_GetNumStorageBitsPerChannel == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_PixelFormat_GetNumStorageBitsPerChannel");

    }


    m_PEAK_IPL_PixelFormat_GetMaximumValuePerChannel = (dyn_PEAK_IPL_PixelFormat_GetMaximumValuePerChannel) (load ?  import_function(m_handle, "PEAK_IPL_PixelFormat_GetMaximumValuePerChannel") : nullptr);

    if(m_PEAK_IPL_PixelFormat_GetMaximumValuePerChannel == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_PixelFormat_GetMaximumValuePerChannel");

    }


    m_PEAK_IPL_PixelFormat_GetNumSignificantBitsPerPixel = (dyn_PEAK_IPL_PixelFormat_GetNumSignificantBitsPerPixel) (load ?  import_function(m_handle, "PEAK_IPL_PixelFormat_GetNumSignificantBitsPerPixel") : nullptr);

    if(m_PEAK_IPL_PixelFormat_GetNumSignificantBitsPerPixel == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_PixelFormat_GetNumSignificantBitsPerPixel");

    }


    m_PEAK_IPL_PixelFormat_GetNumStorageBitsPerPixel = (dyn_PEAK_IPL_PixelFormat_GetNumStorageBitsPerPixel) (load ?  import_function(m_handle, "PEAK_IPL_PixelFormat_GetNumStorageBitsPerPixel") : nullptr);

    if(m_PEAK_IPL_PixelFormat_GetNumStorageBitsPerPixel == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_PixelFormat_GetNumStorageBitsPerPixel");

    }


    m_PEAK_IPL_PixelFormat_GetEndianness = (dyn_PEAK_IPL_PixelFormat_GetEndianness) (load ?  import_function(m_handle, "PEAK_IPL_PixelFormat_GetEndianness") : nullptr);

    if(m_PEAK_IPL_PixelFormat_GetEndianness == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_PixelFormat_GetEndianness");

    }


    m_PEAK_IPL_PixelFormat_CalculateStorageSizeOfPixels = (dyn_PEAK_IPL_PixelFormat_CalculateStorageSizeOfPixels) (load ?  import_function(m_handle, "PEAK_IPL_PixelFormat_CalculateStorageSizeOfPixels") : nullptr);

    if(m_PEAK_IPL_PixelFormat_CalculateStorageSizeOfPixels == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_PixelFormat_CalculateStorageSizeOfPixels");

    }


    m_PEAK_IPL_PixelFormat_IsPacked = (dyn_PEAK_IPL_PixelFormat_IsPacked) (load ?  import_function(m_handle, "PEAK_IPL_PixelFormat_IsPacked") : nullptr);

    if(m_PEAK_IPL_PixelFormat_IsPacked == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_PixelFormat_IsPacked");

    }


    m_PEAK_IPL_PixelFormat_IsBayered = (dyn_PEAK_IPL_PixelFormat_IsBayered) (load ?  import_function(m_handle, "PEAK_IPL_PixelFormat_IsBayered") : nullptr);

    if(m_PEAK_IPL_PixelFormat_IsBayered == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_PixelFormat_IsBayered");

    }


    m_PEAK_IPL_PixelFormat_IsYUV = (dyn_PEAK_IPL_PixelFormat_IsYUV) (load ?  import_function(m_handle, "PEAK_IPL_PixelFormat_IsYUV") : nullptr);

    if(m_PEAK_IPL_PixelFormat_IsYUV == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_PixelFormat_IsYUV");

    }


    m_PEAK_IPL_PixelFormat_IsCoord3D = (dyn_PEAK_IPL_PixelFormat_IsCoord3D) (load ?  import_function(m_handle, "PEAK_IPL_PixelFormat_IsCoord3D") : nullptr);

    if(m_PEAK_IPL_PixelFormat_IsCoord3D == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_PixelFormat_IsCoord3D");

    }


    m_PEAK_IPL_PixelFormat_IsFloat = (dyn_PEAK_IPL_PixelFormat_IsFloat) (load ?  import_function(m_handle, "PEAK_IPL_PixelFormat_IsFloat") : nullptr);

    if(m_PEAK_IPL_PixelFormat_IsFloat == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_PixelFormat_IsFloat");

    }


    m_PEAK_IPL_PixelFormat_GetBayerPattern = (dyn_PEAK_IPL_PixelFormat_GetBayerPattern) (load ?  import_function(m_handle, "PEAK_IPL_PixelFormat_GetBayerPattern") : nullptr);

    if(m_PEAK_IPL_PixelFormat_GetBayerPattern == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_PixelFormat_GetBayerPattern");

    }


    m_PEAK_IPL_ImageWriter_WriteAsRAW = (dyn_PEAK_IPL_ImageWriter_WriteAsRAW) (load ?  import_function(m_handle, "PEAK_IPL_ImageWriter_WriteAsRAW") : nullptr);

    if(m_PEAK_IPL_ImageWriter_WriteAsRAW == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ImageWriter_WriteAsRAW");

    }


    m_PEAK_IPL_ImageWriter_WriteAsBMP = (dyn_PEAK_IPL_ImageWriter_WriteAsBMP) (load ?  import_function(m_handle, "PEAK_IPL_ImageWriter_WriteAsBMP") : nullptr);

    if(m_PEAK_IPL_ImageWriter_WriteAsBMP == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ImageWriter_WriteAsBMP");

    }


    m_PEAK_IPL_ImageWriter_WriteAsPNG = (dyn_PEAK_IPL_ImageWriter_WriteAsPNG) (load ?  import_function(m_handle, "PEAK_IPL_ImageWriter_WriteAsPNG") : nullptr);

    if(m_PEAK_IPL_ImageWriter_WriteAsPNG == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ImageWriter_WriteAsPNG");

    }


    m_PEAK_IPL_ImageWriter_WriteAsJPG = (dyn_PEAK_IPL_ImageWriter_WriteAsJPG) (load ?  import_function(m_handle, "PEAK_IPL_ImageWriter_WriteAsJPG") : nullptr);

    if(m_PEAK_IPL_ImageWriter_WriteAsJPG == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ImageWriter_WriteAsJPG");

    }


    m_PEAK_IPL_ImageWriter_Write = (dyn_PEAK_IPL_ImageWriter_Write) (load ?  import_function(m_handle, "PEAK_IPL_ImageWriter_Write") : nullptr);

    if(m_PEAK_IPL_ImageWriter_Write == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ImageWriter_Write");

    }


    m_PEAK_IPL_ImageReader_Read = (dyn_PEAK_IPL_ImageReader_Read) (load ?  import_function(m_handle, "PEAK_IPL_ImageReader_Read") : nullptr);

    if(m_PEAK_IPL_ImageReader_Read == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ImageReader_Read");

    }


    m_PEAK_IPL_ImageReaderRead_ReadAsPixelFormat = (dyn_PEAK_IPL_ImageReaderRead_ReadAsPixelFormat) (load ?  import_function(m_handle, "PEAK_IPL_ImageReaderRead_ReadAsPixelFormat") : nullptr);

    if(m_PEAK_IPL_ImageReaderRead_ReadAsPixelFormat == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ImageReaderRead_ReadAsPixelFormat");

    }


    m_PEAK_IPL_VideoWriter_Video_Open = (dyn_PEAK_IPL_VideoWriter_Video_Open) (load ?  import_function(m_handle, "PEAK_IPL_VideoWriter_Video_Open") : nullptr);

    if(m_PEAK_IPL_VideoWriter_Video_Open == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_VideoWriter_Video_Open");

    }


    m_PEAK_IPL_VideoWriter_Video_IsOpen = (dyn_PEAK_IPL_VideoWriter_Video_IsOpen) (load ?  import_function(m_handle, "PEAK_IPL_VideoWriter_Video_IsOpen") : nullptr);

    if(m_PEAK_IPL_VideoWriter_Video_IsOpen == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_VideoWriter_Video_IsOpen");

    }


    m_PEAK_IPL_VideoWriter_Video_Close = (dyn_PEAK_IPL_VideoWriter_Video_Close) (load ?  import_function(m_handle, "PEAK_IPL_VideoWriter_Video_Close") : nullptr);

    if(m_PEAK_IPL_VideoWriter_Video_Close == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_VideoWriter_Video_Close");

    }


    m_PEAK_IPL_VideoWriter_Video_Append = (dyn_PEAK_IPL_VideoWriter_Video_Append) (load ?  import_function(m_handle, "PEAK_IPL_VideoWriter_Video_Append") : nullptr);

    if(m_PEAK_IPL_VideoWriter_Video_Append == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_VideoWriter_Video_Append");

    }


    m_PEAK_IPL_VideoWriter_Encoder_SetOption = (dyn_PEAK_IPL_VideoWriter_Encoder_SetOption) (load ?  import_function(m_handle, "PEAK_IPL_VideoWriter_Encoder_SetOption") : nullptr);

    if(m_PEAK_IPL_VideoWriter_Encoder_SetOption == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_VideoWriter_Encoder_SetOption");

    }


    m_PEAK_IPL_VideoWriter_Encoder_GetOption = (dyn_PEAK_IPL_VideoWriter_Encoder_GetOption) (load ?  import_function(m_handle, "PEAK_IPL_VideoWriter_Encoder_GetOption") : nullptr);

    if(m_PEAK_IPL_VideoWriter_Encoder_GetOption == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_VideoWriter_Encoder_GetOption");

    }


    m_PEAK_IPL_VideoWriter_Encoder_OptionRange = (dyn_PEAK_IPL_VideoWriter_Encoder_OptionRange) (load ?  import_function(m_handle, "PEAK_IPL_VideoWriter_Encoder_OptionRange") : nullptr);

    if(m_PEAK_IPL_VideoWriter_Encoder_OptionRange == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_VideoWriter_Encoder_OptionRange");

    }


    m_PEAK_IPL_VideoWriter_GetSupportedEncodersForAContainer = (dyn_PEAK_IPL_VideoWriter_GetSupportedEncodersForAContainer) (load ?  import_function(m_handle, "PEAK_IPL_VideoWriter_GetSupportedEncodersForAContainer") : nullptr);

    if(m_PEAK_IPL_VideoWriter_GetSupportedEncodersForAContainer == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_VideoWriter_GetSupportedEncodersForAContainer");

    }


    m_PEAK_IPL_VideoWriter_Container_SetOption = (dyn_PEAK_IPL_VideoWriter_Container_SetOption) (load ?  import_function(m_handle, "PEAK_IPL_VideoWriter_Container_SetOption") : nullptr);

    if(m_PEAK_IPL_VideoWriter_Container_SetOption == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_VideoWriter_Container_SetOption");

    }


    m_PEAK_IPL_VideoWriter_Container_GetOption = (dyn_PEAK_IPL_VideoWriter_Container_GetOption) (load ?  import_function(m_handle, "PEAK_IPL_VideoWriter_Container_GetOption") : nullptr);

    if(m_PEAK_IPL_VideoWriter_Container_GetOption == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_VideoWriter_Container_GetOption");

    }


    m_PEAK_IPL_VideoWriter_Container_OptionRange = (dyn_PEAK_IPL_VideoWriter_Container_OptionRange) (load ?  import_function(m_handle, "PEAK_IPL_VideoWriter_Container_OptionRange") : nullptr);

    if(m_PEAK_IPL_VideoWriter_Container_OptionRange == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_VideoWriter_Container_OptionRange");

    }


    m_PEAK_IPL_VideoWriter_GetSupportedContainersForAnEncoder = (dyn_PEAK_IPL_VideoWriter_GetSupportedContainersForAnEncoder) (load ?  import_function(m_handle, "PEAK_IPL_VideoWriter_GetSupportedContainersForAnEncoder") : nullptr);

    if(m_PEAK_IPL_VideoWriter_GetSupportedContainersForAnEncoder == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_VideoWriter_GetSupportedContainersForAnEncoder");

    }


    m_PEAK_IPL_VideoWriter_Encoder_GetSupportedPixelFormats = (dyn_PEAK_IPL_VideoWriter_Encoder_GetSupportedPixelFormats) (load ?  import_function(m_handle, "PEAK_IPL_VideoWriter_Encoder_GetSupportedPixelFormats") : nullptr);

    if(m_PEAK_IPL_VideoWriter_Encoder_GetSupportedPixelFormats == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_VideoWriter_Encoder_GetSupportedPixelFormats");

    }


    m_PEAK_IPL_VideoWriter_Video_GetEncodedFrames = (dyn_PEAK_IPL_VideoWriter_Video_GetEncodedFrames) (load ?  import_function(m_handle, "PEAK_IPL_VideoWriter_Video_GetEncodedFrames") : nullptr);

    if(m_PEAK_IPL_VideoWriter_Video_GetEncodedFrames == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_VideoWriter_Video_GetEncodedFrames");

    }


    m_PEAK_IPL_VideoWriter_Video_GetDroppedFrames = (dyn_PEAK_IPL_VideoWriter_Video_GetDroppedFrames) (load ?  import_function(m_handle, "PEAK_IPL_VideoWriter_Video_GetDroppedFrames") : nullptr);

    if(m_PEAK_IPL_VideoWriter_Video_GetDroppedFrames == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_VideoWriter_Video_GetDroppedFrames");

    }


    m_PEAK_IPL_VideoWriter_Video_GetFileSize = (dyn_PEAK_IPL_VideoWriter_Video_GetFileSize) (load ?  import_function(m_handle, "PEAK_IPL_VideoWriter_Video_GetFileSize") : nullptr);

    if(m_PEAK_IPL_VideoWriter_Video_GetFileSize == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_VideoWriter_Video_GetFileSize");

    }


    m_PEAK_IPL_VideoWriter_Video_ResetFrameCounters = (dyn_PEAK_IPL_VideoWriter_Video_ResetFrameCounters) (load ?  import_function(m_handle, "PEAK_IPL_VideoWriter_Video_ResetFrameCounters") : nullptr);

    if(m_PEAK_IPL_VideoWriter_Video_ResetFrameCounters == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_VideoWriter_Video_ResetFrameCounters");

    }


    m_PEAK_IPL_VideoWriter_Queue_SetSize = (dyn_PEAK_IPL_VideoWriter_Queue_SetSize) (load ?  import_function(m_handle, "PEAK_IPL_VideoWriter_Queue_SetSize") : nullptr);

    if(m_PEAK_IPL_VideoWriter_Queue_SetSize == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_VideoWriter_Queue_SetSize");

    }


    m_PEAK_IPL_VideoWriter_Queue_GetSize = (dyn_PEAK_IPL_VideoWriter_Queue_GetSize) (load ?  import_function(m_handle, "PEAK_IPL_VideoWriter_Queue_GetSize") : nullptr);

    if(m_PEAK_IPL_VideoWriter_Queue_GetSize == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_VideoWriter_Queue_GetSize");

    }


    m_PEAK_IPL_VideoWriter_Queue_GetRange = (dyn_PEAK_IPL_VideoWriter_Queue_GetRange) (load ?  import_function(m_handle, "PEAK_IPL_VideoWriter_Queue_GetRange") : nullptr);

    if(m_PEAK_IPL_VideoWriter_Queue_GetRange == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_VideoWriter_Queue_GetRange");

    }


    m_PEAK_IPL_VideoWriter_Queue_GetQueued = (dyn_PEAK_IPL_VideoWriter_Queue_GetQueued) (load ?  import_function(m_handle, "PEAK_IPL_VideoWriter_Queue_GetQueued") : nullptr);

    if(m_PEAK_IPL_VideoWriter_Queue_GetQueued == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_VideoWriter_Queue_GetQueued");

    }


    m_PEAK_IPL_VideoWriter_Video_WaitUntilFrameDone = (dyn_PEAK_IPL_VideoWriter_Video_WaitUntilFrameDone) (load ?  import_function(m_handle, "PEAK_IPL_VideoWriter_Video_WaitUntilFrameDone") : nullptr);

    if(m_PEAK_IPL_VideoWriter_Video_WaitUntilFrameDone == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_VideoWriter_Video_WaitUntilFrameDone");

    }


    m_PEAK_IPL_VideoWriter_Video_WaitUntilQueueEmpty = (dyn_PEAK_IPL_VideoWriter_Video_WaitUntilQueueEmpty) (load ?  import_function(m_handle, "PEAK_IPL_VideoWriter_Video_WaitUntilQueueEmpty") : nullptr);

    if(m_PEAK_IPL_VideoWriter_Video_WaitUntilQueueEmpty == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_VideoWriter_Video_WaitUntilQueueEmpty");

    }


    m_PEAK_IPL_ImageSharpness_Construct = (dyn_PEAK_IPL_ImageSharpness_Construct) (load ?  import_function(m_handle, "PEAK_IPL_ImageSharpness_Construct") : nullptr);

    if(m_PEAK_IPL_ImageSharpness_Construct == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ImageSharpness_Construct");

    }


    m_PEAK_IPL_ImageSharpness_Acquire = (dyn_PEAK_IPL_ImageSharpness_Acquire) (load ?  import_function(m_handle, "PEAK_IPL_ImageSharpness_Acquire") : nullptr);

    if(m_PEAK_IPL_ImageSharpness_Acquire == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ImageSharpness_Acquire");

    }


    m_PEAK_IPL_ImageSharpness_Destruct = (dyn_PEAK_IPL_ImageSharpness_Destruct) (load ?  import_function(m_handle, "PEAK_IPL_ImageSharpness_Destruct") : nullptr);

    if(m_PEAK_IPL_ImageSharpness_Destruct == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ImageSharpness_Destruct");

    }


    m_PEAK_IPL_ImageSharpness_Measure = (dyn_PEAK_IPL_ImageSharpness_Measure) (load ?  import_function(m_handle, "PEAK_IPL_ImageSharpness_Measure") : nullptr);

    if(m_PEAK_IPL_ImageSharpness_Measure == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ImageSharpness_Measure");

    }


    m_PEAK_IPL_ImageSharpness_GetIsPixelFormatSupported = (dyn_PEAK_IPL_ImageSharpness_GetIsPixelFormatSupported) (load ?  import_function(m_handle, "PEAK_IPL_ImageSharpness_GetIsPixelFormatSupported") : nullptr);

    if(m_PEAK_IPL_ImageSharpness_GetIsPixelFormatSupported == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ImageSharpness_GetIsPixelFormatSupported");

    }


    m_PEAK_IPL_ImageSharpness_GetSupportedPixelFormatList = (dyn_PEAK_IPL_ImageSharpness_GetSupportedPixelFormatList) (load ?  import_function(m_handle, "PEAK_IPL_ImageSharpness_GetSupportedPixelFormatList") : nullptr);

    if(m_PEAK_IPL_ImageSharpness_GetSupportedPixelFormatList == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ImageSharpness_GetSupportedPixelFormatList");

    }


    m_PEAK_IPL_ImageSharpness_SetAlgorithm = (dyn_PEAK_IPL_ImageSharpness_SetAlgorithm) (load ?  import_function(m_handle, "PEAK_IPL_ImageSharpness_SetAlgorithm") : nullptr);

    if(m_PEAK_IPL_ImageSharpness_SetAlgorithm == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ImageSharpness_SetAlgorithm");

    }


    m_PEAK_IPL_ImageSharpness_GetAlgorithm = (dyn_PEAK_IPL_ImageSharpness_GetAlgorithm) (load ?  import_function(m_handle, "PEAK_IPL_ImageSharpness_GetAlgorithm") : nullptr);

    if(m_PEAK_IPL_ImageSharpness_GetAlgorithm == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ImageSharpness_GetAlgorithm");

    }


    m_PEAK_IPL_ImageSharpness_GetROIMinimumSize = (dyn_PEAK_IPL_ImageSharpness_GetROIMinimumSize) (load ?  import_function(m_handle, "PEAK_IPL_ImageSharpness_GetROIMinimumSize") : nullptr);

    if(m_PEAK_IPL_ImageSharpness_GetROIMinimumSize == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ImageSharpness_GetROIMinimumSize");

    }


    m_PEAK_IPL_ImageSharpness_SetROIs = (dyn_PEAK_IPL_ImageSharpness_SetROIs) (load ?  import_function(m_handle, "PEAK_IPL_ImageSharpness_SetROIs") : nullptr);

    if(m_PEAK_IPL_ImageSharpness_SetROIs == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ImageSharpness_SetROIs");

    }


    m_PEAK_IPL_ImageSharpness_GetROIs = (dyn_PEAK_IPL_ImageSharpness_GetROIs) (load ?  import_function(m_handle, "PEAK_IPL_ImageSharpness_GetROIs") : nullptr);

    if(m_PEAK_IPL_ImageSharpness_GetROIs == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ImageSharpness_GetROIs");

    }


    m_PEAK_IPL_EdgeEnhancement_Construct = (dyn_PEAK_IPL_EdgeEnhancement_Construct) (load ?  import_function(m_handle, "PEAK_IPL_EdgeEnhancement_Construct") : nullptr);

    if(m_PEAK_IPL_EdgeEnhancement_Construct == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_EdgeEnhancement_Construct");

    }


    m_PEAK_IPL_EdgeEnhancement_Acquire = (dyn_PEAK_IPL_EdgeEnhancement_Acquire) (load ?  import_function(m_handle, "PEAK_IPL_EdgeEnhancement_Acquire") : nullptr);

    if(m_PEAK_IPL_EdgeEnhancement_Acquire == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_EdgeEnhancement_Acquire");

    }


    m_PEAK_IPL_EdgeEnhancement_Destruct = (dyn_PEAK_IPL_EdgeEnhancement_Destruct) (load ?  import_function(m_handle, "PEAK_IPL_EdgeEnhancement_Destruct") : nullptr);

    if(m_PEAK_IPL_EdgeEnhancement_Destruct == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_EdgeEnhancement_Destruct");

    }


    m_PEAK_IPL_EdgeEnhancement_ProcessInPlace = (dyn_PEAK_IPL_EdgeEnhancement_ProcessInPlace) (load ?  import_function(m_handle, "PEAK_IPL_EdgeEnhancement_ProcessInPlace") : nullptr);

    if(m_PEAK_IPL_EdgeEnhancement_ProcessInPlace == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_EdgeEnhancement_ProcessInPlace");

    }


    m_PEAK_IPL_EdgeEnhancement_Process = (dyn_PEAK_IPL_EdgeEnhancement_Process) (load ?  import_function(m_handle, "PEAK_IPL_EdgeEnhancement_Process") : nullptr);

    if(m_PEAK_IPL_EdgeEnhancement_Process == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_EdgeEnhancement_Process");

    }


    m_PEAK_IPL_EdgeEnhancement_GetFactorRange = (dyn_PEAK_IPL_EdgeEnhancement_GetFactorRange) (load ?  import_function(m_handle, "PEAK_IPL_EdgeEnhancement_GetFactorRange") : nullptr);

    if(m_PEAK_IPL_EdgeEnhancement_GetFactorRange == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_EdgeEnhancement_GetFactorRange");

    }


    m_PEAK_IPL_EdgeEnhancement_SetFactor = (dyn_PEAK_IPL_EdgeEnhancement_SetFactor) (load ?  import_function(m_handle, "PEAK_IPL_EdgeEnhancement_SetFactor") : nullptr);

    if(m_PEAK_IPL_EdgeEnhancement_SetFactor == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_EdgeEnhancement_SetFactor");

    }


    m_PEAK_IPL_EdgeEnhancement_GetFactor = (dyn_PEAK_IPL_EdgeEnhancement_GetFactor) (load ?  import_function(m_handle, "PEAK_IPL_EdgeEnhancement_GetFactor") : nullptr);

    if(m_PEAK_IPL_EdgeEnhancement_GetFactor == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_EdgeEnhancement_GetFactor");

    }


    m_PEAK_IPL_EdgeEnhancement_GetDefaultFactor = (dyn_PEAK_IPL_EdgeEnhancement_GetDefaultFactor) (load ?  import_function(m_handle, "PEAK_IPL_EdgeEnhancement_GetDefaultFactor") : nullptr);

    if(m_PEAK_IPL_EdgeEnhancement_GetDefaultFactor == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_EdgeEnhancement_GetDefaultFactor");

    }


    m_PEAK_IPL_EdgeEnhancement_IsPixelFormatSupported = (dyn_PEAK_IPL_EdgeEnhancement_IsPixelFormatSupported) (load ?  import_function(m_handle, "PEAK_IPL_EdgeEnhancement_IsPixelFormatSupported") : nullptr);

    if(m_PEAK_IPL_EdgeEnhancement_IsPixelFormatSupported == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_EdgeEnhancement_IsPixelFormatSupported");

    }


    m_PEAK_IPL_Lut_Construct = (dyn_PEAK_IPL_Lut_Construct) (load ?  import_function(m_handle, "PEAK_IPL_Lut_Construct") : nullptr);

    if(m_PEAK_IPL_Lut_Construct == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Lut_Construct");

    }


    m_PEAK_IPL_Lut_Acquire = (dyn_PEAK_IPL_Lut_Acquire) (load ?  import_function(m_handle, "PEAK_IPL_Lut_Acquire") : nullptr);

    if(m_PEAK_IPL_Lut_Acquire == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Lut_Acquire");

    }


    m_PEAK_IPL_Lut_GetLutValue = (dyn_PEAK_IPL_Lut_GetLutValue) (load ?  import_function(m_handle, "PEAK_IPL_Lut_GetLutValue") : nullptr);

    if(m_PEAK_IPL_Lut_GetLutValue == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Lut_GetLutValue");

    }


    m_PEAK_IPL_Lut_SetLutValue = (dyn_PEAK_IPL_Lut_SetLutValue) (load ?  import_function(m_handle, "PEAK_IPL_Lut_SetLutValue") : nullptr);

    if(m_PEAK_IPL_Lut_SetLutValue == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Lut_SetLutValue");

    }


    m_PEAK_IPL_Lut_GetAllLutValues = (dyn_PEAK_IPL_Lut_GetAllLutValues) (load ?  import_function(m_handle, "PEAK_IPL_Lut_GetAllLutValues") : nullptr);

    if(m_PEAK_IPL_Lut_GetAllLutValues == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Lut_GetAllLutValues");

    }


    m_PEAK_IPL_Lut_SetAllLutValues = (dyn_PEAK_IPL_Lut_SetAllLutValues) (load ?  import_function(m_handle, "PEAK_IPL_Lut_SetAllLutValues") : nullptr);

    if(m_PEAK_IPL_Lut_SetAllLutValues == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Lut_SetAllLutValues");

    }


    m_PEAK_IPL_Lut_SetLutPreset = (dyn_PEAK_IPL_Lut_SetLutPreset) (load ?  import_function(m_handle, "PEAK_IPL_Lut_SetLutPreset") : nullptr);

    if(m_PEAK_IPL_Lut_SetLutPreset == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Lut_SetLutPreset");

    }


    m_PEAK_IPL_Lut_IsPixelFormatSupported = (dyn_PEAK_IPL_Lut_IsPixelFormatSupported) (load ?  import_function(m_handle, "PEAK_IPL_Lut_IsPixelFormatSupported") : nullptr);

    if(m_PEAK_IPL_Lut_IsPixelFormatSupported == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Lut_IsPixelFormatSupported");

    }


    m_PEAK_IPL_Lut_Process = (dyn_PEAK_IPL_Lut_Process) (load ?  import_function(m_handle, "PEAK_IPL_Lut_Process") : nullptr);

    if(m_PEAK_IPL_Lut_Process == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Lut_Process");

    }


    m_PEAK_IPL_Lut_ProcessInPlace = (dyn_PEAK_IPL_Lut_ProcessInPlace) (load ?  import_function(m_handle, "PEAK_IPL_Lut_ProcessInPlace") : nullptr);

    if(m_PEAK_IPL_Lut_ProcessInPlace == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Lut_ProcessInPlace");

    }


    m_PEAK_IPL_Lut_Destruct = (dyn_PEAK_IPL_Lut_Destruct) (load ?  import_function(m_handle, "PEAK_IPL_Lut_Destruct") : nullptr);

    if(m_PEAK_IPL_Lut_Destruct == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_Lut_Destruct");

    }


    m_PEAK_IPL_ChromaticAdapter_Construct = (dyn_PEAK_IPL_ChromaticAdapter_Construct) (load ?  import_function(m_handle, "PEAK_IPL_ChromaticAdapter_Construct") : nullptr);

    if(m_PEAK_IPL_ChromaticAdapter_Construct == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ChromaticAdapter_Construct");

    }


    m_PEAK_IPL_ChromaticAdapter_Acquire = (dyn_PEAK_IPL_ChromaticAdapter_Acquire) (load ?  import_function(m_handle, "PEAK_IPL_ChromaticAdapter_Acquire") : nullptr);

    if(m_PEAK_IPL_ChromaticAdapter_Acquire == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ChromaticAdapter_Acquire");

    }


    m_PEAK_IPL_ChromaticAdapter_Destruct = (dyn_PEAK_IPL_ChromaticAdapter_Destruct) (load ?  import_function(m_handle, "PEAK_IPL_ChromaticAdapter_Destruct") : nullptr);

    if(m_PEAK_IPL_ChromaticAdapter_Destruct == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ChromaticAdapter_Destruct");

    }


    m_PEAK_IPL_ChromaticAdapter_GetTargetColorSpace = (dyn_PEAK_IPL_ChromaticAdapter_GetTargetColorSpace) (load ?  import_function(m_handle, "PEAK_IPL_ChromaticAdapter_GetTargetColorSpace") : nullptr);

    if(m_PEAK_IPL_ChromaticAdapter_GetTargetColorSpace == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ChromaticAdapter_GetTargetColorSpace");

    }


    m_PEAK_IPL_ChromaticAdapter_SetTargetColorSpace = (dyn_PEAK_IPL_ChromaticAdapter_SetTargetColorSpace) (load ?  import_function(m_handle, "PEAK_IPL_ChromaticAdapter_SetTargetColorSpace") : nullptr);

    if(m_PEAK_IPL_ChromaticAdapter_SetTargetColorSpace == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ChromaticAdapter_SetTargetColorSpace");

    }


    m_PEAK_IPL_ChromaticAdapter_GetAdaptionAlgorithm = (dyn_PEAK_IPL_ChromaticAdapter_GetAdaptionAlgorithm) (load ?  import_function(m_handle, "PEAK_IPL_ChromaticAdapter_GetAdaptionAlgorithm") : nullptr);

    if(m_PEAK_IPL_ChromaticAdapter_GetAdaptionAlgorithm == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ChromaticAdapter_GetAdaptionAlgorithm");

    }


    m_PEAK_IPL_ChromaticAdapter_SetAdaptionAlgorithm = (dyn_PEAK_IPL_ChromaticAdapter_SetAdaptionAlgorithm) (load ?  import_function(m_handle, "PEAK_IPL_ChromaticAdapter_SetAdaptionAlgorithm") : nullptr);

    if(m_PEAK_IPL_ChromaticAdapter_SetAdaptionAlgorithm == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ChromaticAdapter_SetAdaptionAlgorithm");

    }


    m_PEAK_IPL_ChromaticAdapter_CalculateColorCorrectionMatrix = (dyn_PEAK_IPL_ChromaticAdapter_CalculateColorCorrectionMatrix) (load ?  import_function(m_handle, "PEAK_IPL_ChromaticAdapter_CalculateColorCorrectionMatrix") : nullptr);

    if(m_PEAK_IPL_ChromaticAdapter_CalculateColorCorrectionMatrix == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ChromaticAdapter_CalculateColorCorrectionMatrix");

    }


    m_PEAK_IPL_ChromaticAdapter_GetTemperatureRange = (dyn_PEAK_IPL_ChromaticAdapter_GetTemperatureRange) (load ?  import_function(m_handle, "PEAK_IPL_ChromaticAdapter_GetTemperatureRange") : nullptr);

    if(m_PEAK_IPL_ChromaticAdapter_GetTemperatureRange == nullptr && load)

    {

        throw std::runtime_error("Failed to load PEAK_IPL_ChromaticAdapter_GetTemperatureRange");

    }


            return true;

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Library_GetVersionMajor(uint32_t * libraryVersionMajor)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Library_GetVersionMajor)

    {

        return inst.m_PEAK_IPL_Library_GetVersionMajor(libraryVersionMajor);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Library_GetVersionMinor(uint32_t * libraryVersionMinor)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Library_GetVersionMinor)

    {

        return inst.m_PEAK_IPL_Library_GetVersionMinor(libraryVersionMinor);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Library_GetVersionSubminor(uint32_t * libraryVersionSubminor)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Library_GetVersionSubminor)

    {

        return inst.m_PEAK_IPL_Library_GetVersionSubminor(libraryVersionSubminor);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Library_GetMaxConcurrentThreads(size_t * concurrentThreads)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Library_GetMaxConcurrentThreads)

    {

        return inst.m_PEAK_IPL_Library_GetMaxConcurrentThreads(concurrentThreads);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Library_SetMaxConcurrentThreads(size_t concurrentThreads)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Library_SetMaxConcurrentThreads)

    {

        return inst.m_PEAK_IPL_Library_SetMaxConcurrentThreads(concurrentThreads);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Library_GetMultiThreadingEnabled(PEAK_IPL_BOOL8 * enabled)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Library_GetMultiThreadingEnabled)

    {

        return inst.m_PEAK_IPL_Library_GetMultiThreadingEnabled(enabled);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Library_SetMultiThreadingEnabled(PEAK_IPL_BOOL8 enabled)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Library_SetMultiThreadingEnabled)

    {

        return inst.m_PEAK_IPL_Library_SetMultiThreadingEnabled(enabled);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Library_GetSIMDEnabled(PEAK_IPL_BOOL8 * enabled)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Library_GetSIMDEnabled)

    {

        return inst.m_PEAK_IPL_Library_GetSIMDEnabled(enabled);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Library_SetSIMDEnabled(PEAK_IPL_BOOL8 enabled)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Library_SetSIMDEnabled)

    {

        return inst.m_PEAK_IPL_Library_SetSIMDEnabled(enabled);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Library_GetLastError(PEAK_IPL_RETURN_CODE * lastErrorCode, char * lastErrorDescription, size_t * lastErrorDescriptionSize)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Library_GetLastError)

    {

        return inst.m_PEAK_IPL_Library_GetLastError(lastErrorCode, lastErrorDescription, lastErrorDescriptionSize);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageConverter_Construct(PEAK_IPL_IMAGE_CONVERTER_HANDLE * imageConverterHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ImageConverter_Construct)

    {

        return inst.m_PEAK_IPL_ImageConverter_Construct(imageConverterHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageConverter_Acquire(PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ImageConverter_Acquire)

    {

        return inst.m_PEAK_IPL_ImageConverter_Acquire(imageConverterHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::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)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ImageConverter_PreAllocateConversion)

    {

        return inst.m_PEAK_IPL_ImageConverter_PreAllocateConversion(imageConverterHandle, inputPixelFormat, outputPixelFormat, width, height, imageCount);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageConverter_GetConversionMode(PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle, PEAK_IPL_CONVERSION_MODE * conversionMode)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ImageConverter_GetConversionMode)

    {

        return inst.m_PEAK_IPL_ImageConverter_GetConversionMode(imageConverterHandle, conversionMode);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageConverter_SetConversionMode(PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle, PEAK_IPL_CONVERSION_MODE conversionMode)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ImageConverter_SetConversionMode)

    {

        return inst.m_PEAK_IPL_ImageConverter_SetConversionMode(imageConverterHandle, conversionMode);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageConverter_GetSupportedOutputPixelFormats(PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle, PEAK_IPL_PIXEL_FORMAT inputPixelFormat, PEAK_IPL_PIXEL_FORMAT * outputPixelFormats, size_t * outputPixelFormatsSize)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ImageConverter_GetSupportedOutputPixelFormats)

    {

        return inst.m_PEAK_IPL_ImageConverter_GetSupportedOutputPixelFormats(imageConverterHandle, inputPixelFormat, outputPixelFormats, outputPixelFormatsSize);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::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)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ImageConverter_Convert)

    {

        return inst.m_PEAK_IPL_ImageConverter_Convert(imageConverterHandle, inputImageHandle, outputPixelFormat, outputImageHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::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)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ImageConverter_ConvertToBuffer)

    {

        return inst.m_PEAK_IPL_ImageConverter_ConvertToBuffer(imageConverterHandle, inputImageHandle, outputPixelFormat, outputImageBuffer, outputImageBufferSize, outputImageHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::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)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ImageConverter_ConvertWithFactorAndOffset)

    {

        return inst.m_PEAK_IPL_ImageConverter_ConvertWithFactorAndOffset(imageConverterHandle, inputImageHandle, outputPixelFormat, factor, offset, outputImageHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::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)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ImageConverter_ConvertToBufferWithFactorAndOffset)

    {

        return inst.m_PEAK_IPL_ImageConverter_ConvertToBufferWithFactorAndOffset(imageConverterHandle, inputImageHandle, factor, offset, outputPixelFormat, outputImageBuffer, outputImageBufferSize, outputImageHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::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)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ImageConverter_ConvertFromInterval)

    {

        return inst.m_PEAK_IPL_ImageConverter_ConvertFromInterval(imageConverterHandle, inputImageHandle, outputPixelFormat, start, end, outputImageHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::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)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ImageConverter_ConvertToBufferFromInterval)

    {

        return inst.m_PEAK_IPL_ImageConverter_ConvertToBufferFromInterval(imageConverterHandle, inputImageHandle, start, end, outputPixelFormat, outputImageBuffer, outputImageBufferSize, outputImageHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageConverter_Destruct(PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ImageConverter_Destruct)

    {

        return inst.m_PEAK_IPL_ImageConverter_Destruct(imageConverterHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_AdaptiveHotpixelCorrector_Construct(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE * adaptiveHotpixelCorrectorHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_AdaptiveHotpixelCorrector_Construct)

    {

        return inst.m_PEAK_IPL_AdaptiveHotpixelCorrector_Construct(adaptiveHotpixelCorrectorHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_AdaptiveHotpixelCorrector_Acquire(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_AdaptiveHotpixelCorrector_Acquire)

    {

        return inst.m_PEAK_IPL_AdaptiveHotpixelCorrector_Acquire(adaptiveHotpixelCorrectorHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_AdaptiveHotpixelCorrector_SetSensitivity(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_HOTPIXELCORRECTION_SENSITIVITY sensitivityLevel)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_AdaptiveHotpixelCorrector_SetSensitivity)

    {

        return inst.m_PEAK_IPL_AdaptiveHotpixelCorrector_SetSensitivity(adaptiveHotpixelCorrectorHandle, sensitivityLevel);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_AdaptiveHotpixelCorrector_GetSensitivity(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_HOTPIXELCORRECTION_SENSITIVITY * sensitivityLevel)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_AdaptiveHotpixelCorrector_GetSensitivity)

    {

        return inst.m_PEAK_IPL_AdaptiveHotpixelCorrector_GetSensitivity(adaptiveHotpixelCorrectorHandle, sensitivityLevel);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_AdaptiveHotpixelCorrector_SetGainFactorPercent(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, uint32_t gainFactorPercent)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_AdaptiveHotpixelCorrector_SetGainFactorPercent)

    {

        return inst.m_PEAK_IPL_AdaptiveHotpixelCorrector_SetGainFactorPercent(adaptiveHotpixelCorrectorHandle, gainFactorPercent);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_AdaptiveHotpixelCorrector_GetGainFactorPercent(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, uint32_t * gainFactorPercent)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_AdaptiveHotpixelCorrector_GetGainFactorPercent)

    {

        return inst.m_PEAK_IPL_AdaptiveHotpixelCorrector_GetGainFactorPercent(adaptiveHotpixelCorrectorHandle, gainFactorPercent);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_AdaptiveHotpixelCorrector_Detect(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_IMAGE_HANDLE inputImageHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_AdaptiveHotpixelCorrector_Detect)

    {

        return inst.m_PEAK_IPL_AdaptiveHotpixelCorrector_Detect(adaptiveHotpixelCorrectorHandle, inputImageHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_AdaptiveHotpixelCorrector_GetHotpixels(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, struct PEAK_IPL_POINT_2D * hotpixels, size_t * hotpixelsSize)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_AdaptiveHotpixelCorrector_GetHotpixels)

    {

        return inst.m_PEAK_IPL_AdaptiveHotpixelCorrector_GetHotpixels(adaptiveHotpixelCorrectorHandle, hotpixels, hotpixelsSize);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::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)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_AdaptiveHotpixelCorrector_Correct)

    {

        return inst.m_PEAK_IPL_AdaptiveHotpixelCorrector_Correct(adaptiveHotpixelCorrectorHandle, inputImageHandle, hotpixels, hotpixelsSize, outputImageHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::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)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_AdaptiveHotpixelCorrector_CorrectInPlace)

    {

        return inst.m_PEAK_IPL_AdaptiveHotpixelCorrector_CorrectInPlace(adaptiveHotpixelCorrectorHandle, inputImageHandle, hotpixels, hotpixelsSize);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_AdaptiveHotpixelCorrector_CorrectAdaptive(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_IMAGE_HANDLE inputImageHandle, PEAK_IPL_IMAGE_HANDLE * outputImageHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_AdaptiveHotpixelCorrector_CorrectAdaptive)

    {

        return inst.m_PEAK_IPL_AdaptiveHotpixelCorrector_CorrectAdaptive(adaptiveHotpixelCorrectorHandle, inputImageHandle, outputImageHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_AdaptiveHotpixelCorrector_CorrectAdaptiveInPlace(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_IMAGE_HANDLE inputImageHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_AdaptiveHotpixelCorrector_CorrectAdaptiveInPlace)

    {

        return inst.m_PEAK_IPL_AdaptiveHotpixelCorrector_CorrectAdaptiveInPlace(adaptiveHotpixelCorrectorHandle, inputImageHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_AdaptiveHotpixelCorrector_Destruct(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_AdaptiveHotpixelCorrector_Destruct)

    {

        return inst.m_PEAK_IPL_AdaptiveHotpixelCorrector_Destruct(adaptiveHotpixelCorrectorHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ColorCorrector_Construct(PEAK_IPL_COLOR_CORRECTOR_HANDLE * colorCorrectorHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ColorCorrector_Construct)

    {

        return inst.m_PEAK_IPL_ColorCorrector_Construct(colorCorrectorHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ColorCorrector_Acquire(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ColorCorrector_Acquire)

    {

        return inst.m_PEAK_IPL_ColorCorrector_Acquire(colorCorrectorHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ColorCorrector_SetColorCorrectionFactors(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, float * colorCorrectorFactors)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ColorCorrector_SetColorCorrectionFactors)

    {

        return inst.m_PEAK_IPL_ColorCorrector_SetColorCorrectionFactors(colorCorrectorHandle, colorCorrectorFactors);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ColorCorrector_GetColorCorrectionFactors(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, float * colorCorrectorFactors, size_t * colorCorrectorFactorsSize)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ColorCorrector_GetColorCorrectionFactors)

    {

        return inst.m_PEAK_IPL_ColorCorrector_GetColorCorrectionFactors(colorCorrectorHandle, colorCorrectorFactors, colorCorrectorFactorsSize);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ColorCorrector_GetIsPixelFormatSupported(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 * isPixelFormatSupported)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ColorCorrector_GetIsPixelFormatSupported)

    {

        return inst.m_PEAK_IPL_ColorCorrector_GetIsPixelFormatSupported(colorCorrectorHandle, pixelFormat, isPixelFormatSupported);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ColorCorrector_Process(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE * outputImageHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ColorCorrector_Process)

    {

        return inst.m_PEAK_IPL_ColorCorrector_Process(colorCorrectorHandle, imageHandle, outputImageHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ColorCorrector_ProcessInPlace(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, PEAK_IPL_IMAGE_HANDLE imageHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ColorCorrector_ProcessInPlace)

    {

        return inst.m_PEAK_IPL_ColorCorrector_ProcessInPlace(colorCorrectorHandle, imageHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ColorCorrector_Destruct(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ColorCorrector_Destruct)

    {

        return inst.m_PEAK_IPL_ColorCorrector_Destruct(colorCorrectorHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ColorCorrector_GetSaturation(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, float * saturation)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ColorCorrector_GetSaturation)

    {

        return inst.m_PEAK_IPL_ColorCorrector_GetSaturation(colorCorrectorHandle, saturation);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ColorCorrector_GetSaturationMin(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, float * saturationMin)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ColorCorrector_GetSaturationMin)

    {

        return inst.m_PEAK_IPL_ColorCorrector_GetSaturationMin(colorCorrectorHandle, saturationMin);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ColorCorrector_GetSaturationMax(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, float * saturationMax)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ColorCorrector_GetSaturationMax)

    {

        return inst.m_PEAK_IPL_ColorCorrector_GetSaturationMax(colorCorrectorHandle, saturationMax);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ColorCorrector_SetSaturation(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, float saturation)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ColorCorrector_SetSaturation)

    {

        return inst.m_PEAK_IPL_ColorCorrector_SetSaturation(colorCorrectorHandle, saturation);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Binning_Construct(PEAK_IPL_BINNING_HANDLE * binningHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Binning_Construct)

    {

        return inst.m_PEAK_IPL_Binning_Construct(binningHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Binning_Acquire(PEAK_IPL_BINNING_HANDLE binningHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Binning_Acquire)

    {

        return inst.m_PEAK_IPL_Binning_Acquire(binningHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Binning_SetBinningX(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t * binningXValue)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Binning_SetBinningX)

    {

        return inst.m_PEAK_IPL_Binning_SetBinningX(binningHandle, binningXValue);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Binning_GetBinningX(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t * binningXValue)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Binning_GetBinningX)

    {

        return inst.m_PEAK_IPL_Binning_GetBinningX(binningHandle, binningXValue);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Binning_SetBinningY(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t * binningYValue)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Binning_SetBinningY)

    {

        return inst.m_PEAK_IPL_Binning_SetBinningY(binningHandle, binningYValue);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Binning_GetBinningY(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t * binningYValue)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Binning_GetBinningY)

    {

        return inst.m_PEAK_IPL_Binning_GetBinningY(binningHandle, binningYValue);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Binning_GetBinningMin(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t * binningMin)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Binning_GetBinningMin)

    {

        return inst.m_PEAK_IPL_Binning_GetBinningMin(binningHandle, binningMin);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Binning_GetBinningMax(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t * binningMax)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Binning_GetBinningMax)

    {

        return inst.m_PEAK_IPL_Binning_GetBinningMax(binningHandle, binningMax);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::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)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Binning_ExpectedOutputSize)

    {

        return inst.m_PEAK_IPL_Binning_ExpectedOutputSize(binningHandle, outputWidth, outputHeight, inputWidth, inputHeight, pixelFormat);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Binning_IsPixelformatSupported(PEAK_IPL_BINNING_HANDLE binningHandle, PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 * isPixelFormatSupported)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Binning_IsPixelformatSupported)

    {

        return inst.m_PEAK_IPL_Binning_IsPixelformatSupported(binningHandle, pixelFormat, isPixelFormatSupported);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Binning_SetBinningMode(PEAK_IPL_BINNING_HANDLE binningHandle, PEAK_IPL_BINNINGMODE * mode)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Binning_SetBinningMode)

    {

        return inst.m_PEAK_IPL_Binning_SetBinningMode(binningHandle, mode);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Binning_GetBinningMode(PEAK_IPL_BINNING_HANDLE binningHandle, PEAK_IPL_BINNINGMODE * mode)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Binning_GetBinningMode)

    {

        return inst.m_PEAK_IPL_Binning_GetBinningMode(binningHandle, mode);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Binning_Process(PEAK_IPL_BINNING_HANDLE binningHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE * outputImageHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Binning_Process)

    {

        return inst.m_PEAK_IPL_Binning_Process(binningHandle, imageHandle, outputImageHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Binning_Destruct(PEAK_IPL_BINNING_HANDLE binningHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Binning_Destruct)

    {

        return inst.m_PEAK_IPL_Binning_Destruct(binningHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Decimation_Construct(PEAK_IPL_DECIMATION_HANDLE * decimationHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Decimation_Construct)

    {

        return inst.m_PEAK_IPL_Decimation_Construct(decimationHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Decimation_Acquire(PEAK_IPL_DECIMATION_HANDLE decimationHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Decimation_Acquire)

    {

        return inst.m_PEAK_IPL_Decimation_Acquire(decimationHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Decimation_SetDecimationX(PEAK_IPL_DECIMATION_HANDLE decimationHandle, uint8_t * decimationXValue)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Decimation_SetDecimationX)

    {

        return inst.m_PEAK_IPL_Decimation_SetDecimationX(decimationHandle, decimationXValue);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Decimation_GetDecimationX(PEAK_IPL_DECIMATION_HANDLE decimationHandle, uint8_t * decimationXValue)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Decimation_GetDecimationX)

    {

        return inst.m_PEAK_IPL_Decimation_GetDecimationX(decimationHandle, decimationXValue);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Decimation_SetDecimationY(PEAK_IPL_DECIMATION_HANDLE decimationHandle, uint8_t * decimationYValue)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Decimation_SetDecimationY)

    {

        return inst.m_PEAK_IPL_Decimation_SetDecimationY(decimationHandle, decimationYValue);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Decimation_GetDecimationY(PEAK_IPL_DECIMATION_HANDLE decimationHandle, uint8_t * decimationYValue)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Decimation_GetDecimationY)

    {

        return inst.m_PEAK_IPL_Decimation_GetDecimationY(decimationHandle, decimationYValue);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Decimation_GetDecimationMin(PEAK_IPL_DECIMATION_HANDLE decimationHandle, uint8_t * decimationMin)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Decimation_GetDecimationMin)

    {

        return inst.m_PEAK_IPL_Decimation_GetDecimationMin(decimationHandle, decimationMin);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Decimation_GetDecimationMax(PEAK_IPL_DECIMATION_HANDLE decimationHandle, uint8_t * decimationMax)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Decimation_GetDecimationMax)

    {

        return inst.m_PEAK_IPL_Decimation_GetDecimationMax(decimationHandle, decimationMax);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::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)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Decimation_ExpectedOutputSize)

    {

        return inst.m_PEAK_IPL_Decimation_ExpectedOutputSize(decimationHandle, outputWidth, outputHeight, inputWidth, inputHeight, pixelFormat);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Decimation_IsPixelformatSupported(PEAK_IPL_DECIMATION_HANDLE decimationHandle, PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 * isPixelFormatSupported)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Decimation_IsPixelformatSupported)

    {

        return inst.m_PEAK_IPL_Decimation_IsPixelformatSupported(decimationHandle, pixelFormat, isPixelFormatSupported);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Decimation_Process(PEAK_IPL_DECIMATION_HANDLE decimationHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE * outputImageHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Decimation_Process)

    {

        return inst.m_PEAK_IPL_Decimation_Process(decimationHandle, imageHandle, outputImageHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Decimation_Destruct(PEAK_IPL_DECIMATION_HANDLE decimationHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Decimation_Destruct)

    {

        return inst.m_PEAK_IPL_Decimation_Destruct(decimationHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Gain_Construct(PEAK_IPL_GAIN_HANDLE * gainHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Gain_Construct)

    {

        return inst.m_PEAK_IPL_Gain_Construct(gainHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Gain_Acquire(PEAK_IPL_GAIN_HANDLE gainHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Gain_Acquire)

    {

        return inst.m_PEAK_IPL_Gain_Acquire(gainHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Gain_SetMasterGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float * masterGainValue)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Gain_SetMasterGainValue)

    {

        return inst.m_PEAK_IPL_Gain_SetMasterGainValue(gainHandle, masterGainValue);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Gain_GetMasterGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float * masterGainValue)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Gain_GetMasterGainValue)

    {

        return inst.m_PEAK_IPL_Gain_GetMasterGainValue(gainHandle, masterGainValue);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Gain_GetMasterGainMax(PEAK_IPL_GAIN_HANDLE gainHandle, float * masterGainMax)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Gain_GetMasterGainMax)

    {

        return inst.m_PEAK_IPL_Gain_GetMasterGainMax(gainHandle, masterGainMax);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Gain_GetMasterGainMin(PEAK_IPL_GAIN_HANDLE gainHandle, float * masterGainMin)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Gain_GetMasterGainMin)

    {

        return inst.m_PEAK_IPL_Gain_GetMasterGainMin(gainHandle, masterGainMin);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Gain_SetRedGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float * redGainValue)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Gain_SetRedGainValue)

    {

        return inst.m_PEAK_IPL_Gain_SetRedGainValue(gainHandle, redGainValue);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Gain_GetRedGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float * redGainValue)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Gain_GetRedGainValue)

    {

        return inst.m_PEAK_IPL_Gain_GetRedGainValue(gainHandle, redGainValue);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Gain_GetRedGainMax(PEAK_IPL_GAIN_HANDLE gainHandle, float * redGainMax)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Gain_GetRedGainMax)

    {

        return inst.m_PEAK_IPL_Gain_GetRedGainMax(gainHandle, redGainMax);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Gain_GetRedGainMin(PEAK_IPL_GAIN_HANDLE gainHandle, float * redGainMin)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Gain_GetRedGainMin)

    {

        return inst.m_PEAK_IPL_Gain_GetRedGainMin(gainHandle, redGainMin);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Gain_SetGreenGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float * greenGainValue)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Gain_SetGreenGainValue)

    {

        return inst.m_PEAK_IPL_Gain_SetGreenGainValue(gainHandle, greenGainValue);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Gain_GetGreenGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float * greenGainValue)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Gain_GetGreenGainValue)

    {

        return inst.m_PEAK_IPL_Gain_GetGreenGainValue(gainHandle, greenGainValue);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Gain_GetGreenGainMax(PEAK_IPL_GAIN_HANDLE gainHandle, float * greenGainMax)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Gain_GetGreenGainMax)

    {

        return inst.m_PEAK_IPL_Gain_GetGreenGainMax(gainHandle, greenGainMax);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Gain_GetGreenGainMin(PEAK_IPL_GAIN_HANDLE gainHandle, float * greenGainMin)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Gain_GetGreenGainMin)

    {

        return inst.m_PEAK_IPL_Gain_GetGreenGainMin(gainHandle, greenGainMin);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Gain_SetBlueGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float * blueGainValue)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Gain_SetBlueGainValue)

    {

        return inst.m_PEAK_IPL_Gain_SetBlueGainValue(gainHandle, blueGainValue);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Gain_GetBlueGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float * blueGainValue)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Gain_GetBlueGainValue)

    {

        return inst.m_PEAK_IPL_Gain_GetBlueGainValue(gainHandle, blueGainValue);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Gain_GetBlueGainMax(PEAK_IPL_GAIN_HANDLE gainHandle, float * blueGainMax)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Gain_GetBlueGainMax)

    {

        return inst.m_PEAK_IPL_Gain_GetBlueGainMax(gainHandle, blueGainMax);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Gain_GetBlueGainMin(PEAK_IPL_GAIN_HANDLE gainHandle, float * blueGainMin)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Gain_GetBlueGainMin)

    {

        return inst.m_PEAK_IPL_Gain_GetBlueGainMin(gainHandle, blueGainMin);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Gain_GetIsPixelFormatSupported(PEAK_IPL_GAIN_HANDLE gainHandle, PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 * isPixelFormatSupported)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Gain_GetIsPixelFormatSupported)

    {

        return inst.m_PEAK_IPL_Gain_GetIsPixelFormatSupported(gainHandle, pixelFormat, isPixelFormatSupported);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Gain_Process(PEAK_IPL_GAIN_HANDLE gainHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE * outputImageHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Gain_Process)

    {

        return inst.m_PEAK_IPL_Gain_Process(gainHandle, imageHandle, outputImageHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Gain_ProcessInPlace(PEAK_IPL_GAIN_HANDLE gainHandle, PEAK_IPL_IMAGE_HANDLE imageHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Gain_ProcessInPlace)

    {

        return inst.m_PEAK_IPL_Gain_ProcessInPlace(gainHandle, imageHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Gain_Destruct(PEAK_IPL_GAIN_HANDLE gainHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Gain_Destruct)

    {

        return inst.m_PEAK_IPL_Gain_Destruct(gainHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_GammaCorrector_Construct(PEAK_IPL_GAMMA_CORRECTOR_HANDLE * gammaCorrectorHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_GammaCorrector_Construct)

    {

        return inst.m_PEAK_IPL_GammaCorrector_Construct(gammaCorrectorHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_GammaCorrector_Acquire(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_GammaCorrector_Acquire)

    {

        return inst.m_PEAK_IPL_GammaCorrector_Acquire(gammaCorrectorHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_GammaCorrector_SetGammaCorrectionValue(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float * gammaValue)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_GammaCorrector_SetGammaCorrectionValue)

    {

        return inst.m_PEAK_IPL_GammaCorrector_SetGammaCorrectionValue(gammaCorrectorHandle, gammaValue);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_GammaCorrector_GetGammaCorrectionValue(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float * gammaValue)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_GammaCorrector_GetGammaCorrectionValue)

    {

        return inst.m_PEAK_IPL_GammaCorrector_GetGammaCorrectionValue(gammaCorrectorHandle, gammaValue);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_GammaCorrector_GetGammaCorrectionMax(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float * gammaMax)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_GammaCorrector_GetGammaCorrectionMax)

    {

        return inst.m_PEAK_IPL_GammaCorrector_GetGammaCorrectionMax(gammaCorrectorHandle, gammaMax);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_GammaCorrector_GetGammaCorrectionMin(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float * gammaMin)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_GammaCorrector_GetGammaCorrectionMin)

    {

        return inst.m_PEAK_IPL_GammaCorrector_GetGammaCorrectionMin(gammaCorrectorHandle, gammaMin);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_GammaCorrector_SetDigitalBlack(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float * digitalBlackValue)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_GammaCorrector_SetDigitalBlack)

    {

        return inst.m_PEAK_IPL_GammaCorrector_SetDigitalBlack(gammaCorrectorHandle, digitalBlackValue);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_GammaCorrector_GetDigitalBlack(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float * digitalBlackValue)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_GammaCorrector_GetDigitalBlack)

    {

        return inst.m_PEAK_IPL_GammaCorrector_GetDigitalBlack(gammaCorrectorHandle, digitalBlackValue);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_GammaCorrector_GetDigitalBlackMax(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float * digitalBlackMax)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_GammaCorrector_GetDigitalBlackMax)

    {

        return inst.m_PEAK_IPL_GammaCorrector_GetDigitalBlackMax(gammaCorrectorHandle, digitalBlackMax);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_GammaCorrector_GetDigitalBlackMin(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float * digitalBlackMin)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_GammaCorrector_GetDigitalBlackMin)

    {

        return inst.m_PEAK_IPL_GammaCorrector_GetDigitalBlackMin(gammaCorrectorHandle, digitalBlackMin);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_GammaCorrector_GetIsPixelFormatSupported(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 * isPixelFormatSupported)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_GammaCorrector_GetIsPixelFormatSupported)

    {

        return inst.m_PEAK_IPL_GammaCorrector_GetIsPixelFormatSupported(gammaCorrectorHandle, pixelFormat, isPixelFormatSupported);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_GammaCorrector_Process(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE * outputImageHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_GammaCorrector_Process)

    {

        return inst.m_PEAK_IPL_GammaCorrector_Process(gammaCorrectorHandle, imageHandle, outputImageHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_GammaCorrector_ProcessInPlace(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, PEAK_IPL_IMAGE_HANDLE imageHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_GammaCorrector_ProcessInPlace)

    {

        return inst.m_PEAK_IPL_GammaCorrector_ProcessInPlace(gammaCorrectorHandle, imageHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_GammaCorrector_Destruct(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_GammaCorrector_Destruct)

    {

        return inst.m_PEAK_IPL_GammaCorrector_Destruct(gammaCorrectorHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Image_Construct(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t width, size_t height, PEAK_IPL_IMAGE_HANDLE * imageHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Image_Construct)

    {

        return inst.m_PEAK_IPL_Image_Construct(pixelFormat, width, height, imageHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Image_Acquire(PEAK_IPL_IMAGE_HANDLE imageHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Image_Acquire)

    {

        return inst.m_PEAK_IPL_Image_Acquire(imageHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::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)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Image_ConstructFromBuffer)

    {

        return inst.m_PEAK_IPL_Image_ConstructFromBuffer(pixelFormat, buffer, bufferSize, width, height, imageHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Image_GetWidth(PEAK_IPL_IMAGE_HANDLE imageHandle, size_t * width)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Image_GetWidth)

    {

        return inst.m_PEAK_IPL_Image_GetWidth(imageHandle, width);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Image_GetHeight(PEAK_IPL_IMAGE_HANDLE imageHandle, size_t * height)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Image_GetHeight)

    {

        return inst.m_PEAK_IPL_Image_GetHeight(imageHandle, height);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Image_GetPixelPointer(PEAK_IPL_IMAGE_HANDLE imageHandle, size_t xPos, size_t yPos, uint8_t * * pixelPointer)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Image_GetPixelPointer)

    {

        return inst.m_PEAK_IPL_Image_GetPixelPointer(imageHandle, xPos, yPos, pixelPointer);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Image_GetByteCount(PEAK_IPL_IMAGE_HANDLE imageHandle, size_t * byteCount)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Image_GetByteCount)

    {

        return inst.m_PEAK_IPL_Image_GetByteCount(imageHandle, byteCount);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Image_GetPixelFormat(PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_PIXEL_FORMAT * pixelFormat)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Image_GetPixelFormat)

    {

        return inst.m_PEAK_IPL_Image_GetPixelFormat(imageHandle, pixelFormat);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Image_GetData(PEAK_IPL_IMAGE_HANDLE imageHandle, uint8_t * * data)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Image_GetData)

    {

        return inst.m_PEAK_IPL_Image_GetData(imageHandle, data);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Image_Clone(PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE * outputImageHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Image_Clone)

    {

        return inst.m_PEAK_IPL_Image_Clone(imageHandle, outputImageHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Image_ConvertTo(PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_PIXEL_FORMAT outputPixelFormat, PEAK_IPL_CONVERSION_MODE conversionMode, PEAK_IPL_IMAGE_HANDLE * outputImageHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Image_ConvertTo)

    {

        return inst.m_PEAK_IPL_Image_ConvertTo(imageHandle, outputPixelFormat, conversionMode, outputImageHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::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)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Image_ConvertToBuffer)

    {

        return inst.m_PEAK_IPL_Image_ConvertToBuffer(imageHandle, outputPixelFormat, outputImageBuffer, outputImageBufferSize, conversionMode, outputImageHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::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)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Image_ConvertToWithFactor)

    {

        return inst.m_PEAK_IPL_Image_ConvertToWithFactor(imageHandle, outputPixelFormat, factor, conversionMode, outputImageHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::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)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Image_ConvertToWithFactorAndOffset)

    {

        return inst.m_PEAK_IPL_Image_ConvertToWithFactorAndOffset(imageHandle, outputPixelFormat, factor, offset, conversionMode, outputImageHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::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)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Image_ConvertToBufferWithFactorAndOffset)

    {

        return inst.m_PEAK_IPL_Image_ConvertToBufferWithFactorAndOffset(imageHandle, outputPixelFormat, factor, offset, outputImageBuffer, outputImageBufferSize, conversionMode, outputImageHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::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)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Image_ConvertToFromInterval)

    {

        return inst.m_PEAK_IPL_Image_ConvertToFromInterval(imageHandle, outputPixelFormat, start, end, conversionMode, outputImageHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::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)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Image_ConvertToBufferFromInterval)

    {

        return inst.m_PEAK_IPL_Image_ConvertToBufferFromInterval(imageHandle, outputPixelFormat, start, end, outputImageBuffer, outputImageBufferSize, conversionMode, outputImageHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::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)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Image_Scale)

    {

        return inst.m_PEAK_IPL_Image_Scale(imageHandle, size, algorithm, outputImageHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::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)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Image_ScaleInto)

    {

        return inst.m_PEAK_IPL_Image_ScaleInto(imageHandle, size, buffer, bufferSize, algorithm);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::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)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Image_Crop)

    {

        return inst.m_PEAK_IPL_Image_Crop(imageHandle, pos, size, outputImageHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Image_Destruct(PEAK_IPL_IMAGE_HANDLE imageHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Image_Destruct)

    {

        return inst.m_PEAK_IPL_Image_Destruct(imageHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageTransformer_Construct(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE * imageTransformerHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ImageTransformer_Construct)

    {

        return inst.m_PEAK_IPL_ImageTransformer_Construct(imageTransformerHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageTransformer_Acquire(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ImageTransformer_Acquire)

    {

        return inst.m_PEAK_IPL_ImageTransformer_Acquire(imageTransformerHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Image_SetTimestamp(PEAK_IPL_IMAGE_HANDLE imageHandle, uint64_t timestamp_ns)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Image_SetTimestamp)

    {

        return inst.m_PEAK_IPL_Image_SetTimestamp(imageHandle, timestamp_ns);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Image_GetTimestamp(PEAK_IPL_IMAGE_HANDLE imageHandle, uint64_t * timestamp_ns)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Image_GetTimestamp)

    {

        return inst.m_PEAK_IPL_Image_GetTimestamp(imageHandle, timestamp_ns);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageTransformer_MirrorUpDown(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE * outputImageHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ImageTransformer_MirrorUpDown)

    {

        return inst.m_PEAK_IPL_ImageTransformer_MirrorUpDown(imageTransformerHandle, imageHandle, outputImageHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageTransformer_MirrorLeftRight(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE * outputImageHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ImageTransformer_MirrorLeftRight)

    {

        return inst.m_PEAK_IPL_ImageTransformer_MirrorLeftRight(imageTransformerHandle, imageHandle, outputImageHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageTransformer_MirrorUpDownLeftRight(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE * outputImageHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ImageTransformer_MirrorUpDownLeftRight)

    {

        return inst.m_PEAK_IPL_ImageTransformer_MirrorUpDownLeftRight(imageTransformerHandle, imageHandle, outputImageHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageTransformer_MirrorUpDownInPlace(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle, PEAK_IPL_IMAGE_HANDLE imageHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ImageTransformer_MirrorUpDownInPlace)

    {

        return inst.m_PEAK_IPL_ImageTransformer_MirrorUpDownInPlace(imageTransformerHandle, imageHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageTransformer_MirrorLeftRightInPlace(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle, PEAK_IPL_IMAGE_HANDLE imageHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ImageTransformer_MirrorLeftRightInPlace)

    {

        return inst.m_PEAK_IPL_ImageTransformer_MirrorLeftRightInPlace(imageTransformerHandle, imageHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageTransformer_MirrorUpDownLeftRightInPlace(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle, PEAK_IPL_IMAGE_HANDLE imageHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ImageTransformer_MirrorUpDownLeftRightInPlace)

    {

        return inst.m_PEAK_IPL_ImageTransformer_MirrorUpDownLeftRightInPlace(imageTransformerHandle, imageHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::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)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ImageTransformer_Rotate)

    {

        return inst.m_PEAK_IPL_ImageTransformer_Rotate(imageTransformerHandle, imageHandle, outputImageHandle, rotationAngle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageTransformer_RotateInPlace(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, enum PEAK_IPL_IMAGE_TRANSFORMER_ROTATION_ANGLE_t rotationAngle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ImageTransformer_RotateInPlace)

    {

        return inst.m_PEAK_IPL_ImageTransformer_RotateInPlace(imageTransformerHandle, imageHandle, rotationAngle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageTransformer_Destruct(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ImageTransformer_Destruct)

    {

        return inst.m_PEAK_IPL_ImageTransformer_Destruct(imageTransformerHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Histogram_Construct(PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_HISTOGRAM_HANDLE * histogramHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Histogram_Construct)

    {

        return inst.m_PEAK_IPL_Histogram_Construct(imageHandle, histogramHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Histogram_Acquire(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Histogram_Acquire)

    {

        return inst.m_PEAK_IPL_Histogram_Acquire(histogramHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Histogram_GetPixelFormat(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle, PEAK_IPL_PIXEL_FORMAT * pixelFormat)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Histogram_GetPixelFormat)

    {

        return inst.m_PEAK_IPL_Histogram_GetPixelFormat(histogramHandle, pixelFormat);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Histogram_GetNumChannels(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle, size_t * numChannels)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Histogram_GetNumChannels)

    {

        return inst.m_PEAK_IPL_Histogram_GetNumChannels(histogramHandle, numChannels);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Histogram_GetPixelSumForChannel(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle, size_t channelIndex, uint64_t * pixelSum)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Histogram_GetPixelSumForChannel)

    {

        return inst.m_PEAK_IPL_Histogram_GetPixelSumForChannel(histogramHandle, channelIndex, pixelSum);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Histogram_GetPixelCountForChannel(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle, size_t channelIndex, uint64_t * pixelCount)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Histogram_GetPixelCountForChannel)

    {

        return inst.m_PEAK_IPL_Histogram_GetPixelCountForChannel(histogramHandle, channelIndex, pixelCount);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Histogram_GetBinsForChannel(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle, size_t channelIndex, uint64_t * bins, size_t * binsSize)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Histogram_GetBinsForChannel)

    {

        return inst.m_PEAK_IPL_Histogram_GetBinsForChannel(histogramHandle, channelIndex, bins, binsSize);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Histogram_Destruct(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Histogram_Destruct)

    {

        return inst.m_PEAK_IPL_Histogram_Destruct(histogramHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_PixelLine_Construct(PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_ORIENTATION orientation, size_t offset, PEAK_IPL_PIXEL_LINE_HANDLE * pixelLineHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_PixelLine_Construct)

    {

        return inst.m_PEAK_IPL_PixelLine_Construct(imageHandle, orientation, offset, pixelLineHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_PixelLine_Acquire(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_PixelLine_Acquire)

    {

        return inst.m_PEAK_IPL_PixelLine_Acquire(pixelLineHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_PixelLine_GetPixelFormat(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle, PEAK_IPL_PIXEL_FORMAT * pixelFormat)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_PixelLine_GetPixelFormat)

    {

        return inst.m_PEAK_IPL_PixelLine_GetPixelFormat(pixelLineHandle, pixelFormat);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_PixelLine_GetOrientation(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle, PEAK_IPL_ORIENTATION * orientation)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_PixelLine_GetOrientation)

    {

        return inst.m_PEAK_IPL_PixelLine_GetOrientation(pixelLineHandle, orientation);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_PixelLine_GetOffset(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle, size_t * offset)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_PixelLine_GetOffset)

    {

        return inst.m_PEAK_IPL_PixelLine_GetOffset(pixelLineHandle, offset);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_PixelLine_GetNumChannels(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle, size_t * numChannels)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_PixelLine_GetNumChannels)

    {

        return inst.m_PEAK_IPL_PixelLine_GetNumChannels(pixelLineHandle, numChannels);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_PixelLine_GetValuesForChannel(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle, size_t channelIndex, uint32_t * values, size_t * valuesSize)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_PixelLine_GetValuesForChannel)

    {

        return inst.m_PEAK_IPL_PixelLine_GetValuesForChannel(pixelLineHandle, channelIndex, values, valuesSize);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_PixelLine_Destruct(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_PixelLine_Destruct)

    {

        return inst.m_PEAK_IPL_PixelLine_Destruct(pixelLineHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_PixelFormat_GetNumChannels(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t * numChannels)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_PixelFormat_GetNumChannels)

    {

        return inst.m_PEAK_IPL_PixelFormat_GetNumChannels(pixelFormat, numChannels);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_PixelFormat_GetNumSignificantBitsPerChannel(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t * numSignificantBits)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_PixelFormat_GetNumSignificantBitsPerChannel)

    {

        return inst.m_PEAK_IPL_PixelFormat_GetNumSignificantBitsPerChannel(pixelFormat, numSignificantBits);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_PixelFormat_GetNumStorageBitsPerChannel(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t * numStorageBits)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_PixelFormat_GetNumStorageBitsPerChannel)

    {

        return inst.m_PEAK_IPL_PixelFormat_GetNumStorageBitsPerChannel(pixelFormat, numStorageBits);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_PixelFormat_GetMaximumValuePerChannel(PEAK_IPL_PIXEL_FORMAT pixelFormat, uint32_t * channelMaximumValue)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_PixelFormat_GetMaximumValuePerChannel)

    {

        return inst.m_PEAK_IPL_PixelFormat_GetMaximumValuePerChannel(pixelFormat, channelMaximumValue);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_PixelFormat_GetNumSignificantBitsPerPixel(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t * numSignificantBits)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_PixelFormat_GetNumSignificantBitsPerPixel)

    {

        return inst.m_PEAK_IPL_PixelFormat_GetNumSignificantBitsPerPixel(pixelFormat, numSignificantBits);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_PixelFormat_GetNumStorageBitsPerPixel(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t * numStorageBits)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_PixelFormat_GetNumStorageBitsPerPixel)

    {

        return inst.m_PEAK_IPL_PixelFormat_GetNumStorageBitsPerPixel(pixelFormat, numStorageBits);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_PixelFormat_GetEndianness(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_ENDIANNESS * endianness)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_PixelFormat_GetEndianness)

    {

        return inst.m_PEAK_IPL_PixelFormat_GetEndianness(pixelFormat, endianness);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_PixelFormat_CalculateStorageSizeOfPixels(PEAK_IPL_PIXEL_FORMAT pixelFormat, uint64_t numPixels, uint64_t * size)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_PixelFormat_CalculateStorageSizeOfPixels)

    {

        return inst.m_PEAK_IPL_PixelFormat_CalculateStorageSizeOfPixels(pixelFormat, numPixels, size);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_PixelFormat_IsPacked(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 * isPacked)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_PixelFormat_IsPacked)

    {

        return inst.m_PEAK_IPL_PixelFormat_IsPacked(pixelFormat, isPacked);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_PixelFormat_IsBayered(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 * isBayered)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_PixelFormat_IsBayered)

    {

        return inst.m_PEAK_IPL_PixelFormat_IsBayered(pixelFormat, isBayered);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_PixelFormat_IsYUV(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 * isYUV)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_PixelFormat_IsYUV)

    {

        return inst.m_PEAK_IPL_PixelFormat_IsYUV(pixelFormat, isYUV);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_PixelFormat_IsCoord3D(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 * isCoord3D)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_PixelFormat_IsCoord3D)

    {

        return inst.m_PEAK_IPL_PixelFormat_IsCoord3D(pixelFormat, isCoord3D);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_PixelFormat_IsFloat(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 * isFloat)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_PixelFormat_IsFloat)

    {

        return inst.m_PEAK_IPL_PixelFormat_IsFloat(pixelFormat, isFloat);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_PixelFormat_GetBayerPattern(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BAYER_PATTERN * pattern)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_PixelFormat_GetBayerPattern)

    {

        return inst.m_PEAK_IPL_PixelFormat_GetBayerPattern(pixelFormat, pattern);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageWriter_WriteAsRAW(PEAK_IPL_IMAGE_HANDLE inputImageHandle, const char * filePath, size_t filePathSize)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ImageWriter_WriteAsRAW)

    {

        return inst.m_PEAK_IPL_ImageWriter_WriteAsRAW(inputImageHandle, filePath, filePathSize);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageWriter_WriteAsBMP(PEAK_IPL_IMAGE_HANDLE inputImageHandle, const char * filePath, size_t filePathSize)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ImageWriter_WriteAsBMP)

    {

        return inst.m_PEAK_IPL_ImageWriter_WriteAsBMP(inputImageHandle, filePath, filePathSize);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageWriter_WriteAsPNG(PEAK_IPL_IMAGE_HANDLE inputImageHandle, uint32_t quality, const char * filePath, size_t filePathSize)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ImageWriter_WriteAsPNG)

    {

        return inst.m_PEAK_IPL_ImageWriter_WriteAsPNG(inputImageHandle, quality, filePath, filePathSize);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageWriter_WriteAsJPG(PEAK_IPL_IMAGE_HANDLE inputImageHandle, uint32_t quality, const char * filePath, size_t filePathSize)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ImageWriter_WriteAsJPG)

    {

        return inst.m_PEAK_IPL_ImageWriter_WriteAsJPG(inputImageHandle, quality, filePath, filePathSize);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageWriter_Write(PEAK_IPL_IMAGE_HANDLE inputImageHandle, const char * filePath, size_t filePathSize)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ImageWriter_Write)

    {

        return inst.m_PEAK_IPL_ImageWriter_Write(inputImageHandle, filePath, filePathSize);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageReader_Read(const char * filePath, size_t filePathSize, PEAK_IPL_IMAGE_HANDLE * outputImageHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ImageReader_Read)

    {

        return inst.m_PEAK_IPL_ImageReader_Read(filePath, filePathSize, outputImageHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageReaderRead_ReadAsPixelFormat(const char * filePath, size_t filePathSize, PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_IMAGE_HANDLE * outputImageHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ImageReaderRead_ReadAsPixelFormat)

    {

        return inst.m_PEAK_IPL_ImageReaderRead_ReadAsPixelFormat(filePath, filePathSize, pixelFormat, outputImageHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_VideoWriter_Video_Open(PEAK_IPL_VIDEO_HANDLE * videoHandle, const char * filePath, PEAK_IPL_VIDEO_CONTAINER container, PEAK_IPL_VIDEO_ENCODER encoder)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_VideoWriter_Video_Open)

    {

        return inst.m_PEAK_IPL_VideoWriter_Video_Open(videoHandle, filePath, container, encoder);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_VideoWriter_Video_IsOpen(PEAK_IPL_VIDEO_HANDLE videoHandle, PEAK_IPL_BOOL8 * isOpen)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_VideoWriter_Video_IsOpen)

    {

        return inst.m_PEAK_IPL_VideoWriter_Video_IsOpen(videoHandle, isOpen);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_VideoWriter_Video_Close(PEAK_IPL_VIDEO_HANDLE videoHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_VideoWriter_Video_Close)

    {

        return inst.m_PEAK_IPL_VideoWriter_Video_Close(videoHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_VideoWriter_Video_Append(PEAK_IPL_VIDEO_HANDLE videoHandle, PEAK_IPL_IMAGE_HANDLE imageHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_VideoWriter_Video_Append)

    {

        return inst.m_PEAK_IPL_VideoWriter_Video_Append(videoHandle, imageHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_VideoWriter_Encoder_SetOption(PEAK_IPL_VIDEO_HANDLE videoHandle, PEAK_IPL_VIDEO_ENCODER_OPTION option, const void * value, size_t count)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_VideoWriter_Encoder_SetOption)

    {

        return inst.m_PEAK_IPL_VideoWriter_Encoder_SetOption(videoHandle, option, value, count);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_VideoWriter_Encoder_GetOption(PEAK_IPL_VIDEO_HANDLE videoHandle, PEAK_IPL_VIDEO_ENCODER_OPTION option, void * value, size_t count, size_t * outCount)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_VideoWriter_Encoder_GetOption)

    {

        return inst.m_PEAK_IPL_VideoWriter_Encoder_GetOption(videoHandle, option, value, count, outCount);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_VideoWriter_Encoder_OptionRange(PEAK_IPL_VIDEO_HANDLE videoHandle, PEAK_IPL_VIDEO_ENCODER_OPTION option, void * min, void * max, void * inc)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_VideoWriter_Encoder_OptionRange)

    {

        return inst.m_PEAK_IPL_VideoWriter_Encoder_OptionRange(videoHandle, option, min, max, inc);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_VideoWriter_GetSupportedEncodersForAContainer(PEAK_IPL_VIDEO_CONTAINER container, PEAK_IPL_VIDEO_ENCODER * encoders, size_t * size)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_VideoWriter_GetSupportedEncodersForAContainer)

    {

        return inst.m_PEAK_IPL_VideoWriter_GetSupportedEncodersForAContainer(container, encoders, size);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_VideoWriter_Container_SetOption(PEAK_IPL_VIDEO_HANDLE videoHandle, PEAK_IPL_VIDEO_CONTAINER_OPTION option, const void * value, size_t count)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_VideoWriter_Container_SetOption)

    {

        return inst.m_PEAK_IPL_VideoWriter_Container_SetOption(videoHandle, option, value, count);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_VideoWriter_Container_GetOption(PEAK_IPL_VIDEO_HANDLE videoHandle, PEAK_IPL_VIDEO_ENCODER_OPTION option, void * value, size_t count, size_t * outCount)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_VideoWriter_Container_GetOption)

    {

        return inst.m_PEAK_IPL_VideoWriter_Container_GetOption(videoHandle, option, value, count, outCount);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_VideoWriter_Container_OptionRange(PEAK_IPL_VIDEO_HANDLE videoHandle, PEAK_IPL_VIDEO_ENCODER_OPTION option, void * min, void * max, void * inc)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_VideoWriter_Container_OptionRange)

    {

        return inst.m_PEAK_IPL_VideoWriter_Container_OptionRange(videoHandle, option, min, max, inc);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_VideoWriter_GetSupportedContainersForAnEncoder(PEAK_IPL_VIDEO_ENCODER encoder, PEAK_IPL_VIDEO_CONTAINER * containers, size_t * size)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_VideoWriter_GetSupportedContainersForAnEncoder)

    {

        return inst.m_PEAK_IPL_VideoWriter_GetSupportedContainersForAnEncoder(encoder, containers, size);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_VideoWriter_Encoder_GetSupportedPixelFormats(PEAK_IPL_VIDEO_ENCODER encoder, PEAK_IPL_PIXEL_FORMAT * pixelFormatList, size_t * pixelFormatListSize)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_VideoWriter_Encoder_GetSupportedPixelFormats)

    {

        return inst.m_PEAK_IPL_VideoWriter_Encoder_GetSupportedPixelFormats(encoder, pixelFormatList, pixelFormatListSize);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_VideoWriter_Video_GetEncodedFrames(PEAK_IPL_VIDEO_HANDLE videoHandle, uint64_t * numFrames)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_VideoWriter_Video_GetEncodedFrames)

    {

        return inst.m_PEAK_IPL_VideoWriter_Video_GetEncodedFrames(videoHandle, numFrames);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_VideoWriter_Video_GetDroppedFrames(PEAK_IPL_VIDEO_HANDLE videoHandle, uint64_t * numFrames)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_VideoWriter_Video_GetDroppedFrames)

    {

        return inst.m_PEAK_IPL_VideoWriter_Video_GetDroppedFrames(videoHandle, numFrames);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_VideoWriter_Video_GetFileSize(PEAK_IPL_VIDEO_HANDLE videoHandle, uint64_t * fileSize)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_VideoWriter_Video_GetFileSize)

    {

        return inst.m_PEAK_IPL_VideoWriter_Video_GetFileSize(videoHandle, fileSize);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_VideoWriter_Video_ResetFrameCounters(PEAK_IPL_VIDEO_HANDLE videoHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_VideoWriter_Video_ResetFrameCounters)

    {

        return inst.m_PEAK_IPL_VideoWriter_Video_ResetFrameCounters(videoHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_VideoWriter_Queue_SetSize(PEAK_IPL_VIDEO_HANDLE videoHandle, int32_t size)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_VideoWriter_Queue_SetSize)

    {

        return inst.m_PEAK_IPL_VideoWriter_Queue_SetSize(videoHandle, size);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_VideoWriter_Queue_GetSize(PEAK_IPL_VIDEO_HANDLE videoHandle, int32_t * size)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_VideoWriter_Queue_GetSize)

    {

        return inst.m_PEAK_IPL_VideoWriter_Queue_GetSize(videoHandle, size);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_VideoWriter_Queue_GetRange(PEAK_IPL_VIDEO_HANDLE videoHandle, int32_t * minSize, int32_t * maxSize)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_VideoWriter_Queue_GetRange)

    {

        return inst.m_PEAK_IPL_VideoWriter_Queue_GetRange(videoHandle, minSize, maxSize);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_VideoWriter_Queue_GetQueued(PEAK_IPL_VIDEO_HANDLE videoHandle, int32_t * queued)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_VideoWriter_Queue_GetQueued)

    {

        return inst.m_PEAK_IPL_VideoWriter_Queue_GetQueued(videoHandle, queued);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_VideoWriter_Video_WaitUntilFrameDone(PEAK_IPL_VIDEO_HANDLE videoHandle, int32_t timeout_ms)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_VideoWriter_Video_WaitUntilFrameDone)

    {

        return inst.m_PEAK_IPL_VideoWriter_Video_WaitUntilFrameDone(videoHandle, timeout_ms);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_VideoWriter_Video_WaitUntilQueueEmpty(PEAK_IPL_VIDEO_HANDLE videoHandle, int32_t timeout_ms)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_VideoWriter_Video_WaitUntilQueueEmpty)

    {

        return inst.m_PEAK_IPL_VideoWriter_Video_WaitUntilQueueEmpty(videoHandle, timeout_ms);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageSharpness_Construct(PEAK_IPL_SHARPNESS_HANDLE * handle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ImageSharpness_Construct)

    {

        return inst.m_PEAK_IPL_ImageSharpness_Construct(handle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageSharpness_Acquire(PEAK_IPL_SHARPNESS_HANDLE handle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ImageSharpness_Acquire)

    {

        return inst.m_PEAK_IPL_ImageSharpness_Acquire(handle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageSharpness_Destruct(PEAK_IPL_SHARPNESS_HANDLE handle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ImageSharpness_Destruct)

    {

        return inst.m_PEAK_IPL_ImageSharpness_Destruct(handle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageSharpness_Measure(PEAK_IPL_SHARPNESS_HANDLE handle, PEAK_IPL_IMAGE_HANDLE imageHandle, double * calculated_value)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ImageSharpness_Measure)

    {

        return inst.m_PEAK_IPL_ImageSharpness_Measure(handle, imageHandle, calculated_value);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageSharpness_GetIsPixelFormatSupported(PEAK_IPL_SHARPNESS_HANDLE handle, PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 * isPixelFormatSupported)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ImageSharpness_GetIsPixelFormatSupported)

    {

        return inst.m_PEAK_IPL_ImageSharpness_GetIsPixelFormatSupported(handle, pixelFormat, isPixelFormatSupported);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageSharpness_GetSupportedPixelFormatList(PEAK_IPL_SHARPNESS_HANDLE handle, PEAK_IPL_PIXEL_FORMAT * pixelFormatList, size_t * pixelFormatListSize)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ImageSharpness_GetSupportedPixelFormatList)

    {

        return inst.m_PEAK_IPL_ImageSharpness_GetSupportedPixelFormatList(handle, pixelFormatList, pixelFormatListSize);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageSharpness_SetAlgorithm(PEAK_IPL_SHARPNESS_HANDLE handle, PEAK_IPL_SHARPNESS_ALGORITHM algorithm)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ImageSharpness_SetAlgorithm)

    {

        return inst.m_PEAK_IPL_ImageSharpness_SetAlgorithm(handle, algorithm);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageSharpness_GetAlgorithm(PEAK_IPL_SHARPNESS_HANDLE handle, PEAK_IPL_SHARPNESS_ALGORITHM * algorithm)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ImageSharpness_GetAlgorithm)

    {

        return inst.m_PEAK_IPL_ImageSharpness_GetAlgorithm(handle, algorithm);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageSharpness_GetROIMinimumSize(PEAK_IPL_SHARPNESS_HANDLE handle, struct PEAK_IPL_SIZE_2D * min_size)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ImageSharpness_GetROIMinimumSize)

    {

        return inst.m_PEAK_IPL_ImageSharpness_GetROIMinimumSize(handle, min_size);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageSharpness_SetROIs(PEAK_IPL_SHARPNESS_HANDLE handle, struct PEAK_IPL_SHARPNESS_ROI * roiList, size_t roiListSize)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ImageSharpness_SetROIs)

    {

        return inst.m_PEAK_IPL_ImageSharpness_SetROIs(handle, roiList, roiListSize);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageSharpness_GetROIs(PEAK_IPL_SHARPNESS_HANDLE handle, struct PEAK_IPL_SHARPNESS_ROI * roiList, size_t * roiListSize)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ImageSharpness_GetROIs)

    {

        return inst.m_PEAK_IPL_ImageSharpness_GetROIs(handle, roiList, roiListSize);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_EdgeEnhancement_Construct(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE * handle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_EdgeEnhancement_Construct)

    {

        return inst.m_PEAK_IPL_EdgeEnhancement_Construct(handle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_EdgeEnhancement_Acquire(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_EdgeEnhancement_Acquire)

    {

        return inst.m_PEAK_IPL_EdgeEnhancement_Acquire(handle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_EdgeEnhancement_Destruct(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_EdgeEnhancement_Destruct)

    {

        return inst.m_PEAK_IPL_EdgeEnhancement_Destruct(handle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_EdgeEnhancement_ProcessInPlace(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle, PEAK_IPL_IMAGE_HANDLE imageHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_EdgeEnhancement_ProcessInPlace)

    {

        return inst.m_PEAK_IPL_EdgeEnhancement_ProcessInPlace(handle, imageHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_EdgeEnhancement_Process(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE * outputImageHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_EdgeEnhancement_Process)

    {

        return inst.m_PEAK_IPL_EdgeEnhancement_Process(handle, imageHandle, outputImageHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_EdgeEnhancement_GetFactorRange(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle, struct PEAK_IPL_RANGE * range)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_EdgeEnhancement_GetFactorRange)

    {

        return inst.m_PEAK_IPL_EdgeEnhancement_GetFactorRange(handle, range);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_EdgeEnhancement_SetFactor(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle, uint32_t factor)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_EdgeEnhancement_SetFactor)

    {

        return inst.m_PEAK_IPL_EdgeEnhancement_SetFactor(handle, factor);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_EdgeEnhancement_GetFactor(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle, uint32_t * factor)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_EdgeEnhancement_GetFactor)

    {

        return inst.m_PEAK_IPL_EdgeEnhancement_GetFactor(handle, factor);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_EdgeEnhancement_GetDefaultFactor(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle, uint32_t * factor)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_EdgeEnhancement_GetDefaultFactor)

    {

        return inst.m_PEAK_IPL_EdgeEnhancement_GetDefaultFactor(handle, factor);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_EdgeEnhancement_IsPixelFormatSupported(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle, PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 * isPixelFormatSupported)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_EdgeEnhancement_IsPixelFormatSupported)

    {

        return inst.m_PEAK_IPL_EdgeEnhancement_IsPixelFormatSupported(handle, pixelFormat, isPixelFormatSupported);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Lut_Construct(PEAK_IPL_LUT_HANDLE * lutHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Lut_Construct)

    {

        return inst.m_PEAK_IPL_Lut_Construct(lutHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Lut_Acquire(PEAK_IPL_LUT_HANDLE lutHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Lut_Acquire)

    {

        return inst.m_PEAK_IPL_Lut_Acquire(lutHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::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)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Lut_GetLutValue)

    {

        return inst.m_PEAK_IPL_Lut_GetLutValue(lutHandle, lutSelector, channel, index, value);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::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)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Lut_SetLutValue)

    {

        return inst.m_PEAK_IPL_Lut_SetLutValue(lutHandle, lutSelector, channel, index, value);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::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)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Lut_GetAllLutValues)

    {

        return inst.m_PEAK_IPL_Lut_GetAllLutValues(lutHandle, lutSelector, channel, values, sizeValues);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::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)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Lut_SetAllLutValues)

    {

        return inst.m_PEAK_IPL_Lut_SetAllLutValues(lutHandle, lutSelector, channel, values, sizeValues);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Lut_SetLutPreset(PEAK_IPL_LUT_HANDLE lutHandle, PEAK_IPL_LUT_SELECTOR lutSelector, PEAK_IPL_LUT_PRESET preset)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Lut_SetLutPreset)

    {

        return inst.m_PEAK_IPL_Lut_SetLutPreset(lutHandle, lutSelector, preset);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Lut_IsPixelFormatSupported(PEAK_IPL_LUT_HANDLE lutHandle, PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 * isPixelFormatSupported)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Lut_IsPixelFormatSupported)

    {

        return inst.m_PEAK_IPL_Lut_IsPixelFormatSupported(lutHandle, pixelFormat, isPixelFormatSupported);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Lut_Process(PEAK_IPL_LUT_HANDLE lutHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE * outputImageHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Lut_Process)

    {

        return inst.m_PEAK_IPL_Lut_Process(lutHandle, imageHandle, outputImageHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Lut_ProcessInPlace(PEAK_IPL_LUT_HANDLE lutHandle, PEAK_IPL_IMAGE_HANDLE imageHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Lut_ProcessInPlace)

    {

        return inst.m_PEAK_IPL_Lut_ProcessInPlace(lutHandle, imageHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Lut_Destruct(PEAK_IPL_LUT_HANDLE lutHandle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_Lut_Destruct)

    {

        return inst.m_PEAK_IPL_Lut_Destruct(lutHandle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ChromaticAdapter_Construct(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE * handle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ChromaticAdapter_Construct)

    {

        return inst.m_PEAK_IPL_ChromaticAdapter_Construct(handle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ChromaticAdapter_Acquire(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE handle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ChromaticAdapter_Acquire)

    {

        return inst.m_PEAK_IPL_ChromaticAdapter_Acquire(handle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ChromaticAdapter_Destruct(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE handle)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ChromaticAdapter_Destruct)

    {

        return inst.m_PEAK_IPL_ChromaticAdapter_Destruct(handle);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ChromaticAdapter_GetTargetColorSpace(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE handle, PEAK_IPL_CHROMATIC_ADAPTER_COLOR_SPACE * colorSpace)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ChromaticAdapter_GetTargetColorSpace)

    {

        return inst.m_PEAK_IPL_ChromaticAdapter_GetTargetColorSpace(handle, colorSpace);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ChromaticAdapter_SetTargetColorSpace(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE handle, PEAK_IPL_CHROMATIC_ADAPTER_COLOR_SPACE colorSpace)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ChromaticAdapter_SetTargetColorSpace)

    {

        return inst.m_PEAK_IPL_ChromaticAdapter_SetTargetColorSpace(handle, colorSpace);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ChromaticAdapter_GetAdaptionAlgorithm(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE handle, PEAK_IPL_CHROMATIC_ADAPTER_ALGORITHM * algorithm)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ChromaticAdapter_GetAdaptionAlgorithm)

    {

        return inst.m_PEAK_IPL_ChromaticAdapter_GetAdaptionAlgorithm(handle, algorithm);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ChromaticAdapter_SetAdaptionAlgorithm(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE handle, PEAK_IPL_CHROMATIC_ADAPTER_ALGORITHM model)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ChromaticAdapter_SetAdaptionAlgorithm)

    {

        return inst.m_PEAK_IPL_ChromaticAdapter_SetAdaptionAlgorithm(handle, model);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ChromaticAdapter_CalculateColorCorrectionMatrix(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE handle, uint32_t temperature, const float * colorCorrectionMatrixInput, float * colorCorrectionMatrixOutput)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ChromaticAdapter_CalculateColorCorrectionMatrix)

    {

        return inst.m_PEAK_IPL_ChromaticAdapter_CalculateColorCorrectionMatrix(handle, temperature, colorCorrectionMatrixInput, colorCorrectionMatrixOutput);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ChromaticAdapter_GetTemperatureRange(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE handle, uint32_t * minTemperature, uint32_t * maxTemperature, uint32_t * incTemperature)

{

    auto& inst = instance();

    if(inst.m_PEAK_IPL_ChromaticAdapter_GetTemperatureRange)

    {

        return inst.m_PEAK_IPL_ChromaticAdapter_GetTemperatureRange(handle, minTemperature, maxTemperature, incTemperature);

    }

    else

    {

        throw std::runtime_error("Library not loaded!");

    }

}


} /* namespace dynamic */


} /* namespace ipl */

} /* namespace peak */

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ImageTransformer_MirrorUpDownLeftRightInPlace
static PEAK_IPL_C_API PEAK_IPL_ImageTransformer_MirrorUpDownLeftRightInPlace(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle, PEAK_IPL_IMAGE_HANDLE imageHandle)
Definition peak_ipl_dynamic_loader.h:4211

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_GammaCorrector_Process
static PEAK_IPL_C_API PEAK_IPL_GammaCorrector_Process(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE *outputImageHandle)
Definition peak_ipl_dynamic_loader.h:3782

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ImageConverter_ConvertToBufferWithFactorAndOffset
static 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)
Definition peak_ipl_dynamic_loader.h:2638

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ImageSharpness_SetAlgorithm
static PEAK_IPL_C_API PEAK_IPL_ImageSharpness_SetAlgorithm(PEAK_IPL_SHARPNESS_HANDLE handle, PEAK_IPL_SHARPNESS_ALGORITHM algorithm)
Definition peak_ipl_dynamic_loader.h:5121

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_PixelFormat_CalculateStorageSizeOfPixels
static PEAK_IPL_C_API PEAK_IPL_PixelFormat_CalculateStorageSizeOfPixels(PEAK_IPL_PIXEL_FORMAT pixelFormat, uint64_t numPixels, uint64_t *size)
Definition peak_ipl_dynamic_loader.h:4562

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Library_GetSIMDEnabled
static PEAK_IPL_C_API PEAK_IPL_Library_GetSIMDEnabled(PEAK_IPL_BOOL8 *enabled)
Definition peak_ipl_dynamic_loader.h:2482

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_PixelFormat_GetNumSignificantBitsPerPixel
static PEAK_IPL_C_API PEAK_IPL_PixelFormat_GetNumSignificantBitsPerPixel(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t *numSignificantBits)
Definition peak_ipl_dynamic_loader.h:4523

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ImageConverter_ConvertWithFactorAndOffset
static 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)
Definition peak_ipl_dynamic_loader.h:2625

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Decimation_GetDecimationX
static PEAK_IPL_C_API PEAK_IPL_Decimation_GetDecimationX(PEAK_IPL_DECIMATION_HANDLE decimationHandle, uint8_t *decimationXValue)
Definition peak_ipl_dynamic_loader.h:3236

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_VideoWriter_Video_Append
static PEAK_IPL_C_API PEAK_IPL_VideoWriter_Video_Append(PEAK_IPL_VIDEO_HANDLE videoHandle, PEAK_IPL_IMAGE_HANDLE imageHandle)
Definition peak_ipl_dynamic_loader.h:4783

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_AdaptiveHotpixelCorrector_Correct
static 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)
Definition peak_ipl_dynamic_loader.h:2794

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Binning_SetBinningX
static PEAK_IPL_C_API PEAK_IPL_Binning_SetBinningX(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t *binningXValue)
Definition peak_ipl_dynamic_loader.h:3041

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Image_ConvertToWithFactorAndOffset
static 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)
Definition peak_ipl_dynamic_loader.h:3990

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Decimation_Destruct
static PEAK_IPL_C_API PEAK_IPL_Decimation_Destruct(PEAK_IPL_DECIMATION_HANDLE decimationHandle)
Definition peak_ipl_dynamic_loader.h:3340

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_PixelFormat_IsBayered
static PEAK_IPL_C_API PEAK_IPL_PixelFormat_IsBayered(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 *isBayered)
Definition peak_ipl_dynamic_loader.h:4588

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ImageSharpness_GetIsPixelFormatSupported
static PEAK_IPL_C_API PEAK_IPL_ImageSharpness_GetIsPixelFormatSupported(PEAK_IPL_SHARPNESS_HANDLE handle, PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 *isPixelFormatSupported)
Definition peak_ipl_dynamic_loader.h:5095

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ImageSharpness_Construct
static PEAK_IPL_C_API PEAK_IPL_ImageSharpness_Construct(PEAK_IPL_SHARPNESS_HANDLE *handle)
Definition peak_ipl_dynamic_loader.h:5043

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_AdaptiveHotpixelCorrector_Destruct
static PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_Destruct(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle)
Definition peak_ipl_dynamic_loader.h:2846

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Binning_SetBinningY
static PEAK_IPL_C_API PEAK_IPL_Binning_SetBinningY(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t *binningYValue)
Definition peak_ipl_dynamic_loader.h:3067

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_PixelFormat_GetNumSignificantBitsPerChannel
static PEAK_IPL_C_API PEAK_IPL_PixelFormat_GetNumSignificantBitsPerChannel(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t *numSignificantBits)
Definition peak_ipl_dynamic_loader.h:4484

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ImageSharpness_SetROIs
static PEAK_IPL_C_API PEAK_IPL_ImageSharpness_SetROIs(PEAK_IPL_SHARPNESS_HANDLE handle, struct PEAK_IPL_SHARPNESS_ROI *roiList, size_t roiListSize)
Definition peak_ipl_dynamic_loader.h:5160

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_GammaCorrector_GetDigitalBlackMin
static PEAK_IPL_C_API PEAK_IPL_GammaCorrector_GetDigitalBlackMin(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float *digitalBlackMin)
Definition peak_ipl_dynamic_loader.h:3756

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ImageSharpness_Destruct
static PEAK_IPL_C_API PEAK_IPL_ImageSharpness_Destruct(PEAK_IPL_SHARPNESS_HANDLE handle)
Definition peak_ipl_dynamic_loader.h:5069

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Binning_GetBinningY
static PEAK_IPL_C_API PEAK_IPL_Binning_GetBinningY(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t *binningYValue)
Definition peak_ipl_dynamic_loader.h:3080

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_GammaCorrector_GetGammaCorrectionMax
static PEAK_IPL_C_API PEAK_IPL_GammaCorrector_GetGammaCorrectionMax(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float *gammaMax)
Definition peak_ipl_dynamic_loader.h:3691

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Lut_GetLutValue
static 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)
Definition peak_ipl_dynamic_loader.h:5342

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Gain_SetGreenGainValue
static PEAK_IPL_C_API PEAK_IPL_Gain_SetGreenGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float *greenGainValue)
Definition peak_ipl_dynamic_loader.h:3483

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Lut_IsPixelFormatSupported
static PEAK_IPL_C_API PEAK_IPL_Lut_IsPixelFormatSupported(PEAK_IPL_LUT_HANDLE lutHandle, PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 *isPixelFormatSupported)
Definition peak_ipl_dynamic_loader.h:5407

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ChromaticAdapter_GetTargetColorSpace
static PEAK_IPL_C_API PEAK_IPL_ChromaticAdapter_GetTargetColorSpace(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE handle, PEAK_IPL_CHROMATIC_ADAPTER_COLOR_SPACE *colorSpace)
Definition peak_ipl_dynamic_loader.h:5498

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_PixelFormat_GetEndianness
static PEAK_IPL_C_API PEAK_IPL_PixelFormat_GetEndianness(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_ENDIANNESS *endianness)
Definition peak_ipl_dynamic_loader.h:4549

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ImageTransformer_Destruct
static PEAK_IPL_C_API PEAK_IPL_ImageTransformer_Destruct(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle)
Definition peak_ipl_dynamic_loader.h:4250

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_AdaptiveHotpixelCorrector_CorrectAdaptiveInPlace
static PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_CorrectAdaptiveInPlace(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_IMAGE_HANDLE inputImageHandle)
Definition peak_ipl_dynamic_loader.h:2833

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Lut_Destruct
static PEAK_IPL_C_API PEAK_IPL_Lut_Destruct(PEAK_IPL_LUT_HANDLE lutHandle)
Definition peak_ipl_dynamic_loader.h:5446

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_VideoWriter_Queue_GetSize
static PEAK_IPL_C_API PEAK_IPL_VideoWriter_Queue_GetSize(PEAK_IPL_VIDEO_HANDLE videoHandle, int32_t *size)
Definition peak_ipl_dynamic_loader.h:4978

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Gain_GetMasterGainMax
static PEAK_IPL_C_API PEAK_IPL_Gain_GetMasterGainMax(PEAK_IPL_GAIN_HANDLE gainHandle, float *masterGainMax)
Definition peak_ipl_dynamic_loader.h:3405

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Gain_SetRedGainValue
static PEAK_IPL_C_API PEAK_IPL_Gain_SetRedGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float *redGainValue)
Definition peak_ipl_dynamic_loader.h:3431

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ImageTransformer_Rotate
static 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)
Definition peak_ipl_dynamic_loader.h:4224

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_VideoWriter_Container_OptionRange
static 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)
Definition peak_ipl_dynamic_loader.h:4874

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Binning_Acquire
static PEAK_IPL_C_API PEAK_IPL_Binning_Acquire(PEAK_IPL_BINNING_HANDLE binningHandle)
Definition peak_ipl_dynamic_loader.h:3028

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ImageWriter_Write
static PEAK_IPL_C_API PEAK_IPL_ImageWriter_Write(PEAK_IPL_IMAGE_HANDLE inputImageHandle, const char *filePath, size_t filePathSize)
Definition peak_ipl_dynamic_loader.h:4705

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_EdgeEnhancement_Construct
static PEAK_IPL_C_API PEAK_IPL_EdgeEnhancement_Construct(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE *handle)
Definition peak_ipl_dynamic_loader.h:5186

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Histogram_Destruct
static PEAK_IPL_C_API PEAK_IPL_Histogram_Destruct(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle)
Definition peak_ipl_dynamic_loader.h:4354

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Gain_GetBlueGainMax
static PEAK_IPL_C_API PEAK_IPL_Gain_GetBlueGainMax(PEAK_IPL_GAIN_HANDLE gainHandle, float *blueGainMax)
Definition peak_ipl_dynamic_loader.h:3561

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_GammaCorrector_GetGammaCorrectionMin
static PEAK_IPL_C_API PEAK_IPL_GammaCorrector_GetGammaCorrectionMin(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float *gammaMin)
Definition peak_ipl_dynamic_loader.h:3704

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Image_ConvertToFromInterval
static 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)
Definition peak_ipl_dynamic_loader.h:4016

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_AdaptiveHotpixelCorrector_GetSensitivity
static PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_GetSensitivity(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_HOTPIXELCORRECTION_SENSITIVITY *sensitivityLevel)
Definition peak_ipl_dynamic_loader.h:2729

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ImageConverter_Construct
static PEAK_IPL_C_API PEAK_IPL_ImageConverter_Construct(PEAK_IPL_IMAGE_CONVERTER_HANDLE *imageConverterHandle)
Definition peak_ipl_dynamic_loader.h:2521

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Image_GetHeight
static PEAK_IPL_C_API PEAK_IPL_Image_GetHeight(PEAK_IPL_IMAGE_HANDLE imageHandle, size_t *height)
Definition peak_ipl_dynamic_loader.h:3873

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_GammaCorrector_GetIsPixelFormatSupported
static PEAK_IPL_C_API PEAK_IPL_GammaCorrector_GetIsPixelFormatSupported(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 *isPixelFormatSupported)
Definition peak_ipl_dynamic_loader.h:3769

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Image_GetWidth
static PEAK_IPL_C_API PEAK_IPL_Image_GetWidth(PEAK_IPL_IMAGE_HANDLE imageHandle, size_t *width)
Definition peak_ipl_dynamic_loader.h:3860

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Library_SetMaxConcurrentThreads
static PEAK_IPL_C_API PEAK_IPL_Library_SetMaxConcurrentThreads(size_t concurrentThreads)
Definition peak_ipl_dynamic_loader.h:2443

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Gain_ProcessInPlace
static PEAK_IPL_C_API PEAK_IPL_Gain_ProcessInPlace(PEAK_IPL_GAIN_HANDLE gainHandle, PEAK_IPL_IMAGE_HANDLE imageHandle)
Definition peak_ipl_dynamic_loader.h:3613

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_PixelFormat_GetMaximumValuePerChannel
static PEAK_IPL_C_API PEAK_IPL_PixelFormat_GetMaximumValuePerChannel(PEAK_IPL_PIXEL_FORMAT pixelFormat, uint32_t *channelMaximumValue)
Definition peak_ipl_dynamic_loader.h:4510

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Gain_GetBlueGainValue
static PEAK_IPL_C_API PEAK_IPL_Gain_GetBlueGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float *blueGainValue)
Definition peak_ipl_dynamic_loader.h:3548

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Library_SetSIMDEnabled
static PEAK_IPL_C_API PEAK_IPL_Library_SetSIMDEnabled(PEAK_IPL_BOOL8 enabled)
Definition peak_ipl_dynamic_loader.h:2495

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_GammaCorrector_GetDigitalBlackMax
static PEAK_IPL_C_API PEAK_IPL_GammaCorrector_GetDigitalBlackMax(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float *digitalBlackMax)
Definition peak_ipl_dynamic_loader.h:3743

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Binning_SetBinningMode
static PEAK_IPL_C_API PEAK_IPL_Binning_SetBinningMode(PEAK_IPL_BINNING_HANDLE binningHandle, PEAK_IPL_BINNINGMODE *mode)
Definition peak_ipl_dynamic_loader.h:3145

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Image_GetTimestamp
static PEAK_IPL_C_API PEAK_IPL_Image_GetTimestamp(PEAK_IPL_IMAGE_HANDLE imageHandle, uint64_t *timestamp_ns)
Definition peak_ipl_dynamic_loader.h:4133

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Gain_GetGreenGainValue
static PEAK_IPL_C_API PEAK_IPL_Gain_GetGreenGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float *greenGainValue)
Definition peak_ipl_dynamic_loader.h:3496

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_GammaCorrector_Acquire
static PEAK_IPL_C_API PEAK_IPL_GammaCorrector_Acquire(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle)
Definition peak_ipl_dynamic_loader.h:3652

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_PixelFormat_GetNumStorageBitsPerChannel
static PEAK_IPL_C_API PEAK_IPL_PixelFormat_GetNumStorageBitsPerChannel(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t *numStorageBits)
Definition peak_ipl_dynamic_loader.h:4497

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Decimation_Process
static PEAK_IPL_C_API PEAK_IPL_Decimation_Process(PEAK_IPL_DECIMATION_HANDLE decimationHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE *outputImageHandle)
Definition peak_ipl_dynamic_loader.h:3327

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Binning_GetBinningMin
static PEAK_IPL_C_API PEAK_IPL_Binning_GetBinningMin(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t *binningMin)
Definition peak_ipl_dynamic_loader.h:3093

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Binning_GetBinningX
static PEAK_IPL_C_API PEAK_IPL_Binning_GetBinningX(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t *binningXValue)
Definition peak_ipl_dynamic_loader.h:3054

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_VideoWriter_Video_GetEncodedFrames
static PEAK_IPL_C_API PEAK_IPL_VideoWriter_Video_GetEncodedFrames(PEAK_IPL_VIDEO_HANDLE videoHandle, uint64_t *numFrames)
Definition peak_ipl_dynamic_loader.h:4913

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ChromaticAdapter_Acquire
static PEAK_IPL_C_API PEAK_IPL_ChromaticAdapter_Acquire(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE handle)
Definition peak_ipl_dynamic_loader.h:5472

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Histogram_GetPixelFormat
static PEAK_IPL_C_API PEAK_IPL_Histogram_GetPixelFormat(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle, PEAK_IPL_PIXEL_FORMAT *pixelFormat)
Definition peak_ipl_dynamic_loader.h:4289

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_GammaCorrector_ProcessInPlace
static PEAK_IPL_C_API PEAK_IPL_GammaCorrector_ProcessInPlace(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, PEAK_IPL_IMAGE_HANDLE imageHandle)
Definition peak_ipl_dynamic_loader.h:3795

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Lut_SetLutValue
static 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)
Definition peak_ipl_dynamic_loader.h:5355

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ImageSharpness_Acquire
static PEAK_IPL_C_API PEAK_IPL_ImageSharpness_Acquire(PEAK_IPL_SHARPNESS_HANDLE handle)
Definition peak_ipl_dynamic_loader.h:5056

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_EdgeEnhancement_GetFactor
static PEAK_IPL_C_API PEAK_IPL_EdgeEnhancement_GetFactor(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle, uint32_t *factor)
Definition peak_ipl_dynamic_loader.h:5277

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ColorCorrector_ProcessInPlace
static PEAK_IPL_C_API PEAK_IPL_ColorCorrector_ProcessInPlace(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, PEAK_IPL_IMAGE_HANDLE imageHandle)
Definition peak_ipl_dynamic_loader.h:2937

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Decimation_IsPixelformatSupported
static PEAK_IPL_C_API PEAK_IPL_Decimation_IsPixelformatSupported(PEAK_IPL_DECIMATION_HANDLE decimationHandle, PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 *isPixelFormatSupported)
Definition peak_ipl_dynamic_loader.h:3314

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Lut_SetLutPreset
static PEAK_IPL_C_API PEAK_IPL_Lut_SetLutPreset(PEAK_IPL_LUT_HANDLE lutHandle, PEAK_IPL_LUT_SELECTOR lutSelector, PEAK_IPL_LUT_PRESET preset)
Definition peak_ipl_dynamic_loader.h:5394

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_EdgeEnhancement_GetDefaultFactor
static PEAK_IPL_C_API PEAK_IPL_EdgeEnhancement_GetDefaultFactor(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle, uint32_t *factor)
Definition peak_ipl_dynamic_loader.h:5290

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Binning_Destruct
static PEAK_IPL_C_API PEAK_IPL_Binning_Destruct(PEAK_IPL_BINNING_HANDLE binningHandle)
Definition peak_ipl_dynamic_loader.h:3184

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Image_Construct
static PEAK_IPL_C_API PEAK_IPL_Image_Construct(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t width, size_t height, PEAK_IPL_IMAGE_HANDLE *imageHandle)
Definition peak_ipl_dynamic_loader.h:3821

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Lut_Process
static PEAK_IPL_C_API PEAK_IPL_Lut_Process(PEAK_IPL_LUT_HANDLE lutHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE *outputImageHandle)
Definition peak_ipl_dynamic_loader.h:5420

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_VideoWriter_Container_GetOption
static 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)
Definition peak_ipl_dynamic_loader.h:4861

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Image_ConvertToWithFactor
static 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)
Definition peak_ipl_dynamic_loader.h:3977

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ImageConverter_PreAllocateConversion
static 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)
Definition peak_ipl_dynamic_loader.h:2547

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_PixelFormat_GetNumStorageBitsPerPixel
static PEAK_IPL_C_API PEAK_IPL_PixelFormat_GetNumStorageBitsPerPixel(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t *numStorageBits)
Definition peak_ipl_dynamic_loader.h:4536

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Library_GetVersionMajor
static PEAK_IPL_C_API PEAK_IPL_Library_GetVersionMajor(uint32_t *libraryVersionMajor)
Definition peak_ipl_dynamic_loader.h:2391

peak::ipl::dynamic::DynamicLoader::isLoaded
static bool isLoaded()
Definition peak_ipl_dynamic_loader.h:858

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Gain_GetRedGainMin
static PEAK_IPL_C_API PEAK_IPL_Gain_GetRedGainMin(PEAK_IPL_GAIN_HANDLE gainHandle, float *redGainMin)
Definition peak_ipl_dynamic_loader.h:3470

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_VideoWriter_Encoder_SetOption
static 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)
Definition peak_ipl_dynamic_loader.h:4796

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Image_SetTimestamp
static PEAK_IPL_C_API PEAK_IPL_Image_SetTimestamp(PEAK_IPL_IMAGE_HANDLE imageHandle, uint64_t timestamp_ns)
Definition peak_ipl_dynamic_loader.h:4120

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_VideoWriter_Encoder_OptionRange
static 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)
Definition peak_ipl_dynamic_loader.h:4822

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Image_ConstructFromBuffer
static 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)
Definition peak_ipl_dynamic_loader.h:3847

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Binning_GetBinningMode
static PEAK_IPL_C_API PEAK_IPL_Binning_GetBinningMode(PEAK_IPL_BINNING_HANDLE binningHandle, PEAK_IPL_BINNINGMODE *mode)
Definition peak_ipl_dynamic_loader.h:3158

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ColorCorrector_Acquire
static PEAK_IPL_C_API PEAK_IPL_ColorCorrector_Acquire(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle)
Definition peak_ipl_dynamic_loader.h:2872

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_PixelFormat_IsFloat
static PEAK_IPL_C_API PEAK_IPL_PixelFormat_IsFloat(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 *isFloat)
Definition peak_ipl_dynamic_loader.h:4627

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_VideoWriter_Video_GetDroppedFrames
static PEAK_IPL_C_API PEAK_IPL_VideoWriter_Video_GetDroppedFrames(PEAK_IPL_VIDEO_HANDLE videoHandle, uint64_t *numFrames)
Definition peak_ipl_dynamic_loader.h:4926

peak::ipl::dynamic::DynamicLoader::~DynamicLoader
~DynamicLoader()
Definition peak_ipl_dynamic_loader.h:850

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_EdgeEnhancement_Destruct
static PEAK_IPL_C_API PEAK_IPL_EdgeEnhancement_Destruct(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle)
Definition peak_ipl_dynamic_loader.h:5212

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Library_GetVersionSubminor
static PEAK_IPL_C_API PEAK_IPL_Library_GetVersionSubminor(uint32_t *libraryVersionSubminor)
Definition peak_ipl_dynamic_loader.h:2417

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_AdaptiveHotpixelCorrector_Construct
static PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_Construct(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE *adaptiveHotpixelCorrectorHandle)
Definition peak_ipl_dynamic_loader.h:2690

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ImageTransformer_MirrorUpDown
static PEAK_IPL_C_API PEAK_IPL_ImageTransformer_MirrorUpDown(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE *outputImageHandle)
Definition peak_ipl_dynamic_loader.h:4146

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ImageConverter_Convert
static 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)
Definition peak_ipl_dynamic_loader.h:2599

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Binning_Construct
static PEAK_IPL_C_API PEAK_IPL_Binning_Construct(PEAK_IPL_BINNING_HANDLE *binningHandle)
Definition peak_ipl_dynamic_loader.h:3015

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_VideoWriter_Video_WaitUntilFrameDone
static PEAK_IPL_C_API PEAK_IPL_VideoWriter_Video_WaitUntilFrameDone(PEAK_IPL_VIDEO_HANDLE videoHandle, int32_t timeout_ms)
Definition peak_ipl_dynamic_loader.h:5017

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Lut_Acquire
static PEAK_IPL_C_API PEAK_IPL_Lut_Acquire(PEAK_IPL_LUT_HANDLE lutHandle)
Definition peak_ipl_dynamic_loader.h:5329

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_VideoWriter_Video_WaitUntilQueueEmpty
static PEAK_IPL_C_API PEAK_IPL_VideoWriter_Video_WaitUntilQueueEmpty(PEAK_IPL_VIDEO_HANDLE videoHandle, int32_t timeout_ms)
Definition peak_ipl_dynamic_loader.h:5030

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Library_GetVersionMinor
static PEAK_IPL_C_API PEAK_IPL_Library_GetVersionMinor(uint32_t *libraryVersionMinor)
Definition peak_ipl_dynamic_loader.h:2404

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Gain_Process
static PEAK_IPL_C_API PEAK_IPL_Gain_Process(PEAK_IPL_GAIN_HANDLE gainHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE *outputImageHandle)
Definition peak_ipl_dynamic_loader.h:3600

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Decimation_SetDecimationY
static PEAK_IPL_C_API PEAK_IPL_Decimation_SetDecimationY(PEAK_IPL_DECIMATION_HANDLE decimationHandle, uint8_t *decimationYValue)
Definition peak_ipl_dynamic_loader.h:3249

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ImageWriter_WriteAsBMP
static PEAK_IPL_C_API PEAK_IPL_ImageWriter_WriteAsBMP(PEAK_IPL_IMAGE_HANDLE inputImageHandle, const char *filePath, size_t filePathSize)
Definition peak_ipl_dynamic_loader.h:4666

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ImageReader_Read
static PEAK_IPL_C_API PEAK_IPL_ImageReader_Read(const char *filePath, size_t filePathSize, PEAK_IPL_IMAGE_HANDLE *outputImageHandle)
Definition peak_ipl_dynamic_loader.h:4718

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_PixelFormat_GetNumChannels
static PEAK_IPL_C_API PEAK_IPL_PixelFormat_GetNumChannels(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t *numChannels)
Definition peak_ipl_dynamic_loader.h:4471

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Library_SetMultiThreadingEnabled
static PEAK_IPL_C_API PEAK_IPL_Library_SetMultiThreadingEnabled(PEAK_IPL_BOOL8 enabled)
Definition peak_ipl_dynamic_loader.h:2469

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ImageConverter_GetSupportedOutputPixelFormats
static 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)
Definition peak_ipl_dynamic_loader.h:2586

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Decimation_Acquire
static PEAK_IPL_C_API PEAK_IPL_Decimation_Acquire(PEAK_IPL_DECIMATION_HANDLE decimationHandle)
Definition peak_ipl_dynamic_loader.h:3210

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Gain_Destruct
static PEAK_IPL_C_API PEAK_IPL_Gain_Destruct(PEAK_IPL_GAIN_HANDLE gainHandle)
Definition peak_ipl_dynamic_loader.h:3626

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ChromaticAdapter_SetTargetColorSpace
static PEAK_IPL_C_API PEAK_IPL_ChromaticAdapter_SetTargetColorSpace(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE handle, PEAK_IPL_CHROMATIC_ADAPTER_COLOR_SPACE colorSpace)
Definition peak_ipl_dynamic_loader.h:5511

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ImageWriter_WriteAsPNG
static PEAK_IPL_C_API PEAK_IPL_ImageWriter_WriteAsPNG(PEAK_IPL_IMAGE_HANDLE inputImageHandle, uint32_t quality, const char *filePath, size_t filePathSize)
Definition peak_ipl_dynamic_loader.h:4679

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Image_GetPixelFormat
static PEAK_IPL_C_API PEAK_IPL_Image_GetPixelFormat(PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_PIXEL_FORMAT *pixelFormat)
Definition peak_ipl_dynamic_loader.h:3912

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ImageConverter_Destruct
static PEAK_IPL_C_API PEAK_IPL_ImageConverter_Destruct(PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle)
Definition peak_ipl_dynamic_loader.h:2677

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ImageConverter_ConvertToBuffer
static 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)
Definition peak_ipl_dynamic_loader.h:2612

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_PixelFormat_IsCoord3D
static PEAK_IPL_C_API PEAK_IPL_PixelFormat_IsCoord3D(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 *isCoord3D)
Definition peak_ipl_dynamic_loader.h:4614

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Lut_GetAllLutValues
static 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)
Definition peak_ipl_dynamic_loader.h:5368

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Histogram_GetPixelCountForChannel
static PEAK_IPL_C_API PEAK_IPL_Histogram_GetPixelCountForChannel(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle, size_t channelIndex, uint64_t *pixelCount)
Definition peak_ipl_dynamic_loader.h:4328

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_AdaptiveHotpixelCorrector_GetHotpixels
static PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_GetHotpixels(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, struct PEAK_IPL_POINT_2D *hotpixels, size_t *hotpixelsSize)
Definition peak_ipl_dynamic_loader.h:2781

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Gain_GetIsPixelFormatSupported
static PEAK_IPL_C_API PEAK_IPL_Gain_GetIsPixelFormatSupported(PEAK_IPL_GAIN_HANDLE gainHandle, PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 *isPixelFormatSupported)
Definition peak_ipl_dynamic_loader.h:3587

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_AdaptiveHotpixelCorrector_GetGainFactorPercent
static PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_GetGainFactorPercent(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, uint32_t *gainFactorPercent)
Definition peak_ipl_dynamic_loader.h:2755

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Gain_GetMasterGainMin
static PEAK_IPL_C_API PEAK_IPL_Gain_GetMasterGainMin(PEAK_IPL_GAIN_HANDLE gainHandle, float *masterGainMin)
Definition peak_ipl_dynamic_loader.h:3418

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ImageConverter_Acquire
static PEAK_IPL_C_API PEAK_IPL_ImageConverter_Acquire(PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle)
Definition peak_ipl_dynamic_loader.h:2534

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ColorCorrector_GetIsPixelFormatSupported
static PEAK_IPL_C_API PEAK_IPL_ColorCorrector_GetIsPixelFormatSupported(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 *isPixelFormatSupported)
Definition peak_ipl_dynamic_loader.h:2911

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Gain_GetRedGainMax
static PEAK_IPL_C_API PEAK_IPL_Gain_GetRedGainMax(PEAK_IPL_GAIN_HANDLE gainHandle, float *redGainMax)
Definition peak_ipl_dynamic_loader.h:3457

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ImageTransformer_MirrorLeftRightInPlace
static PEAK_IPL_C_API PEAK_IPL_ImageTransformer_MirrorLeftRightInPlace(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle, PEAK_IPL_IMAGE_HANDLE imageHandle)
Definition peak_ipl_dynamic_loader.h:4198

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Gain_SetBlueGainValue
static PEAK_IPL_C_API PEAK_IPL_Gain_SetBlueGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float *blueGainValue)
Definition peak_ipl_dynamic_loader.h:3535

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ImageTransformer_MirrorLeftRight
static PEAK_IPL_C_API PEAK_IPL_ImageTransformer_MirrorLeftRight(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE *outputImageHandle)
Definition peak_ipl_dynamic_loader.h:4159

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Histogram_GetPixelSumForChannel
static PEAK_IPL_C_API PEAK_IPL_Histogram_GetPixelSumForChannel(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle, size_t channelIndex, uint64_t *pixelSum)
Definition peak_ipl_dynamic_loader.h:4315

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Decimation_ExpectedOutputSize
static 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)
Definition peak_ipl_dynamic_loader.h:3301

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_PixelLine_Acquire
static PEAK_IPL_C_API PEAK_IPL_PixelLine_Acquire(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle)
Definition peak_ipl_dynamic_loader.h:4380

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Decimation_SetDecimationX
static PEAK_IPL_C_API PEAK_IPL_Decimation_SetDecimationX(PEAK_IPL_DECIMATION_HANDLE decimationHandle, uint8_t *decimationXValue)
Definition peak_ipl_dynamic_loader.h:3223

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ChromaticAdapter_Destruct
static PEAK_IPL_C_API PEAK_IPL_ChromaticAdapter_Destruct(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE handle)
Definition peak_ipl_dynamic_loader.h:5485

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Image_ConvertTo
static 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)
Definition peak_ipl_dynamic_loader.h:3951

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_EdgeEnhancement_Process
static PEAK_IPL_C_API PEAK_IPL_EdgeEnhancement_Process(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE *outputImageHandle)
Definition peak_ipl_dynamic_loader.h:5238

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Binning_GetBinningMax
static PEAK_IPL_C_API PEAK_IPL_Binning_GetBinningMax(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t *binningMax)
Definition peak_ipl_dynamic_loader.h:3106

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_EdgeEnhancement_IsPixelFormatSupported
static PEAK_IPL_C_API PEAK_IPL_EdgeEnhancement_IsPixelFormatSupported(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle, PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 *isPixelFormatSupported)
Definition peak_ipl_dynamic_loader.h:5303

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ImageConverter_SetConversionMode
static PEAK_IPL_C_API PEAK_IPL_ImageConverter_SetConversionMode(PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle, PEAK_IPL_CONVERSION_MODE conversionMode)
Definition peak_ipl_dynamic_loader.h:2573

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Image_GetData
static PEAK_IPL_C_API PEAK_IPL_Image_GetData(PEAK_IPL_IMAGE_HANDLE imageHandle, uint8_t **data)
Definition peak_ipl_dynamic_loader.h:3925

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Lut_SetAllLutValues
static 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)
Definition peak_ipl_dynamic_loader.h:5381

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_VideoWriter_Queue_SetSize
static PEAK_IPL_C_API PEAK_IPL_VideoWriter_Queue_SetSize(PEAK_IPL_VIDEO_HANDLE videoHandle, int32_t size)
Definition peak_ipl_dynamic_loader.h:4965

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_GammaCorrector_GetDigitalBlack
static PEAK_IPL_C_API PEAK_IPL_GammaCorrector_GetDigitalBlack(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float *digitalBlackValue)
Definition peak_ipl_dynamic_loader.h:3730

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ColorCorrector_GetSaturation
static PEAK_IPL_C_API PEAK_IPL_ColorCorrector_GetSaturation(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, float *saturation)
Definition peak_ipl_dynamic_loader.h:2963

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ColorCorrector_GetSaturationMin
static PEAK_IPL_C_API PEAK_IPL_ColorCorrector_GetSaturationMin(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, float *saturationMin)
Definition peak_ipl_dynamic_loader.h:2976

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_AdaptiveHotpixelCorrector_CorrectAdaptive
static 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)
Definition peak_ipl_dynamic_loader.h:2820

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_PixelLine_Destruct
static PEAK_IPL_C_API PEAK_IPL_PixelLine_Destruct(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle)
Definition peak_ipl_dynamic_loader.h:4458

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ImageSharpness_GetAlgorithm
static PEAK_IPL_C_API PEAK_IPL_ImageSharpness_GetAlgorithm(PEAK_IPL_SHARPNESS_HANDLE handle, PEAK_IPL_SHARPNESS_ALGORITHM *algorithm)
Definition peak_ipl_dynamic_loader.h:5134

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_GammaCorrector_SetGammaCorrectionValue
static PEAK_IPL_C_API PEAK_IPL_GammaCorrector_SetGammaCorrectionValue(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float *gammaValue)
Definition peak_ipl_dynamic_loader.h:3665

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Decimation_GetDecimationMin
static PEAK_IPL_C_API PEAK_IPL_Decimation_GetDecimationMin(PEAK_IPL_DECIMATION_HANDLE decimationHandle, uint8_t *decimationMin)
Definition peak_ipl_dynamic_loader.h:3275

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Binning_Process
static PEAK_IPL_C_API PEAK_IPL_Binning_Process(PEAK_IPL_BINNING_HANDLE binningHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE *outputImageHandle)
Definition peak_ipl_dynamic_loader.h:3171

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ImageTransformer_MirrorUpDownInPlace
static PEAK_IPL_C_API PEAK_IPL_ImageTransformer_MirrorUpDownInPlace(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle, PEAK_IPL_IMAGE_HANDLE imageHandle)
Definition peak_ipl_dynamic_loader.h:4185

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ImageSharpness_GetROIs
static PEAK_IPL_C_API PEAK_IPL_ImageSharpness_GetROIs(PEAK_IPL_SHARPNESS_HANDLE handle, struct PEAK_IPL_SHARPNESS_ROI *roiList, size_t *roiListSize)
Definition peak_ipl_dynamic_loader.h:5173

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ImageTransformer_MirrorUpDownLeftRight
static PEAK_IPL_C_API PEAK_IPL_ImageTransformer_MirrorUpDownLeftRight(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE *outputImageHandle)
Definition peak_ipl_dynamic_loader.h:4172

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_AdaptiveHotpixelCorrector_Acquire
static PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_Acquire(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle)
Definition peak_ipl_dynamic_loader.h:2703

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Gain_Acquire
static PEAK_IPL_C_API PEAK_IPL_Gain_Acquire(PEAK_IPL_GAIN_HANDLE gainHandle)
Definition peak_ipl_dynamic_loader.h:3366

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_VideoWriter_Queue_GetRange
static PEAK_IPL_C_API PEAK_IPL_VideoWriter_Queue_GetRange(PEAK_IPL_VIDEO_HANDLE videoHandle, int32_t *minSize, int32_t *maxSize)
Definition peak_ipl_dynamic_loader.h:4991

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ImageSharpness_GetROIMinimumSize
static PEAK_IPL_C_API PEAK_IPL_ImageSharpness_GetROIMinimumSize(PEAK_IPL_SHARPNESS_HANDLE handle, struct PEAK_IPL_SIZE_2D *min_size)
Definition peak_ipl_dynamic_loader.h:5147

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_PixelFormat_IsPacked
static PEAK_IPL_C_API PEAK_IPL_PixelFormat_IsPacked(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 *isPacked)
Definition peak_ipl_dynamic_loader.h:4575

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_VideoWriter_GetSupportedContainersForAnEncoder
static PEAK_IPL_C_API PEAK_IPL_VideoWriter_GetSupportedContainersForAnEncoder(PEAK_IPL_VIDEO_ENCODER encoder, PEAK_IPL_VIDEO_CONTAINER *containers, size_t *size)
Definition peak_ipl_dynamic_loader.h:4887

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Histogram_Construct
static PEAK_IPL_C_API PEAK_IPL_Histogram_Construct(PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_HISTOGRAM_HANDLE *histogramHandle)
Definition peak_ipl_dynamic_loader.h:4263

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ColorCorrector_Process
static PEAK_IPL_C_API PEAK_IPL_ColorCorrector_Process(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE *outputImageHandle)
Definition peak_ipl_dynamic_loader.h:2924

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_AdaptiveHotpixelCorrector_SetSensitivity
static PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_SetSensitivity(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_HOTPIXELCORRECTION_SENSITIVITY sensitivityLevel)
Definition peak_ipl_dynamic_loader.h:2716

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Gain_Construct
static PEAK_IPL_C_API PEAK_IPL_Gain_Construct(PEAK_IPL_GAIN_HANDLE *gainHandle)
Definition peak_ipl_dynamic_loader.h:3353

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Image_Destruct
static PEAK_IPL_C_API PEAK_IPL_Image_Destruct(PEAK_IPL_IMAGE_HANDLE imageHandle)
Definition peak_ipl_dynamic_loader.h:4081

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Image_Scale
static 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)
Definition peak_ipl_dynamic_loader.h:4042

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ChromaticAdapter_GetAdaptionAlgorithm
static PEAK_IPL_C_API PEAK_IPL_ChromaticAdapter_GetAdaptionAlgorithm(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE handle, PEAK_IPL_CHROMATIC_ADAPTER_ALGORITHM *algorithm)
Definition peak_ipl_dynamic_loader.h:5524

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_AdaptiveHotpixelCorrector_Detect
static PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_Detect(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_IMAGE_HANDLE inputImageHandle)
Definition peak_ipl_dynamic_loader.h:2768

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Gain_GetGreenGainMax
static PEAK_IPL_C_API PEAK_IPL_Gain_GetGreenGainMax(PEAK_IPL_GAIN_HANDLE gainHandle, float *greenGainMax)
Definition peak_ipl_dynamic_loader.h:3509

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Gain_SetMasterGainValue
static PEAK_IPL_C_API PEAK_IPL_Gain_SetMasterGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float *masterGainValue)
Definition peak_ipl_dynamic_loader.h:3379

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ImageWriter_WriteAsRAW
static PEAK_IPL_C_API PEAK_IPL_ImageWriter_WriteAsRAW(PEAK_IPL_IMAGE_HANDLE inputImageHandle, const char *filePath, size_t filePathSize)
Definition peak_ipl_dynamic_loader.h:4653

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_VideoWriter_Video_IsOpen
static PEAK_IPL_C_API PEAK_IPL_VideoWriter_Video_IsOpen(PEAK_IPL_VIDEO_HANDLE videoHandle, PEAK_IPL_BOOL8 *isOpen)
Definition peak_ipl_dynamic_loader.h:4757

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Library_GetMaxConcurrentThreads
static PEAK_IPL_C_API PEAK_IPL_Library_GetMaxConcurrentThreads(size_t *concurrentThreads)
Definition peak_ipl_dynamic_loader.h:2430

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Lut_ProcessInPlace
static PEAK_IPL_C_API PEAK_IPL_Lut_ProcessInPlace(PEAK_IPL_LUT_HANDLE lutHandle, PEAK_IPL_IMAGE_HANDLE imageHandle)
Definition peak_ipl_dynamic_loader.h:5433

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ChromaticAdapter_Construct
static PEAK_IPL_C_API PEAK_IPL_ChromaticAdapter_Construct(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE *handle)
Definition peak_ipl_dynamic_loader.h:5459

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Image_ConvertToBufferWithFactorAndOffset
static 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)
Definition peak_ipl_dynamic_loader.h:4003

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Image_Clone
static PEAK_IPL_C_API PEAK_IPL_Image_Clone(PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE *outputImageHandle)
Definition peak_ipl_dynamic_loader.h:3938

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Decimation_GetDecimationY
static PEAK_IPL_C_API PEAK_IPL_Decimation_GetDecimationY(PEAK_IPL_DECIMATION_HANDLE decimationHandle, uint8_t *decimationYValue)
Definition peak_ipl_dynamic_loader.h:3262

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ImageTransformer_RotateInPlace
static 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)
Definition peak_ipl_dynamic_loader.h:4237

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Decimation_GetDecimationMax
static PEAK_IPL_C_API PEAK_IPL_Decimation_GetDecimationMax(PEAK_IPL_DECIMATION_HANDLE decimationHandle, uint8_t *decimationMax)
Definition peak_ipl_dynamic_loader.h:3288

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_PixelLine_GetOrientation
static PEAK_IPL_C_API PEAK_IPL_PixelLine_GetOrientation(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle, PEAK_IPL_ORIENTATION *orientation)
Definition peak_ipl_dynamic_loader.h:4406

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ImageTransformer_Construct
static PEAK_IPL_C_API PEAK_IPL_ImageTransformer_Construct(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE *imageTransformerHandle)
Definition peak_ipl_dynamic_loader.h:4094

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Binning_ExpectedOutputSize
static 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)
Definition peak_ipl_dynamic_loader.h:3119

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_AdaptiveHotpixelCorrector_CorrectInPlace
static 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)
Definition peak_ipl_dynamic_loader.h:2807

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_VideoWriter_Encoder_GetSupportedPixelFormats
static PEAK_IPL_C_API PEAK_IPL_VideoWriter_Encoder_GetSupportedPixelFormats(PEAK_IPL_VIDEO_ENCODER encoder, PEAK_IPL_PIXEL_FORMAT *pixelFormatList, size_t *pixelFormatListSize)
Definition peak_ipl_dynamic_loader.h:4900

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ChromaticAdapter_GetTemperatureRange
static PEAK_IPL_C_API PEAK_IPL_ChromaticAdapter_GetTemperatureRange(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE handle, uint32_t *minTemperature, uint32_t *maxTemperature, uint32_t *incTemperature)
Definition peak_ipl_dynamic_loader.h:5563

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_EdgeEnhancement_ProcessInPlace
static PEAK_IPL_C_API PEAK_IPL_EdgeEnhancement_ProcessInPlace(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle, PEAK_IPL_IMAGE_HANDLE imageHandle)
Definition peak_ipl_dynamic_loader.h:5225

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ChromaticAdapter_SetAdaptionAlgorithm
static PEAK_IPL_C_API PEAK_IPL_ChromaticAdapter_SetAdaptionAlgorithm(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE handle, PEAK_IPL_CHROMATIC_ADAPTER_ALGORITHM model)
Definition peak_ipl_dynamic_loader.h:5537

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Binning_IsPixelformatSupported
static PEAK_IPL_C_API PEAK_IPL_Binning_IsPixelformatSupported(PEAK_IPL_BINNING_HANDLE binningHandle, PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 *isPixelFormatSupported)
Definition peak_ipl_dynamic_loader.h:3132

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Library_GetMultiThreadingEnabled
static PEAK_IPL_C_API PEAK_IPL_Library_GetMultiThreadingEnabled(PEAK_IPL_BOOL8 *enabled)
Definition peak_ipl_dynamic_loader.h:2456

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_AdaptiveHotpixelCorrector_SetGainFactorPercent
static PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_SetGainFactorPercent(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, uint32_t gainFactorPercent)
Definition peak_ipl_dynamic_loader.h:2742

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ImageReaderRead_ReadAsPixelFormat
static PEAK_IPL_C_API PEAK_IPL_ImageReaderRead_ReadAsPixelFormat(const char *filePath, size_t filePathSize, PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_IMAGE_HANDLE *outputImageHandle)
Definition peak_ipl_dynamic_loader.h:4731

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_PixelLine_GetValuesForChannel
static PEAK_IPL_C_API PEAK_IPL_PixelLine_GetValuesForChannel(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle, size_t channelIndex, uint32_t *values, size_t *valuesSize)
Definition peak_ipl_dynamic_loader.h:4445

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ImageSharpness_Measure
static PEAK_IPL_C_API PEAK_IPL_ImageSharpness_Measure(PEAK_IPL_SHARPNESS_HANDLE handle, PEAK_IPL_IMAGE_HANDLE imageHandle, double *calculated_value)
Definition peak_ipl_dynamic_loader.h:5082

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ColorCorrector_SetSaturation
static PEAK_IPL_C_API PEAK_IPL_ColorCorrector_SetSaturation(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, float saturation)
Definition peak_ipl_dynamic_loader.h:3002

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Gain_GetGreenGainMin
static PEAK_IPL_C_API PEAK_IPL_Gain_GetGreenGainMin(PEAK_IPL_GAIN_HANDLE gainHandle, float *greenGainMin)
Definition peak_ipl_dynamic_loader.h:3522

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Image_ScaleInto
static 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)
Definition peak_ipl_dynamic_loader.h:4055

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_VideoWriter_Video_GetFileSize
static PEAK_IPL_C_API PEAK_IPL_VideoWriter_Video_GetFileSize(PEAK_IPL_VIDEO_HANDLE videoHandle, uint64_t *fileSize)
Definition peak_ipl_dynamic_loader.h:4939

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Gain_GetRedGainValue
static PEAK_IPL_C_API PEAK_IPL_Gain_GetRedGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float *redGainValue)
Definition peak_ipl_dynamic_loader.h:3444

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Histogram_Acquire
static PEAK_IPL_C_API PEAK_IPL_Histogram_Acquire(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle)
Definition peak_ipl_dynamic_loader.h:4276

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ColorCorrector_GetColorCorrectionFactors
static PEAK_IPL_C_API PEAK_IPL_ColorCorrector_GetColorCorrectionFactors(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, float *colorCorrectorFactors, size_t *colorCorrectorFactorsSize)
Definition peak_ipl_dynamic_loader.h:2898

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Lut_Construct
static PEAK_IPL_C_API PEAK_IPL_Lut_Construct(PEAK_IPL_LUT_HANDLE *lutHandle)
Definition peak_ipl_dynamic_loader.h:5316

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_GammaCorrector_Destruct
static PEAK_IPL_C_API PEAK_IPL_GammaCorrector_Destruct(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle)
Definition peak_ipl_dynamic_loader.h:3808

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_VideoWriter_Queue_GetQueued
static PEAK_IPL_C_API PEAK_IPL_VideoWriter_Queue_GetQueued(PEAK_IPL_VIDEO_HANDLE videoHandle, int32_t *queued)
Definition peak_ipl_dynamic_loader.h:5004

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Histogram_GetNumChannels
static PEAK_IPL_C_API PEAK_IPL_Histogram_GetNumChannels(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle, size_t *numChannels)
Definition peak_ipl_dynamic_loader.h:4302

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_PixelLine_GetNumChannels
static PEAK_IPL_C_API PEAK_IPL_PixelLine_GetNumChannels(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle, size_t *numChannels)
Definition peak_ipl_dynamic_loader.h:4432

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_VideoWriter_Video_Close
static PEAK_IPL_C_API PEAK_IPL_VideoWriter_Video_Close(PEAK_IPL_VIDEO_HANDLE videoHandle)
Definition peak_ipl_dynamic_loader.h:4770

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Decimation_Construct
static PEAK_IPL_C_API PEAK_IPL_Decimation_Construct(PEAK_IPL_DECIMATION_HANDLE *decimationHandle)
Definition peak_ipl_dynamic_loader.h:3197

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ImageConverter_ConvertToBufferFromInterval
static 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)
Definition peak_ipl_dynamic_loader.h:2664

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ImageWriter_WriteAsJPG
static PEAK_IPL_C_API PEAK_IPL_ImageWriter_WriteAsJPG(PEAK_IPL_IMAGE_HANDLE inputImageHandle, uint32_t quality, const char *filePath, size_t filePathSize)
Definition peak_ipl_dynamic_loader.h:4692

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ColorCorrector_Destruct
static PEAK_IPL_C_API PEAK_IPL_ColorCorrector_Destruct(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle)
Definition peak_ipl_dynamic_loader.h:2950

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ImageTransformer_Acquire
static PEAK_IPL_C_API PEAK_IPL_ImageTransformer_Acquire(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle)
Definition peak_ipl_dynamic_loader.h:4107

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ChromaticAdapter_CalculateColorCorrectionMatrix
static PEAK_IPL_C_API PEAK_IPL_ChromaticAdapter_CalculateColorCorrectionMatrix(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE handle, uint32_t temperature, const float *colorCorrectionMatrixInput, float *colorCorrectionMatrixOutput)
Definition peak_ipl_dynamic_loader.h:5550

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Image_ConvertToBufferFromInterval
static 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)
Definition peak_ipl_dynamic_loader.h:4029

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Image_ConvertToBuffer
static 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)
Definition peak_ipl_dynamic_loader.h:3964

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_VideoWriter_Video_Open
static 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)
Definition peak_ipl_dynamic_loader.h:4744

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_PixelFormat_GetBayerPattern
static PEAK_IPL_C_API PEAK_IPL_PixelFormat_GetBayerPattern(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BAYER_PATTERN *pattern)
Definition peak_ipl_dynamic_loader.h:4640

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ImageConverter_ConvertFromInterval
static 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)
Definition peak_ipl_dynamic_loader.h:2651

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_GammaCorrector_SetDigitalBlack
static PEAK_IPL_C_API PEAK_IPL_GammaCorrector_SetDigitalBlack(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float *digitalBlackValue)
Definition peak_ipl_dynamic_loader.h:3717

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ImageSharpness_GetSupportedPixelFormatList
static PEAK_IPL_C_API PEAK_IPL_ImageSharpness_GetSupportedPixelFormatList(PEAK_IPL_SHARPNESS_HANDLE handle, PEAK_IPL_PIXEL_FORMAT *pixelFormatList, size_t *pixelFormatListSize)
Definition peak_ipl_dynamic_loader.h:5108

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Image_Acquire
static PEAK_IPL_C_API PEAK_IPL_Image_Acquire(PEAK_IPL_IMAGE_HANDLE imageHandle)
Definition peak_ipl_dynamic_loader.h:3834

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Gain_GetMasterGainValue
static PEAK_IPL_C_API PEAK_IPL_Gain_GetMasterGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float *masterGainValue)
Definition peak_ipl_dynamic_loader.h:3392

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_VideoWriter_Encoder_GetOption
static 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)
Definition peak_ipl_dynamic_loader.h:4809

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Image_Crop
static 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)
Definition peak_ipl_dynamic_loader.h:4068

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Image_GetPixelPointer
static PEAK_IPL_C_API PEAK_IPL_Image_GetPixelPointer(PEAK_IPL_IMAGE_HANDLE imageHandle, size_t xPos, size_t yPos, uint8_t **pixelPointer)
Definition peak_ipl_dynamic_loader.h:3886

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ColorCorrector_Construct
static PEAK_IPL_C_API PEAK_IPL_ColorCorrector_Construct(PEAK_IPL_COLOR_CORRECTOR_HANDLE *colorCorrectorHandle)
Definition peak_ipl_dynamic_loader.h:2859

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_VideoWriter_Video_ResetFrameCounters
static PEAK_IPL_C_API PEAK_IPL_VideoWriter_Video_ResetFrameCounters(PEAK_IPL_VIDEO_HANDLE videoHandle)
Definition peak_ipl_dynamic_loader.h:4952

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_EdgeEnhancement_SetFactor
static PEAK_IPL_C_API PEAK_IPL_EdgeEnhancement_SetFactor(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle, uint32_t factor)
Definition peak_ipl_dynamic_loader.h:5264

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_EdgeEnhancement_GetFactorRange
static PEAK_IPL_C_API PEAK_IPL_EdgeEnhancement_GetFactorRange(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle, struct PEAK_IPL_RANGE *range)
Definition peak_ipl_dynamic_loader.h:5251

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_PixelLine_GetOffset
static PEAK_IPL_C_API PEAK_IPL_PixelLine_GetOffset(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle, size_t *offset)
Definition peak_ipl_dynamic_loader.h:4419

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_PixelFormat_IsYUV
static PEAK_IPL_C_API PEAK_IPL_PixelFormat_IsYUV(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 *isYUV)
Definition peak_ipl_dynamic_loader.h:4601

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_VideoWriter_Container_SetOption
static 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)
Definition peak_ipl_dynamic_loader.h:4848

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_GammaCorrector_Construct
static PEAK_IPL_C_API PEAK_IPL_GammaCorrector_Construct(PEAK_IPL_GAMMA_CORRECTOR_HANDLE *gammaCorrectorHandle)
Definition peak_ipl_dynamic_loader.h:3639

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ColorCorrector_GetSaturationMax
static PEAK_IPL_C_API PEAK_IPL_ColorCorrector_GetSaturationMax(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, float *saturationMax)
Definition peak_ipl_dynamic_loader.h:2989

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Gain_GetBlueGainMin
static PEAK_IPL_C_API PEAK_IPL_Gain_GetBlueGainMin(PEAK_IPL_GAIN_HANDLE gainHandle, float *blueGainMin)
Definition peak_ipl_dynamic_loader.h:3574

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Histogram_GetBinsForChannel
static PEAK_IPL_C_API PEAK_IPL_Histogram_GetBinsForChannel(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle, size_t channelIndex, uint64_t *bins, size_t *binsSize)
Definition peak_ipl_dynamic_loader.h:4341

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Library_GetLastError
static PEAK_IPL_C_API PEAK_IPL_Library_GetLastError(PEAK_IPL_RETURN_CODE *lastErrorCode, char *lastErrorDescription, size_t *lastErrorDescriptionSize)
Definition peak_ipl_dynamic_loader.h:2508

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_Image_GetByteCount
static PEAK_IPL_C_API PEAK_IPL_Image_GetByteCount(PEAK_IPL_IMAGE_HANDLE imageHandle, size_t *byteCount)
Definition peak_ipl_dynamic_loader.h:3899

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_VideoWriter_GetSupportedEncodersForAContainer
static PEAK_IPL_C_API PEAK_IPL_VideoWriter_GetSupportedEncodersForAContainer(PEAK_IPL_VIDEO_CONTAINER container, PEAK_IPL_VIDEO_ENCODER *encoders, size_t *size)
Definition peak_ipl_dynamic_loader.h:4835

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ColorCorrector_SetColorCorrectionFactors
static PEAK_IPL_C_API PEAK_IPL_ColorCorrector_SetColorCorrectionFactors(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, float *colorCorrectorFactors)
Definition peak_ipl_dynamic_loader.h:2885

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_GammaCorrector_GetGammaCorrectionValue
static PEAK_IPL_C_API PEAK_IPL_GammaCorrector_GetGammaCorrectionValue(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float *gammaValue)
Definition peak_ipl_dynamic_loader.h:3678

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_PixelLine_GetPixelFormat
static PEAK_IPL_C_API PEAK_IPL_PixelLine_GetPixelFormat(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle, PEAK_IPL_PIXEL_FORMAT *pixelFormat)
Definition peak_ipl_dynamic_loader.h:4393

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_PixelLine_Construct
static 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)
Definition peak_ipl_dynamic_loader.h:4367

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_ImageConverter_GetConversionMode
static PEAK_IPL_C_API PEAK_IPL_ImageConverter_GetConversionMode(PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle, PEAK_IPL_CONVERSION_MODE *conversionMode)
Definition peak_ipl_dynamic_loader.h:2560

peak::ipl::dynamic::DynamicLoader::PEAK_IPL_EdgeEnhancement_Acquire
static PEAK_IPL_C_API PEAK_IPL_EdgeEnhancement_Acquire(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle)
Definition peak_ipl_dynamic_loader.h:5199

peak::ipl::dynamic::LoadLibraryException
Definition peak_ipl_dynamic_loader.h:288

peak::ipl::container
Definition peak_ipl_video_writer.hpp:249

peak::ipl::dynamic
Definition peak_ipl_dynamic_loader.h:39

peak::ipl::dynamic::dyn_PEAK_IPL_Gain_ProcessInPlace
PEAK_IPL_C_API(* dyn_PEAK_IPL_Gain_ProcessInPlace)(PEAK_IPL_GAIN_HANDLE gainHandle, PEAK_IPL_IMAGE_HANDLE imageHandle)
Definition peak_ipl_dynamic_loader.h:135

peak::ipl::dynamic::dyn_PEAK_IPL_EdgeEnhancement_GetFactor
PEAK_IPL_C_API(* dyn_PEAK_IPL_EdgeEnhancement_GetFactor)(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle, uint32_t *factor)
Definition peak_ipl_dynamic_loader.h:263

peak::ipl::dynamic::dyn_PEAK_IPL_ImageConverter_Construct
PEAK_IPL_C_API(* dyn_PEAK_IPL_ImageConverter_Construct)(PEAK_IPL_IMAGE_CONVERTER_HANDLE *imageConverterHandle)
Definition peak_ipl_dynamic_loader.h:51

peak::ipl::dynamic::dyn_PEAK_IPL_Library_SetMaxConcurrentThreads
PEAK_IPL_C_API(* dyn_PEAK_IPL_Library_SetMaxConcurrentThreads)(size_t concurrentThreads)
Definition peak_ipl_dynamic_loader.h:45

peak::ipl::dynamic::dyn_PEAK_IPL_GammaCorrector_GetDigitalBlackMin
PEAK_IPL_C_API(* dyn_PEAK_IPL_GammaCorrector_GetDigitalBlackMin)(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float *digitalBlackMin)
Definition peak_ipl_dynamic_loader.h:146

peak::ipl::dynamic::dyn_PEAK_IPL_GammaCorrector_SetGammaCorrectionValue
PEAK_IPL_C_API(* dyn_PEAK_IPL_GammaCorrector_SetGammaCorrectionValue)(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float *gammaValue)
Definition peak_ipl_dynamic_loader.h:139

peak::ipl::dynamic::dyn_PEAK_IPL_VideoWriter_Video_ResetFrameCounters
PEAK_IPL_C_API(* dyn_PEAK_IPL_VideoWriter_Video_ResetFrameCounters)(PEAK_IPL_VIDEO_HANDLE videoHandle)
Definition peak_ipl_dynamic_loader.h:238

peak::ipl::dynamic::dyn_PEAK_IPL_Library_GetMaxConcurrentThreads
PEAK_IPL_C_API(* dyn_PEAK_IPL_Library_GetMaxConcurrentThreads)(size_t *concurrentThreads)
Definition peak_ipl_dynamic_loader.h:44

peak::ipl::dynamic::dyn_PEAK_IPL_Histogram_GetPixelCountForChannel
PEAK_IPL_C_API(* dyn_PEAK_IPL_Histogram_GetPixelCountForChannel)(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle, size_t channelIndex, uint64_t *pixelCount)
Definition peak_ipl_dynamic_loader.h:190

peak::ipl::dynamic::dyn_PEAK_IPL_Image_Construct
PEAK_IPL_C_API(* dyn_PEAK_IPL_Image_Construct)(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t width, size_t height, PEAK_IPL_IMAGE_HANDLE *imageHandle)
Definition peak_ipl_dynamic_loader.h:151

peak::ipl::dynamic::dyn_PEAK_IPL_Image_Destruct
PEAK_IPL_C_API(* dyn_PEAK_IPL_Image_Destruct)(PEAK_IPL_IMAGE_HANDLE imageHandle)
Definition peak_ipl_dynamic_loader.h:171

peak::ipl::dynamic::dyn_PEAK_IPL_Decimation_IsPixelformatSupported
PEAK_IPL_C_API(* dyn_PEAK_IPL_Decimation_IsPixelformatSupported)(PEAK_IPL_DECIMATION_HANDLE decimationHandle, PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 *isPixelFormatSupported)
Definition peak_ipl_dynamic_loader.h:112

peak::ipl::dynamic::dyn_PEAK_IPL_ColorCorrector_SetColorCorrectionFactors
PEAK_IPL_C_API(* dyn_PEAK_IPL_ColorCorrector_SetColorCorrectionFactors)(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, float *colorCorrectorFactors)
Definition peak_ipl_dynamic_loader.h:79

peak::ipl::dynamic::dyn_PEAK_IPL_ImageTransformer_MirrorLeftRightInPlace
PEAK_IPL_C_API(* dyn_PEAK_IPL_ImageTransformer_MirrorLeftRightInPlace)(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle, PEAK_IPL_IMAGE_HANDLE imageHandle)
Definition peak_ipl_dynamic_loader.h:180

peak::ipl::dynamic::dyn_PEAK_IPL_Gain_GetIsPixelFormatSupported
PEAK_IPL_C_API(* dyn_PEAK_IPL_Gain_GetIsPixelFormatSupported)(PEAK_IPL_GAIN_HANDLE gainHandle, PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 *isPixelFormatSupported)
Definition peak_ipl_dynamic_loader.h:133

peak::ipl::dynamic::dyn_PEAK_IPL_EdgeEnhancement_SetFactor
PEAK_IPL_C_API(* dyn_PEAK_IPL_EdgeEnhancement_SetFactor)(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle, uint32_t factor)
Definition peak_ipl_dynamic_loader.h:262

peak::ipl::dynamic::dyn_PEAK_IPL_Binning_GetBinningMin
PEAK_IPL_C_API(* dyn_PEAK_IPL_Binning_GetBinningMin)(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t *binningMin)
Definition peak_ipl_dynamic_loader.h:95

peak::ipl::dynamic::dyn_PEAK_IPL_PixelFormat_GetEndianness
PEAK_IPL_C_API(* dyn_PEAK_IPL_PixelFormat_GetEndianness)(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_ENDIANNESS *endianness)
Definition peak_ipl_dynamic_loader.h:207

peak::ipl::dynamic::dyn_PEAK_IPL_Decimation_Destruct
PEAK_IPL_C_API(* dyn_PEAK_IPL_Decimation_Destruct)(PEAK_IPL_DECIMATION_HANDLE decimationHandle)
Definition peak_ipl_dynamic_loader.h:114

peak::ipl::dynamic::dyn_PEAK_IPL_VideoWriter_Video_GetFileSize
PEAK_IPL_C_API(* dyn_PEAK_IPL_VideoWriter_Video_GetFileSize)(PEAK_IPL_VIDEO_HANDLE videoHandle, uint64_t *fileSize)
Definition peak_ipl_dynamic_loader.h:237

peak::ipl::dynamic::dyn_PEAK_IPL_Lut_Acquire
PEAK_IPL_C_API(* dyn_PEAK_IPL_Lut_Acquire)(PEAK_IPL_LUT_HANDLE lutHandle)
Definition peak_ipl_dynamic_loader.h:267

peak::ipl::dynamic::dyn_PEAK_IPL_VideoWriter_Container_OptionRange
PEAK_IPL_C_API(* dyn_PEAK_IPL_VideoWriter_Container_OptionRange)(PEAK_IPL_VIDEO_HANDLE videoHandle, PEAK_IPL_VIDEO_ENCODER_OPTION option, void *min, void *max, void *inc)
Definition peak_ipl_dynamic_loader.h:232

peak::ipl::dynamic::dyn_PEAK_IPL_EdgeEnhancement_ProcessInPlace
PEAK_IPL_C_API(* dyn_PEAK_IPL_EdgeEnhancement_ProcessInPlace)(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle, PEAK_IPL_IMAGE_HANDLE imageHandle)
Definition peak_ipl_dynamic_loader.h:259

peak::ipl::dynamic::dyn_PEAK_IPL_Image_GetWidth
PEAK_IPL_C_API(* dyn_PEAK_IPL_Image_GetWidth)(PEAK_IPL_IMAGE_HANDLE imageHandle, size_t *width)
Definition peak_ipl_dynamic_loader.h:154

peak::ipl::dynamic::dyn_PEAK_IPL_VideoWriter_Queue_GetRange
PEAK_IPL_C_API(* dyn_PEAK_IPL_VideoWriter_Queue_GetRange)(PEAK_IPL_VIDEO_HANDLE videoHandle, int32_t *minSize, int32_t *maxSize)
Definition peak_ipl_dynamic_loader.h:241

peak::ipl::dynamic::dyn_PEAK_IPL_PixelLine_GetNumChannels
PEAK_IPL_C_API(* dyn_PEAK_IPL_PixelLine_GetNumChannels)(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle, size_t *numChannels)
Definition peak_ipl_dynamic_loader.h:198

peak::ipl::dynamic::dyn_PEAK_IPL_ImageWriter_WriteAsRAW
PEAK_IPL_C_API(* dyn_PEAK_IPL_ImageWriter_WriteAsRAW)(PEAK_IPL_IMAGE_HANDLE inputImageHandle, const char *filePath, size_t filePathSize)
Definition peak_ipl_dynamic_loader.h:215

peak::ipl::dynamic::dyn_PEAK_IPL_AdaptiveHotpixelCorrector_SetGainFactorPercent
PEAK_IPL_C_API(* dyn_PEAK_IPL_AdaptiveHotpixelCorrector_SetGainFactorPercent)(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, uint32_t gainFactorPercent)
Definition peak_ipl_dynamic_loader.h:68

peak::ipl::dynamic::dyn_PEAK_IPL_ImageSharpness_Acquire
PEAK_IPL_C_API(* dyn_PEAK_IPL_ImageSharpness_Acquire)(PEAK_IPL_SHARPNESS_HANDLE handle)
Definition peak_ipl_dynamic_loader.h:246

peak::ipl::dynamic::dyn_PEAK_IPL_Decimation_GetDecimationMax
PEAK_IPL_C_API(* dyn_PEAK_IPL_Decimation_GetDecimationMax)(PEAK_IPL_DECIMATION_HANDLE decimationHandle, uint8_t *decimationMax)
Definition peak_ipl_dynamic_loader.h:110

peak::ipl::dynamic::dyn_PEAK_IPL_ImageSharpness_GetROIs
PEAK_IPL_C_API(* dyn_PEAK_IPL_ImageSharpness_GetROIs)(PEAK_IPL_SHARPNESS_HANDLE handle, struct PEAK_IPL_SHARPNESS_ROI *roiList, size_t *roiListSize)
Definition peak_ipl_dynamic_loader.h:255

peak::ipl::dynamic::dyn_PEAK_IPL_Library_GetVersionMinor
PEAK_IPL_C_API(* dyn_PEAK_IPL_Library_GetVersionMinor)(uint32_t *libraryVersionMinor)
Definition peak_ipl_dynamic_loader.h:42

peak::ipl::dynamic::dyn_PEAK_IPL_Image_SetTimestamp
PEAK_IPL_C_API(* dyn_PEAK_IPL_Image_SetTimestamp)(PEAK_IPL_IMAGE_HANDLE imageHandle, uint64_t timestamp_ns)
Definition peak_ipl_dynamic_loader.h:174

peak::ipl::dynamic::dyn_PEAK_IPL_ChromaticAdapter_GetTemperatureRange
PEAK_IPL_C_API(* dyn_PEAK_IPL_ChromaticAdapter_GetTemperatureRange)(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE handle, uint32_t *minTemperature, uint32_t *maxTemperature, uint32_t *incTemperature)
Definition peak_ipl_dynamic_loader.h:285

peak::ipl::dynamic::dyn_PEAK_IPL_PixelFormat_IsPacked
PEAK_IPL_C_API(* dyn_PEAK_IPL_PixelFormat_IsPacked)(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 *isPacked)
Definition peak_ipl_dynamic_loader.h:209

peak::ipl::dynamic::dyn_PEAK_IPL_Image_GetPixelFormat
PEAK_IPL_C_API(* dyn_PEAK_IPL_Image_GetPixelFormat)(PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_PIXEL_FORMAT *pixelFormat)
Definition peak_ipl_dynamic_loader.h:158

peak::ipl::dynamic::dyn_PEAK_IPL_PixelFormat_GetMaximumValuePerChannel
PEAK_IPL_C_API(* dyn_PEAK_IPL_PixelFormat_GetMaximumValuePerChannel)(PEAK_IPL_PIXEL_FORMAT pixelFormat, uint32_t *channelMaximumValue)
Definition peak_ipl_dynamic_loader.h:204

peak::ipl::dynamic::dyn_PEAK_IPL_Gain_GetGreenGainValue
PEAK_IPL_C_API(* dyn_PEAK_IPL_Gain_GetGreenGainValue)(PEAK_IPL_GAIN_HANDLE gainHandle, float *greenGainValue)
Definition peak_ipl_dynamic_loader.h:126

peak::ipl::dynamic::dyn_PEAK_IPL_Histogram_GetPixelSumForChannel
PEAK_IPL_C_API(* dyn_PEAK_IPL_Histogram_GetPixelSumForChannel)(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle, size_t channelIndex, uint64_t *pixelSum)
Definition peak_ipl_dynamic_loader.h:189

peak::ipl::dynamic::dyn_PEAK_IPL_GammaCorrector_SetDigitalBlack
PEAK_IPL_C_API(* dyn_PEAK_IPL_GammaCorrector_SetDigitalBlack)(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float *digitalBlackValue)
Definition peak_ipl_dynamic_loader.h:143

peak::ipl::dynamic::dyn_PEAK_IPL_Image_ConvertToWithFactorAndOffset
PEAK_IPL_C_API(* dyn_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)
Definition peak_ipl_dynamic_loader.h:164

peak::ipl::dynamic::dyn_PEAK_IPL_ImageTransformer_MirrorUpDownLeftRightInPlace
PEAK_IPL_C_API(* dyn_PEAK_IPL_ImageTransformer_MirrorUpDownLeftRightInPlace)(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle, PEAK_IPL_IMAGE_HANDLE imageHandle)
Definition peak_ipl_dynamic_loader.h:181

peak::ipl::dynamic::dyn_PEAK_IPL_PixelLine_Destruct
PEAK_IPL_C_API(* dyn_PEAK_IPL_PixelLine_Destruct)(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle)
Definition peak_ipl_dynamic_loader.h:200

peak::ipl::dynamic::dyn_PEAK_IPL_AdaptiveHotpixelCorrector_Detect
PEAK_IPL_C_API(* dyn_PEAK_IPL_AdaptiveHotpixelCorrector_Detect)(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_IMAGE_HANDLE inputImageHandle)
Definition peak_ipl_dynamic_loader.h:70

peak::ipl::dynamic::dyn_PEAK_IPL_Image_GetHeight
PEAK_IPL_C_API(* dyn_PEAK_IPL_Image_GetHeight)(PEAK_IPL_IMAGE_HANDLE imageHandle, size_t *height)
Definition peak_ipl_dynamic_loader.h:155

peak::ipl::dynamic::dyn_PEAK_IPL_Image_Scale
PEAK_IPL_C_API(* dyn_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)
Definition peak_ipl_dynamic_loader.h:168

peak::ipl::dynamic::dyn_PEAK_IPL_PixelLine_GetOffset
PEAK_IPL_C_API(* dyn_PEAK_IPL_PixelLine_GetOffset)(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle, size_t *offset)
Definition peak_ipl_dynamic_loader.h:197

peak::ipl::dynamic::dyn_PEAK_IPL_Decimation_SetDecimationX
PEAK_IPL_C_API(* dyn_PEAK_IPL_Decimation_SetDecimationX)(PEAK_IPL_DECIMATION_HANDLE decimationHandle, uint8_t *decimationXValue)
Definition peak_ipl_dynamic_loader.h:105

peak::ipl::dynamic::dyn_PEAK_IPL_ImageWriter_Write
PEAK_IPL_C_API(* dyn_PEAK_IPL_ImageWriter_Write)(PEAK_IPL_IMAGE_HANDLE inputImageHandle, const char *filePath, size_t filePathSize)
Definition peak_ipl_dynamic_loader.h:219

peak::ipl::dynamic::dyn_PEAK_IPL_Binning_SetBinningY
PEAK_IPL_C_API(* dyn_PEAK_IPL_Binning_SetBinningY)(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t *binningYValue)
Definition peak_ipl_dynamic_loader.h:93

peak::ipl::dynamic::dyn_PEAK_IPL_ImageSharpness_SetAlgorithm
PEAK_IPL_C_API(* dyn_PEAK_IPL_ImageSharpness_SetAlgorithm)(PEAK_IPL_SHARPNESS_HANDLE handle, PEAK_IPL_SHARPNESS_ALGORITHM algorithm)
Definition peak_ipl_dynamic_loader.h:251

peak::ipl::dynamic::dyn_PEAK_IPL_EdgeEnhancement_Process
PEAK_IPL_C_API(* dyn_PEAK_IPL_EdgeEnhancement_Process)(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE *outputImageHandle)
Definition peak_ipl_dynamic_loader.h:260

peak::ipl::dynamic::dyn_PEAK_IPL_PixelLine_Construct
PEAK_IPL_C_API(* dyn_PEAK_IPL_PixelLine_Construct)(PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_ORIENTATION orientation, size_t offset, PEAK_IPL_PIXEL_LINE_HANDLE *pixelLineHandle)
Definition peak_ipl_dynamic_loader.h:193

peak::ipl::dynamic::dyn_PEAK_IPL_Gain_Destruct
PEAK_IPL_C_API(* dyn_PEAK_IPL_Gain_Destruct)(PEAK_IPL_GAIN_HANDLE gainHandle)
Definition peak_ipl_dynamic_loader.h:136

peak::ipl::dynamic::dyn_PEAK_IPL_Library_GetMultiThreadingEnabled
PEAK_IPL_C_API(* dyn_PEAK_IPL_Library_GetMultiThreadingEnabled)(PEAK_IPL_BOOL8 *enabled)
Definition peak_ipl_dynamic_loader.h:46

peak::ipl::dynamic::dyn_PEAK_IPL_Image_GetPixelPointer
PEAK_IPL_C_API(* dyn_PEAK_IPL_Image_GetPixelPointer)(PEAK_IPL_IMAGE_HANDLE imageHandle, size_t xPos, size_t yPos, uint8_t **pixelPointer)
Definition peak_ipl_dynamic_loader.h:156

peak::ipl::dynamic::dyn_PEAK_IPL_GammaCorrector_Acquire
PEAK_IPL_C_API(* dyn_PEAK_IPL_GammaCorrector_Acquire)(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle)
Definition peak_ipl_dynamic_loader.h:138

peak::ipl::dynamic::dyn_PEAK_IPL_ImageWriter_WriteAsJPG
PEAK_IPL_C_API(* dyn_PEAK_IPL_ImageWriter_WriteAsJPG)(PEAK_IPL_IMAGE_HANDLE inputImageHandle, uint32_t quality, const char *filePath, size_t filePathSize)
Definition peak_ipl_dynamic_loader.h:218

peak::ipl::dynamic::dyn_PEAK_IPL_VideoWriter_Encoder_GetOption
PEAK_IPL_C_API(* dyn_PEAK_IPL_VideoWriter_Encoder_GetOption)(PEAK_IPL_VIDEO_HANDLE videoHandle, PEAK_IPL_VIDEO_ENCODER_OPTION option, void *value, size_t count, size_t *outCount)
Definition peak_ipl_dynamic_loader.h:227

peak::ipl::dynamic::dyn_PEAK_IPL_AdaptiveHotpixelCorrector_Correct
PEAK_IPL_C_API(* dyn_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)
Definition peak_ipl_dynamic_loader.h:72

peak::ipl::dynamic::dyn_PEAK_IPL_Library_GetSIMDEnabled
PEAK_IPL_C_API(* dyn_PEAK_IPL_Library_GetSIMDEnabled)(PEAK_IPL_BOOL8 *enabled)
Definition peak_ipl_dynamic_loader.h:48

peak::ipl::dynamic::dyn_PEAK_IPL_Gain_Process
PEAK_IPL_C_API(* dyn_PEAK_IPL_Gain_Process)(PEAK_IPL_GAIN_HANDLE gainHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE *outputImageHandle)
Definition peak_ipl_dynamic_loader.h:134

peak::ipl::dynamic::dyn_PEAK_IPL_VideoWriter_Video_WaitUntilFrameDone
PEAK_IPL_C_API(* dyn_PEAK_IPL_VideoWriter_Video_WaitUntilFrameDone)(PEAK_IPL_VIDEO_HANDLE videoHandle, int32_t timeout_ms)
Definition peak_ipl_dynamic_loader.h:243

peak::ipl::dynamic::dyn_PEAK_IPL_Binning_Process
PEAK_IPL_C_API(* dyn_PEAK_IPL_Binning_Process)(PEAK_IPL_BINNING_HANDLE binningHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE *outputImageHandle)
Definition peak_ipl_dynamic_loader.h:101

peak::ipl::dynamic::dyn_PEAK_IPL_ImageSharpness_GetIsPixelFormatSupported
PEAK_IPL_C_API(* dyn_PEAK_IPL_ImageSharpness_GetIsPixelFormatSupported)(PEAK_IPL_SHARPNESS_HANDLE handle, PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 *isPixelFormatSupported)
Definition peak_ipl_dynamic_loader.h:249

peak::ipl::dynamic::dyn_PEAK_IPL_PixelLine_GetPixelFormat
PEAK_IPL_C_API(* dyn_PEAK_IPL_PixelLine_GetPixelFormat)(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle, PEAK_IPL_PIXEL_FORMAT *pixelFormat)
Definition peak_ipl_dynamic_loader.h:195

peak::ipl::dynamic::dyn_PEAK_IPL_ImageSharpness_Destruct
PEAK_IPL_C_API(* dyn_PEAK_IPL_ImageSharpness_Destruct)(PEAK_IPL_SHARPNESS_HANDLE handle)
Definition peak_ipl_dynamic_loader.h:247

peak::ipl::dynamic::dyn_PEAK_IPL_ChromaticAdapter_Destruct
PEAK_IPL_C_API(* dyn_PEAK_IPL_ChromaticAdapter_Destruct)(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE handle)
Definition peak_ipl_dynamic_loader.h:279

peak::ipl::dynamic::dyn_PEAK_IPL_ColorCorrector_Construct
PEAK_IPL_C_API(* dyn_PEAK_IPL_ColorCorrector_Construct)(PEAK_IPL_COLOR_CORRECTOR_HANDLE *colorCorrectorHandle)
Definition peak_ipl_dynamic_loader.h:77

peak::ipl::dynamic::dyn_PEAK_IPL_EdgeEnhancement_Destruct
PEAK_IPL_C_API(* dyn_PEAK_IPL_EdgeEnhancement_Destruct)(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle)
Definition peak_ipl_dynamic_loader.h:258

peak::ipl::dynamic::dyn_PEAK_IPL_ChromaticAdapter_CalculateColorCorrectionMatrix
PEAK_IPL_C_API(* dyn_PEAK_IPL_ChromaticAdapter_CalculateColorCorrectionMatrix)(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE handle, uint32_t temperature, const float *colorCorrectionMatrixInput, float *colorCorrectionMatrixOutput)
Definition peak_ipl_dynamic_loader.h:284

peak::ipl::dynamic::dyn_PEAK_IPL_AdaptiveHotpixelCorrector_Destruct
PEAK_IPL_C_API(* dyn_PEAK_IPL_AdaptiveHotpixelCorrector_Destruct)(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle)
Definition peak_ipl_dynamic_loader.h:76

peak::ipl::dynamic::dyn_PEAK_IPL_Gain_GetMasterGainMin
PEAK_IPL_C_API(* dyn_PEAK_IPL_Gain_GetMasterGainMin)(PEAK_IPL_GAIN_HANDLE gainHandle, float *masterGainMin)
Definition peak_ipl_dynamic_loader.h:120

peak::ipl::dynamic::dyn_PEAK_IPL_Image_ScaleInto
PEAK_IPL_C_API(* dyn_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)
Definition peak_ipl_dynamic_loader.h:169

peak::ipl::dynamic::dyn_PEAK_IPL_AdaptiveHotpixelCorrector_Construct
PEAK_IPL_C_API(* dyn_PEAK_IPL_AdaptiveHotpixelCorrector_Construct)(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE *adaptiveHotpixelCorrectorHandle)
Definition peak_ipl_dynamic_loader.h:64

peak::ipl::dynamic::dyn_PEAK_IPL_PixelFormat_CalculateStorageSizeOfPixels
PEAK_IPL_C_API(* dyn_PEAK_IPL_PixelFormat_CalculateStorageSizeOfPixels)(PEAK_IPL_PIXEL_FORMAT pixelFormat, uint64_t numPixels, uint64_t *size)
Definition peak_ipl_dynamic_loader.h:208

peak::ipl::dynamic::dyn_PEAK_IPL_Gain_GetBlueGainMin
PEAK_IPL_C_API(* dyn_PEAK_IPL_Gain_GetBlueGainMin)(PEAK_IPL_GAIN_HANDLE gainHandle, float *blueGainMin)
Definition peak_ipl_dynamic_loader.h:132

peak::ipl::dynamic::dyn_PEAK_IPL_Lut_ProcessInPlace
PEAK_IPL_C_API(* dyn_PEAK_IPL_Lut_ProcessInPlace)(PEAK_IPL_LUT_HANDLE lutHandle, PEAK_IPL_IMAGE_HANDLE imageHandle)
Definition peak_ipl_dynamic_loader.h:275

peak::ipl::dynamic::dyn_PEAK_IPL_ImageTransformer_Construct
PEAK_IPL_C_API(* dyn_PEAK_IPL_ImageTransformer_Construct)(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE *imageTransformerHandle)
Definition peak_ipl_dynamic_loader.h:172

peak::ipl::dynamic::dyn_PEAK_IPL_EdgeEnhancement_GetDefaultFactor
PEAK_IPL_C_API(* dyn_PEAK_IPL_EdgeEnhancement_GetDefaultFactor)(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle, uint32_t *factor)
Definition peak_ipl_dynamic_loader.h:264

peak::ipl::dynamic::dyn_PEAK_IPL_VideoWriter_Video_Open
PEAK_IPL_C_API(* dyn_PEAK_IPL_VideoWriter_Video_Open)(PEAK_IPL_VIDEO_HANDLE *videoHandle, const char *filePath, PEAK_IPL_VIDEO_CONTAINER container, PEAK_IPL_VIDEO_ENCODER encoder)
Definition peak_ipl_dynamic_loader.h:222

peak::ipl::dynamic::dyn_PEAK_IPL_Image_ConvertToWithFactor
PEAK_IPL_C_API(* dyn_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)
Definition peak_ipl_dynamic_loader.h:163

peak::ipl::dynamic::dyn_PEAK_IPL_Library_GetVersionSubminor
PEAK_IPL_C_API(* dyn_PEAK_IPL_Library_GetVersionSubminor)(uint32_t *libraryVersionSubminor)
Definition peak_ipl_dynamic_loader.h:43

peak::ipl::dynamic::dyn_PEAK_IPL_Gain_GetRedGainMax
PEAK_IPL_C_API(* dyn_PEAK_IPL_Gain_GetRedGainMax)(PEAK_IPL_GAIN_HANDLE gainHandle, float *redGainMax)
Definition peak_ipl_dynamic_loader.h:123

peak::ipl::dynamic::dyn_PEAK_IPL_Gain_GetMasterGainMax
PEAK_IPL_C_API(* dyn_PEAK_IPL_Gain_GetMasterGainMax)(PEAK_IPL_GAIN_HANDLE gainHandle, float *masterGainMax)
Definition peak_ipl_dynamic_loader.h:119

peak::ipl::dynamic::dyn_PEAK_IPL_VideoWriter_Encoder_GetSupportedPixelFormats
PEAK_IPL_C_API(* dyn_PEAK_IPL_VideoWriter_Encoder_GetSupportedPixelFormats)(PEAK_IPL_VIDEO_ENCODER encoder, PEAK_IPL_PIXEL_FORMAT *pixelFormatList, size_t *pixelFormatListSize)
Definition peak_ipl_dynamic_loader.h:234

peak::ipl::dynamic::dyn_PEAK_IPL_ImageConverter_GetConversionMode
PEAK_IPL_C_API(* dyn_PEAK_IPL_ImageConverter_GetConversionMode)(PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle, PEAK_IPL_CONVERSION_MODE *conversionMode)
Definition peak_ipl_dynamic_loader.h:54

peak::ipl::dynamic::dyn_PEAK_IPL_AdaptiveHotpixelCorrector_Acquire
PEAK_IPL_C_API(* dyn_PEAK_IPL_AdaptiveHotpixelCorrector_Acquire)(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle)
Definition peak_ipl_dynamic_loader.h:65

peak::ipl::dynamic::dyn_PEAK_IPL_Binning_IsPixelformatSupported
PEAK_IPL_C_API(* dyn_PEAK_IPL_Binning_IsPixelformatSupported)(PEAK_IPL_BINNING_HANDLE binningHandle, PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 *isPixelFormatSupported)
Definition peak_ipl_dynamic_loader.h:98

peak::ipl::dynamic::dyn_PEAK_IPL_ImageTransformer_Destruct
PEAK_IPL_C_API(* dyn_PEAK_IPL_ImageTransformer_Destruct)(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle)
Definition peak_ipl_dynamic_loader.h:184

peak::ipl::dynamic::dyn_PEAK_IPL_Image_ConvertTo
PEAK_IPL_C_API(* dyn_PEAK_IPL_Image_ConvertTo)(PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_PIXEL_FORMAT outputPixelFormat, PEAK_IPL_CONVERSION_MODE conversionMode, PEAK_IPL_IMAGE_HANDLE *outputImageHandle)
Definition peak_ipl_dynamic_loader.h:161

peak::ipl::dynamic::dyn_PEAK_IPL_Gain_GetMasterGainValue
PEAK_IPL_C_API(* dyn_PEAK_IPL_Gain_GetMasterGainValue)(PEAK_IPL_GAIN_HANDLE gainHandle, float *masterGainValue)
Definition peak_ipl_dynamic_loader.h:118

peak::ipl::dynamic::dyn_PEAK_IPL_ColorCorrector_GetSaturation
PEAK_IPL_C_API(* dyn_PEAK_IPL_ColorCorrector_GetSaturation)(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, float *saturation)
Definition peak_ipl_dynamic_loader.h:85

peak::ipl::dynamic::dyn_PEAK_IPL_AdaptiveHotpixelCorrector_CorrectAdaptive
PEAK_IPL_C_API(* dyn_PEAK_IPL_AdaptiveHotpixelCorrector_CorrectAdaptive)(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_IMAGE_HANDLE inputImageHandle, PEAK_IPL_IMAGE_HANDLE *outputImageHandle)
Definition peak_ipl_dynamic_loader.h:74

peak::ipl::dynamic::dyn_PEAK_IPL_GammaCorrector_Process
PEAK_IPL_C_API(* dyn_PEAK_IPL_GammaCorrector_Process)(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE *outputImageHandle)
Definition peak_ipl_dynamic_loader.h:148

peak::ipl::dynamic::dyn_PEAK_IPL_GammaCorrector_GetDigitalBlack
PEAK_IPL_C_API(* dyn_PEAK_IPL_GammaCorrector_GetDigitalBlack)(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float *digitalBlackValue)
Definition peak_ipl_dynamic_loader.h:144

peak::ipl::dynamic::dyn_PEAK_IPL_ImageConverter_SetConversionMode
PEAK_IPL_C_API(* dyn_PEAK_IPL_ImageConverter_SetConversionMode)(PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle, PEAK_IPL_CONVERSION_MODE conversionMode)
Definition peak_ipl_dynamic_loader.h:55

peak::ipl::dynamic::dyn_PEAK_IPL_Image_ConvertToFromInterval
PEAK_IPL_C_API(* dyn_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)
Definition peak_ipl_dynamic_loader.h:166

peak::ipl::dynamic::dyn_PEAK_IPL_Image_Clone
PEAK_IPL_C_API(* dyn_PEAK_IPL_Image_Clone)(PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE *outputImageHandle)
Definition peak_ipl_dynamic_loader.h:160

peak::ipl::dynamic::dyn_PEAK_IPL_ImageSharpness_Measure
PEAK_IPL_C_API(* dyn_PEAK_IPL_ImageSharpness_Measure)(PEAK_IPL_SHARPNESS_HANDLE handle, PEAK_IPL_IMAGE_HANDLE imageHandle, double *calculated_value)
Definition peak_ipl_dynamic_loader.h:248

peak::ipl::dynamic::dyn_PEAK_IPL_PixelLine_Acquire
PEAK_IPL_C_API(* dyn_PEAK_IPL_PixelLine_Acquire)(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle)
Definition peak_ipl_dynamic_loader.h:194

peak::ipl::dynamic::dyn_PEAK_IPL_GammaCorrector_GetGammaCorrectionMin
PEAK_IPL_C_API(* dyn_PEAK_IPL_GammaCorrector_GetGammaCorrectionMin)(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float *gammaMin)
Definition peak_ipl_dynamic_loader.h:142

peak::ipl::dynamic::dyn_PEAK_IPL_EdgeEnhancement_Acquire
PEAK_IPL_C_API(* dyn_PEAK_IPL_EdgeEnhancement_Acquire)(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle)
Definition peak_ipl_dynamic_loader.h:257

peak::ipl::dynamic::dyn_PEAK_IPL_GammaCorrector_Destruct
PEAK_IPL_C_API(* dyn_PEAK_IPL_GammaCorrector_Destruct)(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle)
Definition peak_ipl_dynamic_loader.h:150

peak::ipl::dynamic::dyn_PEAK_IPL_VideoWriter_Queue_SetSize
PEAK_IPL_C_API(* dyn_PEAK_IPL_VideoWriter_Queue_SetSize)(PEAK_IPL_VIDEO_HANDLE videoHandle, int32_t size)
Definition peak_ipl_dynamic_loader.h:239

peak::ipl::dynamic::dyn_PEAK_IPL_Gain_GetRedGainValue
PEAK_IPL_C_API(* dyn_PEAK_IPL_Gain_GetRedGainValue)(PEAK_IPL_GAIN_HANDLE gainHandle, float *redGainValue)
Definition peak_ipl_dynamic_loader.h:122

peak::ipl::dynamic::dyn_PEAK_IPL_PixelFormat_GetNumSignificantBitsPerChannel
PEAK_IPL_C_API(* dyn_PEAK_IPL_PixelFormat_GetNumSignificantBitsPerChannel)(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t *numSignificantBits)
Definition peak_ipl_dynamic_loader.h:202

peak::ipl::dynamic::dyn_PEAK_IPL_ChromaticAdapter_GetAdaptionAlgorithm
PEAK_IPL_C_API(* dyn_PEAK_IPL_ChromaticAdapter_GetAdaptionAlgorithm)(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE handle, PEAK_IPL_CHROMATIC_ADAPTER_ALGORITHM *algorithm)
Definition peak_ipl_dynamic_loader.h:282

peak::ipl::dynamic::dyn_PEAK_IPL_GammaCorrector_Construct
PEAK_IPL_C_API(* dyn_PEAK_IPL_GammaCorrector_Construct)(PEAK_IPL_GAMMA_CORRECTOR_HANDLE *gammaCorrectorHandle)
Definition peak_ipl_dynamic_loader.h:137

peak::ipl::dynamic::dyn_PEAK_IPL_ColorCorrector_GetSaturationMax
PEAK_IPL_C_API(* dyn_PEAK_IPL_ColorCorrector_GetSaturationMax)(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, float *saturationMax)
Definition peak_ipl_dynamic_loader.h:87

peak::ipl::dynamic::dyn_PEAK_IPL_Histogram_Acquire
PEAK_IPL_C_API(* dyn_PEAK_IPL_Histogram_Acquire)(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle)
Definition peak_ipl_dynamic_loader.h:186

peak::ipl::dynamic::dyn_PEAK_IPL_Histogram_GetBinsForChannel
PEAK_IPL_C_API(* dyn_PEAK_IPL_Histogram_GetBinsForChannel)(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle, size_t channelIndex, uint64_t *bins, size_t *binsSize)
Definition peak_ipl_dynamic_loader.h:191

peak::ipl::dynamic::dyn_PEAK_IPL_Decimation_GetDecimationMin
PEAK_IPL_C_API(* dyn_PEAK_IPL_Decimation_GetDecimationMin)(PEAK_IPL_DECIMATION_HANDLE decimationHandle, uint8_t *decimationMin)
Definition peak_ipl_dynamic_loader.h:109

peak::ipl::dynamic::dyn_PEAK_IPL_ImageTransformer_Acquire
PEAK_IPL_C_API(* dyn_PEAK_IPL_ImageTransformer_Acquire)(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle)
Definition peak_ipl_dynamic_loader.h:173

peak::ipl::dynamic::dyn_PEAK_IPL_Lut_GetAllLutValues
PEAK_IPL_C_API(* dyn_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)
Definition peak_ipl_dynamic_loader.h:270

peak::ipl::dynamic::dyn_PEAK_IPL_Binning_Construct
PEAK_IPL_C_API(* dyn_PEAK_IPL_Binning_Construct)(PEAK_IPL_BINNING_HANDLE *binningHandle)
Definition peak_ipl_dynamic_loader.h:89

peak::ipl::dynamic::dyn_PEAK_IPL_Library_SetSIMDEnabled
PEAK_IPL_C_API(* dyn_PEAK_IPL_Library_SetSIMDEnabled)(PEAK_IPL_BOOL8 enabled)
Definition peak_ipl_dynamic_loader.h:49

peak::ipl::dynamic::dyn_PEAK_IPL_PixelLine_GetValuesForChannel
PEAK_IPL_C_API(* dyn_PEAK_IPL_PixelLine_GetValuesForChannel)(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle, size_t channelIndex, uint32_t *values, size_t *valuesSize)
Definition peak_ipl_dynamic_loader.h:199

peak::ipl::dynamic::dyn_PEAK_IPL_Library_GetVersionMajor
PEAK_IPL_C_API(* dyn_PEAK_IPL_Library_GetVersionMajor)(uint32_t *libraryVersionMajor)
Definition peak_ipl_dynamic_loader.h:41

peak::ipl::dynamic::dyn_PEAK_IPL_ColorCorrector_SetSaturation
PEAK_IPL_C_API(* dyn_PEAK_IPL_ColorCorrector_SetSaturation)(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, float saturation)
Definition peak_ipl_dynamic_loader.h:88

peak::ipl::dynamic::dyn_PEAK_IPL_VideoWriter_GetSupportedEncodersForAContainer
PEAK_IPL_C_API(* dyn_PEAK_IPL_VideoWriter_GetSupportedEncodersForAContainer)(PEAK_IPL_VIDEO_CONTAINER container, PEAK_IPL_VIDEO_ENCODER *encoders, size_t *size)
Definition peak_ipl_dynamic_loader.h:229

peak::ipl::dynamic::dyn_PEAK_IPL_GammaCorrector_ProcessInPlace
PEAK_IPL_C_API(* dyn_PEAK_IPL_GammaCorrector_ProcessInPlace)(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, PEAK_IPL_IMAGE_HANDLE imageHandle)
Definition peak_ipl_dynamic_loader.h:149

peak::ipl::dynamic::dyn_PEAK_IPL_VideoWriter_Container_GetOption
PEAK_IPL_C_API(* dyn_PEAK_IPL_VideoWriter_Container_GetOption)(PEAK_IPL_VIDEO_HANDLE videoHandle, PEAK_IPL_VIDEO_ENCODER_OPTION option, void *value, size_t count, size_t *outCount)
Definition peak_ipl_dynamic_loader.h:231

peak::ipl::dynamic::dyn_PEAK_IPL_AdaptiveHotpixelCorrector_CorrectAdaptiveInPlace
PEAK_IPL_C_API(* dyn_PEAK_IPL_AdaptiveHotpixelCorrector_CorrectAdaptiveInPlace)(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_IMAGE_HANDLE inputImageHandle)
Definition peak_ipl_dynamic_loader.h:75

peak::ipl::dynamic::dyn_PEAK_IPL_ImageTransformer_MirrorLeftRight
PEAK_IPL_C_API(* dyn_PEAK_IPL_ImageTransformer_MirrorLeftRight)(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE *outputImageHandle)
Definition peak_ipl_dynamic_loader.h:177

peak::ipl::dynamic::dyn_PEAK_IPL_Gain_GetBlueGainMax
PEAK_IPL_C_API(* dyn_PEAK_IPL_Gain_GetBlueGainMax)(PEAK_IPL_GAIN_HANDLE gainHandle, float *blueGainMax)
Definition peak_ipl_dynamic_loader.h:131

peak::ipl::dynamic::dyn_PEAK_IPL_Lut_Destruct
PEAK_IPL_C_API(* dyn_PEAK_IPL_Lut_Destruct)(PEAK_IPL_LUT_HANDLE lutHandle)
Definition peak_ipl_dynamic_loader.h:276

peak::ipl::dynamic::dyn_PEAK_IPL_Histogram_Destruct
PEAK_IPL_C_API(* dyn_PEAK_IPL_Histogram_Destruct)(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle)
Definition peak_ipl_dynamic_loader.h:192

peak::ipl::dynamic::dyn_PEAK_IPL_ImageConverter_Convert
PEAK_IPL_C_API(* dyn_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)
Definition peak_ipl_dynamic_loader.h:57

peak::ipl::dynamic::dyn_PEAK_IPL_ImageConverter_ConvertFromInterval
PEAK_IPL_C_API(* dyn_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)
Definition peak_ipl_dynamic_loader.h:61

peak::ipl::dynamic::dyn_PEAK_IPL_PixelFormat_GetNumSignificantBitsPerPixel
PEAK_IPL_C_API(* dyn_PEAK_IPL_PixelFormat_GetNumSignificantBitsPerPixel)(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t *numSignificantBits)
Definition peak_ipl_dynamic_loader.h:205

peak::ipl::dynamic::dyn_PEAK_IPL_Gain_SetMasterGainValue
PEAK_IPL_C_API(* dyn_PEAK_IPL_Gain_SetMasterGainValue)(PEAK_IPL_GAIN_HANDLE gainHandle, float *masterGainValue)
Definition peak_ipl_dynamic_loader.h:117

peak::ipl::dynamic::dyn_PEAK_IPL_Lut_GetLutValue
PEAK_IPL_C_API(* dyn_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)
Definition peak_ipl_dynamic_loader.h:268

peak::ipl::dynamic::dyn_PEAK_IPL_Histogram_Construct
PEAK_IPL_C_API(* dyn_PEAK_IPL_Histogram_Construct)(PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_HISTOGRAM_HANDLE *histogramHandle)
Definition peak_ipl_dynamic_loader.h:185

peak::ipl::dynamic::dyn_PEAK_IPL_VideoWriter_Queue_GetQueued
PEAK_IPL_C_API(* dyn_PEAK_IPL_VideoWriter_Queue_GetQueued)(PEAK_IPL_VIDEO_HANDLE videoHandle, int32_t *queued)
Definition peak_ipl_dynamic_loader.h:242

peak::ipl::dynamic::dyn_PEAK_IPL_EdgeEnhancement_GetFactorRange
PEAK_IPL_C_API(* dyn_PEAK_IPL_EdgeEnhancement_GetFactorRange)(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle, struct PEAK_IPL_RANGE *range)
Definition peak_ipl_dynamic_loader.h:261

peak::ipl::dynamic::dyn_PEAK_IPL_EdgeEnhancement_IsPixelFormatSupported
PEAK_IPL_C_API(* dyn_PEAK_IPL_EdgeEnhancement_IsPixelFormatSupported)(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle, PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 *isPixelFormatSupported)
Definition peak_ipl_dynamic_loader.h:265

peak::ipl::dynamic::dyn_PEAK_IPL_GammaCorrector_GetGammaCorrectionMax
PEAK_IPL_C_API(* dyn_PEAK_IPL_GammaCorrector_GetGammaCorrectionMax)(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float *gammaMax)
Definition peak_ipl_dynamic_loader.h:141

peak::ipl::dynamic::dyn_PEAK_IPL_EdgeEnhancement_Construct
PEAK_IPL_C_API(* dyn_PEAK_IPL_EdgeEnhancement_Construct)(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE *handle)
Definition peak_ipl_dynamic_loader.h:256

peak::ipl::dynamic::dyn_PEAK_IPL_VideoWriter_Video_IsOpen
PEAK_IPL_C_API(* dyn_PEAK_IPL_VideoWriter_Video_IsOpen)(PEAK_IPL_VIDEO_HANDLE videoHandle, PEAK_IPL_BOOL8 *isOpen)
Definition peak_ipl_dynamic_loader.h:223

peak::ipl::dynamic::dyn_PEAK_IPL_Lut_SetLutValue
PEAK_IPL_C_API(* dyn_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)
Definition peak_ipl_dynamic_loader.h:269

peak::ipl::dynamic::dyn_PEAK_IPL_AdaptiveHotpixelCorrector_GetHotpixels
PEAK_IPL_C_API(* dyn_PEAK_IPL_AdaptiveHotpixelCorrector_GetHotpixels)(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, struct PEAK_IPL_POINT_2D *hotpixels, size_t *hotpixelsSize)
Definition peak_ipl_dynamic_loader.h:71

peak::ipl::dynamic::dyn_PEAK_IPL_Image_GetData
PEAK_IPL_C_API(* dyn_PEAK_IPL_Image_GetData)(PEAK_IPL_IMAGE_HANDLE imageHandle, uint8_t **data)
Definition peak_ipl_dynamic_loader.h:159

peak::ipl::dynamic::dyn_PEAK_IPL_ImageConverter_ConvertToBufferWithFactorAndOffset
PEAK_IPL_C_API(* dyn_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)
Definition peak_ipl_dynamic_loader.h:60

peak::ipl::dynamic::dyn_PEAK_IPL_Decimation_Construct
PEAK_IPL_C_API(* dyn_PEAK_IPL_Decimation_Construct)(PEAK_IPL_DECIMATION_HANDLE *decimationHandle)
Definition peak_ipl_dynamic_loader.h:103

peak::ipl::dynamic::dyn_PEAK_IPL_Gain_GetGreenGainMin
PEAK_IPL_C_API(* dyn_PEAK_IPL_Gain_GetGreenGainMin)(PEAK_IPL_GAIN_HANDLE gainHandle, float *greenGainMin)
Definition peak_ipl_dynamic_loader.h:128

peak::ipl::dynamic::dyn_PEAK_IPL_Histogram_GetNumChannels
PEAK_IPL_C_API(* dyn_PEAK_IPL_Histogram_GetNumChannels)(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle, size_t *numChannels)
Definition peak_ipl_dynamic_loader.h:188

peak::ipl::dynamic::dyn_PEAK_IPL_PixelFormat_GetNumChannels
PEAK_IPL_C_API(* dyn_PEAK_IPL_PixelFormat_GetNumChannels)(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t *numChannels)
Definition peak_ipl_dynamic_loader.h:201

peak::ipl::dynamic::dyn_PEAK_IPL_VideoWriter_Container_SetOption
PEAK_IPL_C_API(* dyn_PEAK_IPL_VideoWriter_Container_SetOption)(PEAK_IPL_VIDEO_HANDLE videoHandle, PEAK_IPL_VIDEO_CONTAINER_OPTION option, const void *value, size_t count)
Definition peak_ipl_dynamic_loader.h:230

peak::ipl::dynamic::dyn_PEAK_IPL_ImageConverter_Acquire
PEAK_IPL_C_API(* dyn_PEAK_IPL_ImageConverter_Acquire)(PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle)
Definition peak_ipl_dynamic_loader.h:52

peak::ipl::dynamic::dyn_PEAK_IPL_Binning_GetBinningY
PEAK_IPL_C_API(* dyn_PEAK_IPL_Binning_GetBinningY)(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t *binningYValue)
Definition peak_ipl_dynamic_loader.h:94

peak::ipl::dynamic::dyn_PEAK_IPL_Decimation_SetDecimationY
PEAK_IPL_C_API(* dyn_PEAK_IPL_Decimation_SetDecimationY)(PEAK_IPL_DECIMATION_HANDLE decimationHandle, uint8_t *decimationYValue)
Definition peak_ipl_dynamic_loader.h:107

peak::ipl::dynamic::dyn_PEAK_IPL_PixelFormat_IsFloat
PEAK_IPL_C_API(* dyn_PEAK_IPL_PixelFormat_IsFloat)(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 *isFloat)
Definition peak_ipl_dynamic_loader.h:213

peak::ipl::dynamic::dyn_PEAK_IPL_ImageSharpness_GetAlgorithm
PEAK_IPL_C_API(* dyn_PEAK_IPL_ImageSharpness_GetAlgorithm)(PEAK_IPL_SHARPNESS_HANDLE handle, PEAK_IPL_SHARPNESS_ALGORITHM *algorithm)
Definition peak_ipl_dynamic_loader.h:252

peak::ipl::dynamic::dyn_PEAK_IPL_PixelFormat_GetNumStorageBitsPerPixel
PEAK_IPL_C_API(* dyn_PEAK_IPL_PixelFormat_GetNumStorageBitsPerPixel)(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t *numStorageBits)
Definition peak_ipl_dynamic_loader.h:206

peak::ipl::dynamic::dyn_PEAK_IPL_VideoWriter_Video_WaitUntilQueueEmpty
PEAK_IPL_C_API(* dyn_PEAK_IPL_VideoWriter_Video_WaitUntilQueueEmpty)(PEAK_IPL_VIDEO_HANDLE videoHandle, int32_t timeout_ms)
Definition peak_ipl_dynamic_loader.h:244

peak::ipl::dynamic::dyn_PEAK_IPL_ChromaticAdapter_SetTargetColorSpace
PEAK_IPL_C_API(* dyn_PEAK_IPL_ChromaticAdapter_SetTargetColorSpace)(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE handle, PEAK_IPL_CHROMATIC_ADAPTER_COLOR_SPACE colorSpace)
Definition peak_ipl_dynamic_loader.h:281

peak::ipl::dynamic::dyn_PEAK_IPL_ImageConverter_ConvertToBufferFromInterval
PEAK_IPL_C_API(* dyn_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)
Definition peak_ipl_dynamic_loader.h:62

peak::ipl::dynamic::dyn_PEAK_IPL_ChromaticAdapter_Construct
PEAK_IPL_C_API(* dyn_PEAK_IPL_ChromaticAdapter_Construct)(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE *handle)
Definition peak_ipl_dynamic_loader.h:277

peak::ipl::dynamic::dyn_PEAK_IPL_ImageTransformer_Rotate
PEAK_IPL_C_API(* dyn_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)
Definition peak_ipl_dynamic_loader.h:182

peak::ipl::dynamic::dyn_PEAK_IPL_Decimation_ExpectedOutputSize
PEAK_IPL_C_API(* dyn_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)
Definition peak_ipl_dynamic_loader.h:111

peak::ipl::dynamic::dyn_PEAK_IPL_Binning_GetBinningMode
PEAK_IPL_C_API(* dyn_PEAK_IPL_Binning_GetBinningMode)(PEAK_IPL_BINNING_HANDLE binningHandle, PEAK_IPL_BINNINGMODE *mode)
Definition peak_ipl_dynamic_loader.h:100

peak::ipl::dynamic::import_function
void * import_function(void *module, const char *proc_name)
Definition peak_ipl_dynamic_loader.h:807

peak::ipl::dynamic::dyn_PEAK_IPL_Gain_SetBlueGainValue
PEAK_IPL_C_API(* dyn_PEAK_IPL_Gain_SetBlueGainValue)(PEAK_IPL_GAIN_HANDLE gainHandle, float *blueGainValue)
Definition peak_ipl_dynamic_loader.h:129

peak::ipl::dynamic::dyn_PEAK_IPL_Decimation_Acquire
PEAK_IPL_C_API(* dyn_PEAK_IPL_Decimation_Acquire)(PEAK_IPL_DECIMATION_HANDLE decimationHandle)
Definition peak_ipl_dynamic_loader.h:104

peak::ipl::dynamic::dyn_PEAK_IPL_Decimation_GetDecimationY
PEAK_IPL_C_API(* dyn_PEAK_IPL_Decimation_GetDecimationY)(PEAK_IPL_DECIMATION_HANDLE decimationHandle, uint8_t *decimationYValue)
Definition peak_ipl_dynamic_loader.h:108

peak::ipl::dynamic::dyn_PEAK_IPL_Image_ConstructFromBuffer
PEAK_IPL_C_API(* dyn_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)
Definition peak_ipl_dynamic_loader.h:153

peak::ipl::dynamic::dyn_PEAK_IPL_Binning_Acquire
PEAK_IPL_C_API(* dyn_PEAK_IPL_Binning_Acquire)(PEAK_IPL_BINNING_HANDLE binningHandle)
Definition peak_ipl_dynamic_loader.h:90

peak::ipl::dynamic::dyn_PEAK_IPL_Gain_SetGreenGainValue
PEAK_IPL_C_API(* dyn_PEAK_IPL_Gain_SetGreenGainValue)(PEAK_IPL_GAIN_HANDLE gainHandle, float *greenGainValue)
Definition peak_ipl_dynamic_loader.h:125

peak::ipl::dynamic::dyn_PEAK_IPL_Gain_Acquire
PEAK_IPL_C_API(* dyn_PEAK_IPL_Gain_Acquire)(PEAK_IPL_GAIN_HANDLE gainHandle)
Definition peak_ipl_dynamic_loader.h:116

peak::ipl::dynamic::dyn_PEAK_IPL_PixelFormat_GetBayerPattern
PEAK_IPL_C_API(* dyn_PEAK_IPL_PixelFormat_GetBayerPattern)(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BAYER_PATTERN *pattern)
Definition peak_ipl_dynamic_loader.h:214

peak::ipl::dynamic::dyn_PEAK_IPL_Binning_SetBinningMode
PEAK_IPL_C_API(* dyn_PEAK_IPL_Binning_SetBinningMode)(PEAK_IPL_BINNING_HANDLE binningHandle, PEAK_IPL_BINNINGMODE *mode)
Definition peak_ipl_dynamic_loader.h:99

peak::ipl::dynamic::dyn_PEAK_IPL_GammaCorrector_GetGammaCorrectionValue
PEAK_IPL_C_API(* dyn_PEAK_IPL_GammaCorrector_GetGammaCorrectionValue)(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float *gammaValue)
Definition peak_ipl_dynamic_loader.h:140

peak::ipl::dynamic::dyn_PEAK_IPL_ChromaticAdapter_SetAdaptionAlgorithm
PEAK_IPL_C_API(* dyn_PEAK_IPL_ChromaticAdapter_SetAdaptionAlgorithm)(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE handle, PEAK_IPL_CHROMATIC_ADAPTER_ALGORITHM model)
Definition peak_ipl_dynamic_loader.h:283

peak::ipl::dynamic::dyn_PEAK_IPL_Image_Acquire
PEAK_IPL_C_API(* dyn_PEAK_IPL_Image_Acquire)(PEAK_IPL_IMAGE_HANDLE imageHandle)
Definition peak_ipl_dynamic_loader.h:152

peak::ipl::dynamic::dyn_PEAK_IPL_Binning_GetBinningX
PEAK_IPL_C_API(* dyn_PEAK_IPL_Binning_GetBinningX)(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t *binningXValue)
Definition peak_ipl_dynamic_loader.h:92

peak::ipl::dynamic::dyn_PEAK_IPL_Gain_Construct
PEAK_IPL_C_API(* dyn_PEAK_IPL_Gain_Construct)(PEAK_IPL_GAIN_HANDLE *gainHandle)
Definition peak_ipl_dynamic_loader.h:115

peak::ipl::dynamic::dyn_PEAK_IPL_ImageConverter_ConvertWithFactorAndOffset
PEAK_IPL_C_API(* dyn_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)
Definition peak_ipl_dynamic_loader.h:59

peak::ipl::dynamic::dyn_PEAK_IPL_Library_GetLastError
PEAK_IPL_C_API(* dyn_PEAK_IPL_Library_GetLastError)(PEAK_IPL_RETURN_CODE *lastErrorCode, char *lastErrorDescription, size_t *lastErrorDescriptionSize)
Definition peak_ipl_dynamic_loader.h:50

peak::ipl::dynamic::dyn_PEAK_IPL_PixelFormat_GetNumStorageBitsPerChannel
PEAK_IPL_C_API(* dyn_PEAK_IPL_PixelFormat_GetNumStorageBitsPerChannel)(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t *numStorageBits)
Definition peak_ipl_dynamic_loader.h:203

peak::ipl::dynamic::dyn_PEAK_IPL_VideoWriter_Video_Close
PEAK_IPL_C_API(* dyn_PEAK_IPL_VideoWriter_Video_Close)(PEAK_IPL_VIDEO_HANDLE videoHandle)
Definition peak_ipl_dynamic_loader.h:224

peak::ipl::dynamic::dyn_PEAK_IPL_VideoWriter_Queue_GetSize
PEAK_IPL_C_API(* dyn_PEAK_IPL_VideoWriter_Queue_GetSize)(PEAK_IPL_VIDEO_HANDLE videoHandle, int32_t *size)
Definition peak_ipl_dynamic_loader.h:240

peak::ipl::dynamic::dyn_PEAK_IPL_Binning_Destruct
PEAK_IPL_C_API(* dyn_PEAK_IPL_Binning_Destruct)(PEAK_IPL_BINNING_HANDLE binningHandle)
Definition peak_ipl_dynamic_loader.h:102

peak::ipl::dynamic::dyn_PEAK_IPL_ImageConverter_ConvertToBuffer
PEAK_IPL_C_API(* dyn_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)
Definition peak_ipl_dynamic_loader.h:58

peak::ipl::dynamic::dyn_PEAK_IPL_Binning_SetBinningX
PEAK_IPL_C_API(* dyn_PEAK_IPL_Binning_SetBinningX)(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t *binningXValue)
Definition peak_ipl_dynamic_loader.h:91

peak::ipl::dynamic::dyn_PEAK_IPL_ColorCorrector_ProcessInPlace
PEAK_IPL_C_API(* dyn_PEAK_IPL_ColorCorrector_ProcessInPlace)(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, PEAK_IPL_IMAGE_HANDLE imageHandle)
Definition peak_ipl_dynamic_loader.h:83

peak::ipl::dynamic::dyn_PEAK_IPL_ImageSharpness_SetROIs
PEAK_IPL_C_API(* dyn_PEAK_IPL_ImageSharpness_SetROIs)(PEAK_IPL_SHARPNESS_HANDLE handle, struct PEAK_IPL_SHARPNESS_ROI *roiList, size_t roiListSize)
Definition peak_ipl_dynamic_loader.h:254

peak::ipl::dynamic::dyn_PEAK_IPL_ImageWriter_WriteAsBMP
PEAK_IPL_C_API(* dyn_PEAK_IPL_ImageWriter_WriteAsBMP)(PEAK_IPL_IMAGE_HANDLE inputImageHandle, const char *filePath, size_t filePathSize)
Definition peak_ipl_dynamic_loader.h:216

peak::ipl::dynamic::dyn_PEAK_IPL_ChromaticAdapter_Acquire
PEAK_IPL_C_API(* dyn_PEAK_IPL_ChromaticAdapter_Acquire)(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE handle)
Definition peak_ipl_dynamic_loader.h:278

peak::ipl::dynamic::dyn_PEAK_IPL_ImageTransformer_MirrorUpDownLeftRight
PEAK_IPL_C_API(* dyn_PEAK_IPL_ImageTransformer_MirrorUpDownLeftRight)(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE *outputImageHandle)
Definition peak_ipl_dynamic_loader.h:178

peak::ipl::dynamic::dyn_PEAK_IPL_ImageConverter_Destruct
PEAK_IPL_C_API(* dyn_PEAK_IPL_ImageConverter_Destruct)(PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle)
Definition peak_ipl_dynamic_loader.h:63

peak::ipl::dynamic::dyn_PEAK_IPL_Gain_SetRedGainValue
PEAK_IPL_C_API(* dyn_PEAK_IPL_Gain_SetRedGainValue)(PEAK_IPL_GAIN_HANDLE gainHandle, float *redGainValue)
Definition peak_ipl_dynamic_loader.h:121

peak::ipl::dynamic::dyn_PEAK_IPL_AdaptiveHotpixelCorrector_GetGainFactorPercent
PEAK_IPL_C_API(* dyn_PEAK_IPL_AdaptiveHotpixelCorrector_GetGainFactorPercent)(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, uint32_t *gainFactorPercent)
Definition peak_ipl_dynamic_loader.h:69

peak::ipl::dynamic::dyn_PEAK_IPL_AdaptiveHotpixelCorrector_SetSensitivity
PEAK_IPL_C_API(* dyn_PEAK_IPL_AdaptiveHotpixelCorrector_SetSensitivity)(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_HOTPIXELCORRECTION_SENSITIVITY sensitivityLevel)
Definition peak_ipl_dynamic_loader.h:66

peak::ipl::dynamic::dyn_PEAK_IPL_Gain_GetBlueGainValue
PEAK_IPL_C_API(* dyn_PEAK_IPL_Gain_GetBlueGainValue)(PEAK_IPL_GAIN_HANDLE gainHandle, float *blueGainValue)
Definition peak_ipl_dynamic_loader.h:130

peak::ipl::dynamic::dyn_PEAK_IPL_ImageConverter_PreAllocateConversion
PEAK_IPL_C_API(* dyn_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)
Definition peak_ipl_dynamic_loader.h:53

peak::ipl::dynamic::dyn_PEAK_IPL_Gain_GetRedGainMin
PEAK_IPL_C_API(* dyn_PEAK_IPL_Gain_GetRedGainMin)(PEAK_IPL_GAIN_HANDLE gainHandle, float *redGainMin)
Definition peak_ipl_dynamic_loader.h:124

peak::ipl::dynamic::dyn_PEAK_IPL_PixelFormat_IsYUV
PEAK_IPL_C_API(* dyn_PEAK_IPL_PixelFormat_IsYUV)(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 *isYUV)
Definition peak_ipl_dynamic_loader.h:211

peak::ipl::dynamic::dyn_PEAK_IPL_ColorCorrector_Acquire
PEAK_IPL_C_API(* dyn_PEAK_IPL_ColorCorrector_Acquire)(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle)
Definition peak_ipl_dynamic_loader.h:78

peak::ipl::dynamic::dyn_PEAK_IPL_ImageReader_Read
PEAK_IPL_C_API(* dyn_PEAK_IPL_ImageReader_Read)(const char *filePath, size_t filePathSize, PEAK_IPL_IMAGE_HANDLE *outputImageHandle)
Definition peak_ipl_dynamic_loader.h:220

peak::ipl::dynamic::dyn_PEAK_IPL_VideoWriter_Video_GetDroppedFrames
PEAK_IPL_C_API(* dyn_PEAK_IPL_VideoWriter_Video_GetDroppedFrames)(PEAK_IPL_VIDEO_HANDLE videoHandle, uint64_t *numFrames)
Definition peak_ipl_dynamic_loader.h:236

peak::ipl::dynamic::dyn_PEAK_IPL_Lut_Process
PEAK_IPL_C_API(* dyn_PEAK_IPL_Lut_Process)(PEAK_IPL_LUT_HANDLE lutHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE *outputImageHandle)
Definition peak_ipl_dynamic_loader.h:274

peak::ipl::dynamic::dyn_PEAK_IPL_Binning_ExpectedOutputSize
PEAK_IPL_C_API(* dyn_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)
Definition peak_ipl_dynamic_loader.h:97

peak::ipl::dynamic::dyn_PEAK_IPL_GammaCorrector_GetDigitalBlackMax
PEAK_IPL_C_API(* dyn_PEAK_IPL_GammaCorrector_GetDigitalBlackMax)(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float *digitalBlackMax)
Definition peak_ipl_dynamic_loader.h:145

peak::ipl::dynamic::dyn_PEAK_IPL_Image_ConvertToBufferFromInterval
PEAK_IPL_C_API(* dyn_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)
Definition peak_ipl_dynamic_loader.h:167

peak::ipl::dynamic::dyn_PEAK_IPL_VideoWriter_Video_GetEncodedFrames
PEAK_IPL_C_API(* dyn_PEAK_IPL_VideoWriter_Video_GetEncodedFrames)(PEAK_IPL_VIDEO_HANDLE videoHandle, uint64_t *numFrames)
Definition peak_ipl_dynamic_loader.h:235

peak::ipl::dynamic::dyn_PEAK_IPL_VideoWriter_Video_Append
PEAK_IPL_C_API(* dyn_PEAK_IPL_VideoWriter_Video_Append)(PEAK_IPL_VIDEO_HANDLE videoHandle, PEAK_IPL_IMAGE_HANDLE imageHandle)
Definition peak_ipl_dynamic_loader.h:225

peak::ipl::dynamic::dyn_PEAK_IPL_VideoWriter_Encoder_OptionRange
PEAK_IPL_C_API(* dyn_PEAK_IPL_VideoWriter_Encoder_OptionRange)(PEAK_IPL_VIDEO_HANDLE videoHandle, PEAK_IPL_VIDEO_ENCODER_OPTION option, void *min, void *max, void *inc)
Definition peak_ipl_dynamic_loader.h:228

peak::ipl::dynamic::dyn_PEAK_IPL_PixelLine_GetOrientation
PEAK_IPL_C_API(* dyn_PEAK_IPL_PixelLine_GetOrientation)(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle, PEAK_IPL_ORIENTATION *orientation)
Definition peak_ipl_dynamic_loader.h:196

peak::ipl::dynamic::dyn_PEAK_IPL_VideoWriter_GetSupportedContainersForAnEncoder
PEAK_IPL_C_API(* dyn_PEAK_IPL_VideoWriter_GetSupportedContainersForAnEncoder)(PEAK_IPL_VIDEO_ENCODER encoder, PEAK_IPL_VIDEO_CONTAINER *containers, size_t *size)
Definition peak_ipl_dynamic_loader.h:233

peak::ipl::dynamic::dyn_PEAK_IPL_Binning_GetBinningMax
PEAK_IPL_C_API(* dyn_PEAK_IPL_Binning_GetBinningMax)(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t *binningMax)
Definition peak_ipl_dynamic_loader.h:96

peak::ipl::dynamic::dyn_PEAK_IPL_ImageReaderRead_ReadAsPixelFormat
PEAK_IPL_C_API(* dyn_PEAK_IPL_ImageReaderRead_ReadAsPixelFormat)(const char *filePath, size_t filePathSize, PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_IMAGE_HANDLE *outputImageHandle)
Definition peak_ipl_dynamic_loader.h:221

peak::ipl::dynamic::dyn_PEAK_IPL_PixelFormat_IsCoord3D
PEAK_IPL_C_API(* dyn_PEAK_IPL_PixelFormat_IsCoord3D)(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 *isCoord3D)
Definition peak_ipl_dynamic_loader.h:212

peak::ipl::dynamic::dyn_PEAK_IPL_PixelFormat_IsBayered
PEAK_IPL_C_API(* dyn_PEAK_IPL_PixelFormat_IsBayered)(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 *isBayered)
Definition peak_ipl_dynamic_loader.h:210

peak::ipl::dynamic::dyn_PEAK_IPL_ImageConverter_GetSupportedOutputPixelFormats
PEAK_IPL_C_API(* dyn_PEAK_IPL_ImageConverter_GetSupportedOutputPixelFormats)(PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle, PEAK_IPL_PIXEL_FORMAT inputPixelFormat, PEAK_IPL_PIXEL_FORMAT *outputPixelFormats, size_t *outputPixelFormatsSize)
Definition peak_ipl_dynamic_loader.h:56

peak::ipl::dynamic::dyn_PEAK_IPL_ColorCorrector_GetSaturationMin
PEAK_IPL_C_API(* dyn_PEAK_IPL_ColorCorrector_GetSaturationMin)(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, float *saturationMin)
Definition peak_ipl_dynamic_loader.h:86

peak::ipl::dynamic::dyn_PEAK_IPL_ImageWriter_WriteAsPNG
PEAK_IPL_C_API(* dyn_PEAK_IPL_ImageWriter_WriteAsPNG)(PEAK_IPL_IMAGE_HANDLE inputImageHandle, uint32_t quality, const char *filePath, size_t filePathSize)
Definition peak_ipl_dynamic_loader.h:217

peak::ipl::dynamic::dyn_PEAK_IPL_ImageTransformer_RotateInPlace
PEAK_IPL_C_API(* dyn_PEAK_IPL_ImageTransformer_RotateInPlace)(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, enum PEAK_IPL_IMAGE_TRANSFORMER_ROTATION_ANGLE_t rotationAngle)
Definition peak_ipl_dynamic_loader.h:183

peak::ipl::dynamic::dyn_PEAK_IPL_Lut_SetLutPreset
PEAK_IPL_C_API(* dyn_PEAK_IPL_Lut_SetLutPreset)(PEAK_IPL_LUT_HANDLE lutHandle, PEAK_IPL_LUT_SELECTOR lutSelector, PEAK_IPL_LUT_PRESET preset)
Definition peak_ipl_dynamic_loader.h:272

peak::ipl::dynamic::dyn_PEAK_IPL_Image_ConvertToBuffer
PEAK_IPL_C_API(* dyn_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)
Definition peak_ipl_dynamic_loader.h:162

peak::ipl::dynamic::dyn_PEAK_IPL_GammaCorrector_GetIsPixelFormatSupported
PEAK_IPL_C_API(* dyn_PEAK_IPL_GammaCorrector_GetIsPixelFormatSupported)(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 *isPixelFormatSupported)
Definition peak_ipl_dynamic_loader.h:147

peak::ipl::dynamic::dyn_PEAK_IPL_Image_GetTimestamp
PEAK_IPL_C_API(* dyn_PEAK_IPL_Image_GetTimestamp)(PEAK_IPL_IMAGE_HANDLE imageHandle, uint64_t *timestamp_ns)
Definition peak_ipl_dynamic_loader.h:175

peak::ipl::dynamic::dyn_PEAK_IPL_Gain_GetGreenGainMax
PEAK_IPL_C_API(* dyn_PEAK_IPL_Gain_GetGreenGainMax)(PEAK_IPL_GAIN_HANDLE gainHandle, float *greenGainMax)
Definition peak_ipl_dynamic_loader.h:127

peak::ipl::dynamic::dyn_PEAK_IPL_ImageSharpness_Construct
PEAK_IPL_C_API(* dyn_PEAK_IPL_ImageSharpness_Construct)(PEAK_IPL_SHARPNESS_HANDLE *handle)
Definition peak_ipl_dynamic_loader.h:245

peak::ipl::dynamic::dyn_PEAK_IPL_Lut_SetAllLutValues
PEAK_IPL_C_API(* dyn_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)
Definition peak_ipl_dynamic_loader.h:271

peak::ipl::dynamic::dyn_PEAK_IPL_ColorCorrector_GetIsPixelFormatSupported
PEAK_IPL_C_API(* dyn_PEAK_IPL_ColorCorrector_GetIsPixelFormatSupported)(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 *isPixelFormatSupported)
Definition peak_ipl_dynamic_loader.h:81

peak::ipl::dynamic::dyn_PEAK_IPL_ColorCorrector_GetColorCorrectionFactors
PEAK_IPL_C_API(* dyn_PEAK_IPL_ColorCorrector_GetColorCorrectionFactors)(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, float *colorCorrectorFactors, size_t *colorCorrectorFactorsSize)
Definition peak_ipl_dynamic_loader.h:80

peak::ipl::dynamic::dyn_PEAK_IPL_Image_Crop
PEAK_IPL_C_API(* dyn_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)
Definition peak_ipl_dynamic_loader.h:170

peak::ipl::dynamic::dyn_PEAK_IPL_ImageTransformer_MirrorUpDownInPlace
PEAK_IPL_C_API(* dyn_PEAK_IPL_ImageTransformer_MirrorUpDownInPlace)(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle, PEAK_IPL_IMAGE_HANDLE imageHandle)
Definition peak_ipl_dynamic_loader.h:179

peak::ipl::dynamic::dyn_PEAK_IPL_Decimation_GetDecimationX
PEAK_IPL_C_API(* dyn_PEAK_IPL_Decimation_GetDecimationX)(PEAK_IPL_DECIMATION_HANDLE decimationHandle, uint8_t *decimationXValue)
Definition peak_ipl_dynamic_loader.h:106

peak::ipl::dynamic::dyn_PEAK_IPL_Image_GetByteCount
PEAK_IPL_C_API(* dyn_PEAK_IPL_Image_GetByteCount)(PEAK_IPL_IMAGE_HANDLE imageHandle, size_t *byteCount)
Definition peak_ipl_dynamic_loader.h:157

peak::ipl::dynamic::dyn_PEAK_IPL_AdaptiveHotpixelCorrector_GetSensitivity
PEAK_IPL_C_API(* dyn_PEAK_IPL_AdaptiveHotpixelCorrector_GetSensitivity)(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_HOTPIXELCORRECTION_SENSITIVITY *sensitivityLevel)
Definition peak_ipl_dynamic_loader.h:67

peak::ipl::dynamic::dyn_PEAK_IPL_Decimation_Process
PEAK_IPL_C_API(* dyn_PEAK_IPL_Decimation_Process)(PEAK_IPL_DECIMATION_HANDLE decimationHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE *outputImageHandle)
Definition peak_ipl_dynamic_loader.h:113

peak::ipl::dynamic::dyn_PEAK_IPL_ColorCorrector_Process
PEAK_IPL_C_API(* dyn_PEAK_IPL_ColorCorrector_Process)(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE *outputImageHandle)
Definition peak_ipl_dynamic_loader.h:82

peak::ipl::dynamic::dyn_PEAK_IPL_Lut_Construct
PEAK_IPL_C_API(* dyn_PEAK_IPL_Lut_Construct)(PEAK_IPL_LUT_HANDLE *lutHandle)
Definition peak_ipl_dynamic_loader.h:266

peak::ipl::dynamic::dyn_PEAK_IPL_VideoWriter_Encoder_SetOption
PEAK_IPL_C_API(* dyn_PEAK_IPL_VideoWriter_Encoder_SetOption)(PEAK_IPL_VIDEO_HANDLE videoHandle, PEAK_IPL_VIDEO_ENCODER_OPTION option, const void *value, size_t count)
Definition peak_ipl_dynamic_loader.h:226

peak::ipl::dynamic::dyn_PEAK_IPL_ColorCorrector_Destruct
PEAK_IPL_C_API(* dyn_PEAK_IPL_ColorCorrector_Destruct)(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle)
Definition peak_ipl_dynamic_loader.h:84

peak::ipl::dynamic::dyn_PEAK_IPL_Library_SetMultiThreadingEnabled
PEAK_IPL_C_API(* dyn_PEAK_IPL_Library_SetMultiThreadingEnabled)(PEAK_IPL_BOOL8 enabled)
Definition peak_ipl_dynamic_loader.h:47

peak::ipl::dynamic::dyn_PEAK_IPL_ImageSharpness_GetROIMinimumSize
PEAK_IPL_C_API(* dyn_PEAK_IPL_ImageSharpness_GetROIMinimumSize)(PEAK_IPL_SHARPNESS_HANDLE handle, struct PEAK_IPL_SIZE_2D *min_size)
Definition peak_ipl_dynamic_loader.h:253

peak::ipl::dynamic::dyn_PEAK_IPL_ImageTransformer_MirrorUpDown
PEAK_IPL_C_API(* dyn_PEAK_IPL_ImageTransformer_MirrorUpDown)(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE *outputImageHandle)
Definition peak_ipl_dynamic_loader.h:176

peak::ipl::dynamic::dyn_PEAK_IPL_Image_ConvertToBufferWithFactorAndOffset
PEAK_IPL_C_API(* dyn_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)
Definition peak_ipl_dynamic_loader.h:165

peak::ipl::dynamic::dyn_PEAK_IPL_Lut_IsPixelFormatSupported
PEAK_IPL_C_API(* dyn_PEAK_IPL_Lut_IsPixelFormatSupported)(PEAK_IPL_LUT_HANDLE lutHandle, PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 *isPixelFormatSupported)
Definition peak_ipl_dynamic_loader.h:273

peak::ipl::dynamic::dyn_PEAK_IPL_Histogram_GetPixelFormat
PEAK_IPL_C_API(* dyn_PEAK_IPL_Histogram_GetPixelFormat)(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle, PEAK_IPL_PIXEL_FORMAT *pixelFormat)
Definition peak_ipl_dynamic_loader.h:187

peak::ipl::dynamic::dyn_PEAK_IPL_ImageSharpness_GetSupportedPixelFormatList
PEAK_IPL_C_API(* dyn_PEAK_IPL_ImageSharpness_GetSupportedPixelFormatList)(PEAK_IPL_SHARPNESS_HANDLE handle, PEAK_IPL_PIXEL_FORMAT *pixelFormatList, size_t *pixelFormatListSize)
Definition peak_ipl_dynamic_loader.h:250

peak::ipl::dynamic::dyn_PEAK_IPL_ChromaticAdapter_GetTargetColorSpace
PEAK_IPL_C_API(* dyn_PEAK_IPL_ChromaticAdapter_GetTargetColorSpace)(PEAK_IPL_CHROMATIC_ADAPTER_HANDLE handle, PEAK_IPL_CHROMATIC_ADAPTER_COLOR_SPACE *colorSpace)
Definition peak_ipl_dynamic_loader.h:280

peak::ipl::dynamic::dyn_PEAK_IPL_AdaptiveHotpixelCorrector_CorrectInPlace
PEAK_IPL_C_API(* dyn_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)
Definition peak_ipl_dynamic_loader.h:73

peak::ipl::encoder
Definition peak_ipl_video_writer.hpp:32

peak
The "peak::ipl" namespace contains the whole image processing library.
Definition peak_ipl_binning.hpp:23

peak_ipl_backend.h

PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE
struct PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR * PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE
Definition peak_ipl_backend.h:381

PEAK_IPL_GAMMA_CORRECTOR_HANDLE
struct PEAK_IPL_GAMMA_CORRECTOR * PEAK_IPL_GAMMA_CORRECTOR_HANDLE
Definition peak_ipl_backend.h:401

PEAK_IPL_SHARPNESS_ALGORITHM
uint16_t PEAK_IPL_SHARPNESS_ALGORITHM
Definition peak_ipl_backend.h:283

PEAK_IPL_VIDEO_ENCODER
uint16_t PEAK_IPL_VIDEO_ENCODER
Definition peak_ipl_backend.h:243

PEAK_IPL_HOTPIXELCORRECTION_SENSITIVITY
int32_t PEAK_IPL_HOTPIXELCORRECTION_SENSITIVITY
Definition peak_ipl_backend.h:214

PEAK_IPL_LUT_PRESET
int32_t PEAK_IPL_LUT_PRESET
Definition peak_ipl_backend.h:352

PEAK_IPL_PIXEL_LINE_HANDLE
struct PEAK_IPL_PIXEL_LINE * PEAK_IPL_PIXEL_LINE_HANDLE
Definition peak_ipl_backend.h:413

PEAK_IPL_VIDEO_CONTAINER_OPTION
uint16_t PEAK_IPL_VIDEO_CONTAINER_OPTION
Definition peak_ipl_backend.h:255

PEAK_IPL_LUT_SELECTOR
int32_t PEAK_IPL_LUT_SELECTOR
Definition peak_ipl_backend.h:336

PEAK_IPL_VIDEO_CONTAINER
uint16_t PEAK_IPL_VIDEO_CONTAINER
Definition peak_ipl_backend.h:236

PEAK_IPL_C_API
#define PEAK_IPL_C_API
Definition peak_ipl_backend.h:438

PEAK_IPL_IMAGE_TRANSFORMER_ROTATION_ANGLE_t
PEAK_IPL_IMAGE_TRANSFORMER_ROTATION_ANGLE_t
Definition peak_ipl_backend.h:218

PEAK_IPL_BINNINGMODE
uint16_t PEAK_IPL_BINNINGMODE
Definition peak_ipl_backend.h:230

PEAK_IPL_VIDEO_ENCODER_OPTION
uint16_t PEAK_IPL_VIDEO_ENCODER_OPTION
Definition peak_ipl_backend.h:249

PEAK_IPL_CONVERSION_MODE
int32_t PEAK_IPL_CONVERSION_MODE
Definition peak_ipl_backend.h:55

PEAK_IPL_ORIENTATION
int32_t PEAK_IPL_ORIENTATION
Definition peak_ipl_backend.h:202

PEAK_IPL_VIDEO_HANDLE
struct PEAK_IPL_VIDEO * PEAK_IPL_VIDEO_HANDLE
Definition peak_ipl_backend.h:417

PEAK_IPL_HISTOGRAM_HANDLE
struct PEAK_IPL_HISTOGRAM * PEAK_IPL_HISTOGRAM_HANDLE
Definition peak_ipl_backend.h:409

PEAK_IPL_CHROMATIC_ADAPTER_ALGORITHM
uint16_t PEAK_IPL_CHROMATIC_ADAPTER_ALGORITHM
Definition peak_ipl_backend.h:369

PEAK_IPL_GAIN_HANDLE
struct PEAK_IPL_GAIN * PEAK_IPL_GAIN_HANDLE
Definition peak_ipl_backend.h:397

PEAK_IPL_SHARPNESS_HANDLE
struct PEAK_IPL_SHARPNESS * PEAK_IPL_SHARPNESS_HANDLE
Definition peak_ipl_backend.h:421

PEAK_IPL_IMAGE_HANDLE
struct PEAK_IPL_IMAGE * PEAK_IPL_IMAGE_HANDLE
Definition peak_ipl_backend.h:405

PEAK_IPL_COLOR_CORRECTOR_HANDLE
struct PEAK_IPL_COLOR_CORRECTOR * PEAK_IPL_COLOR_CORRECTOR_HANDLE
Definition peak_ipl_backend.h:393

PEAK_IPL_LUT_HANDLE
struct PEAK_IPL_LUT * PEAK_IPL_LUT_HANDLE
Definition peak_ipl_backend.h:429

PEAK_IPL_IMAGE_TRANSFORMER_HANDLE
struct PEAK_IPL_IMAGE_transformer * PEAK_IPL_IMAGE_TRANSFORMER_HANDLE
Definition peak_ipl_backend.h:377

PEAK_IPL_RETURN_CODE
int32_t PEAK_IPL_RETURN_CODE
Definition peak_ipl_backend.h:46

PEAK_IPL_BOOL8
int8_t PEAK_IPL_BOOL8
Definition peak_ipl_backend.h:26

PEAK_IPL_LUT_CHANNEL
int32_t PEAK_IPL_LUT_CHANNEL
Definition peak_ipl_backend.h:327

PEAK_IPL_INTERPOLATION_ALGORITHM
int32_t PEAK_IPL_INTERPOLATION_ALGORITHM
Definition peak_ipl_backend.h:303

PEAK_IPL_BAYER_PATTERN
int32_t PEAK_IPL_BAYER_PATTERN
Definition peak_ipl_backend.h:185

PEAK_IPL_PIXEL_FORMAT
int32_t PEAK_IPL_PIXEL_FORMAT
Definition peak_ipl_backend.h:173

PEAK_IPL_EDGE_ENHANCEMENT_HANDLE
struct PEAK_IPL_EDGE_ENHANCEMENT * PEAK_IPL_EDGE_ENHANCEMENT_HANDLE
Definition peak_ipl_backend.h:425

PEAK_IPL_CHROMATIC_ADAPTER_COLOR_SPACE
uint16_t PEAK_IPL_CHROMATIC_ADAPTER_COLOR_SPACE
Definition peak_ipl_backend.h:362

PEAK_IPL_BINNING_HANDLE
struct PEAK_IPL_BINNING * PEAK_IPL_BINNING_HANDLE
Definition peak_ipl_backend.h:385

PEAK_IPL_IMAGE_CONVERTER_HANDLE
struct PEAK_IPL_IMAGE_CONVERTER * PEAK_IPL_IMAGE_CONVERTER_HANDLE
Definition peak_ipl_backend.h:373

PEAK_IPL_CHROMATIC_ADAPTER_HANDLE
struct PEAK_IPL_CHROMATIC_ADAPTER * PEAK_IPL_CHROMATIC_ADAPTER_HANDLE
Definition peak_ipl_backend.h:433

PEAK_IPL_DECIMATION_HANDLE
struct PEAK_IPL_DECIMATION * PEAK_IPL_DECIMATION_HANDLE
Definition peak_ipl_backend.h:389

PEAK_IPL_ENDIANNESS
int32_t PEAK_IPL_ENDIANNESS
Definition peak_ipl_backend.h:194

PEAK_IPL_POINT_2D
Definition peak_ipl_backend.h:259

PEAK_IPL_RANGE
Definition peak_ipl_backend.h:314

PEAK_IPL_SHARPNESS_ROI
Definition peak_ipl_backend.h:306

PEAK_IPL_SIZE_2D
Definition peak_ipl_backend.h:265