EgtExecutor :

- codice di test per Zmap.

DllExchange.cpp

@@ -42,7 +42,6 @@ static const char* EEX_GETEEXVERSION = "GetEExVersion" ;
 static const char* EEX_SETEEXKEY = "SetEExKey" ;
 static const char* EEX_SETEEXNETHWKEY = "SetEExNetHwKey" ;
 static const char* EEX_SETBTLAUXDIR = "SetBtlAuxDir" ;
-static const char* EEX_SETBTLLUADATA = "SetBtlLuaData" ;
 static const char* EEX_CREATEBEAMMGR = "CreateBeamMgr" ;
 static const char* EEX_CREATEIMPORTBTL = "CreateImportBtl" ;
 static const char* EEX_CREATEIMPORTBTLX = "CreateImportBtlx" ;
@@ -51,8 +50,6 @@ static const char* EEX_CREATEIMPORTCSF = "CreateImportCsf" ;
 static const char* EEX_CREATEIMPORTDXF = "CreateImportDxf" ;
 static const char* EEX_CREATEIMPORTPNT = "CreateImportPnt" ;
 static const char* EEX_CREATEIMPORTSTL = "CreateImportStl" ;
-static const char* EEX_CREATEIMPORTOFF = "CreateImportOff" ;
-static const char* EEX_CREATEIMPORTPLY = "CreateImportPly" ;
 static const char* EEX_CREATEIMPORT3MF = "CreateImport3MF" ;
 static const char* EEX_CREATEEXPORTDXF = "CreateExportDxf" ;
 static const char* EEX_CREATEEXPORTSTL = "CreateExportStl" ;
@@ -186,21 +183,6 @@ MySetBtlAuxDir( const string& sBtlAuxDir)
    return pFun( sBtlAuxDir) ;
 }
 
-//-----------------------------------------------------------------------------
-bool
-MySetBtlLuaData( const string& sLuaLibsDir, const string& sLuaLastRequire)
-{
-  // verifico caricamento libreria EgtExchange
-   if ( s_hEEx == nullptr)
-      return false ;
-  // recupero funzione creazione oggetto
-   typedef bool (* PF_SetBtlLuaData) ( const string& sLuaLibsDir, const string& sLuaLastRequire) ;
-   PF_SetBtlLuaData pFun = (PF_SetBtlLuaData)GetProcAddress( s_hEEx, EEX_SETBTLLUADATA) ;
-   if ( pFun == nullptr)
-      return false ;
-   return pFun( sLuaLibsDir, sLuaLastRequire) ;
-}
-
 //-----------------------------------------------------------------------------
 IBeamMgr*
 MyCreateBeamMgr( void)
@@ -321,36 +303,6 @@ MyCreateImportStl( void)
    return pFun() ;
 }
 
-//-----------------------------------------------------------------------------
-IImportOff*
-MyCreateImportOff( void)
-{
-  // verifico caricamento libreria EgtExchange
-   if ( s_hEEx == nullptr)
-      return nullptr ;
-  // recupero funzione creazione oggetto
-   typedef IImportOff* (* PF_CreateImportOff) ( void) ;
-   PF_CreateImportOff pFun = (PF_CreateImportOff)GetProcAddress( s_hEEx, EEX_CREATEIMPORTOFF) ;
-   if ( pFun == nullptr)
-      return nullptr ;
-   return pFun() ;
-}
-
-//-----------------------------------------------------------------------------
-IImportPly*
-MyCreateImportPly( void)
-{
-  // verifico caricamento libreria EgtExchange
-   if ( s_hEEx == nullptr)
-      return nullptr ;
-  // recupero funzione creazione oggetto
-   typedef IImportPly* (* PF_CreateImportPly) ( void) ;
-   PF_CreateImportPly pFun = (PF_CreateImportPly)GetProcAddress( s_hEEx, EEX_CREATEIMPORTPLY) ;
-   if ( pFun == nullptr)
-      return nullptr ;
-   return pFun() ;
-}
-
 //-----------------------------------------------------------------------------
 IImport3MF*
 MyCreateImport3MF( void)

DllExchange.h

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2015-2025
+//  EgalTech 2015-2021
 //----------------------------------------------------------------------------
-// File : DllExchange.h         Data : 28.02.25        Versione : 2.7b2
+// File : DllExchange.h         Data : 27.08.21        Versione : 2.3h2
 // Contenuto : Dichiarazioni funzioni per libreria opzionale EgtExchange.
 //
 //
@@ -24,8 +24,6 @@ class IImportCsf ;
 class IImportDxf ;
 class IImportPnt ;
 class IImportStl ;
-class IImportOff ;
-class IImportPly ;
 class IImport3MF ;
 class IExportDxf ;
 class IExportStl ;
@@ -43,7 +41,6 @@ void MySetEExKey( const std::string& sKey) ;
 void MySetEExNetHwKey( bool bNetHwKey) ;
 const char* MyGetEExVersion( void) ;
 bool MySetBtlAuxDir( const std::string& sBtlAuxDir) ;
-bool MySetBtlLuaData( const std::string& sLuaLibsDir, const std::string& sLuaLastRequire) ;
 IBeamMgr* MyCreateBeamMgr( void) ;
 IImportBtl* MyCreateImportBtl( void) ;
 IImportBtlx* MyCreateImportBtlx( void) ;
@@ -52,8 +49,6 @@ IImportCsf* MyCreateImportCsf( void) ;
 IImportDxf* MyCreateImportDxf( void) ;
 IImportPnt* MyCreateImportPnt( void) ;
 IImportStl* MyCreateImportStl( void) ;
-IImportOff* MyCreateImportOff( void) ;
-IImportPly* MyCreateImportPly( void) ;
 IImport3MF* MyCreateImport3MF( void) ;
 IExportDxf* MyCreateExportDxf( void) ;
 IExportStl* MyCreateExportStl( void) ;

EXE.h

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2014-2024
+//  EgalTech 2014-2023
 //----------------------------------------------------------------------------
-// File : EXE.h             Data : 15.05.24        Versione : 2.6e4
+// File : EXE.h             Data : 05.02.23        Versione : 2.5a6
 // Contenuto : Dichiarazioni locali per moduli EXE.
 //
 //
@@ -26,7 +26,6 @@ const std::string& ExeGetIniFile( void) ;
 const std::string& ExeGetKey( void) ;
 const std::string& ExeGetNestKey( void) ;
 const std::string& ExeGetLockId( void) ;
-bool ExeVerifyKeyOption( int nOptInd) ;
 
 //----------------------------------------------------------------------------
 ILogger* GetLogger( void) ;

EXE_CAvTool.cpp

@@ -175,23 +175,16 @@ ExeCAvToolPathStm( int nCrvId, const Vector3d& vtAx, int nSurfTmId, const Vector
   // verifico oggetto per evitare collisioni
    if ( IsNull( s_pCAvTlStm))
       return false ;
-  // Controllo la tolleranza lineare (se negativa non vanno fatti controlli sui punti medi)
-   if ( dLinTol > -EPS_ZERO)
-      dLinTol = max( dLinTol, EPS_SMALL) ;
-   else
-      dLinTol = -1 ;
   // approssimo la curva con una polilinea
    PolyLine PL ;
    if ( ! pCrv->ApproxWithLines( dLinTol, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL, PL))
       return false ;
   // eventuale aggiunta di punti per garantire max distanza
-   if ( dLinTol > 0) {
-      const double MIN_DIST = 1. ;
-      const double MAX_DIST = 50. ;
-      double dDist = Clamp( s_pCAvTlStm->GetToolRadius(), MIN_DIST, MAX_DIST) ;
-      if ( ! PL.AdjustForMaxSegmentLen( dDist))
-         return false ;
-   }
+   const double MIN_DIST = 1. ;
+   const double MAX_DIST = 50. ;
+   double dDist = Clamp( s_pCAvTlStm->GetToolRadius(), MIN_DIST, MAX_DIST) ;
+   if ( ! PL.AdjustForMaxSegmentLen( dDist))
+      return false ;
   // porto nel riferimento della superficie
    PL.LocToLoc( frCrv, frSurf) ;
   // porto i dati geometrici in locale alla superficie
@@ -205,8 +198,7 @@ ExeCAvToolPathStm( int nCrvId, const Vector3d& vtAx, int nSurfTmId, const Vector
   // riporto la polilinea nel riferimento della curva
    PL.LocToLoc( frSurf, frCrv) ;
   // elimino i punti allineati
-   if ( dLinTol > 0)
-      PL.RemoveAlignedPoints( 0.8 * dLinTol) ;
+   PL.RemoveAlignedPoints( 0.8 * dLinTol) ;
   // creo una curva composita a partire dalla polilinea
    PtrOwner< ICurveComposite> pCompo( CreateCurveComposite()) ;
    if ( IsNull( pCompo)  ||  ! pCompo->FromPolyLine( PL))

EXE_Exchange.cpp

@@ -15,7 +15,6 @@
 #include "stdafx.h"
 #include "EXE.h"
 #include "EXE_Macro.h"
-#include "LUA_Base.h"
 #include "AuxTools.h"
 #include "DllExchange.h"
 #include "DllExch3dm.h"
@@ -30,8 +29,6 @@
 #include "/EgtDev/Include/EExImportPnt.h"
 #include "/EgtDev/Include/EExImportBtl.h"
 #include "/EgtDev/Include/EExImportBtlx.h"
-#include "/EgtDev/Include/EExImportOff.h"
-#include "/EgtDev/Include/EExImportPly.h"
 #include "/EgtDev/Include/EExExportDxf.h"
 #include "/EgtDev/Include/EExExportStl.h"
 #include "/EgtDev/Include/EExExport3MF.h"
@@ -80,10 +77,6 @@ ExeGetFileType( const string& sFilePath)
       return FT_3DM ;
    else if ( sFileExt == "OBJ")
       return FT_OBJ ;
-   else if ( sFileExt == "OFF")
-      return FT_OFF ;
-   else if ( sFileExt == "PLY")
-      return FT_PLY ;
    else if ( sFileExt == "CNC"  ||  sFileExt == "XPI"  ||  sFileExt == "MPF"  ||  sFileExt == "ISO"  ||  sFileExt == "EIA")
       return FT_CNC ;
    else if ( sFileExt == "HED"  ||  sFileExt == "ENT"  ||  sFileExt == "ENS")
@@ -92,6 +85,8 @@ ExeGetFileType( const string& sFilePath)
       return FT_BTL ;
    else if ( sFileExt == "BTLX")
       return FT_BTLX ;
+   else if ( sFileExt == "3DM")
+      return FT_3DM ;
    else if ( sFileExt == "PNG"  ||  sFileExt == "JPG"  ||  sFileExt == "JPEG"  ||  sFileExt == "BMP")
       return FT_IMG ;
    else if ( sFileExt == "PNT"  ||  sFileExt == "XYZ")
@@ -130,7 +125,7 @@ ExeGetFileType( const string& sFilePath)
 bool
 ExeSetBtlAuxDir( const string& sBtlAuxDir)
 {
-   return MySetBtlAuxDir( sBtlAuxDir) && MySetBtlLuaData( LuaGetLuaLibsDir(), LuaGetLastRequire()) ;
+   return MySetBtlAuxDir( sBtlAuxDir) ;
 }
 
 //-----------------------------------------------------------------------------
@@ -374,95 +369,20 @@ ExeImportStl( const string& sFilePath, double dScaleFactor)
 
 //-----------------------------------------------------------------------------
 bool
-ExeImportOff( const string& sFilePath, double dScaleFactor)
-{
-   GseContext* pGseCtx = GetCurrGseContext() ;
-   VERIFY_CTX_GEOMDB( pGseCtx, false)
-   bool bOk = true ;
-  // importo il file OFF
-   // aggiungo un gruppo pezzo e un gruppo layer
-   int nPartId = pGseCtx->m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, Frame3d()) ;
-   int nLayerId = pGseCtx->m_pGeomDB->AddGroup( GDB_ID_NULL, nPartId, Frame3d()) ;
-  // preparo l'importatore
-   PtrOwner<IImportOff> pImpOff( MyCreateImportOff()) ;
-   bOk = bOk && ! IsNull( pImpOff) ;
-  // eseguo l'importazione
-   bOk = bOk && pImpOff->Import( sFilePath, pGseCtx->m_pGeomDB, nLayerId, dScaleFactor) ;
-  // aggiorno stato file corrente
-   if ( pGseCtx->m_sFilePath.empty())
-      pGseCtx->m_sFilePath = sFilePath ;
-   ExeSetModified() ;
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtImportOff('" + StringToLuaString( sFilePath) + "'," +
-                                       ToString( dScaleFactor) + ")" +
-                    " -- Ok=" + ToString( bOk) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-  // scrivo il log
-   if ( ! IsNull( pImpOff)) {
-      string sLog = "Import File " + sFilePath ;
-      LOG_INFO( GetLogger(), sLog.c_str()) ;
-   }
-  // restituisco il risultato
-   return bOk ;
-}
-
-//-----------------------------------------------------------------------------
-bool
-ExeImportPly( const string& sFilePath, double dScaleFactor)
-{
-   GseContext* pGseCtx = GetCurrGseContext() ;
-   VERIFY_CTX_GEOMDB( pGseCtx, false)
-   bool bOk = true ;
-  // importo il file PLY
-   // aggiungo un gruppo pezzo e un gruppo layer
-   int nPartId = pGseCtx->m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, Frame3d()) ;
-   int nLayerId = pGseCtx->m_pGeomDB->AddGroup( GDB_ID_NULL, nPartId, Frame3d()) ;
-  // preparo l'importatore
-   PtrOwner<IImportPly> pImpPly( MyCreateImportPly()) ;
-   bOk = bOk && ! IsNull( pImpPly) ;
-  // eseguo l'importazione
-   bOk = bOk && pImpPly->Import( sFilePath, pGseCtx->m_pGeomDB, nLayerId, dScaleFactor) ;
-  // aggiorno stato file corrente
-   if ( pGseCtx->m_sFilePath.empty())
-      pGseCtx->m_sFilePath = sFilePath ;
-   ExeSetModified() ;
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtImportPly('" + StringToLuaString( sFilePath) + "'," +
-                                       ToString( dScaleFactor) + ")" +
-                    " -- Ok=" + ToString( bOk) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-  // scrivo il log
-   if ( ! IsNull( pImpPly)) {
-      string sLog = "Import File " + sFilePath ;
-      LOG_INFO( GetLogger(), sLog.c_str()) ;
-   }
-  // restituisco il risultato
-   return bOk ;
-}
-
-//-----------------------------------------------------------------------------
-bool
-ExeImport3MF( const string& sFilePath, int nFlag)
+ExeImport3MF( const string& sFilePath)
 {
    GseContext* pGseCtx = GetCurrGseContext() ;
    VERIFY_CTX_GEOMDB( pGseCtx, false)
    bool bOk = true ;
   // importo il file 3MF
-   int nLayerId = GDB_ID_ROOT ;
-  // aggiungo un gruppo pezzo e un gruppo layer se non devo conservare la gerarchia del file
-   if ( ( nFlag & EI3FLAG_KEEP_GROUPS) == 0) {
-      int nPartId = pGseCtx->m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, Frame3d()) ;
-      nLayerId = pGseCtx->m_pGeomDB->AddGroup( GDB_ID_NULL, nPartId, Frame3d()) ;
-   }  
+  // aggiungo un gruppo pezzo e un gruppo layer
+   int nPartId = pGseCtx->m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, Frame3d()) ;
+   int nLayerId = pGseCtx->m_pGeomDB->AddGroup( GDB_ID_NULL, nPartId, Frame3d()) ;
   // preparo l'importatore
    PtrOwner<IImport3MF> pImp3MF( MyCreateImport3MF()) ;
    bOk = bOk && ! IsNull( pImp3MF) ;
   // eseguo l'importazione
-   bOk = bOk && pImp3MF->Import( sFilePath, pGseCtx->m_pGeomDB, nLayerId, nFlag) ;
+   bOk = bOk && pImp3MF->Import( sFilePath, pGseCtx->m_pGeomDB, nLayerId) ;
   // aggiorno stato file corrente
    if ( pGseCtx->m_sFilePath.empty())
       pGseCtx->m_sFilePath = sFilePath ;
@@ -488,11 +408,10 @@ ExeImport3dm( const string& sFilePath)
 {
    GseContext* pGseCtx = GetCurrGseContext() ;
    VERIFY_CTX_GEOMDB( pGseCtx, false)
-  // se necessario, carico libreria exchange 3dm opzionale
-   if ( ! IsLoadedExch3dmDll()  &&  LoadExch3dmDll( GetLogger(), ExeGetKey(), ExeGetNetHwKey()))
-      LOG_INFO( GetLogger(), MyGetEE3Version())
-  // importo il file 3dm
    bool bOk = true ;
+  // importo il file 3dm
+  //// aggiungo un gruppo pezzo e un gruppo layer
+  // int nPartId = pGseCtx->m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, Frame3d()) ;
   // preparo l'importatore
    PtrOwner<IImport3dm> pImp3dm( MyCreateImport3dm()) ;
    bOk = bOk && ! IsNull( pImp3dm) ;
@@ -720,11 +639,8 @@ ExeExport3dm( int nId, const string& sFilePath, int nFilter)
 {
    IGeomDB* pGeomDB = GetCurrGeomDB() ;
    VERIFY_GEOMDB( pGeomDB, false)
-  // se necessario, carico libreria exchange 3dm opzionale
-   if ( ! IsLoadedExch3dmDll()  &&  LoadExch3dmDll( GetLogger(), ExeGetKey(), ExeGetNetHwKey()))
-      LOG_INFO( GetLogger(), MyGetEE3Version())
-  // esporto il file 3dm
    bool bOk = true ;
+  // esporto il file 3dm
   // preparo l'esportatore
    PtrOwner<IExport3dm> pExp3dm( MyCreateExport3dm()) ;
    bOk = bOk && ! IsNull( pExp3dm) ;

EXE_GdbCreateCurve.cpp

@@ -40,12 +40,11 @@
 #include "/EgtDev/Include/EGkChainCurves.h"
 #include "/EgtDev/Include/EGkCurveByInterp.h"
 #include "/EgtDev/Include/EGkCurveByApprox.h"
-#include "/EgtDev/Include/EGkCurveAux.h"
 #include "/EgtDev/Include/EGkOffsetCurve.h"
-#include "/EgtDev/Include/EGkCurveLocal.h"
 #include "/EgtDev/Include/EGkSurfTriMesh.h"
 #include "/EgtDev/Include/EGkDistPointCurve.h"
 #include "/EgtDev/Include/EGkStringUtils3d.h"
+#include "/EgtDev/Include/EGkCurveLocal.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
 
 using namespace std ;
@@ -1089,45 +1088,6 @@ ExeCreateArc3P( int nParentId, const Point3d& ptP1,
    return nId ;
 }
 
-//-------------------------------------------------------------------------------
-int
-ExeCreateArc2PR( int nParentId, const Point3d& ptStart, const Point3d& ptEnd,
-                 double dRad, bool bCCW, int nRefType)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
-   nParentId = AdjustId( nParentId) ;
-  // recupero il riferimento locale
-   Frame3d frLoc ;
-   bool bOk = pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
-  // porto in locale i punti, il versore normale e quelloe estrusione
-   Point3d ptStartL = GetPointLocal( pGeomDB, ptStart, nRefType, frLoc) ;
-   Point3d ptEndL = GetPointLocal( pGeomDB, ptEnd, nRefType, frLoc) ;
-   Vector3d vtNormL = GetVectorLocal( pGeomDB, Z_AX, nRefType, frLoc) ;
-   Vector3d vtExtrL = GetVectorLocal( pGeomDB, Z_AX, nRefType, frLoc) ;
-  // creo l'arco
-   PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
-   bOk = bOk && ( ! IsNull( pCrvArc)  &&
-                  pCrvArc->Set2PNRS( ptStartL, ptEndL, vtNormL, dRad, bCCW)) ;
-  // assegno il versore estrusione
-   bOk = bOk && pCrvArc->SetExtrusion( vtExtrL) ;
-  // inserisco l'arco nel DB
-   int nId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvArc)) : GDB_ID_NULL) ;
-   ExeSetModified() ;
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtArc2PR(" + IdToString( nParentId) + ",{" +
-                                   ToString( ptStart) + "},{" +
-                                   ToString( ptEnd) + "}," +
-                                   ToString( dRad) + "," +
-                                   RefTypeToString( nRefType) + ")" +
-                    " -- Id=" + ToString( nId) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-  // restituisco l'identificativo della nuova entità
-   return nId ;
-}
-
 //-------------------------------------------------------------------------------
 int
 ExeCreateArc2PB( int nParentId, const Point3d& ptStart, const Point3d& ptEnd,
@@ -2585,71 +2545,3 @@ CalcExtrusion( IGeomDB* pGeomDB, int nParentId, int nRefType)
       vtExtr.LocToLoc( pGeomDB->GetGridFrame(), frEnt) ;
    return vtExtr ;
 }
-
-//-------------------------------------------------------------------------------
-static int
-MyCreateCurveBezierForm( int nParentId, int nCrvId)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
-   nParentId = AdjustId( nParentId) ;
-   // recupero il riferimento della curva
-   Frame3d frCrv ;
-   if ( ! pGeomDB->GetGlobFrame( nCrvId, frCrv))
-      return GDB_ID_NULL ;
-   // recupero il riferimento di destinazione
-   Frame3d frLoc ;
-   if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frLoc))
-      return GDB_ID_NULL ;
-   // recupero la curva
-   const ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nCrvId)) ;
-   if ( pCurve == nullptr  ||  ! pCurve->IsValid())
-      return GDB_ID_NULL ;
-   // recupero il vettore estrusione della curva e lo porto in locale al gruppo destinazione
-   Vector3d vtExtr ;
-   pCurve->GetExtrusion( vtExtr) ;
-   vtExtr.LocToLoc( frCrv, frLoc) ;
-   PtrOwner<ICurve> pCrvBez ( CurveToBezierCurve( pCurve)) ;
-
-   //int nType = pCurve->GetType() ;
-   //switch ( nType ) {
-   //case CRV_LINE :
-   //   pCrvBez.Set( LineToBezierCurve( GetCurveLine( pCurve))) ;
-   //   break ;
-   //case CRV_ARC :
-   //   pCrvBez.Set( ArcToBezierCurve( GetCurveArc( pCurve))) ;
-   //   break ;
-   //case CRV_BEZIER :
-   //   pCrvBez.Set( BezierToBasicBezierCurve( GetCurveBezier( pCurve))) ;
-   //   break ;
-   //case CRV_COMPO :
-   //   pCrvBez.Set( CompositeToBezierCurve( GetCurveComposite( pCurve))) ;
-   //   break ;
-   //default :
-   //   break ;
-   //}
-   // setto l'estrusione
-   pCrvBez->SetExtrusion( vtExtr) ;
-   // aggiungo la curva in forma di Bezier al DB
-   int nId = pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvBez)) ;
-   return nId ;
-}
-
-//-------------------------------------------------------------------------------
-int
-ExeCreateCurveBezierForm( int nParentId, int nCrvId, int nDeg)
-{
-   // eseguo
-   int nId = MyCreateCurveBezierForm( nParentId, nCrvId) ;
-   ExeSetModified() ;
-   // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtCurveBezierForm(" + IdToString( nParentId) + "," +
-                                            IdToString( nCrvId) + "," +
-                                            ToString( nDeg) + ")"
-                     " -- Id=" + ToString( nId) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-   // restituisco l'identificativo della nuova entità
-   return nId ;
-}

EXE_GdbCreateSurf.cpp

@@ -1,4 +1,4 @@
-//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
 //  EgalTech 2014-2015
 //----------------------------------------------------------------------------
 // File : EXE_GdbCreateSurf.cpp       Data : 04.05.15       Versione : 1.6e1
@@ -19,7 +19,6 @@
 #include "GeoTools.h"
 #include "/EgtDev/Include/EXeExecutor.h"
 #include "/EgtDev/Include/EXeConst.h"
-#include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/EGkSurfFlatRegion.h"
 #include "/EgtDev/Include/EGkSfrCreate.h"
 #include "/EgtDev/Include/EGkSurfTriMesh.h"
@@ -36,7 +35,6 @@
 #include "/EgtDev/Include/EgtPointerOwner.h"
 #include "/EgtDev/Include/EGkExtText.h"
 #include "/EgtDev/Include/EGkSbzStandard.h"
-#include "/EgtDev/Include/EGkSbzFromCurves.h"
 
 using namespace std ;
 
@@ -348,28 +346,6 @@ ExeCreateSurfFlatRegion( int nParentId, const INTVECTOR& vCrvIds, int* pnCount)
    return nFirstId ;
 }
 
-//-------------------------------------------------------------------------------
-int
-ExeCreateSurfTmEmpty( int nParentId)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
-   nParentId = AdjustId( nParentId) ;
-  // creo la superficie vuota
-   PtrOwner<ISurfTriMesh> pStm( GetSurfTriMeshEmpty()) ;
-  // inserisco la superficie nel DB
-   int nNewId = pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pStm)) ;
-   ExeSetModified() ;
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtSurfTmEmpty(" + IdToString( nParentId) + ")" +
-                    " -- Id=" + ToString( nNewId) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-  // restituisco l'identificativo della nuova entità
-   return nNewId ;
-}
-
 //-------------------------------------------------------------------------------
 static int
 MyCreateSurfTmPlaneInBBox( int nParentId, const Point3d& ptP, const Vector3d& vtN, const BBox3d& b3Box, int nRefType)
@@ -1197,43 +1173,6 @@ ExeCreateSurfTmByRevolve( int nParentId, int nCrvId,
    return nNewId ;
 }
 
