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.
1104 lines
36 KiB
Plaintext
1104 lines
36 KiB
Plaintext
// Created by Microsoft (R) C/C++ Compiler Version 14.16.27050.0 (6a538ac1).
|
|
//
|
|
// d:\git\hzleaper\smokebox\tpvs17\smokeboxidentification\x64\release\lpvCalib.tlh
|
|
//
|
|
// C++ source equivalent of type library faa32948-bf4e-4482-9216-70412f34bb66
|
|
// compiler-generated file created 02/21/24 at 11:50:39 - DO NOT EDIT!
|
|
|
|
//
|
|
// Cross-referenced type libraries:
|
|
//
|
|
//
|
|
|
|
#pragma once
|
|
#pragma pack(push, 8)
|
|
|
|
#include <comdef.h>
|
|
|
|
//
|
|
// Forward references and typedefs
|
|
//
|
|
|
|
struct __declspec(uuid("faa32948-bf4e-4482-9216-70412f34bb66"))
|
|
/* LIBID */ __LPVCalibLib;
|
|
enum LPVFixImageMode;
|
|
enum LPVDistortionModel;
|
|
enum LPVCalibBoardType;
|
|
enum LPVCalibModel;
|
|
struct __declspec(uuid("7ec2dc7f-abf3-428f-ac9e-46ef7f73d150"))
|
|
/* dual interface */ ILCalib;
|
|
struct __declspec(uuid("7bcf71ba-f0da-4525-8e36-699662d5ad62"))
|
|
/* dual interface */ ILCalibPointPairs;
|
|
struct __declspec(uuid("123c56da-0e02-4149-89e7-50201429643b"))
|
|
/* dual interface */ ILCalibNPoints;
|
|
struct __declspec(uuid("07fcc5a5-0ed9-4347-a74f-562256704225"))
|
|
/* dual interface */ ILCalibPinHole;
|
|
struct __declspec(uuid("ca9b5f85-b867-4f08-a464-7b33e88de4d0"))
|
|
/* dual interface */ ILCalibFFD;
|
|
struct __declspec(uuid("91998f82-0bb9-40f4-a9e7-83c09c13c50c"))
|
|
/* dual interface */ ILCalibCustom;
|
|
struct __declspec(uuid("0301dbd7-7b19-4477-af7b-960bc1605750"))
|
|
/* dual interface */ ILCalibBoard;
|
|
struct __declspec(uuid("e84620c2-bc84-4ffe-b234-85dc5285ded8"))
|
|
/* dual interface */ ILCalibRotation;
|
|
struct __declspec(uuid("d53587b5-0d36-47ce-874b-381ea3b37c50"))
|
|
/* dual interface */ ILCameraArray;
|
|
struct __declspec(uuid("db03ed32-8f8c-47ef-b6b5-bb6a0e7d62d6"))
|
|
/* dual interface */ ILFlatField;
|
|
struct /* coclass */ LCalibNPoints;
|
|
struct /* coclass */ LCalibPinHole;
|
|
struct /* coclass */ LCalibFFD;
|
|
struct /* coclass */ LCalibCustom;
|
|
struct /* coclass */ LCalibBoard;
|
|
struct /* coclass */ LCalibPointPairs;
|
|
struct /* coclass */ LCalibRotation;
|
|
struct /* coclass */ LCameraArray;
|
|
struct /* coclass */ LFlatField;
|
|
|
|
//
|
|
// Smart pointer typedef declarations
|
|
//
|
|
|
|
_COM_SMARTPTR_TYPEDEF(ILCalibPointPairs, __uuidof(ILCalibPointPairs));
|
|
_COM_SMARTPTR_TYPEDEF(ILCalib, __uuidof(ILCalib));
|
|
_COM_SMARTPTR_TYPEDEF(ILCalibNPoints, __uuidof(ILCalibNPoints));
|
|
_COM_SMARTPTR_TYPEDEF(ILCalibPinHole, __uuidof(ILCalibPinHole));
|
|
_COM_SMARTPTR_TYPEDEF(ILCalibFFD, __uuidof(ILCalibFFD));
|
|
_COM_SMARTPTR_TYPEDEF(ILCalibCustom, __uuidof(ILCalibCustom));
|
|
_COM_SMARTPTR_TYPEDEF(ILCalibBoard, __uuidof(ILCalibBoard));
|
|
_COM_SMARTPTR_TYPEDEF(ILCalibRotation, __uuidof(ILCalibRotation));
|
|
_COM_SMARTPTR_TYPEDEF(ILCameraArray, __uuidof(ILCameraArray));
|
|
_COM_SMARTPTR_TYPEDEF(ILFlatField, __uuidof(ILFlatField));
|
|
|
|
//
|
|
// Type library items
|
|
//
|
|
|
|
enum LPVFixImageMode
|
|
{
|
|
LPVFixImageNone = 0,
|
|
LPVFixImageUndistort = 1,
|
|
LPVFixImageUndistortAndUntilt = 2
|
|
};
|
|
|
|
enum LPVDistortionModel
|
|
{
|
|
LPVDistortionRadial = 0,
|
|
LPVDistortionRationalRadial = 1,
|
|
LPVDistortionThinPrism = 2,
|
|
LPVDistortionTangential = 4,
|
|
LPVDistortionAll = 7
|
|
};
|
|
|
|
enum LPVCalibBoardType
|
|
{
|
|
LPVChessBoard = 0,
|
|
LPVCircleGrid = 1,
|
|
LPVDistCharucoBoard = 2,
|
|
LPVEMCircleGrid = 4
|
|
};
|
|
|
|
enum LPVCalibModel
|
|
{
|
|
LPVCalibPinHole = 1,
|
|
LPVCalibNPoints = 2,
|
|
LPVCalibCustom = 3,
|
|
LPVCalibFFD = 4
|
|
};
|
|
|
|
struct __declspec(uuid("7bcf71ba-f0da-4525-8e36-699662d5ad62"))
|
|
ILCalibPointPairs : ILObject
|
|
{
|
|
//
|
|
// Wrapper methods for error-handling
|
|
//
|
|
|
|
int Count ( );
|
|
ILPointPtr GetImagePoint (
|
|
int index );
|
|
ILPointPtr GetWorldPoint (
|
|
int index );
|
|
HRESULT AddPointPair (
|
|
double imagePointX,
|
|
double imagePointY,
|
|
double worldPointX,
|
|
double worldPointY );
|
|
HRESULT Draw (
|
|
void * hdc,
|
|
int index,
|
|
double zoomX,
|
|
double zoomY,
|
|
double panX,
|
|
double panY );
|
|
HRESULT DrawAll (
|
|
void * hdc,
|
|
double zoomX,
|
|
double zoomY,
|
|
double panX,
|
|
double panY );
|
|
ILPointsPtr GetImagePoints ( );
|
|
ILPointsPtr GetWorldPoints ( );
|
|
|
|
//
|
|
// Raw methods provided by interface
|
|
//
|
|
|
|
virtual HRESULT __stdcall raw_Count (
|
|
/*[out,retval]*/ int * val ) = 0;
|
|
virtual HRESULT __stdcall raw_GetImagePoint (
|
|
/*[in]*/ int index,
|
|
/*[out,retval]*/ struct ILPoint * * imagePoint ) = 0;
|
|
virtual HRESULT __stdcall raw_GetWorldPoint (
|
|
/*[in]*/ int index,
|
|
/*[out,retval]*/ struct ILPoint * * worldPoint ) = 0;
|
|
virtual HRESULT __stdcall raw_AddPointPair (
|
|
/*[in]*/ double imagePointX,
|
|
/*[in]*/ double imagePointY,
|
|
/*[in]*/ double worldPointX,
|
|
/*[in]*/ double worldPointY ) = 0;
|
|
virtual HRESULT __stdcall raw_Draw (
|
|
/*[in]*/ void * hdc,
|
|
/*[in]*/ int index,
|
|
/*[in]*/ double zoomX,
|
|
/*[in]*/ double zoomY,
|
|
/*[in]*/ double panX,
|
|
/*[in]*/ double panY ) = 0;
|
|
virtual HRESULT __stdcall raw_DrawAll (
|
|
/*[in]*/ void * hdc,
|
|
/*[in]*/ double zoomX,
|
|
/*[in]*/ double zoomY,
|
|
/*[in]*/ double panX,
|
|
/*[in]*/ double panY ) = 0;
|
|
virtual HRESULT __stdcall raw_GetImagePoints (
|
|
/*[out,retval]*/ struct ILPoints * * imagePoints ) = 0;
|
|
virtual HRESULT __stdcall raw_GetWorldPoints (
|
|
/*[out,retval]*/ struct ILPoints * * worldPoints ) = 0;
|
|
};
|
|
|
|
struct __declspec(uuid("7ec2dc7f-abf3-428f-ac9e-46ef7f73d150"))
|
|
ILCalib : ILObject
|
|
{
|
|
//
|
|
// Property data
|
|
//
|
|
|
|
__declspec(property(get=GetCalibError))
|
|
double CalibError;
|
|
__declspec(property(get=GetFixImageMode,put=PutFixImageMode))
|
|
enum LPVFixImageMode FixImageMode;
|
|
__declspec(property(get=GetFixImageScale,put=PutFixImageScale))
|
|
double FixImageScale;
|
|
__declspec(property(get=GetFixImageOffsetX,put=PutFixImageOffsetX))
|
|
double FixImageOffsetX;
|
|
__declspec(property(get=GetFixImageOffsetY,put=PutFixImageOffsetY))
|
|
double FixImageOffsetY;
|
|
__declspec(property(get=GetModel))
|
|
enum LPVCalibModel Model;
|
|
__declspec(property(get=GetUseCache,put=PutUseCache))
|
|
VARIANT_BOOL UseCache;
|
|
__declspec(property(get=GetInterpolationMethod,put=PutInterpolationMethod))
|
|
enum LPVInterpolationMethod InterpolationMethod;
|
|
|
|
//
|
|
// Wrapper methods for error-handling
|
|
//
|
|
|
|
VARIANT_BOOL IsCalibrated ( );
|
|
enum LPVErrorCode Calibrate ( );
|
|
HRESULT ImageToWorld (
|
|
double imagePointX,
|
|
double imagePointY,
|
|
double * worldPointX,
|
|
double * worldPointY );
|
|
HRESULT WorldToImage (
|
|
double worldPointX,
|
|
double worldPointY,
|
|
double * imagePointX,
|
|
double * imagePointY );
|
|
double GetCalibError ( );
|
|
enum LPVFixImageMode GetFixImageMode ( );
|
|
void PutFixImageMode (
|
|
enum LPVFixImageMode val );
|
|
double GetFixImageScale ( );
|
|
void PutFixImageScale (
|
|
double val );
|
|
double GetFixImageOffsetX ( );
|
|
void PutFixImageOffsetX (
|
|
double val );
|
|
double GetFixImageOffsetY ( );
|
|
void PutFixImageOffsetY (
|
|
double val );
|
|
enum LPVErrorCode FixImage (
|
|
struct ILImage * image,
|
|
struct ILImage * fixedImage );
|
|
HRESULT SetPostTransform (
|
|
double offsetX,
|
|
double offsetY,
|
|
double deltaAngle );
|
|
HRESULT SetPostTransformMatrix (
|
|
int cols,
|
|
int rows,
|
|
SAFEARRAY * data );
|
|
enum LPVErrorCode AddPoint (
|
|
double imagePointX,
|
|
double imagePointY,
|
|
double worldPointX,
|
|
double worldPointY );
|
|
enum LPVErrorCode AddPoints (
|
|
struct ILCalibPointPairs * pointPairs );
|
|
HRESULT SetImageSize (
|
|
int w,
|
|
int h );
|
|
HRESULT SetPostTransformMatrix23 (
|
|
struct LMatrix23 * data );
|
|
HRESULT SetPostTransformMatrix33 (
|
|
struct LMatrix33 * data );
|
|
enum LPVErrorCode GenPostTransformMatrix (
|
|
struct ILCalibPointPairs * pointPairs );
|
|
enum LPVCalibModel GetModel ( );
|
|
VARIANT_BOOL GetUseCache ( );
|
|
void PutUseCache (
|
|
VARIANT_BOOL val );
|
|
enum LPVInterpolationMethod GetInterpolationMethod ( );
|
|
void PutInterpolationMethod (
|
|
enum LPVInterpolationMethod val );
|
|
|
|
//
|
|
// Raw methods provided by interface
|
|
//
|
|
|
|
virtual HRESULT __stdcall raw_IsCalibrated (
|
|
/*[out,retval]*/ VARIANT_BOOL * val ) = 0;
|
|
virtual HRESULT __stdcall raw_Calibrate (
|
|
/*[out,retval]*/ enum LPVErrorCode * error ) = 0;
|
|
virtual HRESULT __stdcall raw_ImageToWorld (
|
|
/*[in]*/ double imagePointX,
|
|
/*[in]*/ double imagePointY,
|
|
/*[out]*/ double * worldPointX,
|
|
/*[out]*/ double * worldPointY ) = 0;
|
|
virtual HRESULT __stdcall raw_WorldToImage (
|
|
/*[in]*/ double worldPointX,
|
|
/*[in]*/ double worldPointY,
|
|
/*[out]*/ double * imagePointX,
|
|
/*[out]*/ double * imagePointY ) = 0;
|
|
virtual HRESULT __stdcall get_CalibError (
|
|
/*[out,retval]*/ double * val ) = 0;
|
|
virtual HRESULT __stdcall get_FixImageMode (
|
|
/*[out,retval]*/ enum LPVFixImageMode * val ) = 0;
|
|
virtual HRESULT __stdcall put_FixImageMode (
|
|
/*[in]*/ enum LPVFixImageMode val ) = 0;
|
|
virtual HRESULT __stdcall get_FixImageScale (
|
|
/*[out,retval]*/ double * val ) = 0;
|
|
virtual HRESULT __stdcall put_FixImageScale (
|
|
/*[in]*/ double val ) = 0;
|
|
virtual HRESULT __stdcall get_FixImageOffsetX (
|
|
/*[out,retval]*/ double * val ) = 0;
|
|
virtual HRESULT __stdcall put_FixImageOffsetX (
|
|
/*[in]*/ double val ) = 0;
|
|
virtual HRESULT __stdcall get_FixImageOffsetY (
|
|
/*[out,retval]*/ double * val ) = 0;
|
|
virtual HRESULT __stdcall put_FixImageOffsetY (
|
|
/*[in]*/ double val ) = 0;
|
|
virtual HRESULT __stdcall raw_FixImage (
|
|
/*[in]*/ struct ILImage * image,
|
|
/*[out]*/ struct ILImage * fixedImage,
|
|
/*[out,retval]*/ enum LPVErrorCode * error ) = 0;
|
|
virtual HRESULT __stdcall raw_SetPostTransform (
|
|
/*[in]*/ double offsetX,
|
|
/*[in]*/ double offsetY,
|
|
/*[in]*/ double deltaAngle ) = 0;
|
|
virtual HRESULT __stdcall raw_SetPostTransformMatrix (
|
|
/*[in]*/ int cols,
|
|
/*[in]*/ int rows,
|
|
/*[in]*/ SAFEARRAY * data ) = 0;
|
|
virtual HRESULT __stdcall raw_AddPoint (
|
|
/*[in]*/ double imagePointX,
|
|
/*[in]*/ double imagePointY,
|
|
/*[in]*/ double worldPointX,
|
|
/*[in]*/ double worldPointY,
|
|
/*[out,retval]*/ enum LPVErrorCode * error ) = 0;
|
|
virtual HRESULT __stdcall raw_AddPoints (
|
|
/*[in]*/ struct ILCalibPointPairs * pointPairs,
|
|
/*[out,retval]*/ enum LPVErrorCode * error ) = 0;
|
|
virtual HRESULT __stdcall raw_SetImageSize (
|
|
/*[in]*/ int w,
|
|
/*[in]*/ int h ) = 0;
|
|
virtual HRESULT __stdcall raw_SetPostTransformMatrix23 (
|
|
/*[in]*/ struct LMatrix23 * data ) = 0;
|
|
virtual HRESULT __stdcall raw_SetPostTransformMatrix33 (
|
|
/*[in]*/ struct LMatrix33 * data ) = 0;
|
|
virtual HRESULT __stdcall raw_GenPostTransformMatrix (
|
|
/*[in]*/ struct ILCalibPointPairs * pointPairs,
|
|
/*[out,retval]*/ enum LPVErrorCode * error ) = 0;
|
|
virtual HRESULT __stdcall get_Model (
|
|
/*[out,retval]*/ enum LPVCalibModel * val ) = 0;
|
|
virtual HRESULT __stdcall get_UseCache (
|
|
/*[out,retval]*/ VARIANT_BOOL * val ) = 0;
|
|
virtual HRESULT __stdcall put_UseCache (
|
|
/*[in]*/ VARIANT_BOOL val ) = 0;
|
|
virtual HRESULT __stdcall get_InterpolationMethod (
|
|
/*[out,retval]*/ enum LPVInterpolationMethod * val ) = 0;
|
|
virtual HRESULT __stdcall put_InterpolationMethod (
|
|
/*[in]*/ enum LPVInterpolationMethod val ) = 0;
|
|
};
|
|
|
|
struct __declspec(uuid("123c56da-0e02-4149-89e7-50201429643b"))
|
|
ILCalibNPoints : ILCalib
|
|
{
|
|
//
|
|
// Property data
|
|
//
|
|
|
|
__declspec(property(get=GetTransformType,put=PutTransformType))
|
|
enum LPVTransformType TransformType;
|
|
|
|
//
|
|
// Wrapper methods for error-handling
|
|
//
|
|
|
|
enum LPVTransformType GetTransformType ( );
|
|
void PutTransformType (
|
|
enum LPVTransformType val );
|
|
|
|
//
|
|
// Raw methods provided by interface
|
|
//
|
|
|
|
virtual HRESULT __stdcall get_TransformType (
|
|
/*[out,retval]*/ enum LPVTransformType * val ) = 0;
|
|
virtual HRESULT __stdcall put_TransformType (
|
|
/*[in]*/ enum LPVTransformType val ) = 0;
|
|
};
|
|
|
|
struct __declspec(uuid("07fcc5a5-0ed9-4347-a74f-562256704225"))
|
|
ILCalibPinHole : ILCalib
|
|
{
|
|
//
|
|
// Property data
|
|
//
|
|
|
|
__declspec(property(get=GetDistortionModel,put=PutDistortionModel))
|
|
enum LPVDistortionModel DistortionModel;
|
|
|
|
//
|
|
// Wrapper methods for error-handling
|
|
//
|
|
|
|
enum LPVDistortionModel GetDistortionModel ( );
|
|
void PutDistortionModel (
|
|
enum LPVDistortionModel val );
|
|
HRESULT SetCameraProps (
|
|
double cellSize,
|
|
double focusLength,
|
|
double viewDistance );
|
|
enum LPVErrorCode AddMVPoints (
|
|
struct ILCalibPointPairs * pointPairs );
|
|
|
|
//
|
|
// Raw methods provided by interface
|
|
//
|
|
|
|
virtual HRESULT __stdcall get_DistortionModel (
|
|
/*[out,retval]*/ enum LPVDistortionModel * val ) = 0;
|
|
virtual HRESULT __stdcall put_DistortionModel (
|
|
/*[in]*/ enum LPVDistortionModel val ) = 0;
|
|
virtual HRESULT __stdcall raw_SetCameraProps (
|
|
/*[in]*/ double cellSize,
|
|
/*[in]*/ double focusLength,
|
|
/*[in]*/ double viewDistance ) = 0;
|
|
virtual HRESULT __stdcall raw_AddMVPoints (
|
|
/*[in]*/ struct ILCalibPointPairs * pointPairs,
|
|
/*[out,retval]*/ enum LPVErrorCode * error ) = 0;
|
|
};
|
|
|
|
struct __declspec(uuid("ca9b5f85-b867-4f08-a464-7b33e88de4d0"))
|
|
ILCalibFFD : ILCalib
|
|
{
|
|
//
|
|
// Wrapper methods for error-handling
|
|
//
|
|
|
|
HRESULT SetFFDGrid (
|
|
int cols,
|
|
int rows );
|
|
|
|
//
|
|
// Raw methods provided by interface
|
|
//
|
|
|
|
virtual HRESULT __stdcall raw_SetFFDGrid (
|
|
/*[in]*/ int cols,
|
|
/*[in]*/ int rows ) = 0;
|
|
};
|
|
|
|
struct __declspec(uuid("91998f82-0bb9-40f4-a9e7-83c09c13c50c"))
|
|
ILCalibCustom : ILCalib
|
|
{
|
|
//
|
|
// Property data
|
|
//
|
|
|
|
__declspec(property(get=GetScaleX,put=PutScaleX))
|
|
double ScaleX;
|
|
__declspec(property(get=GetScaleY,put=PutScaleY))
|
|
double ScaleY;
|
|
__declspec(property(get=GetTheta,put=PutTheta))
|
|
double Theta;
|
|
__declspec(property(get=GetAxisDirX,put=PutAxisDirX))
|
|
enum LPVDirection AxisDirX;
|
|
__declspec(property(get=GetAxisDirY,put=PutAxisDirY))
|
|
enum LPVDirection AxisDirY;
|
|
|
|
//
|
|
// Wrapper methods for error-handling
|
|
//
|
|
|
|
double GetScaleX ( );
|
|
void PutScaleX (
|
|
double val );
|
|
double GetScaleY ( );
|
|
void PutScaleY (
|
|
double val );
|
|
double GetTheta ( );
|
|
void PutTheta (
|
|
double val );
|
|
enum LPVDirection GetAxisDirX ( );
|
|
void PutAxisDirX (
|
|
enum LPVDirection val );
|
|
enum LPVDirection GetAxisDirY ( );
|
|
void PutAxisDirY (
|
|
enum LPVDirection val );
|
|
HRESULT MoveOriginTo (
|
|
double x,
|
|
double y );
|
|
|
|
//
|
|
// Raw methods provided by interface
|
|
//
|
|
|
|
virtual HRESULT __stdcall get_ScaleX (
|
|
/*[out,retval]*/ double * val ) = 0;
|
|
virtual HRESULT __stdcall put_ScaleX (
|
|
/*[in]*/ double val ) = 0;
|
|
virtual HRESULT __stdcall get_ScaleY (
|
|
/*[out,retval]*/ double * val ) = 0;
|
|
virtual HRESULT __stdcall put_ScaleY (
|
|
/*[in]*/ double val ) = 0;
|
|
virtual HRESULT __stdcall get_Theta (
|
|
/*[out,retval]*/ double * val ) = 0;
|
|
virtual HRESULT __stdcall put_Theta (
|
|
/*[in]*/ double val ) = 0;
|
|
virtual HRESULT __stdcall get_AxisDirX (
|
|
/*[out,retval]*/ enum LPVDirection * val ) = 0;
|
|
virtual HRESULT __stdcall put_AxisDirX (
|
|
/*[in]*/ enum LPVDirection val ) = 0;
|
|
virtual HRESULT __stdcall get_AxisDirY (
|
|
/*[out,retval]*/ enum LPVDirection * val ) = 0;
|
|
virtual HRESULT __stdcall put_AxisDirY (
|
|
/*[in]*/ enum LPVDirection val ) = 0;
|
|
virtual HRESULT __stdcall raw_MoveOriginTo (
|
|
/*[in]*/ double x,
|
|
/*[in]*/ double y ) = 0;
|
|
};
|
|
|
|
struct __declspec(uuid("0301dbd7-7b19-4477-af7b-960bc1605750"))
|
|
ILCalibBoard : ILObject
|
|
{
|
|
//
|
|
// Property data
|
|
//
|
|
|
|
__declspec(property(get=GetCalibBoardType,put=PutCalibBoardType))
|
|
enum LPVCalibBoardType CalibBoardType;
|
|
__declspec(property(get=GetGridWidth,put=PutGridWidth))
|
|
int GridWidth;
|
|
__declspec(property(get=GetGridHeight,put=PutGridHeight))
|
|
int GridHeight;
|
|
__declspec(property(get=GetSquareSize,put=PutSquareSize))
|
|
double SquareSize;
|
|
__declspec(property(get=GetMarkerSize,put=PutMarkerSize))
|
|
double MarkerSize;
|
|
__declspec(property(get=GetBoardThickness,put=PutBoardThickness))
|
|
double BoardThickness;
|
|
__declspec(property(get=GetAutoRemoveBad,put=PutAutoRemoveBad))
|
|
VARIANT_BOOL AutoRemoveBad;
|
|
__declspec(property(get=GetUseFittingMethod,put=PutUseFittingMethod))
|
|
VARIANT_BOOL UseFittingMethod;
|
|
__declspec(property(get=GetGuessPartialBlock,put=PutGuessPartialBlock))
|
|
VARIANT_BOOL GuessPartialBlock;
|
|
__declspec(property(get=GetInvertBlock,put=PutInvertBlock))
|
|
VARIANT_BOOL InvertBlock;
|
|
__declspec(property(get=GetStartX,put=PutStartX))
|
|
double StartX;
|
|
__declspec(property(get=GetStartY,put=PutStartY))
|
|
double StartY;
|
|
__declspec(property(get=GetStartFromCetner,put=PutStartFromCetner))
|
|
VARIANT_BOOL StartFromCetner;
|
|
__declspec(property(get=GetSwapXY,put=PutSwapXY))
|
|
VARIANT_BOOL SwapXY;
|
|
__declspec(property(get=GetStepX,put=PutStepX))
|
|
double StepX;
|
|
__declspec(property(get=GetStepY,put=PutStepY))
|
|
double StepY;
|
|
|
|
//
|
|
// Wrapper methods for error-handling
|
|
//
|
|
|
|
enum LPVCalibBoardType GetCalibBoardType ( );
|
|
void PutCalibBoardType (
|
|
enum LPVCalibBoardType val );
|
|
int GetGridWidth ( );
|
|
void PutGridWidth (
|
|
int val );
|
|
int GetGridHeight ( );
|
|
void PutGridHeight (
|
|
int val );
|
|
double GetSquareSize ( );
|
|
void PutSquareSize (
|
|
double val );
|
|
double GetMarkerSize ( );
|
|
void PutMarkerSize (
|
|
double val );
|
|
double GetBoardThickness ( );
|
|
void PutBoardThickness (
|
|
double val );
|
|
VARIANT_BOOL GetAutoRemoveBad ( );
|
|
void PutAutoRemoveBad (
|
|
VARIANT_BOOL val );
|
|
VARIANT_BOOL GetUseFittingMethod ( );
|
|
void PutUseFittingMethod (
|
|
VARIANT_BOOL val );
|
|
enum LPVErrorCode Detect (
|
|
struct ILImage * img,
|
|
struct ILCalibPointPairs * * pointPairs );
|
|
enum LPVErrorCode DetectInRegion (
|
|
struct ILImage * img,
|
|
struct ILRegion * region,
|
|
struct ILCalibPointPairs * * pointPairs );
|
|
VARIANT_BOOL GetGuessPartialBlock ( );
|
|
void PutGuessPartialBlock (
|
|
VARIANT_BOOL val );
|
|
VARIANT_BOOL GetInvertBlock ( );
|
|
void PutInvertBlock (
|
|
VARIANT_BOOL val );
|
|
double GetStartX ( );
|
|
void PutStartX (
|
|
double val );
|
|
double GetStartY ( );
|
|
void PutStartY (
|
|
double val );
|
|
enum LPVErrorCode GeneratePointPairs (
|
|
struct ILPoints * imgPoints,
|
|
struct ILCalibPointPairs * * pointPairs );
|
|
VARIANT_BOOL GetStartFromCetner ( );
|
|
void PutStartFromCetner (
|
|
VARIANT_BOOL val );
|
|
VARIANT_BOOL GetSwapXY ( );
|
|
void PutSwapXY (
|
|
VARIANT_BOOL val );
|
|
double GetStepX ( );
|
|
void PutStepX (
|
|
double val );
|
|
double GetStepY ( );
|
|
void PutStepY (
|
|
double val );
|
|
|
|
//
|
|
// Raw methods provided by interface
|
|
//
|
|
|
|
virtual HRESULT __stdcall get_CalibBoardType (
|
|
/*[out,retval]*/ enum LPVCalibBoardType * val ) = 0;
|
|
virtual HRESULT __stdcall put_CalibBoardType (
|
|
/*[in]*/ enum LPVCalibBoardType val ) = 0;
|
|
virtual HRESULT __stdcall get_GridWidth (
|
|
/*[out,retval]*/ int * val ) = 0;
|
|
virtual HRESULT __stdcall put_GridWidth (
|
|
/*[in]*/ int val ) = 0;
|
|
virtual HRESULT __stdcall get_GridHeight (
|
|
/*[out,retval]*/ int * val ) = 0;
|
|
virtual HRESULT __stdcall put_GridHeight (
|
|
/*[in]*/ int val ) = 0;
|
|
virtual HRESULT __stdcall get_SquareSize (
|
|
/*[out,retval]*/ double * val ) = 0;
|
|
virtual HRESULT __stdcall put_SquareSize (
|
|
/*[in]*/ double val ) = 0;
|
|
virtual HRESULT __stdcall get_MarkerSize (
|
|
/*[out,retval]*/ double * val ) = 0;
|
|
virtual HRESULT __stdcall put_MarkerSize (
|
|
/*[in]*/ double val ) = 0;
|
|
virtual HRESULT __stdcall get_BoardThickness (
|
|
/*[out,retval]*/ double * val ) = 0;
|
|
virtual HRESULT __stdcall put_BoardThickness (
|
|
/*[in]*/ double val ) = 0;
|
|
virtual HRESULT __stdcall get_AutoRemoveBad (
|
|
/*[out,retval]*/ VARIANT_BOOL * val ) = 0;
|
|
virtual HRESULT __stdcall put_AutoRemoveBad (
|
|
/*[in]*/ VARIANT_BOOL val ) = 0;
|
|
virtual HRESULT __stdcall get_UseFittingMethod (
|
|
/*[out,retval]*/ VARIANT_BOOL * val ) = 0;
|
|
virtual HRESULT __stdcall put_UseFittingMethod (
|
|
/*[in]*/ VARIANT_BOOL val ) = 0;
|
|
virtual HRESULT __stdcall raw_Detect (
|
|
/*[in]*/ struct ILImage * img,
|
|
/*[out]*/ struct ILCalibPointPairs * * pointPairs,
|
|
/*[out,retval]*/ enum LPVErrorCode * error ) = 0;
|
|
virtual HRESULT __stdcall raw_DetectInRegion (
|
|
/*[in]*/ struct ILImage * img,
|
|
/*[in]*/ struct ILRegion * region,
|
|
/*[out]*/ struct ILCalibPointPairs * * pointPairs,
|
|
/*[out,retval]*/ enum LPVErrorCode * error ) = 0;
|
|
virtual HRESULT __stdcall get_GuessPartialBlock (
|
|
/*[out,retval]*/ VARIANT_BOOL * val ) = 0;
|
|
virtual HRESULT __stdcall put_GuessPartialBlock (
|
|
/*[in]*/ VARIANT_BOOL val ) = 0;
|
|
virtual HRESULT __stdcall get_InvertBlock (
|
|
/*[out,retval]*/ VARIANT_BOOL * val ) = 0;
|
|
virtual HRESULT __stdcall put_InvertBlock (
|
|
/*[in]*/ VARIANT_BOOL val ) = 0;
|
|
virtual HRESULT __stdcall get_StartX (
|
|
/*[out,retval]*/ double * val ) = 0;
|
|
virtual HRESULT __stdcall put_StartX (
|
|
/*[in]*/ double val ) = 0;
|
|
virtual HRESULT __stdcall get_StartY (
|
|
/*[out,retval]*/ double * val ) = 0;
|
|
virtual HRESULT __stdcall put_StartY (
|
|
/*[in]*/ double val ) = 0;
|
|
virtual HRESULT __stdcall raw_GeneratePointPairs (
|
|
/*[in]*/ struct ILPoints * imgPoints,
|
|
/*[out]*/ struct ILCalibPointPairs * * pointPairs,
|
|
/*[out,retval]*/ enum LPVErrorCode * error ) = 0;
|
|
virtual HRESULT __stdcall get_StartFromCetner (
|
|
/*[out,retval]*/ VARIANT_BOOL * val ) = 0;
|
|
virtual HRESULT __stdcall put_StartFromCetner (
|
|
/*[in]*/ VARIANT_BOOL val ) = 0;
|
|
virtual HRESULT __stdcall get_SwapXY (
|
|
/*[out,retval]*/ VARIANT_BOOL * val ) = 0;
|
|
virtual HRESULT __stdcall put_SwapXY (
|
|
/*[in]*/ VARIANT_BOOL val ) = 0;
|
|
virtual HRESULT __stdcall get_StepX (
|
|
/*[out,retval]*/ double * val ) = 0;
|
|
virtual HRESULT __stdcall put_StepX (
|
|
/*[in]*/ double val ) = 0;
|
|
virtual HRESULT __stdcall get_StepY (
|
|
/*[out,retval]*/ double * val ) = 0;
|
|
virtual HRESULT __stdcall put_StepY (
|
|
/*[in]*/ double val ) = 0;
|
|
};
|
|
|
|
struct __declspec(uuid("e84620c2-bc84-4ffe-b234-85dc5285ded8"))
|
|
ILCalibRotation : ILObject
|
|
{
|
|
//
|
|
// Property data
|
|
//
|
|
|
|
__declspec(property(get=GetTranslationOnRotation,put=PutTranslationOnRotation))
|
|
VARIANT_BOOL TranslationOnRotation;
|
|
|
|
//
|
|
// Wrapper methods for error-handling
|
|
//
|
|
|
|
VARIANT_BOOL IsCalibrated ( );
|
|
enum LPVErrorCode Calibrate ( );
|
|
HRESULT AddRotPoint (
|
|
double pntX,
|
|
double pntY,
|
|
double angle );
|
|
HRESULT AddRotPointPair (
|
|
double pntX1,
|
|
double pntY1,
|
|
double pntX2,
|
|
double pntY2,
|
|
double angle );
|
|
HRESULT SetAim (
|
|
double aimPointX1,
|
|
double aimPointY1,
|
|
double aimPointX2,
|
|
double aimPointY2 );
|
|
HRESULT Align (
|
|
double pntX1,
|
|
double pntY1,
|
|
double pntX2,
|
|
double pntY2,
|
|
double * dx,
|
|
double * dy,
|
|
double * da );
|
|
HRESULT AlignTo (
|
|
double pntX1,
|
|
double pntY1,
|
|
double pntX2,
|
|
double pntY2,
|
|
double aimPointX1,
|
|
double aimPointY1,
|
|
double aimPointX2,
|
|
double aimPointY2,
|
|
double * dx,
|
|
double * dy,
|
|
double * da );
|
|
VARIANT_BOOL GetTranslationOnRotation ( );
|
|
void PutTranslationOnRotation (
|
|
VARIANT_BOOL val );
|
|
ILPointPtr GetRotCenter ( );
|
|
HRESULT Transform (
|
|
double pntX,
|
|
double pntY,
|
|
double dx,
|
|
double dy,
|
|
double da,
|
|
double * newX,
|
|
double * newY );
|
|
|
|
//
|
|
// Raw methods provided by interface
|
|
//
|
|
|
|
virtual HRESULT __stdcall raw_IsCalibrated (
|
|
/*[out,retval]*/ VARIANT_BOOL * val ) = 0;
|
|
virtual HRESULT __stdcall raw_Calibrate (
|
|
/*[out,retval]*/ enum LPVErrorCode * error ) = 0;
|
|
virtual HRESULT __stdcall raw_AddRotPoint (
|
|
/*[in]*/ double pntX,
|
|
/*[in]*/ double pntY,
|
|
/*[in]*/ double angle ) = 0;
|
|
virtual HRESULT __stdcall raw_AddRotPointPair (
|
|
/*[in]*/ double pntX1,
|
|
/*[in]*/ double pntY1,
|
|
/*[in]*/ double pntX2,
|
|
/*[in]*/ double pntY2,
|
|
/*[in]*/ double angle ) = 0;
|
|
virtual HRESULT __stdcall raw_SetAim (
|
|
/*[in]*/ double aimPointX1,
|
|
/*[in]*/ double aimPointY1,
|
|
/*[in]*/ double aimPointX2,
|
|
/*[in]*/ double aimPointY2 ) = 0;
|
|
virtual HRESULT __stdcall raw_Align (
|
|
/*[in]*/ double pntX1,
|
|
/*[in]*/ double pntY1,
|
|
/*[in]*/ double pntX2,
|
|
/*[in]*/ double pntY2,
|
|
/*[out]*/ double * dx,
|
|
/*[out]*/ double * dy,
|
|
/*[out]*/ double * da ) = 0;
|
|
virtual HRESULT __stdcall raw_AlignTo (
|
|
/*[in]*/ double pntX1,
|
|
/*[in]*/ double pntY1,
|
|
/*[in]*/ double pntX2,
|
|
/*[in]*/ double pntY2,
|
|
/*[in]*/ double aimPointX1,
|
|
/*[in]*/ double aimPointY1,
|
|
/*[in]*/ double aimPointX2,
|
|
/*[in]*/ double aimPointY2,
|
|
/*[out]*/ double * dx,
|
|
/*[out]*/ double * dy,
|
|
/*[out]*/ double * da ) = 0;
|
|
virtual HRESULT __stdcall get_TranslationOnRotation (
|
|
/*[out,retval]*/ VARIANT_BOOL * val ) = 0;
|
|
virtual HRESULT __stdcall put_TranslationOnRotation (
|
|
/*[in]*/ VARIANT_BOOL val ) = 0;
|
|
virtual HRESULT __stdcall raw_GetRotCenter (
|
|
/*[out,retval]*/ struct ILPoint * * center ) = 0;
|
|
virtual HRESULT __stdcall raw_Transform (
|
|
/*[in]*/ double pntX,
|
|
/*[in]*/ double pntY,
|
|
/*[in]*/ double dx,
|
|
/*[in]*/ double dy,
|
|
/*[in]*/ double da,
|
|
/*[out]*/ double * newX,
|
|
/*[out]*/ double * newY ) = 0;
|
|
};
|
|
|
|
struct __declspec(uuid("d53587b5-0d36-47ce-874b-381ea3b37c50"))
|
|
ILCameraArray : IDispatch
|
|
{
|
|
//
|
|
// Property data
|
|
//
|
|
|
|
__declspec(property(get=GetEnableBlend,put=PutEnableBlend))
|
|
VARIANT_BOOL EnableBlend;
|
|
__declspec(property(get=GetCalibError))
|
|
double CalibError;
|
|
__declspec(property(get=GetUseCache,put=PutUseCache))
|
|
VARIANT_BOOL UseCache;
|
|
__declspec(property(get=GetInterpolationMethod,put=PutInterpolationMethod))
|
|
enum LPVInterpolationMethod InterpolationMethod;
|
|
|
|
//
|
|
// Wrapper methods for error-handling
|
|
//
|
|
|
|
VARIANT_BOOL GetEnableBlend ( );
|
|
void PutEnableBlend (
|
|
VARIANT_BOOL val );
|
|
HRESULT Init (
|
|
enum LPVCalibModel calibModel,
|
|
int hCount,
|
|
int vCount );
|
|
HRESULT InitByCopy (
|
|
struct ILCalib * calib,
|
|
int hCount,
|
|
int vCount,
|
|
VARIANT_BOOL copyCalib,
|
|
double hStep,
|
|
double vStep );
|
|
HRESULT InitByCopyN (
|
|
SAFEARRAY * calibs,
|
|
int rows,
|
|
int hCount,
|
|
int vCount,
|
|
VARIANT_BOOL copyCalib,
|
|
double hStep,
|
|
double vStep );
|
|
int Count ( );
|
|
ILCalibPtr Item (
|
|
int index );
|
|
VARIANT_BOOL IsCalibrated ( );
|
|
enum LPVErrorCode Calibrate ( );
|
|
HRESULT ImageToWorld (
|
|
double imagePointX,
|
|
double imagePointY,
|
|
double * worldPointX,
|
|
double * worldPointY );
|
|
HRESULT WorldToImage (
|
|
double worldPointX,
|
|
double worldPointY,
|
|
double * imagePointX,
|
|
double * imagePointY );
|
|
double GetCalibError ( );
|
|
enum LPVErrorCode StitchImage (
|
|
struct ILImageList * images,
|
|
struct ILImage * stitchedImage );
|
|
VARIANT_BOOL GetUseCache ( );
|
|
void PutUseCache (
|
|
VARIANT_BOOL val );
|
|
enum LPVInterpolationMethod GetInterpolationMethod ( );
|
|
void PutInterpolationMethod (
|
|
enum LPVInterpolationMethod val );
|
|
|
|
//
|
|
// Raw methods provided by interface
|
|
//
|
|
|
|
virtual HRESULT __stdcall get_EnableBlend (
|
|
/*[out,retval]*/ VARIANT_BOOL * val ) = 0;
|
|
virtual HRESULT __stdcall put_EnableBlend (
|
|
/*[in]*/ VARIANT_BOOL val ) = 0;
|
|
virtual HRESULT __stdcall raw_Init (
|
|
/*[in]*/ enum LPVCalibModel calibModel,
|
|
/*[in]*/ int hCount,
|
|
/*[in]*/ int vCount ) = 0;
|
|
virtual HRESULT __stdcall raw_InitByCopy (
|
|
/*[in]*/ struct ILCalib * calib,
|
|
/*[in]*/ int hCount,
|
|
/*[in]*/ int vCount,
|
|
/*[in]*/ VARIANT_BOOL copyCalib,
|
|
/*[in]*/ double hStep,
|
|
/*[in]*/ double vStep ) = 0;
|
|
virtual HRESULT __stdcall raw_InitByCopyN (
|
|
/*[in]*/ SAFEARRAY * calibs,
|
|
/*[in]*/ int rows,
|
|
/*[in]*/ int hCount,
|
|
/*[in]*/ int vCount,
|
|
/*[in]*/ VARIANT_BOOL copyCalib,
|
|
/*[in]*/ double hStep,
|
|
/*[in]*/ double vStep ) = 0;
|
|
virtual HRESULT __stdcall raw_Count (
|
|
/*[out,retval]*/ int * val ) = 0;
|
|
virtual HRESULT __stdcall raw_Item (
|
|
/*[in]*/ int index,
|
|
/*[out,retval]*/ struct ILCalib * * calib ) = 0;
|
|
virtual HRESULT __stdcall raw_IsCalibrated (
|
|
/*[out,retval]*/ VARIANT_BOOL * val ) = 0;
|
|
virtual HRESULT __stdcall raw_Calibrate (
|
|
/*[out,retval]*/ enum LPVErrorCode * error ) = 0;
|
|
virtual HRESULT __stdcall raw_ImageToWorld (
|
|
/*[in]*/ double imagePointX,
|
|
/*[in]*/ double imagePointY,
|
|
/*[out]*/ double * worldPointX,
|
|
/*[out]*/ double * worldPointY ) = 0;
|
|
virtual HRESULT __stdcall raw_WorldToImage (
|
|
/*[in]*/ double worldPointX,
|
|
/*[in]*/ double worldPointY,
|
|
/*[out]*/ double * imagePointX,
|
|
/*[out]*/ double * imagePointY ) = 0;
|
|
virtual HRESULT __stdcall get_CalibError (
|
|
/*[out,retval]*/ double * val ) = 0;
|
|
virtual HRESULT __stdcall raw_StitchImage (
|
|
/*[in]*/ struct ILImageList * images,
|
|
/*[out]*/ struct ILImage * stitchedImage,
|
|
/*[out,retval]*/ enum LPVErrorCode * error ) = 0;
|
|
virtual HRESULT __stdcall get_UseCache (
|
|
/*[out,retval]*/ VARIANT_BOOL * val ) = 0;
|
|
virtual HRESULT __stdcall put_UseCache (
|
|
/*[in]*/ VARIANT_BOOL val ) = 0;
|
|
virtual HRESULT __stdcall get_InterpolationMethod (
|
|
/*[out,retval]*/ enum LPVInterpolationMethod * val ) = 0;
|
|
virtual HRESULT __stdcall put_InterpolationMethod (
|
|
/*[in]*/ enum LPVInterpolationMethod val ) = 0;
|
|
};
|
|
|
|
struct __declspec(uuid("db03ed32-8f8c-47ef-b6b5-bb6a0e7d62d6"))
|
|
ILFlatField : ILObject
|
|
{
|
|
//
|
|
// Property data
|
|
//
|
|
|
|
__declspec(property(get=GetColorMode,put=PutColorMode))
|
|
enum LPVImageFormat ColorMode;
|
|
__declspec(property(get=GetFromGray,put=PutFromGray))
|
|
int FromGray;
|
|
__declspec(property(get=GetToGray,put=PutToGray))
|
|
int ToGray;
|
|
__declspec(property(get=GetFromColor,put=PutFromColor))
|
|
struct LColor FromColor;
|
|
__declspec(property(get=GetToColor,put=PutToColor))
|
|
struct LColor ToColor;
|
|
__declspec(property(get=GetTolerance,put=PutTolerance))
|
|
int Tolerance;
|
|
__declspec(property(get=GetKernelWidth,put=PutKernelWidth))
|
|
int KernelWidth;
|
|
__declspec(property(get=GetUpdateRate,put=PutUpdateRate))
|
|
double UpdateRate;
|
|
|
|
//
|
|
// Wrapper methods for error-handling
|
|
//
|
|
|
|
VARIANT_BOOL IsCalibrated ( );
|
|
enum LPVImageFormat GetColorMode ( );
|
|
void PutColorMode (
|
|
enum LPVImageFormat val );
|
|
int GetFromGray ( );
|
|
void PutFromGray (
|
|
int val );
|
|
int GetToGray ( );
|
|
void PutToGray (
|
|
int val );
|
|
struct LColor GetFromColor ( );
|
|
void PutFromColor (
|
|
struct LColor val );
|
|
struct LColor GetToColor ( );
|
|
void PutToColor (
|
|
struct LColor val );
|
|
int GetTolerance ( );
|
|
void PutTolerance (
|
|
int val );
|
|
int GetKernelWidth ( );
|
|
void PutKernelWidth (
|
|
int val );
|
|
double GetUpdateRate ( );
|
|
void PutUpdateRate (
|
|
double val );
|
|
enum LPVErrorCode SetDarkFrame (
|
|
struct ILImage * image );
|
|
enum LPVErrorCode Train (
|
|
struct ILImage * image,
|
|
struct ILRegion * region );
|
|
enum LPVErrorCode FixImage (
|
|
struct ILImage * image,
|
|
struct ILImage * fixedImage );
|
|
HRESULT GetFlatField (
|
|
struct ILImage * previewImage );
|
|
|
|
//
|
|
// Raw methods provided by interface
|
|
//
|
|
|
|
virtual HRESULT __stdcall raw_IsCalibrated (
|
|
/*[out,retval]*/ VARIANT_BOOL * val ) = 0;
|
|
virtual HRESULT __stdcall get_ColorMode (
|
|
/*[out,retval]*/ enum LPVImageFormat * val ) = 0;
|
|
virtual HRESULT __stdcall put_ColorMode (
|
|
/*[in]*/ enum LPVImageFormat val ) = 0;
|
|
virtual HRESULT __stdcall get_FromGray (
|
|
/*[out,retval]*/ int * val ) = 0;
|
|
virtual HRESULT __stdcall put_FromGray (
|
|
/*[in]*/ int val ) = 0;
|
|
virtual HRESULT __stdcall get_ToGray (
|
|
/*[out,retval]*/ int * val ) = 0;
|
|
virtual HRESULT __stdcall put_ToGray (
|
|
/*[in]*/ int val ) = 0;
|
|
virtual HRESULT __stdcall get_FromColor (
|
|
/*[out,retval]*/ struct LColor * val ) = 0;
|
|
virtual HRESULT __stdcall put_FromColor (
|
|
/*[in]*/ struct LColor val ) = 0;
|
|
virtual HRESULT __stdcall get_ToColor (
|
|
/*[out,retval]*/ struct LColor * val ) = 0;
|
|
virtual HRESULT __stdcall put_ToColor (
|
|
/*[in]*/ struct LColor val ) = 0;
|
|
virtual HRESULT __stdcall get_Tolerance (
|
|
/*[out,retval]*/ int * val ) = 0;
|
|
virtual HRESULT __stdcall put_Tolerance (
|
|
/*[in]*/ int val ) = 0;
|
|
virtual HRESULT __stdcall get_KernelWidth (
|
|
/*[out,retval]*/ int * val ) = 0;
|
|
virtual HRESULT __stdcall put_KernelWidth (
|
|
/*[in]*/ int val ) = 0;
|
|
virtual HRESULT __stdcall get_UpdateRate (
|
|
/*[out,retval]*/ double * val ) = 0;
|
|
virtual HRESULT __stdcall put_UpdateRate (
|
|
/*[in]*/ double val ) = 0;
|
|
virtual HRESULT __stdcall raw_SetDarkFrame (
|
|
/*[in]*/ struct ILImage * image,
|
|
/*[out,retval]*/ enum LPVErrorCode * error ) = 0;
|
|
virtual HRESULT __stdcall raw_Train (
|
|
/*[in]*/ struct ILImage * image,
|
|
/*[in]*/ struct ILRegion * region,
|
|
/*[out,retval]*/ enum LPVErrorCode * error ) = 0;
|
|
virtual HRESULT __stdcall raw_FixImage (
|
|
/*[in]*/ struct ILImage * image,
|
|
/*[out]*/ struct ILImage * fixedImage,
|
|
/*[out,retval]*/ enum LPVErrorCode * error ) = 0;
|
|
virtual HRESULT __stdcall raw_GetFlatField (
|
|
/*[out]*/ struct ILImage * previewImage ) = 0;
|
|
};
|
|
|
|
struct __declspec(uuid("3ae96217-669c-40ea-9e3d-6c1d21235d9e"))
|
|
LCalibNPoints;
|
|
// [ default ] interface ILCalibNPoints
|
|
|
|
struct __declspec(uuid("3aeb3fed-4469-4c2d-acc4-b287d6d52327"))
|
|
LCalibPinHole;
|
|
// [ default ] interface ILCalibPinHole
|
|
|
|
struct __declspec(uuid("c3c2be54-c24e-4cca-86a0-f6ee5c24221a"))
|
|
LCalibFFD;
|
|
// [ default ] interface ILCalibFFD
|
|
|
|
struct __declspec(uuid("fda3eff1-0282-4f37-a048-d3eb64d8c228"))
|
|
LCalibCustom;
|
|
// [ default ] interface ILCalibCustom
|
|
|
|
struct __declspec(uuid("99a5fb19-790e-4f08-aeb8-9216ac036b78"))
|
|
LCalibBoard;
|
|
// [ default ] interface ILCalibBoard
|
|
|
|
struct __declspec(uuid("7d980a53-f1bb-45fa-b33d-5a76581a8ed5"))
|
|
LCalibPointPairs;
|
|
// [ default ] interface ILCalibPointPairs
|
|
// interface ILDrawable
|
|
|
|
struct __declspec(uuid("79b9bf40-288e-47dd-860c-e98a4be692c1"))
|
|
LCalibRotation;
|
|
// [ default ] interface ILCalibRotation
|
|
|
|
struct __declspec(uuid("21898120-3c29-44ba-8573-40a7e55a2f82"))
|
|
LCameraArray;
|
|
// [ default ] interface ILCameraArray
|
|
|
|
struct __declspec(uuid("75b13e3e-25be-4e3c-8820-d2606b9ab865"))
|
|
LFlatField;
|
|
// [ default ] interface ILFlatField
|
|
|
|
//
|
|
// Wrapper method implementations
|
|
//
|
|
|
|
#include "d:\git\hzleaper\smokebox\tpvs17\smokeboxidentification\x64\release\lpvCalib.tli"
|
|
|
|
#pragma pack(pop)
|