//----------------------------------------------------------------------------
//  EgalTech 2014-2014
//----------------------------------------------------------------------------
// File : API_GdbCreateSurf.cpp       Data : 02.11.14        Versione : 1.5j7
// Contenuto : Funzioni di creazione superfici del DB geometrico per API.
//
//
//
// Modifiche : 02.11.14 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "API.h"
#include "API_Macro.h"
#include "AuxTools.h"
#include "GeoTools.h"
#include "/EgtDev/Include/EInAPI.h"
#include "/EgtDev/Include/EInConst.h"
#include "/EgtDev/Include/EGkStmStandard.h"
#include "/EgtDev/Include/EGkStmFromCurves.h"
#include "/EgtDev/Include/EGkStmFromTriangleSoup.h"
#include "/EgtDev/Include/EgkStringUtils3d.h"
#include "/EgtDev/Include/EgkGeoPoint3d.h"
#include "/EgtDev/Include/EgkCurveLocal.h"
#include "/EgtDev/Include/EgtPointerOwner.h"

using namespace std ;

//-------------------------------------------------------------------------------
int
__stdcall EgtCreateSurfTmBox( int nParentId, const double ptIni[3], const double ptCross[3],
                              const double ptDir[3], double dHeight, int nRefType)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
   bool bOk = true ;
  // recupero il riferimento locale
   Frame3d frLoc ;
   if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frLoc))
      return GDB_ID_NULL ;
  // porto in locale i punti, i versori e il versore estrusione
   Point3d ptIniL = GetPointLocal( pGeomDB, ptIni, nRefType, frLoc) ;
   Point3d ptCrossL = GetPointLocal( pGeomDB, ptCross, nRefType, frLoc) ;
   Point3d ptDirL = GetPointLocal( pGeomDB, ptDir, nRefType, frLoc) ;
  // ne ricavo un riferimento intrinseco
   Frame3d frBox ;
   bOk = bOk && frBox.Set( ptIniL, ptDirL, ptCrossL) ;
  // ricavo le dimensioni della base
   Point3d ptCrossI = ptCrossL ;
   ptCrossI.ToLoc( frBox) ;
   double dWidth = ptCrossI.x ;
   double dLen = ptCrossI.y ;
  // creo il box nel suo riferimento intrinseco
   PtrOwner<ISurfTriMesh> pSTM( GetSurfTriMeshBox( fabs( dWidth), dLen, dHeight)) ;
   bOk = bOk && ! IsNull( pSTM) ;
  // eventuale traslazione per larghezza negativa
   if ( dWidth < 0)
      pSTM->Translate( Vector3d( dWidth, 0, 0)) ;
  // porto il box nel riferimento locale
   bOk = bOk && pSTM->ToGlob( frBox) ;
  // inserisco la superficie nel DB
   int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSTM)) : GDB_ID_NULL) ;
   EgtSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtSurfTmBox(" + ToString( nParentId) + ",{" +
                                      ToString( Point3d( ptIni)) + "},{" +
                                      ToString( Point3d( ptCross)) + "},{" +
                                      ToString( Point3d( ptDir)) + "}," +
                                      ToString( dHeight) + "," +
                                      RefTypeToString( nRefType) + ")" +
                    " -- Id=" + ToString( nNewId) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco l'identificativo della nuova entità
   return nNewId ;
}

//-------------------------------------------------------------------------------
int
__stdcall EgtCreateSurfTmPyramid( int nParentId, const double ptIni[3], const double ptCross[3],
                                  const double ptDir[3], double dHeight, int nRefType)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
   bool bOk = true ;
  // recupero il riferimento locale
   Frame3d frLoc ;
   if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frLoc))
      return GDB_ID_NULL ;
  // porto in locale i punti, i versori e il versore estrusione
   Point3d ptIniL = GetPointLocal( pGeomDB, ptIni, nRefType, frLoc) ;
   Point3d ptCrossL = GetPointLocal( pGeomDB, ptCross, nRefType, frLoc) ;
   Point3d ptDirL = GetPointLocal( pGeomDB, ptDir, nRefType, frLoc) ;
  // ne ricavo un riferimento intrinseco
   Frame3d frBox ;
   bOk = bOk && frBox.Set( ptIniL, ptDirL, ptCrossL) ;
  // ricavo le dimensioni della base
   Point3d ptCrossI = ptCrossL ;
   ptCrossI.ToLoc( frBox) ;
   double dWidth = ptCrossI.x ;
   double dLen = ptCrossI.y ;
  // creo la piramide nel suo riferimento intrinseco
   PtrOwner<ISurfTriMesh> pSTM( GetSurfTriMeshPyramid( fabs( dWidth), dLen, dHeight)) ;
   bOk = bOk && ! IsNull( pSTM) ;
  // eventuale traslazione per larghezza negativa
   if ( dWidth < 0)
      pSTM->Translate( Vector3d( dWidth, 0, 0)) ;
  // porto la piramide nel riferimento locale
   bOk = bOk && pSTM->ToGlob( frBox) ;
  // inserisco la superficie nel DB
   int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSTM)) : GDB_ID_NULL) ;
   EgtSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtSurfTmPyramid(" + ToString( nParentId) + ",{" +
                                          ToString( Point3d( ptIni)) + "},{" +
                                          ToString( Point3d( ptCross)) + "},{" +
                                          ToString( Point3d( ptDir)) + "}," +
                                          ToString( dHeight) + "," +
                                          RefTypeToString( nRefType) + ")" +
                    " -- Id=" + ToString( nNewId) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco l'identificativo della nuova entità
   return nNewId ;
}

//-------------------------------------------------------------------------------
int
__stdcall EgtCreateSurfTmCylinder( int nParentId, const double ptOrig[3], const double vtN[3],
                                   double dRad, double dHeight, double dLinTol, int nRefType)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
   bool bOk = true ;
  // recupero il riferimento locale
   Frame3d frLoc ;
   bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
  // porto in locale il punto e il versore
   Point3d ptOrigL = GetPointLocal( pGeomDB, ptOrig, nRefType, frLoc) ;
   Vector3d vtNL = GetVectorLocal( pGeomDB, vtN, nRefType, frLoc) ;
  // calcolo riferimento OCS a partire da questo punto e versore
   Frame3d frCyl ;
   bOk = bOk && frCyl.Set( ptOrigL, vtNL) ;
  // creo il cilindro nel suo riferimento intrinseco
   PtrOwner<ISurfTriMesh> pSTM( GetSurfTriMeshCylinder( dRad, dHeight, dLinTol)) ;
   bOk = bOk && ! IsNull( pSTM) ;
  // porto il cilindro nel riferimento locale
   bOk = bOk && pSTM->ToGlob( frCyl) ;
  // inserisco la superficie nel DB
   int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSTM)) : GDB_ID_NULL) ;
   EgtSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtSurfTmCylinder(" + ToString( nParentId) + ",{" +
                                           ToString( Point3d( ptOrig)) + "},{" +
                                           ToString( Vector3d( vtN)) + "}," +
                                           ToString( dRad) + "," +
                                           ToString( dHeight) + "," +
                                           ToString( dLinTol) + "," +
                                           RefTypeToString( nRefType) + ")" +
                    " -- Id=" + ToString( nNewId) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco l'identificativo della nuova entità
   return nNewId ;
}

//-------------------------------------------------------------------------------
int
__stdcall EgtCreateSurfTmCone( int nParentId, const double ptOrig[3], const double vtN[3],
                               double dRad, double dHeight, double dLinTol, int nRefType)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
   bool bOk = true ;
  // recupero il riferimento locale
   Frame3d frLoc ;
   bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
  // porto in locale il punto e il versore
   Point3d ptOrigL = GetPointLocal( pGeomDB, ptOrig, nRefType, frLoc) ;
   Vector3d vtNL = GetVectorLocal( pGeomDB, vtN, nRefType, frLoc) ;
  // calcolo riferimento OCS a partire da questo punto e versore
   Frame3d frCyl ;
   bOk = bOk && frCyl.Set( ptOrigL, vtNL) ;
  // creo il cono nel suo riferimento intrinseco
   PtrOwner<ISurfTriMesh> pSTM( GetSurfTriMeshCone( dRad, dHeight, dLinTol)) ;
   bOk = bOk && ! IsNull( pSTM) ;
  // porto il cono nel riferimento locale
   bOk = bOk && pSTM->ToGlob( frCyl) ;
  // inserisco la superficie nel DB
   int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSTM)) : GDB_ID_NULL) ;
   EgtSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtSurfTmCone(" + ToString( nParentId) + ",{" +
                                       ToString( Point3d( ptOrig)) + "},{" +
                                       ToString( Vector3d( vtN)) + "}," +
                                       ToString( dRad) + "," +
                                       ToString( dHeight) + "," +
                                       ToString( dLinTol) + "," +
                                       RefTypeToString( nRefType) + ")" +
                    " -- Id=" + ToString( nNewId) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco l'identificativo della nuova entità
   return nNewId ;
}

//-------------------------------------------------------------------------------
int
__stdcall EgtCreateSurfTmSphere( int nParentId, const double ptOrig[3],
                                 double dRad, double dLinTol, int nRefType)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
   bool bOk = true ;
  // recupero il riferimento locale
   Frame3d frLoc ;
   bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
  // porto in locale il punto
   Point3d ptOrigL = GetPointLocal( pGeomDB, ptOrig, nRefType, frLoc) ;
  // creo la sfera
   PtrOwner<ISurfTriMesh> pSTM( GetSurfTriMeshSphere( dRad, dLinTol)) ;
   bOk = bOk && ! IsNull( pSTM) ;
  // porto la sfera nella sua origine
   bOk = bOk && pSTM->Translate( ptOrig - ORIG) ;
  // inserisco la superficie nel DB
   int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSTM)) : GDB_ID_NULL) ;
   EgtSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtSurfTmSphere(" + ToString( nParentId) + ",{" +
                                         ToString( Point3d( ptOrig)) + "}," +
                                         ToString( dRad) + "," +
                                         ToString( dLinTol) + "," +
                                         RefTypeToString( nRefType) + ")" +
                    " -- Id=" + ToString( nNewId) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco l'identificativo della nuova entità
   return nNewId ;
}

//-------------------------------------------------------------------------------
int
__stdcall EgtCreateSurfTmByFlatContour( int nParentId, int nCrvId, double dLinTol)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
   bool bOk = true ;
  // recupero il riferimento locale
   Frame3d frLoc ;
   bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
  // recupero la curva in locale
   CurveLocal CrvLoc( pGeomDB, nCrvId, frLoc) ;
   bOk = bOk && ( CrvLoc.Get() != nullptr) ;
  // calcolo la superficie
   ISurfTriMesh* pSTM = ( bOk ? GetSurfTriMeshByFlatContour( CrvLoc.Get(), dLinTol) : nullptr) ;
  // inserisco la superficie nel DB
   int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, pSTM) : GDB_ID_NULL) ;
   EgtSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtSurfTmByFlatContour(" + ToString( nParentId) + "," +
                                                ToString( nCrvId) + "," +
                                                ToString( dLinTol) + ")" +
                    " -- Id=" + ToString( nNewId) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco l'identificativo della nuova entità
   return nNewId ;
}