-//-------------------------------------------------------------------------------
-int
-ExeCreateSurfBzByPointCurve( int nParentId, int nCrvId, const Point3d& ptTop,
-                             bool bCapEnds, double dLinTol, int nRefType)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
-   nParentId = AdjustId( nParentId) ;
-   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 ptTopL = GetPointLocal( pGeomDB, ptTop, nRefType, frLoc) ;
-   // calcolo la superficie
-   ISurfBezier* pSTM = ( bOk ? GetSurfBezierRuled( ptTopL, CrvLoc, dLinTol) : nullptr) ;
-   // inserisco la superficie nel DB
-   int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, pSTM) : GDB_ID_NULL) ;
-   ExeSetModified() ;
-   // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtSurfBzByPointCurve(" + IdToString( nParentId) + "," +
-                                               ToString( nCrvId) + ",{" +
-                                               ToString( ptTop) + "},{" +
-                                               ( 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
 ExeCreateSurfTmByScrewing( int nParentId, int nCrvId,
@@ -1729,6 +1668,8 @@ ExeCreateSurfBezier( int nParentId, int nDegU, int nDegV, int nSpanU, int nSpanV
       if ( ! pSurfBez->SetControlPoint( i, ptCtrl))
          bOk = false ;
    }
+  // calcolo eventuali poli
+   pSurfBez->CalcPoles() ;
   // se superficie nulla (ovvero ridotta a punto), errore
    bOk = bOk && ! pSurfBez->IsAPoint() ;
   // inserisco la superficie nel DB
@@ -1781,6 +1722,8 @@ ExeCreateSurfBezierRational( int nParentId, int nDegU, int nDegV, int nSpanU, in
       if ( ! pSurfBez->SetControlPoint( i, ptCtrl, vPntW[i].second))
          bOk = false ;
    }
+  // calcolo eventuali poli
+   pSurfBez->CalcPoles() ;
   // se superficie nulla (ovvero ridotta a punto), errore
    bOk = bOk && ! pSurfBez->IsAPoint() ;
   // inserisco la superficie nel DB
@@ -1894,9 +1837,9 @@ ExeCreateSurfBezierTria2D( int nParentId, int nSurfBzId, int nTextHeight, bool b
    for ( int k = 0 ; k < (int)vTria2D.size() ; ++ k) {
       PtrOwner<ISurfTriMesh> pStm( CreateSurfTriMesh()) ;
       bOk = bOk && ! IsNull( pStm) ;
-      Point3d ptP1L = get<1>(vTria2D[k]) ;
-      Point3d ptP2L = get<2>(vTria2D[k]) ;
-      Point3d ptP3L = get<3>(vTria2D[k]) ;
+      Point3d ptP1L =  get<1>(vTria2D[k]) ;
+      Point3d ptP2L =  get<2>(vTria2D[k]) ;
+      Point3d ptP3L =  get<3>(vTria2D[k]) ;
       // assegno il triangolo
       if ( bOk) {
          pStm->Init( 3, 1, 1) ;
@@ -1944,8 +1887,7 @@ ExeCreateSurfBezierTria2D( int nParentId, int nSurfBzId, int nTextHeight, bool b
 
 //-------------------------------------------------------------------------------
 int
-ExeCreateBezierSphere( int nParentId, const Point3d& ptCenter, double dR, int nRefType)
-{
+ExeCreateBezierSphere( int nParentId, const Point3d& ptCenter, double dR, int nRefType) {
    IGeomDB* pGeomDB = GetCurrGeomDB() ;
    VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
    nParentId = AdjustId( nParentId) ;
@@ -1956,733 +1898,19 @@ ExeCreateBezierSphere( int nParentId, const Point3d& ptCenter, double dR, int nR
   // reucpero il punto in locale
    Point3d ptCenterLoc = GetPointLocal( pGeomDB, ptCenter, nRefType, frLoc) ;
   // Creo la superficie
-   PtrOwner<ISurfBezier> pSurfBez( GetSurfBezierSphere( ptCenterLoc, dR)) ;
-   bOk = bOk && ! IsNull( pSurfBez) ;
+   PtrOwner<ISurfBezier> pSurfBez( CreateBezierSphere( ptCenterLoc, dR)) ;
+   pSurfBez->CalcPoles() ;
    int nId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSurfBez)) : GDB_ID_NULL) ;
    ExeSetModified() ;
    // se richiesto, salvo il comando Lua equivalente
    if ( IsCmdLog()) {
-      string sLua = "EgtSurfBzSphere(" + IdToString( nParentId) + "," +
-                                         ToString( ptCenter) + "," +
-                                         ToString( dR) + "," +
-                                         RefTypeToString( nRefType) + ")" +
-                    " -- Id=" + ToString( nId) ;
+      string sLua = "EgtCreateBezierSphere(" + IdToString( nParentId) + "," +
+         ToString( ptCenter) + "," +
+         ToString( dR) + "," +
+         RefTypeToString( nRefType) + ")" +
+         " -- Id=" + ToString( nId) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
    }
-  // resituisco l'identificativo dell'entità creata
+  // resituisco l'identificativo dell'entit� creata
    return nId ;
 }
-
-//-------------------------------------------------------------------------------
-int
-ExeCreateSurfBzByFlatContour( int nParentId, int nCrvId, double dLinTol)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
-   nParentId = AdjustId( nParentId) ;
-   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
-   PtrOwner<ISurfBezier> pSbz( bOk ? GetSurfBezierByFlatContour( CrvLoc, dLinTol) : nullptr) ;
-   bOk = bOk && ! IsNull( pSbz) ;
-  // inserisco la superficie nel DB
-   int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSbz)) : GDB_ID_NULL) ;
-   ExeSetModified() ;
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtSurfBzByFlatContour(" + IdToString( nParentId) + "," +
-                                                ToString( nCrvId) + "," +
-                                                ToString( dLinTol) + ")" +
-                    " -- Id=" + ToString( nNewId) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-  // restituisco l'identificativo della nuova entità
-   return nNewId ;
-}
-
-//-------------------------------------------------------------------------------
-int
-ExeCreateSurfBzByRegion( int nParentId, const INTVECTOR& vCrvIds, double dLinTol)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
-      nParentId = AdjustId( nParentId) ;
-   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()) ;
-   CICURVEPVECTOR vCrvP ;
-   vCrvP.reserve( vCrvIds.size()) ;
-   for ( size_t i = 0 ; i < vCrvIds.size() ; ++ i) {
-      int nId = (( vCrvIds[i] != GDB_ID_SEL) ? vCrvIds[i] : pGeomDB->GetFirstSelectedObj()) ;
-      while ( nId != GDB_ID_NULL) {
-         vCrvLoc.emplace_back( pGeomDB, nId, frLoc) ;
-         vCrvP.push_back( vCrvLoc.back().Get()) ;
-         bOk = bOk && ( vCrvLoc[i].Get() != nullptr) ;
-         // passo al successivo
-         nId = (( vCrvIds[i] != GDB_ID_SEL) ? GDB_ID_NULL : pGeomDB->GetNextSelectedObj()) ;
-      }
-   }
-   // calcolo la superficie
-   PtrOwner<ISurfBezier> pSbz( bOk ? GetSurfBezierByRegion( vCrvP, dLinTol) : nullptr) ;
-   bOk = bOk && ! IsNull( pSbz) ;
-   // inserisco la superficie nel DB
-   int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSbz)) : GDB_ID_NULL) ;
-   ExeSetModified() ;
-   // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtSurfBzByRegion(" + IdToString( nParentId) + ",{" +
-                                           IdListToString( vCrvIds) + "}," +
-                                           ToString( dLinTol) + ")" +
-                    " -- Id=" + ToString( nNewId) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-   // restituisco l'identificativo della nuova entità
-   return nNewId ;
-}
-
-//-------------------------------------------------------------------------------
-int
-ExeCreateSurfBzByExtrusion( int nParentId, int nCrvId, const Vector3d& vtExtr, bool bCapEnds,
-                            double dLinTol, int nRefType)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
-      nParentId = AdjustId( nParentId) ;
-   bool bOk = true ;
-  // recupero il riferimento locale
-   Frame3d frLoc ;
-   bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
-  // recupero il riferimento della curva
-   Frame3d frCrv ;
-   bOk = bOk && pGeomDB->GetGlobFrame( nCrvId, frCrv) ;
-  // recupero la curva in locale
-   const ICurve* pCrvOrig = GetCurve( pGeomDB->GetGeoObj( nCrvId)) ;
-   PtrOwner<ICurve> pCrv( pCrvOrig->Clone()) ;
-  // porto in locale il vettore estrusione
-   Vector3d vtExtrL = GetVectorLocal( pGeomDB, vtExtr, nRefType, frLoc) ;
-  // creo la superficie e la inserisco nel DB
-   int nFirstId = GDB_ID_NULL ;
-   double dAndTolStdDeg = 15 ;
-   Plane3d plPlane ;
-   double dArea ;
-   PolyLine plApprox ;
-   pCrv->ApproxWithLines( dLinTol, dAndTolStdDeg, ICurve::APL_STD, plApprox) ;
-   double dOrthoExtr = 0 ;
-   if ( bCapEnds  &&  plApprox.IsClosedAndFlat( plPlane, dArea, 50 * EPS_SMALL)){
-      dOrthoExtr = plPlane.GetVersN() * vtExtr ;
-      if ( ( abs( dOrthoExtr) < EPS_SMALL))
-         return GDB_ID_NULL ;
-      if ( dOrthoExtr < 0)
-         pCrv->Invert() ;
-   }
-  // creo l'estrusione della curva
-   PtrOwner<ISurfBezier> pSbz( bOk ? GetSurfBezierByExtrusion( pCrv, vtExtrL, false, dLinTol) : nullptr ) ;
-   bOk = bOk && ! IsNull( pSbz) ;
-  // inserisco la superficie nel DB
-   int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSbz)) : GDB_ID_NULL) ;
-   bOk = bOk && ( nNewId != GDB_ID_NULL) ;
-
-  // se richiesta chiusura agli estremi
-   if ( bCapEnds  &&  bOk) {
-      PtrOwner<ISurfBezier> pSrfBzTop( CreateSurfBezier()) ;
-      pSrfBzTop->CreateByFlatContour( plApprox) ;
-      pSrfBzTop->Translate( vtExtrL) ;
-      pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSrfBzTop)) ;
-      PtrOwner<ISurfBezier> pSrfBzBottom( CreateSurfBezier()) ;
-      pSrfBzBottom->CreateByFlatContour( plApprox) ;
-      pSrfBzBottom->Invert() ;
-      pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSrfBzBottom)) ;
-   }
-
-   ExeSetModified() ;
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtSurfBzByExtrusion(" + IdToString( nParentId) + "," +
-                                              IdToString( nCrvId) + ",{" +
-                                              ToString( vtExtr) + "}," +
-                                              ( bCapEnds ? "true" : "false") + "," +
-                                              ToString( dLinTol) + "," +
-                                              RefTypeToString( nRefType) + ")" +
-                    " -- Id=" + ToString( nFirstId) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-  // restituisco l'identificativo della nuova entità
-   return nFirstId ;
-}
-
-//-------------------------------------------------------------------------------
-int
-ExeCreateSurfBzByRegionExtrusion( int nParentId, const INTVECTOR& vCrvIds, const Vector3d& vtExtr, bool bCapEnds,
-                                  double dLinTol, int nRefType)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
-   nParentId = AdjustId( nParentId) ;
-   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()) ;
-   CICURVEPVECTOR vCrvP ;
-   vCrvP.reserve( vCrvIds.size()) ;
-   for ( size_t i = 0 ; i < vCrvIds.size() ; ++ i) {
-      int nId = (( vCrvIds[i] != GDB_ID_SEL) ? vCrvIds[i] : pGeomDB->GetFirstSelectedObj()) ;
-      while ( nId != GDB_ID_NULL) {
-         vCrvLoc.emplace_back( pGeomDB, nId, frLoc) ;
-         vCrvP.push_back( const_cast<ICurve*>( vCrvLoc.back().Get())) ;
-         bOk = bOk && ( vCrvLoc[i].Get() != nullptr) ;
-        // passo al successivo
-         nId = (( vCrvIds[i] != GDB_ID_SEL) ? GDB_ID_NULL : pGeomDB->GetNextSelectedObj()) ;
-      }
-   }
-  // porto in locale il vettore estrusione
-   Vector3d vtExtrL = GetVectorLocal( pGeomDB, vtExtr, nRefType, frLoc) ;
-  // creo le superfici e le inserisco nel DB
-   int nFirstId = GDB_ID_NULL ;
-   double dAndTolStdDeg = 15 ;
-
-  // riordino le curve in modo che la prima sia quella esterna e tutte le altre dopo
-   POLYLINEVECTOR vPL ;
-   for ( int i = 0 ; i < int( vCrvP.size()) ; ++ i) {
-      vPL.emplace_back() ;
-      if ( ! vCrvP[i]->ApproxWithLines( dLinTol, dAndTolStdDeg, ICurve::APL_SPECIAL, vPL.back()))
-         return false ;
-   }
-   Vector3d vtN ;
-   INTMATRIX vnPLIndMat ;
-   BOOLVECTOR vbInvert ;
-   if ( ! CalcRegionPolyLines( vPL, vtN, vnPLIndMat, vbInvert))
-      return nFirstId ;
-
-  // creo una copia delle curve, orientate giuste
-   ICURVEPOVECTOR vpCrvOr ;
-   for (int i = 0 ; i < int( vnPLIndMat.size()) ; ++i) {
-      for ( int j = 0 ; j< int( vnPLIndMat[i].size()) ; ++j) {
-         vpCrvOr.emplace_back( vCrvP[vnPLIndMat[i][j]]->Clone()) ;
-         if ( vbInvert[vnPLIndMat[i][j]])
-            vpCrvOr.back()->Invert() ;
-      }
-   }
-
-  // controlo se il vettore di estrusione è orientato come la normale della curva più grande o no
-   bool bOrientedAsExtrusion = false ;
-   Plane3d plPlane ;
-   double dArea ;
-   double dOrthoExtr = 0 ;
-  // verifico che la curva sia chiusa e piatta
-   if ( vPL[0].IsClosedAndFlat(plPlane, dArea, dLinTol)) {
-      dOrthoExtr = plPlane.GetVersN() * vtExtr ;
-     // controllo che ci sia una componente dell'estrusione perpendicolare al piano della curva
-      if ( abs( dOrthoExtr) < EPS_SMALL)
-         return GDB_ID_NULL ;
-      if ( dOrthoExtr > EPS_SMALL)
-         bOrientedAsExtrusion = true ;
-   }
-   else
-      bCapEnds = false ;
-
-  // creo l'estrusione delle curve
-   for ( int i = 0 ; i < int( vpCrvOr.size()) ; ++ i) {
-     // calcolo la superficie
-      ISurfBezier* pSbz = ( bOk ? GetSurfBezierByExtrusion( vpCrvOr[i], vtExtrL, false, dLinTol) : nullptr ) ;
-      if ( ! bOrientedAsExtrusion)
-         pSbz->Invert() ;
-     // inserisco la superficie nel DB
-      int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, pSbz) : GDB_ID_NULL) ;
-      bOk = bOk && ( nNewId != GDB_ID_NULL) ;
-      if ( bOk  &&  nFirstId == GDB_ID_NULL)
-         nFirstId = nNewId ;
-   }
-
-  // se richiesta chiusura agli estremi
-   if ( bCapEnds) {
-      PtrOwner<ISurfBezier> pSrfBzTop( CreateSurfBezier()) ;
-      pSrfBzTop->CreateByRegion( vPL) ;
-      pSrfBzTop->Translate( vtExtrL) ;
-      if ( ! bOrientedAsExtrusion)
-         pSrfBzTop->Invert() ;
-      pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSrfBzTop)) ;
-      PtrOwner<ISurfBezier> pSrfBzBottom( CreateSurfBezier()) ;
-      pSrfBzBottom->CreateByRegion( vPL) ;
-      if ( bOrientedAsExtrusion)
-         pSrfBzBottom->Invert() ;
-      pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSrfBzBottom)) ;
-   }
-
-   ExeSetModified() ;
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtSurfBzByRegionExtrusion(" + IdToString( nParentId) + ",{" +
-                                                    IdListToString( vCrvIds) + "},{" +
-                                                    ToString( vtExtr) + "}," +
-                                                    ( bCapEnds ? "true" : "false") + "," +
-                                                    ToString( dLinTol) + "," +
-                                                    RefTypeToString( nRefType) + ")" +
-                    " -- Id=" + ToString( nFirstId) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-  // restituisco l'identificativo della nuova entità
-   return nFirstId ;
-}
-
-//-------------------------------------------------------------------------------
-int
-ExeCreateSurfBzByScrewing( int nParentId, int nCrvId,
-                           const Point3d& ptAx, const Vector3d& vtAx,
-                           double dAngRotDeg, double dMove, bool bCapEnds, double dLinTol, int nRefType)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
-   nParentId = AdjustId( nParentId) ;
-   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) ;
-   vtAxL.Normalize() ;
-
-  // la curva che fa da sezione alla superficie è chiusa e piana ed è richiesto il capping verifico se la superficie è da invertire
-  // lo screwing non deve essere una semplice rivoluzione
-   bool bOrientedAsScrewing = false ;
-   Plane3d plPlane ;
-   double dArea = 0 ;
-   double dAngTolDeg = 15 ;
-   PolyLine pl ; CrvLoc->ApproxWithLines( dLinTol, dAngTolDeg, ICurve::APL_STD, pl) ;
-   if ( pl.IsClosedAndFlat( plPlane, dArea, dLinTol)  &&  ! (abs(abs(dAngRotDeg) - ANG_FULL) < EPS_SMALL  &&  abs( dMove) < EPS_SMALL)) {
-      double dOrthoMove = plPlane.GetVersN() * vtAxL * dMove ;
-      if( bCapEnds) {
-         // se la curva sta in un piano passante per l'asse allora devo fare qualche conto per capire come è orientata
-         if( abs( dOrthoMove) < EPS_SMALL) {
-         // ruoto il centroide della curva di un minimo angolo e poi controllo se mi sono spostato in verso concorde alla normale al piano della curva
-         Point3d ptCen ; CrvLoc->GetCentroid( ptCen) ;
-         Point3d ptCenRot = ptCen ;
-         ptCenRot.Rotate( ptAxL, vtAxL, 2) ;
-         Vector3d vtRot = ptCenRot - ptCen ;
-         dOrthoMove = vtRot * plPlane.GetVersN() ;
-         }
-
-         if ( dOrthoMove > EPS_SMALL)
-            bOrientedAsScrewing = true ;
-      }
-   }
-   else
-      bCapEnds = false ;
-
-  // calcolo la superficie
-   PtrOwner<ISurfBezier> pSbz( bOk ? GetSurfBezierByScrewing( CrvLoc, ptAxL, vtAxL, dAngRotDeg, dMove, bCapEnds, dLinTol) : nullptr) ;
-   bOk = bOk && ! IsNull( pSbz) ;
-   if ( ! bOrientedAsScrewing  &&  bCapEnds  &&  bOk)
-      pSbz->Invert() ;
-  // inserisco la superficie nel DB
-   int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSbz)) : GDB_ID_NULL) ;
-
-  // se richiesto creo anche i cap
-   if ( bCapEnds  &&  bOk) {
-      ISurfBezier* pSbzBase1 = GetSurfBezierByFlatContour(CrvLoc,dLinTol) ;
-      if ( bOrientedAsScrewing)
-         pSbzBase1->Invert() ;
-      bOk = bOk  &&  pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, pSbzBase1) ;
-      ISurfBezier* pSbzBase2 = GetSurfBezierByFlatContour( CrvLoc,dLinTol) ;
-      pSbzBase2->Translate( vtAxL * dMove) ;
-      pSbzBase2->Rotate( ptAxL, vtAxL, dAngRotDeg) ;
-      if( ! bOrientedAsScrewing)
-         pSbzBase2->Invert() ;
-      bOk = bOk  &&  pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, pSbzBase2) ;
-   }
-   ExeSetModified() ;
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtSurfbzByScrewing(" + IdToString( nParentId) + "," +
-                                             ToString( nCrvId) + ",{" +
-                                             ToString( ptAx) + "},{" +
-                                             ToString( vtAx) + "}," +
-                                             ToString( dAngRotDeg) + "," +
-                                             ToString( dMove) + "," +
-                                             ( 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
-ExeCreateSurfBzByRevolve( int nParentId, int nCrvId,
-                          const Point3d& ptAx, const Vector3d& vtAx,
-                          bool bCapEnds, double dLinTol, int nRefType)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
-   nParentId = AdjustId( nParentId) ;
-   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
-   PtrOwner<ISurfBezier> pSbz (( bOk ? GetSurfBezierByRevolve( CrvLoc, ptAxL, vtAxL, bCapEnds, dLinTol) : nullptr)) ;
-   if( IsNull( pSbz)  ||  ! pSbz->IsValid())
-      return GDB_ID_NULL ;
-   // controllo se devo invertire la superficie
-   Point3d ptStart ; CrvLoc->GetStartPoint( ptStart) ;
-   DistPointLine dplS( ptStart, ptAxL, vtAxL, 1, false) ;
-   double dDistS = 0 ; dplS.GetDist( dDistS) ;
-   bool bStartOnAx = dDistS > EPS_SMALL ;
-   Point3d ptEnd ; CrvLoc->GetEndPoint( ptEnd) ;
-   DistPointLine dplE( ptEnd, ptAxL, vtAxL, 1, false) ;
-   double dDistE = 0 ; dplE.GetDist( dDistE) ;
-   bool bEndOnAx = dDistE > EPS_SMALL ;
-   Vector3d vtDir = ptEnd - ptStart ;
-   double dParallel = vtDir * vtAxL ;
-   if ( dParallel > EPS_SMALL)
-      pSbz->Invert() ;
-
-   // finché non ho le SurfCompo creo qui i cap
-   if ( bCapEnds  &&  bOk) {
-      // calcola il bbox della superficie
-      BBox3d bbox3dSurf ;
-      int nDegU, nDegV, nSpanU, nSpanV ;
-      bool bTrim, bRat ;
-      pSbz->GetInfo( nDegU, nDegV, nSpanU, nSpanV, bTrim, bRat) ;
-      int nPointCount = ( nDegU * nSpanU + 1) * ( nDegV * nSpanV + 1) ;
-      for ( int p = 0 ; p < nPointCount ; ++p) {
-         bool bPointOk = true ;
-         Point3d ptCtrl = pSbz->GetControlPoint( p, &bPointOk) ;
-         bbox3dSurf.Add( ptCtrl) ;
-      }
-     // recupero i loop
-      ICRVCOMPOPOVECTOR vCCLoop ;
-      pSbz->GetLoops( vCCLoop, true) ;
-      // controllo se i loop trovati sono validi
-      bool bValidLoop1 = false ;
-      bool bValidLoop3 = false ;
-      if( ! IsNull(vCCLoop[1])  &&  vCCLoop[1]->IsValid())
-         bValidLoop1 = true ;
-      if( ! IsNull(vCCLoop[3])  &&  vCCLoop[3]->IsValid())
-         bValidLoop3 = true ;
-      
-      if( ! IsNull(vCCLoop[1])  &&  ! vCCLoop[1]->IsValid()  &&  ! bStartOnAx)
-         return GDB_ID_NULL ;
-      if( ! IsNull(vCCLoop[3])  &&  ! vCCLoop[3]->IsValid()  &&  ! bEndOnAx)
-         return GDB_ID_NULL ;
-     // il getLoops per superfici non trimmate restituisce 1 elemento per ogni lato dello spazio parametrico.
-     // in questo caso la superficie è chiusa lungo il parametro V, quindi i lati 0 e 2 saranno null.
-      double dAngTolDeg = 5 ;
-      PolyLine plEdge1 ;
-      if( bValidLoop1)
-         vCCLoop[1]->ApproxWithLines( dLinTol, dAngTolDeg, ICurve::APL_STD, plEdge1) ;
-      PolyLine plEdge3 ;
-      if( bValidLoop3)
-         vCCLoop[3]->ApproxWithLines( dLinTol, dAngTolDeg, ICurve::APL_STD, plEdge3) ;
-
-      // devo distinguere tra il loop superiore e quello inferiore
-      Point3d ptCen ;
-      Vector3d vtN ;
-      Plane3d plPlane ; double dArea ;
-      if( bValidLoop1){
-         bOk = bOk &&  plEdge1.IsClosedAndFlat( plPlane, dArea, 50 * EPS_SMALL) ;
-         vtN = plPlane.GetVersN() ;
-         // vedo come questa normale è orientata rispetto alla bbox della superficie
-         vCCLoop[1]->GetCentroid( ptCen) ;
-         ptCen += vtN ;
-         if ( bbox3dSurf.Encloses( ptCen))
-            plEdge1.Invert() ;
-      }
-      if ( bValidLoop3) {
-         bOk = bOk &&  plEdge3.IsClosedAndFlat( plPlane, dArea, 50 * EPS_SMALL) ;
-         vtN = plPlane.GetVersN() ;
-         // vedo come questa normale è orientata rispetto alla bbox della superficie
-         vCCLoop[3]->GetCentroid( ptCen) ;
-         ptCen += vtN ;
-         if ( bbox3dSurf.Encloses( ptCen))
-            plEdge3.Invert() ;
-      }
-      
-      // creo le superfici e le inserisco nel DB
-      if( bValidLoop1) {
-         PtrOwner<ISurfBezier> pSrfBzCap1( CreateSurfBezier()) ;
-         pSrfBzCap1->CreateByFlatContour( plEdge1) ;
-         pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSrfBzCap1)) ;
-      }
-      if( bValidLoop3) {
-         PtrOwner<ISurfBezier> pSrfBzCap3( CreateSurfBezier()) ;
-         pSrfBzCap3->CreateByFlatContour( plEdge3) ;
-         pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSrfBzCap3)) ;
-      }
-   }
-
-   // inserisco la superficie nel DB
-   int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSbz)) : GDB_ID_NULL) ;
-   ExeSetModified() ;
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtSurfBzByRevolve(" + IdToString( nParentId) + "," +
-                                            ToString( nCrvId) + ",{" +
-                                            ToString( ptAx) + "},{" +
-                                            ToString( 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
-ExeCreateSurfBzRuled( int nParentId, int nCrvId1, int nCrvId2, int nRuledType, bool bCapEnds, double dLinTol)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
-   nParentId = AdjustId( nParentId) ;
-   bool bOk = true ;
-  // recupero il riferimento locale
-   Frame3d frLoc ;
-   bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
-  // recupero le curve in locale
-   CurveLocal CrvLoc1( pGeomDB, nCrvId1, frLoc) ;
-   bOk = bOk && ( CrvLoc1.Get() != nullptr) ;
-   CurveLocal CrvLoc2( pGeomDB, nCrvId2, frLoc) ;
-   bOk = bOk && ( CrvLoc2.Get() != nullptr) ;
-  // calcolo la superficie
-   PtrOwner<ISurfBezier> pSbz( bOk ? GetSurfBezierRuled( CrvLoc1, CrvLoc2, nRuledType, dLinTol) : nullptr) ;
-   bOk = bOk && ! IsNull( pSbz) ;
-  // verifiche per orientamento se con tappi
-   bool bWithCaps = false ;
-   bool bStdOrient = true ;
-   Plane3d plPlane1, plPlane2 ;
-   double dArea1, dArea2 ;
-   if ( bOk  &&  bCapEnds  &&
-        CrvLoc1->IsClosed()  &&  CrvLoc2->IsClosed()  &&  CrvLoc1->GetArea( plPlane1, dArea1)  &&  CrvLoc2->GetArea( plPlane2, dArea2)) {
-      bWithCaps = true ;
-      Point3d ptStart1 ; CrvLoc1->GetStartPoint( ptStart1) ;
-      Point3d ptStart2 ; CrvLoc2->GetStartPoint( ptStart2) ;
-      Vector3d vtRuling = ptStart2 - ptStart1 ;
-      bStdOrient = ( vtRuling * plPlane1.GetVersN() > 0) ;
-      if ( ! bStdOrient)
-         pSbz->Invert() ;
-   }
-   
-  // inserisco la superficie nel DB
-   int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSbz)) : GDB_ID_NULL) ;
-
-  // se richiesto inserisco anche il cap
-   if ( bOk  &&  bWithCaps) {
-     // costruisco la superficie dalla curva 1
-      PtrOwner<ISurfBezier> pSbzFlat1( CreateSurfBezier()) ;
-      double dAngTolDeg = 5 ;
-      PolyLine pl1 ; CrvLoc1->ApproxWithLines(dLinTol, dAngTolDeg, ICurve::APL_STD, pl1) ;
-      pSbzFlat1->CreateByFlatContour( pl1) ;
-      if ( bStdOrient)
-         pSbzFlat1->Invert() ;
-     // inserisco la superficie nel DB
-      bOk = bOk &&  pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSbzFlat1)) ;
-     // costruisco la superficie dalla curva 2
-      PtrOwner<ISurfBezier> pSbzFlat2( CreateSurfBezier()) ;
-      PolyLine pl2 ; CrvLoc2->ApproxWithLines(dLinTol, dAngTolDeg, ICurve::APL_STD, pl2) ;
-      pSbzFlat2->CreateByFlatContour( pl2) ;
-      if ( ! bStdOrient)
-         pSbzFlat2->Invert() ;
-     // inserisco la superficie nel DB
-      bOk = bOk  &&  pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSbzFlat2)) ;
-   }
-   ExeSetModified() ;
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtSurfBzRuled(" + IdToString( nParentId) + "," +
-                                        ToString( nCrvId1) + "," +
-                                        ToString( nCrvId2) + "," +
-                                        ToString( nRuledType) + "," +
-                                        ( bCapEnds ? "true" : "false") + "," +  
-                                        ToString( dLinTol) + ")" +
-                                       " -- Id=" + ToString( nNewId) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-   // restituisco l'identificativo della nuova entità
-   return nNewId ;
-}
-
-//-------------------------------------------------------------------------------
-int
-ExeCreateSurfBzSkinned( int nParentId, const INTVECTOR& vCrvIds, bool bCapEnds, double dLinTol)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
-   nParentId = AdjustId( nParentId) ;
-   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()) ;
-   CICURVEPVECTOR vCrvP ;
-   vCrvP.reserve( vCrvIds.size()) ;
-   for ( size_t i = 0 ; i < vCrvIds.size() ; ++ i) {
-      int nId = vCrvIds[i] ;
-      vCrvLoc.emplace_back( pGeomDB, nId, frLoc) ;
-      vCrvP.push_back( vCrvLoc.back().Get()) ;
-      bOk = bOk && ( vCrvLoc[i].Get() != nullptr) ;
-   }
-
-  // calcolo la superficie
-   PtrOwner<ISurfBezier> pSbz( bOk ? GetSurfBezierSkinned( vCrvP, dLinTol) : nullptr ) ;
-   bOk = bOk && ! IsNull( pSbz) ;
-  // inserisco la superficie nel DB
-   int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSbz)) : GDB_ID_NULL) ;
-   ExeSetModified() ;
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtSurfBzSkinned(" + IdToString( nParentId) + ",{" +
-                                          IdListToString( vCrvIds) + "}," +
-                                          ( bCapEnds ? "true" : "false") + "," +  
-                                          ToString( dLinTol) + ")" +
-                    " -- Id=" + ToString( nNewId) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-  // restituisco l'identificativo della nuova entità
-   return nNewId ;
-}
-
-//-------------------------------------------------------------------------------
-int
-ExeCreateSurfBzSwept( int nParentId, int nSectId, int nGuideId, const Vector3d& vtAx,
-                      bool bCapEnds, double dLinTol, int nRefType)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
-   nParentId = AdjustId( nParentId) ;
-   bool bOk = true ;
-   // recupero il riferimento locale
-   Frame3d frLoc ;
-   bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
-   // recupero le curve in locale
-   CurveLocal CrvSect( pGeomDB, nSectId, frLoc) ;
-   CurveLocal CrvGuide( pGeomDB, nGuideId, frLoc) ;
-   // porto in locale vettore asse
-   Vector3d vtAxL = GetVectorLocal( pGeomDB, vtAx, nRefType, frLoc) ;
-
-   PolyLine plGuide ;
-   double dAngTolDeg = 15 ;
-   CrvGuide->ApproxWithLines( dLinTol, dAngTolDeg, ICurve::APL_STD, plGuide) ;
-   Plane3d plPlane ;
-   bool bFlatGuide = plGuide.IsFlat( plPlane) ;
-   // calcolo la superficie
-   PtrOwner<ISurfBezier> pSbz( CreateSurfBezier()) ;
-   if( bFlatGuide)
-      pSbz.Set( bOk ? GetSurfBezierSweptInPlane( CrvSect, CrvGuide, vtAxL, bCapEnds, dLinTol) : nullptr ) ;
-   else
-      pSbz.Set( bOk ? GetSurfBezierSwept3d( CrvSect, CrvGuide, vtAxL, bCapEnds, dLinTol) : nullptr ) ;
-
-   // se richiesto il capping verifico che la superficie abbia il gisto orientamento
-   bool bOrientedAsGuide = false ;
-   ICRVCOMPOPOVECTOR vCCLoop ;
-   if( bCapEnds) {
-      // controlo se il vettore di start della guida è orientato come la normale della curva o no
-      Vector3d vtStart ; CrvGuide->GetStartDir( vtStart) ;
-      Plane3d plPlane ;
-      double dArea ;
-      double dOrthoGuide = 0 ;
-      // verifico che la curva sia chiusa e piatta
-      PolyLine PL ;
-      CrvSect->ApproxWithLines(dLinTol, dAngTolDeg, ICurve::APL_STD, PL) ;
-      if ( PL.IsClosedAndFlat(plPlane, dArea, dLinTol)) {
-         dOrthoGuide = plPlane.GetVersN() * vtStart ;
-         // controllo che ci sia una componente dell'estrusione perpendicolare al piano della curva
-         if( abs( dOrthoGuide) < EPS_SMALL)
-            return GDB_ID_NULL ;
-         // recupero i loop
-         pSbz->GetLoops( vCCLoop, true) ;
-         // se necessario inverto la superficie
-         if( dOrthoGuide > EPS_SMALL)
-            bOrientedAsGuide = true ;
-         else
-            pSbz->Invert() ;
-      }
-      else
-         bCapEnds = false ;
-   }
-
-
-
-   // inserisco la superficie nel DB
-   int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSbz)) : GDB_ID_NULL) ;
-
-   // se richiesto aggiungo anche i cap
-   if ( bCapEnds) {
-      // controllo se i loop trovati sono validi
-      bool bValidLoop0 = false ;
-      bool bValidLoop2 = false ;
-      if( ! IsNull(vCCLoop[0])  &&  vCCLoop[0]->IsValid())
-         bValidLoop0 = true ;
-      if( ! IsNull(vCCLoop[2])  &&  vCCLoop[2]->IsValid())
-         bValidLoop2 = true ;
-
-      if( ! IsNull(vCCLoop[0])  &&  ! vCCLoop[0]->IsValid())
-         return GDB_ID_NULL ;
-      if( ! IsNull(vCCLoop[2])  &&  ! vCCLoop[2]->IsValid())
-         return GDB_ID_NULL ;
-      // il getLoops per superfici non trimmate restituisce 1 elemento per ogni lato dello spazio parametrico.
-      // in questo caso la superficie è chiusa lungo il parametro V, quindi i lati 1 e 3 saranno null.
-      double dAngTolDeg = 5 ;
-      PolyLine plEdge0 ;
-      if( bValidLoop0)
-         vCCLoop[0]->ApproxWithLines( dLinTol, dAngTolDeg, ICurve::APL_STD, plEdge0) ;
-      PolyLine plEdge2 ;
-      if( bValidLoop2)
-         vCCLoop[2]->ApproxWithLines( dLinTol, dAngTolDeg, ICurve::APL_STD, plEdge2) ;
-
-      PtrOwner<ISurfBezier> pSrfBezStart( CreateSurfBezier()) ;
-      pSrfBezStart->CreateByFlatContour( plEdge2) ;
-     // se necessario inverto
-      if( bOrientedAsGuide)  // edge 2, che è la prima riga della matrice dei punti di controllo è orientato nello stesso verso della curva di sezione
-         pSrfBezStart->Invert() ;
-      // aggiungo al database
-      pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSrfBezStart)) ;
-      PtrOwner<ISurfBezier> pSrfBezEnd( CreateSurfBezier()) ;
-      pSrfBezEnd->CreateByFlatContour( plEdge0) ;
-     // se necessario inverto
-      if( bOrientedAsGuide) // edge 0, che è l'ultima riga della matrice dei punti di controllo è orientato in verso opposto alla curva di sezione
-         pSrfBezEnd->Invert() ;
-      // aggiungo al database
-      pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSrfBezEnd)) ;
-   }
-   ExeSetModified() ;
-   // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtSurfbzByScrewing(" + IdToString( nParentId) + "," +
-                                             IdToString( nSectId) + "," +
-                                             IdToString( nGuideId) + "," +
-                                             ToString( dLinTol) + ")" +
-         " -- Id=" + ToString( nNewId) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-  // restituisco l'identificativo della nuova entità
-   return nNewId ;
-}

EXE_GdbCreateVol.cpp

@@ -1,4 +1,4 @@
-//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
 //  EgalTech 2016-2016
 //----------------------------------------------------------------------------
 // File : EXE_GdbCreateVol.cpp       Data : 27.10.16       Versione : 1.6v7
@@ -53,7 +53,7 @@ ExeCreateVolZmap( int nParentId, const Point3d& ptIni, double dDimX, double dDim
    ExeSetModified() ;
   // se richiesto, salvo il comando Lua equivalente
    if ( IsCmdLog()) {
-      string sLua = "EgtVolZmapBox(" + IdToString( nParentId) + ",{" +
+      string sLua = "EgtVolZmapEmpty(" + IdToString( nParentId) + ",{" +
                                        ToString( ptIni) + "}," +
                                        ToString( dDimX) + "," +
                                        ToString( dDimY) + "," +
@@ -64,7 +64,7 @@ ExeCreateVolZmap( int nParentId, const Point3d& ptIni, double dDimX, double dDim
                     " -- Id=" + ToString( nNewId) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
    }
-  // restituisco l'identificativo della nuova entità
+  // restituisco l'identificativo della nuova entità
    return nNewId ;
 }
 
@@ -88,7 +88,7 @@ int ExeCreateVolZmapEmpty( int nParentId, const Point3d& ptIni, double dDimX, do
   // creo lo Zmap nel suo riferimento intrinseco
    PtrOwner<IVolZmap> pVZM( CreateVolZmap()) ;
    bOk = bOk && ! IsNull( pVZM) ;
-   bOk = bOk && pVZM->CreateEmpty( ORIG, dDimX, dDimY, dDimZ, dPrec, bTriDex) ;
+   bOk = bOk && pVZM->CreateEmptyMap( ORIG, dDimX, dDimY, dDimZ, dPrec, bTriDex) ;
   // lo porto nel riferimento locale
    bOk = bOk && pVZM->ToGlob( frBox) ;
   // inserisco lo Zmap nel DB
@@ -107,7 +107,7 @@ int ExeCreateVolZmapEmpty( int nParentId, const Point3d& ptIni, double dDimX, do
                     " -- Id=" + ToString( nNewId) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
    }
-  // restituisco l'identificativo della nuova entità
+  // restituisco l'identificativo della nuova entità
    return nNewId ;
 }
 
@@ -146,7 +146,7 @@ ExeCreateVolZmapByRegionExtrusion( int nParentId, int nSfrId, double dDimZ, doub
                     " -- Id=" + ToString( nNewId) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
    }
-  // restituisco l'identificativo della nuova entità
+  // restituisco l'identificativo della nuova entità
    return nNewId ;
 }
 
@@ -161,8 +161,8 @@ ExeCreateVolZmapFromSurfTm( int nParentId, int nStmId, double dPrec, bool bTriDe
    const ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nStmId)) ;
    bool bOk = ( pStm != nullptr) ;
   // recupero il riferimento della trimesh
-   Frame3d frStm ;
-   bOk = bOk && pGeomDB->GetGlobFrame( nStmId, frStm) ;
+   //Frame3d frStm ;
+   //bOk = bOk && pGeomDB->GetGlobFrame( nStmId, frStm) ;
   // recupero il riferimento del gruppo di destinazione
    Frame3d frDest ;
    bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frDest) ;
@@ -171,73 +171,61 @@ ExeCreateVolZmapFromSurfTm( int nParentId, int nStmId, double dPrec, bool bTriDe
    bOk = bOk && ! IsNull( pVZM) ;
    bOk = bOk && pVZM->CreateFromTriMesh( *pStm, dPrec, bTriDex) ;
   // lo porto nel riferimento di destinazione
-   bOk = bOk && pVZM->LocToLoc( frStm, frDest) ;
+   //bOk = bOk && pVZM->LocToLoc( frStm, frDest) ;
   // inserisco lo Zmap nel DB
    int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pVZM)) : GDB_ID_NULL) ;
    ExeSetModified() ;
   // se richiesto, salvo il comando Lua equivalente
    if ( IsCmdLog()) {
-      string sLua = "EgtVolZmapFromTriMesh(" + IdToString( nParentId) + "," +
-                                               ToString( nStmId) + "," +
-                                               ToString( dPrec) + "," +
-                                               ( bTriDex ? "true" : "false") + ")" +
+      string sLua = "UpdateVolZmapByAddingSurfTm(" + IdToString( nParentId) + "," +
+                                                   IdToString( nStmId) + "," +
+                                                   ToString( nStmId) + "," +
+                                                   ToString( dPrec) + "," +
+                                                   ( bTriDex ? "true" : "false") + ")" +
                     " -- Id=" + ToString( nNewId) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
    }
-  // restituisco l'identificativo della nuova entità
+  // restituisco l'identificativo della nuova entità
    return nNewId ;
 }
 
 //-------------------------------------------------------------------------------
 bool
