mi32/vecfuncs.h

Go to the documentation of this file.

/****
*  mi32/vecfuncs.h - Vector manipulation functions include file
*
*  \if NODOC
*  $Id: vecfuncs.h_v 1.130 2003/09/15 13:49:56 fileserver!dwilliss Exp $
*
*  $Log: vecfuncs.h_v $
*  Revision 1.130  2003/09/15 13:49:56  fileserver!dwilliss
*  Doxygen
*
*  Revision 1.129  2003/06/05 21:13:38  dwilliss
*  Never mind.  Wrong include file.
*
*  Revision 1.128  2002/10/04 21:47:41  scowan
*  nc.
*
*  Revision 1.127  2002/06/27 15:10:03  scowan
*  Parameter chagne./
*
*  Revision 1.126  2002/05/10 20:27:20  scowan
*  Added another member.
*
*  Revision 1.125  2001/10/23 15:20:34  scowan
*  Added parameters to add snap points function.
*
*  Revision 1.124  2001/02/22 15:27:22  scowan
*  Check bound conditions on legacy flags.
*
*  Revision 1.123  2001/02/14 17:37:07  scowan
*  Parameter change to auto generate label baseline.
*
*  Revision 1.122  2001/02/07 23:01:02  scowan
*  Yet more functions.
*
*  Revision 1.121  2001/02/06 20:52:02  scowan
*  Added snap parameters class and functions to deal with them.
*  Added snop object class and functions to deal with them.
*
*  Revision 1.120  2001/01/18 17:06:02  scowan
*  Added node to point function.
*
*  Revision 1.119  2001/01/17 18:37:56  scowan
*  Added functions for std attrbi and elem id table management.
*
*  Revision 1.118  2001/01/16 21:29:40  scowan
*  Added save flag.
*
*  Revision 1.117  2000/08/31 14:25:27  vdronov
*  changed set to bitset
*
*  Revision 1.116  2000/08/30 20:01:25  msmith
*  Genitor documentation
*
*  Revision 1.115  2000/08/24 20:55:45  scowan
*  Added recover from undo.
*
*  Revision 1.113  2000/08/18 17:26:48  scowan
*  Uses new standard attribute handle.
*
*  Revision 1.110  2000/02/14 18:55:27  SBC
*  Added flags and fields.
*
*  Revision 1.109  2000/01/27 23:26:11  scowan
*  Create do not mess with topology type flag.
*
*  Revision 1.106  1999/10/20 20:02:03  mju
*  const filename in MfvNew/Open.
*
 * Revision 1.105  1999/10/04  20:16:42  scowan
 * Fixed elem type change.
 *
*  Revision 1.104  1999/08/04 20:33:32  scowan
*  Added flags.
*
*  Revision 1.103  1999/06/11 16:24:00  scowan
*  Added stub 3d add line function.
*
*  Revision 1.102  1999/05/07 21:25:53  mju
*  Hdr restruct.
*
 * Revision 1.101  1999/04/08  16:04:19  mju
 * Add inclusion guard for mcb.h.
 *
 * Revision 1.100  1999/01/05  19:12:47  scowan
 * Swapped multiple keywords
 *
 * Revision 1.97  1998/05/22  16:38:28  scowan
 * Changed a flag.
 *
 * Revision 1.94  1998/04/24  19:53:40  scowan
 * Added a flag.
 *
 * Revision 1.93  1998/04/03  16:22:31  scowan
 * Removed calls.
 *
 * Revision 1.92  1998/04/02  21:32:56  scowan
 * Added toolkit line splining functions.
 *
 * Revision 1.88  1998/02/20  17:27:41  scowan
 * Added callback reasons.
 *
 * Revision 1.87  1998/02/18  20:39:22  scowan
 * Added 3D editing capabilities.
 *
 * Revision 1.83  1998/02/09  18:22:26  scowan
 * Added a flag.
 *
 * Revision 1.82  1998/02/04  23:31:08  scowan
 * Added fields for element id's.
 *
 * Revision 1.81  1998/01/29  16:43:13  scowan
 * Update prototype.
 *
 * Revision 1.80  1998/01/29  00:08:39  scowan
 * Added stuff for planar and network object types.
 *
 * Revision 1.79  1997/10/30  23:39:31  scowan
 * Added prototype.
 *
 * Revision 1.78  1997/10/15  15:53:11  scowan
 * Added MFVSnap_ToVertex.
 *
 * Revision 1.77  1997/08/28  23:05:08  scowan
 * Added flag for removing excess nodes when deleting lines.
 *
 * Revision 1.76  1997/08/28  17:01:55  scowan
 * Added GetSnapOptions.
 *
 * Revision 1.75  1997/08/26  19:53:20  scowan
 * Add flags for line end snapping.
 *
 * Revision 1.74  1997/08/15  17:00:30  scowan
 * Added SplitLineAtMaxPoints.
 *
 * Revision 1.73  1997/08/14  17:22:38  scowan
 * Changed filename to UNICODE.
 *
 * Revision 1.72  1997/07/01  16:52:39  scowan
 * Added callbak field.
 *
 * Revision 1.71  1997/06/04  20:33:46  scowan
 * Added new internal function.
 *
 * Revision 1.71  1997/06/04  20:33:46  scowan
 * Added new internal function.
 *
 * Revision 1.70  1997/05/23  22:43:32  scowan
 * Removed some flags.
 *
 * Revision 1.69  1997/05/22  22:15:44  scowan
 * Added polygon island support.
 *
 * Revision 1.67  1997/02/14  22:22:54  scowan
 * Added flag.
 *
 * Revision 1.66  1996/12/30  21:20:28  scowan
 * Added MfvUpdate function.
 *
 * Revision 1.65  1996/12/18  21:09:30  scowan
 * Added islelist field and another save flag.
 *
 * Revision 1.64  1996/12/02  21:37:15  scowan
 * Added save flag for excess node removal.
 *
 * Revision 1.63  1996/11/25  23:37:08  scowan
 * Removed use of status handle, uses new status functions.
 *
 * Revision 1.62  1996/11/20  21:46:40  scowan
 * Added TestEndSnap field.
 *
 * Revision 1.61  1996/11/14  17:09:26  scowan
 * Added DontCrossLines flag.
 *
 * Revision 1.59  1996/10/14  16:50:48  scowan
 * Added NoStdAttrib flag for validate.
 *
 * Revision 1.58  1996/07/29  19:48:46  scowan
 * Added new notify reason.
 *
 * Revision 1.57  1996/06/19  15:46:06  scowan
 * Prototype addition for vectutil.c
 *
 * Revision 1.56  1996/06/17  16:10:38  scowan
 * Added ExtractToRegion.
 *
 * Revision 1.55  1996/06/14  19:12:33  scowan
 * Added ClipToRegion prototype.
 *
 * Revision 1.54  1996/04/02  20:52:05  scowan
 * Added MfvVerifyStdAttrib().
 *
 * Revision 1.53  1996/03/27  22:47:17  scowan
 * Added function prototypes.
 *
 * Revision 1.52  1996/02/29  20:42:24  scowan
 * API change for MfvSnapLines().
 *
 * Revision 1.51  1996/01/12  00:05:42  scowan
 * Made MfvRemoveOvershoots() static.
 *
 * Revision 1.50  1996/01/11  01:04:18  scowan
 * Added SnapBackAngle field.
 *
 * Revision 1.49  1996/01/04  17:42:39  scowan
 * Added stat manager handle field.
 * Removed old attempt at managing stat table fields.
 *
 * Revision 1.48  1995/12/22  16:33:26  scowan
 * Added prototype for MfvGetIntsHandle().
 *
 * Revision 1.47  1995/12/14  16:04:30  scowan
 * Added flags for multi-line snapping.
 *
 * Revision 1.46  1995/12/13  22:00:15  scowan
 * Added INTSHANDLE and element bit arrays.
 *
 * Revision 1.45  1995/12/13  20:00:58  scowan
 * Added MFVFLAG_AttemptAllElem flag.
 * Changed MfvSnapLines() API.
 *
 * Revision 1.44  1995/11/13  23:41:57  scowan
 * Added prototype for MfvCopyElemDBRecords().
 *
 * Revision 1.43  1995/11/08  21:30:21  scowan
 * Added prototype for MfvSnapLines().
 *
 * Revision 1.42  1995/10/24  19:04:49  scowan
 * Removed many database variables which are no longer needed.
 * Add recursion test field.
 *
 * Revision 1.41  1995/09/15  16:25:40  scowan
 * Added PointSize field to VEDITINFO.
 *
 * Revision 1.40  1995/09/14  20:58:18  scowan
 * Added prototype for _MfvChangeNodeRaw().
 *
 * Revision 1.39  1995/08/28  16:59:38  scowan
 * Removed FontTrans functions and variable.
 *
 * Revision 1.38  1995/08/11  20:39:15  scowan
 * Added prototype for MfvUpdateFontTrans().
 *
 * Revision 1.37  1995/08/11  18:58:48  scowan
 * Added FontTrans field to VEDITINFO.
 *
 * Revision 1.36  1995/05/18  22:14:06  scowan
 * Added prototype for MfvRemoveExcessNodesEx().
 *
 * Revision 1.35  1995/05/02  22:36:47  scowan
 * Added prototypes for polygon deletion functions.
 *
 * Revision 1.34  1995/03/16  22:34:29  scowan
 * Changed flag to KeepAttachedLabels.
 *
 * Revision 1.33  1995/02/24  00:40:12  scowan
 * Added fields to handle label to element attachments.
 *
 * Revision 1.32  1995/02/23  18:30:04  scowan
 * Added prototype for MfvSnapLine().
 *
 * Revision 1.31  1995/02/22  23:00:32  scowan
 * Added prototype for MfvGetStyleHandle().
 *
 * Revision 1.30  1995/02/22  20:46:53  scowan
 * Added prototype for MfvGetDBHandle().
 *
 * Revision 1.1  1994/02/18  21:53:37  scowan
 * Initial revision
 *
*  \endif
****/