//-------------------------------------------------------------------------------
int
__stdcall EgtCreateSurfTmByRegion( int nParentId, int nNumId, const int nCrvIds[], double dLinTol)
{
   INTVECTOR vCrvIds ;
   vCrvIds.reserve( nNumId) ;
   for ( int i = 0 ; i < nNumId ; ++i) {
      vCrvIds.push_back( nCrvIds[i]) ;
   }
   return EgtCreateSurfTmByRegion( nParentId, vCrvIds, dLinTol) ;
}

//-------------------------------------------------------------------------------
int
EgtCreateSurfTmByRegion( int nParentId, INTVECTOR& vCrvIds, double dLinTol)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
   bool bOk = true ;
  // recupero il riferimento locale
   Frame3d frLoc ;
   bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
  // recupero le curve in locale
   CURVELOCALVECTOR vCrvLoc ;
   vCrvLoc.reserve( vCrvIds.size()) ;
   ICURVEPVECTOR vCrvP ;
   vCrvP.reserve( vCrvIds.size()) ;
   for ( size_t i = 0 ; i < vCrvIds.size() ; ++ i) {
      vCrvLoc.emplace_back( pGeomDB, vCrvIds[i], frLoc) ;
      vCrvP.push_back( const_cast<ICurve*>( vCrvLoc[i].Get())) ;
      bOk = bOk && ( vCrvLoc[i].Get() != nullptr) ;
   }
  // calcolo la superficie
   ISurfTriMesh* pSTM = ( bOk ? GetSurfTriMeshByRegion( vCrvP, dLinTol) : nullptr) ;
   bOk = bOk && ( pSTM != nullptr) ;
  // elimino punti ripetuti
   bOk = bOk && pSTM->DoCompacting() ;
  // inserisco la superficie nel DB
   int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, pSTM) : GDB_ID_NULL) ;
   EgtSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sIds ;
      for ( size_t i = 0 ; i < vCrvIds.size() ; ++ i)
         sIds += ToString( vCrvIds[i]) + "," ;
      sIds.pop_back() ;
      string sLua = "EgtSurfTmByRegion(" + ToString( nParentId) + ",{" +
                                           sIds + "}," +
                                           ToString( dLinTol) + ")" +
                    " -- Id=" + ToString( nNewId) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco l'identificativo della nuova entità
   return nNewId ;
}