-ExeUpdateVolZmapByAddingSurfTm( int nVolZmapId, int nStmId)
+ExeUpdateVolZmapByAddingSurfTm( int nParentId, int nZmapId, int nStmId)
 {
    IGeomDB* pGeomDB = GetCurrGeomDB() ;
    VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
+   nParentId = AdjustId( nParentId) ;
   // recupero lo Zmap
-   IVolZmap* pVZM = GetVolZmap( pGeomDB->GetGeoObj( nVolZmapId)) ;
-   bool bOk = ( pVZM != nullptr) ;
+   IVolZmap* pVolZmap = GetVolZmap( pGeomDB->GetGeoObj( nZmapId)) ;
+   bool bOk = pVolZmap != nullptr ;
+  // recupero il riferimento dello Zmap
+   Frame3d frZmap ;
+   bOk = bOk && pGeomDB->GetGlobFrame( nZmapId, frZmap) ;
   // recupero la trimesh
    PtrOwner<ISurfTriMesh> pStm( CloneSurfTriMesh( pGeomDB->GetGeoObj( nStmId))) ;
-   bOk = bOk && !IsNull( pStm) ;
-  // recupero il frame dello Zmap e della Trimesh
-   Frame3d frZmap, frStm ;
-   bOk = bOk && pGeomDB->GetGlobFrame( nVolZmapId, frZmap) &&
-                pGeomDB->GetGlobFrame( nStmId, frStm) ;
-  // porto la Stm nel frame dello Zmap
-   bOk = bOk && pStm->LocToLoc( frStm, frZmap) ;
-  // aggiorno lo Zmap con la nuova superficie
-   bOk = bOk && pVZM->AddSurfTm( pStm) ;
-   ExeSetModified() ;
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtUpdateVolZmapByAddingSurfTm(" + ToString( nVolZmapId) + "," +
-                                                        ToString( nStmId) + ")"
-                    " -- bOk =" + ToString( bOk) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-   return bOk ;
-}
-
-//-------------------------------------------------------------------------------
-bool
-ExeUniformVolZmap( int nVolZmapId, double dToler)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
-  // recupero lo Zmap
-   IVolZmap* pVZM = GetVolZmap( pGeomDB->GetGeoObj( nVolZmapId)) ;
-   bool bOk = ( pVZM != nullptr) ;
+   bOk = bOk && ( pStm != nullptr) ;
+  // recupero il riferimento della trimesh
+   Frame3d frStm ;
+   bOk = bOk && pGeomDB->GetGlobFrame( nStmId, frStm) ;
+  // recupero il riferimento del gruppo di destinazione
+   Frame3d frDest ;
+   bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frDest) ;
+  // porto lo Zmap e la trimesh nel riferimento della destinazione
+   bOk = bOk && 
+         pVolZmap->LocToLoc( frZmap, frDest) &&
+         pStm->LocToLoc( frStm, frDest) ;
   // aggiorno lo Zmap
-   dToler = max( dToler, EPS_SMALL) ;
-   bOk = bOk && pVZM->MakeUniform( dToler) ;
+   bOk = bOk &&  pVolZmap->AddSrfTm( pStm) ;
+  // riporto lo Zmap nel frame originario
+   bOk = bOk &&  pVolZmap->LocToLoc( frDest, frStm) ;
    ExeSetModified() ;
   // se richiesto, salvo il comando Lua equivalente
    if ( IsCmdLog()) {
-      string sLua = "EgtUniformZmap(" + ToString( nVolZmapId) + "," +
-                                        ToString( dToler) + ")"
-                    " -- bOk =" + ToString( bOk) ;
+      string sLua = "EgtVolZmapFromTriMesh(" + IdToString( nParentId) + "," +
+                                               ToString( nStmId) + ")" ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
    }
+  // restituisco l'identificativo della nuova entità
    return bOk ;
 }

EXE_GdbGetCurve.cpp

@@ -17,11 +17,8 @@
 #include "EXE_Const.h"
 #include "EXE_Macro.h"
 #include "GeoTools.h"
-#include "/EgtDev/Include/EgtNumUtils.h"
 #include "/EgtDev/Include/EXeExecutor.h"
 #include "/EgtDev/Include/EXeConst.h"
-#include "/EgtDev/Include/EGkGeoPoint3d.h"
-#include "/EgtDev/Include/EGkGeoPoint3d.h"
 #include "/EgtDev/Include/EGkCurve.h"
 #include "/EgtDev/Include/EGkCurveArc.h"
 #include "/EgtDev/Include/EGkCurveBezier.h"
@@ -61,21 +58,6 @@ ExeCurveLength( int nId, double* pdLen)
    return ( pCurve != nullptr  &&  pCurve->GetLength( *pdLen)) ;
 }
 
-//----------------------------------------------------------------------------
-bool
-ExeCurveLengthAtParam( int nId, double dPar, double* pdLen)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-  // verifico il parametro
-   if ( pdLen == nullptr)
-      return false ;
-  // recupero la curva
-   ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
-  // recupero la lunghezza
-   return ( pCurve != nullptr  &&  pCurve->GetLengthAtParam( dPar, *pdLen)) ;
-}
-
 //----------------------------------------------------------------------------
 bool
 ExeCurveParamAtLength( int nId, double dLen, double* pdPar)
@@ -179,7 +161,7 @@ ExeCurveIsFlat( int nId, Plane3d& Plane, bool bUseExtrusion, double dToler)
       return false ;
   // recupero la curva
    ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
-  // ne verifico la planarit�
+  // ne verifico la planarità
    return ( pCurve != nullptr  &&  pCurve->IsFlat( Plane, bUseExtrusion, dToler)) ;
 }
 
@@ -224,8 +206,6 @@ ExeCurveIsACircle( int nId, Point3d& ptCen, Vector3d& vtN, double& dRad, bool& b
            return false ;
         return pCompo->IsACircle( dToler, ptCen, vtN, dRad, bCCW) ;
       }
-   default :
-      return false ;
    }
 
    return false ;
@@ -311,7 +291,7 @@ ExeCurveNearestExtremityToPoint( int nId, const Point3d& ptP, bool& bStart)
    VERIFY_GEOMDB( pGeomDB, false)
   // recupero la curva
    ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
-  // recupero quale estremo � pi� vicino al punto
+  // recupero quale estremo è più vicino al punto
    return ( pCurve != nullptr  &&  pCurve->GetNearestExtremityToPoint( ptP, bStart)) ;
 }
 
@@ -387,7 +367,7 @@ ExeCurveMinAreaRectangleXY( int nId, int nRefId, Frame3d& frRect, double& dDimX,
       PL.LocToLoc( frCrv, pGeomDB->GetGridFrame()) ;
    else if ( bOk  &&  nRefId != nId) {
       Frame3d frDest ;
-     // nRefId pu� essere un gruppo o una entit�
+     // nRefId può essere un gruppo o una entità
       if ( pGeomDB->GetGroupGlobFrame( nRefId, frDest)  ||
            pGeomDB->GetGlobFrame( nRefId, frDest))
          PL.LocToLoc( frCrv, frDest) ;
@@ -635,9 +615,6 @@ ExeCurveCompoRadius( int nId, int nSimpCrv, double& dRad)
    case CRV_BEZIER :
       dRad = -2 ;
       break ;
-   default :
-      dRad = -3 ;
-      break ;
    }
    return true ;
 }
@@ -667,9 +644,6 @@ ExeCurveCompoAngCenter( int nId, int nSimpCrv, double& dAngCen)
    case CRV_BEZIER :
       dAngCen = 0 ;
       break ;
-   default :
-      dAngCen = 0 ;
-      break ;
    }
    return true ;
 }
@@ -699,211 +673,7 @@ ExeCurveCompoNormVersor( int nId, int nSimpCrv, int nRefId, Vector3d& vtNorm)
    case CRV_BEZIER :
       vtNorm = V_NULL ;
       break ;
-   default :
-      vtNorm = V_NULL ;
-      break ;
    }
   // gestione trasformazione ( eventuale)
    return TransformVector( pGeomDB, nId, nRefId, vtNorm) ;
 }
-
-//----------------------------------------------------------------------------
-bool
-ExeCurveCompoGetTempProp( int nId, INTVECTOR& vProp, int nPropInd) 
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-  // recupero la curva composita
-   const ICurveComposite* pCompo = GetCurveComposite( pGeomDB->GetGeoObj( nId)) ;
-   if ( pCompo == nullptr)
-      return false ;
-  // recupero i valori
-   vProp.clear() ;
-   vProp.reserve( pCompo->GetCurveCount()) ;
-   const ICurve* pSmplCrv = pCompo->GetFirstCurve() ;
-   while ( pSmplCrv != nullptr) {
-      vProp.push_back( pSmplCrv->GetTempProp( nPropInd)) ;
-      pSmplCrv = pCompo->GetNextCurve() ;
-   }
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool
-ExeCurveCompoGetTempParam( int nId, DBLVECTOR& vParam, int nParamInd) 
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-  // recupero la curva composita
-   const ICurveComposite* pCompo = GetCurveComposite( pGeomDB->GetGeoObj( nId)) ;
-   if ( pCompo == nullptr)
-      return false ;
-  // recupero i valori
-   vParam.clear() ;
-   vParam.reserve( pCompo->GetCurveCount()) ;
-   const ICurve* pSmplCrv = pCompo->GetFirstCurve() ;
-   while ( pSmplCrv != nullptr) {
-      vParam.push_back( pSmplCrv->GetTempParam( nParamInd)) ;
-      pSmplCrv = pCompo->GetNextCurve() ;
-   }
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-int
-ExeShowCurveBezierControlPoints( int nCrvId, int nDestGrpId, int* pnCount)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-   // recupero la curva di bezier
-   IGeoObj* pGeoObj = pGeomDB->GetGeoObj( nCrvId) ;
-   if ( pGeoObj->GetType() != CRV_BEZIER  &&  pGeoObj->GetType() != CRV_COMPO)
-      return GDB_ID_NULL ;
-   // recupero il riferimento della curva
-   Frame3d frCrv ;
-   bool bOk = true ;
-   bOk = bOk && pGeomDB->GetGlobFrame( nCrvId, frCrv) ;
-   // recupero il riferimento di destinazione
-   Frame3d frDest ;
-   bOk = bOk && pGeomDB->GetGroupGlobFrame( nDestGrpId, frDest) ;
-   if ( ! bOk)
-      return GDB_ID_NULL ;
-   int nType = pGeoObj->GetType() ;
-   if ( nType == CRV_COMPO) {
-      const ICurveComposite* pCrvCompo = GetCurveComposite( pGeoObj) ;
-      if ( pCrvCompo == nullptr)
-         return false ;
-      int nFirstId = -1 ;
-      int nCount = 0 ;
-      for ( int i = 0 ; i < pCrvCompo->GetCurveCount() ; ++i) {
-         const ICurveBezier* pCrvBezier = GetCurveBezier( pCrvCompo->GetCurve(i)) ;
-         if ( pCrvBezier == nullptr) {
-            if ( pnCount != nullptr)
-               *pnCount = nCount ;
-            return nFirstId ;
-         }
-         int nDeg = pCrvBezier->GetDegree() ;
-         //bool bRat = pCrvBezier->IsRational() ;
-         for ( int i = 0 ; i < nDeg + 1 ; ++i) {
-            IGeoPoint3d* pGeoPt( CreateGeoPoint3d()) ;
-            //if ( ! bRat)
-            //   pGeoPt->Set( pCrvBezier->GetControlPoint( i)) ;
-            //else
-            //   pGeoPt->Set( pCrvBezier->GetControlPoint( i) * pCrvBezier->GetControlWeight( i)) ;
-            pGeoPt->Set( pCrvBezier->GetControlPoint( i)) ;
-            pGeoPt->LocToLoc( frCrv, frDest) ;
-            int nId = pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, pGeoPt) ;
-            if ( nFirstId == GDB_ID_NULL)
-               nFirstId = nId ;
-            if ( nId != GDB_ID_NULL)
-               ++nCount ;
-         }
-      }
-      // restituisco i risultati
-      if ( pnCount != nullptr)
-         *pnCount = nCount ;
-      return nFirstId ;
-   }
-   else if ( nType == CRV_BEZIER) {
-      const ICurveBezier* pCrvBezier = GetCurveBezier( pGeoObj) ;
-      if ( pCrvBezier == nullptr)
-         return false ;
-      int nDeg = pCrvBezier->GetDegree() ;
-      //bool bRat = pCrvBezier->IsRational() ;
-      int nFirstId = -1 ;
-      int nCount = 0 ;
-      for ( int i = 0 ; i < nDeg + 1 ; ++i) {
-         IGeoPoint3d* pGeoPt( CreateGeoPoint3d()) ;
-         //if ( ! bRat)
-         //   pGeoPt->Set( pCrvBezier->GetControlPoint( i)) ;
-         //else
-         //   pGeoPt->Set( pCrvBezier->GetControlPoint( i) * pCrvBezier->GetControlWeight( i)) ;
-         pGeoPt->Set( pCrvBezier->GetControlPoint( i)) ;
-         pGeoPt->LocToLoc( frCrv, frDest) ;
-         int nId = pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, pGeoPt) ;
-         if ( nFirstId == GDB_ID_NULL)
-            nFirstId = nId ;
-         if ( nId != GDB_ID_NULL)
-            ++nCount ;
-      }
-      // restituisco i risultati
-      if ( pnCount != nullptr)
-         *pnCount = nCount ;
-      return nFirstId ;
-   }
-   else
-      return GDB_ID_NULL ;
-}
-
-//----------------------------------------------------------------------------
-bool
-ExeCurveMaxOffset( int nId, double& dMaxOffset)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-   // verifico il parametro
-   if ( &dMaxOffset == nullptr)
-      return false ;
-   // recupero la curva
-   const ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( nId)) ;
-   return CalcCurveLimitOffset( *pCrv, dMaxOffset) ;
-}
-
-//----------------------------------------------------------------------------
-int
-ExeCopyCompoSubCurve( int nCrvId, int nSubCrvToCopy, int nDestGrpId)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-   // recupero la curva compo
-   const ICurveComposite* pCompo = GetCurveComposite( pGeomDB->GetGeoObj( nCrvId)) ;
-   if ( pCompo == nullptr)
-      return GDB_ID_NULL ;
-   // recupero il riferimento della curva
-   Frame3d frCrv ;
-   bool bOk = true ;
-   bOk = bOk && pGeomDB->GetGlobFrame( nCrvId, frCrv) ;
-   // recupero il riferimento di destinazione
-   Frame3d frDest ;
-   bOk = bOk && pGeomDB->GetGroupGlobFrame( nDestGrpId, frDest) ;
-   if ( ! bOk)
-      return GDB_ID_NULL ;
-
-   int nSubCrvs = pCompo->GetCurveCount() ;
-   if ( nSubCrvToCopy > nSubCrvs - 1)
-      return GDB_ID_NULL ;
-
-   // creo una copia e la porto nel frame della destinazione
-   const ICurve* pSubCrv = pCompo->GetCurve( nSubCrvToCopy) ;
-   ICurve* pSubCrvCopy = pSubCrv->Clone() ;
-   pSubCrvCopy->LocToLoc( frCrv, frDest) ;
-   int nSubCrvId = pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, pSubCrvCopy) ;
-   
-   return nSubCrvId ;
-}
-
-//----------------------------------------------------------------------------
-int
-ExeCopyParamRange( int nCrvId, double dUStart, double dUEnd, int nDestGrpId)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-   // recupero la curva
-   const ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( nCrvId)) ;
-   // recupero il riferimento della curva
-   Frame3d frCrv ;
-   bool bOk = true ;
-   bOk = bOk && pGeomDB->GetGlobFrame( nCrvId, frCrv) ;
-   // recupero il riferimento di destinazione
-   Frame3d frDest ;
-   bOk = bOk && pGeomDB->GetGroupGlobFrame( nDestGrpId, frDest) ;
-   if ( ! bOk)
-      return GDB_ID_NULL ;
-
-   // creo una copia e la porto nel frame della destinazione
-   ICurve* pSubCrvCopy = pCrv->CopyParamRange( dUStart, dUEnd) ;
-   pSubCrvCopy->LocToLoc( frCrv, frDest) ;
-   int nSubCrvId = pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, pSubCrvCopy) ;
-
-   return nSubCrvId ;
-}

EXE_GdbGetPocketing.cpp

@@ -59,7 +59,7 @@ ExePocketing( const int nId, double dRad, double dStep, double dAngle, int nType
 
   // eseguo Pocketing
    ICRVCOMPOPOVECTOR vCrvCompoRes ;
-   bool bOk = CalcPocketing( pSfr, dRad, 0, dStep, dAngle, 5., nType, bSmooth, false, false, false, true, P_INVALID, nullptr, false, vCrvCompoRes) ;
+   bool bOk = CalcPocketing( pSfr, dRad, dStep, dAngle, nType, bSmooth, vCrvCompoRes) ;
    nFirstId = GDB_ID_NULL ;
    nCrvCount = int( vCrvCompoRes.size()) ;
    if ( bOk  &&  nCrvCount > 0) {

EXE_GdbGetSurf.cpp

@@ -29,12 +29,10 @@
 #include "/EgtDev/Include/EGkSurfFlatRegion.h"
 #include "/EgtDev/Include/EGkSurfTriMesh.h"
 #include "/EgtDev/Include/EGkSurfBezier.h"
-#include "/EgtDev/Include/EGkDistPointSurfFr.h"
 #include "/EgtDev/Include/EGkDistPointSurfTm.h"
 #include "/EgtDev/Include/EGkIntersCurves.h"
 #include "/EgtDev/Include/EGkIntersLineBox.h"
 #include "/EgtDev/Include/EGkIntersLineSurfTm.h"
-#include "/EgtDev/Include/EGkCAvSilhouetteSurfTm.h"
 #include "/EgtDev/Include/EGkCalcPocketing.h"
 #include "/EgtDev/Include/EGkPolygonElevation.h"
 #include "/EgtDev/Include/EGkSurfLocal.h"
@@ -65,7 +63,7 @@ ExeSurfIsClosed( int nId)
    VERIFY_GEOMDB( pGeomDB, false)
   // recupero la superficie
    ISurf* pSurf = GetSurf( pGeomDB->GetGeoObj( nId)) ;
-  // verifico se è superficie chiusa
+  // verifico se è superficie chiusa
    return ( pSurf != nullptr  &&  pSurf->IsClosed()) ;
 }
 
@@ -80,7 +78,7 @@ ExeSurfVolume( int nId, double& dVol)
       return false ;
   // recupero la superficie
    ISurf* pSurf = GetSurf( pGeomDB->GetGeoObj( nId)) ;
-  // ne restituisco l'eventuale volume (se è chiusa)
+  // ne restituisco l'eventuale volume (se è chiusa)
    return ( pSurf != nullptr  &&  pSurf->GetVolume( dVol)) ;
 }
 
