rvctin.h

Go to the documentation of this file.

/***
 * \file rvctin.h <mi32/rvctin.h>
 * \brief Definitions for TIN (Triangulated Irregular Network) objects
 *
 * \if NODOC
 * $Id: rvctin.h_v 1.51 2004/08/24 22:09:08 scowan Exp $
 *
 * $Log: rvctin.h_v $
 * Revision 1.51  2004/08/24 22:09:08  scowan
 * Added total line length field to header.
 *
 * Revision 1.50  2004/03/12 15:07:04  mju
 * Remove another unused legacy object selection dialog inline.
 *
 * Revision 1.49  2004/03/10 22:53:26  mju
 * Mark legacy dialogs as deprecated.
 *
 * Revision 1.48  2004/01/30 18:57:51  vdronov
 * make it HardEdge
 *
 * Revision 1.47  2004/01/29 23:42:34  vdronov
 * added FLAG_BreakEdge to EDGEINFO
 *
 * Revision 1.46  2004/01/08 20:29:23  vdronov
 * added cople more structures
 *
 * Revision 1.45  2004/01/08 00:01:15  vdronov
 * added TRIANGLENODES, TRIANGLEEDGES, EDGEINFO structures.
 *
 * Revision 1.44  2003/10/15 17:39:43  mju
 * Deprecate groupkey.
 *
 * Revision 1.43  2003/10/13 16:10:58  scowan
 * Removed more inline unused functions.
 *
 * Revision 1.42  2003/10/13 15:42:36  scowan
 * Removed unused function prototypes.
 *
 * Revision 1.41  2003/09/15 13:49:56  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.40  2002/12/26 16:23:54  scowan
 * Fixed invalid extents handling.
 *
 * Revision 1.39  2002/10/04 21:46:45  scowan
 * Added more methodcs.
 *
 * Revision 1.38  2002/09/10 22:54:59  scowan
 * Added ext function version.
 *
 * Revision 1.37  2002/09/10 21:03:58  scowan
 * Added is valid methods.
 *
 * Revision 1.36  2002/08/21 21:55:46  scowan
 * Fixed derecated stuff.
 *
 * Revision 1.35  2002/08/20 15:20:03  mju
 * Use prevent_memfunc macro always.
 * Remove obsolete dialog defines.
 *
 * Revision 1.34  2002/03/08 18:38:05  scowan
 * Added clear method.
 *
 * Revision 1.33  2002/01/03 22:50:30  scowan
 * Added functions to manage tin object extents.
 *
 * Revision 1.32  2001/09/14 14:58:45  mju
 * No mdlg in win32native.
 *
 * Revision 1.31  2001/01/31 14:49:45  scowan
 * Fixed dll import / export error.
 *
 * Revision 1.30  2000/10/30 18:52:15  msmith
 * Genitor documentation.
 *
 * Revision 1.29  2000/10/19 17:46:56  scowan
 * Added function to get the number of elements.
 *
 * Revision 1.28  2000/08/11 19:40:42  scowan
 * Update prompts.
 *
 * Revision 1.27  2000/05/08 16:52:32  mju
 * Remove TRIANGLEDATA and TINCASCADING struct defns as nothing uses them.
 *
 * Revision 1.26  2000/04/21 15:49:34  mju
 * Add op= for assignment of GENINFO to TININFO.
 *
 * Revision 1.25  1999/11/19 14:23:20  mju
 * MdlgGetTIN... prompt const.
 *
 * Revision 1.24  1999/10/05  22:48:49  scowan
 * Changed headers to use inheritance.
 *
 * Revision 1.23  1999/06/14 19:43:55  mju
 * Add defaults for Mdlg fns.
 *
 * Revision 1.22  1999/06/11  14:46:32  mju
 * Obj sel dlg.
 *
 * Revision 1.21  1999/06/10  22:11:28  mju
 * Object selection dialog update.
 *
 * Revision 1.20  1999/05/07  21:23:58  mju
 * Hdr restruct.
 *
 * Revision 1.19  1999/04/08  15:36:20  mju
 * Use wrong inclusion guard for rvcdefns.h
 *
 * Revision 1.18  1999/01/05  19:13:49  scowan
 * Swapped multiple keywords
 *
 * Revision 1.17  1998/09/30 21:54:46  scowan
 * Setup DLL.
 *
 * Revision 1.15  1998/09/02  20:22:22  scowan
 * Exported Dealaunay functions.
 *
 * Revision 1.14  1998/02/04  23:27:01  scowan
 * Added element id's.
 *
 * Revision 1.13  1996/12/20  16:37:34  coffee!dwilliss
 * Added __cplusplus things
 *
 * Revision 1.11  1996/09/26  21:46:44  dfrolov
 * ComputeTriangleContoursExt added
 *
 * Revision 1.10  1996/09/26  19:18:04  dfrolov
 * add ComputeTriangleContours
 *
 * Revision 1.9  1996/09/20  00:03:22  dfrolov
 * nothing important
 *
 * Revision 1.8  1996/01/11  17:39:51  scowan
 * Added MfReadOpenTINHeader().
 *
 * Revision 1.7  1995/09/01  23:16:25  scowan
 * Added prototype for MfResizeTIN().
 *
 * Revision 1.6  1995/02/01  21:45:09  dfrolov
 * eliminate problem with versions
 *
 * Revision 1.4  1994/12/16  00:04:53  dfrolov
 * Add Delaunay family
 *
 * Revision 1.3  1994/11/07  17:45:54  mju
 * Add FindClosestTIN...() functions and PointInTINTriangle().
 *
 * Revision 1.2  1994/11/02  18:22:16  scowan
 * Fixed spelling error.
 *
 * Revision 1.1  1994/11/02  17:40:02  scowan
 * Initial revision
 *
 *
 *
 * \endif
**/

