// Created by Microsoft (R) C/C++ Compiler Version 14.16.27051.0 (656e3eff).
//
// d:\code\logistics\smokeboxidentification\tpvs17\smokeboxidentification\x64\release\lpvImgProc.tlh
//
// C++ source equivalent of Win32 type library 29c8366a-f227-4cc4-bdbb-b32397056cf5
// compiler-generated file created 01/03/24 at 16:59:27 - DO NOT EDIT!

//
// Cross-referenced type libraries:
//
//

#pragma once
#pragma pack(push, 8)

#include <comdef.h>

//
// Forward references and typedefs
//

struct __declspec(uuid("29c8366a-f227-4cc4-bdbb-b32397056cf5"))
/* LIBID */ __LPVImgProcLib;
struct __declspec(uuid("8d2d4809-12dc-43f5-a8db-6e019f30aaf6"))
/* dual interface */ ILImageThreshold;
struct __declspec(uuid("eae8f218-93d3-46dc-bd33-33094226d93e"))
/* dual interface */ ILImageFilter;
struct __declspec(uuid("3c452435-77ac-4c17-98b0-30a89b050ef7"))
/* dual interface */ ILImageMorph;
struct __declspec(uuid("6b2fa65f-b23d-426a-a8c6-6605a161eee8"))
/* dual interface */ ILEdgeFilter;
struct __declspec(uuid("051e5237-6993-40f2-93e4-9bee5aab498d"))
/* dual interface */ ILImageArithm;
struct __declspec(uuid("2ff1a6a0-eefb-422e-a1f6-e0d4d7c7b548"))
/* dual interface */ ILHistogram;
struct __declspec(uuid("f16695d2-7be5-4643-beac-04770f17c8a0"))
/* dual interface */ ILImageStats;
struct __declspec(uuid("4955c40c-3bd2-40f4-90bb-d89ae0d29493"))
/* dual interface */ ILHDR;
struct __declspec(uuid("9a7e60dc-393b-442f-95ba-c8fc96ad4e0f"))
/* dual interface */ ILImageConvert;
struct __declspec(uuid("80eb7211-94e1-49ce-8d71-7587c068fc0c"))
/* dual interface */ ILBGSubtract;
struct /* coclass */ LImageThreshold;
struct /* coclass */ LImageFilter;
struct /* coclass */ LImageMorph;
struct /* coclass */ LEdgeFilter;
struct /* coclass */ LImageArithm;
struct /* coclass */ LHistogram;
struct /* coclass */ LImageStats;
struct /* coclass */ LHDR;
struct /* coclass */ LImageConvert;
struct /* coclass */ LBGSubtract;

//
// Smart pointer typedef declarations
//

_COM_SMARTPTR_TYPEDEF(ILImageThreshold, __uuidof(ILImageThreshold));
_COM_SMARTPTR_TYPEDEF(ILImageFilter, __uuidof(ILImageFilter));
_COM_SMARTPTR_TYPEDEF(ILImageMorph, __uuidof(ILImageMorph));
_COM_SMARTPTR_TYPEDEF(ILEdgeFilter, __uuidof(ILEdgeFilter));
_COM_SMARTPTR_TYPEDEF(ILImageArithm, __uuidof(ILImageArithm));
_COM_SMARTPTR_TYPEDEF(ILHistogram, __uuidof(ILHistogram));
_COM_SMARTPTR_TYPEDEF(ILImageStats, __uuidof(ILImageStats));
_COM_SMARTPTR_TYPEDEF(ILHDR, __uuidof(ILHDR));
_COM_SMARTPTR_TYPEDEF(ILImageConvert, __uuidof(ILImageConvert));
_COM_SMARTPTR_TYPEDEF(ILBGSubtract, __uuidof(ILBGSubtract));

//
// Type library items
//

