//----------------------------------------------------------------------------
//  EgalTech 2015-2015
//----------------------------------------------------------------------------
// File : EXE_ModifySurf.cpp       Data : 04.05.15        Versione : 1.6e1
// Contenuto : Funzioni di modifica delle superfici per EXE.
//
//
//
// Modifiche : 09.03.15 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "EXE.h"
#include "EXE_Macro.h"
#include "EXE_Const.h"
#include "AuxTools.h"
#include "GeoTools.h"
#include "/EgtDev/Include/EXeExecutor.h"
#include "/EgtDev/Include/EXeConst.h"
#include "/EgtDev/Include/EGkCurveComposite.h"
#include "/EgtDev/Include/EGkCurveLocal.h"
#include "/EgtDev/Include/EGkSurfFlatRegion.h"
#include "/EgtDev/Include/EGkSurfTriMeshAux.h"
#include "/EgtDev/Include/EGkSurfBezier.h"
#include "/EgtDev/Include/EGkSurfLocal.h"
#include "/EgtDev/Include/EGkStmFromTriangleSoup.h"
#include "/EgtDev/Include/EGkCAvSimpleSurfFrMove.h"
#include "/EgtDev/Include/EGkStringUtils3d.h"
#include "/EgtDev/Include/EGkSubtractProjectedFacesOnStmFace.h"
#include "/EgtDev/Include/EgtPointerOwner.h"


using namespace std ;

//----------------------------------------------------------------------------
bool
ExeInvertSurface( const INTVECTOR& vIds)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // eseguo inversione
   bool bOk = true ;
   for ( size_t i = 0 ; i < vIds.size() && bOk ; ++ i) {
      int nId = (( vIds[i] != GDB_ID_SEL) ? vIds[i] : pGeomDB->GetFirstSelectedObj()) ;
      while ( nId != GDB_ID_NULL  &&  bOk) {
        // recupero la superficie e la inverto
         ISurf* pSurf = GetSurf( pGeomDB->GetGeoObj( nId)) ;
         if ( pSurf != nullptr  &&  ! pSurf->Invert())
            bOk = false ;
        // passo alla successiva
         nId = (( vIds[i] != GDB_ID_SEL) ? GDB_ID_NULL : pGeomDB->GetNextSelectedObj()) ;
      }
   }
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtInvertSurf({" + IdListToString( vIds) + "})" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return bOk ;
}

//-------------------------------------------------------------------------------
static int
MyExplodeSurfTriMesh( int nId, int& nCount)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // recupero la superficie TriMesh
   const ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
   if ( pStm == nullptr)
      return GDB_ID_NULL ;
  // recupero il numero di componenti connesse
   int nParts = pStm->GetPartCount() ;
  // se ci sono più parti, separo queste
   if ( nParts > 1) {
      int nFirstId = GDB_ID_NULL ;
      nCount = 0 ;
      for ( int i = 0 ; i < nParts ; ++ i) {
         ISurfTriMesh* pFac = pStm->ClonePart( i) ;
         if ( pFac == nullptr)
            continue ;
        // inserisco la superficie nello stesso gruppo e nello stesso posto del GeomDB
         int nNewId = pGeomDB->InsertGeoObj( GDB_ID_NULL, nId, GDB_BEFORE, pFac) ;
         if ( nNewId == GDB_ID_NULL)
            return GDB_ID_NULL ;
        // copio gli attributi
        if ( ! pGeomDB->CopyAttributes( nId, nNewId))
            return GDB_ID_NULL ;
        // aggiorno contatori
         if ( nFirstId == GDB_ID_NULL)
            nFirstId = nNewId ;
         ++ nCount ;
      }
     // elimino la superficie originale
      pGeomDB->Erase( nId) ;
     // restituisco risultati
      return nFirstId ;
   }
  // recupero il numero di gusci
   int nShells = pStm->GetShellCount() ;
  // se ci sono più gusci, separo questi
   if ( nShells > 1) {
      int nFirstId = GDB_ID_NULL ;
      nCount = 0 ;
      for ( int i = 0 ; i < nShells ; ++ i) {
         ISurfTriMesh* pFac = pStm->CloneShell( i) ;
         if ( pFac == nullptr)
            continue ;
        // inserisco la superficie nello stesso gruppo e nello stesso posto del GeomDB
         int nNewId = pGeomDB->InsertGeoObj( GDB_ID_NULL, nId, GDB_BEFORE, pFac) ;
         if ( nNewId == GDB_ID_NULL)
            return GDB_ID_NULL ;
        // copio gli attributi
        if ( ! pGeomDB->CopyAttributes( nId, nNewId))
            return GDB_ID_NULL ;
        // aggiorno contatori
         if ( nFirstId == GDB_ID_NULL)
            nFirstId = nNewId ;
         ++ nCount ;
      }
     // elimino la superficie originale
      pGeomDB->Erase( nId) ;
     // restituisco risultati
      return nFirstId ;
   }
  // recupero il numero di facce
   int nFacets = pStm->GetFacetCount() ;
  // se ci sono più facce, separo queste
   if ( nFacets > 1) {
     // copio tutte le facce
      int nFirstId = GDB_ID_NULL ;
      nCount = 0 ;
      for ( int i = 0 ; i < nFacets ; ++ i) {
         ISurfTriMesh* pFac = pStm->CloneFacet( i) ;
         if ( pFac == nullptr)
            continue ;
        // inserisco la superficie nello stesso gruppo e nello stesso posto del GeomDB
         int nNewId = pGeomDB->InsertGeoObj( GDB_ID_NULL, nId, GDB_BEFORE, pFac) ;
         if ( nNewId == GDB_ID_NULL)
            return GDB_ID_NULL ;
        // copio gli attributi
        if ( ! pGeomDB->CopyAttributes( nId, nNewId))
            return GDB_ID_NULL ;
        // aggiorno contatori
         if ( nFirstId == GDB_ID_NULL)
            nFirstId = nNewId ;
         ++ nCount ;
      }
     // elimino la superficie originale
      pGeomDB->Erase( nId) ;
     // restituisco risultati
      return nFirstId ;
   }
  // non devo fare alcunché
   nCount = 1 ;
   return nId ;
}