#ifndef  INC_MI32_VECFUNCS_H
#define  INC_MI32_VECFUNCS_H

#ifndef  INC_MI32_MCB_H
   #include <mi32/mcb.h>
#endif

#ifndef  INC_MI32_RVCVECT_H
   #include <mi32/rvcvect.h>
#endif

#ifndef  INC_MI32_RVCDBASE_H
   #include <mi32/rvcdbase.h>
#endif

#ifndef  INC_MI32_INTSEC2_H
   #include <mi32/intsec2.h>
#endif

#ifndef  INC_MI32_GEOM2D_H
   #include <mi32/geom2d.h>
#endif

#ifndef  INC_MI32_RVCQTREE_H
   #include <mi32/rvcqtree.h>
#endif

#ifndef  INC_MI32_ELEMTYPE_H
   #include <mi32/elemtype.h>
#endif

#ifndef  INC_MI32_STATOBJ_H
   #include <mi32/statobj.h>
#endif

#ifndef  INC_MI32_TRANS2DC_H
   #include <mi32/trans2dc.h>
#endif

struct VNODELINEANGLE {
   double angle;                 //!<  Angle going out from the node 
   INT32 linenum;                //!<  Line coming to/from the node 
   int orient;                   //!<  1 = To the node, 0 = From the node 
   };

struct VEDITINFO;

struct VELEMINFO {
   ELEMTYPE ElemType;
   int dbid;
   INT32 *NumElements;           //!< Pointer to field that contains number of elements
   unsigned HasDftZValue:1,      //!< Add default Z Value to element that is added
            HasBitArray:1,       //!< Has a valid bit array
            ExternalQTree:1,
            unused:29;
   STATOBJ *m_sdh;               //!< Standard attribute manager handle
   UINT8 *dbbuf;                 //!< Work buffer for database record maintenence
   INT32 dbbufsize;
   double CurZValue;             //!< Current 3DXY Z value to assign to the element
   QTREEHANDLE qtree;
   VEDITINFO *ved;
   UINT8 *elemlist;              //!< Bit array of selected elements, used for multi-line snap for now
   UINT32 ElemListSize;          //!< Size of bit array in bytes
   INT32 ElemIDTableNum;         //!< Element ID table number
   INT32 *ElemIDCount;           //!< Pointer to header element ID counter
   };

#define ELEMLISTALLOC   (64)
#define STATLISTALLOC   (64)

//! Vector toolkit snap object parameters structure

class VTKSNAPOBJECT {
public:
   int m_VectorID;
   QTREEHANDLE m_LineQTree;
   QTREEHANDLE m_NodeQTree;
   QTREEHANDLE m_PointQTree;
   INT32 m_MaxPoints;
   bool m_SameAsEditor;
   TRANS2D_MAPGEN m_VectorToObject;
   
   VTKSNAPOBJECT (
      ) {
      memset(this, 0, sizeof(*this));
      }
      
   VTKSNAPOBJECT (
      VEDITINFO* ved
      ) {
      SetValues(ved);
      }
      
   void SetValues (
      VEDITINFO* ved
      );
      
   };
   

/*****
*  Main vector editing structure definition
*****/

typedef void *VEHANDLE;

struct MfvAnyCallbackStruct {
   VEHANDLE vh;
   UINT32 reason;
   INT32 ElemNum;
   INT32 OtherElemNum;        //!<  Set if reason is a SplitEnd or Delete 
   ELEMTYPE ElemType;
   };

struct MfvAddLineOverlapCallbackStruct {
   UINT32 reason;
   VEHANDLE vh;
   INT32 NumOverlaps;
   OVERLAPREC *overlap;
   };

