//----------------------------------------------------------------------------
//  EgalTech 2014-2014
//----------------------------------------------------------------------------
// File : API_GdbCreate.cpp       Data : 30.09.14        Versione : 1.5i5
// Contenuto : Funzioni di creazione oggetti del DB geometrico per API.
//
//
//
// Modifiche : 30.09.14 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "API.h"
#include "API_Macro.h"
#include "/EgtDev/Include/EInAPI.h"
#include "/EgtDev/Include/EgkGeoPoint3d.h"
#include "/EgtDev/Include/EgkGeoVector3d.h"
#include "/EgtDev/Include/EgkCurveLine.h"
#include "/EgtDev/Include/EgkCurveArc.h"
#include "/EgtDev/Include/EgkCurveBezier.h"
#include "/EgtDev/Include/EgkCurveComposite.h"
#include "/EgtDev/Include/EgkSurfTriMesh.h"
#include "/EgtDev/Include/EgkExtText.h"
#include "/EgtDev/Include/EGkDistPointCurve.h"
#include "/EgtDev/Include/EGnStringConverter.h"
#include "/EgtDev/Include/EgtPointerOwner.h"

using namespace std ;

//-------------------------------------------------------------------------------
static bool GetPolyLineFromCurve( IGeomDB* pGeomDB, int nId, const Frame3d& frDest, double dLinTol, PolyLine& PL) ;


//-------------------------------------------------------------------------------
int
__stdcall EgtCreateGroup( int nParentId, const double ptOrig[3],
                          const double vX[3], const double vY[3], const double vZ[3])
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // costruisco il riferimento
   Frame3d frFrame ;
   if ( ! frFrame.Set( ptOrig, vX, vY, vZ))
      return GDB_ID_NULL ;
  // creo il gruppo
   return pGeomDB->AddGroup( GDB_ID_NULL, nParentId, frFrame) ;
}

//-------------------------------------------------------------------------------
int
__stdcall EgtCreateGeoPoint( int nParentId, const double ptP[3])
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // creo il punto
   PtrOwner<IGeoPoint3d> pGeoPnt( CreateGeoPoint3d()) ;
   if ( IsNull( pGeoPnt))
      return GDB_ID_NULL ;
  // setto il punto
   if ( ! pGeoPnt->Set(  ptP))
      return GDB_ID_NULL ;
  // inserisco il punto nel DB
   return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pGeoPnt)) ;
}

//-------------------------------------------------------------------------------
int
__stdcall EgtCreateGeoVector( int nParentId, const double vtV[3], const double ptB[3])
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // creo il vettore
   PtrOwner<IGeoVector3d> pGeoVct( CreateGeoVector3d()) ;
   if ( IsNull( pGeoVct))
      return GDB_ID_NULL ;
  // setto il vettore (con il punto base)
   if ( ! pGeoVct->Set( vtV, ptB))
      return GDB_ID_NULL ;
  // inserisco il vettore nel DB
   return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pGeoVct)) ;
}

//-------------------------------------------------------------------------------
int
__stdcall EgtCreateGeoFrame( int nParentId, const double ptOrig[3],
                             const double vX[3], const double vY[3], const double vZ[3])
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // creo il riferimento
   PtrOwner<IGeoFrame3d> pGeoFrm( CreateGeoFrame3d()) ;
   if ( IsNull( pGeoFrm))
      return GDB_ID_NULL ;
  // setto il riferimento
   if ( ! pGeoFrm->Set( ptOrig, vX, vY, vZ)) 
      return GDB_ID_NULL ;
  // inserisco il vettore nel DB
   return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pGeoFrm)) ;
}

//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveLine( int nParentId, const double ptIni[3], const double ptFin[3])
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // creo la linea
   PtrOwner<ICurveLine> pCrvLine( CreateCurveLine()) ;
   if ( IsNull( pCrvLine))
      return GDB_ID_NULL ;
  // setto la linea
   if ( ! pCrvLine->Set( ptIni, ptFin))
      return GDB_ID_NULL ;
  // inserisco la linea nel DB
   return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvLine)) ;
}

