// ************************************************************************ //
// WARNING                                                                    
// -------                                                                    
// The types declared in this file were generated from data read from a       
// Type Library. If this type library is explicitly or indirectly (via        
// another type library referring to this type library) re-imported, or the   
// 'Refresh' command of the Type Library Editor activated while editing the   
// Type Library, the contents of this file will be regenerated and all        
// manual modifications will be lost.                                         
// ************************************************************************ //

// C++ TLBWRTR : $Revision:   1.134.1.39  $
// File generated on 6/20/2001 12:48:11 PM from Type Library described below.

// ************************************************************************ //
// Type Lib: C:\Program Files\eVision\ActiveX\evision.ocx (1)
// IID\LCID: {9AE86E03-97BC-11D1-A49B-000021633168}\0
// Helpfile: C:\Program Files\eVision\ActiveX\eVisionVB.hlp
// DepndLst: 
//   (1) v2.0 stdole, (C:\WINNT\System32\stdole2.tlb)
//   (2) v4.0 StdVCL, (C:\WINNT\System32\STDVCL40.DLL)
// ************************************************************************ //

#include <vcl.h>
#pragma hdrstop

#if defined(USING_ATL)
#include <atl\atlvcl.h>
#endif

#include "eVision_OCX.h"

#if !defined(__PRAGMA_PACKAGE_SMART_INIT)
#define      __PRAGMA_PACKAGE_SMART_INIT
#pragma package(smart_init)
#endif