//-------------------------------------------------------------------------------
int
__stdcall EgtCreateSurfTmByExtrusion( int nParentId, int nNumId, const int nCrvIds[],
                                      const double vtExtr[3], double dLinTol, int nRefType)
{
   INTVECTOR vCrvIds ;
   vCrvIds.reserve( nNumId) ;
   for ( int i = 0 ; i < nNumId ; ++i) {
      vCrvIds.push_back( nCrvIds[i]) ;
   }
   return EgtCreateSurfTmByExtrusion( nParentId, vCrvIds, vtExtr, dLinTol, nRefType) ;
}

//-------------------------------------------------------------------------------
int
EgtCreateSurfTmByExtrusion( int nParentId, INTVECTOR& vCrvIds, const Vector3d& vtExtr,
                            double dLinTol, int nRefType)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
   bool bOk = true ;
  // recupero il riferimento locale
   Frame3d frLoc ;
   bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
  // recupero le curve in locale
   CURVELOCALVECTOR vCrvLoc ;
   vCrvLoc.reserve( vCrvIds.size()) ;
   ICURVEPVECTOR vCrvP ;
   vCrvP.reserve( vCrvIds.size()) ;
   for ( size_t i = 0 ; i < vCrvIds.size() ; ++ i) {
      vCrvLoc.emplace_back( pGeomDB, vCrvIds[i], frLoc) ;
      vCrvP.push_back( const_cast<ICurve*>( vCrvLoc[i].Get())) ;
      bOk = bOk && ( vCrvLoc[i].Get() != nullptr) ;
   }
  // porto in locale il vettore estrusione
   Vector3d vtExtrL = GetVectorLocal( pGeomDB, vtExtr.v, nRefType, frLoc) ;
  // creo le superfici e le inserisco nel DB
   int nFirstId = GDB_ID_NULL ;
   for ( int i = 0 ; i < int( vCrvP.size()) ; ++ i) {
      // calcolo la superficie
      ISurfTriMesh* pSTM = ( bOk ? GetSurfTriMeshByExtrusion( vCrvP[i], vtExtrL, false, dLinTol) : nullptr) ;
      // inserisco la superficie nel DB
      int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, pSTM) : GDB_ID_NULL) ;
      bOk = bOk && ( nNewId != GDB_ID_NULL) ;
      if ( bOk  &&  nFirstId == GDB_ID_NULL)
         nFirstId = nNewId ;
   }
   EgtSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sIds ;
      for ( size_t i = 0 ; i < vCrvIds.size() ; ++ i)
         sIds += ToString( vCrvIds[i]) + "," ;
      sIds.pop_back() ;
      string sLua = "EgtSurfTmByExtrusion(" + ToString( nParentId) + ",{" +
                                              sIds + "},{" +
                                              ToString( Vector3d( vtExtr)) + "}," +
                                              ToString( dLinTol) + "," +
                                              RefTypeToString( nRefType) + ")" +
                    " -- Id=" + ToString( nFirstId) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco l'identificativo della nuova entità
   return nFirstId ;
}