//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveLineMinPointCurve( int nParentId,
                                           const double ptStart[3], int nCrvId, double dNearPar)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // recupero il riferimento del gruppo destinazione
   Frame3d frPoint ;
   if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frPoint))
      return GDB_ID_NULL ;
  // recupero il riferimento della curva
   Frame3d frCurve ;
   if ( ! pGeomDB->GetGlobFrame( nCrvId, frCurve))
      return GDB_ID_NULL ;
  // recupero la curva
   const ICurve* pCurve =  GetCurve( pGeomDB->GetGeoObj( nCrvId)) ;
   if ( pCurve == nullptr)
      return GDB_ID_NULL ;
  // porto il punto nel riferimento della curva
   Point3d ptSloc = ptStart ;
   ptSloc.LocToLoc( frPoint, frCurve) ;
  // calcolo il punto a minima distanza
   int nFlag ;
   Point3d ptEnd ;
   DistPointCurve dstPtCurve( ptSloc, *pCurve) ;
   if ( ! dstPtCurve.GetMinDistPoint( dNearPar, ptEnd, nFlag))
      return GDB_ID_NULL ;
  // porto il punto finale nel riferimento di creazione
   ptEnd.LocToLoc( frCurve, frPoint) ;
  // creo la linea
   PtrOwner<ICurveLine> pCrvLine( CreateCurveLine()) ;
   if ( IsNull( pCrvLine))
      return GDB_ID_NULL ;
  // setto la linea
   if ( ! pCrvLine->Set( ptStart, ptEnd))
      return GDB_ID_NULL ;
  // inserisco la linea nel DB
   return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvLine)) ;
}

//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveCircle( int nParentId,
                                const double ptCen[3], const double vtN[3], double dRad)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // creo l'arco
   PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
   if ( IsNull( pCrvArc))
      return GDB_ID_NULL ;
  // setto la circonferenza
   if ( ! pCrvArc->Set( ptCen, vtN, dRad)) 
      return GDB_ID_NULL ;
  // inserisco l'arco nel DB
   return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvArc)) ;
}

//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveCircleXY( int nParentId,
                                  const double ptCen[3], double dRad)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // creo l'arco
   PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
   if ( IsNull( pCrvArc))
      return GDB_ID_NULL ;
  // setto la circonferenza
   if ( ! pCrvArc->SetXY( ptCen, dRad)) 
      return GDB_ID_NULL ;
  // inserisco l'arco nel DB
   return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvArc)) ;
}

//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveCircle3P( int nParentId,
                                  const double ptP1[3], const double ptP2[3], const double ptP3[3])
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // creo l'arco
   PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
   if ( IsNull( pCrvArc))
      return GDB_ID_NULL ;
  // setto l'arco
   if ( ! pCrvArc->Set3P( ptP1, ptP2, ptP3, true))
      return GDB_ID_NULL ;
  // inserisco l'arco nel DB
   return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvArc)) ;
}

//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveArc( int nParentId,
                             const double ptCen[3], const double vtN[3], double dRad,
                             const double vtS[3], double dAngCenDeg, double dDeltaN)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // creo l'arco
   PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
   if ( IsNull( pCrvArc))
      return GDB_ID_NULL ;
  // setto l'arco
   if ( ! pCrvArc->Set( ptCen, vtN, dRad, vtS, dAngCenDeg, dDeltaN)) 
      return GDB_ID_NULL ;
  // inserisco l'arco nel DB
   return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvArc)) ;
}

//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveArcXY( int nParentId,
                               const double ptCen[3], double dRad,
                               double dAngStartDeg, double dAngCenDeg, double dDeltaZ)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // creo l'arco
   PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
   if ( IsNull( pCrvArc))
      return GDB_ID_NULL ;
  // setto l'arco
   if ( ! pCrvArc->SetXY( ptCen, dRad, dAngStartDeg, dAngCenDeg, dDeltaZ)) 
      return GDB_ID_NULL ;
  // inserisco l'arco nel DB
   return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvArc)) ;
}

//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveArc3P( int nParentId,
                               const double ptP1[3], const double ptP2[3], const double ptP3[3])
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // creo l'arco
   PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
   if ( IsNull( pCrvArc))
      return GDB_ID_NULL ;
  // setto l'arco
   if ( ! pCrvArc->Set3P( ptP1, ptP2, ptP3, false))
      return GDB_ID_NULL ;
  // inserisco l'arco nel DB
   return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvArc)) ;
}

//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveBezier( int nParentId, int nDegree, const double ptCtrls[])
{
   PNTVECTOR vPnt ;
   vPnt.reserve( nDegree + 1) ;
   for ( int i = 0 ; i <= nDegree ; ++i) {
      vPnt.push_back( Point3d( ptCtrls[3*i], ptCtrls[3*i+1], ptCtrls[3*i+2])) ;
   }
   return EgtCreateCurveBezier( nParentId, nDegree, vPnt) ;
}