struct __declspec(uuid("8d2d4809-12dc-43f5-a8db-6e019f30aaf6"))
ILImageThreshold : ILObject
{
    //
    // Property data
    //

    __declspec(property(get=GetThresholdType))
    enum LPVThresholdType ThresholdType;
    __declspec(property(get=GetThresholdLB))
    int ThresholdLB;
    __declspec(property(get=GetThresholdUB))
    int ThresholdUB;
    __declspec(property(get=GetThresholdLBBias))
    int ThresholdLBBias;
    __declspec(property(get=GetThresholdUBBias))
    int ThresholdUBBias;
    __declspec(property(get=GetLocalBlockWidth))
    int LocalBlockWidth;
    __declspec(property(get=GetLocalBlockHeight))
    int LocalBlockHeight;

    //
    // Wrapper methods for error-handling
    //

    HRESULT SetThreshold (
        int lb,
        int ub );
    HRESULT SetThresholdAdaptGlobal (
        int lbBias,
        int ubBias );
    HRESULT SetThresholdAdaptLocal (
        int blockWidth,
        int blockHeight,
        int lbBias,
        int ubBias );
    HRESULT Binarize (
        struct ILImage * img,
        struct ILImage * result );
    HRESULT ThresholdDistance (
        struct ILImage * img,
        struct ILImage * result );
    HRESULT Clip (
        struct ILImage * img,
        struct ILImage * result );
    HRESULT Stretch (
        struct ILImage * img,
        struct ILImage * result );
    enum LPVThresholdType GetThresholdType ( );
    int GetThresholdLB ( );
    int GetThresholdUB ( );
    int GetThresholdLBBias ( );
    int GetThresholdUBBias ( );
    int GetLocalBlockWidth ( );
    int GetLocalBlockHeight ( );

    //
    // Raw methods provided by interface
    //

      virtual HRESULT __stdcall raw_SetThreshold (
        /*[in]*/ int lb,
        /*[in]*/ int ub ) = 0;
      virtual HRESULT __stdcall raw_SetThresholdAdaptGlobal (
        /*[in]*/ int lbBias,
        /*[in]*/ int ubBias ) = 0;
      virtual HRESULT __stdcall raw_SetThresholdAdaptLocal (
        /*[in]*/ int blockWidth,
        /*[in]*/ int blockHeight,
        /*[in]*/ int lbBias,
        /*[in]*/ int ubBias ) = 0;
      virtual HRESULT __stdcall raw_Binarize (
        /*[in]*/ struct ILImage * img,
        /*[out]*/ struct ILImage * result ) = 0;
      virtual HRESULT __stdcall raw_ThresholdDistance (
        /*[in]*/ struct ILImage * img,
        /*[out]*/ struct ILImage * result ) = 0;
      virtual HRESULT __stdcall raw_Clip (
        /*[in]*/ struct ILImage * img,
        /*[out]*/ struct ILImage * result ) = 0;
      virtual HRESULT __stdcall raw_Stretch (
        /*[in]*/ struct ILImage * img,
        /*[out]*/ struct ILImage * result ) = 0;
      virtual HRESULT __stdcall get_ThresholdType (
        /*[out,retval]*/ enum LPVThresholdType * val ) = 0;
      virtual HRESULT __stdcall get_ThresholdLB (
        /*[out,retval]*/ int * val ) = 0;
      virtual HRESULT __stdcall get_ThresholdUB (
        /*[out,retval]*/ int * val ) = 0;
      virtual HRESULT __stdcall get_ThresholdLBBias (
        /*[out,retval]*/ int * val ) = 0;
      virtual HRESULT __stdcall get_ThresholdUBBias (
        /*[out,retval]*/ int * val ) = 0;
      virtual HRESULT __stdcall get_LocalBlockWidth (
        /*[out,retval]*/ int * val ) = 0;
      virtual HRESULT __stdcall get_LocalBlockHeight (
        /*[out,retval]*/ int * val ) = 0;
};

struct __declspec(uuid("eae8f218-93d3-46dc-bd33-33094226d93e"))
ILImageFilter : ILObject
{
    //
    // Property data
    //

    __declspec(property(get=GetKernelWidth))
    int KernelWidth;
    __declspec(property(get=GetKernelHeight))
    int KernelHeight;
    __declspec(property(get=GetKernelSigma))
    double KernelSigma;
    __declspec(property(get=GetKernelGain))
    double KernelGain;

    //
    // Wrapper methods for error-handling
    //

    HRESULT SetKernelSize (
        int kWidth,
        int kHeight );
    HRESULT SetKernelSigma (
        double kSigma,
        double kGain );
    HRESULT Equalize (
        struct ILImage * img,
        struct ILImage * result );
    HRESULT HighPass (
        struct ILImage * img,
        struct ILImage * result );
    HRESULT Gaussian (
        struct ILImage * img,
        struct ILImage * result );
    HRESULT LocalMedian (
        struct ILImage * img,
        struct ILImage * result );
    HRESULT LocalMedianNorm (
        struct ILImage * img,
        struct ILImage * result );
    HRESULT OpticalDensity (
        struct ILImage * img,
        struct ILImage * result );
    HRESULT MeanFilter (
        struct ILImage * img,
        struct ILImage * result );
    int GetKernelWidth ( );
    int GetKernelHeight ( );
    HRESULT Sharpen (
        struct ILImage * img,
        struct ILImage * result );
    double GetKernelSigma ( );
    double GetKernelGain ( );

    //
    // Raw methods provided by interface
    //

      virtual HRESULT __stdcall raw_SetKernelSize (
        /*[in]*/ int kWidth,
        /*[in]*/ int kHeight ) = 0;
      virtual HRESULT __stdcall raw_SetKernelSigma (
        /*[in]*/ double kSigma,
        /*[in]*/ double kGain ) = 0;
      virtual HRESULT __stdcall raw_Equalize (
        /*[in]*/ struct ILImage * img,
        /*[out]*/ struct ILImage * result ) = 0;
      virtual HRESULT __stdcall raw_HighPass (
        /*[in]*/ struct ILImage * img,
        /*[out]*/ struct ILImage * result ) = 0;
      virtual HRESULT __stdcall raw_Gaussian (
        /*[in]*/ struct ILImage * img,
        /*[out]*/ struct ILImage * result ) = 0;
      virtual HRESULT __stdcall raw_LocalMedian (
        /*[in]*/ struct ILImage * img,
        /*[out]*/ struct ILImage * result ) = 0;
      virtual HRESULT __stdcall raw_LocalMedianNorm (
        /*[in]*/ struct ILImage * img,
        /*[out]*/ struct ILImage * result ) = 0;
      virtual HRESULT __stdcall raw_OpticalDensity (
        /*[in]*/ struct ILImage * img,
        /*[out]*/ struct ILImage * result ) = 0;
      virtual HRESULT __stdcall raw_MeanFilter (
        /*[in]*/ struct ILImage * img,
        /*[out]*/ struct ILImage * result ) = 0;
      virtual HRESULT __stdcall get_KernelWidth (
        /*[out,retval]*/ int * val ) = 0;
      virtual HRESULT __stdcall get_KernelHeight (
        /*[out,retval]*/ int * val ) = 0;
      virtual HRESULT __stdcall raw_Sharpen (
        /*[in]*/ struct ILImage * img,
        /*[out]*/ struct ILImage * result ) = 0;
      virtual HRESULT __stdcall get_KernelSigma (
        /*[out,retval]*/ double * val ) = 0;
      virtual HRESULT __stdcall get_KernelGain (
        /*[out,retval]*/ double * val ) = 0;
};