//-------------------------------------------------------------------------------
int
__stdcall EgtCreateSurfTmByRegionExtrusion( int nParentId, int nNumId, const int nCrvIds[],
                                            const double vtExtr[3], double dLinTol, int nRefType)
{
   INTVECTOR vCrvIds ;
   vCrvIds.reserve( nNumId) ;
   for ( int i = 0 ; i < nNumId ; ++i) {
      vCrvIds.push_back( nCrvIds[i]) ;
   }
   return EgtCreateSurfTmByRegionExtrusion( nParentId, vCrvIds, vtExtr, dLinTol, nRefType) ;
}

//-------------------------------------------------------------------------------
int
EgtCreateSurfTmByRegionExtrusion( int nParentId, INTVECTOR& vCrvIds, const Vector3d& vtExtr,
                                  double dLinTol, int nRefType)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
   bool bOk = true ;
  // recupero il riferimento locale
   Frame3d frLoc ;
   bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
  // recupero le curve in locale
   CURVELOCALVECTOR vCrvLoc ;
   vCrvLoc.reserve( vCrvIds.size()) ;
   ICURVEPVECTOR vCrvP ;
   vCrvP.reserve( vCrvIds.size()) ;
   for ( size_t i = 0 ; i < vCrvIds.size() ; ++ i) {
      vCrvLoc.emplace_back( pGeomDB, vCrvIds[i], frLoc) ;
      vCrvP.push_back( const_cast<ICurve*>( vCrvLoc[i].Get())) ;
      bOk = bOk && ( vCrvLoc[i].Get() != nullptr) ;
   }
  // porto in locale il vettore estrusione
   Vector3d vtExtrL = GetVectorLocal( pGeomDB, vtExtr.v, nRefType, frLoc) ;
   int nNewId = GDB_ID_NULL ;
  // creo la superficie
   ISurfTriMesh* pSTM = ( bOk ? GetSurfTriMeshByRegionExtrusion( vCrvP, vtExtrL, dLinTol) : nullptr) ;
  // inserisco la superficie nel DB
   nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, pSTM) : GDB_ID_NULL) ;
   EgtSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sIds ;
      for ( size_t i = 0 ; i < vCrvIds.size() ; ++ i)
         sIds += ToString( vCrvIds[i]) + "," ;
      sIds.pop_back() ;
      string sLua = "EgtSurfTmByRegionExtrusion(" + ToString( nParentId) + ",{" +
                                                    sIds + "},{" +
                                                    ToString( Vector3d( vtExtr)) + "}," +
                                                    ToString( dLinTol) + "," +
                                                    RefTypeToString( nRefType) + ")" +
                    " -- Id=" + ToString( nNewId) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco l'identificativo della nuova entità
   return nNewId ;
}