//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveBezier( int nParentId, int nDegree, const PNTVECTOR& vPnt)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
   // il numero dei punti deve essere pari al grado + 1
   if ( vPnt.size() != nDegree + 1) 
      return GDB_ID_NULL ;
  // creo la curva di Bezier
   PtrOwner<ICurveBezier> pCrvBez( CreateCurveBezier()) ;
   if ( IsNull( pCrvBez))
      return GDB_ID_NULL ;
  // inizializzo la curva di Bezier
   if ( ! pCrvBez->Init( nDegree, false))
      return GDB_ID_NULL ;
  // setto i punti di controllo
   for ( int i = 0 ; i <= nDegree ; ++ i) {
      if ( ! pCrvBez->SetControlPoint( i, vPnt[i]))
         return GDB_ID_NULL ;
   }
  // se curva nulla (ovvero ridotta a punto), errore
   if ( pCrvBez->IsAPoint())
      return GDB_ID_NULL ;
  // inserisco la curva nel DB
   return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvBez)) ;
}

//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveBezierRational( int nParentId, int nDegree, const double ptCtrlWs[])
{
   PNTUVECTOR vPntW ;
   vPntW.reserve( nDegree + 1) ;
   for ( int i = 0 ; i <= nDegree ; ++i) {
      vPntW.push_back( make_pair( Point3d( ptCtrlWs[4*i], ptCtrlWs[4*i+1], ptCtrlWs[4*i+2]), ptCtrlWs[4*i+3])) ;
   }
   return EgtCreateCurveBezierRational( nParentId, nDegree, vPntW) ;
}

//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveBezierRational( int nParentId, int nDegree, const PNTUVECTOR& vPntW)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
   // il numero dei punti deve essere pari al grado + 1
   if ( vPntW.size() != nDegree + 1) 
      return GDB_ID_NULL ;
  // creo la curva di Bezier
   PtrOwner<ICurveBezier> pCrvBez( CreateCurveBezier()) ;
   if ( IsNull( pCrvBez))
      return GDB_ID_NULL ;
  // inizializzo la curva di Bezier
   if ( ! pCrvBez->Init( nDegree, true))
      return GDB_ID_NULL ;
  // setto i punti di controllo
   for ( int i = 0 ; i <= nDegree ; ++ i) {
      if ( ! pCrvBez->SetControlPoint( i, vPntW[i].first, vPntW[i].second))
         return GDB_ID_NULL ;
   }
  // se curva nulla (ovvero ridotta a punto), errore
   if ( pCrvBez->IsAPoint())
      return GDB_ID_NULL ;
  // inserisco la curva nel DB
   return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvBez)) ;
}

//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveBezierFromArc( int nParentId, int nArcId, BOOL bErase)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // creo la curva di Bezier
   PtrOwner<ICurveBezier> pCrvBez( CreateCurveBezier()) ;
   if ( IsNull( pCrvBez))
      return GDB_ID_NULL ;
  // recupero l'arco
   const ICurveArc* pCrvArc = GetCurveArc( pGeomDB->GetGeoObj( nArcId)) ; 
   if ( pCrvArc == nullptr)
      return GDB_ID_NULL ;
  // ne deduco la curva di Bezier
   if ( ! pCrvBez->FromArc( *pCrvArc))
      return GDB_ID_NULL ;
  // recupero il riferimento dell'arco
   Frame3d frSou ;
   if ( ! pGeomDB->GetGlobFrame( nArcId, frSou))
      return GDB_ID_NULL ;
  // recupero il riferimento del gruppo destinazione
   Frame3d frDest ;
   if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frDest))
      return GDB_ID_NULL ;
  // porto la curva di Bezier dal riferimento dell'arco a quello di inserimento
   if ( ! AreSameFrame( frSou, frDest)) {
      pCrvBez->ToGlob( frSou) ;
      pCrvBez->ToLoc( frDest) ;
   }
  // se curva nulla (ovvero ridotta a punto), errore
   if ( pCrvBez->IsAPoint())
      return GDB_ID_NULL ;
  // inserisco la curva nel DB
   int nId = pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvBez)) ;
   if ( nId != GDB_ID_NULL) {
     // se richiesto, cancello l'arco originale
      if ( bErase) {
         if ( ! pGeomDB->Erase( nArcId))
            return GDB_ID_NULL ;
      }
   }
   return nId ;
}