@@ -120,26 +118,24 @@ bool
 ExeSurfFrTestExternal( int nId1, int nId2, double dMinDist)
 {
    IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
+   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
   // recupero la prima superficie FlatRegion
-   const ISurfFlatRegion* pSfr1 = GetSurfFlatRegion( pGeomDB->GetGeoObj( nId1)) ;
+   ISurfFlatRegion* pSfr1 = GetSurfFlatRegion( pGeomDB->GetGeoObj( nId1)) ;
    if ( pSfr1 == nullptr)
       return false ;
   // se richiesta distanza di sicurezza, ne faccio l'offset
-   PtrOwner<ISurfFlatRegion> pSfr1O ;
-   if ( abs( dMinDist) > 5 * EPS_SMALL) {
-      pSfr1O.Set( pSfr1->Clone()) ;
-      if ( IsNull( pSfr1O)  ||  ! pSfr1O->Offset( dMinDist, ICurve::OFF_FILLET))
-         return false ;
-      pSfr1 = Get( pSfr1O) ;
-   }
+   PtrOwner<ISurfFlatRegion> pSfr1O( pSfr1->Clone()) ;
+   if ( IsNull( pSfr1O))
+      return false ;
+   if ( dMinDist > 10 * EPS_SMALL)
+      pSfr1O->Offset( dMinDist, ICurve::OFF_FILLET) ;
   // recupero il riferimento della superficie
    Frame3d frSurf1 ;
    if ( ! pGeomDB->GetGlobFrame( nId1, frSurf1))
       return false ;
-  // recupero il tipo della seconda entità
+  // recupero il tipo della seconda entità
    int nType2 = pGeomDB->GetGeoType( nId2) ;
-  // se seconda entità regione
+  // se seconda entità regione
    if ( nType2 == SRF_FLATRGN) {
      // recupero la seconda superficie FlatRegion in locale alla prima
       SurfLocal Surf2Loc( pGeomDB, nId2, frSurf1) ;
@@ -147,9 +143,9 @@ ExeSurfFrTestExternal( int nId1, int nId2, double dMinDist)
       if ( pSfr2L == nullptr)
          return false ;
      // eseguo il test di intersezione tra le due regioni
-      for ( int i = 0 ; i < pSfr1->GetChunkCount() ; ++ i) {
+      for ( int i = 0 ; i < pSfr1O->GetChunkCount() ; ++ i) {
          for ( int j = 0 ; j < pSfr2L->GetChunkCount() ; ++ j) {
-            if ( pSfr1->GetChunkSimpleClassification( i, *pSfr2L, j) != REGC_OUT)
+            if ( pSfr1O->GetChunkSimpleClassification( i, *pSfr2L, j) != REGC_OUT)
                return false ;
          }
       }
@@ -163,8 +159,8 @@ ExeSurfFrTestExternal( int nId1, int nId2, double dMinDist)
       if ( pCrv2L == nullptr)
          return false ;
      // eseguo il test di intersezione tra regione e curva
-      for ( int i = 0 ; i < pSfr1->GetChunkCount() ; ++ i) {
-         PtrOwner<ICurve> pCrv1( pSfr1->GetLoop( i, 0)) ;
+      for ( int i = 0 ; i < pSfr1O->GetChunkCount() ; ++ i) {
+         PtrOwner<ICurve> pCrv1( pSfr1O->GetLoop( i, 0)) ;
          if ( pCrv1 == nullptr)
             return false ;
          IntersCurveCurve ccInt( *pCrv1, *pCrv2L) ;
@@ -172,8 +168,7 @@ ExeSurfFrTestExternal( int nId1, int nId2, double dMinDist)
          if ( ! ccInt.GetCurveClassification( 1, EPS_SMALL, vcClass)  ||  vcClass.empty())
             return false ;
          for ( auto& cClass : vcClass) {
-            if ( cClass.nClass == CRVC_IN  ||  cClass.nClass == CRVC_ON_M  ||
-                 cClass.nClass == CRVC_ON_P  ||  cClass.nClass == CRVC_NULL)
+            if ( cClass.nClass == CRVC_IN  ||  cClass.nClass == CRVC_NULL)
                return false ;
          }
       }
@@ -183,17 +178,34 @@ ExeSurfFrTestExternal( int nId1, int nId2, double dMinDist)
    else if ( nType2 == GEO_PNT3D) {
      // recupero il punto
       IGeoPoint3d* pGeoPt = GetGeoPoint3d( pGeomDB->GetGeoObj( nId2)) ;      
-      Point3d ptP = pGeoPt->GetPoint() ;
+      Point3d pt = pGeoPt->GetPoint() ;
      // porto il punto in locale
       Frame3d frPt ;
       if ( ! pGeomDB->GetGlobFrame( nId2, frPt))
          return false ;
-      ptP.LocToLoc( frPt, frSurf1) ;
-     // determino se interno (comprende la frontiera)
-      bool bInside ;
-      if ( ! IsPointInsideSurfFr( ptP, pSfr1, 0, bInside))
-         return false ;
-      return ( ! bInside) ;
+      pt.LocToLoc( frPt, frSurf1) ;
+     
+      for ( int i = 0 ; i < pSfr1O->GetChunkCount() ; i ++) {
+        // verifico se è contenuto nel loop esterno
+         PtrOwner<ICurve> pCrv( pSfr1O->GetLoop( i, 0)) ;
+         PolyLine PL ;
+         pCrv->ApproxWithLines( 10 * EPS_SMALL, 15, ICurve::APL_STD, PL) ;
+         if ( IsPointInsidePolyLine( pt, PL, EPS_SMALL)) {
+            bool bInsideHole = false ;
+           // verifico se è contenuto in un loop interno
+            for ( int j = 1 ; j < pSfr1O->GetLoopCount( i) ; j ++) {
+               PtrOwner<ICurve> pCrv( pSfr1O->GetLoop( i, j)) ;
+               pCrv->ApproxWithLines( 10 * EPS_SMALL, 15, ICurve::APL_STD, PL) ;
+               PL.Invert() ;
+               if ( IsPointInsidePolyLine( pt, PL, EPS_SMALL))
+                  bInsideHole = true ;
+            }
+           // se è contenuto nel loop esterno ma non è contenuto in nessuno dei loop interni allora il punto è interno
+            if ( ! bInsideHole)
+               return false ;
+         }         
+      }
+      return true ;
    }
   // altrimenti non valida
    else
@@ -214,20 +226,6 @@ ExeSurfFrChunkCount( int nId)
    return pSfr->GetChunkCount() ;
 }
 
-//----------------------------------------------------------------------------
-bool
-ExeSurfFrChunkMaxOffset( int nId, int nChunk, double& dMaxOffset)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-  // verifico il parametro
-   if ( &dMaxOffset == nullptr)
-      return false ;
-  // recupero la Regione
-   const ISurfFlatRegion* pSfr = GetSurfFlatRegion( pGeomDB->GetGeoObj( nId)) ;
-   return ( pSfr != nullptr  &&  pSfr->GetChunkMaxOffset( nChunk, dMaxOffset)) ;
-}
-
 //----------------------------------------------------------------------------
 int
 ExeSurfFrChunkSimpleClassify( int nId1, int nChunk1, int nId2, int nChunk2, double dToler)
@@ -261,25 +259,6 @@ ExeSurfFrChunkSimpleClassify( int nId1, int nChunk1, int nId2, int nChunk2, doub
    return nRes ;
 }
 
-//----------------------------------------------------------------------------
-bool
-ExeSurfFrChunkCenter( int nId, int nChunk, int nRefId, Point3d& ptCen, Vector3d& vtN)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-  // recupero la superficie FlatRegion
-   ISurfFlatRegion* pSfr = GetSurfFlatRegion( pGeomDB->GetGeoObj( nId)) ;
-   if ( pSfr == nullptr)
-      return false ;
-  // recupero il centro della parte
-   if ( ! pSfr->GetChunkCentroid( nChunk, ptCen))
-      return false ;
-  // recupero la normale della regione
-   vtN = pSfr->GetNormVersor() ;
-  // gestione trasformazioni ( eventuali)
-   return TransformPoint( pGeomDB, nId, nRefId, ptCen) && TransformVector( pGeomDB, nId, nRefId, vtN) ;
-}
-
 //----------------------------------------------------------------------------
 int
 ExeExtractSurfFrChunkLoops( int nId, int nChunk, int nDestGrpId, int* pnCount)
@@ -401,11 +380,11 @@ ExeSurfTmGetNearestVertex( int nId, const Point3d& ptNear, int nRefId, int& nVer
    const ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
    if ( pStm == nullptr)
       return false ;
-  // porto il punto Near nel riferimento dell'entità
+  // porto il punto Near nel riferimento dell'entità
    Point3d ptNearL = ptNear ;
    if ( ! InvTransformPoint( pGeomDB, nId, nRefId, ptNearL))
       return false ;
-  // recupero il vertice più vicino della superficie
+  // recupero il vertice più vicino della superficie
    nVert = GetSurfTmNearestVertex( ptNearL, *pStm) ;
    if ( ! pStm->GetVertex( nVert, ptVert))
       return false ;
@@ -413,26 +392,6 @@ ExeSurfTmGetNearestVertex( int nId, const Point3d& ptNear, int nRefId, int& nVer
    return TransformPoint( pGeomDB, nId, nRefId, ptVert) ;
 }
 
-//----------------------------------------------------------------------------
-bool
-ExeSurfTmTriangleNormVersor( int nId, int nTria, int nRefId, Vector3d& vtNorm)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-  // recupero la superficie trimesh
-   const ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
-   if ( pStm == nullptr)
-      return false ;
-  // recupero il triangolo
-   Triangle3d Tria ;
-   if ( ! pStm->GetTriangle( nTria, Tria))
-      return false ;
-  // assegno la normale
-   vtNorm = Tria.GetN() ;
-  // gestione trasformazione ( eventuale)
-   return TransformVector( pGeomDB, nId, nRefId, vtNorm) ;
-}
-
 //----------------------------------------------------------------------------
 int
 ExeSurfTmFacetFromTria( int nId, int nT)
@@ -472,11 +431,11 @@ ExeSurfTmFacetNearestEndPoint( int nId, int nFacet, const Point3d& ptNear, int n
    const ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
    if ( pStm == nullptr)
       return false ;
-  // porto il punto Near nel riferimento dell'entità
+  // porto il punto Near nel riferimento dell'entità
    Point3d ptNearL = ptNear ;
    if ( ! InvTransformPoint( pGeomDB, nId, nRefId, ptNearL))
       return false ;
-  // recupero il punto End più vicino della faccia
+  // recupero il punto End più vicino della faccia
    if ( ! pStm->GetFacetNearestEndPoint( nFacet, ptNearL, ptEnd, vtN))
       return false ;
   // gestione trasformazioni ( eventuali)
@@ -494,11 +453,11 @@ ExeSurfTmFacetNearestMidPoint( int nId, int nFacet, const Point3d& ptNear, int n
    const ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
    if ( pStm == nullptr)
       return false ;
-  // porto il punto Near nel riferimento dell'entità
+  // porto il punto Near nel riferimento dell'entità
    Point3d ptNearL = ptNear ;
    if ( ! InvTransformPoint( pGeomDB, nId, nRefId, ptNearL))
       return false ;
-  // recupero il punto Mid più vicino della faccia
+  // recupero il punto Mid più vicino della faccia
    if ( ! pStm->GetFacetNearestMidPoint( nFacet, ptNearL, ptMid, vtN))
       return false ;
   // gestione trasformazioni ( eventuali)
@@ -596,7 +555,7 @@ ExeSurfTmFacetElevationInBBox( int nId, int nFacet, const BBox3d& b3Box, bool bA
    else if ( nRefId == GDB_ID_GRID)
       frBox = pGeomDB->GetGridFrame() ;
    else {
-     // nRefId può essere un gruppo o una entità
+     // nRefId può essere un gruppo o una entità
       if ( ! pGeomDB->GetGroupGlobFrame( nRefId, frBox)  &&
            ! pGeomDB->GetGlobFrame( nRefId, frBox))
          return false ;
@@ -704,7 +663,7 @@ ExeSurfTmFacetOppositeSideEx( int nId, int nFacet, const Vector3d& vtDir, int nR
    pCrvCompo->ToLoc( frSpec) ;
   // ne faccio una copia per usi successivi
    PtrOwner<ICurveComposite> pCrvCopy( pCrvCompo->Clone()) ;
-  // la direzione di riferimento è l'asse X, la sostituisco con quella perpendicolare alla curva più adatta
+  // la direzione di riferimento è l'asse X, la sostituisco con quella perpendicolare alla curva più adatta
    Vector3d vtRef = X_AX ;
    double dCosMax = -1 ;
    const ICurve* pCrv = pCrvCompo->GetFirstCurve() ;
@@ -954,108 +913,6 @@ ExeGetSurfTmSilhouette( int nId, const Vector3d& vtDir, double dToler, int nDest
    return nFirstId ;
 }
 
-//----------------------------------------------------------------------------
-static int
-MyGetSurfTmParSilhouettes( const INTVECTOR& vIds, const Point3d& ptOn, const Vector3d& vtN, const DBLVECTOR& vdDist,
-                           double dToler, int nDestGrpId, int nRefType, int& nCount)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
-  // inizializzo contatore a valore negativo (errore)
-   nCount = -1 ;
-  // se non ci sono superfici o quote di calcolo, non c'è niente da calcolare
-   if ( vIds.empty()  ||  vdDist.empty())
-      return GDB_ID_NULL ;
-  // recupero il riferimento della prima superficie
-   Frame3d frSurf ;
-   if ( ! pGeomDB->GetGlobFrame( vIds[0], frSurf))
-      return GDB_ID_NULL ;
-  // recupero il riferimento di destinazione
-   Frame3d frDest ;
-   if ( ! pGeomDB->GetGroupGlobFrame( nDestGrpId, frDest))
-      return GDB_ID_NULL ;
-  // recupero le superfici TriMesh e le porto tutte in locale alla prima
-   SURFLOCALVECTOR vSurfL ; vSurfL.reserve( vIds.size()) ;
-   CISURFTMPVECTOR vpStm ;  vpStm.reserve( vIds.size()) ;
-   for ( int i = 0 ; i < int( vIds.size()) ; ++ i) {
-      vSurfL.emplace_back( pGeomDB, vIds[i], frSurf) ;
-      if ( vSurfL[i].Get() == nullptr)
-         return GDB_ID_NULL ;
-      vpStm.emplace_back( GetSurfTriMesh( vSurfL[i].Get())) ;
-   }
-  // porto in locale alla superficie il punto e la normale e ne calcolo un riferimento
-   Point3d ptOnL = GetPointLocal( pGeomDB, ptOn, nRefType, frSurf) ;
-   Vector3d vtNL = GetVectorLocal( pGeomDB, vtN, nRefType, frSurf) ;
-   Frame3d frPlanes ;
-   if ( ! frPlanes.Set( ptOnL, vtNL))
-      return GDB_ID_NULL ;
-  // recupero i contorni delle varie silhouette
-   int nFirstId = GDB_ID_NULL ;
-   int nTempCount = 0 ;
-   PtrOwner<ICAvParSilhouettesSurfTm> pCavParSilh( CreateCAvParSilhouettesSurfTm()) ;
-   if ( IsNull( pCavParSilh)  ||  ! pCavParSilh->SetData( vpStm, frPlanes, dToler))
-      return GDB_ID_NULL ;
-   for ( auto dDist : vdDist) {
-     // recupero i loop come polilinee
-      POLYLINEVECTOR vPL ;
-      if ( ! pCavParSilh->GetSilhouette( dDist, vPL))
-         return GDB_ID_NULL ;
-     // dalle polilinee creo le curve e le inserisco nel DB
-      for ( int i = 0 ; i < int( vPL.size()) ; ++ i) {
-        // creo la curva
-         PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
-         if ( ! pCrvCompo->FromPolyLine( vPL[i]))
-            return GDB_ID_NULL ;
-        // assegno direzione di estrusione
-         pCrvCompo->SetExtrusion( vtNL) ;
-        // la porto nel riferimento destinazione
-         pCrvCompo->LocToLoc( frSurf, frDest) ;
-        // la inserisco nel DB geometrico
-         int nNewId = pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, Release( pCrvCompo)) ;
-         if ( nNewId == GDB_ID_NULL)
-            return GDB_ID_NULL ;
-        // copio il materiale
-         if ( ! pGeomDB->CopyMaterial( vIds[0], nNewId))
-            return GDB_ID_NULL ;
-        // aggiorno contatori
-         if ( nFirstId == GDB_ID_NULL)
-            nFirstId = nNewId ;
-         ++ nTempCount ;
-      }
-   }
-   nCount = nTempCount ;
-   return nFirstId ;
-}
-
-//----------------------------------------------------------------------------
-int
-ExeGetSurfTmParSilhouettes( const INTVECTOR& vIds, const Point3d& ptOn, const Vector3d& vtN, const DBLVECTOR& vdDist,
-                            double dToler, int nDestGrpId, int nRefType, int* pnCount)
-{
-  // eseguo
-   int nCount = -1 ;
-   int nFirstId = MyGetSurfTmParSilhouettes( vIds, ptOn, vtN, vdDist, dToler, nDestGrpId, nRefType, nCount) ;
-  // aggiorno contatori
-   if ( nFirstId != GDB_ID_NULL)
-      ExeSetModified() ;
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtGetSurfTmParSilhouettes({" + ToString( vIds) + "},{" +
-                                                     ToString( ptOn) + "},{" +
-                                                     ToString( vtN) + "},{" +
-                                                     ToString( vdDist) + "}," +
-                                                     ToString( dToler) + "," +
-                                                     ToString( nDestGrpId) + "," +
-                                                     RefTypeToString( nRefType) + ")" +
-                    " -- Id1=" + ToString( nFirstId) + ",Nbr=" + ToString( nCount) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-  // restituisco risultati
-   if ( pnCount != nullptr)
-      *pnCount = nCount ;
-   return nFirstId ;
-}
-
 //----------------------------------------------------------------------------
 int
 ExeExtractSurfTmFacetLoops( int nId, int nFacet, int nDestGrpId, int* pnCount)
@@ -1224,98 +1081,6 @@ ExeSurfTmGetFacetBBoxRef( int nId, int nFacet, int nFlag, const Frame3d& frRef,
    return pStm->GetFacetBBox( nFacet, frGlobL, b3Box, nFlag) ;
 }
 
-//-----------------------------------------------------------------------------
-bool
-ExeSurfTmGetFacetOutlineInfo( int nId, int nFacet, int nRefId,
-                              int& nStatus, BOOLVECTOR& vbOpen, INTVECTOR& vnAdj, DBLVECTOR& vdLen, VCT3DVECTOR& vvtNorm, DBLVECTOR& vdElev)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-  // recupero la superficie TriMesh
-   const ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
-   if ( pStm == nullptr)
-      return false ;
-  // recupero normale della faccia
-   Vector3d vtNorm ;
-   if ( ! pStm->GetFacetNormal( nFacet, vtNorm))
-      return false ;
-  // recupero i loop come polilinee
-   POLYLINEVECTOR vPL ;
-   if ( ! pStm->GetFacetLoops( nFacet, vPL)  ||  vPL.empty())
-      return false ;
-  // calcolo lo stato
-   if ( vPL.size() == 1)
-      nStatus = 0 ;
-   else {
-      nStatus = -1 ;
-      for ( int i = 1 ; nStatus == -1 && i < int( vPL.size()) ; ++ i) {
-         double dIni, dFin ;
-         Point3d ptIni, ptFin ;
-         bool bFound = vPL[i].GetFirstULine( &dIni, &ptIni, &dFin, &ptFin) ;
-         while ( bFound) {
-            int nAdj = lround( dIni) ;
-            Vector3d vtNf ;
-            if ( nAdj >= 0  &&  pStm->GetFacetNormal( nAdj, vtNf)) {
-               Vector3d vtTg = ptFin - ptIni ;
-               vtTg.Normalize() ;
-               if ( ( vtTg ^ vtNf) * vtNorm > EPS_SMALL) {
-                  nStatus = 1 ;
-                  break ;
-               }
-            }
-            bFound = vPL[i].GetNextULine( &dIni, &ptIni, &dFin, &ptFin) ;
-         }
-      }
-   }
-  // pulisco e prealloco i vettori del risultato
-   int nDim = vPL[0].GetLineNbr() ;
-   vbOpen.clear() ; vbOpen.reserve( nDim) ;
-   vnAdj.clear() ; vnAdj.reserve( nDim) ;
-   vdLen.clear() ; vdLen.reserve( nDim) ;
-   vvtNorm.clear() ; vvtNorm.reserve( nDim) ;
-   vdElev.clear() ; vdElev.reserve( nDim) ;
-  // recupero riferimento alla lista dei punti
-   PNTULIST& lstPU = vPL[0].GetUPointList() ; 
-  // ciclo sui lati del loop esterno (il primo)
-   double dIni, dFin ;
-   Point3d ptIni, ptFin ;
-   bool bFound = vPL[0].GetFirstULine( &dIni, &ptIni, &dFin, &ptFin) ;
-   while ( bFound) {
-     // faccia adiacente
-      int nAdj = lround( dIni) ;
-     // lunghezza lato
-      double dLen = Dist( ptIni, ptFin) ;
-     // aperto se senza adiacenza o con faccia adiacente che va da parte negativa (tipo foro)
-      bool bOpen = true ;
-      Vector3d vtTg = ptFin - ptIni ;
-      vtTg.Normalize() ;
-      Vector3d vtNf ;
-      if ( nAdj >= 0  &&  pStm->GetFacetNormal( nAdj, vtNf))
-         bOpen = ((vtTg ^ vtNf) * vtNorm < EPS_SMALL) ;
-     // normale al lato (verso interno se chiuso, verso esterno se aperto)
-      Vector3d vtN = vtTg ;
-      vtN.Rotate( vtNorm, 0, ( bOpen ? -1 : 1)) ;
-     // elevazione secondo direzione della normale al lato
-      double dElev = 0 ;
-      for ( const auto& PU : lstPU) {
-         double dDist = ( PU.first - ptIni) * vtN ;
-         dElev = ( bOpen ? min( dElev, dDist) : max( dElev, dDist)) ;
-      }
-     // porto normale nel riferimento desiderato
-      TransformVector( pGeomDB, nId, nRefId, vtN) ;
-     // inserisco dati nei parametri di ritorno
-      vbOpen.emplace_back( bOpen) ;
-      vnAdj.emplace_back( nAdj) ;
-      vdLen.emplace_back( dLen) ;
-      vvtNorm.emplace_back( vtN) ;
-      vdElev.emplace_back( dElev) ;
-     // passo al prossimo lato
-      bFound = vPL[0].GetNextULine( &dIni, &ptIni, &dFin, &ptFin) ;
-   }
-
-   return true ;
-}
-
 //----------------------------------------------------------------------------
 int
 ExeSurfTmGetEdges( int nId, int nDestGrpId, bool bSmoothAng, int* pnCount)
@@ -1495,7 +1260,7 @@ MySurfBezierGetCurveUV( int nSurfId, bool bIsU, double dPar, int nDestGrpId)
    PtrOwner<ICurveComposite> pCrv( bIsU ? pSbz->GetCurveOnU( dPar) : pSbz->GetCurveOnV( dPar)) ;
    if ( IsNull( pCrv))
       return GDB_ID_NULL ;
-  // se è una curva
+  // se è una curva
    if ( ! pCrv->IsAPoint()) {
      // porto la curva nel riferimento destinazione
       pCrv->LocToLoc( frSurf, frDest) ;
@@ -1505,7 +1270,7 @@ MySurfBezierGetCurveUV( int nSurfId, bool bIsU, double dPar, int nDestGrpId)
       pGeomDB->CopyMaterial( nSurfId, nNewId) ;
       return nNewId ;
    }
-  // altrimenti è collassata in un punto
+  // altrimenti è collassata in un punto
    else {
       Point3d ptP ; pCrv->GetStartPoint( ptP) ;
       PtrOwner<IGeoPoint3d> pGeoPnt( CreateGeoPoint3d()) ;
@@ -1609,7 +1374,7 @@ MySurfBezierGetControlCurveUV( int nSurfId, bool bIsU, int nInd, int nDestGrpId)
       pSbz->GetControlCurveOnU( nInd, PL) ;
    else
       pSbz->GetControlCurveOnV( nInd, PL) ;
-  // se è una curva
+  // se è una curva
    if ( PL.GetPointNbr() > 1) {
       PtrOwner<ICurveComposite> pCrvCo( CreateCurveComposite()) ;
       if ( IsNull( pCrvCo)  ||  ! pCrvCo->FromPolyLine( PL))
@@ -1622,7 +1387,7 @@ MySurfBezierGetControlCurveUV( int nSurfId, bool bIsU, int nInd, int nDestGrpId)
       pGeomDB->CopyMaterial( nSurfId, nNewId) ;
       return nNewId ;
    }
-  // se altrimenti è collassata in un punto
+  // se altrimenti è collassata in un punto
    else if ( PL.GetPointNbr() == 1) {
       Point3d ptP ; PL.GetFirstPoint( ptP) ;
       PtrOwner<IGeoPoint3d> pGeoPnt( CreateGeoPoint3d()) ;
@@ -1636,7 +1401,7 @@ MySurfBezierGetControlCurveUV( int nSurfId, bool bIsU, int nInd, int nDestGrpId)
       pGeomDB->CopyMaterial( nSurfId, nNewId) ;
       return nNewId ;
    }
-  // altrimenti è errore
+  // altrimenti è errore
    else
       return GDB_ID_NULL ;
 }
@@ -1729,45 +1494,4 @@ ExeExtractSurfBezierLoops( int nId, int nDestGrpId, int* pnCount)
    if ( pnCount != nullptr)
       *pnCount = nCount ;
    return nFirstId ;
-}
-
-//----------------------------------------------------------------------------
-int
-ExeShowSurfBezierControlPoints( int nSrfId, int nDestGrpId, int* pnCount)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-   // recupero la superficie di bezier
-   IGeoObj* pGeoObj = pGeomDB->GetGeoObj( nSrfId) ;
-   if ( pGeoObj->GetType() != SRF_BEZIER)
-      return GDB_ID_NULL ;
-   // recupero il riferimento della superficie
-   Frame3d frSurf ;
-   bool bOk = true ;
-   bOk = bOk && pGeomDB->GetGlobFrame( nSrfId, frSurf) ;
-   // recupero il riferimento di destinazione
-   Frame3d frDest ;
-   bOk = bOk && pGeomDB->GetGroupGlobFrame( nDestGrpId, frDest) ;
-   if ( ! bOk)
-      return GDB_ID_NULL ;
-   int nDegU = - 1, nDegV = - 1, nSpanU = - 1, nSpanV = - 1 ;
-   bool bRat = false, bTrimmed = false ;
-   ISurfBezier* pSrfBez = GetSurfBezier( pGeoObj) ;
-   pSrfBez->GetInfo( nDegU, nDegV, nSpanU, nSpanV, bRat, bTrimmed) ;
-   int nFirstId = -1 ;
-   int nCount = 0 ;
-   for ( int i = 0 ; i < (nDegU * nSpanU + 1) * ( nDegV * nSpanV + 1) ; ++i) {
-      IGeoPoint3d* pGeoPt( CreateGeoPoint3d()) ;
-      pGeoPt->Set( pSrfBez->GetControlPoint( i, &bOk)) ;
-      pGeoPt->LocToLoc( frSurf, frDest) ;
-      int nId = pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, pGeoPt) ;
-      if ( nFirstId == GDB_ID_NULL)
-         nFirstId = nId ;
-      if ( nId != GDB_ID_NULL)
-         ++nCount ;
-   }
-   // restituisco i risultati
-   if ( pnCount != nullptr)
-      *pnCount = nCount ;
-   return nFirstId ;
 }

EXE_GdbModifyCurve.cpp

@@ -20,8 +20,6 @@
 #include "GeoTools.h"
 #include "/EgtDev/Include/EXeExecutor.h"
 #include "/EgtDev/Include/EXeConst.h"
-#include "/EgtDev/Include/EGkGeoPoint3d.h"
-#include "/EgtDev/Include/EGkGeoVector3d.h"
 #include "/EgtDev/Include/EGkCurve.h"
 #include "/EgtDev/Include/EGkCurveArc.h"
 #include "/EgtDev/Include/EGkCurveBezier.h"
@@ -34,17 +32,18 @@
 #include "/EgtDev/Include/EGkOffsetCurve.h"
 #include "/EgtDev/Include/EGkMedialAxis.h"
 #include "/EgtDev/Include/EGkChainCurves.h"
-#include "/EgtDev/Include/EGkProjectCurveSurf.h"
+#include "/EgtDev/Include/EGkProjectCurveSurfTm.h"
 #include "/EgtDev/Include/EGkSurfFlatRegion.h"
-#include "/EgtDev/Include/EGkSfrCreate.h"
-#include "/EgtDev/Include/EGkSurfBezier.h"
 #include "/EgtDev/Include/EGkExtTExt.h"
 #include "/EgtDev/Include/EGkGdbIterator.h"
 #include "/EgtDev/Include/EGkStringUtils3d.h"
 #include "/EgtDev/Include/EGkIntervals.h"
 #include "/EgtDev/Include/EGkPolygon3d.h"
-#include "/EgtDev/Include/EGkCalcPocketing.h"
+#include "/EgtDev/Include/EGkGeoPoint3d.h"
+#include "/EgtDev/Include/EGkGeoVector3d.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
+#include "/EgtDev/Include/EGkCalcPocketing.h"
+#include <EgtDev/Include/EGkSfrCreate.h>
 #include <functional>
 
 
@@ -334,9 +333,10 @@ ExeChangeClosedCurveStartPoint( int nId, const Point3d& ptP, int nRefType)
   // porto in locale il punto vicino ad iniziale
    Point3d ptPL = GetPointLocal( pGeomDB, ptP, nRefType, frLoc) ;
   // recupero la posizione parametrica della proiezione di questo punto sulla curva
+   DistPointCurve distPC( ptPL, *pCurve) ;
    double dPar ;
    int nFlag ;
-   bOk = bOk && DistPointCurve( ptPL, *pCurve).GetParamAtMinDistPoint( 0, dPar, nFlag) ;
+   bOk = bOk && distPC.GetParamAtMinDistPoint( 0, dPar, nFlag) ;
   // cambio il punto iniziale
    if ( bOk  &&  pCurve->GetType() == CRV_ARC)
       bOk = bOk && GetCurveArc(pCurve)->ChangeStartPoint(dPar) ;
@@ -876,7 +876,7 @@ ExeTrimExtendCurveByLen( int nId, double dLen, const Point3d& ptNear, int nRefTy
    bOk = bOk && pGeomDB->GetGlobFrame( nId, frLoc) ;
   // porto in locale il punto
    Point3d ptNearL = GetPointLocal( pGeomDB, ptNear, nRefType, frLoc) ;
-  // cerco l'estremo più vicino al punto passato
+  // cerco l'estremo più vicino al punto passato
    bool bStart ;
    if ( bOk  &&  pCurve->GetNearestExtremityToPoint( ptNearL, bStart)) {
       if ( bStart) {
@@ -971,7 +971,7 @@ MyTrimCurveWithRegion( int nCrvId, int nRegId, bool bInVsOut, bool bOn, int& nCo
      // passo alla successiva divisione
       bFound = inOk.GetNext( dParS, dParE) ;
    }
-  // cancello l'ultima copia (se non c'erano intervalli validi è l'originale)
+  // cancello l'ultima copia (se non c'erano intervalli validi è l'originale)
    pGeomDB->Erase( nCurrId) ;
    return nFirstId ;
 }
@@ -1016,7 +1016,7 @@ MyTrimFlatCurveWithBox( int nCrvId, const Frame3d& frBox, const Vector3d& vtDiag
    Plane3d plPlane ;
    if ( ! pCrv->IsFlat( plPlane, false, 10 * EPS_SMALL))
       return GDB_ID_NULL ;
-  // porto in locale alla curva il riferimento del box (il vettore è già in locale a questo stesso riferimento)
+  // porto in locale alla curva il riferimento del box (il vettore è già in locale a questo stesso riferimento)
    Frame3d frBoxL = GetFrameLocal( pGeomDB, frBox, nRefType, frCrv) ;
   // determino la parte di piano (poligono) compresa nel box (applicando le opportune trasformazioni di riferimento)
    plPlane.ToLoc( frBoxL) ;
@@ -1080,7 +1080,7 @@ MyTrimFlatCurveWithBox( int nCrvId, const Frame3d& frBox, const Vector3d& vtDiag
      // passo alla successiva divisione
       bFound = inOk.GetNext( dParS, dParE) ;
    }
-  // cancello l'ultima copia (se non c'erano intervalli validi è l'originale)
+  // cancello l'ultima copia (se non c'erano intervalli validi è l'originale)
    pGeomDB->Erase( nCurrId) ;
    return nFirstId ;
 }
@@ -1118,7 +1118,7 @@ ExeSplitCurve( int nId, int nParts)
   // recupero la curva
    ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
    bool bOk = ( pCurve != nullptr) ;
-  // il numero di parti non può essere inferiore a 1
+  // il numero di parti non può essere inferiore a 1
    nParts = max( nParts, 1) ;
   // lunghezza totale della curva
    double dLenTot = 0 ;
@@ -1179,7 +1179,7 @@ ExeSplitCurveAtPoint( int nId, const Point3d& ptOn, int nRefType)
       int nFlag ;
       if ( ! dstPC.GetParamAtMinDistPoint( 0, dU, nFlag)  ||  nFlag != MDPCI_NORMAL)
          bOk = false ;
-     // se sull'inizio, provo se c'è una soluzione successiva
+     // se sull'inizio, provo se c'è una soluzione successiva
       if ( bOk  &&  dU < EPS_PARAM)
          dstPC.GetParamAtMinDistPoint( 1, dU, nFlag) ;
    }
@@ -1196,7 +1196,7 @@ ExeSplitCurveAtPoint( int nId, const Point3d& ptOn, int nRefType)
       if ( bOk  &&  dCutLen > EPS_SMALL  &&  dLen - dCutLen > EPS_SMALL)
          bIsInside = true ;
    }
-  // se il punto di taglio è interno, devo realmente tagliare
+  // se il punto di taglio è interno, devo realmente tagliare
    int nNewId = GDB_ID_NULL ;
    if ( bIsInside) {
      // copio la curva
@@ -1243,7 +1243,7 @@ ExeSplitCurveAtParam( int nId, double dParam)
       if ( bOk  &&  dCutLen > EPS_SMALL  &&  dLen - dCutLen > EPS_SMALL)
          bIsInside = true ;
    }
-  // se il punto di taglio è interno, devo realmente tagliare
+  // se il punto di taglio è interno, devo realmente tagliare
    int nNewId = GDB_ID_NULL ;
    if ( bIsInside) {
      // copio la curva
@@ -1465,7 +1465,7 @@ ExeGetCurveLinearConvexHullXY( int nId, double dLinTol, int nRefType)
                     " -- Id=" + ToString( nNewId) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
    }
-  // restituisco l'identificativo della nuova entità
+  // restituisco l'identificativo della nuova entità
    return nNewId ;
 }
 
@@ -1562,7 +1562,7 @@ MyModifyArcRadiusEx( IGeomDB* pGeomDB, int nId, double dRad)
   // se angolo al centro maggiore o uguale ad un giro o estremi coincidenti, conservo il centro
    if ( abs( pArc->GetAngCenter()) >= ANG_FULL - EPS_ANG_ZERO  ||  dPlaneDist < 2 * EPS_SMALL)
       return MyModifyArcRadius( pGeomDB, nId, dRad) ;
-  // mantengo i punti estremi (pertanto il nuovo raggio non può essere inferiore a metà della loro distanza nel piano)
+  // mantengo i punti estremi (pertanto il nuovo raggio non può essere inferiore a metà della loro distanza nel piano)
    if ( dRad < dPlaneDist / 2 - EPS_ZERO)
       return false ;
   // creo arco con gli stessi estremi, con identica normale e con nuovo raggio
@@ -1765,7 +1765,7 @@ ExeAddCurveCompoCurve( int nId, int nAddCrvId, bool bEraseOrig, bool bEndVsStart
                     " -- Ok=" + ToString( bOk) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
    }
-  // restituisco l'identificativo della nuova entità
+  // restituisco l'identificativo della nuova entità
    return bOk ;
 }
 
@@ -1979,7 +1979,7 @@ ExeGetCurveCompoJointCount( int nId)
    ICurveComposite* pCompo = GetCurveComposite( pGeomDB->GetGeoObj( nId)) ;
    if ( pCompo == nullptr)
       return 0 ;
-  // calcolo il numero di giunzioni (se chiusa è uguale al numero delle curve altrimenti -1)
+  // calcolo il numero di giunzioni (se chiusa è uguale al numero delle curve altrimenti -1)
    if ( pCompo->IsClosed())
       return pCompo->GetCurveCount() ;
    else
@@ -2183,52 +2183,6 @@ ExeRemoveCurveCompoUndercutOnY( int nId, double dLinTol)
    return bOk ;
 }
 
-//----------------------------------------------------------------------------
-bool
-ExeCurveCompoSetTempProp( int nId, int nCrv, int nProp, int nPropInd) 
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-  // recupero la curva composita
-   ICurveComposite* pCompo = GetCurveComposite( pGeomDB->GetGeoObj( nId)) ;
-   bool bOk = ( pCompo != nullptr) ;
-  // imposto il valore
-   bOk = bOk && pCompo->SetCurveTempProp( nCrv, nProp, nPropInd) ;
-   ExeSetModified() ;
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtCurveCompoSetTempProp(" + ToString( nId) + "," +
-                                                  ToString( nCrv) + "," +
-                                                  ToString( nProp) + ")" +
-                    " -- Ok=" + ToString( bOk) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-   return bOk ;
-}
-
-//----------------------------------------------------------------------------
-bool
-ExeCurveCompoSetTempParam( int nId, int nCrv, double dParam, int nParamInd) 
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-  // recupero la curva composita
-   ICurveComposite* pCompo = GetCurveComposite( pGeomDB->GetGeoObj( nId)) ;
-   bool bOk = ( pCompo != nullptr) ;
-  // imposto il valore
-   bOk = bOk && pCompo->SetCurveTempParam( nCrv, dParam, nParamInd) ;
-   ExeSetModified() ;
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtCurveCompoSetTempParam(" + ToString( nId) + "," +
-                                                   ToString( nCrv) + "," +
-                                                   ToString( dParam) + ")" +
-                    " -- Ok=" + ToString( bOk) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-   return bOk ;
-}
-
 //-------------------------------------------------------------------------------
 static bool
 MyChainCurvesInGroup( int nGroupId, const Point3d& ptNear, bool bAllowInvert, int nRefType)
@@ -2319,8 +2273,8 @@ ExeReorderCurvesInGroup( int nGroupId, const Point3d& ptNear, int nRefType)
 
 //-------------------------------------------------------------------------------
 static bool
-MyProjectCurveOnSurf( int nCurveId, int nSurfTmId, const Vector3d& vtProj, int nDestGrpId,
-                      double dLinTol, double dMaxSegmLen, bool bDirFromProj, int nRefType)
+MyProjectCurveOnSurfTm( int nCurveId, int nSurfTmId, const Vector3d& vtDir, int nDestGrpId,
+                        double dLinTol, double dMaxSegmLen, int nRefType)
 {
    IGeomDB* pGeomDB = GetCurrGeomDB() ;
    VERIFY_GEOMDB( pGeomDB, false)
@@ -2331,9 +2285,9 @@ MyProjectCurveOnSurf( int nCurveId, int nSurfTmId, const Vector3d& vtProj, int n
    Frame3d frCrv ;
    if ( ! pGeomDB->GetGlobFrame( nCurveId, frCrv))
       return false ;
-  // recupero la superficie e il suo riferimento
-   const ISurf* pSurf = GetSurf( pGeomDB->GetGeoObj( nSurfTmId)) ;
-   if ( pSurf == nullptr)
+  // recupero la superficie trimesh e il suo riferimento
+   const ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nSurfTmId)) ;
+   if ( pStm == nullptr)
       return false ;
    Frame3d frStm ;
    if ( ! pGeomDB->GetGlobFrame( nSurfTmId, frStm))