//-------------------------------------------------------------------------------
static int
MyExplodeSurfFlatRegion( int nId, int& nCount)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // recupero la superficie FlatRegion
   const ISurfFlatRegion* pSfr = GetSurfFlatRegion( pGeomDB->GetGeoObj( nId)) ;
   if ( pSfr == nullptr)
      return GDB_ID_NULL ;
  // recupero il numero di componenti connessi (chunk)
   int nChunk = pSfr->GetChunkCount() ;
  // se c'è un solo componente, non devo fare alcunché
   if ( nChunk == 1) {
      nCount = 1 ;
      return nId ;
   }
  // copio tutti i componenti connessi (chunk)
   int nFirstId = GDB_ID_NULL ;
   nCount = 0 ;
   for ( int i = 0 ; i < nChunk ; ++ i) {
      ISurfFlatRegion* pChk = pSfr->CloneChunk( i) ;
      if ( pChk == nullptr)
         continue ;
     // inserisco la superficie nello stesso gruppo e nello stesso posto del GeomDB
      int nNewId = pGeomDB->InsertGeoObj( GDB_ID_NULL, nId, GDB_BEFORE, pChk) ;
      if ( nNewId == GDB_ID_NULL)
         return GDB_ID_NULL ;
     // copio gli attributi
     if ( ! pGeomDB->CopyAttributes( nId, nNewId))
         return GDB_ID_NULL ;
     // aggiorno contatori
      if ( nFirstId == GDB_ID_NULL)
         nFirstId = nNewId ;
      ++ nCount ;
   }
  // elimino la superficie
   pGeomDB->Erase( nId) ;
  // restituisco risultati
   return nFirstId ;
}

//-------------------------------------------------------------------------------
int
ExeExplodeSurface( int nId, int* pnCount)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // recupero il tipo di superficie
   int nFirstId = GDB_ID_NULL ;
   int nCount = 0 ;
   switch ( pGeomDB->GetGeoType( nId)) {
   case SRF_TRIMESH :
      nFirstId = MyExplodeSurfTriMesh( nId, nCount) ;
      break ;
   case SRF_FLATRGN :
      nFirstId = MyExplodeSurfFlatRegion( nId, nCount) ;
      break ;
   }
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtExplodeSurf(" + ToString( nId) + ")" +
                    " -- Id1=" + ToString( nFirstId) + ",Nbr=" + ToString( nCount) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultati
   if ( pnCount != nullptr)
      *pnCount = nCount ;
   return nFirstId ;
}

//-------------------------------------------------------------------------------
bool
ExeApproxSurface( int nId, double dLinTol, double dTriaMinSide)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // opero secondo il tipo di superficie
   PtrOwner<ISurfTriMesh> pStm ;
   int nType = pGeomDB->GetGeoType( nId) ;
   if ( nType == SRF_TRIMESH) {
     // copio la superficie
      const ISurfTriMesh* pStri = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
      pStm.Set( pStri != nullptr ? pStri->Clone() : nullptr) ;
   }
   else if ( nType == SRF_FLATRGN) {
     // recupero la superficie ausiliaria della regione
      const ISurfFlatRegion* pSfr = GetSurfFlatRegion( pGeomDB->GetGeoObj( nId)) ;
      const ISurfTriMesh* pAuxSurf = ( pSfr != nullptr ? pSfr->GetAuxSurf() : nullptr) ;
      pStm.Set( pAuxSurf != nullptr ? pAuxSurf->Clone() : nullptr) ;
   }
   else if ( nType == SRF_BEZIER) {
     // recupero la superficie ausiliaria della Bezier
      const ISurfBezier* pSbez = GetSurfBezier( pGeomDB->GetGeoObj( nId)) ;
      pStm.Set( ( pSbez != nullptr ? pSbez->GetApproxSurf( dLinTol, dTriaMinSide) : nullptr)) ;
   }
   bool bOk = ( ! IsNull( pStm)) ;
  // semplificazione della trimesh
   bOk = bOk && pStm->DoCompacting( dLinTol) ;
  // sostituisco la vecchia superficie con la nuova
   bOk = bOk && pGeomDB->ReplaceGeoObj( nId, Release( pStm)) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtApproxSurf(" + ToString( nId) + "," +
                                       ToString( dLinTol) + "," +
                                       ToString( dTriaMinSide) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
   return bOk ;
}

//----------------------------------------------------------------------------
bool
ExeSurfFrAdd( int nId1, int nId2)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la prima superficie FlatRegion
   ISurfFlatRegion* pSfr1 = GetSurfFlatRegion( pGeomDB->GetGeoObj( nId1)) ;
   bool bOk = ( pSfr1 != nullptr) ;
  // recupero il riferimento della superficie
   Frame3d frSurf1 ;
   bOk = bOk && pGeomDB->GetGlobFrame( nId1, frSurf1) ;
  // recupero la seconda superficie FlatRegion in locale alla prima
   SurfLocal Surf2Loc( pGeomDB, nId2, frSurf1) ;
   const ISurfFlatRegion* pSfr2L = GetSurfFlatRegion( Surf2Loc) ;
   bOk = bOk && ( pSfr2L != nullptr) ;
  // eseguo l'unione tra le due superfici
   bOk = bOk && pSfr1->Add( *pSfr2L) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtSurfFrAdd(" + ToString( nId1) + "," +
                                      ToString( nId2) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
   return bOk ;
}

//----------------------------------------------------------------------------
bool
ExeSurfFrSubtract( int nId1, int nId2)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la prima superficie FlatRegion
   ISurfFlatRegion* pSfr1 = GetSurfFlatRegion( pGeomDB->GetGeoObj( nId1)) ;
   bool bOk = ( pSfr1 != nullptr) ;
  // recupero il riferimento della superficie
   Frame3d frSurf1 ;
   bOk = bOk && pGeomDB->GetGlobFrame( nId1, frSurf1) ;
  // recupero la seconda superficie FlatRegion in locale alla prima
   SurfLocal Surf2Loc( pGeomDB, nId2, frSurf1) ;
   const ISurfFlatRegion* pSfr2L = GetSurfFlatRegion( Surf2Loc) ;
   bOk = bOk && ( pSfr2L != nullptr) ;
  // eseguo la sottrazione della seconda superficie dalla prima
   bOk = bOk && pSfr1->Subtract( *pSfr2L) ;
  // se il risultato è vuoto, cancello la FlatRegion
   if ( bOk  &&  ! pSfr1->IsValid())
      pGeomDB->Erase( nId1) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtSurfFrSubtract(" + ToString( nId1) + "," +
                                           ToString( nId2) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
   return bOk ;
}