//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveCompo( int nParentId, int nNumId, const int nIds[], BOOL bErase)
{
   INTVECTOR vIds ;
   vIds.reserve( nNumId) ;
   for ( int i = 0 ; i < nNumId ; ++i) {
      vIds.push_back( nIds[i]) ;
   }
   return EgtCreateCurveCompo( nParentId, vIds, ( bErase != FALSE)) ;
}

//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveCompo( int nParentId, const INTVECTOR& vIds, bool bErase)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // creo la curva composita
   PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
   if ( IsNull( pCrvCompo))
      return GDB_ID_NULL ;
  // recupero il riferimento del gruppo destinazione
   Frame3d frDest ;
   if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frDest))
      return false ;
  // esecuzione
   INTVECTOR::const_iterator Iter ;
   for ( Iter = vIds.begin() ; Iter != vIds.end() ; ++Iter) {
     // recupero la curva
      int nIdCrv = *Iter ;
      const ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( nIdCrv)) ; 
      if ( pCrv == nullptr)
         return false ;
     // recupero il riferimento della curva
      Frame3d frSou ;
      if ( ! pGeomDB->GetGlobFrame( nIdCrv, frSou))
         return false ;
     // se i riferimenti sono uguali
      if ( AreSameFrame( frSou, frDest)) {
        // aggiungo direttamente questa curva
         if ( ! pCrvCompo->AddCurve( *pCrv))
            return false ;
      }
     // altrimenti devo prima trasformare la curva
      else {
        // creo una copia della curva
         PtrOwner<ICurve> pModCrv( pCrv->Clone()) ;
         if ( IsNull( pModCrv))
            return false ;
        // eseguo la trasformazione
         pModCrv->LocToLoc( frSou, frDest) ;
        // aggiungo la curva modificata
         if ( ! pCrvCompo->AddCurve( Release( pModCrv)))
            return false ;
      }
   }
  // inserisco la curva composita nel DB
   int nId = pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvCompo)) ;
   if ( nId != GDB_ID_NULL) {
     // se richiesto, cancello le curve originali
      if ( bErase) {
         for ( Iter = vIds.begin() ; Iter != vIds.end() ; ++Iter) {
            if ( ! pGeomDB->Erase( *Iter))
               return GDB_ID_NULL ;
         }
      }
   }
   return nId ;
}

//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveCompoFromPoints( int nParentId, int nP, const double ptPs[])
{
   PolyLine PL ;
   for ( int i = 0 ; i < nP ; ++i) {
      PL.AddUPoint( 0, Point3d( ptPs[3*i], ptPs[3*i+1], ptPs[3*i+2])) ;
   }
   return EgtCreateCurveCompoFromPoints( nParentId, PL) ;
}

//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveCompoFromPoints( int nParentId, const PolyLine& PL)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // creo la curva composita
   PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
   if ( IsNull( pCrvCompo))
      return GDB_ID_NULL ;
  // inserisco i segmenti che uniscono i punti
   if ( ! pCrvCompo->FromPolyLine( PL))
      return GDB_ID_NULL ;
  // inserisco la curva composita nel DB
   return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvCompo)) ;
}

//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveCompoFromPointBulges( int nParentId, int nPB, const double ptPBs[])
{
   PolyArc PA ;
   for ( int i = 0 ; i < nPB ; ++i) {
      PA.AddUPoint( 0, Point3d( ptPBs[4*i], ptPBs[4*i+1], ptPBs[4*i+2]), ptPBs[4*i+3]) ;
   }
   return EgtCreateCurveCompoFromPointBulges( nParentId, PA) ;
}

//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveCompoFromPointBulges( int nParentId, const PolyArc& PA)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // creo la curva composita
   PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
   if ( IsNull( pCrvCompo))
      return GDB_ID_NULL ;
  // inserisco i segmenti e gli archi che uniscono i punti
   if ( ! pCrvCompo->FromPolyArc( PA))
      return GDB_ID_NULL ;
  // inserisco la curva composita nel DB
   return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvCompo)) ;
}

//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveCompoFromPolygonSide( int nParentId, int nNumSides,
                                              const double ptIni[3], const double ptFin[3])
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // creo la curva composita
   PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
   if ( IsNull( pCrvCompo))
      return GDB_ID_NULL ;
  // setto la curva
   if ( ! pCrvCompo->PolygonSide( nNumSides, ptIni, ptFin))
      return GDB_ID_NULL ;
  // inserisco la curva nel DB
   return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvCompo)) ;
}

