// Created by Microsoft (R) C/C++ Compiler Version 14.16.27051.0 (656e3eff).
//
// d:\code\logistics\smokeboxidentification\tpvs17\smokeboxidentification\x64\release\lpvImgProc.tli
//
// Wrapper implementations for Win32 type library 29c8366a-f227-4cc4-bdbb-b32397056cf5
// compiler-generated file created 01/03/24 at 16:59:27 - DO NOT EDIT!

#pragma once

//
// interface ILImageThreshold wrapper method implementations
//

inline HRESULT ILImageThreshold::SetThreshold ( int lb, int ub ) {
    HRESULT _hr = raw_SetThreshold(lb, ub);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImageThreshold::SetThresholdAdaptGlobal ( int lbBias, int ubBias ) {
    HRESULT _hr = raw_SetThresholdAdaptGlobal(lbBias, ubBias);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImageThreshold::SetThresholdAdaptLocal ( int blockWidth, int blockHeight, int lbBias, int ubBias ) {
    HRESULT _hr = raw_SetThresholdAdaptLocal(blockWidth, blockHeight, lbBias, ubBias);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImageThreshold::Binarize ( struct ILImage * img, struct ILImage * result ) {
    HRESULT _hr = raw_Binarize(img, result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImageThreshold::ThresholdDistance ( struct ILImage * img, struct ILImage * result ) {
    HRESULT _hr = raw_ThresholdDistance(img, result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImageThreshold::Clip ( struct ILImage * img, struct ILImage * result ) {
    HRESULT _hr = raw_Clip(img, result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImageThreshold::Stretch ( struct ILImage * img, struct ILImage * result ) {
    HRESULT _hr = raw_Stretch(img, result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline enum LPVThresholdType ILImageThreshold::GetThresholdType ( ) {
    enum LPVThresholdType _result;
    HRESULT _hr = get_ThresholdType(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline int ILImageThreshold::GetThresholdLB ( ) {
    int _result = 0;
    HRESULT _hr = get_ThresholdLB(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline int ILImageThreshold::GetThresholdUB ( ) {
    int _result = 0;
    HRESULT _hr = get_ThresholdUB(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline int ILImageThreshold::GetThresholdLBBias ( ) {
    int _result = 0;
    HRESULT _hr = get_ThresholdLBBias(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline int ILImageThreshold::GetThresholdUBBias ( ) {
    int _result = 0;
    HRESULT _hr = get_ThresholdUBBias(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline int ILImageThreshold::GetLocalBlockWidth ( ) {
    int _result = 0;
    HRESULT _hr = get_LocalBlockWidth(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline int ILImageThreshold::GetLocalBlockHeight ( ) {
    int _result = 0;
    HRESULT _hr = get_LocalBlockHeight(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

//
// interface ILImageFilter wrapper method implementations
//

inline HRESULT ILImageFilter::SetKernelSize ( int kWidth, int kHeight ) {
    HRESULT _hr = raw_SetKernelSize(kWidth, kHeight);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImageFilter::SetKernelSigma ( double kSigma, double kGain ) {
    HRESULT _hr = raw_SetKernelSigma(kSigma, kGain);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImageFilter::Equalize ( struct ILImage * img, struct ILImage * result ) {
    HRESULT _hr = raw_Equalize(img, result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImageFilter::HighPass ( struct ILImage * img, struct ILImage * result ) {
    HRESULT _hr = raw_HighPass(img, result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImageFilter::Gaussian ( struct ILImage * img, struct ILImage * result ) {
    HRESULT _hr = raw_Gaussian(img, result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImageFilter::LocalMedian ( struct ILImage * img, struct ILImage * result ) {
    HRESULT _hr = raw_LocalMedian(img, result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImageFilter::LocalMedianNorm ( struct ILImage * img, struct ILImage * result ) {
    HRESULT _hr = raw_LocalMedianNorm(img, result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImageFilter::OpticalDensity ( struct ILImage * img, struct ILImage * result ) {
    HRESULT _hr = raw_OpticalDensity(img, result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImageFilter::MeanFilter ( struct ILImage * img, struct ILImage * result ) {
    HRESULT _hr = raw_MeanFilter(img, result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline int ILImageFilter::GetKernelWidth ( ) {
    int _result = 0;
    HRESULT _hr = get_KernelWidth(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline int ILImageFilter::GetKernelHeight ( ) {
    int _result = 0;
    HRESULT _hr = get_KernelHeight(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline HRESULT ILImageFilter::Sharpen ( struct ILImage * img, struct ILImage * result ) {
    HRESULT _hr = raw_Sharpen(img, result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline double ILImageFilter::GetKernelSigma ( ) {
    double _result = 0;
    HRESULT _hr = get_KernelSigma(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline double ILImageFilter::GetKernelGain ( ) {
    double _result = 0;
    HRESULT _hr = get_KernelGain(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

//
// interface ILImageMorph wrapper method implementations
//

inline HRESULT ILImageMorph::SetMorphShape ( enum LPVMorphShape shape, int kWidth, int kHeight ) {
    HRESULT _hr = raw_SetMorphShape(shape, kWidth, kHeight);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImageMorph::BottomHat ( struct ILImage * img, struct ILImage * result ) {
    HRESULT _hr = raw_BottomHat(img, result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImageMorph::TopHat ( struct ILImage * img, struct ILImage * result ) {
    HRESULT _hr = raw_TopHat(img, result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImageMorph::TopBottomHat ( struct ILImage * img, struct ILImage * result ) {
    HRESULT _hr = raw_TopBottomHat(img, result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImageMorph::Close ( struct ILImage * img, struct ILImage * result ) {
    HRESULT _hr = raw_Close(img, result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImageMorph::Open ( struct ILImage * img, struct ILImage * result ) {
    HRESULT _hr = raw_Open(img, result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImageMorph::Dilate ( struct ILImage * img, struct ILImage * result ) {
    HRESULT _hr = raw_Dilate(img, result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImageMorph::Erode ( struct ILImage * img, struct ILImage * result ) {
    HRESULT _hr = raw_Erode(img, result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImageMorph::Gradient ( struct ILImage * img, struct ILImage * result ) {
    HRESULT _hr = raw_Gradient(img, result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline enum LPVMorphShape ILImageMorph::GetMorphShape ( ) {
    enum LPVMorphShape _result;
    HRESULT _hr = get_MorphShape(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline int ILImageMorph::GetMorphWidth ( ) {
    int _result = 0;
    HRESULT _hr = get_MorphWidth(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline int ILImageMorph::GetMorphHeight ( ) {
    int _result = 0;
    HRESULT _hr = get_MorphHeight(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

//
// interface ILEdgeFilter wrapper method implementations
//

inline HRESULT ILEdgeFilter::SetEdgeKernel ( enum LPVEdgeKernel kType, int kWidth, int kHeight ) {
    HRESULT _hr = raw_SetEdgeKernel(kType, kWidth, kHeight);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILEdgeFilter::SetEdgePolarity ( enum LPVPolarity xPolarity, enum LPVPolarity yPolarity ) {
    HRESULT _hr = raw_SetEdgePolarity(xPolarity, yPolarity);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILEdgeFilter::GradientH ( struct ILImage * img, struct ILImage * result ) {
    HRESULT _hr = raw_GradientH(img, result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILEdgeFilter::GradientV ( struct ILImage * img, struct ILImage * result ) {
    HRESULT _hr = raw_GradientV(img, result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILEdgeFilter::GradientFull ( struct ILImage * img, struct ILImage * result ) {
    HRESULT _hr = raw_GradientFull(img, result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline enum LPVEdgeKernel ILEdgeFilter::GetKernelType ( ) {
    enum LPVEdgeKernel _result;
    HRESULT _hr = get_KernelType(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline int ILEdgeFilter::GetKernelWidth ( ) {
    int _result = 0;
    HRESULT _hr = get_KernelWidth(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline int ILEdgeFilter::GetKernelHeight ( ) {
    int _result = 0;
    HRESULT _hr = get_KernelHeight(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline enum LPVPolarity ILEdgeFilter::GetEdgePolarityX ( ) {
    enum LPVPolarity _result;
    HRESULT _hr = get_EdgePolarityX(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline enum LPVPolarity ILEdgeFilter::GetEdgePolarityY ( ) {
    enum LPVPolarity _result;
    HRESULT _hr = get_EdgePolarityY(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

//
// interface ILImageArithm wrapper method implementations
//

inline HRESULT ILImageArithm::Invert ( struct ILImage * img, struct ILImage * result ) {
    HRESULT _hr = raw_Invert(img, result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImageArithm::GainOffset ( struct ILImage * img, struct ILImage * result, double gain, double offset ) {
    HRESULT _hr = raw_GainOffset(img, result, gain, offset);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImageArithm::Add ( struct ILImage * img1, struct ILImage * img2, struct ILImage * result ) {
    HRESULT _hr = raw_Add(img1, img2, result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImageArithm::AddWeighted ( struct ILImage * img1, struct ILImage * img2, double alpha, double beta, struct ILImage * result ) {
    HRESULT _hr = raw_AddWeighted(img1, img2, alpha, beta, result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImageArithm::Sub ( struct ILImage * img1, struct ILImage * img2, struct ILImage * result ) {
    HRESULT _hr = raw_Sub(img1, img2, result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImageArithm::Multiply ( struct ILImage * img1, struct ILImage * img2, struct ILImage * result ) {
    HRESULT _hr = raw_Multiply(img1, img2, result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImageArithm::Divide ( struct ILImage * img1, struct ILImage * img2, struct ILImage * result ) {
    HRESULT _hr = raw_Divide(img1, img2, result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImageArithm::Diff ( struct ILImage * img1, struct ILImage * img2, struct ILImage * result ) {
    HRESULT _hr = raw_Diff(img1, img2, result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImageArithm::Min ( struct ILImage * img1, struct ILImage * img2, struct ILImage * result ) {
    HRESULT _hr = raw_Min(img1, img2, result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImageArithm::Max ( struct ILImage * img1, struct ILImage * img2, struct ILImage * result ) {
    HRESULT _hr = raw_Max(img1, img2, result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImageArithm::Pow ( struct ILImage * img, double power, struct ILImage * result ) {
    HRESULT _hr = raw_Pow(img, power, result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImageArithm::Log ( struct ILImage * img, double base, struct ILImage * result ) {
    HRESULT _hr = raw_Log(img, base, result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImageArithm::Flip ( struct ILImage * img, enum LPVFlipType flipType, struct ILImage * result ) {
    HRESULT _hr = raw_Flip(img, flipType, result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImageArithm::Rotate ( struct ILImage * img, double angle, enum LPVInterpolationMethod interMethod, struct ILImage * result ) {
    HRESULT _hr = raw_Rotate(img, angle, interMethod, result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImageArithm::Resize ( struct ILImage * img, double zoomX, double zoomY, enum LPVInterpolationMethod interMethod, struct ILImage * result ) {
    HRESULT _hr = raw_Resize(img, zoomX, zoomY, interMethod, result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImageArithm::ResizeTo ( struct ILImage * img, int w, int h, enum LPVInterpolationMethod interMethod, struct ILImage * result ) {
    HRESULT _hr = raw_ResizeTo(img, w, h, interMethod, result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImageArithm::ScaleRotate ( struct ILImage * img, double angle, double zoomX, double zoomY, double pivotImgX, double pivotImgY, double pivotResultX, double pivotResultY, enum LPVInterpolationMethod interMethod, struct ILImage * result ) {
    HRESULT _hr = raw_ScaleRotate(img, angle, zoomX, zoomY, pivotImgX, pivotImgY, pivotResultX, pivotResultY, interMethod, result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImageArithm::Transform ( struct ILImage * img, struct ILTransform * tf, enum LPVInterpolationMethod interMethod, struct ILImage * result ) {
    HRESULT _hr = raw_Transform(img, tf, interMethod, result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImageArithm::Blend ( struct ILImageList * imgList, enum LPVAggregation aggType, struct ILImage * result ) {
    HRESULT _hr = raw_Blend(imgList, aggType, result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline SAFEARRAY * ILImageArithm::ProjectX ( struct ILImage * img, enum LPVAggregation aggType ) {
    SAFEARRAY * _result = 0;
    HRESULT _hr = raw_ProjectX(img, aggType, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline SAFEARRAY * ILImageArithm::ProjectY ( struct ILImage * img, enum LPVAggregation aggType ) {
    SAFEARRAY * _result = 0;
    HRESULT _hr = raw_ProjectY(img, aggType, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline double ILImageArithm::GetResultGain ( ) {
    double _result = 0;
    HRESULT _hr = get_ResultGain(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILImageArithm::PutResultGain ( double val ) {
    HRESULT _hr = put_ResultGain(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline double ILImageArithm::GetResultOffset ( ) {
    double _result = 0;
    HRESULT _hr = get_ResultOffset(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILImageArithm::PutResultOffset ( double val ) {
    HRESULT _hr = put_ResultOffset(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline HRESULT ILImageArithm::TileX ( struct ILImageList * imgList, int columnCount, VARIANT_BOOL compactMode, struct ILImage * result ) {
    HRESULT _hr = raw_TileX(imgList, columnCount, compactMode, result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImageArithm::TileY ( struct ILImageList * imgList, int rowCount, VARIANT_BOOL compactMode, struct ILImage * result ) {
    HRESULT _hr = raw_TileY(imgList, rowCount, compactMode, result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline struct LColor ILImageArithm::GetBGColor ( ) {
    struct LColor _result;
    HRESULT _hr = get_BGColor(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILImageArithm::PutBGColor ( struct LColor val ) {
    HRESULT _hr = put_BGColor(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

//
// interface ILHistogram wrapper method implementations
//

inline HRESULT ILHistogram::Reset ( ) {
    HRESULT _hr = raw_Reset();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILHistogram::Build ( struct ILImage * img, struct ILRegion * region, int binCount, int lowerBound, int upperBound ) {
    HRESULT _hr = raw_Build(img, region, binCount, lowerBound, upperBound);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline double ILHistogram::Item ( int index ) {
    double _result = 0;
    HRESULT _hr = raw_Item(index, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline HRESULT ILHistogram::MinMax ( int * minIdx, double * minValue, int * maxIdx, double * maxValue ) {
    HRESULT _hr = raw_MinMax(minIdx, minValue, maxIdx, maxValue);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILHistogram::MeanStdDev ( double * meanValue, double * stdDevValue ) {
    HRESULT _hr = raw_MeanStdDev(meanValue, stdDevValue);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILHistogram::Draw ( void * hdc, enum LPVChartDrawFlags drawFlags, int xGridStep, int yGridStep ) {
    HRESULT _hr = raw_Draw(hdc, drawFlags, xGridStep, yGridStep);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILHistogram::BuildFromDataVec ( SAFEARRAY * dataVec, int binCount, double lowerBound, double upperBound ) {
    HRESULT _hr = raw_BuildFromDataVec(dataVec, binCount, lowerBound, upperBound);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

//
// interface ILImageStats wrapper method implementations
//

inline HRESULT ILImageStats::Min ( struct ILImage * img, struct ILRegion * region, int * value, int * posX, int * posY ) {
    HRESULT _hr = raw_Min(img, region, value, posX, posY);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImageStats::Max ( struct ILImage * img, struct ILRegion * region, int * value, int * posX, int * posY ) {
    HRESULT _hr = raw_Max(img, region, value, posX, posY);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImageStats::MeanStdDev ( struct ILImage * img, struct ILRegion * region, double * meanValue, double * stdDevValue ) {
    HRESULT _hr = raw_MeanStdDev(img, region, meanValue, stdDevValue);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImageStats::CountPixel ( struct ILImage * img, struct ILRegion * region, int lb, int ub, int * belowCount, int * betweenCount, int * aboveCount ) {
    HRESULT _hr = raw_CountPixel(img, region, lb, ub, belowCount, betweenCount, aboveCount);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILImageStats::CountPixelColor ( struct ILImage * img, struct ILRegion * region, struct LColor lb, struct LColor ub, int * betweenCount, int * outsideCount ) {
    HRESULT _hr = raw_CountPixelColor(img, region, lb, ub, betweenCount, outsideCount);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline double ILImageStats::Sharpness ( struct ILImage * img, struct ILRegion * region ) {
    double _result = 0;
    HRESULT _hr = raw_Sharpness(img, region, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

//
// interface ILHDR wrapper method implementations
//

inline HRESULT ILHDR::Reset ( ) {
    HRESULT _hr = raw_Reset();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline enum LPVErrorCode ILHDR::BuildCRF ( struct ILImageList * imgList, SAFEARRAY * exposureTimes ) {
    enum LPVErrorCode _result;
    HRESULT _hr = raw_BuildCRF(imgList, exposureTimes, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline HRESULT ILHDR::ToneMapping ( struct ILImageList * imgList, struct ILImage * result, double gamma, double contrastEnhance, double saturationEnhance ) {
    HRESULT _hr = raw_ToneMapping(imgList, result, gamma, contrastEnhance, saturationEnhance);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILHDR::ExposureFusion ( struct ILImageList * imgList, struct ILImage * result, double contrastWeight, double saturationWeight, double exposureWeight ) {
    HRESULT _hr = raw_ExposureFusion(imgList, result, contrastWeight, saturationWeight, exposureWeight);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

//
// interface ILImageConvert wrapper method implementations
//

inline HRESULT ILImageConvert::BGRToGray ( struct ILImage * bgrImg, struct ILImage * grayImg ) {
    HRESULT _hr = raw_BGRToGray(bgrImg, grayImg);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline int ILImageConvert::BGRToGrayColor ( struct LColor bgrColor ) {
    int _result = 0;
    HRESULT _hr = raw_BGRToGrayColor(bgrColor, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline HRESULT ILImageConvert::GrayToBGR ( struct ILImage * grayImg, struct ILImage * bgrImg ) {
    HRESULT _hr = raw_GrayToBGR(grayImg, bgrImg);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline struct LColor ILImageConvert::GrayToBGRColor ( int grayColor ) {
    struct LColor _result;
    HRESULT _hr = raw_GrayToBGRColor(grayColor, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline HRESULT ILImageConvert::Convert ( enum LPVColorSpace fromColorSpace, enum LPVColorSpace toColorSpace, struct ILImage * srcColorImg, struct ILImage * dstColorImg ) {
    HRESULT _hr = raw_Convert(fromColorSpace, toColorSpace, srcColorImg, dstColorImg);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline struct LColor ILImageConvert::ConvertColor ( enum LPVColorSpace fromColorSpace, enum LPVColorSpace toColorSpace, struct LColor srcColor ) {
    struct LColor _result;
    HRESULT _hr = raw_ConvertColor(fromColorSpace, toColorSpace, srcColor, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline HRESULT ILImageConvert::BGRMix ( struct ILImage * bgrImg, double w0, double w1, double w2, struct ILImage * grayImg ) {
    HRESULT _hr = raw_BGRMix(bgrImg, w0, w1, w2, grayImg);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

//
// interface ILBGSubtract wrapper method implementations
//

inline HRESULT ILBGSubtract::Reset ( ) {
    HRESULT _hr = raw_Reset();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline int ILBGSubtract::GetHistoryMaxCount ( ) {
    int _result = 0;
    HRESULT _hr = get_HistoryMaxCount(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILBGSubtract::PutHistoryMaxCount ( int val ) {
    HRESULT _hr = put_HistoryMaxCount(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline double ILBGSubtract::GetVarianceThreshold ( ) {
    double _result = 0;
    HRESULT _hr = get_VarianceThreshold(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILBGSubtract::PutVarianceThreshold ( double val ) {
    HRESULT _hr = put_VarianceThreshold(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline double ILBGSubtract::GetGenerateThreshold ( ) {
    double _result = 0;
    HRESULT _hr = get_GenerateThreshold(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILBGSubtract::PutGenerateThreshold ( double val ) {
    HRESULT _hr = put_GenerateThreshold(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline double ILBGSubtract::GetLearningRate ( ) {
    double _result = 0;
    HRESULT _hr = get_LearningRate(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILBGSubtract::PutLearningRate ( double val ) {
    HRESULT _hr = put_LearningRate(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline enum LPVErrorCode ILBGSubtract::Apply ( struct ILImage * img, struct ILImage * fgMask, VARIANT_BOOL doUpdateBGModel ) {
    enum LPVErrorCode _result;
    HRESULT _hr = raw_Apply(img, fgMask, doUpdateBGModel, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline enum LPVErrorCode ILBGSubtract::UpdateBGModel ( struct ILImage * img ) {
    enum LPVErrorCode _result;
    HRESULT _hr = raw_UpdateBGModel(img, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}