//-------------------------------------------------------------------------------
int
__stdcall EgtCreateSurfTmByRevolve( int nParentId, int nCrvId,
                                    const double ptAx[3], const double vtAx[3],
                                    BOOL bCapEnds, double dLinTol, int nRefType)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
   bool bOk = true ;
  // recupero il riferimento locale
   Frame3d frLoc ;
   bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
  // recupero la curva in locale
   CurveLocal CrvLoc( pGeomDB, nCrvId, frLoc) ;
   bOk = bOk && ( CrvLoc.Get() != nullptr) ;
  // porto in locale punto e vettore asse
   Point3d ptAxL = GetPointLocal( pGeomDB, ptAx, nRefType, frLoc) ;
   Vector3d vtAxL = GetVectorLocal( pGeomDB, vtAx, nRefType, frLoc) ;
  // calcolo la superficie
   ISurfTriMesh* pSTM = ( bOk ? GetSurfTriMeshByRevolve( CrvLoc.Get(), ptAxL, vtAxL, ( bCapEnds != FALSE), dLinTol) : nullptr) ;
  // inserisco la superficie nel DB
   int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, pSTM) : GDB_ID_NULL) ;
   EgtSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtSurfTmByRevolve(" + ToString( nParentId) + "," +
                                            ToString( nCrvId) + ",{" +
                                            ToString( Point3d( ptAx)) + "},{" +
                                            ToString( Vector3d( vtAx)) + "}," +
                                            ( bCapEnds ? "true" : "false") + "," +
                                            ToString( dLinTol) + "," +
                                            RefTypeToString( nRefType) + ")" +
                    " -- Id=" + ToString( nNewId) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco l'identificativo della nuova entità
   return nNewId ;
}

