// Created by Microsoft (R) C/C++ Compiler Version 14.16.27050.0 (7c58e703).
//
// d:\git\hzleaper\smokebox\tpvs17\smokeboxidentification\x64\debug\lpvCalib.tlh
//
// C++ source equivalent of type library faa32948-bf4e-4482-9216-70412f34bb66
// compiler-generated file created 02/21/24 at 17:05:22 - 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\debug\lpvCalib.tli"

#pragma pack(pop)