@@ -2347,13 +2301,11 @@ MyProjectCurveOnSurf( int nCurveId, int nSurfTmId, const Vector3d& vtProj, int n
    CurveLocal CrvLoc( pCrv, frCrv, frStm) ;
    if ( CrvLoc.Get() == nullptr)
       return false ;
-   Vector3d vtProjL = GetVectorLocal( pGeomDB, vtProj, nRefType, frCrv) ;
-   vtProjL.LocToLoc( frCrv, frStm) ;
-  // vanno affilati gli spigoli solo se direzione non da proiezione
-   bool bSharpEdges = ( ! bDirFromProj) ;
+   Vector3d vtDirL = GetVectorLocal( pGeomDB, vtDir, nRefType, frCrv) ;
+   vtDirL.LocToLoc( frCrv, frStm) ;
   // eseguo la proiezione
    PNT5AXVECTOR vPt5ax ;
-   if ( ! ProjectCurveOnSurf( *CrvLoc.Get(), *pSurf, vtProjL, dLinTol, dMaxSegmLen, bSharpEdges, vPt5ax))
+   if ( ! ProjectCurveOnSurfTm( *CrvLoc.Get(), *pStm, vtDirL, dLinTol, dMaxSegmLen, vPt5ax))
       return false ;
   // inserisco la composita nel gruppo destinazione
    PtrOwner<ICurveComposite> pCompo ;
@@ -2376,8 +2328,7 @@ MyProjectCurveOnSurf( int nCurveId, int nSurfTmId, const Vector3d& vtProj, int n
       PtrOwner<IGeoVector3d> pGeoVct( CreateGeoVector3d()) ;
       if ( IsNull( pGeoVct))
          return false ;
-      Vector3d vtDir = ( bDirFromProj ? Pt5ax.vtDir2 : Pt5ax.vtDir1) ;
-      pGeoVct->Set( 10 * GetLocToLoc( vtDir, frStm, frDest), GetLocToLoc( Pt5ax.ptP, frStm, frDest)) ;
+      pGeoVct->Set( 10 * GetLocToLoc( Pt5ax.vtDir, frStm, frDest), GetLocToLoc( Pt5ax.ptP, frStm, frDest)) ;
       int nNewId = pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, Release( pGeoVct)) ;
       if ( nNewId == GDB_ID_NULL)
          return false ;
@@ -2391,21 +2342,20 @@ MyProjectCurveOnSurf( int nCurveId, int nSurfTmId, const Vector3d& vtProj, int n
 
 //-------------------------------------------------------------------------------
 bool
-ExeProjectCurveOnSurf( int nCurveId, int nSurfTmId, const Vector3d& vtProj, int nDestGrpId,
-                       double dLinTol, double dMaxSegmLen, bool bDirFromProj, int nRefType)
+ExeProjectCurveOnSurfTm( int nCurveId, int nSurfTmId, const Vector3d& vtDir, int nDestGrpId,
+                         double dLinTol, double dMaxSegmLen, int nRefType)
 {
-   bool bOk = MyProjectCurveOnSurf( nCurveId, nSurfTmId, vtProj, nDestGrpId, dLinTol, dMaxSegmLen, bDirFromProj, nRefType) ;
+   bool bOk = MyProjectCurveOnSurfTm( nCurveId, nSurfTmId, vtDir, nDestGrpId, dLinTol, dMaxSegmLen, nRefType) ;
    ExeSetModified() ;
   // se richiesto, salvo il comando Lua equivalente
    if ( IsCmdLog()) {
-      string sLua = "EgtProjectCurveOnSurf(" + ToString( nCurveId) + "," +
-                                               ToString( nSurfTmId) + ",{" +
-                                               ToString( vtProj) + "}," +
-                                               ToString( nDestGrpId) + "," +
-                                               ToString( dLinTol) + "," +
-                                               ToString( dMaxSegmLen) + "," +
-                                               ( bDirFromProj ? "true" : "false") + "," +
-                                               RefTypeToString( nRefType) + ")" +
+      string sLua = "EgtProjectCurveOnSurfTm(" + ToString( nCurveId) + "," +
+                                                 ToString( nSurfTmId) + ",{" +
+                                                 ToString( vtDir) + "}," +
+                                                 ToString( nDestGrpId) + "," +
+                                                 ToString( dLinTol) + "," +
+                                                 ToString( dMaxSegmLen) + "," +
+                                                 RefTypeToString( nRefType) + ")" +
                     " -- Ok=" + ToString( bOk) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
    }
@@ -2415,8 +2365,8 @@ ExeProjectCurveOnSurf( int nCurveId, int nSurfTmId, const Vector3d& vtProj, int
 
 //-------------------------------------------------------------------------------
 static bool
-MyProjectCurveOnSurfExt( int nCurveId, int nSurfTmId, int nGuideId, int nDestGrpId,
-                         double dLinTol, double dMaxSegmLen, bool bDirFromGuide)
+MyProjectCurveOnSurfTmExt( int nCurveId, int nSurfTmId, int nGuideId, int nDestGrpId,
+                           double dLinTol, double dMaxSegmLen, bool bDirFromGuide)
 {
    IGeomDB* pGeomDB = GetCurrGeomDB() ;
    VERIFY_GEOMDB( pGeomDB, false)
@@ -2427,22 +2377,22 @@ MyProjectCurveOnSurfExt( int nCurveId, int nSurfTmId, int nGuideId, int nDestGrp
    Frame3d frCrv ;
    if ( ! pGeomDB->GetGlobFrame( nCurveId, frCrv))
       return false ;
-  // recupero la superficie e il suo riferimento
-   const ISurf* pStm = GetSurf( pGeomDB->GetGeoObj( nSurfTmId)) ;
+  // recupero la superficie trimesh e il suo riferimento
+   const ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nSurfTmId)) ;
    if ( pStm == nullptr)
       return false ;
    Frame3d frStm ;
    if ( ! pGeomDB->GetGlobFrame( nSurfTmId, frStm))
       return false ;
-   // recupero l'entità guida (punto, curva o superficie) e il suo riferimento
+   // recupero l'entità guida (punto, curva o superficie) e il suo riferimento
    const IGeoPoint3d* pGdePnt = nullptr ;
    const ICurve* pGdeCrv = nullptr ;
-   const ISurf* pGdeStm = nullptr ;
+   const ISurfTriMesh* pGdeStm = nullptr ;
    pGdePnt = GetGeoPoint3d( pGeomDB->GetGeoObj( nGuideId)) ;
    if ( pGdePnt == nullptr) {
       pGdeCrv = GetCurve( pGeomDB->GetGeoObj( nGuideId)) ;
       if ( pGdeCrv == nullptr) {
-         pGdeStm = GetSurf( pGeomDB->GetGeoObj( nGuideId)) ;
+         pGdeStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nGuideId)) ;
          if ( pGdeStm == nullptr)
             return false ;
       }
@@ -2459,31 +2409,29 @@ MyProjectCurveOnSurfExt( int nCurveId, int nSurfTmId, int nGuideId, int nDestGrp
    CurveLocal CrvLoc( pCrv, frCrv, frStm) ;
    if ( CrvLoc.Get() == nullptr)
       return false ;
-  // vanno affilati gli spigoli solo se direzione non da guida
-   bool bSharpEdges = ( ! bDirFromGuide) ;
-  // eseguo l'opportuna proiezione dopo aver portato l'entità guida nel riferimento della superficie
+  // eseguo l'opportuna proiezione dopo aver portato l'entità guida nel riferimento della superficie
    PNT5AXVECTOR vPt5ax ;
    if ( pGdePnt != nullptr) {
       PtrOwner<IGeoPoint3d> pGdeLoc( pGdePnt->Clone()) ;
       if ( pGdeLoc == nullptr)
          return false ;
       pGdeLoc->LocToLoc( frGde, frStm) ;
-      if ( ! ProjectCurveOnSurf( *CrvLoc.Get(), *pStm, *pGdeLoc, dLinTol, dMaxSegmLen, bSharpEdges, vPt5ax))
+      if ( ! ProjectCurveOnSurfTm( *CrvLoc.Get(), *pStm, *pGdeLoc, dLinTol, dMaxSegmLen, vPt5ax))
          return false ;
    }
    else if ( pGdeCrv != nullptr) {
       CurveLocal GdeLoc( pGdeCrv, frGde, frStm) ;
       if ( GdeLoc.Get() == nullptr)
          return false ;
-      if ( ! ProjectCurveOnSurf( *CrvLoc.Get(), *pStm, *GdeLoc.Get(), dLinTol, dMaxSegmLen, bSharpEdges, vPt5ax))
+      if ( ! ProjectCurveOnSurfTm( *CrvLoc.Get(), *pStm, *GdeLoc.Get(), dLinTol, dMaxSegmLen, vPt5ax))
          return false ;
    }
    else { // pGdeStm != nullptr
       SurfLocal GdeLoc( pGdeStm, frGde, frStm) ;
-      const ISurf* pGdeLoc = GetSurf( GdeLoc.Get()) ;
+      const ISurfTriMesh* pGdeLoc = GetSurfTriMesh( GdeLoc.Get()) ;
       if ( pGdeLoc == nullptr)
          return false ;
-      if ( ! ProjectCurveOnSurf( *CrvLoc.Get(), *pStm, *pGdeLoc, dLinTol, dMaxSegmLen, bSharpEdges, vPt5ax))
+      if ( ! ProjectCurveOnSurfTm( *CrvLoc.Get(), *pStm, *pGdeLoc, dLinTol, dMaxSegmLen, vPt5ax))
          return false ;
    }
   // inserisco la composita nel gruppo destinazione
@@ -2507,7 +2455,7 @@ MyProjectCurveOnSurfExt( int nCurveId, int nSurfTmId, int nGuideId, int nDestGrp
       PtrOwner<IGeoVector3d> pGeoVct( CreateGeoVector3d()) ;
       if ( IsNull( pGeoVct))
          return false ;
-      Vector3d vtDir = ( bDirFromGuide ? Pt5ax.vtDir2 : Pt5ax.vtDir1) ;
+      Vector3d vtDir = ( bDirFromGuide ? Pt5ax.vtDir2 : Pt5ax.vtDir) ;
       pGeoVct->Set( 10 * GetLocToLoc( vtDir, frStm, frDest), GetLocToLoc( Pt5ax.ptP, frStm, frDest)) ;
       int nNewId = pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, Release( pGeoVct)) ;
       if ( nNewId == GDB_ID_NULL)
@@ -2522,20 +2470,20 @@ MyProjectCurveOnSurfExt( int nCurveId, int nSurfTmId, int nGuideId, int nDestGrp
 
 //-------------------------------------------------------------------------------
 bool
-ExeProjectCurveOnSurfExt( int nCurveId, int nSurfTmId, int nGuideId, int nDestGrpId,
+ExeProjectCurveOnSurfTmExt( int nCurveId, int nSurfTmId, int nGuideId, int nDestGrpId,
                             double dLinTol, double dMaxSegmLen, bool bDirFromGuide)
 {
-   bool bOk = MyProjectCurveOnSurfExt( nCurveId, nSurfTmId, nGuideId, nDestGrpId, dLinTol, dMaxSegmLen, bDirFromGuide) ;
+   bool bOk = MyProjectCurveOnSurfTmExt( nCurveId, nSurfTmId, nGuideId, nDestGrpId, dLinTol, dMaxSegmLen, bDirFromGuide) ;
    ExeSetModified() ;
   // se richiesto, salvo il comando Lua equivalente
    if ( IsCmdLog()) {
-      string sLua = "EgtProjectCurveOnSurfExt(" + ToString( nCurveId) + "," +
-                                                  ToString( nSurfTmId) + ",{" +
-                                                  ToString( nGuideId) + "}," +
-                                                  ToString( nDestGrpId) + "," +
-                                                  ToString( dLinTol) + "," +
-                                                  ToString( dMaxSegmLen) + "," +
-                                                  ( bDirFromGuide ? "true" : "false") + ")" +
+      string sLua = "EgtProjectCurveOnSurfTmExt(" + ToString( nCurveId) + "," +
+                                                    ToString( nSurfTmId) + ",{" +
+                                                    ToString( nGuideId) + "}," +
+                                                    ToString( nDestGrpId) + "," +
+                                                    ToString( dLinTol) + "," +
+                                                    ToString( dMaxSegmLen) + "," +
+                                                    ( bDirFromGuide ? "true" : "false") + ")" +
                     " -- Ok=" + ToString( bOk) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
    }
@@ -2545,17 +2493,17 @@ ExeProjectCurveOnSurfExt( int nCurveId, int nSurfTmId, int nGuideId, int nDestGr
 
 //----------------------------------------------------------------------------
 int
-ExeCurveGetVoronoi( const INTVECTOR& vIds, int nDestGrpId, int nBound, int* pnCount) 
+ExeCurveGetVoronoi( int nId, int nDestGrpId, int nBound, int* pnCount) 
 {
    IGeomDB* pGeomDB = GetCurrGeomDB() ;
    VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
-
-   if ( vIds.empty())
-      return false ;
-
-  // recupero il riferimento della prima curva che sarà utilizzato da Voronoi
+  // recupero la curva
+   const ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( nId)) ;
+   if ( pCrv == nullptr)
+      return GDB_ID_NULL ;
+  // recupero il riferimento della curva
    Frame3d frCrv ;
-   if ( ! pGeomDB->GetGlobFrame( vIds[0], frCrv))
+   if ( ! pGeomDB->GetGlobFrame( nId, frCrv))
       return GDB_ID_NULL ;
   // recupero il riferimento di destinazione
    Frame3d frDest ;
@@ -2564,32 +2512,7 @@ ExeCurveGetVoronoi( const INTVECTOR& vIds, int nDestGrpId, int nBound, int* pnCo
 
   // Calcolo diagramma di Voronoi
    ICURVEPOVECTOR vCrv ;
-   if ( int( vIds.size()) == 1) {
-     // recupero la curva
-      const ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( vIds[0])) ;
-      if ( pCrv == nullptr)
-         return GDB_ID_NULL ;
-     // calcolo
-      CalcCurveVoronoiDiagram( *pCrv, vCrv, nBound) ;  
-   }     
-   else {
-     // recupero le curve e le porto in locale al frame della prima curva
-      CICURVEPVECTOR vOrigCrvs ;
-      for ( int i = 0 ; i < int( vIds.size()) ; i ++) {         
-         CurveLocal CrvLoc( pGeomDB, vIds[i], frCrv) ;
-         if ( CrvLoc.Get() == nullptr) {
-            for ( auto pCrv : vOrigCrvs)
-               delete( pCrv) ;
-            return GDB_ID_NULL ;
-         }            
-         vOrigCrvs.emplace_back( CrvLoc->Clone()) ;
-      }
-     // calcolo
-      CalcCurvesVoronoiDiagram( vOrigCrvs, vCrv, nBound) ;
-     // libero la memoria
-      for ( auto pCrv : vOrigCrvs)
-         delete( pCrv) ;
-   }     
+   CalcCurveVoronoiDiagram( *pCrv, vCrv, nBound) ;
 
   // inserisco i risultati nel DB geometrico
    int nFirstId = GDB_ID_NULL ;
@@ -2606,7 +2529,7 @@ ExeCurveGetVoronoi( const INTVECTOR& vIds, int nDestGrpId, int nBound, int* pnCo
    ExeSetModified() ;
 
    if ( IsCmdLog()) {
-      string sLua = "EgtCurveGetVoronoi(" + ToString( vIds[0]) + "," +
+      string sLua = "EgtCurveGetVoronoi(" + ToString( nId) + "," +
                                             ToString( nDestGrpId) + ")" +
                     " FirstId=" + ToString( nFirstId) + " nCurveCount=" + ToString( nCount) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
@@ -2620,51 +2543,26 @@ ExeCurveGetVoronoi( const INTVECTOR& vIds, int nDestGrpId, int nBound, int* pnCo
 
 //----------------------------------------------------------------------------
 int
-ExeCurveGetMedialAxis( const INTVECTOR& vIds, int nDestGrpId, int nSide, int* pnCount) 
+ExeCurveGetMedialAxis( int nId, int nDestGrpId, int nSide, int* pnCount) 
 {
    IGeomDB* pGeomDB = GetCurrGeomDB() ;
    VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
-
-   if ( vIds.empty())
-      return false ;
-
-  // recupero il riferimento della prima curva che sarà utilizzato da Voronoi
+  // recupero la curva
+   const ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( nId)) ;
+   if ( pCrv == nullptr)
+      return GDB_ID_NULL ;
+  // recupero il riferimento della curva
    Frame3d frCrv ;
-   if ( ! pGeomDB->GetGlobFrame( vIds[0], frCrv))
+   if ( ! pGeomDB->GetGlobFrame( nId, frCrv))
       return GDB_ID_NULL ;
   // recupero il riferimento di destinazione
    Frame3d frDest ;
    if ( ! pGeomDB->GetGroupGlobFrame( nDestGrpId, frDest))
-      return GDB_ID_NULL ;    
+      return GDB_ID_NULL ;
 
   // Calcolo il Medial Axis
    ICURVEPOVECTOR vCrv ;
-   if ( int( vIds.size()) == 1) {
-     // recupero la curva
-      const ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( vIds[0])) ;
-      if ( pCrv == nullptr)
-         return GDB_ID_NULL ;
-     // calcolo
-      CalcCurveMedialAxis( *pCrv, vCrv, nSide) ;   
-   }     
-   else {
-     // recupero le curve e le porto in locale al frame della prima curva
-      CICURVEPVECTOR vOrigCrvs ;
-      for ( int i = 0 ; i < int( vIds.size()) ; i ++) {         
-         CurveLocal CrvLoc( pGeomDB, vIds[i], frCrv) ;
-         if ( CrvLoc.Get() == nullptr) {
-            for ( auto pCrv : vOrigCrvs)
-               delete( pCrv) ;
-            return GDB_ID_NULL ;
-         }            
-         vOrigCrvs.emplace_back( CrvLoc->Clone()) ;
-      }
-     // calcolo
-      CalcCurvesMedialAxis( vOrigCrvs, vCrv, nSide) ;
-     // libero la memoria
-      for ( auto pCrv : vOrigCrvs)
-         delete( pCrv) ;
-   }
+   CalcCurveMedialAxis( *pCrv, vCrv, nSide) ;
 
   // inserisco i risultati nel DB geometrico
    int nFirstId = GDB_ID_NULL ;
@@ -2681,7 +2579,7 @@ ExeCurveGetMedialAxis( const INTVECTOR& vIds, int nDestGrpId, int nSide, int* pn
    ExeSetModified() ;
 
    if ( IsCmdLog()) {
-      string sLua = "EgtCurveMedialAxisAdv(" + ToString( vIds[0]) + "," +
+      string sLua = "EgtCurveMedialAxisAdv(" + ToString( nId) + "," +
                                                ToString( nSide) + "," +
                                                ToString( nDestGrpId) + ")" +
                     " FirstId=" + ToString( nFirstId) + " nCurveCount=" + ToString( nCount) ;
@@ -2743,265 +2641,3 @@ ExeCurveGetFatCurve( int nId, int nDestGrpId, double dRad, bool bSquareEnds, boo
       *pnCount = nCount ;
    return nFirstId ;
 }
-
-//----------------------------------------------------------------------------
-bool
-ExeCurveBezierIncreaseDegree( int nCrvId) 
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
-   // recupero la curva
-   const ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( nCrvId)) ;
-   if ( pCrv == nullptr)
-      return false ;
-   //// recupero il riferimento della curva
-   //Frame3d frCrv ;
-   //if ( ! pGeomDB->GetGlobFrame( nCrvId, frCrv))
-   //   return GDB_ID_NULL ;
-
-   if( pCrv->GetType() != CRV_BEZIER)
-      return false ;
-
-   // aumento il grado della curva
-   bool bOk = true ;
-   PtrOwner<ICurveBezier> pCrvBezierNew ( BezierIncreaseDegree( GetCurveBezier( pCrv))) ;
-   Vector3d vtExtr ;
-   if ( bOk && pCrv->GetExtrusion( vtExtr))
-      pCrvBezierNew->SetExtrusion( vtExtr) ;
-   double dThick = 0 ;
-   if ( bOk  &&  pCrv->GetThickness( dThick))
-      pCrvBezierNew->SetThickness(dThick) ;
-   // sostituisco la vecchia curva con la nuova
-   bOk = bOk && pGeomDB->ReplaceGeoObj( nCrvId, Release( pCrvBezierNew)) ;
-   ExeSetModified() ;
-
-   if ( IsCmdLog()) {
-      string sLua = "EgtCurveBezierIncreaseDegree(" + ToString( nCrvId) + ")"
-                     " -- Ok=" + ToString( bOk) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-
-   return bOk ;
-}
-
-//----------------------------------------------------------------------------
-bool
-ExeCurveBezierDecreaseDegree( int nCrvId, double dTol) 
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
-   // recupero la curva
-   const ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( nCrvId)) ;
-   if ( pCrv == nullptr)
-      return false ;
-   //// recupero il riferimento della curva
-   //Frame3d frCrv ;
-   //if ( ! pGeomDB->GetGlobFrame( nCrvId, frCrv))
-   //   return GDB_ID_NULL ;
-
-   if( pCrv->GetType() != CRV_BEZIER)
-      return false ;
-
-   // riduco il grado della curva
-   bool bOk = true ;
-   PtrOwner<ICurveBezier> pCrvBezierNew ( BezierDecreaseDegree( GetCurveBezier( pCrv), dTol)) ;
-   bOk = bOk  &&  ! IsNull( pCrvBezierNew)  &&  pCrvBezierNew->IsValid() ;
-   Vector3d vtExtr ;
-   if ( bOk && pCrv->GetExtrusion( vtExtr))
-      pCrvBezierNew->SetExtrusion( vtExtr) ;
-   double dThick = 0 ;
-   if ( bOk  &&  pCrv->GetThickness( dThick))
-      pCrvBezierNew->SetThickness(dThick) ;
-   // sostituisco la vecchia curva con la nuova
-   bOk = bOk && pGeomDB->ReplaceGeoObj( nCrvId, Release( pCrvBezierNew)) ;
-   ExeSetModified() ;
-
-   if ( IsCmdLog()) {
-      string sLua = "EgtCurveBezierDecreaseDegree(" + ToString( nCrvId) + ")"
-                    " -- Ok=" + ToString( bOk) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-
-   return bOk ;
-}
-
-//----------------------------------------------------------------------------
-bool
-ExeCurveBezierApproxToNonRat( int nCrvId, double dTol)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
-   // recupero la curva
-   const ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( nCrvId)) ;
-   if ( pCrv == nullptr)
-      return false ;
-   //// recupero il riferimento della curva
-   //Frame3d frCrv ;
-   //if ( ! pGeomDB->GetGlobFrame( nCrvId, frCrv))
-   //   return GDB_ID_NULL ;
-
-   // controllo che il tipo sia giusto
-   if( pCrv->GetType() != CRV_BEZIER) {
-      if( pCrv->GetType() != CRV_COMPO)
-         return false ;
-      else {
-         const ICurveComposite* pCC = GetCurveComposite( pCrv) ;
-         for ( int i = 0 ; i < pCC->GetCurveCount() ; ++i) {
-            const ICurve* pSubCrv = pCC->GetCurve( i) ;
-            if( pSubCrv->GetType() != CRV_BEZIER)
-               return false ;
-         }
-      }
-   }
-   bool bOk = true ;
-   if( pCrv->GetType() == CRV_BEZIER) {
-      const ICurveBezier* pCrvBez = GetCurveBezier( pCrv) ;
-      if( ! pCrvBez->IsRational())
-         return true ;
-
-      // approssimo la curva con una corrispettiva non razionale
-      PtrOwner<ICurveBezier> pCrvBezierNew ( pCrvBez->Clone()) ;
-      bOk = bOk  &&  pCrvBezierNew->MakeNonRational( dTol) ;
-      PtrOwner<ICurve> pCrvNew ;
-      if ( ! bOk) {
-         pCrvNew.Set( ApproxBezierWithCubics( pCrvBezierNew, dTol)) ;
-         bOk = bOk  &&  ! IsNull( pCrvNew)  &&  pCrvNew->IsValid() ;
-      }
-      else
-         pCrvNew.Set( Release( pCrvBezierNew)) ;
-      bOk = bOk  &&  ! IsNull( pCrvNew)  &&  pCrvNew->IsValid() ;
-      Vector3d vtExtr ;
-      if ( bOk && pCrv->GetExtrusion( vtExtr))
-         pCrvNew->SetExtrusion( vtExtr) ;
-      double dThick = 0 ;
-      if ( bOk  &&  pCrv->GetThickness( dThick))
-         pCrvNew->SetThickness(dThick) ;
-      // sostituisco la vecchia curva con la nuova
-      bOk = bOk && pGeomDB->ReplaceGeoObj( nCrvId, Release( pCrvNew)) ;
-   }
-   else {
-      const ICurveComposite* pCC = GetCurveComposite( pCrv) ;
-      PtrOwner<ICurveComposite> pCCNew( CreateCurveComposite()) ;
-      for( int i = 0 ; i < pCC->GetCurveCount() ; ++i) {
-         const ICurveBezier* pCrvBez = GetCurveBezier( pCC->GetCurve( i)) ;
-         if( ! pCrvBez->IsRational()) {
-            continue ;
-         }
-
-         // approssimo la curva con una corrispettiva non razionale
-         PtrOwner<ICurveBezier> pCrvBezierNew ( pCrvBez->Clone()) ;
-         bOk = bOk  &&  pCrvBezierNew->MakeNonRational( dTol) ;
-         PtrOwner<ICurve> pCrvNew ;
-         if ( ! bOk) {
-            pCrvNew.Set( ApproxBezierWithCubics( pCrvBezierNew, dTol)) ;
-            bOk = bOk  &&  ! IsNull( pCrvNew)  &&  pCrvNew->IsValid() ;
-         }
-         else
-            pCrvNew.Set( Release( pCrvBezierNew)) ;
-         bOk = bOk  &&  ! IsNull( pCrvNew)  &&  pCrvNew->IsValid() ;
-         Vector3d vtExtr ;
-         if ( bOk && pCrv->GetExtrusion( vtExtr))
-            pCrvNew->SetExtrusion( vtExtr) ;
-         double dThick = 0 ;
-         if ( bOk  &&  pCrv->GetThickness( dThick))
-            pCrvNew->SetThickness(dThick) ;
-         if( bOk)
-            pCCNew->AddCurve( Release(pCrvNew)) ;
-         else
-            break ;
-      }
-      // sostituisco la vecchia curva con la nuova
-      bOk = bOk && pGeomDB->ReplaceGeoObj( nCrvId, Release( pCCNew)) ;
-   }
-   ExeSetModified() ;
-
-   if ( IsCmdLog()) {
-      string sLua = "EgtCurveBezierApproxToNonRat(" + ToString( nCrvId) + ", "
-                                                    + ToString( dTol) + ")"
-                    " -- Ok=" + ToString( bOk) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-
-   return bOk ;
-}
-
-//----------------------------------------------------------------------------
-bool
-ExeCurveBezierApproxWithCubicBeziers( int nCrvId, double dTol)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
-   // recupero la curva
-   const ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( nCrvId)) ;
-   if ( pCrv == nullptr)
-      return false ;
-
-   // controllo che il tipo sia giusto
-   if( pCrv->GetType() != CRV_BEZIER) {
-      if( pCrv->GetType() != CRV_COMPO)
-         return false ;
-      else {
-         const ICurveComposite* pCC = GetCurveComposite( pCrv) ;
-         for ( int i = 0 ; i < pCC->GetCurveCount() ; ++i) {
-            const ICurve* pSubCrv = pCC->GetCurve( i) ;
-            if( pSubCrv->GetType() != CRV_BEZIER)
-               return false ;
-         }
-      }
-   }
-
-   // converto in bezier cubiche
-   bool bOk = true ;
-   if( pCrv->GetType() == CRV_BEZIER) {
-      const ICurveBezier* pCrvBez = GetCurveBezier( pCrv) ;
-
-      // approssimo la curva con una serie di bezier
-      PtrOwner<ICurve> pCrvBezierNew ( ApproxBezierWithCubics( pCrvBez, dTol)) ;
-      bOk = bOk  &&  ! IsNull( pCrvBezierNew)  &&  pCrvBezierNew->IsValid() ;
-      Vector3d vtExtr ;
-      if ( bOk && pCrv->GetExtrusion( vtExtr))
-         pCrvBezierNew->SetExtrusion( vtExtr) ;
-      double dThick = 0 ;
-      if ( bOk  &&  pCrv->GetThickness( dThick))
-         pCrvBezierNew->SetThickness(dThick) ;
-      // sostituisco la vecchia curva con la nuova
-      bOk = bOk && pGeomDB->ReplaceGeoObj( nCrvId, Release( pCrvBezierNew)) ;
-   }
-   else {
-      const ICurveComposite* pCC = GetCurveComposite( pCrv) ;
-      PtrOwner<ICurveComposite> pCCNew( CreateCurveComposite()) ;
-      for( int i = 0 ; i < pCC->GetCurveCount() ; ++i) {
-         const ICurveBezier* pCrvBez = GetCurveBezier( pCC->GetCurve( i)) ;
-         if( ! pCrvBez->IsRational()) {
-            continue ;
-         }
-
-         // approssimo la curva con una serie di bezier
-         PtrOwner<ICurve> pCrvBezierNew ( ApproxBezierWithCubics( pCrvBez, dTol)) ;
-         bOk = bOk  &&  ! IsNull( pCrvBezierNew)  &&  pCrvBezierNew->IsValid() ;
-         Vector3d vtExtr ;
-         if ( bOk && pCrv->GetExtrusion( vtExtr))
-            pCrvBezierNew->SetExtrusion( vtExtr) ;
-         double dThick = 0 ;
-         if ( bOk  &&  pCrv->GetThickness( dThick))
-            pCrvBezierNew->SetThickness(dThick) ;
-         if( bOk)
-            pCCNew->AddCurve( Release(pCrvBezierNew)) ;
-         else
-            break ;
-      }
-      // sostituisco la vecchia curva con la nuova
-      bOk = bOk && pGeomDB->ReplaceGeoObj( nCrvId, Release( pCCNew)) ;
-   }
-
-   ExeSetModified() ;
-
-   if ( IsCmdLog()) {
-      string sLua = "EgtCurveBezierApproxWithCubicBeziers(" + ToString( nCrvId) + ", "
-                                                            + ToString( dTol) + ")"
-                     " -- Ok=" + ToString( bOk) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-
-   return bOk ;
-}

EXE_GdbModifySurf.cpp

@@ -102,33 +102,6 @@ MyExplodeSurfTriMesh( int nId, int& nCount)
      // 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
@@ -324,7 +297,7 @@ ExeSurfFrSubtract( int nId1, int nId2)
   // eseguo la sottrazione della seconda superficie dalla prima
    bOk = bOk && pSfr1->Subtract( *pSfr2L) ;
   // se il risultato è vuoto, cancello la FlatRegion
-   if ( bOk  &&  ! pSfr1->IsValid())
+   if ( bOk  && ! pSfr1->IsValid())
       pGeomDB->Erase( nId1) ;
    ExeSetModified() ;
   // se richiesto, salvo il comando Lua equivalente
@@ -356,7 +329,7 @@ ExeSurfFrIntersect( int nId1, int nId2)
   // eseguo l'intersezione tra le due superfici
    bOk = bOk && pSfr1->Intersect( *pSfr2L) ;
   // se il risultato è vuoto, cancello la FlatRegion
-   if ( bOk  &&  ! pSfr1->IsValid())
+   if ( bOk  && ! pSfr1->IsValid())
       pGeomDB->Erase( nId1) ;
    ExeSetModified() ;
   // se richiesto, salvo il comando Lua equivalente
@@ -381,7 +354,7 @@ ExeSurfFrOffset( int nId, double dDist, int nType)
   // eseguo l'offset
    bOk = bOk && pSfr->Offset( dDist, nType) ;
   // se il risultato è vuoto, cancello la FlatRegion
-   if ( bOk  &&  ! pSfr->IsValid())
+   if ( bOk  && ! pSfr->IsValid())
       pGeomDB->Erase( nId) ;
    ExeSetModified() ;
   // se richiesto, salvo il comando Lua equivalente
@@ -400,7 +373,7 @@ bool
 ExeSurfFrOffsetAdv( int nId, double dDist, int nType, int& nNewId)
 {
    IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
+   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
   // recupero la superficie FlatRegion
    ISurfFlatRegion* pSfr = GetSurfFlatRegion( pGeomDB->GetGeoObj( nId)) ;
    if ( pSfr == nullptr)
@@ -421,32 +394,6 @@ ExeSurfFrOffsetAdv( int nId, double dDist, int nType, int& nNewId)
    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)
@@ -1127,45 +1074,6 @@ ExeSurfTmSubtractProjectedFacesOnFace( int nSurfId, int nFaceInd, int nDestGrpId
    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)
@@ -1210,20 +1118,6 @@ ExeSurfTmSetShowEdges( int nId, bool bShow)
    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
-   bShow = ( bOk && pStm->GetShowEdges()) ;
-   return bOk ;
-}
-
 //----------------------------------------------------------------------------
 static bool 
 MySurfBzTrim( int nId, int nTrimmerId)
@@ -1260,31 +1154,10 @@ ExeSurfBzTrim( int nId, int nCutterId)
    ExeSetModified() ;
    // se richiesto, salvo il comando Lua equivalente
    if ( IsCmdLog()) {
-      string sLua = "EgtSurfBzCut(" + ToString( nId) + "," +
+      string sLua = "EgtSurfTmCut(" + ToString( nId) + "," +
          ToString( nCutterId) + "," +
          " -- Ok=" + ToString( bOk) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
    }
    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 ;
-   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 ;
-}

EXE_GdbModifyVol.cpp

@@ -337,34 +337,6 @@ ExeVolZmapSetChiselTool( const INTVECTOR& vIds, const string& sToolName,
    return bOk ;
 }
 
-//----------------------------------------------------------------------------
-bool
-ExeVolZmapSetAdditiveTool( const INTVECTOR& vIds, const string& sToolName,
-                           double dLen, double dDiam, double dCornR, int nFlag, bool bFirst)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-  // recupero gli Zmap e assegno i dati dell'utensile
-   bool bOk = true ;
-   for ( int i = 0 ; i < int( vIds.size()) ; ++ i) {
-      IVolZmap* pVZM = GetVolZmap( pGeomDB->GetGeoObj( vIds[i])) ;
-      bOk = ( bOk && pVZM != nullptr && pVZM->SetAdditiveTool( sToolName, dLen, dDiam / 2, dCornR, nFlag, bFirst)) ;
-   }
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtVolZmapSetAdditiveTool({" + IdListToString( vIds) + "}," +
-                                                  sToolName + "," +
-                                                  ToString( dLen) + "," +
-                                                  ToString( dDiam) + "," +
-                                                  ToString( dCornR) + "," +
-                                                  ToString( nFlag) + ")" +
-                    " -- Ok=" + ToString( bOk) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-  // restituisco risultato
-   return bOk ;
-}
-
 //----------------------------------------------------------------------------
 bool
 ExeVolZmapResetTools( const INTVECTOR& vIds)

EXE_GdbObjAttribs.cpp

@@ -232,12 +232,12 @@ ExeGetCalcStatus( int nId, int* pnStat)
 
 //-----------------------------------------------------------------------------
 bool
-ExeSetMark( int nId, int nMark)
+ExeSetMark( int nId)
 {
    IGeomDB* pGeomDB = GetCurrGeomDB() ;
    VERIFY_GEOMDB( pGeomDB, false)
   // imposto l'evidenziazione
-   bool bOk = pGeomDB->SetMark( nId, nMark) ;
+   bool bOk = pGeomDB->SetMark( nId) ;
   // non produce modifica perchè mark ignorato in salvataggio  
    return bOk ;
 }
@@ -826,13 +826,3 @@ ExeGetTextureFrame( int nId, int nRefId, Frame3d& frTxrRef)
   // gestione trasformazione ( eventuale)
    return TransformFrame( pGeomDB, nId, nRefId, frTxrRef) ;
 }
-
-//-----------------------------------------------------------------------------
-bool
-ExeSetStipple( int nId, int nFactor, int nPattern)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-  // setto stipple
-   return pGeomDB->SetStipple( nId, nFactor, nPattern) ;
-}

EXE_GdbObjects.cpp

@@ -219,43 +219,6 @@ ExeGetPrevName( int nId, const string& sName)
    return pGeomDB->GetPrevName( nId, sName) ;
 }
 
-//-----------------------------------------------------------------------------
-bool
-ExeGetNameInGroup( int nGroupId, const string& sName, INTVECTOR& vIds)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-   if ( ! pGeomDB->ExistsObj( nGroupId))
-      return false ;
-  // recupero gli oggetti con il nome desiderato
-   vIds.clear() ;
-   int nId = pGeomDB->GetFirstNameInGroup( nGroupId, sName) ;
-   while ( nId != GDB_ID_NULL) {
-      vIds.push_back( nId) ;
-      nId = pGeomDB->GetNextName( nId, sName) ;
-   }
-   return true ;
-}
-
-//-----------------------------------------------------------------------------
-bool
-ExeGetInfoInGroup( int nGroupId, const string& sKey, INTVECTOR& vIds)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-   if ( ! pGeomDB->ExistsObj( nGroupId))
-      return false ;
-  // recupero gli oggetti con l'info desiderata
-   vIds.clear() ;
-   int nId = pGeomDB->GetFirstInGroup( nGroupId) ;
-   while ( nId != GDB_ID_NULL) {
-      if ( pGeomDB->ExistsInfo( nId, sKey))
-         vIds.push_back( nId) ;
-      nId = pGeomDB->GetNext( nId) ;
-   }
-   return true ;
-}
-
 //-----------------------------------------------------------------------------
 bool
 ExeGetBBox( int nId, int nFlag, BBox3d& b3Box)

EXE_General.cpp

@@ -35,7 +35,6 @@
 #include "/EgtDev/Include/EgtIniFile.h"
 #include "/EgtDev/Include/EgtLogger.h"
 #include "/EgtDev/Include/EgtStringConverter.h"
-#include "/EgtDev/Include/EgtKeyCodes.h"
 #include "/EgtDev/Include/SELkLockId.h"
 #include "/EgtDev/Include/SELkKeyProc.h"
 #include <fstream>
@@ -118,8 +117,9 @@ ExeInit( int nDebug, const string& sLogFile, const string& sLogMsg)
    if ( LoadExchangeDll( s_pGenLog, s_sKey, s_bNetHwKey))
       LOG_INFO( s_pGenLog, MyGetEExVersion())
 
-  // la libreria exchange 3dm opzionale viene caricata solo al momento del bisogno
-  // (è molto lento il caricamento di OpenNurbs)
+  // carico libreria exchange 3dm opzionale
+   if ( LoadExch3dmDll( s_pGenLog, s_sKey, s_bNetHwKey))
+      LOG_INFO( s_pGenLog, MyGetEE3Version())
 
   // carico libreria di lavorazione opzionale
    if ( LoadMachKernelDll( s_pGenLog, s_sKey, s_bNetHwKey))
@@ -352,34 +352,6 @@ ExeGetNetHwKey( void)
    return s_bNetHwKey ;
 }
 
-//-----------------------------------------------------------------------------
-bool
-ExeVerifyKeyOption( int nOptInd)
-{
-  // recupero le opzioni abilitate
-   unsigned int nOpt1, nOpt2 ;
-   int nOptExpDays ;
-   int nRet = GetEGnKeyOptions( KEY_BASELIB_PROD, KEY_BASELIB_VER, KEY_BASELIB_LEV,
-                                nOpt1, nOpt2, nOptExpDays) ;
-   if ( ! ExeGetNetHwKey())
-      nRet = GetKeyOptions( ExeGetKey(), KEY_BASELIB_PROD, KEY_BASELIB_VER, KEY_BASELIB_LEV,
-                            nOpt1, nOpt2, nOptExpDays) ;
-  // verifico validità chiave con licenza
-   if ( nRet != KEY_OK  ||  nOptExpDays < GetCurrDay())
-      return false ;
-  // verifico le opzioni (nOptInd = 100 -> bit 0 di Opt1 ... = 200 -> bit 0 di Opt2 ... = 231 -> bit 31 di Opt2)
-   if ( nOptInd >= 100  &&  nOptInd <= 131) {
-      unsigned int nOptVal = ( 1 << ( nOptInd - 100)) ;
-      return ( ( nOpt1 & nOptVal) != 0) ;
-   }
-   else if ( nOptInd >= 200  &&  nOptInd <= 231) {
-      unsigned int nOptVal = ( 1 << ( nOptInd - 200)) ;
-      return ( ( nOpt2 & nOptVal) != 0) ;
-   }
-   else
-      return false ;
-}
-
 //-----------------------------------------------------------------------------
 bool
 ExeSetFont( const string& sNfeFontDir, const string& sDefaultFont)

EXE_MachMgr.cpp

@@ -21,11 +21,9 @@
 #include "/EgtDev/Include/EXeExecutor.h"
 #include "/EgtDev/Include/EXeConst.h"
 #include "/EgtDev/Include/EGkStringUtils3d.h"
-#include "/EgtDev/Include/EMkToolConst.h"
 #include "/EgtDev/Include/EMkOperationConst.h"
 #include "/EgtDev/Include/EMkSimuGenConst.h"
 #include "/EgtDev/Include/EGnFileUtils.h"
-#include "/EgtDev/Include/EGnEgtUUID.h"
 #include "/EgtDev/Include/EgtStringConverter.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
 
@@ -997,7 +995,7 @@ ExeGetTableAreaOffset( int nInd, BBox3d& b3AreaOffs)
 {
    IMachMgr* pMachMgr = GetCurrMachMgr() ;
    VERIFY_MACHMGR( pMachMgr, false)
-  // recupero l'estensione dell'area utile con offset della fase corrente della tavola corrente della macchinata corrente
+  // recupero l'estensione dell'area utile con offset della tavola corrente della macchinata corrente
    return pMachMgr->GetTableAreaOffset( nInd, b3AreaOffs) ;
 }
 
@@ -1021,64 +1019,6 @@ ExeShowOnlyTable( bool bVal)
    return pMachMgr->ShowOnlyTable( bVal) ;
 }
 
