// Created by Microsoft (R) C/C++ Compiler Version 14.16.27051.0 (6e2a7e5e).
//
// d:\code\logistics\smokeboxidentification\tpvs17\smokeboxidentification\x64\release\lpvPat.tli
//
// Wrapper implementations for Win32 type library 799860e5-cec7-4d65-9c62-a93320c0f60a
// compiler-generated file created 01/03/24 at 16:59:27 - DO NOT EDIT!

#pragma once

//
// interface ILMatchResult wrapper method implementations
//

inline double ILMatchResult::GetScore ( ) {
    double _result = 0;
    HRESULT _hr = get_Score(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

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

inline double ILMatchResult::GetAngle ( ) {
    double _result = 0;
    HRESULT _hr = get_Angle(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline double ILMatchResult::GetScale ( ) {
    double _result = 0;
    HRESULT _hr = get_Scale(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline HRESULT ILMatchResult::Draw ( void * hdc, enum LPVPatDrawFlags drawFlags, double zoomX, double zoomY, double panX, double panY ) {
    HRESULT _hr = raw_Draw(hdc, drawFlags, zoomX, zoomY, panX, panY);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline ILRectPtr ILMatchResult::GetRect ( ) {
    struct ILRect * _result = 0;
    HRESULT _hr = raw_GetRect(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ILRectPtr(_result, false);
}

inline HRESULT ILMatchResult::Set ( struct ILMatch * matchObject, double patX, double patY, double patAngle, double patScale, double patScore ) {
    HRESULT _hr = raw_Set(matchObject, patX, patY, patAngle, patScale, patScore);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

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

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

inline double ILMatchResult::GetShapeScore ( ) {
    double _result = 0;
    HRESULT _hr = get_ShapeScore(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline double ILMatchResult::GetGrayScore ( ) {
    double _result = 0;
    HRESULT _hr = get_GrayScore(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

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

//
// interface ILMatchResults wrapper method implementations
//

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

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

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

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

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

//
// interface ILMatch wrapper method implementations
//

inline enum LPVErrorCode ILMatch::Learn ( struct ILImage * img, struct ILRegion * region ) {
    enum LPVErrorCode _result;
    HRESULT _hr = raw_Learn(img, region, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline enum LPVErrorCode ILMatch::LearnWithShape ( struct ILImage * img, struct ILRegion * region, struct ILRegion * shapeRegion ) {
    enum LPVErrorCode _result;
    HRESULT _hr = raw_LearnWithShape(img, region, shapeRegion, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline enum LPVErrorCode ILMatch::LearnWithShapeImage ( struct ILImage * img, struct ILRegion * region, struct ILImage * shapeImg ) {
    enum LPVErrorCode _result;
    HRESULT _hr = raw_LearnWithShapeImage(img, region, shapeImg, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline VARIANT_BOOL ILMatch::IsLearnt ( ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = raw_IsLearnt(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline enum LPVErrorCode ILMatch::Match ( struct ILImage * img, struct ILRegion * region, struct ILMatchResults * * results ) {
    enum LPVErrorCode _result;
    HRESULT _hr = raw_Match(img, region, results, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline int ILMatch::GetAcceptScore ( ) {
    int _result = 0;
    HRESULT _hr = get_AcceptScore(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILMatch::PutAcceptScore ( int val ) {
    HRESULT _hr = put_AcceptScore(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline int ILMatch::GetAngleTolerance ( ) {
    int _result = 0;
    HRESULT _hr = get_AngleTolerance(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILMatch::PutAngleTolerance ( int val ) {
    HRESULT _hr = put_AngleTolerance(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline int ILMatch::GetAngleBias ( ) {
    int _result = 0;
    HRESULT _hr = get_AngleBias(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILMatch::PutAngleBias ( int val ) {
    HRESULT _hr = put_AngleBias(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline int ILMatch::GetScaleTolerance ( ) {
    int _result = 0;
    HRESULT _hr = get_ScaleTolerance(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILMatch::PutScaleTolerance ( int val ) {
    HRESULT _hr = put_ScaleTolerance(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline int ILMatch::GetScaleBias ( ) {
    int _result = 0;
    HRESULT _hr = get_ScaleBias(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILMatch::PutScaleBias ( int val ) {
    HRESULT _hr = put_ScaleBias(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline int ILMatch::GetMaxCount ( ) {
    int _result = 0;
    HRESULT _hr = get_MaxCount(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILMatch::PutMaxCount ( int val ) {
    HRESULT _hr = put_MaxCount(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline int ILMatch::GetOverlap ( ) {
    int _result = 0;
    HRESULT _hr = get_Overlap(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILMatch::PutOverlap ( int val ) {
    HRESULT _hr = put_Overlap(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline VARIANT_BOOL ILMatch::GetIgnorePolarity ( ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = get_IgnorePolarity(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILMatch::PutIgnorePolarity ( VARIANT_BOOL val ) {
    HRESULT _hr = put_IgnorePolarity(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

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

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

inline VARIANT_BOOL ILMatch::GetStrictScore ( ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = get_StrictScore(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILMatch::PutStrictScore ( VARIANT_BOOL val ) {
    HRESULT _hr = put_StrictScore(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline VARIANT_BOOL ILMatch::GetExcludeBoundary ( ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = get_ExcludeBoundary(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILMatch::PutExcludeBoundary ( VARIANT_BOOL val ) {
    HRESULT _hr = put_ExcludeBoundary(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline int ILMatch::GetGrayValueWeight ( ) {
    int _result = 0;
    HRESULT _hr = get_GrayValueWeight(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILMatch::PutGrayValueWeight ( int val ) {
    HRESULT _hr = put_GrayValueWeight(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline HRESULT ILMatch::SetPatCenter ( enum LPVPatCenterMode centerMode, double patX, double patY, double patAngle ) {
    HRESULT _hr = raw_SetPatCenter(centerMode, patX, patY, patAngle);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILMatch::GetPatCenter ( double * patX, double * patY, double * patAngle ) {
    HRESULT _hr = raw_GetPatCenter(patX, patY, patAngle);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline enum LPVPatCenterMode ILMatch::GetPatCenterMode ( ) {
    enum LPVPatCenterMode _result;
    HRESULT _hr = raw_GetPatCenterMode(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline HRESULT ILMatch::GetPatImage ( struct ILImage * img ) {
    HRESULT _hr = raw_GetPatImage(img);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ILMatch::GetPatMask ( struct ILImage * mask ) {
    HRESULT _hr = raw_GetPatMask(mask);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline double ILMatch::GetDetailLevel ( ) {
    double _result = 0;
    HRESULT _hr = get_DetailLevel(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILMatch::PutDetailLevel ( double val ) {
    HRESULT _hr = put_DetailLevel(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline VARIANT_BOOL ILMatch::GetIsotropicScale ( ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = get_IsotropicScale(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILMatch::PutIsotropicScale ( VARIANT_BOOL val ) {
    HRESULT _hr = put_IsotropicScale(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

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

inline int ILMatch::GetAccuracyLevel ( ) {
    int _result = 0;
    HRESULT _hr = get_AccuracyLevel(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILMatch::PutAccuracyLevel ( int val ) {
    HRESULT _hr = put_AccuracyLevel(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline VARIANT_BOOL ILMatch::GetIgnoreMissing ( ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = get_IgnoreMissing(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILMatch::PutIgnoreMissing ( VARIANT_BOOL val ) {
    HRESULT _hr = put_IgnoreMissing(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline int ILMatch::GetMissingTolerance ( ) {
    int _result = 0;
    HRESULT _hr = get_MissingTolerance(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void ILMatch::PutMissingTolerance ( int val ) {
    HRESULT _hr = put_MissingTolerance(val);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}