#define MfvCR_Add             0x00000001
#define MfvCR_Delete          0x00000002
#define MfvCR_SplitBegin      0x00000004
#define MfvCR_SplitEnd        0x00000008
#define MfvCR_MoveBegin       0x00000010
#define MfvCR_MoveEnd         0x00000020
#define MfvCR_JoinBegin       0x00000040
#define MfvCR_JoinEnd         0x00000080
#define MfvCR_ValSplitLine    0x00000100           //!<  MfvValidateTopology() line splitting callback 
#define MfvCR_AddLineOverlap  0x00000200           //!<  Overlap detected in MfvAddLine() 
#define MfvCR_NodeToPtBegin   0x00000400
#define MfvCR_NodeToPtEnd     0x00000800
#define MfvCR_PtToNodeBegin   0x00001000
#define MfvCR_PtToNodeEnd     0x00002000
#define MfvCR_NodeLineAdd     0x00004000           //!<  Number of lines attached to this node has changed, mainly for drawing 
#define MfvCR_NodeLineDelete  0x00008000           //!<  Number of lines attached to this node has changed, mainly for drawing 


#ifndef GENERATING_DOXYGEN_OUTPUT
struct VEDCBL {
   void (*NotifyCB)(MfvAnyCallbackStruct*, void*);
   void *NotifyUserData;
   VEDCBL *next;
   };


struct VEDITINFO {
   UNICODE filename[FILENAME_MAX];
   RVCVECTINFO *vinfo;              //!<  Pointer to vector header to be modified 
   VELEMINFO line_d;
   VELEMINFO point_d;
   VELEMINFO poly_d;
   VELEMINFO node_d;
   VELEMINFO label_d;
   INT32 *linelist;                 //!<  Work buffer for node and polygon line lists 
   INT32 llistsize;
   DPOINT2D *ptbuff;                //!<  Work buffer for line points 
   INT32 ptbsize;
   DBLISTELMT *elist;               //!<  Work buffer for database lists 
   INT32 elistsize;
   int findex;                      //!<  Handle to open RVC file 
   int vid;                         //!<  Handle to open vector object 
   int hyperid;
   int stylefindex;
   int styleid;
   UINT32 flags;
   UINT32 SnapOpt;
   double SnapDist;
   unsigned HasMinMax:1,
            IsContour:1,
            WasPreOpened:1,
            InValidateFunc:1,
            HasAttachedLabels:1,
            IgnoreAddDBList:1,
            MultiLineSnap:1,
            TestEndLine:1,
            SnappedSelfLine:1,
            UseAddLineOverlapCallback:1,
            NoCombinePolyAttrib:1,
            unused:21;
   VEDCBL *NotifyCBList;
   int LabelTransFile;
   int ToLabelID[ELEMTYPE_NumTypes];
   RVCINODENUM ToLabelInodes[ELEMTYPE_NumTypes];
   int PointSize;
   UINT32 RecursiveCount;
   INT32 ModifyLineNum;
   INT32 ModifyNodeNum;
   INTSHANDLE ihp;                     //!<  Handle to Ints...() routines 
   double SnapBackAngle;               //!<  Allowable variation of angle of snap point to differ with the line segment 
   INT32 *islelist;                    //!<  Work buffer for polygon island lists 
   INT32 ilistsize;
   McbLIST CallbackList;
   INT32 MaxLinePoints;                //!<  Maximum number of points a line can have, 0 = infinite 
   INT32 DeletePolyNum;
   VTKSNAPOBJECT m_SnapObject;
   };


/*****
*  Internal flags
*****/

#define MFVADD_ForceNode         0x00000001

#define MFVELEMID_SetInvalid     0x00000001


/*****
*  Local utility functions
*****/

