// Created by Microsoft (R) C/C++ Compiler Version 14.16.27050.0 (6a538ac1).
//
// d:\git\hzleaper\smokebox\tpvs17\smokeboxidentification\x64\release\lpvCalib.tli
//
// Wrapper implementations for type library faa32948-bf4e-4482-9216-70412f34bb66
// compiler-generated file created 02/21/24 at 11:50:39 - DO NOT EDIT!

#pragma once

//
// interface ILCalibPointPairs wrapper method implementations
//

inline int ILCalibPointPairs::Count ( ) {
    int _result = 0;
    HRESULT _hr = raw_Count(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline ILPointPtr ILCalibPointPairs::GetImagePoint ( int index ) {
    struct ILPoint * _result = 0;
    HRESULT _hr = raw_GetImagePoint(index, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPointPtr(_result, false);
}

inline ILPointPtr ILCalibPointPairs::GetWorldPoint ( int index ) {
    struct ILPoint * _result = 0;
    HRESULT _hr = raw_GetWorldPoint(index, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPointPtr(_result, false);
}

inline HRESULT ILCalibPointPairs::AddPointPair ( double imagePointX, double imagePointY, double worldPointX, double worldPointY ) {
    HRESULT _hr = raw_AddPointPair(imagePointX, imagePointY, worldPointX, worldPointY);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILCalibPointPairs::Draw ( void * hdc, int index, double zoomX, double zoomY, double panX, double panY ) {
    HRESULT _hr = raw_Draw(hdc, index, zoomX, zoomY, panX, panY);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILCalibPointPairs::DrawAll ( void * hdc, double zoomX, double zoomY, double panX, double panY ) {
    HRESULT _hr = raw_DrawAll(hdc, zoomX, zoomY, panX, panY);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline ILPointsPtr ILCalibPointPairs::GetImagePoints ( ) {
    struct ILPoints * _result = 0;
    HRESULT _hr = raw_GetImagePoints(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPointsPtr(_result, false);
}

inline ILPointsPtr ILCalibPointPairs::GetWorldPoints ( ) {
    struct ILPoints * _result = 0;
    HRESULT _hr = raw_GetWorldPoints(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPointsPtr(_result, false);
}

//
// interface ILCalib wrapper method implementations
//

inline VARIANT_BOOL ILCalib::IsCalibrated ( ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = raw_IsCalibrated(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline enum LPVErrorCode ILCalib::Calibrate ( ) {
    enum LPVErrorCode _result;
    HRESULT _hr = raw_Calibrate(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline HRESULT ILCalib::ImageToWorld ( double imagePointX, double imagePointY, double * worldPointX, double * worldPointY ) {
    HRESULT _hr = raw_ImageToWorld(imagePointX, imagePointY, worldPointX, worldPointY);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILCalib::WorldToImage ( double worldPointX, double worldPointY, double * imagePointX, double * imagePointY ) {
    HRESULT _hr = raw_WorldToImage(worldPointX, worldPointY, imagePointX, imagePointY);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline double ILCalib::GetCalibError ( ) {
    double _result = 0;
    HRESULT _hr = get_CalibError(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline enum LPVFixImageMode ILCalib::GetFixImageMode ( ) {
    enum LPVFixImageMode _result;
    HRESULT _hr = get_FixImageMode(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILCalib::PutFixImageMode ( enum LPVFixImageMode val ) {
    HRESULT _hr = put_FixImageMode(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline double ILCalib::GetFixImageScale ( ) {
    double _result = 0;
    HRESULT _hr = get_FixImageScale(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILCalib::PutFixImageScale ( double val ) {
    HRESULT _hr = put_FixImageScale(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline double ILCalib::GetFixImageOffsetX ( ) {
    double _result = 0;
    HRESULT _hr = get_FixImageOffsetX(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILCalib::PutFixImageOffsetX ( double val ) {
    HRESULT _hr = put_FixImageOffsetX(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline double ILCalib::GetFixImageOffsetY ( ) {
    double _result = 0;
    HRESULT _hr = get_FixImageOffsetY(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILCalib::PutFixImageOffsetY ( double val ) {
    HRESULT _hr = put_FixImageOffsetY(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline enum LPVErrorCode ILCalib::FixImage ( struct ILImage * image, struct ILImage * fixedImage ) {
    enum LPVErrorCode _result;
    HRESULT _hr = raw_FixImage(image, fixedImage, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline HRESULT ILCalib::SetPostTransform ( double offsetX, double offsetY, double deltaAngle ) {
    HRESULT _hr = raw_SetPostTransform(offsetX, offsetY, deltaAngle);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILCalib::SetPostTransformMatrix ( int cols, int rows, SAFEARRAY * data ) {
    HRESULT _hr = raw_SetPostTransformMatrix(cols, rows, data);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline enum LPVErrorCode ILCalib::AddPoint ( double imagePointX, double imagePointY, double worldPointX, double worldPointY ) {
    enum LPVErrorCode _result;
    HRESULT _hr = raw_AddPoint(imagePointX, imagePointY, worldPointX, worldPointY, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline enum LPVErrorCode ILCalib::AddPoints ( struct ILCalibPointPairs * pointPairs ) {
    enum LPVErrorCode _result;
    HRESULT _hr = raw_AddPoints(pointPairs, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline HRESULT ILCalib::SetImageSize ( int w, int h ) {
    HRESULT _hr = raw_SetImageSize(w, h);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILCalib::SetPostTransformMatrix23 ( struct LMatrix23 * data ) {
    HRESULT _hr = raw_SetPostTransformMatrix23(data);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILCalib::SetPostTransformMatrix33 ( struct LMatrix33 * data ) {
    HRESULT _hr = raw_SetPostTransformMatrix33(data);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline enum LPVErrorCode ILCalib::GenPostTransformMatrix ( struct ILCalibPointPairs * pointPairs ) {
    enum LPVErrorCode _result;
    HRESULT _hr = raw_GenPostTransformMatrix(pointPairs, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline enum LPVCalibModel ILCalib::GetModel ( ) {
    enum LPVCalibModel _result;
    HRESULT _hr = get_Model(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline VARIANT_BOOL ILCalib::GetUseCache ( ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = get_UseCache(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILCalib::PutUseCache ( VARIANT_BOOL val ) {
    HRESULT _hr = put_UseCache(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline enum LPVInterpolationMethod ILCalib::GetInterpolationMethod ( ) {
    enum LPVInterpolationMethod _result;
    HRESULT _hr = get_InterpolationMethod(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILCalib::PutInterpolationMethod ( enum LPVInterpolationMethod val ) {
    HRESULT _hr = put_InterpolationMethod(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

//
// interface ILCalibNPoints wrapper method implementations
//

inline enum LPVTransformType ILCalibNPoints::GetTransformType ( ) {
    enum LPVTransformType _result;
    HRESULT _hr = get_TransformType(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILCalibNPoints::PutTransformType ( enum LPVTransformType val ) {
    HRESULT _hr = put_TransformType(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

//
// interface ILCalibPinHole wrapper method implementations
//

inline enum LPVDistortionModel ILCalibPinHole::GetDistortionModel ( ) {
    enum LPVDistortionModel _result;
    HRESULT _hr = get_DistortionModel(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILCalibPinHole::PutDistortionModel ( enum LPVDistortionModel val ) {
    HRESULT _hr = put_DistortionModel(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline HRESULT ILCalibPinHole::SetCameraProps ( double cellSize, double focusLength, double viewDistance ) {
    HRESULT _hr = raw_SetCameraProps(cellSize, focusLength, viewDistance);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline enum LPVErrorCode ILCalibPinHole::AddMVPoints ( struct ILCalibPointPairs * pointPairs ) {
    enum LPVErrorCode _result;
    HRESULT _hr = raw_AddMVPoints(pointPairs, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

//
// interface ILCalibFFD wrapper method implementations
//

inline HRESULT ILCalibFFD::SetFFDGrid ( int cols, int rows ) {
    HRESULT _hr = raw_SetFFDGrid(cols, rows);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

//
// interface ILCalibCustom wrapper method implementations
//

inline double ILCalibCustom::GetScaleX ( ) {
    double _result = 0;
    HRESULT _hr = get_ScaleX(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILCalibCustom::PutScaleX ( double val ) {
    HRESULT _hr = put_ScaleX(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline double ILCalibCustom::GetScaleY ( ) {
    double _result = 0;
    HRESULT _hr = get_ScaleY(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILCalibCustom::PutScaleY ( double val ) {
    HRESULT _hr = put_ScaleY(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline double ILCalibCustom::GetTheta ( ) {
    double _result = 0;
    HRESULT _hr = get_Theta(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILCalibCustom::PutTheta ( double val ) {
    HRESULT _hr = put_Theta(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline enum LPVDirection ILCalibCustom::GetAxisDirX ( ) {
    enum LPVDirection _result;
    HRESULT _hr = get_AxisDirX(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILCalibCustom::PutAxisDirX ( enum LPVDirection val ) {
    HRESULT _hr = put_AxisDirX(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline enum LPVDirection ILCalibCustom::GetAxisDirY ( ) {
    enum LPVDirection _result;
    HRESULT _hr = get_AxisDirY(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILCalibCustom::PutAxisDirY ( enum LPVDirection val ) {
    HRESULT _hr = put_AxisDirY(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline HRESULT ILCalibCustom::MoveOriginTo ( double x, double y ) {
    HRESULT _hr = raw_MoveOriginTo(x, y);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

//
// interface ILCalibBoard wrapper method implementations
//

inline enum LPVCalibBoardType ILCalibBoard::GetCalibBoardType ( ) {
    enum LPVCalibBoardType _result;
    HRESULT _hr = get_CalibBoardType(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILCalibBoard::PutCalibBoardType ( enum LPVCalibBoardType val ) {
    HRESULT _hr = put_CalibBoardType(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline int ILCalibBoard::GetGridWidth ( ) {
    int _result = 0;
    HRESULT _hr = get_GridWidth(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILCalibBoard::PutGridWidth ( int val ) {
    HRESULT _hr = put_GridWidth(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline int ILCalibBoard::GetGridHeight ( ) {
    int _result = 0;
    HRESULT _hr = get_GridHeight(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILCalibBoard::PutGridHeight ( int val ) {
    HRESULT _hr = put_GridHeight(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline double ILCalibBoard::GetSquareSize ( ) {
    double _result = 0;
    HRESULT _hr = get_SquareSize(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILCalibBoard::PutSquareSize ( double val ) {
    HRESULT _hr = put_SquareSize(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline double ILCalibBoard::GetMarkerSize ( ) {
    double _result = 0;
    HRESULT _hr = get_MarkerSize(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILCalibBoard::PutMarkerSize ( double val ) {
    HRESULT _hr = put_MarkerSize(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline double ILCalibBoard::GetBoardThickness ( ) {
    double _result = 0;
    HRESULT _hr = get_BoardThickness(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILCalibBoard::PutBoardThickness ( double val ) {
    HRESULT _hr = put_BoardThickness(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline VARIANT_BOOL ILCalibBoard::GetAutoRemoveBad ( ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = get_AutoRemoveBad(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILCalibBoard::PutAutoRemoveBad ( VARIANT_BOOL val ) {
    HRESULT _hr = put_AutoRemoveBad(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline VARIANT_BOOL ILCalibBoard::GetUseFittingMethod ( ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = get_UseFittingMethod(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILCalibBoard::PutUseFittingMethod ( VARIANT_BOOL val ) {
    HRESULT _hr = put_UseFittingMethod(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline enum LPVErrorCode ILCalibBoard::Detect ( struct ILImage * img, struct ILCalibPointPairs * * pointPairs ) {
    enum LPVErrorCode _result;
    HRESULT _hr = raw_Detect(img, pointPairs, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline enum LPVErrorCode ILCalibBoard::DetectInRegion ( struct ILImage * img, struct ILRegion * region, struct ILCalibPointPairs * * pointPairs ) {
    enum LPVErrorCode _result;
    HRESULT _hr = raw_DetectInRegion(img, region, pointPairs, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline VARIANT_BOOL ILCalibBoard::GetGuessPartialBlock ( ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = get_GuessPartialBlock(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILCalibBoard::PutGuessPartialBlock ( VARIANT_BOOL val ) {
    HRESULT _hr = put_GuessPartialBlock(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline VARIANT_BOOL ILCalibBoard::GetInvertBlock ( ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = get_InvertBlock(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILCalibBoard::PutInvertBlock ( VARIANT_BOOL val ) {
    HRESULT _hr = put_InvertBlock(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline double ILCalibBoard::GetStartX ( ) {
    double _result = 0;
    HRESULT _hr = get_StartX(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILCalibBoard::PutStartX ( double val ) {
    HRESULT _hr = put_StartX(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline double ILCalibBoard::GetStartY ( ) {
    double _result = 0;
    HRESULT _hr = get_StartY(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILCalibBoard::PutStartY ( double val ) {
    HRESULT _hr = put_StartY(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline enum LPVErrorCode ILCalibBoard::GeneratePointPairs ( struct ILPoints * imgPoints, struct ILCalibPointPairs * * pointPairs ) {
    enum LPVErrorCode _result;
    HRESULT _hr = raw_GeneratePointPairs(imgPoints, pointPairs, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline VARIANT_BOOL ILCalibBoard::GetStartFromCetner ( ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = get_StartFromCetner(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILCalibBoard::PutStartFromCetner ( VARIANT_BOOL val ) {
    HRESULT _hr = put_StartFromCetner(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline VARIANT_BOOL ILCalibBoard::GetSwapXY ( ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = get_SwapXY(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILCalibBoard::PutSwapXY ( VARIANT_BOOL val ) {
    HRESULT _hr = put_SwapXY(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline double ILCalibBoard::GetStepX ( ) {
    double _result = 0;
    HRESULT _hr = get_StepX(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILCalibBoard::PutStepX ( double val ) {
    HRESULT _hr = put_StepX(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline double ILCalibBoard::GetStepY ( ) {
    double _result = 0;
    HRESULT _hr = get_StepY(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILCalibBoard::PutStepY ( double val ) {
    HRESULT _hr = put_StepY(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

//
// interface ILCalibRotation wrapper method implementations
//

inline VARIANT_BOOL ILCalibRotation::IsCalibrated ( ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = raw_IsCalibrated(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline enum LPVErrorCode ILCalibRotation::Calibrate ( ) {
    enum LPVErrorCode _result;
    HRESULT _hr = raw_Calibrate(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline HRESULT ILCalibRotation::AddRotPoint ( double pntX, double pntY, double angle ) {
    HRESULT _hr = raw_AddRotPoint(pntX, pntY, angle);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILCalibRotation::AddRotPointPair ( double pntX1, double pntY1, double pntX2, double pntY2, double angle ) {
    HRESULT _hr = raw_AddRotPointPair(pntX1, pntY1, pntX2, pntY2, angle);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILCalibRotation::SetAim ( double aimPointX1, double aimPointY1, double aimPointX2, double aimPointY2 ) {
    HRESULT _hr = raw_SetAim(aimPointX1, aimPointY1, aimPointX2, aimPointY2);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILCalibRotation::Align ( double pntX1, double pntY1, double pntX2, double pntY2, double * dx, double * dy, double * da ) {
    HRESULT _hr = raw_Align(pntX1, pntY1, pntX2, pntY2, dx, dy, da);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILCalibRotation::AlignTo ( double pntX1, double pntY1, double pntX2, double pntY2, double aimPointX1, double aimPointY1, double aimPointX2, double aimPointY2, double * dx, double * dy, double * da ) {
    HRESULT _hr = raw_AlignTo(pntX1, pntY1, pntX2, pntY2, aimPointX1, aimPointY1, aimPointX2, aimPointY2, dx, dy, da);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline VARIANT_BOOL ILCalibRotation::GetTranslationOnRotation ( ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = get_TranslationOnRotation(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILCalibRotation::PutTranslationOnRotation ( VARIANT_BOOL val ) {
    HRESULT _hr = put_TranslationOnRotation(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline ILPointPtr ILCalibRotation::GetRotCenter ( ) {
    struct ILPoint * _result = 0;
    HRESULT _hr = raw_GetRotCenter(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILPointPtr(_result, false);
}

inline HRESULT ILCalibRotation::Transform ( double pntX, double pntY, double dx, double dy, double da, double * newX, double * newY ) {
    HRESULT _hr = raw_Transform(pntX, pntY, dx, dy, da, newX, newY);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

//
// interface ILCameraArray wrapper method implementations
//

inline VARIANT_BOOL ILCameraArray::GetEnableBlend ( ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = get_EnableBlend(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILCameraArray::PutEnableBlend ( VARIANT_BOOL val ) {
    HRESULT _hr = put_EnableBlend(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline HRESULT ILCameraArray::Init ( enum LPVCalibModel calibModel, int hCount, int vCount ) {
    HRESULT _hr = raw_Init(calibModel, hCount, vCount);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILCameraArray::InitByCopy ( struct ILCalib * calib, int hCount, int vCount, VARIANT_BOOL copyCalib, double hStep, double vStep ) {
    HRESULT _hr = raw_InitByCopy(calib, hCount, vCount, copyCalib, hStep, vStep);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILCameraArray::InitByCopyN ( SAFEARRAY * calibs, int rows, int hCount, int vCount, VARIANT_BOOL copyCalib, double hStep, double vStep ) {
    HRESULT _hr = raw_InitByCopyN(calibs, rows, hCount, vCount, copyCalib, hStep, vStep);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline int ILCameraArray::Count ( ) {
    int _result = 0;
    HRESULT _hr = raw_Count(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline ILCalibPtr ILCameraArray::Item ( int index ) {
    struct ILCalib * _result = 0;
    HRESULT _hr = raw_Item(index, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILCalibPtr(_result, false);
}

inline VARIANT_BOOL ILCameraArray::IsCalibrated ( ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = raw_IsCalibrated(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline enum LPVErrorCode ILCameraArray::Calibrate ( ) {
    enum LPVErrorCode _result;
    HRESULT _hr = raw_Calibrate(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline HRESULT ILCameraArray::ImageToWorld ( double imagePointX, double imagePointY, double * worldPointX, double * worldPointY ) {
    HRESULT _hr = raw_ImageToWorld(imagePointX, imagePointY, worldPointX, worldPointY);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILCameraArray::WorldToImage ( double worldPointX, double worldPointY, double * imagePointX, double * imagePointY ) {
    HRESULT _hr = raw_WorldToImage(worldPointX, worldPointY, imagePointX, imagePointY);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline double ILCameraArray::GetCalibError ( ) {
    double _result = 0;
    HRESULT _hr = get_CalibError(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline enum LPVErrorCode ILCameraArray::StitchImage ( struct ILImageList * images, struct ILImage * stitchedImage ) {
    enum LPVErrorCode _result;
    HRESULT _hr = raw_StitchImage(images, stitchedImage, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline VARIANT_BOOL ILCameraArray::GetUseCache ( ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = get_UseCache(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILCameraArray::PutUseCache ( VARIANT_BOOL val ) {
    HRESULT _hr = put_UseCache(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline enum LPVInterpolationMethod ILCameraArray::GetInterpolationMethod ( ) {
    enum LPVInterpolationMethod _result;
    HRESULT _hr = get_InterpolationMethod(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILCameraArray::PutInterpolationMethod ( enum LPVInterpolationMethod val ) {
    HRESULT _hr = put_InterpolationMethod(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

//
// interface ILFlatField wrapper method implementations
//

inline VARIANT_BOOL ILFlatField::IsCalibrated ( ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = raw_IsCalibrated(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline enum LPVImageFormat ILFlatField::GetColorMode ( ) {
    enum LPVImageFormat _result;
    HRESULT _hr = get_ColorMode(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILFlatField::PutColorMode ( enum LPVImageFormat val ) {
    HRESULT _hr = put_ColorMode(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline int ILFlatField::GetFromGray ( ) {
    int _result = 0;
    HRESULT _hr = get_FromGray(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILFlatField::PutFromGray ( int val ) {
    HRESULT _hr = put_FromGray(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline int ILFlatField::GetToGray ( ) {
    int _result = 0;
    HRESULT _hr = get_ToGray(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILFlatField::PutToGray ( int val ) {
    HRESULT _hr = put_ToGray(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline struct LColor ILFlatField::GetFromColor ( ) {
    struct LColor _result;
    HRESULT _hr = get_FromColor(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILFlatField::PutFromColor ( struct LColor val ) {
    HRESULT _hr = put_FromColor(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline struct LColor ILFlatField::GetToColor ( ) {
    struct LColor _result;
    HRESULT _hr = get_ToColor(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILFlatField::PutToColor ( struct LColor val ) {
    HRESULT _hr = put_ToColor(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline int ILFlatField::GetTolerance ( ) {
    int _result = 0;
    HRESULT _hr = get_Tolerance(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILFlatField::PutTolerance ( int val ) {
    HRESULT _hr = put_Tolerance(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

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

inline void ILFlatField::PutKernelWidth ( int val ) {
    HRESULT _hr = put_KernelWidth(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline double ILFlatField::GetUpdateRate ( ) {
    double _result = 0;
    HRESULT _hr = get_UpdateRate(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILFlatField::PutUpdateRate ( double val ) {
    HRESULT _hr = put_UpdateRate(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline enum LPVErrorCode ILFlatField::SetDarkFrame ( struct ILImage * image ) {
    enum LPVErrorCode _result;
    HRESULT _hr = raw_SetDarkFrame(image, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline enum LPVErrorCode ILFlatField::Train ( struct ILImage * image, struct ILRegion * region ) {
    enum LPVErrorCode _result;
    HRESULT _hr = raw_Train(image, region, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline enum LPVErrorCode ILFlatField::FixImage ( struct ILImage * image, struct ILImage * fixedImage ) {
    enum LPVErrorCode _result;
    HRESULT _hr = raw_FixImage(image, fixedImage, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline HRESULT ILFlatField::GetFlatField ( struct ILImage * previewImage ) {
    HRESULT _hr = raw_GetFlatField(previewImage);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}