namespace Evision_tlb
{



// *********************************************************************//
// OCX PROXY CLASS IMPLEMENTATION
// (The following variables/methods implement the class TEBW8Image which
// allows "EBW8Image Control" to be hosted in CBuilder IDE/apps).
// *********************************************************************//
int   TEBW8Image::EventDispIDs[1] = {
    0x00000001};

int TEBW8Image::TFontIDs[1] = {
    0x0000002E
};

TControlData TEBW8Image::CControlData =
{
  // GUID of CoClass and Event Interface of Control
  {0x9AE86E0A, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // CoClass
  {0x9AE86E09, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // Events

  // Count of Events and array of their DISPIDs
  1, &EventDispIDs,

  // Pointer to Runtime License string
  NULL,  // HRESULT(0x80004005)

  // Flags for OnChanged PropertyNotification
  0x00000000,
  300,// (IDE Version)

  // Count of Font Prop and array of their DISPIDs
  1, TFontIDs,

  // Count of Pict Prop and array of their DISPIDs
  0, NULL,
  0, // Reserved
  0, // Instance count (used internally)
  0, // List of Enum descriptions (internal)
};

GUID     TEBW8Image::DEF_CTL_INTF = {0x9AE86E08, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} };
TNoParam TEBW8Image::OptParam;

static inline void ValidCtrCheck(TEBW8Image *)
{
   delete new TEBW8Image((TComponent*)(0));
};

void __fastcall TEBW8Image::InitControlData()
{
  ControlData = &CControlData;
};

void __fastcall TEBW8Image::CreateControl()
{
  if (!m_OCXIntf)
  {
    _ASSERTE(DefaultDispatch);
    DefaultDispatch->QueryInterface(DEF_CTL_INTF, (LPVOID*)&m_OCXIntf);
  }
};

_DEBW8ImageDisp __fastcall TEBW8Image::GetDefaultInterface()
{
  CreateControl();
  return m_OCXIntf;
};

TOLEBOOL __fastcall TEBW8Image::SameSize(LPDISPATCH SrcImage)
{
  return GetDefaultInterface()->SameSize(SrcImage);
}

void __fastcall TEBW8Image::SetSize(long Width, long Height)
{
  GetDefaultInterface()->SetSize(Width, Height);
}

long __fastcall TEBW8Image::GetImagePointer(long OriginX, long OriginY)
{
  return GetDefaultInterface()->GetImagePointer(OriginX, OriginY);
}

void __fastcall TEBW8Image::SetImagePointer(long NewValue)
{
  GetDefaultInterface()->SetImagePointer(NewValue);
}

void __fastcall TEBW8Image::GetPixel(long X, long Y, short* GrayValue)
{
  GetDefaultInterface()->GetPixel(X, Y, GrayValue);
}

void __fastcall TEBW8Image::SetPixel(long X, long Y, short GrayValue)
{
  GetDefaultInterface()->SetPixel(X, Y, GrayValue);
}

TOLEBOOL __fastcall TEBW8Image::Void(void)
{
  return GetDefaultInterface()->Void();
}

void __fastcall TEBW8Image::SaveFile(BSTR FileName, Evision_tlb::enumFileFormats FileFormat)
{
  GetDefaultInterface()->SaveFile(FileName, FileFormat);
}

Evision_tlb::enumFileFormats __fastcall TEBW8Image::LoadFile(BSTR FileName)
{
  return GetDefaultInterface()->LoadFile(FileName);
}

void __fastcall TEBW8Image::Refresh(void)
{
  GetDefaultInterface()->Refresh();
}

void __fastcall TEBW8Image::DrawToDC(OLE_HANDLE hDC)
{
  GetDefaultInterface()->DrawToDC(hDC);
}

void __fastcall TEBW8Image::DrawLine(float X1, float Y1, float X2, float Y2)
{
  GetDefaultInterface()->DrawLine(X1, Y1, X2, Y2);
}

void __fastcall TEBW8Image::DrawBox(float X1, float Y1, float X2, float Y2)
{
  GetDefaultInterface()->DrawBox(X1, Y1, X2, Y2);
}

void __fastcall TEBW8Image::DrawCircle(float X, float Y, float Radius)
{
  GetDefaultInterface()->DrawCircle(X, Y, Radius);
}

void __fastcall TEBW8Image::DrawArc(float X, float Y, float Radius, float Start, float End)
{
  GetDefaultInterface()->DrawArc(X, Y, Radius, Start, End);
}

void __fastcall TEBW8Image::DrawText(long X, long Y, BSTR TextOut)
{
  GetDefaultInterface()->DrawText(X, Y, TextOut);
}

Evision_tlb::enumFileFormats __fastcall TEBW8Image::Load(BSTR FileName)
{
  return GetDefaultInterface()->Load(FileName);
}

void __fastcall TEBW8Image::Save(BSTR FileName, Evision_tlb::enumFileFormats FileFormat)
{
  GetDefaultInterface()->Save(FileName, FileFormat);
}

void __fastcall TEBW8Image::AboutBox(void)
{
  GetDefaultInterface()->AboutBox();
}

LPDISPATCH __fastcall TEBW8Image::Get_Obj()
{
  return GetDefaultInterface()->get_Obj();
}

void __fastcall TEBW8Image::Set_Obj(LPDISPATCH param)
{
  GetDefaultInterface()->set_Obj(param);
}



// *********************************************************************//
// OCX PROXY CLASS IMPLEMENTATION
// (The following variables/methods implement the class TEBW16Image which
// allows "EBW16Image Control" to be hosted in CBuilder IDE/apps).
// *********************************************************************//
int   TEBW16Image::EventDispIDs[1] = {
    0x00000001};

int TEBW16Image::TFontIDs[1] = {
    0x00000023
};

TControlData TEBW16Image::CControlData =
{
  // GUID of CoClass and Event Interface of Control
  {0x9AE86E0E, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // CoClass
  {0x9AE86E0D, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // Events

  // Count of Events and array of their DISPIDs
  1, &EventDispIDs,

  // Pointer to Runtime License string
  NULL,  // HRESULT(0x80004005)

  // Flags for OnChanged PropertyNotification
  0x00000000,
  300,// (IDE Version)

  // Count of Font Prop and array of their DISPIDs
  1, TFontIDs,

  // Count of Pict Prop and array of their DISPIDs
  0, NULL,
  0, // Reserved
  0, // Instance count (used internally)
  0, // List of Enum descriptions (internal)
};

GUID     TEBW16Image::DEF_CTL_INTF = {0x9AE86E0C, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} };
TNoParam TEBW16Image::OptParam;

static inline void ValidCtrCheck(TEBW16Image *)
{
   delete new TEBW16Image((TComponent*)(0));
};

void __fastcall TEBW16Image::InitControlData()
{
  ControlData = &CControlData;
};

void __fastcall TEBW16Image::CreateControl()
{
  if (!m_OCXIntf)
  {
    _ASSERTE(DefaultDispatch);
    DefaultDispatch->QueryInterface(DEF_CTL_INTF, (LPVOID*)&m_OCXIntf);
  }
};

_DEBW16ImageDisp __fastcall TEBW16Image::GetDefaultInterface()
{
  CreateControl();
  return m_OCXIntf;
};

TOLEBOOL __fastcall TEBW16Image::SameSize(LPDISPATCH SrcImage)
{
  return GetDefaultInterface()->SameSize(SrcImage);
}

void __fastcall TEBW16Image::SetSize(long Width, long Height)
{
  GetDefaultInterface()->SetSize(Width, Height);
}

long __fastcall TEBW16Image::GetImagePointer(long OriginX, long OriginY)
{
  return GetDefaultInterface()->GetImagePointer(OriginX, OriginY);
}

void __fastcall TEBW16Image::SetImagePointer(long NewValue)
{
  GetDefaultInterface()->SetImagePointer(NewValue);
}

void __fastcall TEBW16Image::GetPixel(long X, long Y, short* Value)
{
  GetDefaultInterface()->GetPixel(X, Y, Value);
}

void __fastcall TEBW16Image::SetPixel(long X, long Y, short Value)
{
  GetDefaultInterface()->SetPixel(X, Y, Value);
}

TOLEBOOL __fastcall TEBW16Image::Void(void)
{
  return GetDefaultInterface()->Void();
}

void __fastcall TEBW16Image::DrawText(long X, long Y, BSTR TextOut)
{
  GetDefaultInterface()->DrawText(X, Y, TextOut);
}

Evision_tlb::enumFileFormats __fastcall TEBW16Image::Load(BSTR FileName)
{
  return GetDefaultInterface()->Load(FileName);
}

void __fastcall TEBW16Image::Save(BSTR FileName, Evision_tlb::enumFileFormats FileFormat)
{
  GetDefaultInterface()->Save(FileName, FileFormat);
}

void __fastcall TEBW16Image::AboutBox(void)
{
  GetDefaultInterface()->AboutBox();
}

LPDISPATCH __fastcall TEBW16Image::Get_Obj()
{
  return GetDefaultInterface()->get_Obj();
}

void __fastcall TEBW16Image::Set_Obj(LPDISPATCH param)
{
  GetDefaultInterface()->set_Obj(param);
}



// *********************************************************************//
// OCX PROXY CLASS IMPLEMENTATION
// (The following variables/methods implement the class TEC24Image which
// allows "EC24Image Control" to be hosted in CBuilder IDE/apps).
// *********************************************************************//
int   TEC24Image::EventDispIDs[1] = {
    0x00000001};

int TEC24Image::TFontIDs[1] = {
    0x0000002E
};

TControlData TEC24Image::CControlData =
{
  // GUID of CoClass and Event Interface of Control
  {0x9AE86E16, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // CoClass
  {0x9AE86E15, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // Events

  // Count of Events and array of their DISPIDs
  1, &EventDispIDs,

  // Pointer to Runtime License string
  NULL,  // HRESULT(0x80004005)

  // Flags for OnChanged PropertyNotification
  0x00000000,
  300,// (IDE Version)

  // Count of Font Prop and array of their DISPIDs
  1, TFontIDs,

  // Count of Pict Prop and array of their DISPIDs
  0, NULL,
  0, // Reserved
  0, // Instance count (used internally)
  0, // List of Enum descriptions (internal)
};

GUID     TEC24Image::DEF_CTL_INTF = {0x9AE86E14, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} };
TNoParam TEC24Image::OptParam;

static inline void ValidCtrCheck(TEC24Image *)
{
   delete new TEC24Image((TComponent*)(0));
};

void __fastcall TEC24Image::InitControlData()
{
  ControlData = &CControlData;
};

void __fastcall TEC24Image::CreateControl()
{
  if (!m_OCXIntf)
  {
    _ASSERTE(DefaultDispatch);
    DefaultDispatch->QueryInterface(DEF_CTL_INTF, (LPVOID*)&m_OCXIntf);
  }
};

_DEC24ImageDisp __fastcall TEC24Image::GetDefaultInterface()
{
  CreateControl();
  return m_OCXIntf;
};

TOLEBOOL __fastcall TEC24Image::SameSize(LPDISPATCH SrcImage)
{
  return GetDefaultInterface()->SameSize(SrcImage);
}

void __fastcall TEC24Image::SetSize(long Width, long Height)
{
  GetDefaultInterface()->SetSize(Width, Height);
}

long __fastcall TEC24Image::GetImagePointer(long OriginX, long OriginY)
{
  return GetDefaultInterface()->GetImagePointer(OriginX, OriginY);
}

void __fastcall TEC24Image::SetImagePointer(long NewValue)
{
  GetDefaultInterface()->SetImagePointer(NewValue);
}

void __fastcall TEC24Image::GetPixel(long X, long Y, short* RedValue, short* GreenValue, 
                                     short* BlueValue)
{
  GetDefaultInterface()->GetPixel(X, Y, RedValue, GreenValue, BlueValue);
}

void __fastcall TEC24Image::SetPixel(long X, long Y, short RedValue, short GreenValue, 
                                     short BlueValue)
{
  GetDefaultInterface()->SetPixel(X, Y, RedValue, GreenValue, BlueValue);
}

TOLEBOOL __fastcall TEC24Image::Void(void)
{
  return GetDefaultInterface()->Void();
}

void __fastcall TEC24Image::SaveFile(BSTR FileName, Evision_tlb::enumFileFormats FileFormat)
{
  GetDefaultInterface()->SaveFile(FileName, FileFormat);
}

Evision_tlb::enumFileFormats __fastcall TEC24Image::LoadFile(BSTR FileName)
{
  return GetDefaultInterface()->LoadFile(FileName);
}

void __fastcall TEC24Image::DrawToDC(OLE_HANDLE hDC)
{
  GetDefaultInterface()->DrawToDC(hDC);
}

void __fastcall TEC24Image::DrawLine(float X1, float Y1, float X2, float Y2)
{
  GetDefaultInterface()->DrawLine(X1, Y1, X2, Y2);
}

void __fastcall TEC24Image::DrawBox(float X1, float Y1, float X2, float Y2)
{
  GetDefaultInterface()->DrawBox(X1, Y1, X2, Y2);
}

void __fastcall TEC24Image::DrawCircle(float X, float Y, float Radius)
{
  GetDefaultInterface()->DrawCircle(X, Y, Radius);
}

void __fastcall TEC24Image::DrawArc(float X, float Y, float Radius, float Start, float End)
{
  GetDefaultInterface()->DrawArc(X, Y, Radius, Start, End);
}

void __fastcall TEC24Image::Refresh(void)
{
  GetDefaultInterface()->Refresh();
}

void __fastcall TEC24Image::DrawText(long X, long Y, BSTR TextOut)
{
  GetDefaultInterface()->DrawText(X, Y, TextOut);
}

void __fastcall TEC24Image::Save(BSTR FileName, Evision_tlb::enumFileFormats FileFormat)
{
  GetDefaultInterface()->Save(FileName, FileFormat);
}

Evision_tlb::enumFileFormats __fastcall TEC24Image::Load(BSTR FileName)
{
  return GetDefaultInterface()->Load(FileName);
}

void __fastcall TEC24Image::AboutBox(void)
{
  GetDefaultInterface()->AboutBox();
}

LPDISPATCH __fastcall TEC24Image::Get_Obj()
{
  return GetDefaultInterface()->get_Obj();
}

void __fastcall TEC24Image::Set_Obj(LPDISPATCH param)
{
  GetDefaultInterface()->set_Obj(param);
}



// *********************************************************************//
// OCX PROXY CLASS IMPLEMENTATION
// (The following variables/methods implement the class TEBW8ROI which
// allows "EBW8ROI Control" to be hosted in CBuilder IDE/apps).
// *********************************************************************//
int   TEBW8ROI::EventDispIDs[1] = {
    0x00000001};

TControlData TEBW8ROI::CControlData =
{
  // GUID of CoClass and Event Interface of Control
  {0x9AE86E26, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // CoClass
  {0x9AE86E25, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // Events

  // Count of Events and array of their DISPIDs
  1, &EventDispIDs,

  // Pointer to Runtime License string
  NULL,  // HRESULT(0x80004005)

  // Flags for OnChanged PropertyNotification
  0x00000000,
  300,// (IDE Version)

  // Count of Font Prop and array of their DISPIDs
  0, NULL,

  // Count of Pict Prop and array of their DISPIDs
  0, NULL,
  0, // Reserved
  0, // Instance count (used internally)
  0, // List of Enum descriptions (internal)
};

GUID     TEBW8ROI::DEF_CTL_INTF = {0x9AE86E24, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} };
TNoParam TEBW8ROI::OptParam;

static inline void ValidCtrCheck(TEBW8ROI *)
{
   delete new TEBW8ROI((TComponent*)(0));
};

void __fastcall TEBW8ROI::InitControlData()
{
  ControlData = &CControlData;
};

void __fastcall TEBW8ROI::CreateControl()
{
  if (!m_OCXIntf)
  {
    _ASSERTE(DefaultDispatch);
    DefaultDispatch->QueryInterface(DEF_CTL_INTF, (LPVOID*)&m_OCXIntf);
  }
};

_DEBW8ROIDisp __fastcall TEBW8ROI::GetDefaultInterface()
{
  CreateControl();
  return m_OCXIntf;
};

TOLEBOOL __fastcall TEBW8ROI::SameSize(LPDISPATCH SrcImage)
{
  return GetDefaultInterface()->SameSize(SrcImage);
}

void __fastcall TEBW8ROI::Detach(void)
{
  GetDefaultInterface()->Detach();
}

void __fastcall TEBW8ROI::SetSize(long Width, long Height)
{
  GetDefaultInterface()->SetSize(Width, Height);
}

void __fastcall TEBW8ROI::SetPlacement(long OriginX, long OriginY, long Width, long Height)
{
  GetDefaultInterface()->SetPlacement(OriginX, OriginY, Width, Height);
}

long __fastcall TEBW8ROI::GetImagePointer(long OriginX, long OriginY)
{
  return GetDefaultInterface()->GetImagePointer(OriginX, OriginY);
}

void __fastcall TEBW8ROI::GetPixel(long X, long Y, short* GrayValue)
{
  GetDefaultInterface()->GetPixel(X, Y, GrayValue);
}

void __fastcall TEBW8ROI::SetPixel(long X, long Y, short GrayValue)
{
  GetDefaultInterface()->SetPixel(X, Y, GrayValue);
}

TOLEBOOL __fastcall TEBW8ROI::Void(void)
{
  return GetDefaultInterface()->Void();
}

void __fastcall TEBW8ROI::DrawFrame(Evision_tlb::enumFramePosition FramePosition, 
                                    TOLEBOOL DrawHandles)
{
  GetDefaultInterface()->DrawFrame(FramePosition, DrawHandles);
}

void __fastcall TEBW8ROI::DrawToDC(void)
{
  GetDefaultInterface()->DrawToDC();
}

Evision_tlb::enumHandleNames __fastcall TEBW8ROI::HitTest(long X, long Y)
{
  return GetDefaultInterface()->HitTest(X, Y);
}

void __fastcall TEBW8ROI::Drag(Evision_tlb::enumHandleNames Handle, long X, long Y)
{
  GetDefaultInterface()->Drag(Handle, X, Y);
}

short __fastcall TEBW8ROI::Load(BSTR FileName)
{
  return GetDefaultInterface()->Load(FileName);
}

void __fastcall TEBW8ROI::Save(BSTR FileName, Evision_tlb::enumFileFormats FileFormat)
{
  GetDefaultInterface()->Save(FileName, FileFormat);
}

void __fastcall TEBW8ROI::AboutBox(void)
{
  GetDefaultInterface()->AboutBox();
}

LPDISPATCH __fastcall TEBW8ROI::Get_ParentImage()
{
  return GetDefaultInterface()->get_ParentImage();
}

void __fastcall TEBW8ROI::Set_ParentImage(LPDISPATCH param)
{
  GetDefaultInterface()->set_ParentImage(param);
}

LPDISPATCH __fastcall TEBW8ROI::Get_Obj()
{
  return GetDefaultInterface()->get_Obj();
}

void __fastcall TEBW8ROI::Set_Obj(LPDISPATCH param)
{
  GetDefaultInterface()->set_Obj(param);
}



// *********************************************************************//
// OCX PROXY CLASS IMPLEMENTATION
// (The following variables/methods implement the class TEBW16ROI which
// allows "EBW16ROI Control" to be hosted in CBuilder IDE/apps).
// *********************************************************************//
TControlData TEBW16ROI::CControlData =
{
  // GUID of CoClass and Event Interface of Control
  {0x9AE86E2A, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // CoClass
  {0x9AE86E29, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // Events

  // Count of Events and array of their DISPIDs
  0, NULL,

  // Pointer to Runtime License string
  NULL,  // HRESULT(0x80004005)

  // Flags for OnChanged PropertyNotification
  0x00000000,
  300,// (IDE Version)

  // Count of Font Prop and array of their DISPIDs
  0, NULL,

  // Count of Pict Prop and array of their DISPIDs
  0, NULL,
  0, // Reserved
  0, // Instance count (used internally)
  0, // List of Enum descriptions (internal)
};

GUID     TEBW16ROI::DEF_CTL_INTF = {0x9AE86E28, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} };
TNoParam TEBW16ROI::OptParam;

static inline void ValidCtrCheck(TEBW16ROI *)
{
   delete new TEBW16ROI((TComponent*)(0));
};

void __fastcall TEBW16ROI::InitControlData()
{
  ControlData = &CControlData;
};

void __fastcall TEBW16ROI::CreateControl()
{
  if (!m_OCXIntf)
  {
    _ASSERTE(DefaultDispatch);
    DefaultDispatch->QueryInterface(DEF_CTL_INTF, (LPVOID*)&m_OCXIntf);
  }
};

_DEBW16ROIDisp __fastcall TEBW16ROI::GetDefaultInterface()
{
  CreateControl();
  return m_OCXIntf;
};

TOLEBOOL __fastcall TEBW16ROI::SameSize(LPDISPATCH SrcImage)
{
  return GetDefaultInterface()->SameSize(SrcImage);
}

void __fastcall TEBW16ROI::Detach(void)
{
  GetDefaultInterface()->Detach();
}

void __fastcall TEBW16ROI::SetSize(long Width, long Height)
{
  GetDefaultInterface()->SetSize(Width, Height);
}

void __fastcall TEBW16ROI::SetPlacement(long OriginX, long OriginY, long Width, long Height)
{
  GetDefaultInterface()->SetPlacement(OriginX, OriginY, Width, Height);
}

long __fastcall TEBW16ROI::GetImagePointer(long OriginX, long OriginY)
{
  return GetDefaultInterface()->GetImagePointer(OriginX, OriginY);
}

void __fastcall TEBW16ROI::GetPixel(long X, long Y, short* Value)
{
  GetDefaultInterface()->GetPixel(X, Y, Value);
}

void __fastcall TEBW16ROI::SetPixel(long X, long Y, short Value)
{
  GetDefaultInterface()->SetPixel(X, Y, Value);
}

TOLEBOOL __fastcall TEBW16ROI::Void(void)
{
  return GetDefaultInterface()->Void();
}

Evision_tlb::enumFileFormats __fastcall TEBW16ROI::Load(BSTR FileName)
{
  return GetDefaultInterface()->Load(FileName);
}

void __fastcall TEBW16ROI::Save(BSTR FileName, Evision_tlb::enumFileFormats FileFormat)
{
  GetDefaultInterface()->Save(FileName, FileFormat);
}

void __fastcall TEBW16ROI::AboutBox(void)
{
  GetDefaultInterface()->AboutBox();
}

LPDISPATCH __fastcall TEBW16ROI::Get_ParentImage()
{
  return GetDefaultInterface()->get_ParentImage();
}

void __fastcall TEBW16ROI::Set_ParentImage(LPDISPATCH param)
{
  GetDefaultInterface()->set_ParentImage(param);
}

LPDISPATCH __fastcall TEBW16ROI::Get_Obj()
{
  return GetDefaultInterface()->get_Obj();
}

void __fastcall TEBW16ROI::Set_Obj(LPDISPATCH param)
{
  GetDefaultInterface()->set_Obj(param);
}



// *********************************************************************//
// OCX PROXY CLASS IMPLEMENTATION
// (The following variables/methods implement the class TEC24ROI which
// allows "EC24ROI Control" to be hosted in CBuilder IDE/apps).
// *********************************************************************//
int   TEC24ROI::EventDispIDs[1] = {
    0x00000001};

TControlData TEC24ROI::CControlData =
{
  // GUID of CoClass and Event Interface of Control
  {0x9AE86E32, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // CoClass
  {0x9AE86E31, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // Events

  // Count of Events and array of their DISPIDs
  1, &EventDispIDs,

  // Pointer to Runtime License string
  NULL,  // HRESULT(0x80004005)

  // Flags for OnChanged PropertyNotification
  0x00000000,
  300,// (IDE Version)

  // Count of Font Prop and array of their DISPIDs
  0, NULL,

  // Count of Pict Prop and array of their DISPIDs
  0, NULL,
  0, // Reserved
  0, // Instance count (used internally)
  0, // List of Enum descriptions (internal)
};

GUID     TEC24ROI::DEF_CTL_INTF = {0x9AE86E30, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} };
TNoParam TEC24ROI::OptParam;

static inline void ValidCtrCheck(TEC24ROI *)
{
   delete new TEC24ROI((TComponent*)(0));
};

void __fastcall TEC24ROI::InitControlData()
{
  ControlData = &CControlData;
};

void __fastcall TEC24ROI::CreateControl()
{
  if (!m_OCXIntf)
  {
    _ASSERTE(DefaultDispatch);
    DefaultDispatch->QueryInterface(DEF_CTL_INTF, (LPVOID*)&m_OCXIntf);
  }
};

_DEC24ROIDisp __fastcall TEC24ROI::GetDefaultInterface()
{
  CreateControl();
  return m_OCXIntf;
};

TOLEBOOL __fastcall TEC24ROI::SameSize(LPDISPATCH SrcImage)
{
  return GetDefaultInterface()->SameSize(SrcImage);
}

void __fastcall TEC24ROI::Detach(void)
{
  GetDefaultInterface()->Detach();
}

void __fastcall TEC24ROI::SetSize(long Width, long Height)
{
  GetDefaultInterface()->SetSize(Width, Height);
}

void __fastcall TEC24ROI::SetPlacement(long OriginX, long OriginY, long Width, long Height)
{
  GetDefaultInterface()->SetPlacement(OriginX, OriginY, Width, Height);
}

long __fastcall TEC24ROI::GetImagePointer(long OriginX, long OriginY)
{
  return GetDefaultInterface()->GetImagePointer(OriginX, OriginY);
}

void __fastcall TEC24ROI::GetPixel(long X, long Y, short* RedValue, short* GreenValue, 
                                   short* BlueValue)
{
  GetDefaultInterface()->GetPixel(X, Y, RedValue, GreenValue, BlueValue);
}

void __fastcall TEC24ROI::SetPixel(long X, long Y, short RedValue, short GreenValue, short BlueValue)
{
  GetDefaultInterface()->SetPixel(X, Y, RedValue, GreenValue, BlueValue);
}

TOLEBOOL __fastcall TEC24ROI::Void(void)
{
  return GetDefaultInterface()->Void();
}

void __fastcall TEC24ROI::DrawFrame(Evision_tlb::enumFramePosition FramePosition, 
                                    TOLEBOOL DrawHandles)
{
  GetDefaultInterface()->DrawFrame(FramePosition, DrawHandles);
}

void __fastcall TEC24ROI::DrawToDC(void)
{
  GetDefaultInterface()->DrawToDC();
}

Evision_tlb::enumHandleNames __fastcall TEC24ROI::HitTest(long X, long Y)
{
  return GetDefaultInterface()->HitTest(X, Y);
}

void __fastcall TEC24ROI::Drag(Evision_tlb::enumHandleNames Handle, long X, long Y)
{
  GetDefaultInterface()->Drag(Handle, X, Y);
}

Evision_tlb::enumFileFormats __fastcall TEC24ROI::Load(BSTR FileName)
{
  return GetDefaultInterface()->Load(FileName);
}

void __fastcall TEC24ROI::Save(BSTR FileName, Evision_tlb::enumFileFormats FileFormat)
{
  GetDefaultInterface()->Save(FileName, FileFormat);
}

void __fastcall TEC24ROI::AboutBox(void)
{
  GetDefaultInterface()->AboutBox();
}

LPDISPATCH __fastcall TEC24ROI::Get_ParentImage()
{
  return GetDefaultInterface()->get_ParentImage();
}

void __fastcall TEC24ROI::Set_ParentImage(LPDISPATCH param)
{
  GetDefaultInterface()->set_ParentImage(param);
}

LPDISPATCH __fastcall TEC24ROI::Get_Obj()
{
  return GetDefaultInterface()->get_Obj();
}

void __fastcall TEC24ROI::Set_Obj(LPDISPATCH param)
{
  GetDefaultInterface()->set_Obj(param);
}



// *********************************************************************//
// OCX PROXY CLASS IMPLEMENTATION
// (The following variables/methods implement the class TEBW8Vector which
// allows "EBW8Vector Control" to be hosted in CBuilder IDE/apps).
// *********************************************************************//
int TEBW8Vector::TFontIDs[1] = {
    0xFFFFFE00
};

TControlData TEBW8Vector::CControlData =
{
  // GUID of CoClass and Event Interface of Control
  {0x9AE86E42, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // CoClass
  {0x9AE86E41, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // Events

  // Count of Events and array of their DISPIDs
  0, NULL,

  // Pointer to Runtime License string
  NULL,  // HRESULT(0x80004005)

  // Flags for OnChanged PropertyNotification
  0x00000004,
  300,// (IDE Version)

  // Count of Font Prop and array of their DISPIDs
  1, TFontIDs,

  // Count of Pict Prop and array of their DISPIDs
  0, NULL,
  0, // Reserved
  0, // Instance count (used internally)
  0, // List of Enum descriptions (internal)
};

GUID     TEBW8Vector::DEF_CTL_INTF = {0x9AE86E40, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} };
TNoParam TEBW8Vector::OptParam;

static inline void ValidCtrCheck(TEBW8Vector *)
{
   delete new TEBW8Vector((TComponent*)(0));
};

void __fastcall TEBW8Vector::InitControlData()
{
  ControlData = &CControlData;
};

void __fastcall TEBW8Vector::CreateControl()
{
  if (!m_OCXIntf)
  {
    _ASSERTE(DefaultDispatch);
    DefaultDispatch->QueryInterface(DEF_CTL_INTF, (LPVOID*)&m_OCXIntf);
  }
};

_DEBW8VectorDisp __fastcall TEBW8Vector::GetDefaultInterface()
{
  CreateControl();
  return m_OCXIntf;
};

void __fastcall TEBW8Vector::Empty(void)
{
  GetDefaultInterface()->Empty();
}

void __fastcall TEBW8Vector::AddElement(short GrayValue)
{
  GetDefaultInterface()->AddElement(GrayValue);
}

void __fastcall TEBW8Vector::GetAt(long Index, short* GrayValue)
{
  GetDefaultInterface()->GetAt(Index, GrayValue);
}

void __fastcall TEBW8Vector::SetAt(long Index, short GrayValue)
{
  GetDefaultInterface()->SetAt(Index, GrayValue);
}

void __fastcall TEBW8Vector::Refresh(void)
{
  GetDefaultInterface()->Refresh();
}

void __fastcall TEBW8Vector::AboutBox(void)
{
  GetDefaultInterface()->AboutBox();
}

LPDISPATCH __fastcall TEBW8Vector::Get_Obj()
{
  return GetDefaultInterface()->get_Obj();
}

void __fastcall TEBW8Vector::Set_Obj(LPDISPATCH param)
{
  GetDefaultInterface()->set_Obj(param);
}



// *********************************************************************//
// OCX PROXY CLASS IMPLEMENTATION
// (The following variables/methods implement the class TEBW16Vector which
// allows "EBW16Vector Control" to be hosted in CBuilder IDE/apps).
// *********************************************************************//
int TEBW16Vector::TFontIDs[1] = {
    0xFFFFFE00
};

TControlData TEBW16Vector::CControlData =
{
  // GUID of CoClass and Event Interface of Control
  {0x9AE86E46, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // CoClass
  {0x9AE86E45, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // Events

  // Count of Events and array of their DISPIDs
  0, NULL,

  // Pointer to Runtime License string
  NULL,  // HRESULT(0x80004005)

  // Flags for OnChanged PropertyNotification
  0x00000004,
  300,// (IDE Version)

  // Count of Font Prop and array of their DISPIDs
  1, TFontIDs,

  // Count of Pict Prop and array of their DISPIDs
  0, NULL,
  0, // Reserved
  0, // Instance count (used internally)
  0, // List of Enum descriptions (internal)
};

GUID     TEBW16Vector::DEF_CTL_INTF = {0x9AE86E44, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} };
TNoParam TEBW16Vector::OptParam;

static inline void ValidCtrCheck(TEBW16Vector *)
{
   delete new TEBW16Vector((TComponent*)(0));
};

void __fastcall TEBW16Vector::InitControlData()
{
  ControlData = &CControlData;
};

void __fastcall TEBW16Vector::CreateControl()
{
  if (!m_OCXIntf)
  {
    _ASSERTE(DefaultDispatch);
    DefaultDispatch->QueryInterface(DEF_CTL_INTF, (LPVOID*)&m_OCXIntf);
  }
};

_DEBW16VectorDisp __fastcall TEBW16Vector::GetDefaultInterface()
{
  CreateControl();
  return m_OCXIntf;
};

void __fastcall TEBW16Vector::Empty(void)
{
  GetDefaultInterface()->Empty();
}

void __fastcall TEBW16Vector::AddElement(short GrayValue)
{
  GetDefaultInterface()->AddElement(GrayValue);
}

void __fastcall TEBW16Vector::GetAt(long Index, short* GrayValue)
{
  GetDefaultInterface()->GetAt(Index, GrayValue);
}

void __fastcall TEBW16Vector::SetAt(long Index, short GrayValue)
{
  GetDefaultInterface()->SetAt(Index, GrayValue);
}

void __fastcall TEBW16Vector::Refresh(void)
{
  GetDefaultInterface()->Refresh();
}

void __fastcall TEBW16Vector::AboutBox(void)
{
  GetDefaultInterface()->AboutBox();
}

LPDISPATCH __fastcall TEBW16Vector::Get_Obj()
{
  return GetDefaultInterface()->get_Obj();
}

void __fastcall TEBW16Vector::Set_Obj(LPDISPATCH param)
{
  GetDefaultInterface()->set_Obj(param);
}



// *********************************************************************//
// OCX PROXY CLASS IMPLEMENTATION
// (The following variables/methods implement the class TEBW32Vector which
// allows "EBW32Vector Control" to be hosted in CBuilder IDE/apps).
// *********************************************************************//
int TEBW32Vector::TFontIDs[1] = {
    0xFFFFFE00
};

TControlData TEBW32Vector::CControlData =
{
  // GUID of CoClass and Event Interface of Control
  {0x9AE86E4A, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // CoClass
  {0x9AE86E49, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // Events

  // Count of Events and array of their DISPIDs
  0, NULL,

  // Pointer to Runtime License string
  NULL,  // HRESULT(0x80004005)

  // Flags for OnChanged PropertyNotification
  0x00000004,
  300,// (IDE Version)

  // Count of Font Prop and array of their DISPIDs
  1, TFontIDs,

  // Count of Pict Prop and array of their DISPIDs
  0, NULL,
  0, // Reserved
  0, // Instance count (used internally)
  0, // List of Enum descriptions (internal)
};

GUID     TEBW32Vector::DEF_CTL_INTF = {0x9AE86E48, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} };
TNoParam TEBW32Vector::OptParam;

static inline void ValidCtrCheck(TEBW32Vector *)
{
   delete new TEBW32Vector((TComponent*)(0));
};

void __fastcall TEBW32Vector::InitControlData()
{
  ControlData = &CControlData;
};

void __fastcall TEBW32Vector::CreateControl()
{
  if (!m_OCXIntf)
  {
    _ASSERTE(DefaultDispatch);
    DefaultDispatch->QueryInterface(DEF_CTL_INTF, (LPVOID*)&m_OCXIntf);
  }
};

_DEBW32VectorDisp __fastcall TEBW32Vector::GetDefaultInterface()
{
  CreateControl();
  return m_OCXIntf;
};

void __fastcall TEBW32Vector::Empty(void)
{
  GetDefaultInterface()->Empty();
}

void __fastcall TEBW32Vector::AddElement(long GrayValue)
{
  GetDefaultInterface()->AddElement(GrayValue);
}

void __fastcall TEBW32Vector::GetAt(long Index, long* GrayValue)
{
  GetDefaultInterface()->GetAt(Index, GrayValue);
}

void __fastcall TEBW32Vector::SetAt(long Index, long GrayValue)
{
  GetDefaultInterface()->SetAt(Index, GrayValue);
}

void __fastcall TEBW32Vector::Refresh(void)
{
  GetDefaultInterface()->Refresh();
}

void __fastcall TEBW32Vector::AboutBox(void)
{
  GetDefaultInterface()->AboutBox();
}

LPDISPATCH __fastcall TEBW32Vector::Get_Obj()
{
  return GetDefaultInterface()->get_Obj();
}

void __fastcall TEBW32Vector::Set_Obj(LPDISPATCH param)
{
  GetDefaultInterface()->set_Obj(param);
}



// *********************************************************************//
// OCX PROXY CLASS IMPLEMENTATION
// (The following variables/methods implement the class TEC24Vector which
// allows "EC24Vector Control" to be hosted in CBuilder IDE/apps).
// *********************************************************************//
TControlData TEC24Vector::CControlData =
{
  // GUID of CoClass and Event Interface of Control
  {0x9AE86E4E, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // CoClass
  {0x9AE86E4D, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // Events

  // Count of Events and array of their DISPIDs
  0, NULL,

  // Pointer to Runtime License string
  NULL,  // HRESULT(0x80004005)

  // Flags for OnChanged PropertyNotification
  0x00000000,
  300,// (IDE Version)

  // Count of Font Prop and array of their DISPIDs
  0, NULL,

  // Count of Pict Prop and array of their DISPIDs
  0, NULL,
  0, // Reserved
  0, // Instance count (used internally)
  0, // List of Enum descriptions (internal)
};

GUID     TEC24Vector::DEF_CTL_INTF = {0x9AE86E4C, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} };
TNoParam TEC24Vector::OptParam;

static inline void ValidCtrCheck(TEC24Vector *)
{
   delete new TEC24Vector((TComponent*)(0));
};

void __fastcall TEC24Vector::InitControlData()
{
  ControlData = &CControlData;
};

void __fastcall TEC24Vector::CreateControl()
{
  if (!m_OCXIntf)
  {
    _ASSERTE(DefaultDispatch);
    DefaultDispatch->QueryInterface(DEF_CTL_INTF, (LPVOID*)&m_OCXIntf);
  }
};

_DEC24VectorDisp __fastcall TEC24Vector::GetDefaultInterface()
{
  CreateControl();
  return m_OCXIntf;
};

void __fastcall TEC24Vector::Empty(void)
{
  GetDefaultInterface()->Empty();
}

void __fastcall TEC24Vector::AddElement(short RedValue, short GreenValue, short BlueValue)
{
  GetDefaultInterface()->AddElement(RedValue, GreenValue, BlueValue);
}

void __fastcall TEC24Vector::GetAt(long Index, short* RedValue, short* GreenValue, short* BlueValue)
{
  GetDefaultInterface()->GetAt(Index, RedValue, GreenValue, BlueValue);
}

void __fastcall TEC24Vector::SetAt(long Index, short RedValue, short GreenValue, short BlueValue)
{
  GetDefaultInterface()->SetAt(Index, RedValue, GreenValue, BlueValue);
}

void __fastcall TEC24Vector::AboutBox(void)
{
  GetDefaultInterface()->AboutBox();
}

void __fastcall TEC24Vector::Refresh(void)
{
  GetDefaultInterface()->Refresh();
}

LPDISPATCH __fastcall TEC24Vector::Get_Obj()
{
  return GetDefaultInterface()->get_Obj();
}

void __fastcall TEC24Vector::Set_Obj(LPDISPATCH param)
{
  GetDefaultInterface()->set_Obj(param);
}



// *********************************************************************//
// OCX PROXY CLASS IMPLEMENTATION
// (The following variables/methods implement the class TEPathVector which
// allows "EPathVector Control" to be hosted in CBuilder IDE/apps).
// *********************************************************************//
TControlData TEPathVector::CControlData =
{
  // GUID of CoClass and Event Interface of Control
  {0x9AE86E5E, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // CoClass
  {0x9AE86E5D, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // Events

  // Count of Events and array of their DISPIDs
  0, NULL,

  // Pointer to Runtime License string
  NULL,  // HRESULT(0x80004005)

  // Flags for OnChanged PropertyNotification
  0x00000000,
  300,// (IDE Version)

  // Count of Font Prop and array of their DISPIDs
  0, NULL,

  // Count of Pict Prop and array of their DISPIDs
  0, NULL,
  0, // Reserved
  0, // Instance count (used internally)
  0, // List of Enum descriptions (internal)
};

GUID     TEPathVector::DEF_CTL_INTF = {0x9AE86E5C, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} };
TNoParam TEPathVector::OptParam;

static inline void ValidCtrCheck(TEPathVector *)
{
   delete new TEPathVector((TComponent*)(0));
};

void __fastcall TEPathVector::InitControlData()
{
  ControlData = &CControlData;
};

void __fastcall TEPathVector::CreateControl()
{
  if (!m_OCXIntf)
  {
    _ASSERTE(DefaultDispatch);
    DefaultDispatch->QueryInterface(DEF_CTL_INTF, (LPVOID*)&m_OCXIntf);
  }
};

_DEPathVectorDisp __fastcall TEPathVector::GetDefaultInterface()
{
  CreateControl();
  return m_OCXIntf;
};

void __fastcall TEPathVector::Empty(void)
{
  GetDefaultInterface()->Empty();
}

void __fastcall TEPathVector::AddElement(short X, short Y)
{
  GetDefaultInterface()->AddElement(X, Y);
}

void __fastcall TEPathVector::GetAt(long Index, short* X, short* Y)
{
  GetDefaultInterface()->GetAt(Index, X, Y);
}

void __fastcall TEPathVector::SetAt(long Index, short X, short Y)
{
  GetDefaultInterface()->SetAt(Index, X, Y);
}

void __fastcall TEPathVector::Draw(LPDISPATCH Image)
{
  GetDefaultInterface()->Draw(Image);
}

void __fastcall TEPathVector::AboutBox(void)
{
  GetDefaultInterface()->AboutBox();
}

LPDISPATCH __fastcall TEPathVector::Get_Obj()
{
  return GetDefaultInterface()->get_Obj();
}

void __fastcall TEPathVector::Set_Obj(LPDISPATCH param)
{
  GetDefaultInterface()->set_Obj(param);
}



// *********************************************************************//
// OCX PROXY CLASS IMPLEMENTATION
// (The following variables/methods implement the class TEBW8HistogramVector which
// allows "EBW8HistogramVector Control" to be hosted in CBuilder IDE/apps).
// *********************************************************************//
int TEBW8HistogramVector::TFontIDs[1] = {
    0xFFFFFE00
};

TControlData TEBW8HistogramVector::CControlData =
{
  // GUID of CoClass and Event Interface of Control
  {0x9AE86E66, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // CoClass
  {0x9AE86E65, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // Events

  // Count of Events and array of their DISPIDs
  0, NULL,

  // Pointer to Runtime License string
  NULL,  // HRESULT(0x80004005)

  // Flags for OnChanged PropertyNotification
  0x00000004,
  300,// (IDE Version)

  // Count of Font Prop and array of their DISPIDs
  1, TFontIDs,

  // Count of Pict Prop and array of their DISPIDs
  0, NULL,
  0, // Reserved
  0, // Instance count (used internally)
  0, // List of Enum descriptions (internal)
};

GUID     TEBW8HistogramVector::DEF_CTL_INTF = {0x9AE86E64, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} };
TNoParam TEBW8HistogramVector::OptParam;

static inline void ValidCtrCheck(TEBW8HistogramVector *)
{
   delete new TEBW8HistogramVector((TComponent*)(0));
};

void __fastcall TEBW8HistogramVector::InitControlData()
{
  ControlData = &CControlData;
};

void __fastcall TEBW8HistogramVector::CreateControl()
{
  if (!m_OCXIntf)
  {
    _ASSERTE(DefaultDispatch);
    DefaultDispatch->QueryInterface(DEF_CTL_INTF, (LPVOID*)&m_OCXIntf);
  }
};

_DEBW8HistogramVectorDisp __fastcall TEBW8HistogramVector::GetDefaultInterface()
{
  CreateControl();
  return m_OCXIntf;
};

void __fastcall TEBW8HistogramVector::Empty(void)
{
  GetDefaultInterface()->Empty();
}

void __fastcall TEBW8HistogramVector::AddElement(long Value)
{
  GetDefaultInterface()->AddElement(Value);
}

void __fastcall TEBW8HistogramVector::GetAt(long Index, long* Value)
{
  GetDefaultInterface()->GetAt(Index, Value);
}

void __fastcall TEBW8HistogramVector::SetAt(long Index, long Value)
{
  GetDefaultInterface()->SetAt(Index, Value);
}

void __fastcall TEBW8HistogramVector::Refresh(void)
{
  GetDefaultInterface()->Refresh();
}

void __fastcall TEBW8HistogramVector::AboutBox(void)
{
  GetDefaultInterface()->AboutBox();
}

LPDISPATCH __fastcall TEBW8HistogramVector::Get_Obj()
{
  return GetDefaultInterface()->get_Obj();
}

void __fastcall TEBW8HistogramVector::Set_Obj(LPDISPATCH param)
{
  GetDefaultInterface()->set_Obj(param);
}



// *********************************************************************//
// OCX PROXY CLASS IMPLEMENTATION
// (The following variables/methods implement the class TEBW8PathVector which
// allows "EBW8PathVector Control" to be hosted in CBuilder IDE/apps).
// *********************************************************************//
TControlData TEBW8PathVector::CControlData =
{
  // GUID of CoClass and Event Interface of Control
  {0x9AE86E6A, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // CoClass
  {0x9AE86E69, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // Events

  // Count of Events and array of their DISPIDs
  0, NULL,

  // Pointer to Runtime License string
  NULL,  // HRESULT(0x80004005)

  // Flags for OnChanged PropertyNotification
  0x00000000,
  300,// (IDE Version)

  // Count of Font Prop and array of their DISPIDs
  0, NULL,

  // Count of Pict Prop and array of their DISPIDs
  0, NULL,
  0, // Reserved
  0, // Instance count (used internally)
  0, // List of Enum descriptions (internal)
};

GUID     TEBW8PathVector::DEF_CTL_INTF = {0x9AE86E68, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} };
TNoParam TEBW8PathVector::OptParam;

static inline void ValidCtrCheck(TEBW8PathVector *)
{
   delete new TEBW8PathVector((TComponent*)(0));
};

void __fastcall TEBW8PathVector::InitControlData()
{
  ControlData = &CControlData;
};

void __fastcall TEBW8PathVector::CreateControl()
{
  if (!m_OCXIntf)
  {
    _ASSERTE(DefaultDispatch);
    DefaultDispatch->QueryInterface(DEF_CTL_INTF, (LPVOID*)&m_OCXIntf);
  }
};

_DEBW8PathVectorDisp __fastcall TEBW8PathVector::GetDefaultInterface()
{
  CreateControl();
  return m_OCXIntf;
};

void __fastcall TEBW8PathVector::Empty(void)
{
  GetDefaultInterface()->Empty();
}

void __fastcall TEBW8PathVector::AddElement(short X, short Y, short Pixel)
{
  GetDefaultInterface()->AddElement(X, Y, Pixel);
}

void __fastcall TEBW8PathVector::GetAt(long Index, short* X, short* Y, short* Pixel)
{
  GetDefaultInterface()->GetAt(Index, X, Y, Pixel);
}

void __fastcall TEBW8PathVector::SetAt(long Index, short X, short Y, short Pixel)
{
  GetDefaultInterface()->SetAt(Index, X, Y, Pixel);
}

void __fastcall TEBW8PathVector::Draw(LPDISPATCH Image)
{
  GetDefaultInterface()->Draw(Image);
}

void __fastcall TEBW8PathVector::AboutBox(void)
{
  GetDefaultInterface()->AboutBox();
}

LPDISPATCH __fastcall TEBW8PathVector::Get_Obj()
{
  return GetDefaultInterface()->get_Obj();
}

void __fastcall TEBW8PathVector::Set_Obj(LPDISPATCH param)
{
  GetDefaultInterface()->set_Obj(param);
}



// *********************************************************************//
// OCX PROXY CLASS IMPLEMENTATION
// (The following variables/methods implement the class TEC24PathVector which
// allows "EC24PathVector Control" to be hosted in CBuilder IDE/apps).
// *********************************************************************//
TControlData TEC24PathVector::CControlData =
{
  // GUID of CoClass and Event Interface of Control
  {0x9AE86E6E, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // CoClass
  {0x9AE86E6D, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // Events

  // Count of Events and array of their DISPIDs
  0, NULL,

  // Pointer to Runtime License string
  NULL,  // HRESULT(0x80004005)

  // Flags for OnChanged PropertyNotification
  0x00000000,
  300,// (IDE Version)

  // Count of Font Prop and array of their DISPIDs
  0, NULL,

  // Count of Pict Prop and array of their DISPIDs
  0, NULL,
  0, // Reserved
  0, // Instance count (used internally)
  0, // List of Enum descriptions (internal)
};

GUID     TEC24PathVector::DEF_CTL_INTF = {0x9AE86E6C, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} };
TNoParam TEC24PathVector::OptParam;

static inline void ValidCtrCheck(TEC24PathVector *)
{
   delete new TEC24PathVector((TComponent*)(0));
};

void __fastcall TEC24PathVector::InitControlData()
{
  ControlData = &CControlData;
};

void __fastcall TEC24PathVector::CreateControl()
{
  if (!m_OCXIntf)
  {
    _ASSERTE(DefaultDispatch);
    DefaultDispatch->QueryInterface(DEF_CTL_INTF, (LPVOID*)&m_OCXIntf);
  }
};

_DEC24PathVectorDisp __fastcall TEC24PathVector::GetDefaultInterface()
{
  CreateControl();
  return m_OCXIntf;
};

void __fastcall TEC24PathVector::Empty(void)
{
  GetDefaultInterface()->Empty();
}

void __fastcall TEC24PathVector::AddElement(short X, short Y, short PixelRed, short PixelGreen, 
                                            short PixelBlue)
{
  GetDefaultInterface()->AddElement(X, Y, PixelRed, PixelGreen, PixelBlue);
}

void __fastcall TEC24PathVector::GetAt(short Index, short* X, long* Y, short* PixelRed, 
                                       short* PixelGreen, short* PixelBlue)
{
  GetDefaultInterface()->GetAt(Index, X, Y, PixelRed, PixelGreen, PixelBlue);
}

void __fastcall TEC24PathVector::SetAt(short Index, short X, long Y, short PixelRed, 
                                       short PixelGreen, short PixelBlue)
{
  GetDefaultInterface()->SetAt(Index, X, Y, PixelRed, PixelGreen, PixelBlue);
}

void __fastcall TEC24PathVector::Draw(LPDISPATCH Image)
{
  GetDefaultInterface()->Draw(Image);
}

void __fastcall TEC24PathVector::AboutBox(void)
{
  GetDefaultInterface()->AboutBox();
}

LPDISPATCH __fastcall TEC24PathVector::Get_Obj()
{
  return GetDefaultInterface()->get_Obj();
}

void __fastcall TEC24PathVector::Set_Obj(LPDISPATCH param)
{
  GetDefaultInterface()->set_Obj(param);
}



// *********************************************************************//
// OCX PROXY CLASS IMPLEMENTATION
// (The following variables/methods implement the class TEPeaksVector which
// allows "EPeaksVector Control" to be hosted in CBuilder IDE/apps).
// *********************************************************************//
TControlData TEPeaksVector::CControlData =
{
  // GUID of CoClass and Event Interface of Control
  {0x9AE86E72, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // CoClass
  {0x9AE86E71, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // Events

  // Count of Events and array of their DISPIDs
  0, NULL,

  // Pointer to Runtime License string
  NULL,  // HRESULT(0x80004005)

  // Flags for OnChanged PropertyNotification
  0x00000000,
  300,// (IDE Version)

  // Count of Font Prop and array of their DISPIDs
  0, NULL,

  // Count of Pict Prop and array of their DISPIDs
  0, NULL,
  0, // Reserved
  0, // Instance count (used internally)
  0, // List of Enum descriptions (internal)
};

GUID     TEPeaksVector::DEF_CTL_INTF = {0x9AE86E70, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} };
TNoParam TEPeaksVector::OptParam;

static inline void ValidCtrCheck(TEPeaksVector *)
{
   delete new TEPeaksVector((TComponent*)(0));
};

void __fastcall TEPeaksVector::InitControlData()
{
  ControlData = &CControlData;
};

void __fastcall TEPeaksVector::CreateControl()
{
  if (!m_OCXIntf)
  {
    _ASSERTE(DefaultDispatch);
    DefaultDispatch->QueryInterface(DEF_CTL_INTF, (LPVOID*)&m_OCXIntf);
  }
};

_DEPeaksVectorDisp __fastcall TEPeaksVector::GetDefaultInterface()
{
  CreateControl();
  return m_OCXIntf;
};

void __fastcall TEPeaksVector::Empty(void)
{
  GetDefaultInterface()->Empty();
}

void __fastcall TEPeaksVector::AddElement(long Start, long Length, long Amplitude, long Area, 
                                          float Center)
{
  GetDefaultInterface()->AddElement(Start, Length, Amplitude, Area, Center);
}

void __fastcall TEPeaksVector::GetAt(long Index, long* Start, long* Length, long* Amplitude, 
                                     long* Area, float* Center)
{
  GetDefaultInterface()->GetAt(Index, Start, Length, Amplitude, Area, Center);
}

void __fastcall TEPeaksVector::SetAt(long Index, long Start, long Length, long Amplitude, long Area, 
                                     float Center)
{
  GetDefaultInterface()->SetAt(Index, Start, Length, Amplitude, Area, Center);
}

void __fastcall TEPeaksVector::AboutBox(void)
{
  GetDefaultInterface()->AboutBox();
}

LPDISPATCH __fastcall TEPeaksVector::Get_Obj()
{
  return GetDefaultInterface()->get_Obj();
}

void __fastcall TEPeaksVector::Set_Obj(LPDISPATCH param)
{
  GetDefaultInterface()->set_Obj(param);
}



// *********************************************************************//
// OCX PROXY CLASS IMPLEMENTATION
// (The following variables/methods implement the class TEKernel which
// allows "EKernel Control" to be hosted in CBuilder IDE/apps).
// *********************************************************************//
TControlData TEKernel::CControlData =
{
  // GUID of CoClass and Event Interface of Control
  {0x9AE86E7A, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // CoClass
  {0x9AE86E79, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // Events

  // Count of Events and array of their DISPIDs
  0, NULL,

  // Pointer to Runtime License string
  NULL,  // HRESULT(0x80004005)

  // Flags for OnChanged PropertyNotification
  0x00000000,
  300,// (IDE Version)

  // Count of Font Prop and array of their DISPIDs
  0, NULL,

  // Count of Pict Prop and array of their DISPIDs
  0, NULL,
  0, // Reserved
  0, // Instance count (used internally)
  0, // List of Enum descriptions (internal)
};

GUID     TEKernel::DEF_CTL_INTF = {0x9AE86E78, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} };
TNoParam TEKernel::OptParam;

static inline void ValidCtrCheck(TEKernel *)
{
   delete new TEKernel((TComponent*)(0));
};

void __fastcall TEKernel::InitControlData()
{
  ControlData = &CControlData;
};

void __fastcall TEKernel::CreateControl()
{
  if (!m_OCXIntf)
  {
    _ASSERTE(DefaultDispatch);
    DefaultDispatch->QueryInterface(DEF_CTL_INTF, (LPVOID*)&m_OCXIntf);
  }
};

_DEKernelDisp __fastcall TEKernel::GetDefaultInterface()
{
  CreateControl();
  return m_OCXIntf;
};

void __fastcall TEKernel::GetKernelData(long X, long Y, float* Data)
{
  GetDefaultInterface()->GetKernelData(X, Y, Data);
}

void __fastcall TEKernel::SetKernelData(long X, long Y, float Data)
{
  GetDefaultInterface()->SetKernelData(X, Y, Data);
}

void __fastcall TEKernel::AboutBox(void)
{
  GetDefaultInterface()->AboutBox();
}

LPDISPATCH __fastcall TEKernel::Get_Obj()
{
  return GetDefaultInterface()->get_Obj();
}

void __fastcall TEKernel::Set_Obj(LPDISPATCH param)
{
  GetDefaultInterface()->set_Obj(param);
}



// *********************************************************************//
// OCX PROXY CLASS IMPLEMENTATION
// (The following variables/methods implement the class TEColorLookup which
// allows "EColorLookup Control" to be hosted in CBuilder IDE/apps).
// *********************************************************************//
TControlData TEColorLookup::CControlData =
{
  // GUID of CoClass and Event Interface of Control
  {0x9AE86E7E, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // CoClass
  {0x9AE86E7D, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // Events

  // Count of Events and array of their DISPIDs
  0, NULL,

  // Pointer to Runtime License string
  NULL,  // HRESULT(0x80004005)

  // Flags for OnChanged PropertyNotification
  0x00000000,
  300,// (IDE Version)

  // Count of Font Prop and array of their DISPIDs
  0, NULL,

  // Count of Pict Prop and array of their DISPIDs
  0, NULL,
  0, // Reserved
  0, // Instance count (used internally)
  0, // List of Enum descriptions (internal)
};

GUID     TEColorLookup::DEF_CTL_INTF = {0x9AE86E7C, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} };
TNoParam TEColorLookup::OptParam;

static inline void ValidCtrCheck(TEColorLookup *)
{
   delete new TEColorLookup((TComponent*)(0));
};

void __fastcall TEColorLookup::InitControlData()
{
  ControlData = &CControlData;
};

void __fastcall TEColorLookup::CreateControl()
{
  if (!m_OCXIntf)
  {
    _ASSERTE(DefaultDispatch);
    DefaultDispatch->QueryInterface(DEF_CTL_INTF, (LPVOID*)&m_OCXIntf);
  }
};

_DEColorLookupDisp __fastcall TEColorLookup::GetDefaultInterface()
{
  CreateControl();
  return m_OCXIntf;
};

void __fastcall TEColorLookup::AdjustGainOffset(Evision_tlb::enumColorSystems ColorSystem, 
                                                float Gain0, float Offset0, float Gain1, 
                                                float Offset1, float Gain2, float Offset2)
{
  GetDefaultInterface()->AdjustGainOffset(ColorSystem, Gain0, Offset0, Gain1, Offset1, Gain2, 
                                          Offset2);
}

void __fastcall TEColorLookup::ConvertToRGB(Evision_tlb::enumColorSystems ColorSystem)
{
  GetDefaultInterface()->ConvertToRGB(ColorSystem);
}

void __fastcall TEColorLookup::ConvertFromRGB(Evision_tlb::enumColorSystems ColorSystem)
{
  GetDefaultInterface()->ConvertFromRGB(ColorSystem);
}

void __fastcall TEColorLookup::Calibrate1(short RedValue, short GreenValue, short BlueValue, float X, 
                                          float Y, float Z)
{
  GetDefaultInterface()->Calibrate1(RedValue, GreenValue, BlueValue, X, Y, Z);
}

void __fastcall TEColorLookup::Calibrate3(short RedValue1, short GreenValue1, short BlueValue1, 
                                          float X1, float Y1, float Z1, short RedValue2, 
                                          short GreenValue2, short BlueValue2, float X2, float Y2, 
                                          float Z2, short RedValue3, short GreenValue3, 
                                          short BlueValue3, float X3, float Y3, float Z3)
{
  GetDefaultInterface()->Calibrate3(RedValue1, GreenValue1, BlueValue1, X1, Y1, Z1, RedValue2, 
                                    GreenValue2, BlueValue2, X2, Y2, Z2, RedValue3, GreenValue3, 
                                    BlueValue3, X3, Y3, Z3);
}

void __fastcall TEColorLookup::Calibrate4(short RedValue0, short GreenValue0, short BlueValue0, 
                                          float X0, float Y0, float Z0, short RedValue1, 
                                          short GreenValue1, short BlueValue1, float X1, float Y1, 
                                          float Z1, short RedValue2, short GreenValue2, 
                                          short BlueValue2, float X2, float Y2, float Z2, 
                                          short RedValue3, short GreenValue3, short BlueValue3, 
                                          float X3, float Y3, float Z3)
{
  GetDefaultInterface()->Calibrate4(RedValue0, GreenValue0, BlueValue0, X0, Y0, Z0, RedValue1, 
                                    GreenValue1, BlueValue1, X1, Y1, Z1, RedValue2, GreenValue2, 
                                    BlueValue2, X2, Y2, Z2, RedValue3, GreenValue3, BlueValue3, X3, 
                                    Y3, Z3);
}

void __fastcall TEColorLookup::SetTransform(long Transformation, 
                                            Evision_tlb::enumColorSystems ColorSystemIn, 
                                            Evision_tlb::enumColorSystems ColorSystemOut)
{
  GetDefaultInterface()->SetTransform(Transformation, ColorSystemIn, ColorSystemOut);
}

void __fastcall TEColorLookup::Transform(short SrcRedValue, short SrcGreenValue, short SrcBlueValue, 
                                         short* DstRedValue, short* DstGreenValue, 
                                         short* DstBlueValue)
{
  GetDefaultInterface()->Transform(SrcRedValue, SrcGreenValue, SrcBlueValue, DstRedValue, 
                                   DstGreenValue, DstBlueValue);
}

void __fastcall TEColorLookup::TransformImage(LPDISPATCH C24SrcImage, LPDISPATCH C24DstImage)
{
  GetDefaultInterface()->TransformImage(C24SrcImage, C24DstImage);
}

void __fastcall TEColorLookup::WhiteBalance(float Gain, float Gamma, float BalanceR, float BalanceG, 
                                            float BalanceB)
{
  GetDefaultInterface()->WhiteBalance(Gain, Gamma, BalanceR, BalanceG, BalanceB);
}

void __fastcall TEColorLookup::AboutBox(void)
{
  GetDefaultInterface()->AboutBox();
}

LPDISPATCH __fastcall TEColorLookup::Get_Obj()
{
  return GetDefaultInterface()->get_Obj();
}

void __fastcall TEColorLookup::Set_Obj(LPDISPATCH param)
{
  GetDefaultInterface()->set_Obj(param);
}



// *********************************************************************//
// OCX PROXY CLASS IMPLEMENTATION
// (The following variables/methods implement the class TECodedImage which
// allows "ECodedImage Control" to be hosted in CBuilder IDE/apps).
// *********************************************************************//
TControlData TECodedImage::CControlData =
{
  // GUID of CoClass and Event Interface of Control
  {0x9AE86E92, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // CoClass
  {0x9AE86E91, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // Events

  // Count of Events and array of their DISPIDs
  0, NULL,

  // Pointer to Runtime License string
  NULL,  // HRESULT(0x80004005)

  // Flags for OnChanged PropertyNotification
  0x00000000,
  300,// (IDE Version)

  // Count of Font Prop and array of their DISPIDs
  0, NULL,

  // Count of Pict Prop and array of their DISPIDs
  0, NULL,
  0, // Reserved
  0, // Instance count (used internally)
  0, // List of Enum descriptions (internal)
};

GUID     TECodedImage::DEF_CTL_INTF = {0x9AE86E90, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} };
TNoParam TECodedImage::OptParam;

static inline void ValidCtrCheck(TECodedImage *)
{
   delete new TECodedImage((TComponent*)(0));
};

void __fastcall TECodedImage::InitControlData()
{
  ControlData = &CControlData;
};

void __fastcall TECodedImage::CreateControl()
{
  if (!m_OCXIntf)
  {
    _ASSERTE(DefaultDispatch);
    DefaultDispatch->QueryInterface(DEF_CTL_INTF, (LPVOID*)&m_OCXIntf);
  }
};

_DECodedImageDisp __fastcall TECodedImage::GetDefaultInterface()
{
  CreateControl();
  return m_OCXIntf;
};

void __fastcall TECodedImage::SetLowColorThreshold(short Red, short Green, short Blue)
{
  GetDefaultInterface()->SetLowColorThreshold(Red, Green, Blue);
}

void __fastcall TECodedImage::GetLowColorThreshold(short* Red, short* Green, short* Blue)
{
  GetDefaultInterface()->GetLowColorThreshold(Red, Green, Blue);
}

void __fastcall TECodedImage::SetHighColorThreshold(short Red, short Green, short Blue)
{
  GetDefaultInterface()->SetHighColorThreshold(Red, Green, Blue);
}

void __fastcall TECodedImage::GetHighColorThreshold(short* Red, short* Green, short* Blue)
{
  GetDefaultInterface()->GetHighColorThreshold(Red, Green, Blue);
}

void __fastcall TECodedImage::GoToFirstRun(void)
{
  GetDefaultInterface()->GoToFirstRun();
}

void __fastcall TECodedImage::GoToLastRun(void)
{
  GetDefaultInterface()->GoToLastRun();
}

void __fastcall TECodedImage::GoToNextRun(void)
{
  GetDefaultInterface()->GoToNextRun();
}

void __fastcall TECodedImage::GoToPreviousRun(void)
{
  GetDefaultInterface()->GoToPreviousRun();
}

void __fastcall TECodedImage::GetRunData(long* OriginX, long* OriginY, long* Length, long* Class, 
                                         long* RunIndex, long* ObjectIndex)
{
  GetDefaultInterface()->GetRunData(OriginX, OriginY, Length, Class, RunIndex, ObjectIndex);
}

void __fastcall TECodedImage::RemoveAllRuns(void)
{
  GetDefaultInterface()->RemoveAllRuns();
}

void __fastcall TECodedImage::GoToFirstObject(void)
{
  GetDefaultInterface()->GoToFirstObject();
}

void __fastcall TECodedImage::GoToLastObject(void)
{
  GetDefaultInterface()->GoToLastObject();
}

void __fastcall TECodedImage::GoToNextObject(void)
{
  GetDefaultInterface()->GoToNextObject();
}

void __fastcall TECodedImage::GoToPreviousObject(void)
{
  GetDefaultInterface()->GoToPreviousObject();
}

void __fastcall TECodedImage::GoToObjectByIndex(long ObjectIndex)
{
  GetDefaultInterface()->GoToObjectByIndex(ObjectIndex);
}

void __fastcall TECodedImage::GetObjectData(long* Class, long* ObjectIndex, long* NumberOfRuns, 
                                            TOLEBOOL* IsSelected)
{
  GetDefaultInterface()->GetObjectData(Class, ObjectIndex, NumberOfRuns, IsSelected);
}

long __fastcall TECodedImage::GetObjectIndex(void)
{
  return GetDefaultInterface()->GetObjectIndex();
}

void __fastcall TECodedImage::SelectObject(void)
{
  GetDefaultInterface()->SelectObject();
}

void __fastcall TECodedImage::UnselectObject(void)
{
  GetDefaultInterface()->UnselectObject();
}

TOLEBOOL __fastcall TECodedImage::IsObjectSelected(void)
{
  return GetDefaultInterface()->IsObjectSelected();
}

void __fastcall TECodedImage::SelectAllObjects(void)
{
  GetDefaultInterface()->SelectAllObjects();
}

void __fastcall TECodedImage::UnselectAllObjects(void)
{
  GetDefaultInterface()->UnselectAllObjects();
}

void __fastcall TECodedImage::RemoveAllObjects(void)
{
  GetDefaultInterface()->RemoveAllObjects();
}

void __fastcall TECodedImage::GoToFirstObjectRun(void)
{
  GetDefaultInterface()->GoToFirstObjectRun();
}

void __fastcall TECodedImage::GoToLastObjectRun(void)
{
  GetDefaultInterface()->GoToLastObjectRun();
}

void __fastcall TECodedImage::GoToNextObjectRun(void)
{
  GetDefaultInterface()->GoToNextObjectRun();
}

void __fastcall TECodedImage::GoToPreviousObjectRun(void)
{
  GetDefaultInterface()->GoToPreviousObjectRun();
}

long __fastcall TECodedImage::GetNumberOfObjectRuns(void)
{
  return GetDefaultInterface()->GetNumberOfObjectRuns();
}

short __fastcall TECodedImage::GetObjectIntegerFeature(Evision_tlb::enumObjObjectFeatures Feature)
{
  return GetDefaultInterface()->GetObjectIntegerFeature(Feature);
}

long __fastcall TECodedImage::GetObjectLongFeature(Evision_tlb::enumObjObjectFeatures Feature)
{
  return GetDefaultInterface()->GetObjectLongFeature(Feature);
}

float __fastcall TECodedImage::GetObjectSingleFeature(Evision_tlb::enumObjObjectFeatures Feature)
{
  return GetDefaultInterface()->GetObjectSingleFeature(Feature);
}

void __fastcall TECodedImage::BuildRuns(LPDISPATCH SrcImage)
{
  GetDefaultInterface()->BuildRuns(SrcImage);
}

void __fastcall TECodedImage::BuildObjects(LPDISPATCH SrcImage)
{
  GetDefaultInterface()->BuildObjects(SrcImage);
}

void __fastcall TECodedImage::AnalyseObjects(Evision_tlb::enumObjObjectFeatures Feature)
{
  GetDefaultInterface()->AnalyseObjects(Feature);
}

void __fastcall TECodedImage::SelectObjectsUsingIntegerFeature(Evision_tlb::enumObjObjectFeatures Feature, 
                                                               short Min, short Max, 
                                                               Evision_tlb::enumObjSelectOptions Operation)
{
  GetDefaultInterface()->SelectObjectsUsingIntegerFeature(Feature, Min, Max, Operation);
}

void __fastcall TECodedImage::SelectObjectsUsingLongFeature(Evision_tlb::enumObjObjectFeatures Feature, 
                                                            long Min, long Max, 
                                                            Evision_tlb::enumObjSelectOptions Operation)
{
  GetDefaultInterface()->SelectObjectsUsingLongFeature(Feature, Min, Max, Operation);
}

void __fastcall TECodedImage::SelectObjectsUsingSingleFeature(Evision_tlb::enumObjObjectFeatures Feature, 
                                                              float Min, float Max, 
                                                              Evision_tlb::enumObjSelectOptions Operation)
{
  GetDefaultInterface()->SelectObjectsUsingSingleFeature(Feature, Min, Max, Operation);
}

void __fastcall TECodedImage::SelectObjectsUsingPosition(long OriginX, long OriginY, long Width, 
                                                         long Height, 
                                                         Evision_tlb::enumObjSelectByPosition Operation)
{
  GetDefaultInterface()->SelectObjectsUsingPosition(OriginX, OriginY, Width, Height, Operation);
}

void __fastcall TECodedImage::SortObjectsUsingFeature(Evision_tlb::enumObjObjectFeatures Feature, 
                                                      Evision_tlb::enumObjSortOptions Operation)
{
  GetDefaultInterface()->SortObjectsUsingFeature(Feature, Operation);
}

void __fastcall TECodedImage::GetObjectRunData(long* OriginX, long* OriginY, long* Length, 
                                               long* Class, long* RunIndex, long* ObjectIndex)
{
  GetDefaultInterface()->GetObjectRunData(OriginX, OriginY, Length, Class, RunIndex, ObjectIndex);
}

void __fastcall TECodedImage::DrawObject(LPDISPATCH Image)
{
  GetDefaultInterface()->DrawObject(Image);
}

void __fastcall TECodedImage::DrawObjects(LPDISPATCH Image, 
                                          Evision_tlb::enumObjSelectionMode SelectionMode)
{
  GetDefaultInterface()->DrawObjects(Image, SelectionMode);
}

void __fastcall TECodedImage::DrawObjectFeature(LPDISPATCH Image, 
                                                Evision_tlb::enumObjObjectFeatures Feature)
{
  GetDefaultInterface()->DrawObjectFeature(Image, Feature);
}

void __fastcall TECodedImage::DrawObjectsFeature(LPDISPATCH Image, 
                                                 Evision_tlb::enumObjObjectFeatures Feature, 
                                                 Evision_tlb::enumObjSelectionMode SelectionMode)
{
  GetDefaultInterface()->DrawObjectsFeature(Image, Feature, SelectionMode);
}

void __fastcall TECodedImage::BuildLabeledRuns(LPDISPATCH SrcImage)
{
  GetDefaultInterface()->BuildLabeledRuns(SrcImage);
}

void __fastcall TECodedImage::BuildLabeledObjects(LPDISPATCH SrcImage)
{
  GetDefaultInterface()->BuildLabeledObjects(SrcImage);
}

void __fastcall TECodedImage::FeatureAverage(Evision_tlb::enumObjObjectFeatures Feature, 
                                             float* Average)
{
  GetDefaultInterface()->FeatureAverage(Feature, Average);
}

void __fastcall TECodedImage::FeatureVariance(Evision_tlb::enumObjObjectFeatures Feature, 
                                              float* Average, float* Variance)
{
  GetDefaultInterface()->FeatureVariance(Feature, Average, Variance);
}

void __fastcall TECodedImage::FeatureMinimum(Evision_tlb::enumObjObjectFeatures Feature, 
                                             float* Minimum)
{
  GetDefaultInterface()->FeatureMinimum(Feature, Minimum);
}

void __fastcall TECodedImage::FeatureMaximum(Evision_tlb::enumObjObjectFeatures Feature, 
                                             float* Maximum)
{
  GetDefaultInterface()->FeatureMaximum(Feature, Maximum);
}

void __fastcall TECodedImage::ConvexHull(LPDISPATCH PathVector)
{
  GetDefaultInterface()->ConvexHull(PathVector);
}

void __fastcall TECodedImage::AboutBox(void)
{
  GetDefaultInterface()->AboutBox();
}

LPDISPATCH __fastcall TECodedImage::Get_LowImage()
{
  return GetDefaultInterface()->get_LowImage();
}

void __fastcall TECodedImage::Set_LowImage(LPDISPATCH param)
{
  GetDefaultInterface()->set_LowImage(param);
}

LPDISPATCH __fastcall TECodedImage::Get_HighImage()
{
  return GetDefaultInterface()->get_HighImage();
}

void __fastcall TECodedImage::Set_HighImage(LPDISPATCH param)
{
  GetDefaultInterface()->set_HighImage(param);
}

LPDISPATCH __fastcall TECodedImage::Get_Obj()
{
  return GetDefaultInterface()->get_Obj();
}

void __fastcall TECodedImage::Set_Obj(LPDISPATCH param)
{
  GetDefaultInterface()->set_Obj(param);
}



// *********************************************************************//
// OCX PROXY CLASS IMPLEMENTATION
// (The following variables/methods implement the class TEMatch which
// allows "EMatch Control" to be hosted in CBuilder IDE/apps).
// *********************************************************************//
TControlData TEMatch::CControlData =
{
  // GUID of CoClass and Event Interface of Control
  {0x9AE86E96, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // CoClass
  {0x9AE86E95, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // Events

  // Count of Events and array of their DISPIDs
  0, NULL,

  // Pointer to Runtime License string
  NULL,  // HRESULT(0x80004005)

  // Flags for OnChanged PropertyNotification
  0x00000000,
  300,// (IDE Version)

  // Count of Font Prop and array of their DISPIDs
  0, NULL,

  // Count of Pict Prop and array of their DISPIDs
  0, NULL,
  0, // Reserved
  0, // Instance count (used internally)
  0, // List of Enum descriptions (internal)
};

GUID     TEMatch::DEF_CTL_INTF = {0x9AE86E94, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} };
TNoParam TEMatch::OptParam;

static inline void ValidCtrCheck(TEMatch *)
{
   delete new TEMatch((TComponent*)(0));
};

void __fastcall TEMatch::InitControlData()
{
  ControlData = &CControlData;
};

void __fastcall TEMatch::CreateControl()
{
  if (!m_OCXIntf)
  {
    _ASSERTE(DefaultDispatch);
    DefaultDispatch->QueryInterface(DEF_CTL_INTF, (LPVOID*)&m_OCXIntf);
  }
};

_DEMatchDisp __fastcall TEMatch::GetDefaultInterface()
{
  CreateControl();
  return m_OCXIntf;
};

void __fastcall TEMatch::LearnPattern(LPDISPATCH SrcImage)
{
  GetDefaultInterface()->LearnPattern(SrcImage);
}

void __fastcall TEMatch::Match(LPDISPATCH SrcImage)
{
  GetDefaultInterface()->Match(SrcImage);
}

void __fastcall TEMatch::GetPosition(long Index, float* CenterX, float* CenterY, float* Angle, 
                                     float* ScaleX, float* ScaleY, float* Score)
{
  GetDefaultInterface()->GetPosition(Index, CenterX, CenterY, Angle, ScaleX, ScaleY, Score);
}

void __fastcall TEMatch::DrawPosition(LPDISPATCH Image, long Index)
{
  GetDefaultInterface()->DrawPosition(Image, Index);
}

void __fastcall TEMatch::DrawPositions(LPDISPATCH Image)
{
  GetDefaultInterface()->DrawPositions(Image);
}

void __fastcall TEMatch::Load(BSTR PathName)
{
  GetDefaultInterface()->Load(PathName);
}

void __fastcall TEMatch::Save(BSTR PathName)
{
  GetDefaultInterface()->Save(PathName);
}

void __fastcall TEMatch::GetPattern(LPDISPATCH DstImg)
{
  GetDefaultInterface()->GetPattern(DstImg);
}

void __fastcall TEMatch::AboutBox(void)
{
  GetDefaultInterface()->AboutBox();
}

LPDISPATCH __fastcall TEMatch::Get_Obj()
{
  return GetDefaultInterface()->get_Obj();
}

void __fastcall TEMatch::Set_Obj(LPDISPATCH param)
{
  GetDefaultInterface()->set_Obj(param);
}



// *********************************************************************//
// OCX PROXY CLASS IMPLEMENTATION
// (The following variables/methods implement the class TEPointMeasure which
// allows "EPointMeasure Control" to be hosted in CBuilder IDE/apps).
// *********************************************************************//
TControlData TEPointMeasure::CControlData =
{
  // GUID of CoClass and Event Interface of Control
  {0x9AE86E9E, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // CoClass
  {0x9AE86E9D, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // Events

  // Count of Events and array of their DISPIDs
  0, NULL,

  // Pointer to Runtime License string
  NULL,  // HRESULT(0x80004005)

  // Flags for OnChanged PropertyNotification
  0x00000000,
  300,// (IDE Version)

  // Count of Font Prop and array of their DISPIDs
  0, NULL,

  // Count of Pict Prop and array of their DISPIDs
  0, NULL,
  0, // Reserved
  0, // Instance count (used internally)
  0, // List of Enum descriptions (internal)
};

GUID     TEPointMeasure::DEF_CTL_INTF = {0x9AE86E9C, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} };
TNoParam TEPointMeasure::OptParam;

static inline void ValidCtrCheck(TEPointMeasure *)
{
   delete new TEPointMeasure((TComponent*)(0));
};

void __fastcall TEPointMeasure::InitControlData()
{
  ControlData = &CControlData;
};

void __fastcall TEPointMeasure::CreateControl()
{
  if (!m_OCXIntf)
  {
    _ASSERTE(DefaultDispatch);
    DefaultDispatch->QueryInterface(DEF_CTL_INTF, (LPVOID*)&m_OCXIntf);
  }
};

_DEPointMeasureDisp __fastcall TEPointMeasure::GetDefaultInterface()
{
  CreateControl();
  return m_OCXIntf;
};

void __fastcall TEPointMeasure::FindPointAlongLine(LPDISPATCH BW8SrcImage)
{
  GetDefaultInterface()->FindPointAlongLine(BW8SrcImage);
}

void __fastcall TEPointMeasure::Draw(LPDISPATCH Image, Evision_tlb::enumMsrDrawingMode DrawingMode, 
                                     TOLEBOOL DrawHandles)
{
  GetDefaultInterface()->Draw(Image, DrawingMode, DrawHandles);
}

Evision_tlb::enumMsrHandleNames __fastcall TEPointMeasure::HitTest(LPDISPATCH Image, long X, long Y)
{
  return GetDefaultInterface()->HitTest(Image, X, Y);
}

void __fastcall TEPointMeasure::Drag(LPDISPATCH Image, Evision_tlb::enumMsrHandleNames Handle, 
                                     long X, long Y)
{
  GetDefaultInterface()->Drag(Image, Handle, X, Y);
}

void __fastcall TEPointMeasure::AboutBox(void)
{
  GetDefaultInterface()->AboutBox();
}

LPDISPATCH __fastcall TEPointMeasure::Get_Obj()
{
  return GetDefaultInterface()->get_Obj();
}

void __fastcall TEPointMeasure::Set_Obj(LPDISPATCH param)
{
  GetDefaultInterface()->set_Obj(param);
}



// *********************************************************************//
// OCX PROXY CLASS IMPLEMENTATION
// (The following variables/methods implement the class TELineMeasure which
// allows "ELineMeasure Control" to be hosted in CBuilder IDE/apps).
// *********************************************************************//
TControlData TELineMeasure::CControlData =
{
  // GUID of CoClass and Event Interface of Control
  {0x9AE86EA2, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // CoClass
  {0x9AE86EA1, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // Events

  // Count of Events and array of their DISPIDs
  0, NULL,

  // Pointer to Runtime License string
  NULL,  // HRESULT(0x80004005)

  // Flags for OnChanged PropertyNotification
  0x00000000,
  300,// (IDE Version)

  // Count of Font Prop and array of their DISPIDs
  0, NULL,

  // Count of Pict Prop and array of their DISPIDs
  0, NULL,
  0, // Reserved
  0, // Instance count (used internally)
  0, // List of Enum descriptions (internal)
};

GUID     TELineMeasure::DEF_CTL_INTF = {0x9AE86EA0, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} };
TNoParam TELineMeasure::OptParam;

static inline void ValidCtrCheck(TELineMeasure *)
{
   delete new TELineMeasure((TComponent*)(0));
};

void __fastcall TELineMeasure::InitControlData()
{
  ControlData = &CControlData;
};

void __fastcall TELineMeasure::CreateControl()
{
  if (!m_OCXIntf)
  {
    _ASSERTE(DefaultDispatch);
    DefaultDispatch->QueryInterface(DEF_CTL_INTF, (LPVOID*)&m_OCXIntf);
  }
};

_DELineMeasureDisp __fastcall TELineMeasure::GetDefaultInterface()
{
  CreateControl();
  return m_OCXIntf;
};

void __fastcall TELineMeasure::FitLine(LPDISPATCH BW8SrcImage)
{
  GetDefaultInterface()->FitLine(BW8SrcImage);
}

void __fastcall TELineMeasure::Draw(LPDISPATCH Image, Evision_tlb::enumMsrDrawingMode DrawingMode, 
                                    TOLEBOOL DrawHandles)
{
  GetDefaultInterface()->Draw(Image, DrawingMode, DrawHandles);
}

Evision_tlb::enumMsrHandleNames __fastcall TELineMeasure::HitTest(LPDISPATCH Image, long X, long Y)
{
  return GetDefaultInterface()->HitTest(Image, X, Y);
}

void __fastcall TELineMeasure::Drag(LPDISPATCH Image, Evision_tlb::enumMsrHandleNames Handle, long X, 
                                    long Y)
{
  GetDefaultInterface()->Drag(Image, Handle, X, Y);
}

void __fastcall TELineMeasure::AboutBox(void)
{
  GetDefaultInterface()->AboutBox();
}

LPDISPATCH __fastcall TELineMeasure::Get_Obj()
{
  return GetDefaultInterface()->get_Obj();
}

void __fastcall TELineMeasure::Set_Obj(LPDISPATCH param)
{
  GetDefaultInterface()->set_Obj(param);
}

float __fastcall TELineMeasure::Get_PointX(short Indice)
{
  return GetDefaultInterface()->get_PointX(Indice);
}

float __fastcall TELineMeasure::Get_PointY(short Indice)
{
  return GetDefaultInterface()->get_PointY(Indice);
}

TOLEBOOL __fastcall TELineMeasure::Get_PointValid(short Indice)
{
  return GetDefaultInterface()->get_PointValid(Indice);
}



// *********************************************************************//
// OCX PROXY CLASS IMPLEMENTATION
// (The following variables/methods implement the class TECircleMeasure which
// allows "ECircleMeasure Control" to be hosted in CBuilder IDE/apps).
// *********************************************************************//
TControlData TECircleMeasure::CControlData =
{
  // GUID of CoClass and Event Interface of Control
  {0x9AE86EA6, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // CoClass
  {0x9AE86EA5, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // Events

  // Count of Events and array of their DISPIDs
  0, NULL,

  // Pointer to Runtime License string
  NULL,  // HRESULT(0x80004005)

  // Flags for OnChanged PropertyNotification
  0x00000000,
  300,// (IDE Version)

  // Count of Font Prop and array of their DISPIDs
  0, NULL,

  // Count of Pict Prop and array of their DISPIDs
  0, NULL,
  0, // Reserved
  0, // Instance count (used internally)
  0, // List of Enum descriptions (internal)
};

GUID     TECircleMeasure::DEF_CTL_INTF = {0x9AE86EA4, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} };
TNoParam TECircleMeasure::OptParam;

static inline void ValidCtrCheck(TECircleMeasure *)
{
   delete new TECircleMeasure((TComponent*)(0));
};

void __fastcall TECircleMeasure::InitControlData()
{
  ControlData = &CControlData;
};

void __fastcall TECircleMeasure::CreateControl()
{
  if (!m_OCXIntf)
  {
    _ASSERTE(DefaultDispatch);
    DefaultDispatch->QueryInterface(DEF_CTL_INTF, (LPVOID*)&m_OCXIntf);
  }
};

_DECircleMeasureDisp __fastcall TECircleMeasure::GetDefaultInterface()
{
  CreateControl();
  return m_OCXIntf;
};

void __fastcall TECircleMeasure::FitCircle(LPDISPATCH BW8SrcImage)
{
  GetDefaultInterface()->FitCircle(BW8SrcImage);
}

void __fastcall TECircleMeasure::Draw(LPDISPATCH Image, Evision_tlb::enumMsrDrawingMode DrawingMode, 
                                      TOLEBOOL DrawHandles)
{
  GetDefaultInterface()->Draw(Image, DrawingMode, DrawHandles);
}

Evision_tlb::enumMsrHandleNames __fastcall TECircleMeasure::HitTest(LPDISPATCH Image, long X, long Y)
{
  return GetDefaultInterface()->HitTest(Image, X, Y);
}

void __fastcall TECircleMeasure::Drag(LPDISPATCH Image, Evision_tlb::enumMsrHandleNames Handle, 
                                      long X, long Y)
{
  GetDefaultInterface()->Drag(Image, Handle, X, Y);
}

void __fastcall TECircleMeasure::AboutBox(void)
{
  GetDefaultInterface()->AboutBox();
}

LPDISPATCH __fastcall TECircleMeasure::Get_Obj()
{
  return GetDefaultInterface()->get_Obj();
}

void __fastcall TECircleMeasure::Set_Obj(LPDISPATCH param)
{
  GetDefaultInterface()->set_Obj(param);
}

float __fastcall TECircleMeasure::Get_PointX(short Indice)
{
  return GetDefaultInterface()->get_PointX(Indice);
}

float __fastcall TECircleMeasure::Get_PointY(short Indice)
{
  return GetDefaultInterface()->get_PointY(Indice);
}

TOLEBOOL __fastcall TECircleMeasure::Get_PointValid(short Indice)
{
  return GetDefaultInterface()->get_PointValid(Indice);
}



// *********************************************************************//
// OCX PROXY CLASS IMPLEMENTATION
// (The following variables/methods implement the class TEOCR which
// allows "EOCR Control" to be hosted in CBuilder IDE/apps).
// *********************************************************************//
TControlData TEOCR::CControlData =
{
  // GUID of CoClass and Event Interface of Control
  {0x9AE86EAA, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // CoClass
  {0x9AE86EA9, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // Events

  // Count of Events and array of their DISPIDs
  0, NULL,

  // Pointer to Runtime License string
  NULL,  // HRESULT(0x80004005)

  // Flags for OnChanged PropertyNotification
  0x00000000,
  300,// (IDE Version)

  // Count of Font Prop and array of their DISPIDs
  0, NULL,

  // Count of Pict Prop and array of their DISPIDs
  0, NULL,
  0, // Reserved
  0, // Instance count (used internally)
  0, // List of Enum descriptions (internal)
};

GUID     TEOCR::DEF_CTL_INTF = {0x9AE86EA8, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} };
TNoParam TEOCR::OptParam;

static inline void ValidCtrCheck(TEOCR *)
{
   delete new TEOCR((TComponent*)(0));
};

void __fastcall TEOCR::InitControlData()
{
  ControlData = &CControlData;
};

void __fastcall TEOCR::CreateControl()
{
  if (!m_OCXIntf)
  {
    _ASSERTE(DefaultDispatch);
    DefaultDispatch->QueryInterface(DEF_CTL_INTF, (LPVOID*)&m_OCXIntf);
  }
};

_DEOCRDisp __fastcall TEOCR::GetDefaultInterface()
{
  CreateControl();
  return m_OCXIntf;
};

long __fastcall TEOCR::GetFirstCharCode(long Index)
{
  return GetDefaultInterface()->GetFirstCharCode(Index);
}

long __fastcall TEOCR::GetSecondCharCode(long Index)
{
  return GetDefaultInterface()->GetSecondCharCode(Index);
}

float __fastcall TEOCR::GetFirstCharDistance(long Index)
{
  return GetDefaultInterface()->GetFirstCharDistance(Index);
}

float __fastcall TEOCR::GetSecondCharDistance(long Index)
{
  return GetDefaultInterface()->GetSecondCharDistance(Index);
}

long __fastcall TEOCR::CharOrgX(long Index)
{
  return GetDefaultInterface()->CharOrgX(Index);
}

long __fastcall TEOCR::CharOrgY(long Index)
{
  return GetDefaultInterface()->CharOrgY(Index);
}

long __fastcall TEOCR::CharDstX(long Index)
{
  return GetDefaultInterface()->CharDstX(Index);
}

long __fastcall TEOCR::CharDstY(long Index)
{
  return GetDefaultInterface()->CharDstY(Index);
}

long __fastcall TEOCR::CharTotalOrgX(long Index)
{
  return GetDefaultInterface()->CharTotalOrgX(Index);
}

long __fastcall TEOCR::CharTotalOrgY(long Index)
{
  return GetDefaultInterface()->CharTotalOrgY(Index);
}

long __fastcall TEOCR::CharTotalDstX(long Index)
{
  return GetDefaultInterface()->CharTotalDstX(Index);
}

long __fastcall TEOCR::CharTotalDstY(long Index)
{
  return GetDefaultInterface()->CharTotalDstY(Index);
}

long __fastcall TEOCR::CharWidth(long Index)
{
  return GetDefaultInterface()->CharWidth(Index);
}

long __fastcall TEOCR::CharHeight(long Index)
{
  return GetDefaultInterface()->CharHeight(Index);
}

void __fastcall TEOCR::AddClasses(long Classes)
{
  GetDefaultInterface()->AddClasses(Classes);
}

void __fastcall TEOCR::EmptyClasses(void)
{
  GetDefaultInterface()->EmptyClasses();
}

void __fastcall TEOCR::RecognizeClasses(LPDISPATCH BW8SrcImage, long MaxChars, BSTR* DstString)
{
  GetDefaultInterface()->RecognizeClasses(BW8SrcImage, MaxChars, DstString);
}

void __fastcall TEOCR::RecognizeClass(LPDISPATCH BW8SrcImage, long MaxChars, 
                                      Evision_tlb::enumOcrClasses Classes, BSTR* DstString)
{
  GetDefaultInterface()->RecognizeClass(BW8SrcImage, MaxChars, Classes, DstString);
}

void __fastcall TEOCR::LoadFont(BSTR PathName)
{
  GetDefaultInterface()->LoadFont(PathName);
}

void __fastcall TEOCR::SaveFont(BSTR PathName)
{
  GetDefaultInterface()->SaveFont(PathName);
}

long __fastcall TEOCR::GetPatternCode(long Index)
{
  return GetDefaultInterface()->GetPatternCode(Index);
}

long __fastcall TEOCR::GetPatternClass(long Index)
{
  return GetDefaultInterface()->GetPatternClass(Index);
}

void __fastcall TEOCR::AddPatternFromImage(LPDISPATCH BW8SrcImage, long OriginX, long OriginY, 
                                           long Width, long Height, long Code, 
                                           Evision_tlb::enumOcrClasses Class)
{
  GetDefaultInterface()->AddPatternFromImage(BW8SrcImage, OriginX, OriginY, Width, Height, Code, 
                                             Class);
}

void __fastcall TEOCR::DrawChar(LPDISPATCH Image, long Index)
{
  GetDefaultInterface()->DrawChar(Image, Index);
}

void __fastcall TEOCR::DrawChars(LPDISPATCH Image)
{
  GetDefaultInterface()->DrawChars(Image);
}

void __fastcall TEOCR::NewFont(long PatternWidth, long PatternHeight)
{
  GetDefaultInterface()->NewFont(PatternWidth, PatternHeight);
}

void __fastcall TEOCR::BuildObjects(LPDISPATCH BW8SrcImage)
{
  GetDefaultInterface()->BuildObjects(BW8SrcImage);
}

void __fastcall TEOCR::FindAllChars(LPDISPATCH BW8SrcImage)
{
  GetDefaultInterface()->FindAllChars(BW8SrcImage);
}

void __fastcall TEOCR::EmptyChars(void)
{
  GetDefaultInterface()->EmptyChars();
}

short __fastcall TEOCR::AddChars(long OrgX, long OrgY, long EndX, long EndY)
{
  return GetDefaultInterface()->AddChars(OrgX, OrgY, EndX, EndY);
}

void __fastcall TEOCR::ReadTextClass(LPDISPATCH BW8SrcImage, long MaxChars, 
                                     Evision_tlb::enumOcrClasses Classes, BSTR* DstString)
{
  GetDefaultInterface()->ReadTextClass(BW8SrcImage, MaxChars, Classes, DstString);
}

void __fastcall TEOCR::ReadTextClasses(LPDISPATCH BW8SrcImage, long MaxChars, BSTR* DstString)
{
  GetDefaultInterface()->ReadTextClasses(BW8SrcImage, MaxChars, DstString);
}

TOLEBOOL __fastcall TEOCR::HitChars(float CursorX, float CursorY, long CharIndex, float ZoomX, 
                                    float ZoomY, float PanX, float PanY)
{
  return GetDefaultInterface()->HitChars(CursorX, CursorY, CharIndex, ZoomX, ZoomY, PanX, PanY);
}

void __fastcall TEOCR::LearnPattern(LPDISPATCH BW8SrcImg, long* CharIndex, long Code, 
                                    Evision_tlb::enumOcrClasses Class)
{
  GetDefaultInterface()->LearnPattern(BW8SrcImg, CharIndex, Code, Class);
}

void __fastcall TEOCR::AboutBox(void)
{
  GetDefaultInterface()->AboutBox();
}

LPDISPATCH __fastcall TEOCR::Get_Obj()
{
  return GetDefaultInterface()->get_Obj();
}

void __fastcall TEOCR::Set_Obj(LPDISPATCH param)
{
  GetDefaultInterface()->set_Obj(param);
}



// *********************************************************************//
// OCX PROXY CLASS IMPLEMENTATION
// (The following variables/methods implement the class TEOCV which
// allows "EOCV Control" to be hosted in CBuilder IDE/apps).
// *********************************************************************//
TControlData TEOCV::CControlData =
{
  // GUID of CoClass and Event Interface of Control
  {0x9AE86EB2, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // CoClass
  {0x9AE86EB1, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // Events

  // Count of Events and array of their DISPIDs
  0, NULL,

  // Pointer to Runtime License string
  NULL,  // HRESULT(0x80004005)

  // Flags for OnChanged PropertyNotification
  0x00000000,
  300,// (IDE Version)

  // Count of Font Prop and array of their DISPIDs
  0, NULL,

  // Count of Pict Prop and array of their DISPIDs
  0, NULL,
  0, // Reserved
  0, // Instance count (used internally)
  0, // List of Enum descriptions (internal)
};

GUID     TEOCV::DEF_CTL_INTF = {0x9AE86EB0, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} };
TNoParam TEOCV::OptParam;

static inline void ValidCtrCheck(TEOCV *)
{
   delete new TEOCV((TComponent*)(0));
};

void __fastcall TEOCV::InitControlData()
{
  ControlData = &CControlData;
};

void __fastcall TEOCV::CreateControl()
{
  if (!m_OCXIntf)
  {
    _ASSERTE(DefaultDispatch);
    DefaultDispatch->QueryInterface(DEF_CTL_INTF, (LPVOID*)&m_OCXIntf);
  }
};

_DEOCVDisp __fastcall TEOCV::GetDefaultInterface()
{
  CreateControl();
  return m_OCXIntf;
};

void __fastcall TEOCV::Load(BSTR PathName)
{
  GetDefaultInterface()->Load(PathName);
}

void __fastcall TEOCV::Save(BSTR PathName)
{
  GetDefaultInterface()->Save(PathName);
}

void __fastcall TEOCV::Inspect(LPDISPATCH BW8SampleImage, long Threshold)
{
  GetDefaultInterface()->Inspect(BW8SampleImage, Threshold);
}

void __fastcall TEOCV::DrawText(LPDISPATCH Image, LPDISPATCH OCVText)
{
  GetDefaultInterface()->DrawText(Image, OCVText);
}

void __fastcall TEOCV::DrawTexts(LPDISPATCH Image, 
                                 Evision_tlb::enumSelectionMode eTextsSelectionMode)
{
  GetDefaultInterface()->DrawTexts(Image, eTextsSelectionMode);
}

void __fastcall TEOCV::DrawTextChars(LPDISPATCH Image, LPDISPATCH OCVText, 
                                     Evision_tlb::enumSelectionMode eCharsSelectionMode)
{
  GetDefaultInterface()->DrawTextChars(Image, OCVText, eCharsSelectionMode);
}

void __fastcall TEOCV::DrawTextsChars(LPDISPATCH Image, 
                                      Evision_tlb::enumSelectionMode eTextsSelectionMode, 
                                      Evision_tlb::enumSelectionMode eCharsSelectionMode)
{
  GetDefaultInterface()->DrawTextsChars(Image, eTextsSelectionMode, eCharsSelectionMode);
}

void __fastcall TEOCV::GetTextParameters(LPDISPATCH OCVText, long TextIndex)
{
  GetDefaultInterface()->GetTextParameters(OCVText, TextIndex);
}

void __fastcall TEOCV::SetTextParameters(LPDISPATCH OCVText, long TextIndex)
{
  GetDefaultInterface()->SetTextParameters(OCVText, TextIndex);
}

void __fastcall TEOCV::GatherTextsParameters(LPDISPATCH OCVText, 
                                             Evision_tlb::enumSelectionMode eTextsSelectionMode)
{
  GetDefaultInterface()->GatherTextsParameters(OCVText, eTextsSelectionMode);
}

void __fastcall TEOCV::ScatterTextsParameters(LPDISPATCH OCVText, 
                                              Evision_tlb::enumSelectionMode eTextsSelectionMode)
{
  GetDefaultInterface()->ScatterTextsParameters(OCVText, eTextsSelectionMode);
}

void __fastcall TEOCV::GetTextCharParameters(LPDISPATCH OCVChar, long TextIndex, long CharIndex)
{
  GetDefaultInterface()->GetTextCharParameters(OCVChar, TextIndex, CharIndex);
}

void __fastcall TEOCV::SetTextCharParameters(LPDISPATCH OCVChar, long TextIndex, long CharIndex)
{
  GetDefaultInterface()->SetTextCharParameters(OCVChar, TextIndex, CharIndex);
}

void __fastcall TEOCV::GatherTextsCharsParameters(LPDISPATCH OCVChar, 
                                                  Evision_tlb::enumSelectionMode eTextsSelectionMode, 
                                                  Evision_tlb::enumSelectionMode eCharsSelectionMode)
{
  GetDefaultInterface()->GatherTextsCharsParameters(OCVChar, eTextsSelectionMode, 
                                                    eCharsSelectionMode);
}

void __fastcall TEOCV::ScatterTextsCharsParameters(LPDISPATCH OCVChar, 
                                                   Evision_tlb::enumSelectionMode eTextsSelectionMode, 
                                                   Evision_tlb::enumSelectionMode eCharsSelectionMode)
{
  GetDefaultInterface()->ScatterTextsCharsParameters(OCVChar, eTextsSelectionMode, 
                                                     eCharsSelectionMode);
}

void __fastcall TEOCV::SelectSampleTexts(long OriginX, long OriginY, long Width, long Height, 
                                         Evision_tlb::enumSelectionMode eTextsSelectionMode)
{
  GetDefaultInterface()->SelectSampleTexts(OriginX, OriginY, Width, Height, eTextsSelectionMode);
}

void __fastcall TEOCV::SelectSampleTextsChars(long OriginX, long OriginY, long Width, long Height, 
                                              Evision_tlb::enumSelectionMode eTextsSelectionMode, 
                                              Evision_tlb::enumSelectionMode eCharsSelectionMode)
{
  GetDefaultInterface()->SelectSampleTextsChars(OriginX, OriginY, Width, Height, eTextsSelectionMode, 
                                                eCharsSelectionMode);
}

void __fastcall TEOCV::ClearStatistics(void)
{
  GetDefaultInterface()->ClearStatistics();
}

void __fastcall TEOCV::UpdateStatistics(void)
{
  GetDefaultInterface()->UpdateStatistics();
}

void __fastcall TEOCV::ComputeDefaultTolerances(LPDISPATCH BW8Image, long Threshold)
{
  GetDefaultInterface()->ComputeDefaultTolerances(BW8Image, Threshold);
}

float __fastcall TEOCV::GetSampleContrast(void)
{
  return GetDefaultInterface()->GetSampleContrast();
}

float __fastcall TEOCV::GetContrastAverage(void)
{
  return GetDefaultInterface()->GetContrastAverage();
}

float __fastcall TEOCV::GetContrastDeviation(void)
{
  return GetDefaultInterface()->GetContrastDeviation();
}

void __fastcall TEOCV::SetContrastTolerance(float fNewValue)
{
  GetDefaultInterface()->SetContrastTolerance(fNewValue);
}

float __fastcall TEOCV::GetConstrastTolerance(void)
{
  return GetDefaultInterface()->GetConstrastTolerance();
}

float __fastcall TEOCV::GetTemplateContrast(void)
{
  return GetDefaultInterface()->GetTemplateContrast();
}

void __fastcall TEOCV::AdjustShiftTolerance(LPDISPATCH BW8Image)
{
  GetDefaultInterface()->AdjustShiftTolerance(BW8Image);
}

void __fastcall TEOCV::AdjustTextsLocationRanges(float fFactor, 
                                                 Evision_tlb::enumSelectionMode eSelection)
{
  GetDefaultInterface()->AdjustTextsLocationRanges(fFactor, eSelection);
}

void __fastcall TEOCV::AdjustTextsQualityRanges(float fFactor, 
                                                Evision_tlb::enumSelectionMode eModeSelection)
{
  GetDefaultInterface()->AdjustTextsQualityRanges(fFactor, eModeSelection);
}

void __fastcall TEOCV::AdjustCharsLocationRanges(float fFactor, 
                                                 Evision_tlb::enumSelectionMode eTextSelection, 
                                                 Evision_tlb::enumSelectionMode eCharSelection)
{
  GetDefaultInterface()->AdjustCharsLocationRanges(fFactor, eTextSelection, eCharSelection);
}

void __fastcall TEOCV::AdjustCharsQualityRanges(float fFacor, 
                                                Evision_tlb::enumSelectionMode eTextSelection, 
                                                Evision_tlb::enumSelectionMode eCharSelection)
{
  GetDefaultInterface()->AdjustCharsQualityRanges(fFacor, eTextSelection, eCharSelection);
}

void __fastcall TEOCV::AboutBox(void)
{
  GetDefaultInterface()->AboutBox();
}

LPDISPATCH __fastcall TEOCV::Get_Obj()
{
  return GetDefaultInterface()->get_Obj();
}

void __fastcall TEOCV::Set_Obj(LPDISPATCH param)
{
  GetDefaultInterface()->set_Obj(param);
}

long __fastcall TEOCV::Get_NumTextChars(long TextIndex)
{
  return GetDefaultInterface()->get_NumTextChars(TextIndex);
}



// *********************************************************************//
// OCX PROXY CLASS IMPLEMENTATION
// (The following variables/methods implement the class TEOCVChar which
// allows "EOCVChar Control" to be hosted in CBuilder IDE/apps).
// *********************************************************************//
TControlData TEOCVChar::CControlData =
{
  // GUID of CoClass and Event Interface of Control
  {0x9AE86EB6, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // CoClass
  {0x9AE86EB5, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // Events

  // Count of Events and array of their DISPIDs
  0, NULL,

  // Pointer to Runtime License string
  NULL,  // HRESULT(0x80004005)

  // Flags for OnChanged PropertyNotification
  0x00000000,
  300,// (IDE Version)

  // Count of Font Prop and array of their DISPIDs
  0, NULL,

  // Count of Pict Prop and array of their DISPIDs
  0, NULL,
  0, // Reserved
  0, // Instance count (used internally)
  0, // List of Enum descriptions (internal)
};

GUID     TEOCVChar::DEF_CTL_INTF = {0x9AE86EB4, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} };
TNoParam TEOCVChar::OptParam;

static inline void ValidCtrCheck(TEOCVChar *)
{
   delete new TEOCVChar((TComponent*)(0));
};

void __fastcall TEOCVChar::InitControlData()
{
  ControlData = &CControlData;
};

void __fastcall TEOCVChar::CreateControl()
{
  if (!m_OCXIntf)
  {
    _ASSERTE(DefaultDispatch);
    DefaultDispatch->QueryInterface(DEF_CTL_INTF, (LPVOID*)&m_OCXIntf);
  }
};

_DEOCVCharDisp __fastcall TEOCVChar::GetDefaultInterface()
{
  CreateControl();
  return m_OCXIntf;
};

void __fastcall TEOCVChar::ResetParameters(void)
{
  GetDefaultInterface()->ResetParameters();
}

void __fastcall TEOCVChar::AboutBox(void)
{
  GetDefaultInterface()->AboutBox();
}

LPDISPATCH __fastcall TEOCVChar::Get_Obj()
{
  return GetDefaultInterface()->get_Obj();
}

void __fastcall TEOCVChar::Set_Obj(LPDISPATCH param)
{
  GetDefaultInterface()->set_Obj(param);
}



// *********************************************************************//
// OCX PROXY CLASS IMPLEMENTATION
// (The following variables/methods implement the class TEOCVText which
// allows "EOCVText Control" to be hosted in CBuilder IDE/apps).
// *********************************************************************//
TControlData TEOCVText::CControlData =
{
  // GUID of CoClass and Event Interface of Control
  {0x9AE86EBA, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // CoClass
  {0x9AE86EB9, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // Events

  // Count of Events and array of their DISPIDs
  0, NULL,

  // Pointer to Runtime License string
  NULL,  // HRESULT(0x80004005)

  // Flags for OnChanged PropertyNotification
  0x00000000,
  300,// (IDE Version)

  // Count of Font Prop and array of their DISPIDs
  0, NULL,

  // Count of Pict Prop and array of their DISPIDs
  0, NULL,
  0, // Reserved
  0, // Instance count (used internally)
  0, // List of Enum descriptions (internal)
};

GUID     TEOCVText::DEF_CTL_INTF = {0x9AE86EB8, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} };
TNoParam TEOCVText::OptParam;

static inline void ValidCtrCheck(TEOCVText *)
{
   delete new TEOCVText((TComponent*)(0));
};

void __fastcall TEOCVText::InitControlData()
{
  ControlData = &CControlData;
};

void __fastcall TEOCVText::CreateControl()
{
  if (!m_OCXIntf)
  {
    _ASSERTE(DefaultDispatch);
    DefaultDispatch->QueryInterface(DEF_CTL_INTF, (LPVOID*)&m_OCXIntf);
  }
};

_DEOCVTextDisp __fastcall TEOCVText::GetDefaultInterface()
{
  CreateControl();
  return m_OCXIntf;
};

void __fastcall TEOCVText::ResetParameters(void)
{
  GetDefaultInterface()->ResetParameters();
}

void __fastcall TEOCVText::AboutBox(void)
{
  GetDefaultInterface()->AboutBox();
}

LPDISPATCH __fastcall TEOCVText::Get_Obj()
{
  return GetDefaultInterface()->get_Obj();
}

void __fastcall TEOCVText::Set_Obj(LPDISPATCH param)
{
  GetDefaultInterface()->set_Obj(param);
}



// *********************************************************************//
// OCX PROXY CLASS IMPLEMENTATION
// (The following variables/methods implement the class TEasyMain which
// allows "EasyMain Control" to be hosted in CBuilder IDE/apps).
// *********************************************************************//
TControlData TEasyMain::CControlData =
{
  // GUID of CoClass and Event Interface of Control
  {0x9AE86EAE, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // CoClass
  {0x9AE86EAD, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // Events

  // Count of Events and array of their DISPIDs
  0, NULL,

  // Pointer to Runtime License string
  NULL,  // HRESULT(0x80004005)

  // Flags for OnChanged PropertyNotification
  0x00000000,
  300,// (IDE Version)

  // Count of Font Prop and array of their DISPIDs
  0, NULL,

  // Count of Pict Prop and array of their DISPIDs
  0, NULL,
  0, // Reserved
  0, // Instance count (used internally)
  0, // List of Enum descriptions (internal)
};

GUID     TEasyMain::DEF_CTL_INTF = {0x9AE86EAC, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} };
TNoParam TEasyMain::OptParam;

static inline void ValidCtrCheck(TEasyMain *)
{
   delete new TEasyMain((TComponent*)(0));
};

void __fastcall TEasyMain::InitControlData()
{
  ControlData = &CControlData;
};

void __fastcall TEasyMain::CreateControl()
{
  if (!m_OCXIntf)
  {
    _ASSERTE(DefaultDispatch);
    DefaultDispatch->QueryInterface(DEF_CTL_INTF, (LPVOID*)&m_OCXIntf);
  }
};

_DEasyMainDisp __fastcall TEasyMain::GetDefaultInterface()
{
  CreateControl();
  return m_OCXIntf;
};

void __fastcall TEasyMain::Render3DBW8(LPDISPATCH BW8SrcImage, LPDISPATCH BW8DstImage, float Phi, 
                                       float Psi, float XScale, float YScale, float ZScale, 
                                       long PixelSize)
{
  GetDefaultInterface()->Render3DBW8(BW8SrcImage, BW8DstImage, Phi, Psi, XScale, YScale, ZScale, 
                                     PixelSize);
}

void __fastcall TEasyMain::Render3DC24(LPDISPATCH C24SrcImage, LPDISPATCH BW8ZImage, 
                                       LPDISPATCH C24DstImage, float Phi, float Psi, float XScale, 
                                       float YScale, float ZScale, long PixelSize)
{
  GetDefaultInterface()->Render3DC24(C24SrcImage, BW8ZImage, C24DstImage, Phi, Psi, XScale, YScale, 
                                     ZScale, PixelSize);
}

void __fastcall TEasyMain::RenderColorHistogram(LPDISPATCH C24SrcImage, LPDISPATCH C24DstImage, 
                                                float Phi, float Psi, float XScale, float YScale, 
                                                float ZScale)
{
  GetDefaultInterface()->RenderColorHistogram(C24SrcImage, C24DstImage, Phi, Psi, XScale, YScale, 
                                              ZScale);
}

void __fastcall TEasyMain::OpBW8Cst2(Evision_tlb::enumImgOperators Operation, short GrayCst, 
                                     LPDISPATCH BW8DstImage)
{
  GetDefaultInterface()->OpBW8Cst2(Operation, GrayCst, BW8DstImage);
}

void __fastcall TEasyMain::OpBW8Cst23(Evision_tlb::enumImgOperators Operation, short GrayCst, 
                                      LPDISPATCH BW8SrcImage, LPDISPATCH BW8DstImage)
{
  GetDefaultInterface()->OpBW8Cst23(Operation, GrayCst, BW8SrcImage, BW8DstImage);
}

void __fastcall TEasyMain::Op1BW8Cst3(Evision_tlb::enumImgOperators Operation, 
                                      LPDISPATCH BW8SrcImage, short GrayCst, LPDISPATCH BW8DstImage)
{
  GetDefaultInterface()->Op1BW8Cst3(Operation, BW8SrcImage, GrayCst, BW8DstImage);
}

void __fastcall TEasyMain::OpC24Cst2(Evision_tlb::enumImgOperators Operation, short RedCst, 
                                     short GreenCst, short BlueCst, LPDISPATCH C24DstImage)
{
  GetDefaultInterface()->OpC24Cst2(Operation, RedCst, GreenCst, BlueCst, C24DstImage);
}

void __fastcall TEasyMain::OpC24Cst23(Evision_tlb::enumImgOperators Operation, short RedCst, 
                                      short GreenCst, short BlueCst, LPDISPATCH C24SrcImage, 
                                      LPDISPATCH C24DstImage)
{
  GetDefaultInterface()->OpC24Cst23(Operation, RedCst, GreenCst, BlueCst, C24SrcImage, C24DstImage);
}

void __fastcall TEasyMain::Op1C24Cst3(Evision_tlb::enumImgOperators Operation, 
                                      LPDISPATCH C24SrcImage, short RedCst, short GreenCst, 
                                      short BlueCst, LPDISPATCH C24DstImage)
{
  GetDefaultInterface()->Op1C24Cst3(Operation, C24SrcImage, RedCst, GreenCst, BlueCst, C24DstImage);
}

void __fastcall TEasyMain::Op12(Evision_tlb::enumImgOperators Operation, LPDISPATCH SrcImage, 
                                LPDISPATCH DstImage)
{
  GetDefaultInterface()->Op12(Operation, SrcImage, DstImage);
}

void __fastcall TEasyMain::Op123(Evision_tlb::enumImgOperators Operation, LPDISPATCH SrcImage1, 
                                 LPDISPATCH SrcImage2, LPDISPATCH DstImage)
{
  GetDefaultInterface()->Op123(Operation, SrcImage1, SrcImage2, DstImage);
}

void __fastcall TEasyMain::Convert(LPDISPATCH SrcImage, LPDISPATCH DstImage)
{
  GetDefaultInterface()->Convert(SrcImage, DstImage);
}

void __fastcall TEasyMain::GainOffset(LPDISPATCH BW8SrcImage, LPDISPATCH BW8DstImage, float Gain, 
                                      float Offset)
{
  GetDefaultInterface()->GainOffset(BW8SrcImage, BW8DstImage, Gain, Offset);
}

void __fastcall TEasyMain::Transform(LPDISPATCH BW8SrcImage, LPDISPATCH BW8DstImage, 
                                     long Transformation, TOLEBOOL UseLUT)
{
  GetDefaultInterface()->Transform(BW8SrcImage, BW8DstImage, Transformation, UseLUT);
}

void __fastcall TEasyMain::Lut(LPDISPATCH BW8SrcImage, LPDISPATCH BW8DstImage, 
                               LPDISPATCH BW8LUTVector)
{
  GetDefaultInterface()->Lut(BW8SrcImage, BW8DstImage, BW8LUTVector);
}

void __fastcall TEasyMain::Normalize(LPDISPATCH BW8SrcImage, LPDISPATCH BW8DstImage, 
                                     float NewAverage, float NewStdDev)
{
  GetDefaultInterface()->Normalize(BW8SrcImage, BW8DstImage, NewAverage, NewStdDev);
}

void __fastcall TEasyMain::Uniformize1(LPDISPATCH BW8SrcImage, short Light, 
                                       LPDISPATCH BW8LightBackgroundImage, LPDISPATCH BW8DstImage)
{
  GetDefaultInterface()->Uniformize1(BW8SrcImage, Light, BW8LightBackgroundImage, BW8DstImage);
}

void __fastcall TEasyMain::Uniformize2(LPDISPATCH BW8SrcImage, short Light, 
                                       LPDISPATCH BW8LightBackgroundImage, short Dark, 
                                       LPDISPATCH BW8DarkBackgroundImage, LPDISPATCH BW8DstImage)
{
  GetDefaultInterface()->Uniformize2(BW8SrcImage, Light, BW8LightBackgroundImage, Dark, 
                                     BW8DarkBackgroundImage, BW8DstImage);
}

void __fastcall TEasyMain::SetRecursiveAverageLUT(LPDISPATCH BW16LUTVector, float Reduction, 
                                                  float Width)
{
  GetDefaultInterface()->SetRecursiveAverageLUT(BW16LUTVector, Reduction, Width);
}

void __fastcall TEasyMain::RecursiveAverage(LPDISPATCH BW8SrcImage, LPDISPATCH BW16StoreImage, 
                                            LPDISPATCH BW8DstImage, LPDISPATCH BW16LUTVector)
{
  GetDefaultInterface()->RecursiveAverage(BW8SrcImage, BW16StoreImage, BW8DstImage, BW16LUTVector);
}

void __fastcall TEasyMain::ThresholdBW8(LPDISPATCH BW8SrcImage, LPDISPATCH BW8DstImage, 
                                        long Threshold, short LowValue, short HighValue)
{
  GetDefaultInterface()->ThresholdBW8(BW8SrcImage, BW8DstImage, Threshold, LowValue, HighValue);
}

void __fastcall TEasyMain::DoubleThreshold(LPDISPATCH BW8SrcImage, LPDISPATCH BW8DstImage, 
                                           long LowThreshold, long HighThreshold, short LowValue, 
                                           short MidValue, short HighValue)
{
  GetDefaultInterface()->DoubleThreshold(BW8SrcImage, BW8DstImage, LowThreshold, HighThreshold, 
                                         LowValue, MidValue, HighValue);
}

void __fastcall TEasyMain::ThresholdC24Lookup(LPDISPATCH C24SrcImage, LPDISPATCH BW8DstImage, 
                                              short MinRedValue, short MinGreenValue, 
                                              short MinBlueValue, short MaxRedValue, 
                                              short MaxGreenValue, short MaxBlueValue, 
                                              LPDISPATCH ColorLookup, short RejectValue, 
                                              short AcceptValue)
{
  GetDefaultInterface()->ThresholdC24Lookup(C24SrcImage, BW8DstImage, MinRedValue, MinGreenValue, 
                                            MinBlueValue, MaxRedValue, MaxGreenValue, MaxBlueValue, 
                                            ColorLookup, RejectValue, AcceptValue);
}

void __fastcall TEasyMain::ThresholdC24(LPDISPATCH C24SrcImage, LPDISPATCH BW8DstImage, 
                                        short MinRedValue, short MinGreenValue, short MinBlueValue, 
                                        short MaxRedValue, short MaxGreenValue, short MaxBlueValue, 
                                        short RejectValue, short AcceptValue)
{
  GetDefaultInterface()->ThresholdC24(C24SrcImage, BW8DstImage, MinRedValue, MinGreenValue, 
                                      MinBlueValue, MaxRedValue, MaxGreenValue, MaxBlueValue, 
                                      RejectValue, AcceptValue);
}

void __fastcall TEasyMain::IsodataThreshold(LPDISPATCH BW8HistogramVector, long From, long To, 
                                            long* Threshold)
{
  GetDefaultInterface()->IsodataThreshold(BW8HistogramVector, From, To, Threshold);
}

void __fastcall TEasyMain::Convolution(LPDISPATCH SrcImage, LPDISPATCH DstImage, LPDISPATCH Kernel)
{
  GetDefaultInterface()->Convolution(SrcImage, DstImage, Kernel);
}

void __fastcall TEasyMain::Highpass1(LPDISPATCH SrcImage, LPDISPATCH DstImage)
{
  GetDefaultInterface()->Highpass1(SrcImage, DstImage);
}

void __fastcall TEasyMain::Highpass2(LPDISPATCH SrcImage, LPDISPATCH DstImage)
{
  GetDefaultInterface()->Highpass2(SrcImage, DstImage);
}

void __fastcall TEasyMain::Lowpass1(LPDISPATCH SrcImage, LPDISPATCH DstImage)
{
  GetDefaultInterface()->Lowpass1(SrcImage, DstImage);
}

void __fastcall TEasyMain::Lowpass2(LPDISPATCH SrcImage, LPDISPATCH DstImage)
{
  GetDefaultInterface()->Lowpass2(SrcImage, DstImage);
}

void __fastcall TEasyMain::Lowpass3(LPDISPATCH SrcImage, LPDISPATCH DstImage)
{
  GetDefaultInterface()->Lowpass3(SrcImage, DstImage);
}

void __fastcall TEasyMain::SobelX(LPDISPATCH SrcImage, LPDISPATCH DstImage)
{
  GetDefaultInterface()->SobelX(SrcImage, DstImage);
}

void __fastcall TEasyMain::SobelY(LPDISPATCH SrcImage, LPDISPATCH DstImage)
{
  GetDefaultInterface()->SobelY(SrcImage, DstImage);
}

void __fastcall TEasyMain::Sobel(LPDISPATCH SrcImage, LPDISPATCH DstImage)
{
  GetDefaultInterface()->Sobel(SrcImage, DstImage);
}

void __fastcall TEasyMain::PrewittX(LPDISPATCH SrcImage, LPDISPATCH DstImage)
{
  GetDefaultInterface()->PrewittX(SrcImage, DstImage);
}

void __fastcall TEasyMain::PrewittY(LPDISPATCH SrcImage, LPDISPATCH DstImage)
{
  GetDefaultInterface()->PrewittY(SrcImage, DstImage);
}

void __fastcall TEasyMain::Prewitt(LPDISPATCH SrcImage, LPDISPATCH DstImage)
{
  GetDefaultInterface()->Prewitt(SrcImage, DstImage);
}

void __fastcall TEasyMain::Laplacian4(LPDISPATCH SrcImage, LPDISPATCH DstImage)
{
  GetDefaultInterface()->Laplacian4(SrcImage, DstImage);
}

void __fastcall TEasyMain::Laplacian8(LPDISPATCH SrcImage, LPDISPATCH DstImage)
{
  GetDefaultInterface()->Laplacian8(SrcImage, DstImage);
}

void __fastcall TEasyMain::Open(LPDISPATCH SrcImage, LPDISPATCH DstImage, long Passes)
{
  GetDefaultInterface()->Open(SrcImage, DstImage, Passes);
}

void __fastcall TEasyMain::Close(LPDISPATCH SrcImage, LPDISPATCH DstImage, long Passes)
{
  GetDefaultInterface()->Close(SrcImage, DstImage, Passes);
}

void __fastcall TEasyMain::Erode(LPDISPATCH SrcImage, LPDISPATCH DstImage, long Passes)
{
  GetDefaultInterface()->Erode(SrcImage, DstImage, Passes);
}

void __fastcall TEasyMain::Dilate(LPDISPATCH SrcImage, LPDISPATCH DstImage, long Passes)
{
  GetDefaultInterface()->Dilate(SrcImage, DstImage, Passes);
}

void __fastcall TEasyMain::BlackTopHat(LPDISPATCH SrcImage, LPDISPATCH DstImage, long Passes)
{
  GetDefaultInterface()->BlackTopHat(SrcImage, DstImage, Passes);
}

void __fastcall TEasyMain::WhiteTopHat(LPDISPATCH SrcImage, LPDISPATCH DstImage, long Passes)
{
  GetDefaultInterface()->WhiteTopHat(SrcImage, DstImage, Passes);
}

void __fastcall TEasyMain::Median(LPDISPATCH SrcImage, LPDISPATCH DstImage)
{
  GetDefaultInterface()->Median(SrcImage, DstImage);
}

void __fastcall TEasyMain::Thin(LPDISPATCH SrcImage, LPDISPATCH DstImage, LPDISPATCH ThinKernel, 
                                Evision_tlb::enumImgKernelRotationModes KernelRotationMode, 
                                short Iterations)
{
  GetDefaultInterface()->Thin(SrcImage, DstImage, ThinKernel, KernelRotationMode, Iterations);
}

void __fastcall TEasyMain::Thick(LPDISPATCH SrcImage, LPDISPATCH DstImage, LPDISPATCH ThickKernel, 
                                 Evision_tlb::enumImgKernelRotationModes KernelRotationMode, 
                                 short Iterations)
{
  GetDefaultInterface()->Thick(SrcImage, DstImage, ThickKernel, KernelRotationMode, Iterations);
}

void __fastcall TEasyMain::Histogram(LPDISPATCH BW8SrcImage, LPDISPATCH BW8HistogramVector)
{
  GetDefaultInterface()->Histogram(BW8SrcImage, BW8HistogramVector);
}

float __fastcall TEasyMain::AnalyseHistogram(LPDISPATCH BW8HistogramVector, 
                                             Evision_tlb::enumImgHistogramFeatures HistogramFeature, 
                                             long MinIndex, long MaxIndex)
{
  return GetDefaultInterface()->AnalyseHistogram(BW8HistogramVector, HistogramFeature, MinIndex, 
                                                 MaxIndex);
}

void __fastcall TEasyMain::Equalize(LPDISPATCH BW8SrcImage, LPDISPATCH BW8DstImage)
{
  GetDefaultInterface()->Equalize(BW8SrcImage, BW8DstImage);
}

void __fastcall TEasyMain::ProjectOnARow(LPDISPATCH BW8SrcImage, LPDISPATCH BW32ProjectionVector)
{
  GetDefaultInterface()->ProjectOnARow(BW8SrcImage, BW32ProjectionVector);
}

void __fastcall TEasyMain::ProjectOnAColumn(LPDISPATCH BW8SrcImage, LPDISPATCH BW32ProjectionVector)
{
  GetDefaultInterface()->ProjectOnAColumn(BW8SrcImage, BW32ProjectionVector);
}

void __fastcall TEasyMain::RebuildFrame(LPDISPATCH SrcImage, LPDISPATCH DstImage, long FixedRow)
{
  GetDefaultInterface()->RebuildFrame(SrcImage, DstImage, FixedRow);
}

void __fastcall TEasyMain::RealignFrame(LPDISPATCH SrcImage, LPDISPATCH DstImage, long Offset, 
                                        long FixedRow)
{
  GetDefaultInterface()->RealignFrame(SrcImage, DstImage, Offset, FixedRow);
}

void __fastcall TEasyMain::MatchFrames(LPDISPATCH SrcImage, long FixedRow, long MinOffset, 
                                       long MaxOffset, long* BestOffset)
{
  GetDefaultInterface()->MatchFrames(SrcImage, FixedRow, MinOffset, MaxOffset, BestOffset);
}

void __fastcall TEasyMain::SetupEqualize(LPDISPATCH BW8HistogramVector, 
                                         LPDISPATCH BW8VectorLookupTable)
{
  GetDefaultInterface()->SetupEqualize(BW8HistogramVector, BW8VectorLookupTable);
}

void __fastcall TEasyMain::ImageToLineSegment(LPDISPATCH SrcImage, LPDISPATCH Vector, long X0, 
                                              long Y0, long X1, long Y1)
{
  GetDefaultInterface()->ImageToLineSegment(SrcImage, Vector, X0, Y0, X1, Y1);
}

void __fastcall TEasyMain::LineSegmentToImage(LPDISPATCH DstImage, LPDISPATCH Vector, long X0, 
                                              long Y0, long X1, long Y1)
{
  GetDefaultInterface()->LineSegmentToImage(DstImage, Vector, X0, Y0, X1, Y1);
}

void __fastcall TEasyMain::ImageToPath(LPDISPATCH SrcImage, LPDISPATCH PathVector)
{
  GetDefaultInterface()->ImageToPath(SrcImage, PathVector);
}

void __fastcall TEasyMain::PathToImage(LPDISPATCH DstImage, LPDISPATCH PathVector)
{
  GetDefaultInterface()->PathToImage(DstImage, PathVector);
}

void __fastcall TEasyMain::ProfileDerivative(LPDISPATCH BW8SrcVector, LPDISPATCH BW8DstVector)
{
  GetDefaultInterface()->ProfileDerivative(BW8SrcVector, BW8DstVector);
}

void __fastcall TEasyMain::GetProfilePeaks(LPDISPATCH BW8VectorProfile, LPDISPATCH PeaksVector, 
                                           long LowThreshold, long HighThreshold, long MinAmplitude, 
                                           long MinArea)
{
  GetDefaultInterface()->GetProfilePeaks(BW8VectorProfile, PeaksVector, LowThreshold, HighThreshold, 
                                         MinAmplitude, MinArea);
}

void __fastcall TEasyMain::PixelMin(LPDISPATCH BW8SrcImage, short* MinPixelValue)
{
  GetDefaultInterface()->PixelMin(BW8SrcImage, MinPixelValue);
}

void __fastcall TEasyMain::PixelMax(LPDISPATCH BW8SrcImage, short* MaxPixelValue)
{
  GetDefaultInterface()->PixelMax(BW8SrcImage, MaxPixelValue);
}

void __fastcall TEasyMain::PixelAverageBW8(LPDISPATCH BW8SrcImage, float* Average)
{
  GetDefaultInterface()->PixelAverageBW8(BW8SrcImage, Average);
}

void __fastcall TEasyMain::PixelAverageC24(LPDISPATCH C24SrcImage, float* Mean0, float* Mean1, 
                                           float* Mean2)
{
  GetDefaultInterface()->PixelAverageC24(C24SrcImage, Mean0, Mean1, Mean2);
}

void __fastcall TEasyMain::PixelStat(LPDISPATCH BW8SrcImage, short* MinPixelValue, 
                                     short* MaxPixelValue, float* Average)
{
  GetDefaultInterface()->PixelStat(BW8SrcImage, MinPixelValue, MaxPixelValue, Average);
}

void __fastcall TEasyMain::PixelStdDevBW8(LPDISPATCH BW8SrcImage, float* StdDev, float* Average)
{
  GetDefaultInterface()->PixelStdDevBW8(BW8SrcImage, StdDev, Average);
}

void __fastcall TEasyMain::PixelStdDevC24(LPDISPATCH C24SrcImage, float* StdDev0, float* StdDev1, 
                                          float* StdDev2, float* Correlation01, float* Correlation12, 
                                          float* Correlation20, float* Mean0, float* Mean1, 
                                          float* Mean2)
{
  GetDefaultInterface()->PixelStdDevC24(C24SrcImage, StdDev0, StdDev1, StdDev2, Correlation01, 
                                        Correlation12, Correlation20, Mean0, Mean1, Mean2);
}

void __fastcall TEasyMain::PixelCount(LPDISPATCH BW8SrcImage, short LowThreshold, 
                                      short HighThreshold, long* PixelsBelow, long* PixelsBetween, 
                                      long* PixelsAbove)
{
  GetDefaultInterface()->PixelCount(BW8SrcImage, LowThreshold, HighThreshold, PixelsBelow, 
                                    PixelsBetween, PixelsAbove);
}

void __fastcall TEasyMain::Area(LPDISPATCH BW8SrcImage, short Threshold, long* PixelsAbove)
{
  GetDefaultInterface()->Area(BW8SrcImage, Threshold, PixelsAbove);
}

void __fastcall TEasyMain::AreaDoubleThreshold(LPDISPATCH BW8SrcImage, short LowThreshold, 
                                               short HighThreshold, long* PixelsBetween)
{
  GetDefaultInterface()->AreaDoubleThreshold(BW8SrcImage, LowThreshold, HighThreshold, PixelsBetween);
}

void __fastcall TEasyMain::PixelVarianceBW8(LPDISPATCH BW8SrcImage, float* Variance, float* Mean)
{
  GetDefaultInterface()->PixelVarianceBW8(BW8SrcImage, Variance, Mean);
}

void __fastcall TEasyMain::PixelVarianceC24(LPDISPATCH C24SrcImage, float* Variance0, 
                                            float* Variance1, float* Variance2, float* Covariance01, 
                                            float* Covariance12, float* Covariance20, float* Mean0, 
                                            float* Mean1, float* Mean2)
{
  GetDefaultInterface()->PixelVarianceC24(C24SrcImage, Variance0, Variance1, Variance2, Covariance01, 
                                          Covariance12, Covariance20, Mean0, Mean1, Mean2);
}

void __fastcall TEasyMain::GravityCenter(LPDISPATCH BW8SrcImage, long Threshold, float* GravityX, 
                                         float* GravityY)
{
  GetDefaultInterface()->GravityCenter(BW8SrcImage, Threshold, GravityX, GravityY);
}

void __fastcall TEasyMain::BinaryMoments1(LPDISPATCH BW8SrcImage, long Threshold, float* M, 
                                          float* Mx, float* My)
{
  GetDefaultInterface()->BinaryMoments1(BW8SrcImage, Threshold, M, Mx, My);
}

void __fastcall TEasyMain::BinaryMoments2(LPDISPATCH BW8SrcImage, long Threshold, float* M, 
                                          float* Mx, float* My, float* Mxx, float* Mxy, float* Myy)
{
  GetDefaultInterface()->BinaryMoments2(BW8SrcImage, Threshold, M, Mx, My, Mxx, Mxy, Myy);
}

void __fastcall TEasyMain::WeighedMoments1(LPDISPATCH BW8SrcImage, float* M, float* Mx, float* My)
{
  GetDefaultInterface()->WeighedMoments1(BW8SrcImage, M, Mx, My);
}

void __fastcall TEasyMain::WeighedMoments2(LPDISPATCH BW8SrcImage, float* M, float* Mx, float* My, 
                                           float* Mxx, float* Mxy, float* Myy)
{
  GetDefaultInterface()->WeighedMoments2(BW8SrcImage, M, Mx, My, Mxx, Mxy, Myy);
}

void __fastcall TEasyMain::ContourBW8(LPDISPATCH BW8SrcImage, 
                                      Evision_tlb::enumImgContourMode ContourMode, long StartX, 
                                      long StartY, 
                                      Evision_tlb::enumImgContourThreshold ThresholdMode, 
                                      long Threshold, 
                                      Evision_tlb::enumImgContourConnexity ConnexityMode, 
                                      LPDISPATCH BW8PathVector)
{
  GetDefaultInterface()->ContourBW8(BW8SrcImage, ContourMode, StartX, StartY, ThresholdMode, 
                                    Threshold, ConnexityMode, BW8PathVector);
}

void __fastcall TEasyMain::VerticalMirror(LPDISPATCH SrcImage)
{
  GetDefaultInterface()->VerticalMirror(SrcImage);
}

void __fastcall TEasyMain::HorizontalMirror(LPDISPATCH SrcImage)
{
  GetDefaultInterface()->HorizontalMirror(SrcImage);
}

void __fastcall TEasyMain::ScaleRotate(LPDISPATCH SrcImage, float SrcPivotX, float SrcPivotY, 
                                       float DstPivotX, float DstPivotY, float ScaleX, float ScaleY, 
                                       float Rotation, LPDISPATCH DstImage, long InterpolationBits)
{
  GetDefaultInterface()->ScaleRotate(SrcImage, SrcPivotX, SrcPivotY, DstPivotX, DstPivotY, ScaleX, 
                                     ScaleY, Rotation, DstImage, InterpolationBits);
}

void __fastcall TEasyMain::Shrink(LPDISPATCH SrcImage, LPDISPATCH DstImage)
{
  GetDefaultInterface()->Shrink(SrcImage, DstImage);
}

void __fastcall TEasyMain::DequantizeRGB(short SrcRed, short SrcGreen, short SrcBlue, float* DstRed, 
                                         float* DstGreen, float* DstBlue)
{
  GetDefaultInterface()->DequantizeRGB(SrcRed, SrcGreen, SrcBlue, DstRed, DstGreen, DstBlue);
}

void __fastcall TEasyMain::QuantizeRGB(float SrcRed, float SrcGreen, float SrcBlue, short* DstRed, 
                                       short* DstGreen, short* DstBlue)
{
  GetDefaultInterface()->QuantizeRGB(SrcRed, SrcGreen, SrcBlue, DstRed, DstGreen, DstBlue);
}

void __fastcall TEasyMain::DequantizeXYZ(short Red, short Green, short Blue, float* X, float* Y, 
                                         float* Z)
{
  GetDefaultInterface()->DequantizeXYZ(Red, Green, Blue, X, Y, Z);
}

void __fastcall TEasyMain::QuantizeXYZ(float X, float Y, float Z, short* Red, short* Green, 
                                       short* Blue)
{
  GetDefaultInterface()->QuantizeXYZ(X, Y, Z, Red, Green, Blue);
}

void __fastcall TEasyMain::UnquantizedRGBToXYZ(float Red, float Green, float Blue, float* X, 
                                               float* Y, float* Z)
{
  GetDefaultInterface()->UnquantizedRGBToXYZ(Red, Green, Blue, X, Y, Z);
}

void __fastcall TEasyMain::UnquantizedXYZToRGB(float X, float Y, float Z, float* Red, float* Green, 
                                               float* Blue)
{
  GetDefaultInterface()->UnquantizedXYZToRGB(X, Y, Z, Red, Green, Blue);
}

void __fastcall TEasyMain::UnquantizedRGBToReducedXYZ(float Red, float Green, float Blue, float* X, 
                                                      float* Y, float* Z)
{
  GetDefaultInterface()->UnquantizedRGBToReducedXYZ(Red, Green, Blue, X, Y, Z);
}

void __fastcall TEasyMain::DequantizeYUV(short Red, short Green, short Blue, float* YLuma, 
                                         float* UChroma, float* VChroma)
{
  GetDefaultInterface()->DequantizeYUV(Red, Green, Blue, YLuma, UChroma, VChroma);
}

void __fastcall TEasyMain::QuantizeYUV(float YLuma, float UChroma, float VChroma, short* Red, 
                                       short* Green, short* Blue)
{
  GetDefaultInterface()->QuantizeYUV(YLuma, UChroma, VChroma, Red, Green, Blue);
}

void __fastcall TEasyMain::UnquantizedRGBToYUV(float Red, float Green, float Blue, float* YLuma, 
                                               float* UChroma, float* VChroma)
{
  GetDefaultInterface()->UnquantizedRGBToYUV(Red, Green, Blue, YLuma, UChroma, VChroma);
}

void __fastcall TEasyMain::UnquantizedYUVToRGB(float YLuma, float UChroma, float VChroma, float* Red, 
                                               float* Green, float* Blue)
{
  GetDefaultInterface()->UnquantizedYUVToRGB(YLuma, UChroma, VChroma, Red, Green, Blue);
}

void __fastcall TEasyMain::DequantizeYIQ(short Red, short Green, short Blue, float* YLuma, 
                                         float* Inphase, float* Quadrature)
{
  GetDefaultInterface()->DequantizeYIQ(Red, Green, Blue, YLuma, Inphase, Quadrature);
}

void __fastcall TEasyMain::QuantizeYIQ(float YLuma, float Inphase, float Quadrature, short* Red, 
                                       short* Green, short* Blue)
{
  GetDefaultInterface()->QuantizeYIQ(YLuma, Inphase, Quadrature, Red, Green, Blue);
}

void __fastcall TEasyMain::UnquantizedRGBToYIQ(float Red, float Green, float Blue, float* YLuma, 
                                               float* Inphase, float* Quadrature)
{
  GetDefaultInterface()->UnquantizedRGBToYIQ(Red, Green, Blue, YLuma, Inphase, Quadrature);
}

void __fastcall TEasyMain::UnquantizedYIQToRGB(float YLuma, float Inphase, float Quadrature, 
                                               float* Red, float* Green, float* Blue)
{
  GetDefaultInterface()->UnquantizedYIQToRGB(YLuma, Inphase, Quadrature, Red, Green, Blue);
}

void __fastcall TEasyMain::DequantizeLSH(short Red, short Green, short Blue, float* Lightness, 
                                         float* Saturation, float* Hue)
{
  GetDefaultInterface()->DequantizeLSH(Red, Green, Blue, Lightness, Saturation, Hue);
}

void __fastcall TEasyMain::QuantizeLSH(float Lightness, float Saturation, float Hue, short* Red, 
                                       short* Green, short* Blue)
{
  GetDefaultInterface()->QuantizeLSH(Lightness, Saturation, Hue, Red, Green, Blue);
}

void __fastcall TEasyMain::UnquantizedRGBToLSH(float Red, float Green, float Blue, float* Lightness, 
                                               float* Saturation, float* Hue)
{
  GetDefaultInterface()->UnquantizedRGBToLSH(Red, Green, Blue, Lightness, Saturation, Hue);
}

void __fastcall TEasyMain::UnquantizedLSHToRGB(float Lightness, float Saturation, float Hue, 
                                               float* Red, float* Green, float* Blue)
{
  GetDefaultInterface()->UnquantizedLSHToRGB(Lightness, Saturation, Hue, Red, Green, Blue);
}

void __fastcall TEasyMain::DequantizeVSH(short Red, short Green, short Blue, float* Value, 
                                         float* Saturation, float* Hue)
{
  GetDefaultInterface()->DequantizeVSH(Red, Green, Blue, Value, Saturation, Hue);
}

void __fastcall TEasyMain::QuantizeVSH(float Value, float Saturation, float Hue, short* Red, 
                                       short* Green, short* Blue)
{
  GetDefaultInterface()->QuantizeVSH(Value, Saturation, Hue, Red, Green, Blue);
}

void __fastcall TEasyMain::UnquantizedRGBToVSH(float Red, float Green, float Blue, float* Value, 
                                               float* Saturation, float* Hue)
{
  GetDefaultInterface()->UnquantizedRGBToVSH(Red, Green, Blue, Value, Saturation, Hue);
}

void __fastcall TEasyMain::UnquantizedVSHToRGB(float Value, float Saturation, float Hue, float* Red, 
                                               float* Green, float* Blue)
{
  GetDefaultInterface()->UnquantizedVSHToRGB(Value, Saturation, Hue, Red, Green, Blue);
}

void __fastcall TEasyMain::DequantizeISH(short Red, short Green, short Blue, float* Intensity, 
                                         float* Saturation, float* Hue)
{
  GetDefaultInterface()->DequantizeISH(Red, Green, Blue, Intensity, Saturation, Hue);
}

void __fastcall TEasyMain::QuantizeISH(float Intensity, float Saturation, float Hue, short* Red, 
                                       short* Green, short* Blue)
{
  GetDefaultInterface()->QuantizeISH(Intensity, Saturation, Hue, Red, Green, Blue);
}

void __fastcall TEasyMain::UnquantizedRGBToISH(float Red, float Green, float Blue, float* Intensity, 
                                               float* Saturation, float* Hue)
{
  GetDefaultInterface()->UnquantizedRGBToISH(Red, Green, Blue, Intensity, Saturation, Hue);
}

void __fastcall TEasyMain::UnquantizedISHToRGB(float Intensity, float Saturation, float Hue, 
                                               float* Red, float* Green, float* Blue)
{
  GetDefaultInterface()->UnquantizedISHToRGB(Intensity, Saturation, Hue, Red, Green, Blue);
}

void __fastcall TEasyMain::DequantizeYSH(short Red, short Green, short Blue, float* Brightness, 
                                         float* Saturation, float* Hue)
{
  GetDefaultInterface()->DequantizeYSH(Red, Green, Blue, Brightness, Saturation, Hue);
}

void __fastcall TEasyMain::QuantizeYSH(float Brightness, float Saturation, float Hue, short* Red, 
                                       short* Green, short* Blue)
{
  GetDefaultInterface()->QuantizeYSH(Brightness, Saturation, Hue, Red, Green, Blue);
}

void __fastcall TEasyMain::UnquantizedRGBToYSH(float Red, float Green, float Blue, float* Brightness, 
                                               float* Saturation, float* Hue)
{
  GetDefaultInterface()->UnquantizedRGBToYSH(Red, Green, Blue, Brightness, Saturation, Hue);
}

void __fastcall TEasyMain::UnquantizedYSHToRGB(float Brightness, float Saturation, float Hue, 
                                               float* Red, float* Green, float* Blue)
{
  GetDefaultInterface()->UnquantizedYSHToRGB(Brightness, Saturation, Hue, Red, Green, Blue);
}

void __fastcall TEasyMain::DequantizeLAB(short Red, short Green, short Blue, float* Lightness, 
                                         float* A, float* B)
{
  GetDefaultInterface()->DequantizeLAB(Red, Green, Blue, Lightness, A, B);
}

void __fastcall TEasyMain::QuantizeLAB(float Lightness, float A, float B, short* Red, short* Green, 
                                       short* Blue)
{
  GetDefaultInterface()->QuantizeLAB(Lightness, A, B, Red, Green, Blue);
}

void __fastcall TEasyMain::UnquantizedRGBToLAB(float Red, float Green, float Blue, float* Lightness, 
                                               float* A, float* B)
{
  GetDefaultInterface()->UnquantizedRGBToLAB(Red, Green, Blue, Lightness, A, B);
}

void __fastcall TEasyMain::UnquantizedLABToRGB(float Lightness, float A, float B, float* Red, 
                                               float* Green, float* Blue)
{
  GetDefaultInterface()->UnquantizedLABToRGB(Lightness, A, B, Red, Green, Blue);
}

void __fastcall TEasyMain::UnquantizedXYZToLAB(float X, float Y, float Z, float* Lightness, float* A, 
                                               float* B)
{
  GetDefaultInterface()->UnquantizedXYZToLAB(X, Y, Z, Lightness, A, B);
}

void __fastcall TEasyMain::UnquantizedLABToXYZ(float Lightness, float A, float B, float* X, float* Y, 
                                               float* Z)
{
  GetDefaultInterface()->UnquantizedLABToXYZ(Lightness, A, B, X, Y, Z);
}

void __fastcall TEasyMain::DequantizeLCH(short Red, short Green, short Blue, float* Lightness, 
                                         float* Chroma, float* Hue)
{
  GetDefaultInterface()->DequantizeLCH(Red, Green, Blue, Lightness, Chroma, Hue);
}

void __fastcall TEasyMain::QuantizeLCH(float Lightness, float Chroma, float Hue, short* Red, 
                                       short* Green, short* Blue)
{
  GetDefaultInterface()->QuantizeLCH(Lightness, Chroma, Hue, Red, Green, Blue);
}

void __fastcall TEasyMain::UnquantizedRGBToLCH(float Red, float Green, float Blue, float* Lightness, 
                                               float* Chroma, float* Hue)
{
  GetDefaultInterface()->UnquantizedRGBToLCH(Red, Green, Blue, Lightness, Chroma, Hue);
}

void __fastcall TEasyMain::UnquantizedLCHToRGB(float Lightness, float Chroma, float Hue, float* Red, 
                                               float* Green, float* Blue)
{
  GetDefaultInterface()->UnquantizedLCHToRGB(Lightness, Chroma, Hue, Red, Green, Blue);
}

void __fastcall TEasyMain::DequantizeLUV(short Red, short Green, short Blue, float* Lightness, 
                                         float* U, float* V)
{
  GetDefaultInterface()->DequantizeLUV(Red, Green, Blue, Lightness, U, V);
}

void __fastcall TEasyMain::QuantizeLUV(float Lightness, float U, float V, short* Red, short* Green, 
                                       short* Blue)
{
  GetDefaultInterface()->QuantizeLUV(Lightness, U, V, Red, Green, Blue);
}

void __fastcall TEasyMain::UnquantizedRGBToLUV(float Red, float Green, float Blue, float* Lightness, 
                                               float* U, float* V)
{
  GetDefaultInterface()->UnquantizedRGBToLUV(Red, Green, Blue, Lightness, U, V);
}

void __fastcall TEasyMain::UnquantizedLUVToRGB(float Lightness, float U, float V, float* Red, 
                                               float* Green, float* Blue)
{
  GetDefaultInterface()->UnquantizedLUVToRGB(Lightness, U, V, Red, Green, Blue);
}

void __fastcall TEasyMain::UnquantizedXYZToLUV(float X, float Y, float Z, float* Lightness, float* U, 
                                               float* V)
{
  GetDefaultInterface()->UnquantizedXYZToLUV(X, Y, Z, Lightness, U, V);
}

void __fastcall TEasyMain::UnquantizedLUVToXYZ(float Lightness, float U, float V, float* X, float* Y, 
                                               float* Z)
{
  GetDefaultInterface()->UnquantizedLUVToXYZ(Lightness, U, V, X, Y, Z);
}

void __fastcall TEasyMain::QuantizedRGBToXYZ(short Red, short Green, short Blue, short* X, short* Y, 
                                             short* Z)
{
  GetDefaultInterface()->QuantizedRGBToXYZ(Red, Green, Blue, X, Y, Z);
}

void __fastcall TEasyMain::QuantizedXYZToRGB(short X, short Y, short Z, short* Red, short* Green, 
                                             short* Blue)
{
  GetDefaultInterface()->QuantizedXYZToRGB(X, Y, Z, Red, Green, Blue);
}

void __fastcall TEasyMain::QuantizedRGBToReducedXYZ(short Red, short Green, short Blue, short* X, 
                                                    short* Y, short* Z)
{
  GetDefaultInterface()->QuantizedRGBToReducedXYZ(Red, Green, Blue, X, Y, Z);
}

void __fastcall TEasyMain::QuantizedRGBToYUV(short Red, short Green, short Blue, short* YLuma, 
                                             short* UChroma, short* VChroma)
{
  GetDefaultInterface()->QuantizedRGBToYUV(Red, Green, Blue, YLuma, UChroma, VChroma);
}

void __fastcall TEasyMain::QuantizedYUVToRGB(short YLuma, short UChroma, short VChroma, short* Red, 
                                             short* Green, short* Blue)
{
  GetDefaultInterface()->QuantizedYUVToRGB(YLuma, UChroma, VChroma, Red, Green, Blue);
}

void __fastcall TEasyMain::QuantizedRGBToYIQ(short Red, short Green, short Blue, short* YLuma, 
                                             short* Inphase, short* Quadrature)
{
  GetDefaultInterface()->QuantizedRGBToYIQ(Red, Green, Blue, YLuma, Inphase, Quadrature);
}

void __fastcall TEasyMain::QuantizedYIQToRGB(short YLuma, short Inphase, short Quadrature, 
                                             short* Red, short* Green, short* Blue)
{
  GetDefaultInterface()->QuantizedYIQToRGB(YLuma, Inphase, Quadrature, Red, Green, Blue);
}

void __fastcall TEasyMain::QuantizedRGBToLSH(short Red, short Green, short Blue, short* Lightness, 
                                             short* Saturation, short* Hue)
{
  GetDefaultInterface()->QuantizedRGBToLSH(Red, Green, Blue, Lightness, Saturation, Hue);
}

void __fastcall TEasyMain::QuantizedLSHToRGB(short Lightness, short Saturation, short Hue, 
                                             short* Red, short* Green, short* Blue)
{
  GetDefaultInterface()->QuantizedLSHToRGB(Lightness, Saturation, Hue, Red, Green, Blue);
}

void __fastcall TEasyMain::QuantizedRGBToVSH(short Red, short Green, short Blue, short* Value, 
                                             short* Saturation, short* Hue)
{
  GetDefaultInterface()->QuantizedRGBToVSH(Red, Green, Blue, Value, Saturation, Hue);
}

void __fastcall TEasyMain::QuantizedVSHToRGB(short Value, short Saturation, short Hue, short* Red, 
                                             short* Green, short* Blue)
{
  GetDefaultInterface()->QuantizedVSHToRGB(Value, Saturation, Hue, Red, Green, Blue);
}

void __fastcall TEasyMain::QuantizedRGBToISH(short Red, short Green, short Blue, short* Intensity, 
                                             short* Saturation, short* Hue)
{
  GetDefaultInterface()->QuantizedRGBToISH(Red, Green, Blue, Intensity, Saturation, Hue);
}

void __fastcall TEasyMain::QuantizedISHToRGB(short Intensity, short Saturation, short Hue, 
                                             short* Red, short* Green, short* Blue)
{
  GetDefaultInterface()->QuantizedISHToRGB(Intensity, Saturation, Hue, Red, Green, Blue);
}

void __fastcall TEasyMain::QuantizedRGBToYSH(short Red, short Green, short Blue, short* Brightness, 
                                             short* Saturation, short* Hue)
{
  GetDefaultInterface()->QuantizedRGBToYSH(Red, Green, Blue, Brightness, Saturation, Hue);
}

void __fastcall TEasyMain::QuantizedYSHToRGB(short Brightness, short Saturation, short Hue, 
                                             short* Red, short* Green, short* Blue)
{
  GetDefaultInterface()->QuantizedYSHToRGB(Brightness, Saturation, Hue, Red, Green, Blue);
}

void __fastcall TEasyMain::QuantizedRGBToLAB(short Red, short Green, short Blue, short* Luminance, 
                                             short* A, short* B)
{
  GetDefaultInterface()->QuantizedRGBToLAB(Red, Green, Blue, Luminance, A, B);
}

void __fastcall TEasyMain::QuantizedLABToRGB(short Luminance, short A, short B, short* Red, 
                                             short* Green, short* Blue)
{
  GetDefaultInterface()->QuantizedLABToRGB(Luminance, A, B, Red, Green, Blue);
}

void __fastcall TEasyMain::QuantizedXYZToLAB(short X, short Y, short Z, short* Luminance, short* A, 
                                             short* B)
{
  GetDefaultInterface()->QuantizedXYZToLAB(X, Y, Z, Luminance, A, B);
}

void __fastcall TEasyMain::QuantizedLABToXYZ(short Luminance, short A, short B, short* X, short* Y, 
                                             short* Z)
{
  GetDefaultInterface()->QuantizedLABToXYZ(Luminance, A, B, X, Y, Z);
}

void __fastcall TEasyMain::QuantizedRGBToLCH(short Red, short Green, short Blue, short* Lightness, 
                                             short* Chroma, short* Hue)
{
  GetDefaultInterface()->QuantizedRGBToLCH(Red, Green, Blue, Lightness, Chroma, Hue);
}

void __fastcall TEasyMain::QuantizedLCHToRGB(short Lightness, short Chroma, short Hue, short* Red, 
                                             short* Green, short* Blue)
{
  GetDefaultInterface()->QuantizedLCHToRGB(Lightness, Chroma, Hue, Red, Green, Blue);
}

void __fastcall TEasyMain::QuantizedRGBToLUV(short Red, short Green, short Blue, short* Luminance, 
                                             short* U, short* V)
{
  GetDefaultInterface()->QuantizedRGBToLUV(Red, Green, Blue, Luminance, U, V);
}

void __fastcall TEasyMain::QuantizedLUVToRGB(short Luminance, short U, short V, short* Red, 
                                             short* Green, short* Blue)
{
  GetDefaultInterface()->QuantizedLUVToRGB(Luminance, U, V, Red, Green, Blue);
}

void __fastcall TEasyMain::QuantizedXYZToLUV(short X, short Y, short Z, short* Luminance, short* U, 
                                             short* V)
{
  GetDefaultInterface()->QuantizedXYZToLUV(X, Y, Z, Luminance, U, V);
}

void __fastcall TEasyMain::QuantizedLUVToXYZ(short Luminance, short U, short V, short* X, short* Y, 
                                             short* Z)
{
  GetDefaultInterface()->QuantizedLUVToXYZ(Luminance, U, V, X, Y, Z);
}

void __fastcall TEasyMain::Compose(LPDISPATCH BW8SrcC0Image, LPDISPATCH BW8SrcC1Image, 
                                   LPDISPATCH BW8SrcC2Image, LPDISPATCH C24DstImage, 
                                   LPDISPATCH ColorLookup)
{
  GetDefaultInterface()->Compose(BW8SrcC0Image, BW8SrcC1Image, BW8SrcC2Image, C24DstImage, 
                                 ColorLookup);
}

void __fastcall TEasyMain::Decompose(LPDISPATCH C24SrcImage, LPDISPATCH BW8DstC0Image, 
                                     LPDISPATCH BW8DstC1Image, LPDISPATCH BW8DstC2Image, 
                                     LPDISPATCH ColorLookup)
{
  GetDefaultInterface()->Decompose(C24SrcImage, BW8DstC0Image, BW8DstC1Image, BW8DstC2Image, 
                                   ColorLookup);
}

void __fastcall TEasyMain::SetComponent(LPDISPATCH BW8SrcImage, LPDISPATCH C24DstImage, 
                                        long Component)
{
  GetDefaultInterface()->SetComponent(BW8SrcImage, C24DstImage, Component);
}

void __fastcall TEasyMain::TransformLookup(LPDISPATCH C24SrcImage, LPDISPATCH C24DstImage, 
                                           LPDISPATCH ColorLookup)
{
  GetDefaultInterface()->TransformLookup(C24SrcImage, C24DstImage, ColorLookup);
}

void __fastcall TEasyMain::TransformQuantized(LPDISPATCH C24SrcImage, LPDISPATCH C24DstImage, 
                                              long Transformation, 
                                              Evision_tlb::enumColorSystems ColorSystemIn, 
                                              Evision_tlb::enumColorSystems ColorSystemOut)
{
  GetDefaultInterface()->TransformQuantized(C24SrcImage, C24DstImage, Transformation, ColorSystemIn, 
                                            ColorSystemOut);
}

void __fastcall TEasyMain::TransformUnquantized(LPDISPATCH C24SrcImage, LPDISPATCH C24DstImage, 
                                                long Transformation, 
                                                Evision_tlb::enumColorSystems ColorSystemIn, 
                                                Evision_tlb::enumColorSystems ColorSystemOut)
{
  GetDefaultInterface()->TransformUnquantized(C24SrcImage, C24DstImage, Transformation, 
                                              ColorSystemIn, ColorSystemOut);
}

void __fastcall TEasyMain::GetComponent(LPDISPATCH C24SrcImage, LPDISPATCH BW8DstImage, 
                                        long Component)
{
  GetDefaultInterface()->GetComponent(C24SrcImage, BW8DstImage, Component);
}

void __fastcall TEasyMain::GetComponentLookup(LPDISPATCH C24SrcImage, LPDISPATCH BW8DstImage, 
                                              long Component, LPDISPATCH ColorLookup)
{
  GetDefaultInterface()->GetComponentLookup(C24SrcImage, BW8DstImage, Component, ColorLookup);
}

void __fastcall TEasyMain::StartTiming(void)
{
  GetDefaultInterface()->StartTiming();
}

long __fastcall TEasyMain::StopTiming(void)
{
  return GetDefaultInterface()->StopTiming();
}

void __fastcall TEasyMain::FromRadians(float* Angle)
{
  GetDefaultInterface()->FromRadians(Angle);
}

void __fastcall TEasyMain::ToRadians(float* Angle)
{
  GetDefaultInterface()->ToRadians(Angle);
}

void __fastcall TEasyMain::ContourArea(LPDISPATCH PathVector, long* Area)
{
  GetDefaultInterface()->ContourArea(PathVector, Area);
}

void __fastcall TEasyMain::ContourGravityCenter(LPDISPATCH PathVector, long* Area, 
                                                float* GravityCenterX, float* GravityCenterY)
{
  GetDefaultInterface()->ContourGravityCenter(PathVector, Area, GravityCenterX, GravityCenterY);
}

void __fastcall TEasyMain::ContourInertia(LPDISPATCH PathVector, long* Area, float* GravityCenterX, 
                                          float* GravityCenterY, float* SigmaX, float* SigmaY, 
                                          float* sigmaXY)
{
  GetDefaultInterface()->ContourInertia(PathVector, Area, GravityCenterX, GravityCenterY, SigmaX, 
                                        SigmaY, sigmaXY);
}

void __fastcall TEasyMain::Contour(LPDISPATCH BW8SrcImage, 
                                   Evision_tlb::enumImgContourMode ContourMode, long StartX, 
                                   long StartY, Evision_tlb::enumImgContourThreshold ThresholdMode, 
                                   long Threshold, 
                                   Evision_tlb::enumImgContourConnexity ConnexityMode, 
                                   LPDISPATCH PathVector)
{
  GetDefaultInterface()->Contour(BW8SrcImage, ContourMode, StartX, StartY, ThresholdMode, Threshold, 
                                 ConnexityMode, PathVector);
}

void __fastcall TEasyMain::Roberts(LPDISPATCH SrcImage, LPDISPATCH DstImage)
{
  GetDefaultInterface()->Roberts(SrcImage, DstImage);
}

void __fastcall TEasyMain::Distance(LPDISPATCH BW8SrcImage, LPDISPATCH BW16DstImage, long ValOut)
{
  GetDefaultInterface()->Distance(BW8SrcImage, BW16DstImage, ValOut);
}

void __fastcall TEasyMain::ConvertBW16(LPDISPATCH SrcImage, LPDISPATCH DstImage, long Shift)
{
  GetDefaultInterface()->ConvertBW16(SrcImage, DstImage, Shift);
}

void __fastcall TEasyMain::GainOffsetC24(LPDISPATCH C24SrcImage, LPDISPATCH C24DstImage, 
                                         float RedGain, float GreenGain, float BlueGain, 
                                         float RedOffset, float GreenOffset, float BlueOffset)
{
  GetDefaultInterface()->GainOffsetC24(C24SrcImage, C24DstImage, RedGain, GreenGain, BlueGain, 
                                       RedOffset, GreenOffset, BlueOffset);
}

short __fastcall TEasyMain::AutoThresholdLevel(LPDISPATCH BW8SrcImage, 
                                               Evision_tlb::enumImgThresholdModes ThresholdMode, 
                                               float RelativeThreshold)
{
  return GetDefaultInterface()->AutoThresholdLevel(BW8SrcImage, ThresholdMode, RelativeThreshold);
}

void __fastcall TEasyMain::AutoThreshold(LPDISPATCH BW8SrcImage, LPDISPATCH BW8DstImage, 
                                         Evision_tlb::enumImgThresholdModes ThresholdMode, 
                                         float RelativeThreshold)
{
  GetDefaultInterface()->AutoThreshold(BW8SrcImage, BW8DstImage, ThresholdMode, RelativeThreshold);
}

void __fastcall TEasyMain::Uniform(LPDISPATCH SrcImage, LPDISPATCH DstImage, long HalfWidth, 
                                   long HalfHeight)
{
  GetDefaultInterface()->Uniform(SrcImage, DstImage, HalfWidth, HalfHeight);
}

void __fastcall TEasyMain::VectorUniform(LPDISPATCH BW8SrcVector, LPDISPATCH BW8DstVector, 
                                         long HalfWidth)
{
  GetDefaultInterface()->VectorUniform(BW8SrcVector, BW8DstVector, HalfWidth);
}

float __fastcall TEasyMain::Focusing(LPDISPATCH SrcImage)
{
  return GetDefaultInterface()->Focusing(SrcImage);
}

float __fastcall TEasyMain::RmsNoise(LPDISPATCH BW8SrcImage, LPDISPATCH BW8RefImage, 
                                     Evision_tlb::enumImgReferenceNoise ReferenceNoise)
{
  return GetDefaultInterface()->RmsNoise(BW8SrcImage, BW8RefImage, ReferenceNoise);
}

float __fastcall TEasyMain::RmsNoiseAveraged(LPDISPATCH BW8SrcImage, LPDISPATCH BW16RefImage, 
                                             long Count, 
                                             Evision_tlb::enumImgReferenceNoise ReferenceNoise)
{
  return GetDefaultInterface()->RmsNoiseAveraged(BW8SrcImage, BW16RefImage, Count, ReferenceNoise);
}

void __fastcall TEasyMain::SignalNoiseRatio(LPDISPATCH BW8SrcImage, LPDISPATCH BW8RefImage, 
                                            Evision_tlb::enumImgReferenceNoise ReferenceNoise)
{
  GetDefaultInterface()->SignalNoiseRatio(BW8SrcImage, BW8RefImage, ReferenceNoise);
}

void __fastcall TEasyMain::SignalNoiseRatioAveraged(LPDISPATCH BW8SrcImage, LPDISPATCH BW16RefImage, 
                                                    long Count, 
                                                    Evision_tlb::enumImgReferenceNoise ReferenceNoise)
{
  GetDefaultInterface()->SignalNoiseRatioAveraged(BW8SrcImage, BW16RefImage, Count, ReferenceNoise);
}

void __fastcall TEasyMain::RegisterTranslate(LPDISPATCH SrcImage, LPDISPATCH DstImage, 
                                             float SrcPivot0X, float SrcPivot0Y, float DstPivot0X, 
                                             float DstPivot0Y, long InterpolationBits)
{
  GetDefaultInterface()->RegisterTranslate(SrcImage, DstImage, SrcPivot0X, SrcPivot0Y, DstPivot0X, 
                                           DstPivot0Y, InterpolationBits);
}

void __fastcall TEasyMain::Register(LPDISPATCH SrcImage, LPDISPATCH DstImage, float SrcPivot0X, 
                                    float SrcPivot0Y, float SrcPivot1X, float SrcPivot1Y, 
                                    float DstPivot0X, float DstPivot0Y, float DstPivot1X, 
                                    float DstPivot1Y, long InterpolationBits, TOLEBOOL Resize)
{
  GetDefaultInterface()->Register(SrcImage, DstImage, SrcPivot0X, SrcPivot0Y, SrcPivot1X, SrcPivot1Y, 
                                  DstPivot0X, DstPivot0Y, DstPivot1X, DstPivot1Y, InterpolationBits, 
                                  Resize);
}

void __fastcall TEasyMain::EmptyCalibrationPointPairs(void)
{
  GetDefaultInterface()->EmptyCalibrationPointPairs();
}

void __fastcall TEasyMain::AddCalibrationPointPair(float WorldX, float WorldY, float ImageX, 
                                                   float ImageY)
{
  GetDefaultInterface()->AddCalibrationPointPair(WorldX, WorldY, ImageX, ImageY);
}

void __fastcall TEasyMain::SetupLinearCalibration(void)
{
  GetDefaultInterface()->SetupLinearCalibration();
}

void __fastcall TEasyMain::SetupPerspectiveCalibration(void)
{
  GetDefaultInterface()->SetupPerspectiveCalibration();
}

void __fastcall TEasyMain::GetCalibration(float* Axx, float* Axy, float* Ax, float* Ayx, float* Ayy, 
                                          float* Ay, float* Bx, float* By)
{
  GetDefaultInterface()->GetCalibration(Axx, Axy, Ax, Ayx, Ayy, Ay, Bx, By);
}

void __fastcall TEasyMain::GetInvCalibration(float* Axx, float* Axy, float* Ax, float* Ayx, 
                                             float* Ayy, float* Ay, float* Bx, float* By)
{
  GetDefaultInterface()->GetInvCalibration(Axx, Axy, Ax, Ayx, Ayy, Ay, Bx, By);
}

void __fastcall TEasyMain::GetCalibrationAngles(float* AngleX, float* AngleY, float* AngleZ)
{
  GetDefaultInterface()->GetCalibrationAngles(AngleX, AngleY, AngleZ);
}

void __fastcall TEasyMain::LinearCalibration(float WorldX, float WorldY, float* ImageX, 
                                             float* ImageY)
{
  GetDefaultInterface()->LinearCalibration(WorldX, WorldY, ImageX, ImageY);
}

void __fastcall TEasyMain::InvLinearCalibration(float ImageX, float ImageY, float* WorldX, 
                                                float* WorldY)
{
  GetDefaultInterface()->InvLinearCalibration(ImageX, ImageY, WorldX, WorldY);
}

void __fastcall TEasyMain::PerspectiveCalibration(float WorldX, float WorldY, float* ImageX, 
                                                  float* ImageY)
{
  GetDefaultInterface()->PerspectiveCalibration(WorldX, WorldY, ImageX, ImageY);
}

void __fastcall TEasyMain::InvPerspectiveCalibration(float ImageX, float ImageY, float* WorldX, 
                                                     float* WorldY)
{
  GetDefaultInterface()->InvPerspectiveCalibration(ImageX, ImageY, WorldX, WorldY);
}

void __fastcall TEasyMain::LinearCalibrationImg(LPDISPATCH BW8SrcImage, LPDISPATCH BW8DstImage)
{
  GetDefaultInterface()->LinearCalibrationImg(BW8SrcImage, BW8DstImage);
}

void __fastcall TEasyMain::InvLinearCalibrationImg(LPDISPATCH BW8SrcImage, LPDISPATCH BW8DstImage)
{
  GetDefaultInterface()->InvLinearCalibrationImg(BW8SrcImage, BW8DstImage);
}

void __fastcall TEasyMain::PerspectiveCalibrationImg(LPDISPATCH BW8SrcImage, LPDISPATCH BW8DstImage)
{
  GetDefaultInterface()->PerspectiveCalibrationImg(BW8SrcImage, BW8DstImage);
}

void __fastcall TEasyMain::InvPerspectiveCalibrationImg(LPDISPATCH BW8SrcImage, 
                                                        LPDISPATCH BW8DstImage)
{
  GetDefaultInterface()->InvPerspectiveCalibrationImg(BW8SrcImage, BW8DstImage);
}

void __fastcall TEasyMain::ConvolSymmetric(LPDISPATCH BW8SrcImage, LPDISPATCH BW8DstImage, 
                                           LPDISPATCH Kernel)
{
  GetDefaultInterface()->ConvolSymmetric(BW8SrcImage, BW8DstImage, Kernel);
}

void __fastcall TEasyMain::Uniform3x3(LPDISPATCH SrcImage, LPDISPATCH DstImage)
{
  GetDefaultInterface()->Uniform3x3(SrcImage, DstImage);
}

void __fastcall TEasyMain::Uniform5x5(LPDISPATCH SrcImage, LPDISPATCH DstImage)
{
  GetDefaultInterface()->Uniform5x5(SrcImage, DstImage);
}

void __fastcall TEasyMain::Uniform7x7(LPDISPATCH SrcImage, LPDISPATCH DstImage)
{
  GetDefaultInterface()->Uniform7x7(SrcImage, DstImage);
}

void __fastcall TEasyMain::Gaussian3x3(LPDISPATCH SrcImage, LPDISPATCH DstImage)
{
  GetDefaultInterface()->Gaussian3x3(SrcImage, DstImage);
}

void __fastcall TEasyMain::Gaussian5x5(LPDISPATCH SrcImage, LPDISPATCH DstImage)
{
  GetDefaultInterface()->Gaussian5x5(SrcImage, DstImage);
}

void __fastcall TEasyMain::Gaussian7x7(LPDISPATCH SrcImage, LPDISPATCH DstImage)
{
  GetDefaultInterface()->Gaussian7x7(SrcImage, DstImage);
}

void __fastcall TEasyMain::LocalAverage(LPDISPATCH BW8SrcImage, LPDISPATCH BW8DstImage, 
                                        long HalfWidth, long HalfHeight)
{
  GetDefaultInterface()->LocalAverage(BW8SrcImage, BW8DstImage, HalfWidth, HalfHeight);
}

void __fastcall TEasyMain::LocalDeviation(LPDISPATCH BW8SrcImage, LPDISPATCH BW8DstImage, 
                                          long HalfWidth, long HalfHeight)
{
  GetDefaultInterface()->LocalDeviation(BW8SrcImage, BW8DstImage, HalfWidth, HalfHeight);
}

void __fastcall TEasyMain::DilateBox(LPDISPATCH SrcImage, LPDISPATCH DstImage, long HalfWidth, 
                                     long HalfHeight)
{
  GetDefaultInterface()->DilateBox(SrcImage, DstImage, HalfWidth, HalfHeight);
}

void __fastcall TEasyMain::ErodeBox(LPDISPATCH SrcImage, LPDISPATCH DstImage, long HalfWidth, 
                                    long HalfHeight)
{
  GetDefaultInterface()->ErodeBox(SrcImage, DstImage, HalfWidth, HalfHeight);
}

void __fastcall TEasyMain::OpenBox(LPDISPATCH SrcImage, LPDISPATCH DstImage, long HalfWidth, 
                                   long HalfHeight)
{
  GetDefaultInterface()->OpenBox(SrcImage, DstImage, HalfWidth, HalfHeight);
}

void __fastcall TEasyMain::CloseBox(LPDISPATCH SrcImage, LPDISPATCH DstImage, long HalfWidth, 
                                    long HalfHeight)
{
  GetDefaultInterface()->CloseBox(SrcImage, DstImage, HalfWidth, HalfHeight);
}

void __fastcall TEasyMain::WhiteTopHatBox(LPDISPATCH SrcImage, LPDISPATCH DstImage, long HalfWidth, 
                                          long HalfHeight)
{
  GetDefaultInterface()->WhiteTopHatBox(SrcImage, DstImage, HalfWidth, HalfHeight);
}

void __fastcall TEasyMain::BlackTopHatBox(LPDISPATCH SrcImage, LPDISPATCH DstImage, long HalfWidth, 
                                          long HalfHeight)
{
  GetDefaultInterface()->BlackTopHatBox(SrcImage, DstImage, HalfWidth, HalfHeight);
}

void __fastcall TEasyMain::DilateDisk(LPDISPATCH SrcImage, LPDISPATCH DstImage, long HalfWidth)
{
  GetDefaultInterface()->DilateDisk(SrcImage, DstImage, HalfWidth);
}

void __fastcall TEasyMain::ErodeDisk(LPDISPATCH SrcImage, LPDISPATCH DstImage, long HalfWidth)
{
  GetDefaultInterface()->ErodeDisk(SrcImage, DstImage, HalfWidth);
}

void __fastcall TEasyMain::OpenDisk(LPDISPATCH SrcImage, LPDISPATCH DstImage, long HalfWidth)
{
  GetDefaultInterface()->OpenDisk(SrcImage, DstImage, HalfWidth);
}

void __fastcall TEasyMain::CloseDisk(LPDISPATCH SrcImage, LPDISPATCH DstImage, long HalfWidth)
{
  GetDefaultInterface()->CloseDisk(SrcImage, DstImage, HalfWidth);
}

void __fastcall TEasyMain::WhiteTopHatDisk(LPDISPATCH SrcImage, LPDISPATCH DstImage, long HalfWidth)
{
  GetDefaultInterface()->WhiteTopHatDisk(SrcImage, DstImage, HalfWidth);
}

void __fastcall TEasyMain::BlackTopHatDisk(LPDISPATCH SrcImage, LPDISPATCH DstImage, long HalfWidth)
{
  GetDefaultInterface()->BlackTopHatDisk(SrcImage, DstImage, HalfWidth);
}

void __fastcall TEasyMain::SetCircleWarp(float XCenter, float YCenter, long NumCircles, 
                                         float MinRadius, float MaxRadius, long NumRadii, 
                                         float MinAngle, float MaxAngle, LPDISPATCH BW16XImage, 
                                         LPDISPATCH BW16YImage)
{
  GetDefaultInterface()->SetCircleWarp(XCenter, YCenter, NumCircles, MinRadius, MaxRadius, NumRadii, 
                                       MinAngle, MaxAngle, BW16XImage, BW16YImage);
}

void __fastcall TEasyMain::ComposeRGB(LPDISPATCH BW8SrcC0Image, LPDISPATCH BW8SrcC1Image, 
                                      LPDISPATCH BW8SrcC2Image, LPDISPATCH C24DstImage)
{
  GetDefaultInterface()->ComposeRGB(BW8SrcC0Image, BW8SrcC1Image, BW8SrcC2Image, C24DstImage);
}

void __fastcall TEasyMain::DecomposeRGB(LPDISPATCH C24SrcImage, LPDISPATCH BW8DstC0Image, 
                                        LPDISPATCH BW8DstC1Image, LPDISPATCH BW8DstC2Image)
{
  GetDefaultInterface()->DecomposeRGB(C24SrcImage, BW8DstC0Image, BW8DstC1Image, BW8DstC2Image);
}

void __fastcall TEasyMain::Warp(LPDISPATCH SrcImage, LPDISPATCH DstImage, LPDISPATCH BW16WarpXImage, 
                                LPDISPATCH BW16WarpYImage, long ShiftX, long ShiftY)
{
  GetDefaultInterface()->Warp(SrcImage, DstImage, BW16WarpXImage, BW16WarpYImage, ShiftX, ShiftY);
}

OLE_HANDLE __fastcall TEasyMain::OpenImageBW8DC(LPDISPATCH ImageBW8)
{
  return GetDefaultInterface()->OpenImageBW8DC(ImageBW8);
}

OLE_HANDLE __fastcall TEasyMain::OpenImageC24DC(LPDISPATCH ImageC24)
{
  return GetDefaultInterface()->OpenImageC24DC(ImageC24);
}

void __fastcall TEasyMain::CloseImageBW8DC(LPDISPATCH ImageBW8)
{
  GetDefaultInterface()->CloseImageBW8DC(ImageBW8);
}

void __fastcall TEasyMain::CloseImageC24DC(LPDISPATCH ImageC24)
{
  GetDefaultInterface()->CloseImageC24DC(ImageC24);
}

void __fastcall TEasyMain::Gaussian(LPDISPATCH SrcImage, LPDISPATCH DstImage, long HalfWidth, 
                                    long HalfHeight)
{
  GetDefaultInterface()->Gaussian(SrcImage, DstImage, HalfWidth, HalfHeight);
}

void __fastcall TEasyMain::LaplacianX(LPDISPATCH SrcImage, LPDISPATCH DstImage)
{
  GetDefaultInterface()->LaplacianX(SrcImage, DstImage);
}

void __fastcall TEasyMain::LaplacianY(LPDISPATCH SrcImage, LPDISPATCH DstImage)
{
  GetDefaultInterface()->LaplacianY(SrcImage, DstImage);
}

void __fastcall TEasyMain::Gradient(LPDISPATCH SrcImage, LPDISPATCH DstImage)
{
  GetDefaultInterface()->Gradient(SrcImage, DstImage);
}

void __fastcall TEasyMain::GradientX(LPDISPATCH SrcImage, LPDISPATCH DstImage)
{
  GetDefaultInterface()->GradientX(SrcImage, DstImage);
}

void __fastcall TEasyMain::GradientY(LPDISPATCH SrcImage, LPDISPATCH DstImage)
{
  GetDefaultInterface()->GradientY(SrcImage, DstImage);
}

void __fastcall TEasyMain::C24ToBayer(LPDISPATCH C24SrcImage, LPDISPATCH BW8DstImage, 
                                      TOLEBOOL EvenCol, TOLEBOOL EvenRow)
{
  GetDefaultInterface()->C24ToBayer(C24SrcImage, BW8DstImage, EvenCol, EvenRow);
}

void __fastcall TEasyMain::BayerToC24(LPDISPATCH BW8SrcImage, LPDISPATCH C24DstImage, 
                                      TOLEBOOL EvenCol, TOLEBOOL EvenRow, TOLEBOOL Interpolate, 
                                      TOLEBOOL Improved)
{
  GetDefaultInterface()->BayerToC24(BW8SrcImage, C24DstImage, EvenCol, EvenRow, Interpolate, 
                                    Improved);
}

void __fastcall TEasyMain::TransformBayer(LPDISPATCH BW8SrcImage, LPDISPATCH BW8DstImage, 
                                          LPDISPATCH ColorLookup, TOLEBOOL EvenCol, TOLEBOOL EvenRow)
{
  GetDefaultInterface()->TransformBayer(BW8SrcImage, BW8DstImage, ColorLookup, EvenCol, EvenRow);
}

void __fastcall TEasyMain::MorphoGradientBox(LPDISPATCH SrcImage, LPDISPATCH DstImage, 
                                             long HalfWidth, long HalfHeight)
{
  GetDefaultInterface()->MorphoGradientBox(SrcImage, DstImage, HalfWidth, HalfHeight);
}

void __fastcall TEasyMain::MorphoGradientDisk(LPDISPATCH SrcImage, LPDISPATCH DstImage, 
                                              long HalfWidth)
{
  GetDefaultInterface()->MorphoGradientDisk(SrcImage, DstImage, HalfWidth);
}

void __fastcall TEasyMain::AboutBox(void)
{
  GetDefaultInterface()->AboutBox();
}

LPDISPATCH __fastcall TEasyMain::Get_Obj()
{
  return GetDefaultInterface()->get_Obj();
}

void __fastcall TEasyMain::Set_Obj(LPDISPATCH param)
{
  GetDefaultInterface()->set_Obj(param);
}



// *********************************************************************//
// OCX PROXY CLASS IMPLEMENTATION
// (The following variables/methods implement the class TEMovingAverage which
// allows "EMovingAverage Control" to be hosted in CBuilder IDE/apps).
// *********************************************************************//
TControlData TEMovingAverage::CControlData =
{
  // GUID of CoClass and Event Interface of Control
  {0x9AE86EBE, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // CoClass
  {0x9AE86EBD, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // Events

  // Count of Events and array of their DISPIDs
  0, NULL,

  // Pointer to Runtime License string
  NULL,  // HRESULT(0x80004005)

  // Flags for OnChanged PropertyNotification
  0x00000000,
  300,// (IDE Version)

  // Count of Font Prop and array of their DISPIDs
  0, NULL,

  // Count of Pict Prop and array of their DISPIDs
  0, NULL,
  0, // Reserved
  0, // Instance count (used internally)
  0, // List of Enum descriptions (internal)
};

GUID     TEMovingAverage::DEF_CTL_INTF = {0x9AE86EBC, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} };
TNoParam TEMovingAverage::OptParam;

static inline void ValidCtrCheck(TEMovingAverage *)
{
   delete new TEMovingAverage((TComponent*)(0));
};

void __fastcall TEMovingAverage::InitControlData()
{
  ControlData = &CControlData;
};

void __fastcall TEMovingAverage::CreateControl()
{
  if (!m_OCXIntf)
  {
    _ASSERTE(DefaultDispatch);
    DefaultDispatch->QueryInterface(DEF_CTL_INTF, (LPVOID*)&m_OCXIntf);
  }
};

_DEMovingAverageDisp __fastcall TEMovingAverage::GetDefaultInterface()
{
  CreateControl();
  return m_OCXIntf;
};

void __fastcall TEMovingAverage::SetSize(long Period, long Width, long Height, TOLEBOOL Internal)
{
  GetDefaultInterface()->SetSize(Period, Width, Height, Internal);
}

void __fastcall TEMovingAverage::GetSize(long* Period, long* Width, long* Height, TOLEBOOL* Internal)
{
  GetDefaultInterface()->GetSize(Period, Width, Height, Internal);
}

void __fastcall TEMovingAverage::Average(LPDISPATCH BW8DstImage)
{
  GetDefaultInterface()->Average(BW8DstImage);
}

void __fastcall TEMovingAverage::AverageSrc(LPDISPATCH BW8SrcImage, LPDISPATCH BW8DstImage)
{
  GetDefaultInterface()->AverageSrc(BW8SrcImage, BW8DstImage);
}

void __fastcall TEMovingAverage::Reset(void)
{
  GetDefaultInterface()->Reset();
}

void __fastcall TEMovingAverage::AboutBox(void)
{
  GetDefaultInterface()->AboutBox();
}

LPDISPATCH __fastcall TEMovingAverage::Get_Obj()
{
  return GetDefaultInterface()->get_Obj();
}

void __fastcall TEMovingAverage::Set_Obj(LPDISPATCH param)
{
  GetDefaultInterface()->set_Obj(param);
}



// *********************************************************************//
// OCX PROXY CLASS IMPLEMENTATION
// (The following variables/methods implement the class TEMatrixCode which
// allows "EMatrixCode Control" to be hosted in CBuilder IDE/apps).
// *********************************************************************//
TControlData TEMatrixCode::CControlData =
{
  // GUID of CoClass and Event Interface of Control
  {0x9AE86EC2, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // CoClass
  {0x9AE86EC1, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // Events

  // Count of Events and array of their DISPIDs
  0, NULL,

  // Pointer to Runtime License string
  NULL,  // HRESULT(0x80004005)

  // Flags for OnChanged PropertyNotification
  0x00000000,
  300,// (IDE Version)

  // Count of Font Prop and array of their DISPIDs
  0, NULL,

  // Count of Pict Prop and array of their DISPIDs
  0, NULL,
  0, // Reserved
  0, // Instance count (used internally)
  0, // List of Enum descriptions (internal)
};

GUID     TEMatrixCode::DEF_CTL_INTF = {0x9AE86EC0, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} };
TNoParam TEMatrixCode::OptParam;

static inline void ValidCtrCheck(TEMatrixCode *)
{
   delete new TEMatrixCode((TComponent*)(0));
};

void __fastcall TEMatrixCode::InitControlData()
{
  ControlData = &CControlData;
};

void __fastcall TEMatrixCode::CreateControl()
{
  if (!m_OCXIntf)
  {
    _ASSERTE(DefaultDispatch);
    DefaultDispatch->QueryInterface(DEF_CTL_INTF, (LPVOID*)&m_OCXIntf);
  }
};

_DEMatrixCodeDisp __fastcall TEMatrixCode::GetDefaultInterface()
{
  CreateControl();
  return m_OCXIntf;
};

void __fastcall TEMatrixCode::Load(BSTR PathName)
{
  GetDefaultInterface()->Load(PathName);
}

void __fastcall TEMatrixCode::SetCellPitch(float PitchX, float PitchY)
{
  GetDefaultInterface()->SetCellPitch(PitchX, PitchY);
}

void __fastcall TEMatrixCode::ResetCorners(void)
{
  GetDefaultInterface()->ResetCorners();
}

void __fastcall TEMatrixCode::DrawCorners(LPDISPATCH EImageBW8)
{
  GetDefaultInterface()->DrawCorners(EImageBW8);
}

Evision_tlb::enumMxcHandles __fastcall TEMatrixCode::HitTest(LPDISPATCH EImageBW8, long CursorX, 
                                                             long CursorY)
{
  return GetDefaultInterface()->HitTest(EImageBW8, CursorX, CursorY);
}

void __fastcall TEMatrixCode::Drag(LPDISPATCH EImageBW8, Evision_tlb::enumMxcHandles EHandle, 
                                   long CursorX, long CursorY)
{
  GetDefaultInterface()->Drag(EImageBW8, EHandle, CursorX, CursorY);
}

void __fastcall TEMatrixCode::Draw(LPDISPATCH EImageBW8)
{
  GetDefaultInterface()->Draw(EImageBW8);
}

void __fastcall TEMatrixCode::Save(BSTR PathName)
{
  GetDefaultInterface()->Save(PathName);
}

void __fastcall TEMatrixCode::AutoDetect(LPDISPATCH BW8SrcImage, 
                                         Evision_tlb::enumMxcSymbolSize SymbolSize, 
                                         Evision_tlb::enumMxcSymbolOrientation SymbolOrientation, 
                                         Evision_tlb::enumMxcSymbolContrast Contrast, 
                                         BSTR* DstString)
{
  GetDefaultInterface()->AutoDetect(BW8SrcImage, SymbolSize, SymbolOrientation, Contrast, DstString);
}

void __fastcall TEMatrixCode::ReadSymbol(LPDISPATCH BW8SrcImage, BSTR* DstString)
{
  GetDefaultInterface()->ReadSymbol(BW8SrcImage, DstString);
}

void __fastcall TEMatrixCode::GetCellPitch(float* PitchX, float* PitchY)
{
  GetDefaultInterface()->GetCellPitch(PitchX, PitchY);
}

void __fastcall TEMatrixCode::SetPrintGrowthRange(float f32Minimum, float f32Nominal, 
                                                  float f32Maximum)
{
  GetDefaultInterface()->SetPrintGrowthRange(f32Minimum, f32Nominal, f32Maximum);
}

void __fastcall TEMatrixCode::DrawErrors(LPDISPATCH EImageBW8)
{
  GetDefaultInterface()->DrawErrors(EImageBW8);
}

void __fastcall TEMatrixCode::DrawCornersErrors(LPDISPATCH EImageBW8)
{
  GetDefaultInterface()->DrawCornersErrors(EImageBW8);
}

void __fastcall TEMatrixCode::AutoReadSymbol(LPDISPATCH BW8SrcImage, BSTR* DstString)
{
  GetDefaultInterface()->AutoReadSymbol(BW8SrcImage, DstString);
}

void __fastcall TEMatrixCode::AboutBox(void)
{
  GetDefaultInterface()->AboutBox();
}

LPDISPATCH __fastcall TEMatrixCode::Get_SourceImage()
{
  return GetDefaultInterface()->get_SourceImage();
}

void __fastcall TEMatrixCode::Set_SourceImage(LPDISPATCH param)
{
  GetDefaultInterface()->set_SourceImage(param);
}



// *********************************************************************//
// OCX PROXY CLASS IMPLEMENTATION
// (The following variables/methods implement the class TEImageSequence which
// allows "EImageSequence Control" to be hosted in CBuilder IDE/apps).
// *********************************************************************//
TControlData TEImageSequence::CControlData =
{
  // GUID of CoClass and Event Interface of Control
  {0x9AE86EC6, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // CoClass
  {0x9AE86EC5, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // Events

  // Count of Events and array of their DISPIDs
  0, NULL,

  // Pointer to Runtime License string
  NULL,  // HRESULT(0x80004005)

  // Flags for OnChanged PropertyNotification
  0x00000000,
  300,// (IDE Version)

  // Count of Font Prop and array of their DISPIDs
  0, NULL,

  // Count of Pict Prop and array of their DISPIDs
  0, NULL,
  0, // Reserved
  0, // Instance count (used internally)
  0, // List of Enum descriptions (internal)
};

GUID     TEImageSequence::DEF_CTL_INTF = {0x9AE86EC4, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} };
TNoParam TEImageSequence::OptParam;

static inline void ValidCtrCheck(TEImageSequence *)
{
   delete new TEImageSequence((TComponent*)(0));
};

void __fastcall TEImageSequence::InitControlData()
{
  ControlData = &CControlData;
};

void __fastcall TEImageSequence::CreateControl()
{
  if (!m_OCXIntf)
  {
    _ASSERTE(DefaultDispatch);
    DefaultDispatch->QueryInterface(DEF_CTL_INTF, (LPVOID*)&m_OCXIntf);
  }
};

_DEImageSequenceDisp __fastcall TEImageSequence::GetDefaultInterface()
{
  CreateControl();
  return m_OCXIntf;
};

void __fastcall TEImageSequence::Seek(long lngDelta)
{
  GetDefaultInterface()->Seek(lngDelta);
}

void __fastcall TEImageSequence::AddImage(LPDISPATCH SrcImage)
{
  GetDefaultInterface()->AddImage(SrcImage);
}

void __fastcall TEImageSequence::GetImage(LPDISPATCH DstImage)
{
  GetDefaultInterface()->GetImage(DstImage);
}

void __fastcall TEImageSequence::CloseFile(void)
{
  GetDefaultInterface()->CloseFile();
}

void __fastcall TEImageSequence::StartLoading(BSTR pszFileName)
{
  GetDefaultInterface()->StartLoading(pszFileName);
}

void __fastcall TEImageSequence::StartSaving(BSTR pszFileName, long hwndDialogParent)
{
  GetDefaultInterface()->StartSaving(pszFileName, hwndDialogParent);
}

void __fastcall TEImageSequence::AddImageData(short* pImgData)
{
  GetDefaultInterface()->AddImageData(pImgData);
}

void __fastcall TEImageSequence::AboutBox(void)
{
  GetDefaultInterface()->AboutBox();
}



// *********************************************************************//
// OCX PROXY CLASS IMPLEMENTATION
// (The following variables/methods implement the class TEFind which
// allows "EFind Control" to be hosted in CBuilder IDE/apps).
// *********************************************************************//
TControlData TEFind::CControlData =
{
  // GUID of CoClass and Event Interface of Control
  {0x9AE86ECA, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // CoClass
  {0x9AE86EC9, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} }, // Events

  // Count of Events and array of their DISPIDs
  0, NULL,

  // Pointer to Runtime License string
  NULL,  // HRESULT(0x80004005)

  // Flags for OnChanged PropertyNotification
  0x00000000,
  300,// (IDE Version)

  // Count of Font Prop and array of their DISPIDs
  0, NULL,

  // Count of Pict Prop and array of their DISPIDs
  0, NULL,
  0, // Reserved
  0, // Instance count (used internally)
  0, // List of Enum descriptions (internal)
};

GUID     TEFind::DEF_CTL_INTF = {0x9AE86EC8, 0x97BC, 0x11D1,{ 0xA4, 0x9B, 0x00, 0x00, 0x21, 0x63, 0x31, 0x68} };
TNoParam TEFind::OptParam;

static inline void ValidCtrCheck(TEFind *)
{
   delete new TEFind((TComponent*)(0));
};

void __fastcall TEFind::InitControlData()
{
  ControlData = &CControlData;
};

void __fastcall TEFind::CreateControl()
{
  if (!m_OCXIntf)
  {
    _ASSERTE(DefaultDispatch);
    DefaultDispatch->QueryInterface(DEF_CTL_INTF, (LPVOID*)&m_OCXIntf);
  }
};

_DEFindDisp __fastcall TEFind::GetDefaultInterface()
{
  CreateControl();
  return m_OCXIntf;
};

void __fastcall TEFind::Find(LPDISPATCH BW8SrcRoi)
{
  GetDefaultInterface()->Find(BW8SrcRoi);
}

void __fastcall TEFind::Learn(LPDISPATCH BW8SrcRoi)
{
  GetDefaultInterface()->Learn(BW8SrcRoi);
}

void __fastcall TEFind::SelectInstance(long lngIndex)
{
  GetDefaultInterface()->SelectInstance(lngIndex);
}

void __fastcall TEFind::SetCenter(float f32CenterX, float f32CenterY)
{
  GetDefaultInterface()->SetCenter(f32CenterX, f32CenterY);
}

void __fastcall TEFind::LearnWithMask(LPDISPATCH BW8SrcRoi, LPDISPATCH pDontCare)
{
  GetDefaultInterface()->LearnWithMask(BW8SrcRoi, pDontCare);
}

void __fastcall TEFind::Load(BSTR PathName)
{
  GetDefaultInterface()->Load(PathName);
}

void __fastcall TEFind::Save(BSTR PathName)
{
  GetDefaultInterface()->Save(PathName);
}

void __fastcall TEFind::DrawInstances(LPDISPATCH EImageBW8, TOLEBOOL bEdge)
{
  GetDefaultInterface()->DrawInstances(EImageBW8, bEdge);
}

void __fastcall TEFind::DrawInstance(LPDISPATCH EImageBW8, TOLEBOOL bEdge)
{
  GetDefaultInterface()->DrawInstance(EImageBW8, bEdge);
}

void __fastcall TEFind::AboutBox(void)
{
  GetDefaultInterface()->AboutBox();
}


};     // namespace Evision_tlb


// *********************************************************************//
// The Register function is invoked by the IDE when this module is 
// installed in a Package. It provides the list of Components (including
// OCXes) implemented by this module. The following implementation
// informs the IDE of the OCX proxy classes implemented here.
// *********************************************************************//
namespace Evision_ocx
{

void __fastcall PACKAGE Register()
{
  // [31]
  TComponentClass cls_ocx[] = {
                              __classid(Evision_tlb::TEBW8Image), 
                              __classid(Evision_tlb::TEBW16Image), 
                              __classid(Evision_tlb::TEC24Image), 
                              __classid(Evision_tlb::TEBW8ROI), 
                              __classid(Evision_tlb::TEBW16ROI), 
                              __classid(Evision_tlb::TEC24ROI), 
                              __classid(Evision_tlb::TEBW8Vector), 
                              __classid(Evision_tlb::TEBW16Vector), 
                              __classid(Evision_tlb::TEBW32Vector), 
                              __classid(Evision_tlb::TEC24Vector), 
                              __classid(Evision_tlb::TEPathVector), 
                              __classid(Evision_tlb::TEBW8HistogramVector), 
                              __classid(Evision_tlb::TEBW8PathVector), 
                              __classid(Evision_tlb::TEC24PathVector), 
                              __classid(Evision_tlb::TEPeaksVector), 
                              __classid(Evision_tlb::TEKernel), 
                              __classid(Evision_tlb::TEColorLookup), 
                              __classid(Evision_tlb::TECodedImage), 
                              __classid(Evision_tlb::TEMatch), 
                              __classid(Evision_tlb::TEPointMeasure), 
                              __classid(Evision_tlb::TELineMeasure), 
                              __classid(Evision_tlb::TECircleMeasure), 
                              __classid(Evision_tlb::TEOCR), 
                              __classid(Evision_tlb::TEOCV), 
                              __classid(Evision_tlb::TEOCVChar), 
                              __classid(Evision_tlb::TEOCVText), 
                              __classid(Evision_tlb::TEasyMain), 
                              __classid(Evision_tlb::TEMovingAverage), 
                              __classid(Evision_tlb::TEMatrixCode), 
                              __classid(Evision_tlb::TEImageSequence), 
                              __classid(Evision_tlb::TEFind)
                           };
  RegisterComponents("ActiveX", cls_ocx,
                     sizeof(cls_ocx)/sizeof(cls_ocx[0])-1);
}

};     // namespace Evision_ocx