struct __declspec(uuid("3c452435-77ac-4c17-98b0-30a89b050ef7"))
ILImageMorph : ILObject
{
    //
    // Property data
    //

    __declspec(property(get=GetMorphShape))
    enum LPVMorphShape MorphShape;
    __declspec(property(get=GetMorphWidth))
    int MorphWidth;
    __declspec(property(get=GetMorphHeight))
    int MorphHeight;

    //
    // Wrapper methods for error-handling
    //

    HRESULT SetMorphShape (
        enum LPVMorphShape shape,
        int kWidth,
        int kHeight );
    HRESULT BottomHat (
        struct ILImage * img,
        struct ILImage * result );
    HRESULT TopHat (
        struct ILImage * img,
        struct ILImage * result );
    HRESULT TopBottomHat (
        struct ILImage * img,
        struct ILImage * result );
    HRESULT Close (
        struct ILImage * img,
        struct ILImage * result );
    HRESULT Open (
        struct ILImage * img,
        struct ILImage * result );
    HRESULT Dilate (
        struct ILImage * img,
        struct ILImage * result );
    HRESULT Erode (
        struct ILImage * img,
        struct ILImage * result );
    HRESULT Gradient (
        struct ILImage * img,
        struct ILImage * result );
    enum LPVMorphShape GetMorphShape ( );
    int GetMorphWidth ( );
    int GetMorphHeight ( );

    //
    // Raw methods provided by interface
    //

      virtual HRESULT __stdcall raw_SetMorphShape (
        /*[in]*/ enum LPVMorphShape shape,
        /*[in]*/ int kWidth,
        /*[in]*/ int kHeight ) = 0;
      virtual HRESULT __stdcall raw_BottomHat (
        /*[in]*/ struct ILImage * img,
        /*[out]*/ struct ILImage * result ) = 0;
      virtual HRESULT __stdcall raw_TopHat (
        /*[in]*/ struct ILImage * img,
        /*[out]*/ struct ILImage * result ) = 0;
      virtual HRESULT __stdcall raw_TopBottomHat (
        /*[in]*/ struct ILImage * img,
        /*[out]*/ struct ILImage * result ) = 0;
      virtual HRESULT __stdcall raw_Close (
        /*[in]*/ struct ILImage * img,
        /*[out]*/ struct ILImage * result ) = 0;
      virtual HRESULT __stdcall raw_Open (
        /*[in]*/ struct ILImage * img,
        /*[out]*/ struct ILImage * result ) = 0;
      virtual HRESULT __stdcall raw_Dilate (
        /*[in]*/ struct ILImage * img,
        /*[out]*/ struct ILImage * result ) = 0;
      virtual HRESULT __stdcall raw_Erode (
        /*[in]*/ struct ILImage * img,
        /*[out]*/ struct ILImage * result ) = 0;
      virtual HRESULT __stdcall raw_Gradient (
        /*[in]*/ struct ILImage * img,
        /*[out]*/ struct ILImage * result ) = 0;
      virtual HRESULT __stdcall get_MorphShape (
        /*[out,retval]*/ enum LPVMorphShape * shape ) = 0;
      virtual HRESULT __stdcall get_MorphWidth (
        /*[out,retval]*/ int * val ) = 0;
      virtual HRESULT __stdcall get_MorphHeight (
        /*[out,retval]*/ int * val ) = 0;
};

