upright
/
smokeboxidentification
mirror of https://gitlab.hzleaper.com:81/qu.shuailong/smokeboxidentification.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
滁州
master
NanJingYanCao
LanXin3D
main
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'NanJingYanCao'
${ noResults }
smokeboxidentification/tpvs17/SmokeBoxIdentification/x64/Release/lpvCalib.tli

901 lines
31 KiB
Plaintext
Raw Permalink Blame History

// 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;
}
Reference in New Issue View Git Blame Copy Permalink