// Created by Microsoft (R) C/C++ Compiler Version 14.16.27051.0 (739a92f1).
//
// d:\code\logistics\smokeboxidentification\tpvs17\smokeboxidentification\x64\release\lpvGeomX.tlh
//
// C++ source equivalent of Win32 type library 02517f91-b197-4cd5-a1b5-92d1da6ca9ce
// compiler-generated file created 01/03/24 at 16:59:27 - DO NOT EDIT!

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

#pragma once
#pragma pack(push, 8)

#include <comdef.h>

//
// Forward references and typedefs
//

struct __declspec(uuid("02517f91-b197-4cd5-a1b5-92d1da6ca9ce"))
/* LIBID */ __LPVGeomXLib;
enum LPVSortedArrayDrawFlags;
struct __declspec(uuid("18d6bce0-257a-4c4c-a8a3-c23ff1ffa7d9"))
/* dual interface */ ILSortedArray;
struct __declspec(uuid("e521cc81-60e4-4d70-829c-ab54ecd41671"))
/* dual interface */ ILGeomOp;
struct __declspec(uuid("20f82bdf-ef37-4e91-897f-6be7e74d5cbe"))
/* dual interface */ ILSorter;
struct __declspec(uuid("50db3b8b-dc90-4c91-8900-cef9f74ad644"))
/* dual interface */ ILPolygonClipper;
struct /* coclass */ LGeomOp;
struct /* coclass */ LSorter;
struct /* coclass */ LSortedArray;
struct /* coclass */ LPolygonClipper;

//
// Smart pointer typedef declarations
//

_COM_SMARTPTR_TYPEDEF(ILSortedArray, __uuidof(ILSortedArray));
_COM_SMARTPTR_TYPEDEF(ILGeomOp, __uuidof(ILGeomOp));
_COM_SMARTPTR_TYPEDEF(ILSorter, __uuidof(ILSorter));
_COM_SMARTPTR_TYPEDEF(ILPolygonClipper, __uuidof(ILPolygonClipper));

//
// Type library items
//

enum LPVSortedArrayDrawFlags
{
    LPVSortedArrayDrawPosition = 1,
    LPVSortedArrayDrawIndex = 2,
    LPVSortedArrayDrawFiltered = 4,
    LPVSortedArrayDrawMissing = 8,
    LPVSortedArrayDrawRowLines = 16,
    LPVSortedArrayDrawColumnLines = 32,
    LPVSortedArrayDrawDefault = 3,
    LPVSortedArrayDrawAll = 255
};

struct __declspec(uuid("18d6bce0-257a-4c4c-a8a3-c23ff1ffa7d9"))
ILSortedArray : IDispatch
{
    //
    // Property data
    //

    __declspec(property(get=GetRowCount))
    int RowCount;
    __declspec(property(get=GetColumnCount))
    int ColumnCount;
    __declspec(property(get=GetHasItem))
    VARIANT_BOOL HasItem[][];
    __declspec(property(get=GetItem))
    ILSortablePtr Item[][];
    __declspec(property(get=GetPosition))
    ILPointPtr Position[][];
    __declspec(property(get=GetRowLine))
    ILLinePtr RowLine[];
    __declspec(property(get=GetColumnLine))
    ILLinePtr ColumnLine[];
    __declspec(property(get=GetAvgRowSpace))
    double AvgRowSpace;
    __declspec(property(get=GetAvgColumnSpace))
    double AvgColumnSpace;
    __declspec(property(get=GetFilteredCount))
    int FilteredCount;
    __declspec(property(get=GetItemFiltered))
    ILSortablePtr ItemFiltered[];

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

    int GetRowCount ( );
    int GetColumnCount ( );
    VARIANT_BOOL GetHasItem (
        int columnIndex,
        int rowIndex );
    ILSortablePtr GetItem (
        int columnIndex,
        int rowIndex );
    ILPointPtr GetPosition (
        int columnIndex,
        int rowIndex );
    ILLinePtr GetRowLine (
        int rowIndex );
    ILLinePtr GetColumnLine (
        int columnIndex );
    double GetAvgRowSpace ( );
    double GetAvgColumnSpace ( );
    HRESULT Draw (
        void * hdc,
        enum LPVSortedArrayDrawFlags drawFlags,
        double zoomX,
        double zoomY,
        double panX,
        double panY );
    int GetFilteredCount ( );
    ILSortablePtr GetItemFiltered (
        int index );
    HRESULT Reset ( );

    //
    // Raw methods provided by interface
    //

      virtual HRESULT __stdcall get_RowCount (
        /*[out,retval]*/ int * val ) = 0;
      virtual HRESULT __stdcall get_ColumnCount (
        /*[out,retval]*/ int * val ) = 0;
      virtual HRESULT __stdcall get_HasItem (
        /*[in]*/ int columnIndex,
        /*[in]*/ int rowIndex,
        /*[out,retval]*/ VARIANT_BOOL * val ) = 0;
      virtual HRESULT __stdcall get_Item (
        /*[in]*/ int columnIndex,
        /*[in]*/ int rowIndex,
        /*[out,retval]*/ struct ILSortable * * sortable ) = 0;
      virtual HRESULT __stdcall get_Position (
        /*[in]*/ int columnIndex,
        /*[in]*/ int rowIndex,
        /*[out,retval]*/ struct ILPoint * * posPoint ) = 0;
      virtual HRESULT __stdcall get_RowLine (
        /*[in]*/ int rowIndex,
        /*[out,retval]*/ struct ILLine * * RowLine ) = 0;
      virtual HRESULT __stdcall get_ColumnLine (
        /*[in]*/ int columnIndex,
        /*[out,retval]*/ struct ILLine * * ColumnLine ) = 0;
      virtual HRESULT __stdcall get_AvgRowSpace (
        /*[out,retval]*/ double * val ) = 0;
      virtual HRESULT __stdcall get_AvgColumnSpace (
        /*[out,retval]*/ double * val ) = 0;
      virtual HRESULT __stdcall raw_Draw (
        /*[in]*/ void * hdc,
        /*[in]*/ enum LPVSortedArrayDrawFlags drawFlags,
        /*[in]*/ double zoomX,
        /*[in]*/ double zoomY,
        /*[in]*/ double panX,
        /*[in]*/ double panY ) = 0;
      virtual HRESULT __stdcall get_FilteredCount (
        /*[out,retval]*/ int * val ) = 0;
      virtual HRESULT __stdcall get_ItemFiltered (
        /*[in]*/ int index,
        /*[out,retval]*/ struct ILSortable * * sortable ) = 0;
      virtual HRESULT __stdcall raw_Reset ( ) = 0;
};