-//-----------------------------------------------------------------------------
-bool
-ExeMoveDispAxis( const string& sName, double dPos)
-{
-   IMachMgr* pMachMgr = GetCurrMachMgr() ;
-   VERIFY_MACHMGR( pMachMgr, GDB_ID_NULL)
-  // eseguo e registro il movimento dell'asse
-   bool bOk = pMachMgr->MoveDispAxis( sName, dPos) ;
-   ExeSetModified() ;
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtMoveDispAxis('" + StringToLuaString( sName) + "'," +
-                                          ToString( dPos) + ")" +
-                    " -- Ok=" + ToString( bOk) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-  // restituisco il risultato
-   return bOk ;
-}
-
-//-----------------------------------------------------------------------------
-bool
-ExeRemoveDispAxis( const string& sName)
-{
-   IMachMgr* pMachMgr = GetCurrMachMgr() ;
-   VERIFY_MACHMGR( pMachMgr, GDB_ID_NULL)
-  // eseguo e registro la rimozione del movimento dell'asse
-   bool bOk = pMachMgr->RemoveDispAxis( sName) ;
-   ExeSetModified() ;
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtRemoveDispAxis('" + StringToLuaString( sName) + "')" +
-                    " -- Ok=" + ToString( bOk) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-  // restituisco il risultato
-   return bOk ;
-}
-
-//-----------------------------------------------------------------------------
-bool
-ExeKeepAllDispAxes( int nSouPhase)
-{
-   IMachMgr* pMachMgr = GetCurrMachMgr() ;
-   VERIFY_MACHMGR( pMachMgr, false)
-  // confermo i movimenti degli assi di disposizione nella fase corrente della macchinata corrente
-   bool bOk = pMachMgr->KeepAllDispAxes( nSouPhase) ;
-   ExeSetModified() ;
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtKeepAllDispAxes(" + ToString( nSouPhase) + ")" +
-                    " -- Ok=" + ToString( bOk) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-  // restituisco il risultato
-   return bOk ;
-}
-
 //-----------------------------------------------------------------------------
 int
 ExeAddFixture( const string& sName, const Point3d& ptPos, double dAngRotDeg, double dMov)
@@ -1090,10 +1030,10 @@ ExeAddFixture( const string& sName, const Point3d& ptPos, double dAngRotDeg, dou
    ExeSetModified() ;
   // se richiesto, salvo il comando Lua equivalente
    if ( IsCmdLog()) {
-      string sLua = "EgtAddFixture('" + StringToLuaString( sName) + "',{" +
-                                        ToString( ptPos) + "}," +
-                                        ToString( dAngRotDeg) + "," +
-                                        ToString( dMov) + ")" +
+      string sLua = "EgtAddFixture(" + sName + ",{" +
+                                       ToString( ptPos) + "}," +
+                                       ToString( dAngRotDeg) + "," +
+                                       ToString( dMov) + ")" +
                     " -- Id=" + ToString( nId) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
    }
@@ -1196,33 +1136,13 @@ ExeRotateFixture( int nFxtId, double dDeltaAngDeg)
 {
    IMachMgr* pMachMgr = GetCurrMachMgr() ;
    VERIFY_MACHMGR( pMachMgr, false)
-  // vario la rotazione del dispositivo di presa dell'angolo indicato
+  // ruoto il dispositivo di presa dell'angolo indicato
    bool bOk = pMachMgr->RotateFixture( nFxtId, dDeltaAngDeg) ;
    ExeSetModified() ;
   // se richiesto, salvo il comando Lua equivalente
    if ( IsCmdLog()) {
-      string sLua = "EgtRotateFixture(" + ToString( nFxtId) + "," +
-                                          ToString( dDeltaAngDeg) + ")" +
-                    " -- Ok=" + ToString( bOk) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-  // restituisco il risultato
-   return bOk ;
-}
-
-//-----------------------------------------------------------------------------
-bool
-ExeSetFixtureLink( int nFxtId, const string& sTaLink)
-{
-   IMachMgr* pMachMgr = GetCurrMachMgr() ;
-   VERIFY_MACHMGR( pMachMgr, false)
-  // imposto il collegamento all'asse di tavola indicato
-   bool bOk = pMachMgr->SetFixtureLink( nFxtId, sTaLink) ;
-   ExeSetModified() ;
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtSetFixtureLink(" + ToString( nFxtId) + ",'" +
-                                           StringToLuaString( sTaLink) + "')" +
+      string sLua = "EgtRotateFixture(" + ToString( nFxtId) + ",{" +
+                                          ToString( dDeltaAngDeg) + "})" +
                     " -- Ok=" + ToString( bOk) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
    }
@@ -1236,7 +1156,7 @@ ExeMoveFixtureMobile( int nFxtId, double dDeltaMove)
 {
    IMachMgr* pMachMgr = GetCurrMachMgr() ;
    VERIFY_MACHMGR( pMachMgr, false)
-  // varia il movimento della parte mobile della morsa della quantità indicata
+  // ruoto il dispositivo di presa dell'angolo indicato
    bool bOk = pMachMgr->MoveFixtureMobile( nFxtId, dDeltaMove) ;
    ExeSetModified() ;
   // se richiesto, salvo il comando Lua equivalente
@@ -1250,26 +1170,6 @@ ExeMoveFixtureMobile( int nFxtId, double dDeltaMove)
    return bOk ;
 }
 
-//-----------------------------------------------------------------------------
-bool
-ExeSetFixtureMobile( int nFxtId, double dMove)
-{
-   IMachMgr* pMachMgr = GetCurrMachMgr() ;
-   VERIFY_MACHMGR( pMachMgr, false)
-  // imposta il movimento della parte mobile della morsa alla quantità indicata
-   bool bOk = pMachMgr->SetFixtureMobile( nFxtId, dMove) ;
-   ExeSetModified() ;
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtSetFixtureMobile(" + ToString( nFxtId) + "," +
-                                             ToString( dMove) + ")" +
-                    " -- Ok=" + ToString( bOk) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-  // restituisco il risultato
-   return bOk ;
-}
-
 //-----------------------------------------------------------------------------
 //  DB utensili
 //-----------------------------------------------------------------------------
@@ -1572,21 +1472,6 @@ ExeTdbGetCurrToolThLength( double& dThLen)
    return pMachMgr->TdbGetCurrToolThLength( dThLen) ;
 }
 
-//-----------------------------------------------------------------------------
-bool
-ExeTdbCurrToolIsStandardDraw( bool& bStandard)
-{
-   IMachMgr* pMachMgr = GetCurrMachMgr() ;
-   VERIFY_MACHMGR( pMachMgr, false)
-  // recupero il nome del disegno dell'utensile
-   string sDraw ;
-   if ( ! pMachMgr->TdbGetCurrToolParam( TPA_DRAW, sDraw))
-      return false ;
-  // verifico il tipo
-   bStandard = IsUUID( GetFileTitleEgt( sDraw)) ;
-   return true ;
-}
-
 //-----------------------------------------------------------------------------
 int
 ExeTdbCurrToolDraw( int nGenCtx, int nToolCtx)
@@ -2466,16 +2351,6 @@ ExeSpecialUpdateDisposition( int nId)
    return bOk ;
 }
 
-//-----------------------------------------------------------------------------
-bool
-ExeGetDispositionToolData( int nId, string& sName, string& sHead, int& nExit, string& sTcPos)
-{
-   IMachMgr* pMachMgr = GetCurrMachMgr() ;
-   VERIFY_MACHMGR( pMachMgr, false)
-  // aggiorno assi macchina e collegamento con precedente della disposizione indicata
-   return pMachMgr->GetDispositionToolData( nId, sName, sHead, nExit, sTcPos) ;
-}
-
 //-----------------------------------------------------------------------------
 //   Lavorazioni
 //-----------------------------------------------------------------------------
@@ -2759,22 +2634,12 @@ ExeRemovePreviewMachiningTool( void)
 
 //-----------------------------------------------------------------------------
 int
-ExeGetPreviewMachiningToolStepCount( void)
+ExePreviewMachiningTool( int nEntId, int nFlag)
 {
    IMachMgr* pMachMgr = GetCurrMachMgr() ;
-   VERIFY_MACHMGR( pMachMgr, -1)
-  // restituisce il numero di passi per anteprima utensile presenti nella lavorazione
-   return pMachMgr->GetPreviewMachiningToolStepCount() ;
-}
-
-//-----------------------------------------------------------------------------
-int
-ExePreviewMachiningTool( int nEntId, int nStep)
-{
-   IMachMgr* pMachMgr = GetCurrMachMgr() ;
-   VERIFY_MACHMGR( pMachMgr, GDB_ID_NULL)
+   VERIFY_MACHMGR( pMachMgr, false)
   // visualizzazione anteprima utensile su lavorazione
-   return pMachMgr->PreviewMachiningTool( nEntId, nStep) ;
+   return pMachMgr->PreviewMachiningTool( nEntId, nFlag) ;
 }
 
 //-----------------------------------------------------------------------------
@@ -2827,16 +2692,6 @@ ExeGetMachiningGeometry( SELVECTOR& vIds)
    return pMachMgr->GetMachiningGeometry( vIds) ;
 }
 
-//-----------------------------------------------------------------------------
-bool
-ExeGetMachiningSkippedGeometry( SELVECTOR& vIds)
-{
-   IMachMgr* pMachMgr = GetCurrMachMgr() ;
-   VERIFY_MACHMGR( pMachMgr, false)
-  // recupero la geometria non lavorata della lavorazione corrente
-   return pMachMgr->GetMachiningSkippedGeometry( vIds) ;
-}
-
 //-----------------------------------------------------------------------------
 bool
 ExeIsMachiningEmpty( void)
@@ -3059,23 +2914,13 @@ ExeGetClEntIndex( int nEntId, int& nIndex)
    return pMachMgr->GetClEntIndex( nEntId, nIndex) ;
 }
 
-//-----------------------------------------------------------------------------
-bool
-ExeGetClEntAxesStatus( int nEntId, int& nStatus)
-{
-   IMachMgr* pMachMgr = GetCurrMachMgr() ;
-   VERIFY_MACHMGR( pMachMgr, false)
-  // recupero lo stato del movimento assi
-   return pMachMgr->GetClEntAxesStatus( nEntId, nStatus) ;
-}
-
 //-----------------------------------------------------------------------------
 bool
 ExeGetClEntAxesMask( int nEntId, int& nMask)
 {
    IMachMgr* pMachMgr = GetCurrMachMgr() ;
    VERIFY_MACHMGR( pMachMgr, false)
-  // recupero la mascheratura del movimento assi (valida solo in rapido)
+  // recupero la mascheratura del movimento assi
    return pMachMgr->GetClEntAxesMask( nEntId, nMask) ;
 }
 
@@ -3279,9 +3124,7 @@ ExeSimulate( int& nErr, string& sError)
    nErr = SHE_NONE ;
    sError = "" ;
   // disabilito UI
-   bool bPrevEnableUI = ExeGetEnableUI() ;
-   if ( bPrevEnableUI)
-      ExeSetEnableUI( false) ;
+   ExeSetEnableUI( false) ;
   // avvio simulazione
    if ( ! pMachMgr->SimInit()  ||  ! pMachMgr->SimStart( true)  ||  ! pMachMgr->SimStart( false)) {
      // inutile continuare con simulazione se avvio non riuscito
@@ -3343,8 +3186,7 @@ ExeSimulate( int& nErr, string& sError)
   // terminazione simulazione
    pMachMgr->SimExit() ;
   // riabilito UI
-   if ( bPrevEnableUI)
-      ExeSetEnableUI( true) ;
+   ExeSetEnableUI( true) ;
    return ( nErr == 0) ;
 }
 
@@ -3579,16 +3421,6 @@ ExeGetHeadExitCount( const string& sHead)
    return pMachMgr->GetHeadExitCount( sHead) ;
 }
 
-//-----------------------------------------------------------------------------
-int
-ExeGetExitId( const string& sHead, int nExit)
-{
-   IMachMgr* pMachMgr = GetCurrMachMgr() ;
-   VERIFY_MACHMGR( pMachMgr, GDB_ID_NULL)
-  // restituisco identificativo dell'uscita della testa indicata nella macchina della macchinata corrente
-   return pMachMgr->GetExitId( sHead, nExit) ;
-}
-
 //-----------------------------------------------------------------------------
 int
 ExeGetTcPosId( const string& sTcPos)
@@ -3619,16 +3451,6 @@ ExeGetAxisType( const string& sAxis, bool& bLinear)
    return pMachMgr->GetAxisType( sAxis, bLinear) ;
 }
 
-//-----------------------------------------------------------------------------
-bool
-ExeGetAxisDir( const string& sAxis, Vector3d& vtDir)
-{
-   IMachMgr* pMachMgr = GetCurrMachMgr() ;
-   VERIFY_MACHMGR( pMachMgr, false)
-  // recupero la direzione dell'asse
-   return pMachMgr->GetAxisDir( sAxis, vtDir) ;
-}
-
 //-----------------------------------------------------------------------------
 bool
 ExeGetAxisInvert( const string& sAxis, bool& bInvert)

EXE_NstMachining.cpp

@@ -254,7 +254,7 @@ ExeVerifyCutAsSplitting( int nMchId)
       pMachMgr->MachiningPreview( true) ;
      // verifico interferenza
       int nRes ;
-      if ( ExeVerifyMachining( nMchId, nRes)  &&  ( nRes == FMI_NONE  ||  nRes == FMI_LO))
+      if ( ExeVerifyMachining( nMchId, nRes)  &&  nRes == FMI_NONE)
          nResult += CAR_LI_OK ;
      // ripristino attacco originale
       pMachMgr->SetMachiningParam( MPA_LEADINTYPE, nLiType) ;
@@ -265,7 +265,7 @@ ExeVerifyCutAsSplitting( int nMchId)
    else {
      // verifico interferenza
       int nRes ;
-      if ( ExeVerifyMachining( nMchId, nRes)  &&  ( nRes == FMI_NONE  ||  nRes == FMI_LO))
+      if ( ExeVerifyMachining( nMchId, nRes)  &&  nRes == FMI_NONE)
          nResult += CAR_LI_OK ;
    }
   // verifico se posso portare uscita al bordo grezzo
@@ -276,7 +276,7 @@ ExeVerifyCutAsSplitting( int nMchId)
       pMachMgr->MachiningPreview( true) ;
      // verifico interferenza
       int nRes ;
-      if ( ExeVerifyMachining( nMchId, nRes)  &&  ( nRes == FMI_NONE  ||  nRes == FMI_LI))
+      if ( ExeVerifyMachining( nMchId, nRes)  &&  nRes == FMI_NONE)
          nResult += CAR_LO_OK ;
      // ripristino uscita originale
       pMachMgr->SetMachiningParam( MPA_LEADOUTTYPE, nLoType) ;
@@ -287,7 +287,7 @@ ExeVerifyCutAsSplitting( int nMchId)
    else {
      // verifico interferenza
       int nRes ;
-      if ( ExeVerifyMachining( nMchId, nRes)  &&  ( nRes == FMI_NONE  ||  nRes == FMI_LI))
+      if ( ExeVerifyMachining( nMchId, nRes)  &&  nRes == FMI_NONE)
          nResult += CAR_LO_OK ;
    }
   // verifico se taglio non passante

EXE_Scene.cpp

@@ -109,12 +109,12 @@ ExeSetLineAttribs( int nWidth)
 
 //-----------------------------------------------------------------------------
 bool
-ExeSetMarkAttribs( Color MarkCol, Color Mark2Col)
+ExeSetMarkAttribs( Color MarkCol)
 {
    IEGrScene* pScene = GetCurrScene() ;
    VERIFY_SCENE( pScene, false)
   // imposto il colore del Mark
-   return ( pScene->SetMark( MarkCol)  &&  pScene->SetMark2( Mark2Col)) ;
+   return pScene->SetMark( MarkCol) ;
 }
 
 //-----------------------------------------------------------------------------
@@ -228,7 +228,6 @@ ExeDraw( void)
   // se interfaccia disabilitata, esco subito
    if ( ! ExeGetEnableUI())
       return true ;
-
    GseContext* pGseCtx = GetCurrGseContext() ;
    VERIFY_CTX_SCENE( pGseCtx, false)
   // eseguo disegno
@@ -494,10 +493,6 @@ ExeZoomRadius( double dRadius, bool bRedraw)
 bool
 ExeZoom( int nZoom, bool bRedraw)
 {
-  // se interfaccia disabilitata, esco subito
-   if ( ! ExeGetEnableUI())
-      return true ;
-
    IEGrScene* pScene = GetCurrScene() ;
    VERIFY_SCENE( pScene, false)
 
@@ -658,10 +653,6 @@ ExeSetViewOrizzOffsStep( int nDirOffsStep)
 bool
 ExeSetView( int nDir, bool bRedraw)
 {
-  // se interfaccia disabilitata, esco subito
-   if ( ! ExeGetEnableUI())
-      return true ;
-
    IEGrScene* pScene = GetCurrScene() ;
    VERIFY_SCENE( pScene, false)
   // imposto vista
@@ -896,28 +887,3 @@ ExeGetImage( int nShowMode, Color colBackTop, Color colBackBottom,
   // creo e salvo una immagine della scena
    return pScene->GetImage( nShowMode, colBackTop, colBackBottom, nWidth, nHeight, sFile) ;
 }
-
-//-----------------------------------------------------------------------------
-bool
-ExeSetCameraType( bool bOrthoOrPersp, bool bRedraw)
-{
-   IEGrScene* pScene = GetCurrScene() ;
-   VERIFY_SCENE( pScene, false)
-   pScene->SetCameraType( bOrthoOrPersp) ;
-   if ( bRedraw)
-      pScene->RedrawWindow() ;
-   return true ;
-}
-
-//-----------------------------------------------------------------------------
-bool
-ExeSetZoomType( int nMode, bool bRedraw)
-{
-   IEGrScene* pScene = GetCurrScene() ;
-   VERIFY_SCENE( pScene, false)
-   if ( ! pScene->SetZoomType( nMode))
-      return false ;
-   if ( bRedraw)
-      pScene->RedrawWindow() ;
-   return true ;
-}

EgtExecutor.vcxproj

@@ -22,14 +22,14 @@
     <ProjectGuid>{DF654897-F85B-4108-A621-F2C4AB099A48}</ProjectGuid>
     <Keyword>Win32Proj</Keyword>
     <RootNamespace>EgtExecutor</RootNamespace>
-    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+    <WindowsTargetPlatformVersion>10.0.20348.0</WindowsTargetPlatformVersion>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
     <CharacterSet>Unicode</CharacterSet>
-    <PlatformToolset>v143</PlatformToolset>
+    <PlatformToolset>v141_xp</PlatformToolset>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>
@@ -42,7 +42,7 @@
     <UseDebugLibraries>false</UseDebugLibraries>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>Unicode</CharacterSet>
-    <PlatformToolset>v143</PlatformToolset>
+    <PlatformToolset>v141_xp</PlatformToolset>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>

LUA_Exchange.cpp

@@ -154,52 +154,16 @@ LuaImportStl( lua_State* L)
    return 1 ;
 }
 
-//-------------------------------------------------------------------------------
-static int
-LuaImportOff( lua_State* L)
-{
-  // 1 o 2 parametri : path del file da importare [, Fattore di scala]
-   string sFilePath ;
-   LuaCheckParam( L, 1, sFilePath)
-   double dScaleFactor = 1.0 ;
-   LuaGetParam( L, 2, dScaleFactor) ;
-   LuaClearStack( L) ;
-  // apro il file
-   bool bOk = ExeImportOff( sFilePath, dScaleFactor) ; 
-  // restituisco il risultato
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaImportPly( lua_State* L)
-{
-  // 1 o 2 parametri : path del file da importare [, Fattore di scala]
-   string sFilePath ;
-   LuaCheckParam( L, 1, sFilePath)
-   double dScaleFactor = 1.0 ;
-   LuaGetParam( L, 2, dScaleFactor) ;
-   LuaClearStack( L) ;
-  // apro il file
-   bool bOk = ExeImportPly( sFilePath, dScaleFactor) ; 
-  // restituisco il risultato
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
 //-------------------------------------------------------------------------------
 static int
 LuaImport3MF( lua_State* L)
 {
-  // 1 o 2 parametri : path del file da importare [, flag]
+  // 1 parametro : path del file da importare
    string sFilePath ;
-   LuaCheckParam( L, 1, sFilePath) 
-   int nFlag = 0 ;
-   LuaGetParam( L, 2, nFlag) ;
+   LuaCheckParam( L, 1, sFilePath)
    LuaClearStack( L) ;
   // apro il file
-   bool bOk = ExeImport3MF( sFilePath, nFlag) ; 
+   bool bOk = ExeImport3MF( sFilePath) ; 
   // restituisco il risultato
    LuaSetParam( L, bOk) ;
    return 1 ;
@@ -368,8 +332,6 @@ LuaInstallExchange( LuaMgr& luaMgr)
    bOk = bOk && luaMgr.RegisterFunction( "EgtImportDxf", LuaImportDxf) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtImportPnt", LuaImportPnt) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtImportStl", LuaImportStl) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtImportOff", LuaImportOff) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtImportPly", LuaImportPly) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtImport3MF", LuaImport3MF) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtImport3dm", LuaImport3dm) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtAdvancedImport", LuaAdvancedImport) ;

LUA_GdbCreateCurve.cpp

@@ -425,34 +425,6 @@ LuaCreateArc3P( lua_State* L)
    return 1 ;
 }
 
-//-------------------------------------------------------------------------------
-static int
-LuaCreateArc2PR( lua_State* L)
-{
-  // 5 o 6 parametri : ParentId, PtStart, PtEnd, dRad, bCCW [, nRefType]
-   int nParentId ;
-   LuaCheckParam( L, 1, nParentId)
-   Point3d ptStart ;
-   LuaCheckParam( L, 2, ptStart)
-   Point3d ptEnd ;
-   LuaCheckParam( L, 3, ptEnd)
-   double dRad ;
-   LuaCheckParam( L, 4, dRad)
-   bool bCCW ;
-   LuaCheckParam( L, 5, bCCW) ;
-   int nRefType = RTY_DEFAULT ;
-   LuaGetParam( L, 6, nRefType) ;
-   LuaClearStack( L) ;
-  // creo l'arco
-   int nId = ExeCreateArc2PR( nParentId, ptStart, ptEnd, dRad, bCCW, nRefType) ;
-  // restituisco il risultato
-   if ( nId != GDB_ID_NULL)
-      LuaSetParam( L, nId) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
 //-------------------------------------------------------------------------------
 static int
 LuaCreateArc2PB( lua_State* L)
@@ -1091,27 +1063,6 @@ LuaCreateCirclesAlongCurve( lua_State* L)
    return 2 ;
 }
 
-//-------------------------------------------------------------------------------
-static int
-LuaCreateCurveBezierForm( lua_State* L)
-{
-  // 2 o 3 parametri : ParentId, nCrvId [, nDeg]
-   int nParentId ;
-   LuaCheckParam( L, 1, nParentId)
-   int nCrvId ;
-   LuaCheckParam( L, 2, nCrvId)
-   int nDeg = 3 ;
-   LuaGetParam( L, 3, nDeg) ;
-  // creo la versione bezier della curva
-   int nId = ExeCreateCurveBezierForm( nParentId, nCrvId, nDeg) ;
-  // restituisco il risultato
-   if ( nId != GDB_ID_NULL)
-      LuaSetParam( L, nId) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
 //-------------------------------------------------------------------------------
 bool
 LuaInstallGdbCreateCurve( LuaMgr& luaMgr)
@@ -1132,7 +1083,6 @@ LuaInstallGdbCreateCurve( LuaMgr& luaMgr)
    bOk = bOk && luaMgr.RegisterFunction( "EgtArcC2P", LuaCreateArcC2P) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtArcC2PEx", LuaCreateArcC2PEx) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtArc3P", LuaCreateArc3P) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtArc2PR", LuaCreateArc2PR) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtArc2PB", LuaCreateArc2PB) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtArc2PD", LuaCreateArc2PD) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtArc2PDEx", LuaCreateArc2PDEx) ;
@@ -1156,6 +1106,5 @@ LuaInstallGdbCreateCurve( LuaMgr& luaMgr)
    bOk = bOk && luaMgr.RegisterFunction( "EgtPolygonFromApothem", LuaCreatePolygonFromApothem) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtPolygonFromSide", LuaCreatePolygonFromSide) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtCirclesAlongCurve", LuaCreateCirclesAlongCurve) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtCurveBezierForm", LuaCreateCurveBezierForm) ;
    return bOk ;
 }

LUA_GdbCreateSurf.cpp

@@ -171,24 +171,6 @@ LuaCreateSurfFrFatCurve( lua_State* L)
    return 1 ;
 }
 
-//-------------------------------------------------------------------------------
-static int
-LuaCreateSurfTmEmpty( lua_State* L)
-{
-  // 1 parametro : ParentId
-   int nParentId ;
-   LuaCheckParam( L, 1, nParentId)
-   LuaClearStack( L) ;
-  // creo STM vuoto
-   int nId = ExeCreateSurfTmEmpty( nParentId) ;
-  // restituisco il risultato
-   if ( nId != GDB_ID_NULL)
-      LuaSetParam( L, nId) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
 //-------------------------------------------------------------------------------
 static int
 LuaCreateSurfTmPlaneInBBox( lua_State* L)
@@ -527,9 +509,11 @@ LuaCreateSurfTmByExtrusion( lua_State* L)
    Vector3d vtExtr ;
    LuaCheckParam( L, 3, vtExtr)
    double dLinTol = LIN_TOL_SRF ;
-   LuaGetParam( L, 4, dLinTol) ;
    int nRefType = RTY_DEFAULT ;
-   LuaGetParam( L, 5, nRefType) ;
+   if ( LuaGetParam( L, 4, dLinTol))
+      LuaGetParam( L, 5, nRefType) ;
+   else
+      LuaGetParam( L, 4, nRefType) ;
    LuaClearStack( L) ;
   // creo STM estrudendo uno o più percorsi, se piani si possono mettere i tappi
    int nId = ExeCreateSurfTmByExtrusion( nParentId, vCrvIds, vtExtr,
@@ -993,310 +977,6 @@ LuaCreateBezierSphere( lua_State* L)
    return 2 ;
 }
 
-//-------------------------------------------------------------------------------
-static int
-LuaCreateSurfBzByFlatContour( lua_State* L)
-{
-   // 2 o 3 parametri : ParentId, CrvId [, dTol]
-   int nParentId ;
-   LuaCheckParam( L, 1, nParentId)
-   int nCrvId ;
-   LuaCheckParam( L, 2, nCrvId)
-   double dLinTol = LIN_TOL_SRF ;
-   if ( lua_gettop( L) >= 3)
-      LuaCheckParam( L, 3, dLinTol) ;
-   LuaClearStack( L) ;
-   // creo Sbz piana e la trimmo con il contorno
-   int nId = ExeCreateSurfBzByFlatContour( nParentId, nCrvId, dLinTol) ;
-   // restituisco il risultato
-   if ( nId != GDB_ID_NULL)
-      LuaSetParam( L, nId) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaCreateSurfBzByRegion( lua_State* L)
-{
-   // 2 o 3 parametri : ParentId, CrvIds [, dTol]
-   int nParentId ;
-   LuaCheckParam( L, 1, nParentId)
-   INTVECTOR vCrvIds ;
-   LuaCheckParam( L, 2, vCrvIds)
-   double dLinTol = LIN_TOL_SRF ;
-   if ( lua_gettop( L) >= 3)
-   LuaCheckParam( L, 3, dLinTol) ;
-   LuaClearStack( L) ;
-   // creo una Sbz piana a cui aggiungo le curve come trim
-   int nId = ExeCreateSurfBzByRegion( nParentId, vCrvIds, dLinTol) ;
-   // restituisco il risultato
-   if ( nId != GDB_ID_NULL)
-      LuaSetParam( L, nId) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
-
-//-------------------------------------------------------------------------------
-static int
-LuaCreateSurfBzByExtrusion( lua_State* L)
-{
-   // 3 o 4 o 5 o 6  parametri : ParentId, CrvId, vtExtr [, bool bCapEnds] [, dTol] [, nRefType]
-   int nParentId ;
-   LuaCheckParam( L, 1, nParentId)
-   int nCrvId ;
-   LuaCheckParam( L, 2, nCrvId)
-   Vector3d vtExtr ;
-   LuaCheckParam( L, 3, vtExtr)
-   bool bCapEnds = false ;
-   int nPar = 4 ;
-   if ( LuaGetParam( L, nPar, bCapEnds))
-      ++ nPar ;
-   double dLinTol = LIN_TOL_SRF ;
-   if ( LuaGetParam( L, nPar, dLinTol))
-      ++ nPar ;
-   int nRefType = RTY_DEFAULT ;
-   LuaGetParam( L, nPar, nRefType) ;
-   LuaClearStack( L) ;
-   // creo STM estrudendo uno o più percorsi, se piani si possono mettere i tappi
-   int nId = ExeCreateSurfBzByExtrusion( nParentId, nCrvId, vtExtr, bCapEnds, dLinTol, nRefType) ;
-   // restituisco il risultato
-   if ( nId != GDB_ID_NULL)
-      LuaSetParam( L, nId) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaCreateSurfBzByRegionExtrusion( lua_State* L)
-{
-   // 3 o 4 o 5 o 6  parametri : ParentId, CrvIds, vtExtr [, bool bCapEnds] [, dTol] [, nRefType]
-   int nParentId ;
-   LuaCheckParam( L, 1, nParentId)
-   INTVECTOR vCrvIds ;
-   LuaCheckParam( L, 2, vCrvIds)
-   Vector3d vtExtr ;
-   LuaCheckParam( L, 3, vtExtr)
-   bool bCapEnds = false ;
-   int nPar = 4 ;
-   if ( LuaGetParam( L, nPar, bCapEnds))
-      ++ nPar ;
-   double dLinTol = LIN_TOL_SRF ;
-   if ( LuaGetParam( L, nPar, dLinTol))
-      ++ nPar ;
-   int nRefType = RTY_DEFAULT ;
-   LuaGetParam( L, nPar, nRefType) ;
-   LuaClearStack( L) ;
-   // creo STM estrudendo uno o più percorsi, se piani si possono mettere i tappi
-   int nId = ExeCreateSurfBzByRegionExtrusion( nParentId, vCrvIds, vtExtr, bCapEnds, dLinTol, nRefType) ;
-   // restituisco il risultato
-   if ( nId != GDB_ID_NULL)
-      LuaSetParam( L, nId) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaCreateSurfBzByScrewing( lua_State* L)
-{
-   // 6 o 7 o 8 o 9 parametri : ParentId, CrvId, ptAx, vtAx, dAngRotDeg, dMove [, bCapEnds] [, dTol] [, nRefType]
-   int nParentId ;
-   LuaCheckParam( L, 1, nParentId)
-   int nCrvId ;
-   LuaCheckParam( L, 2, nCrvId)
-   Point3d ptAx ;
-   LuaCheckParam( L, 3, ptAx)
-   Vector3d vtAx ;
-   LuaCheckParam( L, 4, vtAx)
-   double dAngRotDeg ;
-   LuaCheckParam( L, 5, dAngRotDeg)
-   double dMove ;
-   LuaCheckParam( L, 6, dMove)
-   int nPar = 7 ;
-   bool bCapEnds = false ;
-   if ( LuaGetParam( L, nPar, bCapEnds))
-      ++ nPar ;
-   double dLinTol = LIN_TOL_SRF ;
-   if ( LuaGetParam( L, nPar, dLinTol))
-      ++ nPar ;
-   int nRefType = RTY_DEFAULT ;
-   if ( LuaGetParam( L, nPar, nRefType))
-      ++ nPar ;
-   LuaClearStack( L) ;
-   // creo STM riempiendo un contorno piano
-   int nId = ExeCreateSurfBzByScrewing( nParentId, nCrvId, ptAx, vtAx, dAngRotDeg, dMove, bCapEnds, dLinTol, nRefType) ;
-   // restituisco il risultato
-   if ( nId != GDB_ID_NULL)
-      LuaSetParam( L, nId) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaCreateSurfBzByRevolve( lua_State* L)
-{
-   // 4 o 5 o 6 o 7 parametri : ParentId, CrvId, ptAx, vtAx [, bCapEnds] [, dTol] [, nRefType]
-   int nParentId ;
-   LuaCheckParam( L, 1, nParentId)
-   int nCrvId ;
-   LuaCheckParam( L, 2, nCrvId)
-   Point3d ptAx ;
-   LuaCheckParam( L, 3, ptAx)
-   Vector3d vtAx ;
-   LuaCheckParam( L, 4, vtAx)
-   int nPar = 5 ;
-   bool bCapEnds = false ;
-   if ( LuaGetParam( L, nPar, bCapEnds))
-      ++ nPar ;
-   double dLinTol = LIN_TOL_SRF ;
-   if ( LuaGetParam( L, nPar, dLinTol))
-      ++ nPar ;
-   int nRefType = RTY_DEFAULT ;
-   if ( LuaGetParam( L, nPar, nRefType))
-      ++ nPar ;
-   LuaClearStack( L) ;
-   // creo STM riempiendo un contorno piano
-   int nId = ExeCreateSurfBzByRevolve( nParentId, nCrvId, ptAx, vtAx, bCapEnds, dLinTol, nRefType) ;
-   // restituisco il risultato
-   if ( nId != GDB_ID_NULL)
-      LuaSetParam( L, nId) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaCreateSurfBzByPointCurve( lua_State* L)
-{
-   // 4 o 5 o 6 o 7 parametri : ParentId, CrvId, ptAx, vtAx [, bCapEnds] [, dTol] [, nRefType]
-   int nParentId ;
-   LuaCheckParam( L, 1, nParentId)
-   int nCrvId ;
-   LuaCheckParam( L, 2, nCrvId)
-   Point3d ptTop ;
-   LuaCheckParam( L, 3, ptTop)
-   int nPar = 4 ;
-   bool bCapEnds = false ;
-   if ( LuaGetParam( L, nPar, bCapEnds))
-      ++ nPar ;
-   double dLinTol = LIN_TOL_SRF ;
-   if ( LuaGetParam( L, nPar, dLinTol))
-      ++ nPar ;
-   int nRefType = RTY_DEFAULT ;
-   if ( LuaGetParam( L, nPar, nRefType))
-      ++ nPar ;
-   LuaClearStack( L) ;
-   // creo STM riempiendo un contorno piano
-   int nId = ExeCreateSurfBzByPointCurve( nParentId, nCrvId, ptTop, bCapEnds, dLinTol, nRefType) ;
-   // restituisco il risultato
-   if ( nId != GDB_ID_NULL)
-      LuaSetParam( L, nId) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaCreateSurfBzRuled( lua_State* L)
-{
-   // 4 o 5 o 6 parametri : ParentId, CrvId1, CrvId2, nRuledType [, bCapEnds] [, dTol]
-   int nParentId ;
-   LuaCheckParam( L, 1, nParentId)
-   int nCrvId1 ;
-   LuaCheckParam( L, 2, nCrvId1)
-   int nCrvId2 ;
-   LuaCheckParam( L, 3, nCrvId2)
-   int nRuledType ;
-   LuaCheckParam( L, 4, nRuledType)
-   bool bCapEnds = false ;
-   int nPar = 5 ;
-   if ( LuaGetParam( L, nPar, bCapEnds))
-      ++ nPar ;
-   double dLinTol = LIN_TOL_SRF ;
-   LuaGetParam( L, nPar, dLinTol) ;
-   LuaClearStack( L) ;
-   // creo STM riempiendo un contorno piano
-   int nId = ExeCreateSurfBzRuled( nParentId, nCrvId1, nCrvId2, nRuledType, bCapEnds, dLinTol) ;
-   // restituisco il risultato
-   if ( nId != GDB_ID_NULL)
-      LuaSetParam( L, nId) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaCreateSurfBzSkinned( lua_State* L)
-{
-   // 2 o 3 o 4 parametri : ParentId, vCrvIds [, bCapEnds] [, dTol]
-   int nParentId ;
-   LuaCheckParam( L, 1, nParentId)
-   INTVECTOR vCrvIds ;
-   LuaCheckParam( L, 2, vCrvIds)
-   bool bCapEnds = false ;
-   int nPar = 3 ;
-   if ( LuaGetParam( L, nPar, bCapEnds))
-      ++ nPar ;
-   double dLinTol = LIN_TOL_SRF ;
-   LuaGetParam( L, nPar, dLinTol) ;
-   LuaClearStack( L) ;
-   // creo STM riempiendo un contorno piano
-   int nId = ExeCreateSurfBzSkinned( nParentId, vCrvIds, bCapEnds, dLinTol) ;
-   // restituisco il risultato
-   if ( nId != GDB_ID_NULL)
-      LuaSetParam( L, nId) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaCreateSurfBzSwept( lua_State* L)
-{
-   // 3 o 4 o 5 o 6 o 7  parametri : ParentId, nSectCrvId, nGuideCrvId [, vtAx] [, bCapEnds] [, dTol] [, nRefType]
-   int nParentId ;
-   LuaCheckParam( L, 1, nParentId)
-   int nSectId ;
-   LuaCheckParam( L, 2, nSectId)
-   int nGuideId ;
-   LuaCheckParam( L, 3, nGuideId)
-   Vector3d vtAx = V_NULL ;
-   int nPar = 4 ;
-   if ( LuaGetParam( L, nPar, vtAx))
-      ++ nPar ;
-   bool bCapEnds = false ;
-   if ( LuaGetParam( L, nPar, bCapEnds))
-      ++ nPar ;
-   double dLinTol = LIN_TOL_SRF ;
-   if ( LuaGetParam( L, nPar, dLinTol))
-      ++ nPar ;
-   int nRefType = RTY_DEFAULT ;
-   if ( LuaGetParam( L, nPar, dLinTol))
-      ++ nPar ;
-   LuaClearStack( L) ;
-   // creo STM riempiendo un contorno piano
-   int nId = ExeCreateSurfBzSwept( nParentId, nSectId, nGuideId, vtAx, bCapEnds, dLinTol, nRefType) ;
-   // restituisco il risultato
-   if ( nId != GDB_ID_NULL)
-      LuaSetParam( L, nId) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
 //-------------------------------------------------------------------------------
 bool
 LuaInstallGdbCreateSurf( LuaMgr& luaMgr)
@@ -1308,7 +988,6 @@ LuaInstallGdbCreateSurf( LuaMgr& luaMgr)
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfFrDisk", LuaCreateSurfFrDisk) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfFrFatCurve", LuaCreateSurfFrFatCurve) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfFlatRegion", LuaCreateSurfFlatRegion) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmEmpty", LuaCreateSurfTmEmpty) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmPlaneInBBox", LuaCreateSurfTmPlaneInBBox) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmConvexHullInBBox", LuaCreateSurfTmConvexHullInBBox) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmBBox", LuaCreateSurfTmBBox) ;
@@ -1336,16 +1015,6 @@ LuaInstallGdbCreateSurf( LuaMgr& luaMgr)
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBezierRat", LuaCreateSurfBezierRational) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBezierLeaves", LuaCreateSurfBezierLeaves) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBezierTria2D", LuaCreateSurfBezierTria2D) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBzSphere", LuaCreateBezierSphere) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBzByFlatContour", LuaCreateSurfBzByFlatContour) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBzByRegion", LuaCreateSurfBzByRegion) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBzByExtrusion", LuaCreateSurfBzByExtrusion) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBzByRegionExtrusion", LuaCreateSurfBzByRegionExtrusion) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBzByScrewing", LuaCreateSurfBzByScrewing) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBzByRevolve", LuaCreateSurfBzByRevolve) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBzByPointCurve", LuaCreateSurfBzByPointCurve) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBzRuled", LuaCreateSurfBzRuled) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBzSkinned", LuaCreateSurfBzSkinned) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBzSwept", LuaCreateSurfBzSwept) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtCreateBezierSphere", LuaCreateBezierSphere) ;
    return bOk ;
 }