#ifndef  INC_MI32_RVCTIN_H
#define  INC_MI32_RVCTIN_H

#ifndef  INC_MI32_STDDEFNS_H
   #include <mi32/stddefns.h>
#endif

#ifndef  INC_MI32_RVCDEFNS_H
   #include <mi32/rvcdefns.h>
#endif

#ifndef  INC_MI32_MSTATUS_H
   #include <mi32/mstatus.h>
#endif

#ifndef  INC_MI32_POINT_H
   #include <mi32/point.h>
#endif

#ifndef  INC_MI32_RECT_H
   #include <mi32/rect.h>
#endif

//! Note: This MUST go after inclusion of stddefns.h
#ifdef GEOMDLL
   #define GEOMLIBEXPORT MI_DLLEXPORT
#else
   #define GEOMLIBEXPORT MI_DLLIMPORT
#endif

//! TIN node structure.
struct RVCTINNODE : public DPOINT3D {

   RVCTINNODE& operator= (
      const DPOINT3D& pt
      ) { 
      *static_cast<DPOINT3D*>(this) = pt; 
      return (*this);
      }

   //! Get extents of TIN node.
   //! @return extents of TIN node
   DRECT3D GetExtents (
      ) const { return (DRECT3D(*this)); }

   bool IsValid (
      ) const { return (true); }
   };

//! TIN triangle structure.
struct RVCTINTRIANGLE {
   INT32 node1;                        //!< Id of node 1
   INT32 node2;                        //!< Id of node 2
   INT32 node3;                        //!< Id of node 3
   INT32 triangle12;                   //!< Connected triangle id, shared edge 1-2
   INT32 triangle23;                   //!< Connected triangle id, shared edge 2-3
   INT32 triangle31;                   //!< Connected triangle id, shared edge 3-1
   INT32 edge12;                       //!< Id of edge 1-2
   INT32 edge23;                       //!< Id of edge 2-3
   INT32 edge31;                       //!< Id of edge 3-1
   UINT8 edgeflags12;                  //!< Flags for edge 1-2
   UINT8 edgeflags23;                  //!< Flags for edge 2-3
   UINT8 edgeflags31;                  //!< Flags for edge 3-1
   #ifndef GENERATING_DOXYGEN_OUTPUT
   UINT8 spare;
   #endif //!< GENERATING_DOXYGEN_OUTPUT
   
   bool IsValid (
      ) const { return (true); }
   };