//-------------------------------------------------------------------------------
int
__stdcall EgtCreateSurfTmByScrewing( int nParentId, int nCrvId,
                                     const double ptAx[3], const double vtAx[3],
                                     double dAngRotDeg, double dMove, double dLinTol, int nRefType)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
   bool bOk = true ;
  // recupero il riferimento locale
   Frame3d frLoc ;
   bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
  // recupero la curva in locale
   CurveLocal CrvLoc( pGeomDB, nCrvId, frLoc) ;
   bOk = bOk && ( CrvLoc.Get() != nullptr) ;
  // porto in locale punto e vettore asse
   Point3d ptAxL = GetPointLocal( pGeomDB, ptAx, nRefType, frLoc) ;
   Vector3d vtAxL = GetVectorLocal( pGeomDB, vtAx, nRefType, frLoc) ;
  // calcolo la superficie
   ISurfTriMesh* pSTM = ( bOk ? GetSurfTriMeshByScrewing( CrvLoc.Get(), ptAxL, vtAxL, dAngRotDeg, dMove, dLinTol) : nullptr) ;
  // inserisco la superficie nel DB
   int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, pSTM) : GDB_ID_NULL) ;
   EgtSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtSurfTmByScrewing(" + ToString( nParentId) + "," +
                                             ToString( nCrvId) + ",{" +
                                             ToString( Point3d( ptAx)) + "},{" +
                                             ToString( Vector3d( vtAx)) + "}," +
                                             ToString( dAngRotDeg) + "," +
                                             ToString( dMove) + "," +
                                             ToString( dLinTol) + "," +
                                             RefTypeToString( nRefType) + ")" +
                    " -- Id=" + ToString( nNewId) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco l'identificativo della nuova entità
   return nNewId ;
}

//-------------------------------------------------------------------------------
int
__stdcall EgtCreateSurfTmRuled( int nParentId, int nPtOrCrvId1, int nPtOrCrvId2, double dLinTol)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
   bool bOk = true ;
  // recupero il riferimento locale
   Frame3d frLoc ;
   bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
  // creo la superficie trimesh
   ISurfTriMesh* pSTM = nullptr ;
  // se la prima entità è un punto e la seconda una curva
   if ( pGeomDB->GetGeoType( nPtOrCrvId1) == GEO_PNT3D  &&
        ( pGeomDB->GetGeoType( nPtOrCrvId2) & GEO_CURVE) != 0) {
     // recupero il punto in locale
      // recupero riferimento del punto
      Frame3d frPnt ;
      bOk = bOk && pGeomDB->GetGlobFrame( nPtOrCrvId1, frPnt) ;
      // porto il punto in locale
      Point3d ptP = GetGeoPoint3d( pGeomDB->GetGeoObj( nPtOrCrvId1))->GetPoint() ;
      bOk = bOk && ptP.LocToLoc( frPnt, frLoc) ;
     // recupero la curva in locale
      CurveLocal CrvLoc( pGeomDB, nPtOrCrvId2, frLoc) ;
      bOk = bOk && ( CrvLoc.Get() != nullptr) ;
     // calcolo la superficie
      pSTM = ( bOk ? GetSurfTriMeshRuled( ptP, CrvLoc.Get(), dLinTol) : nullptr) ;
   }
  // se la prima entità è una curva e la seconda un punto
   else if ( ( pGeomDB->GetGeoType( nPtOrCrvId1) & GEO_CURVE) != 0  &&
             pGeomDB->GetGeoType( nPtOrCrvId2) == GEO_PNT3D) {
     // recupero la curva in locale
      CurveLocal CrvLoc( pGeomDB, nPtOrCrvId1, frLoc) ;
      bOk = bOk && ( CrvLoc.Get() != nullptr) ;
     // recupero il punto in locale
      // recupero riferimento del punto
      Frame3d frPnt ;
      bOk = bOk && pGeomDB->GetGlobFrame( nPtOrCrvId2, frPnt) ;
      // porto il punto in locale
      Point3d ptP = GetGeoPoint3d( pGeomDB->GetGeoObj( nPtOrCrvId2))->GetPoint() ;
      bOk = bOk && ptP.LocToLoc( frPnt, frLoc) ;
     // calcolo la superficie
      pSTM = ( bOk ? GetSurfTriMeshRuled( ptP, CrvLoc.Get(), dLinTol) : nullptr) ;
   }
  // se entrambe curve
   else if ( ( pGeomDB->GetGeoType( nPtOrCrvId1) & GEO_CURVE) != 0  &&
             ( pGeomDB->GetGeoType( nPtOrCrvId2) & GEO_CURVE) != 0) {
     // recupero la prima curva in locale
      CurveLocal CrvLoc1( pGeomDB, nPtOrCrvId1, frLoc) ;
      bOk = bOk && ( CrvLoc1.Get() != nullptr) ;
     // recupero la seconda curva in locale
      CurveLocal CrvLoc2( pGeomDB, nPtOrCrvId2, frLoc) ;
      bOk = bOk && ( CrvLoc2.Get() != nullptr) ;
     // calcolo la superficie
      pSTM = ( bOk ? GetSurfTriMeshRuled( CrvLoc1.Get(), CrvLoc2.Get(), dLinTol) : nullptr) ;
   }
  // altrimenti errore
   else
      bOk = false ;
  // inserisco la superficie trimesh nel DB
   int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, pSTM) : GDB_ID_NULL) ;
   EgtSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtSurfTmRuled(" + ToString( nParentId) + "," +
                                        ToString( nPtOrCrvId1) + "," +
                                        ToString( nPtOrCrvId2) + "," +
                                        ToString( dLinTol) + ")" +
                    " -- Id=" + ToString( nNewId) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco l'identificativo della nuova entità
   return nNewId ;
}