struct __declspec(uuid("6b2fa65f-b23d-426a-a8c6-6605a161eee8"))
ILEdgeFilter : ILObject
{
    //
    // Property data
    //

    __declspec(property(get=GetKernelType))
    enum LPVEdgeKernel KernelType;
    __declspec(property(get=GetKernelWidth))
    int KernelWidth;
    __declspec(property(get=GetKernelHeight))
    int KernelHeight;
    __declspec(property(get=GetEdgePolarityX))
    enum LPVPolarity EdgePolarityX;
    __declspec(property(get=GetEdgePolarityY))
    enum LPVPolarity EdgePolarityY;

    //
    // Wrapper methods for error-handling
    //

    HRESULT SetEdgeKernel (
        enum LPVEdgeKernel kType,
        int kWidth,
        int kHeight );
    HRESULT SetEdgePolarity (
        enum LPVPolarity xPolarity,
        enum LPVPolarity yPolarity );
    HRESULT GradientH (
        struct ILImage * img,
        struct ILImage * result );
    HRESULT GradientV (
        struct ILImage * img,
        struct ILImage * result );
    HRESULT GradientFull (
        struct ILImage * img,
        struct ILImage * result );
    enum LPVEdgeKernel GetKernelType ( );
    int GetKernelWidth ( );
    int GetKernelHeight ( );
    enum LPVPolarity GetEdgePolarityX ( );
    enum LPVPolarity GetEdgePolarityY ( );

    //
    // Raw methods provided by interface
    //

      virtual HRESULT __stdcall raw_SetEdgeKernel (
        /*[in]*/ enum LPVEdgeKernel kType,
        /*[in]*/ int kWidth,
        /*[in]*/ int kHeight ) = 0;
      virtual HRESULT __stdcall raw_SetEdgePolarity (
        /*[in]*/ enum LPVPolarity xPolarity,
        /*[in]*/ enum LPVPolarity yPolarity ) = 0;
      virtual HRESULT __stdcall raw_GradientH (
        /*[in]*/ struct ILImage * img,
        /*[out]*/ struct ILImage * result ) = 0;
      virtual HRESULT __stdcall raw_GradientV (
        /*[in]*/ struct ILImage * img,
        /*[out]*/ struct ILImage * result ) = 0;
      virtual HRESULT __stdcall raw_GradientFull (
        /*[in]*/ struct ILImage * img,
        /*[out]*/ struct ILImage * result ) = 0;
      virtual HRESULT __stdcall get_KernelType (
        /*[out,retval]*/ enum LPVEdgeKernel * kType ) = 0;
      virtual HRESULT __stdcall get_KernelWidth (
        /*[out,retval]*/ int * val ) = 0;
      virtual HRESULT __stdcall get_KernelHeight (
        /*[out,retval]*/ int * val ) = 0;
      virtual HRESULT __stdcall get_EdgePolarityX (
        /*[out,retval]*/ enum LPVPolarity * val ) = 0;
      virtual HRESULT __stdcall get_EdgePolarityY (
        /*[out,retval]*/ enum LPVPolarity * val ) = 0;
};