//----------------------------------------------------------------------------
bool
ExeSurfFrIntersect( int nId1, int nId2)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la prima superficie FlatRegion
   ISurfFlatRegion* pSfr1 = GetSurfFlatRegion( pGeomDB->GetGeoObj( nId1)) ;
   bool bOk = ( pSfr1 != nullptr) ;
  // recupero il riferimento della superficie
   Frame3d frSurf1 ;
   bOk = bOk && pGeomDB->GetGlobFrame( nId1, frSurf1) ;
  // recupero la seconda superficie FlatRegion in locale alla prima
   SurfLocal Surf2Loc( pGeomDB, nId2, frSurf1) ;
   const ISurfFlatRegion* pSfr2L = GetSurfFlatRegion( Surf2Loc) ;
   bOk = bOk && ( pSfr2L != nullptr) ;
  // eseguo l'intersezione tra le due superfici
   bOk = bOk && pSfr1->Intersect( *pSfr2L) ;
  // se il risultato è vuoto, cancello la FlatRegion
   if ( bOk  &&  ! pSfr1->IsValid())
      pGeomDB->Erase( nId1) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtSurfFrIntersect(" + ToString( nId1) + "," +
                                            ToString( nId2) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
   return bOk ;
}

//----------------------------------------------------------------------------
bool
ExeSurfFrOffset( int nId, double dDist, int nType)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la superficie FlatRegion
   ISurfFlatRegion* pSfr = GetSurfFlatRegion( pGeomDB->GetGeoObj( nId)) ;
   bool bOk = ( pSfr != nullptr) ;
  // eseguo l'offset
   bOk = bOk && pSfr->Offset( dDist, nType) ;
  // se il risultato è vuoto, cancello la FlatRegion
   if ( bOk  &&  ! pSfr->IsValid())
      pGeomDB->Erase( nId) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtSurfFrOffset(" + ToString( nId) + "," +
                                         ToString( dDist) + "," +
                                         ToString( nType) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
   return bOk ;
}

//----------------------------------------------------------------------------
bool
ExeSurfFrOffsetAdv( int nId, double dDist, int nType, int& nNewId)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la superficie FlatRegion
   ISurfFlatRegion* pSfr = GetSurfFlatRegion( pGeomDB->GetGeoObj( nId)) ;
   if ( pSfr == nullptr)
      return false ;      
  // eseguo l'offset
   PtrOwner<ISurfFlatRegion> pSfrOffs( pSfr->CreateOffsetSurf( dDist, nType)) ;
   if ( IsNull( pSfrOffs))
      return false ;
  // salvo la superficie di offset
   nNewId = GDB_ID_NULL ;
   if ( pSfr->GetChunkCount() > 0) {
     // inserisco nel DB geometrico
      nNewId = pGeomDB->InsertGeoObj( GDB_ID_NULL, nId, GDB_AFTER, Release( pSfrOffs)) ;
     // copio gli attributi
      pGeomDB->CopyAttributes( nId, nNewId) ;
      ExeSetModified() ;
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
ExeSurfFrEraseChunk( int nId, int nChunk)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la superficie FlatRegion
   ISurfFlatRegion* pSfr = GetSurfFlatRegion( pGeomDB->GetGeoObj( nId)) ;
   if ( pSfr == nullptr)
      return false ;      
  // elimino il chunk indicato
   bool bOk = pSfr->EraseChunk( nChunk) ;
  // se il risultato è vuoto, cancello la FlatRegion
   if ( bOk  &&  ! pSfr->IsValid())
      pGeomDB->Erase( nId) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtSurfFrEraseChunk(" + ToString( nId) + "," +
                                             ToString( nChunk) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
   return bOk ;
}

//----------------------------------------------------------------------------
bool
ExeSurfFrMoveSimpleNoCollision( int nId1, int nId2, const Vector3d& vtDir, double& dLen, int nRefType)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la prima superficie FlatRegion
   ISurfFlatRegion* pSfr1 = GetSurfFlatRegion( pGeomDB->GetGeoObj( nId1)) ;
   bool bOk = ( pSfr1 != nullptr) ;
  // recupero il riferimento della superficie
   Frame3d frSurf1 ;
   bOk = bOk && pGeomDB->GetGlobFrame( nId1, frSurf1) ;
  // recupero la seconda superficie FlatRegion in locale alla prima
   SurfLocal Surf2Loc( pGeomDB, nId2, frSurf1) ;
   const ISurfFlatRegion* pSfr2L = GetSurfFlatRegion( Surf2Loc) ;
   bOk = bOk && ( pSfr2L != nullptr) ;
  // porto in locale alla prima superficie il versore di movimento
   Vector3d vtDirL = GetVectorLocal( pGeomDB, vtDir, nRefType, frSurf1) ;
  // calcolo massima lunghezza di traslazione della prima regione senza semplice collisione con la seconda
   return ( bOk && CAvSimpleSurfFrMove( *pSfr1, *pSfr2L).Translate( vtDirL, dLen)) ;
}

//----------------------------------------------------------------------------
bool
ExeSurfFrRotateSimpleNoCollision( int nId1, int nId2, const Point3d& ptCen, double& dAngDeg, int nRefType)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la prima superficie FlatRegion
   ISurfFlatRegion* pSfr1 = GetSurfFlatRegion( pGeomDB->GetGeoObj( nId1)) ;
   bool bOk = ( pSfr1 != nullptr) ;
  // recupero il riferimento della superficie
   Frame3d frSurf1 ;
   bOk = bOk && pGeomDB->GetGlobFrame( nId1, frSurf1) ;
  // recupero la seconda superficie FlatRegion in locale alla prima
   SurfLocal Surf2Loc( pGeomDB, nId2, frSurf1) ;
   const ISurfFlatRegion* pSfr2L = GetSurfFlatRegion( Surf2Loc) ;
   bOk = bOk && ( pSfr2L != nullptr) ;
  // porto in locale alla prima superficie il versore di movimento
   Point3d ptCenL = GetPointLocal( pGeomDB, ptCen, nRefType, frSurf1) ;
  // calcolo massimo angolo di rotazione della prima regione senza semplice collisione con la seconda
   return ( bOk && CAvSimpleSurfFrMove( *pSfr1, *pSfr2L).Rotate(ptCenL, dAngDeg)) ;
}