LUA_GdbCreateVol.cpp

@@ -56,7 +56,7 @@ LuaCreateVolZmapBox( lua_State* L)
 
 //-------------------------------------------------------------------------------
 static int
-LuaCreateVolZmapEmpty( lua_State* L)
+LuaCreateVolZMapEmpty( lua_State* L)
 {
   // 6 o 7 o 8 parametri : ParentId, PtIni, dDimX, dDimY, dDimZ, dPrec [, bTriDex] [, nRefType]
    int nParentId ;
@@ -78,7 +78,7 @@ LuaCreateVolZmapEmpty( lua_State* L)
    else
       LuaGetParam( L, 8, nRefType) ;
    LuaClearStack( L) ;
-  // creo VZM parallelepipedo
+  // creo VZM da superficie trimesh 
    int nId = ExeCreateVolZmapEmpty( nParentId, ptIni, dDimX, dDimY, dDimZ, dPrec, bTriDex, nRefType) ;
   // restituisco il risultato
    if ( nId != GDB_ID_NULL)
@@ -88,8 +88,6 @@ LuaCreateVolZmapEmpty( lua_State* L)
    return 1 ;
 }
 
-
-
 //-------------------------------------------------------------------------------
 static int
 LuaCreateVolZmapByRegionExtrusion( lua_State* L)
@@ -130,7 +128,7 @@ LuaCreateVolZmapFromSurfTm( lua_State* L)
    bool bTriDex = true ;
    LuaGetParam( L, 4, bTriDex) ;
    LuaClearStack( L) ;
-  // creo VZM da superficie trimesh 
+  // creo VZM da superficie trimesh
    int nId = ExeCreateVolZmapFromSurfTm( nParentId, nStmId, dPrec, bTriDex) ;
   // restituisco il risultato
    if ( nId != GDB_ID_NULL)
@@ -144,43 +142,29 @@ LuaCreateVolZmapFromSurfTm( lua_State* L)
 static int
 LuaUpdateVolZmapByAddingSurfTm( lua_State* L)
 {
-  // 2 parametri : nVolZmapId, StmId,
-   int nVolZmapId ;
-   LuaCheckParam( L, 1, nVolZmapId) ;
+  // 3 ParentId, ZmapId, StmId
+   int nParentId ;
+   LuaCheckParam( L, 1, nParentId)
+   int nZmapId ;
+   LuaCheckParam( L, 2, nZmapId)
    int nStmId ;
-   LuaCheckParam( L, 2, nStmId) ;
+   LuaCheckParam( L, 3, nStmId)
    LuaClearStack( L) ;
-   bool bOk = ExeUpdateVolZmapByAddingSurfTm( nVolZmapId, nStmId) ;
+  // creo VZM da superficie trimesh
+   bool bOk = ExeUpdateVolZmapByAddingSurfTm( nParentId, nZmapId, nStmId) ;
    LuaSetParam( L, bOk) ;
    return 1 ;
 }
 
-//-------------------------------------------------------------------------------
-static int
-LuaUniformVolZmap( lua_State* L)
-{
-  // 1 o 2 parametri : nVolZmapId [, dToler]
-   int nVolZmapId ;
-   LuaCheckParam( L, 1, nVolZmapId) ;
-   double dToler = EPS_SMALL ;
-   LuaGetParam( L, 2, dToler) ;
-   LuaClearStack( L) ;
-   bool bOk = ExeUniformVolZmap( nVolZmapId, dToler) ;
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
-
 //-------------------------------------------------------------------------------
 bool
 LuaInstallGdbCreateVol( LuaMgr& luaMgr)
 {
    bool bOk = ( &luaMgr != nullptr) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtVolZmapBox", LuaCreateVolZmapBox) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtVolZmapEmpty", LuaCreateVolZmapEmpty) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtVolZmapEmpty", LuaCreateVolZMapEmpty) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtVolZmapByRegionExtrusion", LuaCreateVolZmapByRegionExtrusion) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtVolZmapFromSurfTm", LuaCreateVolZmapFromSurfTm) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtUpdateVolZmapByAddingSurfTm", LuaUpdateVolZmapByAddingSurfTm ) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtUniformZmap", LuaUniformVolZmap) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtUpdateVolZmapByAddingSurfTm", LuaUpdateVolZmapByAddingSurfTm) ;
    return bOk ;
 }

LUA_GdbGetCurve.cpp

@@ -57,25 +57,6 @@ LuaCurveLength( lua_State* L)
    return 1 ;
 }
 
-//----------------------------------------------------------------------------
-static int
-LuaCurveLengthAtParam( lua_State* L)
-{
-  // 2 parametri : Id, dPar
-   int nId ;
-   LuaCheckParam( L, 1, nId)
-   double dPar ;
-   LuaCheckParam( L, 2, dPar) ;
-   LuaClearStack( L) ;
-  // recupero la lunghezza della curva
-   double dLen ;
-   if ( ExeCurveLengthAtParam( nId, dPar, &dLen))
-      LuaSetParam( L, dLen) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
 //----------------------------------------------------------------------------
 static int
 LuaCurveParamAtLength( lua_State* L)
@@ -161,7 +142,7 @@ LuaCurveIsACircle( lua_State* L)
    double dToler = EPS_SMALL ;
    LuaGetParam( L, 2, dToler) ;
    LuaClearStack( L) ;
-  // verifico se curva � equivalente ad una circonferenza
+  // verifico se curva è equivalente ad una circonferenza
    Point3d ptCen ;
    Vector3d vtN ;
    double dRad ;
@@ -185,7 +166,7 @@ LuaCurveIsARectangle( lua_State* L)
    double dToler = EPS_SMALL ;
    LuaGetParam( L, 2, dToler) ;
    LuaClearStack( L) ;
-  // verifico se curva � equivalente ad un rettangolo
+  // verifico se curva è equivalente ad un rettangolo
    Point3d ptP ;
    Vector3d vtL1 ;
    Vector3d vtL2 ;
@@ -207,7 +188,7 @@ LuaCurveIsATrapezoid( lua_State* L)
    double dToler = EPS_SMALL ;
    LuaGetParam( L, 2, dToler) ;
    LuaClearStack( L) ;
-  // verifico se curva � equivalente ad un trapezio
+  // verifico se curva è equivalente ad un trapezio
    Point3d ptP ;
    Vector3d vtB1 ;
    Vector3d vtL1 ;
@@ -261,23 +242,6 @@ LuaCurveArea( lua_State* L)
    }
 }
 
-//----------------------------------------------------------------------------
-static int
-LuaCurveMaxOffset( lua_State* L)
-{
-   // 2 parametri : Id
-   int nId ;
-   LuaCheckParam( L, 1, nId)
-   LuaClearStack( L) ;
-   // recupero la sua area senza eventuali buchi
-   double dMaxOffset ;
-   if ( ExeCurveMaxOffset( nId, dMaxOffset))
-      LuaSetParam( L, dMaxOffset) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
 //----------------------------------------------------------------------------
 static int
 LuaCurveExtrusion( lua_State* L)
@@ -567,108 +531,6 @@ LuaCurveCompoNormVersor( lua_State* L)
    return 1 ;
 }
 
-//----------------------------------------------------------------------------
-static int
-LuaCurveCompoGetTempProp( lua_State* L)
-{
-  // 1 parametro : Id
-   int nId ;
-   LuaCheckParam( L, 1, nId)
-   LuaClearStack( L) ;
-  // recupero l'angolo al centro della curva semplice indicizzata
-   INTVECTOR vProp ;
-   if ( ExeCurveCompoGetTempProp( nId, vProp, 0))
-      LuaSetParam( L, vProp) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
-//----------------------------------------------------------------------------
-static int
-LuaCurveCompoGetTempParam( lua_State* L)
-{
-  // 1 parametro : Id
-   int nId ;
-   LuaCheckParam( L, 1, nId)
-   LuaClearStack( L) ;
-  // recupero l'angolo al centro della curva semplice indicizzata
-   DBLVECTOR vParam ;
-   if ( ExeCurveCompoGetTempParam( nId, vParam, 0))
-      LuaSetParam( L, vParam) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
-//----------------------------------------------------------------------------
-static int
-LuaShowCurveBezierControlPoints( lua_State* L)
-{
-   // 2 parametri : nCrvId, nDestGrpId
-   int nCrvId ;
-   LuaCheckParam( L, 1, nCrvId)
-   int nDestGrpId ;
-   LuaCheckParam( L, 2, nDestGrpId)
-   LuaClearStack( L) ;
-   int nCount = 0 ;
-   int nId = ExeShowCurveBezierControlPoints( nCrvId, nDestGrpId, &nCount) ;
-   // restituisco il risultato
-   if ( nId != GDB_ID_NULL) {
-      LuaSetParam( L, nId) ;
-      LuaSetParam( L, nCount) ;  
-   }
-   else {
-      LuaSetParam( L) ;
-      LuaSetParam( L) ;
-   }
-   return 2 ;
-}
-
-//----------------------------------------------------------------------------
-static int
-LuaCopyCompoSubCurve( lua_State* L)
-{
-   // 3 parametri : nCrvId, nSubCrvToCopy, nDestGrpId
-   int nCrvId ;
-   LuaCheckParam( L, 1, nCrvId)
-   int nSubCrvToCopy ;
-   LuaCheckParam( L, 2, nSubCrvToCopy)
-   int nDestGrpId ;
-   LuaCheckParam( L, 3, nDestGrpId)
-   LuaClearStack( L) ;
-   int nId = ExeCopyCompoSubCurve( nCrvId, nSubCrvToCopy, nDestGrpId) ;
-   // restituisco il risultato
-   if ( nId != GDB_ID_NULL)
-      LuaSetParam( L, nId) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
-//----------------------------------------------------------------------------
-static int
-LuaCopyParamRange( lua_State* L)
-{
-   // 4 parametri : nCrvId, dUStart, dUEnd, nDestGrpId
-   int nCrvId ;
-   LuaCheckParam( L, 1, nCrvId)
-   double dUStart ;
-   LuaCheckParam( L, 2, dUStart)
-   double dUEnd ;
-   LuaCheckParam( L, 3, dUEnd) 
-   int nDestGrpId ;
-   LuaCheckParam( L, 4, nDestGrpId)
-   LuaClearStack( L) ;
-   int nId = ExeCopyParamRange( nCrvId, dUStart, dUEnd, nDestGrpId) ;
-   // restituisco il risultato
-   if ( nId != GDB_ID_NULL)
-      LuaSetParam( L, nId) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
 //-------------------------------------------------------------------------------
 bool
 LuaInstallGdbGetCurve( LuaMgr& luaMgr)
@@ -676,7 +538,6 @@ LuaInstallGdbGetCurve( LuaMgr& luaMgr)
    bool bOk = ( &luaMgr != nullptr) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtCurveDomain", LuaCurveDomain) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtCurveLength", LuaCurveLength) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtCurveLengthAtParam", LuaCurveLengthAtParam) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtCurveParamAtLength", LuaCurveParamAtLength) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtCurveParamAtPoint", LuaCurveParamAtPoint) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtCurveIsClosed", LuaCurveIsClosed) ;
@@ -686,7 +547,6 @@ LuaInstallGdbGetCurve( LuaMgr& luaMgr)
    bOk = bOk && luaMgr.RegisterFunction( "EgtCurveIsATrapezoid", LuaCurveIsATrapezoid) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtCurveAreaXY", LuaCurveAreaXY) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtCurveArea", LuaCurveArea) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtCurveMaxOffset", LuaCurveMaxOffset) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtCurveExtrusion", LuaCurveExtrusion) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtCurveThickness", LuaCurveThickness) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtCurveSelfIntersCount", LuaCurveSelfIntersCount) ;
@@ -702,10 +562,5 @@ LuaInstallGdbGetCurve( LuaMgr& luaMgr)
    bOk = bOk && luaMgr.RegisterFunction( "EgtCurveCompoRadius", LuaCurveCompoRadius) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtCurveCompoAngCenter", LuaCurveCompoAngCenter) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtCurveCompoNormVersor", LuaCurveCompoNormVersor) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtCurveCompoGetTempProp", LuaCurveCompoGetTempProp) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtCurveCompoGetTempParam", LuaCurveCompoGetTempParam) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtShowCurveBezierControlPoints", LuaShowCurveBezierControlPoints) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtCopyCompoSubCurve", LuaCopyCompoSubCurve) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtCopyParamRange", LuaCopyParamRange) ;
    return bOk ;
 }

LUA_GdbGetSurf.cpp

@@ -121,25 +121,6 @@ LuaSurfFrChunkCount( lua_State* L)
    return 1 ;
 }
 
-//----------------------------------------------------------------------------
-static int
-LuaSurfFrChunkMaxOffset( lua_State* L)
-{
-   // 2 parametri : Id, nChunk
-   int nId ;
-   LuaCheckParam( L, 1, nId)
-      int nChunk ;
-   LuaCheckParam( L, 2, nChunk)
-      LuaClearStack( L) ;
-   // recupero la sua area senza eventuali buchi
-   double dMaxOffset ;
-   if ( ExeSurfFrChunkMaxOffset( nId, nChunk, dMaxOffset))
-      LuaSetParam( L, dMaxOffset) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
 //----------------------------------------------------------------------------
 static int
 LuaSurfFrChunkSimpleClassify( lua_State* L)
@@ -350,27 +331,6 @@ LuaSurfTmGetNearestVertex( lua_State* L)
    return 2 ;
 }
 
-//----------------------------------------------------------------------------
-static int
-LuaSurfTmTriangleNormVersor( lua_State* L)
-{
-  // 2 o 3 parametri : nId, nTria [, nRefId]
-   int nId ;
-   LuaCheckParam( L, 1, nId)
-   int nTria ;
-   LuaCheckParam( L, 2, nTria)
-   int nRefId = nId ;
-   LuaGetParam( L, 3, nRefId) ;
-   LuaClearStack( L) ;
-  // recupero la normale del triangolo della superficie
-   Vector3d vtNorm ;
-   if ( ExeSurfTmTriangleNormVersor( nId, nTria, nRefId, vtNorm))
-      LuaSetParam( L, vtNorm) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
 //----------------------------------------------------------------------------
 static int
 LuaSurfTmFacetFromTria( lua_State* L)
@@ -483,42 +443,6 @@ LuaSurfTmGetFacetBBoxRef( lua_State* L)
    return 1 ;
 }
 
-//----------------------------------------------------------------------------
-static int
-LuaSurfTmGetFacetOutlineInfo( lua_State* L)
-{
-  // 2 o 3 parametri : Id, nFacet [, nRefId]
-   int nId ;
-   LuaCheckParam( L, 1, nId)
-   int nFacet ;
-   LuaCheckParam( L, 2, nFacet)
-   int nRefId = nId ;
-   LuaGetParam( L, 3, nRefId) ;
-   LuaClearStack( L) ;
-  // recupero le informazioni
-   int nStatus ;
-   BOOLVECTOR vbOpen ;
-   INTVECTOR vnAdj ;
-   VCT3DVECTOR vvtNorm ;
-   DBLVECTOR vdElev ;
-   DBLVECTOR vdLen ;
-   bool bOk = ExeSurfTmGetFacetOutlineInfo( nId, nFacet, nRefId, nStatus, vbOpen, vnAdj, vdLen, vvtNorm, vdElev) ;
-  // restituisco il risultato
-   if ( bOk) {
-      LuaSetParam( L, nStatus) ;
-      LuaSetParam( L, vbOpen) ;
-      LuaSetParam( L, vnAdj) ;
-      LuaSetParam( L, vdLen) ;
-      LuaSetParam( L, vvtNorm) ;
-      LuaSetParam( L, vdElev) ;
-      return 6 ;
-   }
-   else {
-      LuaSetParam( L) ;
-      return 1 ;
-   }
-}
-
 //----------------------------------------------------------------------------
 static int
 LuaSurfTmFacetAdjacencies( lua_State* L)
@@ -848,38 +772,6 @@ LuaGetSurfTmSilhouette( lua_State* L)
    return 2 ;
 }
 
-//----------------------------------------------------------------------------
-static int
-LuaGetSurfTmParSilhouettes( lua_State* L)
-{
-  // 6 o 7 parametri : vIds, ptOn, vtN, vdDist, dToler, nDestGrpId [, nRefType]
-   INTVECTOR vIds ;
-   LuaCheckParam( L, 1, vIds)
-   Point3d ptOn ;
-   LuaCheckParam( L, 2, ptOn)
-   Vector3d vtN ;
-   LuaCheckParam( L, 3, vtN)
-   DBLVECTOR vdDist ;
-   LuaCheckParam( L, 4, vdDist)
-   double dToler ;
-   LuaCheckParam( L, 5, dToler)
-   int nDestGrpId ;
-   LuaCheckParam( L, 6, nDestGrpId)
-   int nRefType = RTY_DEFAULT ;
-   LuaGetParam( L, 7, nRefType) ;
-   LuaClearStack( L) ;
-  // recupero i contorni della superficie
-   int nCount = 0 ;
-   int nNewId = ExeGetSurfTmParSilhouettes( vIds, ptOn, vtN, vdDist, dToler, nDestGrpId, nRefType, &nCount) ;
-  // restituisco il risultato
-   if ( nCount >= 0)
-      LuaSetParam( L, nNewId) ;
-   else
-      LuaSetParam( L) ;
-   LuaSetParam( L, nCount) ;
-   return 2 ;
-}
-
 //----------------------------------------------------------------------------
 static int
 LuaExtractSurfTmFacetLoops( lua_State* L)
@@ -1188,30 +1080,6 @@ LuaExtractSurfBezierLoops( lua_State* L)
    return 2 ;
 }
 
-//----------------------------------------------------------------------------
-static int
-LuaShowSurfBezierControlPoints( lua_State* L)
-{
-   // 2 parametri : nCrvId, nDestGrpId
-   int nCrvId ;
-   LuaCheckParam( L, 1, nCrvId)
-   int nDestGrpId ;
-   LuaCheckParam( L, 2, nDestGrpId)
-   LuaClearStack( L) ;
-   int nCount = 0 ;
-   int nId = ExeShowSurfBezierControlPoints( nCrvId, nDestGrpId, &nCount) ;
-   // restituisco il risultato
-   if ( nId != GDB_ID_NULL) {
-      LuaSetParam( L, nId) ;
-      LuaSetParam( L, nCount) ;  
-   }
-   else {
-      LuaSetParam( L) ;
-      LuaSetParam( L) ;
-   }
-   return 2 ;
-}
-
 //-------------------------------------------------------------------------------
 bool
 LuaInstallGdbGetSurf( LuaMgr& luaMgr)
@@ -1223,7 +1091,6 @@ LuaInstallGdbGetSurf( LuaMgr& luaMgr)
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfFrNormVersor", LuaSurfFrNormVersor) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfFrGrossArea", LuaSurfFrGrossArea) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfFrChunkCount", LuaSurfFrChunkCount) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfFrChunkMaxOffset", LuaSurfFrChunkMaxOffset) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfFrChunkSimpleClassify", LuaSurfFrChunkSimpleClassify) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfFrTestExternal", LuaSurfFrTestExternal) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtExtractSurfFrChunkLoops", LuaExtractSurfFrChunkLoops) ;
@@ -1234,13 +1101,11 @@ LuaInstallGdbGetSurf( LuaMgr& luaMgr)
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmPartCount", LuaSurfTmPartCount) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmGetVertex", LuaSurfTmGetVertex) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmGetNearestVertex", LuaSurfTmGetNearestVertex) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmTriangleNormVersor", LuaSurfTmTriangleNormVersor) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmFacetFromTria", LuaSurfTmFacetFromTria) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmGetAllVertInFacet", LuaSurfTmGetAllVertInFacet) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmGetFacetBBox", LuaSurfTmGetFacetBBox) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmGetFacetBBoxGlob", LuaSurfTmGetFacetBBoxGlob) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmGetFacetBBoxRef", LuaSurfTmGetFacetBBoxRef) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmGetFacetOutlineInfo", LuaSurfTmGetFacetOutlineInfo) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmFacetAdjacencies", LuaSurfTmFacetAdjacencies) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmFacetNearestEndPoint", LuaSurfTmFacetNearestEndPoint) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmFacetNearestMidPoint", LuaSurfTmFacetNearestMidPoint) ;
@@ -1253,7 +1118,6 @@ LuaInstallGdbGetSurf( LuaMgr& luaMgr)
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmFacetsContact", LuaSurfTmFacetsContact) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtExtractSurfTmLoops", LuaExtractSurfTmLoops) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtGetSurfTmSilhouette", LuaGetSurfTmSilhouette) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtGetSurfTmParSilhouettes", LuaGetSurfTmParSilhouettes) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtExtractSurfTmFacetLoops", LuaExtractSurfTmFacetLoops) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtCopySurfTmFacet", LuaCopySurfTmFacet) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmGetEdges", LuaSurfTmGetEdges) ;
@@ -1266,6 +1130,5 @@ LuaInstallGdbGetSurf( LuaMgr& luaMgr)
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBezierGetControlCurveU", LuaSurfBezierGetControlCurveU) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBezierGetControlCurveV", LuaSurfBezierGetControlCurveV) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtExtractSurfBezierLoops", LuaExtractSurfBezierLoops) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtShowSurfBezierControlPoints", LuaShowSurfBezierControlPoints) ;
    return bOk ;
 }

LUA_GdbModifyCurve.cpp

@@ -913,42 +913,6 @@ LuaRemoveCurveCompoUndercutOnY( lua_State* L)
    return 1 ;
 }
 
-//-------------------------------------------------------------------------------
-static int
-LuaCurveCompoSetTempProp( lua_State* L)
-{
-  // 3 parametri : Id, nCrv, nProp
-   int nId ;
-   LuaCheckParam( L, 1, nId)
-   int nCrv ;
-   LuaCheckParam( L, 2, nCrv)
-   int nProp ;
-   LuaCheckParam( L, 3, nProp)
-   LuaClearStack( L) ;
-  // imposto sulla curva della composita la proprietà temporanea
-   bool bOk = ExeCurveCompoSetTempProp( nId, nCrv, nProp) ;
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaCurveCompoSetTempParam( lua_State* L)
-{
-  // 3 parametri : Id, nCrv, dParam
-   int nId ;
-   LuaCheckParam( L, 1, nId)
-   int nCrv ;
-   LuaCheckParam( L, 2, nCrv)
-   double dParam ;
-   LuaCheckParam( L, 3, dParam)
-   LuaClearStack( L) ;
-  // imposto sulla curva della composita il parametro temporaneo
-   bool bOk = ExeCurveCompoSetTempParam( nId, nCrv, dParam) ;
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
 //----------------------------------------------------------------------------
 static int
 LuaChainCurvesInGroup( lua_State* L)
@@ -987,9 +951,9 @@ LuaReorderCurvesInGroup( lua_State* L)
 
 //----------------------------------------------------------------------------
 static int
-LuaProjectCurveOnSurf( lua_State* L)
+LuaProjectCurveOnSurfTm( lua_State* L)
 {
-  // 4, 5, 6, 7 o 8 parametri : nCurveId, nSurfTmId, vtDir, nDestGrpId [, dLinTol [, dMaxSegmLen] [, bDirFromProj] [, nRefType]]
+  // 4, 5, 6 o 7 parametri : nCurveId, nSurfTmId, vtDir, nDestGrpId [, dLinTol [, dMaxSegmLen] [, nRefType]]
    int nCurveId ;
    LuaCheckParam( L, 1, nCurveId)
    int nSurfTmId ;
@@ -1000,22 +964,20 @@ LuaProjectCurveOnSurf( lua_State* L)
    LuaCheckParam( L, 4, nDestGrpId)
    double dLinTol = 0.01 ;
    double dMaxSegmLen = INFINITO ;
-   bool bDirFromProj = false ;
    int nRefType = RTY_DEFAULT ;
    if ( LuaGetParam( L, 5, dLinTol)  &&
-        LuaGetParam( L, 6, dMaxSegmLen)  &&
-        LuaGetParam( L, 7, bDirFromProj))
-      LuaGetParam( L, 8, nRefType) ;
+        LuaGetParam( L, 6, dMaxSegmLen))
+      LuaGetParam( L, 7, nRefType) ;
    LuaClearStack( L) ;
-  // proietto la curva su una superficie secondo la direzione data
-   bool bOk = ExeProjectCurveOnSurf( nCurveId, nSurfTmId, vtDir, nDestGrpId, dLinTol, dMaxSegmLen, bDirFromProj, nRefType) ;
+  // proietto la curva su una trimesh secondo la direzione data
+   bool bOk = ExeProjectCurveOnSurfTm( nCurveId, nSurfTmId, vtDir, nDestGrpId, dLinTol, dMaxSegmLen, nRefType) ;
    LuaSetParam( L, bOk) ;
    return 1 ;
 }
 
 //----------------------------------------------------------------------------
 static int
-LuaProjectCurveOnSurfExt( lua_State* L)
+LuaProjectCurveOnSurfTmExt( lua_State* L)
 {
   // 4, 5, 6 o 7 parametri : nCurveId, nSurfTmId, nGuideId, nDestGrpId [, dLinTol [, dMaxSegmLen] [, bDirFromGuide]]
    int nCurveId ;
@@ -1033,8 +995,8 @@ LuaProjectCurveOnSurfExt( lua_State* L)
         LuaGetParam( L, 6, dMaxSegmLen))
       LuaGetParam( L, 7, bDirFromGuide) ;
    LuaClearStack( L) ;
-  // proietto la curva su una superficie secondo la direzione verso la guida
-   bool bOk = ExeProjectCurveOnSurfExt( nCurveId, nSurfTmId, nGuideId, nDestGrpId, dLinTol, dMaxSegmLen, bDirFromGuide) ;
+  // proietto la curva su una trimesh secondo la direzione data
+   bool bOk = ExeProjectCurveOnSurfTmExt( nCurveId, nSurfTmId, nGuideId, nDestGrpId, dLinTol, dMaxSegmLen, bDirFromGuide) ;
    LuaSetParam( L, bOk) ;
    return 1 ;
 }