//! TIN edge structure.
struct RVCTINEDGE {
   INT32 nodefrom;                     //!< Id of the starting node
   INT32 nodeto;                       //!< Id of the ending node
   INT32 trileft;                      //!< Id of the left triangle
   INT32 triright;                     //!< Id of the right triangle

   bool IsValid (
      ) const { return (true); }
   };

//! TIN hull structure.
struct RVCTINHULL {
   DPOINT3D minval;                    //!< Minimum range value for HULL
   DPOINT3D maxval;                    //!< Maxmum range value for HULL
   DOUBLE length;                      //!< Perimeter
   DOUBLE area;                        //!< Area, excluding islands area
   DOUBLE volume;                      //!< Volume if applicable
   DOUBLE zerolevel;                   //!< Zero-level for volume, if applicable
   INT32 exthull;                      //!< id of the external hull, -1 if none
   UINT16 hulltype;                    //!< TINHULL_Convex, TINHULL_Clip or TINHULL_Exclude
   UINT16 spare;                       //!< For double alignment

   //! Get extents of TIN object.
   //! @return extents of TIN object
   DRECT3D GetExtents (
      ) const {
      DRECT3D retval(minval);
      retval.Extend(maxval);
      return (retval);
      }

   bool IsValid (
      ) const { return (true); }
      
   //! Set extents of TIN object.
   void SetExtents (
      const DRECT3D& rect
      ) {
      minval.x = rect.xinit;     
      minval.y = rect.yinit;     
      minval.z = rect.zinit;     
      maxval.x = rect.xlast;
      maxval.y = rect.ylast;
      maxval.z = rect.zlast;
      return;
      }

   };

//! TIN hull edge structure.
struct RVCTINHULLEDGE {
   INT32 nodefrom;                     //!< Starting node
   INT32 trileft;                      //!< Left triangle
   };

struct RVCTININFO : public RVCGENINFO {
   DPOINT3D_OLD minval;                //!< Minimum range value for entire TIN object
   DPOINT3D_OLD maxval;                //!< Maximum range value for entire TIN object
   DOUBLE xscale;                      //!< X scale between object and ground distances
   DOUBLE yscale;                      //!< Y scale between object and ground distances
   DOUBLE zscale;                      //!< Z-value scale factor
   DOUBLE zoffset;                     //!< Z-value offset
   DOUBLE xytolerance;                 //!< Minimal distance between 2 points in TIN
   DOUBLE minangle;                    //!< Possible minimal angle in triangle
   DOUBLE flatfactor;                  //!< Flat-triangle criterion
   DOUBLE area;                        //!< Total area covered by TIN
   DOUBLE volume;                      //!< Total volume
   INT32 NumNodes;                     //!< Total number of nodes
   INT32 NumEdges;                     //!< Total number of edges
   INT32 NumTriangles;                 //!< Total number of triangles
   INT32 NumFlat;                      //!< Number of flat triangles
   INT32 NumHulls;                     //!< Total number of separated hulls, include "exclude areas"
   INT32 NumExclude;                   //!< Number of exclude areas
   INT16 zunits;                       //!< Units of measure elevation or something else
   UINT16 flags;                       //!< HASNODELIST, HASEDGELIST, HASCASCADINGTABLE
   INT32 NextNodeID;                   //!< Next node ID variable
   INT32 NextEdgeID;                   //!< Next edge ID variable
   INT32 NextTriangleID;               //!< Next triangle ID variable
   DOUBLE m_TotalLineLength;

   RVCTININFO (
      ) {Clear();}
   
   RVCTININFO (
      const RVCGENINFO& ginfo
      ) {Clear();*static_cast<RVCGENINFO*>(this) = ginfo;}
   
   //! Assignment operator.
   //! @return copy of RVCTININFO
   RVCTININFO& operator= (
      const RVCGENINFO& ginfo          //!< RVCTININFO to copy
      ) {*static_cast<RVCGENINFO*>(this) = ginfo; return (*this);}

   void Clear (
      ) {memset(static_cast<void*>(this), 0, sizeof(*this));}
   