struct __declspec(uuid("e521cc81-60e4-4d70-829c-ab54ecd41671"))
ILGeomOp : IDispatch
{
    //
    // Wrapper methods for error-handling
    //

    ILRectPtr InnerRect (
        struct ILImage * mask );
    ILRectPtr InnerSquare (
        struct ILImage * mask );

    //
    // Raw methods provided by interface
    //

      virtual HRESULT __stdcall raw_InnerRect (
        /*[in]*/ struct ILImage * mask,
        /*[out,retval]*/ struct ILRect * * resultRect ) = 0;
      virtual HRESULT __stdcall raw_InnerSquare (
        /*[in]*/ struct ILImage * mask,
        /*[out,retval]*/ struct ILRect * * resultSquare ) = 0;
};

struct __declspec(uuid("20f82bdf-ef37-4e91-897f-6be7e74d5cbe"))
ILSorter : IDispatch
{
    //
    // Wrapper methods for error-handling
    //

    HRESULT SetSource (
        struct ILSortables * sortables );
    HRESULT SetSource2 (
        SAFEARRAY * sortableArray );
    enum LPVErrorCode SortToArray (
        enum LPVPositionMode posMode,
        double columnSpaceAppr,
        double rowSpaceAppr,
        double toleranceFactor,
        struct ILSortedArray * * sortedResult );

    //
    // Raw methods provided by interface
    //

      virtual HRESULT __stdcall raw_SetSource (
        /*[in]*/ struct ILSortables * sortables ) = 0;
      virtual HRESULT __stdcall raw_SetSource2 (
        /*[in]*/ SAFEARRAY * sortableArray ) = 0;
      virtual HRESULT __stdcall raw_SortToArray (
        /*[in]*/ enum LPVPositionMode posMode,
        /*[in]*/ double columnSpaceAppr,
        /*[in]*/ double rowSpaceAppr,
        /*[in]*/ double toleranceFactor,
        /*[out]*/ struct ILSortedArray * * sortedResult,
        /*[out,retval]*/ enum LPVErrorCode * error ) = 0;
};