//----------------------------------------------------------------------------
int
__stdcall EgtCreateSurfTmByTriangles( 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 EgtCreateSurfTmByTriangles( nParentId, vIds, ( bErase != FALSE)) ;
}

//----------------------------------------------------------------------------
int
EgtCreateSurfTmByTriangles( int nParentId, const INTVECTOR& vIds, bool bErase)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // almeno un oggetto nell'elenco
   bool bOk = ( vIds.size() > 0) ;
  // recupero il riferimento locale
   Frame3d frLoc ;
   bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
  // Costruttore di trimesh da insieme disordinato di triangoli
   StmFromTriangleSoup StmFts ;
   bOk = bOk && StmFts.Start() ;
  // Recupero tutti i triangoli delle superfici sorgenti e li inserisco nella nuova
   for ( size_t i = 0 ; i < vIds.size() ; ++ i) {
      int nId = (( vIds[i] != GDB_ID_SEL) ? vIds[i] : pGeomDB->GetFirstSelectedObj()) ;
      while ( nId != GDB_ID_NULL) {
        // recupero la superficie sorgente
         const ISurfTriMesh* pStmS = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
         bOk = bOk && ( pStmS != nullptr) ;
        // recupero il riferimento della superficie sorgente
         Frame3d frSou ;
         bOk = bOk && pGeomDB->GetGlobFrame( nId, frSou) ;
        // recupero tutti i triangoli
         Triangle3d Tria ;
         int nT = ( bOk ? pStmS->GetFirstTriangle( Tria) : SVT_NULL) ;
         while ( nT != SVT_NULL) {
           // aggiusto per i sistemi di riferimento
            Tria.LocToLoc( frSou, frLoc) ;
           // inserisco il triangolo nella nuova superficie
            if ( ! StmFts.AddTriangle( Tria))
               return false ;
           // passo al triangolo successivo
            nT = pStmS->GetNextTriangle( nT, Tria) ;
         }
        // passo al successivo
         nId = (( vIds[i] != GDB_ID_SEL) ? GDB_ID_NULL : pGeomDB->GetNextSelectedObj()) ;
      }
   }
  // valido la superficie e calcolo le adiacenze
   bOk = bOk && StmFts.End() ;
  // inserisco la superficie trimesh nel DB
   PtrOwner<ISurfTriMesh> pStm( StmFts.GetSurf()) ;
   int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pStm)) : GDB_ID_NULL) ;
  // se richiesto, cancello le superfici originali
   if ( nNewId != GDB_ID_NULL  &&  bErase) {
      for ( size_t i = 0 ; i < vIds.size() ; ++ i) {
         int nId = (( vIds[i] != GDB_ID_SEL) ? vIds[i] : pGeomDB->GetFirstSelectedObj()) ;
         while ( nId != GDB_ID_NULL) {
            pGeomDB->Erase( nId) ;
           // passo al successivo
            nId = (( vIds[i] != GDB_ID_SEL) ? GDB_ID_NULL : pGeomDB->GetFirstSelectedObj()) ;
         }
      }
   }
   EgtSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sIds ;
      for ( size_t i = 0 ; i < vIds.size() ; ++ i)
         sIds += ( vIds[i] != GDB_ID_SEL ? ToString( vIds[i]) : "GDB_ID_SEL") + "," ;
      sIds.pop_back() ;
      string sLua = "EgtSurfTmByTriangles(" + ToString( nParentId) + ",{" +
                                              sIds + "}," +
                                              ( bErase ? "true" : "false") + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco il risultato
   return nNewId ;
}