@@ -1043,9 +1005,9 @@ LuaProjectCurveOnSurfExt( lua_State* L)
 static int
 LuaCurveGetVoronoi( lua_State* L)
 {
-  // 2 o 3 parametri : Id/s, nDestGrpId [, nBound]
-   INTVECTOR vIds ;
-   LuaCheckParam( L, 1, vIds)
+  // 2 o 3 parametri : Id, nDestGrpId [, nBound]
+   int nId ;
+   LuaCheckParam( L, 1, nId)
    int nDestGrpId ;
    LuaCheckParam( L, 2, nDestGrpId)
    int nBound = 3 ;      // VORONOI_STD_BOUND
@@ -1053,7 +1015,7 @@ LuaCurveGetVoronoi( lua_State* L)
    LuaClearStack( L) ;
   // eseguo
    int nCount = 0 ;
-   int nNewId = ExeCurveGetVoronoi( vIds, nDestGrpId, nBound, &nCount) ;
+   int nNewId = ExeCurveGetVoronoi( nId, nDestGrpId, nBound, &nCount) ;
    if ( nNewId != GDB_ID_NULL)
       LuaSetParam( L, nNewId) ;
    else
@@ -1067,9 +1029,9 @@ LuaCurveGetVoronoi( lua_State* L)
 static int
 LuaCurveMedialAxisAdv( lua_State* L)
 {
-  // 2 o 3 parametri : Id/s, nDestGrpId [, nSide]
-   INTVECTOR vIds ;
-   LuaCheckParam( L, 1, vIds)
+  // 2 o 3 parametri : Id, nDestGrpId [, nSide]
+   int nId ;
+   LuaCheckParam( L, 1, nId)
    int nDestGrpId ;
    LuaCheckParam( L, 2, nDestGrpId)
    int nSide = 1 ;         // WMAT_LEFT
@@ -1077,7 +1039,7 @@ LuaCurveMedialAxisAdv( lua_State* L)
    LuaClearStack( L) ;
   // eseguo
    int nCount = 0 ;
-   int nNewId = ExeCurveGetMedialAxis( vIds, nDestGrpId, nSide, &nCount) ;
+   int nNewId = ExeCurveGetMedialAxis( nId, nDestGrpId, nSide, &nCount) ;
    if ( nNewId != GDB_ID_NULL)
       LuaSetParam( L, nNewId) ;
    else
@@ -1115,70 +1077,6 @@ LuaCurveGetFatCurve( lua_State* L)
    return 2 ;
 }
 
-//----------------------------------------------------------------------------
-static int
-LuaCurveBezierIncreaseDegree( lua_State* L)
-{
-   // 1 parametro : CrvId
-   int nId ;
-   LuaCheckParam( L, 1, nId)
-   LuaClearStack( L) ;
-   // eseguo
-   bool bOk = ExeCurveBezierIncreaseDegree( nId) ;
-   LuaSetParam( L, bOk) ;
-
-   return 1 ;
-}
-
-//----------------------------------------------------------------------------
-static int
-LuaCurveBezierDecreaseDegree( lua_State* L)
-{
-   // 1 parametro : CrvId
-   int nId ;
-   LuaCheckParam( L, 1, nId)
-   LuaClearStack( L) ;
-   // eseguo
-   bool bOk = ExeCurveBezierDecreaseDegree( nId) ;
-   LuaSetParam( L, bOk) ;
-
-   return 1 ;
-}
-
-//----------------------------------------------------------------------------
-static int
-LuaCurveBezierApproxToNonRat( lua_State* L)
-{
-   // 1 o 2 parametri : CrvId [, dTol]
-   int nId ;
-   LuaCheckParam( L, 1, nId)
-   double dTol = 10 * EPS_SMALL ;
-   LuaGetParam( L, 2, dTol) ;
-   LuaClearStack( L) ;
-   // eseguo
-   bool bOk = ExeCurveBezierApproxToNonRat( nId, dTol) ;
-   LuaSetParam( L, bOk) ;
-
-   return 1 ;
-}
-
-//----------------------------------------------------------------------------
-static int
-LuaCurveBezierApproxWithCubicBeziers( lua_State* L)
-{
-   // 1 o 2 parametri : CrvId [, dTol]
-   int nId ;
-   LuaCheckParam( L, 1, nId)
-   double dTol = 10 * EPS_SMALL ;
-   LuaGetParam( L, 2, dTol) ;
-   LuaClearStack( L) ;
-   // eseguo
-   bool bOk = ExeCurveBezierApproxWithCubicBeziers( nId, dTol) ;
-   LuaSetParam( L, bOk) ;
-
-   return 1 ;
-}
- 
 //-------------------------------------------------------------------------------
 bool
 LuaInstallGdbModifyCurve( LuaMgr& luaMgr)
@@ -1232,18 +1130,12 @@ LuaInstallGdbModifyCurve( LuaMgr& luaMgr)
    bOk = bOk && luaMgr.RegisterFunction( "EgtExplodeCurveCompo", LuaExplodeCurveCompo) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtMergeCurvesInCurveCompo", LuaMergeCurvesInCurveCompo) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtRemoveCurveCompoUndercutOnY", LuaRemoveCurveCompoUndercutOnY) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtCurveCompoSetTempProp", LuaCurveCompoSetTempProp) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtCurveCompoSetTempParam", LuaCurveCompoSetTempParam) ;  
    bOk = bOk && luaMgr.RegisterFunction( "EgtChainCurvesInGroup", LuaChainCurvesInGroup) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtReorderCurvesInGroup", LuaReorderCurvesInGroup) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtProjectCurveOnSurf", LuaProjectCurveOnSurf) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtProjectCurveOnSurfExt", LuaProjectCurveOnSurfExt) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtProjectCurveOnSurfTm", LuaProjectCurveOnSurfTm) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtProjectCurveOnSurfTmExt", LuaProjectCurveOnSurfTmExt) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtCurveGetVoronoi", LuaCurveGetVoronoi) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtCurveMedialAxisAdv", LuaCurveMedialAxisAdv) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtCurveGetFatCurve", LuaCurveGetFatCurve) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtCurveBezierIncreaseDeg", LuaCurveBezierIncreaseDegree) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtCurveBezierDecreaseDeg", LuaCurveBezierDecreaseDegree) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtCurveBezierApproxToNonRat", LuaCurveBezierApproxToNonRat) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtApproxBezierWithCubics", LuaCurveBezierApproxWithCubicBeziers) ;
    return bOk ;
 }

LUA_GdbModifySurf.cpp

@@ -165,23 +165,6 @@ LuaSurfFrOffsetAdv( lua_State* L)
    return 1 ;
 }
 
-//-------------------------------------------------------------------------------
-static int
-LuaSurfFrEraseChunk( lua_State* L)
-{
-  // 2 parametri : Id, nChunk
-   int nId ;
-   LuaCheckParam( L, 1, nId)
-   int nChunk ;
-   LuaCheckParam( L, 2, nChunk)
-   LuaClearStack( L) ;
-  // eseguo l'offset della regione
-   bool bOk = ExeSurfFrEraseChunk( nId, nChunk) ;
-   LuaSetParam( L, bOk) ;
-
-   return 1 ;
-}
-
 //----------------------------------------------------------------------------
 static int
 LuaSurfTmMoveVertex( lua_State* L)
@@ -496,44 +479,6 @@ LuaSurfTmSubtractProjectedFacesOnFace( lua_State* L)
    return 4 ;
 }
 
-//-------------------------------------------------------------------------------
-static int
-LuaSurfTmSetFaceColor( lua_State* L)
-{
-  // 3 parametri : Id, nFacet, nColor
-   int nId ;
-   LuaCheckParam( L, 1, nId)
-   int nFacet ;
-   LuaCheckParam( L, 2, nFacet)
-   int nColor ;
-   LuaCheckParam( L, 3, nColor)
-   LuaClearStack( L) ;
-  // imposto il colore alla faccia della superficie TM
-   bool bOk = ExeSurfTmSetFaceColor( nId, nFacet, nColor) ;
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaSurfTmGetTriaColor( lua_State* L)
-{
-  // 2 parametri : Id, nTria
-   int nId ;
-   LuaCheckParam( L, 1, nId)
-   int nTria ;
-   LuaCheckParam( L, 2, nTria)
-   LuaClearStack( L) ;
-  // recupero il flag di colore del triangolo della superficie TM
-   int nColor ;
-   bool bOk = ExeSurfTmGetTriaColor( nId, nTria, nColor) ;
-   if ( bOk)
-      LuaSetParam( L, nColor) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
 //-------------------------------------------------------------------------------
 static int
 LuaSurfTmResetTwoColors( lua_State* L)
@@ -565,24 +510,6 @@ LuaSurfTmSetShowEdges( lua_State* L)
    return 1 ;
 }
 
-//-------------------------------------------------------------------------------
-static int
-LuaSurfTmGetShowEdges( lua_State* L)
-{
-  // 1 parametro : Id
-   int nId ;
-   LuaCheckParam( L, 1, nId)
-   LuaClearStack( L) ;
-  // recupero il flag di visualizzazione degli spigoli vivi della superficie TM
-   bool bShow ;
-   bool bOk = ExeSurfTmGetShowEdges( nId, bShow) ;
-   if ( bOk)
-      LuaSetParam( L, bShow) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
 //-------------------------------------------------------------------------------
 static int
 LuaSurfBzTrim( lua_State* L)
@@ -599,22 +526,6 @@ LuaSurfBzTrim( lua_State* L)
    return 1 ;
 }
 
-//-------------------------------------------------------------------------------
-static int
-LuaSurfTmSetSmoothAng( lua_State* L)
-{
-  // 2 parametri : nId, nCutterId
-   int nId ;
-   LuaCheckParam( L, 1, nId)
-   double dAngDeg ;
-   LuaCheckParam( L, 2, dAngDeg)
-   LuaClearStack( L) ;
-  // aggiorno lo smooth angle della superficie
-   bool bOk = ExeSurfTmSetSmoothAng( nId, dAngDeg) ;
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
 //-------------------------------------------------------------------------------
 bool
 LuaInstallGdbModifySurf( LuaMgr& luaMgr)
@@ -628,7 +539,6 @@ LuaInstallGdbModifySurf( LuaMgr& luaMgr)
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfFrIntersect", LuaSurfFrIntersect) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfFrOffset", LuaSurfFrOffset) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfFrOffsetAdv", LuaSurfFrOffsetAdv) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfFrEraseChunk", LuaSurfFrEraseChunk) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmMoveVertex", LuaSurfTmMoveVertex) ;  
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmMoveFacet", LuaSurfTmMoveFacet) ;  
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmToTriangles", LuaSurfTmToTriangles) ;  
@@ -644,12 +554,8 @@ LuaInstallGdbModifySurf( LuaMgr& luaMgr)
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmSplit", LuaSurfTmSplit) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmCut", LuaSurfTmCut) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmSubtractProjectedFacesOnFace", LuaSurfTmSubtractProjectedFacesOnFace) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmSetFaceColor", LuaSurfTmSetFaceColor) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmGetTriaColor", LuaSurfTmGetTriaColor) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmResetTwoColors", LuaSurfTmResetTwoColors) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmSetShowEdges", LuaSurfTmSetShowEdges) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmGetShowEdges", LuaSurfTmGetShowEdges) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBzTrim", LuaSurfBzTrim) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmSetSmoothAng", LuaSurfTmSetSmoothAng) ;
    return bOk ;
 }

LUA_GdbModifyVol.cpp

@@ -152,7 +152,7 @@ LuaVolZmapSetAdvTool( lua_State* L)
 static int
 LuaVolZmapSetSawTool( lua_State* L)
 {
-  // 7 o 8 parametri : vIds, sToolName, dLen, dDiam, dThick, dStemDiam, dCornR [, nFlag]
+  // 7 o 8 parametri : vIds, sToolName, dLen, dDiam, dThick, dStemDiam, dCornR, nFlag
    INTVECTOR vIds ;
    LuaCheckParam( L, 1, vIds)
    string sToolName ;
@@ -181,7 +181,7 @@ LuaVolZmapSetSawTool( lua_State* L)
 static int
 LuaVolZmapSetGenTool( lua_State* L)
 {
-  // 3 o 4 parametri : vIds, sToolName, ToolSectId [, nFlag]
+  // 3 o 4 parametri : vIds, sToolName, ToolSectId, nFlag
    INTVECTOR vIds ;
    LuaCheckParam( L, 1, vIds)
    string sToolName ;
@@ -202,7 +202,7 @@ LuaVolZmapSetGenTool( lua_State* L)
 static int
 LuaVolZmapSetMortiserTool( lua_State* L)
 {
-  // 6 o 7 parametri : Id, sToolName, dLen, dWidth, dThick, dCornR [, nFlag]
+  // 6 o 7 parametri : Id, sToolName, dLen, dWidth, dThick, dCornR, nFlag
    INTVECTOR vIds ;
    LuaCheckParam( L, 1, vIds)
    string sToolName ;
@@ -229,7 +229,7 @@ LuaVolZmapSetMortiserTool( lua_State* L)
 static int
 LuaVolZmapSetChiselTool( lua_State* L)
 {
-  // 5 o 6 parametri : vIds, sToolName, dLen, dWidth, dThick [, nFlag]
+  // 5 o 6 parametri : vIds, sToolName, dLen, dWidth, dThick, nFlag
    INTVECTOR vIds ;
    LuaCheckParam( L, 1, vIds)
    string sToolName ;
@@ -250,31 +250,6 @@ LuaVolZmapSetChiselTool( lua_State* L)
    return 1 ;
 }
 
-//----------------------------------------------------------------------------
-static int
-LuaVolZmapSetAdditiveTool( lua_State* L)
-{
-  // 5 o 6 parametri : vIds, sToolName, dLen, dDiam, dCornR [, nFlag]
-   INTVECTOR vIds ;
-   LuaCheckParam( L, 1, vIds)
-   string sToolName ;
-   LuaCheckParam( L, 2, sToolName)
-   double dLen ;
-   LuaCheckParam( L, 3, dLen)
-   double dDiam ;
-   LuaCheckParam( L, 4, dDiam)
-   double dCornR ;
-   LuaCheckParam( L, 5, dCornR)
-   int nFlag = 1 ;
-   LuaGetParam( L, 6, nFlag) ;
-   LuaClearStack( L) ;
-  // imposto utensile additivo a Zmap indicati
-   bool bOk = ExeVolZmapSetAdditiveTool( vIds, sToolName, dLen, dDiam, dCornR, nFlag, true) ;
-  // restituisco il risultato
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
 //----------------------------------------------------------------------------
 static int
 LuaVolZmapResetTool( lua_State* L)
@@ -400,7 +375,6 @@ LuaInstallGdbModifyVol( LuaMgr& luaMgr)
    bOk = bOk && luaMgr.RegisterFunction( "EgtVolZmapSetGenTool", LuaVolZmapSetGenTool) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtVolZmapSetMortiserTool", LuaVolZmapSetMortiserTool) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtVolZmapSetChiselTool", LuaVolZmapSetChiselTool) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtVolZmapSetAdditiveTool", LuaVolZmapSetAdditiveTool) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtVolZmapResetTool", LuaVolZmapResetTool) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtVolZmapGetToolOutline", LuaVolZmapGetToolOutline) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtVolZmapMillingStep", LuaVolZmapMillingStep) ;

LUA_GdbObjAttribs.cpp

@@ -247,14 +247,12 @@ LuaGetCalcStatus( lua_State* L)
 static int
 LuaSetMark( lua_State* L)
 {
-  // 1 o 2 parametri : Id [, nMark]
+  // 1 parametro : Id
    int nId ;
    LuaCheckParam( L, 1, nId)
-   int nMark = 1 ;
-   LuaGetParam( L, 2, nMark) ;
    LuaClearStack( L) ;
   // imposto l'evidenziazione
-   bool bOk = ExeSetMark( nId, nMark) ;
+   bool bOk = ExeSetMark( nId) ;
   // restituisco il risultato
    LuaSetParam( L, bOk) ;
    return 1 ;
@@ -784,25 +782,6 @@ LuaGetTextureFrame( lua_State* L)
    return 1 ;
 }
 
-//-------------------------------------------------------------------------------
-static int
-LuaSetStipple( lua_State* L)
-{
-  // 3 parametri : Id, nFactor, nPattern
-   int nId ;
-   LuaCheckParam( L, 1, nId)
-   int nFactor ;
-   LuaCheckParam( L, 2, nFactor)
-   int nPattern ;
-   LuaCheckParam( L, 3, nPattern)
-   LuaClearStack( L) ;
-  // setto stipple
-   bool bOk = ExeSetStipple( nId, nFactor, nPattern) ;
-  // restituisco il risultato
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
 //-------------------------------------------------------------------------------
 bool
 LuaInstallGdbObjAttribs( LuaMgr& luaMgr)
@@ -845,6 +824,5 @@ LuaInstallGdbObjAttribs( LuaMgr& luaMgr)
    bOk = bOk && luaMgr.RegisterFunction( "EgtRemoveTextureData", LuaRemoveTextureData) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtGetTextureName", LuaGetTextureName) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtGetTextureFrame", LuaGetTextureFrame) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSetStipple", LuaSetStipple) ;
    return bOk ;
 }

LUA_GdbObjects.cpp

@@ -208,6 +208,31 @@ LuaGetPrev( lua_State* L)
    return 1 ;
 }
 
+//-------------------------------------------------------------------------------
+static int
+LuaGetNameInGroup( lua_State* L)
+{
+  // 2 parametri : GroupId, sName
+   int nGroupId = GDB_ID_NULL ;
+   LuaGetParam( L, 1, nGroupId) ;
+   string sName ;
+   LuaGetParam( L, 2, sName) ;
+   LuaClearStack( L) ;
+  // recupero tutti gli oggetti del gruppo con il nome o suo inizio desiderato
+   INTVECTOR vId ;
+   int nId = ExeGetFirstNameInGroup( nGroupId, sName) ;
+   while ( nId != GDB_ID_NULL) {
+      vId.push_back ( nId) ;
+      nId = ExeGetNextName( nId, sName) ;
+   }
+  // restituisco il risultato
+   if ( ! vId.empty())
+      LuaSetParam( L, vId) ;
+   else
+      LuaSetParam( L) ;
+   return 1 ;
+}
+
 //-------------------------------------------------------------------------------
 static int
 LuaGetFirstNameInGroup( lua_State* L)
@@ -288,48 +313,6 @@ LuaGetPrevName( lua_State* L)
    return 1 ;
 }
 
-//-------------------------------------------------------------------------------
-static int
-LuaGetNameInGroup( lua_State* L)
-{
-  // 2 parametri : GroupId, sName
-   int nGroupId = GDB_ID_NULL ;
-   LuaGetParam( L, 1, nGroupId) ;
-   string sName ;
-   LuaGetParam( L, 2, sName) ;
-   LuaClearStack( L) ;
-  // recupero tutti gli oggetti del gruppo con il nome o suo inizio desiderato
-   INTVECTOR vIds ;
-   bool bOk = ExeGetNameInGroup( nGroupId, sName, vIds) ;
-  // restituisco il risultato
-   if ( bOk)
-      LuaSetParam( L, vIds) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaGetInfoInGroup( lua_State* L)
-{
-  // 2 parametri : GroupId, sKey
-   int nGroupId = GDB_ID_NULL ;
-   LuaGetParam( L, 1, nGroupId) ;
-   string sKey ;
-   LuaGetParam( L, 2, sKey) ;
-   LuaClearStack( L) ;
-  // recupero tutti gli oggetti con l'info richiesta
-   INTVECTOR vIds ;
-   bool bOk = ExeGetInfoInGroup( nGroupId, sKey, vIds) ;
-  // restituisco il risultato
-   if ( bOk)
-      LuaSetParam( L, vIds) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
 //-------------------------------------------------------------------------------
 static int
 LuaGetFirstGroupInGroup( lua_State* L)
@@ -649,12 +632,11 @@ LuaInstallGdbObjects( LuaMgr& luaMgr)
    bOk = bOk && luaMgr.RegisterFunction( "EgtGetNext", LuaGetNext) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtGetLastInGroup", LuaGetLastInGroup) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtGetPrev", LuaGetPrev) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtGetNameInGroup", LuaGetNameInGroup) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtGetFirstNameInGroup", LuaGetFirstNameInGroup) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtGetNextName", LuaGetNextName) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtGetLastNameInGroup", LuaGetLastNameInGroup) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtGetPrevName", LuaGetPrevName) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtGetNameInGroup", LuaGetNameInGroup) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtGetInfoInGroup", LuaGetInfoInGroup) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtGetFirstGroupInGroup", LuaGetFirstGroupInGroup) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtGetNextGroup", LuaGetNextGroup) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtGetLastGroupInGroup", LuaGetLastGroupInGroup) ;

LUA_General.cpp

@@ -107,24 +107,6 @@ LuaPause( lua_State* L)
    return 1 ;
 }
 
-//-------------------------------------------------------------------------------
-static int
-LuaGetKeyPressed( lua_State* L)
-{
-  // 1 parametro : nKeyCode
-   int nKeyCode ;
-   LuaCheckParam( L, 1, nKeyCode)
-   LuaClearStack( L) ;
-  // se abilitata UI, controllo se il tasto indicato è premuto
-   bool bPressed = false ;
-   if ( ExeGetEnableUI()) {
-      bPressed = (( GetAsyncKeyState( nKeyCode) & 0x8000) != 0) ;
-   }
-  // restituisco il risultato
-   LuaSetParam( L, bPressed) ;
-   return 1 ;
-}
-
 //-------------------------------------------------------------------------------
 static int
 LuaStartCounter( lua_State* L)
@@ -1083,20 +1065,6 @@ LuaGetMsg( lua_State* L)
    return 1 ;
 }
 
-//-------------------------------------------------------------------------------
-static int
-LuaVerifyKeyOption( lua_State* L)
-{
-  // 1 parametro : nOptInd
-   int nOptInd ;
-   LuaCheckParam( L, 1, nOptInd)
-   LuaClearStack( L) ;
-  // verifico l'abilitazione dell'opzione (da chiave + licenza)
-   bool bOk = ExeVerifyKeyOption( nOptInd) ;
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
 //-------------------------------------------------------------------------------
 static int
 LuaWinExec( lua_State* L)
@@ -1354,7 +1322,6 @@ LuaInstallGeneral( LuaMgr& luaMgr)
    bOk = bOk && luaMgr.RegisterFunction( "print", MyPrint) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtEvalNumExpr", LuaEvalNumExpr) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtPause", LuaPause) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtGetKeyPressed", LuaGetKeyPressed) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtStartCounter", LuaStartCounter) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtStopCounter", LuaStopCounter) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtNumToString", LuaNumToString) ;
@@ -1398,7 +1365,6 @@ LuaInstallGeneral( LuaMgr& luaMgr)
    bOk = bOk && luaMgr.RegisterFunction( "EgtIs64bit", LuaIs64bit) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtGetLanguage", LuaGetLanguage) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtMsg", LuaGetMsg) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtVerifyKeyOption", LuaVerifyKeyOption) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtDialogBox", LuaDialogBox) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtWinExec", LuaWinExec) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtCloseExe", LuaCloseExe) ;  

LUA_MachMgr.cpp

@@ -1080,53 +1080,6 @@ LuaChangeTable( lua_State* L)
    return 1 ;
 }
 
-//-------------------------------------------------------------------------------
-static int
-LuaMoveDispAxis( lua_State* L)
-{
-  // 2 parametri : sName, dPos
-   string sName ;
-   LuaCheckParam( L, 1, sName)
-   double dPos ;
-   LuaCheckParam( L, 2, dPos)
-   LuaClearStack( L) ;
-  // muovo l'asse nella nuova posizione
-   bool bOk = ExeMoveDispAxis( sName, dPos) ;
-  // restituisco il risultato
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaRemoveDispAxis( lua_State* L)
-{
-  // 1 parametro : sName
-   string sName ;
-   LuaCheckParam( L, 1, sName)
-   LuaClearStack( L) ;
-  // rimuovo il movimento dell'asse
-   bool bOk = ExeRemoveDispAxis( sName) ;
-  // restituisco il risultato
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaKeepAllDispAxes( lua_State* L)
-{
-  // 1 parametro : nSouPhase
-   int nSouPhase ;
-   LuaCheckParam( L, 1, nSouPhase) ;
-   LuaClearStack( L) ;
-  // confermo i movimenti degli assi di disposizione nella fase corrente della macchinata corrente
-   bool bOk = ExeKeepAllDispAxes( nSouPhase) ;
-  // restituisco il risultato
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
 //-------------------------------------------------------------------------------
 static int
 LuaAddFixture( lua_State* L)
@@ -1141,7 +1094,7 @@ LuaAddFixture( lua_State* L)
    if ( LuaGetParam( L, 3, dAngRotDeg))
       LuaGetParam( L, 4, dMov) ;
    LuaClearStack( L) ;
-  // aggiungo la ventosa nella posizione indicata
+  // metto l'asse nella nuova posizione
    int nId = ExeAddFixture( sName, ptPos, dAngRotDeg, dMov) ;
   // restituisco il risultato
    if ( nId != GDB_ID_NULL)
@@ -1251,23 +1204,6 @@ LuaRotateFixture( lua_State* L)
    return 1 ;
 }
 
-//-------------------------------------------------------------------------------
-static int
-LuaSetFixtureLink( lua_State* L)
-{
-  // 2 parametri : nFxtId, sTaLink
-   int nFxtId ;
-   LuaCheckParam( L, 1, nFxtId)
-   string sTaLink ;
-   LuaCheckParam( L, 2, sTaLink)
-   LuaClearStack( L) ;
-  // aggancio il bloccaggio ad asse tavola
-   bool bOk= ExeSetFixtureLink( nFxtId, sTaLink) ;
-  // restituisco il risultato
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
 //-------------------------------------------------------------------------------
 static int
 LuaMoveFixtureMobile( lua_State* L)
@@ -1285,23 +1221,6 @@ LuaMoveFixtureMobile( lua_State* L)
    return 1 ;
 }
 
-//-------------------------------------------------------------------------------
-static int
-LuaSetFixtureMobile( lua_State* L)
-{
-  // 2 parametri : nFxtId, dMov
-   int nFxtId ;
-   LuaCheckParam( L, 1, nFxtId)
-   double dMov ;
-   LuaCheckParam( L, 2, dMov)
-   LuaClearStack( L) ;
-  // imposto il movimento della parte mobile del bloccaggio
-   bool bOk= ExeSetFixtureMobile( nFxtId, dMov) ;
-  // restituisco il risultato
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
 //-------------------------------------------------------------------------------
 //     Tools database
 //-------------------------------------------------------------------------------
@@ -1710,22 +1629,6 @@ LuaTdbGetCurrToolThLength( lua_State* L)
    return 1 ;
 }
 
-//-------------------------------------------------------------------------------
-static int
-LuaTdbIsCurrToolStandardDraw( lua_State* L)
-{
-  // nessun parametro
-   LuaClearStack( L) ;
-  // recupero lo stato
-   bool bStandard ;
-   bool bOk = ExeTdbCurrToolIsStandardDraw( bStandard) ;
-   if ( bOk)
-      LuaSetParam( L, bStandard) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
 //-------------------------------------------------------------------------------
 static int
 LuaTdbGetCurrToolDraw( lua_State* L)
@@ -2693,34 +2596,6 @@ LuaSpecialUpdateDisposition( lua_State* L)
    return 1 ;
 }
 
-//-------------------------------------------------------------------------------
-static int
-LuaGetDispositionToolData( lua_State* L)
-{
-  // 1 parametro : nId
-   int nId ;
-   LuaCheckParam( L, 1, nId)
-   LuaClearStack( L) ;
-  // recupero dati dell'eventuale utensile associato alla disposizione
-   string sName ;
-   string sHead ;
-   int nExit ;
-   string sTcPos ;
-   bool bOk = ExeGetDispositionToolData( nId, sName, sHead, nExit, sTcPos) ;
-  // restituisco il risultato
-   if ( bOk) {
-      LuaSetParam( L, sName) ;
-      LuaSetParam( L, sHead) ;
-      LuaSetParam( L, nExit) ;
-      LuaSetParam( L, sTcPos) ;
-      return 4 ;
-   }
-   else {
-      LuaSetParam( L) ;
-      return 1 ;
-   }
-}
-
 //-------------------------------------------------------------------------------
 //    Machinings
 //-------------------------------------------------------------------------------
@@ -3007,23 +2882,6 @@ LuaGetMachiningGeometry( lua_State* L)
    return 1 ;
 }
 
-//-------------------------------------------------------------------------------
-static int
-LuaGetMachiningSkippedGeometry( lua_State* L)
-{
-  // nessun parametro
-   LuaClearStack( L) ;
-  // recupero gli indici della geometria non lavorata della lavorazione corrente
-   SELVECTOR vSel ;
-   bool bOk = ExeGetMachiningSkippedGeometry( vSel) ;
-  // restituisco il risultato
-   if ( bOk)
-      LuaSetParam( L, vSel) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
 //-------------------------------------------------------------------------------
 static int
 LuaIsMachiningEmpty( lua_State* L)
@@ -3172,25 +3030,6 @@ LuaGetClEntIndex( lua_State* L)
    return 1 ;
 }
 
-//-----------------------------------------------------------------------------
-static int
-LuaGetClEntAxesStatus( lua_State* L)
-{
-  // 1 parametro : nEntId
-   int nEntId ;
-   LuaGetParam( L, 1, nEntId) ;
-   LuaClearStack( L) ;
-  // recupero lo stato del movimento assi
-   int nStatus ;
-   bool bOk = ExeGetClEntAxesStatus( nEntId, nStatus) ;
-  // restituisco il risultato
-   if ( bOk)
-      LuaSetParam( L, nStatus) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
 //-----------------------------------------------------------------------------
 static int
 LuaGetClEntAxesMask( lua_State* L)
@@ -3199,7 +3038,7 @@ LuaGetClEntAxesMask( lua_State* L)
    int nEntId ;
    LuaGetParam( L, 1, nEntId) ;
    LuaClearStack( L) ;
-  // recupero la mascheratura del movimento assi (valida solo in rapido)
+  // recupero la mascheratura del movimento assi
    int nMask ;
    bool bOk = ExeGetClEntAxesMask( nEntId, nMask) ;
   // restituisco il risultato
@@ -3898,26 +3737,6 @@ LuaGetHeadExitCount( lua_State* L)
    return 1 ;
 }
 
-//-------------------------------------------------------------------------------
-static int
-LuaGetExitId( lua_State* L)
-{
-  // 2 parametri : sHead, nExit
-   string sHead ;
-   LuaCheckParam( L, 1, sHead)
-   int nExit ;
-   LuaCheckParam( L, 2, nExit)
-   LuaClearStack( L) ;
-  // recupero l'identificativo dell'Uscita della Testa indicata della macchina
-   int nId = ExeGetExitId( sHead, nExit) ;
-  // restituisco il risultato
-   if ( nId != GDB_ID_NULL)
-      LuaSetParam( L, nId) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
 //-------------------------------------------------------------------------------
 static int
 LuaGetTcPosId( lua_State* L)
@@ -3974,25 +3793,6 @@ LuaGetAxisType( lua_State* L)
    return 1 ;
 }
 
-//-------------------------------------------------------------------------------
-static int
-LuaGetAxisDir( lua_State* L)
-{
-  // 1 parametro : sAxis
-   string sAxis ;
-   LuaCheckParam( L, 1, sAxis)
-   LuaClearStack( L) ;
-  // recupero la direzione dell'asse
-   Vector3d vtDir ;
-   bool bOk = ExeGetAxisDir( sAxis, vtDir) ;
-  // restituisco il risultato
-   if ( bOk)
-      LuaSetParam( L, vtDir) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
 //-------------------------------------------------------------------------------
 static int
 LuaGetAxisInvert( lua_State* L)
@@ -4367,9 +4167,6 @@ LuaInstallMachMgr( LuaMgr& luaMgr)
    bOk = bOk && luaMgr.RegisterFunction( "EgtGetTableArea", LuaGetTableArea) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtGetTableAreaOffset", LuaGetTableAreaOffset) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtChangeTable", LuaChangeTable) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtMoveDispAxis", LuaMoveDispAxis) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtRemoveDispAxis", LuaRemoveDispAxis) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtKeepAllDispAxes", LuaKeepAllDispAxes) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtAddFixture", LuaAddFixture) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtKeepFixture", LuaKeepFixture) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtRemoveFixture", LuaRemoveFixture) ;
@@ -4377,9 +4174,7 @@ LuaInstallMachMgr( LuaMgr& luaMgr)
    bOk = bOk && luaMgr.RegisterFunction( "EgtGetNextFixture", LuaGetNextFixture) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtMoveFixture", LuaMoveFixture) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtRotateFixture", LuaRotateFixture) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSetFixtureLink", LuaSetFixtureLink) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtMoveFixtureMobile", LuaMoveFixtureMobile) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSetFixtureMobile", LuaSetFixtureMobile) ;
    // Tools database
    bOk = bOk && luaMgr.RegisterFunction( "EgtTdbGetToolNewName", LuaTdbGetToolNewName) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtTdbAddTool", LuaTdbAddTool) ;
@@ -4399,7 +4194,6 @@ LuaInstallMachMgr( LuaMgr& luaMgr)
    bOk = bOk && luaMgr.RegisterFunction( "EgtTdbGetCurrToolMaxDepth", LuaTdbGetCurrToolMaxDepth) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtTdbGetCurrToolThDiam", LuaTdbGetCurrToolThDiam) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtTdbGetCurrToolThLength", LuaTdbGetCurrToolThLength) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtTdbIsCurrToolStandardDraw", LuaTdbIsCurrToolStandardDraw) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtTdbGetCurrToolDraw", LuaTdbGetCurrToolDraw) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtTdbReload", LuaTdbReload) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtTdbSave", LuaTdbSave) ;
@@ -4458,7 +4252,6 @@ LuaInstallMachMgr( LuaMgr& luaMgr)
    bOk = bOk && luaMgr.RegisterFunction( "EgtGetPhaseDisposition", LuaGetPhaseDisposition) ; 
    bOk = bOk && luaMgr.RegisterFunction( "EgtSpecialApplyDisposition", LuaSpecialApplyDisposition) ; 
    bOk = bOk && luaMgr.RegisterFunction( "EgtSpecialUpdateDisposition", LuaSpecialUpdateDisposition) ; 
-   bOk = bOk && luaMgr.RegisterFunction( "EgtGetDispositionToolData", LuaGetDispositionToolData) ;   
    // Machinings
    bOk = bOk && luaMgr.RegisterFunction( "EgtAddMachining", LuaAddMachining) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtCreateMachining", LuaCreateMachining) ;
@@ -4473,7 +4266,6 @@ LuaInstallMachMgr( LuaMgr& luaMgr)
    bOk = bOk && luaMgr.RegisterFunction( "EgtUpdateMachining", LuaUpdateMachining) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtGetMachiningParam", LuaGetMachiningParam) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtGetMachiningGeometry", LuaGetMachiningGeometry) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtGetMachiningSkippedGeometry", LuaGetMachiningSkippedGeometry) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtIsMachiningEmpty", LuaIsMachiningEmpty) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtGetMachiningStartPoint", LuaGetMachiningStartPoint) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtGetMachiningEndPoint", LuaGetMachiningEndPoint) ;
@@ -4483,7 +4275,6 @@ LuaInstallMachMgr( LuaMgr& luaMgr)
    bOk = bOk && luaMgr.RegisterFunction( "EgtGetClEntMove", LuaGetClEntMove) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtGetClEntFlag", LuaGetClEntFlag) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtGetClEntIndex", LuaGetClEntIndex) ;  
-   bOk = bOk && luaMgr.RegisterFunction( "EgtGetClEntAxesStatus", LuaGetClEntAxesStatus) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtGetClEntAxesMask", LuaGetClEntAxesMask) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtGetClEntAxesVal", LuaGetClEntAxesVal) ;  
    // Simulation
@@ -4508,11 +4299,9 @@ LuaInstallMachMgr( LuaMgr& luaMgr)
    bOk = bOk && luaMgr.RegisterFunction( "EgtGetAxisId", LuaGetAxisId) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtGetHeadId", LuaGetHeadId) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtGetHeadExitCount", LuaGetHeadExitCount) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtGetExitId", LuaGetExitId) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtGetTcPosId", LuaGetTcPosId) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtGetAxisToken", LuaGetAxisToken) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtGetAxisType", LuaGetAxisType) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtGetAxisDir", LuaGetAxisDir) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtGetAxisInvert", LuaGetAxisInvert) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtGetAxisOffset", LuaGetAxisOffset) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtGetAllTablesNames", LuaGetAllTablesNames) ;