//-------------------------------------------------------------------------------
bool
ExeSurfTmMoveVertex( int nId, int nVert, const Point3d& ptNewVert, int nRefType, bool bUpdate)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la superficie
   ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
   bool bOk = ( pStm != nullptr) ;
  // recupero il riferimento in cui è immersa la superficie
   Frame3d frStm ;
   bOk = bOk && pGeomDB->GetGlobFrame( nId, frStm) ;
  // eseguo la modifica
   if ( bOk) {
     // porto il nuovo vertice nel riferimento della superficie
      Point3d ptNewVertL = GetPointLocal( pGeomDB, ptNewVert, nRefType, frStm) ;
     // eseguo la modifica
      bOk = pStm->MoveVertex( nVert, ptNewVertL) ;
     // se richiesto, semplificazione della trimesh
      if ( bUpdate)
         bOk = bOk && pStm->DoCompacting() ;
   }
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtSurfTmMoveVertex(" + IdToString( nId) + "," +
                                             ToString( nVert) + ",{"  +
                                             ToString( ptNewVert) + "}," +
                                             RefTypeToString( nRefType) + "," +
                                             ( bUpdate ? "true" : "false") + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return bOk ;
}

//-------------------------------------------------------------------------------
bool
ExeSurfTmMoveFacet( int nId, int nFacet, const Vector3d& vtMove, int nRefType, bool bUpdate)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la superficie
   ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
   bool bOk = ( pStm != nullptr) ;
  // recupero il riferimento in cui è immersa la superficie
   Frame3d frStm ;
   bOk = bOk && pGeomDB->GetGlobFrame( nId, frStm) ;
  // porto in locale il movimento
   Vector3d vtMoveL = GetVectorLocal( pGeomDB, vtMove, nRefType, frStm) ;
  // recupero tutti i vertici della faccia
   INTVECTOR vVert ;
   bOk = bOk && pStm->GetAllVertInFacet( nFacet, vVert) ;
  // sposto tutti i vertici della faccia della quantità desiderata
   if ( bOk) {
      for ( const auto nVert : vVert) {
        // recupero la posizione originale del vertice
         Point3d ptV ;
         if ( pStm->GetVertex( nVert, ptV))
            pStm->MoveVertex( nVert, ptV + vtMoveL) ;
      }
   }
  // se richiesto, semplificazione della trimesh
   if ( bUpdate)
      bOk = bOk && pStm->DoCompacting() ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtSurfTmMoveFacet(" + IdToString( nId) + "," +
                                            ToString( nFacet) + ",{"  +
                                            ToString( vtMove) + "}," +
                                            RefTypeToString( nRefType) + "," +
                                            ( bUpdate ? "true" : "false") + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return bOk ;
}

//-------------------------------------------------------------------------------
static int
MySurfTmToTriangles( int nId, int& nCount)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // recupero la superficie TriMesh
   const ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
   if ( pStm == nullptr)
      return GDB_ID_NULL ;
  // recupero il numero di triangoli
   int nTria = pStm->GetTriangleCount() ;
  // se ci sono più triangoli, li separo
   if ( nTria > 1) {
     // copio tutti triangoli
      int nFirstId = GDB_ID_NULL ;
      nCount = 0 ;
      for ( int i = 0 ; i < pStm->GetTriangleSize() ; ++ i) {
         ISurfTriMesh* pFac = pStm->CloneTriangle( i) ;
         if ( pFac == nullptr)
            continue ;
        // inserisco la superficie nello stesso gruppo e nello stesso posto del GeomDB
         int nNewId = pGeomDB->InsertGeoObj( GDB_ID_NULL, nId, GDB_BEFORE, pFac) ;
         if ( nNewId == GDB_ID_NULL)
            return GDB_ID_NULL ;
        // copio gli attributi
        if ( ! pGeomDB->CopyAttributes( nId, nNewId))
            return GDB_ID_NULL ;
        // aggiorno contatori
         if ( nFirstId == GDB_ID_NULL)
            nFirstId = nNewId ;
         ++ nCount ;
      }
     // elimino la superficie originale
      pGeomDB->Erase( nId) ;
     // restituisco risultati
      return nFirstId ;
   }
  // non devo fare alcunché
   nCount = 1 ;
   return nId ;
}

//-------------------------------------------------------------------------------
int
ExeSurfTmToTriangles( int nId, int* pnCount)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // verifico sia una superficie trimesh
   int nFirstId = GDB_ID_NULL ;
   int nCount = 0 ;
   if ( pGeomDB->GetGeoType( nId) == SRF_TRIMESH) {
      nFirstId = MySurfTmToTriangles( nId, nCount) ;
   }
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtSurfTmToTriangles(" + IdToString( nId) + ")" +
                    " -- Id1=" + ToString( nFirstId) + ",Nbr=" + ToString( nCount) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultati
   if ( pnCount != nullptr)
      *pnCount = nCount ;
   return nFirstId ;
}

//-------------------------------------------------------------------------------
bool
ExeSurfTmRemoveFacet( int nId, int nFacet)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la superficie TriMesh
   ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
   bool bOk = ( pStm != nullptr) ;
  // eseguo la rimozione
   bOk = bOk && pStm->RemoveFacet( nFacet) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtSurfTmRemoveFacet(" + IdToString( nId) + "," +
                                              ToString( nFacet) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return bOk ;
}
 
//-------------------------------------------------------------------------------
bool
ExeSurfTmSwapFacets( int nId, int nFacet1, int nFacet2)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la superficie TriMesh
   ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
   bool bOk = ( pStm != nullptr) ;
  // eseguo lo scambio
   bOk = bOk && pStm->SwapFacets( nFacet1, nFacet2) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtSurfTmSwapFacets(" + IdToString( nId) + "," +
                                             ToString( nFacet1) + "," +
                                             ToString( nFacet2) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return bOk ;
}

//-------------------------------------------------------------------------------
bool
ExeSurfTmRemovePart( int nId, int nPart)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la superficie TriMesh
   ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
   bool bOk = ( pStm != nullptr) ;
  // eseguo la rimozione
   bOk = bOk && pStm->RemovePart( nPart) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtSurfTmRemovePart(" + IdToString( nId) + "," +
                                             ToString( nPart) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return bOk ;
}

