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.
1088 lines
35 KiB
Plaintext
1088 lines
35 KiB
Plaintext
// Created by Microsoft (R) C/C++ Compiler Version 14.16.27050.0 (55c2a25e).
|
|
//
|
|
// d:\git\hzleaper\smokebox\tpvs17\smokeboxidentification\x64\release\lpvImgProc.tlh
|
|
//
|
|
// C++ source equivalent of type library 29c8366a-f227-4cc4-bdbb-b32397056cf5
|
|
// compiler-generated file created 03/05/24 at 14:34:41 - 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:\git\hzleaper\smokebox\tpvs17\smokeboxidentification\x64\release\lpvImgProc.tli"
|
|
|
|
#pragma pack(pop)
|