   #ifdef RVCSYSDLL
   void CopyFrom (
      const RVCTININFO& Source,
      size_t size
      ) { memcpy(static_cast<void*>(this), &Source, MIN(size, sizeof(*this))); }
   #endif
   
   //! Get extents of TIN object.
   //! @return extents of TIN object
   DRECT3D GetExtents (
      ) const {
      DRECT3D rect;
      rect.xinit = minval.x;     
      rect.yinit = minval.y;     
      rect.zinit = minval.z;     
      rect.xlast = maxval.x;
      rect.ylast = maxval.y;
      rect.zlast = maxval.z;
      return (rect);
      }

   //! Set extents of TIN object.
   void SetExtents (
      const DRECT3D& rect
      ) {
      minval.x = rect.xinit;     
      minval.y = rect.yinit;     
      minval.z = rect.zinit;     
      maxval.x = rect.xlast;
      maxval.y = rect.ylast;
      maxval.z = rect.zlast;
      return;
      }

   };

PREVENT_MEMFUNC(RVCTININFO)

//! Triangle structure.
struct TRIANGLEREF {
   INT32 node1;                        //!< Id of node 1
   INT32 node2;                        //!< Id of node 2
   INT32 node3;                        //!< Id of node 3
   INT32 triangle12;                   //!< Connected triangle id, shared edge 1-2
   INT32 triangle23;                   //!< Connected triangle id, shared edge 2-3
   INT32 triangle31;                   //!< Connected triangle id, shared edge 3-1
   };

//! Triangle Nodes structure.
struct TRIANGLENODES {
   INT32 node1;      
   INT32 node2; 
   INT32 node3;    
   UINT32 flags;    
   };

//! Triangle Edges structure.
struct TRIANGLEEDGES {
   INT32 edge1;      
   INT32 edge2; 
   INT32 edge3;    
   UINT32 flags;    
   };

//! Triangle Triangles structure.
struct TRIANGLETRIANGLES {
   INT32 triangle1;     
   INT32 triangle2; 
   INT32 triangle3;   
   UINT32 flags;    
   };

//! Triangle Info structure.
struct TRIANGLEINFO {
   INT32 node1;                 
   INT32 node2;                      
   INT32 node3;                   
   INT32 triangle12;                 
   INT32 triangle23;               
   INT32 triangle31;                 
   INT32 edge12;                      
   INT32 edge23;                    
   INT32 edge31;                      
   UINT32 flags;    
   };

//! Edge Info structure.
struct EDGEINFO {

   enum FLAG {
      FLAG_HardEdge = 0x00000001
      };

   INT32 startnode;     
   INT32 endnode; 
   INT32 lefttriangle;  
   INT32 righttriangle; 
   UINT32 flags;    
   };

//! Values for RVCTINTRIANGLE.edgeflagsXX
#define  TINEDGE_Hard   0x01

//! Values for RVCTINHULL.hulltype
#define TINHULL_Convex  0
#define TINHULL_Clip    1
#define TINHULL_Exclude 2

//! Values for RVCTININFO.flags
#define  TIN_HasNodeLists  0x0001
#define  TIN_HasEdgeLists  0x0002
#define  TIN_HasCascading  0x0004


/*-------------------------------------------------------------------------*/
/*    Object Selection Dialogs                                             */
/*-------------------------------------------------------------------------*/

#if (defined(X_NATIVE) || defined(WIN32_MFC)) && !defined(DEPRECATE_GROUPKEY)

//! Pop-up dialog allowing user to select a TIN object.
DEPRECATED inline int MdlgGetTINObject (
   MDLGPARENT dlgparent,               //!< Parent widget
   FILEPATH& filename,                 //!< Default filename
   INT32 *inode,                       //!< Vector object inode passed/returned
   const void *prompt,                 //!< Prompt label
   RVCTININFO *objinfo,                //!< Object header passed/returned
   MfFiltFuncProto filter=0,           //!< Filter function
   void *filtuserdata=0,               //!< Filter function data
   GETOBJFLAGS flags=GETOBJFLAG_None   //!< Get object flags (See rvcdefns.h)
   ) {
   return (MdlgGetObject(dlgparent,filename,inode,prompt,OTYPE_TIN,RVCCONV_TINInfo,objinfo,sizeof(RVCTININFO),filter,filtuserdata,flags));
   }