//-------------------------------------------------------------------------------
bool
ExeCutSurfTmPlane( int nId, const Point3d& ptOn, const Vector3d& vtN, bool bSaveOnEq, int nRefType)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la superficie TriMesh
   ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
   bool bOk = ( pStm != nullptr) ;
  // recupero il riferimento locale
   Frame3d frLoc ;
   bOk = bOk && pGeomDB->GetGlobFrame( nId, frLoc) ;
  // porto in locale il punto e la normale del piano
   Point3d ptOnL = GetPointLocal( pGeomDB, ptOn, nRefType, frLoc) ;
   Vector3d vtNL = GetVectorLocal( pGeomDB, vtN, nRefType, frLoc) ;
  // calcolo il piano di taglio
   Plane3d plPlane ;
   bOk = bOk && plPlane.Set( ptOnL, vtNL) ;
  // eseguo il taglio
   bOk = bOk &&  pStm->Cut( plPlane, bSaveOnEq) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtCutSurfTmPlane(" + IdToString( nId) + ",{" +
                                           ToString( ptOn) + "},{" +
                                           ToString( vtN) + "}," +
                                           ( bSaveOnEq ? "true" : "false") + "," +
                                           RefTypeToString( nRefType) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return bOk ;
}

//-------------------------------------------------------------------------------
bool
ExeCutSurfTmClosedCurve( int nSurfId, int nCurveId, bool bSaveOnEq)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la superficie TriMesh
   ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nSurfId)) ;
   bool bOk = ( pStm != nullptr) ;
  // recupero il riferimento locale
   Frame3d frLoc ;
   bOk = bOk && pGeomDB->GetGlobFrame( nSurfId, frLoc) ;
  // recupero la curva nel riferimento locale della superficie
   CurveLocal CrvCut( pGeomDB, nCurveId, frLoc) ;
   bOk = bOk && CrvCut.Get() != nullptr ;
  // eseguo il taglio
   bOk = bOk &&  pStm->GeneralizedCut( *CrvCut.Get(), bSaveOnEq) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtCutSurfTmClosedCurve(" + ToString( nSurfId) + ",{" +
                                                 ToString( nCurveId) + "},{" +
                                                 ( bSaveOnEq ? "true" : "false") + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return bOk ;
}

//----------------------------------------------------------------------------
bool
ExeSurfTmAdd( int nId1, int nId2, bool bTwoColors)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la prima superficie TriMesh
   ISurfTriMesh* pStm1 = GetSurfTriMesh( pGeomDB->GetGeoObj( nId1)) ;
   bool bOk = ( pStm1 != nullptr) ;
  // recupero il riferimento della superficie
   Frame3d frSurf1 ;
   bOk = bOk && pGeomDB->GetGlobFrame( nId1, frSurf1) ;
  // recupero la seconda superficie TriMesh in locale alla prima
   SurfLocal Surf2Loc( pGeomDB, nId2, frSurf1) ;
   const ISurfTriMesh* pStm2L = GetSurfTriMesh( Surf2Loc) ;
   bOk = bOk && ( pStm2L != nullptr) ;
  // eseguo l'unione tra le due superfici
   bOk = bOk && pStm1->Add( *pStm2L) ;
  // se non richiesti due colori
   if ( bOk  &&  ! bTwoColors)
      pStm1->ResetTFlags() ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtSurfTmAdd(" + ToString( nId1) + "," +
                                      ToString( nId2) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
   return bOk ;
}

//----------------------------------------------------------------------------
bool
ExeSurfTmSubtract( int nId1, int nId2, bool bTwoColors)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la prima superficie TriMesh
   ISurfTriMesh* pStm1 = GetSurfTriMesh( pGeomDB->GetGeoObj( nId1)) ;
   bool bOk = ( pStm1 != nullptr) ;
  // recupero il riferimento della superficie
   Frame3d frSurf1 ;
   bOk = bOk && pGeomDB->GetGlobFrame( nId1, frSurf1) ;
  // recupero la seconda superficie TriMesh in locale alla prima
   SurfLocal Surf2Loc( pGeomDB, nId2, frSurf1) ;
   const ISurfTriMesh* pStm2L = GetSurfTriMesh( Surf2Loc) ;
   bOk = bOk && ( pStm2L != nullptr) ;
  // eseguo la sottrazione tra le due superfici
   bOk = bOk && pStm1->Subtract( *pStm2L) ;
  // se il risultato � vuoto, cancello la superficie
   if ( bOk  && ! pStm1->IsValid()) {
      pGeomDB->Erase( nId1) ;
      pStm1 = nullptr ;
   }
  // se non richiesti due colori
   if ( bOk  &&  ! bTwoColors  &&  pStm1 != nullptr)
      pStm1->ResetTFlags() ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtSurfTmSubtract(" + ToString( nId1) + "," +
                                           ToString( nId2) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
   return bOk ;
}

//----------------------------------------------------------------------------
bool
ExeSurfTmIntersect( int nId1, int nId2, bool bTwoColors)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la prima superficie TriMesh
   ISurfTriMesh* pStm1 = GetSurfTriMesh( pGeomDB->GetGeoObj( nId1)) ;
   bool bOk = ( pStm1 != nullptr) ;
  // recupero il riferimento della superficie
   Frame3d frSurf1 ;
   bOk = bOk && pGeomDB->GetGlobFrame( nId1, frSurf1) ;
  // recupero la seconda superficie TriMesh in locale alla prima
   SurfLocal Surf2Loc( pGeomDB, nId2, frSurf1) ;
   const ISurfTriMesh* pStm2L = GetSurfTriMesh( Surf2Loc) ;
   bOk = bOk && ( pStm2L != nullptr) ;
  // eseguo l'intersezione tra le due superfici
   bOk = bOk && pStm1->Intersect( *pStm2L) ;
  // se il risultato � vuoto, cancello la superficie
   if ( bOk  && ! pStm1->IsValid()) {
      pGeomDB->Erase( nId1) ;
      pStm1 = nullptr ;
   }
  // se non richiesti due colori
   if ( bOk  &&  ! bTwoColors  &&  pStm1 != nullptr)
      pStm1->ResetTFlags() ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtSurfTmIntersect(" + ToString( nId1) + "," +
                                            ToString( nId2) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
   return bOk ;
}

//----------------------------------------------------------------------------
static ISurfTriMesh*
MyCreateSubSurfTm( const ISurfTriMesh* pStm, const INTVECTOR& vTria, const INTVECTOR& vTria2)
{
   StmFromTriangleSoup StmFts ;
   if ( ! StmFts.Start())
      return nullptr ;
   for ( int nT : vTria) {
      Triangle3d Tria ;
      if ( ! pStm->GetTriangle( nT, Tria)  ||
           ! StmFts.AddTriangle( Tria))
         return nullptr ;
   }
   for ( int nT : vTria2) {
      Triangle3d Tria ;
      if ( ! pStm->GetTriangle( nT, Tria)  ||
            ! StmFts.AddTriangle( Tria))
         return nullptr ;
   }
  // valido la superficie e calcolo le adiacenze
   if ( ! StmFts.End())
      return nullptr ;
  // restituisco la superficie
   return StmFts.GetSurf() ; 
}

//----------------------------------------------------------------------------
static ISurfTriMesh*
MyCreateSubSurfTm( const ISurfTriMesh* pStm, const INTVECTOR& vTria)
{
   INTVECTOR vNull ;
   return MyCreateSubSurfTm( pStm, vTria, vNull) ;
}

//----------------------------------------------------------------------------
static int 
MySurfTmSplit( int nId, int nSplitterId, int& nCount)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // recupero la superficie TriMesh da dividere in parti
   ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
   if ( pStm == nullptr)
      return GDB_ID_NULL ;
  // recupero il riferimento della superficie
   Frame3d frSurf ;
   if ( ! pGeomDB->GetGlobFrame( nId, frSurf))
      return GDB_ID_NULL ;
  // recupero la superficie TriMesh divisore in locale alla prima
   SurfLocal SurfCLoc( pGeomDB, nSplitterId, frSurf) ;
   const ISurfTriMesh* pStmCLoc = GetSurfTriMesh( SurfCLoc) ;
   if ( pStmCLoc == nullptr)
      return GDB_ID_NULL ;
  // eseguo la classificazione
   INTVECTOR vTriaIn, vTriaOut, vTriaOnP, vTriaOnM, vTriaIndef ;
   if ( ! pStm->GetSurfClassification( *pStmCLoc, vTriaIn, vTriaOut, vTriaOnP, vTriaOnM, vTriaIndef))
      return GDB_ID_NULL ;
  // costruisco le diverse superfici
   PtrOwner<ISurfTriMesh> pStmIn( MyCreateSubSurfTm( pStm, vTriaIn)) ;
   PtrOwner<ISurfTriMesh> pStmOut( MyCreateSubSurfTm( pStm, vTriaOut)) ;
   PtrOwner<ISurfTriMesh> pStmOnP( MyCreateSubSurfTm( pStm, vTriaOnP)) ;
   PtrOwner<ISurfTriMesh> pStmOnM( MyCreateSubSurfTm( pStm, vTriaOnM)) ;
   PtrOwner<ISurfTriMesh> pStmIndef( MyCreateSubSurfTm( pStm, vTriaIndef)) ;
   if ( IsNull( pStmIn)  ||  IsNull( pStmOut)  ||  IsNull( pStmOnP)  ||  IsNull( pStmOnM)  ||  IsNull( pStmIndef))
      return GDB_ID_NULL ;
  // le inserisco nel DB geometrico
   int nStmIn = pGeomDB->InsertGeoObj( GDB_ID_NULL, nId, GDB_BEFORE, Release( pStmIn)) ;
   int nStmOut = pGeomDB->InsertGeoObj( GDB_ID_NULL, nId, GDB_BEFORE, Release( pStmOut)) ;
   int nStmOnP = pGeomDB->InsertGeoObj( GDB_ID_NULL, nId, GDB_BEFORE, Release( pStmOnP)) ;
   int nStmOnM = pGeomDB->InsertGeoObj( GDB_ID_NULL, nId, GDB_BEFORE, Release( pStmOnM)) ;
   int nStmIndef = pGeomDB->InsertGeoObj( GDB_ID_NULL, nId, GDB_BEFORE, Release( pStmIndef)) ;
  // se tutto ok
   if ( nStmIn != GDB_ID_NULL  &&  nStmOut != GDB_ID_NULL  &&  nStmOnP != GDB_ID_NULL  &&  nStmOnM != GDB_ID_NULL  &&  nStmIndef != GDB_ID_NULL) {
      pGeomDB->Erase( nId) ;
      nCount = 5 ;
      return nStmIn ;
   }
   else {
      pGeomDB->Erase( nStmIn) ;
      pGeomDB->Erase( nStmOut) ;
      pGeomDB->Erase( nStmOnP) ;
      pGeomDB->Erase( nStmOnM) ;
      pGeomDB->Erase( nStmIndef) ;
      nCount = 0 ;
      return GDB_ID_NULL ;
   }
}