struct __declspec(uuid("051e5237-6993-40f2-93e4-9bee5aab498d"))
ILImageArithm : IDispatch
{
    //
    // Property data
    //

    __declspec(property(get=GetResultGain,put=PutResultGain))
    double ResultGain;
    __declspec(property(get=GetResultOffset,put=PutResultOffset))
    double ResultOffset;
    __declspec(property(get=GetBGColor,put=PutBGColor))
    struct LColor BGColor;

    //
    // Wrapper methods for error-handling
    //

    HRESULT Invert (
        struct ILImage * img,
        struct ILImage * result );
    HRESULT GainOffset (
        struct ILImage * img,
        struct ILImage * result,
        double gain,
        double offset );
    HRESULT Add (
        struct ILImage * img1,
        struct ILImage * img2,
        struct ILImage * result );
    HRESULT AddWeighted (
        struct ILImage * img1,
        struct ILImage * img2,
        double alpha,
        double beta,
        struct ILImage * result );
    HRESULT Sub (
        struct ILImage * img1,
        struct ILImage * img2,
        struct ILImage * result );
    HRESULT Multiply (
        struct ILImage * img1,
        struct ILImage * img2,
        struct ILImage * result );
    HRESULT Divide (
        struct ILImage * img1,
        struct ILImage * img2,
        struct ILImage * result );
    HRESULT Diff (
        struct ILImage * img1,
        struct ILImage * img2,
        struct ILImage * result );
    HRESULT Min (
        struct ILImage * img1,
        struct ILImage * img2,
        struct ILImage * result );
    HRESULT Max (
        struct ILImage * img1,
        struct ILImage * img2,
        struct ILImage * result );
    HRESULT Pow (
        struct ILImage * img,
        double power,
        struct ILImage * result );
    HRESULT Log (
        struct ILImage * img,
        double base,
        struct ILImage * result );
    HRESULT Flip (
        struct ILImage * img,
        enum LPVFlipType flipType,
        struct ILImage * result );
    HRESULT Rotate (
        struct ILImage * img,
        double angle,
        enum LPVInterpolationMethod interMethod,
        struct ILImage * result );
    HRESULT Resize (
        struct ILImage * img,
        double zoomX,
        double zoomY,
        enum LPVInterpolationMethod interMethod,
        struct ILImage * result );
    HRESULT ResizeTo (
        struct ILImage * img,
        int w,
        int h,
        enum LPVInterpolationMethod interMethod,
        struct ILImage * result );
    HRESULT ScaleRotate (
        struct ILImage * img,
        double angle,
        double zoomX,
        double zoomY,
        double pivotImgX,
        double pivotImgY,
        double pivotResultX,
        double pivotResultY,
        enum LPVInterpolationMethod interMethod,
        struct ILImage * result );
    HRESULT Transform (
        struct ILImage * img,
        struct ILTransform * tf,
        enum LPVInterpolationMethod interMethod,
        struct ILImage * result );
    HRESULT Blend (
        struct ILImageList * imgList,
        enum LPVAggregation aggType,
        struct ILImage * result );
    SAFEARRAY * ProjectX (
        struct ILImage * img,
        enum LPVAggregation aggType );
    SAFEARRAY * ProjectY (
        struct ILImage * img,
        enum LPVAggregation aggType );
    double GetResultGain ( );
    void PutResultGain (
        double val );
    double GetResultOffset ( );
    void PutResultOffset (
        double val );
    HRESULT TileX (
        struct ILImageList * imgList,
        int columnCount,
        VARIANT_BOOL compactMode,
        struct ILImage * result );
    HRESULT TileY (
        struct ILImageList * imgList,
        int rowCount,
        VARIANT_BOOL compactMode,
        struct ILImage * result );
    struct LColor GetBGColor ( );
    void PutBGColor (
        struct LColor val );

    //
    // Raw methods provided by interface
    //

      virtual HRESULT __stdcall raw_Invert (
        /*[in]*/ struct ILImage * img,
        /*[out]*/ struct ILImage * result ) = 0;
      virtual HRESULT __stdcall raw_GainOffset (
        /*[in]*/ struct ILImage * img,
        /*[out]*/ struct ILImage * result,
        /*[in]*/ double gain,
        /*[in]*/ double offset ) = 0;
      virtual HRESULT __stdcall raw_Add (
        /*[in]*/ struct ILImage * img1,
        /*[in]*/ struct ILImage * img2,
        /*[out]*/ struct ILImage * result ) = 0;
      virtual HRESULT __stdcall raw_AddWeighted (
        /*[in]*/ struct ILImage * img1,
        /*[in]*/ struct ILImage * img2,
        /*[in]*/ double alpha,
        /*[in]*/ double beta,
        /*[out]*/ struct ILImage * result ) = 0;
      virtual HRESULT __stdcall raw_Sub (
        /*[in]*/ struct ILImage * img1,
        /*[in]*/ struct ILImage * img2,
        /*[out]*/ struct ILImage * result ) = 0;
      virtual HRESULT __stdcall raw_Multiply (
        /*[in]*/ struct ILImage * img1,
        /*[in]*/ struct ILImage * img2,
        /*[out]*/ struct ILImage * result ) = 0;
      virtual HRESULT __stdcall raw_Divide (
        /*[in]*/ struct ILImage * img1,
        /*[in]*/ struct ILImage * img2,
        /*[out]*/ struct ILImage * result ) = 0;
      virtual HRESULT __stdcall raw_Diff (
        /*[in]*/ struct ILImage * img1,
        /*[in]*/ struct ILImage * img2,
        /*[out]*/ struct ILImage * result ) = 0;
      virtual HRESULT __stdcall raw_Min (
        /*[in]*/ struct ILImage * img1,
        /*[in]*/ struct ILImage * img2,
        /*[out]*/ struct ILImage * result ) = 0;
      virtual HRESULT __stdcall raw_Max (
        /*[in]*/ struct ILImage * img1,
        /*[in]*/ struct ILImage * img2,
        /*[out]*/ struct ILImage * result ) = 0;
      virtual HRESULT __stdcall raw_Pow (
        /*[in]*/ struct ILImage * img,
        /*[in]*/ double power,
        /*[out]*/ struct ILImage * result ) = 0;
      virtual HRESULT __stdcall raw_Log (
        /*[in]*/ struct ILImage * img,
        /*[in]*/ double base,
        /*[out]*/ struct ILImage * result ) = 0;
      virtual HRESULT __stdcall raw_Flip (
        /*[in]*/ struct ILImage * img,
        /*[in]*/ enum LPVFlipType flipType,
        /*[out]*/ struct ILImage * result ) = 0;
      virtual HRESULT __stdcall raw_Rotate (
        /*[in]*/ struct ILImage * img,
        /*[in]*/ double angle,
        /*[in]*/ enum LPVInterpolationMethod interMethod,
        /*[out]*/ struct ILImage * result ) = 0;
      virtual HRESULT __stdcall raw_Resize (
        /*[in]*/ struct ILImage * img,
        /*[in]*/ double zoomX,
        /*[in]*/ double zoomY,
        /*[in]*/ enum LPVInterpolationMethod interMethod,
        /*[out]*/ struct ILImage * result ) = 0;
      virtual HRESULT __stdcall raw_ResizeTo (
        /*[in]*/ struct ILImage * img,
        /*[in]*/ int w,
        /*[in]*/ int h,
        /*[in]*/ enum LPVInterpolationMethod interMethod,
        /*[out]*/ struct ILImage * result ) = 0;
      virtual HRESULT __stdcall raw_ScaleRotate (
        /*[in]*/ struct ILImage * img,
        /*[in]*/ double angle,
        /*[in]*/ double zoomX,
        /*[in]*/ double zoomY,
        /*[in]*/ double pivotImgX,
        /*[in]*/ double pivotImgY,
        /*[in]*/ double pivotResultX,
        /*[in]*/ double pivotResultY,
        /*[in]*/ enum LPVInterpolationMethod interMethod,
        /*[out]*/ struct ILImage * result ) = 0;
      virtual HRESULT __stdcall raw_Transform (
        /*[in]*/ struct ILImage * img,
        /*[in]*/ struct ILTransform * tf,
        /*[in]*/ enum LPVInterpolationMethod interMethod,
        /*[out]*/ struct ILImage * result ) = 0;
      virtual HRESULT __stdcall raw_Blend (
        /*[in]*/ struct ILImageList * imgList,
        /*[in]*/ enum LPVAggregation aggType,
        /*[out]*/ struct ILImage * result ) = 0;
      virtual HRESULT __stdcall raw_ProjectX (
        /*[in]*/ struct ILImage * img,
        /*[in]*/ enum LPVAggregation aggType,
        /*[out,retval]*/ SAFEARRAY * * result ) = 0;
      virtual HRESULT __stdcall raw_ProjectY (
        /*[in]*/ struct ILImage * img,
        /*[in]*/ enum LPVAggregation aggType,
        /*[out,retval]*/ SAFEARRAY * * result ) = 0;
      virtual HRESULT __stdcall get_ResultGain (
        /*[out,retval]*/ double * val ) = 0;
      virtual HRESULT __stdcall put_ResultGain (
        /*[in]*/ double val ) = 0;
      virtual HRESULT __stdcall get_ResultOffset (
        /*[out,retval]*/ double * val ) = 0;
      virtual HRESULT __stdcall put_ResultOffset (
        /*[in]*/ double val ) = 0;
      virtual HRESULT __stdcall raw_TileX (
        /*[in]*/ struct ILImageList * imgList,
        /*[in]*/ int columnCount,
        /*[in]*/ VARIANT_BOOL compactMode,
        /*[out]*/ struct ILImage * result ) = 0;
      virtual HRESULT __stdcall raw_TileY (
        /*[in]*/ struct ILImageList * imgList,
        /*[in]*/ int rowCount,
        /*[in]*/ VARIANT_BOOL compactMode,
        /*[out]*/ struct ILImage * result ) = 0;
      virtual HRESULT __stdcall get_BGColor (
        /*[out,retval]*/ struct LColor * val ) = 0;
      virtual HRESULT __stdcall put_BGColor (
        /*[in]*/ struct LColor val ) = 0;
};