struct __declspec(uuid("50db3b8b-dc90-4c91-8900-cef9f74ad644"))
ILPolygonClipper : IDispatch
{
    //
    // Wrapper methods for error-handling
    //

    ILPolygonPtr Smooth (
        struct ILPolygon * poly,
        double nbRange );
    ILPolygonPtr SmoothIterative (
        struct ILPolygon * poly,
        double filterNbRng,
        double updateNbRng,
        int maxIterCount,
        double stopCriteria );
    ILPolygonPtr Simplify (
        struct ILPolygon * poly,
        int maxVertexes,
        double areaThreshold,
        double angleThreshold );
    ILPolygonPtr SimplifyDP (
        struct ILPolygon * poly,
        double distThreshold );
    ILPolygonPtr TrimCollinear (
        struct ILPolygon * poly );
    ILPolygonPtr Expand (
        struct ILPolygon * poly,
        double delta,
        double miterLimit );
    ILPolygonPtr Shrink (
        struct ILPolygon * poly,
        double delta,
        double miterLimit );
    SAFEARRAY * Union (
        struct ILPolygon * poly1,
        struct ILPolygon * poly2 );
    ILPolygonPtr Union1 (
        struct ILPolygon * poly1,
        struct ILPolygon * poly2 );
    SAFEARRAY * Subtract (
        struct ILPolygon * poly1,
        struct ILPolygon * poly2 );
    ILPolygonPtr Subtract1 (
        struct ILPolygon * poly1,
        struct ILPolygon * poly2 );
    SAFEARRAY * Intersect (
        struct ILPolygon * poly1,
        struct ILPolygon * poly2 );
    ILPolygonPtr Intersect1 (
        struct ILPolygon * poly1,
        struct ILPolygon * poly2 );
    SAFEARRAY * XOR (
        struct ILPolygon * poly1,
        struct ILPolygon * poly2 );

    //
    // Raw methods provided by interface
    //

      virtual HRESULT __stdcall raw_Smooth (
        /*[in]*/ struct ILPolygon * poly,
        /*[in]*/ double nbRange,
        /*[out,retval]*/ struct ILPolygon * * resultPoly ) = 0;
      virtual HRESULT __stdcall raw_SmoothIterative (
        /*[in]*/ struct ILPolygon * poly,
        /*[in]*/ double filterNbRng,
        /*[in]*/ double updateNbRng,
        /*[in]*/ int maxIterCount,
        /*[in]*/ double stopCriteria,
        /*[out,retval]*/ struct ILPolygon * * resultPoly ) = 0;
      virtual HRESULT __stdcall raw_Simplify (
        /*[in]*/ struct ILPolygon * poly,
        /*[in]*/ int maxVertexes,
        /*[in]*/ double areaThreshold,
        /*[in]*/ double angleThreshold,
        /*[out,retval]*/ struct ILPolygon * * resultPoly ) = 0;
      virtual HRESULT __stdcall raw_SimplifyDP (
        /*[in]*/ struct ILPolygon * poly,
        /*[in]*/ double distThreshold,
        /*[out,retval]*/ struct ILPolygon * * resultPoly ) = 0;
      virtual HRESULT __stdcall raw_TrimCollinear (
        /*[in]*/ struct ILPolygon * poly,
        /*[out,retval]*/ struct ILPolygon * * resultPoly ) = 0;
      virtual HRESULT __stdcall raw_Expand (
        /*[in]*/ struct ILPolygon * poly,
        /*[in]*/ double delta,
        /*[in]*/ double miterLimit,
        /*[out,retval]*/ struct ILPolygon * * resultPoly ) = 0;
      virtual HRESULT __stdcall raw_Shrink (
        /*[in]*/ struct ILPolygon * poly,
        /*[in]*/ double delta,
        /*[in]*/ double miterLimit,
        /*[out,retval]*/ struct ILPolygon * * resultPoly ) = 0;
      virtual HRESULT __stdcall raw_Union (
        /*[in]*/ struct ILPolygon * poly1,
        /*[in]*/ struct ILPolygon * poly2,
        /*[out,retval]*/ SAFEARRAY * * resultPolys ) = 0;
      virtual HRESULT __stdcall raw_Union1 (
        /*[in]*/ struct ILPolygon * poly1,
        /*[in]*/ struct ILPolygon * poly2,
        /*[out,retval]*/ struct ILPolygon * * resultPoly ) = 0;
      virtual HRESULT __stdcall raw_Subtract (
        /*[in]*/ struct ILPolygon * poly1,
        /*[in]*/ struct ILPolygon * poly2,
        /*[out,retval]*/ SAFEARRAY * * resultPolys ) = 0;
      virtual HRESULT __stdcall raw_Subtract1 (
        /*[in]*/ struct ILPolygon * poly1,
        /*[in]*/ struct ILPolygon * poly2,
        /*[out,retval]*/ struct ILPolygon * * resultPoly ) = 0;
      virtual HRESULT __stdcall raw_Intersect (
        /*[in]*/ struct ILPolygon * poly1,
        /*[in]*/ struct ILPolygon * poly2,
        /*[out,retval]*/ SAFEARRAY * * resultPolys ) = 0;
      virtual HRESULT __stdcall raw_Intersect1 (
        /*[in]*/ struct ILPolygon * poly1,
        /*[in]*/ struct ILPolygon * poly2,
        /*[out,retval]*/ struct ILPolygon * * resultPoly ) = 0;
      virtual HRESULT __stdcall raw_XOR (
        /*[in]*/ struct ILPolygon * poly1,
        /*[in]*/ struct ILPolygon * poly2,
        /*[out,retval]*/ SAFEARRAY * * resultPolys ) = 0;
};

struct __declspec(uuid("d35c7edc-02af-4f65-8c04-cfc4150ade69"))
LGeomOp;
    // [ default ] interface ILGeomOp

struct __declspec(uuid("200e31b1-c00a-4530-b811-4c763235a062"))
LSorter;
    // [ default ] interface ILSorter
    // interface ILSortables

struct __declspec(uuid("d3568c16-e90b-4db4-8449-dd3536757a30"))
LSortedArray;
    // [ default ] interface ILSortedArray
    // interface ILDrawable

struct __declspec(uuid("9816d73e-b81c-435f-ab2d-67d6c7860a64"))
LPolygonClipper;
    // [ default ] interface ILPolygonClipper

//
// Wrapper method implementations
//

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

#pragma pack(pop)