//----------------------------------------------------------------------------
int
ExeSurfTmSplit( int nId, int nSplitterId, int* pnCount)
{
   int nCount ;
   int nFirstId = MySurfTmSplit( nId, nSplitterId, nCount) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtSurfTmSplit(" + ToString( nId) + "," +
                                        ToString( nSplitterId) + ")" +
                    " -- Id1=" + ToString( nFirstId) + ",Nbr=" + ToString( nCount) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
   if ( pnCount != nullptr)
      *pnCount = nCount ;
   return nFirstId ;
}

//----------------------------------------------------------------------------
static bool 
MySurfTmCut( int nId, int nSplitterId, bool bInVsOut, bool bSaveOnEq)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la superficie TriMesh da dividere in parti
   ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
   if ( pStm == nullptr)
      return false ;
  // recupero il riferimento della superficie
   Frame3d frSurf ;
   if ( ! pGeomDB->GetGlobFrame( nId, frSurf))
      return false ;
  // recupero la superficie TriMesh divisore in locale alla prima
   SurfLocal SurfCLoc( pGeomDB, nSplitterId, frSurf) ;
   const ISurfTriMesh* pStmCLoc = GetSurfTriMesh( SurfCLoc) ;
   if ( pStmCLoc == nullptr)
      return false ;
  // eseguo il taglio
   return pStm->CutWithOtherSurf( *pStmCLoc, bInVsOut, bSaveOnEq) ;
}