//! Pop-up dialog allowing user to select a TIN object.
DEPRECATED inline int MdlgGetTINObject (
   MDLGPARENT dlgparent,               //!< Parent widget
   UNICODE *filename,                  //!< Default filename
   INT32 *inode,                       //!< Vector object inode passed/returned
   const void *prompt,                 //!< Prompt label
   RVCTININFO *objinfo,                //!< Object header passed/returned
   MfFiltFuncProto filter=0,           //!< Filter function
   void *filtuserdata=0,               //!< Filter function data
   GETOBJFLAGS flags=GETOBJFLAG_None   //!< Get object flags (See rvcdefns.h)
   ) {
   return (MdlgGetObject(dlgparent,filename,inode,prompt,OTYPE_TIN,RVCCONV_TINInfo,objinfo,sizeof(RVCTININFO),filter,filtuserdata,flags));
   }

#endif   //!< X_NATIVE || WIN32_MFC

//! Read TIN header.
inline int MfReadTINHeader (
   int fhandle,                        //!< RVC file handle
   RVCINODENUM inode,                  //!< Object inode
   RVCTININFO* info                    //!< TIN info to read
   ) {
   return (_MfReadHeader(fhandle,inode,info,sizeof(RVCTININFO),RVCCONV_TIN));
   }

//! Write TIN header.
inline int MfWriteTINHeader (
   int fhandle,                        //!< RVC file handle
   RVCINODENUM inode,                  //!< Object inode
   RVCTININFO* info                    //!< TIN info to write
   ) {
   return (_MfWriteHeader(fhandle,inode,info,sizeof(RVCTININFO),RVCCONV_TIN));
   }

/*-----------------------------------------------------------------------*/
/*    Prototypes for RVC TIN functions                                   */
/*-----------------------------------------------------------------------*/