struct __declspec(uuid("2ff1a6a0-eefb-422e-a1f6-e0d4d7c7b548"))
ILHistogram : IDispatch
{
    //
    // Wrapper methods for error-handling
    //

    HRESULT Reset ( );
    HRESULT Build (
        struct ILImage * img,
        struct ILRegion * region,
        int binCount,
        int lowerBound,
        int upperBound );
    double Item (
        int index );
    HRESULT MinMax (
        int * minIdx,
        double * minValue,
        int * maxIdx,
        double * maxValue );
    HRESULT MeanStdDev (
        double * meanValue,
        double * stdDevValue );
    HRESULT Draw (
        void * hdc,
        enum LPVChartDrawFlags drawFlags,
        int xGridStep,
        int yGridStep );
    HRESULT BuildFromDataVec (
        SAFEARRAY * dataVec,
        int binCount,
        double lowerBound,
        double upperBound );

    //
    // Raw methods provided by interface
    //

      virtual HRESULT __stdcall raw_Reset ( ) = 0;
      virtual HRESULT __stdcall raw_Build (
        /*[in]*/ struct ILImage * img,
        /*[in]*/ struct ILRegion * region,
        /*[in]*/ int binCount,
        /*[in]*/ int lowerBound,
        /*[in]*/ int upperBound ) = 0;
      virtual HRESULT __stdcall raw_Item (
        /*[in]*/ int index,
        /*[out,retval]*/ double * value ) = 0;
      virtual HRESULT __stdcall raw_MinMax (
        /*[out]*/ int * minIdx,
        /*[out]*/ double * minValue,
        /*[out]*/ int * maxIdx,
        /*[out]*/ double * maxValue ) = 0;
      virtual HRESULT __stdcall raw_MeanStdDev (
        /*[out]*/ double * meanValue,
        /*[out]*/ double * stdDevValue ) = 0;
      virtual HRESULT __stdcall raw_Draw (
        /*[in]*/ void * hdc,
        /*[in]*/ enum LPVChartDrawFlags drawFlags,
        /*[in]*/ int xGridStep,
        /*[in]*/ int yGridStep ) = 0;
      virtual HRESULT __stdcall raw_BuildFromDataVec (
        /*[in]*/ SAFEARRAY * dataVec,
        /*[in]*/ int binCount,
        /*[in]*/ double lowerBound,
        /*[in]*/ double upperBound ) = 0;
};

struct __declspec(uuid("f16695d2-7be5-4643-beac-04770f17c8a0"))
ILImageStats : IDispatch
{
    //
    // Wrapper methods for error-handling
    //

    HRESULT Min (
        struct ILImage * img,
        struct ILRegion * region,
        int * value,
        int * posX,
        int * posY );
    HRESULT Max (
        struct ILImage * img,
        struct ILRegion * region,
        int * value,
        int * posX,
        int * posY );
    HRESULT MeanStdDev (
        struct ILImage * img,
        struct ILRegion * region,
        double * meanValue,
        double * stdDevValue );
    HRESULT CountPixel (
        struct ILImage * img,
        struct ILRegion * region,
        int lb,
        int ub,
        int * belowCount,
        int * betweenCount,
        int * aboveCount );
    HRESULT CountPixelColor (
        struct ILImage * img,
        struct ILRegion * region,
        struct LColor lb,
        struct LColor ub,
        int * betweenCount,
        int * outsideCount );
    double Sharpness (
        struct ILImage * img,
        struct ILRegion * region );

    //
    // Raw methods provided by interface
    //

      virtual HRESULT __stdcall raw_Min (
        /*[in]*/ struct ILImage * img,
        /*[in]*/ struct ILRegion * region,
        /*[out]*/ int * value,
        /*[out]*/ int * posX,
        /*[out]*/ int * posY ) = 0;
      virtual HRESULT __stdcall raw_Max (
        /*[in]*/ struct ILImage * img,
        /*[in]*/ struct ILRegion * region,
        /*[out]*/ int * value,
        /*[out]*/ int * posX,
        /*[out]*/ int * posY ) = 0;
      virtual HRESULT __stdcall raw_MeanStdDev (
        /*[in]*/ struct ILImage * img,
        /*[in]*/ struct ILRegion * region,
        /*[out]*/ double * meanValue,
        /*[out]*/ double * stdDevValue ) = 0;
      virtual HRESULT __stdcall raw_CountPixel (
        /*[in]*/ struct ILImage * img,
        /*[in]*/ struct ILRegion * region,
        /*[in]*/ int lb,
        /*[in]*/ int ub,
        /*[out]*/ int * belowCount,
        /*[out]*/ int * betweenCount,
        /*[out]*/ int * aboveCount ) = 0;
      virtual HRESULT __stdcall raw_CountPixelColor (
        /*[in]*/ struct ILImage * img,
        /*[in]*/ struct ILRegion * region,
        /*[in]*/ struct LColor lb,
        /*[in]*/ struct LColor ub,
        /*[out]*/ int * betweenCount,
        /*[out]*/ int * outsideCount ) = 0;
      virtual HRESULT __stdcall raw_Sharpness (
        /*[in]*/ struct ILImage * img,
        /*[in]*/ struct ILRegion * region,
        /*[out,retval]*/ double * value ) = 0;
};