//----------------------------------------------------------------------------
bool
ExeSurfTmCut( int nId, int nCutterId, bool bInVsOut, bool bSaveOnEq)
{
   bool bOk = MySurfTmCut( nId, nCutterId, bInVsOut, bSaveOnEq) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtSurfTmCut(" + ToString( nId) + "," +
                                      ToString( nCutterId) + "," +
                                      ToString( bInVsOut) + "," +
                                      ToString( bSaveOnEq) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
   return bOk ;
}

//----------------------------------------------------------------------------
bool
ExeSurfTmSubtractProjectedFacesOnFace( int nSurfId, int nFaceInd, int nDestGrpId,
                                       INTVECTOR vSurfsId, bool bOCFlag,
                                       bool& bExistProjection, int& nNewId, int& nNewFaceNbr)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la superficie TriMesh su cui proiettare
   ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nSurfId)) ;
   if ( pStm == nullptr)
      return false ;
  // recupero il riferimento della superficie
   Frame3d frSurf ;
   if ( ! pGeomDB->GetGlobFrame( nSurfId, frSurf))
      return false ;
  // recupero il riferimento del gruppo di destinazione
   Frame3d frDest ;
   if ( ! pGeomDB->GetGroupGlobFrame( nDestGrpId, frDest))
      return false ;
  // costruzione vettori di superfici e indici delle facce per proiezione
   ISURFTMPOVECTOR vpStmOthers ;
   vector<SurfLocal> vSurfCLoc ;
  // recupero le altre superfici e le porto nel sistema di riferimento della prima
   for ( int i = 0 ; i < int( vSurfsId.size()) ; ++ i) {
      if ( pGeomDB->GetGeoType( vSurfsId[i]) != SRF_TRIMESH)
         return false ;
      vSurfCLoc.emplace_back( pGeomDB, vSurfsId[i], frSurf) ;
      const ISurfTriMesh* pStmCurr = GetSurfTriMesh( vSurfCLoc.back().Get()) ;
      vpStmOthers.emplace_back( pStmCurr->Clone()) ;
   }
  // eseguo la proiezione
   ISurfTriMesh* pStmRes = nullptr ;
   bool bOk = SubtractProjectedFacesOnStmFace( *pStm, nFaceInd, vpStmOthers, bOCFlag,
                                               bExistProjection, pStmRes, nNewFaceNbr) ;
   if ( ! bOk) {
      delete( pStmRes) ;
      pStmRes = nullptr ;
   }

   nNewId = GDB_ID_NULL ;
   if ( bOk  &&  pStmRes != nullptr) {
     // porto nel sistema di riferimento destinazione
      pStmRes->LocToLoc( frSurf, frDest) ;
     // la inserisco nel DB geometrico
      nNewId = pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, pStmRes) ;
      if ( nNewId == GDB_ID_NULL)
         return false ;
      ExeSetModified() ;
   }

   if ( IsCmdLog()) {
      string sLua = "EgtSubtractProjectedFacesOnStmFace(" + ToString( nSurfId) + "," +
                                                            ToString( nFaceInd) + "," +
                                                            ToString( nDestGrpId) + "," +
                                                            ToString( vSurfsId) + "," +
                                                            ToString( bOCFlag) + ")" +
                    " -- Ok=" + ToString( bOk) + " Id=" + ToString( nNewId) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
   return bOk ;
}

//----------------------------------------------------------------------------
bool
ExeSurfTmSetFaceColor( int nId, int nFacet, int nColor)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la superficie TriMesh
   ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
   bool bOk = ( pStm != nullptr) ;
  // recupero tutti i triangoli della faccia e imposto il flag opportuno per il colore
   INTVECTOR vTria ;
   bOk = bOk && pStm->GetAllTriaInFacet( nFacet, vTria) ;
   for ( const auto nT : vTria)
      pStm->SetTFlag( nT, nColor) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtSurfTmSetFaceColor(" + ToString( nId) + "," +
                                               ToString( nFacet) + "," +
                                               ToString( nColor) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
   return bOk ;
}

//----------------------------------------------------------------------------
bool
ExeSurfTmGetTriaColor( int nId, int nTria, int& nColor)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la superficie TriMesh
   ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
   bool bOk = ( pStm != nullptr) ;
  // recupero il colore del triangolo
   return ( bOk && pStm->GetTFlag( nTria, nColor)) ;
}

//----------------------------------------------------------------------------
bool
ExeSurfTmResetTwoColors( int nId)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la superficie TriMesh
   ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
   bool bOk = ( pStm != nullptr) ;
  // reset dei flag sui triangoli per i due colori
   bOk = bOk && pStm->ResetTFlags() ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtSurfTmResetTwoColors(" + ToString( nId) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
   return bOk ;
}

//----------------------------------------------------------------------------
bool
ExeSurfTmSetShowEdges( int nId, bool bShow)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la superficie trimesh
   ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
   bool bOk = ( pStm != nullptr) ;
  // imposto lo stato di visualizzazione degli spigoli vivi
   if ( bOk)
      pStm->SetShowEdges( bShow) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtSurfTmSetShowEdges(" + ToString( nId) + "," +
                                               ToString( bShow) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
   return bOk ;
}

//----------------------------------------------------------------------------
bool
ExeSurfTmGetShowEdges( int nId, bool& bShow)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la superficie trimesh
   ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
   bool bOk = ( pStm != nullptr) ;
  // recupero lo stato di visualizzazione degli spigoli vivi
   if ( bOk)
      bShow = pStm->GetShowEdges() ;
   else
      bShow = false ;
   return bOk ;
}

//----------------------------------------------------------------------------
bool
ExeSurfTmSetSmoothAng( int nId, double dAngDeg)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
   // recupero la superficie trimseh da trimmare
   ISurfTriMesh* pSrfTm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
   if ( pSrfTm == nullptr)
      return false ;
  // imposto l'angolo discriminante degli spigoli vivi
   pSrfTm->SetSmoothAngle( dAngDeg) ;
   ExeSetModified() ;
   // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtSurfTmSetSmoothAng(" + ToString( nId) + "," +
                                             ToString( dAngDeg) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
ExeSurfTmGetSmoothAng( int nId, double& dAngDeg)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la superficie trimesh
   ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
   bool bOk = ( pStm != nullptr) ;
  // recupero l'angolo discriminante degli spigoli vivi
   if ( bOk)
      dAngDeg = pStm->GetSmoothAngle() ;
   else
      dAngDeg = 0 ;
   return bOk ;
}

//----------------------------------------------------------------------------
static double
GetStmOffsPrec( double dOffs, double dLinTol)
{
   return max( min( abs( dOffs) / 4., 10. * max( dLinTol, EPS_SMALL)), 0.5) ;
}