#if defined(__cplusplus)
extern "C" {
#endif
//! Performs Delaunay triangulation (full parameters list).
//!
//! NOTE: The triangle vertices in TRIANGLEREF structure are organized in
//! clockwise direction (when looking down)
//! WARNING: The order of input Nodes will be changed, all nodes will be sorted
//! using X coordinate (then Y if two points have equal X coordinates).
//! WARNING: NUMBER OF NODES RETURNED MIGHT BE DIFFERENT FROM INPUT,
//! because of duplicate point removal using tolerance value.
GEOMLIBEXPORT int DelaunayProc (
   DPOINT3D **Nodes,                   //!< Input/output array of points
   TRIANGLEREF **Triangles,            //!< Output array of triangles
   RVCTINHULLEDGE **Con,               //!< Output array of hull edges
   RVCTINHULL *HullInfo,               //!< Information about convex hull
   INT32 *NumNodes,                    //!< Number of input/output nodes passed/returned
   INT32 *NumTriangles,                //!<  Number of the output triangles
   INT32 *NumHullEdges,                //!< Number of the hull edges
   double Tolerance,                   //!< Spatial tolerance
   MSTATUSINTERFACE StatInt            //!< Status interface from MstatusInterfaceGet()
   );

//! Performs Delaunay triangulation (short parameters list).
//!
//! Note: This function calls DelaunayProc.
GEOMLIBEXPORT int Delaunay3D (
   DPOINT3D **Nodes,                   //!< Input/output array of points
   TRIANGLEREF **Triangles,            //!< Output array of triangles
   INT32 *NumNodes,                    //!< Number of input/output nodes passed/returned
   INT32 *NumTriangles,                //!< Number of the output triangles
   double Tolerance,                   //!< Spatial tolerance
   MSTATUSINTERFACE StatInt            //!< Status interface from MstatusInterfaceGet()
   );

//! Performs Delaunay triangulation (short parameters list).
//!
//! Note: This function calls DelaunayProc.
GEOMLIBEXPORT int Delaunay2D (
   DPOINT2D **Nodes,                   //!< Input/output array of points
   TRIANGLEREF **Triangles,            //!< Output array of triangles
   INT32 *NumNodes,                    //!< Number of input/output nodes passed/returned
   INT32 *NumTriangles,                //!< Number of the output triangles
   double Tolerance,                   //!< Spatial tolerance
   MSTATUSINTERFACE StatInt            //!< Status interface from MstatusInterfaceGet()
   );

#ifndef GENERATING_DOXYGEN_OUTPUT

RVCAPPLIBEXPORT int _MfTINClose (
   int id,
   RVCTININFO *info,
   int HeaderSize
   );

RVCAPPLIBEXPORT int _MfTINHeaderReadOpen (
   int id,
   RVCTININFO *newtinfo,
   int HeaderSize
   );

RVCAPPLIBEXPORT int _MfTINHeaderWriteOpen (
   int id,
   RVCTININFO *tinfo,
   int HeaderSize
   );

RVCAPPLIBEXPORT int _MfTINMake (
   int fhandle,
   RVCTININFO *info,
   int HeaderSize,
   UINT32 flags
   );

RVCAPPLIBEXPORT int _MfTINOpen (
   int fhandle,
   INT32 inode,
   RVCTININFO *info,
   int HeaderSize,
   UINT32 flags
   );

#endif //!< GENERATING_DOXYGEN_OUTPUT

//! Efficiently erases the edge list.
//!
//! Used before rebuilding the edge list to avoid AddToFreeList() calls in rvclist.c.
RVCAPPLIBEXPORT int MfClearTINEdgeList (
   int id                              //!< Open TIN object handle
   );

//! Read TIN edge.
RVCAPPLIBEXPORT int MfReadTINEdge (
   int id,                             //!< Open TIN object handle
   INT32 num,                          //!< Edge id
   RVCTINEDGE *hdr                     //!< RVCTINEDGE passed / returned
   );

//! Read TIN hull.
RVCAPPLIBEXPORT int MfReadTINHull (
   int id,                             //!< Open TIN object handle
   INT32 num,                          //!< Hull id
   RVCTINHULL *hdr,                    //!< RVCTINHULL passed / returned
   INT32 *numedges,                    //!< Number of edges returned
   INT32 *numisles                     //!< Number of islands returned
   );

//! Read TIN hull edges.
//!
//! @return number of edges read
RVCAPPLIBEXPORT INT32 MfReadTINHullEdges (
   int id,                             //!< Open TIN object handle
   INT32 hullnum,                      //!< Hull id
   INT32 start,                        //!< Starting edge id
   INT32 num,                          //!< Number of edges to read
   RVCTINHULLEDGE *edges               //!< RVCTINHULLEDGE passed / returned
   );

//! Read TIN hull islands.
//!
//! @return number of islands read
RVCAPPLIBEXPORT INT32 MfReadTINHullIslands (
   int id,                             //!< Open TIN object handle
   INT32 hullnum,                      //!< Hull id
   INT32 start,                        //!< Starting island id
   INT32 num,                          //!< Number of islands to read
   INT32 *islands                      //!< Island id's returned
   );

//! Read TIN node.
RVCAPPLIBEXPORT int MfReadTINNode (
   int id,                             //!< Open TIN object handle
   INT32 num,                          //!< Node id
   RVCTINNODE *hdr,                    //!< RVCTINNODE passed / returned
   INT32 *numedges                     //!< Edge id's returned
   );

//! Read TIN node edges.
//! @return number of edges read
RVCAPPLIBEXPORT INT32 MfReadTINNodeEdges (
   int id,                             //!< Open TIN object handle
   INT32 node,                         //!< Node id
   INT32 start,                        //!< Starting edge id
   INT32 num,                          //!< Number of edges to read
   INT32 *edges                        //!< Edge id's returned
   );

//! Read TIN node edges.
//! Used by the wrapper class
//! @return number of edges read
RVCAPPLIBEXPORT INT32 MfReadTINNodeEdgesExt (
   int id,                             //!< Open TIN object handle
   INT32 node,                         //!< Node id
   INT32 **edges,                      //!< Edge id's returned
   INT32 MaxItems                      //!< Size of buffer in INT32 increments
   );

//! Read TIN triangle
RVCAPPLIBEXPORT int MfReadTINTriangle (
   int id,                             //!< Open TIN object handle
   INT32 num,                          //!< Triangle id
   RVCTINTRIANGLE *hdr                 //!< RVDTINTRIANGLE returned
   );

//! Resize a TIN.
RVCAPPLIBEXPORT int MfResizeTIN (
   int id,                             //!< Open TIN object handle
   INT32 nodes,                        //!< Number of nodes in the new TIN
   INT32 edges,                        //!< Number of edges in the new TIN
   INT32 triangles,                    //!< Number of triangles in the new TIN
   INT32 hulls                         //!< Number of hulls in the new TIN
   );

//! Swap two TIN hulls.
RVCAPPLIBEXPORT int MfSwapTINHullEdges (
   int ohandle,                        //!< Open TIN object handle
   INT32 hullnum1,                     //!< Hull number to swap
   INT32 hullnum2                      //!< Hull number to swap
   );

//! Swap two TIN nodes.
RVCAPPLIBEXPORT int MfSwapTINNodeEdges (
   int ohandle,                        //!< Open TIN object handle
   INT32 node1,                        //!< Node number to swap
   INT32 node2                         //!< Node number to swap
   );

//!  Add a callback.
RVCLOWLIBEXPORT ERRVALUE MfTINCallbackAdd (
   int fhandle,                        //!< Open file handle
   MfCallbackFunc func,                //!< Callback function
   void *data,                         //!< Callback data
   UINT32 reason                       //!< Callback reason
   );

//! REmove a callback.
RVCLOWLIBEXPORT ERRVALUE MfTINCallbackRemove (
   int fhandle,                        //!< Open file handle
   MfCallbackFunc func,                //!< Callback function
   void *data,                         //!< Callback data
   UINT32 reason                       //!< Callback reason
   );

//! Get extents for the vector object
RVCAPPLIBEXPORT ERRVALUE MfTINGetExtents (
   int id,
   DRECT3D& Extents
   );
   
//! Get number of edges in a TIN.
//!
//! @return number of edges
RVCAPPLIBEXPORT INT32 MfTINGetNumEdges (
   int id                              //!< Open TIN object handle
   );

//! Get number of hulls in a TIN.
//!
//! @return number of hulls
RVCAPPLIBEXPORT INT32 MfTINGetNumHulls (
   int id                              //!< Open TIN object handle
   );

//! Get number of nodes in a TIN.
//!
//! @return number of nodes
RVCAPPLIBEXPORT INT32 MfTINGetNumNodes (
   int id                              //!< Open TIN object handle
   );

//! Get number of triangles in a TIN.
//!
//! @return number of triangles
RVCAPPLIBEXPORT INT32 MfTINGetNumTriangles (
   int id                              //!< Open TIN object handle
   );

//! Set extents for the vector object
RVCAPPLIBEXPORT ERRVALUE MfTINSetExtents (
   int id,
   const DRECT3D& Extents
   );
   
//! Update extents for the vector object
RVCAPPLIBEXPORT ERRVALUE MfTINUpdateExtents (
   int id,
   const DRECT3D& Extents
   );
   
//! Write TIN edge.
RVCAPPLIBEXPORT int MfWriteTINEdge (
   int id,                             //!< Open TIN object handle
   INT32 num,                          //!< Edge number to write
   const RVCTINEDGE *hdr               //!< TIN edge data to write
   );

//! Write TIN hull.
RVCAPPLIBEXPORT int MfWriteTINHull (
   int id,                             //!< Open TIN object handle
   INT32 num,                          //!< Hull number to write
   const RVCTINHULL *hdr               //!< TIN hull data to write
   );

//! Write TIN hull edges.
RVCAPPLIBEXPORT INT32 MfWriteTINHullEdges (
   int id,                             //!< Open TIN object handle
   INT32 hullnum,                      //!< Hull number to write
   INT32 total,                        //!< Total number of edges
   INT32 start,                        //!< Starting edge
   INT32 num,                          //!< Number of edges to write
   const RVCTINHULLEDGE *edges         //!< TIN hull edge data to write
   );

//! Write TIN hull islands.
RVCAPPLIBEXPORT INT32 MfWriteTINHullIslands (
   int id,                             //!< Open TIN object handle
   INT32 hullnum,                      //!< Hull number to write
   INT32 total,                        //!< Total number of islands
   INT32 start,                        //!< Starting island
   INT32 num,                          //!< Number of islands to write
   const INT32 *islands                //!< TIN hull island id's to write
   );

//! Write TIN node.
RVCAPPLIBEXPORT int MfWriteTINNode (
   int id,                             //!< Open TIN object handle
   INT32 num,                          //!< Node number to write
   const RVCTINNODE *hdr               //!< TIN node data to write
   );

//! Write TIN node edges.
RVCAPPLIBEXPORT INT32 MfWriteTINNodeEdges (
   int id,                             //!< Open TIN object handle
   INT32 node,                         //!< Node number to write
   INT32 total,                        //!< Total number to edges
   INT32 start,                        //!< Starting edge
   INT32 num,                          //!< Number of edges to write
   const INT32 *edges                  //!< TIN edge id's to write
   );

//! Write TIN triangle.
RVCAPPLIBEXPORT int MfWriteTINTriangle (
   int id,                             //!< Open TIN object handle
   INT32 num,                          //!< Triangle number to write
   const RVCTINTRIANGLE *hdr           //!< TIN triangle data to write
   );

//! Determine if a given point is inside specified TIN triangle.
//!
//! @return 1 if true, 0 if false, < 0 if error
int PointInTINTriangle (
   int ohandle,                        //!< RVC handle for open TIN object
   INT32 TriangleNum,                  //!< Triangle number to test
   double xcheck,                      //!< TIN X coordinate of point to test
   double ycheck                       //!< TIN Y coordinate of point to test
   );

//! Compute full set of contour segments for a given triangle (as a set of 3 nodes).
//!
//! Return: number of contours computed (might return 0).
//! NOTE:   Programmer is responsible for freeing Contours when done, 
//!   do not forget to free individual entries: (*Contours)[i].point  .
int ComputeTriangleContours (
   RVCTINNODE *A,                      //!< passed node of the triangle (supply x,y,z)
   RVCTINNODE *B,                      //!< passed node of the triangle (supply x,y,z)
   RVCTINNODE *C,                      //!< passed node of the triangle (supply x,y,z)
   DOUBLE start,                       //!< passed starting level of contouring range (Z)
   DOUBLE end,                         //!< passed ending level of contouring range (Z)
   DOUBLE interval,                    //!< passed interval between contour lines in Z units
   DPOLYLINE3D **Contours              //!< return array of DPOLYLINE3D that contains contours
   );

//! Compute full set of contour segments for a given triangle (as a set of 3 nodes).
//!
//! @return number of contours computed (might return 0).
int ComputeTriangleContoursExt (
   RVCTINNODE *A,                      //!< passed node of the triangle (supply x,y,z)
   RVCTINNODE *B,                      //!< passed node of the triangle (supply x,y,z)
   RVCTINNODE *C,                      //!< passed node of the triangle (supply x,y,z)
   DOUBLE start,                       //!< passed starting level of contouring range (Z)
   DOUBLE end,                         //!< passed ending level of contouring range (Z)
   DOUBLE interval,                    //!< passed interval between contour lines in Z units
   void (*CBfunc)(DPOLYLINE3D*, void*),//! callback that will be envoked for each contour line
   void *userdata                      //!< user specified data to be passed to callback
   );

#define  MfCloseTIN(_id,_info)            _MfTINClose((_id),(_info),sizeof(RVCTININFO))
#define  MfReadOpenTINHeader(_id,_info)   _MfTINHeaderReadOpen((_id),(_info),sizeof(RVCTININFO))
#define  MfMakeTIN(_id,_info,_fl)         _MfTINMake((_id),(_info),sizeof(RVCTININFO),(_fl))
#define  MfOpenTIN(_id,_oi,_info,_fl)     _MfTINOpen((_id),(_oi),(_info),sizeof(RVCTININFO),(_fl))

#if defined(__cplusplus)
}
#endif

#endif      //!<  #ifndef INC_MI32_RVCTIN_H 

---