#if defined(__cplusplus)
extern "C" {
#endif

int         _MfvAddElemDBList (VELEMINFO *elem_d, INT32 elemnum);
int         _MfvAddLineRaw (VEHANDLE vh, DPOLYGON *dpoly);
int         _MfvAddNodeRaw (VEHANDLE vh, DPOINT3D *point);
int         _MfvAddNodeLine (VEHANDLE vh, INT32 nodenum, INT32 linenum);
int         _MfvAddPolyIsland (VEHANDLE vh, INT32 polynum, INT32 islenum);
int         _MfvAddQTreeElem (VELEMINFO *elemdb, INT32 elemnum, void *data);
int         _MfvBuildNodeLineList (VEHANDLE vh);
int         _MfvBuildQTreeElem (VELEMINFO *elem_d);
void        _MfvCallNotifyCallback (VEDITINFO *ved, UINT32 reason, ELEMTYPE ElemType, INT32 ElemNum, INT32 OtherElemNum);
int         _MfvChangeElemInHyperShape (VELEMINFO *elemdb, INT32 oldnum, INT32 newnum);
int         _MfvChangeLabelAttach (VEHANDLE vh, ELEMTYPE ElemType, INT32 OldElemNum, INT32 NewElemNum);
int         _MfvChangeLabelAttachPosn (VEHANDLE vh, ELEMTYPE ElemType, INT32 ElemNum, DPOINT3D *pt);
int         _MfvChangeLineRaw (VEHANDLE vh, INT32 linenum, DPOLYGON *dpoly);
int         _MfvChangeNodeLine (VEHANDLE vh, INT32 nodenum, INT32 oldlinenum, INT32 newlinenum);
int         _MfvChangeNodeRaw (VEHANDLE vh, INT32 nodenum, DPOINT3D *pt);
int         _MfvChangePolyLine (VEHANDLE vh, INT32 polynum, INT32 oldlinenum, INT32 newlinenum);
int         _MfvChangePolyIsland (VEHANDLE vh, INT32 polynum, INT32 oldislenum, INT32 newislenum);
int         _MfvChangeTypeInHyperShape (VELEMINFO *elem_d, INT32 elemnum, int newtype);
int         _MfvCheckIfIntersect (VEHANDLE vh, INT32 linenum, DPOLYGON *dpoly);
void        _MfvCheckLabelAttach (VEHANDLE vh, RVCVECTLABEL *vlabel);
int         _MfvCleanupElemToLabelTrans (VEHANDLE vh);
int         _MfvCombineDBLists (VELEMINFO *elem_d, INT32 source, INT32 dest);
int         _MfvCombineHyperLinks (VELEMINFO *elem_d, INT32 source, INT32 dest);
int         _MfvCompareDBLists (VELEMINFO *elem_d, INT32 elem1,   INT32 elem2,   UINT32 flags);
int         _MfvCompareHyperShapes (VELEMINFO *elem_d, INT32 elem1, INT32 elem2, UINT32 flags);
void        _MfvComputeLineRect (DRECT2D *rect, DPOINT2D *pt, INT32 NumPoints);
void        _MfvComputeLineRect3D (DRECT3D *rect, DPOINT3D *pt, INT32 NumPoints);
int         _MfvCopyElemDBRecords (VELEMINFO *elem_d, INT32 source, INT32 dest, UINT32 flags);
int         _MfvCopyHyperLinks (VELEMINFO *elem_d, INT32 source, INT32 dest);
int         _MfvCopyQTreeElem (VELEMINFO *elemdb, INT32 source, INT32 dest, void *data);
int         _MfvDeleteElemHyperShape (VELEMINFO *elem_d, INT32 elemnum);
int         _MfvDeleteLineRaw (VEHANDLE vh, INT32 linenum);
int         _MfvDeleteNodeRaw (VEHANDLE vh, INT32 nodenum);
int         _MfvDeleteNodeLine (VEHANDLE vh, INT32 nodenum, INT32 linenum);
int         _MfvDeletePolygonRaw (VEHANDLE vh, INT32 polynum);
int         _MfvDeletePolyLine (VEHANDLE vh, INT32 polynum, INT32 linenum);
int         _MfvDeletePolyIsland (VEHANDLE vh, INT32 polynum, INT32 islenum);
int         _MfvDeleteQTreeElem (VELEMINFO *elem_d, INT32 elemnum);
int         _MfvDoubleEqual(double, double, double);
int         _MfvElementIDTableValidate (VELEMINFO *elem_d);
double      _MfvFindDist (DPOINT2D *p1, DPOINT2D *p2);
int         _MfvMakeElementIDTable (VELEMINFO *elem_d, UINT32 flags);
int         _MfvFindLineAndSplit (VEHANDLE vh, DPOINT3D *point, DPOINT3D *retpt);
INT32       _MfvFindNodeLineAngles (VEHANDLE vh, INT32 nodenum, VNODELINEANGLE *list);
int         _MfvFindPolygons (VEDITINFO *ved, INT32 startline, INT32 PolyInside);
int         _MfvGenerateIntersectionsRaw (VEDITINFO *ved, DPOLYGON *dpoly, INTERSECTINFO *ints, INT32 MaxIntersection, VTKSNAPOBJECT& SnapObject);
int         _MfvGetElementGroupExtents (VELEMINFO *elem_d, DRECT2D *GroupRect);
VELEMINFO  *_MfvGetElementPtr (VEHANDLE vh, ELEMTYPE ElemType);
int         _MfvGetQTreeRect (VELEMINFO *elem_d, INT32 elemnum, DRECT2D *rect);
int         _MfvJoinLines (VEDITINFO *ved, INT32 nodenum, INT32 RepLineNum, INT32 DelLineNum);
int         _MfvMergePolygons (VEHANDLE vh, INT32 leftpolynum, INT32 rightpolynum, INT32 linenum);
int         _MfvOpenElement (VELEMINFO *elem_d, INT32 *NumElem, INT32 *ElemIDCount);
int         _MfvPickLineLabelAttach (VEHANDLE vh, INT32 OldLine, INT32 NewLine);
int         _MfvPickPolyLabelAttach (VEHANDLE vh, INT32 OldPoly, INT32 NewPoly);
int         _MfvPointAddRaw (VEHANDLE vh, RVCVECTPOINT *point);
int         _MfvQTreeFilt (int fhandle, INT32 inode, RVCGENINFO *ginfo, void *filtdata, char *msg);
ERRVALUE    _MfvRecoverFromUndoLabelTrans (VEHANDLE vhandle);
int         _MfvRemoveDupDBListEntries (DBLISTELMT *buf, int NumList1, int NumList2);
int         _MfvRemoveIslandInfo (VEHANDLE vh);
int         _MfvRemovePolygon (VEHANDLE vh, INT32 polynum);
int         _MfvRemovePolygonInfo (VEHANDLE vh, bool IsPolyRebuild);
int         _MfvResizeLabelAttach (VEHANDLE vh, ELEMTYPE ElemType, INT32 NumItems);
int         _MfvSetupElemToLabelTrans (VEHANDLE vh);
int         _MfvSplitLineInPolygons (VEHANDLE vh, INT32 origlinenum, RVCVECTLINE *origvline, INT32 newlinenum);
INT32       _MfvSplitLineNearPoint (VEHANDLE vh, INT32 linenum, DPOINT2D *point, INT32& NewLineNum);
int         _MfvSwapElemLabelAttach (VEHANDLE vh, ELEMTYPE ElemType, INT32 FirstElem, INT32 LastElem);
int         _MfvSwapDBRecords (VELEMINFO *elem_d, INT32 elem1, INT32 elem2, UINT32 flags);
int         _MfvUpdateCurrentElemID (VELEMINFO *elem_d, INT32 elemnum);
int         _MfvUpdatePolygon (VEDITINFO *ved, INT32 polynum);
int         _MfvValidateNodes (VEHANDLE vh);
int         _MfvValidatePolyInside (VEHANDLE vh);

/*****
*  Local utility defines
*****/

#define  _MfvChangeQTreeElem(e,f,d) _MfvCopyQTreeElem((e),(f),(f),(d))

#endif //!< GENERATING_DOXYGEN_OUTPUT

/*****
*  Snap Option values and flags
*****/

#define MFVSNAP_ElemMask         0x0000000F
#define MFVSNAP_ToAnyElement     0x00000000
#define MFVSNAP_ToLine           0x00000001
#define MFVSNAP_ToPoint          0x00000002
#define MFVSNAP_ToNode           0x00000003
#define MFVSNAP_ToNothing        0x00000004
#define MFVSNAP_ToVertex         0x00000005

#define MFVSNAP_SnapMask         0x000000F0
#define MFVSNAP_AddVertexSnap    0x00000000
#define MFVSNAP_DirectSnap       0x00000010
#define MFVSNAP_ContinueSnap     0x00000020

#define MFVSNAP_RemOvershoots    0x00000100
#define MFVSNAP_DontCrossLines   0x00000200
#define MFVSNAP_DontSnapToSelf   0x00000400

#define MFVSNAP_BothEnds         0x00000000
#define MFVSNAP_StartPtOnly      0x00000800        //!<  Mutually exclusive with MFVSNAP_EndPtOnly 
#define MFVSNAP_EndPtOnly        0x00001000        //!<  Mutually exclusive with MFVSNAP_StartPtOnly 

   
class VTKSNAPPARMS {
public:

   // ENUMERATIONS
   
   enum SNAPTOELEM {
      SNAPTOELEM_AnyElement = 0,
      SNAPTOELEM_Line,
      SNAPTOELEM_Point,
      SNAPTOELEM_Node,
      SNAPTOELEM_Nothing,
      SNAPTOELEM_Vertex
      };

   enum SNAPTYPE {
      SNAPTYPE_AddVertexSnap = 0,
      SNAPTYPE_DirectSnap,
      SNAPTYPE_ContinueSnap
      };
      
   enum SNAPEND {
      SNAPEND_Both = 0,
      SNAPEND_Start,
      SNAPEND_End
      };
      
   // CONSTRUCTORS / DESTRUCTOR
   
   //! Default constructor
   VTKSNAPPARMS (
      ) :
      m_SnapToElem(SNAPTOELEM_AnyElement),
      m_SnapType(SNAPTYPE_AddVertexSnap),
      m_SnapEnd(SNAPEND_Both),
      m_SnapDist(1.0),
      m_SnapBackAngle(PI / 2.0),
      m_RemOvershoots(false),
      m_DontCrossLines(false),
      m_DontSnapToSelf(false)
      {}
      
   // METHODS

   bool CanCrossLines (
      ) const {
      return (!m_DontCrossLines);
      }

   bool CanRemoveOvershoots (
      ) const {
      return (m_RemOvershoots);
      }

   bool CanSnapToSelf (
      ) const {
      return (!m_DontSnapToSelf);
      }

   SNAPTOELEM GetElementSnap (
      ) const {
      return (m_SnapToElem);
      }
      
   UINT32 GetLegacyFlags (
      ) const {
      UINT32 retval = 0;
      if (m_RemOvershoots) retval |= MFVSNAP_RemOvershoots;
      if (m_DontCrossLines) retval |= MFVSNAP_DontCrossLines;
      if (m_DontSnapToSelf) retval |= MFVSNAP_DontSnapToSelf;
      retval |= static_cast<UINT32>(m_SnapToElem);
      retval |= static_cast<UINT32>(m_SnapType) << 4; 
      if (m_SnapEnd == SNAPEND_Start) retval |= MFVSNAP_StartPtOnly;
      else if (m_SnapEnd == SNAPEND_End) retval |= MFVSNAP_EndPtOnly;
      return (retval);
      }
      
   double GetSnapBackAngle (
      ) const {
      return (m_SnapBackAngle);
      }
      
   double GetSnapDist (
      ) const {
      return (m_SnapDist);
      }
      
   SNAPEND GetSnapEnd (
      ) const {
      return (m_SnapEnd);
      }
      
   SNAPTYPE GetSnapType (
      ) const {
      return (m_SnapType);
      }
      
   void SetCrossLines (
      bool CrossLines
      ) {
      m_DontCrossLines = !CrossLines;
      return;
      }

   void SetElementSnap (
      SNAPTOELEM element
      ) {
      m_SnapToElem = element;
      return;
      }
      
   void SetFromLegacyFlags (
      UINT32 flags
      ) {
      m_RemOvershoots = ((flags & MFVSNAP_RemOvershoots) != 0);
      m_DontCrossLines = ((flags & MFVSNAP_DontCrossLines) != 0);
      m_DontSnapToSelf = ((flags & MFVSNAP_DontSnapToSelf) != 0);
      m_SnapToElem = static_cast<SNAPTOELEM>(flags & MFVSNAP_ElemMask);
      if (m_SnapToElem > SNAPTOELEM_Vertex) m_SnapToElem = SNAPTOELEM_AnyElement;
      m_SnapType = static_cast<SNAPTYPE>((flags & MFVSNAP_SnapMask) >> 4);
      if (m_SnapType > SNAPTYPE_ContinueSnap) m_SnapType = SNAPTYPE_AddVertexSnap;
      if ((flags & MFVSNAP_StartPtOnly) != 0) m_SnapEnd = SNAPEND_Start;
      else if ((flags & MFVSNAP_EndPtOnly) != 0) m_SnapEnd = SNAPEND_End;
      else m_SnapEnd = SNAPEND_Both;
      return;
      }
      
   void SetRemoveOvershoots (
      bool RemoveOvershoots
      ) {
      m_RemOvershoots = RemoveOvershoots;
      return;
      }

   void SetSnapBackAngle (
      double angle
      ) {
      m_SnapBackAngle = bound(angle, 0.0, PI);
      return;
      }
      
   void SetSnapDist (
      double dist
      ) {
      m_SnapDist = dist;
      return;
      }
      
   void SetSnapEnd (
      SNAPEND SnapEnd
      ) {
      m_SnapEnd = SnapEnd;
      return;
      }
      
   void SetSnapToSelf (
      bool SnapToSelf
      ) {
      m_DontSnapToSelf = !SnapToSelf;
      return;
      }

   void SetSnapType (
      SNAPTYPE SnapType
      ) {
      m_SnapType = SnapType;
      return;
      }
      
private:
   #ifndef GENERATING_DOXYGEN_OUTPUT
   SNAPTOELEM m_SnapToElem;   
   SNAPTYPE m_SnapType; 
   SNAPEND m_SnapEnd;
   double m_SnapDist;
   double m_SnapBackAngle;             //!<  Allowable variation of angle of snap point to differ with the line segment 
   bool m_RemOvershoots;
   bool m_DontCrossLines;
   bool m_DontSnapToSelf;
   #endif // GENERATING_DOXYGEN_OUTPUT
   
};

/*****
*  MfvOpen - MfvNew flags
*****/

#define MFVFLAG_NoQtree             0x00000001  //!<  Do not maintain qtrees 
#define MFVFLAG_NoDBStatTable       0x00000002  //!<  Do not update Database Statistics tables 
#define MFVFLAG_KeepAttachedLabels  0x00000004  //!<  Keep labels that become unattached 
#define MFVFLAG_IsContour           0x00000008  //!<  Vector data is a contour set 
#define MFVFLAG_NoStyle             0x00000010  //!<  Do not open/create a style table 
#define MFVFLAG_NoConvIfElemID      0x00000020  //!<  Do not convert node to point if element ID attachment only 
#define MFVFLAG_NoDatabase          0x00000040  //!<  Do not maintain databases 
#define MFVFLAG_RemExNodesDelLine   0x00000080  //!<  Delete excess nodes when deleting lines 
#define MFVFLAG_NoHyper             0x00000100  //!<  Do not update hyper object 
#define MFVFLAG_NoCreateTables      0x00000200  //!<  Do not create databases 
#define MFVFLAG_NoCreateStyle       0x00000400  //!<  Do not create a style object 
#define MFVFLAG_NoCreateElemID      0x00000800  //!<  Do not create element ID tables 
#define MFVFLAG_IgnoreBadMinMax     0x00001000  //!<  Ignore bad min/max values (Should be used only by validate topo) 
#define MFVFLAG_NoValidateNodes     0x00002000  //!<  Do not execute _MfvValidateNodes in MfvOpen() 
#define MFVFLAG_NoSaveQTree         0x00004000  //!<  Do not save search tree in MfvClose() or MfvStop() 
#define MFVFLAG_NoStatusText        0x00008000  //!<  Do not show status text 
#define MFVFLAG_NoCreatePolyID      0x00010000  //!<  Do not create polygon element ID tables 
#define MFVFLAG_NoChangeTopoType    0x00020000  //!<  Do not change / fix vector topology type 

#define MFVFLAG_NoPolyQTree         0x01000000  //!<  Do not generate a polygon qtree 
#define MFVFLAG_NoLineQTree         0x02000000  //!<  Do not generate a line qtree 
#define MFVFLAG_NoPointQTree        0x04000000  //!<  Do not generate a point qtree 
#define MFVFLAG_NoLabelQTree        0x08000000  //!<  Do not generate a label qtree 
#define MFVFLAG_NoNodeQTree         0x10000000  //!<  Do not generate a node qtree 
#define MFVFLAG_NoElemQTree         0x1F000000  //!<  Do not generate an element qtree 

/*****
*  Validate Topo, Build Polygon and Build Islands flags
*****/

#define MFVFLAG_RebuildPolys     0x00000001  //!<  Force rebuild polygons (Validate Topo) 
#define MFVFLAG_RebuildIslands   0x00000002  //!<  Force rebuild polygon islands (Validate Topo) 
#define MFVFLAG_RebuildNodeLL    0x00000004  //!<  Force rebuild node line lists (Validate Topo) 
#define MFVTOPO_DontValidateZ    0x00000008  //!<  Do not validate Z values 
#define MFVFLAG_GoodLeftRight    0x00000010  //!<  Vector Left/Right fields correct, do not rebuild 
#define MFVFLAG_NoCheckHyper     0x00000020  //!<  Do not check hyper links in removing excess nodes 
#define MFVFLAG_NoCheckDatabase  0x00000040  //!<  Do not check database attributes in removing excess nodes 
#define MFVFLAG_NoRemoveNodes    0x00000080  //!<  Do not execute MfvRemoveExcessNodes() in topology validation 
#define MFVFLAG_AttemptAllElem   0x00000100  //!<  In a multi-elem operation, attempt rest of elements if an error occurs 
#define MFVFLAG_ForceClipBorder  0x00000200  //!<  Force the clip routine to add a border 
#define MFVFLAG_NoClipBorder     0x00000400  //!<  Force the clip routine to not add any border 
#define MFVFLAG_OnlyClipLines    0x00000800  //!<  Do not bother with the points and labels 
#define MFVFLAG_NoStdAttrib      0x00001000  //!<  Avoid standard attribute rebuild in validate 
#define MFVFLAG_RemUnusedDBRec   0x00002000  //!<  Removed unattached database records 
#define MFVFLAG_NoValTopoType    0x00004000  //!<  Do not change / fix vector topology type 

/*****
*  MfvSave() flags
*****/

#define MFVSAVE_RemExNodes       0x00000001  //!< Remove excess nodes on destination object
#define MFVSAVE_RemExRecords     0x00000002  //!< Remove excess database records on destination object
#define MFVSAVE_Optimize         0x00000004  //!< Insert vector optimization code

/*****
*  MfvLine...() flags
*****/

#define MFVLINE_AverageZValue    0x00000001  //!<  Average line z coordinates when truncating 
#define MFVLINE_SetMaxPoints     0x00000002  //!<  Set max points for toolkit in MfvLineSplitAtMaxPoints 

/*****
*  MfvPolygon...() flags
*****/

#define MFVPOLY_LongLineDelete   0x00000001  //!<  Delete longest line for deleting polygon 
#define MFVPOLY_NoDeleteSpurs    0x00000002  //!<  Do not delete polygon spurs when deleting polygons 
#define MFVPOLY_PolyCntCollapse  0x00000004  //!<  Collapse polygon to its centroid method of deleting polygons 
#define MFVPOLY_RemoveAllIslands 0x00000008  //!<  Remove all islands 
#define MFVPOLY_NoCombineAttrib  0x00000010  //!< Do not combine attributes from the deleted polygon to the new merged polygon

/*****
*  MfvPoint...() flags
*****/

#define MFVPOINT_IsNodePoint     0x00000001  //!<  Point to modify is a node point 

/*****
*  Vector toolkit API
*****/

//! Add a label to a vector.
//!
//! @return Error code or 0 if succussful.
//! Description of RVCVECTLABEL:
//! typedef struct _VECTLLDATA {
//!   RVCLEADERLINE LeaderLine;        Leader Line structure
//!   RVCLABELSTYLE LStyleIndex;       Leader Style structure
//!   void *LeaderPts;                 Leader Line point buffer
//!   LONG NumLeaderPts;               Number of leader line points
//!   } VECTLEADERINFO;                Vector Leader Line Data
//! typedef struct _VECTLABEL {
//!   RVCLABELDESC desc;               Label descrition structure
//!   void *LabelStr;                  String or query
//!   LONG LabelStrSize;               Size of label string
//!   void *BasePts;                   Array of label base points, 2D or 3D
//!   LONG NumBasePts;                 Number of base points in array
//!   VECTLEADERINFO *LLines;          Leader Line Data buffer
//!   LONG NumLLines;                  Number of leader lines allocated
//!   int PointSize;                   Size of the points in bytes
//!   } RVCVECTLABEL;
int            MfvAddLabel (
   VEHANDLE vhandl,                    //!< Handle created by MfvInit()
   RVCVECTLABEL *vlabel                //!< Pointer to label structure
   );

//! Add a line to a vector.
//!
//! @return Error code or 0 if successful
//! This function will resolve all topological issues that occur when adding this line.  This function
//! assumes that the point array is large enough to handle adding at least two more points for snapping
//! purposes.
int            MfvAddLine (
   VEHANDLE vhandle,                   //!< Handle created by MfvInit()
   DPOLYGON *dpoly                     //!< Pointer to structure containing the line coordinates
   );

//! API call to add a 3D line to a vector object.
int            MfvAddLine3D (
   VEHANDLE vhandle,                   //!< Handle created by MfvInit()
   DPOLYLINE3D *dpoly                  //!< Pointer to structure containing the line coordinates
   );

//! Append points to the end of a vector line according to snap options and return the line.
//!
//! @return Error if < 0
//! The 'dpoly.point' field is allocated in this function, it must be freed by the caller.
//! The dpoly.numpts field is the number of points after snapping.  The MfvAddSnapPoints() 
//! function will not work for generating the snap points because that function assumes that
//! the line being passed does not exist in the vector.
int            MfvAddLineSnapPoints (
   VEHANDLE vhandle,                   //!< Handle created by MfvInit()
   INT32 LineNum,                      //!< The vector line to snap and return
   DPOLYGON *dpoly                     //!< Pointer to structure to return the snapped line in
   );

//! Add a node to a vector splitting the line if necessary.
//!
//! @return Error code or 0 if successful
//! This routine may or may not add the node.  It depends on whether or
//! not the routine finds a line close enough to split.  If it finds a
//! node that is close enough and snap to node is enabled, then it will
//! not create the node.  The actual place of the node will be returned
//! in the point parameter.
int            MfvAddNode (
   VEHANDLE vhandle,                   //!< Handle created by MfvInit()
   DPOINT2D *point                     //!< Place to try to add the node
   );

//! Add a point to a vector.
//!
//! @return Error code or 0 if successful
int            MfvAddPoint (
   VEHANDLE vhandle,                   //!< Handle created by MfvInit()
   RVCVECTPOINT *point                 //!< Point coordinate structure
   );

//! Add a polygon to a vector.
//!
//! @return Error code or 0 if successful
//! This function calls MfvAddLine() to add the polygon.  The node that exists at the closure of the
//! polygon is tested and removed if possible using MfvDeleteNode().
int            MfvAddPolygon (
   VEHANDLE vhandle,                   //!< Handle created by MfvInit()
   DPOLYGON *dpoly                     //!< Pointer to structure containing the polygon coordinates
   );

//! Append points to the end of a non vector line according to snap options.
//!
//! @return Error code or 0 if successful
int            MfvAddSnapPoints (
   VEHANDLE vhandle,                   //!< Handle created by MfvInit()
   DPOLYGON *dpoly,                    //!< Line to append snap points to
   bool& SnappedStart,                 //!< Set to 'true' if start point can be snapped
   bool& SnappedEnd                    //!< Set to 'true' if end point can be snapped
   );

//! Generate a place to put a label along a vector element.
//!
//! @return Error code or 0 if successful
//! You must free dpoly.point after this function is called
int            MfvAutoGenLabelPosn (
   VEHANDLE vhandle,                   //!< Handle created by MfvInit()
   INT32 elemnum,                      //!< Element number to generate label position from
   ELEMTYPE ElemType,                  //!< ELEMTYPE_,.. (Point, Poly, Line)
   DPOLYGON *dpoly,                    //!< Baseline for label RETURNED
   double length                       //!< Length of label in vector units
   );

//! Find all polygons in a vector object.
//!
//! @return Error code or 0 if successful
//! This function rebuilds the polygons from scratch.  Any reattachment of polygon attributes must be 
//! done outside of this code since the first thing this function does is to remove the polygons from 
//! the vector object.  This routine is Mstatus enabled.
int            MfvBuildPolygons (
   VEHANDLE vhandle,                   //!< Handle created by MfvInit()
   UINT32 flags                        //!< Flags, none defined yet
   );

//! Changes a vector label
//!
//! @return Error code or 0 if successful
int            MfvChangeLabel (
   VEHANDLE vhandle,                   //!< Handle created by MfvInit()
   INT32 labelnum,                     //!< Number of label to change
   RVCVECTLABEL *vlabel                //!< Vector label structure
   );

//! Changes a vector line.
//!
//! @return Error code or WCantChangeLine or 0
//! If this function returns WCantChangeLine as an error code, it means that the change request would
//! intersect other lines and therefore the operation cannot be completed.  The start and end points
//! of the line must not be modified unless either the start or end of the line is a dangling end, i.e. no
//! other lines connected to that node on that end.
int            MfvChangeLine (
   VEHANDLE vhandle,                   //!< Handle created by MfvInit()
   INT32 linenum,                      //!< Number of the line to change
   DPOLYGON *dpoly                     //!< PointList to change to line to
   );

//! Changes the position of a node and all lines attached.
//!
//! @return Error code or WCantChangeLine or 0
//! The pllist array is used to determine the new shape of the lines
//! that are attached to the node being moved.  The array is in the
//! same order as the node line list, i.e. each element in the pllist
//! array cooresponds with the line in the node line list.  The start
//! or end point in the pllist[i].point list must be the same as the 
//! point variable passed.  Determine the start or end point based on
//! the start/end of the line.
//! WCantChangeLine is issued if the lines are moved in such a way as
//! to cross other lines, the lines and node are returned to the
//! previous state before the function call.
int            MfvChangeNode (
   VEHANDLE vhandle,                   //!< Handle create by MfvInit()
   INT32 nodenum,                      //!< Number of the node to change
   DPOINT3D *point,                    //!< New location of the node
   DPOLYGON *pllist,                   //!< Array of line points to move
   INT32 numpllist                     //!< Number of lines to manipulate
   );

//! Changes a vector point.
//!
//! @return Error code or 0 if successful
//! See also: MfvAddPoint, MfvDeletePoint
int            MfvChangePoint (
   VEHANDLE vhandle,                   //!< Handle created by MfvInit()
   INT32 pointnum,                     //!< Number of the point to change
   RVCVECTPOINT *point,                //!< Vector point structure
   UINT32 flags
   );

//! Clip a vector object to a region.
//!
//! @return Error code or 0 if successful
//! Flags:
//!   MFVFLAG_ForceClipBorder          Force the clip routine to add a border
//!   MFVFLAG_NoClipBorder             Force the clip routine to not add any border
//!   MFVFLAG_OnlyClipLines            Do not bother with the points and labels
//! The default action with regards to the region border is to add the segment only if the
//! segment divides a polygon.  The PolySet bit array can control which polygons are considered
//! int for region segment addition.  This function is more efficient if the target vector is
//! thinned using the extraction routines.
//! See also: MregionClipLine, MfvExtractToRegion
int            MfvClipToRegion (
   VEHANDLE vhandle,                   //!< Handle created by MfvInit()
   DREGION *region,                    //!< Region to clip to
   UINT32 RegionTest,                  //!< REGIONTEST_CompInside or REGIONTEST_CompOutside
   UINT8 *PolySet,                     //!< Bit array of polygons to clip in, NULL for all.
   UINT32 flags                        //!< Flags
   );

//! Close an open vector object opened via MfvOpen or MfvNew.
//!
//! @return Error code
//! This function will save the search trees under the vector object
//! unless MFVFLAG_NoSaveQTree is specified in MfvOpen(), MfvSetup() or
//! MfvNew().
int            MfvClose (
   VEHANDLE vhandle,                   //!< Handle created by MfvInit()
   UINT32 flags                        //!< 1 to rebuild polygon islands
   );

//! API call to collapse multiple nodes into one node.
//!
//! @return Error code
//! Any lines that are attached at both ends to the nodes to be removed will also be removed.
//! Any polygons that have all of their line removed will also be removed.  This function
//! is used by _MfvFindPolygons() to remove zero area polygons.
int            MfvCombineNodes (
   VEHANDLE vhandle,                   //!< Handle created by MfvInit()
   INT32 NodeNum,
   DPOINT3D *pt,
   INT32 *nodelist,                    //!< List of node to combine
   INT32 NumNodes,                     //!< Number of nodes in the list
   UINT32 flags                        //!< Flags
   );

//! Change vector point type from 2D -> 3D or 3D -> 2D.
int            MfvConvertPointType (
   VEHANDLE vhandle,                   //!< Handle created by MfvInit()
   UINT32 NewPointType,                //!< VPOINT_2DXY, VPOINT_3DXY, or VPOINT_3DXYZ
   UINT32 flags                        //!< MfvFLAG_...
   );

//! Convert node element to a pseudo point element by adding a database record to it
ERRVALUE MfvConvertNodeToPoint (
   VEHANDLE vh,
   INT32 NodeNum
   );
   
//! Delete a vector label.
//!
//! @return Error code
//! This function will reduce the number of labels in the vector
//! object.  If you intend to delete multiple labels, use
//! MfvDeleteLabels() instead.
int            MfvDeleteLabel (
   VEHANDLE vhandle,                   //!< Handle created by MfvInit()
   INT32 labelnum                      //!< Label to delete
   );

//! Delete vector labels.
//!
//! @return Error code
//! This function properly deletes multiple vector labels.  The labellist must be sorted in 
//! accending order for the function to work properly.  This routine is Mstatus enabled.
int            MfvDeleteLabels (
   VEHANDLE vhandle,                   //!< Handle created by MfvInit()
   INT32 *labellist,                   //!< List of labels to delete
   INT32 numlabels                     //!< Number of labels to delete
   );

//! Delete a vector line.
//!
//! @return Error code
//! This function properly deletes a line from a vector object maintaining
//! topology.  Do not call this function to delete multiple lines, call
//! MfvDeleteLines().
int            MfvDeleteLine (
   VEHANDLE vhandle,                   //!< Handle created by MfvInit()
   INT32 linenum                       //!< Line to delete
   );

//! Delete vector lines.
//!
//! @return Error code
//! This function properly deletes multiple vector lines.  The linelist must be sorted in 
//! ascending order for the function to work properly.  This routine is Mstatus enabled.
int            MfvDeleteLines (
   VEHANDLE vhandle,                   //!< Handle created by MfvInit()
   INT32 *linelist,                    //!< List of lines to delete
   INT32 numlines                      //!< Number of lines in the list
   );

//! Delete a vector node.
//!
//! @return 1 if node is removed, 0 if not, or Error code
//! Flags:
//!   MFVFLAG_NoCheckHyper             To not check differences between hyper links
//!   MFVFLAG_NoCheckDatabase          To not check differences between database attachments
//! This function properly deletes a node from a vector object maintaining
//! topology.  Do not call this function to delete multiple nodes, call
//! MfvDeleteNodes().  This function determines if the node is safe to
//! remove, if it is, it will do so and join the lines together, if not,
//! it will do nothing.
int            MfvDeleteNode (
   VEHANDLE vhandle,                   //!< Handle created by MfvInit()
   INT32 nodenum,                      //!< Node to delete
   UINT32 flags                        //!< Flags
   );

//! Delete vector nodes.
//!
//! @return Error code
//! Flags:
//!   MFVFLAG_NoCheckHyper             To not check differences between hyper links
//!      MFVFLAG_NoCheckDatabase          To not check differences between database attachments
//! This function properly deletes multiple vector nodes.  The nodelist must be sorted in 
//! ascending order for the function to work properly.  This routine is Mstatus enabled.
//! See MfvDeleteNode() for node removal behavior.
int            MfvDeleteNodes (
   VEHANDLE vhandle,                   //!< Handle created by MfvInit()
   INT32 *nodelist,                    //!< List of nodes to delete
   INT32 numnodes,                     //!< Number of nodes in the list
   UINT32 flags                        //!< Flags
   );

//! Delete a vector point.
//!
//! @return Error code
//! This function properly deletes a point from a vector object.  Do not
//! call this function to delete multiple points, call MfvDeletePoints().
int            MfvDeletePoint (
   VEHANDLE vhandle,                   //!< Handle created by MfvInit()
   INT32 pointnum                      //!< Point to delete
   );

//! Delete vector points.
//!
//! @return Error code
//! This function properly deletes multiple vector points.  The ptlist must be sorted in accending 
//! order for the function to work properly.  This routine is Mstatus enabled.
int            MfvDeletePoints (
   VEHANDLE vhandle,                   //!< Handle created by MfvInit()
   INT32 *ptlist,                      //!< List of points to delete
   INT32 numpts                        //!< Number of points to delete
   );

//! Attempt to delete polygon by deleting lines.
//!
//! @return 1 if polygon removed, 0 if not, or Error code
//! Flags:
//!      MFVPOLY_LongLineDelete           Delete longest line for deleting polygon, will always delete polygon
//!      MFVPOLY_NoDeleteSpurs            Do not delete polygon spurs when deleting polygons
//!      MFVPOLY_PolyCntCollapse          Collapse polygon to its centroid method of deleting polygons
//! This function searches the lines that make up the polygon to find a line that is not part of another 
//! polygon if no flags are set.  If such a line is found, the routine then searches for all of the lines 
//! that can be removed that form the polygon and deletes them.  If MFVPOLY_LongLineDelete is used, the
//! routine will delete the polygon by deleting the longest line.  Do not call this function to delete multiple 
//! polygons, call MfvDeletePolygons().
int            MfvDeletePolygon (
   VEHANDLE vhandle,                   //!< Handle created by MfvInit()
   INT32 polynum,                      //!< Polygon to attempt to delete
   UINT32 flags                        //!< Flags
   );

//! Attempt to delete multiple polygons.
//!
//! @return Error code
//! This function properly deletes multiple polygons.  The polylist must be sorted in accending 
//! order for the function to work properly.  This routine is Mstatus enabled.
int            MfvDeletePolygons (
   VEHANDLE vhandle,                   //!< Handle created by MfvInit()
   INT32 *polylist,                    //!< List of polygons to attempt to delete
   INT32 numpolys,                     //!< Number of polygons in the list
   UINT32 flags                        //!< Flags
   );

//! Remove all elements that fail the region test.
//!
//! @return Error code
//! Region test values:
//!   REGIONTEST_CompInside            Is the line completely inside the region
//!   REGIONTEST_PartInside            Is the line partially inside the region
//!   REGIONTEST_CompOutside           Is the line completely outside the region
//!   REGIONTEST_PartOutside           Is the line partially outside the region
//! Flags:
//!   MFVFLAG_OnlyClipLines   Do not bother with the points and labels
//! See also: MregionClipLine, MfvClipToRegion
int            MfvExtractToRegion (
   VEHANDLE vhandle,                   //!< Handle created by MfvInit()
   DREGION *region,                    //!< Region to clip to
   UINT32 RegionTest,                  //!< Region test values
   UINT32 flags                        //!< Flags
   );

//! Given a line number, return the closest point and segment on the line.
//!
//! @return Segment number that point was found or Error if < 0
INT32          MfvFindClosestLineVertex (
   VEHANDLE vhandle,                   //!< Handle created by MfvInit()
   INT32 linenum,                      //!< Line to find closest point on
   DPOINT2D *testpt,                   //!< Point to search with
   DPOINT3D *retpt                     //!< Closest point RETURNED
   );

//! Search and record polygon islands.
//!
//! @return Error code
//! This function rebuilds polygons from scratch.  Any recovery of polygon attributes must be
//! done elsewhere.  This routine is Mstatus enabled.
//! Flag definitions:
//!   MFVFLAG_GoodLeftRight            Vector line Left/Right fields
//!                                       are correct, do not rebuild
int            MfvFindPolygonIslands (
   VEHANDLE vhandle,                   //!< Handle created by MfvInit()
   UINT32 flags                        //!< Flags
   );

//! Generate Element ID tables
ERRVALUE MfvGenerateElementIDTables (
   VEHANDLE vhandle                    //!< Handle created by MfvInit()
   );
   
//! API call to generate an INTERSECTINFO data of the intersections.
//!
//! @return Error code
//! This is made by the line passed into the function with respect to
//! the vector object with a limit on the number found.
//! It will not resolve topology.
//! See use in MfvClipToRegion for an example.
int            MfvGenerateIntersectionsExt (
   VEHANDLE vhandle,                   //!< Handle created by MfvInit()
   DPOLYGON *dpoly,                    //!< Line to generate intersections on
   INTERSECTINFO *ints,                //!< Structure for intersection information
   INT32 MaxIntersections              //!< Maximum number of intersections
   );

//! Given a polyline, return the intersection list.
//!
//! @return Error code
//! This function determines the intersections between the line and the
//! vector object.  It does not modify the vector or the line itself, but
//! generates intersection data that can be used elsewhere (see IntsSplitLine()).
inline int     MfvGenerateInt