IDS peak IPL  v1.4.0
peak_ipl_dynamic_loader.h
Go to the documentation of this file.
1 
10 #pragma once
11 
12 #include "peak_ipl_backend.h"
13 #include <string>
14 #include <cstdint>
15 
16 #ifdef __linux__
17  #include <dlfcn.h>
18 #else
19  #include <vector>
20  #include <windows.h>
21  #include <tchar.h>
22 #endif
23 
24 #include <stdexcept>
25 
26 #undef PEAK_IPL_PUBLIC
27 #define PEAK_IPL_PUBLIC
28 #undef PEAK_IPL_CALL_CONV
29 #define PEAK_IPL_CALL_CONV
30 
31 
32 namespace peak
33 {
34 namespace ipl
35 {
36 namespace dynamic
37 {
38 
39 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Library_GetVersionMajor)(uint32_t * libraryVersionMajor);
40 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Library_GetVersionMinor)(uint32_t * libraryVersionMinor);
41 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Library_GetVersionSubminor)(uint32_t * libraryVersionSubminor);
42 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Library_GetLastError)(PEAK_IPL_RETURN_CODE * lastErrorCode, char * lastErrorDescription, size_t * lastErrorDescriptionSize);
43 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ImageConverter_Construct)(PEAK_IPL_IMAGE_CONVERTER_HANDLE * imageConverterHandle);
44 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);
45 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ImageConverter_GetConversionMode)(PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle, PEAK_IPL_CONVERSION_MODE * conversionMode);
46 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ImageConverter_SetConversionMode)(PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle, PEAK_IPL_CONVERSION_MODE conversionMode);
47 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);
48 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);
49 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);
50 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ImageConverter_Destruct)(PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle);
51 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_AdaptiveHotpixelCorrector_Construct)(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE * adaptiveHotpixelCorrectorHandle);
52 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_AdaptiveHotpixelCorrector_SetSensitivity)(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_HOTPIXELCORRECTION_SENSITIVITY sensitivityLevel);
53 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_AdaptiveHotpixelCorrector_GetSensitivity)(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_HOTPIXELCORRECTION_SENSITIVITY * sensitivityLevel);
54 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_AdaptiveHotpixelCorrector_SetGainFactorPercent)(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, uint32_t gainFactorPercent);
55 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_AdaptiveHotpixelCorrector_GetGainFactorPercent)(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, uint32_t * gainFactorPercent);
56 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_AdaptiveHotpixelCorrector_Detect)(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_IMAGE_HANDLE inputImageHandle);
57 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_AdaptiveHotpixelCorrector_GetHotpixels)(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_POINT_2D * hotpixels, size_t * hotpixelsSize);
58 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_AdaptiveHotpixelCorrector_Correct)(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_IMAGE_HANDLE inputImageHandle, const PEAK_IPL_POINT_2D * hotpixels, size_t hotpixelsSize, PEAK_IPL_IMAGE_HANDLE * outputImageHandle);
59 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);
60 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_AdaptiveHotpixelCorrector_Destruct)(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle);
61 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ColorCorrector_Construct)(PEAK_IPL_COLOR_CORRECTOR_HANDLE * colorCorrectorHandle);
62 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ColorCorrector_SetColorCorrectionFactors)(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, float * colorCorrectorFactors);
63 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ColorCorrector_GetColorCorrectionFactors)(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, float * colorCorrectorFactors, size_t * colorCorrectorFactorsSize);
64 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);
65 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);
66 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ColorCorrector_ProcessInPlace)(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, PEAK_IPL_IMAGE_HANDLE imageHandle);
67 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ColorCorrector_Destruct)(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle);
68 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Binning_Construct)(PEAK_IPL_BINNING_HANDLE * binningHandle);
69 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Binning_SetBinningX)(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t * binningXValue);
70 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Binning_GetBinningX)(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t * binningXValue);
71 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Binning_SetBinningY)(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t * binningYValue);
72 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Binning_GetBinningY)(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t * binningYValue);
73 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Binning_GetBinningMin)(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t * binningMin);
74 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Binning_GetBinningMax)(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t * binningMax);
75 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Binning_ExpectedOutputSize)(PEAK_IPL_BINNING_HANDLE binningHandle, size_t * outputWidth, size_t * outputHeight, const size_t inputWidth, const size_t inputHeight, const PEAK_IPL_PIXEL_FORMAT pixelFormat);
76 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Binning_IsPixelformatSupported)(PEAK_IPL_BINNING_HANDLE binningHandle, PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 * isPixelFormatSupported);
77 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Binning_SetBinningMode)(PEAK_IPL_BINNING_HANDLE binningHandle, PEAK_IPL_BINNINGMODE * mode);
78 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Binning_GetBinningMode)(PEAK_IPL_BINNING_HANDLE binningHandle, PEAK_IPL_BINNINGMODE * mode);
79 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);
80 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Binning_Destruct)(PEAK_IPL_BINNING_HANDLE binningHandle);
81 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Gain_Construct)(PEAK_IPL_GAIN_HANDLE * gainHandle);
82 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Gain_SetMasterGainValue)(PEAK_IPL_GAIN_HANDLE gainHandle, float * masterGainValue);
83 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Gain_GetMasterGainValue)(PEAK_IPL_GAIN_HANDLE gainHandle, float * masterGainValue);
84 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Gain_GetMasterGainMax)(PEAK_IPL_GAIN_HANDLE gainHandle, float * masterGainMax);
85 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Gain_GetMasterGainMin)(PEAK_IPL_GAIN_HANDLE gainHandle, float * masterGainMin);
86 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Gain_SetRedGainValue)(PEAK_IPL_GAIN_HANDLE gainHandle, float * redGainValue);
87 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Gain_GetRedGainValue)(PEAK_IPL_GAIN_HANDLE gainHandle, float * redGainValue);
88 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Gain_GetRedGainMax)(PEAK_IPL_GAIN_HANDLE gainHandle, float * redGainMax);
89 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Gain_GetRedGainMin)(PEAK_IPL_GAIN_HANDLE gainHandle, float * redGainMin);
90 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Gain_SetGreenGainValue)(PEAK_IPL_GAIN_HANDLE gainHandle, float * greenGainValue);
91 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Gain_GetGreenGainValue)(PEAK_IPL_GAIN_HANDLE gainHandle, float * greenGainValue);
92 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Gain_GetGreenGainMax)(PEAK_IPL_GAIN_HANDLE gainHandle, float * greenGainMax);
93 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Gain_GetGreenGainMin)(PEAK_IPL_GAIN_HANDLE gainHandle, float * greenGainMin);
94 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Gain_SetBlueGainValue)(PEAK_IPL_GAIN_HANDLE gainHandle, float * blueGainValue);
95 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Gain_GetBlueGainValue)(PEAK_IPL_GAIN_HANDLE gainHandle, float * blueGainValue);
96 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Gain_GetBlueGainMax)(PEAK_IPL_GAIN_HANDLE gainHandle, float * blueGainMax);
97 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Gain_GetBlueGainMin)(PEAK_IPL_GAIN_HANDLE gainHandle, float * blueGainMin);
98 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Gain_GetIsPixelFormatSupported)(PEAK_IPL_GAIN_HANDLE gainHandle, PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 * isPixelFormatSupported);
99 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);
100 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Gain_ProcessInPlace)(PEAK_IPL_GAIN_HANDLE gainHandle, PEAK_IPL_IMAGE_HANDLE imageHandle);
101 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Gain_Destruct)(PEAK_IPL_GAIN_HANDLE gainHandle);
102 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_GammaCorrector_Construct)(PEAK_IPL_GAMMA_CORRECTOR_HANDLE * gammaCorrectorHandle);
103 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_GammaCorrector_SetGammaCorrectionValue)(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float * gammaValue);
104 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_GammaCorrector_GetGammaCorrectionValue)(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float * gammaValue);
105 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_GammaCorrector_GetGammaCorrectionMax)(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float * gammaMax);
106 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_GammaCorrector_GetGammaCorrectionMin)(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float * gammaMin);
107 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);
108 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);
109 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_GammaCorrector_ProcessInPlace)(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, PEAK_IPL_IMAGE_HANDLE imageHandle);
110 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_GammaCorrector_Destruct)(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle);
111 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);
112 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);
113 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Image_GetWidth)(PEAK_IPL_IMAGE_HANDLE imageHandle, size_t * width);
114 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Image_GetHeight)(PEAK_IPL_IMAGE_HANDLE imageHandle, size_t * height);
115 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Image_GetPixelPointer)(PEAK_IPL_IMAGE_HANDLE imageHandle, size_t xPos, size_t yPos, uint8_t * * pixelPointer);
116 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Image_GetByteCount)(PEAK_IPL_IMAGE_HANDLE imageHandle, size_t * byteCount);
117 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Image_GetPixelFormat)(PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_PIXEL_FORMAT * pixelFormat);
118 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Image_GetData)(PEAK_IPL_IMAGE_HANDLE imageHandle, uint8_t * * data);
119 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Image_Clone)(PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE * outputImageHandle);
120 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);
121 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);
122 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Image_Destruct)(PEAK_IPL_IMAGE_HANDLE imageHandle);
123 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ImageTransformer_Construct)(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE * imageTransformerHandle);
124 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);
125 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);
126 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);
127 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ImageTransformer_MirrorUpDownInPlace)(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle, PEAK_IPL_IMAGE_HANDLE imageHandle);
128 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ImageTransformer_MirrorLeftRightInPlace)(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle, PEAK_IPL_IMAGE_HANDLE imageHandle);
129 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ImageTransformer_MirrorUpDownLeftRightInPlace)(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle, PEAK_IPL_IMAGE_HANDLE imageHandle);
130 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, PEAK_IPL_IMAGE_TRANSFORMER_ROTATION_ANGLE_t rotationAngle);
131 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ImageTransformer_RotateInPlace)(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_TRANSFORMER_ROTATION_ANGLE_t rotationAngle);
132 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ImageTransformer_Destruct)(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle);
133 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Histogram_Construct)(PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_HISTOGRAM_HANDLE * histogramHandle);
134 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Histogram_GetPixelFormat)(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle, PEAK_IPL_PIXEL_FORMAT * pixelFormat);
135 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Histogram_GetNumChannels)(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle, size_t * numChannels);
136 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Histogram_GetPixelSumForChannel)(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle, size_t channelIndex, uint64_t * pixelSum);
137 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Histogram_GetPixelCountForChannel)(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle, size_t channelIndex, uint64_t * pixelCount);
138 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Histogram_GetBinsForChannel)(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle, size_t channelIndex, uint64_t * bins, size_t * binsSize);
139 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_Histogram_Destruct)(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle);
140 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);
141 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_PixelLine_GetPixelFormat)(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle, PEAK_IPL_PIXEL_FORMAT * pixelFormat);
142 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_PixelLine_GetOrientation)(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle, PEAK_IPL_ORIENTATION * orientation);
143 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_PixelLine_GetOffset)(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle, size_t * offset);
144 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_PixelLine_GetNumChannels)(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle, size_t * numChannels);
145 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);
146 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_PixelLine_Destruct)(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle);
147 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_PixelFormat_GetNumChannels)(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t * numChannels);
148 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_PixelFormat_GetNumSignificantBitsPerChannel)(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t * numSignificantBits);
149 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_PixelFormat_GetNumStorageBitsPerChannel)(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t * numStorageBits);
150 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_PixelFormat_GetMaximumValuePerChannel)(PEAK_IPL_PIXEL_FORMAT pixelFormat, uint32_t * channelMaximumValue);
151 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_PixelFormat_GetNumSignificantBitsPerPixel)(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t * numSignificantBits);
152 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_PixelFormat_GetNumStorageBitsPerPixel)(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t * numStorageBits);
153 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_PixelFormat_GetEndianness)(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_ENDIANNESS * endianness);
154 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_PixelFormat_CalculateStorageSizeOfPixels)(PEAK_IPL_PIXEL_FORMAT pixelFormat, uint64_t numPixels, uint64_t * size);
155 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ImageWriter_WriteAsRAW)(PEAK_IPL_IMAGE_HANDLE inputImageHandle, const char * filePath, size_t filePathSize);
156 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ImageWriter_WriteAsBMP)(PEAK_IPL_IMAGE_HANDLE inputImageHandle, const char * filePath, size_t filePathSize);
157 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ImageWriter_WriteAsPNG)(PEAK_IPL_IMAGE_HANDLE inputImageHandle, uint32_t quality, const char * filePath, size_t filePathSize);
158 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ImageWriter_WriteAsJPG)(PEAK_IPL_IMAGE_HANDLE inputImageHandle, uint32_t quality, const char * filePath, size_t filePathSize);
159 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ImageWriter_Write)(PEAK_IPL_IMAGE_HANDLE inputImageHandle, const char * filePath, size_t filePathSize);
160 typedef PEAK_IPL_C_API (*dyn_PEAK_IPL_ImageReader_Read)(const char * filePath, size_t filePathSize, PEAK_IPL_IMAGE_HANDLE * outputImageHandle);
161 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);
162 
163 
164 class DynamicLoader
165 {
166 private:
167  DynamicLoader();
168 
169  static DynamicLoader& instance()
170  {
171  static DynamicLoader dynamicLoader{};
172  return dynamicLoader;
173  }
174  bool loadLib(const char* file);
175  void unload();
176  bool setPointers(bool load);
177 
178 public:
179  ~DynamicLoader();
180 
181  static bool isLoaded();
182 
183  static PEAK_IPL_C_API PEAK_IPL_Library_GetVersionMajor(uint32_t * libraryVersionMajor);
184  static PEAK_IPL_C_API PEAK_IPL_Library_GetVersionMinor(uint32_t * libraryVersionMinor);
185  static PEAK_IPL_C_API PEAK_IPL_Library_GetVersionSubminor(uint32_t * libraryVersionSubminor);
186  static PEAK_IPL_C_API PEAK_IPL_Library_GetLastError(PEAK_IPL_RETURN_CODE * lastErrorCode, char * lastErrorDescription, size_t * lastErrorDescriptionSize);
187  static PEAK_IPL_C_API PEAK_IPL_ImageConverter_Construct(PEAK_IPL_IMAGE_CONVERTER_HANDLE * imageConverterHandle);
188  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);
189  static PEAK_IPL_C_API PEAK_IPL_ImageConverter_GetConversionMode(PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle, PEAK_IPL_CONVERSION_MODE * conversionMode);
190  static PEAK_IPL_C_API PEAK_IPL_ImageConverter_SetConversionMode(PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle, PEAK_IPL_CONVERSION_MODE conversionMode);
191  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);
192  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);
193  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);
194  static PEAK_IPL_C_API PEAK_IPL_ImageConverter_Destruct(PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle);
195  static PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_Construct(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE * adaptiveHotpixelCorrectorHandle);
196  static PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_SetSensitivity(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_HOTPIXELCORRECTION_SENSITIVITY sensitivityLevel);
197  static PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_GetSensitivity(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_HOTPIXELCORRECTION_SENSITIVITY * sensitivityLevel);
198  static PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_SetGainFactorPercent(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, uint32_t gainFactorPercent);
199  static PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_GetGainFactorPercent(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, uint32_t * gainFactorPercent);
200  static PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_Detect(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_IMAGE_HANDLE inputImageHandle);
201  static PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_GetHotpixels(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_POINT_2D * hotpixels, size_t * hotpixelsSize);
202  static PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_Correct(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_IMAGE_HANDLE inputImageHandle, const PEAK_IPL_POINT_2D * hotpixels, size_t hotpixelsSize, PEAK_IPL_IMAGE_HANDLE * outputImageHandle);
203  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);
204  static PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_Destruct(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle);
205  static PEAK_IPL_C_API PEAK_IPL_ColorCorrector_Construct(PEAK_IPL_COLOR_CORRECTOR_HANDLE * colorCorrectorHandle);
206  static PEAK_IPL_C_API PEAK_IPL_ColorCorrector_SetColorCorrectionFactors(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, float * colorCorrectorFactors);
207  static PEAK_IPL_C_API PEAK_IPL_ColorCorrector_GetColorCorrectionFactors(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, float * colorCorrectorFactors, size_t * colorCorrectorFactorsSize);
208  static PEAK_IPL_C_API PEAK_IPL_ColorCorrector_GetIsPixelFormatSupported(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 * isPixelFormatSupported);
209  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);
210  static PEAK_IPL_C_API PEAK_IPL_ColorCorrector_ProcessInPlace(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, PEAK_IPL_IMAGE_HANDLE imageHandle);
211  static PEAK_IPL_C_API PEAK_IPL_ColorCorrector_Destruct(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle);
212  static PEAK_IPL_C_API PEAK_IPL_Binning_Construct(PEAK_IPL_BINNING_HANDLE * binningHandle);
213  static PEAK_IPL_C_API PEAK_IPL_Binning_SetBinningX(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t * binningXValue);
214  static PEAK_IPL_C_API PEAK_IPL_Binning_GetBinningX(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t * binningXValue);
215  static PEAK_IPL_C_API PEAK_IPL_Binning_SetBinningY(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t * binningYValue);
216  static PEAK_IPL_C_API PEAK_IPL_Binning_GetBinningY(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t * binningYValue);
217  static PEAK_IPL_C_API PEAK_IPL_Binning_GetBinningMin(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t * binningMin);
218  static PEAK_IPL_C_API PEAK_IPL_Binning_GetBinningMax(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t * binningMax);
219  static PEAK_IPL_C_API PEAK_IPL_Binning_ExpectedOutputSize(PEAK_IPL_BINNING_HANDLE binningHandle, size_t * outputWidth, size_t * outputHeight, const size_t inputWidth, const size_t inputHeight, const PEAK_IPL_PIXEL_FORMAT pixelFormat);
220  static PEAK_IPL_C_API PEAK_IPL_Binning_IsPixelformatSupported(PEAK_IPL_BINNING_HANDLE binningHandle, PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 * isPixelFormatSupported);
221  static PEAK_IPL_C_API PEAK_IPL_Binning_SetBinningMode(PEAK_IPL_BINNING_HANDLE binningHandle, PEAK_IPL_BINNINGMODE * mode);
222  static PEAK_IPL_C_API PEAK_IPL_Binning_GetBinningMode(PEAK_IPL_BINNING_HANDLE binningHandle, PEAK_IPL_BINNINGMODE * mode);
223  static PEAK_IPL_C_API PEAK_IPL_Binning_Process(PEAK_IPL_BINNING_HANDLE binningHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE * outputImageHandle);
224  static PEAK_IPL_C_API PEAK_IPL_Binning_Destruct(PEAK_IPL_BINNING_HANDLE binningHandle);
225  static PEAK_IPL_C_API PEAK_IPL_Gain_Construct(PEAK_IPL_GAIN_HANDLE * gainHandle);
226  static PEAK_IPL_C_API PEAK_IPL_Gain_SetMasterGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float * masterGainValue);
227  static PEAK_IPL_C_API PEAK_IPL_Gain_GetMasterGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float * masterGainValue);
228  static PEAK_IPL_C_API PEAK_IPL_Gain_GetMasterGainMax(PEAK_IPL_GAIN_HANDLE gainHandle, float * masterGainMax);
229  static PEAK_IPL_C_API PEAK_IPL_Gain_GetMasterGainMin(PEAK_IPL_GAIN_HANDLE gainHandle, float * masterGainMin);
230  static PEAK_IPL_C_API PEAK_IPL_Gain_SetRedGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float * redGainValue);
231  static PEAK_IPL_C_API PEAK_IPL_Gain_GetRedGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float * redGainValue);
232  static PEAK_IPL_C_API PEAK_IPL_Gain_GetRedGainMax(PEAK_IPL_GAIN_HANDLE gainHandle, float * redGainMax);
233  static PEAK_IPL_C_API PEAK_IPL_Gain_GetRedGainMin(PEAK_IPL_GAIN_HANDLE gainHandle, float * redGainMin);
234  static PEAK_IPL_C_API PEAK_IPL_Gain_SetGreenGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float * greenGainValue);
235  static PEAK_IPL_C_API PEAK_IPL_Gain_GetGreenGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float * greenGainValue);
236  static PEAK_IPL_C_API PEAK_IPL_Gain_GetGreenGainMax(PEAK_IPL_GAIN_HANDLE gainHandle, float * greenGainMax);
237  static PEAK_IPL_C_API PEAK_IPL_Gain_GetGreenGainMin(PEAK_IPL_GAIN_HANDLE gainHandle, float * greenGainMin);
238  static PEAK_IPL_C_API PEAK_IPL_Gain_SetBlueGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float * blueGainValue);
239  static PEAK_IPL_C_API PEAK_IPL_Gain_GetBlueGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float * blueGainValue);
240  static PEAK_IPL_C_API PEAK_IPL_Gain_GetBlueGainMax(PEAK_IPL_GAIN_HANDLE gainHandle, float * blueGainMax);
241  static PEAK_IPL_C_API PEAK_IPL_Gain_GetBlueGainMin(PEAK_IPL_GAIN_HANDLE gainHandle, float * blueGainMin);
242  static PEAK_IPL_C_API PEAK_IPL_Gain_GetIsPixelFormatSupported(PEAK_IPL_GAIN_HANDLE gainHandle, PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 * isPixelFormatSupported);
243  static PEAK_IPL_C_API PEAK_IPL_Gain_Process(PEAK_IPL_GAIN_HANDLE gainHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE * outputImageHandle);
244  static PEAK_IPL_C_API PEAK_IPL_Gain_ProcessInPlace(PEAK_IPL_GAIN_HANDLE gainHandle, PEAK_IPL_IMAGE_HANDLE imageHandle);
245  static PEAK_IPL_C_API PEAK_IPL_Gain_Destruct(PEAK_IPL_GAIN_HANDLE gainHandle);
246  static PEAK_IPL_C_API PEAK_IPL_GammaCorrector_Construct(PEAK_IPL_GAMMA_CORRECTOR_HANDLE * gammaCorrectorHandle);
247  static PEAK_IPL_C_API PEAK_IPL_GammaCorrector_SetGammaCorrectionValue(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float * gammaValue);
248  static PEAK_IPL_C_API PEAK_IPL_GammaCorrector_GetGammaCorrectionValue(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float * gammaValue);
249  static PEAK_IPL_C_API PEAK_IPL_GammaCorrector_GetGammaCorrectionMax(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float * gammaMax);
250  static PEAK_IPL_C_API PEAK_IPL_GammaCorrector_GetGammaCorrectionMin(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float * gammaMin);
251  static PEAK_IPL_C_API PEAK_IPL_GammaCorrector_GetIsPixelFormatSupported(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 * isPixelFormatSupported);
252  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);
253  static PEAK_IPL_C_API PEAK_IPL_GammaCorrector_ProcessInPlace(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, PEAK_IPL_IMAGE_HANDLE imageHandle);
254  static PEAK_IPL_C_API PEAK_IPL_GammaCorrector_Destruct(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle);
255  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);
256  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);
257  static PEAK_IPL_C_API PEAK_IPL_Image_GetWidth(PEAK_IPL_IMAGE_HANDLE imageHandle, size_t * width);
258  static PEAK_IPL_C_API PEAK_IPL_Image_GetHeight(PEAK_IPL_IMAGE_HANDLE imageHandle, size_t * height);
259  static PEAK_IPL_C_API PEAK_IPL_Image_GetPixelPointer(PEAK_IPL_IMAGE_HANDLE imageHandle, size_t xPos, size_t yPos, uint8_t * * pixelPointer);
260  static PEAK_IPL_C_API PEAK_IPL_Image_GetByteCount(PEAK_IPL_IMAGE_HANDLE imageHandle, size_t * byteCount);
261  static PEAK_IPL_C_API PEAK_IPL_Image_GetPixelFormat(PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_PIXEL_FORMAT * pixelFormat);
262  static PEAK_IPL_C_API PEAK_IPL_Image_GetData(PEAK_IPL_IMAGE_HANDLE imageHandle, uint8_t * * data);
263  static PEAK_IPL_C_API PEAK_IPL_Image_Clone(PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE * outputImageHandle);
264  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);
265  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);
266  static PEAK_IPL_C_API PEAK_IPL_Image_Destruct(PEAK_IPL_IMAGE_HANDLE imageHandle);
267  static PEAK_IPL_C_API PEAK_IPL_ImageTransformer_Construct(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE * imageTransformerHandle);
268  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);
269  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);
270  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);
271  static PEAK_IPL_C_API PEAK_IPL_ImageTransformer_MirrorUpDownInPlace(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle, PEAK_IPL_IMAGE_HANDLE imageHandle);
272  static PEAK_IPL_C_API PEAK_IPL_ImageTransformer_MirrorLeftRightInPlace(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle, PEAK_IPL_IMAGE_HANDLE imageHandle);
273  static PEAK_IPL_C_API PEAK_IPL_ImageTransformer_MirrorUpDownLeftRightInPlace(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle, PEAK_IPL_IMAGE_HANDLE imageHandle);
274  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, PEAK_IPL_IMAGE_TRANSFORMER_ROTATION_ANGLE_t rotationAngle);
275  static PEAK_IPL_C_API PEAK_IPL_ImageTransformer_RotateInPlace(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_TRANSFORMER_ROTATION_ANGLE_t rotationAngle);
276  static PEAK_IPL_C_API PEAK_IPL_ImageTransformer_Destruct(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle);
277  static PEAK_IPL_C_API PEAK_IPL_Histogram_Construct(PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_HISTOGRAM_HANDLE * histogramHandle);
278  static PEAK_IPL_C_API PEAK_IPL_Histogram_GetPixelFormat(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle, PEAK_IPL_PIXEL_FORMAT * pixelFormat);
279  static PEAK_IPL_C_API PEAK_IPL_Histogram_GetNumChannels(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle, size_t * numChannels);
280  static PEAK_IPL_C_API PEAK_IPL_Histogram_GetPixelSumForChannel(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle, size_t channelIndex, uint64_t * pixelSum);
281  static PEAK_IPL_C_API PEAK_IPL_Histogram_GetPixelCountForChannel(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle, size_t channelIndex, uint64_t * pixelCount);
282  static PEAK_IPL_C_API PEAK_IPL_Histogram_GetBinsForChannel(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle, size_t channelIndex, uint64_t * bins, size_t * binsSize);
283  static PEAK_IPL_C_API PEAK_IPL_Histogram_Destruct(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle);
284  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);
285  static PEAK_IPL_C_API PEAK_IPL_PixelLine_GetPixelFormat(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle, PEAK_IPL_PIXEL_FORMAT * pixelFormat);
286  static PEAK_IPL_C_API PEAK_IPL_PixelLine_GetOrientation(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle, PEAK_IPL_ORIENTATION * orientation);
287  static PEAK_IPL_C_API PEAK_IPL_PixelLine_GetOffset(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle, size_t * offset);
288  static PEAK_IPL_C_API PEAK_IPL_PixelLine_GetNumChannels(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle, size_t * numChannels);
289  static PEAK_IPL_C_API PEAK_IPL_PixelLine_GetValuesForChannel(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle, size_t channelIndex, uint32_t * values, size_t * valuesSize);
290  static PEAK_IPL_C_API PEAK_IPL_PixelLine_Destruct(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle);
291  static PEAK_IPL_C_API PEAK_IPL_PixelFormat_GetNumChannels(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t * numChannels);
292  static PEAK_IPL_C_API PEAK_IPL_PixelFormat_GetNumSignificantBitsPerChannel(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t * numSignificantBits);
293  static PEAK_IPL_C_API PEAK_IPL_PixelFormat_GetNumStorageBitsPerChannel(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t * numStorageBits);
294  static PEAK_IPL_C_API PEAK_IPL_PixelFormat_GetMaximumValuePerChannel(PEAK_IPL_PIXEL_FORMAT pixelFormat, uint32_t * channelMaximumValue);
295  static PEAK_IPL_C_API PEAK_IPL_PixelFormat_GetNumSignificantBitsPerPixel(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t * numSignificantBits);
296  static PEAK_IPL_C_API PEAK_IPL_PixelFormat_GetNumStorageBitsPerPixel(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t * numStorageBits);
297  static PEAK_IPL_C_API PEAK_IPL_PixelFormat_GetEndianness(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_ENDIANNESS * endianness);
298  static PEAK_IPL_C_API PEAK_IPL_PixelFormat_CalculateStorageSizeOfPixels(PEAK_IPL_PIXEL_FORMAT pixelFormat, uint64_t numPixels, uint64_t * size);
299  static PEAK_IPL_C_API PEAK_IPL_ImageWriter_WriteAsRAW(PEAK_IPL_IMAGE_HANDLE inputImageHandle, const char * filePath, size_t filePathSize);
300  static PEAK_IPL_C_API PEAK_IPL_ImageWriter_WriteAsBMP(PEAK_IPL_IMAGE_HANDLE inputImageHandle, const char * filePath, size_t filePathSize);
301  static PEAK_IPL_C_API PEAK_IPL_ImageWriter_WriteAsPNG(PEAK_IPL_IMAGE_HANDLE inputImageHandle, uint32_t quality, const char * filePath, size_t filePathSize);
302  static PEAK_IPL_C_API PEAK_IPL_ImageWriter_WriteAsJPG(PEAK_IPL_IMAGE_HANDLE inputImageHandle, uint32_t quality, const char * filePath, size_t filePathSize);
303  static PEAK_IPL_C_API PEAK_IPL_ImageWriter_Write(PEAK_IPL_IMAGE_HANDLE inputImageHandle, const char * filePath, size_t filePathSize);
304  static PEAK_IPL_C_API PEAK_IPL_ImageReader_Read(const char * filePath, size_t filePathSize, PEAK_IPL_IMAGE_HANDLE * outputImageHandle);
305  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);
306 
307 private:
308  void* m_handle = nullptr;
309  dyn_PEAK_IPL_Library_GetVersionMajor m_PEAK_IPL_Library_GetVersionMajor{};
310  dyn_PEAK_IPL_Library_GetVersionMinor m_PEAK_IPL_Library_GetVersionMinor{};
311  dyn_PEAK_IPL_Library_GetVersionSubminor m_PEAK_IPL_Library_GetVersionSubminor{};
312  dyn_PEAK_IPL_Library_GetLastError m_PEAK_IPL_Library_GetLastError{};
313  dyn_PEAK_IPL_ImageConverter_Construct m_PEAK_IPL_ImageConverter_Construct{};
314  dyn_PEAK_IPL_ImageConverter_PreAllocateConversion m_PEAK_IPL_ImageConverter_PreAllocateConversion{};
315  dyn_PEAK_IPL_ImageConverter_GetConversionMode m_PEAK_IPL_ImageConverter_GetConversionMode{};
316  dyn_PEAK_IPL_ImageConverter_SetConversionMode m_PEAK_IPL_ImageConverter_SetConversionMode{};
317  dyn_PEAK_IPL_ImageConverter_GetSupportedOutputPixelFormats m_PEAK_IPL_ImageConverter_GetSupportedOutputPixelFormats{};
318  dyn_PEAK_IPL_ImageConverter_Convert m_PEAK_IPL_ImageConverter_Convert{};
319  dyn_PEAK_IPL_ImageConverter_ConvertToBuffer m_PEAK_IPL_ImageConverter_ConvertToBuffer{};
320  dyn_PEAK_IPL_ImageConverter_Destruct m_PEAK_IPL_ImageConverter_Destruct{};
321  dyn_PEAK_IPL_AdaptiveHotpixelCorrector_Construct m_PEAK_IPL_AdaptiveHotpixelCorrector_Construct{};
322  dyn_PEAK_IPL_AdaptiveHotpixelCorrector_SetSensitivity m_PEAK_IPL_AdaptiveHotpixelCorrector_SetSensitivity{};
323  dyn_PEAK_IPL_AdaptiveHotpixelCorrector_GetSensitivity m_PEAK_IPL_AdaptiveHotpixelCorrector_GetSensitivity{};
324  dyn_PEAK_IPL_AdaptiveHotpixelCorrector_SetGainFactorPercent m_PEAK_IPL_AdaptiveHotpixelCorrector_SetGainFactorPercent{};
325  dyn_PEAK_IPL_AdaptiveHotpixelCorrector_GetGainFactorPercent m_PEAK_IPL_AdaptiveHotpixelCorrector_GetGainFactorPercent{};
326  dyn_PEAK_IPL_AdaptiveHotpixelCorrector_Detect m_PEAK_IPL_AdaptiveHotpixelCorrector_Detect{};
327  dyn_PEAK_IPL_AdaptiveHotpixelCorrector_GetHotpixels m_PEAK_IPL_AdaptiveHotpixelCorrector_GetHotpixels{};
328  dyn_PEAK_IPL_AdaptiveHotpixelCorrector_Correct m_PEAK_IPL_AdaptiveHotpixelCorrector_Correct{};
329  dyn_PEAK_IPL_AdaptiveHotpixelCorrector_CorrectAdaptive m_PEAK_IPL_AdaptiveHotpixelCorrector_CorrectAdaptive{};
330  dyn_PEAK_IPL_AdaptiveHotpixelCorrector_Destruct m_PEAK_IPL_AdaptiveHotpixelCorrector_Destruct{};
331  dyn_PEAK_IPL_ColorCorrector_Construct m_PEAK_IPL_ColorCorrector_Construct{};
332  dyn_PEAK_IPL_ColorCorrector_SetColorCorrectionFactors m_PEAK_IPL_ColorCorrector_SetColorCorrectionFactors{};
333  dyn_PEAK_IPL_ColorCorrector_GetColorCorrectionFactors m_PEAK_IPL_ColorCorrector_GetColorCorrectionFactors{};
334  dyn_PEAK_IPL_ColorCorrector_GetIsPixelFormatSupported m_PEAK_IPL_ColorCorrector_GetIsPixelFormatSupported{};
335  dyn_PEAK_IPL_ColorCorrector_Process m_PEAK_IPL_ColorCorrector_Process{};
336  dyn_PEAK_IPL_ColorCorrector_ProcessInPlace m_PEAK_IPL_ColorCorrector_ProcessInPlace{};
337  dyn_PEAK_IPL_ColorCorrector_Destruct m_PEAK_IPL_ColorCorrector_Destruct{};
338  dyn_PEAK_IPL_Binning_Construct m_PEAK_IPL_Binning_Construct{};
339  dyn_PEAK_IPL_Binning_SetBinningX m_PEAK_IPL_Binning_SetBinningX{};
340  dyn_PEAK_IPL_Binning_GetBinningX m_PEAK_IPL_Binning_GetBinningX{};
341  dyn_PEAK_IPL_Binning_SetBinningY m_PEAK_IPL_Binning_SetBinningY{};
342  dyn_PEAK_IPL_Binning_GetBinningY m_PEAK_IPL_Binning_GetBinningY{};
343  dyn_PEAK_IPL_Binning_GetBinningMin m_PEAK_IPL_Binning_GetBinningMin{};
344  dyn_PEAK_IPL_Binning_GetBinningMax m_PEAK_IPL_Binning_GetBinningMax{};
345  dyn_PEAK_IPL_Binning_ExpectedOutputSize m_PEAK_IPL_Binning_ExpectedOutputSize{};
346  dyn_PEAK_IPL_Binning_IsPixelformatSupported m_PEAK_IPL_Binning_IsPixelformatSupported{};
347  dyn_PEAK_IPL_Binning_SetBinningMode m_PEAK_IPL_Binning_SetBinningMode{};
348  dyn_PEAK_IPL_Binning_GetBinningMode m_PEAK_IPL_Binning_GetBinningMode{};
349  dyn_PEAK_IPL_Binning_Process m_PEAK_IPL_Binning_Process{};
350  dyn_PEAK_IPL_Binning_Destruct m_PEAK_IPL_Binning_Destruct{};
351  dyn_PEAK_IPL_Gain_Construct m_PEAK_IPL_Gain_Construct{};
352  dyn_PEAK_IPL_Gain_SetMasterGainValue m_PEAK_IPL_Gain_SetMasterGainValue{};
353  dyn_PEAK_IPL_Gain_GetMasterGainValue m_PEAK_IPL_Gain_GetMasterGainValue{};
354  dyn_PEAK_IPL_Gain_GetMasterGainMax m_PEAK_IPL_Gain_GetMasterGainMax{};
355  dyn_PEAK_IPL_Gain_GetMasterGainMin m_PEAK_IPL_Gain_GetMasterGainMin{};
356  dyn_PEAK_IPL_Gain_SetRedGainValue m_PEAK_IPL_Gain_SetRedGainValue{};
357  dyn_PEAK_IPL_Gain_GetRedGainValue m_PEAK_IPL_Gain_GetRedGainValue{};
358  dyn_PEAK_IPL_Gain_GetRedGainMax m_PEAK_IPL_Gain_GetRedGainMax{};
359  dyn_PEAK_IPL_Gain_GetRedGainMin m_PEAK_IPL_Gain_GetRedGainMin{};
360  dyn_PEAK_IPL_Gain_SetGreenGainValue m_PEAK_IPL_Gain_SetGreenGainValue{};
361  dyn_PEAK_IPL_Gain_GetGreenGainValue m_PEAK_IPL_Gain_GetGreenGainValue{};
362  dyn_PEAK_IPL_Gain_GetGreenGainMax m_PEAK_IPL_Gain_GetGreenGainMax{};
363  dyn_PEAK_IPL_Gain_GetGreenGainMin m_PEAK_IPL_Gain_GetGreenGainMin{};
364  dyn_PEAK_IPL_Gain_SetBlueGainValue m_PEAK_IPL_Gain_SetBlueGainValue{};
365  dyn_PEAK_IPL_Gain_GetBlueGainValue m_PEAK_IPL_Gain_GetBlueGainValue{};
366  dyn_PEAK_IPL_Gain_GetBlueGainMax m_PEAK_IPL_Gain_GetBlueGainMax{};
367  dyn_PEAK_IPL_Gain_GetBlueGainMin m_PEAK_IPL_Gain_GetBlueGainMin{};
368  dyn_PEAK_IPL_Gain_GetIsPixelFormatSupported m_PEAK_IPL_Gain_GetIsPixelFormatSupported{};
369  dyn_PEAK_IPL_Gain_Process m_PEAK_IPL_Gain_Process{};
370  dyn_PEAK_IPL_Gain_ProcessInPlace m_PEAK_IPL_Gain_ProcessInPlace{};
371  dyn_PEAK_IPL_Gain_Destruct m_PEAK_IPL_Gain_Destruct{};
372  dyn_PEAK_IPL_GammaCorrector_Construct m_PEAK_IPL_GammaCorrector_Construct{};
373  dyn_PEAK_IPL_GammaCorrector_SetGammaCorrectionValue m_PEAK_IPL_GammaCorrector_SetGammaCorrectionValue{};
374  dyn_PEAK_IPL_GammaCorrector_GetGammaCorrectionValue m_PEAK_IPL_GammaCorrector_GetGammaCorrectionValue{};
375  dyn_PEAK_IPL_GammaCorrector_GetGammaCorrectionMax m_PEAK_IPL_GammaCorrector_GetGammaCorrectionMax{};
376  dyn_PEAK_IPL_GammaCorrector_GetGammaCorrectionMin m_PEAK_IPL_GammaCorrector_GetGammaCorrectionMin{};
377  dyn_PEAK_IPL_GammaCorrector_GetIsPixelFormatSupported m_PEAK_IPL_GammaCorrector_GetIsPixelFormatSupported{};
378  dyn_PEAK_IPL_GammaCorrector_Process m_PEAK_IPL_GammaCorrector_Process{};
379  dyn_PEAK_IPL_GammaCorrector_ProcessInPlace m_PEAK_IPL_GammaCorrector_ProcessInPlace{};
380  dyn_PEAK_IPL_GammaCorrector_Destruct m_PEAK_IPL_GammaCorrector_Destruct{};
381  dyn_PEAK_IPL_Image_Construct m_PEAK_IPL_Image_Construct{};
382  dyn_PEAK_IPL_Image_ConstructFromBuffer m_PEAK_IPL_Image_ConstructFromBuffer{};
383  dyn_PEAK_IPL_Image_GetWidth m_PEAK_IPL_Image_GetWidth{};
384  dyn_PEAK_IPL_Image_GetHeight m_PEAK_IPL_Image_GetHeight{};
385  dyn_PEAK_IPL_Image_GetPixelPointer m_PEAK_IPL_Image_GetPixelPointer{};
386  dyn_PEAK_IPL_Image_GetByteCount m_PEAK_IPL_Image_GetByteCount{};
387  dyn_PEAK_IPL_Image_GetPixelFormat m_PEAK_IPL_Image_GetPixelFormat{};
388  dyn_PEAK_IPL_Image_GetData m_PEAK_IPL_Image_GetData{};
389  dyn_PEAK_IPL_Image_Clone m_PEAK_IPL_Image_Clone{};
390  dyn_PEAK_IPL_Image_ConvertTo m_PEAK_IPL_Image_ConvertTo{};
391  dyn_PEAK_IPL_Image_ConvertToBuffer m_PEAK_IPL_Image_ConvertToBuffer{};
392  dyn_PEAK_IPL_Image_Destruct m_PEAK_IPL_Image_Destruct{};
393  dyn_PEAK_IPL_ImageTransformer_Construct m_PEAK_IPL_ImageTransformer_Construct{};
394  dyn_PEAK_IPL_ImageTransformer_MirrorUpDown m_PEAK_IPL_ImageTransformer_MirrorUpDown{};
395  dyn_PEAK_IPL_ImageTransformer_MirrorLeftRight m_PEAK_IPL_ImageTransformer_MirrorLeftRight{};
396  dyn_PEAK_IPL_ImageTransformer_MirrorUpDownLeftRight m_PEAK_IPL_ImageTransformer_MirrorUpDownLeftRight{};
397  dyn_PEAK_IPL_ImageTransformer_MirrorUpDownInPlace m_PEAK_IPL_ImageTransformer_MirrorUpDownInPlace{};
398  dyn_PEAK_IPL_ImageTransformer_MirrorLeftRightInPlace m_PEAK_IPL_ImageTransformer_MirrorLeftRightInPlace{};
399  dyn_PEAK_IPL_ImageTransformer_MirrorUpDownLeftRightInPlace m_PEAK_IPL_ImageTransformer_MirrorUpDownLeftRightInPlace{};
400  dyn_PEAK_IPL_ImageTransformer_Rotate m_PEAK_IPL_ImageTransformer_Rotate{};
401  dyn_PEAK_IPL_ImageTransformer_RotateInPlace m_PEAK_IPL_ImageTransformer_RotateInPlace{};
402  dyn_PEAK_IPL_ImageTransformer_Destruct m_PEAK_IPL_ImageTransformer_Destruct{};
403  dyn_PEAK_IPL_Histogram_Construct m_PEAK_IPL_Histogram_Construct{};
404  dyn_PEAK_IPL_Histogram_GetPixelFormat m_PEAK_IPL_Histogram_GetPixelFormat{};
405  dyn_PEAK_IPL_Histogram_GetNumChannels m_PEAK_IPL_Histogram_GetNumChannels{};
406  dyn_PEAK_IPL_Histogram_GetPixelSumForChannel m_PEAK_IPL_Histogram_GetPixelSumForChannel{};
407  dyn_PEAK_IPL_Histogram_GetPixelCountForChannel m_PEAK_IPL_Histogram_GetPixelCountForChannel{};
408  dyn_PEAK_IPL_Histogram_GetBinsForChannel m_PEAK_IPL_Histogram_GetBinsForChannel{};
409  dyn_PEAK_IPL_Histogram_Destruct m_PEAK_IPL_Histogram_Destruct{};
410  dyn_PEAK_IPL_PixelLine_Construct m_PEAK_IPL_PixelLine_Construct{};
411  dyn_PEAK_IPL_PixelLine_GetPixelFormat m_PEAK_IPL_PixelLine_GetPixelFormat{};
412  dyn_PEAK_IPL_PixelLine_GetOrientation m_PEAK_IPL_PixelLine_GetOrientation{};
413  dyn_PEAK_IPL_PixelLine_GetOffset m_PEAK_IPL_PixelLine_GetOffset{};
414  dyn_PEAK_IPL_PixelLine_GetNumChannels m_PEAK_IPL_PixelLine_GetNumChannels{};
415  dyn_PEAK_IPL_PixelLine_GetValuesForChannel m_PEAK_IPL_PixelLine_GetValuesForChannel{};
416  dyn_PEAK_IPL_PixelLine_Destruct m_PEAK_IPL_PixelLine_Destruct{};
417  dyn_PEAK_IPL_PixelFormat_GetNumChannels m_PEAK_IPL_PixelFormat_GetNumChannels{};
418  dyn_PEAK_IPL_PixelFormat_GetNumSignificantBitsPerChannel m_PEAK_IPL_PixelFormat_GetNumSignificantBitsPerChannel{};
419  dyn_PEAK_IPL_PixelFormat_GetNumStorageBitsPerChannel m_PEAK_IPL_PixelFormat_GetNumStorageBitsPerChannel{};
420  dyn_PEAK_IPL_PixelFormat_GetMaximumValuePerChannel m_PEAK_IPL_PixelFormat_GetMaximumValuePerChannel{};
421  dyn_PEAK_IPL_PixelFormat_GetNumSignificantBitsPerPixel m_PEAK_IPL_PixelFormat_GetNumSignificantBitsPerPixel{};
422  dyn_PEAK_IPL_PixelFormat_GetNumStorageBitsPerPixel m_PEAK_IPL_PixelFormat_GetNumStorageBitsPerPixel{};
423  dyn_PEAK_IPL_PixelFormat_GetEndianness m_PEAK_IPL_PixelFormat_GetEndianness{};
424  dyn_PEAK_IPL_PixelFormat_CalculateStorageSizeOfPixels m_PEAK_IPL_PixelFormat_CalculateStorageSizeOfPixels{};
425  dyn_PEAK_IPL_ImageWriter_WriteAsRAW m_PEAK_IPL_ImageWriter_WriteAsRAW{};
426  dyn_PEAK_IPL_ImageWriter_WriteAsBMP m_PEAK_IPL_ImageWriter_WriteAsBMP{};
427  dyn_PEAK_IPL_ImageWriter_WriteAsPNG m_PEAK_IPL_ImageWriter_WriteAsPNG{};
428  dyn_PEAK_IPL_ImageWriter_WriteAsJPG m_PEAK_IPL_ImageWriter_WriteAsJPG{};
429  dyn_PEAK_IPL_ImageWriter_Write m_PEAK_IPL_ImageWriter_Write{};
430  dyn_PEAK_IPL_ImageReader_Read m_PEAK_IPL_ImageReader_Read{};
431  dyn_PEAK_IPL_ImageReaderRead_ReadAsPixelFormat m_PEAK_IPL_ImageReaderRead_ReadAsPixelFormat{};
432 
433 };
434 
435 inline void* import_function(void *module, const char* proc_name)
436 {
437 #ifdef __linux__
438  return dlsym(module, proc_name);
439 #else
440  return GetProcAddress(static_cast<HMODULE>(module), proc_name);
441 #endif
442 }
443 
444 inline DynamicLoader::DynamicLoader()
445 {
446 #if defined _WIN32 || defined _WIN64
447  size_t sz = 0;
448  if (_wgetenv_s(&sz, NULL, 0, L"IDS_PEAK_GENERIC_SDK_PATH") == 0
449  && sz > 0)
450  {
451  std::vector<wchar_t> env_ids_peak_ipl(sz);
452  if (_wgetenv_s(&sz, env_ids_peak_ipl.data(), sz, L"IDS_PEAK_GENERIC_SDK_PATH") == 0)
453  {
454  if (_wgetenv_s(&sz, NULL, 0, L"PATH") == 0
455  && sz > 0)
456  {
457  std::vector<wchar_t> env_path(sz);
458  if (_wgetenv_s(&sz, env_path.data(), sz, L"PATH") == 0)
459  {
460  std::wstring ids_peak_ipl_path(env_ids_peak_ipl.data());
461 #ifdef _WIN64
462  ids_peak_ipl_path.append(L"\\ipl\\lib\\x86_64");
463 #else
464  ids_peak_ipl_path.append(L"\\ipl\\lib\\x86_32");
465 #endif
466  std::wstring path_var(env_path.data());
467  path_var.append(L";").append(ids_peak_ipl_path);
468  _wputenv_s(L"PATH", path_var.c_str());
469  }
470  }
471  }
472  }
473 
474  loadLib("ids_peak_ipl.dll");
475 #else
476  loadLib("libids_peak_ipl.so");
477 #endif
478 }
479 
480 inline DynamicLoader::~DynamicLoader()
481 {
482  if(m_handle != nullptr)
483  {
484  unload();
485  }
486 }
487 
488 inline bool DynamicLoader::isLoaded()
489 {
490  auto&& inst = instance();
491  return inst.m_handle != nullptr;
492 }
493 
494 inline void DynamicLoader::unload()
495 {
496  setPointers(false);
497 
498  if (m_handle != nullptr)
499  {
500 #ifdef __linux__
501  dlclose(m_handle);
502 #else
503  FreeLibrary(static_cast<HMODULE>(m_handle));
504 #endif
505  }
506  m_handle = nullptr;
507 }
508 
509 
510 inline bool DynamicLoader::loadLib(const char* file)
511 {
512  bool ret = false;
513 
514  if (file)
515  {
516 #ifdef __linux__
517  m_handle = dlopen(file, RTLD_NOW);
518 #else
519  m_handle = LoadLibraryA(file);
520 #endif
521  if (m_handle != nullptr)
522  {
523  try {
524  setPointers(true);
525  ret = true;
526  } catch (const std::exception&) {
527  unload();
528  throw;
529  }
530  }
531  else
532  {
533  throw std::runtime_error(std::string("Lib load failed: ") + file);
534  }
535  }
536  else
537  {
538  throw std::runtime_error("Filename empty");
539  }
540 
541  return ret;
542 }
543 
544 inline bool DynamicLoader::setPointers(bool load)
545 {
546 
547  m_PEAK_IPL_Library_GetVersionMajor = (dyn_PEAK_IPL_Library_GetVersionMajor) (load ? import_function(m_handle, "PEAK_IPL_Library_GetVersionMajor") : nullptr);
548  if(m_PEAK_IPL_Library_GetVersionMajor == nullptr && load)
549  {
550  throw std::runtime_error("Failed to load PEAK_IPL_Library_GetVersionMajor");
551  }
552 
553  m_PEAK_IPL_Library_GetVersionMinor = (dyn_PEAK_IPL_Library_GetVersionMinor) (load ? import_function(m_handle, "PEAK_IPL_Library_GetVersionMinor") : nullptr);
554  if(m_PEAK_IPL_Library_GetVersionMinor == nullptr && load)
555  {
556  throw std::runtime_error("Failed to load PEAK_IPL_Library_GetVersionMinor");
557  }
558 
559  m_PEAK_IPL_Library_GetVersionSubminor = (dyn_PEAK_IPL_Library_GetVersionSubminor) (load ? import_function(m_handle, "PEAK_IPL_Library_GetVersionSubminor") : nullptr);
560  if(m_PEAK_IPL_Library_GetVersionSubminor == nullptr && load)
561  {
562  throw std::runtime_error("Failed to load PEAK_IPL_Library_GetVersionSubminor");
563  }
564 
565  m_PEAK_IPL_Library_GetLastError = (dyn_PEAK_IPL_Library_GetLastError) (load ? import_function(m_handle, "PEAK_IPL_Library_GetLastError") : nullptr);
566  if(m_PEAK_IPL_Library_GetLastError == nullptr && load)
567  {
568  throw std::runtime_error("Failed to load PEAK_IPL_Library_GetLastError");
569  }
570 
571  m_PEAK_IPL_ImageConverter_Construct = (dyn_PEAK_IPL_ImageConverter_Construct) (load ? import_function(m_handle, "PEAK_IPL_ImageConverter_Construct") : nullptr);
572  if(m_PEAK_IPL_ImageConverter_Construct == nullptr && load)
573  {
574  throw std::runtime_error("Failed to load PEAK_IPL_ImageConverter_Construct");
575  }
576 
577  m_PEAK_IPL_ImageConverter_PreAllocateConversion = (dyn_PEAK_IPL_ImageConverter_PreAllocateConversion) (load ? import_function(m_handle, "PEAK_IPL_ImageConverter_PreAllocateConversion") : nullptr);
578  if(m_PEAK_IPL_ImageConverter_PreAllocateConversion == nullptr && load)
579  {
580  throw std::runtime_error("Failed to load PEAK_IPL_ImageConverter_PreAllocateConversion");
581  }
582 
583  m_PEAK_IPL_ImageConverter_GetConversionMode = (dyn_PEAK_IPL_ImageConverter_GetConversionMode) (load ? import_function(m_handle, "PEAK_IPL_ImageConverter_GetConversionMode") : nullptr);
584  if(m_PEAK_IPL_ImageConverter_GetConversionMode == nullptr && load)
585  {
586  throw std::runtime_error("Failed to load PEAK_IPL_ImageConverter_GetConversionMode");
587  }
588 
589  m_PEAK_IPL_ImageConverter_SetConversionMode = (dyn_PEAK_IPL_ImageConverter_SetConversionMode) (load ? import_function(m_handle, "PEAK_IPL_ImageConverter_SetConversionMode") : nullptr);
590  if(m_PEAK_IPL_ImageConverter_SetConversionMode == nullptr && load)
591  {
592  throw std::runtime_error("Failed to load PEAK_IPL_ImageConverter_SetConversionMode");
593  }
594 
595  m_PEAK_IPL_ImageConverter_GetSupportedOutputPixelFormats = (dyn_PEAK_IPL_ImageConverter_GetSupportedOutputPixelFormats) (load ? import_function(m_handle, "PEAK_IPL_ImageConverter_GetSupportedOutputPixelFormats") : nullptr);
596  if(m_PEAK_IPL_ImageConverter_GetSupportedOutputPixelFormats == nullptr && load)
597  {
598  throw std::runtime_error("Failed to load PEAK_IPL_ImageConverter_GetSupportedOutputPixelFormats");
599  }
600 
601  m_PEAK_IPL_ImageConverter_Convert = (dyn_PEAK_IPL_ImageConverter_Convert) (load ? import_function(m_handle, "PEAK_IPL_ImageConverter_Convert") : nullptr);
602  if(m_PEAK_IPL_ImageConverter_Convert == nullptr && load)
603  {
604  throw std::runtime_error("Failed to load PEAK_IPL_ImageConverter_Convert");
605  }
606 
607  m_PEAK_IPL_ImageConverter_ConvertToBuffer = (dyn_PEAK_IPL_ImageConverter_ConvertToBuffer) (load ? import_function(m_handle, "PEAK_IPL_ImageConverter_ConvertToBuffer") : nullptr);
608  if(m_PEAK_IPL_ImageConverter_ConvertToBuffer == nullptr && load)
609  {
610  throw std::runtime_error("Failed to load PEAK_IPL_ImageConverter_ConvertToBuffer");
611  }
612 
613  m_PEAK_IPL_ImageConverter_Destruct = (dyn_PEAK_IPL_ImageConverter_Destruct) (load ? import_function(m_handle, "PEAK_IPL_ImageConverter_Destruct") : nullptr);
614  if(m_PEAK_IPL_ImageConverter_Destruct == nullptr && load)
615  {
616  throw std::runtime_error("Failed to load PEAK_IPL_ImageConverter_Destruct");
617  }
618 
619  m_PEAK_IPL_AdaptiveHotpixelCorrector_Construct = (dyn_PEAK_IPL_AdaptiveHotpixelCorrector_Construct) (load ? import_function(m_handle, "PEAK_IPL_AdaptiveHotpixelCorrector_Construct") : nullptr);
620  if(m_PEAK_IPL_AdaptiveHotpixelCorrector_Construct == nullptr && load)
621  {
622  throw std::runtime_error("Failed to load PEAK_IPL_AdaptiveHotpixelCorrector_Construct");
623  }
624 
625  m_PEAK_IPL_AdaptiveHotpixelCorrector_SetSensitivity = (dyn_PEAK_IPL_AdaptiveHotpixelCorrector_SetSensitivity) (load ? import_function(m_handle, "PEAK_IPL_AdaptiveHotpixelCorrector_SetSensitivity") : nullptr);
626  if(m_PEAK_IPL_AdaptiveHotpixelCorrector_SetSensitivity == nullptr && load)
627  {
628  throw std::runtime_error("Failed to load PEAK_IPL_AdaptiveHotpixelCorrector_SetSensitivity");
629  }
630 
631  m_PEAK_IPL_AdaptiveHotpixelCorrector_GetSensitivity = (dyn_PEAK_IPL_AdaptiveHotpixelCorrector_GetSensitivity) (load ? import_function(m_handle, "PEAK_IPL_AdaptiveHotpixelCorrector_GetSensitivity") : nullptr);
632  if(m_PEAK_IPL_AdaptiveHotpixelCorrector_GetSensitivity == nullptr && load)
633  {
634  throw std::runtime_error("Failed to load PEAK_IPL_AdaptiveHotpixelCorrector_GetSensitivity");
635  }
636 
637  m_PEAK_IPL_AdaptiveHotpixelCorrector_SetGainFactorPercent = (dyn_PEAK_IPL_AdaptiveHotpixelCorrector_SetGainFactorPercent) (load ? import_function(m_handle, "PEAK_IPL_AdaptiveHotpixelCorrector_SetGainFactorPercent") : nullptr);
638  if(m_PEAK_IPL_AdaptiveHotpixelCorrector_SetGainFactorPercent == nullptr && load)
639  {
640  throw std::runtime_error("Failed to load PEAK_IPL_AdaptiveHotpixelCorrector_SetGainFactorPercent");
641  }
642 
643  m_PEAK_IPL_AdaptiveHotpixelCorrector_GetGainFactorPercent = (dyn_PEAK_IPL_AdaptiveHotpixelCorrector_GetGainFactorPercent) (load ? import_function(m_handle, "PEAK_IPL_AdaptiveHotpixelCorrector_GetGainFactorPercent") : nullptr);
644  if(m_PEAK_IPL_AdaptiveHotpixelCorrector_GetGainFactorPercent == nullptr && load)
645  {
646  throw std::runtime_error("Failed to load PEAK_IPL_AdaptiveHotpixelCorrector_GetGainFactorPercent");
647  }
648 
649  m_PEAK_IPL_AdaptiveHotpixelCorrector_Detect = (dyn_PEAK_IPL_AdaptiveHotpixelCorrector_Detect) (load ? import_function(m_handle, "PEAK_IPL_AdaptiveHotpixelCorrector_Detect") : nullptr);
650  if(m_PEAK_IPL_AdaptiveHotpixelCorrector_Detect == nullptr && load)
651  {
652  throw std::runtime_error("Failed to load PEAK_IPL_AdaptiveHotpixelCorrector_Detect");
653  }
654 
655  m_PEAK_IPL_AdaptiveHotpixelCorrector_GetHotpixels = (dyn_PEAK_IPL_AdaptiveHotpixelCorrector_GetHotpixels) (load ? import_function(m_handle, "PEAK_IPL_AdaptiveHotpixelCorrector_GetHotpixels") : nullptr);
656  if(m_PEAK_IPL_AdaptiveHotpixelCorrector_GetHotpixels == nullptr && load)
657  {
658  throw std::runtime_error("Failed to load PEAK_IPL_AdaptiveHotpixelCorrector_GetHotpixels");
659  }
660 
661  m_PEAK_IPL_AdaptiveHotpixelCorrector_Correct = (dyn_PEAK_IPL_AdaptiveHotpixelCorrector_Correct) (load ? import_function(m_handle, "PEAK_IPL_AdaptiveHotpixelCorrector_Correct") : nullptr);
662  if(m_PEAK_IPL_AdaptiveHotpixelCorrector_Correct == nullptr && load)
663  {
664  throw std::runtime_error("Failed to load PEAK_IPL_AdaptiveHotpixelCorrector_Correct");
665  }
666 
667  m_PEAK_IPL_AdaptiveHotpixelCorrector_CorrectAdaptive = (dyn_PEAK_IPL_AdaptiveHotpixelCorrector_CorrectAdaptive) (load ? import_function(m_handle, "PEAK_IPL_AdaptiveHotpixelCorrector_CorrectAdaptive") : nullptr);
668  if(m_PEAK_IPL_AdaptiveHotpixelCorrector_CorrectAdaptive == nullptr && load)
669  {
670  throw std::runtime_error("Failed to load PEAK_IPL_AdaptiveHotpixelCorrector_CorrectAdaptive");
671  }
672 
673  m_PEAK_IPL_AdaptiveHotpixelCorrector_Destruct = (dyn_PEAK_IPL_AdaptiveHotpixelCorrector_Destruct) (load ? import_function(m_handle, "PEAK_IPL_AdaptiveHotpixelCorrector_Destruct") : nullptr);
674  if(m_PEAK_IPL_AdaptiveHotpixelCorrector_Destruct == nullptr && load)
675  {
676  throw std::runtime_error("Failed to load PEAK_IPL_AdaptiveHotpixelCorrector_Destruct");
677  }
678 
679  m_PEAK_IPL_ColorCorrector_Construct = (dyn_PEAK_IPL_ColorCorrector_Construct) (load ? import_function(m_handle, "PEAK_IPL_ColorCorrector_Construct") : nullptr);
680  if(m_PEAK_IPL_ColorCorrector_Construct == nullptr && load)
681  {
682  throw std::runtime_error("Failed to load PEAK_IPL_ColorCorrector_Construct");
683  }
684 
685  m_PEAK_IPL_ColorCorrector_SetColorCorrectionFactors = (dyn_PEAK_IPL_ColorCorrector_SetColorCorrectionFactors) (load ? import_function(m_handle, "PEAK_IPL_ColorCorrector_SetColorCorrectionFactors") : nullptr);
686  if(m_PEAK_IPL_ColorCorrector_SetColorCorrectionFactors == nullptr && load)
687  {
688  throw std::runtime_error("Failed to load PEAK_IPL_ColorCorrector_SetColorCorrectionFactors");
689  }
690 
691  m_PEAK_IPL_ColorCorrector_GetColorCorrectionFactors = (dyn_PEAK_IPL_ColorCorrector_GetColorCorrectionFactors) (load ? import_function(m_handle, "PEAK_IPL_ColorCorrector_GetColorCorrectionFactors") : nullptr);
692  if(m_PEAK_IPL_ColorCorrector_GetColorCorrectionFactors == nullptr && load)
693  {
694  throw std::runtime_error("Failed to load PEAK_IPL_ColorCorrector_GetColorCorrectionFactors");
695  }
696 
697  m_PEAK_IPL_ColorCorrector_GetIsPixelFormatSupported = (dyn_PEAK_IPL_ColorCorrector_GetIsPixelFormatSupported) (load ? import_function(m_handle, "PEAK_IPL_ColorCorrector_GetIsPixelFormatSupported") : nullptr);
698  if(m_PEAK_IPL_ColorCorrector_GetIsPixelFormatSupported == nullptr && load)
699  {
700  throw std::runtime_error("Failed to load PEAK_IPL_ColorCorrector_GetIsPixelFormatSupported");
701  }
702 
703  m_PEAK_IPL_ColorCorrector_Process = (dyn_PEAK_IPL_ColorCorrector_Process) (load ? import_function(m_handle, "PEAK_IPL_ColorCorrector_Process") : nullptr);
704  if(m_PEAK_IPL_ColorCorrector_Process == nullptr && load)
705  {
706  throw std::runtime_error("Failed to load PEAK_IPL_ColorCorrector_Process");
707  }
708 
709  m_PEAK_IPL_ColorCorrector_ProcessInPlace = (dyn_PEAK_IPL_ColorCorrector_ProcessInPlace) (load ? import_function(m_handle, "PEAK_IPL_ColorCorrector_ProcessInPlace") : nullptr);
710  if(m_PEAK_IPL_ColorCorrector_ProcessInPlace == nullptr && load)
711  {
712  throw std::runtime_error("Failed to load PEAK_IPL_ColorCorrector_ProcessInPlace");
713  }
714 
715  m_PEAK_IPL_ColorCorrector_Destruct = (dyn_PEAK_IPL_ColorCorrector_Destruct) (load ? import_function(m_handle, "PEAK_IPL_ColorCorrector_Destruct") : nullptr);
716  if(m_PEAK_IPL_ColorCorrector_Destruct == nullptr && load)
717  {
718  throw std::runtime_error("Failed to load PEAK_IPL_ColorCorrector_Destruct");
719  }
720 
721  m_PEAK_IPL_Binning_Construct = (dyn_PEAK_IPL_Binning_Construct) (load ? import_function(m_handle, "PEAK_IPL_Binning_Construct") : nullptr);
722  if(m_PEAK_IPL_Binning_Construct == nullptr && load)
723  {
724  throw std::runtime_error("Failed to load PEAK_IPL_Binning_Construct");
725  }
726 
727  m_PEAK_IPL_Binning_SetBinningX = (dyn_PEAK_IPL_Binning_SetBinningX) (load ? import_function(m_handle, "PEAK_IPL_Binning_SetBinningX") : nullptr);
728  if(m_PEAK_IPL_Binning_SetBinningX == nullptr && load)
729  {
730  throw std::runtime_error("Failed to load PEAK_IPL_Binning_SetBinningX");
731  }
732 
733  m_PEAK_IPL_Binning_GetBinningX = (dyn_PEAK_IPL_Binning_GetBinningX) (load ? import_function(m_handle, "PEAK_IPL_Binning_GetBinningX") : nullptr);
734  if(m_PEAK_IPL_Binning_GetBinningX == nullptr && load)
735  {
736  throw std::runtime_error("Failed to load PEAK_IPL_Binning_GetBinningX");
737  }
738 
739  m_PEAK_IPL_Binning_SetBinningY = (dyn_PEAK_IPL_Binning_SetBinningY) (load ? import_function(m_handle, "PEAK_IPL_Binning_SetBinningY") : nullptr);
740  if(m_PEAK_IPL_Binning_SetBinningY == nullptr && load)
741  {
742  throw std::runtime_error("Failed to load PEAK_IPL_Binning_SetBinningY");
743  }
744 
745  m_PEAK_IPL_Binning_GetBinningY = (dyn_PEAK_IPL_Binning_GetBinningY) (load ? import_function(m_handle, "PEAK_IPL_Binning_GetBinningY") : nullptr);
746  if(m_PEAK_IPL_Binning_GetBinningY == nullptr && load)
747  {
748  throw std::runtime_error("Failed to load PEAK_IPL_Binning_GetBinningY");
749  }
750 
751  m_PEAK_IPL_Binning_GetBinningMin = (dyn_PEAK_IPL_Binning_GetBinningMin) (load ? import_function(m_handle, "PEAK_IPL_Binning_GetBinningMin") : nullptr);
752  if(m_PEAK_IPL_Binning_GetBinningMin == nullptr && load)
753  {
754  throw std::runtime_error("Failed to load PEAK_IPL_Binning_GetBinningMin");
755  }
756 
757  m_PEAK_IPL_Binning_GetBinningMax = (dyn_PEAK_IPL_Binning_GetBinningMax) (load ? import_function(m_handle, "PEAK_IPL_Binning_GetBinningMax") : nullptr);
758  if(m_PEAK_IPL_Binning_GetBinningMax == nullptr && load)
759  {
760  throw std::runtime_error("Failed to load PEAK_IPL_Binning_GetBinningMax");
761  }
762 
763  m_PEAK_IPL_Binning_ExpectedOutputSize = (dyn_PEAK_IPL_Binning_ExpectedOutputSize) (load ? import_function(m_handle, "PEAK_IPL_Binning_ExpectedOutputSize") : nullptr);
764  if(m_PEAK_IPL_Binning_ExpectedOutputSize == nullptr && load)
765  {
766  throw std::runtime_error("Failed to load PEAK_IPL_Binning_ExpectedOutputSize");
767  }
768 
769  m_PEAK_IPL_Binning_IsPixelformatSupported = (dyn_PEAK_IPL_Binning_IsPixelformatSupported) (load ? import_function(m_handle, "PEAK_IPL_Binning_IsPixelformatSupported") : nullptr);
770  if(m_PEAK_IPL_Binning_IsPixelformatSupported == nullptr && load)
771  {
772  throw std::runtime_error("Failed to load PEAK_IPL_Binning_IsPixelformatSupported");
773  }
774 
775  m_PEAK_IPL_Binning_SetBinningMode = (dyn_PEAK_IPL_Binning_SetBinningMode) (load ? import_function(m_handle, "PEAK_IPL_Binning_SetBinningMode") : nullptr);
776  if(m_PEAK_IPL_Binning_SetBinningMode == nullptr && load)
777  {
778  throw std::runtime_error("Failed to load PEAK_IPL_Binning_SetBinningMode");
779  }
780 
781  m_PEAK_IPL_Binning_GetBinningMode = (dyn_PEAK_IPL_Binning_GetBinningMode) (load ? import_function(m_handle, "PEAK_IPL_Binning_GetBinningMode") : nullptr);
782  if(m_PEAK_IPL_Binning_GetBinningMode == nullptr && load)
783  {
784  throw std::runtime_error("Failed to load PEAK_IPL_Binning_GetBinningMode");
785  }
786 
787  m_PEAK_IPL_Binning_Process = (dyn_PEAK_IPL_Binning_Process) (load ? import_function(m_handle, "PEAK_IPL_Binning_Process") : nullptr);
788  if(m_PEAK_IPL_Binning_Process == nullptr && load)
789  {
790  throw std::runtime_error("Failed to load PEAK_IPL_Binning_Process");
791  }
792 
793  m_PEAK_IPL_Binning_Destruct = (dyn_PEAK_IPL_Binning_Destruct) (load ? import_function(m_handle, "PEAK_IPL_Binning_Destruct") : nullptr);
794  if(m_PEAK_IPL_Binning_Destruct == nullptr && load)
795  {
796  throw std::runtime_error("Failed to load PEAK_IPL_Binning_Destruct");
797  }
798 
799  m_PEAK_IPL_Gain_Construct = (dyn_PEAK_IPL_Gain_Construct) (load ? import_function(m_handle, "PEAK_IPL_Gain_Construct") : nullptr);
800  if(m_PEAK_IPL_Gain_Construct == nullptr && load)
801  {
802  throw std::runtime_error("Failed to load PEAK_IPL_Gain_Construct");
803  }
804 
805  m_PEAK_IPL_Gain_SetMasterGainValue = (dyn_PEAK_IPL_Gain_SetMasterGainValue) (load ? import_function(m_handle, "PEAK_IPL_Gain_SetMasterGainValue") : nullptr);
806  if(m_PEAK_IPL_Gain_SetMasterGainValue == nullptr && load)
807  {
808  throw std::runtime_error("Failed to load PEAK_IPL_Gain_SetMasterGainValue");
809  }
810 
811  m_PEAK_IPL_Gain_GetMasterGainValue = (dyn_PEAK_IPL_Gain_GetMasterGainValue) (load ? import_function(m_handle, "PEAK_IPL_Gain_GetMasterGainValue") : nullptr);
812  if(m_PEAK_IPL_Gain_GetMasterGainValue == nullptr && load)
813  {
814  throw std::runtime_error("Failed to load PEAK_IPL_Gain_GetMasterGainValue");
815  }
816 
817  m_PEAK_IPL_Gain_GetMasterGainMax = (dyn_PEAK_IPL_Gain_GetMasterGainMax) (load ? import_function(m_handle, "PEAK_IPL_Gain_GetMasterGainMax") : nullptr);
818  if(m_PEAK_IPL_Gain_GetMasterGainMax == nullptr && load)
819  {
820  throw std::runtime_error("Failed to load PEAK_IPL_Gain_GetMasterGainMax");
821  }
822 
823  m_PEAK_IPL_Gain_GetMasterGainMin = (dyn_PEAK_IPL_Gain_GetMasterGainMin) (load ? import_function(m_handle, "PEAK_IPL_Gain_GetMasterGainMin") : nullptr);
824  if(m_PEAK_IPL_Gain_GetMasterGainMin == nullptr && load)
825  {
826  throw std::runtime_error("Failed to load PEAK_IPL_Gain_GetMasterGainMin");
827  }
828 
829  m_PEAK_IPL_Gain_SetRedGainValue = (dyn_PEAK_IPL_Gain_SetRedGainValue) (load ? import_function(m_handle, "PEAK_IPL_Gain_SetRedGainValue") : nullptr);
830  if(m_PEAK_IPL_Gain_SetRedGainValue == nullptr && load)
831  {
832  throw std::runtime_error("Failed to load PEAK_IPL_Gain_SetRedGainValue");
833  }
834 
835  m_PEAK_IPL_Gain_GetRedGainValue = (dyn_PEAK_IPL_Gain_GetRedGainValue) (load ? import_function(m_handle, "PEAK_IPL_Gain_GetRedGainValue") : nullptr);
836  if(m_PEAK_IPL_Gain_GetRedGainValue == nullptr && load)
837  {
838  throw std::runtime_error("Failed to load PEAK_IPL_Gain_GetRedGainValue");
839  }
840 
841  m_PEAK_IPL_Gain_GetRedGainMax = (dyn_PEAK_IPL_Gain_GetRedGainMax) (load ? import_function(m_handle, "PEAK_IPL_Gain_GetRedGainMax") : nullptr);
842  if(m_PEAK_IPL_Gain_GetRedGainMax == nullptr && load)
843  {
844  throw std::runtime_error("Failed to load PEAK_IPL_Gain_GetRedGainMax");
845  }
846 
847  m_PEAK_IPL_Gain_GetRedGainMin = (dyn_PEAK_IPL_Gain_GetRedGainMin) (load ? import_function(m_handle, "PEAK_IPL_Gain_GetRedGainMin") : nullptr);
848  if(m_PEAK_IPL_Gain_GetRedGainMin == nullptr && load)
849  {
850  throw std::runtime_error("Failed to load PEAK_IPL_Gain_GetRedGainMin");
851  }
852 
853  m_PEAK_IPL_Gain_SetGreenGainValue = (dyn_PEAK_IPL_Gain_SetGreenGainValue) (load ? import_function(m_handle, "PEAK_IPL_Gain_SetGreenGainValue") : nullptr);
854  if(m_PEAK_IPL_Gain_SetGreenGainValue == nullptr && load)
855  {
856  throw std::runtime_error("Failed to load PEAK_IPL_Gain_SetGreenGainValue");
857  }
858 
859  m_PEAK_IPL_Gain_GetGreenGainValue = (dyn_PEAK_IPL_Gain_GetGreenGainValue) (load ? import_function(m_handle, "PEAK_IPL_Gain_GetGreenGainValue") : nullptr);
860  if(m_PEAK_IPL_Gain_GetGreenGainValue == nullptr && load)
861  {
862  throw std::runtime_error("Failed to load PEAK_IPL_Gain_GetGreenGainValue");
863  }
864 
865  m_PEAK_IPL_Gain_GetGreenGainMax = (dyn_PEAK_IPL_Gain_GetGreenGainMax) (load ? import_function(m_handle, "PEAK_IPL_Gain_GetGreenGainMax") : nullptr);
866  if(m_PEAK_IPL_Gain_GetGreenGainMax == nullptr && load)
867  {
868  throw std::runtime_error("Failed to load PEAK_IPL_Gain_GetGreenGainMax");
869  }
870 
871  m_PEAK_IPL_Gain_GetGreenGainMin = (dyn_PEAK_IPL_Gain_GetGreenGainMin) (load ? import_function(m_handle, "PEAK_IPL_Gain_GetGreenGainMin") : nullptr);
872  if(m_PEAK_IPL_Gain_GetGreenGainMin == nullptr && load)
873  {
874  throw std::runtime_error("Failed to load PEAK_IPL_Gain_GetGreenGainMin");
875  }
876 
877  m_PEAK_IPL_Gain_SetBlueGainValue = (dyn_PEAK_IPL_Gain_SetBlueGainValue) (load ? import_function(m_handle, "PEAK_IPL_Gain_SetBlueGainValue") : nullptr);
878  if(m_PEAK_IPL_Gain_SetBlueGainValue == nullptr && load)
879  {
880  throw std::runtime_error("Failed to load PEAK_IPL_Gain_SetBlueGainValue");
881  }
882 
883  m_PEAK_IPL_Gain_GetBlueGainValue = (dyn_PEAK_IPL_Gain_GetBlueGainValue) (load ? import_function(m_handle, "PEAK_IPL_Gain_GetBlueGainValue") : nullptr);
884  if(m_PEAK_IPL_Gain_GetBlueGainValue == nullptr && load)
885  {
886  throw std::runtime_error("Failed to load PEAK_IPL_Gain_GetBlueGainValue");
887  }
888 
889  m_PEAK_IPL_Gain_GetBlueGainMax = (dyn_PEAK_IPL_Gain_GetBlueGainMax) (load ? import_function(m_handle, "PEAK_IPL_Gain_GetBlueGainMax") : nullptr);
890  if(m_PEAK_IPL_Gain_GetBlueGainMax == nullptr && load)
891  {
892  throw std::runtime_error("Failed to load PEAK_IPL_Gain_GetBlueGainMax");
893  }
894 
895  m_PEAK_IPL_Gain_GetBlueGainMin = (dyn_PEAK_IPL_Gain_GetBlueGainMin) (load ? import_function(m_handle, "PEAK_IPL_Gain_GetBlueGainMin") : nullptr);
896  if(m_PEAK_IPL_Gain_GetBlueGainMin == nullptr && load)
897  {
898  throw std::runtime_error("Failed to load PEAK_IPL_Gain_GetBlueGainMin");
899  }
900 
901  m_PEAK_IPL_Gain_GetIsPixelFormatSupported = (dyn_PEAK_IPL_Gain_GetIsPixelFormatSupported) (load ? import_function(m_handle, "PEAK_IPL_Gain_GetIsPixelFormatSupported") : nullptr);
902  if(m_PEAK_IPL_Gain_GetIsPixelFormatSupported == nullptr && load)
903  {
904  throw std::runtime_error("Failed to load PEAK_IPL_Gain_GetIsPixelFormatSupported");
905  }
906 
907  m_PEAK_IPL_Gain_Process = (dyn_PEAK_IPL_Gain_Process) (load ? import_function(m_handle, "PEAK_IPL_Gain_Process") : nullptr);
908  if(m_PEAK_IPL_Gain_Process == nullptr && load)
909  {
910  throw std::runtime_error("Failed to load PEAK_IPL_Gain_Process");
911  }
912 
913  m_PEAK_IPL_Gain_ProcessInPlace = (dyn_PEAK_IPL_Gain_ProcessInPlace) (load ? import_function(m_handle, "PEAK_IPL_Gain_ProcessInPlace") : nullptr);
914  if(m_PEAK_IPL_Gain_ProcessInPlace == nullptr && load)
915  {
916  throw std::runtime_error("Failed to load PEAK_IPL_Gain_ProcessInPlace");
917  }
918 
919  m_PEAK_IPL_Gain_Destruct = (dyn_PEAK_IPL_Gain_Destruct) (load ? import_function(m_handle, "PEAK_IPL_Gain_Destruct") : nullptr);
920  if(m_PEAK_IPL_Gain_Destruct == nullptr && load)
921  {
922  throw std::runtime_error("Failed to load PEAK_IPL_Gain_Destruct");
923  }
924 
925  m_PEAK_IPL_GammaCorrector_Construct = (dyn_PEAK_IPL_GammaCorrector_Construct) (load ? import_function(m_handle, "PEAK_IPL_GammaCorrector_Construct") : nullptr);
926  if(m_PEAK_IPL_GammaCorrector_Construct == nullptr && load)
927  {
928  throw std::runtime_error("Failed to load PEAK_IPL_GammaCorrector_Construct");
929  }
930 
931  m_PEAK_IPL_GammaCorrector_SetGammaCorrectionValue = (dyn_PEAK_IPL_GammaCorrector_SetGammaCorrectionValue) (load ? import_function(m_handle, "PEAK_IPL_GammaCorrector_SetGammaCorrectionValue") : nullptr);
932  if(m_PEAK_IPL_GammaCorrector_SetGammaCorrectionValue == nullptr && load)
933  {
934  throw std::runtime_error("Failed to load PEAK_IPL_GammaCorrector_SetGammaCorrectionValue");
935  }
936 
937  m_PEAK_IPL_GammaCorrector_GetGammaCorrectionValue = (dyn_PEAK_IPL_GammaCorrector_GetGammaCorrectionValue) (load ? import_function(m_handle, "PEAK_IPL_GammaCorrector_GetGammaCorrectionValue") : nullptr);
938  if(m_PEAK_IPL_GammaCorrector_GetGammaCorrectionValue == nullptr && load)
939  {
940  throw std::runtime_error("Failed to load PEAK_IPL_GammaCorrector_GetGammaCorrectionValue");
941  }
942 
943  m_PEAK_IPL_GammaCorrector_GetGammaCorrectionMax = (dyn_PEAK_IPL_GammaCorrector_GetGammaCorrectionMax) (load ? import_function(m_handle, "PEAK_IPL_GammaCorrector_GetGammaCorrectionMax") : nullptr);
944  if(m_PEAK_IPL_GammaCorrector_GetGammaCorrectionMax == nullptr && load)
945  {
946  throw std::runtime_error("Failed to load PEAK_IPL_GammaCorrector_GetGammaCorrectionMax");
947  }
948 
949  m_PEAK_IPL_GammaCorrector_GetGammaCorrectionMin = (dyn_PEAK_IPL_GammaCorrector_GetGammaCorrectionMin) (load ? import_function(m_handle, "PEAK_IPL_GammaCorrector_GetGammaCorrectionMin") : nullptr);
950  if(m_PEAK_IPL_GammaCorrector_GetGammaCorrectionMin == nullptr && load)
951  {
952  throw std::runtime_error("Failed to load PEAK_IPL_GammaCorrector_GetGammaCorrectionMin");
953  }
954 
955  m_PEAK_IPL_GammaCorrector_GetIsPixelFormatSupported = (dyn_PEAK_IPL_GammaCorrector_GetIsPixelFormatSupported) (load ? import_function(m_handle, "PEAK_IPL_GammaCorrector_GetIsPixelFormatSupported") : nullptr);
956  if(m_PEAK_IPL_GammaCorrector_GetIsPixelFormatSupported == nullptr && load)
957  {
958  throw std::runtime_error("Failed to load PEAK_IPL_GammaCorrector_GetIsPixelFormatSupported");
959  }
960 
961  m_PEAK_IPL_GammaCorrector_Process = (dyn_PEAK_IPL_GammaCorrector_Process) (load ? import_function(m_handle, "PEAK_IPL_GammaCorrector_Process") : nullptr);
962  if(m_PEAK_IPL_GammaCorrector_Process == nullptr && load)
963  {
964  throw std::runtime_error("Failed to load PEAK_IPL_GammaCorrector_Process");
965  }
966 
967  m_PEAK_IPL_GammaCorrector_ProcessInPlace = (dyn_PEAK_IPL_GammaCorrector_ProcessInPlace) (load ? import_function(m_handle, "PEAK_IPL_GammaCorrector_ProcessInPlace") : nullptr);
968  if(m_PEAK_IPL_GammaCorrector_ProcessInPlace == nullptr && load)
969  {
970  throw std::runtime_error("Failed to load PEAK_IPL_GammaCorrector_ProcessInPlace");
971  }
972 
973  m_PEAK_IPL_GammaCorrector_Destruct = (dyn_PEAK_IPL_GammaCorrector_Destruct) (load ? import_function(m_handle, "PEAK_IPL_GammaCorrector_Destruct") : nullptr);
974  if(m_PEAK_IPL_GammaCorrector_Destruct == nullptr && load)
975  {
976  throw std::runtime_error("Failed to load PEAK_IPL_GammaCorrector_Destruct");
977  }
978 
979  m_PEAK_IPL_Image_Construct = (dyn_PEAK_IPL_Image_Construct) (load ? import_function(m_handle, "PEAK_IPL_Image_Construct") : nullptr);
980  if(m_PEAK_IPL_Image_Construct == nullptr && load)
981  {
982  throw std::runtime_error("Failed to load PEAK_IPL_Image_Construct");
983  }
984 
985  m_PEAK_IPL_Image_ConstructFromBuffer = (dyn_PEAK_IPL_Image_ConstructFromBuffer) (load ? import_function(m_handle, "PEAK_IPL_Image_ConstructFromBuffer") : nullptr);
986  if(m_PEAK_IPL_Image_ConstructFromBuffer == nullptr && load)
987  {
988  throw std::runtime_error("Failed to load PEAK_IPL_Image_ConstructFromBuffer");
989  }
990 
991  m_PEAK_IPL_Image_GetWidth = (dyn_PEAK_IPL_Image_GetWidth) (load ? import_function(m_handle, "PEAK_IPL_Image_GetWidth") : nullptr);
992  if(m_PEAK_IPL_Image_GetWidth == nullptr && load)
993  {
994  throw std::runtime_error("Failed to load PEAK_IPL_Image_GetWidth");
995  }
996 
997  m_PEAK_IPL_Image_GetHeight = (dyn_PEAK_IPL_Image_GetHeight) (load ? import_function(m_handle, "PEAK_IPL_Image_GetHeight") : nullptr);
998  if(m_PEAK_IPL_Image_GetHeight == nullptr && load)
999  {
1000  throw std::runtime_error("Failed to load PEAK_IPL_Image_GetHeight");
1001  }
1002 
1003  m_PEAK_IPL_Image_GetPixelPointer = (dyn_PEAK_IPL_Image_GetPixelPointer) (load ? import_function(m_handle, "PEAK_IPL_Image_GetPixelPointer") : nullptr);
1004  if(m_PEAK_IPL_Image_GetPixelPointer == nullptr && load)
1005  {
1006  throw std::runtime_error("Failed to load PEAK_IPL_Image_GetPixelPointer");
1007  }
1008 
1009  m_PEAK_IPL_Image_GetByteCount = (dyn_PEAK_IPL_Image_GetByteCount) (load ? import_function(m_handle, "PEAK_IPL_Image_GetByteCount") : nullptr);
1010  if(m_PEAK_IPL_Image_GetByteCount == nullptr && load)
1011  {
1012  throw std::runtime_error("Failed to load PEAK_IPL_Image_GetByteCount");
1013  }
1014 
1015  m_PEAK_IPL_Image_GetPixelFormat = (dyn_PEAK_IPL_Image_GetPixelFormat) (load ? import_function(m_handle, "PEAK_IPL_Image_GetPixelFormat") : nullptr);
1016  if(m_PEAK_IPL_Image_GetPixelFormat == nullptr && load)
1017  {
1018  throw std::runtime_error("Failed to load PEAK_IPL_Image_GetPixelFormat");
1019  }
1020 
1021  m_PEAK_IPL_Image_GetData = (dyn_PEAK_IPL_Image_GetData) (load ? import_function(m_handle, "PEAK_IPL_Image_GetData") : nullptr);
1022  if(m_PEAK_IPL_Image_GetData == nullptr && load)
1023  {
1024  throw std::runtime_error("Failed to load PEAK_IPL_Image_GetData");
1025  }
1026 
1027  m_PEAK_IPL_Image_Clone = (dyn_PEAK_IPL_Image_Clone) (load ? import_function(m_handle, "PEAK_IPL_Image_Clone") : nullptr);
1028  if(m_PEAK_IPL_Image_Clone == nullptr && load)
1029  {
1030  throw std::runtime_error("Failed to load PEAK_IPL_Image_Clone");
1031  }
1032 
1033  m_PEAK_IPL_Image_ConvertTo = (dyn_PEAK_IPL_Image_ConvertTo) (load ? import_function(m_handle, "PEAK_IPL_Image_ConvertTo") : nullptr);
1034  if(m_PEAK_IPL_Image_ConvertTo == nullptr && load)
1035  {
1036  throw std::runtime_error("Failed to load PEAK_IPL_Image_ConvertTo");
1037  }
1038 
1039  m_PEAK_IPL_Image_ConvertToBuffer = (dyn_PEAK_IPL_Image_ConvertToBuffer) (load ? import_function(m_handle, "PEAK_IPL_Image_ConvertToBuffer") : nullptr);
1040  if(m_PEAK_IPL_Image_ConvertToBuffer == nullptr && load)
1041  {
1042  throw std::runtime_error("Failed to load PEAK_IPL_Image_ConvertToBuffer");
1043  }
1044 
1045  m_PEAK_IPL_Image_Destruct = (dyn_PEAK_IPL_Image_Destruct) (load ? import_function(m_handle, "PEAK_IPL_Image_Destruct") : nullptr);
1046  if(m_PEAK_IPL_Image_Destruct == nullptr && load)
1047  {
1048  throw std::runtime_error("Failed to load PEAK_IPL_Image_Destruct");
1049  }
1050 
1051  m_PEAK_IPL_ImageTransformer_Construct = (dyn_PEAK_IPL_ImageTransformer_Construct) (load ? import_function(m_handle, "PEAK_IPL_ImageTransformer_Construct") : nullptr);
1052  if(m_PEAK_IPL_ImageTransformer_Construct == nullptr && load)
1053  {
1054  throw std::runtime_error("Failed to load PEAK_IPL_ImageTransformer_Construct");
1055  }
1056 
1057  m_PEAK_IPL_ImageTransformer_MirrorUpDown = (dyn_PEAK_IPL_ImageTransformer_MirrorUpDown) (load ? import_function(m_handle, "PEAK_IPL_ImageTransformer_MirrorUpDown") : nullptr);
1058  if(m_PEAK_IPL_ImageTransformer_MirrorUpDown == nullptr && load)
1059  {
1060  throw std::runtime_error("Failed to load PEAK_IPL_ImageTransformer_MirrorUpDown");
1061  }
1062 
1063  m_PEAK_IPL_ImageTransformer_MirrorLeftRight = (dyn_PEAK_IPL_ImageTransformer_MirrorLeftRight) (load ? import_function(m_handle, "PEAK_IPL_ImageTransformer_MirrorLeftRight") : nullptr);
1064  if(m_PEAK_IPL_ImageTransformer_MirrorLeftRight == nullptr && load)
1065  {
1066  throw std::runtime_error("Failed to load PEAK_IPL_ImageTransformer_MirrorLeftRight");
1067  }
1068 
1069  m_PEAK_IPL_ImageTransformer_MirrorUpDownLeftRight = (dyn_PEAK_IPL_ImageTransformer_MirrorUpDownLeftRight) (load ? import_function(m_handle, "PEAK_IPL_ImageTransformer_MirrorUpDownLeftRight") : nullptr);
1070  if(m_PEAK_IPL_ImageTransformer_MirrorUpDownLeftRight == nullptr && load)
1071  {
1072  throw std::runtime_error("Failed to load PEAK_IPL_ImageTransformer_MirrorUpDownLeftRight");
1073  }
1074 
1075  m_PEAK_IPL_ImageTransformer_MirrorUpDownInPlace = (dyn_PEAK_IPL_ImageTransformer_MirrorUpDownInPlace) (load ? import_function(m_handle, "PEAK_IPL_ImageTransformer_MirrorUpDownInPlace") : nullptr);
1076  if(m_PEAK_IPL_ImageTransformer_MirrorUpDownInPlace == nullptr && load)
1077  {
1078  throw std::runtime_error("Failed to load PEAK_IPL_ImageTransformer_MirrorUpDownInPlace");
1079  }
1080 
1081  m_PEAK_IPL_ImageTransformer_MirrorLeftRightInPlace = (dyn_PEAK_IPL_ImageTransformer_MirrorLeftRightInPlace) (load ? import_function(m_handle, "PEAK_IPL_ImageTransformer_MirrorLeftRightInPlace") : nullptr);
1082  if(m_PEAK_IPL_ImageTransformer_MirrorLeftRightInPlace == nullptr && load)
1083  {
1084  throw std::runtime_error("Failed to load PEAK_IPL_ImageTransformer_MirrorLeftRightInPlace");
1085  }
1086 
1087  m_PEAK_IPL_ImageTransformer_MirrorUpDownLeftRightInPlace = (dyn_PEAK_IPL_ImageTransformer_MirrorUpDownLeftRightInPlace) (load ? import_function(m_handle, "PEAK_IPL_ImageTransformer_MirrorUpDownLeftRightInPlace") : nullptr);
1088  if(m_PEAK_IPL_ImageTransformer_MirrorUpDownLeftRightInPlace == nullptr && load)
1089  {
1090  throw std::runtime_error("Failed to load PEAK_IPL_ImageTransformer_MirrorUpDownLeftRightInPlace");
1091  }
1092 
1093  m_PEAK_IPL_ImageTransformer_Rotate = (dyn_PEAK_IPL_ImageTransformer_Rotate) (load ? import_function(m_handle, "PEAK_IPL_ImageTransformer_Rotate") : nullptr);
1094  if(m_PEAK_IPL_ImageTransformer_Rotate == nullptr && load)
1095  {
1096  throw std::runtime_error("Failed to load PEAK_IPL_ImageTransformer_Rotate");
1097  }
1098 
1099  m_PEAK_IPL_ImageTransformer_RotateInPlace = (dyn_PEAK_IPL_ImageTransformer_RotateInPlace) (load ? import_function(m_handle, "PEAK_IPL_ImageTransformer_RotateInPlace") : nullptr);
1100  if(m_PEAK_IPL_ImageTransformer_RotateInPlace == nullptr && load)
1101  {
1102  throw std::runtime_error("Failed to load PEAK_IPL_ImageTransformer_RotateInPlace");
1103  }
1104 
1105  m_PEAK_IPL_ImageTransformer_Destruct = (dyn_PEAK_IPL_ImageTransformer_Destruct) (load ? import_function(m_handle, "PEAK_IPL_ImageTransformer_Destruct") : nullptr);
1106  if(m_PEAK_IPL_ImageTransformer_Destruct == nullptr && load)
1107  {
1108  throw std::runtime_error("Failed to load PEAK_IPL_ImageTransformer_Destruct");
1109  }
1110 
1111  m_PEAK_IPL_Histogram_Construct = (dyn_PEAK_IPL_Histogram_Construct) (load ? import_function(m_handle, "PEAK_IPL_Histogram_Construct") : nullptr);
1112  if(m_PEAK_IPL_Histogram_Construct == nullptr && load)
1113  {
1114  throw std::runtime_error("Failed to load PEAK_IPL_Histogram_Construct");
1115  }
1116 
1117  m_PEAK_IPL_Histogram_GetPixelFormat = (dyn_PEAK_IPL_Histogram_GetPixelFormat) (load ? import_function(m_handle, "PEAK_IPL_Histogram_GetPixelFormat") : nullptr);
1118  if(m_PEAK_IPL_Histogram_GetPixelFormat == nullptr && load)
1119  {
1120  throw std::runtime_error("Failed to load PEAK_IPL_Histogram_GetPixelFormat");
1121  }
1122 
1123  m_PEAK_IPL_Histogram_GetNumChannels = (dyn_PEAK_IPL_Histogram_GetNumChannels) (load ? import_function(m_handle, "PEAK_IPL_Histogram_GetNumChannels") : nullptr);
1124  if(m_PEAK_IPL_Histogram_GetNumChannels == nullptr && load)
1125  {
1126  throw std::runtime_error("Failed to load PEAK_IPL_Histogram_GetNumChannels");
1127  }
1128 
1129  m_PEAK_IPL_Histogram_GetPixelSumForChannel = (dyn_PEAK_IPL_Histogram_GetPixelSumForChannel) (load ? import_function(m_handle, "PEAK_IPL_Histogram_GetPixelSumForChannel") : nullptr);
1130  if(m_PEAK_IPL_Histogram_GetPixelSumForChannel == nullptr && load)
1131  {
1132  throw std::runtime_error("Failed to load PEAK_IPL_Histogram_GetPixelSumForChannel");
1133  }
1134 
1135  m_PEAK_IPL_Histogram_GetPixelCountForChannel = (dyn_PEAK_IPL_Histogram_GetPixelCountForChannel) (load ? import_function(m_handle, "PEAK_IPL_Histogram_GetPixelCountForChannel") : nullptr);
1136  if(m_PEAK_IPL_Histogram_GetPixelCountForChannel == nullptr && load)
1137  {
1138  throw std::runtime_error("Failed to load PEAK_IPL_Histogram_GetPixelCountForChannel");
1139  }
1140 
1141  m_PEAK_IPL_Histogram_GetBinsForChannel = (dyn_PEAK_IPL_Histogram_GetBinsForChannel) (load ? import_function(m_handle, "PEAK_IPL_Histogram_GetBinsForChannel") : nullptr);
1142  if(m_PEAK_IPL_Histogram_GetBinsForChannel == nullptr && load)
1143  {
1144  throw std::runtime_error("Failed to load PEAK_IPL_Histogram_GetBinsForChannel");
1145  }
1146 
1147  m_PEAK_IPL_Histogram_Destruct = (dyn_PEAK_IPL_Histogram_Destruct) (load ? import_function(m_handle, "PEAK_IPL_Histogram_Destruct") : nullptr);
1148  if(m_PEAK_IPL_Histogram_Destruct == nullptr && load)
1149  {
1150  throw std::runtime_error("Failed to load PEAK_IPL_Histogram_Destruct");
1151  }
1152 
1153  m_PEAK_IPL_PixelLine_Construct = (dyn_PEAK_IPL_PixelLine_Construct) (load ? import_function(m_handle, "PEAK_IPL_PixelLine_Construct") : nullptr);
1154  if(m_PEAK_IPL_PixelLine_Construct == nullptr && load)
1155  {
1156  throw std::runtime_error("Failed to load PEAK_IPL_PixelLine_Construct");
1157  }
1158 
1159  m_PEAK_IPL_PixelLine_GetPixelFormat = (dyn_PEAK_IPL_PixelLine_GetPixelFormat) (load ? import_function(m_handle, "PEAK_IPL_PixelLine_GetPixelFormat") : nullptr);
1160  if(m_PEAK_IPL_PixelLine_GetPixelFormat == nullptr && load)
1161  {
1162  throw std::runtime_error("Failed to load PEAK_IPL_PixelLine_GetPixelFormat");
1163  }
1164 
1165  m_PEAK_IPL_PixelLine_GetOrientation = (dyn_PEAK_IPL_PixelLine_GetOrientation) (load ? import_function(m_handle, "PEAK_IPL_PixelLine_GetOrientation") : nullptr);
1166  if(m_PEAK_IPL_PixelLine_GetOrientation == nullptr && load)
1167  {
1168  throw std::runtime_error("Failed to load PEAK_IPL_PixelLine_GetOrientation");
1169  }
1170 
1171  m_PEAK_IPL_PixelLine_GetOffset = (dyn_PEAK_IPL_PixelLine_GetOffset) (load ? import_function(m_handle, "PEAK_IPL_PixelLine_GetOffset") : nullptr);
1172  if(m_PEAK_IPL_PixelLine_GetOffset == nullptr && load)
1173  {
1174  throw std::runtime_error("Failed to load PEAK_IPL_PixelLine_GetOffset");
1175  }
1176 
1177  m_PEAK_IPL_PixelLine_GetNumChannels = (dyn_PEAK_IPL_PixelLine_GetNumChannels) (load ? import_function(m_handle, "PEAK_IPL_PixelLine_GetNumChannels") : nullptr);
1178  if(m_PEAK_IPL_PixelLine_GetNumChannels == nullptr && load)
1179  {
1180  throw std::runtime_error("Failed to load PEAK_IPL_PixelLine_GetNumChannels");
1181  }
1182 
1183  m_PEAK_IPL_PixelLine_GetValuesForChannel = (dyn_PEAK_IPL_PixelLine_GetValuesForChannel) (load ? import_function(m_handle, "PEAK_IPL_PixelLine_GetValuesForChannel") : nullptr);
1184  if(m_PEAK_IPL_PixelLine_GetValuesForChannel == nullptr && load)
1185  {
1186  throw std::runtime_error("Failed to load PEAK_IPL_PixelLine_GetValuesForChannel");
1187  }
1188 
1189  m_PEAK_IPL_PixelLine_Destruct = (dyn_PEAK_IPL_PixelLine_Destruct) (load ? import_function(m_handle, "PEAK_IPL_PixelLine_Destruct") : nullptr);
1190  if(m_PEAK_IPL_PixelLine_Destruct == nullptr && load)
1191  {
1192  throw std::runtime_error("Failed to load PEAK_IPL_PixelLine_Destruct");
1193  }
1194 
1195  m_PEAK_IPL_PixelFormat_GetNumChannels = (dyn_PEAK_IPL_PixelFormat_GetNumChannels) (load ? import_function(m_handle, "PEAK_IPL_PixelFormat_GetNumChannels") : nullptr);
1196  if(m_PEAK_IPL_PixelFormat_GetNumChannels == nullptr && load)
1197  {
1198  throw std::runtime_error("Failed to load PEAK_IPL_PixelFormat_GetNumChannels");
1199  }
1200 
1201  m_PEAK_IPL_PixelFormat_GetNumSignificantBitsPerChannel = (dyn_PEAK_IPL_PixelFormat_GetNumSignificantBitsPerChannel) (load ? import_function(m_handle, "PEAK_IPL_PixelFormat_GetNumSignificantBitsPerChannel") : nullptr);
1202  if(m_PEAK_IPL_PixelFormat_GetNumSignificantBitsPerChannel == nullptr && load)
1203  {
1204  throw std::runtime_error("Failed to load PEAK_IPL_PixelFormat_GetNumSignificantBitsPerChannel");
1205  }
1206 
1207  m_PEAK_IPL_PixelFormat_GetNumStorageBitsPerChannel = (dyn_PEAK_IPL_PixelFormat_GetNumStorageBitsPerChannel) (load ? import_function(m_handle, "PEAK_IPL_PixelFormat_GetNumStorageBitsPerChannel") : nullptr);
1208  if(m_PEAK_IPL_PixelFormat_GetNumStorageBitsPerChannel == nullptr && load)
1209  {
1210  throw std::runtime_error("Failed to load PEAK_IPL_PixelFormat_GetNumStorageBitsPerChannel");
1211  }
1212 
1213  m_PEAK_IPL_PixelFormat_GetMaximumValuePerChannel = (dyn_PEAK_IPL_PixelFormat_GetMaximumValuePerChannel) (load ? import_function(m_handle, "PEAK_IPL_PixelFormat_GetMaximumValuePerChannel") : nullptr);
1214  if(m_PEAK_IPL_PixelFormat_GetMaximumValuePerChannel == nullptr && load)
1215  {
1216  throw std::runtime_error("Failed to load PEAK_IPL_PixelFormat_GetMaximumValuePerChannel");
1217  }
1218 
1219  m_PEAK_IPL_PixelFormat_GetNumSignificantBitsPerPixel = (dyn_PEAK_IPL_PixelFormat_GetNumSignificantBitsPerPixel) (load ? import_function(m_handle, "PEAK_IPL_PixelFormat_GetNumSignificantBitsPerPixel") : nullptr);
1220  if(m_PEAK_IPL_PixelFormat_GetNumSignificantBitsPerPixel == nullptr && load)
1221  {
1222  throw std::runtime_error("Failed to load PEAK_IPL_PixelFormat_GetNumSignificantBitsPerPixel");
1223  }
1224 
1225  m_PEAK_IPL_PixelFormat_GetNumStorageBitsPerPixel = (dyn_PEAK_IPL_PixelFormat_GetNumStorageBitsPerPixel) (load ? import_function(m_handle, "PEAK_IPL_PixelFormat_GetNumStorageBitsPerPixel") : nullptr);
1226  if(m_PEAK_IPL_PixelFormat_GetNumStorageBitsPerPixel == nullptr && load)
1227  {
1228  throw std::runtime_error("Failed to load PEAK_IPL_PixelFormat_GetNumStorageBitsPerPixel");
1229  }
1230 
1231  m_PEAK_IPL_PixelFormat_GetEndianness = (dyn_PEAK_IPL_PixelFormat_GetEndianness) (load ? import_function(m_handle, "PEAK_IPL_PixelFormat_GetEndianness") : nullptr);
1232  if(m_PEAK_IPL_PixelFormat_GetEndianness == nullptr && load)
1233  {
1234  throw std::runtime_error("Failed to load PEAK_IPL_PixelFormat_GetEndianness");
1235  }
1236 
1237  m_PEAK_IPL_PixelFormat_CalculateStorageSizeOfPixels = (dyn_PEAK_IPL_PixelFormat_CalculateStorageSizeOfPixels) (load ? import_function(m_handle, "PEAK_IPL_PixelFormat_CalculateStorageSizeOfPixels") : nullptr);
1238  if(m_PEAK_IPL_PixelFormat_CalculateStorageSizeOfPixels == nullptr && load)
1239  {
1240  throw std::runtime_error("Failed to load PEAK_IPL_PixelFormat_CalculateStorageSizeOfPixels");
1241  }
1242 
1243  m_PEAK_IPL_ImageWriter_WriteAsRAW = (dyn_PEAK_IPL_ImageWriter_WriteAsRAW) (load ? import_function(m_handle, "PEAK_IPL_ImageWriter_WriteAsRAW") : nullptr);
1244  if(m_PEAK_IPL_ImageWriter_WriteAsRAW == nullptr && load)
1245  {
1246  throw std::runtime_error("Failed to load PEAK_IPL_ImageWriter_WriteAsRAW");
1247  }
1248 
1249  m_PEAK_IPL_ImageWriter_WriteAsBMP = (dyn_PEAK_IPL_ImageWriter_WriteAsBMP) (load ? import_function(m_handle, "PEAK_IPL_ImageWriter_WriteAsBMP") : nullptr);
1250  if(m_PEAK_IPL_ImageWriter_WriteAsBMP == nullptr && load)
1251  {
1252  throw std::runtime_error("Failed to load PEAK_IPL_ImageWriter_WriteAsBMP");
1253  }
1254 
1255  m_PEAK_IPL_ImageWriter_WriteAsPNG = (dyn_PEAK_IPL_ImageWriter_WriteAsPNG) (load ? import_function(m_handle, "PEAK_IPL_ImageWriter_WriteAsPNG") : nullptr);
1256  if(m_PEAK_IPL_ImageWriter_WriteAsPNG == nullptr && load)
1257  {
1258  throw std::runtime_error("Failed to load PEAK_IPL_ImageWriter_WriteAsPNG");
1259  }
1260 
1261  m_PEAK_IPL_ImageWriter_WriteAsJPG = (dyn_PEAK_IPL_ImageWriter_WriteAsJPG) (load ? import_function(m_handle, "PEAK_IPL_ImageWriter_WriteAsJPG") : nullptr);
1262  if(m_PEAK_IPL_ImageWriter_WriteAsJPG == nullptr && load)
1263  {
1264  throw std::runtime_error("Failed to load PEAK_IPL_ImageWriter_WriteAsJPG");
1265  }
1266 
1267  m_PEAK_IPL_ImageWriter_Write = (dyn_PEAK_IPL_ImageWriter_Write) (load ? import_function(m_handle, "PEAK_IPL_ImageWriter_Write") : nullptr);
1268  if(m_PEAK_IPL_ImageWriter_Write == nullptr && load)
1269  {
1270  throw std::runtime_error("Failed to load PEAK_IPL_ImageWriter_Write");
1271  }
1272 
1273  m_PEAK_IPL_ImageReader_Read = (dyn_PEAK_IPL_ImageReader_Read) (load ? import_function(m_handle, "PEAK_IPL_ImageReader_Read") : nullptr);
1274  if(m_PEAK_IPL_ImageReader_Read == nullptr && load)
1275  {
1276  throw std::runtime_error("Failed to load PEAK_IPL_ImageReader_Read");
1277  }
1278 
1279  m_PEAK_IPL_ImageReaderRead_ReadAsPixelFormat = (dyn_PEAK_IPL_ImageReaderRead_ReadAsPixelFormat) (load ? import_function(m_handle, "PEAK_IPL_ImageReaderRead_ReadAsPixelFormat") : nullptr);
1280  if(m_PEAK_IPL_ImageReaderRead_ReadAsPixelFormat == nullptr && load)
1281  {
1282  throw std::runtime_error("Failed to load PEAK_IPL_ImageReaderRead_ReadAsPixelFormat");
1283  }
1284 
1285 
1286  return true;
1287 }
1288 
1289 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Library_GetVersionMajor(uint32_t * libraryVersionMajor)
1290 {
1291  auto& inst = instance();
1292  if(inst.m_PEAK_IPL_Library_GetVersionMajor)
1293  {
1294  return inst.m_PEAK_IPL_Library_GetVersionMajor(libraryVersionMajor);
1295  }
1296  else
1297  {
1298  throw std::runtime_error("Library not loaded!");
1299  }
1300 }
1301 
1302 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Library_GetVersionMinor(uint32_t * libraryVersionMinor)
1303 {
1304  auto& inst = instance();
1305  if(inst.m_PEAK_IPL_Library_GetVersionMinor)
1306  {
1307  return inst.m_PEAK_IPL_Library_GetVersionMinor(libraryVersionMinor);
1308  }
1309  else
1310  {
1311  throw std::runtime_error("Library not loaded!");
1312  }
1313 }
1314 
1315 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Library_GetVersionSubminor(uint32_t * libraryVersionSubminor)
1316 {
1317  auto& inst = instance();
1318  if(inst.m_PEAK_IPL_Library_GetVersionSubminor)
1319  {
1320  return inst.m_PEAK_IPL_Library_GetVersionSubminor(libraryVersionSubminor);
1321  }
1322  else
1323  {
1324  throw std::runtime_error("Library not loaded!");
1325  }
1326 }
1327 
1328 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Library_GetLastError(PEAK_IPL_RETURN_CODE * lastErrorCode, char * lastErrorDescription, size_t * lastErrorDescriptionSize)
1329 {
1330  auto& inst = instance();
1331  if(inst.m_PEAK_IPL_Library_GetLastError)
1332  {
1333  return inst.m_PEAK_IPL_Library_GetLastError(lastErrorCode, lastErrorDescription, lastErrorDescriptionSize);
1334  }
1335  else
1336  {
1337  throw std::runtime_error("Library not loaded!");
1338  }
1339 }
1340 
1341 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageConverter_Construct(PEAK_IPL_IMAGE_CONVERTER_HANDLE * imageConverterHandle)
1342 {
1343  auto& inst = instance();
1344  if(inst.m_PEAK_IPL_ImageConverter_Construct)
1345  {
1346  return inst.m_PEAK_IPL_ImageConverter_Construct(imageConverterHandle);
1347  }
1348  else
1349  {
1350  throw std::runtime_error("Library not loaded!");
1351  }
1352 }
1353 
1354 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)
1355 {
1356  auto& inst = instance();
1357  if(inst.m_PEAK_IPL_ImageConverter_PreAllocateConversion)
1358  {
1359  return inst.m_PEAK_IPL_ImageConverter_PreAllocateConversion(imageConverterHandle, inputPixelFormat, outputPixelFormat, width, height, imageCount);
1360  }
1361  else
1362  {
1363  throw std::runtime_error("Library not loaded!");
1364  }
1365 }
1366 
1367 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageConverter_GetConversionMode(PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle, PEAK_IPL_CONVERSION_MODE * conversionMode)
1368 {
1369  auto& inst = instance();
1370  if(inst.m_PEAK_IPL_ImageConverter_GetConversionMode)
1371  {
1372  return inst.m_PEAK_IPL_ImageConverter_GetConversionMode(imageConverterHandle, conversionMode);
1373  }
1374  else
1375  {
1376  throw std::runtime_error("Library not loaded!");
1377  }
1378 }
1379 
1380 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageConverter_SetConversionMode(PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle, PEAK_IPL_CONVERSION_MODE conversionMode)
1381 {
1382  auto& inst = instance();
1383  if(inst.m_PEAK_IPL_ImageConverter_SetConversionMode)
1384  {
1385  return inst.m_PEAK_IPL_ImageConverter_SetConversionMode(imageConverterHandle, conversionMode);
1386  }
1387  else
1388  {
1389  throw std::runtime_error("Library not loaded!");
1390  }
1391 }
1392 
1393 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)
1394 {
1395  auto& inst = instance();
1396  if(inst.m_PEAK_IPL_ImageConverter_GetSupportedOutputPixelFormats)
1397  {
1398  return inst.m_PEAK_IPL_ImageConverter_GetSupportedOutputPixelFormats(imageConverterHandle, inputPixelFormat, outputPixelFormats, outputPixelFormatsSize);
1399  }
1400  else
1401  {
1402  throw std::runtime_error("Library not loaded!");
1403  }
1404 }
1405 
1406 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)
1407 {
1408  auto& inst = instance();
1409  if(inst.m_PEAK_IPL_ImageConverter_Convert)
1410  {
1411  return inst.m_PEAK_IPL_ImageConverter_Convert(imageConverterHandle, inputImageHandle, outputPixelFormat, outputImageHandle);
1412  }
1413  else
1414  {
1415  throw std::runtime_error("Library not loaded!");
1416  }
1417 }
1418 
1419 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)
1420 {
1421  auto& inst = instance();
1422  if(inst.m_PEAK_IPL_ImageConverter_ConvertToBuffer)
1423  {
1424  return inst.m_PEAK_IPL_ImageConverter_ConvertToBuffer(imageConverterHandle, inputImageHandle, outputPixelFormat, outputImageBuffer, outputImageBufferSize, outputImageHandle);
1425  }
1426  else
1427  {
1428  throw std::runtime_error("Library not loaded!");
1429  }
1430 }
1431 
1432 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageConverter_Destruct(PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle)
1433 {
1434  auto& inst = instance();
1435  if(inst.m_PEAK_IPL_ImageConverter_Destruct)
1436  {
1437  return inst.m_PEAK_IPL_ImageConverter_Destruct(imageConverterHandle);
1438  }
1439  else
1440  {
1441  throw std::runtime_error("Library not loaded!");
1442  }
1443 }
1444 
1445 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_AdaptiveHotpixelCorrector_Construct(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE * adaptiveHotpixelCorrectorHandle)
1446 {
1447  auto& inst = instance();
1448  if(inst.m_PEAK_IPL_AdaptiveHotpixelCorrector_Construct)
1449  {
1450  return inst.m_PEAK_IPL_AdaptiveHotpixelCorrector_Construct(adaptiveHotpixelCorrectorHandle);
1451  }
1452  else
1453  {
1454  throw std::runtime_error("Library not loaded!");
1455  }
1456 }
1457 
1458 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_AdaptiveHotpixelCorrector_SetSensitivity(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_HOTPIXELCORRECTION_SENSITIVITY sensitivityLevel)
1459 {
1460  auto& inst = instance();
1461  if(inst.m_PEAK_IPL_AdaptiveHotpixelCorrector_SetSensitivity)
1462  {
1463  return inst.m_PEAK_IPL_AdaptiveHotpixelCorrector_SetSensitivity(adaptiveHotpixelCorrectorHandle, sensitivityLevel);
1464  }
1465  else
1466  {
1467  throw std::runtime_error("Library not loaded!");
1468  }
1469 }
1470 
1471 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_AdaptiveHotpixelCorrector_GetSensitivity(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_HOTPIXELCORRECTION_SENSITIVITY * sensitivityLevel)
1472 {
1473  auto& inst = instance();
1474  if(inst.m_PEAK_IPL_AdaptiveHotpixelCorrector_GetSensitivity)
1475  {
1476  return inst.m_PEAK_IPL_AdaptiveHotpixelCorrector_GetSensitivity(adaptiveHotpixelCorrectorHandle, sensitivityLevel);
1477  }
1478  else
1479  {
1480  throw std::runtime_error("Library not loaded!");
1481  }
1482 }
1483 
1484 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_AdaptiveHotpixelCorrector_SetGainFactorPercent(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, uint32_t gainFactorPercent)
1485 {
1486  auto& inst = instance();
1487  if(inst.m_PEAK_IPL_AdaptiveHotpixelCorrector_SetGainFactorPercent)
1488  {
1489  return inst.m_PEAK_IPL_AdaptiveHotpixelCorrector_SetGainFactorPercent(adaptiveHotpixelCorrectorHandle, gainFactorPercent);
1490  }
1491  else
1492  {
1493  throw std::runtime_error("Library not loaded!");
1494  }
1495 }
1496 
1497 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_AdaptiveHotpixelCorrector_GetGainFactorPercent(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, uint32_t * gainFactorPercent)
1498 {
1499  auto& inst = instance();
1500  if(inst.m_PEAK_IPL_AdaptiveHotpixelCorrector_GetGainFactorPercent)
1501  {
1502  return inst.m_PEAK_IPL_AdaptiveHotpixelCorrector_GetGainFactorPercent(adaptiveHotpixelCorrectorHandle, gainFactorPercent);
1503  }
1504  else
1505  {
1506  throw std::runtime_error("Library not loaded!");
1507  }
1508 }
1509 
1510 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_AdaptiveHotpixelCorrector_Detect(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_IMAGE_HANDLE inputImageHandle)
1511 {
1512  auto& inst = instance();
1513  if(inst.m_PEAK_IPL_AdaptiveHotpixelCorrector_Detect)
1514  {
1515  return inst.m_PEAK_IPL_AdaptiveHotpixelCorrector_Detect(adaptiveHotpixelCorrectorHandle, inputImageHandle);
1516  }
1517  else
1518  {
1519  throw std::runtime_error("Library not loaded!");
1520  }
1521 }
1522 
1523 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_AdaptiveHotpixelCorrector_GetHotpixels(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_POINT_2D * hotpixels, size_t * hotpixelsSize)
1524 {
1525  auto& inst = instance();
1526  if(inst.m_PEAK_IPL_AdaptiveHotpixelCorrector_GetHotpixels)
1527  {
1528  return inst.m_PEAK_IPL_AdaptiveHotpixelCorrector_GetHotpixels(adaptiveHotpixelCorrectorHandle, hotpixels, hotpixelsSize);
1529  }
1530  else
1531  {
1532  throw std::runtime_error("Library not loaded!");
1533  }
1534 }
1535 
1536 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_AdaptiveHotpixelCorrector_Correct(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_IMAGE_HANDLE inputImageHandle, const PEAK_IPL_POINT_2D * hotpixels, size_t hotpixelsSize, PEAK_IPL_IMAGE_HANDLE * outputImageHandle)
1537 {
1538  auto& inst = instance();
1539  if(inst.m_PEAK_IPL_AdaptiveHotpixelCorrector_Correct)
1540  {
1541  return inst.m_PEAK_IPL_AdaptiveHotpixelCorrector_Correct(adaptiveHotpixelCorrectorHandle, inputImageHandle, hotpixels, hotpixelsSize, outputImageHandle);
1542  }
1543  else
1544  {
1545  throw std::runtime_error("Library not loaded!");
1546  }
1547 }
1548 
1549 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)
1550 {
1551  auto& inst = instance();
1552  if(inst.m_PEAK_IPL_AdaptiveHotpixelCorrector_CorrectAdaptive)
1553  {
1554  return inst.m_PEAK_IPL_AdaptiveHotpixelCorrector_CorrectAdaptive(adaptiveHotpixelCorrectorHandle, inputImageHandle, outputImageHandle);
1555  }
1556  else
1557  {
1558  throw std::runtime_error("Library not loaded!");
1559  }
1560 }
1561 
1562 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_AdaptiveHotpixelCorrector_Destruct(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle)
1563 {
1564  auto& inst = instance();
1565  if(inst.m_PEAK_IPL_AdaptiveHotpixelCorrector_Destruct)
1566  {
1567  return inst.m_PEAK_IPL_AdaptiveHotpixelCorrector_Destruct(adaptiveHotpixelCorrectorHandle);
1568  }
1569  else
1570  {
1571  throw std::runtime_error("Library not loaded!");
1572  }
1573 }
1574 
1575 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ColorCorrector_Construct(PEAK_IPL_COLOR_CORRECTOR_HANDLE * colorCorrectorHandle)
1576 {
1577  auto& inst = instance();
1578  if(inst.m_PEAK_IPL_ColorCorrector_Construct)
1579  {
1580  return inst.m_PEAK_IPL_ColorCorrector_Construct(colorCorrectorHandle);
1581  }
1582  else
1583  {
1584  throw std::runtime_error("Library not loaded!");
1585  }
1586 }
1587 
1588 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ColorCorrector_SetColorCorrectionFactors(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, float * colorCorrectorFactors)
1589 {
1590  auto& inst = instance();
1591  if(inst.m_PEAK_IPL_ColorCorrector_SetColorCorrectionFactors)
1592  {
1593  return inst.m_PEAK_IPL_ColorCorrector_SetColorCorrectionFactors(colorCorrectorHandle, colorCorrectorFactors);
1594  }
1595  else
1596  {
1597  throw std::runtime_error("Library not loaded!");
1598  }
1599 }
1600 
1601 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ColorCorrector_GetColorCorrectionFactors(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, float * colorCorrectorFactors, size_t * colorCorrectorFactorsSize)
1602 {
1603  auto& inst = instance();
1604  if(inst.m_PEAK_IPL_ColorCorrector_GetColorCorrectionFactors)
1605  {
1606  return inst.m_PEAK_IPL_ColorCorrector_GetColorCorrectionFactors(colorCorrectorHandle, colorCorrectorFactors, colorCorrectorFactorsSize);
1607  }
1608  else
1609  {
1610  throw std::runtime_error("Library not loaded!");
1611  }
1612 }
1613 
1614 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)
1615 {
1616  auto& inst = instance();
1617  if(inst.m_PEAK_IPL_ColorCorrector_GetIsPixelFormatSupported)
1618  {
1619  return inst.m_PEAK_IPL_ColorCorrector_GetIsPixelFormatSupported(colorCorrectorHandle, pixelFormat, isPixelFormatSupported);
1620  }
1621  else
1622  {
1623  throw std::runtime_error("Library not loaded!");
1624  }
1625 }
1626 
1627 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)
1628 {
1629  auto& inst = instance();
1630  if(inst.m_PEAK_IPL_ColorCorrector_Process)
1631  {
1632  return inst.m_PEAK_IPL_ColorCorrector_Process(colorCorrectorHandle, imageHandle, outputImageHandle);
1633  }
1634  else
1635  {
1636  throw std::runtime_error("Library not loaded!");
1637  }
1638 }
1639 
1640 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ColorCorrector_ProcessInPlace(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, PEAK_IPL_IMAGE_HANDLE imageHandle)
1641 {
1642  auto& inst = instance();
1643  if(inst.m_PEAK_IPL_ColorCorrector_ProcessInPlace)
1644  {
1645  return inst.m_PEAK_IPL_ColorCorrector_ProcessInPlace(colorCorrectorHandle, imageHandle);
1646  }
1647  else
1648  {
1649  throw std::runtime_error("Library not loaded!");
1650  }
1651 }
1652 
1653 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ColorCorrector_Destruct(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle)
1654 {
1655  auto& inst = instance();
1656  if(inst.m_PEAK_IPL_ColorCorrector_Destruct)
1657  {
1658  return inst.m_PEAK_IPL_ColorCorrector_Destruct(colorCorrectorHandle);
1659  }
1660  else
1661  {
1662  throw std::runtime_error("Library not loaded!");
1663  }
1664 }
1665 
1666 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Binning_Construct(PEAK_IPL_BINNING_HANDLE * binningHandle)
1667 {
1668  auto& inst = instance();
1669  if(inst.m_PEAK_IPL_Binning_Construct)
1670  {
1671  return inst.m_PEAK_IPL_Binning_Construct(binningHandle);
1672  }
1673  else
1674  {
1675  throw std::runtime_error("Library not loaded!");
1676  }
1677 }
1678 
1679 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Binning_SetBinningX(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t * binningXValue)
1680 {
1681  auto& inst = instance();
1682  if(inst.m_PEAK_IPL_Binning_SetBinningX)
1683  {
1684  return inst.m_PEAK_IPL_Binning_SetBinningX(binningHandle, binningXValue);
1685  }
1686  else
1687  {
1688  throw std::runtime_error("Library not loaded!");
1689  }
1690 }
1691 
1692 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Binning_GetBinningX(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t * binningXValue)
1693 {
1694  auto& inst = instance();
1695  if(inst.m_PEAK_IPL_Binning_GetBinningX)
1696  {
1697  return inst.m_PEAK_IPL_Binning_GetBinningX(binningHandle, binningXValue);
1698  }
1699  else
1700  {
1701  throw std::runtime_error("Library not loaded!");
1702  }
1703 }
1704 
1705 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Binning_SetBinningY(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t * binningYValue)
1706 {
1707  auto& inst = instance();
1708  if(inst.m_PEAK_IPL_Binning_SetBinningY)
1709  {
1710  return inst.m_PEAK_IPL_Binning_SetBinningY(binningHandle, binningYValue);
1711  }
1712  else
1713  {
1714  throw std::runtime_error("Library not loaded!");
1715  }
1716 }
1717 
1718 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Binning_GetBinningY(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t * binningYValue)
1719 {
1720  auto& inst = instance();
1721  if(inst.m_PEAK_IPL_Binning_GetBinningY)
1722  {
1723  return inst.m_PEAK_IPL_Binning_GetBinningY(binningHandle, binningYValue);
1724  }
1725  else
1726  {
1727  throw std::runtime_error("Library not loaded!");
1728  }
1729 }
1730 
1731 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Binning_GetBinningMin(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t * binningMin)
1732 {
1733  auto& inst = instance();
1734  if(inst.m_PEAK_IPL_Binning_GetBinningMin)
1735  {
1736  return inst.m_PEAK_IPL_Binning_GetBinningMin(binningHandle, binningMin);
1737  }
1738  else
1739  {
1740  throw std::runtime_error("Library not loaded!");
1741  }
1742 }
1743 
1744 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Binning_GetBinningMax(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t * binningMax)
1745 {
1746  auto& inst = instance();
1747  if(inst.m_PEAK_IPL_Binning_GetBinningMax)
1748  {
1749  return inst.m_PEAK_IPL_Binning_GetBinningMax(binningHandle, binningMax);
1750  }
1751  else
1752  {
1753  throw std::runtime_error("Library not loaded!");
1754  }
1755 }
1756 
1757 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Binning_ExpectedOutputSize(PEAK_IPL_BINNING_HANDLE binningHandle, size_t * outputWidth, size_t * outputHeight, const size_t inputWidth, const size_t inputHeight, const PEAK_IPL_PIXEL_FORMAT pixelFormat)
1758 {
1759  auto& inst = instance();
1760  if(inst.m_PEAK_IPL_Binning_ExpectedOutputSize)
1761  {
1762  return inst.m_PEAK_IPL_Binning_ExpectedOutputSize(binningHandle, outputWidth, outputHeight, inputWidth, inputHeight, pixelFormat);
1763  }
1764  else
1765  {
1766  throw std::runtime_error("Library not loaded!");
1767  }
1768 }
1769 
1770 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Binning_IsPixelformatSupported(PEAK_IPL_BINNING_HANDLE binningHandle, PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 * isPixelFormatSupported)
1771 {
1772  auto& inst = instance();
1773  if(inst.m_PEAK_IPL_Binning_IsPixelformatSupported)
1774  {
1775  return inst.m_PEAK_IPL_Binning_IsPixelformatSupported(binningHandle, pixelFormat, isPixelFormatSupported);
1776  }
1777  else
1778  {
1779  throw std::runtime_error("Library not loaded!");
1780  }
1781 }
1782 
1783 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Binning_SetBinningMode(PEAK_IPL_BINNING_HANDLE binningHandle, PEAK_IPL_BINNINGMODE * mode)
1784 {
1785  auto& inst = instance();
1786  if(inst.m_PEAK_IPL_Binning_SetBinningMode)
1787  {
1788  return inst.m_PEAK_IPL_Binning_SetBinningMode(binningHandle, mode);
1789  }
1790  else
1791  {
1792  throw std::runtime_error("Library not loaded!");
1793  }
1794 }
1795 
1796 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Binning_GetBinningMode(PEAK_IPL_BINNING_HANDLE binningHandle, PEAK_IPL_BINNINGMODE * mode)
1797 {
1798  auto& inst = instance();
1799  if(inst.m_PEAK_IPL_Binning_GetBinningMode)
1800  {
1801  return inst.m_PEAK_IPL_Binning_GetBinningMode(binningHandle, mode);
1802  }
1803  else
1804  {
1805  throw std::runtime_error("Library not loaded!");
1806  }
1807 }
1808 
1809 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)
1810 {
1811  auto& inst = instance();
1812  if(inst.m_PEAK_IPL_Binning_Process)
1813  {
1814  return inst.m_PEAK_IPL_Binning_Process(binningHandle, imageHandle, outputImageHandle);
1815  }
1816  else
1817  {
1818  throw std::runtime_error("Library not loaded!");
1819  }
1820 }
1821 
1822 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Binning_Destruct(PEAK_IPL_BINNING_HANDLE binningHandle)
1823 {
1824  auto& inst = instance();
1825  if(inst.m_PEAK_IPL_Binning_Destruct)
1826  {
1827  return inst.m_PEAK_IPL_Binning_Destruct(binningHandle);
1828  }
1829  else
1830  {
1831  throw std::runtime_error("Library not loaded!");
1832  }
1833 }
1834 
1835 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Gain_Construct(PEAK_IPL_GAIN_HANDLE * gainHandle)
1836 {
1837  auto& inst = instance();
1838  if(inst.m_PEAK_IPL_Gain_Construct)
1839  {
1840  return inst.m_PEAK_IPL_Gain_Construct(gainHandle);
1841  }
1842  else
1843  {
1844  throw std::runtime_error("Library not loaded!");
1845  }
1846 }
1847 
1848 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Gain_SetMasterGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float * masterGainValue)
1849 {
1850  auto& inst = instance();
1851  if(inst.m_PEAK_IPL_Gain_SetMasterGainValue)
1852  {
1853  return inst.m_PEAK_IPL_Gain_SetMasterGainValue(gainHandle, masterGainValue);
1854  }
1855  else
1856  {
1857  throw std::runtime_error("Library not loaded!");
1858  }
1859 }
1860 
1861 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Gain_GetMasterGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float * masterGainValue)
1862 {
1863  auto& inst = instance();
1864  if(inst.m_PEAK_IPL_Gain_GetMasterGainValue)
1865  {
1866  return inst.m_PEAK_IPL_Gain_GetMasterGainValue(gainHandle, masterGainValue);
1867  }
1868  else
1869  {
1870  throw std::runtime_error("Library not loaded!");
1871  }
1872 }
1873 
1874 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Gain_GetMasterGainMax(PEAK_IPL_GAIN_HANDLE gainHandle, float * masterGainMax)
1875 {
1876  auto& inst = instance();
1877  if(inst.m_PEAK_IPL_Gain_GetMasterGainMax)
1878  {
1879  return inst.m_PEAK_IPL_Gain_GetMasterGainMax(gainHandle, masterGainMax);
1880  }
1881  else
1882  {
1883  throw std::runtime_error("Library not loaded!");
1884  }
1885 }
1886 
1887 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Gain_GetMasterGainMin(PEAK_IPL_GAIN_HANDLE gainHandle, float * masterGainMin)
1888 {
1889  auto& inst = instance();
1890  if(inst.m_PEAK_IPL_Gain_GetMasterGainMin)
1891  {
1892  return inst.m_PEAK_IPL_Gain_GetMasterGainMin(gainHandle, masterGainMin);
1893  }
1894  else
1895  {
1896  throw std::runtime_error("Library not loaded!");
1897  }
1898 }
1899 
1900 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Gain_SetRedGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float * redGainValue)
1901 {
1902  auto& inst = instance();
1903  if(inst.m_PEAK_IPL_Gain_SetRedGainValue)
1904  {
1905  return inst.m_PEAK_IPL_Gain_SetRedGainValue(gainHandle, redGainValue);
1906  }
1907  else
1908  {
1909  throw std::runtime_error("Library not loaded!");
1910  }
1911 }
1912 
1913 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Gain_GetRedGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float * redGainValue)
1914 {
1915  auto& inst = instance();
1916  if(inst.m_PEAK_IPL_Gain_GetRedGainValue)
1917  {
1918  return inst.m_PEAK_IPL_Gain_GetRedGainValue(gainHandle, redGainValue);
1919  }
1920  else
1921  {
1922  throw std::runtime_error("Library not loaded!");
1923  }
1924 }
1925 
1926 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Gain_GetRedGainMax(PEAK_IPL_GAIN_HANDLE gainHandle, float * redGainMax)
1927 {
1928  auto& inst = instance();
1929  if(inst.m_PEAK_IPL_Gain_GetRedGainMax)
1930  {
1931  return inst.m_PEAK_IPL_Gain_GetRedGainMax(gainHandle, redGainMax);
1932  }
1933  else
1934  {
1935  throw std::runtime_error("Library not loaded!");
1936  }
1937 }
1938 
1939 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Gain_GetRedGainMin(PEAK_IPL_GAIN_HANDLE gainHandle, float * redGainMin)
1940 {
1941  auto& inst = instance();
1942  if(inst.m_PEAK_IPL_Gain_GetRedGainMin)
1943  {
1944  return inst.m_PEAK_IPL_Gain_GetRedGainMin(gainHandle, redGainMin);
1945  }
1946  else
1947  {
1948  throw std::runtime_error("Library not loaded!");
1949  }
1950 }
1951 
1952 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Gain_SetGreenGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float * greenGainValue)
1953 {
1954  auto& inst = instance();
1955  if(inst.m_PEAK_IPL_Gain_SetGreenGainValue)
1956  {
1957  return inst.m_PEAK_IPL_Gain_SetGreenGainValue(gainHandle, greenGainValue);
1958  }
1959  else
1960  {
1961  throw std::runtime_error("Library not loaded!");
1962  }
1963 }
1964 
1965 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Gain_GetGreenGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float * greenGainValue)
1966 {
1967  auto& inst = instance();
1968  if(inst.m_PEAK_IPL_Gain_GetGreenGainValue)
1969  {
1970  return inst.m_PEAK_IPL_Gain_GetGreenGainValue(gainHandle, greenGainValue);
1971  }
1972  else
1973  {
1974  throw std::runtime_error("Library not loaded!");
1975  }
1976 }
1977 
1978 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Gain_GetGreenGainMax(PEAK_IPL_GAIN_HANDLE gainHandle, float * greenGainMax)
1979 {
1980  auto& inst = instance();
1981  if(inst.m_PEAK_IPL_Gain_GetGreenGainMax)
1982  {
1983  return inst.m_PEAK_IPL_Gain_GetGreenGainMax(gainHandle, greenGainMax);
1984  }
1985  else
1986  {
1987  throw std::runtime_error("Library not loaded!");
1988  }
1989 }
1990 
1991 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Gain_GetGreenGainMin(PEAK_IPL_GAIN_HANDLE gainHandle, float * greenGainMin)
1992 {
1993  auto& inst = instance();
1994  if(inst.m_PEAK_IPL_Gain_GetGreenGainMin)
1995  {
1996  return inst.m_PEAK_IPL_Gain_GetGreenGainMin(gainHandle, greenGainMin);
1997  }
1998  else
1999  {
2000  throw std::runtime_error("Library not loaded!");
2001  }
2002 }
2003 
2004 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Gain_SetBlueGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float * blueGainValue)
2005 {
2006  auto& inst = instance();
2007  if(inst.m_PEAK_IPL_Gain_SetBlueGainValue)
2008  {
2009  return inst.m_PEAK_IPL_Gain_SetBlueGainValue(gainHandle, blueGainValue);
2010  }
2011  else
2012  {
2013  throw std::runtime_error("Library not loaded!");
2014  }
2015 }
2016 
2017 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Gain_GetBlueGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float * blueGainValue)
2018 {
2019  auto& inst = instance();
2020  if(inst.m_PEAK_IPL_Gain_GetBlueGainValue)
2021  {
2022  return inst.m_PEAK_IPL_Gain_GetBlueGainValue(gainHandle, blueGainValue);
2023  }
2024  else
2025  {
2026  throw std::runtime_error("Library not loaded!");
2027  }
2028 }
2029 
2030 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Gain_GetBlueGainMax(PEAK_IPL_GAIN_HANDLE gainHandle, float * blueGainMax)
2031 {
2032  auto& inst = instance();
2033  if(inst.m_PEAK_IPL_Gain_GetBlueGainMax)
2034  {
2035  return inst.m_PEAK_IPL_Gain_GetBlueGainMax(gainHandle, blueGainMax);
2036  }
2037  else
2038  {
2039  throw std::runtime_error("Library not loaded!");
2040  }
2041 }
2042 
2043 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Gain_GetBlueGainMin(PEAK_IPL_GAIN_HANDLE gainHandle, float * blueGainMin)
2044 {
2045  auto& inst = instance();
2046  if(inst.m_PEAK_IPL_Gain_GetBlueGainMin)
2047  {
2048  return inst.m_PEAK_IPL_Gain_GetBlueGainMin(gainHandle, blueGainMin);
2049  }
2050  else
2051  {
2052  throw std::runtime_error("Library not loaded!");
2053  }
2054 }
2055 
2056 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Gain_GetIsPixelFormatSupported(PEAK_IPL_GAIN_HANDLE gainHandle, PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8 * isPixelFormatSupported)
2057 {
2058  auto& inst = instance();
2059  if(inst.m_PEAK_IPL_Gain_GetIsPixelFormatSupported)
2060  {
2061  return inst.m_PEAK_IPL_Gain_GetIsPixelFormatSupported(gainHandle, pixelFormat, isPixelFormatSupported);
2062  }
2063  else
2064  {
2065  throw std::runtime_error("Library not loaded!");
2066  }
2067 }
2068 
2069 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)
2070 {
2071  auto& inst = instance();
2072  if(inst.m_PEAK_IPL_Gain_Process)
2073  {
2074  return inst.m_PEAK_IPL_Gain_Process(gainHandle, imageHandle, outputImageHandle);
2075  }
2076  else
2077  {
2078  throw std::runtime_error("Library not loaded!");
2079  }
2080 }
2081 
2082 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Gain_ProcessInPlace(PEAK_IPL_GAIN_HANDLE gainHandle, PEAK_IPL_IMAGE_HANDLE imageHandle)
2083 {
2084  auto& inst = instance();
2085  if(inst.m_PEAK_IPL_Gain_ProcessInPlace)
2086  {
2087  return inst.m_PEAK_IPL_Gain_ProcessInPlace(gainHandle, imageHandle);
2088  }
2089  else
2090  {
2091  throw std::runtime_error("Library not loaded!");
2092  }
2093 }
2094 
2095 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Gain_Destruct(PEAK_IPL_GAIN_HANDLE gainHandle)
2096 {
2097  auto& inst = instance();
2098  if(inst.m_PEAK_IPL_Gain_Destruct)
2099  {
2100  return inst.m_PEAK_IPL_Gain_Destruct(gainHandle);
2101  }
2102  else
2103  {
2104  throw std::runtime_error("Library not loaded!");
2105  }
2106 }
2107 
2108 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_GammaCorrector_Construct(PEAK_IPL_GAMMA_CORRECTOR_HANDLE * gammaCorrectorHandle)
2109 {
2110  auto& inst = instance();
2111  if(inst.m_PEAK_IPL_GammaCorrector_Construct)
2112  {
2113  return inst.m_PEAK_IPL_GammaCorrector_Construct(gammaCorrectorHandle);
2114  }
2115  else
2116  {
2117  throw std::runtime_error("Library not loaded!");
2118  }
2119 }
2120 
2121 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_GammaCorrector_SetGammaCorrectionValue(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float * gammaValue)
2122 {
2123  auto& inst = instance();
2124  if(inst.m_PEAK_IPL_GammaCorrector_SetGammaCorrectionValue)
2125  {
2126  return inst.m_PEAK_IPL_GammaCorrector_SetGammaCorrectionValue(gammaCorrectorHandle, gammaValue);
2127  }
2128  else
2129  {
2130  throw std::runtime_error("Library not loaded!");
2131  }
2132 }
2133 
2134 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_GammaCorrector_GetGammaCorrectionValue(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float * gammaValue)
2135 {
2136  auto& inst = instance();
2137  if(inst.m_PEAK_IPL_GammaCorrector_GetGammaCorrectionValue)
2138  {
2139  return inst.m_PEAK_IPL_GammaCorrector_GetGammaCorrectionValue(gammaCorrectorHandle, gammaValue);
2140  }
2141  else
2142  {
2143  throw std::runtime_error("Library not loaded!");
2144  }
2145 }
2146 
2147 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_GammaCorrector_GetGammaCorrectionMax(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float * gammaMax)
2148 {
2149  auto& inst = instance();
2150  if(inst.m_PEAK_IPL_GammaCorrector_GetGammaCorrectionMax)
2151  {
2152  return inst.m_PEAK_IPL_GammaCorrector_GetGammaCorrectionMax(gammaCorrectorHandle, gammaMax);
2153  }
2154  else
2155  {
2156  throw std::runtime_error("Library not loaded!");
2157  }
2158 }
2159 
2160 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_GammaCorrector_GetGammaCorrectionMin(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float * gammaMin)
2161 {
2162  auto& inst = instance();
2163  if(inst.m_PEAK_IPL_GammaCorrector_GetGammaCorrectionMin)
2164  {
2165  return inst.m_PEAK_IPL_GammaCorrector_GetGammaCorrectionMin(gammaCorrectorHandle, gammaMin);
2166  }
2167  else
2168  {
2169  throw std::runtime_error("Library not loaded!");
2170  }
2171 }
2172 
2173 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)
2174 {
2175  auto& inst = instance();
2176  if(inst.m_PEAK_IPL_GammaCorrector_GetIsPixelFormatSupported)
2177  {
2178  return inst.m_PEAK_IPL_GammaCorrector_GetIsPixelFormatSupported(gammaCorrectorHandle, pixelFormat, isPixelFormatSupported);
2179  }
2180  else
2181  {
2182  throw std::runtime_error("Library not loaded!");
2183  }
2184 }
2185 
2186 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)
2187 {
2188  auto& inst = instance();
2189  if(inst.m_PEAK_IPL_GammaCorrector_Process)
2190  {
2191  return inst.m_PEAK_IPL_GammaCorrector_Process(gammaCorrectorHandle, imageHandle, outputImageHandle);
2192  }
2193  else
2194  {
2195  throw std::runtime_error("Library not loaded!");
2196  }
2197 }
2198 
2199 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_GammaCorrector_ProcessInPlace(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, PEAK_IPL_IMAGE_HANDLE imageHandle)
2200 {
2201  auto& inst = instance();
2202  if(inst.m_PEAK_IPL_GammaCorrector_ProcessInPlace)
2203  {
2204  return inst.m_PEAK_IPL_GammaCorrector_ProcessInPlace(gammaCorrectorHandle, imageHandle);
2205  }
2206  else
2207  {
2208  throw std::runtime_error("Library not loaded!");
2209  }
2210 }
2211 
2212 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_GammaCorrector_Destruct(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle)
2213 {
2214  auto& inst = instance();
2215  if(inst.m_PEAK_IPL_GammaCorrector_Destruct)
2216  {
2217  return inst.m_PEAK_IPL_GammaCorrector_Destruct(gammaCorrectorHandle);
2218  }
2219  else
2220  {
2221  throw std::runtime_error("Library not loaded!");
2222  }
2223 }
2224 
2225 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)
2226 {
2227  auto& inst = instance();
2228  if(inst.m_PEAK_IPL_Image_Construct)
2229  {
2230  return inst.m_PEAK_IPL_Image_Construct(pixelFormat, width, height, imageHandle);
2231  }
2232  else
2233  {
2234  throw std::runtime_error("Library not loaded!");
2235  }
2236 }
2237 
2238 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)
2239 {
2240  auto& inst = instance();
2241  if(inst.m_PEAK_IPL_Image_ConstructFromBuffer)
2242  {
2243  return inst.m_PEAK_IPL_Image_ConstructFromBuffer(pixelFormat, buffer, bufferSize, width, height, imageHandle);
2244  }
2245  else
2246  {
2247  throw std::runtime_error("Library not loaded!");
2248  }
2249 }
2250 
2251 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Image_GetWidth(PEAK_IPL_IMAGE_HANDLE imageHandle, size_t * width)
2252 {
2253  auto& inst = instance();
2254  if(inst.m_PEAK_IPL_Image_GetWidth)
2255  {
2256  return inst.m_PEAK_IPL_Image_GetWidth(imageHandle, width);
2257  }
2258  else
2259  {
2260  throw std::runtime_error("Library not loaded!");
2261  }
2262 }
2263 
2264 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Image_GetHeight(PEAK_IPL_IMAGE_HANDLE imageHandle, size_t * height)
2265 {
2266  auto& inst = instance();
2267  if(inst.m_PEAK_IPL_Image_GetHeight)
2268  {
2269  return inst.m_PEAK_IPL_Image_GetHeight(imageHandle, height);
2270  }
2271  else
2272  {
2273  throw std::runtime_error("Library not loaded!");
2274  }
2275 }
2276 
2277 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Image_GetPixelPointer(PEAK_IPL_IMAGE_HANDLE imageHandle, size_t xPos, size_t yPos, uint8_t * * pixelPointer)
2278 {
2279  auto& inst = instance();
2280  if(inst.m_PEAK_IPL_Image_GetPixelPointer)
2281  {
2282  return inst.m_PEAK_IPL_Image_GetPixelPointer(imageHandle, xPos, yPos, pixelPointer);
2283  }
2284  else
2285  {
2286  throw std::runtime_error("Library not loaded!");
2287  }
2288 }
2289 
2290 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Image_GetByteCount(PEAK_IPL_IMAGE_HANDLE imageHandle, size_t * byteCount)
2291 {
2292  auto& inst = instance();
2293  if(inst.m_PEAK_IPL_Image_GetByteCount)
2294  {
2295  return inst.m_PEAK_IPL_Image_GetByteCount(imageHandle, byteCount);
2296  }
2297  else
2298  {
2299  throw std::runtime_error("Library not loaded!");
2300  }
2301 }
2302 
2303 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Image_GetPixelFormat(PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_PIXEL_FORMAT * pixelFormat)
2304 {
2305  auto& inst = instance();
2306  if(inst.m_PEAK_IPL_Image_GetPixelFormat)
2307  {
2308  return inst.m_PEAK_IPL_Image_GetPixelFormat(imageHandle, pixelFormat);
2309  }
2310  else
2311  {
2312  throw std::runtime_error("Library not loaded!");
2313  }
2314 }
2315 
2316 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Image_GetData(PEAK_IPL_IMAGE_HANDLE imageHandle, uint8_t * * data)
2317 {
2318  auto& inst = instance();
2319  if(inst.m_PEAK_IPL_Image_GetData)
2320  {
2321  return inst.m_PEAK_IPL_Image_GetData(imageHandle, data);
2322  }
2323  else
2324  {
2325  throw std::runtime_error("Library not loaded!");
2326  }
2327 }
2328 
2329 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Image_Clone(PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE * outputImageHandle)
2330 {
2331  auto& inst = instance();
2332  if(inst.m_PEAK_IPL_Image_Clone)
2333  {
2334  return inst.m_PEAK_IPL_Image_Clone(imageHandle, outputImageHandle);
2335  }
2336  else
2337  {
2338  throw std::runtime_error("Library not loaded!");
2339  }
2340 }
2341 
2342 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)
2343 {
2344  auto& inst = instance();
2345  if(inst.m_PEAK_IPL_Image_ConvertTo)
2346  {
2347  return inst.m_PEAK_IPL_Image_ConvertTo(imageHandle, outputPixelFormat, conversionMode, outputImageHandle);
2348  }
2349  else
2350  {
2351  throw std::runtime_error("Library not loaded!");
2352  }
2353 }
2354 
2355 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)
2356 {
2357  auto& inst = instance();
2358  if(inst.m_PEAK_IPL_Image_ConvertToBuffer)
2359  {
2360  return inst.m_PEAK_IPL_Image_ConvertToBuffer(imageHandle, outputPixelFormat, outputImageBuffer, outputImageBufferSize, conversionMode, outputImageHandle);
2361  }
2362  else
2363  {
2364  throw std::runtime_error("Library not loaded!");
2365  }
2366 }
2367 
2368 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Image_Destruct(PEAK_IPL_IMAGE_HANDLE imageHandle)
2369 {
2370  auto& inst = instance();
2371  if(inst.m_PEAK_IPL_Image_Destruct)
2372  {
2373  return inst.m_PEAK_IPL_Image_Destruct(imageHandle);
2374  }
2375  else
2376  {
2377  throw std::runtime_error("Library not loaded!");
2378  }
2379 }
2380 
2381 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageTransformer_Construct(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE * imageTransformerHandle)
2382 {
2383  auto& inst = instance();
2384  if(inst.m_PEAK_IPL_ImageTransformer_Construct)
2385  {
2386  return inst.m_PEAK_IPL_ImageTransformer_Construct(imageTransformerHandle);
2387  }
2388  else
2389  {
2390  throw std::runtime_error("Library not loaded!");
2391  }
2392 }
2393 
2394 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)
2395 {
2396  auto& inst = instance();
2397  if(inst.m_PEAK_IPL_ImageTransformer_MirrorUpDown)
2398  {
2399  return inst.m_PEAK_IPL_ImageTransformer_MirrorUpDown(imageTransformerHandle, imageHandle, outputImageHandle);
2400  }
2401  else
2402  {
2403  throw std::runtime_error("Library not loaded!");
2404  }
2405 }
2406 
2407 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)
2408 {
2409  auto& inst = instance();
2410  if(inst.m_PEAK_IPL_ImageTransformer_MirrorLeftRight)
2411  {
2412  return inst.m_PEAK_IPL_ImageTransformer_MirrorLeftRight(imageTransformerHandle, imageHandle, outputImageHandle);
2413  }
2414  else
2415  {
2416  throw std::runtime_error("Library not loaded!");
2417  }
2418 }
2419 
2420 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)
2421 {
2422  auto& inst = instance();
2423  if(inst.m_PEAK_IPL_ImageTransformer_MirrorUpDownLeftRight)
2424  {
2425  return inst.m_PEAK_IPL_ImageTransformer_MirrorUpDownLeftRight(imageTransformerHandle, imageHandle, outputImageHandle);
2426  }
2427  else
2428  {
2429  throw std::runtime_error("Library not loaded!");
2430  }
2431 }
2432 
2433 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageTransformer_MirrorUpDownInPlace(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle, PEAK_IPL_IMAGE_HANDLE imageHandle)
2434 {
2435  auto& inst = instance();
2436  if(inst.m_PEAK_IPL_ImageTransformer_MirrorUpDownInPlace)
2437  {
2438  return inst.m_PEAK_IPL_ImageTransformer_MirrorUpDownInPlace(imageTransformerHandle, imageHandle);
2439  }
2440  else
2441  {
2442  throw std::runtime_error("Library not loaded!");
2443  }
2444 }
2445 
2446 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageTransformer_MirrorLeftRightInPlace(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle, PEAK_IPL_IMAGE_HANDLE imageHandle)
2447 {
2448  auto& inst = instance();
2449  if(inst.m_PEAK_IPL_ImageTransformer_MirrorLeftRightInPlace)
2450  {
2451  return inst.m_PEAK_IPL_ImageTransformer_MirrorLeftRightInPlace(imageTransformerHandle, imageHandle);
2452  }
2453  else
2454  {
2455  throw std::runtime_error("Library not loaded!");
2456  }
2457 }
2458 
2459 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageTransformer_MirrorUpDownLeftRightInPlace(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle, PEAK_IPL_IMAGE_HANDLE imageHandle)
2460 {
2461  auto& inst = instance();
2462  if(inst.m_PEAK_IPL_ImageTransformer_MirrorUpDownLeftRightInPlace)
2463  {
2464  return inst.m_PEAK_IPL_ImageTransformer_MirrorUpDownLeftRightInPlace(imageTransformerHandle, imageHandle);
2465  }
2466  else
2467  {
2468  throw std::runtime_error("Library not loaded!");
2469  }
2470 }
2471 
2472 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, PEAK_IPL_IMAGE_TRANSFORMER_ROTATION_ANGLE_t rotationAngle)
2473 {
2474  auto& inst = instance();
2475  if(inst.m_PEAK_IPL_ImageTransformer_Rotate)
2476  {
2477  return inst.m_PEAK_IPL_ImageTransformer_Rotate(imageTransformerHandle, imageHandle, outputImageHandle, rotationAngle);
2478  }
2479  else
2480  {
2481  throw std::runtime_error("Library not loaded!");
2482  }
2483 }
2484 
2485 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageTransformer_RotateInPlace(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_TRANSFORMER_ROTATION_ANGLE_t rotationAngle)
2486 {
2487  auto& inst = instance();
2488  if(inst.m_PEAK_IPL_ImageTransformer_RotateInPlace)
2489  {
2490  return inst.m_PEAK_IPL_ImageTransformer_RotateInPlace(imageTransformerHandle, imageHandle, rotationAngle);
2491  }
2492  else
2493  {
2494  throw std::runtime_error("Library not loaded!");
2495  }
2496 }
2497 
2498 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageTransformer_Destruct(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle)
2499 {
2500  auto& inst = instance();
2501  if(inst.m_PEAK_IPL_ImageTransformer_Destruct)
2502  {
2503  return inst.m_PEAK_IPL_ImageTransformer_Destruct(imageTransformerHandle);
2504  }
2505  else
2506  {
2507  throw std::runtime_error("Library not loaded!");
2508  }
2509 }
2510 
2511 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Histogram_Construct(PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_HISTOGRAM_HANDLE * histogramHandle)
2512 {
2513  auto& inst = instance();
2514  if(inst.m_PEAK_IPL_Histogram_Construct)
2515  {
2516  return inst.m_PEAK_IPL_Histogram_Construct(imageHandle, histogramHandle);
2517  }
2518  else
2519  {
2520  throw std::runtime_error("Library not loaded!");
2521  }
2522 }
2523 
2524 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Histogram_GetPixelFormat(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle, PEAK_IPL_PIXEL_FORMAT * pixelFormat)
2525 {
2526  auto& inst = instance();
2527  if(inst.m_PEAK_IPL_Histogram_GetPixelFormat)
2528  {
2529  return inst.m_PEAK_IPL_Histogram_GetPixelFormat(histogramHandle, pixelFormat);
2530  }
2531  else
2532  {
2533  throw std::runtime_error("Library not loaded!");
2534  }
2535 }
2536 
2537 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Histogram_GetNumChannels(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle, size_t * numChannels)
2538 {
2539  auto& inst = instance();
2540  if(inst.m_PEAK_IPL_Histogram_GetNumChannels)
2541  {
2542  return inst.m_PEAK_IPL_Histogram_GetNumChannels(histogramHandle, numChannels);
2543  }
2544  else
2545  {
2546  throw std::runtime_error("Library not loaded!");
2547  }
2548 }
2549 
2550 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Histogram_GetPixelSumForChannel(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle, size_t channelIndex, uint64_t * pixelSum)
2551 {
2552  auto& inst = instance();
2553  if(inst.m_PEAK_IPL_Histogram_GetPixelSumForChannel)
2554  {
2555  return inst.m_PEAK_IPL_Histogram_GetPixelSumForChannel(histogramHandle, channelIndex, pixelSum);
2556  }
2557  else
2558  {
2559  throw std::runtime_error("Library not loaded!");
2560  }
2561 }
2562 
2563 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Histogram_GetPixelCountForChannel(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle, size_t channelIndex, uint64_t * pixelCount)
2564 {
2565  auto& inst = instance();
2566  if(inst.m_PEAK_IPL_Histogram_GetPixelCountForChannel)
2567  {
2568  return inst.m_PEAK_IPL_Histogram_GetPixelCountForChannel(histogramHandle, channelIndex, pixelCount);
2569  }
2570  else
2571  {
2572  throw std::runtime_error("Library not loaded!");
2573  }
2574 }
2575 
2576 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Histogram_GetBinsForChannel(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle, size_t channelIndex, uint64_t * bins, size_t * binsSize)
2577 {
2578  auto& inst = instance();
2579  if(inst.m_PEAK_IPL_Histogram_GetBinsForChannel)
2580  {
2581  return inst.m_PEAK_IPL_Histogram_GetBinsForChannel(histogramHandle, channelIndex, bins, binsSize);
2582  }
2583  else
2584  {
2585  throw std::runtime_error("Library not loaded!");
2586  }
2587 }
2588 
2589 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_Histogram_Destruct(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle)
2590 {
2591  auto& inst = instance();
2592  if(inst.m_PEAK_IPL_Histogram_Destruct)
2593  {
2594  return inst.m_PEAK_IPL_Histogram_Destruct(histogramHandle);
2595  }
2596  else
2597  {
2598  throw std::runtime_error("Library not loaded!");
2599  }
2600 }
2601 
2602 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)
2603 {
2604  auto& inst = instance();
2605  if(inst.m_PEAK_IPL_PixelLine_Construct)
2606  {
2607  return inst.m_PEAK_IPL_PixelLine_Construct(imageHandle, orientation, offset, pixelLineHandle);
2608  }
2609  else
2610  {
2611  throw std::runtime_error("Library not loaded!");
2612  }
2613 }
2614 
2615 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_PixelLine_GetPixelFormat(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle, PEAK_IPL_PIXEL_FORMAT * pixelFormat)
2616 {
2617  auto& inst = instance();
2618  if(inst.m_PEAK_IPL_PixelLine_GetPixelFormat)
2619  {
2620  return inst.m_PEAK_IPL_PixelLine_GetPixelFormat(pixelLineHandle, pixelFormat);
2621  }
2622  else
2623  {
2624  throw std::runtime_error("Library not loaded!");
2625  }
2626 }
2627 
2628 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_PixelLine_GetOrientation(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle, PEAK_IPL_ORIENTATION * orientation)
2629 {
2630  auto& inst = instance();
2631  if(inst.m_PEAK_IPL_PixelLine_GetOrientation)
2632  {
2633  return inst.m_PEAK_IPL_PixelLine_GetOrientation(pixelLineHandle, orientation);
2634  }
2635  else
2636  {
2637  throw std::runtime_error("Library not loaded!");
2638  }
2639 }
2640 
2641 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_PixelLine_GetOffset(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle, size_t * offset)
2642 {
2643  auto& inst = instance();
2644  if(inst.m_PEAK_IPL_PixelLine_GetOffset)
2645  {
2646  return inst.m_PEAK_IPL_PixelLine_GetOffset(pixelLineHandle, offset);
2647  }
2648  else
2649  {
2650  throw std::runtime_error("Library not loaded!");
2651  }
2652 }
2653 
2654 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_PixelLine_GetNumChannels(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle, size_t * numChannels)
2655 {
2656  auto& inst = instance();
2657  if(inst.m_PEAK_IPL_PixelLine_GetNumChannels)
2658  {
2659  return inst.m_PEAK_IPL_PixelLine_GetNumChannels(pixelLineHandle, numChannels);
2660  }
2661  else
2662  {
2663  throw std::runtime_error("Library not loaded!");
2664  }
2665 }
2666 
2667 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)
2668 {
2669  auto& inst = instance();
2670  if(inst.m_PEAK_IPL_PixelLine_GetValuesForChannel)
2671  {
2672  return inst.m_PEAK_IPL_PixelLine_GetValuesForChannel(pixelLineHandle, channelIndex, values, valuesSize);
2673  }
2674  else
2675  {
2676  throw std::runtime_error("Library not loaded!");
2677  }
2678 }
2679 
2680 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_PixelLine_Destruct(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle)
2681 {
2682  auto& inst = instance();
2683  if(inst.m_PEAK_IPL_PixelLine_Destruct)
2684  {
2685  return inst.m_PEAK_IPL_PixelLine_Destruct(pixelLineHandle);
2686  }
2687  else
2688  {
2689  throw std::runtime_error("Library not loaded!");
2690  }
2691 }
2692 
2693 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_PixelFormat_GetNumChannels(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t * numChannels)
2694 {
2695  auto& inst = instance();
2696  if(inst.m_PEAK_IPL_PixelFormat_GetNumChannels)
2697  {
2698  return inst.m_PEAK_IPL_PixelFormat_GetNumChannels(pixelFormat, numChannels);
2699  }
2700  else
2701  {
2702  throw std::runtime_error("Library not loaded!");
2703  }
2704 }
2705 
2706 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_PixelFormat_GetNumSignificantBitsPerChannel(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t * numSignificantBits)
2707 {
2708  auto& inst = instance();
2709  if(inst.m_PEAK_IPL_PixelFormat_GetNumSignificantBitsPerChannel)
2710  {
2711  return inst.m_PEAK_IPL_PixelFormat_GetNumSignificantBitsPerChannel(pixelFormat, numSignificantBits);
2712  }
2713  else
2714  {
2715  throw std::runtime_error("Library not loaded!");
2716  }
2717 }
2718 
2719 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_PixelFormat_GetNumStorageBitsPerChannel(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t * numStorageBits)
2720 {
2721  auto& inst = instance();
2722  if(inst.m_PEAK_IPL_PixelFormat_GetNumStorageBitsPerChannel)
2723  {
2724  return inst.m_PEAK_IPL_PixelFormat_GetNumStorageBitsPerChannel(pixelFormat, numStorageBits);
2725  }
2726  else
2727  {
2728  throw std::runtime_error("Library not loaded!");
2729  }
2730 }
2731 
2732 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_PixelFormat_GetMaximumValuePerChannel(PEAK_IPL_PIXEL_FORMAT pixelFormat, uint32_t * channelMaximumValue)
2733 {
2734  auto& inst = instance();
2735  if(inst.m_PEAK_IPL_PixelFormat_GetMaximumValuePerChannel)
2736  {
2737  return inst.m_PEAK_IPL_PixelFormat_GetMaximumValuePerChannel(pixelFormat, channelMaximumValue);
2738  }
2739  else
2740  {
2741  throw std::runtime_error("Library not loaded!");
2742  }
2743 }
2744 
2745 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_PixelFormat_GetNumSignificantBitsPerPixel(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t * numSignificantBits)
2746 {
2747  auto& inst = instance();
2748  if(inst.m_PEAK_IPL_PixelFormat_GetNumSignificantBitsPerPixel)
2749  {
2750  return inst.m_PEAK_IPL_PixelFormat_GetNumSignificantBitsPerPixel(pixelFormat, numSignificantBits);
2751  }
2752  else
2753  {
2754  throw std::runtime_error("Library not loaded!");
2755  }
2756 }
2757 
2758 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_PixelFormat_GetNumStorageBitsPerPixel(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t * numStorageBits)
2759 {
2760  auto& inst = instance();
2761  if(inst.m_PEAK_IPL_PixelFormat_GetNumStorageBitsPerPixel)
2762  {
2763  return inst.m_PEAK_IPL_PixelFormat_GetNumStorageBitsPerPixel(pixelFormat, numStorageBits);
2764  }
2765  else
2766  {
2767  throw std::runtime_error("Library not loaded!");
2768  }
2769 }
2770 
2771 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_PixelFormat_GetEndianness(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_ENDIANNESS * endianness)
2772 {
2773  auto& inst = instance();
2774  if(inst.m_PEAK_IPL_PixelFormat_GetEndianness)
2775  {
2776  return inst.m_PEAK_IPL_PixelFormat_GetEndianness(pixelFormat, endianness);
2777  }
2778  else
2779  {
2780  throw std::runtime_error("Library not loaded!");
2781  }
2782 }
2783 
2784 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_PixelFormat_CalculateStorageSizeOfPixels(PEAK_IPL_PIXEL_FORMAT pixelFormat, uint64_t numPixels, uint64_t * size)
2785 {
2786  auto& inst = instance();
2787  if(inst.m_PEAK_IPL_PixelFormat_CalculateStorageSizeOfPixels)
2788  {
2789  return inst.m_PEAK_IPL_PixelFormat_CalculateStorageSizeOfPixels(pixelFormat, numPixels, size);
2790  }
2791  else
2792  {
2793  throw std::runtime_error("Library not loaded!");
2794  }
2795 }
2796 
2797 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageWriter_WriteAsRAW(PEAK_IPL_IMAGE_HANDLE inputImageHandle, const char * filePath, size_t filePathSize)
2798 {
2799  auto& inst = instance();
2800  if(inst.m_PEAK_IPL_ImageWriter_WriteAsRAW)
2801  {
2802  return inst.m_PEAK_IPL_ImageWriter_WriteAsRAW(inputImageHandle, filePath, filePathSize);
2803  }
2804  else
2805  {
2806  throw std::runtime_error("Library not loaded!");
2807  }
2808 }
2809 
2810 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageWriter_WriteAsBMP(PEAK_IPL_IMAGE_HANDLE inputImageHandle, const char * filePath, size_t filePathSize)
2811 {
2812  auto& inst = instance();
2813  if(inst.m_PEAK_IPL_ImageWriter_WriteAsBMP)
2814  {
2815  return inst.m_PEAK_IPL_ImageWriter_WriteAsBMP(inputImageHandle, filePath, filePathSize);
2816  }
2817  else
2818  {
2819  throw std::runtime_error("Library not loaded!");
2820  }
2821 }
2822 
2823 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageWriter_WriteAsPNG(PEAK_IPL_IMAGE_HANDLE inputImageHandle, uint32_t quality, const char * filePath, size_t filePathSize)
2824 {
2825  auto& inst = instance();
2826  if(inst.m_PEAK_IPL_ImageWriter_WriteAsPNG)
2827  {
2828  return inst.m_PEAK_IPL_ImageWriter_WriteAsPNG(inputImageHandle, quality, filePath, filePathSize);
2829  }
2830  else
2831  {
2832  throw std::runtime_error("Library not loaded!");
2833  }
2834 }
2835 
2836 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageWriter_WriteAsJPG(PEAK_IPL_IMAGE_HANDLE inputImageHandle, uint32_t quality, const char * filePath, size_t filePathSize)
2837 {
2838  auto& inst = instance();
2839  if(inst.m_PEAK_IPL_ImageWriter_WriteAsJPG)
2840  {
2841  return inst.m_PEAK_IPL_ImageWriter_WriteAsJPG(inputImageHandle, quality, filePath, filePathSize);
2842  }
2843  else
2844  {
2845  throw std::runtime_error("Library not loaded!");
2846  }
2847 }
2848 
2849 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageWriter_Write(PEAK_IPL_IMAGE_HANDLE inputImageHandle, const char * filePath, size_t filePathSize)
2850 {
2851  auto& inst = instance();
2852  if(inst.m_PEAK_IPL_ImageWriter_Write)
2853  {
2854  return inst.m_PEAK_IPL_ImageWriter_Write(inputImageHandle, filePath, filePathSize);
2855  }
2856  else
2857  {
2858  throw std::runtime_error("Library not loaded!");
2859  }
2860 }
2861 
2862 inline PEAK_IPL_C_API DynamicLoader::PEAK_IPL_ImageReader_Read(const char * filePath, size_t filePathSize, PEAK_IPL_IMAGE_HANDLE * outputImageHandle)
2863 {
2864  auto& inst = instance();
2865  if(inst.m_PEAK_IPL_ImageReader_Read)
2866  {
2867  return inst.m_PEAK_IPL_ImageReader_Read(filePath, filePathSize, outputImageHandle);
2868  }
2869  else
2870  {
2871  throw std::runtime_error("Library not loaded!");
2872  }
2873 }
2874 
2875 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)
2876 {
2877  auto& inst = instance();
2878  if(inst.m_PEAK_IPL_ImageReaderRead_ReadAsPixelFormat)
2879  {
2880  return inst.m_PEAK_IPL_ImageReaderRead_ReadAsPixelFormat(filePath, filePathSize, pixelFormat, outputImageHandle);
2881  }
2882  else
2883  {
2884  throw std::runtime_error("Library not loaded!");
2885  }
2886 }
2887 
2888 } /* namespace dynamic */
2889 } /* namespace ipl */
2890 } /* namespace peak */
2891 
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:79
PEAK_IPL_BINNINGMODE
uint16_t PEAK_IPL_BINNINGMODE
Definition: peak_ipl_backend.h:198
PEAK_IPL_COLOR_CORRECTOR_HANDLE
struct PEAK_IPL_COLOR_CORRECTOR * PEAK_IPL_COLOR_CORRECTOR_HANDLE
Definition: peak_ipl_backend.h:226
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:159
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:1692
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:1627
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:1926
PEAK_IPL_ENDIANNESS
int32_t PEAK_IPL_ENDIANNESS
Definition: peak_ipl_backend.h:162
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:41
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:2147
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:133
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:64
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:1718
peak::ipl::dynamic::DynamicLoader::isLoaded
static bool isLoaded()
Definition: peak_ipl_dynamic_loader.h:488
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:2160
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:1315
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:55
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:93
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:44
PEAK_IPL_HISTOGRAM_HANDLE
struct PEAK_IPL_HISTOGRAM * PEAK_IPL_HISTOGRAM_HANDLE
Definition: peak_ipl_backend.h:242
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:87
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:1445
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:2758
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:2641
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:128
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:144
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:2680
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:2745
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:2667
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:2654
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:2602
peak::ipl::dynamic::DynamicLoader::~DynamicLoader
~DynamicLoader()
Definition: peak_ipl_dynamic_loader.h:480
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:40
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:110
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:77
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:2290
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:92
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:2199
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:1822
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:118
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:136
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:146
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:108
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:96
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:2108
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:135
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:156
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:2719
PEAK_IPL_RETURN_CODE
int32_t PEAK_IPL_RETURN_CODE
Definition: peak_ipl_backend.h:41
PEAK_IPL_ORIENTATION
int32_t PEAK_IPL_ORIENTATION
Definition: peak_ipl_backend.h:170
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:50
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 PEAK_IPL_POINT_2D *hotpixels, size_t hotpixelsSize, PEAK_IPL_IMAGE_HANDLE *outputImageHandle)
Definition: peak_ipl_dynamic_loader.h:1536
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:97
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:2121
PEAK_IPL_GAMMA_CORRECTOR_HANDLE
struct PEAK_IPL_GAMMA_CORRECTOR * PEAK_IPL_GAMMA_CORRECTOR_HANDLE
Definition: peak_ipl_backend.h:234
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:2017
peak::ipl::dynamic::import_function
void * import_function(void *module, const char *proc_name)
Definition: peak_ipl_dynamic_loader.h:435
peak
The "peak::ipl" namespace contains the whole image processing library.
Definition: peak_ipl_binning.hpp:16
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:155
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:104
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:2381
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:101
peak::ipl::dynamic::DynamicLoader::PEAK_IPL_AdaptiveHotpixelCorrector_GetHotpixels
static PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_GetHotpixels(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_POINT_2D *hotpixels, size_t *hotpixelsSize)
Definition: peak_ipl_dynamic_loader.h:1523
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:54
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, PEAK_IPL_IMAGE_TRANSFORMER_ROTATION_ANGLE_t rotationAngle)
Definition: peak_ipl_dynamic_loader.h:2485
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:1289
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:1341
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, const size_t inputWidth, const size_t inputHeight, const PEAK_IPL_PIXEL_FORMAT pixelFormat)
Definition: peak_ipl_dynamic_loader.h:75
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:62
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:114
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:39
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:85
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:2238
PEAK_IPL_PIXEL_LINE_HANDLE
struct PEAK_IPL_PIXEL_LINE * PEAK_IPL_PIXEL_LINE_HANDLE
Definition: peak_ipl_backend.h:246
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:99
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:121
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:150
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:2394
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:100
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:2082
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:70
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:61
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:113
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:1497
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:1419
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:1432
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:74
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:109
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:2342
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:129
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:2446
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:2251
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:2043
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:71
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:111
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, PEAK_IPL_IMAGE_TRANSFORMER_ROTATION_ANGLE_t rotationAngle)
Definition: peak_ipl_dynamic_loader.h:130
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:2095
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:2615
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:2004
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:1562
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:132
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:152
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:2511
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:1458
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:142
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 PEAK_IPL_POINT_2D *hotpixels, size_t hotpixelsSize, PEAK_IPL_IMAGE_HANDLE *outputImageHandle)
Definition: peak_ipl_dynamic_loader.h:58
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:2498
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:89
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:2524
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:76
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:1510
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, const size_t inputWidth, const size_t inputHeight, const PEAK_IPL_PIXEL_FORMAT pixelFormat)
Definition: peak_ipl_dynamic_loader.h:1757
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:115
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:66
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:125
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:1809
PEAK_IPL_IMAGE_CONVERTER_HANDLE
struct PEAK_IPL_IMAGE_CONVERTER * PEAK_IPL_IMAGE_CONVERTER_HANDLE
Definition: peak_ipl_backend.h:210
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:68
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:82
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:2875
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:52
PEAK_IPL_IMAGE_HANDLE
struct PEAK_IPL_IMAGE * PEAK_IPL_IMAGE_HANDLE
Definition: peak_ipl_backend.h:238
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:1679
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:1393
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:145
PEAK_IPL_IMAGE_TRANSFORMER_HANDLE
struct PEAK_IPL_IMAGE_transformer * PEAK_IPL_IMAGE_TRANSFORMER_HANDLE
Definition: peak_ipl_backend.h:214
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:126
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:2225
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:2173
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:1471
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:88
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:1796
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:1705
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:143
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:1887
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:95
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:134
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:53
peak::ipl::dynamic::DynamicLoader
Definition: peak_ipl_dynamic_loader.h:164
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:47
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:107
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:1835
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:2537
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:43
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:1601
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:2563
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:1952
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:2277
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:81
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:1978
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:149
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:1406
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:1991
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:98
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:72
PEAK_IPL_GAIN_HANDLE
struct PEAK_IPL_GAIN * PEAK_IPL_GAIN_HANDLE
Definition: peak_ipl_backend.h:230
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:1380
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:86
peak_ipl_backend.h
PEAK_IPL_IMAGE_TRANSFORMER_ROTATION_ANGLE_t
PEAK_IPL_IMAGE_TRANSFORMER_ROTATION_ANGLE_t
Definition: peak_ipl_backend.h:185
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:60
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:2862
PEAK_IPL_HOTPIXELCORRECTION_SENSITIVITY
int32_t PEAK_IPL_HOTPIXELCORRECTION_SENSITIVITY
Definition: peak_ipl_backend.h:182
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:67
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:2355
PEAK_IPL_BOOL8
int8_t PEAK_IPL_BOOL8
Definition: peak_ipl_backend.h:25
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:1666
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:2056
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:1861
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:1614
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:1328
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:1549
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:138
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:147
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:2732
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:1484
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, PEAK_IPL_IMAGE_TRANSFORMER_ROTATION_ANGLE_t rotationAngle)
Definition: peak_ipl_dynamic_loader.h:2472
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:1848
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:2134
PEAK_IPL_CONVERSION_MODE
int32_t PEAK_IPL_CONVERSION_MODE
Definition: peak_ipl_backend.h:50
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:2459
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:153
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:120
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, PEAK_IPL_IMAGE_TRANSFORMER_ROTATION_ANGLE_t rotationAngle)
Definition: peak_ipl_dynamic_loader.h:131
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:140
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:161
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:1367
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:2589
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:151
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:42
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:1770
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:91
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:154
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:117
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:48
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:1302
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:80
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:2264
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:2823
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:1965
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:45
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:112
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:1939
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:1731
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:122
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:1874
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:90
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:56
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:2784
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:119
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:1575
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:78
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:2030
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:1744
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:137
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:1900
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:2771
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:2368
peak::ipl::dynamic::dyn_PEAK_IPL_AdaptiveHotpixelCorrector_GetHotpixels
PEAK_IPL_C_API(* dyn_PEAK_IPL_AdaptiveHotpixelCorrector_GetHotpixels)(PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_POINT_2D *hotpixels, size_t *hotpixelsSize)
Definition: peak_ipl_dynamic_loader.h:57
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:2836
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:2706
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:105
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:103
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:2186
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:1354
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:2849
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:84
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:83
PEAK_IPL_C_API
#define PEAK_IPL_C_API
Definition: peak_ipl_backend.h:249
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:2303
PEAK_IPL_POINT_2D
Definition: peak_ipl_backend.h:201
PEAK_IPL_PIXEL_FORMAT
int32_t PEAK_IPL_PIXEL_FORMAT
Definition: peak_ipl_backend.h:153
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:2433
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:2810
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:124
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:73
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:2316
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:69
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: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:116
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:49
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:102
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:139
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:46
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:51
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:157
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:59
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:1640
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:63
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:2329
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:2797
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:2212
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:1913
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:1653
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:94
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:65
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:123
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:2407
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:1588
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:1783
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:2576
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:158
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:2420
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:2550
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:148
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:2693
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:160
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:141
PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE
struct PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR * PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE
Definition: peak_ipl_backend.h:218
PEAK_IPL_BINNING_HANDLE
struct PEAK_IPL_BINNING * PEAK_IPL_BINNING_HANDLE
Definition: peak_ipl_backend.h:222
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:2069
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:2628
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:127