//----------------------------------------------------------------------------
int
ExeSurfTmOffset( int nParentId, const INTVECTOR& vStmIds, double dOffs, double dLinTol, int nType)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
   nParentId = AdjustId( nParentId) ;
  // se non ci sono superfici non c'è niente da calcolare
   if ( vStmIds.empty())
      return GDB_ID_NULL ;
  // recupero il riferimento del gruppo di inserimento
   Frame3d frLoc ;
   if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frLoc))
      return GDB_ID_NULL ;
  // recupero le superfici TriMesh e le porto tutte in locale
   SURFLOCALVECTOR vSurfL ; vSurfL.reserve( vStmIds.size()) ;
   CISURFTMPVECTOR vpStm ;  vpStm.reserve( vStmIds.size()) ;
   for ( int i = 0 ; i < int( vStmIds.size()) ; ++ i) {
      vSurfL.emplace_back( pGeomDB, vStmIds[i], frLoc) ;
      if ( vSurfL[i].Get() == nullptr)
         return GDB_ID_NULL ;
      vpStm.emplace_back( GetSurfTriMesh( vSurfL[i].Get())) ;
   }
  // precisione per Tridexel in funzione dell'offset e della tolleranza lineare
   double dPrec = GetStmOffsPrec( dOffs, dLinTol) ;
  // recupero la superficie risultante
   PtrOwner<ISurfTriMesh> pStmOffs( CreateSurfTriMeshesOffset( vpStm, dOffs, dPrec, nType)) ;
   bool bOk = ( ! IsNull( pStmOffs) && pStmOffs->IsValid()) ;
   int nId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pStmOffs)) : GDB_ID_NULL) ;
  // copio gli attributi
   pGeomDB->CopyAttributes( vStmIds[0], nId) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtSurfTmOffset(" + ToString( nParentId) + ")" +
                                         ToString( vStmIds) + "," +
                                         ToString( dOffs) + "," +
                                         ToString( dLinTol) + "," +
                                         ToString( nType) + ")" +
                    " -- Id=" + ToString( nId) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco il risultato
   return nId ;
}

//-------------------------------------------------------------------------------
int
ExeSurfTmThickeningOffset( int nParentId, const INTVECTOR& vStmIds, double dOffs, double dLinTol, int nType)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
   nParentId = AdjustId( nParentId) ;
  // se non ci sono superfici non c'è niente da calcolare
   if ( vStmIds.empty())
      return GDB_ID_NULL ;
  // recupero il riferimento del gruppo di inserimento
   Frame3d frLoc ;
   if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frLoc))
      return GDB_ID_NULL ;
  // recupero le superfici TriMesh e le porto tutte in locale
   SURFLOCALVECTOR vSurfL ; vSurfL.reserve( vStmIds.size()) ;
   CISURFTMPVECTOR vpStm ;  vpStm.reserve( vStmIds.size()) ;
   for ( int i = 0 ; i < int( vStmIds.size()) ; ++ i) {
      vSurfL.emplace_back( pGeomDB, vStmIds[i], frLoc) ;
      if ( vSurfL[i].Get() == nullptr)
         return GDB_ID_NULL ;
      vpStm.emplace_back( GetSurfTriMesh( vSurfL[i].Get())) ;
   }
  // precisione per Tridexel in funzione dell'offset e della tolleranza lineare
   double dPrec = GetStmOffsPrec( dOffs, dLinTol) ;
  // recupero la superficie risultante
   PtrOwner<ISurfTriMesh> pStmOffs( CreateSurfTriMeshesThickeningOffset( vpStm, dOffs, dPrec, nType)) ;
   bool bOk = ( ! IsNull( pStmOffs) && pStmOffs->IsValid()) ;
   int nId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pStmOffs)) : GDB_ID_NULL) ;
  // copio gli attributi
   pGeomDB->CopyAttributes( vStmIds[0], nId) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtSurfTmThickeningOffset(" + ToString( nParentId) + ")" +
                                                   ToString( vStmIds) + "," +
                                                   ToString( dOffs) + "," +
                                                   ToString( dLinTol) + "," +
                                                   ToString( nType) + ")" +
                    " -- Id=" + ToString( nId) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
   return nId ;
}

//-------------------------------------------------------------------------------
bool
ExeCutSurfBzPlane( int nId, const Point3d& ptOn, const Vector3d& vtN, bool bSaveOnEq, int nRefType)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la superficie TriMesh
   ISurfBezier* pSbz = GetSurfBezier( pGeomDB->GetGeoObj( nId)) ;
   bool bOk = ( pSbz != nullptr) ;
  // recupero il riferimento locale
   Frame3d frLoc ;
   bOk = bOk && pGeomDB->GetGlobFrame( nId, frLoc) ;
  // porto in locale il punto e la normale del piano
   Point3d ptOnL = GetPointLocal( pGeomDB, ptOn, nRefType, frLoc) ;
   Vector3d vtNL = GetVectorLocal( pGeomDB, vtN, nRefType, frLoc) ;
  // calcolo il piano di taglio
   Plane3d plPlane ;
   bOk = bOk && plPlane.Set( ptOnL, vtNL) ;
  // eseguo il taglio
   bOk = bOk &&  pSbz->Cut( plPlane, bSaveOnEq) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtCutSurfBzPlane(" + IdToString( nId) + ",{" +
                                           ToString( ptOn) + "},{" +
                                           ToString( vtN) + "}," +
                                           ( bSaveOnEq ? "true" : "false") + "," +
                                           RefTypeToString( nRefType) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return bOk ;
}

//----------------------------------------------------------------------------
static bool 
MySurfBzTrim( int nId, int nTrimmerId)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
      // recupero la superficie Bezier da trimmare
   ISurfBezier* pSrfBz = GetSurfBezier( pGeomDB->GetGeoObj( nId)) ;
   if ( pSrfBz == nullptr)
      return false ;
   // recupero il riferimento della superficie
   Frame3d frSurf ;
   if ( ! pGeomDB->GetGlobFrame( nId, frSurf))
      return false ;
   // recupero la superficie TriMesh divisore in locale alla prima

   SurfLocal SurfCLoc( pGeomDB, nTrimmerId, frSurf) ;
   //const ISurfTriMesh* pStmCLoc = GetSurfTriMesh( SurfCLoc) ;
   const ISurfFlatRegion* pSrfFr = GetSurfFlatRegion( SurfCLoc) ;
   if ( pSrfFr == nullptr)
      return false ;
   PtrOwner<ISurfFlatRegion> pSrfFrCopy( pSrfFr->Clone()) ;
   if ( ! pSrfFr->GetNormVersor().IsZplus())
      pSrfFrCopy->Invert() ;
   // eseguo il taglio
   return pSrfBz->SetTrimRegion( *pSrfFrCopy) ;
}

//----------------------------------------------------------------------------
bool
ExeSurfBzTrim( int nId, int nCutterId)
{
   bool bOk = MySurfBzTrim( nId, nCutterId) ;
   ExeSetModified() ;
   // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtSurfBzCut(" + ToString( nId) + "," +
         ToString( nCutterId) + "," +
         " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
   return bOk ;
}