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