//----------------------------------------------------------------------------
int
__stdcall EgtCreateSurfTmBySewing( 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 EgtCreateSurfTmBySewing( nParentId, vIds, ( bErase != FALSE)) ;
}

//----------------------------------------------------------------------------
int
EgtCreateSurfTmBySewing( int nParentId, const INTVECTOR& vIds, bool bErase)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // almeno un oggetto nell'elenco
   bool bOk = ( vIds.size() > 0) ;
  // recupero il riferimento locale
   Frame3d frLoc ;
   bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
  // puntatore alla nuova superficie
   PtrOwner<ISurfTriMesh> pStm( CreateSurfTriMesh()) ;
   bOk = bOk && ! IsNull( pStm) ;
  // esecuzione
   bool bFirst = true ;
   for ( size_t i = 0 ; bOk && i < vIds.size() ; ++ i) {
      int nId = (( vIds[i] != GDB_ID_SEL) ? vIds[i] : pGeomDB->GetFirstSelectedObj()) ;
      while ( nId != GDB_ID_NULL) {
        // recupero la superficie da cucire
         const ISurfTriMesh* pStmS = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
         bOk = bOk && ( pStmS != nullptr) ;
        // recupero il riferimento
         Frame3d frStmS ;
         bOk = bOk && pGeomDB->GetGlobFrame( nId, frStmS) ;
        // lo esprimo rispetto a quello della prima superficie
         frStmS.ToLoc( frLoc) ;
        // se è la prima, copio
         if ( bFirst) {
            bOk = bOk && pStm->CopyFrom( pStmS) ;
            bOk = bOk && pStm->ToGlob( frStmS) ;
            bFirst = false ;
         }
        // altrimenti eseguo la cucitura
         else
            bOk = bOk && pStm->DoSewing( *pStmS, frStmS) ;
        // passo alla successiva
         nId = (( vIds[i] != GDB_ID_SEL) ? GDB_ID_NULL : pGeomDB->GetNextSelectedObj()) ;
      }
   }
  // compatto
   bOk = bOk && pStm->DoCompacting() ;
  // inserisco la superficie trimesh nel DB
   int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pStm)) : GDB_ID_NULL) ;
  // se richiesto, cancello le superfici originali
   if ( nNewId != GDB_ID_NULL  &&  bErase) {
      for ( size_t i = 0 ; i < vIds.size() ; ++ i) {
         int nId = (( vIds[i] != GDB_ID_SEL) ? vIds[i] : pGeomDB->GetFirstSelectedObj()) ;
         while ( nId != GDB_ID_NULL) {
            pGeomDB->Erase( nId) ;
           // passo al successivo
            nId = (( vIds[i] != GDB_ID_SEL) ? GDB_ID_NULL : pGeomDB->GetFirstSelectedObj()) ;
         }
      }
   }
   EgtSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sIds ;
      for ( size_t i = 0 ; i < vIds.size() ; ++ i)
         sIds += ( vIds[i] != GDB_ID_SEL ? ToString( vIds[i]) : "GDB_ID_SEL") + "," ;
      sIds.pop_back() ;
      string sLua = "EgtSurfTmBySewing(" + ToString( nParentId) + ",{" +
                                           sIds + "}," +
                                           ( bErase ? "true" : "false") + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco il risultato
   return nNewId ;
}