struct __declspec(uuid("4955c40c-3bd2-40f4-90bb-d89ae0d29493"))
ILHDR : IDispatch
{
    //
    // Wrapper methods for error-handling
    //

    HRESULT Reset ( );
    enum LPVErrorCode BuildCRF (
        struct ILImageList * imgList,
        SAFEARRAY * exposureTimes );
    HRESULT ToneMapping (
        struct ILImageList * imgList,
        struct ILImage * result,
        double gamma,
        double contrastEnhance,
        double saturationEnhance );
    HRESULT ExposureFusion (
        struct ILImageList * imgList,
        struct ILImage * result,
        double contrastWeight,
        double saturationWeight,
        double exposureWeight );

    //
    // Raw methods provided by interface
    //

      virtual HRESULT __stdcall raw_Reset ( ) = 0;
      virtual HRESULT __stdcall raw_BuildCRF (
        /*[in]*/ struct ILImageList * imgList,
        /*[in]*/ SAFEARRAY * exposureTimes,
        /*[out,retval]*/ enum LPVErrorCode * error ) = 0;
      virtual HRESULT __stdcall raw_ToneMapping (
        /*[in]*/ struct ILImageList * imgList,
        /*[out]*/ struct ILImage * result,
        /*[in]*/ double gamma,
        /*[in]*/ double contrastEnhance,
        /*[in]*/ double saturationEnhance ) = 0;
      virtual HRESULT __stdcall raw_ExposureFusion (
        /*[in]*/ struct ILImageList * imgList,
        /*[out]*/ struct ILImage * result,
        /*[in]*/ double contrastWeight,
        /*[in]*/ double saturationWeight,
        /*[in]*/ double exposureWeight ) = 0;
};

struct __declspec(uuid("9a7e60dc-393b-442f-95ba-c8fc96ad4e0f"))
ILImageConvert : IDispatch
{
    //
    // Wrapper methods for error-handling
    //

    HRESULT BGRToGray (
        struct ILImage * bgrImg,
        struct ILImage * grayImg );
    int BGRToGrayColor (
        struct LColor bgrColor );
    HRESULT GrayToBGR (
        struct ILImage * grayImg,
        struct ILImage * bgrImg );
    struct LColor GrayToBGRColor (
        int grayColor );
    HRESULT Convert (
        enum LPVColorSpace fromColorSpace,
        enum LPVColorSpace toColorSpace,
        struct ILImage * srcColorImg,
        struct ILImage * dstColorImg );
    struct LColor ConvertColor (
        enum LPVColorSpace fromColorSpace,
        enum LPVColorSpace toColorSpace,
        struct LColor srcColor );
    HRESULT BGRMix (
        struct ILImage * bgrImg,
        double w0,
        double w1,
        double w2,
        struct ILImage * grayImg );

    //
    // Raw methods provided by interface
    //

      virtual HRESULT __stdcall raw_BGRToGray (
        /*[in]*/ struct ILImage * bgrImg,
        /*[out]*/ struct ILImage * grayImg ) = 0;
      virtual HRESULT __stdcall raw_BGRToGrayColor (
        /*[in]*/ struct LColor bgrColor,
        /*[out,retval]*/ int * grayColor ) = 0;
      virtual HRESULT __stdcall raw_GrayToBGR (
        /*[in]*/ struct ILImage * grayImg,
        /*[out]*/ struct ILImage * bgrImg ) = 0;
      virtual HRESULT __stdcall raw_GrayToBGRColor (
        /*[in]*/ int grayColor,
        /*[out,retval]*/ struct LColor * bgrColor ) = 0;
      virtual HRESULT __stdcall raw_Convert (
        /*[in]*/ enum LPVColorSpace fromColorSpace,
        /*[in]*/ enum LPVColorSpace toColorSpace,
        /*[in]*/ struct ILImage * srcColorImg,
        /*[out]*/ struct ILImage * dstColorImg ) = 0;
      virtual HRESULT __stdcall raw_ConvertColor (
        /*[in]*/ enum LPVColorSpace fromColorSpace,
        /*[in]*/ enum LPVColorSpace toColorSpace,
        /*[in]*/ struct LColor srcColor,
        /*[out,retval]*/ struct LColor * dstColor ) = 0;
      virtual HRESULT __stdcall raw_BGRMix (
        /*[in]*/ struct ILImage * bgrImg,
        /*[in]*/ double w0,
        /*[in]*/ double w1,
        /*[in]*/ double w2,
        /*[out]*/ struct ILImage * grayImg ) = 0;
};