//-------------------------------------------------------------------------------
int
__stdcall EgtCreateSurfTriMeshByContour( int nParentId, int nCrvId, double dLinTol)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // recupero il riferimento del gruppo destinazione
   Frame3d frDest ;
   if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frDest))
      return GDB_ID_NULL ;
  // calcolo la polilinea che approssima la curva
   PolyLine PL ;
   if ( ! GetPolyLineFromCurve( pGeomDB, nCrvId, frDest, dLinTol, PL))
      return GDB_ID_NULL ;
  // creo la superficie trimesh
   PtrOwner<ISurfTriMesh> pSTM( CreateSurfTriMesh()) ;
   if ( IsNull( pSTM))
      return GDB_ID_NULL ;
  // setto la superficie
   if ( ! pSTM->CreateByFlatContour( PL))
      return GDB_ID_NULL ;
  // inserisco la superficie nel DB
   return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSTM)) ;
}

//-------------------------------------------------------------------------------
int
__stdcall EgtCreateText( int nParentId, const wchar_t* wsText,
                         const double ptP[3], double dAngRotDeg, double dH)
{
   return EgtCreateText( nParentId, wstrztoA( wsText), ptP, dAngRotDeg, dH) ;
}

//-------------------------------------------------------------------------------
int
__stdcall EgtCreateText( int nParentId, const string& sText,
                         const Point3d& ptP, double dAngRotDeg, double dH)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // creo il testo
   PtrOwner<IExtText> pTXT( CreateExtText()) ;
   if ( IsNull( pTXT))
      return GDB_ID_NULL ;
  // lo riempio
   if ( ! pTXT->Set( sText, ptP, dAngRotDeg, dH))
      return GDB_ID_NULL ;
  // inserisco il testo nel DB
   return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pTXT)) ;
}

//-------------------------------------------------------------------------------
int
__stdcall EgtCreateTextEx( int nParentId, const wchar_t* wsText,
                           const double ptP[3], double dAngRotDeg, const wchar_t* wsFont,
                           int nW, BOOL bItalic, double dH, double dRat, double dAddAdv, int nInsPos)
{
   return EgtCreateTextEx( nParentId, wstrztoA( wsText), ptP, dAngRotDeg,
                           wstrztoA( wsFont), nW, ( bItalic != FALSE), dH, dRat, dAddAdv, nInsPos) ;
}

//-------------------------------------------------------------------------------
int
__stdcall EgtCreateTextEx( int nParentId, const string& sText,
                           const Point3d& ptP, double dAngRotDeg, const string& sFont,
                           int nW, bool bItalic, double dH, double dRat, double dAddAdv, int nInsPos)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // creo il testo
   PtrOwner<IExtText> pTXT( CreateExtText()) ;
   if ( IsNull( pTXT))
      return GDB_ID_NULL ;
  // lo riempio
   if ( ! pTXT->Set( sText, ptP, dAngRotDeg, sFont, nW, bItalic, dH, dRat, dAddAdv, nInsPos))
      return GDB_ID_NULL ;
  // inserisco il testo nel DB
   return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pTXT)) ;
}

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
static bool
GetPolyLineFromCurve( IGeomDB* pGeomDB, int nId, const Frame3d& frDest, double dLinTol, PolyLine& PL)
{
   const double ANG_TOL_STD_DEG = 15 ;
  // recupero la curva
   const ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( nId)) ; 
   if ( pCrv == nullptr)
      return false ;
  // recupero il riferimento della curva
   Frame3d frCrv ;
   if ( ! pGeomDB->GetGlobFrame( nId, frCrv))
      return false ;
  // calcolo la polilinea che approssima la curva
  // se i riferimenti sono uguali
   if ( AreSameFrame( frCrv, frDest)) {
     // ricavo l'approssimazione
      if ( ! pCrv->ApproxWithLines( dLinTol, ANG_TOL_STD_DEG, PL))
         return false ;
   }
  // altrimenti devo prima trasformare la curva
   else {
     // creo una copia della curva (da buttare alla fine)
      PtrOwner<ICurve> pModCrv( pCrv->Clone()) ;
      if ( IsNull( pModCrv))
         return false ;
     // eseguo la trasformazione
      pModCrv->LocToLoc( frCrv, frDest) ;
     // ricavo l'approssimazione
      if ( ! pModCrv->ApproxWithLines( dLinTol, ANG_TOL_STD_DEG, PL))
         return false ;
   }
   return true ;
}