struct __declspec(uuid("80eb7211-94e1-49ce-8d71-7587c068fc0c"))
ILBGSubtract : IDispatch
{
    //
    // Property data
    //

    __declspec(property(get=GetHistoryMaxCount,put=PutHistoryMaxCount))
    int HistoryMaxCount;
    __declspec(property(get=GetVarianceThreshold,put=PutVarianceThreshold))
    double VarianceThreshold;
    __declspec(property(get=GetGenerateThreshold,put=PutGenerateThreshold))
    double GenerateThreshold;
    __declspec(property(get=GetLearningRate,put=PutLearningRate))
    double LearningRate;

    //
    // Wrapper methods for error-handling
    //

    HRESULT Reset ( );
    int GetHistoryMaxCount ( );
    void PutHistoryMaxCount (
        int val );
    double GetVarianceThreshold ( );
    void PutVarianceThreshold (
        double val );
    double GetGenerateThreshold ( );
    void PutGenerateThreshold (
        double val );
    double GetLearningRate ( );
    void PutLearningRate (
        double val );
    enum LPVErrorCode Apply (
        struct ILImage * img,
        struct ILImage * fgMask,
        VARIANT_BOOL doUpdateBGModel );
    enum LPVErrorCode UpdateBGModel (
        struct ILImage * img );

    //
    // Raw methods provided by interface
    //

      virtual HRESULT __stdcall raw_Reset ( ) = 0;
      virtual HRESULT __stdcall get_HistoryMaxCount (
        /*[out,retval]*/ int * val ) = 0;
      virtual HRESULT __stdcall put_HistoryMaxCount (
        /*[in]*/ int val ) = 0;
      virtual HRESULT __stdcall get_VarianceThreshold (
        /*[out,retval]*/ double * val ) = 0;
      virtual HRESULT __stdcall put_VarianceThreshold (
        /*[in]*/ double val ) = 0;
      virtual HRESULT __stdcall get_GenerateThreshold (
        /*[out,retval]*/ double * val ) = 0;
      virtual HRESULT __stdcall put_GenerateThreshold (
        /*[in]*/ double val ) = 0;
      virtual HRESULT __stdcall get_LearningRate (
        /*[out,retval]*/ double * val ) = 0;
      virtual HRESULT __stdcall put_LearningRate (
        /*[in]*/ double val ) = 0;
      virtual HRESULT __stdcall raw_Apply (
        /*[in]*/ struct ILImage * img,
        /*[out]*/ struct ILImage * fgMask,
        /*[in]*/ VARIANT_BOOL doUpdateBGModel,
        /*[out,retval]*/ enum LPVErrorCode * error ) = 0;
      virtual HRESULT __stdcall raw_UpdateBGModel (
        /*[in]*/ struct ILImage * img,
        /*[out,retval]*/ enum LPVErrorCode * error ) = 0;
};

struct __declspec(uuid("e1a2ffe0-aa84-4837-b2f5-b6bbd7078621"))
LImageThreshold;
    // [ default ] interface ILImageThreshold

struct __declspec(uuid("b2e6c676-1cc7-4d0a-aca9-3296f308a343"))
LImageFilter;
    // [ default ] interface ILImageFilter

struct __declspec(uuid("04a79f01-1b8c-40ca-aef8-1738f776dd74"))
LImageMorph;
    // [ default ] interface ILImageMorph

struct __declspec(uuid("7d2fea77-6e13-4b55-933d-44f50fa69583"))
LEdgeFilter;
    // [ default ] interface ILEdgeFilter

struct __declspec(uuid("97ddb8e8-2edf-485e-8783-81062ebefbdd"))
LImageArithm;
    // [ default ] interface ILImageArithm

struct __declspec(uuid("6942dc51-43ba-44d2-ac99-73d97c7db049"))
LHistogram;
    // [ default ] interface ILHistogram
    // interface ILDrawable

struct __declspec(uuid("e0644288-acdf-4cce-8b1c-3304ca7d00f4"))
LImageStats;
    // [ default ] interface ILImageStats

struct __declspec(uuid("1a5ed7c4-a315-4c5f-9adc-837fbd6cdca9"))
LHDR;
    // [ default ] interface ILHDR

struct __declspec(uuid("fcdd137e-0c3f-476c-a0f0-e351d4098f75"))
LImageConvert;
    // [ default ] interface ILImageConvert

struct __declspec(uuid("77882fa2-31ce-4d12-a3e7-3f559763ce10"))
LBGSubtract;
    // [ default ] interface ILBGSubtract

//
// Wrapper method implementations
//

#include "d:\code\logistics\smokeboxidentification\tpvs17\smokeboxidentification\x64\release\lpvImgProc.tli"

#pragma pack(pop)