EgtExecutor :

- correzione minore a export 3dm.
EgtExecutor :
2023-10-17 11:12:09 +02:00 · 2023-10-12 11:01:31 +02:00 · 2023-10-12 11:01:27 +02:00 · 2023-10-12 11:01:20 +02:00
83 changed files with 2271 additions and 16604 deletions
@@ -1,181 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2023-2023
-//----------------------------------------------------------------------------
-// File : DllExch3dm.cpp       Data : 14.11.23        Versione : 2.5k2
-// Contenuto : Funzioni di gestione della libreria opzionale EgtExch3dme.
-//
-//
-//
-// Modifiche : 14.11.23 DS Creazione modulo.
-//
-//
-//
-//----------------------------------------------------------------------------
-
-//--------------------------- Include ----------------------------------------
-#include "stdafx.h"
-#include "EXE.h"
-#include "DllExch3dm.h"
-#include "/EgtDev/Include/EE3DllMain.h"
-#define NOMINMAX
-#include <windows.h>
-
-using namespace std ;
-
-//-----------------------------------------------------------------------------
-// Nome della libreria
-#if defined( _WIN64) &&  defined( _DEBUG)
-   static const wchar_t* EE3_NAME = L"EgtExch3dmD64.dll" ;
-#elif defined( _WIN64)
-   static const wchar_t* EE3_NAME = L"EgtExch3dmR64.dll" ;
-#elif defined( _WIN32) &&  defined( _DEBUG)
-   static const wchar_t* EE3_NAME = L"EgtExch3dmD32.dll" ;
-#else
-   static const wchar_t* EE3_NAME = L"EgtExch3dmR32.dll" ;
-#endif
-// Nome delle funzioni caricate
-static const char* EE3_SETEE3LOGGER = "SetEE3Logger" ;
-static const char* EE3_GETEE3VERSION = "GetEE3Version" ;
-static const char* EE3_SETEE3KEY = "SetEE3Key" ;
-static const char* EE3_SETEE3NETHWKEY = "SetEE3NetHwKey" ;
-static const char* EE3_CREATEIMPORT3DM = "CreateImport3dm" ;
-static const char* EE3_CREATEEXPORT3DM = "CreateExport3dm" ;
-
-
-//-----------------------------------------------------------------------------
-HMODULE s_hEE3 = nullptr ;
-
-//-----------------------------------------------------------------------------
-bool
-LoadExch3dmDll( ILogger* pLogger, const string& sKey, bool bNetHwKey)
-{
-  // verifico la chiave
-   if ( ! TestKeyForEE3( sKey, 0, pLogger)) {
-      FreeExch3dmDll() ;
-      return false ;
-   }
-  // se già caricata
-   if ( s_hEE3 != nullptr)
-      return true ;
-  // carico la libreria EgtExch3dm
-   s_hEE3 = LoadLibrary( EE3_NAME) ;
-   if ( s_hEE3 == nullptr)
-      return false ;
-  // imposto logger
-   MySetEE3Logger( pLogger) ;
-  // imposto i codici della chiave
-   MySetEE3Key( sKey) ;
-  // imposto eventuale chiave di rete
-   MySetEE3NetHwKey( bNetHwKey) ;
-   return true ;
-}
-
-//-----------------------------------------------------------------------------
-bool
-FreeExch3dmDll( void)
-{
-  // se non è già caricata
-   if ( s_hEE3 == nullptr)
-      return true ;
-  // libero la libreria EgtExch3dm
-   FreeLibrary( s_hEE3) ;
-   s_hEE3 = nullptr ;
-   return true ;
-}
-
-//-----------------------------------------------------------------------------
-bool
-IsLoadedExch3dmDll( void)
-{
-   return ( s_hEE3 != nullptr) ;
-}
-
-//-----------------------------------------------------------------------------
-void
-MySetEE3Logger( ILogger* pLogger)
-{
-  // verifico caricamento libreria EgtExch3dm
-   if ( s_hEE3 == nullptr)
-      return ;
-  // recupero funzione che imposta il logger
-   typedef void (* PF_SetEE3Logger) ( ILogger* pLogger) ;
-   PF_SetEE3Logger pFun = (PF_SetEE3Logger)GetProcAddress( s_hEE3, EE3_SETEE3LOGGER) ;
-   if ( pFun == nullptr)
-      return ;
-   pFun( pLogger) ;
-}
-
-//-----------------------------------------------------------------------------
-const char*
-MyGetEE3Version( void)
-{
-  // verifico caricamento libreria EgtExch3dm
-   if ( s_hEE3 == nullptr)
-      return "" ;
-  // recupero funzione che restituisce la versione della libreria
-   typedef const char* (* PF_GetEE3Version) ( void) ;
-   PF_GetEE3Version pFun = (PF_GetEE3Version)GetProcAddress( s_hEE3, EE3_GETEE3VERSION) ;
-   if ( pFun == nullptr)
-      return "" ;
-   return pFun() ;
-}
-
-//-----------------------------------------------------------------------------
-void
-MySetEE3Key( const string& sKey)
-{
-  // verifico caricamento libreria EgtExch3dm
-   if ( s_hEE3 == nullptr)
-      return ;
-  // recupero funzione che imposta i codici di protezione
-   typedef void (* PF_SetEE3Key) ( const string& sKey) ;
-   PF_SetEE3Key pFun = (PF_SetEE3Key)GetProcAddress( s_hEE3, EE3_SETEE3KEY) ;
-   if ( pFun == nullptr)
-      return ;
-   pFun( sKey) ;
-}
-
-//-----------------------------------------------------------------------------
-void
-MySetEE3NetHwKey( bool bNetHwKey)
-{
-  // verifico caricamento libreria EgtExch3dm
-   if ( s_hEE3 == nullptr)
-      return ;
-  // recupero funzione che imposta il flag per chiave di rete
-   typedef void (* PF_SetEE3NetHwKey) ( bool bNetHwKey) ;
-   PF_SetEE3NetHwKey pFun = (PF_SetEE3NetHwKey)GetProcAddress( s_hEE3, EE3_SETEE3NETHWKEY) ;
-   if ( pFun == nullptr)
-      return ;
-   pFun( bNetHwKey) ;
-}
-
-//-----------------------------------------------------------------------------
-IImport3dm*
-MyCreateImport3dm( void)
-{
-  // verifico caricamento libreria EgtExch3dm
-   if ( s_hEE3 == nullptr)
-      return nullptr ;
-  // recupero funzione creazione oggetto
-   typedef IImport3dm* (* PF_CreateImport3dm) ( void) ;
-   PF_CreateImport3dm pFun = (PF_CreateImport3dm)GetProcAddress( s_hEE3, EE3_CREATEIMPORT3DM) ;
-   if ( pFun == nullptr)
-      return nullptr ;
-   return pFun() ;
-}
-
-//-----------------------------------------------------------------------------
-IExport3dm*
-MyCreateExport3dm( void)
-{
-  // verifico caricamento libreria EgtExch3dm
-   if ( s_hEE3 == nullptr)
-      return nullptr ;
-  // recupero funzione creazione oggetto
-   typedef IExport3dm* (* PF_CreateExport3dm) ( void) ;
-   PF_CreateExport3dm pFun = (PF_CreateExport3dm)GetProcAddress( s_hEE3, EE3_CREATEEXPORT3DM) ;
-   if ( pFun == nullptr)
-      return nullptr ;
-   return pFun() ;
-}
@@ -1,31 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2023-2023
-//----------------------------------------------------------------------------
-// File : DllExch3dm.h         Data : 14.11.23        Versione : 2.5k3
-// Contenuto : Dichiarazioni funzioni per libreria opzionale EgtExchange.
-//
-//
-//
-// Modifiche : 14.11.23 DS Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-#pragma once
-
-#include <string>
-
-class ILogger ;
-class IImport3dm ;
-class IExport3dm ;
-
-//----------------------------------------------------------------------------
-bool LoadExch3dmDll( ILogger* pLogger, const std::string& sKey, bool bNetHwKey) ;
-bool FreeExch3dmDll( void) ;
-bool IsLoadedExch3dmDll( void) ;
-void MySetEE3Logger( ILogger* pLogger) ;
-void MySetEE3Key( const std::string& sKey) ;
-void MySetEE3NetHwKey( bool bNetHwKey) ;
-const char* MyGetEE3Version( void) ;
-IImport3dm* MyCreateImport3dm( void) ;
-IExport3dm* MyCreateExport3dm( void) ;
@@ -10,8 +10,8 @@
 //             03.07.18 DS Aggiunto ImportPnt.
 //             15.09.19 DS Aggiunto ExportSvg.
 //             14.12.20 DS Aggiunto ImportBtlx.
-//             23.10.23 DB Aggiunto Export3dm.
-//             07.11.23 DB Aggiunto Import3dm.
+//             23.06.23 DB Aggiunto Import3dm.
+//             21.09.23 DB Aggiunto Export3dm.
 //
 //----------------------------------------------------------------------------

@@ -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,12 +50,12 @@ 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_CREATEIMPORT3DM = "CreateImport3dm" ;
 static const char* EEX_CREATEEXPORTDXF = "CreateExportDxf" ;
 static const char* EEX_CREATEEXPORTSTL = "CreateExportStl" ;
 static const char* EEX_CREATEEXPORT3MF = "CreateExport3MF" ;
+static const char* EEX_CREATEEXPORT3DM = "CreateExport3dm" ;
 static const char* EEX_CREATEEXPORTSVG = "CreateExportSvg" ;
 static const char* EEX_SETTHREEJSLIBDIR = "SetThreeJSLibDir" ;
 static const char* EEX_CREATEEXPORTTHREEJS = "CreateExportThreeJS" ;
@@ -75,7 +74,7 @@ LoadExchangeDll( ILogger* pLogger, const string& sKey, bool bNetHwKey)
      FreeExchangeDll() ;
      return false ;
   }
-  // se già caricata
+  // se già caricata
   if ( s_hEEx != nullptr)
      return true ;
  // carico la libreria EgtExchange
@@ -95,7 +94,7 @@ LoadExchangeDll( ILogger* pLogger, const string& sKey, bool bNetHwKey)
 bool
 FreeExchangeDll( void)
 {
-  // se non è già caricata
+  // se non è già caricata
   if ( s_hEEx == nullptr)
      return true ;
  // libero la libreria EgtExchange
@@ -186,21 +185,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 +305,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)
@@ -366,6 +320,21 @@ MyCreateImport3MF( void)
   return pFun() ;
 }

+//-----------------------------------------------------------------------------
+IImport3dm*
+MyCreateImport3dm( void)
+{
+  // verifico caricamento libreria EgtExchange
+   if ( s_hEEx == nullptr)
+      return nullptr ;
+  // recupero funzione creazione oggetto
+   typedef IImport3dm* (* PF_CreateImport3dm) ( void) ;
+   PF_CreateImport3dm pFun = (PF_CreateImport3dm)GetProcAddress( s_hEEx, EEX_CREATEIMPORT3DM) ;
+   if ( pFun == nullptr)
+      return nullptr ;
+   return pFun() ;
+}
+
 //-----------------------------------------------------------------------------
 IExportDxf*
 MyCreateExportDxf( void)
@@ -411,6 +380,21 @@ MyCreateExport3MF( void)
   return pFun() ;
 }

+//-----------------------------------------------------------------------------
+IExport3dm*
+MyCreateExport3dm( void)
+{
+  // verifico caricamento libreria EgtExchange
+   if ( s_hEEx == nullptr)
+      return nullptr ;
+  // recupero funzione creazione oggetto
+   typedef IExport3dm* (* PF_CreateExport3dm) ( void) ;
+   PF_CreateExport3dm pFun = (PF_CreateExport3dm)GetProcAddress( s_hEEx, EEX_CREATEEXPORT3DM) ;
+   if ( pFun == nullptr)
+      return nullptr ;
+   return pFun() ;
+}
+
 //-----------------------------------------------------------------------------
 IExportSvg*
 MyCreateExportSvg( void)
@@ -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,12 +24,12 @@ class IImportCsf ;
 class IImportDxf ;
 class IImportPnt ;
 class IImportStl ;
-class IImportOff ;
-class IImportPly ;
 class IImport3MF ;
+class IImport3dm ;
 class IExportDxf ;
 class IExportStl ;
 class IExport3MF ;
+class IExport3dm ;
 class IExportThreeJS ;
 class IExportSvg ;
 class IExcExecutor ;
@@ -43,7 +43,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,12 +51,12 @@ IImportCsf* MyCreateImportCsf( void) ;
 IImportDxf* MyCreateImportDxf( void) ;
 IImportPnt* MyCreateImportPnt( void) ;
 IImportStl* MyCreateImportStl( void) ;
-IImportOff* MyCreateImportOff( void) ;
-IImportPly* MyCreateImportPly( void) ;
 IImport3MF* MyCreateImport3MF( void) ;
+IImport3dm* MyCreateImport3dm( void) ;
 IExportDxf* MyCreateExportDxf( void) ;
 IExportStl* MyCreateExportStl( void) ;
 IExport3MF* MyCreateExport3MF( void) ;
+IExport3dm* MyCreateExport3dm( void) ;
 bool MySetThreeJSLibDir( const std::string& sThreeJSLibDir) ;
 IExportThreeJS* MyCreateExportThreeJS( void) ;
 IExportSvg* MyCreateExportSvg( void) ;
@@ -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) ;
@@ -44,6 +43,3 @@ bool ExeInsertDuplo( int nInsGrp) ;
 //----------------------------------------------------------------------------
 bool ExeCreateMutex( const std::string& sMutexName) ;
 bool ExeReleaseMutex( void) ;
-
-//----------------------------------------------------------------------------
-bool ExeSetModified( int nCtx) ;
@@ -1,66 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2025-2025
-//----------------------------------------------------------------------------
-// File : EXE_Base64.cpp       Data : 03.11.25        Versione : 2.7k1
-// Contenuto : Funzioni per codificare/decodificare in Base64.
-//
-//
-//
-// Modifiche : 03.11.25 DS Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-//--------------------------- Include ----------------------------------------
-#include "stdafx.h"
-#include "/EgtDev/Include/EXeExecutor.h"
-#include "/EgtDev/Include/EgtStringConverter.h"
-#include "/EgtDev/Include/EgtBase64.h"
-#include <fstream>
-
-using namespace std ;
-
-//----------------------------------------------------------------------------
-bool
-ExeBase64Encode( const string& sFile, string& sB64Dest)
-{
-  // apro il file in modo binario
-   ifstream InFile( stringtoW( sFile), ios::in | ios::binary, _SH_DENYWR) ;
-   if ( InFile.fail()) {
-      if ( InFile.is_open())
-         InFile.close() ;
-      return false ;
-   }
-  // leggo il file
-   string sSou( istreambuf_iterator<char>( InFile), {}) ;
-  // lo chiudo
-   if ( InFile.is_open())
-      InFile.close() ;
-
-  // converto in Base64
-   return B64Encode( sSou, sB64Dest) ;
-}
-
-//----------------------------------------------------------------------------
-bool
-ExeBase64Decode( const string& sB64Sou, const string& sFile)
-{
-  // converto da Base64
-   string sDest ;
-   if ( ! B64Decode( sB64Sou, sDest))
-      return false ;
-
-  // apro il file in modo binario
-   ofstream OutFile( stringtoW( sFile), ios::out | ios::binary, _SH_DENYWR) ;
-   if ( ! OutFile.good()) {
-      if ( OutFile.is_open())
-         OutFile.close() ;
-      return false ;
-   }
-  // scrivo sul file
-   OutFile.write( sDest.data(), sDest.size()) ;
-  // lo chiudo
-   if ( OutFile.is_open())
-      OutFile.close() ;
-   return true ;
-}
@@ -216,44 +216,6 @@ ExeBeamEnableProcess( int nGeomId, bool bEnable, bool bUpdate)
   return pBeamMgr->EnableProcess( nGeomId, bEnable, bUpdate) ;
 }

-//-----------------------------------------------------------------------------
-bool
-ExeBeamCalcAllSolids( bool bShow, bool bRecalc)
-{
-   IBeamMgr* pBeamMgr = GetCurrBeamMgr() ;
-   VERIFY_BEAMMGR( pBeamMgr, false)
-  // disabilito possibilità di alterare il flag di modifica
-   bool bOldEnabModif = ExeGetEnableModified() ;
-   if ( bOldEnabModif)
-      ExeDisableModified() ;
-  // calcolo i solidi di tutte le travi
-   bool bOk = pBeamMgr->CalcAllSolids( bShow, bRecalc, ExeProcessEvents) ;
-  // ripristino possibilità di alterare il flag di modifica
-   if ( bOldEnabModif)
-      ExeEnableModified() ;
-  // risultato
-   return bOk ;
-}
-
-//-----------------------------------------------------------------------------
-bool
-ExeBeamShowAllSolids( bool bShow)
-{
-   IBeamMgr* pBeamMgr = GetCurrBeamMgr() ;
-   VERIFY_BEAMMGR( pBeamMgr, false)
-  // disabilito possibilità di alterare il flag di modifica
-   bool bOldEnabModif = ExeGetEnableModified() ;
-   if ( bOldEnabModif)
-      ExeDisableModified() ;
-  // aggiorno stato di visualizzazione dei solidi di tutte le travi
-   bool bOk = pBeamMgr->ShowAllSolids( bShow, ExeProcessEvents) ;
-  // ripristino possibilità di alterare il flag di modifica
-   if ( bOldEnabModif)
-      ExeEnableModified() ;
-  // risultato
-   return bOk ;
-}
-
 //-----------------------------------------------------------------------------
 bool
 ExeBeamCalcSolid( int nPartId, bool bRecalc)
@@ -304,17 +266,17 @@ ExeBeamShowSolid( int nPartId, bool bShow)

 //-----------------------------------------------------------------------------
 bool
-ExeBeamGetBuildingIsOn( int nAssGrpId)
+ExeBeamGetBuildingIsOn( void)
 {
   IBeamMgr* pBeamMgr = GetCurrBeamMgr() ;
   VERIFY_BEAMMGR( pBeamMgr, false)
  // verifico se assemblaggio attivato
-   return pBeamMgr->GetBuildingIsOn( nAssGrpId) ;
+   return pBeamMgr->GetBuildingIsOn() ;
 }

 //-----------------------------------------------------------------------------
 bool
-ExeBeamShowBuilding( int nAssGrpId, bool bShow)
+ExeBeamShowBuilding( bool bShow)
 {
   IBeamMgr* pBeamMgr = GetCurrBeamMgr() ;
   VERIFY_BEAMMGR( pBeamMgr, false)
@@ -323,7 +285,7 @@ ExeBeamShowBuilding( int nAssGrpId, bool bShow)
   if ( bOldEnabModif)
      ExeDisableModified() ;
  // attivo o disattivo la visualizzazione l'assemblaggio
-   bool bOk = pBeamMgr->ShowBuilding( nAssGrpId, bShow) ;
+   bool bOk = pBeamMgr->ShowBuilding( bShow) ;
  // ripristino possibilità di alterare il flag di modifica
   if ( bOldEnabModif)
      ExeEnableModified() ;
@@ -22,7 +22,6 @@
 #include "/EgtDev/Include/EXeConst.h"
 #include "/EgtDev/Include/EGkCurve.h"
 #include "/EgtDev/Include/EGkCurveComposite.h"
-#include "/EgtDev/Include/EGkStmStandard.h"
 #include "/EgtDev/Include/EGkCAvToolSurfTm.h"
 #include "/EgtDev/Include/EgtNumUtils.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
@@ -99,28 +98,6 @@ ExeCAvGetToolOutline( int nDestGrpId, bool bApprox)
   return nId ;
 }

-//----------------------------------------------------------------------------
-double
-ExeCAvToolPosBox( const Point3d& ptP, const Vector3d& vtAx, const BBox3d& b3Box, const Vector3d& vtMove)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-  // creo la superficie TriMesh
-   PtrOwner<ISurfTriMesh> pStm( GetSurfTriMeshBox( b3Box.GetDimX(), b3Box.GetDimY(), b3Box.GetDimZ())) ;
-   if ( IsNull( pStm))
-      return -1 ;
-   pStm->Translate( b3Box.GetMin() - ORIG) ;
-  // verifico oggetto per evitare collisioni
-   if ( IsNull( s_pCAvTlStm))
-      return -1 ;
-  // imposto dati
-   s_pCAvTlStm->SetSurfTm( *pStm) ;
-   double dMove ;
-   if ( ! s_pCAvTlStm->TestPosition( ptP, vtAx, vtMove, dMove))
-      return -1 ;
-   return dMove ;
-}
-
 //----------------------------------------------------------------------------
 double
 ExeCAvToolPosStm( const Point3d& ptP, const Vector3d& vtAx, int nSurfTmId, const Vector3d& vtMove, int nRefType)
@@ -175,23 +152,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 +175,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))
@@ -1,9 +1,9 @@
 //----------------------------------------------------------------------------
 //  EgalTech 2020-2020
 //----------------------------------------------------------------------------
-// File : EXE_CDeObjSolid.cpp    Data : 09.01.20      Versione : 2.2a2
+// File : EXE_CDeObjClosedSurfTm.cpp    Data : 09.01.20      Versione : 2.2a2
 // Contenuto : Funzioni per verificare collisioni tra
-//             Objects e Solidi (Closed SurftriMesh e Zmap).
+//             Objects e Closed SurftriMesh.
 //
 //
 // Modifiche : 09.01.20 DS Creazione modulo.
@@ -49,7 +49,7 @@ MyCDeBoxClosedSurfTm( const Frame3d& frBox, const Vector3d& vtDiag, int nSurfTmI
  // porto in locale alla superficie il riferimento del box (il vettore è già in questo stesso riferimento)
   Frame3d frBoxL = GetFrameLocal( pGeomDB, frBox, nRefType, frSurf) ;
  // verifico la collisione
-   return ( CDeBoxClosedSurfTm( frBoxL, vtDiag, *pStm, dSafeDist) ? 1 : 0) ;
+   return ( CDeBoxClosedSurfTm( frBoxL, vtDiag, dSafeDist, *pStm) ? 1 : 0) ;
 }

 //----------------------------------------------------------------------------
@@ -69,7 +69,7 @@ MyCDeBoxVolZmap( const Frame3d& frBox, const Vector3d& vtDiag, int nZmapId, doub
  // porto in locale il riferimento (il vettore è già in locale a questo stesso riferimento)
   Frame3d frBoxL = GetFrameLocal( pGeomDB, frBox, nRefType, frLoc) ;
  // verifico la collisione
-   return ( pVZM->CDeBox( frBoxL, vtDiag, dSafeDist, false) ? 1 : 0) ;
+   return ( pVZM->AvoidBox( frBoxL, vtDiag, dSafeDist, false) ? 0 : 1) ;
 }

 //----------------------------------------------------------------------------
@@ -118,7 +118,7 @@ MyCDeRectPrismoidClosedSurfTm( const Frame3d& frPrismoid, double dBaseLenX, doub
  // porto in locale alla superficie il riferimento del prismoide rettangolare
   Frame3d frPrismoidL = GetFrameLocal( pGeomDB, frPrismoid, nRefType, frSurf) ;
  // verifico la collisione
-   return ( CDeRectPrismoidClosedSurfTm( frPrismoidL, dBaseLenX, dBaseLenY, dTopLenX, dTopLenY, dHeight, *pStm, dSafeDist) ? 1 : 0) ;
+   return ( CDeRectPrismoidClosedSurfTm( frPrismoidL, dBaseLenX, dBaseLenY, dTopLenX, dTopLenY, dHeight, dSafeDist, *pStm) ? 1 : 0) ;
 }

 //----------------------------------------------------------------------------
@@ -140,7 +140,7 @@ MyCDeRectPrismoidVolZmap( const Frame3d& frPrismoid, double dBaseLenX, double dB
  // porto in locale il riferimento (il vettore è già in locale a questo stesso riferimento)
   Frame3d frPrismoidL = GetFrameLocal( pGeomDB, frPrismoid, nRefType, frLoc) ;
  // verifico la collisione
-   return ( pVZM->CDeRectPrismoid( frPrismoidL, dBaseLenX, dBaseLenY, dTopLenX, dTopLenY, dHeight, dSafeDist, false) ? 1 : 0) ;
+   return ( pVZM->AvoidRectPrismoid( frPrismoidL, dBaseLenX, dBaseLenY, dTopLenX, dTopLenY, dHeight, dSafeDist, false) ? 0 : 1) ;
 }

 //----------------------------------------------------------------------------
@@ -193,7 +193,7 @@ MyCDeCylClosedSurfTm( const Frame3d& frCyl, double dR, double dH, int nSurfTmId,
  // porto in locale alla superficie il riferimento del cilindro
   Frame3d frCylL = GetFrameLocal( pGeomDB, frCyl, nRefType, frSurf) ;
  // verifico la collisione
-   return ( CDeCylClosedSurfTm( frCylL, dR, dH, *pStm, dSafeDist) ? 1 : 0) ;
+   return ( CDeCylClosedSurfTm( frCylL, dR, dH, dSafeDist, *pStm) ? 1 : 0) ;
 }

 //----------------------------------------------------------------------------
@@ -213,7 +213,7 @@ MyCDeCylVolZmap( const Frame3d& frCyl, double dR, double dH, int nZmapId, double
  // porto in locale il riferimento
   Frame3d frCylL = GetFrameLocal( pGeomDB, frCyl, nRefType, frLoc) ;
  // verifico la collisione
-   return ( pVZM->CDeCylinder( frCylL, dR, dH, dSafeDist, false) ? 1 : 0) ;
+   return ( pVZM->AvoidCylinder( frCylL, dR, dH, dSafeDist, false) ? 0 : 1) ;
 }

 //----------------------------------------------------------------------------
@@ -261,7 +261,7 @@ MyCDeConeClosedSurfTm( const Frame3d& frCone, double dR1, double dR2, double dH,
  // porto in locale alla superficie il riferimento del cilindro
   Frame3d frConeL = GetFrameLocal( pGeomDB, frCone, nRefType, frSurf) ;
  // verifico la collisione
-   return ( CDeConeFrustumClosedSurfTm( frConeL, dR1, dR2, dH, *pStm, dSafeDist) ? 1 : 0) ;
+   return ( CDeConeFrustumClosedSurfTm( frConeL, dR1, dR2, dH, dSafeDist, *pStm) ? 1 : 0) ;
 }

 //----------------------------------------------------------------------------
@@ -281,7 +281,7 @@ MyCDeConeVolZmap( const Frame3d& frCone, double dR1, double dR2, double dH, int
  // porto in locale il riferimento
   Frame3d frConeL = GetFrameLocal( pGeomDB, frCone, nRefType, frLoc) ;
  // verifico la collisione
-   return ( pVZM->CDeConeFrustum( frConeL, dR1, dR2, dH, dSafeDist, false) ? 1 : 0) ;
+   return ( pVZM->AvoidConeFrustum( frConeL, dR1, dR2, dH, dSafeDist, false) ? 0 : 1) ;
 }

 //----------------------------------------------------------------------------
@@ -330,7 +330,7 @@ MyCDeSpheClosedSurfTm( const Point3d& ptCen, double dR, int nSurfTmId, double dS
  // porto in locale alla superficie il centro della sfera
   Point3d ptCenL = GetPointLocal( pGeomDB, ptCen, nRefType, frSurf) ;
  // verifico la collisione
-   return ( CDeSpheClosedSurfTm( ptCenL, dR, *pStm, dSafeDist) ? 1 : 0) ;
+   return ( CDeSpheClosedSurfTm( ptCenL, dR, dSafeDist, *pStm) ? 1 : 0) ;
 }

 //----------------------------------------------------------------------------
@@ -350,7 +350,7 @@ MyCDeSpheVolZmap( const Point3d& ptCen, double dRad, int nZmapId, double dSafeDi
  // porto in locale il centro della sfera
   Point3d ptCenL = GetPointLocal( pGeomDB, ptCen, nRefType, frLoc) ;
  // verifico la collisione
-   return ( pVZM->CDeSphere( ptCenL, dRad, dSafeDist, false) ? 1 : 0) ;
+   return ( pVZM->AvoidSphere( ptCenL, dRad, dSafeDist, false) ? 0 : 1) ;
 }

 //----------------------------------------------------------------------------
@@ -420,7 +420,7 @@ MyCDeClosedSurfTmVolZmap( int nSurfTmId, int nZmapId, double dSafeDist)
   if ( pVZM == nullptr)
      return -1 ;
  // verifico la collisione
-   return ( pVZM->CDeSurfTm( *pStm, dSafeDist, false) ? 1 : 0) ;
+   return ( pVZM->AvoidSurfTm( *pStm, dSafeDist, false) ? 0 : 1) ;
 }

 //----------------------------------------------------------------------------
@@ -429,14 +429,10 @@ ExeCDeSolidSolid( int nSolid1Id, int nSolid2Id, double dSafeDist)
 {
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   int nRes = -1 ;
-   if ( pGeomDB != nullptr) {
-      if ( pGeomDB->GetGeoType( nSolid1Id) == SRF_TRIMESH  &&  pGeomDB->GetGeoType( nSolid2Id) == SRF_TRIMESH)
-         nRes = MyCDeClosedSurfTmClosedSurfTm( nSolid1Id, nSolid2Id, dSafeDist) ;
-      else if ( pGeomDB->GetGeoType( nSolid1Id) == SRF_TRIMESH  &&  pGeomDB->GetGeoType( nSolid2Id) == VOL_ZMAP)
-         nRes = MyCDeClosedSurfTmVolZmap( nSolid1Id, nSolid2Id, dSafeDist) ;
-      else if ( pGeomDB->GetGeoType( nSolid1Id) == VOL_ZMAP  &&  pGeomDB->GetGeoType( nSolid2Id) == SRF_TRIMESH)
-         nRes = MyCDeClosedSurfTmVolZmap( nSolid2Id, nSolid1Id, dSafeDist) ;
-   }
+   if ( pGeomDB != nullptr  &&  pGeomDB->GetGeoType( nSolid1Id) == SRF_TRIMESH  &&  pGeomDB->GetGeoType( nSolid2Id) == SRF_TRIMESH)
+      nRes = MyCDeClosedSurfTmClosedSurfTm( nSolid1Id, nSolid2Id, dSafeDist) ;
+   else if ( pGeomDB != nullptr  &&  pGeomDB->GetGeoType( nSolid1Id) == SRF_TRIMESH  &&  pGeomDB->GetGeoType( nSolid2Id) == VOL_ZMAP)
+      nRes = MyCDeClosedSurfTmVolZmap( nSolid1Id, nSolid2Id, dSafeDist) ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtCDeSolidSolid({" + IdToString( nSolid1Id) + "," +
@@ -15,10 +15,8 @@
 #include "stdafx.h"
 #include "EXE.h"
 #include "EXE_Macro.h"
-#include "LUA_Base.h"
 #include "AuxTools.h"
 #include "DllExchange.h"
-#include "DllExch3dm.h"
 #include "/EgtDev/Include/EXeExecutor.h"
 #include "/EgtDev/Include/EXeConst.h"
 #include "/EgtDev/Include/EXeCmdLogOff.h"
@@ -30,15 +28,13 @@
 #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/EExImport3dm.h"
 #include "/EgtDev/Include/EExExportDxf.h"
 #include "/EgtDev/Include/EExExportStl.h"
 #include "/EgtDev/Include/EExExport3MF.h"
+#include "/EgtDev/Include/EExExport3dm.h"
 #include "/EgtDev/Include/EExExportSvg.h"
 #include "/EgtDev/Include/EExExportThreeJS.h"
-#include "/EgtDev/Include/EE3Import3dm.h"
-#include "/EgtDev/Include/EE3Export3dm.h"
 #include "/EgtDev/Include/EGnStringUtils.h"
 #include "/EgtDev/Include/EGnFileUtils.h"
 #include "/EgtDev/Include/EgtStringConverter.h"
@@ -76,14 +72,8 @@ ExeGetFileType( const string& sFilePath)
      return FT_STL ;
   else if ( sFileExt == "3MF")
      return FT_3MF ;
-   else if ( sFileExt == "3DM")
-      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 +82,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,9 +122,7 @@ ExeGetFileType( const string& sFilePath)
 bool
 ExeSetBtlAuxDir( const string& sBtlAuxDir)
 {
-   bool bOk1 = MySetBtlAuxDir( sBtlAuxDir) ;
-   bool bOk2 = MySetBtlLuaData( LuaGetLuaLibsDir(), LuaGetLastRequire()) ;
-   return ( bOk1  &&  bOk2) ;
+   return MySetBtlAuxDir( sBtlAuxDir) ;
 }

 //-----------------------------------------------------------------------------
@@ -159,11 +149,6 @@ ExeImportBtl( const string& sFilePath, int nFlag)
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
-  // scrivo il log
-   if ( ! IsNull( pImpBtl)) {
-      string sLog = "Import File " + sFilePath ;
-      LOG_INFO( GetLogger(), sLog.c_str()) ;
-   }
  // restituisco il risultato
   return bOk ;
 }
@@ -192,11 +177,6 @@ ExeImportBtlx( const string& sFilePath, int nFlag)
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
-  // scrivo il log
-   if ( ! IsNull( pImpBtlx)) {
-      string sLog = "Import File " + sFilePath ;
-      LOG_INFO( GetLogger(), sLog.c_str()) ;
-   }
  // restituisco il risultato
   return bOk ;
 }
@@ -227,11 +207,6 @@ ExeImportCnc( const string& sFilePath, int nFlag)
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
-  // scrivo il log
-   if ( ! IsNull( pImpCnc)) {
-      string sLog = "Import File " + sFilePath ;
-      LOG_INFO( GetLogger(), sLog.c_str()) ;
-   }
  // restituisco il risultato
   return bOk ;
 }
@@ -259,11 +234,6 @@ ExeImportCsf( const string& sFilePath)
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
-  // scrivo il log
-   if ( ! IsNull( pImpCsf)) {
-      string sLog = "Import File " + sFilePath ;
-      LOG_INFO( GetLogger(), sLog.c_str()) ;
-   }
  // restituisco il risultato
   return bOk ;
 }
@@ -294,11 +264,6 @@ ExeImportDxf( const string& sFilePath, double dScaleFactor)
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
-  // scrivo il log
-   if ( ! IsNull( pImpDxf)) {
-      string sLog = "Import File " + sFilePath ;
-      LOG_INFO( GetLogger(), sLog.c_str()) ;
-   }
  // restituisco il risultato
   return bOk ;
 }
@@ -329,11 +294,6 @@ ExeImportPnt( const string& sFilePath, int nFlag)
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
-  // scrivo il log
-   if ( ! IsNull( pImpPnt)) {
-      string sLog = "Import File " + sFilePath ;
-      LOG_INFO( GetLogger(), sLog.c_str()) ;
-   }
  // restituisco il risultato
   return bOk ;
 }
@@ -349,10 +309,10 @@ ExeImportStl( const string& sFilePath, double dScaleFactor)
   // 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
+   // preparo l'importatore
   PtrOwner<IImportStl> pImpStl( MyCreateImportStl()) ;
   bOk = bOk && ! IsNull( pImpStl) ;
-  // eseguo l'importazione
+   // eseguo l'importazione
   bOk = bOk && pImpStl->Import( sFilePath, pGseCtx->m_pGeomDB, nLayerId, dScaleFactor) ;
  // aggiorno stato file corrente
   if ( pGseCtx->m_sFilePath.empty())
@@ -365,106 +325,26 @@ ExeImportStl( const string& sFilePath, double dScaleFactor)
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
-  // scrivo il log
-   if ( ! IsNull( pImpStl)) {
-      string sLog = "Import File " + sFilePath ;
-      LOG_INFO( GetLogger(), sLog.c_str()) ;
-   }
  // restituisco il risultato
   return bOk ;
 }

 //-----------------------------------------------------------------------------
 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()) ;
-   }  
-  // preparo l'importatore
+   // 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) ;
+   // eseguo l'importazione
+   bOk = bOk && pImp3MF->Import( sFilePath, pGseCtx->m_pGeomDB, nLayerId) ;
  // aggiorno stato file corrente
   if ( pGseCtx->m_sFilePath.empty())
      pGseCtx->m_sFilePath = sFilePath ;
@@ -475,30 +355,25 @@ ExeImport3MF( const string& sFilePath, int nFlag)
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
-  // scrivo il log
-   if ( ! IsNull( pImp3MF)) {
-      string sLog = "Import File " + sFilePath ;
-      LOG_INFO( GetLogger(), sLog.c_str()) ;
-   }
  // restituisco il risultato
   return bOk ;
 }

 //-----------------------------------------------------------------------------
 bool
-ExeImport3dm( const string& sFilePath)
+ExeImport3dm( const string& sFilePath, double dScaleFactor)
 {
   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 ;
-  // preparo l'importatore
+  // 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()) ;
+   int nLayerId = pGseCtx->m_pGeomDB->AddGroup( GDB_ID_NULL, nPartId, Frame3d()) ;
+   // preparo l'importatore
   PtrOwner<IImport3dm> pImp3dm( MyCreateImport3dm()) ;
   bOk = bOk && ! IsNull( pImp3dm) ;
-  // eseguo l'importazione
+   // eseguo l'importazione
   const DimensionStyle& DimSt = pGseCtx->m_dsCurr ;
   double dExtLine = DimSt.dExtLineLen ;
   double dArrLen = DimSt.dArrowLen ;
@@ -507,7 +382,7 @@ ExeImport3dm( const string& sFilePath)
   int nDecDig = DimSt.nDecDigit ;
   string  sFont = DimSt.sFont ;
   double dTextHeight = DimSt.dTextHeight ;
-   bOk = bOk && pImp3dm->Import( sFilePath, pGseCtx->m_pGeomDB, GDB_ID_ROOT,
+   bOk = bOk && pImp3dm->Import( sFilePath, pGseCtx->m_pGeomDB, nLayerId, dScaleFactor,
                                 dTextHeight, dExtLine, dArrLen, dTextDist, bLenIsMM, nDecDig, sFont) ;
  // aggiorno stato file corrente
   if ( pGseCtx->m_sFilePath.empty())
@@ -515,15 +390,11 @@ ExeImport3dm( const string& sFilePath)
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
-      string sLua = "EgtImport3dm('" + StringToLuaString( sFilePath) + "')" +
+      string sLua = "EgtImport3dm('" + StringToLuaString( sFilePath) + "'," +
+                                       ToString( dScaleFactor) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
-  // scrivo il log
-   if ( ! IsNull( pImp3dm)) {
-      string sLog = "Import File " + sFilePath ;
-      LOG_INFO( GetLogger(), sLog.c_str()) ;
-   }
  // restituisco il risultato
   return bOk ;
 }
@@ -553,7 +424,7 @@ ExeAdvancedImportIsEnabled( void)

 //-----------------------------------------------------------------------------
 bool
-ExeAdvancedImport( const string& sFilePath, double dToler, int nFlag)
+ExeAdvancedImport( const string& sFilePath, double dToler)
 {
   GseContext* pGseCtx = GetCurrGseContext() ;
   VERIFY_CTX_GEOMDB( pGseCtx, false)
@@ -587,7 +458,7 @@ ExeAdvancedImport( const string& sFilePath, double dToler, int nFlag)
   #endif
   string sCmdLine = "\"" + sExec + "\" \"" + sFilePath + "\" \"" + sFileOut + "\" \"" +
                     ToString( dToler, 3) + "\" \"" +  ToString( ExeGetDebugLevel()) + "\" \"" +
-                     ExeGetKey() + "\" \"" + ExeGetLockId() + "\" \"" + ToString( nFlag) +  "\"" ;
+                     ExeGetKey() + "\" \"" + ExeGetLockId() + "\""   ;
   STARTUPINFO si ;
   PROCESS_INFORMATION pi ;
   ZeroMemory( &si, sizeof( si)) ;
@@ -631,11 +502,6 @@ ExeAdvancedImport( const string& sFilePath, double dToler, int nFlag)
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
-  // scrivo il log
-   {
-      string sLog = "Advanced Import File " + sFilePath ;
-      LOG_INFO( GetLogger(), sLog.c_str()) ;
-   }
  // restituisco il risultato
   return bOk ;
 }
@@ -648,11 +514,11 @@ ExeExportDxf( int nId, const string& sFilePath, int nFlag, int nFilter)
   VERIFY_GEOMDB( pGeomDB, false)
   bool bOk = true ;
  // esporto il file DXF
-  // preparo l'esportatore
+   // preparo l'esportatore
   PtrOwner<IExportDxf> pExpDxf( MyCreateExportDxf()) ;
   bOk = bOk && ! IsNull( pExpDxf) ;
   // eseguo l'esportazione
-   bOk = bOk && pExpDxf->SetOptions( nFilter, nFlag) ;
+   pExpDxf->SetOptions( nFilter, nFlag) ;
   bOk = bOk && pExpDxf->Export( pGeomDB, nId, sFilePath) ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
@@ -674,11 +540,11 @@ ExeExportStl( int nId, const string& sFilePath, int nFilter)
   VERIFY_GEOMDB( pGeomDB, false)
   bool bOk = true ;
  // esporto il file STL
-  // preparo l'esportatore
+   // preparo l'esportatore
   PtrOwner<IExportStl> pExpStl( MyCreateExportStl()) ;
   bOk = bOk && ! IsNull( pExpStl) ;
   // eseguo l'esportazione
-   bOk = bOk && pExpStl->SetOptions( nFilter) ;
+   pExpStl->SetOptions( nFilter) ;
   bOk = bOk && pExpStl->Export( pGeomDB, nId, sFilePath) ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
@@ -699,11 +565,11 @@ ExeExport3MF( int nId, const string& sFilePath, int nFilter)
   VERIFY_GEOMDB( pGeomDB, false)
   bool bOk = true ;
  // esporto il file 3MF
-  // preparo l'esportatore
+   // preparo l'esportatore
   PtrOwner<IExport3MF> pExp3MF( MyCreateExport3MF()) ;
   bOk = bOk && ! IsNull( pExp3MF) ;
-  // eseguo l'esportazione
-   bOk = bOk && pExp3MF->SetOptions( nFilter) ;
+   // eseguo l'esportazione
+   pExp3MF->SetOptions( nFilter) ;
   bOk = bOk && pExp3MF->Export( pGeomDB, nId, sFilePath) ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
@@ -722,22 +588,19 @@ 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 ;
-  // preparo l'esportatore
+  // esporto il file 3dm
+   // preparo l'esportatore
   PtrOwner<IExport3dm> pExp3dm( MyCreateExport3dm()) ;
   bOk = bOk && ! IsNull( pExp3dm) ;
-  // eseguo l'esportazione
-   bOk = bOk && pExp3dm->SetOptions( nFilter) ;
-   bOk = bOk && pExp3dm->Export( pGeomDB, nId, sFilePath) ;
+   // eseguo l'esportazione
+   bOk = bOk  &&  pExp3dm->SetOptions( nFilter) ;
+   bOk = bOk  &&  pExp3dm->Export( pGeomDB, nId, sFilePath) ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtExport3dm(" + ToString( nId) + ",'" +
                                      StringToLuaString( sFilePath) + "')" +
-                    " -- Ok=" + ToString( bOk) ;
+                                      " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco il risultato
@@ -751,12 +614,12 @@ ExeExportSvg( int nId, const string& sFilePath, int nFilter)
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
   bool bOk = true ;
-  // esporto il file SVG
-  // preparo l'esportatore
+   // esporto il file SVG
+   // preparo l'esportatore
   PtrOwner<IExportSvg> pExpSvg( MyCreateExportSvg()) ;
   bOk = bOk && ! IsNull( pExpSvg) ;
-  // eseguo l'esportazione
-   bOk = bOk && pExpSvg->SetOptions( nFilter) ;
+   // eseguo l'esportazione
+   pExpSvg->SetOptions( nFilter) ;
   bOk = bOk && pExpSvg->Export( pGeomDB, nId, sFilePath) ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
@@ -131,7 +131,7 @@ ExeCreateGeoVector( int nParentId, const Vector3d& vtV, const Point3d& ptB, int
   Point3d ptBL = GetPointLocal( pGeomDB, ptB, nRefType, frLoc) ;
  // creo il vettore
   PtrOwner<IGeoVector3d> pGeoVct( CreateGeoVector3d()) ;
-   bOk = bOk && ! IsNull( pGeoVct) ;
+   bOk = bOk && !IsNull( pGeoVct) ;
  // setto il vettore (con il punto base)
   bOk = bOk && pGeoVct->Set( vtVL, ptBL) ;
  // inserisco il vettore nel DB
@@ -480,7 +480,7 @@ MyCreateRadialDimension( int nParentId, int nCrvId, const Point3d& ptDim,
   Point3d ptCenL = pArc->GetCenter() ;
   ptCenL.LocToLoc( frArc, frLoc) ;
   Vector3d vtNL = pArc->GetNormVersor() ;
-   vtNL.LocToLoc( frArc, frLoc) ;
+   vtNL.LocToLoc( frArc, frLoc) ;  
  // porto ptDimL sulla circonferenza cui appartiene l'arco
   Vector3d vtDir = ptDimL - ptCenL ;
   if ( ! vtDir.Normalize())
@@ -543,7 +543,7 @@ MyCreateDiametralDimension( int nParentId, int nCrvId, const Point3d& ptDim,
   Point3d ptCenL = pArc->GetCenter() ;
   ptCenL.LocToLoc( frArc, frLoc) ;
   Vector3d vtNL = pArc->GetNormVersor() ;
-   vtNL.LocToLoc( frArc, frLoc) ;
+   vtNL.LocToLoc( frArc, frLoc) ;  
  // porto ptDimL sulla circonferenza
   Vector3d vtDir = ptDimL - ptCenL ;
   if ( ! vtDir.Normalize())
@@ -583,7 +583,7 @@ ExeCreateDiametralDimension( int nParentId, int nCrvId, const Point3d& ptDim,

 //-------------------------------------------------------------------------------
 static int
-MyCreateAngularDimension( int nParentId, const Point3d& ptV, const Point3d& ptP1, const Point3d& ptP2,
+MyCreateAngularDimension( int nParentId, const Point3d& ptP1, const Point3d& ptP0, const Point3d& ptP2,
                          const Point3d& ptDim, const string& sText, int nRefType)
 {
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
@@ -594,7 +594,7 @@ MyCreateAngularDimension( int nParentId, const Point3d& ptV, const Point3d& ptP1
   if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frLoc))
      return GDB_ID_NULL ;
  // porto in locale i punti e assegno i versori
-   Point3d ptVL = GetPointLocal( pGeomDB, ptV, nRefType, frLoc) ;
+   Point3d ptP0L = GetPointLocal( pGeomDB, ptP0, nRefType, frLoc) ;
   Point3d ptP1L = GetPointLocal( pGeomDB, ptP1, nRefType, frLoc) ;
   Point3d ptP2L = GetPointLocal( pGeomDB, ptP2, nRefType, frLoc) ;
   Point3d ptDimL = GetPointLocal( pGeomDB, ptDim, nRefType, frLoc) ;
@@ -603,7 +603,7 @@ MyCreateAngularDimension( int nParentId, const Point3d& ptV, const Point3d& ptP1
   PtrOwner<IExtDimension> pDim( CreateExtDimension()) ;
   if ( IsNull( pDim)  ||
        ! MySetDimensionStyle( pDim )  ||
-        ! pDim->SetAngular( ptVL, ptP1L, ptP2L, ptDimL, vtNL, sText))
+        ! pDim->SetAngular( ptP1L, ptP0L, ptP2L, ptDimL, vtNL, sText))
      return GDB_ID_NULL ;
  // inserisco la quota nel DB
   return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pDim)) ;
@@ -611,16 +611,16 @@ MyCreateAngularDimension( int nParentId, const Point3d& ptV, const Point3d& ptP1

 //-------------------------------------------------------------------------------
 int
-ExeCreateAngularDimension( int nParentId, const Point3d& ptV, const Point3d& ptP1, const Point3d& ptP2,
+ExeCreateAngularDimension( int nParentId, const Point3d& ptP1, const Point3d& ptP0, const Point3d& ptP2,
                           const Point3d& ptDim, const string& sText, int nRefType)
 {
  // eseguo
-   int nId = MyCreateAngularDimension( nParentId, ptV, ptP1, ptP2, ptDim, sText, nRefType) ;
+   int nId = MyCreateAngularDimension( nParentId, ptP1, ptP0, ptP2, ptDim, sText, nRefType) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtAngularDimension(" + IdToString( nParentId) + ",{" +
-                                             ToString( ptV) + "},{" +
+                                             ToString( ptP0) + "},{" +
                                             ToString( ptP1) + "},{" +
                                             ToString( ptP2) + "},{" +
                                             ToString( ptDim) + "},'" +
@@ -633,62 +633,6 @@ ExeCreateAngularDimension( int nParentId, const Point3d& ptV, const Point3d& ptP
   return nId ;
 }

-//-------------------------------------------------------------------------------
-static int
-MyCreateAngularDimensionEx( int nParentId, const Point3d& ptV1, const Point3d& ptP1,
-                            const Point3d& ptV2,const Point3d& ptP2, const Point3d& ptDim,
-                            const string& sText, int nRefType)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
-      nParentId = AdjustId( nParentId) ;
-  // recupero il riferimento locale
-   Frame3d frLoc ;
-   if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frLoc))
-      return GDB_ID_NULL ;
-  // porto in locale i punti e assegno i versori
-   Point3d ptV1L = GetPointLocal( pGeomDB, ptV1, nRefType, frLoc) ;
-   Point3d ptP1L = GetPointLocal( pGeomDB, ptP1, nRefType, frLoc) ;
-   Point3d ptV2L = GetPointLocal( pGeomDB, ptV2, nRefType, frLoc) ;
-   Point3d ptP2L = GetPointLocal( pGeomDB, ptP2, nRefType, frLoc) ;
-   Point3d ptDimL = GetPointLocal( pGeomDB, ptDim, nRefType, frLoc) ;
-   Vector3d vtNL = GetVectorLocal( pGeomDB, Z_AX, nRefType, frLoc) ;
-  // creo la quota
-   PtrOwner<IExtDimension> pDim( CreateExtDimension()) ;
-   if ( IsNull( pDim)  ||
-        ! MySetDimensionStyle( pDim )  ||
-        ! pDim->SetAngularEx( ptV1L, ptP1L, ptV2L, ptP2L, ptDimL, vtNL, sText))
-      return GDB_ID_NULL ;
-  // inserisco la quota nel DB
-   return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pDim)) ;
-}
-
-//-------------------------------------------------------------------------------
-int
-ExeCreateAngularDimensionEx( int nParentId, const Point3d& ptV1, const Point3d& ptP1,
-                             const Point3d& ptV2, const Point3d& ptP2, const Point3d& ptDim,
-                             const string& sText, int nRefType)
-{
-  // eseguo
-   int nId = MyCreateAngularDimensionEx( nParentId, ptV1, ptP1, ptV2, ptP2, ptDim, sText, nRefType) ;
-   ExeSetModified() ;
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtAngularDimensionEx(" + IdToString( nParentId) + ",{" +
-                                               ToString( ptV1) + "},{" +
-                                               ToString( ptP1) + "},{" +
-                                               ToString( ptV2) + "},{" +
-                                               ToString( ptP2) + "},{" +
-                                               ToString( ptDim) + "},'" +
-                                               StringToLuaString( sText) + "'," +
-                                               RefTypeToString( nRefType) + ")" +
-                    " -- Id=" + ToString( nId) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-  // restituisco l'identificativo del oggetto
-   return nId ;
-}
-
 //-------------------------------------------------------------------------------
 static int
 MyCreateAngularDimensionFromLines( int nParentId, INTVECTOR vLineIds, const Point3d& ptDim,
@@ -701,24 +645,27 @@ MyCreateAngularDimensionFromLines( int nParentId, INTVECTOR vLineIds, const Poin
   Frame3d frLoc ;
   if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frLoc))
      return GDB_ID_NULL ;
-  // recupero le linee
+
+  //recupero le linee
   ICurveLine* pCrv1 = GetCurveLine( pGeomDB->GetGeoObj( vLineIds[0])) ;
   ICurveLine* pCrv2 = GetCurveLine( pGeomDB->GetGeoObj( vLineIds[1])) ;
   if ( pCrv1 == nullptr  ||  pCrv2 == nullptr)
      return GDB_ID_NULL ;
   PtrOwner<ICurveLine> pL1( pCrv1->Clone()) ;
   PtrOwner<ICurveLine> pL2( pCrv2->Clone()) ;
-   if ( IsNull( pL1 )  ||  ! pL1->IsValid()  ||  IsNull( pL2)  ||  ! pL2->IsValid())
+   if ( IsNull( pL1 )  ||  ! pL1->IsValid()  || IsNull( pL2)  ||  ! pL2->IsValid())
      return GDB_ID_NULL ;
-  // porto tutto nel frLoc
+
+  //porto tutto nel frLoc
   Frame3d frL1, frL2 ;
   if ( ! pGeomDB->GetGlobFrame( vLineIds[0], frL1)  ||  ! pGeomDB->GetGlobFrame( vLineIds[1], frL2))
      return GDB_ID_NULL ;
   pL1->LocToLoc( frL1, frLoc) ;
   pL2->LocToLoc( frL2, frLoc) ;
-  // recupero il punto lo porto nel riferimento locale
   Point3d ptDimL = GetPointLocal( pGeomDB, ptDim, nRefType, frLoc) ;
-  // recupero i punti e le direzioni
+   Vector3d vtNL = GetVectorLocal( pGeomDB, Z_AX, nRefType, frLoc) ;
+
+   //recupero i punti e le direzioni
   Point3d ptP1L, ptP2L, ptP3L, ptP4L ;
   Vector3d vtL1, vtL2 ;
   pL1->GetStartPoint( ptP1L) ;
@@ -727,12 +674,15 @@ MyCreateAngularDimensionFromLines( int nParentId, INTVECTOR vLineIds, const Poin
   pL2->GetEndPoint( ptP4L) ;
   pL1->GetStartDir( vtL1) ;
   pL2->GetStartDir( vtL2) ;
+
  // controllo se le rette sono coincidenti o parallele
   if ( AreSameOrOppositeVectorApprox( vtL1, vtL2))
      return GDB_ID_NULL ;
+
  // verifico se le rette si intersecano già
-   Point3d ptCenL ;
+   Point3d ptP0L ;
   IntersCurveCurve pInters( *pL1, *pL2) ;
+   IntCrvCrvInfo Info ;
   int nNumeroInters = pInters.GetIntersCount() ;
  // se non ho intersezioni estendo
   if ( nNumeroInters == 0) {
@@ -741,54 +691,54 @@ MyCreateAngularDimensionFromLines( int nParentId, INTVECTOR vLineIds, const Poin
      pL2->ExtendStartByLen( dLen) ;
      pL1->ExtendEndByLen( dLen) ;
      pL2->ExtendEndByLen( dLen) ;
-     // faccio intersezione
+
+     //faccio intersezione
      IntersCurveCurve pIntersExt( *pL1, *pL2) ;
      nNumeroInters = pIntersExt.GetIntersCount() ;
+
     // le linee estese non si intersecano, quindi vuol dire che sono quasi parallele e lontanissime
      if ( nNumeroInters == 0 )
         return GDB_ID_NULL ;
      else {
-         IntCrvCrvInfo Info ;
         pIntersExt.GetIntCrvCrvInfo( 0, Info) ;
        // controllo che non siano coincidenti
         if ( Info.bOverlap)
            return false ;
         else
-            ptCenL = Info.IciA->ptI ;
+            ptP0L = Info.IciA->ptI ;
      }
     // seleziono i punti necessari
-     // se ptDimL è più vicino a ptCenL rispetto agli estremi esterni delle linee, allora tengo gli estremi interni
-      double dP1Cen = ( ptP1L - ptCenL).Len() ;
-      double dP2Cen = ( ptP2L - ptCenL).Len() ;
-      double dDimCen = ( ptDimL - ptCenL).Len() ;
-      if ( ( dDimCen < dP1Cen  ||  dDimCen < dP2Cen))
-        // se uno dei due punti è più vicino a ptCenL rispetto a ptDimL, allora tengo il punto più vicino a ptDimL
+     // se ptDimL è più vicino a ptP0L rispetto agli estremi esterni delle linee, allora tengo gli estremi interni
+      double dP1P0 = ( ptP1L - ptP0L ).Len() ;
+      double dP2P0 = ( ptP2L - ptP0L ).Len() ;
+      double dDimP0 = ( ptDimL - ptP0L ).Len() ;
+      if ( ( dDimP0 < dP1P0 || dDimP0 < dP2P0))
+        // se uno dei due punti è più vicino a ptP0L rispetto a ptDimL, allora tengo il punto più vicino a ptDimL
         ptP1L = ( ( ptDimL - ptP1L ).Len() < ( ptDimL - ptP2L ).Len() ? ptP1L : ptP2L) ;
      else
-         ptP1L = ( dP1Cen < dP2Cen ? ptP2L : ptP1L ) ;
+         ptP1L = ( dP1P0 < dP2P0 ? ptP2L : ptP1L ) ;
     // rifaccio anche per l'altro lato
-      double dP3Cen = ( ptP3L - ptCenL).Len() ;
-      double dP4Cen = ( ptP4L - ptCenL).Len() ;
-      if ( dDimCen < dP3Cen  ||  dDimCen < dP4Cen)
-         ptP3L = ( ( ptDimL - ptP3L).Len() < ( ptDimL - ptP4L).Len() ? ptP3L : ptP4L) ;
+      double dP3P0 = ( ptP3L - ptP0L).Len() ;
+      double dP4P0 = ( ptP4L - ptP0L).Len() ;
+      if ( dDimP0 < dP3P0 || dDimP0 < dP4P0 )
+         ptP3L = ( ( ptDimL - ptP3L).Len() < ( ptDimL - ptP4L).Len() ? ptP3L : ptP4L ) ;
      else
-         ptP3L = ( dP3Cen < dP4Cen ? ptP4L : ptP3L) ;
+         ptP3L = ( dP3P0 < dP4P0 ? ptP4L : ptP3L) ;
   }
  // se ho già intesezioni devo capire in quale quadrante si trova ptDim
   else {
     // recupero l'intersezione
-      IntCrvCrvInfo Info ;
      pInters.GetIntCrvCrvInfo( 0, Info) ;
     // controllo che non siano coincidenti
      if ( Info.bOverlap)
         return false ;
-     // se non coincidono restituisco l'intersezione
      else
-         ptCenL = Info.IciA->ptI ;
-     // se le due linee hanno un estremo in comune, estendo le linee da quel lato
-      if ( ( AreSamePointApprox( ptCenL, ptP1L)  ||  AreSamePointApprox( ptCenL, ptP2L))  &&  
-         ( AreSamePointApprox( ptCenL, ptP3L)  ||  AreSamePointApprox( ptCenL, ptP4L))) {
-         if ( AreSamePointApprox( ptCenL, ptP1L)) {
+         ptP0L = Info.IciA->ptI ; // se non coincidono restituisco l'intersezione
+
+     // se le due linee hanno un estremo in comune, estendo le linee quel lato
+      if ( ( AreSamePointApprox( ptP0L, ptP1L)  ||  AreSamePointApprox( ptP0L, ptP2L))  &&  
+         ( AreSamePointApprox( ptP0L, ptP3L)  ||  AreSamePointApprox( ptP0L, ptP4L))) {
+         if ( AreSamePointApprox( ptP0L, ptP1L)) {
            pL1->ExtendStartByLen(Dist( ptP1L, ptP2L) / 2) ;
            pL1->GetStartPoint( ptP1L) ;
         }
@@ -796,8 +746,8 @@ MyCreateAngularDimensionFromLines( int nParentId, INTVECTOR vLineIds, const Poin
            pL1->ExtendEndByLen(Dist( ptP1L, ptP2L) / 2) ;
            pL1->GetEndPoint( ptP2L) ;
         }
-         if ( AreSamePointApprox( ptCenL, ptP3L)) {
-            pL2->ExtendStartByLen( Dist( ptP3L, ptP4L) / 2);
+         if ( AreSamePointApprox( ptP0L, ptP3L) ) {
+            pL2->ExtendStartByLen(Dist( ptP3L, ptP4L) / 2);
            pL2->GetStartPoint( ptP3L) ;
         }
         else {
@@ -805,42 +755,36 @@ MyCreateAngularDimensionFromLines( int nParentId, INTVECTOR vLineIds, const Poin
            pL2->GetEndPoint( ptP4L) ;
         }
      }
+      
     // seleziono i punti necessari
     // proietto pdDim su vtLine1 e su vtLine2
      Point3d ptDim1, ptDim2 ;
      DistPointCurve distPL1( ptDimL, *pL1, true) ;
      DistPointCurve distPL2( ptDimL, *pL2, true) ;
      int nFlag1, nFlag2 ;
-      if ( ! distPL1.GetMinDistPoint( 0, ptDim1, nFlag1)  ||  ! distPL2.GetMinDistPoint( 0, ptDim2, nFlag2) )
+      if ( ! distPL1.GetMinDistPoint( 0, ptDim1, nFlag1) || ! distPL2.GetMinDistPoint( 0, ptDim2, nFlag2) )
         return false ;
-      if ( abs(( ptDim1 - ptP1L).Len() + ( ptCenL - ptDim1).Len() - ( ptCenL - ptP1L).Len()) < EPS_SMALL  ||
-           abs(( ptDim1 - ptP1L).Len() + ( ptCenL - ptP1L ).Len() - ( ptDim1 - ptCenL).Len()) < EPS_SMALL)
-           // ptDim è dal lato di ptP1L, quindi tengo ptP1L
+      if ( abs(( ptDim1 - ptP1L).Len() + ( ptP0L - ptDim1).Len() - ( ptP0L - ptP1L).Len()) < EPS_SMALL  ||
+           abs(( ptDim1 - ptP1L).Len() + ( ptP0L - ptP1L ).Len() - ( ptDim1 - ptP0L).Len()) < EPS_SMALL)
+        // ptDim è dal lato di ptP1L, quindi tengo ptP1L
         ;
      else
        // ptDim è dal lato di ptP2L
         ptP1L = ptP2L ;
-      if ( abs(( ptDim2 - ptP3L).Len() + ( ptCenL - ptDim2).Len() - ( ptCenL - ptP3L).Len()) < EPS_SMALL  ||
-           abs(( ptDim2 - ptP3L).Len() + ( ptCenL - ptP3L).Len() - ( ptDim2 - ptCenL).Len()) < EPS_SMALL)
-        // ptDim è dal lato di ptP1L
-        ;
+      if ( abs(( ptDim2 - ptP3L).Len() + ( ptP0L - ptDim2).Len() - ( ptP0L - ptP3L).Len()) < EPS_SMALL  ||
+           abs(( ptDim2 - ptP3L).Len() + ( ptP0L - ptP3L).Len() - ( ptDim2 - ptP0L).Len()) < EPS_SMALL)
+        // ptDim è dal lato di ptP1L, quindi tengo ptP3L
+         ;
      else
        // ptDim è dal lato di ptP2L
         ptP3L = ptP4L ;
   }
-  // recupero la normale al piano dell'angolo da quotare
-   Frame3d frArc;
-   frArc.Set(ptCenL, ptP1L, ptP3L);
-   Vector3d vtNL = frArc.VersZ() ;
-   if ( vtNL * Z_AX < - EPS_SMALL) {
-      frArc.Set(ptCenL, ptP3L, ptP1L);
-      vtNL = frArc.VersZ() ;
-   }
+
  // creo la quota
   PtrOwner<IExtDimension> pDim( CreateExtDimension()) ;
   if ( IsNull( pDim )  ||
        ! MySetDimensionStyle( pDim )  ||
-        ! pDim->SetAngular( ptP1L, ptCenL, ptP3L, ptDimL, vtNL, sText))
+        ! pDim->SetAngular( ptP1L, ptP0L, ptP3L, ptDimL, vtNL, sText))
      return GDB_ID_NULL ;
  // inserisco la quota nel DB
   return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pDim)) ;
@@ -881,36 +825,50 @@ MyCreateAngularDimensionFromArc( int nParentId, int nCrvId, const Point3d& ptDim
   Frame3d frLoc ;
   if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frLoc))
      return GDB_ID_NULL ;
+
  // recupero l'arco e il suo frame
-   ICurveArc* pArc = GetCurveArc( pGeomDB->GetGeoObj( nCrvId)) ;
-   if ( pArc == nullptr)
+   ICurveArc* pCurve = GetCurveArc( pGeomDB->GetGeoObj( nCrvId)) ;
+   if ( pCurve == nullptr)
      return GDB_ID_NULL ;
-   Frame3d frArc ;
+   Frame3d frArc;
   if ( ! pGeomDB->GetGlobFrame( nCrvId, frArc))
      return GDB_ID_NULL ;
-  // recupero i punti e la normale e li porto nel frame locale
-   Point3d ptDimL = GetPointLocal( pGeomDB, ptDim, nRefType, frLoc) ;
-   Vector3d vtNL = pArc->GetNormVersor() ;
-   vtNL.LocToLoc( frArc, frLoc) ;
-   Point3d ptCenL, ptP1L, ptP2L ;
-   pArc->GetStartPoint( ptP1L) ;
-   ptP1L.LocToLoc( frArc, frLoc) ;
-   pArc->GetEndPoint( ptP2L) ;
-   ptP2L.LocToLoc( frArc, frLoc) ;
-   pArc->GetCenterPoint( ptCenL) ;
-   ptCenL.LocToLoc( frArc, frLoc) ;
-  // porto ptDimL nell'area di influenza dell'arco
-   Point3d ptMid ;
-   pArc->GetMidPoint( ptMid) ;
-   Vector3d vtDir = ( ptMid - ptCenL) ;
-   if ( ! vtDir.Normalize())
+
+   PtrOwner<ICurveArc> pCrv( pCurve->Clone()) ;
+   if ( IsNull( pCrv )  ||  ! pCrv->IsValid())
      return GDB_ID_NULL ;
-   ptDimL = ptCenL + Dist( ptDimL, ptCenL) * vtDir ;
+
+  // porto tutto nel frLoc
+   pCrv->LocToLoc( frArc, frLoc ) ;
+   Point3d ptDimL = GetPointLocal( pGeomDB, ptDim, nRefType, frLoc) ;
+   Vector3d vtNL = GetVectorLocal( pGeomDB, Z_AX, nRefType, frLoc) ;
+
+  //recupero i punti e i versori
+   Point3d ptP0L, ptP1L, ptP2L ;
+   pCrv->GetStartPoint( ptP1L) ;
+   pCrv->GetEndPoint( ptP2L) ;
+   pCrv->GetCenterPoint( ptP0L) ;
+
+  // porto ptDimL nell'area di influenza dell'arco
+   Point3d ptDimNew ;
+   double dDist = ( ptDimL - ptP0L).Len() ;
+   Point3d ptMid ;
+   pCrv->GetMidPoint( ptMid) ;
+   Vector3d vtDir = ( ptMid - ptP0L) ;
+   vtDir.Normalize() ;
+   ptDimNew = ptP0L + dDist * vtDir ;
+  // proietto il punto sul piano XY della griglia
+   Frame3d  frGrid = pGeomDB->GetGridFrame() ;
+   if ( ! frGrid.IsValid())
+       return GDB_ID_NULL ;
+   Point3d ptOrig = frGrid.Orig() ;
+   ptDimNew -= ( ptDimNew - ptOrig) * vtNL * vtNL;
+
  // creo la quota
   PtrOwner<IExtDimension> pDim( CreateExtDimension()) ;
   if ( IsNull( pDim )  ||
        ! MySetDimensionStyle( pDim)  ||
-        ! pDim->SetAngular( ptP1L, ptCenL, ptP2L, ptDimL, vtNL, sText))
+        ! pDim->SetAngular( ptP1L, ptP0L, ptP2L, ptDimNew, vtNL, sText))
      return GDB_ID_NULL ;
  // inserisco la quota nel DB
   return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pDim)) ;
@@ -936,4 +894,93 @@ ExeCreateAngularDimensionFromArc( int nParentId, int nCrvId, const Point3d& ptDi
   }
  // restituisco l'identificativo del oggetto
   return nId ;
-}
+}
+
+//-------------------------------------------------------------------------------
+static int
+MyCreateAngularDimensionFromCircle( int nParentId, int nCrvId, const Point3d& ptP1, const Point3d& ptP2, const Point3d& ptDim,
+                                    const string& sText, int nRefType)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
+   nParentId = AdjustId( nParentId ) ;
+  // recupero il riferimento locale
+   Frame3d frLoc ;
+   if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frLoc))
+      return GDB_ID_NULL ;
+
+  // recupero il cerchio e il suo frame
+   ICurveArc* pCurve = GetCurveArc( pGeomDB->GetGeoObj( nCrvId)) ;
+   if ( pCurve == nullptr)
+      return GDB_ID_NULL ;
+   Frame3d frCrv;
+   if ( ! pGeomDB->GetGlobFrame( nCrvId, frCrv))
+      return GDB_ID_NULL ;
+
+   PtrOwner<ICurveArc> pCrv( pCurve->Clone()) ;
+   if ( IsNull( pCrv )  ||  ! pCrv->IsValid())
+      return GDB_ID_NULL ;
+
+  // porto tutto nel frLoc
+   pCrv->LocToLoc( frCrv, frLoc ) ;
+   Point3d ptP1L = GetPointLocal( pGeomDB, ptP1, nRefType, frLoc) ;
+   Point3d ptP2L = GetPointLocal( pGeomDB, ptP2, nRefType, frLoc) ;
+   Point3d ptDimL = GetPointLocal( pGeomDB, ptDim, nRefType, frLoc) ;
+   Vector3d vtNL = GetVectorLocal( pGeomDB, Z_AX, nRefType, frLoc) ;
+
+  // recupero il centro
+   Point3d ptP0L ;
+   pCrv->GetCenterPoint( ptP0L) ;
+
+  // verifico che i punti P1 e P2 siano sul cerchio, sennò prendo i più vicini
+   if ( ! pCrv->IsPointOn(ptP1L)) {
+      DistPointCurve distPC( ptP1L, *pCrv) ;
+      int nFlag ;
+      distPC.GetMinDistPoint(0,ptP1L,nFlag);
+   }
+   if ( ! pCrv->IsPointOn(ptP2L)) {
+      DistPointCurve distPC(ptP2L, *pCrv) ;
+      int nFlag ;
+      distPC.GetMinDistPoint(0, ptP2L, nFlag);
+   }
+
+  // proietto il punto sul piano XY della griglia
+   Frame3d  frGrid = pGeomDB->GetGridFrame() ;
+   if ( ! frGrid.IsValid())
+      return GDB_ID_NULL ;
+   Point3d ptOrig = frGrid.Orig() ;
+   ptDimL -= ( ptDimL - ptOrig) * vtNL * vtNL;
+
+  // creo la quota
+   PtrOwner<IExtDimension> pDim( CreateExtDimension()) ;
+   if ( IsNull( pDim)  ||
+        ! MySetDimensionStyle( pDim)  ||
+        ! pDim->SetAngular( ptP1L, ptP0L, ptP2L, ptDimL, vtNL, sText))
+      return GDB_ID_NULL ;
+  // inserisco la quota nel DB
+   return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pDim)) ;
+}
+
+//-------------------------------------------------------------------------------
+int
+ExeCreateAngularDimensionFromCircle( int nParentId, int nCrvId, const Point3d& ptP1, const Point3d& ptP2, const Point3d& ptDim,
+                                     const string& sText, int nRefType)
+{
+  // eseguo
+   int nId = MyCreateAngularDimensionFromCircle( nParentId, nCrvId, ptP1, ptP2, ptDim, sText, nRefType) ;
+   ExeSetModified() ;
+  // se richiesto, salvo il comando Lua equivalente
+   if ( IsCmdLog()) {
+      string sLua = "EgtAngularDimensionFromCircle(" + IdToString( nParentId) + "," +
+                                                       IdToString( nCrvId) + ",{" +
+                                                       ToString( ptP1) + "},'" +
+                                                       ToString( ptP2) + "},'" +
+                                                       ToString( ptDim) + "},'" +
+                                                       StringToLuaString( sText) + "'," +
+                                                       RefTypeToString( nRefType) + ")" +
+                    " -- Id=" + ToString( nId) ;
+      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
+   }
+  // restituisco l'identificativo del oggetto
+   return nId ;
+}
@@ -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 ;
@@ -363,13 +362,16 @@ CreateLineTgTwoCurves( IGeomDB* pGeomDB, int nParentId,
   if ( pCrv2 == nullptr)
      return nullptr ;
  // porto la seconda curva nel riferimento della prima
-   CurveLocal Crv2Loc( pGeomDB, nIdF, frCrv1) ;
+   PtrOwner<ICurve> pCrv2Loc( pCrv2->Clone()) ;
+   if ( IsNull( pCrv2Loc))
+      return nullptr ;
+   pCrv2Loc->LocToLoc( frCrv2, frCrv1) ;
  // porto il punto vicino al finale nel riferimento della prima curva
   Point3d ptN2loc( ptFin) ;
   ptN2loc.LocToLoc( frDest, frCrv1) ;
  // calcolo la retta tangente alle due curve
   PtrOwner<ICurveLine> pCrvLine ;
-   pCrvLine.Set( GetLineTgTwoCurves( *pCrv1, ptN1loc, *Crv2Loc, ptN2loc)) ;
+   pCrvLine.Set( GetLineTgTwoCurves( *pCrv1, ptN1loc, *pCrv2Loc, ptN2loc)) ;
   if ( IsNull( pCrvLine))
      return nullptr ;
   // porto la linea nel riferimento del gruppo destinazione
@@ -1089,45 +1091,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,
@@ -1665,55 +1628,6 @@ ExeCreateCurveBezierFromArc( int nParentId, int nArcId, bool bErase)
   return nId ;
 }

-//-------------------------------------------------------------------------------
-static int
-MyCreateCurveBezierFromCurve( int nParentId, int nCrvId, bool bRational)
-{
-   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, bRational)) ;
-  // 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
-ExeCreateCurveBezierFromCurve( int nParentId, int nCrvId, bool bRational)
-{
-  // eseguo
-   int nId = MyCreateCurveBezierFromCurve( nParentId, nCrvId, bRational) ;
-   ExeSetModified() ;
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtCurveBezierFromCurve(" + IdToString( nParentId) + "," +
-                                                 IdToString( nCrvId) + ")"
-                    " -- Id=" + ToString( nId) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-  // restituisco l'identificativo della nuova entità
-   return nId ;
-}
-
 //-------------------------------------------------------------------------------
 int
 MyCreateCurveCompo( int nParentId, const INTVECTOR& vIds, bool bErase)
@@ -2062,12 +1976,12 @@ ExeCreateCurveCompoByInterpolation( int nParentId, const PolyLine& PL, int nType
      nMethod = CurveByInterp::BESSEL ;
      nCrvType = CurveByInterp::CUBIC_BEZIERS ;
   }
-   else if ( nType == ITT_CUBICS_LONG)
-      nCrvType = CurveByInterp::CUBIC_BEZIERS_LONG ;
  // oggetto interpolatore
   CurveByInterp crvByInterp ;
   Point3d ptP ;
-   for ( bool bFound = PL.GetFirstPoint( ptP) ; bFound ; bFound = PL.GetNextPoint( ptP))
+   for ( bool bFound = PL.GetFirstPoint( ptP) ;
+         bFound ;
+         bFound = PL.GetNextPoint( ptP))
      crvByInterp.AddPoint( ptP) ;
   PtrOwner<ICurve> pCrvCompo( crvByInterp.GetCurve( nMethod, nCrvType)) ;
   bOk = bOk && ! IsNull( pCrvCompo) ;
@@ -1,4 +1,4 @@
-//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
 //  EgalTech 2016-2016
 //----------------------------------------------------------------------------
 // File : EXE_GdbCreateVol.cpp       Data : 27.10.16       Versione : 1.6v7
@@ -45,16 +45,7 @@ ExeCreateVolZmap( int nParentId, const Point3d& ptIni, double dDimX, double dDim
  // creo lo Zmap nel suo riferimento intrinseco
   PtrOwner<IVolZmap> pVZM( CreateVolZmap()) ;
   bOk = bOk && ! IsNull( pVZM) ;
-   if ( bOk) {
-      int nError = 0 ;
-      bOk = pVZM->Create( ORIG, dDimX, dDimY, dDimZ, dPrec, bTriDex, &nError) ;
-      if ( ! bOk) {
-         if ( nError == 1)
-            ExeOutLog( "EgtVolZmapBox too big for a 32-bit system") ;
-         else
-            ExeOutLog( "EgtVolZmapBox error number : " + ToString( nError)) ;
-      }
-   }
+   bOk = bOk && pVZM->Create( ORIG, dDimX, dDimY, dDimZ, dPrec, bTriDex) ;
  // lo porto nel riferimento locale
   bOk = bOk && pVZM->ToGlob( frBox) ;
  // inserisco lo Zmap nel DB
@@ -73,59 +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à
-   return nNewId ;
-}
-
-//-------------------------------------------------------------------------------
-int ExeCreateVolZmapEmpty( int nParentId, const Point3d& ptIni, double dDimX, double dDimY, double dDimZ,
-                           double dPrec, bool bTriDex, 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
-   Point3d ptIniL = GetPointLocal( pGeomDB, ptIni, nRefType, frLoc) ;
-   Point3d ptOnXL = GetPointLocal( pGeomDB, ptIni + X_AX, nRefType, frLoc) ;
-   Point3d ptOnYL = GetPointLocal( pGeomDB, ptIni + Y_AX, nRefType, frLoc) ;
-  // ne ricavo un riferimento intrinseco
-   Frame3d frBox ;
-   bOk = bOk && frBox.Set( ptIniL, ptOnXL, ptOnYL) ;
-  // creo lo Zmap nel suo riferimento intrinseco
-   PtrOwner<IVolZmap> pVZM( CreateVolZmap()) ;
-   bOk = bOk && ! IsNull( pVZM) ;
-   if ( bOk) {
-      int nError = 0 ;
-      bOk = pVZM->CreateEmpty( ORIG, dDimX, dDimY, dDimZ, dPrec, bTriDex, &nError) ;
-      if ( ! bOk) {
-         if ( nError == 1)
-            ExeOutLog( "EgtVolZmapEmpty too big for a 32-bit system") ;
-         else
-            ExeOutLog( "EgtVolZmapEmpty error number : " + ToString( nError)) ;
-      }
-   }
-  // lo porto nel riferimento locale
-   bOk = bOk && pVZM->ToGlob( frBox) ;
-  // 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 = "EgtVolZmapEmpty(" + IdToString( nParentId) + ",{" +
-                                       ToString( ptIni) + "}," +
-                                       ToString( dDimX) + "," +
-                                       ToString( dDimY) + "," +
-                                       ToString( dDimZ) + "," +
-                                       ToString( dPrec) + "," +
-                                       ( bTriDex ? "true" : "false") + "," +
-                                       RefTypeToString( nRefType) + ")" +
-                    " -- Id=" + ToString( nNewId) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-  // restituisco l'identificativo della nuova entità
+  // restituisco l'identificativo della nuova entità
   return nNewId ;
 }

@@ -148,16 +87,7 @@ ExeCreateVolZmapByRegionExtrusion( int nParentId, int nSfrId, double dDimZ, doub
  // creo lo Zmap nel suo riferimento intrinseco
   PtrOwner<IVolZmap> pVZM( CreateVolZmap()) ;
   bOk = bOk && ! IsNull( pVZM) ;
-   if ( bOk) {
-      int nError = 0 ;
-      bOk = pVZM->CreateFromFlatRegion( *pSfr, dDimZ, dPrec, bTriDex, &nError) ;
-      if ( ! bOk) {
-         if ( nError == 1)
-            ExeOutLog( "EgtVolZmapByRegionExtrusion too big for a 32-bit system") ;
-         else
-            ExeOutLog( "EgtVolZmapByRegionExtrusion error number : " + ToString( nError)) ;
-      }
-   }
+   bOk = bOk && pVZM->CreateFromFlatRegion( *pSfr, dDimZ, dPrec, bTriDex) ;
  // lo porto nel riferimento di destinazione
   bOk = bOk && pVZM->LocToLoc( frSfr, frDest) ;
  // inserisco lo Zmap nel DB
@@ -173,13 +103,13 @@ 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 ;
 }

 //-------------------------------------------------------------------------------
 int
-ExeCreateVolZmapFromSurfTm( int nParentId, int nStmId, double dPrec, bool bTriDex, double dExtraBox)
+ExeCreateVolZmapFromSurfTm( int nParentId, int nStmId, double dPrec, bool bTriDex)
 {
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
@@ -196,16 +126,7 @@ ExeCreateVolZmapFromSurfTm( int nParentId, int nStmId, double dPrec, bool bTriDe
  // creo lo Zmap nel suo riferimento intrinseco
   PtrOwner<IVolZmap> pVZM( CreateVolZmap()) ;
   bOk = bOk && ! IsNull( pVZM) ;
-   if ( bOk) {
-      int nError = 0 ;
-      bOk = pVZM->CreateFromTriMesh( *pStm, dPrec, bTriDex, dExtraBox, &nError) ;
-      if ( ! bOk) {
-         if ( nError == 1)
-            ExeOutLog( "EgtVolZmapFromSurfTm too big for a 32-bit system") ;
-         else
-            ExeOutLog( "EgtVolZmapFromSurfTm error number : " + ToString( nError)) ;
-      }
-   }
+   bOk = bOk && pVZM->CreateFromTriMesh( *pStm, dPrec, bTriDex) ;
  // lo porto nel riferimento di destinazione
   bOk = bOk && pVZM->LocToLoc( frStm, frDest) ;
  // inserisco lo Zmap nel DB
@@ -213,14 +134,13 @@ ExeCreateVolZmapFromSurfTm( int nParentId, int nStmId, double dPrec, bool bTriDe
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
-      string sLua = "EgtVolZmapFromSurfTm(" + IdToString( nParentId) + "," +
-                                              ToString( nStmId) + "," +
-                                              ToString( dPrec) + "," +
-                                              ( bTriDex ? "true" : "false") + "," +
-                                              ToString( dExtraBox) + ")" +
+      string sLua = "EgtVolZmapFromTriMesh(" + IdToString( nParentId) + "," +
+                                               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 ;
 }
@@ -16,24 +16,17 @@
 #include "EXE.h"
 #include "EXE_Const.h"
 #include "EXE_Macro.h"
-#include "AuxTools.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"
 #include "/EgtDev/Include/EGkCurveComposite.h"
-#include "/EgtDev/Include/EGkCurveAux.h"
 #include "/EgtDev/Include/EGkDistPointCurve.h"
 #include "/EgtDev/Include/EGkIntersCurves.h"
 #include "/EgtDev/Include/EGkSurfFlatRegion.h"

-using namespace std ;
-
 //----------------------------------------------------------------------------
 bool
 ExeCurveDomain( int nId, double* pdStart, double* pdEnd)
@@ -64,21 +57,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)
@@ -182,7 +160,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)) ;
 }

@@ -227,8 +205,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 ;
@@ -314,7 +290,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)) ;
 }

@@ -390,7 +366,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) ;
@@ -638,9 +614,6 @@ ExeCurveCompoRadius( int nId, int nSimpCrv, double& dRad)
   case CRV_BEZIER :
      dRad = -2 ;
      break ;
-   default :
-      dRad = -3 ;
-      break ;
   }
   return true ;
 }
@@ -670,9 +643,6 @@ ExeCurveCompoAngCenter( int nId, int nSimpCrv, double& dAngCen)
   case CRV_BEZIER :
      dAngCen = 0 ;
      break ;
-   default :
-      dAngCen = 0 ;
-      break ;
   }
   return true ;
 }
@@ -702,225 +672,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 == nullptr  ||  ( 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)) ;
-   if ( pCrv == nullptr)
-      return false ;
-   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 ;
-
-  // creo una copia e la porto nel frame della destinazione
-   const ICurve* pSubCrv = pCompo->GetCurve( nSubCrvToCopy) ;
-   if ( pSubCrv == nullptr)
-      return GDB_ID_NULL ;
-   ICurve* pSubCrvCopy = pSubCrv->Clone() ;
-   if ( pSubCrvCopy == nullptr)
-      return GDB_ID_NULL ;
-   pSubCrvCopy->LocToLoc( frCrv, frDest) ;
-   int nSubCrvId = pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, pSubCrvCopy) ;
-   ExeSetModified() ;
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtCopyCompoSubCurve(" + IdToString( nCrvId) + "," +
-                                              ToString( nSubCrvToCopy) + "," +
-                                              IdToString( nDestGrpId) + ")" +
-                    " -- Id=" + ToString( nSubCrvId) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-  // restituisco l'identificativo della nuova entità
-   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) ;
-   if ( pSubCrvCopy == nullptr)
-      return GDB_ID_NULL ;
-   pSubCrvCopy->LocToLoc( frCrv, frDest) ;
-   int nSubCrvId = pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, pSubCrvCopy) ;
-   ExeSetModified() ;
-
-   return nSubCrvId ;
-}
@@ -1,162 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2023-2024
-//----------------------------------------------------------------------------
-// File : Exe_GdbGetPocketing.cpp     Data : 02.02.24      Versione : 2.6b1
-// Contenuto : Funzioni di interrogazione di regioni piane del DBG per EXE.
-//
-//
-//
-// Modifiche : 29.11.23 RE Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-//--------------------------- Include ----------------------------------------
-#include "stdafx.h"
-#include "EXE.h"
-#include "EXE_Macro.h"
-#include "/EgtDev/Include/EXeExecutor.h"
-#include "/EgtDev/Include/EGkSfrCreate.h"
-#include "/EgtDev/Include/EGkCalcPocketing.h"
-
-using namespace std ;
-
-//----------------------------------------------------------------------------
-bool
-ExePocketing( int nId, double dRad, double dStep, double dAngle, int nType, bool bSmooth, int nDestGrpId,
-              int& nFirstId, int& nCrvCount)
-{
-  // database geometrico
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false) ;
-
-  // recupero la FlatRegion da svuotare
-   PtrOwner<ISurfFlatRegion> pMySfr ;
-   const ISurfFlatRegion* pSfr = GetSurfFlatRegion( pGeomDB->GetGeoObj( nId)) ;
-   if ( pSfr == nullptr) {
-     // verifico se è una curva chiusa e piana che permette di definire una regione
-      const ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( nId)) ;
-      Plane3d plPlane ;
-      if ( pCrv == nullptr  ||  ! pCrv->IsFlat( plPlane, true, 10 * EPS_SMALL))
-         return false ;
-      SurfFlatRegionByContours SfrCntr ;
-      SfrCntr.AddCurve( pCrv->Clone()) ;
-      pMySfr.Set( SfrCntr.GetSurf()) ;
-      if ( IsNull( pMySfr))
-         return false ;
-      pSfr = pMySfr ;
-   }
-
-  // recupero il suo frame
-   Frame3d frSfr ;
-   if ( ! pGeomDB->GetGlobFrame( nId, frSfr))
-      return false ;
-
-  // recupero il riferimento del gruppo di destinazione
-   Frame3d frDest ;
-   if ( ! pGeomDB->GetGroupGlobFrame( nDestGrpId, frDest))
-      return false ;
-
-  // eseguo Pocketing
-   ICRVCOMPOPOVECTOR vCrvCompoRes ;
-   bool bOk = CalcPocketing( pSfr, dRad, 0, dStep, dAngle, 5., nType, bSmooth, true, false, false, false, true, P_INVALID, nullptr, false,
-                             dStep, 0, INFINITO, 0, 0, INFINITO, false, 0., 0., vCrvCompoRes) ;
-   nFirstId = GDB_ID_NULL ;
-   nCrvCount = int( vCrvCompoRes.size()) ;
-   if ( bOk  &&  nCrvCount > 0) {
-     // scorro le curve di Pocketing ottenute
-      for ( int nI = 0 ; nI < nCrvCount ; ++ nI) {
-         vCrvCompoRes[nI]->LocToLoc( frSfr, frDest) ;
-        // inserisco la curva nel DB Geometrico
-         int nCurrId = pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, Release( vCrvCompoRes[nI])) ;
-         if ( nCurrId == GDB_ID_NULL)
-            return false ;
-         if ( nI == 0)
-            nFirstId = nCurrId ;
-      }
-      ExeSetModified() ;
-   }
-
-   if ( IsCmdLog()) {
-      string sLua = "EgtPocketing(" + ToString( nId) + "," +
-                                      ToString( dRad) + "," +
-                                      ToString( dStep) + "," +
-                                      ToString( dAngle) + "," +
-                                      ToString( nType) + "," +
-                                      ToString( bSmooth) + "," +
-                                      ToString( nDestGrpId) + ")" +
-                    " FirstId=" + ToString( nFirstId) + " CurveCount=" + ToString( nCrvCount) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-   return bOk ;
-}
-
-//----------------------------------------------------------------------------
-int
-ExeSurfFrGetZigZagInfill( int nId, int nDestGrpId, double dStep, double dAng, bool bSmooth, bool bRemoveOverlapLink,
-                          int* pnCount)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
-
-  // recupero la superficie FlatRegion
-   ISurfFlatRegion* pOrigSrf = GetSurfFlatRegion( pGeomDB->GetGeoObj( nId)) ;
-   if ( pOrigSrf == nullptr)
-      return GDB_ID_NULL ;
-   PtrOwner<ISurfFlatRegion> pSfr( pOrigSrf->Clone()) ;
-   bool bOk = ( ! IsNull( pSfr)) ;
-
-  // recupero il riferimento della superficie
-   Frame3d frSurf ;
-   bOk = bOk && pGeomDB->GetGlobFrame( nId, frSurf) ;
-  // recupero il riferimento di destinazione
-   Frame3d frDest ;
-   bOk = bOk && pGeomDB->GetGroupGlobFrame( nDestGrpId, frDest) ;
-
-  // creo il riferimento per il calcolo del percorso a zigzag
-   Vector3d vtN ;
-   if ( bOk) 
-      vtN = pSfr->GetNormVersor() ;
-   bOk = bOk && vtN.ToGlob( frSurf) ;
-   Frame3d frRef ; 
-   bOk = bOk && frRef.Set( ORIG, vtN) ;
-   bOk = bOk && frRef.Rotate( ORIG, vtN, dAng) ;
-
-  // calcolo il percorso a zigzag
-   bOk = bOk && pSfr->LocToLoc( frSurf, frRef) ;
-   ICRVCOMPOPOVECTOR vpCrvs ;
-   bOk = bOk  &&  CalcZigZagInfill( pSfr, dStep, bSmooth, bRemoveOverlapLink, vpCrvs) ;
-
-  // inserisco le curve risultanti nel DB
-   int nFirstId = GDB_ID_NULL ;
-   int nCount = 0 ;
-   for ( int i = 0 ; bOk  &&  i < ( int) vpCrvs.size() ; i ++) {
-     // porto la curva nel riferimento di destinazione
-      bOk = bOk  &&  vpCrvs[i]->LocToLoc( frRef, frDest) ;
-     // la inserisco nel DB geometrico
-      int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, Release( vpCrvs[i])) : GDB_ID_NULL) ;
-      bOk = bOk && ( nNewId != GDB_ID_NULL) ;
-     // aggiorno contatori
-      if ( bOk  &&  nFirstId == GDB_ID_NULL)
-         nFirstId = nNewId ;
-      if ( bOk)
-         ++ nCount ;
-   } 
-   ExeSetModified() ;
-
-  // restituisco risultati
-   if ( pnCount != nullptr)
-      *pnCount = nCount ;
-
-   if ( IsCmdLog()) {
-      string sLua = "EgtGetSurfFrZigZagInfill(" + ToString( nId) + "," +
-                                                  ToString( dStep) + "," +
-                                                  ToString( dAng) + "," +
-                                                  ToString( bSmooth) + "," +
-                                                  ToString( bRemoveOverlapLink) + "," +
-                    " -- Ok=" + ToString( bOk) + " FirstId=" + ToString( nFirstId) + " CurveCount=" + ToString( nCount) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-
-   return nFirstId ;
-}
@@ -250,8 +250,8 @@ ExeVolZmapGetEdges( int nId, int nDestGrpId, int* pnCount)
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
-      string sLua = "EgtVolZmapGetEdges(" + ToString( nId) + ",{" +
-                                            ToString( nDestGrpId) + ")" +
+      string sLua = "EgtGetSurfTmSilhouette(" + ToString( nId) + ",{" +
+                                                ToString( nDestGrpId) + ")" +
                    " -- Id1=" + ToString( nFirstId) + ",Nbr=" + ToString( nCount) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
@@ -23,16 +23,14 @@
 #include "/EgtDev/Include/EGkCurveComposite.h"
 #include "/EgtDev/Include/EGkCurveLocal.h"
 #include "/EgtDev/Include/EGkSurfFlatRegion.h"
-#include "/EgtDev/Include/EGkSurfTriMeshAux.h"
+#include "/EgtDev/Include/EGkSurfTriMesh.h"
 #include "/EgtDev/Include/EGkSurfBezier.h"
 #include "/EgtDev/Include/EGkSurfLocal.h"
 #include "/EgtDev/Include/EGkStmFromTriangleSoup.h"
 #include "/EgtDev/Include/EGkCAvSimpleSurfFrMove.h"
 #include "/EgtDev/Include/EGkStringUtils3d.h"
-#include "/EgtDev/Include/EGkSubtractProjectedFacesOnStmFace.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"

-
 using namespace std ;

 //----------------------------------------------------------------------------
@@ -77,7 +75,7 @@ MyExplodeSurfTriMesh( int nId, int& nCount)
      return GDB_ID_NULL ;
  // recupero il numero di componenti connesse
   int nParts = pStm->GetPartCount() ;
-  // se ci sono più parti, separo queste
+  // se ci sono più parti, separo queste
   if ( nParts > 1) {
      int nFirstId = GDB_ID_NULL ;
      nCount = 0 ;
@@ -102,36 +100,9 @@ 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
+  // se ci sono più facce, separo queste
   if ( nFacets > 1) {
     // copio tutte le facce
      int nFirstId = GDB_ID_NULL ;
@@ -157,7 +128,7 @@ MyExplodeSurfTriMesh( int nId, int& nCount)
     // restituisco risultati
      return nFirstId ;
   }
-  // non devo fare alcunché
+  // non devo fare alcunché
   nCount = 1 ;
   return nId ;
 }
@@ -174,7 +145,7 @@ MyExplodeSurfFlatRegion( int nId, int& nCount)
      return GDB_ID_NULL ;
  // recupero il numero di componenti connessi (chunk)
   int nChunk = pSfr->GetChunkCount() ;
-  // se c'è un solo componente, non devo fare alcunché
+  // se c'è un solo componente, non devo fare alcunché
   if ( nChunk == 1) {
      nCount = 1 ;
      return nId ;
@@ -236,7 +207,7 @@ ExeExplodeSurface( int nId, int* pnCount)

 //-------------------------------------------------------------------------------
 bool
-ExeApproxSurface( int nId, double dLinTol, double dTriaMinSide)
+ExeApproxSurface( int nId, double dLinTol)
 {
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
@@ -257,7 +228,8 @@ ExeApproxSurface( int nId, double dLinTol, double dTriaMinSide)
   else if ( nType == SRF_BEZIER) {
     // recupero la superficie ausiliaria della Bezier
      const ISurfBezier* pSbez = GetSurfBezier( pGeomDB->GetGeoObj( nId)) ;
-      pStm.Set( ( pSbez != nullptr ? pSbez->GetApproxSurf( dLinTol, dTriaMinSide) : nullptr)) ;
+      const ISurfTriMesh* pAuxSurf = ( pSbez != nullptr ? pSbez->GetAuxSurf() : nullptr) ;
+      pStm.Set( pAuxSurf != nullptr ? pAuxSurf->Clone() : nullptr) ;
   }
   bool bOk = ( ! IsNull( pStm)) ;
  // semplificazione della trimesh
@@ -268,8 +240,7 @@ ExeApproxSurface( int nId, double dLinTol, double dTriaMinSide)
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtApproxSurf(" + ToString( nId) + "," +
-                                       ToString( dLinTol) + "," +
-                                       ToString( dTriaMinSide) + ")" +
+                                       ToString( dLinTol) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
@@ -323,8 +294,8 @@ ExeSurfFrSubtract( int nId1, int nId2)
   bOk = bOk && ( pSfr2L != nullptr) ;
  // eseguo la sottrazione della seconda superficie dalla prima
   bOk = bOk && pSfr1->Subtract( *pSfr2L) ;
-  // se il risultato è vuoto, cancello la FlatRegion
-   if ( bOk  &&  ! pSfr1->IsValid())
+  // se il risultato è vuoto, cancello la FlatRegion
+   if ( bOk  && ! pSfr1->IsValid())
      pGeomDB->Erase( nId1) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
@@ -355,8 +326,8 @@ ExeSurfFrIntersect( int nId1, int nId2)
   bOk = bOk && ( pSfr2L != nullptr) ;
  // eseguo l'intersezione tra le due superfici
   bOk = bOk && pSfr1->Intersect( *pSfr2L) ;
-  // se il risultato è vuoto, cancello la FlatRegion
-   if ( bOk  &&  ! pSfr1->IsValid())
+  // se il risultato è vuoto, cancello la FlatRegion
+   if ( bOk  && ! pSfr1->IsValid())
      pGeomDB->Erase( nId1) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
@@ -380,8 +351,8 @@ ExeSurfFrOffset( int nId, double dDist, int nType)
   bool bOk = ( pSfr != nullptr) ;
  // eseguo l'offset
   bOk = bOk && pSfr->Offset( dDist, nType) ;
-  // se il risultato è vuoto, cancello la FlatRegion
-   if ( bOk  &&  ! pSfr->IsValid())
+  // se il risultato è vuoto, cancello la FlatRegion
+   if ( bOk  && ! pSfr->IsValid())
      pGeomDB->Erase( nId) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
@@ -395,58 +366,6 @@ ExeSurfFrOffset( int nId, double dDist, int nType)
   return bOk ;
 }

-//----------------------------------------------------------------------------
-bool
-ExeSurfFrOffsetAdv( int nId, double dDist, int nType, int& nNewId)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-  // recupero la superficie FlatRegion
-   ISurfFlatRegion* pSfr = GetSurfFlatRegion( pGeomDB->GetGeoObj( nId)) ;
-   if ( pSfr == nullptr)
-      return false ;      
-  // eseguo l'offset
-   PtrOwner<ISurfFlatRegion> pSfrOffs( pSfr->CreateOffsetSurf( dDist, nType)) ;
-   if ( IsNull( pSfrOffs))
-      return false ;
-  // salvo la superficie di offset
-   nNewId = GDB_ID_NULL ;
-   if ( pSfr->GetChunkCount() > 0) {
-     // inserisco nel DB geometrico
-      nNewId = pGeomDB->InsertGeoObj( GDB_ID_NULL, nId, GDB_AFTER, Release( pSfrOffs)) ;
-     // copio gli attributi
-      pGeomDB->CopyAttributes( nId, nNewId) ;
-      ExeSetModified() ;
-   }
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool
-ExeSurfFrEraseChunk( int nId, int nChunk)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-  // recupero la superficie FlatRegion
-   ISurfFlatRegion* pSfr = GetSurfFlatRegion( pGeomDB->GetGeoObj( nId)) ;
-   if ( pSfr == nullptr)
-      return false ;      
-  // elimino il chunk indicato
-   bool bOk = pSfr->EraseChunk( nChunk) ;
-  // se il risultato è vuoto, cancello la FlatRegion
-   if ( bOk  &&  ! pSfr->IsValid())
-      pGeomDB->Erase( nId) ;
-   ExeSetModified() ;
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtSurfFrEraseChunk(" + ToString( nId) + "," +
-                                             ToString( nChunk) + ")" +
-                    " -- Ok=" + ToString( bOk) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-   return bOk ;
-}
-
 //----------------------------------------------------------------------------
 bool
 ExeSurfFrMoveSimpleNoCollision( int nId1, int nId2, const Vector3d& vtDir, double& dLen, int nRefType)
@@ -496,11 +415,11 @@ bool
 ExeSurfTmMoveVertex( int nId, int nVert, const Point3d& ptNewVert, int nRefType, bool bUpdate)
 {
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
+   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // recupero la superficie
   ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
   bool bOk = ( pStm != nullptr) ;
-  // recupero il riferimento in cui è immersa la superficie
+  // recupero il riferimento in cui è immersa la superficie
   Frame3d frStm ;
   bOk = bOk && pGeomDB->GetGlobFrame( nId, frStm) ;
  // eseguo la modifica
@@ -528,50 +447,6 @@ ExeSurfTmMoveVertex( int nId, int nVert, const Point3d& ptNewVert, int nRefType,
   return bOk ;
 }

-//-------------------------------------------------------------------------------
-bool
-ExeSurfTmMoveFacet( int nId, int nFacet, const Vector3d& vtMove, int nRefType, bool bUpdate)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-  // recupero la superficie
-   ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
-   bool bOk = ( pStm != nullptr) ;
-  // recupero il riferimento in cui è immersa la superficie
-   Frame3d frStm ;
-   bOk = bOk && pGeomDB->GetGlobFrame( nId, frStm) ;
-  // porto in locale il movimento
-   Vector3d vtMoveL = GetVectorLocal( pGeomDB, vtMove, nRefType, frStm) ;
-  // recupero tutti i vertici della faccia
-   INTVECTOR vVert ;
-   bOk = bOk && pStm->GetAllVertInFacet( nFacet, vVert) ;
-  // sposto tutti i vertici della faccia della quantità desiderata
-   if ( bOk) {
-      for ( const auto nVert : vVert) {
-        // recupero la posizione originale del vertice
-         Point3d ptV ;
-         if ( pStm->GetVertex( nVert, ptV))
-            pStm->MoveVertex( nVert, ptV + vtMoveL) ;
-      }
-   }
-  // se richiesto, semplificazione della trimesh
-   if ( bUpdate)
-      bOk = bOk && pStm->DoCompacting() ;
-   ExeSetModified() ;
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtSurfTmMoveFacet(" + IdToString( nId) + "," +
-                                            ToString( nFacet) + ",{"  +
-                                            ToString( vtMove) + "}," +
-                                            RefTypeToString( nRefType) + "," +
-                                            ( bUpdate ? "true" : "false") + ")" +
-                    " -- Ok=" + ToString( bOk) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-  // restituisco risultato
-   return bOk ;
-}
-
 //-------------------------------------------------------------------------------
 static int
 MySurfTmToTriangles( int nId, int& nCount)
@@ -584,7 +459,7 @@ MySurfTmToTriangles( int nId, int& nCount)
      return GDB_ID_NULL ;
  // recupero il numero di triangoli
   int nTria = pStm->GetTriangleCount() ;
-  // se ci sono più triangoli, li separo
+  // se ci sono più triangoli, li separo
   if ( nTria > 1) {
     // copio tutti triangoli
      int nFirstId = GDB_ID_NULL ;
@@ -610,7 +485,7 @@ MySurfTmToTriangles( int nId, int& nCount)
     // restituisco risultati
      return nFirstId ;
   }
-  // non devo fare alcunché
+  // non devo fare alcunché
   nCount = 1 ;
   return nId ;
 }
@@ -825,7 +700,7 @@ ExeSurfTmSubtract( int nId1, int nId2, bool bTwoColors)
   bOk = bOk && ( pStm2L != nullptr) ;
  // eseguo la sottrazione tra le due superfici
   bOk = bOk && pStm1->Subtract( *pStm2L) ;
-  // se il risultato � vuoto, cancello la superficie
+  // se il risultato è vuoto, cancello la superficie
   if ( bOk  && ! pStm1->IsValid()) {
      pGeomDB->Erase( nId1) ;
      pStm1 = nullptr ;
@@ -862,7 +737,7 @@ ExeSurfTmIntersect( int nId1, int nId2, bool bTwoColors)
   bOk = bOk && ( pStm2L != nullptr) ;
  // eseguo l'intersezione tra le due superfici
   bOk = bOk && pStm1->Intersect( *pStm2L) ;
-  // se il risultato � vuoto, cancello la superficie
+  // se il risultato è vuoto, cancello la superficie
   if ( bOk  && ! pStm1->IsValid()) {
      pGeomDB->Erase( nId1) ;
      pStm1 = nullptr ;
@@ -881,6 +756,27 @@ ExeSurfTmIntersect( int nId1, int nId2, bool bTwoColors)
   return bOk ;
 }

+//----------------------------------------------------------------------------
+bool
+ExeSurfTmResetTwoColors( int nId)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, false)
+  // recupero la superficie TriMesh
+   ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
+   bool bOk = ( pStm != nullptr) ;
+  // reset dei flag sui triangoli per i due colori
+   bOk = bOk && pStm->ResetTFlags() ;
+   ExeSetModified() ;
+  // se richiesto, salvo il comando Lua equivalente
+   if ( IsCmdLog()) {
+      string sLua = "EgtSurfTmResetTwoColors(" + ToString( nId) + ")" +
+                    " -- Ok=" + ToString( bOk) ;
+      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
+   }
+   return bOk ;
+}
+
 //----------------------------------------------------------------------------
 static ISurfTriMesh*
 MyCreateSubSurfTm( const ISurfTriMesh* pStm, const INTVECTOR& vTria, const INTVECTOR& vTria2)
@@ -1028,382 +924,3 @@ ExeSurfTmCut( int nId, int nCutterId, bool bInVsOut, bool bSaveOnEq)
   }
   return bOk ;
 }
-
-//----------------------------------------------------------------------------
-bool
-ExeSurfTmSubtractProjectedFacesOnFace( int nSurfId, int nFaceInd, int nDestGrpId,
-                                       INTVECTOR vSurfsId, bool bOCFlag,
-                                       bool& bExistProjection, int& nNewId, int& nNewFaceNbr)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-  // recupero la superficie TriMesh su cui proiettare
-   ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nSurfId)) ;
-   if ( pStm == nullptr)
-      return false ;
-  // recupero il riferimento della superficie
-   Frame3d frSurf ;
-   if ( ! pGeomDB->GetGlobFrame( nSurfId, frSurf))
-      return false ;
-  // recupero il riferimento del gruppo di destinazione
-   Frame3d frDest ;
-   if ( ! pGeomDB->GetGroupGlobFrame( nDestGrpId, frDest))
-      return false ;
-  // costruzione vettori di superfici e indici delle facce per proiezione
-   ISURFTMPOVECTOR vpStmOthers ;
-   vector<SurfLocal> vSurfCLoc ;
-  // recupero le altre superfici e le porto nel sistema di riferimento della prima
-   for ( int i = 0 ; i < int( vSurfsId.size()) ; ++ i) {
-      if ( pGeomDB->GetGeoType( vSurfsId[i]) != SRF_TRIMESH)
-         return false ;
-      vSurfCLoc.emplace_back( pGeomDB, vSurfsId[i], frSurf) ;
-      const ISurfTriMesh* pStmCurr = GetSurfTriMesh( vSurfCLoc.back().Get()) ;
-      vpStmOthers.emplace_back( pStmCurr->Clone()) ;
-   }
-  // eseguo la proiezione
-   ISurfTriMesh* pStmRes = nullptr ;
-   bool bOk = SubtractProjectedFacesOnStmFace( *pStm, nFaceInd, vpStmOthers, bOCFlag,
-                                               bExistProjection, pStmRes, nNewFaceNbr) ;
-   if ( ! bOk) {
-      delete( pStmRes) ;
-      pStmRes = nullptr ;
-   }
-
-   nNewId = GDB_ID_NULL ;
-   if ( bOk  &&  pStmRes != nullptr) {
-     // porto nel sistema di riferimento destinazione
-      pStmRes->LocToLoc( frSurf, frDest) ;
-     // la inserisco nel DB geometrico
-      nNewId = pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, pStmRes) ;
-      if ( nNewId == GDB_ID_NULL)
-         return false ;
-      ExeSetModified() ;
-   }
-
-   if ( IsCmdLog()) {
-      string sLua = "EgtSubtractProjectedFacesOnStmFace(" + ToString( nSurfId) + "," +
-                                                            ToString( nFaceInd) + "," +
-                                                            ToString( nDestGrpId) + "," +
-                                                            ToString( vSurfsId) + "," +
-                                                            ToString( bOCFlag) + ")" +
-                    " -- Ok=" + ToString( bOk) + " Id=" + ToString( nNewId) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-   return bOk ;
-}
-
-//----------------------------------------------------------------------------
-bool
-ExeSurfTmSetFaceColor( int nId, int nFacet, int nColor)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-  // recupero la superficie TriMesh
-   ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
-   bool bOk = ( pStm != nullptr) ;
-  // recupero tutti i triangoli della faccia e imposto il flag opportuno per il colore
-   INTVECTOR vTria ;
-   bOk = bOk && pStm->GetAllTriaInFacet( nFacet, vTria) ;
-   for ( const auto nT : vTria)
-      pStm->SetTFlag( nT, nColor) ;
-   ExeSetModified() ;
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtSurfTmSetFaceColor(" + ToString( nId) + "," +
-                                               ToString( nFacet) + "," +
-                                               ToString( nColor) + ")" +
-                    " -- Ok=" + ToString( bOk) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-   return bOk ;
-}
-
-//----------------------------------------------------------------------------
-bool
-ExeSurfTmGetTriaColor( int nId, int nTria, int& nColor)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-  // recupero la superficie TriMesh
-   ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
-   bool bOk = ( pStm != nullptr) ;
-  // recupero il colore del triangolo
-   return ( bOk && pStm->GetTFlag( nTria, nColor)) ;
-}
-
-//----------------------------------------------------------------------------
-bool
-ExeSurfTmResetTwoColors( int nId)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-  // recupero la superficie TriMesh
-   ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
-   bool bOk = ( pStm != nullptr) ;
-  // reset dei flag sui triangoli per i due colori
-   bOk = bOk && pStm->ResetTFlags() ;
-   ExeSetModified() ;
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtSurfTmResetTwoColors(" + ToString( nId) + ")" +
-                    " -- Ok=" + ToString( bOk) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-   return bOk ;
-}
-
-//----------------------------------------------------------------------------
-bool
-ExeSurfTmSetShowEdges( int nId, bool bShow)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-  // recupero la superficie trimesh
-   ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
-   bool bOk = ( pStm != nullptr) ;
-  // imposto lo stato di visualizzazione degli spigoli vivi
-   if ( bOk)
-      pStm->SetShowEdges( bShow) ;
-   ExeSetModified() ;
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtSurfTmSetShowEdges(" + ToString( nId) + "," +
-                                               ToString( bShow) + ")" +
-                    " -- Ok=" + ToString( bOk) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-   return bOk ;
-}
-
-//----------------------------------------------------------------------------
-bool
-ExeSurfTmGetShowEdges( int nId, bool& bShow)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-  // recupero la superficie trimesh
-   ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
-   bool bOk = ( pStm != nullptr) ;
-  // recupero lo stato di visualizzazione degli spigoli vivi
-   if ( bOk)
-      bShow = pStm->GetShowEdges() ;
-   else
-      bShow = false ;
-   return bOk ;
-}
-
-//----------------------------------------------------------------------------
-bool
-ExeSurfTmSetSmoothAng( int nId, double dAngDeg)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-   // recupero la superficie trimseh da trimmare
-   ISurfTriMesh* pSrfTm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
-   if ( pSrfTm == nullptr)
-      return false ;
-  // imposto l'angolo discriminante degli spigoli vivi
-   pSrfTm->SetSmoothAngle( dAngDeg) ;
-   ExeSetModified() ;
-   // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtSurfTmSetSmoothAng(" + ToString( nId) + "," +
-                                             ToString( dAngDeg) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool
-ExeSurfTmGetSmoothAng( int nId, double& dAngDeg)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-  // recupero la superficie trimesh
-   ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
-   bool bOk = ( pStm != nullptr) ;
-  // recupero l'angolo discriminante degli spigoli vivi
-   if ( bOk)
-      dAngDeg = pStm->GetSmoothAngle() ;
-   else
-      dAngDeg = 0 ;
-   return bOk ;
-}
-
-//----------------------------------------------------------------------------
-static double
-GetStmOffsPrec( double dOffs, double dLinTol)
-{
-   return max( min( abs( dOffs) / 4., 10. * max( dLinTol, EPS_SMALL)), 0.5) ;
-}
-
-//----------------------------------------------------------------------------
-int
-ExeSurfTmOffset( int nParentId, const INTVECTOR& vStmIds, double dOffs, double dLinTol, int nType)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
-   nParentId = AdjustId( nParentId) ;
-  // se non ci sono superfici non c'è niente da calcolare
-   if ( vStmIds.empty())
-      return GDB_ID_NULL ;
-  // recupero il riferimento del gruppo di inserimento
-   Frame3d frLoc ;
-   if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frLoc))
-      return GDB_ID_NULL ;
-  // recupero le superfici TriMesh e le porto tutte in locale
-   SURFLOCALVECTOR vSurfL ; vSurfL.reserve( vStmIds.size()) ;
-   CISURFTMPVECTOR vpStm ;  vpStm.reserve( vStmIds.size()) ;
-   for ( int i = 0 ; i < int( vStmIds.size()) ; ++ i) {
-      vSurfL.emplace_back( pGeomDB, vStmIds[i], frLoc) ;
-      if ( vSurfL[i].Get() == nullptr)
-         return GDB_ID_NULL ;
-      vpStm.emplace_back( GetSurfTriMesh( vSurfL[i].Get())) ;
-   }
-  // precisione per Tridexel in funzione dell'offset e della tolleranza lineare
-   double dPrec = GetStmOffsPrec( dOffs, dLinTol) ;
-  // recupero la superficie risultante
-   PtrOwner<ISurfTriMesh> pStmOffs( CreateSurfTriMeshesOffset( vpStm, dOffs, dPrec, nType)) ;
-   bool bOk = ( ! IsNull( pStmOffs) && pStmOffs->IsValid()) ;
-   int nId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pStmOffs)) : GDB_ID_NULL) ;
-  // copio gli attributi
-   pGeomDB->CopyAttributes( vStmIds[0], nId) ;
-   ExeSetModified() ;
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtSurfTmOffset(" + ToString( nParentId) + ")" +
-                                         ToString( vStmIds) + "," +
-                                         ToString( dOffs) + "," +
-                                         ToString( dLinTol) + "," +
-                                         ToString( nType) + ")" +
-                    " -- Id=" + ToString( nId) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-  // restituisco il risultato
-   return nId ;
-}
-
-//-------------------------------------------------------------------------------
-int
-ExeSurfTmThickeningOffset( int nParentId, const INTVECTOR& vStmIds, double dOffs, double dLinTol, int nType)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
-   nParentId = AdjustId( nParentId) ;
-  // se non ci sono superfici non c'è niente da calcolare
-   if ( vStmIds.empty())
-      return GDB_ID_NULL ;
-  // recupero il riferimento del gruppo di inserimento
-   Frame3d frLoc ;
-   if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frLoc))
-      return GDB_ID_NULL ;
-  // recupero le superfici TriMesh e le porto tutte in locale
-   SURFLOCALVECTOR vSurfL ; vSurfL.reserve( vStmIds.size()) ;
-   CISURFTMPVECTOR vpStm ;  vpStm.reserve( vStmIds.size()) ;
-   for ( int i = 0 ; i < int( vStmIds.size()) ; ++ i) {
-      vSurfL.emplace_back( pGeomDB, vStmIds[i], frLoc) ;
-      if ( vSurfL[i].Get() == nullptr)
-         return GDB_ID_NULL ;
-      vpStm.emplace_back( GetSurfTriMesh( vSurfL[i].Get())) ;
-   }
-  // precisione per Tridexel in funzione dell'offset e della tolleranza lineare
-   double dPrec = GetStmOffsPrec( dOffs, dLinTol) ;
-  // recupero la superficie risultante
-   PtrOwner<ISurfTriMesh> pStmOffs( CreateSurfTriMeshesThickeningOffset( vpStm, dOffs, dPrec, nType)) ;
-   bool bOk = ( ! IsNull( pStmOffs) && pStmOffs->IsValid()) ;
-   int nId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pStmOffs)) : GDB_ID_NULL) ;
-  // copio gli attributi
-   pGeomDB->CopyAttributes( vStmIds[0], nId) ;
-   ExeSetModified() ;
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtSurfTmThickeningOffset(" + ToString( nParentId) + ")" +
-                                                   ToString( vStmIds) + "," +
-                                                   ToString( dOffs) + "," +
-                                                   ToString( dLinTol) + "," +
-                                                   ToString( nType) + ")" +
-                    " -- Id=" + ToString( nId) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-   return nId ;
-}
-
-//-------------------------------------------------------------------------------
-bool
-ExeCutSurfBzPlane( int nId, const Point3d& ptOn, const Vector3d& vtN, bool bSaveOnEq, int nRefType)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-  // recupero la superficie TriMesh
-   ISurfBezier* pSbz = GetSurfBezier( pGeomDB->GetGeoObj( nId)) ;
-   bool bOk = ( pSbz != nullptr) ;
-  // recupero il riferimento locale
-   Frame3d frLoc ;
-   bOk = bOk && pGeomDB->GetGlobFrame( nId, frLoc) ;
-  // porto in locale il punto e la normale del piano
-   Point3d ptOnL = GetPointLocal( pGeomDB, ptOn, nRefType, frLoc) ;
-   Vector3d vtNL = GetVectorLocal( pGeomDB, vtN, nRefType, frLoc) ;
-  // calcolo il piano di taglio
-   Plane3d plPlane ;
-   bOk = bOk && plPlane.Set( ptOnL, vtNL) ;
-  // eseguo il taglio
-   bOk = bOk &&  pSbz->Cut( plPlane, bSaveOnEq) ;
-   ExeSetModified() ;
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtCutSurfBzPlane(" + IdToString( nId) + ",{" +
-                                           ToString( ptOn) + "},{" +
-                                           ToString( vtN) + "}," +
-                                           ( bSaveOnEq ? "true" : "false") + "," +
-                                           RefTypeToString( nRefType) + ")" +
-                    " -- Ok=" + ToString( bOk) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-  // restituisco risultato
-   return bOk ;
-}
-
-//----------------------------------------------------------------------------
-static bool 
-MySurfBzTrim( int nId, int nTrimmerId)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-      // recupero la superficie Bezier da trimmare
-   ISurfBezier* pSrfBz = GetSurfBezier( pGeomDB->GetGeoObj( nId)) ;
-   if ( pSrfBz == nullptr)
-      return false ;
-   // recupero il riferimento della superficie
-   Frame3d frSurf ;
-   if ( ! pGeomDB->GetGlobFrame( nId, frSurf))
-      return false ;
-   // recupero la superficie TriMesh divisore in locale alla prima
-
-   SurfLocal SurfCLoc( pGeomDB, nTrimmerId, frSurf) ;
-   //const ISurfTriMesh* pStmCLoc = GetSurfTriMesh( SurfCLoc) ;
-   const ISurfFlatRegion* pSrfFr = GetSurfFlatRegion( SurfCLoc) ;
-   if ( pSrfFr == nullptr)
-      return false ;
-   PtrOwner<ISurfFlatRegion> pSrfFrCopy( pSrfFr->Clone()) ;
-   if ( ! pSrfFr->GetNormVersor().IsZplus())
-      pSrfFrCopy->Invert() ;
-   // eseguo il taglio
-   return pSrfBz->SetTrimRegion( *pSrfFrCopy) ;
-}
-
-//----------------------------------------------------------------------------
-bool
-ExeSurfBzTrim( int nId, int nCutterId)
-{
-   bool bOk = MySurfBzTrim( nId, nCutterId) ;
-   ExeSetModified() ;
-   // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtSurfBzCut(" + ToString( nId) + "," +
-         ToString( nCutterId) + "," +
-         " -- Ok=" + ToString( bOk) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-   return bOk ;
-}
@@ -104,9 +104,10 @@ ExeVolZmapChangeResolution( int nId, int nNewRes)
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero lo Zmap
   IVolZmap* pVZM = GetVolZmap( pGeomDB->GetGeoObj( nId)) ;
-   bool bOk = ( pVZM != nullptr) ;
+   if ( pVZM == nullptr)
+      return false ;
  // cambio la risoluzione (rapporto Voxel/Dexel, valori ammessi 1 e 2)
-   bOk = bOk && pVZM->ChangeResolution( nNewRes) ;
+   bool bOk = pVZM->ChangeResolution( nNewRes) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
@@ -119,46 +120,6 @@ ExeVolZmapChangeResolution( int nId, int nNewRes)
   return bOk ;
 }

-//----------------------------------------------------------------------------
-bool
-ExeVolZmapSetShowEdges( int nId, bool bShow)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-  // recupero lo Zmap
-   IVolZmap* pVZM = GetVolZmap( pGeomDB->GetGeoObj( nId)) ;
-   bool bOk = ( pVZM != nullptr) ;
-  // imposto lo stato di visualizzazione degli spigoli vivi
-   if ( bOk)
-      pVZM->SetShowEdges( bShow) ;
-   ExeSetModified() ;
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtVolZmapSetShowEdges(" + ToString( nId) + "," +
-                                                ToString( bShow) + ")" +
-                    " -- Ok=" + ToString( bOk) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-   return bOk ;
-}
-
-//----------------------------------------------------------------------------
-bool
-ExeVolZmapGetShowEdges( int nId, bool& bShow)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-  // recupero lo Zmap
-   IVolZmap* pVZM = GetVolZmap( pGeomDB->GetGeoObj( nId)) ;
-   bool bOk = ( pVZM != nullptr) ;
-  // leggo lo stato di visualizzazione degli spigoli vivi
-   if ( bOk)
-      bShow = pVZM->GetShowEdges() ;
-   else
-      bShow = false ;
-   return bOk ;
-}
-
 //-------------------------------------------------------------------------------
 bool
 ExeRemoveVolZmapPart( int nId, int nPart)
@@ -354,34 +315,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)
@@ -552,113 +485,3 @@ ExeCutVolZmapPlane( int nId, const Point3d& ptOn, const Vector3d& vtN, int nRefT
  // restituisco risultato
   return bOk ;
 }
-
-//----------------------------------------------------------------------------
-bool
-ExeVolZMapOffset( int nId, double dDist, int nType)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-  // recupero lo Zmap
-   IVolZmap* pVolZmap = GetVolZmap( pGeomDB->GetGeoObj( nId)) ;
-   bool bOk = ( pVolZmap != nullptr) ;
-  // eseguo l'offset
-   bOk = bOk && pVolZmap->Offset( dDist, nType) ;
-  // se il risultato è vuoto, cancello lo Zmap
-   if ( bOk  &&  ! pVolZmap->IsValid())
-      pGeomDB->Erase( nId) ;
-   ExeSetModified() ;
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtVolZmapOffset(" + ToString( nId) + "," +
-                                          ToString( dDist) + "," +
-                                          ToString( nType) + ")" +
-                    " -- Ok=" + ToString( bOk) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-   return bOk ;
-}
-
-//-------------------------------------------------------------------------------
-bool
-ExeUpdateVolZmapByAddingSurfTm( int nVolZmapId, int nStmId)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-  // recupero lo Zmap
-   IVolZmap* pVZM = GetVolZmap( pGeomDB->GetGeoObj( nVolZmapId)) ;
-   bool bOk = ( pVZM != nullptr) ;
-  // 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
-ExeVolZmapMakeUniform( int nVolZmapId, double dToler, bool bExtensionFirst, int nToolNum)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-  // recupero lo Zmap
-   IVolZmap* pVZM = GetVolZmap( pGeomDB->GetGeoObj( nVolZmapId)) ;
-   bool bOk = ( pVZM != nullptr) ;
-  // aggiorno lo Zmap
-   dToler = max( dToler, EPS_SMALL) ;
-   bOk = bOk && pVZM->MakeUniform( dToler, bExtensionFirst, nToolNum) ;
-   ExeSetModified() ;
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtVolZmapMakeUniform(" + ToString( nVolZmapId) + "," +
-                                               ToString( dToler) + "," +
-                                               ( bExtensionFirst ? "true" : "false") +
-                                               ToString( nToolNum) + ")"
-                    " -- bOk =" + ToString( bOk) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-   return bOk ;
-}
-
-//--------------------------------------------------------------------------------
-bool
-ExeVolZMapRemoveFins( int nVolZMapId, const Vector3d& vtDir, double dThick, int nRefType)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false) ;
-  // Recupero lo ZMap
-   IVolZmap* pVZM = GetVolZmap( pGeomDB->GetGeoObj( nVolZMapId)) ;
-   bool bOk = ( pVZM != nullptr) ;
-  // recupero il riferimento locale
-   Frame3d frLoc ;
-   bOk = bOk && pGeomDB->GetGlobFrame( nVolZMapId, frLoc) ;
-  // porto in locale la normale al piano
-   Vector3d vtDirL = GetVectorLocal( pGeomDB, vtDir, nRefType, frLoc) ;
-  // Aggiorno lo ZMap mediante rimozione delle alette
-   bOk = bOk && pVZM->RemoveFins( vtDirL, dThick) ;
-  // Se richiesto salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtVolZMapRemoveFins(" + ToString( nVolZMapId) + "," +
-                                              ToString( vtDir) + "," +
-                                              ToString( dThick) + "," +
-                                              RefTypeToString( nRefType) + ")" +
-                    " -- bOk =" + ToString( bOk) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-   return bOk ;
-}
@@ -38,56 +38,13 @@ ExeCopyAttributes( int nSouId, int nDestId)

 //-----------------------------------------------------------------------------
 bool
-ExeSetLevel( const INTVECTOR& vIds, int nLevel)
+ExeSetLevel( int nId, int nLevel)
 {
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
-  // recupero pezzo e layer correnti
-   bool bCurrPartOff = false ;
-   bool bCurrLayerOff = false ;
-   int nCurrPartId = ExeGetCurrPart() ;
-   int nCurrLayerId = ExeGetCurrLayer() ;
-  // ciclo sul vettore degli identificativi
-   bool bOk = true ;
-   for ( int i = 0 ; i < ssize( vIds) && bOk ; ++ i) {
-     // impostazione livello
-      int nId = (( vIds[i] != GDB_ID_SEL) ? vIds[i] : pGeomDB->GetFirstSelectedObj()) ;
-      while ( nId != GDB_ID_NULL) {
-        // imposto il livello
-         if ( ! pGeomDB->SetLevel( nId, nLevel))
-            bOk = false ;
-        // se nascosto pezzo corrente o layer corrente
-         if ( nLevel != GDB_LV_USER) {
-            if ( nId == nCurrPartId)
-               bCurrPartOff = true ;
-            else if ( nId == nCurrLayerId)
-               bCurrLayerOff = true ;
-         }
-        // passo al successivo
-         nId = (( vIds[i] != GDB_ID_SEL) ? GDB_ID_NULL : pGeomDB->GetNextSelectedObj()) ;
-      }
-   }
-  // se pezzo o layer correnti da rideterminare
-   bool bPrevCmdLog = SetCmdLog( false) ;
-   if ( bCurrPartOff)
-      ExeResetCurrPartLayer() ;
-   else if ( bCurrLayerOff)
-      ExeSetCurrPartLayer( nCurrPartId, ExeGetFirstLayer( nCurrPartId, true)) ;
-   SetCmdLog( bPrevCmdLog) ;
-  // dichiaro progetto modificato
+  // imposto il livello
+   bool bOk = pGeomDB->SetLevel( nId, nLevel) ;
   ExeSetModified() ;
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLevel = "GDB_LV.USER" ;
-      if ( nLevel == GDB_LV_SYSTEM)
-         sLevel = "GDB_LV.SYSTEM" ;
-      else if ( nLevel == GDB_LV_TEMP)
-         sLevel = "GDB_LV.TEMP" ;
-      string sLua = "EgtSetLevel({" + IdListToString( vIds) + "}," +
-                                      sLevel + ")" +
-                    " -- Ok=" + ToString( bOk) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
   return bOk ;
 }

@@ -131,56 +88,13 @@ ExeGetCalcLevel( int nId, int* pnLevel)

 //-----------------------------------------------------------------------------
 bool
-ExeSetMode( const INTVECTOR& vIds, int nMode)
+ExeSetMode( int nId, int nMode)
 {
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
-  // recupero pezzo e layer correnti
-   bool bCurrPartOff = false ;
-   bool bCurrLayerOff = false ;
-   int nCurrPartId = ExeGetCurrPart() ;
-   int nCurrLayerId = ExeGetCurrLayer() ;
-  // ciclo sul vettore degli identificativi
-   bool bOk = true ;
-   for ( int i = 0 ; i < ssize( vIds) && bOk ; ++ i) {
-     // impostazione livello
-      int nId = (( vIds[i] != GDB_ID_SEL) ? vIds[i] : pGeomDB->GetFirstSelectedObj()) ;
-      while ( nId != GDB_ID_NULL) {
-        // imposto il modo
-         if ( ! pGeomDB->SetMode( nId, nMode))
-            bOk = false ;
-        // se nascosto pezzo corrente o layer corrente
-         if ( nMode != GDB_MD_STD) {
-            if ( nId == nCurrPartId)
-               bCurrPartOff = true ;
-            else if ( nId == nCurrLayerId)
-               bCurrLayerOff = true ;
-         }
-        // passo al successivo
-         nId = (( vIds[i] != GDB_ID_SEL) ? GDB_ID_NULL : pGeomDB->GetNextSelectedObj()) ;
-      }
-   }
-  // se pezzo o layer correnti da rideterminare
-   bool bPrevCmdLog = SetCmdLog( false) ;
-   if ( bCurrPartOff)
-      ExeResetCurrPartLayer() ;
-   else if ( bCurrLayerOff)
-      ExeSetCurrPartLayer( nCurrPartId, ExeGetFirstLayer( nCurrPartId, true)) ;
-   SetCmdLog( bPrevCmdLog) ;
-  // dichiaro progetto modificato
+  // imposto il modo
+   bool bOk = pGeomDB->SetMode( nId, nMode) ;
   ExeSetModified() ;
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sMode = "GDB_MD.STD" ;
-      if ( nMode == GDB_MD_LOCKED)
-         sMode = "GDB_MD.LOCKED" ;
-      else if ( nMode == GDB_MD_HIDDEN)
-         sMode = "GDB_MD.HIDDEN" ;
-      string sLua = "EgtSetMode({" + IdListToString( vIds) + "}," +
-                                     sMode + ")" +
-                    " -- Ok=" + ToString( bOk) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
   return bOk ;
 }

@@ -235,11 +149,11 @@ ExeSetStatus( const INTVECTOR& vIds, int nStat)
   int nCurrLayerId = ExeGetCurrLayer() ;
  // ciclo sul vettore degli identificativi
   bool bOk = true ;
-   for ( int i = 0 ; i < ssize( vIds) && bOk ; ++ i) {
+   for ( size_t i = 0 ; i < vIds.size() && bOk ; ++ i) {
     // impostazione stato
      int nId = (( vIds[i] != GDB_ID_SEL) ? vIds[i] : pGeomDB->GetFirstSelectedObj()) ;
      while ( nId != GDB_ID_NULL) {
-        // imposto lo stato
+        // imposto il modo
         if ( ! pGeomDB->SetStatus( nId, nStat))
            bOk = false ;
        // se nascosto pezzo corrente o layer corrente
@@ -318,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 ;
 }
@@ -912,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) ;
-}
@@ -15,10 +15,8 @@
 #include "stdafx.h"
 #include "EXE.h"
 #include "EXE_Macro.h"
-#include "GeoTools.h"
 #include "AuxTools.h"
 #include "/EgtDev/Include/EXeExecutor.h"
-#include "/EgtDev/Include/EGkMultiGeomDB.h"
 #include "/EgtDev/Include/EGkStringUtils3d.h"
 #include "/EgtDev/Include/EGkUiUnits.h"
 #include "/EgtDev/Include/EgtStringConverter.h"
@@ -220,43 +218,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)
@@ -293,7 +254,6 @@ ExeCopy( int nSouId, int nRefId, int nSonBeforeAfter)
 {
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
-   nRefId = AdjustId( nRefId) ;
  // eseguo la copia
   int nNewId = pGeomDB->Copy( nSouId, GDB_ID_NULL, nRefId, nSonBeforeAfter) ;
   pGeomDB->RemoveInfo( nNewId, GDB_SI_LIST) ;
@@ -301,39 +261,16 @@ ExeCopy( int nSouId, int nRefId, int nSonBeforeAfter)
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
-      string sLua = "EgtCopy(" + ToString( nSouId) + "," +
-                                 IdToString( nRefId) + "," +
-                                 InsToString( nSonBeforeAfter) + ")" +
-                    " -- Id=" + ToString( nNewId) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-  // restituisco risultato
-   return nNewId ;
-}
-
-//-----------------------------------------------------------------------------
-int
-ExeCopyEx( int nSouCtx, int nSouId, int nDestCtx, int nRefId, int nSonBeforeAfter)
-{
-  // recupero i due GeomDB
-   IGeomDB* pSouGeomDB = GetGeomDB( nSouCtx) ;
-   VERIFY_GEOMDB( pSouGeomDB, GDB_ID_NULL)
-   IGeomDB* pDstGeomDB = GetGeomDB( nDestCtx) ;
-   VERIFY_GEOMDB( pDstGeomDB, GDB_ID_NULL)
-  // risolvo l'Id di riferimento per destinazione
-   nRefId = AdjustId( nRefId, nDestCtx) ;
-  // eseguo la copia
-   int nNewId = Copy( pSouGeomDB, nSouId, pDstGeomDB, GDB_ID_NULL, nRefId, nSonBeforeAfter) ;
-   pDstGeomDB->RemoveInfo( nNewId, GDB_SI_LIST) ;
-   pDstGeomDB->RemoveInfo( nNewId, GDB_SI_DUPLIST) ;
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtCopyEx(" + ToString( nSouCtx) + "," +
-                                   ToString( nSouId) + "," +
-                                   ToString( nDestCtx) + "," +
-                                   IdToString( nRefId) + "," +
-                                   InsToString( nSonBeforeAfter) + ")" +
-                    " -- Id=" + ToString( nNewId) ;
+      string sLua ;
+      if ( nSonBeforeAfter == GDB_LAST_SON)
+         sLua = "EgtCopy(" + ToString( nSouId) + "," +
+                             ToString( nRefId) + ")" +
+                " -- Id=" + ToString( nNewId) ;
+      else
+         sLua = "EgtCopy(" + ToString( nSouId) + "," +
+                             ToString( nRefId) + "," +
+                             InsToString( nSonBeforeAfter) + ")" +
+                " -- Id=" + ToString( nNewId) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
@@ -346,7 +283,6 @@ ExeCopyGlob( int nSouId, int nRefId, int nSonBeforeAfter)
 {
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
-   nRefId = AdjustId( nRefId) ;
  // eseguo la copia mantenendo la posizione in globale
   int nNewId = pGeomDB->CopyGlob( nSouId, GDB_ID_NULL, nRefId, nSonBeforeAfter) ;
   pGeomDB->RemoveInfo( nNewId, GDB_SI_LIST) ;
@@ -354,84 +290,43 @@ ExeCopyGlob( int nSouId, int nRefId, int nSonBeforeAfter)
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
-      string sLua = "EgtCopyGlob(" + ToString( nSouId) + "," +
-                                     IdToString( nRefId) + "," +
-                                     InsToString( nSonBeforeAfter) + ")" +
-                    " -- Id=" + ToString( nNewId) ;
+      string sLua ;
+      if ( nSonBeforeAfter == GDB_LAST_SON)
+         sLua = "EgtCopyGlob(" + ToString( nSouId) + "," +
+                                 ToString( nRefId) + ")" +
+                " -- Id=" + ToString( nNewId) ;
+      else
+         sLua = "EgtCopyGlob(" + ToString( nSouId) + "," +
+                                 ToString( nRefId) + "," +
+                                 InsToString( nSonBeforeAfter) + ")" +
+                " -- Id=" + ToString( nNewId) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return nNewId ;
 }

-//-----------------------------------------------------------------------------
-int
-ExeCopyGlobEx( int nSouCtx, int nSouId, int nDestCtx, int nRefId, int nSonBeforeAfter)
-{
-  // recupero i due GeomDB
-   IGeomDB* pSouGeomDB = GetGeomDB( nSouCtx) ;
-   VERIFY_GEOMDB( pSouGeomDB, GDB_ID_NULL)
-   IGeomDB* pDstGeomDB = GetGeomDB( nDestCtx) ;
-   VERIFY_GEOMDB( pDstGeomDB, GDB_ID_NULL)
-  // risolvo l'Id di riferimento per destinazione
-   nRefId = AdjustId( nRefId, nDestCtx) ;
-  // eseguo la copia
-   int nNewId = CopyGlob( pSouGeomDB, nSouId, pDstGeomDB, GDB_ID_NULL, nRefId, nSonBeforeAfter) ;
-   pDstGeomDB->RemoveInfo( nNewId, GDB_SI_LIST) ;
-   pDstGeomDB->RemoveInfo( nNewId, GDB_SI_DUPLIST) ;
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtCopyGlobEx(" + ToString( nSouCtx) + "," +
-                                       ToString( nSouId) + "," +
-                                       ToString( nDestCtx) + "," +
-                                       IdToString( nRefId) + "," +
-                                       InsToString( nSonBeforeAfter) + ")" +
-                    " -- Id=" + ToString( nNewId) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-  // restituisco risultato
-   return nNewId ;
-}
-
-//-----------------------------------------------------------------------------
-bool
-ExeDuplicateGeomDB( int nSouCtx, int nDestCtx, bool bSkipTemp)
-{
-  // recupero i due GeomDB
-   IGeomDB* pSouGeomDB = GetGeomDB( nSouCtx) ;
-   VERIFY_GEOMDB( pSouGeomDB, GDB_ID_NULL)
-   IGeomDB* pDstGeomDB = GetGeomDB( nDestCtx) ;
-   VERIFY_GEOMDB( pDstGeomDB, GDB_ID_NULL)
-  // eseguo la duplicazione del primo GeomDB nel secondo
-   bool bOk = DuplicateGeomDB( pSouGeomDB, pDstGeomDB, bSkipTemp) ;
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtDuplicateGeomDB(" + ToString( nSouCtx) + "," +
-                                            ToString( nDestCtx) + "," +
-                                            ( bSkipTemp ? "true" : "false") + ")" +
-                    " -- Ok=" + ToString( bOk) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-  // restituisco risultato
-   return bOk ;
-}
-
 //-----------------------------------------------------------------------------
 bool
 ExeRelocate( int nSouId, int nRefId, int nSonBeforeAfter)
 {
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
-   nRefId = AdjustId( nRefId) ;
  // eseguo la rilocazione
   bool bOk = pGeomDB->Relocate( nSouId, nRefId, nSonBeforeAfter) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
-      string sLua = "EgtRelocate(" + ToString( nSouId) + "," +
-                                     IdToString( nRefId) + "," +
-                                     InsToString( nSonBeforeAfter) + ")" +
-                    " -- Ok=" + ToString( bOk) ;
+      string sLua ;
+      if ( nSonBeforeAfter == GDB_LAST_SON)
+         sLua = "EgtRelocate(" + ToString( nSouId) + "," +
+                                 ToString( nRefId) + ")" +
+                " -- Ok=" + ToString( bOk) ;
+      else
+         sLua = "EgtRelocate(" + ToString( nSouId) + "," +
+                                 ToString( nRefId) + "," +
+                                 InsToString( nSonBeforeAfter) + ")" +
+                " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
@@ -444,16 +339,21 @@ ExeRelocateGlob( int nSouId, int nRefId, int nSonBeforeAfter)
 {
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
-   nRefId = AdjustId( nRefId) ;
  // eseguo la rilocazione mantenendo la posizione in globale
   bool bOk = pGeomDB->RelocateGlob( nSouId, nRefId, nSonBeforeAfter) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
-      string sLua = "EgtRelocateGlob(" + ToString( nSouId) + "," +
-                                         IdToString( nRefId) + "," +
-                                         InsToString( nSonBeforeAfter) + ")" +
-                    " -- Ok=" + ToString( bOk) ;
+      string sLua ;
+      if ( nSonBeforeAfter == GDB_LAST_SON)
+         sLua = "EgtRelocateGlob(" + ToString( nSouId) + "," +
+                                     ToString( nRefId) + ")" +
+                " -- Ok=" + ToString( bOk) ;
+      else
+         sLua = "EgtRelocateGlob(" + ToString( nSouId) + "," +
+                                     ToString( nRefId) + "," +
+                                     InsToString( nSonBeforeAfter) + ")" +
+                " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
@@ -344,26 +344,6 @@ ExeGetPrevLayer( int nId, bool bOnlyVisible)
   return ExeVerifyOrPrev( pGeomDB, nLayerId, bOnlyVisible) ;
 }

-//-------------------------------------------------------------------------------
-bool
-ExeIsGhostPart( int nGhostId)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-  // verifico sia il segnaposto di un pezzo (Ghost)
-   if ( pGeomDB->GetGdbType( nGhostId) == GDB_TY_GROUP  &&
-        pGeomDB->GetParentId( nGhostId) == GDB_ID_ROOT  &&
-        ExeIsSystemObj( pGeomDB, nGhostId)  &&
-        pGeomDB->ExistsInfo( nGhostId, GDB_SI_SOURCE)) {
-      int nPartId = GDB_ID_NULL ;
-      pGeomDB->GetInfo( nGhostId, GDB_SI_SOURCE, nPartId) ;
-      int nRawId = pGeomDB->GetParentId( nPartId) ;
-      if ( ExeIsRawPart( nRawId))
-         return true ;
-   }
-   return false ;  
-}
-
 //-------------------------------------------------------------------------------
 int
 ExeGetFirstGhostPart( void)
@@ -697,32 +677,6 @@ IsPartForDuplo( IGeomDB* pGeomDB, int nPartId)
   return false ;
 }

-//-----------------------------------------------------------------------------
-static bool
-IsDuplo( IGeomDB* pGeomDB, int nDupId, bool& bInDuploGroup)
-{
-  // verifica collegamento a DB geometrico
-   if ( pGeomDB == nullptr)
-      return false ;
-  // Recupero il gruppo base dei duplicati
-   int nDuploBaseId = GetDuploBase( pGeomDB) ;
-   if ( nDuploBaseId == GDB_ID_NULL)
-      return false ;
-  // Verifico sia un duplicato (gruppo sotto quello dei duplicati con riferimento a originale)
-   int nBaseId ;
-   if ( pGeomDB->GetGdbType( nDupId) == GDB_TY_GROUP  &&  pGeomDB->ExistsInfo( nDupId, GDB_SI_DUPSOU)) {
-      if ( pGeomDB->GetParentId( nDupId) == nDuploBaseId) {
-         bInDuploGroup = true ;
-         return true ;
-      }
-      else if ( pGeomDB->GetInfo( nDupId, GDB_SI_BASE, nBaseId)  &&  pGeomDB->GetParentId( nBaseId) == nDuploBaseId) {
-         bInDuploGroup = false ;
-         return true ;
-      }
-   }
-   return false ;  
-}
-
 //-----------------------------------------------------------------------------
 int
 ExeDuploNew( int nSouId)
@@ -775,8 +729,7 @@ ExeDuploCount( int nSouId, int& nCount)
  // Conto i reali duplo
   nCount = 0 ;
   for ( int i = 0 ; i < int( vnRef.size()) ; ++ i) {
-      bool bInDuploGroup ;
-      if ( IsDuplo( pGeomDB, vnRef[i], bInDuploGroup))
+      if ( ExeIsDuplo( vnRef[i]))
         ++ nCount ;
   }
   return true ;
@@ -801,105 +754,6 @@ ExeDuploList( int nSouId, INTVECTOR& vnRef)
   return true ;
 }

-//-----------------------------------------------------------------------------
-bool
-ExeDuploInRawCount( int nSouId, int& nCount)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-  // Verifico sia un pezzo
-   if ( ! IsPartForDuplo( pGeomDB, nSouId))
-      return false ;
-  // Recupero info del sorgente
-   INTVECTOR vnRef ;
-   pGeomDB->GetInfo( nSouId, GDB_SI_DUPLIST, vnRef) ;
-  // Conto i reali duplo che sono riferiti o che stanno in un grezzo
-   nCount = 0 ;
-   for ( int i = 0 ; i < int( vnRef.size()) ; ++ i) {
-     // verifico sia un duplo
-      int nDupId = vnRef[i] ;
-      bool bInDuploGroup ;
-      if ( ! IsDuplo( pGeomDB, nDupId, bInDuploGroup))
-         continue ;
-     // se nel gruppo dei duplo
-      if ( bInDuploGroup) {
-        // verifico sia incluso in un grezzo di un gruppo di lavoro
-         INTVECTOR vnRef ;
-         if ( ! pGeomDB->GetInfo( nDupId, GDB_SI_LIST, vnRef))
-            continue ;
-         for ( auto& nId : vnRef) {
-           // verifico esista 
-            if ( ! pGeomDB->ExistsObj( nId))
-               continue ;
-           // verifico sia in un grezzo (previsto solo in uno come massimo)
-            int nMachGrpId = pGeomDB->GetParentId( pGeomDB->GetParentId( pGeomDB->GetParentId( nId))) ;
-            string sMachGrpName ;
-            if ( ExeGetMachGroupName( nMachGrpId, sMachGrpName)) {
-               ++ nCount ;
-               break ;
-            }
-         }
-      }
-     // se in altro gruppo
-      else {
-        // verifico se incluso nel grezzo del gruppo di lavoro corrente (previsto solo in un gruppo)
-         if ( ExeIsRawPart( pGeomDB->GetParentId( nDupId)))
-            ++ nCount ;
-      }
-   }
-   return true ;
-}
-
-//-----------------------------------------------------------------------------
-bool
-ExeDuploWithoutRawList( INTVECTOR& vnDup)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-  // Reset del risultato
-   vnDup.clear() ;
-  // Recupero gruppo dei duplo
-   int nDuploBaseId = GetDuploBase( pGeomDB) ;
-   if ( nDuploBaseId == GDB_ID_NULL)
-      return true ;
-  // Ciclo sui duplo
-   for ( int nDuploId = pGeomDB->GetFirstGroupInGroup( nDuploBaseId) ;
-         nDuploId != GDB_ID_NULL ;
-         nDuploId = pGeomDB->GetNextGroup( nDuploId)) {
-     // se marcatore
-      if ( pGeomDB->ExistsInfo( nDuploId, GDB_SI_SOURCE)) {
-         int nPartId = GDB_ID_NULL ;
-         pGeomDB->GetInfo( nDuploId, GDB_SI_SOURCE, nPartId) ;
-         int nMachGrpId = pGeomDB->GetParentId( pGeomDB->GetParentId( pGeomDB->GetParentId( nPartId))) ;
-         string sMachGrpName ;
-         if ( pGeomDB->ExistsInfo( nPartId, GDB_SI_DUPSOU)  &&  ExeGetMachGroupName( nMachGrpId, sMachGrpName))
-            continue ;
-      }
-     // se vero duplo
-      else if ( pGeomDB->ExistsInfo( nDuploId, GDB_SI_DUPSOU)  &&  pGeomDB->ExistsInfo( nDuploId, GDB_SI_LIST)) {
-        // verifico sia incluso in un grezzo di un gruppo di lavoro
-         bool bFound = false ;
-         INTVECTOR vnRef ;
-         pGeomDB->GetInfo( nDuploId, GDB_SI_LIST, vnRef) ;
-         for ( auto& nId : vnRef) {
-           // verifico sia in un grezzo (previsto solo in uno come massimo)
-            int nMachGrpId = pGeomDB->GetParentId( pGeomDB->GetParentId( pGeomDB->GetParentId( nId))) ;
-            string sMachGrpName ;
-            if ( ExeGetMachGroupName( nMachGrpId, sMachGrpName)) {
-               bFound = true ;
-               break ;
-            }
-         }
-         if ( bFound)
-            continue ;
-      }
-     // inserisco nella lista dei duplo senza grezzo
-      vnDup.emplace_back( nDuploId) ;
-   }
- 
-   return true ;
-}
-
 //-----------------------------------------------------------------------------
 bool
 ExeDuploSetModified( int nSouId)
@@ -1101,9 +955,19 @@ ExeIsDuplo( int nDupId)
 {
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
-  // Verifico sia un duplicato
-   bool bPartVsGhost ;
-   return IsDuplo( pGeomDB, nDupId, bPartVsGhost) ;
+  // Recupero il gruppo base dei duplicati
+   int nDuploBaseId = GetDuploBase( pGeomDB) ;
+   if ( nDuploBaseId == GDB_ID_NULL)
+      return false ;
+  // Verifico sia un duplicato (gruppo sotto quello dei duplicati con riferimento a originale)
+   int nBaseId ;
+   if ( pGeomDB->GetGdbType( nDupId) == GDB_TY_GROUP  &&
+        ( pGeomDB->GetParentId( nDupId) == nDuploBaseId  ||
+          ( pGeomDB->GetInfo( nDupId, GDB_SI_BASE, nBaseId)  &&  pGeomDB->GetParentId( nBaseId) == nDuploBaseId))  &&
+        pGeomDB->ExistsInfo( nDupId, GDB_SI_DUPSOU))
+      return true ;
+   else
+      return false ;  
 }

 //-----------------------------------------------------------------------------
@@ -1,14 +1,13 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2014-2023
+//  EgalTech 2014-2015
 //----------------------------------------------------------------------------
-// File : EXE_General.cpp       Data : 14.11.23        Versione : 2.5k2
+// File : EXE_General.cpp       Data : 01.09.14        Versione : 1.5i1
 // Contenuto : Funzioni generali per EXE.
 //
 //
 //
 // Modifiche : 01.09.14 DS Creazione modulo.
-//             28.11.19 DS Aggiunto caricamento opzionale di Nesting.
-//             14.11.23 DS Aggiunto caricamento opzionale di Exchange 3dm.
+//             28.11.19 DS Aggiunto caricamento opzionale del Nesting.
 //
 //----------------------------------------------------------------------------

@@ -18,7 +17,6 @@
 #include "LUA_Base.h"
 #include "DllGraphics.h"
 #include "DllExchange.h"
-#include "DllExch3dm.h"
 #include "DllMachKernel.h"
 #include "DllNesting.h"
 #include "/EgtDev/Include/EXeExecutor.h"
@@ -35,7 +33,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>
@@ -53,15 +50,13 @@ static string  s_sKey ;
 static int     s_nKeyType = KEY_LOCK_TYPE_ANY ;
 static bool    s_bNetHwKey = false ;
 static int     s_nKeyExpDays = 0 ;
-static int     s_nKeyAssExpDays = 0 ;
 static int     s_nKeyOptExpDays = 0 ;
 static string  s_sNestKey ;
 static string  s_sLockId ;
 static string  s_sIniFile ;
 static bool    s_bEnableUI = true ;
-static psfOnTerminateProcess s_pFunOnTerminateProcess = nullptr ;
-static psfProcEvents         s_pFunProcEvents = nullptr ;
-static psfOutText            s_pFunOutText = nullptr ;
+static pfProcEvents s_pFunProcEvents = nullptr ;
+static pfOutText    s_pFunOutText = nullptr ;
 static HWND    s_hMainWnd = nullptr ;
 static string  s_sTempDir ;

@@ -75,7 +70,6 @@ ExeInit( int nDebug, const string& sLogFile, const string& sLogMsg)
   if ( s_pGenLog != nullptr)
      delete s_pGenLog ;
  // cancello riferimenti a funzioni installate
-   s_pFunOnTerminateProcess = nullptr ;
   s_pFunProcEvents = nullptr ;
   s_pFunOutText = nullptr ;
   s_bEnableUI = true ;
@@ -118,9 +112,6 @@ 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 di lavorazione opzionale
   if ( LoadMachKernelDll( s_pGenLog, s_sKey, s_bNetHwKey))
      LOG_INFO( s_pGenLog, MyGetEMkVersion())
@@ -177,11 +168,9 @@ ExeExit( void)
  // libero le librerie opzionali
   FreeMachKernelDll() ;
   FreeExchangeDll() ;
-   FreeExch3dmDll() ;
   FreeGraphicsDll() ;

  // cancello riferimenti a funzioni installate
-   s_pFunOnTerminateProcess = nullptr ;
   s_pFunProcEvents = nullptr ;
   s_pFunOutText = nullptr ;
   s_bEnableUI = true ;
@@ -208,30 +197,6 @@ ExeExit( void)
   return true ;
 }

-//-----------------------------------------------------------------------------
-bool
-ExeSetOnTerminateProcess( psfOnTerminateProcess pFun)
-{
-   s_pFunOnTerminateProcess = pFun ;
-   return ( pFun != nullptr) ;
-}
-
-//-----------------------------------------------------------------------------
-bool
-ExeOnTerminateProcess( int nExitCode)
-{
-  // lancio eventuale callback
-   bool bTerminate = true ;
-   if ( s_pFunOnTerminateProcess != nullptr)
-      bTerminate = s_pFunOnTerminateProcess( nExitCode) ;
-
-  // se confermata chiusura, libero eventuale chiave di rete
-   if ( bTerminate  &&  s_bNetHwKey)
-      CloseNetHwKey() ;
-
-   return bTerminate ;
-}
-
 //-----------------------------------------------------------------------------
 int
 ExeGetDebugLevel( void)
@@ -313,12 +278,9 @@ ExeSetLockId( const string& sLockId)
      bOk = ( s_nKeyType != KEY_LOCK_TYPE_HW) ;
      break ;
   case KEY_LOCK_TYPE_HW :
-      {  string sAddrPort ;
-         GetLockIdStringNetData( sLockId, sAddrPort) ;
-         ExeSetNetHwKey( bNetKey, nUserId, sAddrPort) ;
-         bOk = true ;
-         break ;
-      }
+      ExeSetNetHwKey( bNetKey, nUserId) ;
+      bOk = true ;
+      break ;
   }
   if ( bOk)
      s_sLockId = sLockId ;
@@ -338,58 +300,19 @@ ExeGetLockId( void)

 //-----------------------------------------------------------------------------
 bool
-ExeSetNetHwKey( bool bNetHwKey, int nUserId, const string& sAddrPort)
+ExeSetNetHwKey( bool bNetHwKey, int nUserId)
 {
   s_bNetHwKey = bNetHwKey ;
   SetEGnNetHwKey( s_bNetHwKey) ;
-   return SetNetHwKey( s_bNetHwKey, nUserId, sAddrPort) ;
-}
-
-//-----------------------------------------------------------------------------
-bool
-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 ;
+   return SetNetHwKey( s_bNetHwKey, nUserId) ;
 }

 //-----------------------------------------------------------------------------
 bool
 ExeSetFont( const string& sNfeFontDir, const string& sDefaultFont)
 {
-  // se definito anche direttorio font Nfe, inizializzazione gestore font
-   if ( ! sNfeFontDir.empty())
-      InitFontManager( sNfeFontDir, sDefaultFont) ;
-  // altrimenti impostazione del solo font di default
-   else
-      SetDefaultFont( sDefaultFont) ;
+  // inizializzazioni gestore font Nfe
+   InitFontManager( sNfeFontDir, sDefaultFont) ;
   return true ;
 }

@@ -512,10 +435,6 @@ ExeGetVersionInfo( string& sVer, const char* szNewLine)
      sVer += szNewLine ;
      sVer += MyGetEExVersion() ;
   }
-   if ( IsLoadedExch3dmDll()) {
-      sVer += szNewLine ;
-      sVer += MyGetEE3Version() ;
-   }
   if ( IsLoadedMachKernelDll()) {
      sVer += szNewLine ;
      sVer += MyGetEMkVersion() ;
@@ -559,7 +478,7 @@ bool
 ExeGetKeyLevel( int nProd, int nVer, int nLev, int& nKLev)
 {
  // verifico la chiave e il livello
-   int nRet = GetKeyLevelEx( s_sKey, nProd, nVer, nLev, nKLev, s_nKeyExpDays, s_nKeyAssExpDays) ;
+   int nRet = GetKeyLevel( s_sKey, nProd, nVer, nLev, nKLev, s_nKeyExpDays) ;
   SetEGnKeyLevel( nRet, nKLev, s_nKeyExpDays) ;
   if ( nRet != KEY_OK) {
      string sErr = "Error on Key (EGKL/" + ToString( nRet) + ")" ;
@@ -567,6 +486,7 @@ ExeGetKeyLevel( int nProd, int nVer, int nLev, int& nKLev)
      nKLev = - nRet ;
      return false ;
   }
+
   return true ;
 }

@@ -590,6 +510,7 @@ ExeGetKeyOptions( int nProd, int nVer, int nLev, unsigned int& nOpt2)
      LOG_ERROR( s_pGenLog, sErr.c_str()) ;
      return true ;
   }
+
   return true ;
 }

@@ -603,16 +524,6 @@ ExeGetKeyLeftDays( int& nLeftDays)
   return true ;
 }

-//-----------------------------------------------------------------------------
-bool
-ExeGetKeyAssLeftDays( int& nAssLeftDays)
-{
-   if ( s_nKeyAssExpDays == 0)
-      return false ;
-   nAssLeftDays = s_nKeyAssExpDays - GetCurrDay() ;
-   return true ;
-}
-
 //-----------------------------------------------------------------------------
 bool
 ExeGetKeyOptLeftDays( int& nOptLeftDays)
@@ -689,7 +600,7 @@ ExeMessageBox( const string& sText, const string& sTitle, int nType)

 //-----------------------------------------------------------------------------
 bool
-ExeSetProcessEvents( psfProcEvents pFun)
+ExeSetProcessEvents( pfProcEvents pFun)
 {
   s_pFunProcEvents = pFun ;
   SetEGkProcessEvents( pFun) ;
@@ -708,7 +619,7 @@ ExeProcessEvents( int nProg, int nPause)

 //-----------------------------------------------------------------------------
 bool
-ExeSetOutText( psfOutText pFun)
+ExeSetOutText( pfOutText pFun)
 {
   s_pFunOutText = pFun ;
   return ( pFun != nullptr) ;
@@ -21,7 +21,6 @@
 #include "/EgtDev/Include/EXeExecutor.h"
 #include "/EgtDev/Include/EGkDistPointCurve.h"
 #include "/EgtDev/Include/EGkDistPointSurfTm.h"
-#include "/EgtDev/Include/EGkDistPointSurfBz.h"

 using namespace std ;

@@ -123,38 +122,3 @@ ExePointSurfTmDist( const Point3d& ptP, int nStmId, int nRefType,
   ptMin = GetPointInRef( pGeomDB, ptMinL, frStm, nRefType) ;
   return distPS.GetMinDistTriaIndex( *pnTria) ;
 }
-
-//----------------------------------------------------------------------------
-bool
-ExePointSurfBzDist( const Point3d& ptP, int nSbzId, int nRefType,
-                    double* pdDist, Point3d& ptMin, Vector3d& vtN)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-  // verifico il primo parametro di ritorno obbligatorio
-   if ( pdDist == nullptr)
-      return false ;
-  // recupero la superficie bezier
-   ISurfBezier* pSbz = GetSurfBezier( pGeomDB->GetGeoObj( nSbzId)) ;
-   if ( pSbz == nullptr)
-      return false ;
-  // recupero il suo riferimento globale
-   Frame3d frSbz ;
-   if ( ! pGeomDB->GetGlobFrame( nSbzId, frSbz))
-      return false ;
-  // porto il punto nel riferimento della superficie
-   Point3d ptPL = GetPointLocal( pGeomDB, ptP, nRefType, frSbz) ;
-  // recupero i risultati
-   DistPointSurfBz distPS( ptPL, *pSbz) ;
-   if ( ! distPS.GetDist( *pdDist))
-      return false ;
-   Point3d ptMinL ;
-   if ( ! distPS.GetMinDistPoint( ptMinL))
-      return false ;
-   ptMin = GetPointInRef( pGeomDB, ptMinL, frSbz, nRefType) ;
-   Vector3d vtNL ;
-   if ( ! distPS.GetNorm( vtNL))
-      return false ;
-   vtN = GetVectorInRef( pGeomDB, vtNL, frSbz, nRefType) ;
-   return true ;
-}
@@ -32,7 +32,7 @@ ExeStartPoint( int nId, int nRefId, Point3d& ptP)
 {
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
-  // se non è entità geometrica
+  // se non è entità geometrica
   const IGeoObj* pGObj ;
   if ( ( pGObj = pGeomDB->GetGeoObj( nId)) == nullptr)
      return false ;
@@ -85,19 +85,12 @@ ExeEndPoint( int nId, int nRefId, Point3d& ptP)
 {
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
-  // se non è entità geometrica
+  // se non è entità geometrica
   const IGeoObj* pGObj ;
   if ( ( pGObj = pGeomDB->GetGeoObj( nId)) == nullptr)
      return false ;
-  // se punto
-   if ( pGObj->GetType() == GEO_PNT3D) {
-      // recupero il geo-punto 
-      const IGeoPoint3d* pGP = GetGeoPoint3d( pGObj) ;
-     // assegno il punto
-      ptP = pGP->GetPoint() ;
-   }
  // se vettore
-   else if ( pGObj->GetType() == GEO_VECT3D) {
+   if ( pGObj->GetType() == GEO_VECT3D) {
      // recupero il geo-vettore 
      const IGeoVector3d* pGV = GetGeoVector3d( pGObj) ;
     // assegno il punto
@@ -129,7 +122,7 @@ ExeMidPoint( int nId, int nRefId, Point3d& ptP)
 {
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
-  // se non è entità geometrica
+  // se non è entità geometrica
   const IGeoObj* pGObj ;
   if ( ( pGObj = pGeomDB->GetGeoObj( nId)) == nullptr)
      return false ;
@@ -161,7 +154,7 @@ ExeCenterPoint( int nId, int nRefId, Point3d& ptP)
 {
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
-  // se non è entità geometrica
+  // se non è entità geometrica
   const IGeoObj* pGObj ;
   if ( ( pGObj = pGeomDB->GetGeoObj( nId)) == nullptr)
      return false ;
@@ -201,7 +194,7 @@ ExeCentroid( int nId, int nRefId, Point3d& ptP)
 {
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
-  // se non è entità geometrica
+  // se non è entità geometrica
   const IGeoObj* pGObj ;
   if ( ( pGObj = pGeomDB->GetGeoObj( nId)) == nullptr)
      return false ;
@@ -241,7 +234,7 @@ ExeAtParamPoint( int nId, double dU, int nRefId, Point3d& ptP)
 {
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
-  // se non è entità geometrica
+  // se non è entità geometrica
   const IGeoObj* pGObj ;
   if ( ( pGObj = pGeomDB->GetGeoObj( nId)) == nullptr)
      return false ;
@@ -264,11 +257,11 @@ ExeNearPoint( int nId, const Point3d& ptNear, int nRefId, Point3d& ptP)
 {
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
-  // se non è entità geometrica
+  // se non è entità geometrica
   const IGeoObj* pGObj = pGeomDB->GetGeoObj( nId) ;
   if ( pGObj == 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 ;
@@ -276,7 +269,7 @@ ExeNearPoint( int nId, const Point3d& ptNear, int nRefId, Point3d& ptP)
   if ( ( pGObj->GetType() & GEO_CURVE) != 0) {
     // recupero la curva
      const ICurve* pCrv = GetCurve( pGObj) ;
-     // calcolo il punto della curva più vicino al punto di riferimento
+     // calcolo il punto della curva più vicino al punto di riferimento
      DistPointCurve dstPC( ptNearL, *pCrv) ;
      int nFlag ;
      if ( ! dstPC.GetMinDistPoint( 0, ptP, nFlag))
@@ -297,7 +290,7 @@ ExeIntersectionPoint( int nId1, int nId2, const Point3d& ptNear, int nRefId, Poi

  // se auto-intersezione
   if ( nId1 == nId2) {
-     // deve essere entità geometriche
+     // deve essere entità geometriche
      const IGeoObj* pGObj1 ;
      if ( ( pGObj1 = pGeomDB->GetGeoObj( nId1)) == nullptr)
         return false ;
@@ -305,11 +298,11 @@ ExeIntersectionPoint( int nId1, int nId2, const Point3d& ptNear, int nRefId, Poi
      if ( ( pGObj1->GetType() & GEO_CURVE) != 0) {
        // recupero la curva
         const ICurve* pCrv1 = GetCurve( pGObj1) ;
-        // porto il punto Near nel riferimento dell'entità
+        // porto il punto Near nel riferimento dell'entità
         Point3d ptNearL = ptNear ;
         if ( ! InvTransformPoint( pGeomDB, nId1, nRefId, ptNearL))
            return false ;
-        // calcolo il punto di auto-intersezione sulla curva più vicino al punto di riferimento
+        // calcolo il punto di auto-intersezione sulla curva più vicino al punto di riferimento
         SelfIntersCurve sintC( *pCrv1) ;
         if ( ! sintC.GetIntersPointNearTo( ptNearL, ptP))
            return false ;
@@ -320,7 +313,7 @@ ExeIntersectionPoint( int nId1, int nId2, const Point3d& ptNear, int nRefId, Poi
      return TransformPoint( pGeomDB, nId1, nRefId, ptP) ;
   }

-  // devono essere entità geometriche
+  // devono essere entità geometriche
   const IGeoObj* pGObj1 ;
   if ( ( pGObj1 = pGeomDB->GetGeoObj( nId1)) == nullptr)
      return false ;
@@ -339,7 +332,7 @@ ExeIntersectionPoint( int nId1, int nId2, const Point3d& ptNear, int nRefId, Poi
      Frame3d frEnt2 ;
      if ( ! pGeomDB->GetGlobFrame( nId2, frEnt2))
         return false ;
-     // se il riferimento della seconda curva è diverso da quello della prima entità, devo trasformarla
+     // se il riferimento della seconda curva è diverso da quello della prima entità, devo trasformarla
      PtrOwner<ICurve> pcrvTrans ;
      if ( ! AreSameFrame( frEnt1, frEnt2)) {
         pcrvTrans.Set( pCrv2->Clone()) ;
@@ -348,11 +341,11 @@ ExeIntersectionPoint( int nId1, int nId2, const Point3d& ptNear, int nRefId, Poi
         pcrvTrans->LocToLoc( frEnt2, frEnt1) ;
         pCrv2 = pcrvTrans ;
      }
-     // porto il punto Near nel riferimento della prima entità
+     // porto il punto Near nel riferimento della prima entità
      Point3d ptNearL = ptNear ;
      if ( ! InvTransformPoint( pGeomDB, nId1, nRefId, ptNearL))
         return false ;
-     // calcolo il punto di intersezione sulla prima curva più vicino al punto di riferimento
+     // calcolo il punto di intersezione sulla prima curva più vicino al punto di riferimento
      IntersCurveCurve intCC( *pCrv1, *pCrv2, true) ;
      if ( ! intCC.GetIntersPointNearTo( 0, ptNearL, ptP))
         return false ;
@@ -369,7 +362,7 @@ ExeStartVector( int nId, int nRefId, Vector3d& vtV)
 {
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
-  // se non è entità geometrica
+  // se non è entità geometrica
   const IGeoObj* pGObj = pGeomDB->GetGeoObj( nId) ;
   if ( pGObj == nullptr)
      return false ;
@@ -407,7 +400,7 @@ ExeEndVector( int nId, int nRefId, Vector3d& vtV)
 {
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
-  // se non è entità geometrica
+  // se non è entità geometrica
   const IGeoObj* pGObj = pGeomDB->GetGeoObj( nId) ;
   if ( pGObj == nullptr)
      return false ;
@@ -431,7 +424,7 @@ ExeMidVector( int nId, int nRefId, Vector3d& vtV)
 {
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
-  // se non è entità geometrica
+  // se non è entità geometrica
   const IGeoObj* pGObj ;
   if ( ( pGObj = pGeomDB->GetGeoObj( nId)) == nullptr)
      return false ;
@@ -455,7 +448,7 @@ ExeAtParamVector( int nId, double dU, int nSide, int nRefId, Vector3d& vtV)
 {
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
-  // se non è entità geometrica
+  // se non è entità geometrica
   const IGeoObj* pGObj ;
   if ( ( pGObj = pGeomDB->GetGeoObj( nId)) == nullptr)
      return false ;
@@ -226,18 +226,6 @@ ExeSetModified( void)
   return true ;
 }

-//-----------------------------------------------------------------------------
-bool
-ExeSetModified( int nCtx)
-{
-   GseContext* pGseCtx = GetGseContext( nCtx) ;
-   VERIFY_CTX_GEOMDB( pGseCtx, false)
-  // se consentito, imposto il flag
-   if ( pGseCtx->m_bEnableModified)
-      pGseCtx->m_bModified = true ;
-   return true ;
-}
-
 //-----------------------------------------------------------------------------
 bool
 ExeResetModified( void)
@@ -289,8 +277,6 @@ ExeNewFile( void)
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
-  // scrivo il log
-   LOG_INFO( GetLogger(), "New File") ;
  // restituisco il risultato
   return bOk ;
 }
@@ -330,11 +316,6 @@ ExeOpenFile( const string& sFilePath)
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
-  // scrivo il log
-   {
-      string sLog = "Open File " + sFilePath ;
-      LOG_INFO( GetLogger(), sLog.c_str()) ;
-   }
  // restituisco il risultato
   return bOk ;
 }
@@ -399,7 +380,7 @@ ExeInsertFile( const string& sFilePath)
 class CamStatus
 {
   public :
-      CamStatus( void) : m_nCurrMachGroup( GDB_ID_NULL), m_nCurrPhase( 0), m_nCurrMachining( GDB_ID_NULL) {
+      CamStatus( void) : m_nCurrMachGroup( GDB_ID_NULL), m_nCurrPhase( 0) {
         IMachMgr* pMachMgr = GetCurrMachMgr() ;
         if ( pMachMgr == nullptr)
            return ;
@@ -417,19 +398,14 @@ class CamStatus
            m_vIdStat.push_back( ( bShow ? nId : - nId)) ;
            nId = pMachMgr->GetNextOperation( nId) ;
         }
-         pMachMgr->ResetCurrMachGroup() ;
-      }
-      ~CamStatus( void) {
-         Restore() ;
      }
      void Restore( void) {
-         if ( m_nCurrMachGroup == GDB_ID_NULL)
-            return ;
         IMachMgr* pMachMgr = GetCurrMachMgr() ;
         if ( pMachMgr == nullptr)
            return ;
+         if ( m_nCurrMachGroup == GDB_ID_NULL)
+            return ;
         pMachMgr->SetCurrMachGroup( m_nCurrMachGroup) ;
-         m_nCurrMachGroup = GDB_ID_NULL ;
         if ( m_nCurrPhase == 0)
            return ;
         pMachMgr->SetCurrPhase( m_nCurrPhase, true) ;
@@ -454,6 +430,7 @@ ExeSaveFile( const string& sFilePath, int nFlag)
   VERIFY_CTX_GEOMDB( pGseCtx, false)
  // se ero in CAM, esco dopo averne salvato lo stato
   CamStatus CurrCamStatus ;
+   ExeResetCurrMachGroup() ;
  // imposto path corrente del file 
   pGseCtx->m_sFilePath = sFilePath ;
  // salvo il file
@@ -470,71 +447,37 @@ ExeSaveFile( const string& sFilePath, int nFlag)
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
-  // scrivo il log
-   {
-      string sLog = "Saved File " + sFilePath ;
-      LOG_INFO( GetLogger(), sLog.c_str()) ;
-   }
  // restituisco il risultato
   return bOk ;
 }

-//-----------------------------------------------------------------------------
-static bool
-IsMachGroupOrWithin( int nId, const IGeomDB* pGeomDB, const IMachMgr* pMachMgr, int& nMachGroupId)
-{
-  // default non definito
-   nMachGroupId = GDB_ID_NULL ;
-  // verifico validità puntatori
-   if ( pGeomDB == nullptr  ||  pMachMgr == nullptr)
-      return false ;
-  // eseguo ricerca
-   int nParentId = pGeomDB->GetParentId( nId) ;
-   int nPrevParId = nId ;
-   while ( nParentId != GDB_ID_NULL  &&  nParentId != GDB_ID_ROOT) {
-      if ( pMachMgr->IsMachBase( nParentId)) {
-         nMachGroupId = nPrevParId ;
-         return true ;
-      }
-      nPrevParId = nParentId ;
-      nParentId = pGeomDB->GetParentId( nParentId) ;
-   }
-   return false ;
-}
-
 //-----------------------------------------------------------------------------
 bool
-ExeSaveObjToFile( const INTVECTOR& vId, const string& sFilePath, int nFlag)
+ExeSaveObjToFile( int nId, const string& sFilePath, int nFlag)
 {
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
   IMachMgr* pMachMgr = GetCurrMachMgr() ;
-  // se uno degli oggetti è la base dei gruppi di lavoro, chiamo la funzione di salvataggio di tutto
-   for ( int nId : vId) {
-      if ( pMachMgr != nullptr  &&  pMachMgr->IsMachBase( nId))
-         return ExeSaveFile( sFilePath, nFlag) ;
-   }
-  // se uno degli oggetti è un gruppo di lavoro o una sua parte, chiamo la appropriata funzione di salvataggio
-   for ( int nId : vId) {
-      int nMachGroupId ;
-      if ( IsMachGroupOrWithin( nId, pGeomDB, pMachMgr, nMachGroupId)) {
-         INTVECTOR vOthId ;
-         vOthId.reserve( vId.size()) ;
-         for ( int nSouId : vId) {
-            if ( nSouId != nId)
-               vOthId.push_back( nSouId) ;
-         }
-         return ExeSaveMachGroupToFile( nMachGroupId, vOthId, sFilePath, nFlag) ;
-      }
+  // se l'oggetto è la base dei gruppi di lavoro, chiamo la funzione di salvataggio di tutto
+   if ( pMachMgr != nullptr  &&  pMachMgr->IsMachBase( nId))
+      return ExeSaveFile( sFilePath, nFlag) ;
+  // se l'oggetto è un gruppo di lavoro o una sua parte, chiamo la appropriata funzione di salvataggio
+   int nParentId = pGeomDB->GetParentId( nId) ;
+   int nPrevParId = nId ;
+   while ( pMachMgr != nullptr  &&  nParentId != GDB_ID_NULL  &&  nParentId != GDB_ID_ROOT) {
+      if ( pMachMgr->IsMachBase( nParentId))
+         return ExeSaveMachGroupToFile( nPrevParId, sFilePath, nFlag) ;
+      nPrevParId = nParentId ;
+      nParentId = pGeomDB->GetParentId( nParentId) ;
   }
  // se ero in CAM, non esco <---
  // copio l'oggetto nel file
-   bool bOk = pGeomDB->Save( vId, sFilePath, nFlag) ;
+   bool bOk = pGeomDB->Save( nId, sFilePath, nFlag) ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
-      string sLua = "EgtSaveObjToFile({" + ToString( vId) + "},'" +
-                                           StringToLuaString( sFilePath) + "'," +
-                                           NgeTypeToString( nFlag) + ")" +
+      string sLua = "EgtSaveObjToFile(" + ToString( nId) + ",'" +
+                                          StringToLuaString( sFilePath) + "'," +
+                                          NgeTypeToString( nFlag) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
@@ -544,7 +487,7 @@ ExeSaveObjToFile( const INTVECTOR& vId, const string& sFilePath, int nFlag)

 //-----------------------------------------------------------------------------
 bool
-ExeSaveMachGroupToFile( int nMGroupId, const INTVECTOR& vPlusId, const string& sFilePath, int nFlag)
+ExeSaveMachGroupToFile( int nMGroupId, const string& sFilePath, int nFlag)
 {
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
@@ -558,21 +501,12 @@ ExeSaveMachGroupToFile( int nMGroupId, const INTVECTOR& vPlusId, const string& s
      ExeDisableModified() ;
  // se ero in CAM, esco dopo averne salvato lo stato
   CamStatus CurrCamStatus ;
-  // verifico che gli oggetti Plus non siano gruppi di lavoro o una loro parte
-   bool bOk = true ;
-   for ( int nPlusId : vPlusId) {
-      int nMGrpPlusId ;
-      if ( IsMachGroupOrWithin( nPlusId, pGeomDB, pMachMgr, nMGrpPlusId)) {
-         bOk = false ;
-         break ;
-      }
-   }
+   ExeResetCurrMachGroup() ;
  // recupero eventuali pezzi e foto del gruppo di lavoro
   INTVECTOR vId ;
   int nPhotoId = GDB_ID_NULL ;
   string sPhotoOriPath = "" ;
-   bOk = bOk && pMachMgr->SetCurrMachGroup( nMGroupId) ;
-   if ( bOk) {
+   if ( pMachMgr->SetCurrMachGroup( nMGroupId)) {
     // aggiungo gruppo di lavoro
      vId.emplace_back( nMGroupId) ;
     // aggiungo pezzi
@@ -606,11 +540,8 @@ ExeSaveMachGroupToFile( int nMGroupId, const INTVECTOR& vPlusId, const string& s
     // disattivo gruppo di lavoro
      pMachMgr->ResetCurrMachGroup() ;
   }
-  // aggiungo gli oggetti plus
-   if ( bOk)
-      vId.insert( vId.end(), vPlusId.begin(), vPlusId.end()) ;
  // salvo gli oggetti appena identificati
-   bOk = bOk && pGeomDB->Save( vId, sFilePath, nFlag) ;
+   bool bOk = pGeomDB->Save( vId, sFilePath, nFlag) ;
  // eventuale ripristino dati fotografia
   if ( nPhotoId != GDB_ID_NULL)
      ExeChangePhotoPath( nPhotoId, sPhotoOriPath) ;
@@ -623,8 +554,7 @@ ExeSaveMachGroupToFile( int nMGroupId, const INTVECTOR& vPlusId, const string& s
   SetCmdLog( bPrevCmdLog) ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
-      string sLua = "EgtSaveMachGroupToFile(" + ToString( nMGroupId) + ",{" +
-                                                ToString( vPlusId) + "},'" +
+      string sLua = "EgtSaveMachGroupToFile(" + ToString( nMGroupId) + ",'" +
                                                StringToLuaString( sFilePath) + "'," +
                                                NgeTypeToString( nFlag) + ")" +
                    " -- Ok=" + ToString( bOk) ;
@@ -21,13 +21,10 @@
 #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/EgtIniFile.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"

 using namespace std ;
@@ -287,26 +284,6 @@ ExeRemoveMachGroup( int nMGroupId)
   return bOk ;
 }

-//-----------------------------------------------------------------------------
-bool
-ExeChangeMachGroupName( int nId, const string& sNewName)
-{
-   IMachMgr* pMachMgr = GetCurrMachMgr() ;
-   VERIFY_MACHMGR( pMachMgr, false)
-  // cambia il nome della macchinata
-   bool bOk = pMachMgr->ChangeMachGroupName( nId, sNewName) ;
-   ExeSetModified() ;
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtChangeMachGroupName(" + ToString( nId) + ",'" +
-                                                sNewName + "')" +
-                    " -- Ok=" + ToString( bOk) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-  // restituisco il risultato
-   return bOk ;
-}
-
 //-----------------------------------------------------------------------------
 bool
 ExeGetMachGroupName( int nId, string& sName)
@@ -334,8 +311,8 @@ int
 ExeGetMachGroupId( const string& sName)
 {
   IMachMgr* pMachMgr = GetCurrMachMgr() ;
-   VERIFY_MACHMGR( pMachMgr, GDB_ID_NULL)
-  // recupero l'identificativo della macchinata
+   VERIFY_MACHMGR( pMachMgr, false)
+  // recupero l'indice della macchinata
   return pMachMgr->GetMachGroupId( sName) ;
 }

@@ -396,16 +373,16 @@ ExeAddPhase( void)
   IMachMgr* pMachMgr = GetCurrMachMgr() ;
   VERIFY_MACHMGR( pMachMgr, 0)
  // aggiungo una nuova fase di lavorazione alla macchinata corrente
-   int nInd = pMachMgr->AddPhase() ;
+   int nId = pMachMgr->AddPhase() ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtAddPhase()"
-                    " -- Ind=" + ToString( nInd) ;
+                    " -- Id=" + ToString( nId) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco il risultato
-   return nInd ;
+   return nId ;
 }

 //-----------------------------------------------------------------------------
@@ -494,7 +471,7 @@ bool
 ExeIsRawPart( int nRawId)
 {
   IMachMgr* pMachMgr = GetCurrMachMgr() ;
-   VERIFY_MACHMGR( pMachMgr, false)
+   VERIFY_MACHMGR( pMachMgr, GDB_ID_NULL)
  // verifico se è un grezzo della macchinata corrente
   return pMachMgr->IsRawPart( nRawId) ;
 }
@@ -559,12 +536,12 @@ ExeModifyRawPart( int nRawId, Point3d ptOrig, double dLength, double dWidth, dou

 //-----------------------------------------------------------------------------
 bool
-ExeModifyRawPart( int nRawId, int nCrvId, double dOverMat, double dHeight, Color cCol)
+ExeModifyRawPart( int nRawId, int nCrvId, double dOverMat, double dZmin, double dHeight, Color cCol)
 {
   IMachMgr* pMachMgr = GetCurrMachMgr() ;
   VERIFY_MACHMGR( pMachMgr, false)
  // modifico grezzo indicato nella macchinata corrente
-   bool bOk = pMachMgr->ModifyRawPart( nRawId, nCrvId, dOverMat, dHeight, cCol) ;
+   bool bOk = pMachMgr->ModifyRawPart( nRawId, nCrvId, dOverMat, dZmin, dHeight, cCol) ;
   ExeSetModified() ;
  // restituisco il risultato
   return bOk ;
@@ -998,7 +975,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) ;
 }

@@ -1022,64 +999,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)
@@ -1091,10 +1010,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()) ;
   }
@@ -1197,33 +1116,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()) ;
   }
@@ -1237,7 +1136,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
@@ -1251,26 +1150,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
 //-----------------------------------------------------------------------------
@@ -1573,21 +1452,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)
@@ -1701,16 +1565,6 @@ ExeImportSetup( const string& sName)
   return pMachMgr->ImportSetup( sName) ;
 }

-//-----------------------------------------------------------------------------
-bool
-ExeExistsCurrSetup( void)
-{
-   IMachMgr* pMachMgr = GetCurrMachMgr() ;
-   VERIFY_MACHMGR( pMachMgr, false)
-  // eseguo la verifica
-   return pMachMgr->ExistsCurrSetup() ;
-}
-
 //-----------------------------------------------------------------------------
 bool
 ExeVerifyCurrSetup( STRVECTOR& vsErrors)
@@ -1731,16 +1585,6 @@ ExeFindToolInCurrSetup( const string& sTool)
   return pMachMgr->FindToolInCurrSetup( sTool) ;
 }

-//-----------------------------------------------------------------------------
-bool
-ExeGetToolSetupPosInCurrSetup( const string& sTool, string& sTcPos)
-{
-   IMachMgr* pMachMgr = GetCurrMachMgr() ;
-   VERIFY_MACHMGR( pMachMgr, false)
-  // eseguo la verifica
-   return pMachMgr->GetToolSetupPosInCurrSetup( sTool, sTcPos) ;
-}
-
 //-----------------------------------------------------------------------------
 bool
 ExeGetToolsInCurrSetupPos( const string& sTcPos, STRVECTOR& vsTools)
@@ -2116,42 +1960,42 @@ ExeGetPrevOperation( int nId)
 }
 //-----------------------------------------------------------------------------
 int
-ExeGetFirstActiveOperation( bool bNeedMachNotEmpty)
+ExeGetFirstActiveOperation( void)
 {
   IMachMgr* pMachMgr = GetCurrMachMgr() ;
   VERIFY_MACHMGR( pMachMgr, GDB_ID_NULL)
  // recupero la prima operazione attiva della macchinata corrente
-   return pMachMgr->GetFirstActiveOperation( bNeedMachNotEmpty) ;
+   return pMachMgr->GetFirstActiveOperation() ;
 }

 //-----------------------------------------------------------------------------
 int
-ExeGetNextActiveOperation( int nId, bool bNeedMachNotEmpty)
+ExeGetNextActiveOperation( int nId)
 {
   IMachMgr* pMachMgr = GetCurrMachMgr() ;
   VERIFY_MACHMGR( pMachMgr, GDB_ID_NULL)
  // recupero la successiva operazione attiva della macchinata corrente
-   return pMachMgr->GetNextActiveOperation( nId, bNeedMachNotEmpty) ;
+   return pMachMgr->GetNextActiveOperation( nId) ;
 }

 //-----------------------------------------------------------------------------
 int
-ExeGetLastActiveOperation( bool bNeedMachNotEmpty)
+ExeGetLastActiveOperation( void)
 {
   IMachMgr* pMachMgr = GetCurrMachMgr() ;
   VERIFY_MACHMGR( pMachMgr, false)
  // recupero l'ultima operazione attiva della macchinata corrente
-   return pMachMgr->GetLastActiveOperation( bNeedMachNotEmpty) ;
+   return pMachMgr->GetLastActiveOperation() ;
 }

 //-----------------------------------------------------------------------------
 int
-ExeGetPrevActiveOperation( int nId, bool bNeedMachNotEmpty)
+ExeGetPrevActiveOperation( int nId)
 {
   IMachMgr* pMachMgr = GetCurrMachMgr() ;
   VERIFY_MACHMGR( pMachMgr, GDB_ID_NULL)
  // recupero la precedente operazione attiva della macchinata corrente
-   return pMachMgr->GetPrevActiveOperation( nId, bNeedMachNotEmpty) ;
+   return pMachMgr->GetPrevActiveOperation( nId) ;
 }

 //-----------------------------------------------------------------------------
@@ -2216,12 +2060,12 @@ ExeGetOperationId( const string& sName)

 //-----------------------------------------------------------------------------
 bool
-ExeIsOperationEmpty( int nId, int nEmptyType)
+ExeIsOperationEmpty( int nId)
 {
   IMachMgr* pMachMgr = GetCurrMachMgr() ;
   VERIFY_MACHMGR( pMachMgr, false)
  // recupero lo stato dell'operazione indicata della macchinata corrente
-   return pMachMgr->IsOperationEmpty( nId, nEmptyType) ;
+   return pMachMgr->IsOperationEmpty( nId) ;
 }

 //-----------------------------------------------------------------------------
@@ -2477,16 +2321,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
 //-----------------------------------------------------------------------------
@@ -2748,16 +2582,6 @@ ExeUpdateMachining( bool bPostApply)
   return bOk ;
 }

-//-----------------------------------------------------------------------------
-bool
-ExeChangePreviewMachiningToolShow( int nLookFlag)
-{
-   IMachMgr* pMachMgr = GetCurrMachMgr() ;
-   VERIFY_MACHMGR( pMachMgr, false)
-  // impostazione tipo visualizzazione anteprima utensile su lavorazione
-   return pMachMgr->ChangePreviewMachiningToolShow( nLookFlag) ;
-}
-
 //-----------------------------------------------------------------------------
 bool
 ExePreparePreviewMachiningTool( void)
@@ -2780,22 +2604,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) ;
 }

 //-----------------------------------------------------------------------------
@@ -2850,22 +2664,12 @@ ExeGetMachiningGeometry( SELVECTOR& 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( int nEmptyType)
+ExeIsMachiningEmpty( void)
 {
   IMachMgr* pMachMgr = GetCurrMachMgr() ;
   VERIFY_MACHMGR( pMachMgr, false)
  // restituisco lo stato della lavorazione corrente
-   return pMachMgr->IsMachiningEmpty( nEmptyType) ;
+   return pMachMgr->IsMachiningEmpty() ;
 }

 //-----------------------------------------------------------------------------
@@ -2888,26 +2692,6 @@ ExeGetMachiningEndPoint( Point3d& ptEnd)
   return pMachMgr->GetMachiningEndPoint( ptEnd) ;
 }

-//-----------------------------------------------------------------------------
-bool
-ExeGetMachiningStartAxes( bool bSkipClimb, DBLVECTOR& vAxVal)
-{
-   IMachMgr* pMachMgr = GetCurrMachMgr() ;
-   VERIFY_MACHMGR( pMachMgr, false)
-  // restituisco quanto cercato
-   return pMachMgr->GetMachiningStartAxes( bSkipClimb, vAxVal) ;
-}
-
-//-----------------------------------------------------------------------------
-bool
-ExeGetMachiningEndAxes( bool bSkipRise, DBLVECTOR& vAxVal)
-{
-   IMachMgr* pMachMgr = GetCurrMachMgr() ;
-   VERIFY_MACHMGR( pMachMgr, false)
-  // restituisco quanto cercato
-   return pMachMgr->GetMachiningEndAxes( bSkipRise, vAxVal) ;
-}
-
 //-----------------------------------------------------------------------------
 bool
 ExeApplyAllMachinings( bool bRecalc, bool bStopOnFirstErr, string& sErrList)
@@ -3082,12 +2866,12 @@ ExeGetClEntMove( int nEntId, int& nMove)

 //-----------------------------------------------------------------------------
 bool
-ExeGetClEntFlag( int nEntId, int& nFlag, int& nFlag2)
+ExeGetClEntFlag( int nEntId, int& nFlag)
 {
   IMachMgr* pMachMgr = GetCurrMachMgr() ;
   VERIFY_MACHMGR( pMachMgr, false)
-  // recupero i flag
-   return pMachMgr->GetClEntFlag( nEntId, nFlag, nFlag2) ;
+  // recupero il flag
+   return pMachMgr->GetClEntFlag( nEntId, nFlag) ;
 }

 //-----------------------------------------------------------------------------
@@ -3100,76 +2884,6 @@ ExeGetClEntIndex( int nEntId, int& nIndex)
   return pMachMgr->GetClEntIndex( nEntId, nIndex) ;
 }

-//-----------------------------------------------------------------------------
-bool
-ExeGetClEntFeed( int nEntId, double& dFeed)
-{
-   IMachMgr* pMachMgr = GetCurrMachMgr() ;
-   VERIFY_MACHMGR( pMachMgr, false)
-  // recupero la feed
-   return pMachMgr->GetClEntFeed( nEntId, dFeed) ;
-}
-
-//-----------------------------------------------------------------------------
-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)
-   return pMachMgr->GetClEntAxesMask( nEntId, nMask) ;
-}
-
-//-----------------------------------------------------------------------------
-bool
-ExeGetClEntAxesVal( int nEntId, DBLVECTOR& vAxes)
-{
-   IMachMgr* pMachMgr = GetCurrMachMgr() ;
-   VERIFY_MACHMGR( pMachMgr, false)
-  // recupero il valore degli assi
-   return pMachMgr->GetClEntAxesVal( nEntId, vAxes) ;
-}
-
-//-----------------------------------------------------------------------------
-bool
-ExeGetClEntTDir( int nEntId, Vector3d& vTDir)
-{
-   IMachMgr* pMachMgr = GetCurrMachMgr() ;
-   VERIFY_MACHMGR( pMachMgr, false) ;
-  // recupero vTDir
-   return pMachMgr->GetClEntTDir( nEntId, vTDir) ;
-}
-
-//-----------------------------------------------------------------------------
-bool
-ExeGetClEntCDir( int nEntId, Vector3d& vtCDir)
-{
-   IMachMgr* pMachMgr = GetCurrMachMgr() ;
-   VERIFY_MACHMGR( pMachMgr, false) ;
-  // recupero CDir
-   return pMachMgr->GetClEntCDir( nEntId, vtCDir) ;
-}
-
-//-----------------------------------------------------------------------------
-bool
-ExeGetClEntADir( int nEntId, Vector3d& vADir)
-{
-   IMachMgr* pMachMgr = GetCurrMachMgr() ;
-   VERIFY_MACHMGR( pMachMgr, false) ;
-  // recupero ADir
-   return pMachMgr->GetClEntADir( nEntId, vADir) ;
-}
-
 //-----------------------------------------------------------------------------
 //    Simulazione
 //-----------------------------------------------------------------------------
@@ -3232,16 +2946,6 @@ ExeSimSetUiStatus( int nUiStatus)
   return pMachMgr->SimSetUiStatus( nUiStatus) ;
 }

-//-----------------------------------------------------------------------------
-bool
-ExeSimEnableToolTipTrace( bool bEnable)
-{
-   IMachMgr* pMachMgr = GetCurrMachMgr() ;
-   VERIFY_MACHMGR( pMachMgr, false)
-  // imposto abilitazione disegno traccia della punta utensile
-   return pMachMgr->SimEnableToolTipTrace( bEnable) ;
-}
-
 //-----------------------------------------------------------------------------
 bool
 ExeSimGetAxisInfoPos( int nI, string& sName, string& sToken, bool& bLinear, double& dVal)
@@ -3312,15 +3016,8 @@ ExeGenerate( const string& sCncFile, const string& sInfo)
      ReplaceString( sDir, "/", "\\") ;
     // recupero il nome
      string sNcName ;
-      if ( ExeGetInfo( ExeGetCurrMachGroup(), GDL_NC_NAME, sNcName))
-         sNcName = GetFileName( sNcName) ;
-      else {
-         string sCurrMachDir ; pMachMgr->GetCurrMachineDir( sCurrMachDir) ;
-         string sCurrMachName ; pMachMgr->GetCurrMachineName( sCurrMachName) ;
-         string sCurrMachIni = sCurrMachDir + "\\" + sCurrMachName + ".ini" ;
-         string sExt = GetPrivateProfileStringUtf8( "PartProgram", "Extension", ".cnc", sCurrMachIni.c_str()) ;
-         sNcName = ChangeFileExtension( GetFileName( sProjPath), sExt) ;
-      }
+      if ( ! ExeGetInfo( ExeGetCurrMachGroup(), GDL_NC_NAME, sNcName))
+         sNcName = GetFileTitleEgt( sProjPath) + ".cnc" ;
     // creo la path completa
      sMyCncFile = sDir + "\\" + sNcName ;
   }
@@ -3346,10 +3043,8 @@ ExeEstimate( const string& sEstFile, const string& sInfo)
      ReplaceString( sDir, "/", "\\") ;
     // recupero il nome
      string sEstName ;
-      if ( ExeGetInfo( ExeGetCurrMachGroup(), GDL_NC_NAME, sEstName))
-         sEstName = GetFileName( sEstName) ;
-      else
-         sEstName = GetFileName( sProjPath) ;
+      if ( ! ExeGetInfo( ExeGetCurrMachGroup(), GDL_NC_NAME, sEstName))
+         sEstName = GetFileTitleEgt( sProjPath) ;
      sEstName = ChangeFileExtension( sEstName, ".html") ;
     // creo la path completa
      sMyEstFile = sDir + "\\" + sEstName ;
@@ -3379,9 +3074,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
@@ -3443,8 +3136,7 @@ ExeSimulate( int& nErr, string& sError)
  // terminazione simulazione
   pMachMgr->SimExit() ;
  // riabilito UI
-   if ( bPrevEnableUI)
-      ExeSetEnableUI( true) ;
+   ExeSetEnableUI( true) ;
   return ( nErr == 0) ;
 }

@@ -3470,16 +3162,6 @@ ExeSetCalcTool( const string& sTool, const string& sHead, int nExit)
   return pMachMgr->SetCalcTool( sTool, sHead, nExit) ;
 }

-//----------------------------------------------------------------------------
-bool
-ExeSetCalcSolCh( int nScc, bool bExact)
-{
-   IMachMgr* pMachMgr = GetCurrMachMgr() ;
-   VERIFY_MACHMGR( pMachMgr, false)
-  // imposto il criterio di scelta della soluzione e se deve essere rispettato esattamente
-   return pMachMgr->SetCalcSolCh( nScc, bExact) ;
-}
-
 //----------------------------------------------------------------------------
 bool
 ExeSetRotAxisBlock( const string& sAxis, double dVal)
@@ -3490,16 +3172,6 @@ ExeSetRotAxisBlock( const string& sAxis, double dVal)
   return pMachMgr->SetRotAxisBlock( sAxis, dVal) ;
 }

-//-----------------------------------------------------------------------------
-bool
-ExeGetCalcTable( string& sTable)
-{
-   IMachMgr* pMachMgr = GetCurrMachMgr() ;
-   VERIFY_MACHMGR( pMachMgr, false)
-  // restituisco la tavola corrente per il calcolo sulla macchina della macchinata corrente
-   return pMachMgr->GetCalcTable( sTable) ;
-}
-
 //-----------------------------------------------------------------------------
 bool
 ExeGetCalcTool( string& sTool, string& sHead, int& nExit)
@@ -3510,26 +3182,6 @@ ExeGetCalcTool( string& sTool, string& sHead, int& nExit)
   return ( pMachMgr->GetCalcTool( sTool)  &&  pMachMgr->GetCalcHead( sHead)  &&  pMachMgr->GetCalcExit( nExit)) ;
 }

-//----------------------------------------------------------------------------
-bool
-ExeGetCalcSolCh( int& nScc, bool& bExact)
-{
-   IMachMgr* pMachMgr = GetCurrMachMgr() ;
-   VERIFY_MACHMGR( pMachMgr, false)
-  // recupero il criterio di scelta della soluzione e se deve essere rispettato esattamente
-   return pMachMgr->GetCalcSolCh( nScc, bExact) ;
-}
-
-//-----------------------------------------------------------------------------
-bool
-ExeGetAllCurrAxesNames( STRVECTOR& vAxName)
-{
-   IMachMgr* pMachMgr = GetCurrMachMgr() ;
-   VERIFY_MACHMGR( pMachMgr, false)
-  // recupero gli assi correnti derivanti dalla scelta di tavola e utensile
-   return pMachMgr->GetAllCurrAxesNames( vAxName) ;
-}
-
 //----------------------------------------------------------------------------
 bool
 ExeGetRotAxisBlocked( int nInd, string& sAxis, double& dVal)
@@ -3565,34 +3217,23 @@ ExeGetCalcAngles( const Vector3d& vtDirT, const Vector3d& vtDirA,
 //-----------------------------------------------------------------------------
 bool
 ExeGetCalcPositions( const Point3d& ptP, double dAngA, double dAngB,
-                     double& dX, double& dY, double& dZ)
+                     int& nStat, double& dX, double& dY, double& dZ)
 {
   IMachMgr* pMachMgr = GetCurrMachMgr() ;
   VERIFY_MACHMGR( pMachMgr, false)
  // calcolo gli assi lineari macchina dalla posizione e dagli assi rotanti
-   return pMachMgr->GetCalcPositions( ptP, dAngA, dAngB, dX, dY, dZ) ;
+   return pMachMgr->GetCalcPositions( ptP, dAngA, dAngB, nStat, dX, dY, dZ) ;
 }

 //-----------------------------------------------------------------------------
 bool
 ExeGetCalcPositions( const Point3d& ptP, const DBLVECTOR& vAng,
-                     double& dX, double& dY, double& dZ)
+                     int& nStat, double& dX, double& dY, double& dZ)
 {
   IMachMgr* pMachMgr = GetCurrMachMgr() ;
   VERIFY_MACHMGR( pMachMgr, false)
  // calcolo gli assi lineari macchina dalla posizione e dagli assi rotanti
-   return pMachMgr->GetCalcPositions( ptP, vAng, dX, dY, dZ) ;
-}
-
-//-----------------------------------------------------------------------------
-bool
-ExeGetRobotAngles( const Point3d& ptP, const Vector3d& vtDirT, const Vector3d& vtDirA,
-                   DBLVECTOR& vAng1, DBLVECTOR& vAng2)
-{
-   IMachMgr* pMachMgr = GetCurrMachMgr() ;
-   VERIFY_MACHMGR( pMachMgr, false)
-  // calcolo gli angoli macchina dalle direzioni fresa e ausiliaria passate
-   return pMachMgr->GetRobotAngles( ptP, vtDirT, vtDirA, vAng1, vAng2) ;
+   return pMachMgr->GetCalcPositions( ptP, vAng, nStat, dX, dY, dZ) ;
 }

 //-----------------------------------------------------------------------------
@@ -3647,16 +3288,6 @@ ExeVerifyOutstroke( double dX, double dY, double dZ, double dAngA, double dAngB,
   return pMachMgr->VerifyOutstroke( dX, dY, dZ, dAngA, dAngB, nStat) ;
 }

-//-----------------------------------------------------------------------------
-bool
-ExeVerifyOutstroke( double dX, double dY, double dZ, const DBLVECTOR& vAng, int& nStat)
-{
-   IMachMgr* pMachMgr = GetCurrMachMgr() ;
-   VERIFY_MACHMGR( pMachMgr, false)
-  // verifica l'extracorsa degli assi
-   return pMachMgr->VerifyOutstroke( dX, dY, dZ, vAng, true, nStat) ;
-}
-
 //-----------------------------------------------------------------------------
 bool
 ExeGetOutstrokeInfo( string& sInfo)
@@ -3720,16 +3351,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)
@@ -3760,16 +3381,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)
@@ -3800,16 +3411,6 @@ ExeGetAllTablesNames( STRVECTOR& vNames)
   return pMachMgr->GetAllTablesNames( vNames) ;
 }

-//-----------------------------------------------------------------------------
-bool
-ExeGetAllAxesNames( STRVECTOR& vNames)
-{
-   IMachMgr* pMachMgr = GetCurrMachMgr() ;
-   VERIFY_MACHMGR( pMachMgr, false)
-  // recupero l'elenco degli assi
-   return pMachMgr->GetAllAxesNames( vNames) ;
-}
-
 //-----------------------------------------------------------------------------
 bool
 ExeGetAllHeadsNames( STRVECTOR& vNames)
@@ -1,191 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2025-2025
-//----------------------------------------------------------------------------
-// File : EXE_MachOpt.cpp       Data : 02.04.2025      Versione : 2.7c1
-// Contenuto : Funzioni per Ottimizzare i tempi tra le lavorazioni.
-//
-//
-//
-// Modifiche : 02.04.25 RE Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-//--------------------------- Include ----------------------------------------
-#include "stdafx.h"
-#include "EXE.h"
-#include "EXE_Macro.h"
-#include "EXE_Const.h"
-#include "DllNesting.h"
-#include "/EgtDev/Include/EgtPointerOwner.h"
-#include "/EgtDev/Include/ENkMachOptimization.h"
-
-using namespace std ;
-
-//----------------------------------------------------------------------------
-//   Static LuaMgr per EgtExecutor
-//----------------------------------------------------------------------------
-static PtrOwner<IMachOptimization> s_pMO ;
-
-//----------------------------------------------------------------------------
-bool
-ExeOptMachInit( void)
-{
-  // Creo l'oggetto per il calcolo del percorso minimo (ShortestPath)
-   s_pMO.Set( CreateMachOptimization()) ;
-   return ( ! IsNull( s_pMO)) ;
-}
-
-//----------------------------------------------------------------------------
-bool
-ExeOptMachTerminate( void)
-{
-  // Distruggo l'oggetto
-   s_pMO.Reset() ;
-   return ( IsNull( s_pMO)) ;
-}
-
-//----------------------------------------------------------------------------
-bool
-ExeOptMachAddTool( int nId, double dTCX, double dTCY, double dTCZ, double dTCA,
-                   double dTCB, double dTCC, bool bX, bool bY, bool bZ, bool bA,
-                   bool bB, bool bC, double dTLoad, double dTUnL)
-{
-  // Se oggetto non instanziato, errore
-   if ( IsNull( s_pMO))
-      return false ;
-  // Inserisco il Record
-   return ( s_pMO->InsertTool( nId, dTCX, dTCY, dTCZ, dTCA, dTCB, dTCC, bX, bY, bZ, bA,
-                               bB, bC, dTLoad, dTUnL)) ;
-}
-
-//----------------------------------------------------------------------------
-bool
-ExeOptMachAddMachining( int nId, int nToolId, int nGroup,
-                        double dX_Start, double dY_Start, double dZ_Start,
-                        double dA_Start, double dB_Start, double dC_Start,
-                        double dX_End, double dY_End, double dZ_End,
-                        double dA_End, double dB_End, double dC_End)
-{
-  // Se oggetto non instanziato, errore
-   if ( IsNull( s_pMO))
-      return false ;
-  // Inserisco il Record
-   return ( s_pMO->InsertMachining( nId, nToolId, nGroup,
-                                    dX_Start, dY_Start, dZ_Start,
-                                    dA_Start, dB_Start, dC_Start,
-                                    dX_End, dY_End, dZ_End,
-                                    dA_End, dB_End, dC_End)) ;
-}
-
-//----------------------------------------------------------------------------
-bool
-ExeOptMachSetFirstMachining( int nId)
-{
-  // Se oggetto non instanziato, errore
-   if ( IsNull( s_pMO))
-      return false ;
-  // Imposto la prima lavorazione
-   return ( s_pMO->SetFirstMachining( nId)) ;
-}
-
-
-//----------------------------------------------------------------------------
-bool
-ExeOptMachSetLastMachining( int nId)
-{
-  // Se oggetto non instanziato, errore
-   if ( IsNull( s_pMO))
-      return false ;
-  // Imposto l'ultima lavorazione
-   return ( s_pMO->SetLastMachining( nId)) ;
-}
-
-//----------------------------------------------------------------------------
-bool
-ExeOptMachSetFeeds( double dFeedL, double dFeedA)
-{
-  // Se oggetto non instanziato, errore
-   if ( IsNull( s_pMO))
-      return false ;
-  // Imposto l'ultima lavorazione
-   return ( s_pMO->SetFeeds( dFeedL, dFeedA)) ;
-}
-
-//----------------------------------------------------------------------------
-bool
-ExeOptMachAddDependence( int nIdPrec, int nIdSucc)
-{
-  // Se oggetto non instanziato, errore
-   if ( IsNull( s_pMO))
-      return false ;
-  // Inserisco la Dipendenza obbligatoria
-   return ( s_pMO->InsertDependence( nIdPrec, nIdSucc)) ;
-}
-
-//----------------------------------------------------------------------------
-bool
-ExeOptMachAddSuggestedDependence( int nIdPrec, int nIdSucc)
-{
-  // Se oggetto non instanziato, errore
-   if ( IsNull( s_pMO))
-      return false ;
-  // Inserisco la Dipendenza obbligatoria
-   return ( s_pMO->InsertSuggestedDependences( nIdPrec, nIdSucc)) ;
-}
-
-//----------------------------------------------------------------------------
-bool
-ExeOptMachSetAllGroupDependencesAsMandatory( bool bAllMandatory)
-{
-  // Se oggetto non instanziato, errore
-   if ( IsNull( s_pMO))
-      return false ;
-  // Imposto il Flag
-   return ( s_pMO->SetAllGroupsAsMandatory( bAllMandatory)) ;
-}
-
-//----------------------------------------------------------------------------
-bool
-ExeOptMachSetOptimizationForGroups( bool bOptForGroups)
-{
-  // Se oggetto non istanziato, errore
-   if ( IsNull( s_pMO))
-      return false ;
-  // Imposto il Flag
-   return ( s_pMO->SetOptimizationForGroups( bOptForGroups)) ;
-}
-
-//----------------------------------------------------------------------------
-bool
-ExeOptMachSetOpenBound( bool bStartVsEnd, int nFlag, double dX, double dY, double dZ)
-{
-  // Se oggetto non istanziato, errore
-   if ( IsNull( s_pMO))
-      return false ;
-  // Imposto il Flag
-   return ( s_pMO->SetOpenBound( bStartVsEnd, nFlag, dX, dY, dZ)) ;
-}
-
-//----------------------------------------------------------------------------
-bool
-ExeOptMachSetOpenBoundForGroups( int nGroup, bool bStartVsEnd, int nFlag, double dX, double dY, double dZ)
-{
-  // Se oggetto non istanziato, errore
-   if ( IsNull( s_pMO))
-      return false ;
-  // Impsto il Flag
-   return ( s_pMO->SetOpenBoundForGroups( nGroup, bStartVsEnd, nFlag, dX, dY, dZ)) ;
-}
-
-//----------------------------------------------------------------------------
-bool
-ExeOptMachCalculate( INTVECTOR& vIds)
-{
-   vIds.clear() ;
-  // Se oggetto non instanziato, errore
-   if ( IsNull( s_pMO))
-      return false ;
-  // Recupero i risultati
-   return ( s_pMO->Calculate( vIds)) ;
-}
@@ -16,13 +16,13 @@
 class IGeomDB ;

 //----------------------------------------------------------------------------
-int       GetFlatPartRegion( IGeomDB* pGeomDB, int nId) ;
-int       GetFlatPartUpRegion( IGeomDB* pGeomDB, int nId) ;
-int       GetFlatPartDownRegion( IGeomDB* pGeomDB, int nId) ;
-bool      GetFlatPartCutRegions( IGeomDB* pGeomDB, int nId, bool bReduced, INTVECTOR& vCrId) ;
-bool      GetFlatPartDownCutRegions( IGeomDB* pGeomDB, int nId, bool bReduced, INTVECTOR& vCrId) ;
-bool      GetFlatPartInterpartGap(IGeomDB* pGeomDB, int nId, double& dGap);
-int       GetFlatPartFromRegion( IGeomDB* pGeomDB, int nId) ;
-int       GetFlatPartFromCut( IGeomDB* pGeomDB, int nId) ;
-INTVECTOR GetGeometryFromCut( IGeomDB* pGeomDB, IMachMgr* pMachMgr, int nId) ;
-bool      GetFlatPartApproxContour( IGeomDB* pGeomDB, int nId, PolyLine& PL) ;
+int  GetFlatPartRegion( IGeomDB* pGeomDB, int nId) ;
+int  GetFlatPartUpRegion( IGeomDB* pGeomDB, int nId) ;
+int  GetFlatPartDownRegion( IGeomDB* pGeomDB, int nId) ;
+bool GetFlatPartCutRegions( IGeomDB* pGeomDB, int nId, bool bReduced, INTVECTOR& vCrId) ;
+bool GetFlatPartDownCutRegions( IGeomDB* pGeomDB, int nId, bool bReduced, INTVECTOR& vCrId) ;
+bool GetFlatPartInterpartGap(IGeomDB* pGeomDB, int nId, double& dGap);
+int  GetFlatPartFromRegion( IGeomDB* pGeomDB, int nId) ;
+int  GetFlatPartFromCut( IGeomDB* pGeomDB, int nId) ;
+int  GetGeometryFromCut( IGeomDB* pGeomDB, IMachMgr* pMachMgr, int nId) ;
+bool GetFlatPartApproxContour( IGeomDB* pGeomDB, int nId, PolyLine& PL) ;
@@ -19,6 +19,7 @@
 #include "DllNesting.h"
 #include "/EgtDev/Include/EGkCurve.h"
 #include "/EgtDev/Include/EGkCurveComposite.h"
+#include "/EgtDev/Include/EGkOffsetCurve.h"
 #include "/EgtDev/Include/EGkSurfFlatRegion.h"
 #include "/EgtDev/Include/ENsAutoNester.h"
 #include "/EgtDev/Include/EGnStringUtils.h"
@@ -257,15 +258,6 @@ ExeAutoNestSetInterpartGap( double dGap)
   return s_pAutoNester->SetInterpartGap( dGap) ;
 }

-//-----------------------------------------------------------------------------
-bool
-ExeAutoNestSetShearGap( double dShearGap)
-{
-   if ( IsNull( s_pAutoNester))
-      return false ;
-   return s_pAutoNester->SetShearGap( dShearGap) ;
-}
-
 //-----------------------------------------------------------------------------
 bool
 ExeAutoNestSetReportFile( const string& sReportFile)
@@ -347,12 +339,3 @@ ExeAutoNestGetOneResult( int nInd, int& nType, int& nId, int& nFlag, double& dX,
   dAngRot = s_vANestInfo[nInd].dAngRot ;
   return true ;
 }
-
-//-----------------------------------------------------------------------------
-bool
-ExeAutoNestCalcShearSequence( int nNesting, PNTVECTOR& vPtStart, PNTVECTOR& vPtEnd)
-{
-   if ( IsNull( s_pAutoNester))
-      return false ;
-   return s_pAutoNester->CalcShearSequence( nNesting, vPtStart, vPtEnd) ;
-}
@@ -89,10 +89,6 @@ ApproxCurveIfNeeded( IGdbIterator* pEnt, double dToler)
   PolyArc PA ;
   double dTol = max( dToler, LIN_TOL_FINE) ;
   bool bOk = pCrv->ApproxWithArcsEx( dTol, ANG_TOL_STD_DEG, LIN_FEA_STD, PA) && pCC->FromPolyArc( PA) ;
-   // eliminazione di small Z
-   bOk = bOk && pCC->RemoveSmallDefects( 0.5 * dTol, ANG_TOL_STD_DEG) ;
-   // merge di archi identici di biarchi
-   bOk = bOk && pCC->MergeCurves( 0.5 * dTol, ANG_TOL_STD_DEG) ;
   bOk = bOk && pEnt->GetGDB()->ReplaceGeoObj( pEnt->GetId(), Release( pCC)) ;
   return bOk ;
 }
@@ -1617,50 +1613,6 @@ ExeCalcFlatPartUpRegion( int nPartId, bool bCalc)
   return true ;
 }

-//----------------------------------------------------------------------------
-static bool
-IgnoreOutlineFillet( IGeomDB* pGeomDB, int nCrvId, int nLayId)
-{
-  // verifico se la curva nCrvId è un raccordo che deve essere ignorato, ovvero se si tratta di un arco non inclinato, in tangenza 
-  // e consecutivo ad almeno un lato inclinato
-
-  // verifico se arco
-   if ( pGeomDB->GetGeoType( nCrvId) == CRV_ARC) {
-     // verifico se non inclinato
-      double dSideAng = 0, dSideAng2 = 0 ;
-      pGeomDB->GetInfo( nCrvId, NST_KEY_SIDEANG, dSideAng) ;
-      pGeomDB->GetInfo( nCrvId, NST_KEY_SIDEANG2, dSideAng2) ;
-      if ( abs( dSideAng) < EPS_ANG_SMALL && abs( dSideAng2) < EPS_ANG_SMALL) {
-        // verifico se in tangenza con curve consecutive
-         double dPrevAng = ANG_RIGHT, dNextAng = ANG_RIGHT ; 
-         pGeomDB->GetInfo( nCrvId, MCH_KEY_PREVANG, dPrevAng) ;             
-         pGeomDB->GetInfo( nCrvId, MCH_KEY_NEXTANG, dNextAng) ; 
-         if ( abs( dPrevAng) < EPS_ANG_SMALL  &&  abs( dNextAng) < EPS_ANG_SMALL) {
-           // verifico se è inclinata almeno una tra la curva precedente e quella successiva
-            int nPrevId = pGeomDB->GetPrev( nCrvId) ;
-            if ( nPrevId == GDB_ID_NULL)
-               nPrevId = pGeomDB->GetLastInGroup( nLayId) ;
-            if ( nPrevId == GDB_ID_NULL)
-               return false ;
-            double dSideAng, dSideAng2 ;
-            if ( ( pGeomDB->GetInfo( nPrevId, NST_KEY_SIDEANG, dSideAng)  &&  abs( dSideAng) > EPS_ANG_SMALL)  ||
-               ( pGeomDB->GetInfo( nPrevId, NST_KEY_SIDEANG2, dSideAng2)  &&  abs( dSideAng2) > EPS_ANG_SMALL))
-               return true ;
-
-            int nNextId = pGeomDB->GetNext( nCrvId) ;
-            if ( nNextId == GDB_ID_NULL)
-               nNextId = pGeomDB->GetFirstInGroup( nLayId) ;
-            if ( nNextId == GDB_ID_NULL)
-               return false ;
-            if ( ( pGeomDB->GetInfo( nNextId, NST_KEY_SIDEANG, dSideAng)  &&  abs( dSideAng) > EPS_ANG_SMALL)  ||
-               ( pGeomDB->GetInfo( nNextId, NST_KEY_SIDEANG2, dSideAng2)  &&  abs( dSideAng2) > EPS_ANG_SMALL))
-               return true ;
-         }
-      }
-   }
-   return false ;
-}
-
 //----------------------------------------------------------------------------
 static bool
 AdjustLayerForSideAngle( IGeomDB* pGeomDB, int nLayOrigId, const string& sLayOrig, int nLayReg, double dH)
@@ -1731,8 +1683,7 @@ AdjustLayerForSideAngle( IGeomDB* pGeomDB, int nLayOrigId, const string& sLayOri
         ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( nNewId)) ;
         if ( pCrv == nullptr)
            return false ;
-         if ( ! pCrv->SimpleOffset( dCalcOffset))
-            pGeomDB->Erase( nNewId) ;
+         pCrv->SimpleOffset( dCalcOffset) ;
      }
      else if ( pGeomDB->GetInfo( nCrvId, NST_KEY_SIDEANG2, dSideAng2)  &&  abs( dSideAng2) > EPS_ANG_SMALL) {
         double dOffset2 = 0 ;
@@ -1745,12 +1696,8 @@ AdjustLayerForSideAngle( IGeomDB* pGeomDB, int nLayOrigId, const string& sLayOri
         ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( nNewId)) ;
         if ( pCrv == nullptr)
            return false ;
-         if ( ! pCrv->SimpleOffset( dCalcOffset))
-            pGeomDB->Erase( nNewId) ;
+         pCrv->SimpleOffset( dCalcOffset) ;
      }
-     // verifico se raccordo da ignorare per poter calcolare la regione
-      else if ( IgnoreOutlineFillet( pGeomDB, nCrvId, nLayId))
-         pGeomDB->Erase( nNewId) ;            
   }
  // aggiusto tra loro le curve offsettate (allungandole e/o accorciandole)
   if ( ! AdjustLayerCurves( pGeomDB, nTmpLayId))
@@ -1773,7 +1720,7 @@ AdjustLayerForSideAngle( IGeomDB* pGeomDB, int nLayOrigId, const string& sLayOri
      if ( nNewId == GDB_ID_NULL)
         return false ;
     // determino ed eseguo offset
-      double dSideAng, dSideAng2 ;
+      double dSideAng ;
      if ( pGeomDB->GetInfo( nCrvId, NST_KEY_SIDEANG, dSideAng)  &&  abs( dSideAng) > EPS_ANG_SMALL) {
         double dOffset = 0 ;
         pGeomDB->GetInfo( nCrvId, NST_KEY_OFFSET, dOffset) ;
@@ -1781,22 +1728,8 @@ AdjustLayerForSideAngle( IGeomDB* pGeomDB, int nLayOrigId, const string& sLayOri
         ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( nNewId)) ;
         if ( pCrv == nullptr)
            return false ;
-         if ( ! pCrv->SimpleOffset( dCalcOffset))
-            pGeomDB->Erase( nNewId) ;
+         pCrv->SimpleOffset( dCalcOffset) ;
      }
-      else if ( pGeomDB->GetInfo( nCrvId, NST_KEY_SIDEANG2, dSideAng2)  &&  abs( dSideAng2) > EPS_ANG_SMALL) {
-         double dOffset2 = 0 ;
-         pGeomDB->GetInfo( nCrvId, NST_KEY_OFFSET2, dOffset2) ;
-         double dCalcOffset = dOffset2 ;
-         ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( nNewId)) ;
-         if ( pCrv == nullptr)
-            return false ;
-         if ( ! pCrv->SimpleOffset( dCalcOffset))
-            pGeomDB->Erase( nNewId) ;
-      }
-     // verifico se raccordo da ignorare per poter calcolare la regione
-      else if ( IgnoreOutlineFillet( pGeomDB, nCrvId, nLayId))
-         pGeomDB->Erase( nNewId) ;
   }
  // aggiusto tra loro le curve offsettate (allungandole e/o accorciandole)
   if ( ! AdjustLayerCurves( pGeomDB, nTmpLay2Id))
@@ -1836,13 +1769,10 @@ AdjustLayerForSideAngle( IGeomDB* pGeomDB, int nLayOrigId, const string& sLayOri
         //if ( dStartProD > EPS_SMALL)
         //   pCrv->ExtendStartByLen( dStartProD) ;
         double dStartProMin = min( dStartProD, dStartProU) ;
-         if ( dStartProMin < - EPS_SMALL) {
+         if ( dStartProMin < - EPS_SMALL)
            pCrv->TrimStartAtLen( - dStartProMin) ;
-            if ( abs( dStartProD - dStartProU) > EPS_SMALL)
-               pGeomDB->SetInfo( nCrvId, MCH_KEY_START_WHISKEXT, abs( dStartProD - dStartProU)) ;
-         }
-         else
-            pGeomDB->SetInfo( nCrvId, MCH_KEY_START_WHISKEXT, max( dStartProD, dStartProU)) ;        
+         if ( abs( dStartProD - dStartProU) > EPS_SMALL)
+            pGeomDB->SetInfo( nCrvId, MCH_KEY_START_WHISKEXT, abs( dStartProD - dStartProU)) ;
      }
      else {
         if ( dStartProD < - EPS_SMALL)
@@ -1869,11 +1799,9 @@ AdjustLayerForSideAngle( IGeomDB* pGeomDB, int nLayOrigId, const string& sLayOri
            double dLen ;
            pCrv->GetLength( dLen) ;
            pCrv->TrimEndAtLen( dLen + dEndProMin) ;
-            if ( abs( dEndProD - dEndProU) > EPS_SMALL)
-               pGeomDB->SetInfo( nCrvId, MCH_KEY_END_WHISKEXT, abs( dEndProD - dEndProU)) ;
         }
-         else
-            pGeomDB->SetInfo( nCrvId, MCH_KEY_END_WHISKEXT, max( dEndProD, dEndProU)) ;         
+         if ( abs( dEndProD - dEndProU) > EPS_SMALL)
+            pGeomDB->SetInfo( nCrvId, MCH_KEY_END_WHISKEXT, abs( dEndProD - dEndProU)) ;
      }
      else {
         if ( dEndProD < - EPS_SMALL) {
@@ -2184,25 +2112,24 @@ GetFlatPartFromCut( IGeomDB* pGeomDB, int nId)
 }

 //----------------------------------------------------------------------------
-INTVECTOR
+int
 GetGeometryFromCut( IGeomDB* pGeomDB, IMachMgr* pMachMgr, int nId)
 {
-   INTVECTOR vnIds ;
   if ( pGeomDB == nullptr  ||  pMachMgr == nullptr)
-      return vnIds ;
+      return GDB_ID_NULL ;
  // verifico appartenga ad una lavorazione
   int nMchId ;
   if ( ! pGeomDB->GetInfo( pGeomDB->GetParentId( pGeomDB->GetParentId( nId)), "MId", nMchId))
-      return vnIds ;
+      return GDB_ID_NULL ;
  // recupero la geometria di applicazione della lavorazione (deve essere una sola)
   if ( ! pMachMgr->SetCurrMachining( nMchId))
-      return vnIds ;
-   SELVECTOR vSelIds ;
-   pMachMgr->GetMachiningGeometry( vSelIds) ;
-   vnIds.reserve( vSelIds.size()) ;
-   for ( const SelData& mySelData : vSelIds)
-      vnIds.emplace_back( mySelData.nId) ;
-   return vnIds ;
+      return GDB_ID_NULL ;
+   SELVECTOR vIds ;
+   pMachMgr->GetMachiningGeometry( vIds) ;
+   if ( vIds.size() == 1)
+      return vIds[0].nId ;
+   else
+      return GDB_ID_NULL ;
 }

 //----------------------------------------------------------------------------
@@ -143,7 +143,7 @@ ExeVerifyMachining( int nMchId, int& nResult)
  // confronto la regione di attacco della lavorazione con le regioni degli altri pezzi
   for ( int nMchRegId : vMchLiReg) {
      for ( int nOthRegId : vOthReg) {
-         if ( ExeSurfFlatRegionInterference( nOthRegId, 0, nMchRegId, 0, VERIF_TOLER) != REGC_OUT)
+         if ( ExeSurfFrChunkSimpleClassify( nOthRegId, 0, nMchRegId, 0, VERIF_TOLER) != REGC_OUT)
            nResult |= FMI_LI ;
      }
   }
@@ -152,7 +152,7 @@ ExeVerifyMachining( int nMchId, int& nResult)
         if ( vMchDwnLiReg[i] != GDB_ID_NULL  ||  vOthDwnReg[j] != GDB_ID_NULL) {
            int nMchRegId = ( ( vMchDwnLiReg[i] != GDB_ID_NULL) ? vMchDwnLiReg[i] : vMchLiReg[i]) ;
            int nOthRegId = ( ( vOthDwnReg[j] != GDB_ID_NULL) ? vOthDwnReg[j] : vOthReg[j]) ;
-            if ( ExeSurfFlatRegionInterference( nOthRegId, 0, nMchRegId, 0, VERIF_TOLER) != REGC_OUT)
+            if ( ExeSurfFrChunkSimpleClassify( nOthRegId, 0, nMchRegId, 0, VERIF_TOLER) != REGC_OUT)
               nResult |= FMI_LI ;
         }
      }
@@ -160,7 +160,7 @@ ExeVerifyMachining( int nMchId, int& nResult)
  // confronto la regione ridotta della lavorazione con le regioni degli altri pezzi
   for ( int nMchRegId : vMchRReg) {
      for ( int nOthRegId : vOthReg) {
-         if ( ExeSurfFlatRegionInterference( nOthRegId, 0, nMchRegId, 0, VERIF_TOLER) != REGC_OUT)
+         if ( ExeSurfFrChunkSimpleClassify( nOthRegId, 0, nMchRegId, 0, VERIF_TOLER) != REGC_OUT)
            nResult |= FMI_RM ;
      }
   }
@@ -169,7 +169,7 @@ ExeVerifyMachining( int nMchId, int& nResult)
         if ( vMchDwnRReg[i] != GDB_ID_NULL  ||  vOthDwnReg[j] != GDB_ID_NULL) {
            int nMchRegId = ( ( vMchDwnRReg[i] != GDB_ID_NULL) ? vMchDwnRReg[i] : vMchRReg[i]) ;
            int nOthRegId = ( ( vOthDwnReg[j] != GDB_ID_NULL) ? vOthDwnReg[j] : vOthReg[j]) ;
-            if ( ExeSurfFlatRegionInterference( nOthRegId, 0, nMchRegId, 0, VERIF_TOLER) != REGC_OUT)
+            if ( ExeSurfFrChunkSimpleClassify( nOthRegId, 0, nMchRegId, 0, VERIF_TOLER) != REGC_OUT)
               nResult |= FMI_RM ;
         }
      }
@@ -177,7 +177,7 @@ ExeVerifyMachining( int nMchId, int& nResult)
  // confronto la regione di uscita della lavorazione con le regioni degli altri pezzi
   for ( int nMchRegId : vMchLoReg) {
      for ( int nOthRegId : vOthReg) {
-         if ( ExeSurfFlatRegionInterference( nOthRegId, 0, nMchRegId, 0, VERIF_TOLER) != REGC_OUT)
+         if ( ExeSurfFrChunkSimpleClassify( nOthRegId, 0, nMchRegId, 0, VERIF_TOLER) != REGC_OUT)
            nResult |= FMI_LO ;
      }
   }
@@ -186,7 +186,7 @@ ExeVerifyMachining( int nMchId, int& nResult)
         if ( vMchDwnLoReg[i] != GDB_ID_NULL  ||  vOthDwnReg[j] != GDB_ID_NULL) {
            int nMchRegId = ( ( vMchDwnLoReg[i] != GDB_ID_NULL) ? vMchDwnLoReg[i] : vMchLoReg[i]) ;
            int nOthRegId = ( ( vOthDwnReg[j] != GDB_ID_NULL) ? vOthDwnReg[j] : vOthReg[j]) ;
-            if ( ExeSurfFlatRegionInterference( nOthRegId, 0, nMchRegId, 0, VERIF_TOLER) != REGC_OUT)
+            if ( ExeSurfFrChunkSimpleClassify( nOthRegId, 0, nMchRegId, 0, VERIF_TOLER) != REGC_OUT)
               nResult |= FMI_LO ;
         }
      }
@@ -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
@@ -22,10 +22,8 @@
 #include "/EgtDev/Include/EGkCurveLine.h"
 #include "/EgtDev/Include/EGkCurveComposite.h"
 #include "/EgtDev/Include/EGkDistPointCurve.h"
-#include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/EGkSfrCreate.h"
 #include "/EgtDev/Include/EGkCAvSimpleSurfFrMove.h"
-#include "/EgtDev/Include/EGkCAvSurfFrMove.h"
 #include "/EgtDev/Include/EGkStringUtils3d.h"
 #include "/EgtDev/Include/EMkMachiningGeoConst.h"
 #include "/EgtDev/Include/EGkIntervals.h"
@@ -34,7 +32,6 @@
 using namespace std ;

 //----------------------------------------------------------------------------
-// collisioni semplici
 struct SCollInfoEx : public SCollInfo
 {
   int nIdM ;                     // identificativo della regione mobile
@@ -46,7 +43,7 @@ struct SCollInfoEx : public SCollInfo
                                nIdF( GDB_ID_NULL), bIsCutF( false) {}
   SCollInfoEx( const SCollInfo& Sou) : SCollInfo( Sou), nIdM( GDB_ID_NULL), bIsCutM( false),
                                        nIdF( GDB_ID_NULL), bIsCutF( false) {}
-} ;
+} ;        

 //----------------------------------------------------------------------------
 static const double SPESS = 100 ;
@@ -95,7 +92,7 @@ ExeCreateOutRegion( int nParentId, double dXmin, double dYmin, double dXmax, dou
        dYmax < dYmin + GAP + 2 * EPS_SMALL)
      return false ;

-  // se già esiste, posso uscire
+  // se già esiste, posso uscire
   int nBoxId = pGeomDB->GetFirstNameInGroup( nParentId, NST_SHEET_OUTREG) ;
   if ( nBoxId != GDB_ID_NULL)
      return true ;
@@ -152,7 +149,7 @@ ExeCreateOutRegion( int nParentId, int nOutCrvId)
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)

-  // se già esiste, posso uscire
+  // se già esiste, posso uscire
   int nBoxId = pGeomDB->GetFirstNameInGroup( nParentId, NST_SHEET_OUTREG) ;
   if ( nBoxId != GDB_ID_NULL)
      return true ;
@@ -190,7 +187,7 @@ ExeCreateOutRegion( int nParentId, int nOutCrvId)
   BBox3d b3Box ;
   pCompo->GetLocalBBox( b3Box) ;
   b3Box.Expand( SPESS, SPESS, 0) ;
-  // determino il punto più vicino al massimo del box e lo faccio diventare il nuovo inizio
+  // determino il punto più vicino al massimo del box e lo faccio diventare il nuovo inizio
   int nFlag ;
   double dU ;
   DistPointCurve distPC( b3Box.GetMax(), *pCompo) ;
@@ -253,7 +250,7 @@ ExeCreateReferenceRegion( int nParentId, int nOutCrvId, bool bBottomUp)
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)

-  // se già esiste, posso uscire
+  // se già esiste, posso uscire
   int nRegId = pGeomDB->GetFirstNameInGroup( nParentId, NST_REFERENCE_REG) ;
   if ( nRegId != GDB_ID_NULL)
      return true ;
@@ -286,7 +283,7 @@ ExeCreateReferenceRegion( int nParentId, int nOutCrvId, bool bBottomUp)
  // ne ricavo il bbox
   BBox3d b3Box ;
   PL.GetLocalBBox( b3Box) ;
-  // cerco i punti più vicini ai quattro vertici (0=BL, 1=BR, 2=TR, 3=TL)
+  // cerco i punti più vicini ai quattro vertici (0=BL, 1=BR, 2=TR, 3=TL)
   double dU[4] = { -1, -1, -1, -1} ;
   double dMinSqDist[4] = { SQ_INFINITO, SQ_INFINITO, SQ_INFINITO, SQ_INFINITO} ;
   Point3d ptVert[4] ;
@@ -394,7 +391,7 @@ ExeCreateDamagedRegion( int nParentId, int nDmgCrvId)
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)

-  // verifico se esiste già la regione associata
+  // verifico se esiste già la regione associata
   int nRegId = pGeomDB->GetFirstNameInGroup( nParentId, NST_DAMAGED_REG) ; 
   while ( nRegId != GDB_ID_NULL) {
     // recupero l'indice della curva di origine
@@ -713,7 +710,7 @@ MyVerifyPartCluster( IGeomDB* pGeomDB, const INTVECTOR& vTrueIds, const BBox3d&
   // box delle regioni dei pezzi rispetto al box dell'esterno
   if ( ! b3Region.EnclosesXY( b3RegCluster))
      return false ;
-   // regioni dei pezzi rispetto alla regione dell'esterno (controllo semplice)
+   // regioni dei pezzi rispetto alla regione dell'esterno
   for ( int nRegId : vReg) {
      if ( ExeSurfFrChunkSimpleClassify( nRegId, 0, nBoxId, 0) != REGC_OUT)
         return false ;
@@ -724,7 +721,7 @@ MyVerifyPartCluster( IGeomDB* pGeomDB, const INTVECTOR& vTrueIds, const BBox3d&
         return false ;
   }

-  // Verifico con l'eventuale regione di riferimento (controllo semplice)
+  // Verifico con l'eventuale regione di riferimento
   // recupero la regione
   int nRefReg = pGeomDB->GetFirstNameInGroup( nGroupId, NST_REFERENCE_REG) ;
   if ( pGeomDB->ExistsInfo( nRefReg, KEY_NST_OFF))
@@ -752,17 +749,17 @@ MyVerifyPartCluster( IGeomDB* pGeomDB, const INTVECTOR& vTrueIds, const BBox3d&
         vDmgReg.emplace_back( nId) ;
         nId = pGeomDB->GetNextName( nId, NST_DAMAGED_REG) ;
      }
-      // regioni dei pezzi rispetto alle regioni delle aree danneggiate (controllo completo)
+      // regioni dei pezzi rispetto alle regioni delle aree danneggiate
      for ( int nRegId : vReg) {
         for ( int nDmgRegId : vDmgReg) {
-            if ( ExeSurfFlatRegionInterference( nRegId, 0, nDmgRegId, 0) != REGC_OUT)
+            if ( ExeSurfFrChunkSimpleClassify( nRegId, 0, nDmgRegId, 0) != REGC_OUT)
               return false ;
         }
      }
      for ( int nDwnRegId : vDwnReg) {
         if ( nDwnRegId != GDB_ID_NULL) {
            for ( int nDmgRegId : vDmgReg) {
-               if ( ExeSurfFlatRegionInterference( nDwnRegId, 0, nDmgRegId, 0) != REGC_OUT)
+               if ( ExeSurfFrChunkSimpleClassify( nDwnRegId, 0, nDmgRegId, 0) != REGC_OUT)
                  return false ;
            }
         }
@@ -803,62 +800,59 @@ MyVerifyPartCluster( IGeomDB* pGeomDB, const INTVECTOR& vTrueIds, const BBox3d&
      nId2 = ( bInRoot ? ExeGetNextPart( nId2, true) : ExeGetNextGroup( nId2)) ;
   }

-  // Eseguo verifiche (controllo completo)
+  // Eseguo verifiche
  // regioni dei pezzi
-   for ( int i = 0 ; i < ssize( vReg) ; ++ i) {
-     // verifico con le regioni degli altri pezzi
+   for ( size_t i = 0 ; i < vReg.size() ; ++ i) {
+     // verifico con le regioni degli altri pezzi (sempre regioni standard)
      for ( int nOthRegId : vOthReg) {
-         if ( ExeSurfFlatRegionInterference( vReg[i], 0, nOthRegId, 0) != REGC_OUT)
+         if ( ExeSurfFrChunkSimpleClassify( vReg[i], 0, nOthRegId, 0) != REGC_OUT)
            return false ;
      }
     // e con le regioni dei tagli degli altri pezzi (se esistono le regioni up devo usarle)
-      int nRegUpId = ( ( vUpReg[i] == GDB_ID_NULL) ? vReg[i] : vUpReg[i]) ;
+      int nRegUpId = ((vUpReg[i] == GDB_ID_NULL) ? vReg[i] : vUpReg[i]) ; 
      for ( int nOthCutRegId : vOthCutReg) {
-         if ( ExeSurfFlatRegionInterference( nRegUpId, 0, nOthCutRegId, 0) != REGC_OUT)
+         if ( ExeSurfFrChunkSimpleClassify( nRegUpId, 0, nOthCutRegId, 0) != REGC_OUT)
            return false ;
      }
   }
-
-  // regioni sotto dei pezzi (controllo completo)
-   for ( int i = 0 ; i < ssize( vDwnReg) ; ++ i) {
+  // regioni sotto dei pezzi
+   for ( size_t i = 0 ; i < vDwnReg.size() ; ++ i) {
     // verifico con le regioni sotto degli altri pezzi
-      for ( int j = 0 ; j < ssize( vOthDwnReg) ; ++ j) {
+      for ( size_t j = 0 ; j < vOthDwnReg.size() ; ++ j) {
         if ( vDwnReg[i] != GDB_ID_NULL  ||  vOthDwnReg[j] != GDB_ID_NULL) {
            int nDwnRegId = ( vDwnReg[i] != GDB_ID_NULL ? vDwnReg[i] : vReg[i]) ;
            int nOthDwnRegId = ( vOthDwnReg[j] != GDB_ID_NULL ? vOthDwnReg[j] : vOthReg[j]) ;
-            if ( ExeSurfFlatRegionInterference( nDwnRegId, 0, nOthDwnRegId, 0) != REGC_OUT)
+            if ( ExeSurfFrChunkSimpleClassify( nDwnRegId, 0, nOthDwnRegId, 0) != REGC_OUT)
               return false ;
         }
      }
     // e con le regioni sotto dei tagli degli altri pezzi
-      for ( int j = 0 ; j < ssize( vOthDwnCutReg) ; ++ j) {
+      for ( size_t j = 0 ; j < vOthDwnCutReg.size() ; ++ j) {
         if ( vDwnReg[i] != GDB_ID_NULL  ||  vOthDwnCutReg[j] != GDB_ID_NULL) {
            int nDwnRegId = ( vDwnReg[i] != GDB_ID_NULL ? vDwnReg[i] : vReg[i]) ;
            int nOthDwnCutRegId = ( vOthDwnCutReg[j] != GDB_ID_NULL ? vOthDwnCutReg[j] : vOthCutReg[j]) ;
-            if ( ExeSurfFlatRegionInterference( nDwnRegId, 0, nOthDwnCutRegId, 0) != REGC_OUT)
+            if ( ExeSurfFrChunkSimpleClassify( nDwnRegId, 0, nOthDwnCutRegId, 0) != REGC_OUT)
               return false ;
         }
      }
   }
-
  // regioni delle lavorazioni dei pezzi
   for ( int nCutRegId : vCutReg) {
-     // le confronto con le regioni degli altri pezzi (controllo completo)
-      for ( int j = 0 ; j < ssize( vOthReg) ; ++ j) {
-         int nOthUpRegId = ( ( vOthUpReg[j] == GDB_ID_NULL) ? vOthReg[j] : vOthUpReg[j]) ;
-         if ( ExeSurfFlatRegionInterference( nCutRegId, 0, nOthUpRegId, 0) != REGC_OUT)
+     // le confronto con le regioni degli altri pezzi
+      for ( size_t j = 0 ; j < vOthReg.size() ; ++ j) {
+         int nOthUpRegId = (( vOthUpReg[j] == GDB_ID_NULL) ? vOthReg[j] : vOthUpReg[j]) ;
+         if ( ExeSurfFrChunkSimpleClassify( nCutRegId, 0, nOthUpRegId, 0) != REGC_OUT)
            return false ;
      }
   }
-
  // regioni sotto delle lavorazioni dei pezzi
-   for ( int i = 0 ; i < ssize( vDwnCutReg) ; ++ i) {
-     // le confronto con le regioni sotto degli altri pezzi (controllo completo)
-      for ( int j = 0 ; j < ssize( vOthDwnReg) ; ++ j) {
+   for ( size_t i = 0 ; i < vDwnCutReg.size() ; ++ i) {
+     // le confronto con le regioni sotto degli altri pezzi
+      for ( size_t j = 0 ; j < vOthDwnReg.size() ; ++ j) {
         if ( vDwnCutReg[i] != GDB_ID_NULL  ||  vOthDwnReg[j] != GDB_ID_NULL) {
            int nDwnCutRegId = ( vDwnCutReg[i] != GDB_ID_NULL ? vDwnCutReg[i] : vCutReg[i]) ;
            int nOthDwnRegId = ( vOthDwnReg[j] != GDB_ID_NULL ? vOthDwnReg[j] : vOthReg[j]) ;
-            if ( ExeSurfFlatRegionInterference( nDwnCutRegId, 0, nOthDwnRegId, 0) != REGC_OUT)
+            if ( ExeSurfFrChunkSimpleClassify( nDwnCutRegId, 0, nOthDwnRegId, 0) != REGC_OUT)
               return false ;
         }
      }
@@ -1037,14 +1031,14 @@ ExePackPartCluster( const INTVECTOR& vIds, bool bReducedCut, bool bBottomUp)
   double dRegClDimY = b3RegCluster.GetMax().y - b3RegCluster.GetMin().y ;
   Point3d ptOrig = b3RegCluster.GetMin() ;

-  // Determino punto più in basso a sinistra del cluster
+  // Determino punto più in basso a sinistra del cluster
   Point3d ptBL = b3RegCluster.GetMax() ;
   double dDimBottom = 0 ;
   for ( int nId : vTrueIds) {
     // recupero l'approssimazione lineare del contorno del pezzo ( in globale)
      PolyLine PL ;
      if ( GetFlatPartApproxContour( pGeomDB, nId, PL)) {
-        // cerco il punto più in basso a sinistra
+        // cerco il punto più in basso a sinistra
         Point3d ptP ;
         bool bFound = PL.GetFirstPoint( ptP) ;
         while ( bFound) {
@@ -1169,7 +1163,6 @@ UpdateCollId( double dLen, double dPrevLen, int nId1, int nId2, bool bIsCut1, bo
 }

 //----------------------------------------------------------------------------
-// Collisione semplice
 static bool
 MySurfFrMoveSimpleNoCollision( int nId1, int nId2, const Vector3d& vtDir, double& dLen, SCollInfo& scInfo)
 {
@@ -1177,27 +1170,23 @@ MySurfFrMoveSimpleNoCollision( int nId1, int nId2, const Vector3d& vtDir, double
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // recupero la prima superficie FlatRegion
   ISurfFlatRegion* pSfr1 = GetSurfFlatRegion( pGeomDB->GetGeoObj( nId1)) ;
-   if ( pSfr1 == nullptr)
-      return false ;
+   bool bOk = ( pSfr1 != nullptr) ;
  // recupero il riferimento della superficie
   Frame3d frSurf1 ;
-   if ( ! pGeomDB->GetGlobFrame( nId1, frSurf1))
-      return false ;
+   bOk = bOk && pGeomDB->GetGlobFrame( nId1, frSurf1) ;
  // recupero la seconda superficie FlatRegion
   const ISurfFlatRegion* pSfr2 = GetSurfFlatRegion( pGeomDB->GetGeoObj( nId2)) ;
-   if ( pSfr2 == nullptr)
-      return false ;
+   bOk = bOk && ( pSfr2 != nullptr) ;
  // recupero il riferimento della superficie
   Frame3d frSurf2 ;
-   if ( ! pGeomDB->GetGlobFrame( nId2, frSurf2))
-      return false ;
+   bOk = bOk && pGeomDB->GetGlobFrame( nId2, frSurf2) ;
  // se riferimenti diversi, porto una copia della seconda nel riferimento della prima
   const ISurfFlatRegion* pSfr2L = pSfr2 ;
   PtrOwner<ISurfFlatRegion> pTmp ;
   if ( ! AreSameFrame( frSurf1, frSurf2)) {
      pTmp.Set( pSfr2->Clone()) ;
-      if ( IsNull( pTmp)  ||  ! pTmp->LocToLoc( frSurf2, frSurf1))
-         return false ;
+      bOk = bOk && ! IsNull( pTmp) ;
+      bOk = bOk && pTmp->LocToLoc( frSurf2, frSurf1) ;
      pSfr2L = pTmp ;
   }
  // porto in locale alla prima superficie il versore di movimento
@@ -1205,71 +1194,21 @@ MySurfFrMoveSimpleNoCollision( int nId1, int nId2, const Vector3d& vtDir, double
   vtDirL.ToLoc( frSurf1) ;
  // calcolo massima lunghezza di traslazione della prima regione senza semplice collisione con la seconda
   CAvSimpleSurfFrMove ScdSfrMove( *pSfr1, *pSfr2L) ;
-   if ( ! ScdSfrMove.Translate( vtDirL, dLen))
-      return false ;
-   scInfo = ScdSfrMove.GetSCollInfo() ;
-   if ( scInfo.nType != SCI_NONE) {
-      scInfo.ptP1.ToGlob( frSurf1) ;
-      scInfo.vtDirM.ToGlob( frSurf1) ;
-      scInfo.vtDirF.ToGlob( frSurf1) ;
+   bOk = bOk && ScdSfrMove.Translate( vtDirL, dLen) ;
+   if ( bOk) {
+      scInfo = ScdSfrMove.GetSCollInfo() ;
+      if ( scInfo.nType != SCI_NONE) {
+         scInfo.ptP1.ToGlob( frSurf1) ;
+         scInfo.vtDirM.ToGlob( frSurf1) ;
+         scInfo.vtDirF.ToGlob( frSurf1) ;
+      }
+      if ( scInfo.nType == SCI_LINE_LINE)
+         scInfo.ptP2.ToGlob( frSurf1) ;
   }
-   if ( scInfo.nType == SCI_LINE_LINE)
-      scInfo.ptP2.ToGlob( frSurf1) ;
-   return true ;
+   return bOk ;
 }

 //----------------------------------------------------------------------------
-// Collisione completa
-static bool
-MySurfFrMoveNoCollision( int nId1, int nId2, const Vector3d& vtDir, double& dLen, SCollInfo& cInfo)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
-  // recupero la prima superficie FlatRegion
-   ISurfFlatRegion* pSfr1 = GetSurfFlatRegion( pGeomDB->GetGeoObj( nId1)) ;
-   if ( pSfr1 == nullptr)
-      return false ;
-  // recupero il riferimento della superficie
-   Frame3d frSurf1 ;
-   if ( ! pGeomDB->GetGlobFrame( nId1, frSurf1))
-      return false ;
-  // recupero la seconda superficie FlatRegion
-   const ISurfFlatRegion* pSfr2 = GetSurfFlatRegion( pGeomDB->GetGeoObj( nId2)) ;
-   if ( pSfr2 == nullptr)
-      return false ;
-  // recupero il riferimento della superficie
-   Frame3d frSurf2 ;
-   if ( ! pGeomDB->GetGlobFrame( nId2, frSurf2))
-      return false ;
-  // se riferimenti diversi, porto una copia della seconda nel riferimento della prima
-   const ISurfFlatRegion* pSfr2L = pSfr2 ;
-   PtrOwner<ISurfFlatRegion> pTmp ;
-   if ( ! AreSameFrame( frSurf1, frSurf2)) {
-      pTmp.Set( pSfr2->Clone()) ;
-      if ( IsNull( pTmp)  ||  ! pTmp->LocToLoc( frSurf2, frSurf1))
-         return false ;
-      pSfr2L = pTmp ;
-   }
-  // porto in locale alla prima superficie il versore di movimento
-   Vector3d vtDirL = vtDir ;
-   vtDirL.ToLoc( frSurf1) ;
-  // calcolo massima lunghezza di traslazione della prima regione senza collisione con la seconda
-   CAvSurfFrMove cdSfrMove( *pSfr1, *pSfr2L) ;
-   if ( ! cdSfrMove.Translate( vtDirL, dLen))
-      return false ;
-   cInfo = cdSfrMove.GetCollInfo() ;
-   if ( cInfo.nType != SCI_NONE) {
-      cInfo.ptP1.ToGlob( frSurf1) ;
-      cInfo.vtDirM.ToGlob( frSurf1) ;
-      cInfo.vtDirF.ToGlob( frSurf1) ;
-   }
-   if ( cInfo.nType == SCI_LINE_LINE)
-      cInfo.ptP2.ToGlob( frSurf1) ;
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-// Traslazione con CAvSurfFr
 static bool
 MyMovePartCluster( IGeomDB* pGeomDB, const INTVECTOR& vTrueIds, BBox3d b3Cluster, bool bReducedCut, Vector3d& vtMove)
 {
@@ -1354,67 +1293,67 @@ MyMovePartCluster( IGeomDB* pGeomDB, const INTVECTOR& vTrueIds, BBox3d b3Cluster
         bOk = false ;
         break ;
      }
-     // la confronto con il box (collisione semplice)
+     // la confronto con il box
      MySurfFrMoveSimpleNoCollision( nRegId, nBoxId, vtDir, dLen, scInfoCurr) ;
      dPrevLen = UpdateCollId( dLen, dPrevLen, nRegId, nBoxId, false, false, scInfoCurr) ;
-     // la confronto con la regione di riferimento (collisione semplice)
+     // la confronto con la regione di riferimento
      if ( nRefReg != GDB_ID_NULL) {
         MySurfFrMoveSimpleNoCollision( nRegId, nRefReg, vtDir, dLen, scInfoCurr) ;
         dPrevLen = UpdateCollId( dLen, dPrevLen, nRegId, nRefReg, false, false, scInfoCurr) ;
      }
-     // la confronto con le aree danneggiate (collisione completa)
+     // la confronto con le aree danneggiate
      for ( int nDmgRegId : vDmgReg) {
-         MySurfFrMoveNoCollision( nRegId, nDmgRegId, vtDir, dLen, scInfoCurr) ;
+         MySurfFrMoveSimpleNoCollision( nRegId, nDmgRegId, vtDir, dLen, scInfoCurr) ;
         dPrevLen = UpdateCollId( dLen, dPrevLen, nRegId, nDmgRegId, false, false, scInfoCurr) ;
      }
-     // la confronto con le regioni degli altri pezzi (collisione completa)
+     // la confronto con le regioni degli altri pezzi
      for ( int nOthRegId : vOthReg) {
-         MySurfFrMoveNoCollision( nRegId, nOthRegId, vtDir, dLen, scInfoCurr) ;
+         MySurfFrMoveSimpleNoCollision( nRegId, nOthRegId, vtDir, dLen, scInfoCurr) ;
         dPrevLen = UpdateCollId( dLen, dPrevLen, nRegId, nOthRegId, false, false, scInfoCurr) ;
      }
     // e con le regioni dei tagli degli altri pezzi
-      // recupero regione in alto del pezzo (collisione completa)
+      // recupero regione in alto del pezzo
      int nUpRegId = GetFlatPartUpRegion( pGeomDB, nTrueId) ;
      int nTestRegId = (( nUpRegId == GDB_ID_NULL) ? nRegId : nUpRegId) ;
      for ( int nOthCutRegId : vOthCutReg) {
-         MySurfFrMoveNoCollision( nTestRegId, nOthCutRegId, vtDir, dLen, scInfoCurr) ;
+         MySurfFrMoveSimpleNoCollision( nTestRegId, nOthCutRegId, vtDir, dLen, scInfoCurr) ;
         dPrevLen = UpdateCollId( dLen, dPrevLen, nTestRegId, nOthCutRegId, false, true, scInfoCurr) ;
      }
     // -----------------------------------------
     // recupero regione in basso del pezzo
      int nDwnRegId = GetFlatPartDownRegion( pGeomDB, nTrueId) ;
-     // la confronto con il box (collisone semplice)
+     // la confronto con il box
      if ( nDwnRegId != GDB_ID_NULL) {
         MySurfFrMoveSimpleNoCollision( nDwnRegId, nBoxId, vtDir, dLen, scInfoCurr) ;
         dPrevLen = UpdateCollId( dLen, dPrevLen, nDwnRegId, nBoxId, false, false, scInfoCurr) ;
      }
-     // la confronto con la regione di riferimento  (collisione completa)
+     // la confronto con la regione di riferimento
      if ( nDwnRegId != GDB_ID_NULL  &&  nRefReg != GDB_ID_NULL) {
-         MySurfFrMoveNoCollision( nDwnRegId, nRefReg, vtDir, dLen, scInfoCurr) ;
+         MySurfFrMoveSimpleNoCollision( nDwnRegId, nRefReg, vtDir, dLen, scInfoCurr) ;
         dPrevLen = UpdateCollId( dLen, dPrevLen, nDwnRegId, nRefReg, false, false, scInfoCurr) ;
      }
-     // la confronto con le aree danneggiate (collisione completa)
+     // la confronto con le aree danneggiate
      if ( nDwnRegId != GDB_ID_NULL) {
         for ( int nDmgRegId : vDmgReg) {
-            MySurfFrMoveNoCollision( nDwnRegId, nDmgRegId, vtDir, dLen, scInfoCurr) ;
+            MySurfFrMoveSimpleNoCollision( nDwnRegId, nDmgRegId, vtDir, dLen, scInfoCurr) ;
            dPrevLen = UpdateCollId( dLen, dPrevLen, nDwnRegId, nDmgRegId, false, false, scInfoCurr) ;
         }
      }
-     // la confronto con le regioni in basso degli altri pezzi (collisione completa)
-      for ( int j = 0 ; j < ssize( vOthDwnReg) ; ++ j) {
+     // la confronto con le regioni in basso degli altri pezzi
+      for ( size_t j = 0 ; j < vOthDwnReg.size() ; ++ j) {
         if ( nDwnRegId != GDB_ID_NULL  ||  vOthDwnReg[j] != GDB_ID_NULL) {
            int nTmpDwnRegId = ( nDwnRegId != GDB_ID_NULL ? nDwnRegId : nRegId) ;
            int nOthDwnRegId = ( vOthDwnReg[j] != GDB_ID_NULL ? vOthDwnReg[j] : vOthReg[j]) ;
-            MySurfFrMoveNoCollision( nTmpDwnRegId, nOthDwnRegId, vtDir, dLen, scInfoCurr) ;
+            MySurfFrMoveSimpleNoCollision( nTmpDwnRegId, nOthDwnRegId, vtDir, dLen, scInfoCurr) ;
            dPrevLen = UpdateCollId( dLen, dPrevLen, nTmpDwnRegId, nOthDwnRegId, false, false, scInfoCurr) ;
         }
      }
-     // e con le regioni in basso dei tagli degli altri pezzi (collisione completa)
-      for ( int j = 0 ; j < ssize( vOthDwnCutReg) ; ++ j) {
+     // e con le regioni in basso dei tagli degli altri pezzi
+      for ( size_t j = 0 ; j < vOthDwnCutReg.size() ; ++ j) {
         if ( nDwnRegId != GDB_ID_NULL  ||  vOthDwnCutReg[j] != GDB_ID_NULL) {
            int nTmpDwnRegId = ( nDwnRegId != GDB_ID_NULL ? nDwnRegId : nRegId) ;
            int nOthDwnCutRegId = ( vOthDwnCutReg[j] != GDB_ID_NULL ? vOthDwnCutReg[j] : vOthCutReg[j]) ;
-            MySurfFrMoveNoCollision( nTmpDwnRegId, nOthDwnCutRegId, vtDir, dLen, scInfoCurr) ;
+            MySurfFrMoveSimpleNoCollision( nTmpDwnRegId, nOthDwnCutRegId, vtDir, dLen, scInfoCurr) ;
            dPrevLen = UpdateCollId( dLen, dPrevLen, nTmpDwnRegId, nOthDwnCutRegId, false, true, scInfoCurr) ;
         }
      }
@@ -1425,11 +1364,11 @@ MyMovePartCluster( IGeomDB* pGeomDB, const INTVECTOR& vTrueIds, BBox3d b3Cluster
         bOk = false ;
         break ;
      }
-     // le confronto con le regioni degli altri pezzi (collisione completa)
+     // le confronto con le regioni degli altri pezzi
      for ( int nCrId : vCrId) {
-         for ( int k = 0 ; k < ssize( vOthReg) ; ++ k) {
+         for ( size_t k = 0 ; k < vOthReg.size() ; ++ k) {
            int nOthRegId = ( vOthUpReg[k] == GDB_ID_NULL ? vOthReg[k] : vOthUpReg[k]) ;
-            MySurfFrMoveNoCollision( nCrId, nOthRegId, vtDir, dLen, scInfoCurr) ;
+            MySurfFrMoveSimpleNoCollision( nCrId, nOthRegId, vtDir, dLen, scInfoCurr) ;
            dPrevLen = UpdateCollId( dLen, dPrevLen, nCrId, nOthRegId, true, false, scInfoCurr) ;
         }
      }
@@ -1440,13 +1379,13 @@ MyMovePartCluster( IGeomDB* pGeomDB, const INTVECTOR& vTrueIds, BBox3d b3Cluster
         bOk = false ;
         break ;
      }
-     // le confronto con le regioni in basso degli altri pezzi (collisione completa)
-      for ( int j = 0 ; j < ssize( vDwnCrId) ; ++ j) {
-         for ( int k = 0 ; k < ssize( vOthDwnReg) ; ++ k) {
+     // le confronto con le regioni in basso degli altri pezzi
+      for ( size_t j = 0 ; j < vDwnCrId.size() ; ++ j) {
+         for ( size_t k = 0 ; k < vOthDwnReg.size() ; ++ k) {
            if ( vDwnCrId[j] != GDB_ID_NULL  ||  vOthDwnReg[k] != GDB_ID_NULL) {
               int nTmpDwnCrId = ( vDwnCrId[j] != GDB_ID_NULL ? vDwnCrId[j] : vCrId[j]) ;
               int nOthDwnRegId = ( vOthDwnReg[k] != GDB_ID_NULL ? vOthDwnReg[k] : vOthReg[k]) ;
-               MySurfFrMoveNoCollision( nTmpDwnCrId, nOthDwnRegId, vtDir, dLen, scInfoCurr) ;
+               MySurfFrMoveSimpleNoCollision( nTmpDwnCrId, nOthDwnRegId, vtDir, dLen, scInfoCurr) ;
               dPrevLen = UpdateCollId( dLen, dPrevLen, nTmpDwnCrId, nOthDwnRegId, true, false, scInfoCurr) ;
            }
         }
@@ -1480,7 +1419,7 @@ MyMovePartCluster( IGeomDB* pGeomDB, const INTVECTOR& vTrueIds, BBox3d b3Cluster
      }
   }

-  // Se movimento risultante nullo, non faccio alcunché
+  // Se movimento risultante nullo, non faccio alcunché
   vtMoveXY = vtDir * dLen ;
   if ( vtMoveXY.IsSmall())
      return true ;
@@ -1525,7 +1464,7 @@ ExeMovePartCluster( const INTVECTOR& vIds, bool bReducedCut, Vector3d& vtMove)
         vtMove = vtM ;
         return true ;
      }
-     // altrimenti, riprovo con tagli standard
+     // altrimenti, riprovo con tagli standard 
      else {
        // annullo il movimento
         for ( int nId : vTrueIds)
@@ -1536,50 +1475,7 @@ ExeMovePartCluster( const INTVECTOR& vIds, bool bReducedCut, Vector3d& vtMove)
   }
 }

-
 //----------------------------------------------------------------------------
-static bool
-MySurfFrRotateNoCollision( int nId1, int nId2, const Point3d& ptCen, double& dAngDeg, SCollInfo& cInfo)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
-  // recupero la prima superficie FlatRegion
-   ISurfFlatRegion* pSfr1 = GetSurfFlatRegion( pGeomDB->GetGeoObj( nId1)) ;
-   if ( pSfr1 == nullptr)
-      return false ;
-  // recupero il riferimento della superficie
-   Frame3d frSurf1 ;
-   if ( ! pGeomDB->GetGlobFrame( nId1, frSurf1))
-      return false ;
-  // recupero la seconda superficie FlatRegion
-   const ISurfFlatRegion* pSfr2 = GetSurfFlatRegion( pGeomDB->GetGeoObj( nId2)) ;
-   if ( pSfr2 == nullptr)
-      return false ;
-  // recupero il riferimento della superficie
-   Frame3d frSurf2 ;
-   if ( ! pGeomDB->GetGlobFrame( nId2, frSurf2))
-      return false ;
-  // se riferimenti diversi, porto una copia della seconda nel riferimento della prima
-   const ISurfFlatRegion* pSfr2L = pSfr2 ;
-   PtrOwner<ISurfFlatRegion> pTmp ;
-   if ( ! AreSameFrame( frSurf1, frSurf2)) {
-      pTmp.Set( pSfr2->Clone()) ;
-      if ( IsNull( pTmp)  ||  ! pTmp->LocToLoc( frSurf2, frSurf1))
-         return false ;
-      pSfr2L = pTmp ;
-   }
-  // porto in locale alla prima superficie il punto di rotazione
-   Point3d ptCenL = ptCen ;
-   ptCenL.ToLoc( frSurf1) ;
-  // calcolo massima lunghezza di traslazione della prima regione senza collisione con la seconda
-   CAvSurfFrMove cdSfrMove( *pSfr1, *pSfr2L) ;
-   if ( ! cdSfrMove.Rotate( ptCenL, dAngDeg))
-      return false ;
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-// Rotazione con CAvSurfFr
 bool
 MyRotatePartCluster( IGeomDB* pGeomDB, const INTVECTOR& vTrueIds, BBox3d& b3Cluster, bool bReducedCut,
                     const Point3d& ptCen, double& dRotAngDeg)
@@ -1657,21 +1553,21 @@ MyRotatePartCluster( IGeomDB* pGeomDB, const INTVECTOR& vTrueIds, BBox3d& b3Clus
         bOk = false ;
         break ;
      }
-     // la confronto con il box (collisione semplice)
+     // la confronto con il box
      ExeSurfFrRotateSimpleNoCollision( nRegId, nBoxId, ptCen, dAng, RTY_GLOB) ;
-     // la confronto con la regione di riferimento (collisione semplice)
+     // la confronto con la regione di riferimento
      if ( nRefReg != GDB_ID_NULL) {
         ExeSurfFrRotateSimpleNoCollision( nRegId, nRefReg, ptCen, dAng, RTY_GLOB) ;
      }
-     // la confronto con le aree danneggiate (collisione completa)
+     // la confronto con le aree danneggiate
      for ( int nDmgRegId : vDmgReg) {
-         MySurfFrRotateNoCollision( nRegId, nDmgRegId, ptCen, dAng, s_scInfo) ;
+         ExeSurfFrRotateSimpleNoCollision( nRegId, nDmgRegId, ptCen, dAng, RTY_GLOB) ;
      }
-     // la confronto con le regioni degli altri pezzi (collisione completa)
+     // la confronto con le regioni degli altri pezzi
      for ( int nOthRegId : vOthReg) {
-         MySurfFrRotateNoCollision( nRegId, nOthRegId, ptCen, dAng, s_scInfo) ;
+         ExeSurfFrRotateSimpleNoCollision( nRegId, nOthRegId, ptCen, dAng, RTY_GLOB) ;
      }
-     // e con le regioni dei tagli degli altri pezzi (collisione completa)
+     // e con le regioni dei tagli degli altri pezzi
      // recupero regione in alto del pezzo
      int nUpRegId = GetFlatPartUpRegion( pGeomDB, nTrueId) ;
      int nTestRegId = (( nUpRegId == GDB_ID_NULL) ? nRegId : nUpRegId) ;
@@ -1681,33 +1577,33 @@ MyRotatePartCluster( IGeomDB* pGeomDB, const INTVECTOR& vTrueIds, BBox3d& b3Clus
     // -----------------------------------------
     // recupero regione in basso del pezzo
      int nDwnRegId = GetFlatPartDownRegion( pGeomDB, nTrueId) ;
-     // la confronto con il box (collisione semplice)
+     // la confronto con il box
      if ( nDwnRegId != GDB_ID_NULL)
         ExeSurfFrRotateSimpleNoCollision( nDwnRegId, nBoxId, ptCen, dAng, RTY_GLOB) ;
-     // la confronto con la regione di riferimento (collisione semplice)
+     // la confronto con la regione di riferimento
      if ( nRefReg != GDB_ID_NULL) {
         ExeSurfFrRotateSimpleNoCollision( nDwnRegId, nRefReg, ptCen, dAng, RTY_GLOB) ;
      }
-     // la confronto con le aree danneggiate (collisione completa)
+     // la confronto con le aree danneggiate
      if ( nDwnRegId != GDB_ID_NULL) {
         for ( int nDmgRegId : vDmgReg) {
-            MySurfFrRotateNoCollision( nDwnRegId, nDmgRegId, ptCen, dAng, s_scInfo) ;
+            ExeSurfFrRotateSimpleNoCollision( nDwnRegId, nDmgRegId, ptCen, dAng, RTY_GLOB) ;
         }
      }
-     // la confronto con le regioni in basso  degli altri pezzi (collisione completa)
-      for ( int j = 0 ; j < ssize( vOthDwnReg) ; ++ j) {
+     // la confronto con le regioni in basso  degli altri pezzi
+      for ( size_t j = 0 ; j < vOthDwnReg.size() ; ++ j) {
         if ( nDwnRegId != GDB_ID_NULL  ||  vOthDwnReg[j] != GDB_ID_NULL) {
            int nTmpDwnRegId = ( nDwnRegId != GDB_ID_NULL ? nDwnRegId : nRegId) ;
            int nOthDwnRegId = ( vOthDwnReg[j] != GDB_ID_NULL ? vOthDwnReg[j] : vOthReg[j]) ;
-            MySurfFrRotateNoCollision( nTmpDwnRegId, nOthDwnRegId, ptCen, dAng, s_scInfo) ;
+            ExeSurfFrRotateSimpleNoCollision( nTmpDwnRegId, nOthDwnRegId, ptCen, dAng, RTY_GLOB) ;
         }
      }
-     // e con le regioni in basso dei tagli degli altri pezzi (collisione completa)
-      for ( int j = 0 ; j < ssize( vOthDwnCutReg) ; ++ j) {
+     // e con le regioni in basso dei tagli degli altri pezzi
+      for ( size_t j = 0 ; j < vOthDwnCutReg.size() ; ++ j) {
         if ( nDwnRegId != GDB_ID_NULL  ||  vOthDwnCutReg[j] != GDB_ID_NULL) {
            int nTmpDwnRegId = ( nDwnRegId != GDB_ID_NULL ? nDwnRegId : nRegId) ;
            int nOthDwnCutRegId = ( vOthDwnCutReg[j] != GDB_ID_NULL ? vOthDwnCutReg[j] : vOthCutReg[j]) ;
-            MySurfFrRotateNoCollision( nTmpDwnRegId, nOthDwnCutRegId, ptCen, dAng, s_scInfo) ;
+            ExeSurfFrRotateSimpleNoCollision( nTmpDwnRegId, nOthDwnCutRegId, ptCen, dAng, RTY_GLOB) ;
         }
      }
     // -----------------------------------------
@@ -1717,11 +1613,11 @@ MyRotatePartCluster( IGeomDB* pGeomDB, const INTVECTOR& vTrueIds, BBox3d& b3Clus
         bOk = false ;
         break ;
      }
-     // le confronto con le regioni degli altri pezzi (collisione completa)
+     // le confronto con le regioni degli altri pezzi
      for ( int nCrId : vCrId) {
-         for ( int k = 0 ; k < ssize( vOthReg) ; ++ k) {
+         for ( size_t k = 0 ; k < vOthReg.size() ; ++ k) {
            int nOthRegId = ( vOthUpReg[k] == GDB_ID_NULL ? vOthReg[k] : vOthUpReg[k]) ;
-            MySurfFrRotateNoCollision( nCrId, nOthRegId, ptCen, dAng, s_scInfo) ;
+            ExeSurfFrRotateSimpleNoCollision( nCrId, nOthRegId, ptCen, dAng, RTY_GLOB) ;
         }
      }
     // -----------------------------------------
@@ -1731,13 +1627,13 @@ MyRotatePartCluster( IGeomDB* pGeomDB, const INTVECTOR& vTrueIds, BBox3d& b3Clus
         bOk = false ;
         break ;
      }
-     // le confronto con le regioni in basso degli altri pezzi (collisione completa)
-      for ( int j = 0 ; j < ssize( vDwnCrId) ; ++ j) {
-         for ( int k = 0 ; k < ssize( vOthDwnReg) ; ++ k) {
+     // le confronto con le regioni in basso degli altri pezzi
+      for ( size_t j = 0 ; j < vDwnCrId.size() ; ++ j) {
+         for ( size_t k = 0 ; k < vOthDwnReg.size() ; ++ k) {
            if ( vDwnCrId[j] != GDB_ID_NULL  ||  vOthDwnReg[k] != GDB_ID_NULL) {
               int nTmpDwnCrId = ( vDwnCrId[j] != GDB_ID_NULL ? vDwnCrId[j] : vCrId[j]) ;
               int nOthDwnRegId = ( vOthDwnReg[k] != GDB_ID_NULL ? vOthDwnReg[k] : vOthReg[k]) ;
-               MySurfFrRotateNoCollision( nTmpDwnCrId, nOthDwnRegId, ptCen, dAng, s_scInfo) ;
+               ExeSurfFrRotateSimpleNoCollision( nTmpDwnCrId, nOthDwnRegId, ptCen, dAng, RTY_GLOB) ;
            }
         }
      }
@@ -1747,7 +1643,7 @@ MyRotatePartCluster( IGeomDB* pGeomDB, const INTVECTOR& vTrueIds, BBox3d& b3Clus
   if ( ! bOk)
      return false ;

-  // Se movimento risultante nullo, non faccio alcunché
+  // Se movimento risultante nullo, non faccio alcunché
   dRotAngDeg = dAng ;
   if ( abs( dAng) < EPS_ANG_SMALL)
      return true ;
@@ -1790,7 +1686,7 @@ GetObstacleTangent( Vector3d& vtTang)

 //----------------------------------------------------------------------------
 static bool
-GetMovingTangent( Vector3d& vtTang)
+GetMovingTangent(  Vector3d& vtTang)
 {
   if ( s_scInfo.nType != SCI_LINE_PNT  &&  s_scInfo.nType != SCI_LINE_LINE)
      return false ;
@@ -1837,7 +1733,7 @@ ExeAlignPartClusterOnCollision( const INTVECTOR& vIds, bool bReducedCut, bool& b
   Point3d ptCntL = s_scInfo.ptP1 ;
   ptCntL.ToLoc( frSfr) ;
  // cerco le direzioni tangenti prima e dopo il punto di contatto sulle parti mobili
-   PtrOwner<ICurve> pCrv( pSfr->GetLoop( s_scInfo.nChunkM, s_scInfo.nLoopM)) ;
+   PtrOwner<ICurve> pCrv( pSfr->GetLoop( s_scInfo.nChunkM, 0)) ;
   if ( IsNull( pCrv))
      return false ;
   double dU ;
@@ -1864,7 +1760,7 @@ ExeAlignPartClusterOnCollision( const INTVECTOR& vIds, bool bReducedCut, bool& b
      string sOut = "vtTp=(" + ToString( vtTp) + ") vtTn=(" + ToString( vtTn) + ")" ;
      LOG_INFO( GetLogger(), sOut.c_str()) ;
   }
-   // ruoto dalla parte dell'angolo più piccolo (componente più grande)
+   // ruoto dalla parte dell'angolo più piccolo (componente più grande)
   double dRotAngDeg = ( abs( vtTp * s_scInfo.vtDirF) > abs( vtTn * s_scInfo.vtDirF)) ? 90 : - 90 ;
  // provo a ruotare sul punto di collisione in senso orario
   Point3d ptCen = s_scInfo.ptP1 ;
@@ -1888,7 +1784,6 @@ ExeMoveToSnapPointOnCollision( const INTVECTOR& vIds, bool bReducedCut, double d
  // cerco i due tagli in collisione
   int nCutM = GDB_ID_NULL ;
   int nGeoM = GDB_ID_NULL ;
-   INTVECTOR vnGeoM, vnGeoF ;
   Point3d ptStartM, ptEndM ;
   Vector3d vtDirM ;
   Frame3d frGeoM ;
@@ -1897,38 +1792,13 @@ ExeMoveToSnapPointOnCollision( const INTVECTOR& vIds, bool bReducedCut, double d
   Point3d ptStartF, ptEndF ;
   Vector3d vtDirF ;
   Frame3d frGeoF ;
-  // se mobile è già un taglio, ne ricavo i dati
+  // se mobile è già un taglio, ne ricavo i dati
   if ( s_scInfo.bIsCutM) {
-      if ( s_scInfo.nIdM == GDB_ID_NULL)
-         return false ;
      nCutM = s_scInfo.nIdM ;
-      vnGeoM = GetGeometryFromCut( pGeomDB, pMachMgr, nCutM) ;
-      if ( vnGeoM.empty())
-         return false ;
-      ICurveLine* pLineM = nullptr ;
-     // se ho un solo taglio, allora è quello
-      if ( ssize( vnGeoM) == 1) {
-         pLineM = GetCurveLine( pGeomDB->GetGeoObj( vnGeoM[0])) ;
-         nGeoM = vnGeoM[0] ;
-      }
-     // se più tagli, cerco quello più vicino alla linea corrente
-      else {
-         double dMinSqDist = INFINITO ;
-         for ( int i = 0 ; i < ssize( vnGeoM) ; ++ i) {
-            Frame3d frCurrGeoM ;
-            ICurveLine* pCurrLineM = GetCurveLine( pGeomDB->GetGeoObj( vnGeoM[i])) ;
-            if ( pCurrLineM == nullptr  ||  ! pGeomDB->GetGlobFrame( vnGeoM[i], frCurrGeoM))
-               return false ;
-            double dCurrSqDist ;
-            DistPointLine( GetToLoc( s_scInfo.ptP1, frCurrGeoM), *pCurrLineM).GetSqDist( dCurrSqDist) ;
-            if ( dCurrSqDist < dMinSqDist) {
-               dMinSqDist = dCurrSqDist ;
-               pLineM = pCurrLineM ;
-               nGeoM = vnGeoM[i] ;
-            }
-         }
-      }
-      if ( pLineM == nullptr  ||  ! pGeomDB->GetGlobFrame( nGeoM, frGeoM))
+      nGeoM = GetGeometryFromCut( pGeomDB, pMachMgr, nCutM) ;
+      ICurveLine* pLineM = GetCurveLine( pGeomDB->GetGeoObj( nGeoM)) ;
+      if ( nCutM == GDB_ID_NULL  ||  nGeoM == GDB_ID_NULL  ||
+           pLineM == nullptr  ||  ! pGeomDB->GetGlobFrame( nGeoM, frGeoM))
         return false ;
      ptStartM = pLineM->GetStart() ;
      ptStartM.ToGlob( frGeoM) ;
@@ -1937,36 +1807,13 @@ ExeMoveToSnapPointOnCollision( const INTVECTOR& vIds, bool bReducedCut, double d
      vtDirM = ptEndM - ptStartM ;
      vtDirM.Normalize() ;
   }
-  // se fisso è già un taglio, ne ricavo i dati
+  // se fisso è già un taglio, ne ricavo i dati
   if ( s_scInfo.bIsCutF) {
-      if ( s_scInfo.nChunkF == GDB_ID_NULL)
-         return false ;
      nCutF = s_scInfo.nIdF ;
-      vnGeoF = GetGeometryFromCut( pGeomDB, pMachMgr, nCutF) ;
+      nGeoF = GetGeometryFromCut( pGeomDB, pMachMgr, nCutF) ;
      ICurveLine* pLineF = GetCurveLine( pGeomDB->GetGeoObj( nGeoF)) ;
-     // se ho un solo taglio, allora è quello
-      if ( ssize( vnGeoF) == 1) {
-         pLineF = GetCurveLine( pGeomDB->GetGeoObj( vnGeoF[0])) ;
-         nGeoF = vnGeoF[0] ;
-      }
-     // se più tagli, cerco quello più vicino alla linea corrente
-      else {
-         double dMinSqDist = INFINITO ;
-         for ( int i = 0 ; i < ssize( vnGeoF) ; ++ i) {
-            Frame3d frCurrGeoF ;
-            ICurveLine* pCurrLineF = GetCurveLine( pGeomDB->GetGeoObj( vnGeoF[i])) ;
-            if ( pCurrLineF == nullptr  ||  ! pGeomDB->GetGlobFrame( vnGeoF[i], frCurrGeoF))
-               return false ;
-            double dCurrSqDist ;
-            DistPointLine( GetToLoc( s_scInfo.ptP1, frCurrGeoF), *pCurrLineF).GetSqDist( dCurrSqDist) ;
-            if ( dCurrSqDist < dMinSqDist) {
-               dMinSqDist = dCurrSqDist ;
-               pLineF = pCurrLineF ;
-               nGeoF = vnGeoF[i] ;
-            }
-         }
-      }
-      if ( pLineF == nullptr  ||  ! pGeomDB->GetGlobFrame( nGeoF, frGeoF))
+      if ( nCutF == GDB_ID_NULL  ||  nGeoF == GDB_ID_NULL  ||
+           pLineF == nullptr  ||  ! pGeomDB->GetGlobFrame( nGeoF, frGeoF))
         return false ;
      ptStartF = pLineF->GetStart() ;
      ptStartF.ToGlob( frGeoF) ;
@@ -1991,31 +1838,8 @@ ExeMoveToSnapPointOnCollision( const INTVECTOR& vIds, bool bReducedCut, double d
         BBox3d b3Temp ;
         pGeomDB->GetGlobalBBox( nId, b3Temp) ;
         if ( b3Temp.OverlapsXY( b3CutM)) {
-            int nGeom = GDB_ID_NULL ;
-            INTVECTOR vnGeom = GetGeometryFromCut( pGeomDB, pMachMgr, nId) ;
-            ICurveLine* pLine = nullptr ;
-           // se ho un solo taglio, allora è quello
-            if ( ssize( vnGeom) == 1) {
-               pLine = GetCurveLine( pGeomDB->GetGeoObj( vnGeom[0])) ;
-               nGeom = vnGeom[0] ;
-            }
-           // se ho più tagli, cerco quello più vicino alla linea corrente
-            else {
-               double dMinSqDist = INFINITO ;
-               for ( int i = 0 ; i < ssize( vnGeom) ; ++ i) {
-                  Frame3d frCurrGeo ;
-                  ICurveLine* pCurrLine = GetCurveLine( pGeomDB->GetGeoObj( vnGeom[i])) ;
-                  if ( pCurrLine == nullptr  ||  ! pGeomDB->GetGlobFrame( vnGeom[i], frCurrGeo))
-                     return false ;
-                  double dCurrSqDist ;
-                  DistPointLine( GetToLoc( s_scInfo.ptP1, frCurrGeo), *pCurrLine).GetSqDist( dCurrSqDist) ;
-                  if ( dCurrSqDist < dMinSqDist) {
-                     dMinSqDist = dCurrSqDist ;
-                     pLine = pCurrLine ;
-                     nGeom = vnGeom[i] ;
-                  }
-               }
-            }
+            int nGeom = GetGeometryFromCut( pGeomDB, pMachMgr, nId) ;
+            ICurveLine* pLine = GetCurveLine( pGeomDB->GetGeoObj( nGeom)) ;
            if ( nGeom == GDB_ID_NULL  ||  pLine == nullptr  ||  ! pGeomDB->GetGlobFrame( nGeom, frGeoF))
               continue ;
            ptStartF = pLine->GetStart() ;
@@ -2048,31 +1872,8 @@ ExeMoveToSnapPointOnCollision( const INTVECTOR& vIds, bool bReducedCut, double d
         BBox3d b3Temp ;
         pGeomDB->GetGlobalBBox( nId, b3Temp) ;
         if ( b3Temp.OverlapsXY( b3CutF)) {
-            int nGeom = GDB_ID_NULL ;
-            INTVECTOR vnGeom = GetGeometryFromCut( pGeomDB, pMachMgr, nId) ;
-            ICurveLine* pLine = nullptr ;
-           // se ho un solo taglio, allora è quello
-            if ( ssize( vnGeom) == 1) {
-               pLine = GetCurveLine( pGeomDB->GetGeoObj( vnGeom[0])) ;
-               nGeom = vnGeom[0] ;
-            }
-           // se ho più tagli, cerco quello più vicino alla linea corrente
-            else {
-               double dMinSqDist = INFINITO ;
-               for ( int i = 0 ; i < ssize( vnGeom) ; ++ i) {
-                  Frame3d frCurrGeo ;
-                  ICurveLine* pCurrLine = GetCurveLine( pGeomDB->GetGeoObj( vnGeom[0])) ;
-                  if ( pCurrLine == nullptr  ||  ! pGeomDB->GetGlobFrame( vnGeom[i], frCurrGeo))
-                     return false ;
-                  double dCurrSqDist ;
-                  DistPointLine( GetToLoc( s_scInfo.ptP1, frCurrGeo), *pCurrLine).GetSqDist( dCurrSqDist) ;
-                  if ( dCurrSqDist < dMinSqDist) {
-                     dMinSqDist = dCurrSqDist ;
-                     pLine = pCurrLine ;
-                     nGeom = vnGeom[i] ;
-                  }
-               }
-            }
+            int nGeom = GetGeometryFromCut( pGeomDB, pMachMgr, nId) ;
+            ICurveLine* pLine = GetCurveLine( pGeomDB->GetGeoObj( nGeom)) ;
            if ( nGeom == GDB_ID_NULL  ||  pLine == nullptr  ||  ! pGeomDB->GetGlobFrame( nGeom, frGeoM))
               continue ;
            ptStartM = pLine->GetStart() ;
@@ -2149,9 +1950,9 @@ ExeMoveToSnapPointOnCollision( const INTVECTOR& vIds, bool bReducedCut, double d
            dMoveMn = CrossXY( ptStartF - ptEndM, vtDirFp) / dDenom ;
      }
   }
-  // pareggio la parte più vicina, se almeno una sotto soglia
+  // pareggio la parte più vicina, se almeno una sotto soglia
   if ( abs( dMoveMp) < dMaxMove  ||  abs( dMoveMn) < dMaxMove) {
-     // calcolo movimento necessario, se nullo già a posto
+     // calcolo movimento necessario, se nullo già a posto
      Vector3d vtMove = (( abs( dMoveMp) < abs( dMoveMn)) ? dMoveMp : dMoveMn) * vtDirF ;
      if ( vtMove.IsSmall()) {
         bMoved = false ;
@@ -2176,7 +1977,7 @@ ExeMoveToSnapPointOnCollision( const INTVECTOR& vIds, bool bReducedCut, double d
   pGeomDB->GetRefBBox( nCutM, frCutF, b3CutM) ;
   double dStartDelta = b3CutF.GetMin().x - b3CutM.GetMin().x ;
   double dEndDelta = b3CutF.GetMax().x - b3CutM.GetMax().x ;
-  // pareggio la parte più vicina, se sotto soglia
+  // pareggio la parte più vicina, se sotto soglia
   if ( abs( dStartDelta) > dMaxMove  &&  abs( dEndDelta) > dMaxMove)
      return false ;
   Vector3d vtMove = (( abs( dStartDelta) < abs( dEndDelta)) ? dStartDelta : dEndDelta) * vtDirF ;
@@ -2278,7 +2079,7 @@ ExeAutomaticPackParts( INTVECTOR& vIds, bool bMinimizeOnXvsY, bool bReducedCut,
  // Avvio nesting automatico
   ExeAutoNestStart() ;

-  // Modalità ghigliottina incompatibile con tagli completi
+  // Modalità ghigliottina incompatibile con tagli completi
   if ( ! bReducedCut)
      bGuillotineMode = false ;

@@ -2301,11 +2102,11 @@ ExeAutomaticPackParts( INTVECTOR& vIds, bool bMinimizeOnXvsY, bool bReducedCut,
      nDamId = pGeomDB->GetNextName( nDamId, NST_DAMAGED_REG) ;
   }

-   // Modalità ghigliottina incompatibile con pannelli non rettangolari
+   // Modalità ghigliottina incompatibile con pannelli non rettangolari
   if ( ! bIsRect)
      bGuillotineMode = false ;

-  // Assegno le aree occupate dai pezzi già nestati
+  // Assegno le aree occupate dai pezzi già nestati
   bool bPartAlreadyNested = false ;
   BBox3d b3Sheet ;
   pGeomDB->GetGlobalBBox( nRefReg, b3Sheet) ;
@@ -2331,18 +2132,18 @@ ExeAutomaticPackParts( INTVECTOR& vIds, bool bMinimizeOnXvsY, bool bReducedCut,
            GetFlatPartDownCutRegions( pGeomDB, nId, bReducedCut, vCutReg) ;
            for ( int nRegId : vCutReg)
               ExeAutoNestAddDefectToSheet( nSheetId, nRegId) ;
-           // dichiaro ci sono pezzi già nestati
+           // dichiaro ci sono pezzi già nestati
            bPartAlreadyNested = true ;
         }
      }
      nId = ( bInRoot ? ExeGetNextPart( nId, true) : ExeGetNextGroup( nId)) ;
   }

-  // Pezzi già nestati incompatibili con ghigliottina
+  // Pezzi già nestati incompatibili con ghigliottina
   if ( bPartAlreadyNested)
      bGuillotineMode = false ;

-  // Se richiesta modalità ghigliottina 
+  // Se richiesta modalità ghigliottina 
   if ( bGuillotineMode) {
     // cerco il gap necessario tra le parti
      double dGap = 0 ;
@@ -2352,7 +2153,7 @@ ExeAutomaticPackParts( INTVECTOR& vIds, bool bMinimizeOnXvsY, bool bReducedCut,
         if ( GetFlatPartInterpartGap( pGeomDB, nPartId, dCurrGap)  &&  dCurrGap > dGap)
            dGap = dCurrGap ;
      }
-     // se non trovato disabilito richiesta modalità ghigliottina
+     // se non trovato disabilito richiesta modalità ghigliottina
      if ( dGap < EPS_SMALL)
         bGuillotineMode = false ;
     // altrimenti lo imposto
@@ -2360,7 +2161,7 @@ ExeAutomaticPackParts( INTVECTOR& vIds, bool bMinimizeOnXvsY, bool bReducedCut,
         ExeAutoNestSetInterpartGap( dGap) ;
   }

-  // Se richiesto e abilitato, imposto modalità ghigliottina
+  // Se richiesto e abilitato, imposto modalità ghigliottina
   if ( bGuillotineMode)
      ExeAutoNestSetGuillotineMode() ;

@@ -2376,7 +2177,7 @@ ExeAutomaticPackParts( INTVECTOR& vIds, bool bMinimizeOnXvsY, bool bReducedCut,
      int nDwnRegId = GetFlatPartDownRegion( pGeomDB, nPartId) ;
      if ( nDwnRegId != GDB_ID_NULL)
         ExeAutoNestAddAnotherOutlineToPart( nPartId, nDwnRegId) ;
-     // se non è ghigliottina imposto le regioni dei tagli (con ghigliottina si usa il gap)
+     // se non è ghigliottina imposto le regioni dei tagli (con ghigliottina si usa il gap)
      if ( ! bGuillotineMode) {
        // recupero regioni dei tagli del pezzo
         INTVECTOR vCutReg ;
@@ -16,14 +16,10 @@
 #include "EXE.h"
 #include "EXE_Macro.h"
 #include "DllGraphics.h"
-#include "DllMain.h"
-#include "resource.h"
-#include "/EgtDev/Include/EGkSurfBezier.h"
 #include "/EgtDev/Include/EXeExecutor.h"
 #include "/EgtDev/Include/EXeConst.h"
 #include "/EgtDev/Include/EgtStringConverter.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
-#include <Windowsx.h>

 using namespace std ;

@@ -113,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) ;
 }

 //-----------------------------------------------------------------------------
@@ -187,23 +183,10 @@ ExeSetGridGeo( double dSnapStep, int nMinLineSstep, int nMajLineSstep, int nExtS
 {
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
-
  // imposto i parametri geometrici di griglia
   return pScene->SetGridGeo( dSnapStep, nMinLineSstep, nMajLineSstep, nExtSstep) ;
 }

-//-----------------------------------------------------------------------------
-bool
-ExeSetGridGeoAdv( double dSnapStep, int nMinLineSstep, int nMajLineSstep,
-                  double dXmin, double dXmax, double dYmin, double dYmax)
-{
-   IEGrScene* pScene = GetCurrScene() ;
-   VERIFY_SCENE( pScene, false)
-
-  // imposto i parametri geometrici di griglia
-   return pScene->SetGridGeoAdv( dSnapStep, nMinLineSstep, nMajLineSstep, dXmin, dXmax, dYmin, dYmax) ;
-}
-
 //-----------------------------------------------------------------------------
 bool
 ExeSetGridColor( Color colMin, Color colMaj)
@@ -214,31 +197,6 @@ ExeSetGridColor( Color colMin, Color colMaj)
   return pScene->SetGridColor( colMin, colMaj) ;
 }

-//-----------------------------------------------------------------------------
-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 ;
-}
-
 //-----------------------------------------------------------------------------
 bool
 ExeResize( int nW, int nH)
@@ -257,7 +215,6 @@ ExeDraw( void)
  // se interfaccia disabilitata, esco subito
   if ( ! ExeGetEnableUI())
      return true ;
-
   GseContext* pGseCtx = GetCurrGseContext() ;
   VERIFY_CTX_SCENE( pGseCtx, false)
  // eseguo disegno
@@ -267,21 +224,6 @@ ExeDraw( void)
   return true ;
 }

-//-----------------------------------------------------------------------------
-bool
-ExeRedraw( void)
-{
-  // se interfaccia disabilitata, esco subito
-   if ( ! ExeGetEnableUI())
-      return true ;
-
-   IEGrScene* pScene = GetCurrScene() ;
-   VERIFY_SCENE( pScene, false)
-  // forzo ridisegno
-   pScene->RedrawWindow() ;
-   return true ;
-}
-
 //-----------------------------------------------------------------------------
 bool
 ExeSelect( int nWinX, int nWinY, int nSelW, int nSelH, int* pnSel)
@@ -475,44 +417,17 @@ ExeGetShowCurveDirection( void)
   return pScene->GetShowCurveDirection() ;
 }

-//-----------------------------------------------------------------------------
-static bool
-MyResetGroupObjGraphics( IGeomDB* pGDB, int nGroupId)
-{
-   if ( pGDB == nullptr)
-      return false ;
-   int nEntId = pGDB->GetFirstInGroup( nGroupId) ;
-   while ( nEntId != GDB_ID_NULL) {
-      if ( pGDB->GetGdbType( nEntId) == GDB_TY_GROUP) {
-         MyResetGroupObjGraphics( pGDB, nEntId) ;
-      }
-      else {
-         IGeoObj* pGeoObj = pGDB->GetGeoObj( nEntId) ;
-         if ( pGeoObj != nullptr)
-            pGeoObj->SetObjGraphics( nullptr) ;
-      }        
-      nEntId = pGDB->GetNext( nEntId) ;
-   }
-   return true ;
-}
-
 //-----------------------------------------------------------------------------
 bool
 ExeSetShowTriaAdv( bool bAdvanced, bool bRedraw)
 {
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
-  // se cambiato, imposto stato
-   if ( pScene->GetShowTriaAdvanced() != bAdvanced) {
-     // imposto il nuovo stato
-      pScene->SetShowTriaAdvanced( bAdvanced) ;
-     // forzo ricalcolo della grafica di tutti gli oggetti
-      if ( ! MyResetGroupObjGraphics( pScene->GetGeomDB(), GDB_ID_ROOT))
-         return false ;
-   }
+  // imposto stato
+   pScene->SetShowTriaAdvanced( bAdvanced) ;
   if ( bRedraw)
      pScene->RedrawWindow() ;
-   return true ;
+   return TRUE ;
 }

 //-----------------------------------------------------------------------------
@@ -525,50 +440,17 @@ ExeGetShowTriaAdv( void)
   return pScene->GetShowTriaAdvanced() ;
 }

-//-------------------------------------------------------------------------------
-bool
-ExeSetShowSurfBezierTol( double dLinTol, bool bRedraw) 
-{
-   IEGrScene* pScene = GetCurrScene() ;
-   VERIFY_SCENE( pScene, false)
-  // se diverso, imposto il nuovo valore
-   if ( abs( GetSurfBezierAuxSurfTol() - dLinTol) > 10 * EPS_SMALL) {
-     // imposto il nuovo valore di approssimazione
-      SetSurfBezierAuxSurfTol( dLinTol) ;
-     // forzo ricalcolo della grafica di tutti gli oggetti
-      if ( ! MyResetGroupObjGraphics( pScene->GetGeomDB(), GDB_ID_ROOT))
-         return false ;
-   }
-   if ( bRedraw)
-      pScene->RedrawWindow() ;
-   return true ;
-}
-
-//-----------------------------------------------------------------------------
-double
-ExeGetShowSurfBezierTol( void)
-{
-  // recupero il valore
-   return GetSurfBezierAuxSurfTol() ;
-}
-
 //-----------------------------------------------------------------------------
 bool
 ExeSetShowZmap( int nMode, bool bRedraw)
 {
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
-  // se cambiato, imposto il nuovo stato
-   if ( pScene->GetShowZmap() != nMode) {
-     // imposto il nuovo stato
-      pScene->SetShowZmap( nMode) ;
-     // forzo ricalcolo della grafica di tutti gli oggetti
-      if ( ! MyResetGroupObjGraphics( pScene->GetGeomDB(), GDB_ID_ROOT))
-         return false ;
-   }
+  // imposto stato
+   pScene->SetShowZmap( nMode) ;
   if ( bRedraw)
      pScene->RedrawWindow() ;
-   return true ;
+   return TRUE ;
 }

 //-----------------------------------------------------------------------------
@@ -576,7 +458,7 @@ int
 ExeGetShowZmap( void)
 {
   IEGrScene* pScene = GetCurrScene() ;
-   VERIFY_SCENE( pScene, -1)
+   VERIFY_SCENE( pScene, false)
  // recupero lo stato
   return pScene->GetShowZmap() ;
 }
@@ -598,10 +480,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)

@@ -749,23 +627,10 @@ ExeZoomWin( int nPrevX, int nPrevY, int nCurrX, int nCurrY, bool bRedraw)
   return true ;
 }

-//-----------------------------------------------------------------------------
-bool
-ExeSetViewOrizzOffsStep( int nDirOffsStep)
-{
-   IEGrScene* pScene = GetCurrScene() ;
-   VERIFY_SCENE( pScene, false)
-   return pScene->SetCameraDirOrizzOffset( 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
@@ -831,19 +696,6 @@ ExeRotateView( int nPrevX, int nPrevY, int nCurrX, int nCurrY, bool bRedraw)
   return true ;
 }

-//-----------------------------------------------------------------------------
-bool
-ExeGetViewOrizzOffsStep( int* pnDirOffsStep)
-{
-   IEGrScene* pScene = GetCurrScene() ;
-   VERIFY_SCENE( pScene, false)
-  // recupero offset direzione di vista
-   if ( pnDirOffsStep == nullptr)
-      return false ;
-   *pnDirOffsStep = pScene->GetCameraDirOrizzOffset() ;
-   return true ;
-}
-
 //-----------------------------------------------------------------------------
 bool
 ExeGetView( int* pnDir)
@@ -1000,97 +852,3 @@ ExeGetImage( int nShowMode, Color colBackTop, Color colBackBottom,
  // creo e salvo una immagine della scena
   return pScene->GetImage( nShowMode, colBackTop, colBackBottom, nWidth, nHeight, sFile) ;
 }
-
-//-------------------------------------------------------------------------------
-static int    s_nContext = 0 ;
-static int    s_nDriver = 3 ;
-static bool   s_b2Buff = true ;
-static int    s_nColorBits = 32 ;
-static int    s_nDepthBits = 24 ;
-static int    s_nShowMode = SM_SHADING ;
-static Color  s_colBackTop = WHITE ;
-static Color  s_colBackBottom = WHITE ;
-static int    s_nCameraDir = CT_TOP ;
-static int    s_nWidth = 1024 ;
-static int    s_nHeight = 1024 ;
-static string s_sImageFile ;
-
-//-------------------------------------------------------------------------------
-BOOL
-CALLBACK SceneBoxProc( HWND hwndDlg, UINT message, WPARAM wParam, LPARAM lParam) 
-{ 
-   switch ( message) {
-   case WM_INITDIALOG :
-      {
-        // imposto dimensione box e picture
-         const int WIN_MAX_DIM = ( s_nDriver == 1 ? 512 : 1024) ;
-         int nWinW = ( s_nWidth >= s_nHeight ? WIN_MAX_DIM : ( WIN_MAX_DIM * s_nWidth) / s_nHeight) ;
-         int nWinH = ( s_nHeight >= s_nWidth ? WIN_MAX_DIM : ( WIN_MAX_DIM * s_nHeight) / s_nWidth) ;
-         HWND hPic = GetDlgItem( hwndDlg, IDC_PICTURE1) ;
-         SetWindowPos( hwndDlg, HWND_TOP, 0, 0, nWinW, nWinH, SWP_NOMOVE | SWP_NOREPOSITION) ;
-         SetWindowPos( hPic, HWND_TOP, 0, 0, nWinW, nWinH, SWP_NOMOVE | SWP_NOREPOSITION) ;
-        // imposto scena
-         int nContext = GetIndCurrGseContext() ;
-         GseContext* pGseCtx = GetGseContext( nContext) ;
-         if ( pGseCtx != nullptr  &&  pGseCtx->m_pScene == nullptr) {
-            ExeInitScene( hPic, s_nDriver, s_b2Buff, s_nColorBits, s_nDepthBits) ;
-            if ( pGseCtx->m_pGeomDB != nullptr  &&  pGseCtx->m_pScene != nullptr) {
-               s_nContext = nContext ;
-               pGseCtx->m_pScene->SetCamera( s_nCameraDir) ;
-               pGseCtx->m_pScene->ZoomAll() ;
-               if ( ! pGseCtx->m_pScene->GetImage( s_nShowMode, s_colBackTop, s_colBackBottom, s_nWidth, s_nHeight, s_sImageFile))
-                  s_nContext = -s_nContext ;
-               MyResetGroupObjGraphics( pGseCtx->m_pGeomDB, GDB_ID_ROOT) ;
-               EndDialog( hwndDlg, wParam) ; 
-            }
-            else {
-               s_nContext = 0 ;
-               EndDialog( hwndDlg, wParam) ; 
-            }
-         }
-         else
-            s_nContext = 0 ;
-      }
-      break ;
-   }
-   return FALSE ;
-}
-
-//-------------------------------------------------------------------------------
-bool
-ExeGetImageEx( int nDriver, bool b2Buff, int nColorBits, int nDepthBits,
-               int nShowMode, Color colBackTop, Color colBackBottom,
-               int nCameraDir, int nWidth, int nHeight, const string& sFile)
-{
-  // Se il contesto corrente possiede già una scena
-   if ( GetCurrScene() != nullptr) {
-      return ExeGetImage( nShowMode, colBackTop, colBackBottom, nWidth, nHeight, sFile) ;
-   }
-  // altrimenti ne creo una temporanea
-   else {
-     // salvo i parametri
-      s_nDriver = nDriver ;
-      s_b2Buff = b2Buff ;
-      s_nColorBits = nColorBits ;
-      s_nDepthBits = nDepthBits ;
-      s_nShowMode = nShowMode ;
-      s_colBackTop = colBackTop ;
-      s_colBackBottom = colBackBottom ;
-      s_nCameraDir = nCameraDir ;
-      s_nWidth = nWidth ;
-      s_nHeight = nHeight ;
-      s_sImageFile = sFile ;
-     // lancio dialogo
-      HWND hTopWnd = ExeGetMainWindowHandle() ;
-      DialogBox( GetModuleIstance(), MAKEINTRESOURCE( IDD_LUASCENE), hTopWnd, (DLGPROC)SceneBoxProc) ;
-      bool bOk = ( s_nContext > 0) ;
-     // elimino la scena dal contesto
-      GseContext* pGseCtx = GetGseContext( abs( s_nContext)) ;
-      if ( pGseCtx != nullptr) {
-         delete pGseCtx->m_pScene ;
-         pGseCtx->m_pScene = nullptr ;
-      }
-      s_nContext = 0 ;
-      return bOk ;
-   }
-}
@@ -1,317 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2024-2024
-//----------------------------------------------------------------------------
-// File : EXE_TestObjSurface.cpp    Data : 24.03.24      Versione : 2.6c2
-// Contenuto : Funzioni per verificare collisioni tra
-//             Objects e Superfici (TriMesh).
-//
-//
-// Modifiche : 09.01.20 DS Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-//--------------------------- Include ----------------------------------------
-#include "stdafx.h"
-#include "EXE.h"
-#include "EXE_Macro.h"
-#include "EXE_Const.h"
-#include "AuxTools.h"
-#include "GeoTools.h"
-#include "/EgtDev/Include/EXeExecutor.h"
-#include "/EgtDev/Include/EXeConst.h"
-#include "/EgtDev/Include/EGkCDeBoxClosedSurfTm.h"
-#include "/EgtDev/Include/EGkCDeRectPrismoidClosedSurfTm.h"
-#include "/EgtDev/Include/EGkCDeCylClosedSurfTm.h"
-#include "/EgtDev/Include/EGkCDeConeFrustumClosedSurfTm.h"
-#include "/EgtDev/Include/EGkCDeSpheClosedSurfTm.h"
-#include "/EgtDev/Include/EGkCDeClosedSurfTmClosedSurfTm.h"
-#include "/EgtDev/Include/EGkSurfLocal.h"
-#include "/EgtDev/Include/EGkStringUtils3d.h"
-
-using namespace std ;
-
-//----------------------------------------------------------------------------
-static int
-MyTestBoxSurfTm( const Frame3d& frBox, const Vector3d& vtDiag, int nSurfTmId, double dSafeDist, int nRefType)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, -1)
-  // recupero la superficie TriMesh
-   const ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nSurfTmId)) ;
-   if ( pStm == nullptr)
-      return -1 ;
-  // recupero il riferimento della superficie
-   Frame3d frSurf ;
-   if ( ! pGeomDB->GetGlobFrame( nSurfTmId, frSurf))
-      return -1 ;
-  // porto in locale alla superficie il riferimento del box (il vettore è già in questo stesso riferimento)
-   Frame3d frBoxL = GetFrameLocal( pGeomDB, frBox, nRefType, frSurf) ;
-   // verifico l'a collisione'interferenza
-   return ( TestBoxSurfTm( frBoxL, vtDiag, *pStm, dSafeDist) ? 1 : 0) ;
-}
-
-//----------------------------------------------------------------------------
-int
-ExeTestBoxSurface( const Frame3d& frBox, const Vector3d& vtDiag, int nSurfId, double dSafeDist, int nRefType)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   int nRes = -1 ;
-   if ( pGeomDB != nullptr  &&  pGeomDB->GetGeoType( nSurfId) == SRF_TRIMESH)
-      nRes = MyTestBoxSurfTm( frBox, vtDiag, nSurfId, dSafeDist, nRefType) ;
-   // è da aggiungere il test con le superfici di Bezier
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtTestBoxSurface({{" + ToString( frBox.Orig()) + "},{" +
-                                             ToString( frBox.VersX()) + "},{" +
-                                             ToString( frBox.VersY()) + "},{" +
-                                             ToString( frBox.VersZ()) + "}},{" +
-                                             ToString( vtDiag) + "}," +
-                                             IdToString( nSurfId) + "," +
-                                             ToString( dSafeDist) + "," +
-                                             RefTypeToString( nRefType) + ")" +
-                    " -- Res=" + ToString( nRes) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-  // restituisco risultato
-   return nRes ;
-}
-
-//----------------------------------------------------------------------------
-static int
-MyTestRectPrismoidSurfTm( const Frame3d& frPrismoid, double dBaseLenX, double dBaseLenY,
-                          double dTopLenX, double dTopLenY, double dHeight,
-                          int nSurfTmId, double dSafeDist, int nRefType)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, -1)
-  // recupero la superficie TriMesh
-   const ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nSurfTmId)) ;
-   if ( pStm == nullptr)
-      return -1 ;
-  // recupero il riferimento della superficie
-   Frame3d frSurf ;
-   if ( ! pGeomDB->GetGlobFrame( nSurfTmId, frSurf))
-      return -1 ;
-  // porto in locale alla superficie il riferimento del prismoide rettangolare
-   Frame3d frPrismoidL = GetFrameLocal( pGeomDB, frPrismoid, nRefType, frSurf) ;
-   // verifico l'a collisione'interferenza
-   return ( TestRectPrismoidSurfTm( frPrismoidL, dBaseLenX, dBaseLenY, dTopLenX, dTopLenY, dHeight, *pStm, dSafeDist) ? 1 : 0) ;
-}
-
-//----------------------------------------------------------------------------
-int
-ExeTestRectPrismoidSurface( const Frame3d& frPrismoid, double dBaseLenX, double dBaseLenY,
-                            double dTopLenX, double dTopLenY, double dHeight,
-                            int nSurfId, double dSafeDist, int nRefType)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   int nRes = -1 ;
-   if ( pGeomDB != nullptr  &&  pGeomDB->GetGeoType( nSurfId) == SRF_TRIMESH)
-      nRes = MyTestRectPrismoidSurfTm( frPrismoid, dBaseLenX, dBaseLenY, dTopLenX, dTopLenY, dHeight, nSurfId, dSafeDist, nRefType) ;
-   // è da aggiungere il test con le superfici di Bezier
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtTestRectPrismoidSurface({{" + ToString( frPrismoid.Orig()) + "},{" +
-                                                      ToString( frPrismoid.VersX()) + "},{" +
-                                                      ToString( frPrismoid.VersY()) + "},{" +
-                                                      ToString( frPrismoid.VersZ()) + "}}," +
-                                                      ToString( dBaseLenX) + "," +
-                                                      ToString( dBaseLenY) + "," +
-                                                      ToString( dTopLenX) + "," +
-                                                      ToString( dTopLenY) + "," +
-                                                      ToString( dHeight) + "," +
-                                                      IdToString( nSurfId) + "," +
-                                                      ToString( dSafeDist) + "," +
-                                                      RefTypeToString( nRefType) + ")" +
-                    " -- Res=" + ToString( nRes) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-  // restituisco risultato
-   return nRes ;
-}
-
-//----------------------------------------------------------------------------
-static int
-MyTestCylSurfTm( const Frame3d& frCyl, double dR, double dH, int nSurfTmId, double dSafeDist, int nRefType)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, -1)
-  // recupero la superficie TriMesh
-   const ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nSurfTmId)) ;
-   if ( pStm == nullptr)
-      return -1 ;
-  // recupero il riferimento della superficie
-   Frame3d frSurf ;
-   if ( ! pGeomDB->GetGlobFrame( nSurfTmId, frSurf))
-      return -1 ;
-  // porto in locale alla superficie il riferimento del cilindro
-   Frame3d frCylL = GetFrameLocal( pGeomDB, frCyl, nRefType, frSurf) ;
-  // verifico l'interferenza
-   return ( TestCylSurfTm( frCylL, dR, dH, *pStm, dSafeDist) ? 1 : 0) ;
-}
-
-//----------------------------------------------------------------------------
-int
-ExeTestCylSurface( const Frame3d& frCyl, double dR, double dH, int nSurfId, double dSafeDist, int nRefType)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   int nRes = -1 ;
-   if ( pGeomDB != nullptr  &&  pGeomDB->GetGeoType( nSurfId) == SRF_TRIMESH)
-      nRes = MyTestCylSurfTm( frCyl, dR, dH, nSurfId, dSafeDist, nRefType) ;
-   // è da aggiungere il test con le superfici di Bezier
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtTestCylSurface({{" + ToString( frCyl.Orig()) + "},{" +
-                                             ToString( frCyl.VersX()) + "},{" +
-                                             ToString( frCyl.VersY()) + "},{" +
-                                             ToString( frCyl.VersZ()) + "}}," +
-                                             ToString( dR) + "," +
-                                             ToString( dH) + "," +
-                                             IdToString( nSurfId) + "," +
-                                             ToString( dSafeDist) + "," +
-                                             RefTypeToString( nRefType) + ")" +
-                    " -- Res=" + ToString( nRes) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-  // restituisco risultato
-   return nRes ;
-}
-
-//----------------------------------------------------------------------------
-static int
-MyTestConeSurfTm( const Frame3d& frCone, double dR1, double dR2, double dH, int nSurfTmId, double dSafeDist, int nRefType)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, -1)
-  // recupero la superficie TriMesh
-   const ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nSurfTmId)) ;
-   if ( pStm == nullptr)
-      return -1 ;
-  // recupero il riferimento della superficie
-   Frame3d frSurf ;
-   if ( ! pGeomDB->GetGlobFrame( nSurfTmId, frSurf))
-      return -1 ;
-  // porto in locale alla superficie il riferimento del cilindro
-   Frame3d frConeL = GetFrameLocal( pGeomDB, frCone, nRefType, frSurf) ;
-  // verifico l'interferenza
-   return ( TestConeFrustumSurfTm( frConeL, dR1, dR2, dH, *pStm, dSafeDist) ? 1 : 0) ;
-}
-
-//----------------------------------------------------------------------------
-int
-ExeTestConeSurface( const Frame3d& frCone, double dR1, double dR2, double dH, int nSurfId, double dSafeDist, int nRefType)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   int nRes = -1 ;
-   if ( pGeomDB != nullptr  &&  pGeomDB->GetGeoType( nSurfId) == SRF_TRIMESH)
-      nRes = MyTestConeSurfTm( frCone, dR1, dR2, dH, nSurfId, dSafeDist, nRefType) ;
-   // è da aggiungere il test con le superfici di Bezier
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtTestConeSurface({{" + ToString( frCone.Orig()) + "},{" +
-                                              ToString( frCone.VersX()) + "},{" +
-                                              ToString( frCone.VersY()) + "},{" +
-                                              ToString( frCone.VersZ()) + "}}," +
-                                              ToString( dR1) + "," +
-                                              ToString( dR2) + "," +
-                                              ToString( dH) + "," +
-                                              IdToString( nSurfId) + "," +
-                                              ToString( dSafeDist) + "," +
-                                              RefTypeToString( nRefType) + ")" +
-                    " -- Res=" + ToString( nRes) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-  // restituisco risultato
-   return nRes ;
-}
-
-//----------------------------------------------------------------------------
-static int
-MyTestSpheSurfTm( const Point3d& ptCen, double dR, int nSurfTmId, double dSafeDist, int nRefType)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, -1)
-  // recupero la superficie TriMesh
-   const ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nSurfTmId)) ;
-   if ( pStm == nullptr)
-      return -1 ;
-  // recupero il riferimento della superficie
-   Frame3d frSurf ;
-   if ( ! pGeomDB->GetGlobFrame( nSurfTmId, frSurf))
-      return -1 ;
-  // porto in locale alla superficie il centro della sfera
-   Point3d ptCenL = GetPointLocal( pGeomDB, ptCen, nRefType, frSurf) ;
-   // verifico l'interferenza
-   return ( TestSpheSurfTm( ptCenL, dR, *pStm, dSafeDist) ? 1 : 0) ;
-}
-
-//----------------------------------------------------------------------------
-int
-ExeTestSpheSurface( const Point3d& ptCen, double dR, int nSurfId, double dSafeDist, int nRefType)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   int nRes = -1 ;
-   if ( pGeomDB != nullptr  &&  pGeomDB->GetGeoType( nSurfId) == SRF_TRIMESH)
-      nRes = MyTestSpheSurfTm( ptCen, dR, nSurfId, dSafeDist, nRefType) ;
-   // è da aggiungere il test con le superfici di Bezier
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtTestSpheSurface({" + ToString( ptCen) + "}," +
-                                             ToString( dR) + "," +
-                                             IdToString( nSurfId) + "," +
-                                             ToString( dSafeDist) + "," +
-                                             RefTypeToString( nRefType) + ")" +
-                    " -- Res=" + ToString( nRes) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-  // restituisco risultato
-   return nRes ;
-}
-
-//----------------------------------------------------------------------------
-static int
-MyTestSurfTmSurfTm( int nSurfTm1Id, int nSurfTm2Id, double dSafeDist, bool bTestEnclosion)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, -1)
-  // recupero il riferimento della seconda superficie
-   Frame3d frSurf2 ;
-   if ( ! pGeomDB->GetGlobFrame( nSurfTm2Id, frSurf2))
-      return -1 ;
-  // recupero la prima superficie in locale alla seconda
-   SurfLocal Surf1Loc( pGeomDB, nSurfTm1Id, frSurf2) ;
-   const ISurfTriMesh* pStm1 = GetSurfTriMesh( Surf1Loc) ;
-   if ( pStm1 == nullptr)
-      return -1 ;
-  // recupero la seconda superficie TriMesh
-   const ISurfTriMesh* pStm2 = GetSurfTriMesh( pGeomDB->GetGeoObj( nSurfTm2Id)) ;
-   if ( pStm2 == nullptr)
-      return -1 ;
-   // verifico  l'interferenza
-   return ( TestSurfTmSurfTm( *pStm1, *pStm2, dSafeDist, bTestEnclosion) ? 1 : 0) ;
-}
-
-//----------------------------------------------------------------------------
-int
-ExeTestSurfaceSurface( int nSurf1Id, int nSurf2Id, double dSafeDist, bool bTestEnclosion)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   int nRes = -1 ;
-   if ( pGeomDB != nullptr) {
-      if ( pGeomDB->GetGeoType( nSurf1Id) == SRF_TRIMESH  &&  pGeomDB->GetGeoType( nSurf2Id) == SRF_TRIMESH)
-         nRes = MyTestSurfTmSurfTm( nSurf1Id, nSurf2Id, dSafeDist, bTestEnclosion) ;
-     // è da aggiungere il test con le superfici di Bezier
-   }
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtTestSurfaceSurface({" + IdToString( nSurf1Id) + "," +
-                                                IdToString( nSurf2Id) + "," +
-                                                ToString( dSafeDist) + "," +
-                                                ( bTestEnclosion ? "true" : "false") + ")" +
-                    " -- Res=" + ToString( nRes) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-  // restituisco risultato
-   return nRes ;
-}
@@ -1,895 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2025-2025
-//----------------------------------------------------------------------------
-// File : EXE_Trimming.cpp       Data : 25.10.25        Versione : 2.7j3
-// Funzioni per le lavorazioni di Trimming.
-//
-// Modifiche : 23.10.25 RE Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-//--------------------------- Include ----------------------------------------
-#include "stdafx.h"
-#include "EXE.h"
-#include "EXE_Macro.h"
-#include "DllExchange.h"
-#include "GeoTools.h"
-#include "AuxTools.h"
-#include "/EgtDev/Include/EgtNumUtils.h"
-#include "/EgtDev/Include/EXeExecutor.h"
-#include "/EgtDev/Include/EgtPointerOwner.h"
-#include "/EgtDev/Include/EGkSurfLocal.h"
-#include "/EgtDev/Include/EGkCurveComposite.h"
-#include "/EgtDev/Include/EGkTrimming.h"
-#include "/EgtDev/Include/EGkStmFromTriangleSoup.h"
-#include "/EgtDev/Include/EGkDistPointCurve.h"
-#include <unordered_map>
-#include <algorithm>
-
-using namespace std ;
-
-// ---------------------------------------------------------------------------
-bool
-ExeTrimmingGetHoleBorder( int nParentId, const INTVECTOR& vSurfIds, const INTVECTOR& vOtherSurfIds,
-                          double dSurfLinTol, double dSurfAngTol, double dEdgeLinTol, double dEdgeAngTol,
-                          double dEdgeThick, int& nFirstId, int& nCount)
-{
-  // Verifica database geometrico
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-
-  // Inizializzo i valori di ritorno
-   nFirstId = GDB_ID_NULL ;
-   nCount = 0 ;
-
-  // Se non ho geometrie da ricercare, non faccio nulla
-   if ( vSurfIds.empty())
-      return true ;
-
-  // Recupero le superfici da cui estrarre i bordi
-   CISURFPVECTOR vpSurfs ; vpSurfs.reserve( vSurfIds.size()) ;
-   for ( int i = 0 ; i < ssize( vSurfIds) ; ++ i) {
-      int nSurfId = vSurfIds[i] ;
-     // Recupero l'entità
-      const IGeoObj* pGeoObj = pGeomDB->GetGeoObj( nSurfId) ;
-      if ( pGeoObj != nullptr) {
-        // Recupero il Tipo
-         int nType = pGeoObj->GetType() ;
-         if ( nType == SRF_TRIMESH  ||  nType == SRF_BEZIER) {
-           // Recupero la superficie
-            const ISurf* pSurf = GetSurf( pGeoObj) ;
-            if ( pSurf != nullptr  &&  pSurf->IsValid())
-               vpSurfs.emplace_back( pSurf) ;
-         }
-      }
-   }
-  // Se non ho superfici non faccio nulla
-   if ( vpSurfs.empty())
-      return false ;
-
-  // Calcolo il Centroide delle superfici complessive
-   Point3d ptRef = P_INVALID ;
-   if ( ! vOtherSurfIds.empty()) {
-      int nToTSurf = 0 ;
-      for ( int nOtherSurfId : vOtherSurfIds) {
-        // Recupero l'entità
-         const IGeoObj* pGeoObj = pGeomDB->GetGeoObj( nOtherSurfId) ;
-         if ( pGeoObj != nullptr) {
-           // Recupero il Tipo
-            int nType = pGeoObj->GetType() ;
-            if ( nType == SRF_TRIMESH  ||  nType == SRF_BEZIER) {
-              // Recupero la superficie
-               const ISurf* pSurf = GetSurf( pGeoObj) ;
-               if ( pSurf != nullptr  &&  pSurf->IsValid()) {
-                 // Recupero il Centroide
-                  Point3d ptCentroid ;
-                  pSurf->GetCentroid( ptCentroid) ;
-                  if ( ! ptRef.IsValid())
-                     ptRef = ptCentroid ;
-                  else
-                     ptRef += ptCentroid ;
-                  ++ nToTSurf ;
-               }
-            }
-         }
-      }
-      if ( nToTSurf > 0) {
-         for ( const ISurf* pSurf : vpSurfs) {
-            Point3d ptCentroid ;
-            pSurf->GetCentroid( ptCentroid) ;
-            if ( ! ptRef.IsValid())
-               ptRef = ptCentroid ;
-            else
-               ptRef += ptCentroid ;
-            ++ nToTSurf ;
-         }
-         ptRef /= nToTSurf ;
-      }
-   }
-
-  // Recupero i Bordi per fori ed asole
-   ICRVCOMPOPOVECTOR vHoleBorders ;
-   bool bOk = GetTrimmingHoleBorders( vpSurfs, ptRef, dSurfLinTol, dSurfAngTol, dEdgeLinTol, dEdgeAngTol,
-                                      dEdgeThick, vHoleBorders) ;
-   if ( bOk) {
-     // Inserisco le curve nel DB e imposto i parametri di ritorno
-      bool bFirst = true ;
-      for ( int i = 0 ; bOk && i < ssize( vHoleBorders) ; ++ i) {
-        // Verifico che sia valida
-         if ( ! IsNull( vHoleBorders[i])  &&  vHoleBorders[i]->IsValid()) {
-            int nCrvId = pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( vHoleBorders[i])) ;
-            bOk = ( nCrvId != GDB_ID_NULL) ;
-            if ( bOk) {
-               ++ nCount ;
-               if ( bFirst) {
-                  nFirstId = nCrvId ;
-                  bFirst = false ;
-               }
-            }
-         }
-      }
-   }
-
-   ExeSetModified() ;
-  // Se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtTrimmingGetHoleBorder(" + ToString( nParentId) + "," +
-                                                  ToString( vSurfIds) + "," +
-                                                  ToString( dSurfLinTol) + "," +
-                                                  ToString( dSurfAngTol) + "," +
-                                                  ToString( dEdgeLinTol) + "," +
-                                                  ToString( dEdgeAngTol) + "," +
-                                                  ToString( dEdgeThick) + ")" +
-                    " bOk=" + ToString( bOk) +
-                    " nNewSurfId=" + ToString( nFirstId) + ", nCount= " + ToString( nCount) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-
-   return bOk ;
-}
-
-// ---------------------------------------------------------------------------
-int
-ExeTrimmingGetSurfTmFaceAdj( int nParentId, int nSurfId, int nTria, const Point3d& ptTria,
-                             double dAngTol, double dSize, double dSizeTol)
-{
-  // Verifica database geometrico
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-
-  // Recupero la superficie TriMesh
-   const ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nSurfId)) ;
-   bool bOk = ( pStm != nullptr  &&  pStm->IsValid()) ;
-
-  // Recupero la superficie formata dai triangoli di adiacenza
-   int nNewSurfId = GDB_ID_NULL ;
-   if ( bOk) {
-      PtrOwner<ISurfTriMesh> pStmAdjFace( CreateSurfTriMesh()) ;
-      bOk = ( ! IsNull( pStmAdjFace) && pStmAdjFace->AdjustTopology()) ;
-      bOk = GetTrimmingStmAdjTria( pStm, nTria, ptTria, dAngTol, dSize, dSizeTol, pStmAdjFace) ;
-      bOk = ( ! IsNull( pStmAdjFace) && pStmAdjFace->IsValid() && pStmAdjFace->GetTriangleCount() > 0) ;
-     // Inserisco la Superficie nel DB geometrico
-      if ( bOk) {
-         nNewSurfId = pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pStmAdjFace)) ;
-         bOk = ( nNewSurfId != GDB_ID_NULL) ;
-      }
-   }
-
-   ExeSetModified() ;
-  // Se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtTrimmingGetSurfTmFromFaceAdj(" + ToString( nParentId) + "," +
-                                                         ToString( nSurfId) + "," +
-                                                         ToString( nTria) + "," +
-                                                         "{ " + ToString( ptTria.x) + "," +
-                                                                ToString( ptTria.y) + "," +
-                                                                ToString( ptTria.z) + "}," +
-                                                         ToString( dAngTol) + ")" +
-                    " nNewSurfId=" + ToString( nNewSurfId) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-
-   return nNewSurfId ;
-}
-
-// ---------------------------------------------------------------------------
-int
-ExeTrimmingGetSurfTmFromStmFaces( int nParentId, int nSurfId, const INTVECTOR& vFaces)
-{
-  // Verifica database geometrico
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
-
-  // Recupero il riferimento del gruppo di destinazione
-   Frame3d frDest ;
-   if ( ! pGeomDB->GetGlobFrame( nParentId, frDest))
-      return GDB_ID_NULL ;
-
-  // Recupero la superficie TriMesh
-   const ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nSurfId)) ;
-   if ( pStm == nullptr  ||  ! pStm->IsValid())
-      return GDB_ID_NULL ;
-
-  // Verifico che le facce appartengano alla superficie
-   if ( vFaces.empty())
-      return CMD_ID_NULL ;
-   for ( int nF = 0 ; nF < int( vFaces.size()) ; ++ nF) {
-      double dArea = 0. ;
-      if ( ! pStm->GetFacetArea( vFaces[nF], dArea))
-         return GDB_ID_NULL ;
-   }
-
-  // Definisco la superficie
-   StmFromTriangleSoup TriaSoup ;
-   TriaSoup.Start() ;
-   for ( int nF = 0 ; nF < int( vFaces.size()) ; ++ nF) {
-      INTVECTOR vT ;
-      if ( ! pStm->GetAllTriaInFacet( vFaces[nF], vT))
-         return GDB_ID_NULL ;
-      for ( int nT = 0 ; nT < int( vT.size()) ; ++ nT) {
-         Triangle3d Tria ;
-         if ( ! pStm->GetTriangle( vT[nT], Tria)  ||  ! TriaSoup.AddTriangle( Tria))
-            return GDB_ID_NULL ;
-      }
-   }
-   TriaSoup.End() ;
-   PtrOwner<ISurfTriMesh> pStmTria( TriaSoup.GetSurf()) ;
-   if ( IsNull( pStmTria)  || ! pStmTria->IsValid()  ||  pStmTria->GetTriangleCount() == 0)
-      return GDB_ID_NULL ;
-
-  // Aggiungo la superficie al DB
-   int nNewSurfId = pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pStmTria)) ;
-
-   ExeSetModified() ;
-  // Se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "TrimmingGetSurfTmFromStmFaces(" + ToString( nParentId) + "," +
-                                                       ToString( nSurfId) + "," +
-                                                       ToString( vFaces) + ")" +
-                    " -- nId=" + ToString( nNewSurfId)  ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-
-   return nNewSurfId ;
-}
-
-// ---------------------------------------------------------------------------
-bool
-ExeTrimmingGetAdjSurfs( const INTVECTOR& vSurfId, const INTVECTOR& vOtherSurfId, double dLinTol,
-                        double dAngTol, double dAngFaceTol, INTVECTOR& vResId)
-{
-  // Verifica database geometrico
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-
-  // Recupero le superfici di Riferimento
-   CISURFPVECTOR vRefSurf ; vRefSurf.reserve( vSurfId.size()) ;
-   bool bOk = true ;
-   for ( int i = 0 ; bOk && i < int( vSurfId.size()) ; ++ i) {
-      const ISurf* pSurf = GetSurf( pGeomDB->GetGeoObj( vSurfId[i])) ;
-      bOk = ( pSurf != nullptr && pSurf->IsValid()) ;
-      vRefSurf.emplace_back( pSurf) ;
-   }
-
-  // Recupero le superfici complessive, escludendo eventualmente quelle di riferimento se presenti
-   CISURFPVECTOR vOtherSurf ; vOtherSurf.reserve( vOtherSurfId.size()) ;
-   INTVECTOR vIds ;
-   for ( int i = 0 ; bOk && i < int( vOtherSurfId.size()) ; ++ i) {
-      if ( find( vSurfId.begin(), vSurfId.end(), vOtherSurfId[i]) == vSurfId.end()) {
-         const ISurf* pSurf = GetSurf( pGeomDB->GetGeoObj( vOtherSurfId[i])) ;
-         bOk = ( pSurf != nullptr && pSurf->IsValid()) ;
-         vOtherSurf.emplace_back( pSurf) ;
-         vIds.push_back( vOtherSurfId[i]) ;
-      }
-   }
-
-  // Recupero le facce adiancenti nella tolleranza richiesta
-   INTVECTOR vMyInds ;
-   bOk = bOk && GetTrimmingAdjSurfs( vRefSurf, vOtherSurf, dLinTol, dAngTol, dAngFaceTol, vMyInds) ;
-   if ( bOk) {
-      for ( int myInd : vMyInds)
-         vResId.push_back( vIds[myInd]) ;
-   }
-
-   ExeSetModified() ;
-  // Se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtTrimmingGetAdjSurfs(" + ToString( vSurfId) + "," +
-                                                ToString( vOtherSurfId) + "," +
-                                                ToString( dAngTol) + ")" +
-                    " -- bOk=" + ToString( bOk) + ",vResId=" + ToString( vResId) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-
-   return bOk ;
-}
-
-// ---------------------------------------------------------------------------
-bool
-ExeTrimmingGetBorders( int nParentId, const SELVECTOR& vIds, double dSurfLinTol, double dSurfAngTol,
-                       double dLinTol, double dAngTol, int& nFirstId, int& nCount)
-{
-  // Verifica database geometrico
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-
-  // Parametri da restituire
-   nFirstId = GDB_ID_NULL ;
-   nCount = 0 ;
-
-  // vIds : vettore di { nId = SurfId, nSubId = nSurfFace }
-  // Controllo che vIds non sia vuoto
-   bool bOk = ( ! vIds.empty()) ;
-  // Recupero il riferimento della prima superficie
-   Frame3d frSurf ;
-   bOk = bOk && pGeomDB->GetGlobFrame( vIds[0].nId, frSurf) ;
-  // Recupero il riferimento dei gruppi di destinazione
-   Frame3d frDest ;
-   bOk = bOk && pGeomDB->GetGlobFrame( nParentId, frDest) ;
-  // Recupero gli Id univoci delle superfici selezionate
-   INTSET setUniqueId ;
-   for ( const SelData& nIds : vIds)
-      setUniqueId.insert( nIds.nId) ;
-  // Recupero le superfici e le porto tutte in locale alla prima
-   unordered_map<int, int> uMapPos ; uMapPos.reserve( setUniqueId.size()) ;
-   SURFLOCALVECTOR vSurfL ; vSurfL.reserve( setUniqueId.size()) ;
-   CISURFPVECTOR vpSurf ; vpSurf.reserve( setUniqueId.size()) ;
-   int nSurf = 0 ;
-   for ( auto nIter = setUniqueId.begin() ; bOk && nIter != setUniqueId.end() ; ++ nIter) {
-      vSurfL.emplace_back( pGeomDB, *nIter, frSurf) ;
-      bOk = ( vSurfL.back().Get() != nullptr) ;
-      vpSurf.emplace_back( vSurfL.back().Get()) ;
-      uMapPos[*nIter] = nSurf ;
-      ++ nSurf ;
-   }
-  // Recupero il vettore di Selezione associato non più agli Id delle superficie ma alle loro posizioni nel vettore
-   SELVECTOR vFaces ; vFaces.reserve( vIds.size()) ;
-   for ( int i = 0 ; bOk && i < int( vIds.size()) ; ++ i)
-      vFaces.emplace_back( uMapPos[vIds[i].nId], vIds[i].nSub) ;
-
-  // Calcolo le curve di Edge grezze ( quindi i tratti lineari)
-   ICRVCOMPOPOVECTOR vRawEdges ;
-   bOk = bOk && GetTrimmingRawEdges( vpSurf, vFaces, dSurfLinTol, dSurfAngTol, vRawEdges) &&
-                ( ! vRawEdges.empty()) ;
-
-  // Calcolo le curve di Edge approssimate mediante curve di Bezier
-   ICRVCOMPOPOVECTOR vBezierEdges ;
-   bOk = bOk && GetTrimmingBezierEdges( vRawEdges, dLinTol, dAngTol, vBezierEdges) ;
-   nCount = int( vBezierEdges.size()) ;
-   if ( bOk) {
-     // Scorro i gli Edges ottenuti
-      for ( int nCrv = 0 ; bOk && nCrv < nCount ; ++ nCrv) {
-         vBezierEdges[nCrv]->ToLoc( frDest) ;
-        // Inserisco la curva nel DB Geometrico
-         int nCurrId = pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( vBezierEdges[nCrv])) ;
-         bOk = ( nCurrId != GDB_ID_NULL) ;
-         if ( nCrv == 0)
-            nFirstId = nCurrId ;
-      }
-   }
-
-   ExeSetModified() ;
-  // Se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtTrimmingGetBorders(" + IdToString( nParentId) + "," +
-                                               ToString( dSurfLinTol) + "," +
-                                               ToString( dSurfAngTol) + "," +
-                                               ToString( dLinTol) + "," +
-                                               ToString( dAngTol) + ")" ;
-      sLua += " -- bOk=" + ToString( bOk) +
-              " -- FirstId=" + ToString( nFirstId) + " CurveCount=" + ToString( nCount) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-
-   return bOk ;
-}
-
-// ---------------------------------------------------------------------------
-bool
-ExeTrimmingGetBordersByNormals( int nParentId, const SELVECTOR& vIds, double dSurfLinTol,
-                                double dSurfAngTol, double dLinTol, double dAngTol, double dThick,
-                                int& nFirstId, int& nCount)
-{
-  // Verifica database geometrico
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-
-  // Parametri da restituire
-   nFirstId = GDB_ID_NULL ;
-   nCount = 0 ;
-
-  // vIds : vettore di { nId = SurfId, nSubId = nSurfFace }
-  // Controllo che vIds non sia vuoto
-   bool bOk = ( ! vIds.empty()) ;
-  // Recupero il riferimento della prima superficie
-   Frame3d frSurf ;
-   bOk = bOk && pGeomDB->GetGlobFrame( vIds[0].nId, frSurf) ;
-  // Recupero il riferimento dei gruppi di destinazione
-   Frame3d frDest ;
-   bOk = bOk && pGeomDB->GetGlobFrame( nParentId, frDest) ;
-  // Recupero gli Id univoci delle superfici selezionate
-   INTSET setUniqueId ;
-   for ( const SelData& nIds : vIds)
-      setUniqueId.insert( nIds.nId) ;
-  // Recupero le superfici e le porto tutte in locale alla prima
-   unordered_map<int, int> uMapPos ; uMapPos.reserve( setUniqueId.size()) ;
-   SURFLOCALVECTOR vSurfL ; vSurfL.reserve( setUniqueId.size()) ;
-   CISURFPVECTOR vpSurf ; vpSurf.reserve( setUniqueId.size()) ;
-   int nSurf = 0 ;
-   for ( auto nIter = setUniqueId.begin() ; bOk && nIter != setUniqueId.end() ; ++ nIter) {
-      vSurfL.emplace_back( pGeomDB, *nIter, frSurf) ;
-      bOk = ( vSurfL.back().Get() != nullptr) ;
-      vpSurf.emplace_back( vSurfL.back().Get()) ;
-      uMapPos[*nIter] = nSurf ;
-      ++ nSurf ;
-   }
-  // Recupero il vettore di Selezione associato non più agli Id delle superficie ma alle loro posizioni nel vettore
-   SELVECTOR vFaces ; vFaces.reserve( vIds.size()) ;
-   for ( int i = 0 ; bOk && i < int( vIds.size()) ; ++ i)
-      vFaces.emplace_back( uMapPos[vIds[i].nId], vIds[i].nSub) ;
-
-  // Calcolo le curve di Edge approssimate mediante curve di Bezier
-   ICRVCOMPOPOVECTOR vBezierEdges ;
-   bOk = bOk && GetTrimmingFinalBorders( vpSurf, vFaces, dSurfLinTol, dSurfAngTol, dLinTol, dAngTol, dThick, vBezierEdges) ;
-   if ( bOk) {
-      nCount = int( vBezierEdges.size()) ;
-     // Scorro i gli Edges ottenuti
-      for ( int nCrv = 0 ; bOk && nCrv < nCount ; ++ nCrv) {
-         vBezierEdges[nCrv]->ToLoc( frDest) ;
-        // Inserisco la curva nel DB Geometrico
-         int nCurrId = pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( vBezierEdges[nCrv])) ;
-         bOk = ( nCurrId != GDB_ID_NULL) ;
-         if ( nCrv == 0)
-            nFirstId = nCurrId ;
-      }
-   }
-
-   ExeSetModified() ;
-  // Se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtTrimmingGetBordersByNormals(" + IdToString( nParentId) + "," +
-                                                        ToString( dLinTol) + "," +
-                                                        ToString( dAngTol) + ")" ;
-      sLua += " -- bOk=" + ToString( bOk) +
-              " -- FirstId=" + ToString( nFirstId) + " CurveCount=" + ToString( nCount) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-
-   return bOk ;
-}
-
-// ---------------------------------------------------------------------------
-bool
-ExeTrimmingGetFinalBorders( int nParentId, const INTVECTOR& vCrvBezierId, double dLinTol, double dAngTol,
-                            const PNTVECTOR& vBrkPts, double dThick, double dThickTol,
-                            int& nFirstId, int& nCount)
-{
-  // Verifica database geometrico
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-
-  // Parametri da restituire
-   nFirstId = GDB_ID_NULL ;
-   nCount = 0 ;
-
-  // Recupero il riferimento del gruppo di destinazione
-   Frame3d frDest ;
-   bool bOk = ( pGeomDB->GetGlobFrame( nParentId, frDest)) ;
-
-  // Recupero le curve di Bordo approssimate come Bezier
-   ICRVCOMPOPOVECTOR vCompoBezierEdges ; vCompoBezierEdges.reserve( vCrvBezierId.size()) ;
-   for ( int nCrv = 0 ; bOk && nCrv < int( vCrvBezierId.size()) ; ++ nCrv) {
-      const ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( vCrvBezierId[nCrv])) ;
-      bOk = ( pCrv != nullptr && pCrv->IsValid()) ;
-      if ( bOk) {
-         PtrOwner<ICurveComposite> pCompoRawEdges( ConvertCurveToComposite( pCrv->Clone())) ;
-         bOk = ( ! IsNull( pCompoRawEdges) && pCompoRawEdges->IsValid() &&
-                 vCompoBezierEdges.emplace_back( Release( pCompoRawEdges))) ;
-      }
-   }
-
-  // Converto i punti in coppie di punti ( se dispari l'ultimo viene ignorato)
-   BIPNTVECTOR vBreakingPts ; vBreakingPts.reserve( int( int( vBrkPts.size()) / 2)) ;
-   for ( int nPt = 0 ; bOk && nPt < int( vBrkPts.size()) - 1 ; nPt += 2)
-      vBreakingPts.emplace_back( make_pair( vBrkPts[nPt], vBrkPts[nPt+1])) ;
-   if ( int( vBrkPts.size()) % 2 != 0)
-      LOG_INFO( GetCmdLogger(), "Warning in EgtExtractSurfFrChunkLoops : Odd number of breaking points") ;
-
-  // Calcolo le curve di Edge
-   bOk = bOk && GetTrimmingFinalBorders( vCompoBezierEdges, dLinTol, dAngTol, vBreakingPts, dThick, dThickTol) ;
-   nCount = int( vCompoBezierEdges.size()) ;
-   if ( bOk) {
-     // Scorro i gli Edges ottenuti
-      for ( int nCrv = 0 ; bOk && nCrv < nCount ; ++ nCrv) {
-         vCompoBezierEdges[nCrv]->ToLoc( frDest) ;
-        // Inserisco la curva nel DB Geometrico
-         int nCurrId = pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( vCompoBezierEdges[nCrv])) ;
-         bOk = ( nCurrId != GDB_ID_NULL) ;
-         if ( nCrv == 0)
-            nFirstId = nCurrId ;
-      }
-      ExeSetModified() ;
-   }
-
-  // Se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtTrimmingGetFinalBorders(" + IdToString( nParentId) + "," +
-                                                    ToString( vCrvBezierId) + "," +
-                                                    ToString( dLinTol) + "," +
-                                                    ToString( dAngTol) + "," ;
-      sLua += "{" ;
-      for ( int nP = 0 ; nP < int( vBrkPts.size()) ; ++ nP) {
-         sLua += "(" + ToString( vBrkPts[nP].x) + ", " + ToString( vBrkPts[nP].y) + ", " + ToString( vBrkPts[nP].z) + ")" +
-                 ( nP != int( vBrkPts.size()) - 1 ? "," : "") ;
-      }
-      sLua += "}" ;
-      sLua += ToString( dThick) + "," + ToString( dThickTol) + ")" ;
-      sLua += " -- bOk=" + ToString( bOk) +
-              " -- FirstId=" + ToString( nFirstId) + " CurveCount=" + ToString( nCount) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-
-   return bOk ;
-}
-
-// ---------------------------------------------------------------------------
-int
-ExeTrimmingGetRuledBezier( int nParentId, const INTVECTOR& vIds, int nEdge1Id, int nEdge2Id, double dLinTol,
-                           const INTVECTOR& vnLineId)
-{
-  // Verifica database geometrico
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
-
-  // Aggiusto la tolleranza lineare se necessario
-   double dMyLinTol = Clamp( dLinTol, EPS_SMALL, 1e5 * EPS_SMALL) ;
-
-  // Recupero il riferimento dei gruppi di destinazione
-   Frame3d frDest ;
-   bool bOk = pGeomDB->GetGlobFrame( nParentId, frDest) ;
-
-  // Recupero la prima curva
-   const ICurve* pCrvEdge1 = GetCurve( pGeomDB->GetGeoObj( nEdge1Id)) ;
-   bOk = bOk && ( pCrvEdge1 != nullptr && pCrvEdge1->IsValid()) ;
-
-  // Recupero la seconda curva
-   const ICurve* pCrvEdge2 = GetCurve( pGeomDB->GetGeoObj( nEdge2Id)) ;
-   bOk = bOk && ( pCrvEdge2 != nullptr && pCrvEdge2->IsValid()) ;
-
-  // Se ci sono delle superfici di riferimento
-   CISURFPVECTOR vpSurf ; vpSurf.reserve( vIds.size()) ;
-   if ( ! vIds.empty()) {
-      SURFLOCALVECTOR vSurfL ; vSurfL.reserve( vIds.size()) ;
-     // Recupero il riferimento della prima superficie
-      Frame3d frSurf ;
-      bOk = bOk && ( pGeomDB->GetGlobFrame( vIds[0], frSurf)) ;
-     // Porto le altre nel riferimento della prima
-      for ( int nSurf = 0 ; bOk && nSurf < int( vIds.size()) ; ++ nSurf) {
-         vSurfL.emplace_back( pGeomDB, vIds[nSurf], frSurf) ;
-         if ( vSurfL.back().Get() == nullptr) {
-            bOk = false ;
-            break ;
-         }
-         vpSurf.emplace_back( vSurfL.back().Get()) ;
-      }
-   }
-
-  // Recupero i punti di sincronizzazione ( se presenti)
-   BIPNTVECTOR vSyncPoints ; vSyncPoints.reserve( pGeomDB->GetGroupObjs( vnLineId.size())) ;
-   for ( int i = 0 ; bOk && i < ssize( vnLineId) ; ++ i) {
-     // Recupero la Curva
-      const ICurve* pLine = GetCurve( pGeomDB->GetGeoObj( vnLineId[i])) ;
-      bOk = bOk && ( pLine != nullptr && pLine->IsValid()) ;
-      if ( bOk) {
-        // Recupero gli Estremi
-         Point3d ptStart ; pLine->GetStartPoint( ptStart) ;
-         Point3d ptEnd ; pLine->GetEndPoint( ptEnd) ;
-        // Mi assicuro che gli estremi siano sulle curve di Bordo e orientati correttamente ( nel caso inverto)
-         double dSqDistS1 = INFINITO ;
-         if ( ! DistPointCurve( ptStart, *pCrvEdge1).GetSqDist( dSqDistS1))
-            continue ;
-         if ( dSqDistS1 < dLinTol * dLinTol) {
-            double dSqDistE2 = INFINITO ;
-            if ( ! DistPointCurve( ptEnd, *pCrvEdge2).GetSqDist( dSqDistE2)  ||
-                 dSqDistE2 > dLinTol * dLinTol)
-               continue ;
-         }
-         else {
-            double dSqDistS2 = INFINITO ;
-            if ( ! DistPointCurve( ptStart, *pCrvEdge2).GetSqDist( dSqDistS2)  ||
-                 dSqDistS2 > dLinTol * dLinTol)
-               continue ;
-            double dSqDistE1 = INFINITO ;
-            if ( ! DistPointCurve( ptEnd, *pCrvEdge1).GetSqDist( dSqDistE1)  ||
-                 dSqDistE1 > dLinTol * dLinTol)
-               continue ;
-            swap( ptStart, ptEnd) ;
-         }
-         vSyncPoints.emplace_back( make_pair( ptStart, ptEnd)) ;
-      }
-   }
-
-  // Recupero la superficie Bezier rigata
-   PtrOwner<ISurfBezier> pSurfBzRuled ;
-   if ( bOk) {
-      pSurfBzRuled.Set( GetTrimmingRuledBezier( vpSurf, pCrvEdge1, pCrvEdge2, dMyLinTol, vSyncPoints)) ;
-      bOk = bOk && ( ! IsNull( pSurfBzRuled) && pSurfBzRuled->IsValid()) ;
-   }
-
-  // Inserisco la curva nel DB Geometrico
-   int nSurfBzId = GDB_ID_NULL ;
-   if ( bOk) {
-      pSurfBzRuled->ToLoc( frDest) ;
-      nSurfBzId = pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSurfBzRuled)) ;
-      bOk = bOk && ( nSurfBzId != GDB_ID_NULL) ;
-   }
-
-   ExeSetModified() ;
-  // Se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtTrimmingGetRuledBezier(" + ToString( nParentId) + "," +
-                                                   ToString( vIds) + "," +
-                                                   ToString( nEdge1Id) + "," +
-                                                   ToString( nEdge2Id) + "," +
-                                                   ToString( dLinTol) + ")" +
-                    " -- bOk=" + ToString( bOk) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-
-  // Restituisco il risultato
-   return nSurfBzId ;
-}
-
-// ---------------------------------------------------------------------------
-bool
-ExeTrimmingInterpolateSyncLines( int nParentId, int nSync1Id, int nSync2Id, int nBorder1Id,
-                                 int nBorder2Id, double dEdgeLinTol, double dEdgeAngTol,
-                                 int& nFirstId, int& nCount)
-{
-  // Verifica database geometrico
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
-
-  // Reset parametri di ritorno
-   nFirstId = GDB_ID_NULL ;
-   nCount = 0 ;
-
-  // Aggiusto la tolleranza lineare e angolare se necessario
-   double dMyEdgeLinTol = Clamp( dEdgeLinTol, EPS_SMALL, 1e5 * EPS_SMALL) ;
-   double dMyEdgeAngTol = Clamp( dEdgeAngTol, EPS_ANG_SMALL, 60.) ;
-
-  // recupero le due curve di sincronizzazione
-   const ICurve* pSync1 = GetCurve( pGeomDB->GetGeoObj( nSync1Id)) ;
-   const ICurve* pSync2 = GetCurve( pGeomDB->GetGeoObj( nSync2Id)) ;
-   bool bOk = ( pSync1 != nullptr && pSync1->IsValid() &&
-                pSync2 != nullptr && pSync2->IsValid()) ;
-
-  // Recupero le due curve di bordo
-   const ICurve* pCrvEdge1 = GetCurve( pGeomDB->GetGeoObj( nBorder1Id)) ;
-   const ICurve* pCrvEdge2 = GetCurve( pGeomDB->GetGeoObj( nBorder2Id)) ;
-   bOk = bOk && ( pCrvEdge1 != nullptr && pCrvEdge1->IsValid()) ;
-   bOk = bOk && ( pCrvEdge2 != nullptr && pCrvEdge2->IsValid()) ;
-
-  // Calcolo le Curve di sincornizzazione Interpolate
-   BIPNTVECTOR vSyncPoints ;
-   bOk = bOk && GetTrimmingSyncInterpolation( pCrvEdge1, pCrvEdge2, pSync1, pSync2, dMyEdgeLinTol,
-                                              dMyEdgeAngTol, vSyncPoints) ;
-   if ( bOk  &&  ! vSyncPoints.empty()) {
-     // Inserisco le curve di sincronizzazione nel DB
-     // [orientate da pCrvEdge1 a pCrvEdge2]
-      for ( int i = 0 ; bOk && i < ssize( vSyncPoints) ; ++ i) {
-         PtrOwner<ICurveLine> pSyncLine( CreateCurveLine()) ;
-         bOk = ( ! IsNull( pSyncLine) && pSyncLine->Set( vSyncPoints[i].first, vSyncPoints[i].second)) ;
-         if ( bOk) {
-            if ( pCrvEdge1->IsPointOn( vSyncPoints[i].second, dMyEdgeLinTol))
-               pSyncLine->Invert() ;
-            int nSyncId = pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSyncLine)) ;
-            bOk = ( nSyncId != CMD_ID_NULL) ;
-            if ( i == 0)
-               nFirstId = nSyncId ;
-         }
-      }
-      nCount = ssize( vSyncPoints) ;
-   }
-
-   ExeSetModified() ;
-  // Se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtTrimmingInterpolateSyncLines(" + ToString( nParentId) + "," +
-                                                         ToString( nSync1Id) + "," +
-                                                         ToString( nSync2Id) + "," +
-                                                         ToString( nBorder1Id) + "," +
-                                                         ToString( nBorder2Id) + "," +
-                                                         ToString( dEdgeLinTol) + "," +
-                                                         ToString( dEdgeAngTol) + ")" +
-                    " -- bOk=" + ToString( bOk) +
-                    " -- nFirstId=" + ToString( nFirstId) + " nCount=" + ToString( nCount) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-
-   return bOk ;
-}
-
-// ---------------------------------------------------------------------------
-bool
-ExeTrimmingGetSurfBzSyncPoints( int nParentId, int nEdge1Id, int nEdge2Id, double dLinTol,
-                                double dAngTol, int nLineNbr, bool bShowOnCorners,
-                                int& nFirstId, int& nCount)
-{
-  // Verifica database geometrico
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-
-  // Imposto i parametri di ritorno
-   nFirstId = GDB_ID_NULL ;
-   nCount = 0 ;
-
-  // Se non devo visualizzare alcuna linea, non faccio nulla
-   if ( nLineNbr <= 0  &&  ! bShowOnCorners)
-      return true ;
-
-  // Se necessario aggiusto le tolleranze
-   double dMyLinTol = Clamp( dLinTol, EPS_SMALL, 1e5 * EPS_SMALL) ;
-   double dMyAngTol = Clamp( dAngTol, EPS_ANG_SMALL, ANG_RIGHT) ;
-
-  // Recupero il riferimento del gruppo di destinazione
-   Frame3d frDest ;
-   bool bOk = ( pGeomDB->GetGlobFrame( nParentId, frDest)) ;
-
-  // Recupero le due Curve di bordo
-   const ICurve* pCrvEdge1 = GetCurve( pGeomDB->GetGeoObj( nEdge1Id)) ;
-   const ICurve* pCrvEdge2 = GetCurve( pGeomDB->GetGeoObj( nEdge2Id)) ;
-   bOk = bOk && ( pCrvEdge1 != nullptr && pCrvEdge1->IsValid() &&
-                  pCrvEdge2 != nullptr && pCrvEdge2->IsValid()) ;
-
-  // Verifico che le curve siano entrambe Aperte o entrambe Chiuse
-   bOk = bOk && ( pCrvEdge1->IsClosed() == pCrvEdge2->IsClosed()) ;
-
-  // Recupero i punti di sincronizzazione
-   BIPNTVECTOR vSyncPoints ;
-   bOk = bOk && GetTrimmingSurfBzSyncPoints( pCrvEdge1, pCrvEdge2, dMyLinTol, vSyncPoints) &&
-                ( ! vSyncPoints.empty()) ;
-   int nToTSyncLines = ssize( vSyncPoints) ;
-
-  // Ogni punto di sincronizzazione deve avere gli estremi sulle curve di Bordo
-   for ( int i = 0 ; bOk && i < ssize( vSyncPoints) ; ++ i) {
-      double dSqDistStart = INFINITO, dSqDistEnd = INFINITO ;
-      bOk = ( DistPointCurve( vSyncPoints[i].first, *pCrvEdge1).GetSqDist( dSqDistStart)  &&
-              dSqDistStart < dMyLinTol * dMyLinTol  &&
-              DistPointCurve( vSyncPoints[i].second, *pCrvEdge2).GetSqDist( dSqDistEnd)  &&
-              dSqDistEnd < dMyLinTol * dMyLinTol) ;
-   }
-
-   if ( bOk) {
-      INTSET setInds ;
-     // Se devo visualizzare più linee di quante ne ho ricavate, allora le devo visualizzare tutte
-      if ( nLineNbr >= nToTSyncLines) {
-         for ( int i = 0 ; i < nToTSyncLines ; ++ i)
-            setInds.insert( i) ;
-      }
-     // Altrimenti
-      else {
-        // Se voglio visualizzare gli Spigoli
-         if ( bShowOnCorners) {
-            for ( int nL = 0 ; bOk && nL < nToTSyncLines ; ++ nL) {
-              // Controllo se punto su spigolo della curva
-               double dU = 0. ;
-               Vector3d vtTanPrev, vtTanAft ;
-               Point3d ptUseless ;
-               bOk = ( pCrvEdge1->GetParamAtPoint( vSyncPoints[nL].first, dU, dMyLinTol) &&
-                       pCrvEdge1->GetPointD1D2( dU, ICurve::FROM_MINUS, ptUseless, &vtTanPrev) &&
-                       pCrvEdge1->GetPointD1D2( dU, ICurve::FROM_PLUS, ptUseless, &vtTanAft)) ;
-               if ( ! bOk)
-                  break ;
-               vtTanPrev.Normalize() ;
-               vtTanAft.Normalize() ;
-               if ( vtTanPrev * vtTanAft < cos( ( dMyAngTol + EPS_ANG_SMALL) * DEGTORAD)) {
-                  setInds.insert( nL) ;
-                  continue ;
-               }
-               bOk = ( pCrvEdge2->GetParamAtPoint( vSyncPoints[nL].second, dU, dMyLinTol) &&
-                       pCrvEdge2->GetPointD1D2( dU, ICurve::FROM_MINUS, ptUseless, &vtTanPrev) &&
-                       pCrvEdge2->GetPointD1D2( dU, ICurve::FROM_PLUS, ptUseless, &vtTanAft)) ;
-               if ( ! bOk)
-                  break ;
-               vtTanPrev.Normalize() ;
-               vtTanAft.Normalize() ;
-               if ( vtTanPrev * vtTanAft < cos( ( dMyAngTol + EPS_ANG_SMALL) * DEGTORAD)) {
-                  setInds.insert( nL) ;
-                  continue ;
-               }
-            }
-         }
-        // Se devo mostrare alcune Linee
-         if ( bOk  &&  nLineNbr > 0) {
-            bool bBothOpen = ( ! pCrvEdge1->IsClosed() && ! pCrvEdge2->IsClosed()) ;
-            bool bBothClosed = ( ! bBothOpen) ;
-            int nLastIdx = nToTSyncLines - 1 ;
-            if ( bBothClosed) {
-               int nLine = nLineNbr ;
-               if ( nLine == 1)
-                  setInds.insert( 0) ;
-               else {
-                  int nMaxIndex = nToTSyncLines - 2 ;
-                  for ( int i = 0 ; i < nLine ; ++ i) {
-                     double dT = double( i) / double( nLine) ;
-                     int nIdx = int( 0.5 + dT * nMaxIndex) ;
-                     setInds.insert( nIdx) ;
-                  }
-                  setInds.erase( nLastIdx) ;
-               }
-            }
-            else {
-               int nInternal = nLineNbr ;
-               setInds.insert( 0) ;
-               setInds.insert( nLastIdx) ;
-               int nMaxIndex = nLastIdx ;
-               for ( int i = 0; i < nInternal ; ++ i) {
-                  double dT = double( i + 1) / double( nInternal + 1) ;
-                  int nIdx = int( 0.5 + dT * nMaxIndex) ;
-                  setInds.insert( nIdx) ;
-               }
-            }
-         }
-      }
-
-     // Visualizzo i segmenti lineari di sincronizzazione per ogni indice ricavato
-      bool bFirst = true ;
-      for ( auto Iter = setInds.begin() ; bOk && Iter != setInds.end() ; ++ Iter) {
-         PtrOwner<ICurveLine> pLine( CreateCurveLine()) ;
-         bOk = ( ! IsNull( pLine) && pLine->Set( vSyncPoints[*Iter].first, vSyncPoints[*Iter].second)) ;
-         if ( bOk) {
-            int nLineId = pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pLine)) ;
-            bOk = ( nLineId != GDB_ID_NULL) ;
-            if ( bFirst) {
-               nFirstId = nLineId ;
-               bFirst = false ;
-            }
-            ++ nCount ;
-         }
-      }
-   }
-
-   ExeSetModified() ;
-  // Se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtTrimmingGetSurfBzSyncPoints(" + ToString( nParentId) + "," +
-                                                        ToString( nEdge1Id) + "," +
-                                                        ToString( nEdge2Id) + "," +
-                                                        ToString( dLinTol) + "," +
-                                                        ToString( nFirstId) + "," +
-                                                        ToString( nCount) + ")" +
-                    " -- bOk=" + ToString( bOk) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-
-   return bOk ;
-}
-
-// ---------------------------------------------------------------------------
-bool
-ExeRegolarizeSurfaceLocally( int nSurfId, int nSyncStartId, int nSyncEndId, double dLinTol)
-{
-   bool bOk = true ;
-   // Verifica database geometrico
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-
-   // recupero la superficie
-   ISurfBezier* pSurfBez = GetSurfBezier( GetSurf( pGeomDB->GetGeoObj( nSurfId))) ;
-
-   // recupero le due isocurve
-   const ICurve* pSyncStart = GetCurveLine( GetCurve( pGeomDB->GetGeoObj( nSyncStartId))) ;
-   const ICurve* pSyncEnd = GetCurveLine( GetCurve( pGeomDB->GetGeoObj( nSyncEndId))) ;
-   Point3d ptS1 ; pSyncStart->GetStartPoint( ptS1) ;
-   Point3d ptE1 ; pSyncStart->GetEndPoint( ptE1) ;
-   BIPOINT bpIsoStart( ptS1, ptE1) ;
-   Point3d ptS2 ; pSyncEnd->GetStartPoint( ptS2) ;
-   Point3d ptE2 ; pSyncEnd->GetEndPoint( ptE2) ;
-   BIPOINT bpIsoEnd( ptS2, ptE2) ;
-
-   bOk = RegolarizeBordersLocally( pSurfBez, bpIsoStart, bpIsoEnd, 0.2) ;
-
-   return bOk ;
-}
@@ -36,6 +36,7 @@ const int STR_DIM = 50 ;

 //-----------------------------------------------------------------------------
 static HINSTANCE s_hModule = nullptr ;
+static char      s_szEXeNameVer[STR_DIM] ;

 //-----------------------------------------------------------------------------
 BOOL APIENTRY
@@ -70,12 +71,10 @@ DllMain( HMODULE hModule, DWORD dwReason, LPVOID lpReserved)
 const char*
 GetEXeVersion( void)
 {
-   static char s_szEXeNameVer[STR_DIM] = "" ;
-   if ( s_szEXeNameVer[0] == '\0') {
-      std::string sVer ;
-      GetModuleVersion( s_hModule, sVer) ;
-      sprintf_s( s_szEXeNameVer, STR_DIM, "%s%s", EXE_STR, sVer.c_str()) ;
-   }
+   std::string sVer ;
+
+   GetModuleVersion( s_hModule, sVer) ;
+   sprintf_s( s_szEXeNameVer, STR_DIM, "%s%s", EXE_STR, sVer.c_str()) ;

   return s_szEXeNameVer ;
 }
@@ -1,8 +1,6 @@

-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Version 17
-VisualStudioVersion = 17.13.35919.96 d17.13
-MinimumVisualStudioVersion = 10.0.40219.1
+Microsoft Visual Studio Solution File, Format Version 11.00
+# Visual Studio 2010
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "EgtExecutor", "EgtExecutor.vcxproj", "{DF654897-F85B-4108-A621-F2C4AB099A48}"
 EndProject
 Global
@@ -25,7 +23,4 @@ Global
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
 	EndGlobalSection
-	GlobalSection(ExtensibilityGlobals) = postSolution
-		SolutionGuid = {30B63942-DD1D-428A-BFD1-E603299B17B6}
-	EndGlobalSection
 EndGlobal
@@ -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>
@@ -105,7 +105,7 @@
      <MultiProcessorCompilation>true</MultiProcessorCompilation>
      <MinimalRebuild>false</MinimalRebuild>
      <OpenMPSupport>false</OpenMPSupport>
-      <LanguageStandard>stdcpp20</LanguageStandard>
+      <LanguageStandard>stdcpp17</LanguageStandard>
    </ClCompile>
    <Link>
      <SubSystem>Windows</SubSystem>
@@ -131,7 +131,7 @@ copy $(TargetPath) \EgtProg\DllD32</Command>
      <OmitFramePointers>false</OmitFramePointers>
      <MultiProcessorCompilation>true</MultiProcessorCompilation>
      <MinimalRebuild>false</MinimalRebuild>
-      <LanguageStandard>stdcpp20</LanguageStandard>
+      <LanguageStandard>stdcpp17</LanguageStandard>
      <AdditionalOptions>-Wno-tautological-undefined-compare</AdditionalOptions>
    </ClCompile>
    <Link>
@@ -166,7 +166,7 @@ copy $(TargetPath) \EgtProg\DllD64</Command>
      <EnableEnhancedInstructionSet>StreamingSIMDExtensions2</EnableEnhancedInstructionSet>
      <EnableFiberSafeOptimizations>true</EnableFiberSafeOptimizations>
      <EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
-      <LanguageStandard>stdcpp20</LanguageStandard>
+      <LanguageStandard>stdcpp17</LanguageStandard>
    </ClCompile>
    <Link>
      <SubSystem>Windows</SubSystem>
@@ -200,8 +200,8 @@ copy $(TargetPath) \EgtProg\Dll32</Command>
      <OpenMPSupport>false</OpenMPSupport>
      <EnableFiberSafeOptimizations>false</EnableFiberSafeOptimizations>
      <EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
-      <EnableEnhancedInstructionSet>NotSet</EnableEnhancedInstructionSet>
-      <LanguageStandard>stdcpp20</LanguageStandard>
+      <EnableEnhancedInstructionSet>AdvancedVectorExtensions2</EnableEnhancedInstructionSet>
+      <LanguageStandard>stdcpp17</LanguageStandard>
      <AdditionalOptions>-Wno-tautological-undefined-compare</AdditionalOptions>
    </ClCompile>
    <Link>
@@ -228,7 +228,6 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
    <ClInclude Include="..\Include\EXeConst.h" />
    <ClInclude Include="..\Include\EXeDllMain.h" />
    <ClInclude Include="..\Include\EXeExecutor.h" />
-    <ClInclude Include="DllExch3dm.h" />
    <ClInclude Include="DllMain.h" />
    <ClInclude Include="DllNesting.h" />
    <ClInclude Include="EXE.h" />
@@ -249,23 +248,19 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
    <ClInclude Include="stdafx.h" />
  </ItemGroup>
  <ItemGroup>
-    <ClCompile Include="DllExch3dm.cpp" />
    <ClCompile Include="DllNesting.cpp" />
-    <ClCompile Include="EXE_Base64.cpp" />
    <ClCompile Include="EXE_BeamMgr.cpp" />
    <ClCompile Include="EXE_CAvTool.cpp" />
    <ClCompile Include="EXE_CDeObjSolid.cpp" />
    <ClCompile Include="EXE_GdbCreateVol.cpp" />
    <ClCompile Include="EXE_GdbGet.cpp" />
    <ClCompile Include="EXE_GdbGetCurve.cpp" />
-    <ClCompile Include="EXE_GdbGetPocketing.cpp" />
    <ClCompile Include="EXE_GdbGetSurf.cpp" />
    <ClCompile Include="EXE_GdbGetVol.cpp" />
    <ClCompile Include="EXE_GdbModifyVol.cpp" />
    <ClCompile Include="EXE_GeoDist.cpp" />
    <ClCompile Include="EXE_GeoInters.cpp" />
    <ClCompile Include="EXE_Image.cpp" />
-    <ClCompile Include="EXE_MachOpt.cpp" />
    <ClCompile Include="EXE_MaxFiller.cpp" />
    <ClCompile Include="EXE_Mutex.cpp" />
    <ClCompile Include="EXE_NstAutoNesting.cpp" />
@@ -293,11 +288,8 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
    <ClCompile Include="EXE_NstCreateFlatParts.cpp" />
    <ClCompile Include="EXE_Photo.cpp" />
    <ClCompile Include="EXE_Picture.cpp" />
-    <ClCompile Include="EXE_Redis.cpp" />
    <ClCompile Include="EXE_Scene.cpp" />
    <ClCompile Include="EXE_ShortestPath.cpp" />
-    <ClCompile Include="EXE_TestObjSurface.cpp" />
-    <ClCompile Include="EXE_Trimming.cpp" />
    <ClCompile Include="EXE_TscExec.cpp" />
    <ClCompile Include="AuxTools.cpp" />
    <ClCompile Include="DllExchange.cpp" />
@@ -308,24 +300,18 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
    <ClCompile Include="GenTools.cpp" />
    <ClCompile Include="GeoTools.cpp" />
    <ClCompile Include="GseContext.cpp" />
-    <ClCompile Include="LUA_Base64.cpp" />
    <ClCompile Include="LUA_BeamMgr.cpp" />
    <ClCompile Include="LUA_CAvTool.cpp" />
    <ClCompile Include="LUA_CDeObjSolid.cpp" />
    <ClCompile Include="LUA_GdbGet.cpp" />
    <ClCompile Include="LUA_GdbGetCurve.cpp" />
-    <ClCompile Include="LUA_GdbGetPocketing.cpp" />
    <ClCompile Include="LUA_GdbGetSurf.cpp" />
    <ClCompile Include="LUA_GdbGetVol.cpp" />
    <ClCompile Include="LUA_GeoDist.cpp" />
    <ClCompile Include="LUA_GeoInters.cpp" />
-    <ClCompile Include="LUA_MachOpt.cpp" />
    <ClCompile Include="LUA_MaxFiller.cpp" />
    <ClCompile Include="LUA_Picture.cpp" />
    <ClCompile Include="LUA_PolynomialRoots.cpp" />
-    <ClCompile Include="LUA_Redis.cpp" />
-    <ClCompile Include="LUA_TestObjSurface.cpp" />
-    <ClCompile Include="LUA_Trimming.cpp" />
    <ClCompile Include="PictureObj.cpp" />
    <ClCompile Include="LUA_Base.cpp" />
    <ClCompile Include="LUA_GdbCreateCurve.cpp" />
@@ -108,9 +108,6 @@
    <ClInclude Include="DllNesting.h">
      <Filter>File di intestazione</Filter>
    </ClInclude>
-    <ClInclude Include="DllExch3dm.h">
-      <Filter>File di intestazione</Filter>
-    </ClInclude>
  </ItemGroup>
  <ItemGroup>
    <ClCompile Include="LUA_Exchange.cpp">
@@ -392,45 +389,6 @@
    <ClCompile Include="EXE_Mutex.cpp">
      <Filter>File di origine\EXE</Filter>
    </ClCompile>
-    <ClCompile Include="DllExch3dm.cpp">
-      <Filter>File di origine\Optional Dll</Filter>
-    </ClCompile>
-    <ClCompile Include="EXE_GdbGetPocketing.cpp">
-      <Filter>File di origine\EXE</Filter>
-    </ClCompile>
-    <ClCompile Include="LUA_GdbGetPocketing.cpp">
-      <Filter>File di origine\LUA</Filter>
-    </ClCompile>
-    <ClCompile Include="EXE_TestObjSurface.cpp">
-      <Filter>File di origine\EXE</Filter>
-    </ClCompile>
-    <ClCompile Include="LUA_TestObjSurface.cpp">
-      <Filter>File di origine\LUA</Filter>
-    </ClCompile>
-    <ClCompile Include="Lua_Trimming.cpp">
-      <Filter>File di origine\LUA</Filter>
-    </ClCompile>
-    <ClCompile Include="EXE_Trimming.cpp">
-      <Filter>File di origine\EXE</Filter>
-    </ClCompile>
-    <ClCompile Include="EXE_MachOpt.cpp">
-      <Filter>File di origine\EXE</Filter>
-    </ClCompile>
-    <ClCompile Include="LUA_MachOpt.cpp">
-      <Filter>File di origine\LUA</Filter>
-    </ClCompile>
-    <ClCompile Include="EXE_Redis.cpp">
-      <Filter>File di origine\EXE</Filter>
-    </ClCompile>
-    <ClCompile Include="LUA_Redis.cpp">
-      <Filter>File di origine\LUA</Filter>
-    </ClCompile>
-    <ClCompile Include="EXE_Base64.cpp">
-      <Filter>File di origine\EXE</Filter>
-    </ClCompile>
-    <ClCompile Include="LUA_Base64.cpp">
-      <Filter>File di origine\LUA</Filter>
-    </ClCompile>
  </ItemGroup>
  <ItemGroup>
    <ResourceCompile Include="EgtExecutor.rc">
@@ -20,9 +20,9 @@

 //----------------------------------------------------------------------------
 int
-AdjustId( int nId, int nCtx)
+AdjustId( int nId)
 {
-   GseContext* pCtx = ( nCtx == 0 ? GetCurrGseContext() : GetGseContext( nCtx));
+   GseContext* pCtx = GetCurrGseContext() ;
   VERIFY_CTX( pCtx, GDB_ID_NULL)
   if ( nId == GDB_ID_CURRPART)
      return pCtx->m_nCurrPart ;
@@ -20,7 +20,7 @@ class IGeomDB ;

 //----------------------------------------------------------------------------
 // Sistemo Id per pezzo o layer correnti
-int AdjustId( int nId, int nCtx = 0) ;
+int AdjustId( int nId) ;
 // Vettore espresso nel riferimento desiderato partendo da vettore nel riferimento RefType
 Vector3d GetVectorLocal( IGeomDB* pGeomDB, const Vector3d& vtV, int nRefType, const Frame3d& frLoc) ;
 // Vettore espresso nel riferimento RefType partendo da vettore nel riferimento locale
@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2014-2025
+//  EgalTech 2014-2015
 //----------------------------------------------------------------------------
-// File : LUA.h             Data : 03.11.25        Versione : 2.7k1
+// File : LUA.h             Data : 16.01.15        Versione : 1.6a3
 // Contenuto : Dichiarazioni locali per moduli LUA.
 //
 //
@@ -54,9 +54,6 @@ bool LuaInstallGdbModifyVol( LuaMgr& luaMgr) ;
 //-------------------------- GdbGet ------------------------------------------
 bool LuaInstallGdbGet( LuaMgr& luaMgr) ;

-//-------------------------- GdbGetPocketing ---------------------------------
-bool LuaInstallGdbGetPocketing( LuaMgr& luaMgr) ;
-
 //-------------------------- GdbGetCurve -------------------------------------
 bool LuaInstallGdbGetCurve( LuaMgr& luaMgr) ;

@@ -65,7 +62,7 @@ bool LuaInstallGdbGetSurf( LuaMgr& luaMgr) ;

 //-------------------------- GdbGetVol ---------------------------------------
 bool LuaInstallGdbGetVol( LuaMgr& luaMgr) ;
-
+                                              
 //-------------------------- GdbPartLayer ------------------------------------
 bool LuaInstallGdbPartLayer( LuaMgr& luaMgr) ;

@@ -93,9 +90,6 @@ bool LuaInstallGeoInters( LuaMgr& luaMgr) ;
 //-------------------------- Collision Detection -----------------------------
 bool LuaInstallCDeObjSolid( LuaMgr& luaMgr) ;

-//-------------------------- Test Interference -------------------------------
-bool LuaInstallTestObjSurface( LuaMgr& luaMgr) ;
-
 //-------------------------- MachMgr -----------------------------------------
 bool LuaInstallMachMgr( LuaMgr& luaMgr) ;

@@ -129,17 +123,6 @@ bool LuaInstallPolynomialRoots( LuaMgr& luaMgr) ;
 //-------------------------- Shortest Path -----------------------------------
 bool LuaInstallShortestPath( LuaMgr& luaMgr) ;

-//----------------------- Machining Time Optimization ------------------------
-bool LuaInstallMachiningOptimization( LuaMgr& luaMgr) ;
-
 //-------------------------- Collision Avoidance Tool ------------------------
 bool LuaInstallCAvTool( LuaMgr& luaMgr) ;

-//---------------------------------- Redis ----------------------------------
-bool LuaInstallRedis( LuaMgr& luaMgr) ;
-
-//-------------------------- Base64 ------------------------------------------
-bool LuaInstallBase64( LuaMgr& luaMgr) ;
-
-//---------------------------------- Trimming ----------------------------------
-bool LuaInstallTrimming( LuaMgr& luaMgr) ;
@@ -78,10 +78,6 @@ LuaInstallEgtFunctions( LuaMgr& LuaMgr)
      LOG_ERROR( GetLogger(), "Error in LuaInstallGdbGet (LuaInstallEgtFunctions)")
      return false ;
   }
-   if ( ! LuaInstallGdbGetPocketing( LuaMgr)) {
-      LOG_ERROR( GetLogger(), "Error in LuaInstallGdbGetPocketing (LuaInstallEgtFunctions)")
-      return false ;
-   }
   if ( ! LuaInstallGdbGetCurve( LuaMgr)) {
      LOG_ERROR( GetLogger(), "Error in LuaInstallGdbGetCurve (LuaInstallEgtFunctions)")
      return false ;
@@ -130,10 +126,6 @@ LuaInstallEgtFunctions( LuaMgr& LuaMgr)
      LOG_ERROR( GetLogger(), "Error in LuaInstallCDeObjSolid (LuaInstallEgtFunctions)")
      return false ;
   }
-   if ( ! LuaInstallTestObjSurface( LuaMgr)) {
-      LOG_ERROR( GetLogger(), "Error in LuaInstallTestObjSurface (LuaInstallEgtFunctions)")
-      return false ;
-   }
   if ( ! LuaInstallMachMgr( LuaMgr)) {
      LOG_ERROR( GetLogger(), "Error in LuaInstallMachMgr (LuaInstallEgtFunctions)")
      return false ;
@@ -178,27 +170,10 @@ LuaInstallEgtFunctions( LuaMgr& LuaMgr)
      LOG_ERROR( GetLogger(), "Error in LuaInstallShortestPath (LuaInstallEgtFunctions)")
      return false ;
   }
-   if ( ! LuaInstallMachiningOptimization( LuaMgr)) {
-      LOG_ERROR( GetLogger(), "Error in LuaInstallMachiningOptimization (LuaInstallEgtFunctions)")
-      return false ;
-   }
   if ( ! LuaInstallCAvTool( LuaMgr)) {
      LOG_ERROR( GetLogger(), "Error in LuaInstallCAvTool (LuaInstallEgtFunctions)")
      return false ;
   }
-   if ( ! LuaInstallRedis( LuaMgr)) {
-      LOG_ERROR( GetLogger(), "Error in LuaInstallRedis (LuaInstallEgtFunctions)")
-      return false ;
-   }
-   if ( ! LuaInstallBase64( LuaMgr)) {
-      LOG_ERROR( GetLogger(), "Error in LuaInstallBase64 (LuaInstallEgtFunctions)")
-      return false ;
-   }
-   if ( ! LuaInstallTrimming( LuaMgr)) {
-      LOG_ERROR( GetLogger(), "Error in LuaInstallTrimming (LuaInstallEgtFunctions)")
-      return false ;
-   }
-
   return true ;
 }

@@ -1,65 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2025-2025
-//----------------------------------------------------------------------------
-// File : LUA_Base64.cpp       Data : 03.11.25        Versione : 2.7k1
-// Contenuto : Funzioni per codificare/decodificare in Base64 per LUA.
-//
-//
-//
-// Modifiche : 03.11.25 DS Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-//--------------------------- Include ----------------------------------------
-#include "stdafx.h"
-#include "LUA.h"
-#include "/EgtDev/Include/EXeExecutor.h"
-
-using namespace std ;
-
-//-------------------------------------------------------------------------------
-static int
-LuaBase64Encode( lua_State* L)
-{
-  // 1 parametro : sFile
-   string sFile ;
-   LuaCheckParam( L, 1, sFile) ;
-   LuaClearStack( L) ;
-  // eseguo la codifica del contenuto del file
-   string sB64Dest ;
-   bool bOk = ExeBase64Encode( sFile, sB64Dest) ; 
-  // restituisco il risultato
-   if ( bOk)
-      LuaSetParam( L, sB64Dest) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaBase64Decode( lua_State* L)
-{
-  // 2 parametro : sB64Sou, sFile
-   string sB64Sou ;
-   LuaCheckParam( L, 1, sB64Sou) ;
-   string sFile ;
-   LuaCheckParam( L, 2, sFile) ;
-   LuaClearStack( L) ;
-  // eseguo la decodifica della stringa nel file
-   bool bOk = ExeBase64Decode( sB64Sou, sFile) ; 
-  // restituisco il risultato
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-bool
-LuaInstallBase64( LuaMgr& luaMgr)
-{
-   bool bOk = ( &luaMgr != nullptr) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtBase64Encode", LuaBase64Encode) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtBase64Decode", LuaBase64Decode) ;
-   return bOk ;
-}
@@ -21,21 +21,6 @@

 using namespace std ;

-//-------------------------------------------------------------------------------
-static int
-LuaInitBeamMgr( lua_State* L)
-{
-  // 1 o nessun parametro : [nFlag]
-   int nFlag = EIB_FLAG_NONE ;
-   LuaGetParam( L, 1, nFlag) ;
-   LuaClearStack( L) ;
-  // inizializzo in gestore di travi e pareti
-   bool bOk = ExeInitBeamMgr( nFlag) ;
-  // restituisco il risultato
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
 //-------------------------------------------------------------------------------
 static int
 LuaBeamCreatePart( lua_State* L)
@@ -166,7 +151,7 @@ LuaBeamGetSideData( lua_State* L)
   int nSide ;
   LuaCheckParam( L, 1, nSide)
   LuaClearStack( L) ;
-  // restituisce i dati della faccia indicata del pezzo corrente
+  // imposto le dimensioni al pezzo corrente
   Frame3d frRef ;
   double dLength, dWidth, dHeight ;
   bool bOk = ExeBeamGetSideData( nSide, frRef, dLength, dWidth, dHeight) ;
@@ -188,7 +173,7 @@ LuaBeamGetSideData( lua_State* L)
 static int
 LuaBeamAddProcess( lua_State* L)
 {
-  // 9 o 10 o 11 o 12 parametri : nGroup, nProc, nSide, sDes, nProcId, vdPar, sPar, vsUAtt [, nCrv] [, nCrv2] [, bUpdate]
+  // 9 o 10 o 11 o 12 parametri : nGroup, nProc, nSide, sDes, nProcId, vdPar, sPar [, nCrv, nCrv2] [, bUpdate]
   int nGroup ;
   LuaCheckParam( L, 1, nGroup)
   int nProc ;
@@ -213,8 +198,6 @@ LuaBeamAddProcess( lua_State* L)
   if ( LuaGetParam( L, 10, nCrvId)  &&
        LuaGetParam( L, 11, nCrv2Id))
      LuaGetParam( L, 12, bUpdate) ;
-   else if  ( LuaGetParam( L, 10, nCrvId))
-      LuaGetParam( L, 11, bUpdate) ;
   else
      LuaGetParam( L, 10, bUpdate) ;
   LuaClearStack( L) ;
@@ -232,7 +215,7 @@ LuaBeamAddProcess( lua_State* L)
 static int
 LuaBeamModifyProcess( lua_State* L)
 {
-  // 10 o 11 o 12 o 13 parametri : nGeomId, nGroup, nProc, nSide, sDes, nProcId, vdPar, sPar, vsUAtt [, nCrv, nCrv2] [, bUpdate]
+  // 10 o 11 o 12 o 13 parametri : nGeomId, nGroup, nProc, nSide, sDes, nProcId, vdPar, sPar [, nCrv, nCrv2] [, bUpdate]
   int nGeomId ;
   LuaCheckParam( L, 1, nGeomId)
   int nGroup ;
@@ -259,8 +242,6 @@ LuaBeamModifyProcess( lua_State* L)
   if ( LuaGetParam( L, 11, nCrvId)  &&
        LuaGetParam( L, 12, nCrv2Id))
      LuaGetParam( L, 13, bUpdate) ;
-   else if ( LuaGetParam( L, 11, nCrvId))
-      LuaGetParam( L, 12, bUpdate) ;
   else
      LuaGetParam( L, 11, bUpdate) ;
   LuaClearStack( L) ;
@@ -310,38 +291,6 @@ LuaBeamEnableProcess( lua_State* L)
   return 1 ;
 }

-//-------------------------------------------------------------------------------
-static int
-LuaBeamCalcAllSolids( lua_State* L)
-{
-  // 1 o 2 parametri : bShow [,bRecalc]
-   bool bShow ;
-   LuaCheckParam( L, 1, bShow)
-   bool bRecalc = false ;
-   LuaGetParam( L, 2, bRecalc) ;
-   LuaClearStack( L) ;
-  // eseguo calcolo dei solidi di tutte le travi
-   bool bOk = ExeBeamCalcAllSolids( bShow, bRecalc) ;
-  // restituisco il risultato
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaBeamShowAllSolids( lua_State* L)
-{
-  // 1 parametro : bShow
-   bool bShow ;
-   LuaCheckParam( L, 1, bShow)
-   LuaClearStack( L) ;
-  // aggiorno stato di visualizzazione dei solidi di tutte le travi
-   bool bOk = ExeBeamShowAllSolids( bShow) ;
-  // restituisco il risultato
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
 //-------------------------------------------------------------------------------
 static int
 LuaBeamCalcSolid( lua_State* L)
@@ -398,12 +347,10 @@ LuaBeamShowSolid( lua_State* L)
 static int
 LuaBeamGetBuildingIsOn( lua_State* L)
 {
-  // 1 o nessun parametro : [nAssGrpId]
-   int nAssGrpId = GDB_ID_NULL ;
-   LuaGetParam( L, 1, nAssGrpId) ;
+  // Nessun parametro
   LuaClearStack( L) ;
  // restituisco identificativo del solido della trave
-   bool bOk = ExeBeamGetBuildingIsOn( nAssGrpId) ;
+   bool bOk = ExeBeamGetBuildingIsOn() ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
@@ -413,14 +360,12 @@ LuaBeamGetBuildingIsOn( lua_State* L)
 static int
 LuaBeamShowBuilding( lua_State* L)
 {
-  // 1 o 2 parametri : [nAssGrpId,] bShow
-   int nAssGrpId = GDB_ID_NULL ;
-   int nPar = ( LuaGetParam( L, 1, nAssGrpId) ? 2 : 1) ;
+  // 1 parametro : bShow
   bool bShow ;
-   LuaCheckParam( L, nPar, bShow)
+   LuaCheckParam( L, 1, bShow)
   LuaClearStack( L) ;
  // attivo o disattivo la visualizzazione l'assemblaggio
-   bool bOk = ExeBeamShowBuilding( nAssGrpId, bShow) ;
+   bool bOk = ExeBeamShowBuilding( bShow) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
@@ -431,7 +376,6 @@ bool
 LuaInstallBeamMgr( LuaMgr& luaMgr)
 {
   bool bOk = ( &luaMgr != nullptr) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtInitBeamMgr", LuaInitBeamMgr) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtBeamCreatePart", LuaBeamCreatePart) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtBeamSetPart", LuaBeamSetPart) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtBeamErasePart", LuaBeamErasePart) ;
@@ -445,8 +389,6 @@ LuaInstallBeamMgr( LuaMgr& luaMgr)
   bOk = bOk && luaMgr.RegisterFunction( "EgtBeamModifyProcess", LuaBeamModifyProcess) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtBeamEraseProcess", LuaBeamEraseProcess) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtBeamEnableProcess", LuaBeamEnableProcess) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtBeamCalcAllSolids", LuaBeamCalcAllSolids) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtBeamShowAllSolids", LuaBeamShowAllSolids) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtBeamCalcSolid", LuaBeamCalcSolid) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtBeamGetSolid", LuaBeamGetSolid) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtBeamShowSolid", LuaBeamShowSolid) ;
@@ -118,27 +118,6 @@ LuaCAvGetToolOutline( lua_State* L)
   return 1 ;
 }

-//-------------------------------------------------------------------------------
-static int
-LuaCAvToolPosBox( lua_State* L)
-{
-  // 4 parametri : ptP, vtAx, b3Box, vtMove
-   Point3d ptP ;
-   LuaCheckParam( L, 1, ptP)
-   Vector3d vtAx ;
-   LuaCheckParam( L, 2, vtAx)
-   BBox3d b3Box ;
-   LuaCheckParam( L, 3, b3Box)
-   Vector3d vtMove ;
-   LuaCheckParam( L, 4, vtMove)
-   LuaClearStack( L) ;
-  // determino il movimento da dare all'utensile per evitare la collisione con il parallelepipedo
-   double dMove = ExeCAvToolPosBox( ptP, vtAx, b3Box, vtMove) ;
-  // restituisco il risultato
-   LuaSetParam( L, dMove) ;
-   return 1 ;
-}
-
 //-------------------------------------------------------------------------------
 static int
 LuaCAvToolPosStm( lua_State* L)
@@ -197,7 +176,6 @@ LuaInstallCAvTool( LuaMgr& luaMgr)
   bOk = bOk && luaMgr.RegisterFunction( "EgtCAvSetSawTool", LuaCAvSetSawTool) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtCAvSetGenTool", LuaCAvSetGenTool) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtCAvGetToolOutline", LuaCAvGetToolOutline) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtCAvToolPosBox", LuaCAvToolPosBox) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtCAvToolPosStm", LuaCAvToolPosStm) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtCAvToolPathStm", LuaCAvToolPathStm) ;
   return bOk ;
@@ -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 ;
@@ -209,12 +173,14 @@ LuaImport3MF( lua_State* L)
 static int
 LuaImport3dm( lua_State* L)
 {
-   // 1 parametro : path del file da importare
+   // 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 = ExeImport3dm( sFilePath) ; 
+   bool bOk = ExeImport3dm( sFilePath, dScaleFactor) ; 
   // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
@@ -224,16 +190,14 @@ LuaImport3dm( lua_State* L)
 static int
 LuaAdvancedImport( lua_State* L)
 {
-  // 1 o 2 o 3 parametri : path del file da importare [, dLinToler] [, nFlag]
+  // 1 o 2 parametri : path del file da importare [, dLinToler]
   string sFilePath ;
   LuaCheckParam( L, 1, sFilePath)
   double dLinToler = 0.1 ;
   LuaGetParam( L, 2, dLinToler) ;
-   int nFlag = 0 ;
-   LuaGetParam( L, 3, nFlag) ;
   LuaClearStack( L) ;
  // apro il file
-   bool bOk = ExeAdvancedImport( sFilePath, dLinToler, nFlag) ; 
+   bool bOk = ExeAdvancedImport( sFilePath, dLinToler) ; 
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
@@ -292,7 +256,7 @@ LuaExport3MF( lua_State* L)
   LuaGetParam( L, 3, nFilter) ;
   LuaClearStack( L) ;
  // creo il file
-   bool bOk = ExeExport3MF( nGroupId, sFilePath, nFilter) ; 
+   bool bOk = ExeExport3MF( nGroupId, sFilePath) ; 
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
@@ -311,7 +275,7 @@ LuaExport3dm( lua_State* L)
   LuaGetParam( L, 3, nFilter) ;
   LuaClearStack( L) ;
  // creo il file
-   bool bOk = ExeExport3dm( nGroupId, sFilePath, nFilter) ; 
+   bool bOk = ExeExport3dm( nGroupId, 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) ;
@@ -400,13 +400,13 @@ LuaCreateDiametralDimension( lua_State* L )
 static int
 LuaCreateAngularDimension(lua_State* L)
 {
-   // 6 o 7 parametri : ParentId, ptV, ptP1, ptP2, ptDim, Text [, nRefType]
+   // 6 o 7 parametri : ParentId, ptP1, ptP0, ptP2, ptDim, Text [, nRefType]
    int nParentId ;
    LuaCheckParam( L, 1, nParentId)
-    Point3d ptV ;
-    LuaCheckParam( L, 2, ptV) ;
    Point3d ptP1 ;
-    LuaCheckParam( L, 3, ptP1) ;
+    LuaCheckParam( L, 2, ptP1) ;
+    Point3d ptP0 ;
+    LuaCheckParam( L, 3, ptP0) ;
    Point3d ptP2 ;
    LuaCheckParam( L, 4, ptP2) ;
    Point3d ptDim ;
@@ -417,39 +417,7 @@ LuaCreateAngularDimension(lua_State* L)
    LuaGetParam( L, 7, nRefType) ;
    LuaClearStack( L) ;
   // creo la quota angolare
-    int nId = ExeCreateAngularDimension( nParentId, ptV, ptP1, ptP2, ptDim, sText, nRefType) ;
-   // restituisco il risultato
-    if ( nId != GDB_ID_NULL)
-        LuaSetParam( L, nId) ;
-    else
-        LuaSetParam( L) ;
-    return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaCreateAngularDimensionEx(lua_State* L)
-{
-   // 7 o 8 parametri : ParentId, ptV1, ptP1, ptV2, ptP2, ptDim, Text [, nRefType]
-    int nParentId ;
-    LuaCheckParam( L, 1, nParentId)
-    Point3d ptV1 ;
-    LuaCheckParam( L, 2, ptV1) ;
-    Point3d ptP1 ;
-    LuaCheckParam( L, 3, ptP1) ;
-    Point3d ptV2 ;
-    LuaCheckParam( L, 4, ptV2) ;
-    Point3d ptP2 ;
-    LuaCheckParam( L, 5, ptP2) ;
-    Point3d ptDim ;
-    LuaCheckParam( L, 6, ptDim) ;
-    string sText ;
-    LuaCheckParam( L, 7, sText) ;
-    int nRefType = RTY_DEFAULT ;
-    LuaGetParam( L, 8, nRefType) ;
-    LuaClearStack( L) ;
-   // creo la quota angolare
-    int nId = ExeCreateAngularDimensionEx( nParentId, ptV1, ptP1, ptV2, ptP2, ptDim, sText, nRefType) ;
+    int nId = ExeCreateAngularDimension( nParentId, ptP1, ptP0, ptP2, ptDim, sText, nRefType) ;
   // restituisco il risultato
    if ( nId != GDB_ID_NULL)
        LuaSetParam( L, nId) ;
@@ -510,6 +478,36 @@ LuaCreateAngularDimensionFromArc( lua_State* L)
    return 1 ;
 }

+//-------------------------------------------------------------------------------
+static int
+LuaCreateAngularDimensionFromCircle( lua_State* L)
+{
+  // 6 o 7 parametri : nParentId, nCrvId, ptP1, ptP2, ptDim, Text [, nRefType]
+   int nParentId ;
+   LuaCheckParam( L, 1, nParentId)
+   int nCrvId ;
+   LuaCheckParam( L, 2, nCrvId) ;
+   Point3d ptP1 ;
+   LuaCheckParam( L, 3, ptP1) ;
+   Point3d ptP2 ;
+   LuaCheckParam( L, 4, ptP2) ;
+   Point3d ptDim ;
+   LuaCheckParam( L, 5, ptDim) ;
+   string sText ;
+   LuaCheckParam( L, 6, sText) ;
+   int nRefType = RTY_DEFAULT ;
+   LuaGetParam( L, 7, nRefType) ;
+   LuaClearStack( L) ;
+  // creo la quota allineata
+   int nId = ExeCreateAngularDimensionFromCircle( nParentId, nCrvId, ptP1, ptP2, ptDim, sText, nRefType) ;
+  // restituisco il risultato
+   if ( nId != GDB_ID_NULL)
+      LuaSetParam( L, nId) ;
+   else
+      LuaSetParam( L) ;
+   return 1 ;
+}
+
 //-------------------------------------------------------------------------------
 bool
 LuaInstallGdbCreate( LuaMgr& luaMgr)
@@ -529,9 +527,9 @@ LuaInstallGdbCreate( LuaMgr& luaMgr)
   bOk = bOk && luaMgr.RegisterFunction( "EgtAlignedDimension", LuaCreateAlignedDimension) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtRadialDimension", LuaCreateRadialDimension) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtDiametralDimension", LuaCreateDiametralDimension) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtAngularDimension", LuaCreateAngularDimension) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtAngularDimensionEx", LuaCreateAngularDimensionEx) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtAngularDimension", LuaCreateAngularDimension);
   bOk = bOk && luaMgr.RegisterFunction( "EgtAngularDimensionFromLines", LuaCreateAngularDimensionFromLines) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtAngularDimensionFromArc", LuaCreateAngularDimensionFromArc) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtAngularDimensionFromCircle", LuaCreateAngularDimensionFromCircle) ;
   return bOk ;
 }
@@ -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)
@@ -728,27 +700,6 @@ LuaCreateCurveBezierFromArc( lua_State* L)
   return 1 ;
 }

-//-------------------------------------------------------------------------------
-static int
-LuaCreateCurveBezierFromCurve( lua_State* L)
-{
-  // 2 o 3 parametri : ParentId, nCrvId [, bRat]
-   int nParentId ;
-   LuaCheckParam( L, 1, nParentId)
-   int nCrvId ;
-   LuaCheckParam( L, 2, nCrvId)
-   bool bRat = true ;
-   LuaGetParam( L, 3, bRat) ;
-  // creo la versione bezier della curva
-   int nId = ExeCreateCurveBezierFromCurve( nParentId, nCrvId, bRat) ;
-  // restituisco il risultato
-   if ( nId != GDB_ID_NULL)
-      LuaSetParam( L, nId) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
 //-------------------------------------------------------------------------------
 static int
 LuaCreateCurveCompo( lua_State* L)
@@ -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) ;
@@ -1143,7 +1093,6 @@ LuaInstallGdbCreateCurve( LuaMgr& luaMgr)
   bOk = bOk && luaMgr.RegisterFunction( "EgtCurveBezier", LuaCreateCurveBezier) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtCurveBezierRat", LuaCreateCurveBezierRational) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtCurveBezierFromArc", LuaCreateCurveBezierFromArc) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtCurveBezierFromCurve", LuaCreateCurveBezierFromCurve) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtCurveCompo", LuaCreateCurveCompo) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtCurveCompoByChain", LuaCreateCurveCompoByChain) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtCurveCompoByReorder", LuaCreateCurveCompoByReorder) ;
@@ -15,7 +15,6 @@
 #include "stdafx.h"
 #include "LUA.h"
 #include "EXE_Const.h"
-#include "/EgtDev/Include/EGkSurfTriMesh.h"
 #include "/EgtDev/Include/EXeExecutor.h"
 #include "/EgtDev/Include/EXeConst.h"
 #include "/EgtDev/Include/EGkLuaAux.h"
@@ -148,7 +147,7 @@ LuaCreateSurfFlatRegion( lua_State* L)
 static int
 LuaCreateSurfFrFatCurve( lua_State* L)
 {
-  // 4 o 5 o 6 parametri : ParentId, nCrvId, dRad, bSquared [, bSquaredMids] [, dLinTol]
+  // 4 parametri : ParentId, nCrvId, dRad, bSquared
   int nParentId ;
   LuaCheckParam( L, 1, nParentId)
   int nCrvId ;
@@ -157,31 +156,9 @@ LuaCreateSurfFrFatCurve( lua_State* L)
   LuaCheckParam( L, 3, dRad)
   bool bSquared ;
   LuaCheckParam( L, 4, bSquared)
-   bool bSquaredMids = bSquared ;
-   LuaGetParam( L, 5, bSquaredMids) ;
-   double dLinTol = 10 * EPS_SMALL ;
-   LuaGetParam( L, 6, dLinTol) ;
   LuaClearStack( L) ;
  // creo una regione piana
-   int nId = ExeCreateSurfFrFatCurve( nParentId, nCrvId, dRad, bSquared, bSquaredMids, dLinTol) ;
-  // restituisco il risultato
-   if ( nId != GDB_ID_NULL)
-      LuaSetParam( L, nId) ;
-   else
-      LuaSetParam( 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) ;
+   int nId = ExeCreateSurfFrFatCurve( nParentId, nCrvId, dRad, bSquared) ;
  // restituisco il risultato
   if ( nId != GDB_ID_NULL)
      LuaSetParam( L, nId) ;
@@ -408,7 +385,7 @@ LuaCreateSurfTmSphere( lua_State* L)
   else
      LuaGetParam( L, 4, nRefType) ;
   LuaClearStack( L) ;
-  // creo STM sfera
+  // creo STM cilindro
   int nId = ExeCreateSurfTmSphere( nParentId, ptOrig, dRad, dLinTol, nRefType) ;
  // restituisco il risultato
   if ( nId != GDB_ID_NULL)
@@ -418,178 +395,6 @@ LuaCreateSurfTmSphere( lua_State* L)
   return 1 ;
 }

-//-------------------------------------------------------------------------------
-static int
-LuaCreateSurfTmPyramidFrustum( lua_State* L)
-{
-  // 6 parametri : ParentId, dBaseDimX, dBaseDimY, dTopDimX, dTopDimY, dHeight
-   int nParentId ;
-   LuaCheckParam( L, 1, nParentId)
-   double dBaseDimX ;
-   LuaCheckParam( L, 2, dBaseDimX)
-   double dBaseDimY ;
-   LuaCheckParam( L, 3, dBaseDimY)
-   double dTopDimX ;
-   LuaCheckParam( L, 4, dTopDimX)
-   double dTopDimY ;
-   LuaCheckParam( L, 5, dTopDimY)
-   double dHeight ;
-   LuaCheckParam( L, 6, dHeight)
-   LuaClearStack( L) ;
-  // creo STM cilindro
-   int nId = ExeCreateSurfTmPyramidFrustum( nParentId, dBaseDimX, dBaseDimY, dTopDimX, dTopDimY, dHeight) ;
-  // restituisco il risultato
-   if ( nId != GDB_ID_NULL)
-      LuaSetParam( L, nId) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaCreateSurfTmConeFrustum( lua_State* L)
-{
-  // 4 o 5 parametri : ParentId, dBaseRad, dTopRad, dHeight [, dTol]
-   int nParentId ;
-   LuaCheckParam( L, 1, nParentId)
-   double dBaseRad ;
-   LuaCheckParam( L, 2, dBaseRad)
-   double dTopRad ;
-   LuaCheckParam( L, 3, dTopRad)
-   double dHeight ;
-   LuaCheckParam( L, 4, dHeight)
-   double dLinTol = LIN_TOL_SRF ;
-   LuaGetParam( L, 5, dLinTol) ;
-   LuaClearStack( L) ;
-  // creo STM cilindro
-   int nId = ExeCreateSurfTmConeFrustum( nParentId, dBaseRad, dTopRad, dHeight, dLinTol) ;
-  // restituisco il risultato
-   if ( nId != GDB_ID_NULL)
-      LuaSetParam( L, nId) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaCreateSurfTmTriangle( lua_State* L)
-{
-  // 4 o 5 parametri : ParentId, PtP1, PtP2, PtP3 [, nRefType]
-   int nParentId ;
-   LuaCheckParam( L, 1, nParentId)
-   Point3d PtP1 ;
-   LuaCheckParam( L, 2, PtP1)
-   Point3d PtP2 ;
-   LuaCheckParam( L, 3, PtP2)
-   Point3d PtP3 ;
-   LuaCheckParam( L, 4, PtP3)
-   int nRefType = RTY_DEFAULT ;
-   LuaGetParam( L, 5, nRefType) ;
-   LuaClearStack( L) ;
-  // creo STM triangolo
-   int nId = ExeCreateSurfTmTriangle( nParentId, PtP1, PtP2, PtP3, nRefType) ;
-  // restituisco il risultato
-   if ( nId != GDB_ID_NULL)
-      LuaSetParam( L, nId) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaCreateSurfTmRectangle( lua_State* L)
-{
-  // 4 o 5 parametri : ParentId, PtO, PtL, PtT [, nRefType]
-   int nParentId ;
-   LuaCheckParam( L, 1, nParentId)
-   Point3d ptO ;
-   LuaCheckParam( L, 2, ptO)
-   Point3d ptL ;
-   LuaCheckParam( L, 3, ptL)
-   Point3d ptT ;
-   LuaCheckParam( L, 4, ptT)
-   int nRefType = RTY_DEFAULT ;
-   LuaGetParam( L, 5, nRefType) ;
-   LuaClearStack( L) ;
-  // creo STM rettangolo
-   int nId = ExeCreateSurfTmRectangle( nParentId, ptO, ptL, ptT, nRefType) ;
-  // restituisco il risultato
-   if ( nId != GDB_ID_NULL)
-      LuaSetParam( L, nId) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaCreateSurfTmByPolygon( lua_State* L)
-{
-  // 2 o 3 parametri : ParentId, ptPs [, nRefType]
-   int nParentId ;
-   LuaCheckParam( L, 1, nParentId)
-   PNTVECTOR vPnt ;
-   LuaCheckParam( L, 2, vPnt)
-   int nRefType = RTY_DEFAULT ;
-   LuaGetParam( L, 3, nRefType) ;
-   LuaClearStack( L) ;
-  // creo una polilinea a partire dai punti
-   PolyLine PL ;
-   for ( size_t i = 0 ; i < vPnt.size() ; ++ i) {
-      if ( ! vPnt[i].IsValid())
-         break ;
-      PL.AddUPoint( double( i), vPnt[i]) ;
-   }
-   PL.Close() ;
-  // creo la SurfTriMesh del poligono
-   int nId = ExeCreateSurfTmByPolygon( nParentId, PL, nRefType) ;
-  // restituisco il risultato
-   if ( nId != GDB_ID_NULL)
-      LuaSetParam( L, nId) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaCreateSurfTmByPolygonWithHoles( lua_State* L)
-{
-  // 2 o 3 parametri : ParentId, ptPs [, nRefType]
-   int nParentId ;
-   LuaCheckParam( L, 1, nParentId)
-   PNTVECTOR vPnt ;
-   LuaCheckParam( L, 2, vPnt)
-   int nRefType = RTY_DEFAULT ;
-   LuaGetParam( L, 3, nRefType) ;
-   LuaClearStack( L) ;
-  // creo un vettore di polilinee a partire dai punti
-   POLYLINEVECTOR vPL ;
-   vPL.push_back( {}) ;
-   for ( size_t i = 0 ; i < vPnt.size() ; ++ i) {
-      if ( vPnt[i].IsValid())
-         vPL.back().AddUPoint( double( i), vPnt[i]) ;
-      else {
-         if ( ! vPL.empty())
-            vPL.back().Close() ;
-         vPL.push_back( {}) ;
-      }
-   }
-   if ( ! vPL.empty())
-      vPL.back().Close() ;
-  // creo la SurfTriMesh del poligono
-   int nId = ExeCreateSurfTmByPolygonWithHoles( nParentId, vPL, nRefType) ;
-  // restituisco il risultato
-   if ( nId != GDB_ID_NULL)
-      LuaSetParam( L, nId) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
 //-------------------------------------------------------------------------------
 static int
 LuaCreateSurfTmByFlatContour( lua_State* L)
@@ -648,9 +453,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,
@@ -796,41 +603,6 @@ LuaCreateSurfTmRectSwept( lua_State* L)
 //-------------------------------------------------------------------------------
 static int
 LuaCreateSurfTmSwept( lua_State* L)
-{
-  // 4, 5, 6 o 7 parametri : ParentId, SectId, GuideId [, vtAx], bCapEnds [, dTol] [, nRefType]
-   int nParentId ;
-   LuaCheckParam( L, 1, nParentId)
-   int nSectId ;
-   LuaCheckParam( L, 2, nSectId)
-   int nGuideId ;
-   LuaCheckParam( L, 3, nGuideId)
-   int nPar = 4 ;
-   Vector3d vtAx = V_NULL ;
-   if ( LuaGetParam( L, nPar, vtAx))
-      ++ nPar ;
-   bool bCapEnds ;
-   LuaCheckParam( 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 swept
-   int nId = ExeCreateSurfTmSwept( nParentId, nSectId, nGuideId, vtAx, bCapEnds, dLinTol, nRefType) ;
-  // restituisco il risultato
-   if ( nId != GDB_ID_NULL)
-      LuaSetParam( L, nId) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaCreateSurfTmTransSwept( lua_State* L)
 {
  // 4 o 5 parametri : ParentId, SectId, GuideId, bCapEnds [, dTol]
   int nParentId ;
@@ -844,8 +616,8 @@ LuaCreateSurfTmTransSwept( lua_State* L)
   double dLinTol = LIN_TOL_SRF ;
   LuaGetParam( L, 5, dLinTol) ;
   LuaClearStack( L) ;
-  // creo STM swept di traslazione
-   int nId = ExeCreateSurfTmTransSwept( nParentId, nSectId, nGuideId, bCapEnds, dLinTol) ;
+  // creo STM swept
+   int nId = ExeCreateSurfTmSwept( nParentId, nSectId, nGuideId, bCapEnds, dLinTol) ;
  // restituisco il risultato
   if ( nId != GDB_ID_NULL)
      LuaSetParam( L, nId) ;
@@ -933,6 +705,26 @@ LuaCreateSurfTmBySewing( lua_State* L)
   return 1 ;
 }

+//-------------------------------------------------------------------------------
+static int
+LuaCreateSurfTmBySurfBezier( lua_State* L)
+{
+  // 2 parametri : ParentId, nSbezId
+   int nParentId ;
+   LuaCheckParam( L, 1, nParentId)
+   int nZmapId ;
+   LuaCheckParam( L, 2, nZmapId)
+   LuaClearStack( L) ;
+  // creo STM partendo da superficie di Bezier
+   int nId = ExeCreateSurfTmBySurfBezier( nParentId, nZmapId) ;
+  // restituisco il risultato
+   if ( nId != GDB_ID_NULL)
+      LuaSetParam( L, nId) ;
+   else
+      LuaSetParam( L) ;
+   return 1 ;
+}
+
 //-------------------------------------------------------------------------------
 static int
 LuaCreateSurfTmByVolZmap( lua_State* L)
@@ -956,29 +748,6 @@ LuaCreateSurfTmByVolZmap( lua_State* L)
   return 1 ;
 }

-//-------------------------------------------------------------------------------
-static int
-LuaCreateSurfShell( lua_State* L)
-{
-  // 4 parametri : nParentId, nSurfId, dThick, dLinTol
-   int nParentId ;
-   LuaCheckParam( L, 1, nParentId) ;
-   int nSurfId ;
-   LuaCheckParam( L, 2, nSurfId) ;
-   double dThick ;
-   LuaCheckParam( L, 3, dThick) ;
-   double dLinTol ;
-   LuaCheckParam( L, 4, dLinTol) ;
-  // creo la STM
-   int nId = ExeCreateSurfShell( nParentId, nSurfId, dThick, dLinTol) ;
-  // restituisco il risultato
-   if ( nId != GDB_ID_NULL)
-      LuaSetParam( L, nId) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
 //-------------------------------------------------------------------------------
 static int
 LuaCreateSurfBezier( lua_State* L)
@@ -1047,440 +816,6 @@ LuaCreateSurfBezierRational( lua_State* L)
   return 1 ;
 }

-//-------------------------------------------------------------------------------
-static int
-LuaCreateSurfBezierLeaves( lua_State* L)
-{
-   // 2, 3 o 4 parametri : ParentId, nId [, nTextHeight] [, bShowTrim] [, bRefined]
-   int nParentId ;
-   LuaCheckParam( L, 1, nParentId)
-   int nSurfBzId ;
-   LuaCheckParam( L, 2, nSurfBzId)
-   int nTextHeight = 50 ;
-   bool bShowTrim = false ;
-   bool bRefined = false ;
-   // testo più due booleani o solo due booleani
-   if ( LuaGetParam( L, 3, nTextHeight)) {
-      if ( LuaGetParam( L, 4, bShowTrim))
-         LuaGetParam( L, 5, bRefined) ;
-   }
-   else {
-      LuaGetParam( L, 3, bShowTrim) ;
-      LuaGetParam( L, 4, bRefined) ;
-   }
-   LuaClearStack( L) ;
-   // creo la superficie
-   int nCount = 0 ;
-   int nId = ExeCreateSurfBezierLeaves( nParentId, nSurfBzId, nTextHeight, bShowTrim, bRefined, &nCount) ;
-   // restituisco il risultato
-   if ( nId != GDB_ID_NULL) {
-      LuaSetParam( L, nId) ;
-      LuaSetParam( L, nCount) ;  
-   }
-   else {
-      LuaSetParam( L) ;
-      LuaSetParam( L) ;
-   }
-   return 2 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaCreateSurfBezierTria2D( lua_State* L)
-{
-   // 2, 3 o 4 parametri : ParentId, nId [, nTextHeight] [, bShowTrim]
-   int nParentId ;
-   LuaCheckParam( L, 1, nParentId)
-      int nSurfBzId ;
-   LuaCheckParam( L, 2, nSurfBzId)
-      int nTextHeight = 50 ;
-   bool bShowTrim = false ;
-   if ( LuaGetParam( L, 3, nTextHeight))
-      LuaGetParam( L, 4, bShowTrim) ;
-   else
-      LuaGetParam( L, 3, bShowTrim) ;
-   LuaClearStack( L) ;
-   // creo la superficie
-   int nCount = 0 ;
-   int nId = ExeCreateSurfBezierTria2D( nParentId, nSurfBzId, nTextHeight, bShowTrim, &nCount) ;
-   // restituisco il risultato
-   if ( nId != GDB_ID_NULL) {
-      LuaSetParam( L, nId) ;
-      LuaSetParam( L, nCount) ;  
-   }
-   else {
-      LuaSetParam( L) ;
-      LuaSetParam( L) ;
-   }
-   return 2 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaCreateBezierSphere( lua_State* L)
-{
-   // 3 o 4 parametri : ParentId, ptCenter, dRad [, nRefType]
-   int nParentId ;
-   LuaCheckParam( L, 1, nParentId)
-   Point3d ptCenter ;
-   LuaCheckParam( L, 2, ptCenter)
-   double dRad ;
-   LuaCheckParam( L, 3, dRad)
-   int nRefType = RTY_DEFAULT ;
-   LuaGetParam( L, 4, nRefType) ;
-   // creo la superficie
-   int nCount = 0 ;
-   int nId = ExeCreateBezierSphere( nParentId, ptCenter, dRad, nRefType) ;
-   // restituisco il risultato
-   if ( nId != GDB_ID_NULL) {
-      LuaSetParam( L, nId) ;
-      LuaSetParam( L, nCount) ;  
-   }
-   else {
-      LuaSetParam( L) ;
-      LuaSetParam( 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 SurfBezier estrudendo un percorso, se piano si possono mettere i tappi
-   int nCount = 0 ;
-   int nId = ExeCreateSurfBzByExtrusion( nParentId, nCrvId, vtExtr, bCapEnds, dLinTol, nRefType, &nCount) ;
-   // restituisco il risultato
-   if ( nId != GDB_ID_NULL)
-      LuaSetParam( L, nId) ;
-   else
-      LuaSetParam( L) ;
-   LuaSetParam( L, nCount) ;
-   return 2 ;
-}
-
-//-------------------------------------------------------------------------------
-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 una surf bezier come rigata tra le due curve passate
-   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
-LuaCreateSurfBzRuledGuided( lua_State* L)
-{
-   // 4 o 5 o 6 parametri : ParentId, CrvId1, CrvId2, nLayGuides [, bCapEnds] [, dTol] 
-   int nParentId ;
-   LuaCheckParam( L, 1, nParentId)
-   int nCrvId1 ;
-   LuaCheckParam( L, 2, nCrvId1)
-   int nCrvId2 ;
-   LuaCheckParam( L, 3, nCrvId2)
-   int nLayGuides ;
-   LuaCheckParam( L, 4, nLayGuides)
-   bool bCapEnds = false ;
-   int nPar = 5 ;
-   if ( LuaGetParam( L, nPar, bCapEnds))
-      ++ nPar ;
-   double dLinTol = LIN_TOL_SRF ;
-   LuaGetParam( L, nPar, dLinTol) ;
-   LuaClearStack( L) ;
-   BIPNTVECTOR vGuides ;
-
-   // creo una surf bezier come rigata tra le due curve passate, usando le isocurve nel layer nLayIso
-   int nId = ExeCreateSurfBzRuledGuided( nParentId, nCrvId1, nCrvId2, vGuides, bCapEnds, dLinTol, nLayGuides) ;
-   // 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)
@@ -1492,7 +827,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) ;
@@ -1501,12 +835,6 @@ LuaInstallGdbCreateSurf( LuaMgr& luaMgr)
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmCylinder", LuaCreateSurfTmCylinder) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmCone", LuaCreateSurfTmCone) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmSphere", LuaCreateSurfTmSphere) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmPyramidFrustum", LuaCreateSurfTmPyramidFrustum) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmConeFrustum", LuaCreateSurfTmConeFrustum) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmTriangle", LuaCreateSurfTmTriangle) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmRectangle", LuaCreateSurfTmRectangle) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmByPolygon", LuaCreateSurfTmByPolygon) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmByPolygonWithHoles", LuaCreateSurfTmByPolygonWithHoles) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmByFlatContour", LuaCreateSurfTmByFlatContour) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmByRegion", LuaCreateSurfTmByRegion) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmByExtrusion", LuaCreateSurfTmByExtrusion) ;
@@ -1515,27 +843,12 @@ LuaInstallGdbCreateSurf( LuaMgr& luaMgr)
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmByScrewing", LuaCreateSurfTmByScrewing) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmRectSwept", LuaCreateSurfTmRectSwept) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmSwept", LuaCreateSurfTmSwept) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmTransSwept", LuaCreateSurfTmTransSwept) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmRuled", LuaCreateSurfTmRuled) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmByTriangles", LuaCreateSurfTmByTriangles) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmBySewing", LuaCreateSurfTmBySewing) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmBySurfBezier", LuaCreateSurfTmBySurfBezier) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmByVolZmap", LuaCreateSurfTmByVolZmap) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmShell", LuaCreateSurfShell) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBezier", LuaCreateSurfBezier) ;
   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( "EgtSurfBzRuledGuided", LuaCreateSurfBzRuledGuided) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBzSkinned", LuaCreateSurfBzSkinned) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBzSwept", LuaCreateSurfBzSwept) ;
   return bOk ;
 }
@@ -14,7 +14,6 @@
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
 #include "LUA.h"
-#include "/EgtDev/Include/EGkSurfTriMesh.h"
 #include "/EgtDev/Include/EXeExecutor.h"
 #include "/EgtDev/Include/EXeConst.h"
 #include "/EgtDev/Include/EGkLuaAux.h"
@@ -55,42 +54,6 @@ LuaCreateVolZmapBox( lua_State* L)
   return 1 ;
 }

-//-------------------------------------------------------------------------------
-static int
-LuaCreateVolZmapEmpty( lua_State* L)
-{
-  // 6 o 7 o 8 parametri : ParentId, PtIni, dDimX, dDimY, dDimZ, dPrec [, bTriDex] [, nRefType]
-   int nParentId ;
-   LuaCheckParam( L, 1, nParentId)
-   Point3d ptIni ;
-   LuaCheckParam( L, 2, ptIni)
-   double dDimX ;
-   LuaCheckParam( L, 3, dDimX)
-   double dDimY ;
-   LuaCheckParam( L, 4, dDimY)
-   double dDimZ ;
-   LuaCheckParam( L, 5, dDimZ)
-   double dPrec ;
-   LuaCheckParam( L, 6, dPrec)
-   bool bTriDex = true ;
-   int nRefType = RTY_DEFAULT ;
-   if ( ! LuaGetParam( L, 7, bTriDex))
-      LuaGetParam( L, 7, nRefType) ;
-   else
-      LuaGetParam( L, 8, nRefType) ;
-   LuaClearStack( L) ;
-  // creo VZM parallelepipedo
-   int nId = ExeCreateVolZmapEmpty( nParentId, ptIni, dDimX, dDimY, dDimZ, dPrec, bTriDex, nRefType) ;
-  // restituisco il risultato
-   if ( nId != GDB_ID_NULL)
-      LuaSetParam( L, nId) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
-
-
 //-------------------------------------------------------------------------------
 static int
 LuaCreateVolZmapByRegionExtrusion( lua_State* L)
@@ -121,7 +84,7 @@ LuaCreateVolZmapByRegionExtrusion( lua_State* L)
 static int
 LuaCreateVolZmapFromSurfTm( lua_State* L)
 {
-  // 3 o 4 o 5 parametri : ParentId, StmId, dPrec [, bTriDex] [, dExtraBox]
+  // 3 o 4 parametri : ParentId, StmId, dPrec [, bTriDex]
   int nParentId ;
   LuaCheckParam( L, 1, nParentId)
   int nStmId ;
@@ -129,14 +92,10 @@ LuaCreateVolZmapFromSurfTm( lua_State* L)
   double dPrec ;
   LuaCheckParam( L, 3, dPrec)
   bool bTriDex = true ;
-   double dExtraBox = 0 ;
-   if ( LuaGetParam( L, 4, bTriDex))
-      LuaGetParam( L, 5, dExtraBox) ;
-   else
-      LuaGetParam( L, 4, dExtraBox) ;
+   LuaGetParam( L, 4, bTriDex) ;
   LuaClearStack( L) ;
  // creo VZM da superficie trimesh 
-   int nId = ExeCreateVolZmapFromSurfTm( nParentId, nStmId, dPrec, bTriDex, dExtraBox) ;
+   int nId = ExeCreateVolZmapFromSurfTm( nParentId, nStmId, dPrec, bTriDex) ;
  // restituisco il risultato
   if ( nId != GDB_ID_NULL)
      LuaSetParam( L, nId) ;
@@ -151,7 +110,6 @@ LuaInstallGdbCreateVol( LuaMgr& luaMgr)
 {
   bool bOk = ( &luaMgr != nullptr) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtVolZmapBox", LuaCreateVolZmapBox) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtVolZmapEmpty", LuaCreateVolZmapEmpty) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtVolZmapByRegionExtrusion", LuaCreateVolZmapByRegionExtrusion) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtVolZmapFromSurfTm", LuaCreateVolZmapFromSurfTm) ;
   return bOk ;
@@ -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)
@@ -558,7 +522,7 @@ LuaCurveCompoNormVersor( lua_State* L)
   int nRefId = nId ;
   LuaGetParam( L, 3, nRefId) ;
   LuaClearStack( L) ;
-  // recupero il versore normale della curva semplice indicizzata (non nullo solo se arco)
+  // recupero l'angolo al centro della curva semplice indicizzata
   Vector3d vtNorm ;
   if ( ExeCurveCompoNormVersor( nId, nCrv, nRefId, vtNorm))
      LuaSetParam( L, vtNorm) ;
@@ -567,112 +531,6 @@ LuaCurveCompoNormVersor( lua_State* L)
   return 1 ;
 }

-//----------------------------------------------------------------------------
-static int
-LuaCurveCompoGetTempProp( lua_State* L)
-{
-  // 1 o 2 parametri : Id [, nPropInd]
-   int nId ;
-   LuaCheckParam( L, 1, nId)
-   int nPropInd = 0 ;
-   LuaGetParam( L, 2, nPropInd) ;
-   LuaClearStack( L) ;
-  // recupero il vettore delle proprietà temporanee di indice dato
-   INTVECTOR vProp ;
-   if ( ExeCurveCompoGetTempProp( nId, vProp, nPropInd))
-      LuaSetParam( L, vProp) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
-//----------------------------------------------------------------------------
-static int
-LuaCurveCompoGetTempParam( lua_State* L)
-{
-  // 1 o 2 parametri : Id [, nParamInd]
-   int nId ;
-   LuaCheckParam( L, 1, nId)
-   int nParamInd = 0 ;
-   LuaGetParam( L, 2, nParamInd) ;
-   LuaClearStack( L) ;
-  // recupero il vettore dei parametri temporanei di indice dato
-   DBLVECTOR vParam ;
-   if ( ExeCurveCompoGetTempParam( nId, vParam, nParamInd))
-      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)
@@ -680,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) ;
@@ -690,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) ;
@@ -706,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 ;
 }
@@ -1,90 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2023-2023
-//----------------------------------------------------------------------------
-// File : LUA_GdbGetPocketing.cpp       Data : 28.11.23        Versione : 2.5k6
-// Contenuto : Funzioni di creazione percorsi di svuotatura o infill per LUA.
-//
-//
-//
-// Modifiche : 29.11.23 RE Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-//--------------------------- Include ----------------------------------------
-#include "stdafx.h"
-#include "LUA.h"
-#include "/EgtDev/Include/EXeExecutor.h"
-
-using namespace std ;
-
-//----------------------------------------------------------------------------
-static int
-LuaPocketing( lua_State* L) {
-  // 7 parametri : nId, dRad, dStep, dAngle, nType, bSmooth, nDestGrpId
-   int nId ;
-   LuaCheckParam( L, 1, nId) ;
-   double dRad ;
-   LuaCheckParam( L, 2, dRad) ;
-   double dStep ;
-   LuaCheckParam( L, 3, dStep) ;
-   double dAngle ;
-   LuaCheckParam( L, 4, dAngle) ;
-   int nType ;
-   LuaCheckParam( L, 5, nType) ;
-   bool bSmooth ;
-   LuaCheckParam( L, 6, bSmooth) ;
-   int nDestGrpId ;
-   LuaCheckParam( L, 7, nDestGrpId) ;
-   LuaClearStack( L) ;
-  // calcolo delle curve elementari di svuotatura
-   int nFirstId = GDB_ID_NULL ;
-   int nCrvCount = 0 ;
-   bool bOk = ExePocketing( nId, dRad, dStep, dAngle, nType, bSmooth, nDestGrpId, nFirstId, nCrvCount) ;
-   if ( ! bOk)
-      LuaSetParam( L) ;
-   else
-      LuaSetParam( L, nFirstId) ;
-   LuaSetParam( L, nCrvCount) ;
-   return 2 ;
-}
-
-//----------------------------------------------------------------------------
-static int
-LuaSurfFrGetZigZagInfill( lua_State* L)
-{
-  // 6 parametri : nId, nDestGrpId, dSideStep, dAng, bSmooth, bRemoveOverlapLink
-   int nId ;
-   LuaCheckParam( L, 1, nId)
-   int nDestGrpId ;
-   LuaCheckParam( L, 2, nDestGrpId)
-   double dStep ;
-   LuaCheckParam( L, 3, dStep)
-   double dAng ;
-   LuaCheckParam( L, 4, dAng) ;
-   bool bSmooth ;
-   LuaCheckParam( L, 5, bSmooth) ;
-   bool bRemoveOverlapLink ;
-   LuaCheckParam( L, 6, bRemoveOverlapLink) ;
-   LuaClearStack( L) ;
-  // recupero i contorni della superficie
-   int nCount = 0 ;
-   int nNewId = ExeSurfFrGetZigZagInfill( nId, nDestGrpId, dStep, dAng, bSmooth, bRemoveOverlapLink, &nCount) ;
-  // restituisco il risultato
-   if ( nNewId != GDB_ID_NULL)
-      LuaSetParam( L, nNewId) ;
-   else
-      LuaSetParam( L) ;
-   LuaSetParam( L, nCount) ;
-   return 2 ;
-}
-
-//-------------------------------------------------------------------------------
-bool
-LuaInstallGdbGetPocketing( LuaMgr& luaMgr)
-{
-   bool bOk = ( &luaMgr != nullptr) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtPocketing", LuaPocketing) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtGetSurfFrZigZagInfill", LuaSurfFrGetZigZagInfill) ;
-   return bOk ;
-}
@@ -48,7 +48,7 @@ LuaSurfIsClosed( lua_State* L)
   int nId ;
   LuaCheckParam( L, 1, nId)
   LuaClearStack( L) ;
-  // verifico se � superficie chiusa
+  // verifico se è superficie chiusa
   bool bOk = ExeSurfIsClosed( nId) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
@@ -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)
@@ -218,7 +199,7 @@ LuaSurfFrMoveSimpleNoCollision( lua_State* L)
   int nRefType = RTY_DEFAULT ;
   LuaGetParam( L, 4, nRefType) ;
   LuaClearStack( L) ;
-  // verifico quale � la massima traslazione possibile
+  // verifico quale è la massima traslazione possibile
   double dLen = vtMove.Len() ;
   Vector3d vtDir = ( dLen > EPS_SMALL ? vtMove / dLen : V_NULL) ;
   bool bOk = ExeSurfFrMoveSimpleNoCollision( nId1, nId2, vtDir, dLen, nRefType) ;
@@ -246,7 +227,7 @@ LuaSurfFrRotateSimpleNoCollision( lua_State* L)
   int nRefType = RTY_DEFAULT ;
   LuaGetParam( L, 5, nRefType) ;
   LuaClearStack( L) ;
-  // verifico quale � la massima (in valore assoluto) rotazione possibile
+  // verifico quale è la massima (in valore assoluto) rotazione possibile
   bool bOk = ExeSurfFrRotateSimpleNoCollision( nId1, nId2, ptCen, dAngDeg, nRefType) ;
  // restituisco il risultato
   if ( bOk)
@@ -256,6 +237,37 @@ LuaSurfFrRotateSimpleNoCollision( lua_State* L)
   return 1 ;
 }

+
+//----------------------------------------------------------------------------
+static int
+LuaSurfFrGetZigZagInfill( lua_State* L)
+{
+  // 6 parametri : nId, nDestGrpId, dSideStep, dAng, bAllowStepCorrection, bInvert 
+   int nId ;
+   LuaCheckParam( L, 1, nId)
+   int nDestGrpId ;
+   LuaCheckParam( L, 2, nDestGrpId)
+   double dStep ;
+   LuaCheckParam( L, 3, dStep)
+   double dAng ;
+   LuaCheckParam( L, 4, dAng) ;
+   bool bStepCorrection ;
+   LuaCheckParam( L, 5, bStepCorrection)
+   bool bInvert ;
+   LuaCheckParam( L, 6, bInvert)
+   LuaClearStack( L) ;
+  // recupero i contorni della superficie
+   int nCount = 0 ;
+   int nNewId = ExeSurfFrGetZigZagInfill( nId, nDestGrpId, dStep, dAng, bStepCorrection, bInvert, &nCount) ;
+  // restituisco il risultato
+   if ( nNewId != GDB_ID_NULL)
+      LuaSetParam( L, nNewId) ;
+   else
+      LuaSetParam( L) ;
+   LuaSetParam( L, nCount) ;
+   return 2 ;
+}
+
 //----------------------------------------------------------------------------
 static int
 LuaSurfTmVertexCount( lua_State* L)
@@ -301,25 +313,6 @@ LuaSurfTmPartCount( lua_State* L)
   return 1 ;
 }

-//----------------------------------------------------------------------------
-static int
-LuaSurfTmGetPartAndShellFromFacet( lua_State* L)
-{
-   // 2 parametri : Id SurfTm, Id Facet
-   int nIdSurfTm ;
-   LuaCheckParam( L, 1, nIdSurfTm)
-   int nIdFacet ;
-   LuaCheckParam( L, 2, nIdFacet)
-   LuaClearStack( L) ;
-  // recupero il numero di parti della superficie trimesh
-   int nPart = - 1 ;
-   int nShell = - 1 ;
-   ExeSurfTmGetPartAndShellFromFacet( nIdSurfTm, nIdFacet, nPart, nShell) ;
-   LuaSetParam( L, nPart) ;
-   LuaSetParam( L, nShell) ;
-   return 2 ;
-}
-
 //----------------------------------------------------------------------------
 static int
 LuaSurfTmGetVertex( lua_State* L)
@@ -354,7 +347,7 @@ LuaSurfTmGetNearestVertex( lua_State* L)
   int nRefId = nId ;
   LuaGetParam( L, 3, nRefId) ;
   LuaClearStack( L) ;
-  // recupero il vertice pi� vicino della superficie
+  // recupero il vertice più vicino della superficie
   int nVert ;
   Point3d ptVert ;
   bool bOk = ExeSurfTmGetNearestVertex( nId, ptNear, nRefId, nVert, ptVert) ;
@@ -369,27 +362,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)
@@ -502,44 +474,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 ;
-   PNTVECTOR vptStart ;
-   VCT3DVECTOR vvtNorm ;
-   DBLVECTOR vdElev ;
-   DBLVECTOR vdLen ;
-   bool bOk = ExeSurfTmGetFacetOutlineInfo( nId, nFacet, nRefId, nStatus, vbOpen, vnAdj, vdLen, vptStart, vvtNorm, vdElev) ;
-  // restituisco il risultato
-   if ( bOk) {
-      LuaSetParam( L, nStatus) ;
-      LuaSetParam( L, vbOpen) ;
-      LuaSetParam( L, vnAdj) ;
-      LuaSetParam( L, vdLen) ;
-      LuaSetParam( L, vptStart) ;
-      LuaSetParam( L, vvtNorm) ;
-      LuaSetParam( L, vdElev) ;
-      return 7 ;
-   }
-   else {
-      LuaSetParam( L) ;
-      return 1 ;
-   }
-}
-
 //----------------------------------------------------------------------------
 static int
 LuaSurfTmFacetAdjacencies( lua_State* L)
@@ -575,7 +509,7 @@ LuaSurfTmFacetNearestEndPoint( lua_State* L)
   int nRefId = nId ;
   LuaGetParam( L, 4, nRefId) ;
   LuaClearStack( L) ;
-  // recupero il punto End pi� vicino della faccia della superficie trimesh
+  // recupero il punto End più vicino della faccia della superficie trimesh
   Point3d ptEnd ;
   Vector3d vtN ;
   if ( ExeSurfTmFacetNearestEndPoint( nId, nFacet, ptNear, nRefId, ptEnd, vtN)) {
@@ -603,7 +537,7 @@ LuaSurfTmFacetNearestMidPoint( lua_State* L)
   int nRefId = nId ;
   LuaGetParam( L, 4, nRefId) ;
   LuaClearStack( L) ;
-  // recupero il punto Mid pi� vicino della faccia della superficie trimesh
+  // recupero il punto Mid più vicino della faccia della superficie trimesh
   Point3d ptMid ;
   Vector3d vtN ;
   if ( ExeSurfTmFacetNearestMidPoint( nId, nFacet, ptNear, nRefId, ptMid, vtN)) {
@@ -691,58 +625,6 @@ LuaSurfTmFacetMinAreaRectangle( lua_State* L)
   }
 }

-//----------------------------------------------------------------------------
-static int
-LuaSurfTmFacetElevationInBBox( lua_State* L)
-{
-  // 3 o 4 o 5 parametri : Id, nFacet, b3Box [, bAcceptOutFacet] [, nRefId]
-   int nId ;
-   LuaCheckParam( L, 1, nId)
-   int nFacet ;
-   LuaCheckParam( L, 2, nFacet)
-   BBox3d b3Box ;
-   LuaCheckParam( L, 3, b3Box)
-   bool bAcceptOutFacet = false ;
-   int nRefId = nId ;
-   if ( ! LuaGetParam( L, 4, nRefId)) {
-      LuaGetParam( L, 4, bAcceptOutFacet) ;
-      LuaGetParam( L, 5, nRefId) ;
-   }
-   LuaClearStack( L) ;
-  // calcolo elevazione
-   double dElev ;
-   bool bOk = ExeSurfTmFacetElevationInBBox( nId, nFacet, b3Box, bAcceptOutFacet, nRefId, dElev) ;
-   if ( bOk)
-      LuaSetParam( L, dElev) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
-//----------------------------------------------------------------------------
-static int
-LuaSurfTmFacetElevationInClosedSurfTm( lua_State* L)
-{
-  // 3 o 4 parametri : nFacetStmId, nFacet, nClosedStmId [, bAcceptOutFacet]
-   int nFacetStmId ;
-   LuaCheckParam( L, 1, nFacetStmId)
-   int nFacet ;
-   LuaCheckParam( L, 2, nFacet)
-   int nClosedStmId ;
-   LuaCheckParam( L, 3, nClosedStmId)
-   bool bAcceptOutFacet = false ;
-   LuaGetParam( L, 4, bAcceptOutFacet) ;
-   LuaClearStack( L) ;
-  // calcolo elevazione
-   double dElev ;
-   bool bOk = ExeSurfTmFacetElevationInClosedSurfTm( nFacetStmId, nFacet, nClosedStmId, bAcceptOutFacet, dElev) ;
-   if ( bOk)
-      LuaSetParam( L, dElev) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
 //----------------------------------------------------------------------------
 static int
 LuaSurfTmFacetOppositeSide( lua_State* L)
@@ -841,7 +723,7 @@ LuaExtractSurfTmLoops( lua_State* L)
 static int
 LuaGetSurfTmSilhouette( lua_State* L)
 {
-  // 4 o 5 o 6 parametri : nId, vtDir, dToler, nDestGrpId [, nRefType [, bAllTria]]
+  // 4 o 5 parametri : nId, vtDir, dToler, nDestGrpId [, nRefType]
   int nId ;
   LuaCheckParam( L, 1, nId)
   Vector3d vtDir ;
@@ -851,15 +733,11 @@ LuaGetSurfTmSilhouette( lua_State* L)
   int nDestGrpId ;
   LuaCheckParam( L, 4, nDestGrpId)
   int nRefType = RTY_DEFAULT ;
-   bool bAllTria = false ;
-   if ( LuaGetParam( L, 5, nRefType))
-      LuaGetParam( L, 6, bAllTria) ;
-   else
-      LuaGetParam( L, 5, bAllTria) ;
+   LuaGetParam( L, 5, nRefType) ;
   LuaClearStack( L) ;
  // recupero i contorni della superficie
   int nCount = 0 ;
-   int nNewId = ExeGetSurfTmSilhouette( nId, vtDir, dToler, nDestGrpId, nRefType, &nCount, bAllTria) ;
+   int nNewId = ExeGetSurfTmSilhouette( nId, vtDir, dToler, nDestGrpId, nRefType, &nCount) ;
  // restituisco il risultato
   if ( nNewId != GDB_ID_NULL)
      LuaSetParam( L, nNewId) ;
@@ -869,38 +747,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)
@@ -925,28 +771,6 @@ LuaExtractSurfTmFacetLoops( lua_State* L)
   return 2 ;
 }

-//----------------------------------------------------------------------------
-static int
-LuaExtractSurfTmTriaLoop( lua_State* L)
-{
-   // 3 parametri : nId, nT, nDestGrpId
-   int nId ;
-   LuaCheckParam( L, 1, nId)
-      int nT ;
-   LuaCheckParam( L, 2, nT)
-      int nDestGrpId ;
-   LuaCheckParam( L, 3, nDestGrpId)
-      LuaClearStack( L) ;
-   // recupero i contorni della superficie
-   int nNewId = ExeExtractSurfTmTriaLoop( nId, nT, nDestGrpId) ;
-   // restituisco il risultato
-   if ( nNewId != GDB_ID_NULL)
-      LuaSetParam( L, nNewId) ;
-   else
-      LuaSetParam( L) ;
-   return 2 ;
-}
-
 //----------------------------------------------------------------------------
 static int
 LuaCopySurfTmFacet( lua_State* L)
@@ -969,57 +793,6 @@ LuaCopySurfTmFacet( lua_State* L)
   return 1 ;
 }

-//----------------------------------------------------------------------------
-static int
-LuaSurfTmGetEdges( lua_State* L)
-{
-  // 2 o 3 parametri : nId, nDestGrpId [, bSmoothAng]
-   int nId ;
-   LuaCheckParam( L, 1, nId)
-   int nDestGrpId ;
-   LuaCheckParam( L, 2, nDestGrpId)
-   bool bSmoothAng = true ;
-   LuaGetParam( L, 3, bSmoothAng) ;
-   LuaClearStack( L) ;
-  // calcolo gli spigoli della superficie
-   int nCount ;
-   int nFirstId = ExeSurfTmGetEdges( nId, nDestGrpId, bSmoothAng, &nCount) ;
-  // restituisco il risultato
-   if ( nFirstId != GDB_ID_NULL  ||  nCount != -1) {
-      LuaSetParam( L, nFirstId) ;
-      LuaSetParam( L, nCount) ;
-   }
-   else {
-      LuaSetParam( L) ;
-      LuaSetParam( L) ;
-   }
-   return 2 ;
-}
-
-//----------------------------------------------------------------------------
-static int
-LuaSurfTmGetCurvature( lua_State* L)
-{
-  // 2 parametri : nStmId, nIndV
-   int nStmId ;
-   LuaCheckParam( L, 1, nStmId) ;
-   int nIndVertex ;
-   LuaCheckParam( L, 2, nIndVertex) ;
-   LuaClearStack( L) ;
-   double dK1 = 0., dK2 = 0. ;
-   Vector3d vtK1 = V_NULL, vtK2 = V_NULL ;
-   bool bOk = ExeSurfTmGetCurvatures( nStmId, nIndVertex, dK1, vtK1, dK2, vtK2) ;
-   LuaSetParam( L, bOk) ;
-   if ( bOk) {
-      LuaSetParam( L, dK1) ;
-      LuaSetParam( L, vtK1) ;
-      LuaSetParam( L, dK2) ;
-      LuaSetParam( L, vtK2) ;
-      return 5 ;
-   }
-   return 1 ;
-}
-
 //----------------------------------------------------------------------------
 static int
 LuaSurfBezierGetPoint( lua_State* L)
@@ -1159,34 +932,6 @@ LuaSurfBezierGetCurveV( lua_State* L)
   return 1 ;
 }

-//----------------------------------------------------------------------------
-static int
-LuaSurfBezParamsFromPoint( lua_State* L)
-{
-  // 2 o 3 parametri : nSurfId, ptOnSurf [, nRefId]
-   int nSurfId ;
-   LuaCheckParam( L, 1, nSurfId)
-   Point3d ptOnSurf ;
-   LuaCheckParam( L, 2, ptOnSurf)
-   int nRefId = nSurfId ;
-   LuaGetParam( L, 3, nRefId) ;
-   LuaClearStack( L) ;
-  // recupero le coordinate parametriche del punto
-   double dU = - 1 ;
-   double dV = - 1 ;
-   bool bOk = ExeSurfBezierParamsFromPoint( nSurfId, ptOnSurf, nRefId, dU, dV) ;
-   if ( bOk) {
-      LuaSetParam( L, dU) ;
-      LuaSetParam( L, dV) ;
-   }
-   else {
-      LuaSetParam( L) ;
-      LuaSetParam( L) ;
-   }
-
-   return 2 ;
-}
-
 //----------------------------------------------------------------------------
 static int
 LuaSurfBezierGetInfo( lua_State* L)
@@ -1283,30 +1028,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)
@@ -1318,53 +1039,42 @@ 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) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfFrMoveSimpleNoCollision", LuaSurfFrMoveSimpleNoCollision) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfFrRotateSimpleNoCollision", LuaSurfFrRotateSimpleNoCollision) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtGetSurfFrZigZagInfill", LuaSurfFrGetZigZagInfill) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmVertexCount", LuaSurfTmVertexCount) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmFacetCount", LuaSurfTmFacetCount) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmPartCount", LuaSurfTmPartCount) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmGetPartAndShellFromFacet", LuaSurfTmGetPartAndShellFromFacet) ;
   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) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmFacetCenter", LuaSurfTmFacetCenter) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmFacetNormVersor", LuaSurfTmFacetNormVersor) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmFacetMinAreaRectangle", LuaSurfTmFacetMinAreaRectangle) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmFacetElevationInBBox", LuaSurfTmFacetElevationInBBox) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmFacetElevationInClosedSurfTm", LuaSurfTmFacetElevationInClosedSurfTm) ;  
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmFacetOppositeSide", LuaSurfTmFacetOppositeSide) ;
   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( "EgtExtractSurfTmTriaLoop", LuaExtractSurfTmTriaLoop) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtCopySurfTmFacet", LuaCopySurfTmFacet) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmGetEdges", LuaSurfTmGetEdges) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmGetCurvature", LuaSurfTmGetCurvature) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBezierGetPoint", LuaSurfBezierGetPoint) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBezierGetPointD1", LuaSurfBezierGetPointD1) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBezierGetPointNrmD1", LuaSurfBezierGetPointNrmD1) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBezierGetCurveU", LuaSurfBezierGetCurveU) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBezierGetCurveV", LuaSurfBezierGetCurveV) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBezParamsFromPoint", LuaSurfBezParamsFromPoint) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBezierGetInfo", LuaSurfBezierGetInfo) ;
   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 ;
 }
@@ -211,7 +211,6 @@ LuaVolZmapGetDepth( lua_State* L)
   }
   return 2 ;
 }
-
 //----------------------------------------------------------------------------
 static int
 LuaVolZmapGetEdges( lua_State* L)
@@ -222,7 +221,7 @@ LuaVolZmapGetEdges( lua_State* L)
   int nDestGrpId ;
   LuaCheckParam( L, 2, nDestGrpId)
   LuaClearStack( L) ;
-  // calcolo gli spigoli del solido
+  // eseguo calcolo profondità dal punto lungo la direzione
   int nCount ;
   int nFirstId = ExeVolZmapGetEdges( nId, nDestGrpId, &nCount) ;
  // restituisco il risultato
@@ -19,7 +19,6 @@
 #include "/EgtDev/Include/EXeConst.h"
 #include "/EgtDev/Include/EGkCurve.h"
 #include "/EgtDev/Include/EGkLuaAux.h"
-#include "/EgtDev/Include/EGkCalcPocketing.h"

 using namespace std ;

@@ -60,19 +59,17 @@ LuaOffsetCurve( lua_State* L)
 static int
 LuaOffsetCurveAdv( lua_State* L)
 {
-  // 2 o 3 o 4 parametri : Id, dDist [, nType] [, dLinTol]
+  // 2 o 3 parametri : Id, dDist [, nType]
   int nId ;
   LuaCheckParam( L, 1, nId)
   double dDist ;
   LuaCheckParam( L, 2, dDist)
   int nType = ICurve::OFF_FILLET ;
   LuaGetParam( L, 3, nType) ;
-   double dLinTol = 10 * EPS_SMALL ;
-   LuaGetParam( L, 4, dLinTol) ;
   LuaClearStack( L) ;
  // offset della curva
   int nCount ;
-   int nNewId = ExeOffsetCurveAdv( nId, dDist, nType, &nCount, dLinTol) ;
+   int nNewId = ExeOffsetCurveAdv( nId, dDist, nType, &nCount) ;
   if ( nCount >= 0) {
      LuaSetParam( L, nNewId) ;
      LuaSetParam( L, nCount) ;
@@ -105,18 +102,16 @@ LuaCurveMedialAxis( lua_State* L)
 static int
 LuaApproxCurve( lua_State* L)
 {
-  // 2 o 3 o 4 parametri : Id, nApprType [, dLinTol [, dMaxSegmLen]]
+  // 2 o 3 parametri : Id, nApprType [, dLinTol]
   int nId ;
   LuaCheckParam( L, 1, nId)
   int nApprType ;
   LuaCheckParam( L, 2, nApprType)
   double dLinTol = 0.01 ;
-   double dMaxSegmLen = INFINITO ;
-   if ( LuaGetParam( L, 3, dLinTol))
-      LuaGetParam( L, 4, dMaxSegmLen) ;
+   LuaGetParam( L, 3, dLinTol) ;
   LuaClearStack( L) ;
  // approssimazione della curva con rette
-   bool bOk = ExeApproxCurve( nId, nApprType, dLinTol, dMaxSegmLen) ;
+   bool bOk = ExeApproxCurve( nId, nApprType, dLinTol) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
 }
@@ -586,22 +581,6 @@ LuaModifyArcRadius( lua_State* L)
   return 1 ;
 }

-//-------------------------------------------------------------------------------
-static int
-LuaModifyArcAngCenter( lua_State* L)
-{
-  // 2 parametri : Id, dNewAngCenter
-   int nId ;
-   LuaCheckParam( L, 1, nId)
-   double dNewAngCenter ;
-   LuaCheckParam( L, 2, dNewAngCenter)
-   LuaClearStack( L) ;
-  // modifica dell'angolo al centro
-   bool bOk = ExeModifyArcAngCenter( nId, dNewAngCenter) ;
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
 //-------------------------------------------------------------------------------
 static int
 LuaModifyArcToExplementary( lua_State* L)
@@ -757,7 +736,7 @@ LuaRemoveCurveCompoCurve( lua_State* L)
  // 1 o 2 parametri : Id [, bLast]
   int nId ;
   LuaCheckParam( L, 1, nId)
-   bool bLast = true ;
+   bool bLast ;
   LuaGetParam( L, 2, bLast) ;
   LuaClearStack( L) ;
  // rimuovo prima o ultima curva della composita
@@ -929,46 +908,6 @@ LuaRemoveCurveCompoUndercutOnY( lua_State* L)
   return 1 ;
 }

-//-------------------------------------------------------------------------------
-static int
-LuaCurveCompoSetTempProp( lua_State* L)
-{
-  // 3 parametri : Id, nCrv, nProp [, nPropInd]
-   int nId ;
-   LuaCheckParam( L, 1, nId)
-   int nCrv ;
-   LuaCheckParam( L, 2, nCrv)
-   int nProp ;
-   LuaCheckParam( L, 3, nProp)
-   int nPropInd = 0 ;
-   LuaGetParam( L, 4, nPropInd) ;
-   LuaClearStack( L) ;
-  // imposto sulla curva della composita la proprietà temporanea
-   bool bOk = ExeCurveCompoSetTempProp( nId, nCrv, nProp, nPropInd) ;
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaCurveCompoSetTempParam( lua_State* L)
-{
-  // 3 parametri : Id, nCrv, dParam [, nParamInd]
-   int nId ;
-   LuaCheckParam( L, 1, nId)
-   int nCrv ;
-   LuaCheckParam( L, 2, nCrv)
-   double dParam ;
-   LuaCheckParam( L, 3, dParam)
-   int nParamInd = 0 ;
-   LuaGetParam( L, 4, nParamInd) ;
-   LuaClearStack( L) ;
-  // imposto sulla curva della composita il parametro temporaneo
-   bool bOk = ExeCurveCompoSetTempParam( nId, nCrv, dParam, nParamInd) ;
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
 //----------------------------------------------------------------------------
 static int
 LuaChainCurvesInGroup( lua_State* L)
@@ -1005,226 +944,6 @@ LuaReorderCurvesInGroup( lua_State* L)
   return 1 ;
 }

-//----------------------------------------------------------------------------
-static int
-LuaProjectCurveOnSurf( lua_State* L)
-{
-  // 3, 4 o 5 parametri : nCurveId, vSurfId, nDestGrpId [, dLinTol [, dMaxSegmLen]]
-   int nCurveId ;
-   LuaCheckParam( L, 1, nCurveId)
-   INTVECTOR vSurfId ;
-   LuaCheckParam( L, 2, vSurfId)
-   int nDestGrpId ;
-   LuaCheckParam( L, 3, nDestGrpId)
-   double dLinTol = 0.01 ;
-   double dMaxSegmLen = INFINITO ;
-   if ( LuaGetParam( L, 4, dLinTol))
-      LuaGetParam( L, 5, dMaxSegmLen) ;
-   LuaClearStack( L) ;
-  // proietto la curva su una o più superfici a minima distanza
-   bool bOk = ExeProjectCurveOnSurf( nCurveId, vSurfId, nDestGrpId, dLinTol, dMaxSegmLen) ;
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
-//----------------------------------------------------------------------------
-static int
-LuaProjectCurveOnSurfDir( lua_State* L)
-{
-  // 4, 5, 6, 7 o 8 parametri : nCurveId, vSurfId, vtDir, nDestGrpId [, dLinTol [, dMaxSegmLen] [, bDirFromProj] [,bFromVsTo] [, nRefType]]
-   int nCurveId ;
-   LuaCheckParam( L, 1, nCurveId)
-   INTVECTOR vSurfId ;
-   LuaCheckParam( L, 2, vSurfId)
-   Vector3d vtDir ;
-   LuaCheckParam( L, 3, vtDir)
-   int nDestGrpId ;
-   LuaCheckParam( L, 4, nDestGrpId)
-   double dLinTol = 0.01 ;
-   double dMaxSegmLen = INFINITO ;
-   bool bDirFromProj = false ;
-   bool bFromVsTo = true ;
-   int nRefType = RTY_DEFAULT ;
-   if ( LuaGetParam( L, 5, dLinTol)  &&
-        LuaGetParam( L, 6, dMaxSegmLen)  &&
-        LuaGetParam( L, 7, bDirFromProj)  &&
-        LuaGetParam( L, 8, bFromVsTo))
-      LuaGetParam( L, 9, nRefType) ;
-   LuaClearStack( L) ;
-  // proietto la curva su una o più superfici secondo la direzione data
-   bool bOk = ExeProjectCurveOnSurfDir( nCurveId, vSurfId, vtDir, nDestGrpId, dLinTol, dMaxSegmLen, bDirFromProj, bFromVsTo, nRefType) ;
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
-//----------------------------------------------------------------------------
-static int
-LuaProjectCurveOnSurfExt( lua_State* L)
-{
-  // 4, 5, 6 o 7 parametri : nCurveId, vSurfId, nGuideId, nDestGrpId [, dLinTol [, dMaxSegmLen] [, bDirFromGuide] [,bFromVsTo]]
-   int nCurveId ;
-   LuaCheckParam( L, 1, nCurveId)
-   INTVECTOR vSurfId ;
-   LuaCheckParam( L, 2, vSurfId)
-   int nGuideId ;
-   LuaCheckParam( L, 3, nGuideId)
-   int nDestGrpId ;
-   LuaCheckParam( L, 4, nDestGrpId)
-   double dLinTol = 0.01 ;
-   double dMaxSegmLen = INFINITO ;
-   bool bDirFromGuide = false ;
-   bool bFromVsTo = true ;
-   if ( LuaGetParam( L, 5, dLinTol)  &&
-        LuaGetParam( L, 6, dMaxSegmLen)  &&
-        LuaGetParam( L, 7, bDirFromGuide))
-      LuaGetParam( L, 8, bFromVsTo) ;
-   LuaClearStack( L) ;
-  // proietto la curva su una o più superfici secondo la direzione verso la guida
-   bool bOk = ExeProjectCurveOnSurfExt( nCurveId, vSurfId, nGuideId, nDestGrpId, dLinTol, dMaxSegmLen, bDirFromGuide, bFromVsTo) ;
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
-//----------------------------------------------------------------------------
-static int
-LuaCurveGetVoronoi( lua_State* L)
-{
-  // 2 o 3 parametri : Id/s, nDestGrpId [, nBound]
-   INTVECTOR vIds ;
-   LuaCheckParam( L, 1, vIds)
-   int nDestGrpId ;
-   LuaCheckParam( L, 2, nDestGrpId)
-   int nBound = 3 ;      // VORONOI_STD_BOUND
-   LuaGetParam( L, 3, nBound) ;
-   LuaClearStack( L) ;
-  // eseguo
-   int nCount = 0 ;
-   int nNewId = ExeCurveGetVoronoi( vIds, nDestGrpId, nBound, &nCount) ;
-   if ( nNewId != GDB_ID_NULL)
-      LuaSetParam( L, nNewId) ;
-   else
-      LuaSetParam( L) ;
-   LuaSetParam( L, nCount) ;
-
-   return 2 ;
-}
-
-//----------------------------------------------------------------------------
-static int
-LuaCurveMedialAxisAdv( lua_State* L)
-{
-  // 2 o 3 parametri : Id/s, nDestGrpId [, nSide]
-   INTVECTOR vIds ;
-   LuaCheckParam( L, 1, vIds)
-   int nDestGrpId ;
-   LuaCheckParam( L, 2, nDestGrpId)
-   int nSide = 1 ;         // WMAT_LEFT
-   LuaGetParam( L, 3, nSide) ;
-   LuaClearStack( L) ;
-  // eseguo
-   int nCount = 0 ;
-   int nNewId = ExeCurveGetMedialAxis( vIds, nDestGrpId, nSide, &nCount) ;
-   if ( nNewId != GDB_ID_NULL)
-      LuaSetParam( L, nNewId) ;
-   else
-      LuaSetParam( L) ;
-   LuaSetParam( L, nCount) ;
-
-   return 2 ;
-}
-
-//----------------------------------------------------------------------------
-static int
-LuaCurveGetFatCurve( lua_State* L)
-{
-  // 4 o 5 parametri : Id, nDestGrpId, dRad, bSquare [, bSquareMids]
-   int nId ;
-   LuaCheckParam( L, 1, nId)
-   int nDestGrpId ;
-   LuaCheckParam( L, 2, nDestGrpId)
-   double dRad ;
-   LuaCheckParam( L, 3, dRad)
-   bool bSquareEnds ;
-   LuaCheckParam( L, 4, bSquareEnds)
-   bool bSquareMids = bSquareEnds ;
-   LuaGetParam( L, 5, bSquareMids) ;
-   LuaClearStack( L) ;
-  // eseguo
-   int nCount = 0 ;
-   int nNewId = ExeCurveGetFatCurve( nId, nDestGrpId, dRad, bSquareEnds, bSquareMids, &nCount) ;
-   if ( nNewId != GDB_ID_NULL)
-      LuaSetParam( L, nNewId) ;
-   else
-      LuaSetParam( L) ;
-   LuaSetParam( L, nCount) ;
-
-   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)
@@ -1260,7 +979,6 @@ LuaInstallGdbModifyCurve( LuaMgr& luaMgr)
   bOk = bOk && luaMgr.RegisterFunction( "EgtSplitCurveAtCorners", LuaSplitCurveAtCorners) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSplitCurveAtSelfInters", LuaSplitCurveAtSelfInters) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtModifyArcRadius", LuaModifyArcRadius) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtModifyArcAngCenter", LuaModifyArcAngCenter) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtModifyArcToExplementary", LuaModifyArcToExplementary) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtModifyArcByFlip", LuaModifyArcByFlip) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtCloseCurveCompo", LuaCloseCurveCompo) ;
@@ -1279,19 +997,7 @@ 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( "EgtProjectCurveOnSurfDir", LuaProjectCurveOnSurfDir) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtProjectCurveOnSurfExt", LuaProjectCurveOnSurfExt) ;
-   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 ;
 }
@@ -18,12 +18,12 @@
 #include "/EgtDev/Include/EXeExecutor.h"
 #include "/EgtDev/Include/EXeConst.h"
 #include "/EgtDev/Include/EGkCurve.h"
-#include "/EgtDev/Include/EGkSurfTriMeshAux.h"
 #include "/EgtDev/Include/EGkGdbConst.h"
 #include "/EgtDev/Include/EGkLuaAux.h"

 using namespace std ;

+
 //----------------------------------------------------------------------------
 static int
 LuaInvertSurf( lua_State* L)
@@ -62,16 +62,14 @@ LuaExplodeSurf( lua_State* L)
 static int
 LuaApproxSurf( lua_State* L)
 {
-  // 1 o 2 parametri : Id [, dLinTol [, dTriaMinSide]]
+  // 1 o 2 parametri : Id [, dLinTol]
   int nId ;
   LuaCheckParam( L, 1, nId)
   double dLinTol = LIN_TOL_SRF ;
-   double dTriaMinSide = 100 * EPS_SMALL ;
-   if ( LuaGetParam( L, 2, dLinTol))
-      LuaGetParam( L, 3, dTriaMinSide) ;
+   LuaGetParam( L, 2, dLinTol) ;
   LuaClearStack( L) ;
  // approssimazione della superficie
-   bool bOk = ExeApproxSurface( nId, dLinTol, dTriaMinSide) ;
+   bool bOk = ExeApproxSurface( nId, dLinTol) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
@@ -143,46 +141,6 @@ LuaSurfFrOffset( lua_State* L)
   return 1 ;
 }

-//-------------------------------------------------------------------------------
-static int
-LuaSurfFrOffsetAdv( lua_State* L)
-{
-  // 3 parametri : Id, dDist, nType
-   int nId ;
-   LuaCheckParam( L, 1, nId)
-   double dDist ;
-   LuaCheckParam( L, 2, dDist)
-   int nType = ICurve::OFF_FILLET ;
-   LuaGetParam( L, 3, nType) ;
-   LuaClearStack( L) ;
-  // eseguo l'offset della regione
-   int nNewId = GDB_ID_NULL ;
-   bool bOk = ExeSurfFrOffsetAdv( nId, dDist, nType, nNewId) ;
-   if ( bOk) 
-      LuaSetParam( L, nNewId) ;
-   else
-      LuaSetParam( 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)
@@ -207,30 +165,6 @@ LuaSurfTmMoveVertex( lua_State* L)
   return 1 ;
 }

-//----------------------------------------------------------------------------
-static int
-LuaSurfTmMoveFacet( lua_State* L)
-{
-  // 3 o 4 o 5 parametri : nId, nFacet, vtMove [, nRefId] [, bUpdate]
-   int nId ;
-   LuaCheckParam( L, 1, nId)
-   int nFacet ;
-   LuaCheckParam( L, 2, nFacet)
-   Vector3d vtMove ;
-   LuaCheckParam( L, 3, vtMove)
-   int nRefType = RTY_DEFAULT ;
-   bool bUpdate = true ;
-   if ( LuaGetParam( L, 4, nRefType))
-      LuaGetParam( L, 5, bUpdate) ;
-   else
-      LuaGetParam( L, 4, bUpdate) ;
-   LuaClearStack( L) ;
-  // sposto la faccia di indice dato della trimesh
-   bool bOk = ExeSurfTmMoveFacet( nId, nFacet, vtMove, nRefType, bUpdate) ;
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
 //----------------------------------------------------------------------------
 static int
 LuaSurfTmToTriangles( lua_State* L)
@@ -399,6 +333,20 @@ LuaSurfTmIntersect( lua_State* L)
   return 1 ;
 }

+//-------------------------------------------------------------------------------
+static int
+LuaSurfTmResetTwoColors( lua_State* L)
+{
+  // 1 parametro : Id
+   int nId ;
+   LuaCheckParam( L, 1, nId)
+   LuaClearStack( L) ;
+  // eseguo reset TFlag per annullare due colori
+   bool bOk = ExeSurfTmResetTwoColors( nId) ;
+   LuaSetParam( L, bOk) ;
+   return 1 ;
+}
+
 //-------------------------------------------------------------------------------
 static int
 LuaSurfTmSplit( lua_State* L)
@@ -440,249 +388,11 @@ LuaSurfTmCut( lua_State* L)
   return 1 ;
 }

-//-------------------------------------------------------------------------------
-static int
-LuaSurfTmSubtractProjectedFacesOnFace( lua_State* L)
-{
-  // 3 o 4 o 5 parametri : nSurfId, nFaceInd, nDestGrpId [, vSurfsId] [, bOCFlag]
-   int nSurfId ;
-   LuaCheckParam( L, 1, nSurfId) ;
-   int nFaceInd ;
-   LuaCheckParam( L, 2, nFaceInd) ;
-   int nDestGrpId ;
-   LuaCheckParam( L, 3, nDestGrpId) ;
-   INTVECTOR vSurfsId ;
-   bool bOCFlag = true ;
-   if ( LuaGetParam( L, 4, vSurfsId))
-      LuaGetParam( L, 5, bOCFlag) ;
-   else
-      LuaGetParam( L, 4, bOCFlag) ;
-   LuaClearStack( L) ;
-  // sottraggo alla faccia scelta la proiezione delle altre TriMesh
-   int nNewId = GDB_ID_NULL;
-   bool bExistProjection = false ;
-   int nNewFaceNbr = 0 ;
-   bool bOk = ExeSurfTmSubtractProjectedFacesOnFace( nSurfId, nFaceInd, nDestGrpId, vSurfsId,
-                                                     bOCFlag, bExistProjection, nNewId, nNewFaceNbr) ;
-   LuaSetParam( L, bOk) ;
-   LuaSetParam( L, bExistProjection) ;
-   if ( nNewId != GDB_ID_NULL)
-      LuaSetParam( L, nNewId) ;
-   else
-      LuaSetParam( L) ;
-   LuaSetParam( L, nNewFaceNbr) ;
-   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)
-{
-  // 1 parametro : Id
-   int nId ;
-   LuaCheckParam( L, 1, nId)
-   LuaClearStack( L) ;
-  // eseguo reset TFlag per annullare due colori
-   bool bOk = ExeSurfTmResetTwoColors( nId) ;
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaSurfTmSetShowEdges( lua_State* L)
-{
-  // 2 parametri : Id, bShow
-   int nId ;
-   LuaCheckParam( L, 1, nId)
-   bool bShow ;
-   LuaCheckParam( L, 2, bShow) ;
-   LuaClearStack( L) ;
-  // imposto flag visualizzazione spigoli vivi
-   bool bOk = ExeSurfTmSetShowEdges( nId, bShow) ;
-  // restituisco il risultato
-   LuaSetParam( L, bOk) ;
-   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
-LuaSurfTmSetSmoothAng( lua_State* L)
-{
-  // 2 parametri : nId, dAngDeg
-   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 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaSurfTmGetSmoothAng( lua_State* L)
-{
-  // 1 parametro : nId
-   int nId ;
-   LuaCheckParam( L, 1, nId)
-   LuaClearStack( L) ;
-  // recupero lo smooth angle della superficie
-   double dAngDeg ;
-   bool bOk = ExeSurfTmGetSmoothAng( nId, dAngDeg) ;
-   if ( bOk)
-      LuaSetParam( L, dAngDeg) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaSurfTmOffset( lua_State* L)
-{
-  // 4 o 5 parametri : ParentId, vIds, dOffs, dLinTol [, nType]
-   int nParentId ;
-   LuaGetParam( L, 1, nParentId) ;
-   INTVECTOR vIds ;
-   LuaCheckParam( L, 2, vIds)
-   double dOffs ;
-   LuaCheckParam( L, 3, dOffs)
-   double dLinTol ;
-   LuaCheckParam( L, 4, dLinTol) ;
-   int nType = STMOFF_FILLET ;
-   LuaGetParam( L, 5, nType) ;
-   LuaClearStack( L) ;
-  // interseco la prima superficie con la seconda
-   int nId = ExeSurfTmOffset( nParentId, vIds, dOffs, dLinTol, nType) ;
-   LuaSetParam( L, nId) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaSurfTmThickeningOffset( lua_State* L)
-{
-  // 4 o 5 parametri : ParentId, vIds, dOffs, dLinTol [, nType]
-   int nParentId ;
-   LuaGetParam( L, 1, nParentId) ;
-   INTVECTOR vIds ;
-   LuaCheckParam( L, 2, vIds)
-   double dOffs ;
-   LuaCheckParam( L, 3, dOffs)
-   double dLinTol ;
-   LuaCheckParam( L, 4, dLinTol) ;
-   int nType = STMOFF_FILLET ;
-   LuaGetParam( L, 5, nType) ;
-   LuaClearStack( L) ;
-  // interseco la prima superficie con la seconda
-   int nId = ExeSurfTmThickeningOffset( nParentId, vIds, dOffs, dLinTol, nType) ;
-   LuaSetParam( L, nId) ;
-   return 1 ;
-}
-
-//----------------------------------------------------------------------------
-static int
-LuaCutSurfBzPlane( lua_State* L)
-{
-  // 4 o 5 parametri : Id, ptOn, vtN, bSaveOnEq [, nRefType]
-   int nId ;
-   LuaCheckParam( L, 1, nId)
-   Point3d ptOn ;
-   LuaCheckParam( L, 2, ptOn)
-   Vector3d vtN ;
-   LuaCheckParam( L, 3, vtN)
-   bool bSaveOnEq ;
-   LuaGetParam( L, 4, bSaveOnEq) ;
-   int nRefType = RTY_DEFAULT ;
-   LuaGetParam( L, 5, nRefType) ;
-   LuaClearStack( L) ;
-  // taglio la superficie con ilpiano
-   bool bOk = ExeCutSurfBzPlane( nId, ptOn, vtN, bSaveOnEq, nRefType) ;
-  // restituisco il risultato
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaSurfBzTrim( lua_State* L)
-{
-  // 2 parametri : nId, nCutterId
-   int nId ;
-   LuaCheckParam( L, 1, nId)
-   int nCutterId ;
-   LuaCheckParam( L, 2, nCutterId)
-   LuaClearStack( L) ;
-  // taglio la prima superficie in base alla seconda
-   bool bOk = ExeSurfBzTrim( nId, nCutterId) ;
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
 //-------------------------------------------------------------------------------
 bool
 LuaInstallGdbModifySurf( LuaMgr& luaMgr)
 {
-   bool bOk = true ;
+   bool bOk = ( &luaMgr != nullptr) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtInvertSurf", LuaInvertSurf) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtExplodeSurf", LuaExplodeSurf) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtApproxSurf", LuaApproxSurf) ;
@@ -690,10 +400,7 @@ LuaInstallGdbModifySurf( LuaMgr& luaMgr)
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfFrSubtract", LuaSurfFrSubtract) ;
   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) ;  
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmRemoveFacet", LuaSurfTmRemoveFacet) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmSwapFacets", LuaSurfTmSwapFacets) ;
@@ -703,19 +410,8 @@ LuaInstallGdbModifySurf( LuaMgr& luaMgr)
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmAdd", LuaSurfTmAdd) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmSubtract", LuaSurfTmSubtract) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmIntersect", LuaSurfTmIntersect) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmResetTwoColors", LuaSurfTmResetTwoColors) ;
   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( "EgtSurfTmSetSmoothAng", LuaSurfTmSetSmoothAng) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmGetSmoothAng", LuaSurfTmGetSmoothAng) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmOffset", LuaSurfTmOffset) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmThickeningOffset", LuaSurfTmThickeningOffset) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtCutSurfBzPlane", LuaCutSurfBzPlane) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBzTrim", LuaSurfBzTrim) ;
   return bOk ;
 }
@@ -56,42 +56,6 @@ LuaVolZmapChangeResolution( lua_State* L)
   return 1 ;
 }

-//-------------------------------------------------------------------------------
-static int
-LuaVolZmapSetShowEdges( lua_State* L)
-{
-  // 2 parametri : Id, bShow
-   int nId ;
-   LuaCheckParam( L, 1, nId)
-   bool bShow ;
-   LuaCheckParam( L, 2, bShow) ;
-   LuaClearStack( L) ;
-  // imposto flag visualizzazione spigoli vivi
-   bool bOk = ExeVolZmapSetShowEdges( nId, bShow) ;
-  // restituisco il risultato
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaVolZmapGetShowEdges( lua_State* L)
-{
-  // 1 parametro : Id
-   int nId ;
-   LuaCheckParam( L, 1, nId)
-   LuaClearStack( L) ;
-  // imposto flag visualizzazione spigoli vivi
-   bool bShow ;
-   bool bOk = ExeVolZmapGetShowEdges( nId, bShow) ;
-  // restituisco il risultato
-   if ( bOk)
-      LuaSetParam( L, bShow) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
 //----------------------------------------------------------------------------
 static int
 LuaRemoveVolZmapPart( lua_State* L)
@@ -171,7 +135,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 ;
@@ -200,7 +164,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 ;
@@ -221,7 +185,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 ;
@@ -248,7 +212,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 ;
@@ -269,31 +233,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)
@@ -397,85 +336,13 @@ LuaCutVolZmapPlane( lua_State* L)
   int nRefType = RTY_DEFAULT ;
   LuaGetParam( L, 4, nRefType) ;
   LuaClearStack( L) ;
-  // taglio la superficie con il piano
+  // taglio la superficie con ilpiano
   bool bOk = ExeCutVolZmapPlane( nId, ptOn, vtN, nRefType) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
 }

-//-------------------------------------------------------------------------------
-static int
-LuaUpdateVolZmapByAddingSurfTm( lua_State* L)
-{
-  // 2 parametri : nVolZmapId, StmId,
-   int nVolZmapId ;
-   LuaCheckParam( L, 1, nVolZmapId) ;
-   int nStmId ;
-   LuaCheckParam( L, 2, nStmId) ;
-   LuaClearStack( L) ;
-   bool bOk = ExeUpdateVolZmapByAddingSurfTm( nVolZmapId, nStmId) ;
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaVolZmapMakeUniform( lua_State* L)
-{
-  // 2 o 3 o 4 parametri : nVolZmapId, dToler [, bExtensionFirst] [, nToolNum]
-   int nVolZmapId ;
-   LuaCheckParam( L, 1, nVolZmapId) ;
-   double dToler ;
-   LuaCheckParam( L, 2, dToler) ;
-   bool bExtensionFirst = true ;
-   LuaGetParam( L, 3, bExtensionFirst) ;
-   int nToolNum = 0 ;
-   LuaGetParam( L, 4, nToolNum) ;
-   LuaClearStack( L) ;
-   bool bOk = ExeVolZmapMakeUniform( nVolZmapId, dToler, bExtensionFirst, nToolNum) ;
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaVolZmapOffset( lua_State* L)
-{
-  // 3 parametri : Id, dDist, nType
-   int nId ;
-   LuaCheckParam( L, 1, nId)
-   double dDist ;
-   LuaCheckParam( L, 2, dDist)
-   int nType = VolZmapOffset::FILLET ;
-   LuaGetParam( L, 3, nType) ;
-   LuaClearStack( L) ;
-  // eseguo l'offset della regione
-   bool bOk = ExeVolZMapOffset( nId, dDist, nType) ;
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaVolZmapRemoveFins( lua_State* L)
-{
-  // 3 parametri : Id, vtDir, dThick
-   int nId ;
-   LuaCheckParam( L, 1, nId) ;
-   Vector3d vtDir ;
-   LuaCheckParam( L, 2, vtDir) ;
-   double dThick ;
-   LuaCheckParam( L, 3, dThick) ;
-   int nRefType = RTY_DEFAULT ;
-   LuaGetParam( L, 4, nRefType) ;
-   LuaClearStack( L) ;
-  // Eseguo la rimozione delle alette
-   bool bOk = ExeVolZMapRemoveFins( nId, vtDir, dThick, nRefType) ;
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
 //-------------------------------------------------------------------------------
 bool
 LuaInstallGdbModifyVol( LuaMgr& luaMgr)
@@ -483,8 +350,6 @@ LuaInstallGdbModifyVol( LuaMgr& luaMgr)
   bool bOk = ( &luaMgr != nullptr) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtExplodeVolume", LuaExplodeVolume) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtVolZmapChangeResolution", LuaVolZmapChangeResolution) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtVolZmapSetShowEdges", LuaVolZmapSetShowEdges) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtVolZmapGetShowEdges", LuaVolZmapGetShowEdges) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtRemoveVolZmapPart", LuaRemoveVolZmapPart) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtVolZmapSetStdTool", LuaVolZmapSetStdTool) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtVolZmapSetAdvTool", LuaVolZmapSetAdvTool) ;
@@ -492,14 +357,9 @@ 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) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtCutVolZmapPlane", LuaCutVolZmapPlane) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtUpdateVolZmapByAddingSurfTm", LuaUpdateVolZmapByAddingSurfTm ) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtVolZmapMakeUniform", LuaVolZmapMakeUniform) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtVolZmapOffset", LuaVolZmapOffset) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtVolZmapRemoveFins", LuaVolZmapRemoveFins) ;
   return bOk ;
 }
@@ -42,13 +42,13 @@ LuaCopyAttributes( lua_State* L)
 static int
 LuaSetLevel( lua_State* L)
 {
-  // 2 parametri : Ids, nLevel
-   INTVECTOR vId ;
-   LuaCheckParam( L, 1, vId)
+  // 2 parametri : nId, nLevel
+   int nId ;
+   LuaCheckParam( L, 1, nId)
   int nLevel ;
   LuaCheckParam( L, 2, nLevel)
  // imposto lo stato
-   bool bOk = ExeSetLevel( vId, nLevel) ;
+   bool bOk = ExeSetLevel( nId, nLevel) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
@@ -111,14 +111,14 @@ LuaGetCalcLevel( lua_State* L)
 static int
 LuaSetMode( lua_State* L)
 {
-  // 2 parametri : Ids, nMode
-   INTVECTOR vId ;
-   LuaCheckParam( L, 1, vId)
+  // 2 parametri : nId, nMode
+   int nId ;
+   LuaCheckParam( L, 1, nId)
   int nMode ;
   LuaCheckParam( L, 2, nMode)
   LuaClearStack( L) ;
  // imposto il modo
-   bool bOk = ExeSetMode( vId, nMode) ;
+   bool bOk = ExeSetMode( nId, nMode) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
@@ -179,7 +179,7 @@ LuaGetCalcMode( lua_State* L)
 static int
 LuaSetStatus( lua_State* L)
 {
-  // 2 parametri : Ids, nStatus
+  // 2 parametri : Id, nStatus
   INTVECTOR vId ;
   LuaCheckParam( L, 1, vId)
   int nStatus ;
@@ -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 ;
@@ -521,8 +519,10 @@ LuaSetInfo( lua_State* L)
      } break ;
   case LUA_TTABLE :
      {  Frame3d frVal ;
-         BBox3d b3Val ;  
-         DBLVECTOR vdVal ;    // va bene anche per Vector3d, Point3d, vnVal
+         BBox3d b3Val ;
+         Vector3d vtVal ;     // va bene anche per Point3d
+         INTVECTOR vnVal ;
+         DBLVECTOR vdVal ;
         STRVECTOR vsVal ;
         if ( LuaGetParam( L, 3, frVal)) {
            LuaClearStack( L) ;
@@ -531,7 +531,15 @@ LuaSetInfo( lua_State* L)
         else if ( LuaGetParam( L, 3, b3Val)) {
            LuaClearStack( L) ;
            bOk = ExeSetInfo( nId, sKey, b3Val) ;
-         }        
+         }
+         else if ( LuaGetParam( L, 3, vtVal)) {
+            LuaClearStack( L) ;
+            bOk = ExeSetInfo( nId, sKey, vtVal) ;
+         }
+         else if ( LuaGetParam( L, 3, vnVal)) {
+            LuaClearStack( L) ;
+            bOk = ExeSetInfo( nId, sKey, vnVal) ;
+         }
         else if ( LuaGetParam( L, 3, vdVal)) {
            LuaClearStack( L) ;
            bOk = ExeSetInfo( nId, sKey, vdVal) ;
@@ -784,25 +792,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 +834,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 ;
 }
@@ -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)
@@ -489,32 +472,6 @@ LuaCopy( lua_State* L)
   return 1 ;
 }

-//-------------------------------------------------------------------------------
-static int
-LuaCopyEx( lua_State* L)
-{
-  // 4 o 5 parametri : nSouCtx, SouId, nDestCtx, RefId [, nSonBeforeAfter]
-   int nSouCtx ;
-   LuaCheckParam( L, 1, nSouCtx)
-   int nSouId ;
-   LuaCheckParam( L, 2, nSouId)
-   int nDestCtx ;
-   LuaCheckParam( L, 3, nDestCtx)
-   int nRefId ;
-   LuaCheckParam( L, 4, nRefId)
-   int nSonBeforeAfter = GDB_LAST_SON ;
-   LuaGetParam( L, 5, nSonBeforeAfter) ;
-   LuaClearStack( L) ;
-  // eseguo la copia
-   int nNewId = ExeCopyEx( nSouCtx, nSouId, nDestCtx, nRefId, nSonBeforeAfter) ;
-  // restituisco il risultato
-   if ( nNewId != GDB_ID_NULL)
-      LuaSetParam( L, nNewId) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
 //-------------------------------------------------------------------------------
 static int
 LuaCopyGlob( lua_State* L)
@@ -537,51 +494,6 @@ LuaCopyGlob( lua_State* L)
   return 1 ;
 }

-//-------------------------------------------------------------------------------
-static int
-LuaCopyGlobEx( lua_State* L)
-{
-  // 4 o 5 parametri : nSouCtx, SouId, nDestCtx, RefId [, nSonBeforeAfter]
-   int nSouCtx ;
-   LuaCheckParam( L, 1, nSouCtx)
-   int nSouId ;
-   LuaCheckParam( L, 2, nSouId)
-   int nDestCtx ;
-   LuaCheckParam( L, 3, nDestCtx)
-   int nRefId ;
-   LuaCheckParam( L, 4, nRefId)
-   int nSonBeforeAfter = GDB_LAST_SON ;
-   LuaGetParam( L, 5, nSonBeforeAfter) ;
-   LuaClearStack( L) ;
-  // eseguo la copia
-   int nNewId = ExeCopyGlobEx( nSouCtx, nSouId, nDestCtx, nRefId, nSonBeforeAfter) ;
-  // restituisco il risultato
-   if ( nNewId != GDB_ID_NULL)
-      LuaSetParam( L, nNewId) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaDuplicateGeomDB( lua_State* L)
-{
-  // 2 o 3 parametri : nSouCtx, nDestCtx [, bSkipTemp]
-   int nSouCtx ;
-   LuaCheckParam( L, 1, nSouCtx)
-   int nDestCtx ;
-   LuaCheckParam( L, 2, nDestCtx)
-   bool bSkipTemp = false ;
-   LuaGetParam( L, 3, bSkipTemp) ;
-   LuaClearStack( L) ;
-  // eseguo la copia
-   bool bOk = ExeDuplicateGeomDB( nSouCtx, nDestCtx, bSkipTemp) ;
-  // restituisco il risultato
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
 //-------------------------------------------------------------------------------
 static int
 LuaRelocate( lua_State* L)
@@ -720,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) ;
@@ -734,10 +645,7 @@ LuaInstallGdbObjects( LuaMgr& luaMgr)
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetBBoxGlob", LuaGetBBoxGlob) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetBBoxRef", LuaGetBBoxRef) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtCopy", LuaCopy) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtCopyEx", LuaCopyEx) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtCopyGlob", LuaCopyGlob) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtCopyGlobEx", LuaCopyGlobEx) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtDuplicateGeomDB", LuaDuplicateGeomDB) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtRelocate", LuaRelocate) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtRelocateGlob", LuaRelocateGlob) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGroupSwap", LuaGroupSwap) ;
@@ -277,21 +277,6 @@ LuaGetPrevLayer( lua_State* L)
   return 1 ;
 }

-//-------------------------------------------------------------------------------
-static int
-LuaIsGhostPart( lua_State* L)
-{
-  // 1 parametro : nGhostId
-   int nGhostId ;
-   LuaCheckParam( L, 1, nGhostId)
-   LuaClearStack( L) ;
-  // verifico sia un segnaposto di pezzo messo in grezzo
-   bool bOk = ExeIsGhostPart( nGhostId) ;
-  // restituisco il risultato
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
 //-------------------------------------------------------------------------------
 static int
 LuaGetFirstGhostPart( lua_State* L)
@@ -469,42 +454,6 @@ LuaDuploList( lua_State* L)
   return 1 ;
 }

-//-------------------------------------------------------------------------------
-static int
-LuaDuploInRawCount( lua_State* L)
-{
-  // 1 parametro : nSouId
-   int nSouId ;
-   LuaCheckParam( L, 1, nSouId)
-   LuaClearStack( L) ;
-  // recupero il numero di duplicati che sono riferiti da grezzi nei vari gruppi di lavoro del progetto
-   int nCount ;
-   bool bOk = ExeDuploInRawCount( nSouId, nCount) ;
-  // restituisco il risultato
-   if ( bOk)
-      LuaSetParam( L, nCount) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaDuploWithoutRawList( lua_State* L)
-{
-  // nessun parametro
-   LuaClearStack( L) ;
-  // recupero l'elenco dei duplicati
-   INTVECTOR vnDup ;
-   bool bOk = ExeDuploWithoutRawList( vnDup) ;
-  // restituisco il risultato
-   if ( bOk)
-      LuaSetParam( L, vnDup) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
 //-------------------------------------------------------------------------------
 static int
 LuaDuploSetModified( lua_State* L)
@@ -656,7 +605,6 @@ LuaInstallGdbPartLayer( LuaMgr& luaMgr)
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetNextLayer", LuaGetNextLayer) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetLastLayer", LuaGetLastLayer) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetPrevLayer", LuaGetPrevLayer) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtIsGhostPart", LuaIsGhostPart) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetFirstGhostPart", LuaGetFirstGhostPart) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetNextGhostPart", LuaGetNextGhostPart) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtEraseEmptyParts", LuaEraseEmptyParts) ;
@@ -668,8 +616,6 @@ LuaInstallGdbPartLayer( LuaMgr& luaMgr)
   bOk = bOk && luaMgr.RegisterFunction( "EgtDuploNew", LuaDuploNew) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtDuploCount", LuaDuploCount) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtDuploList", LuaDuploList) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtDuploInRawCount", LuaDuploInRawCount) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtDuploWithoutRawList", LuaDuploWithoutRawList) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtDuploSetModified", LuaDuploSetModified) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtDuploGetModified", LuaDuploGetModified) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtDuploSetLocked", LuaDuploSetLocked) ;
@@ -30,9 +30,7 @@
 #include "/EgtDev/Include/EgtIniFile.h"
 #include "/EgtDev/Include/EgtNumUtils.h"
 #include "/EgtDev/Include/EgtStringConverter.h"
-#include <sstream>
-#include <Windowsx.h>
-#include <shlobj.h>
+#include "Windowsx.h"

 using namespace std ;

@@ -89,14 +87,12 @@ LuaEvalNumExpr( lua_State* L)
 static int
 LuaPause( lua_State* L)
 {
-  // 1 o 2 parametri : numero di millisecondi [, bForced]
+  // 1 parametro : numero di millisecondi
   int nTime ;
   LuaCheckParam( L, 1, nTime)
-   bool bForced = false ;
-   LuaGetParam( L, 2, bForced) ;
   LuaClearStack( L) ;
-  // se forzata o abilitata UI, controllo la durata della pausa e la eseguo
-   if ( bForced  ||  ExeGetEnableUI()) {
+  // se abilitata UI, controllo la durata della pausa e la eseguo
+   if ( ExeGetEnableUI()) {
      const int MIN_TIME = 0 ;
      const int MAX_TIME = 10000 ;
      if ( nTime < MIN_TIME)
@@ -110,24 +106,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)
@@ -200,11 +178,11 @@ LuaSplitStringPlus( lua_State* L)
  // 2 parametri : sVal, sHea
   string sVal ;
   string sHea ;
-   bool bOk = LuaGetParam( L, 1, sVal)  &&
-              LuaGetParam( L, 2, sHea) ;
+   bool bFound = LuaGetParam( L, 1, sVal) ;
+   LuaCheckParam( L, 2, sHea)
   LuaClearStack( L) ;
-  // se ricevute stringhe, divido la prima in parti con intestazioni della seconda (che conservo)
-   if ( bOk) {
+  // se ricevuta stringa, la divido in parti conservandone le intestazioni
+   if ( bFound) {
      STRVECTOR vsVal ;
      TokenizePlus( sVal, sHea, vsVal) ;
     // ritorno il risultato
@@ -216,25 +194,6 @@ LuaSplitStringPlus( lua_State* L)
   return 1 ;
 }

-//-------------------------------------------------------------------------------
-static int
-LuaReplaceString( lua_State* L)
-{
-  // 3 parametri : sVal, sOld, sNew
-   string sVal ;
-   LuaCheckParam( L, 1, sVal)
-   string sOld ;
-   LuaCheckParam( L, 2, sOld)
-   string sNew ;
-   LuaCheckParam( L, 3, sNew)
-   LuaClearStack( L) ;
-  // eseguo sostituzione nella stringa della sequenza indicata dal secondo parametro con quella del terzo
-   int nRes = ReplaceString( sVal, sOld, sNew) ;
-  // restituisco il risultato
-   LuaSetParam( L, sVal) ;
-   LuaSetParam( L, nRes) ;
-   return 2 ;
-}
 //-------------------------------------------------------------------------------
 static int
 LuaSetVal( lua_State* L)
@@ -778,67 +737,6 @@ LuaCompareFilesLastWriteTime( lua_State* L)
   return 1 ;
 }

-//-------------------------------------------------------------------------------
-int
-CALLBACK DirectoryBoxProc( HWND hwndDlg, UINT uMsg, LPARAM lParam, LPARAM lpData) 
-{
-   if ( uMsg == BFFM_INITIALIZED)
-      SendMessage( hwndDlg, BFFM_SETSELECTION, TRUE, lpData) ;
-   return 0 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaDirectoryDialog( lua_State* L)
-{
-  // 2 parametri : sText, sDir
-   string sText ;
-   LuaCheckParam( L, 1, sText)
-   string sDir ;
-   LuaCheckParam( L, 2, sDir)
-   LuaClearStack( L) ;
-  // se abilitata UI, emetto la finestra di dialogo
-   if ( ExeGetEnableUI()) {
-     // Converto i parametri nel formato wide
-      AtoWEX<MAX_PATH> wsText( sText.c_str()) ;
-      AtoWEX<MAX_PATH> wsDirName( sDir.c_str()) ;
-     // Converto L'/' in L'\\' nel nome directory proposto
-      for ( wchar_t* pC = wsDirName.m_psz ; *pC != L'\0' ; ++ pC) {
-         if ( *pC == L'/')
-            *pC = L'\\' ;
-      }
-     // Riempio la struttura dati per il dialogo
-      BROWSEINFO bi = { 0} ;
-      bi.hwndOwner = ExeGetMainWindowHandle() ;
-      bi.lpszTitle = LPWSTR( wsText) ;
-      bi.ulFlags = BIF_RETURNONLYFSDIRS | BIF_USENEWUI ;
-      bi.lpfn = DirectoryBoxProc ;
-      bi.lParam = (LPARAM) LPWSTR( wsDirName) ;
-     // Visualizzo il dialogo
-      LPITEMIDLIST pIdl = SHBrowseForFolder( &bi) ;
-      if ( pIdl != NULL) {
-        // recupero la path della directory
-         WCHAR wPath[MAX_PATH] ;
-         if ( SHGetPathFromIDList( pIdl, wPath) != FALSE)
-            LuaSetParam( L, wstrztoA( wPath)) ;
-         else
-            LuaSetParam( L) ;
-        // free memory used
-         IMalloc* pImalloc = NULL ;
-         if ( SUCCEEDED( SHGetMalloc( &pImalloc))) {
-            pImalloc->Free( pIdl) ;
-            pImalloc->Release() ;
-         }
-
-      }
-      else
-         LuaSetParam( L) ;
-   }
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
 //-------------------------------------------------------------------------------
 static int
 LuaExistsDirectory( lua_State* L)
@@ -899,21 +797,6 @@ LuaEraseDirectory( lua_State* L)
   return 1 ;
 }

-//-------------------------------------------------------------------------------
-static int
-LuaEraseNonEmptyDirectory( lua_State* L)
-{
-  // 1 parametro : sDir
-   string sDir ;
-   LuaCheckParam( L, 1, sDir)
-   LuaClearStack( L) ;
-  // cancello direttorio (deve essere vuoto)
-   bool bOk = EraseNonEmptyDirectory( sDir) ;
-  // restituisco il risultato
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
 //-------------------------------------------------------------------------------
 static int
 LuaTextFileCompare( lua_State* L)
@@ -1101,50 +984,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
-LuaSetDefaultFont( lua_State* L)
-{
-  // 1 parametro : sDefaultFont
-   string sDefaultFont ;
-   LuaCheckParam( L, 1, sDefaultFont)
-   LuaClearStack( L) ;
-  // imposta il font di default
-   bool bOk = ExeSetFont( "", sDefaultFont) ;
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaGetDefaultFont( lua_State* L)
-{
-  // nessun parametro
-   LuaClearStack( L) ;
-  // recupera il font di cefault
-   string sDefaultFont ;
-   bool bOk = ExeGetDefaultFont( sDefaultFont) ;
-   if ( bOk)
-      LuaSetParam( L, sDefaultFont) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
 //-------------------------------------------------------------------------------
 static int
 LuaWinExec( lua_State* L)
@@ -1176,10 +1015,9 @@ LuaCloseExe( lua_State* L)
   LuaGetParam( L, 1, nExitCode) ;
   LuaClearStack( L) ;
  // eseguo chiusura forzata
-   if ( ExeOnTerminateProcess( nExitCode))
-      TerminateProcess( GetCurrentProcess(), abs( nExitCode)) ;
-  // restituisco il risultato (se arrivo qui vuol dire che non è consnetito terminare l'esecuzione)
-   LuaSetParam( L, false) ;
+   bool bOk = ( TerminateProcess( GetCurrentProcess(), abs( nExitCode)) != FALSE) ;
+  // restituisco il risultato (in realtà il programma si è già concluso)
+   LuaSetParam( L, bOk) ;
   return 1 ;
 }

@@ -1214,298 +1052,146 @@ LuaReleaseMutex( lua_State* L)
 //-------------------------------------------------------------------------------
 const int MAX_CTRLS = IDC_TEXT8 -IDC_TEXT1 + 1 ;
 const int OFFS_CTRLS = 40 ;
-enum TYPE_CTRLS { CTRL_NONE = 0, CTRL_CHECK = 1, CTRL_COMBO = 2, CTRL_EDIT = 3, CTRL_COLOR = 4} ;
+enum TYPE_CTRLS { CTRL_NONE = 0, CTRL_CHECK = 1, CTRL_COMBO = 2, CTRL_EDIT = 3} ;
 static int s_nCtrls = 0 ;
 static string s_sCaption ;
 static string s_sText[MAX_CTRLS] ;
 static string s_sEdit[MAX_CTRLS] ;
 static int    s_nType[MAX_CTRLS] ;
-static COLORREF s_CustomColors[16] = {12632256} ;                 // 16 colori GRAY
-static bool s_bCustomColorsInit = false ;                         // flag di inizializzazione colori
-const char* SEC_SCENE = "Scene" ;
-const char* KEY_CUSTOMCOLORS = "CustomColors" ;

 //-------------------------------------------------------------------------------
 BOOL
 CALLBACK DialogBoxProc( HWND hwndDlg, UINT message, WPARAM wParam, LPARAM lParam) 
-{
-  // variabili static locali per mantenere lo stato tra chiamate per selezione colori
-   static COLORREF selectedColor[MAX_CTRLS] = {0} ;      // BLACK
-   static HBRUSH   hColorBrush[MAX_CTRLS] = {NULL} ;     // non definito
-
+{ 
   switch ( message) {
-      case WM_INITDIALOG :
-         {
-           // colore di default
-            COLORREF defaultColor = RGB( 255, 0, 0) ;
-           // inizializzazione colori e brush
-            for ( int i = 0 ; i < MAX_CTRLS ; ++ i) {
-               selectedColor[i] = defaultColor ;
-               if ( hColorBrush[i] != NULL)
-                  DeleteObject( hColorBrush[i]) ;
-               hColorBrush[i] = CreateSolidBrush( selectedColor[i]) ;
-            }
-           // dati del dialogo
-            HWND hwndOwner = GetParent( hwndDlg) ;
-            if ( hwndOwner == nullptr)
-               hwndOwner = GetDesktopWindow() ;
-            RECT rcOwner, rcDlg ;
-            GetWindowRect( hwndOwner, &rcOwner) ;
-            GetWindowRect( hwndDlg, &rcDlg) ;
-           // determino la posizione dell'ultima riga di dati da visualizzare
-            HWND hwndLR = GetDlgItem( hwndDlg, IDC_TEXT1 + Clamp( s_nCtrls, 1, MAX_CTRLS) - 1) ;
-            RECT rcLR ;
-            GetWindowRect( hwndLR, &rcLR) ;
-            POINT ptLR{ rcLR.left, rcLR.top} ;
-            ScreenToClient( hwndDlg, &ptLR) ;
-           // centro e scalo il dialogo
-            int nNewH = rcLR.top - rcOwner.top + 2 * OFFS_CTRLS ;  // non chiaro perchè va sottratto rcOwner.top ma funziona sempre
-            SetWindowPos( hwndDlg,
-                          HWND_TOP,
-                          ( rcOwner.left + rcOwner.right - ( rcDlg.right - rcDlg.left)) / 2,
-                          ( rcOwner.top + rcOwner.bottom - nNewH) / 2,
-                          ( rcDlg.right - rcDlg.left),
-                          nNewH,
-                          0) ;
-           // riposiziono il bottone Ok
-            HWND hwndOk = GetDlgItem( hwndDlg, IDOK) ;
-            RECT rcOk ;
-            GetWindowRect( hwndOk, &rcOk) ;
-            POINT ptOk{ rcOk.left, rcOk.top} ;
-            ScreenToClient( hwndDlg, &ptOk) ;
-            SetWindowPos( hwndOk,
-                          hwndDlg,
-                          ptOk.x, 
-                          ptLR.y + OFFS_CTRLS,
-                          0, 0,
-                          SWP_NOSIZE | SWP_NOZORDER) ;
-           // riposiziono il bottone Cancel
-            HWND hwndCl = GetDlgItem( hwndDlg, IDCANCEL) ;
-            RECT rcCl ;
-            GetWindowRect( hwndCl, &rcCl) ;
-            POINT ptCl{ rcCl.left, rcCl.top} ;
-            ScreenToClient( hwndDlg, &ptCl) ;
-            SetWindowPos( hwndCl,
-                          hwndDlg,
-                          ptCl.x, 
-                          ptLR.y + OFFS_CTRLS,
-                          0, 0,
-                          SWP_NOSIZE | SWP_NOZORDER) ;
-         }
-        // assegno titolo del dialogo
-         SetWindowText( hwndDlg, stringtoW( s_sCaption)) ;
-        // assegno testi e valori di default e nascondo linee dei controlli non usati
-         for ( int i = 0 ; i < MAX_CTRLS ; ++ i) {
-            if ( i < s_nCtrls) {
-               SetDlgItemText( hwndDlg, IDC_TEXT1 + i, stringtoW( s_sText[i])) ;
-               if ( s_sEdit[i].find( "CK:") == 0) {
-                  bool bChecked = false ;
-                  FromString( s_sEdit[i].substr( 3), bChecked) ;
-                  CheckDlgButton( hwndDlg, IDC_CHECK1 + i, ( bChecked ? BST_CHECKED : BST_UNCHECKED)) ;
-                  ShowWindow( GetDlgItem( hwndDlg, IDC_EDIT1 + i), SW_HIDE) ;
-                  ShowWindow( GetDlgItem( hwndDlg, IDC_COMBO1 + i), SW_HIDE) ;
-                  s_nType[i] = CTRL_CHECK ;
-               }
-               else if ( s_sEdit[i].find( "CB:") == 0) {
-                  string sList = s_sEdit[i].substr( 3) ;
-                  STRVECTOR vsVal ;
-                  Tokenize( sList, ",", vsVal) ;
-                  int nSel = 0 ;
-                  HWND hwndCBox = GetDlgItem( hwndDlg, IDC_COMBO1 + i) ;
-                  for ( int j = 0 ; j < int( vsVal.size()) ; ++ j) {
-                     string sItem ; 
-                     if ( vsVal[j][0] == '*') {
-                        nSel = j ;
-                        sItem = vsVal[j].substr( 1) ;
-                     }
-                     else
-                        sItem = vsVal[j] ;
-                     ComboBox_AddString( hwndCBox, stringtoW( sItem)) ;
-                  }
-                  ComboBox_SetCurSel( hwndCBox, nSel) ;
-                  ShowWindow( GetDlgItem( hwndDlg, IDC_EDIT1 + i), SW_HIDE) ;
-                  ShowWindow( GetDlgItem( hwndDlg, IDC_CHECK1 + i), SW_HIDE) ;
-                  s_nType[i] = CTRL_COMBO ;
-               }
-               else if ( s_sEdit[i].find( "CP:") == 0) {
-                  string sVal = s_sEdit[i].substr( 3) ;
-                  Color CColor ;
-                  if ( ! FromString( sVal, CColor))
-                     CColor = INVISIBLE ;
-                  selectedColor[i] = RGB( CColor.GetIntRed(), CColor.GetIntGreen(), CColor.GetIntBlue()) ;
-                  if ( hColorBrush[i] != NULL)
-                     DeleteObject( hColorBrush[i]) ;
-                  hColorBrush[i] = CreateSolidBrush( selectedColor[i]) ;
-                 // recupero i valori dei colori personalizzati dal file .ini
-                  if ( ! s_bCustomColorsInit) {
-                    // recupero il file Ini
-                     string sIniFile = ExeGetIniFile() ;
-                     if ( ! sIniFile.empty()) {
-                        string sCustomVals = GetPrivateProfileStringUtf8( SEC_SCENE, KEY_CUSTOMCOLORS, "", sIniFile.c_str()) ;
-                        STRVECTOR vsWinColors ; Tokenize( sCustomVals, ",", vsWinColors) ;
-                        for ( int j = 0 ; j < ssize( vsWinColors) && j < 16 ; ++ j) {
-                           unsigned int unVal ;
-                           if ( FromString( vsWinColors[j], unVal)) {
-                              unsigned int unR = unVal & 0xFF ;
-                              unsigned int unG = ( unVal >> 8) & 0xFF ;
-                              unsigned int unB = ( unVal >> 16) & 0xFF ;
-                              s_CustomColors[j] = RGB( unR, unG, unB) ;
-                           }
-                        }
-                     }
-                     s_bCustomColorsInit = true ;
-                  }
-                 // nascondo qualsiasi tipo di componente ( per sicurezza)
-                  ShowWindow( GetDlgItem( hwndDlg, IDC_EDIT1 + i), SW_HIDE) ;
-                  ShowWindow( GetDlgItem( hwndDlg, IDC_COMBO1 + i), SW_HIDE) ;
-                  ShowWindow( GetDlgItem( hwndDlg, IDC_CHECK1 + i), SW_HIDE) ;
-
-                 // margini per dimensione del rettangolo preview pickColor
-                  const int MARGIN_RIGHT = 8 ;        // spazio tra preview e bordo destro dialog
-                  const int PREVIEW_HEIGHT = 20 ;     // altezza del rettangolo
-                  const int PREVIEW_MIN_WIDTH = 40 ;  // larghezza minima
-
-                 // ottieni o crea la static preview (allargata fino al bordo destro del dialog)
-                  HWND hwndPreview = NULL ;
-                  RECT rcLabel ;
-                  HWND hwndLabel = GetDlgItem( hwndDlg, IDC_TEXT1 + i) ;
-                  RECT rcClient ; GetClientRect( hwndDlg, &rcClient) ; // coordinate client del dialog
-                  if ( hwndLabel  &&  GetWindowRect( hwndLabel, &rcLabel)) { 
-                    // converti rcLabel in coordinate client
-                     POINT ptLabel = { rcLabel.right, rcLabel.top } ;
-                     ScreenToClient( hwndDlg, &ptLabel) ;
-                     int x = ptLabel.x + 8 ; // distanza dal label
-                     int y = ptLabel.y ;
-                     int width = rcClient.right - x - MARGIN_RIGHT ;
-                     if ( width < PREVIEW_MIN_WIDTH)
-                        width = PREVIEW_MIN_WIDTH ;
-                     hwndPreview = CreateWindowEx( 0, L"STATIC", NULL,
-                                                   WS_CHILD | WS_VISIBLE | SS_NOTIFY | SS_CENTERIMAGE | WS_BORDER,
-                                                   x, y, width, PREVIEW_HEIGHT,
-                                                   hwndDlg, ( HMENU)( IDC_COLOR1 + i),
-                                                   GetModuleHandle( NULL), NULL) ;
-                  }
-                 // pulizia elementi testuali
-                  if ( hwndPreview) {
-                     SetWindowText( hwndPreview, L"") ;
-                     SetWindowPos( hwndPreview, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE) ;
-                     InvalidateRect( hwndPreview, NULL, TRUE) ;
-                     UpdateWindow( hwndPreview) ;
-                  }
-                  s_nType[i] = CTRL_COLOR ;
-               }
-               else {
-                  SetDlgItemText( hwndDlg, IDC_EDIT1 + i, stringtoW( s_sEdit[i])) ;
-                  ShowWindow( GetDlgItem( hwndDlg, IDC_COMBO1 + i), SW_HIDE) ;
-                  ShowWindow( GetDlgItem( hwndDlg, IDC_CHECK1 + i), SW_HIDE) ;
-                  s_nType[i] = CTRL_EDIT ;
-               }
-            }
-            else {
-               ShowWindow( GetDlgItem( hwndDlg, IDC_TEXT1 + i), SW_HIDE) ;
+   case WM_INITDIALOG :
+      {
+        // dati del dialogo
+         HWND hwndOwner = GetParent( hwndDlg) ;
+         if ( hwndOwner == nullptr)
+            hwndOwner = GetDesktopWindow() ;
+         RECT rcOwner, rcDlg ;
+         GetWindowRect( hwndOwner, &rcOwner) ;
+         GetWindowRect( hwndDlg, &rcDlg) ;
+        // determino la posizione dell'ultima riga di dati da visualizzare
+         HWND hwndLR = GetDlgItem( hwndDlg, IDC_TEXT1 + Clamp( s_nCtrls, 1, MAX_CTRLS) - 1) ;
+         RECT rcLR ;
+         GetWindowRect( hwndLR, &rcLR) ;
+         POINT ptLR{ rcLR.left, rcLR.top} ;
+         ScreenToClient( hwndDlg, &ptLR) ;
+        // centro e scalo il dialogo
+         int nNewH = rcLR.top - rcOwner.top + 2 * OFFS_CTRLS ;  // non chiaro perchè va sottratto rcOwner.top ma funziona sempre
+         SetWindowPos( hwndDlg,
+                       HWND_TOP,
+                       ( rcOwner.left + rcOwner.right - ( rcDlg.right - rcDlg.left)) / 2,
+                       ( rcOwner.top + rcOwner.bottom - nNewH) / 2,
+                       ( rcDlg.right - rcDlg.left),
+                       nNewH,
+                       0) ;
+        // riposiziono il bottone Ok
+         HWND hwndOk = GetDlgItem( hwndDlg, IDOK) ;
+         RECT rcOk ;
+         GetWindowRect( hwndOk, &rcOk) ;
+         POINT ptOk{ rcOk.left, rcOk.top} ;
+         ScreenToClient( hwndDlg, &ptOk) ;
+         SetWindowPos( hwndOk,
+                       hwndDlg,
+                       ptOk.x, 
+                       ptLR.y + OFFS_CTRLS,
+                       0, 0,
+                       SWP_NOSIZE | SWP_NOZORDER) ;
+        // riposiziono il bottone Cancel
+         HWND hwndCl = GetDlgItem( hwndDlg, IDCANCEL) ;
+         RECT rcCl ;
+         GetWindowRect( hwndCl, &rcCl) ;
+         POINT ptCl{ rcCl.left, rcCl.top} ;
+         ScreenToClient( hwndDlg, &ptCl) ;
+         SetWindowPos( hwndCl,
+                       hwndDlg,
+                       ptCl.x, 
+                       ptLR.y + OFFS_CTRLS,
+                       0, 0,
+                       SWP_NOSIZE | SWP_NOZORDER) ;
+      }
+     // assegno titolo del dialogo
+      SetWindowText( hwndDlg, stringtoW( s_sCaption)) ;
+     // assegno testi e valori di default e nascondo linee dei controlli non usati
+      for ( int i = 0 ; i < MAX_CTRLS ; ++ i) {
+         if ( i < s_nCtrls) {
+            SetDlgItemText( hwndDlg, IDC_TEXT1 + i, stringtoW( s_sText[i])) ;
+            if ( s_sEdit[i].find( "CK:") == 0) {
+               bool bChecked = false ;
+               FromString( s_sEdit[i].substr( 3), bChecked) ;
+               CheckDlgButton( hwndDlg, IDC_CHECK1 + i, ( bChecked ? BST_CHECKED : BST_UNCHECKED)) ;
               ShowWindow( GetDlgItem( hwndDlg, IDC_EDIT1 + i), SW_HIDE) ;
               ShowWindow( GetDlgItem( hwndDlg, IDC_COMBO1 + i), SW_HIDE) ;
+               s_nType[i] = CTRL_CHECK ;
+            }
+            else if ( s_sEdit[i].find( "CB:") == 0) {
+               string sList = s_sEdit[i].substr( 3) ;
+               STRVECTOR vsVal ;
+               Tokenize( sList, ",", vsVal) ;
+               int nSel = 0 ;
+               HWND hwndCBox = GetDlgItem( hwndDlg, IDC_COMBO1 + i) ;
+               for ( int j = 0 ; j < int( vsVal.size()) ; ++ j) {
+                  string sItem ; 
+                  if ( vsVal[j][0] == '*') {
+                     nSel = j ;
+                     sItem = vsVal[j].substr( 1) ;
+                  }
+                  else
+                     sItem = vsVal[j] ;
+                  ComboBox_AddString( hwndCBox, stringtoW( sItem)) ;
+               }
+               ComboBox_SetCurSel( hwndCBox, nSel) ;
+               ShowWindow( GetDlgItem( hwndDlg, IDC_EDIT1 + i), SW_HIDE) ;
               ShowWindow( GetDlgItem( hwndDlg, IDC_CHECK1 + i), SW_HIDE) ;
-               s_nType[i] = CTRL_NONE ;
+               s_nType[i] = CTRL_COMBO ;
+            }
+            else {
+               SetDlgItemText( hwndDlg, IDC_EDIT1 + i, stringtoW( s_sEdit[i])) ;
+               ShowWindow( GetDlgItem( hwndDlg, IDC_COMBO1 + i), SW_HIDE) ;
+               ShowWindow( GetDlgItem( hwndDlg, IDC_CHECK1 + i), SW_HIDE) ;
+               s_nType[i] = CTRL_EDIT ;
            }
         }
-         break ;
-      case WM_CTLCOLORSTATIC :
-         {
-            HDC hdcStatic = ( HDC)wParam ;
-            HWND hwndCtrl = ( HWND)lParam ;
-            int ctrlId = GetDlgCtrlID( hwndCtrl) ;
-            if ( ctrlId >= IDC_COLOR1  &&  ctrlId <= IDC_COLOR8) {
-               int idx = ctrlId - IDC_COLOR1 ;
-               if ( hColorBrush[idx] == NULL)
-                  hColorBrush[idx] = CreateSolidBrush( selectedColor[idx]) ;
-               SetBkMode( hdcStatic, OPAQUE) ;
-               SetBkColor( hdcStatic, selectedColor[idx]) ;
-               return ( INT_PTR)hColorBrush[idx] ;
-            }
-         }
-         break ;
-      case WM_COMMAND : {
-         int id = LOWORD( wParam) ;
-         int code = HIWORD( wParam) ;
-        // comando di Preview per brush di colori mediante click del mouse
-         if ( code == STN_CLICKED  &&  id >= IDC_COLOR1  &&  id <= IDC_COLOR8) {
-            int idx = id - IDC_COLOR1 ;
-            HWND hwndPreview = GetDlgItem( hwndDlg, IDC_COLOR1 + idx) ;
-            if ( ! hwndPreview)
-               return TRUE ;
-           // apertura ChooseColor (usa hwndDlg come owner)
-            CHOOSECOLOR cc = {} ;
-            cc.lStructSize = sizeof( cc) ;
-            cc.hwndOwner = hwndDlg ;
-            cc.lpCustColors = s_CustomColors ;
-            cc.rgbResult = selectedColor[idx] ;
-            cc.Flags = CC_FULLOPEN | CC_RGBINIT ;
-            if ( ChooseColor( &cc)) {
-               selectedColor[idx] = cc.rgbResult ;
-              // salvo nel file Ini i nuovi colori personalizzati
-               string sIniFile = ExeGetIniFile() ;
-               if ( ! sIniFile.empty()) {
-                  string sOut = "" ;
-                  for ( int j = 0 ; j < ssize( s_CustomColors) && j < 16 ; ++ j)
-                     sOut += ToString( ( unsigned int)s_CustomColors[j]) + "," ;
-                  sOut.pop_back() ;
-                  WritePrivateProfileStringUtf8( SEC_SCENE, KEY_CUSTOMCOLORS, sOut.c_str(), sIniFile.c_str()) ;
-               }
-               if ( hColorBrush[idx] != NULL)
-                  DeleteObject( hColorBrush[idx]) ;
-               hColorBrush[idx] = CreateSolidBrush( selectedColor[idx]) ;
-               InvalidateRect(hwndPreview, NULL, TRUE) ;
-               UpdateWindow( hwndPreview) ;
-            }
-            return TRUE ;
-         }
-
-         switch ( LOWORD( wParam)) {
-            case IDOK :
-               for ( int i = 0 ; i < s_nCtrls ; ++ i) {
-                  AtoWEX<128> wsEdit( "") ;
-                  s_sEdit[i] = "" ;
-                  switch ( s_nType[i]) {
-                  case CTRL_CHECK :
-                     s_sEdit[i] = ( IsDlgButtonChecked( hwndDlg, IDC_CHECK1 + i) == BST_CHECKED ? "1" : "0") ;
-                     break ;
-                  case CTRL_COMBO :
-                     if ( GetDlgItemText( hwndDlg, IDC_COMBO1 + i, LPWSTR( wsEdit), 128) > 0)
-                        s_sEdit[i] = wstrztoA( wsEdit) ;
-                     break ;
-                  case CTRL_EDIT :
-                     if ( GetDlgItemText( hwndDlg, IDC_EDIT1 + i, LPWSTR( wsEdit), 128) > 0)
-                        s_sEdit[i] = wstrztoA( wsEdit) ;
-                     break ;
-                  case CTRL_COLOR :
-                     {
-                        COLORREF col = selectedColor[i] ;
-                        BYTE r = GetRValue( col), g = GetGValue( col), b = GetBValue( col) ;
-                        char buf[16] ;
-                        sprintf_s( buf, sizeof( buf), "%u,%u,%u", r, g, b) ;
-                        s_sEdit[i] = buf ;
-                        break ;
-                     }
-                  }
-               }
-               [[fallthrough]] ;
-            case IDCANCEL : {
-              // pulizia brush colori
-               for ( int i = 0 ; i < MAX_CTRLS ; ++ i) {
-                  if ( hColorBrush[i] != NULL) {
-                     DeleteObject( hColorBrush[i]) ;
-                     hColorBrush[i] = NULL ;
-                  }
-               }
-               EndDialog( hwndDlg, wParam) ;
-               return TRUE ;
-            }
+         else {
+            ShowWindow( GetDlgItem( hwndDlg, IDC_TEXT1 + i), SW_HIDE) ;
+            ShowWindow( GetDlgItem( hwndDlg, IDC_EDIT1 + i), SW_HIDE) ;
+            ShowWindow( GetDlgItem( hwndDlg, IDC_COMBO1 + i), SW_HIDE) ;
+            ShowWindow( GetDlgItem( hwndDlg, IDC_CHECK1 + i), SW_HIDE) ;
+            s_nType[i] = CTRL_NONE ;
         }
      }
-   }
-   return FALSE ;
-}
+      break ;
+   case WM_COMMAND : 
+      switch ( LOWORD( wParam)) { 
+      case IDOK :
+         for ( int i = 0 ; i < s_nCtrls ; ++ i) {
+            AtoWEX<128> wsEdit( "") ;
+            s_sEdit[i] = "" ;
+            switch ( s_nType[i]) {
+            case CTRL_CHECK :
+               s_sEdit[i] = ( IsDlgButtonChecked( hwndDlg, IDC_CHECK1 + i) == BST_CHECKED ? "1" : "0") ;
+               break ;
+            case CTRL_COMBO :
+               if ( GetDlgItemText( hwndDlg, IDC_COMBO1 + i, LPWSTR( wsEdit), 128) > 0)
+                  s_sEdit[i] = wstrztoA( wsEdit) ;
+               break ;
+            case CTRL_EDIT :
+               if ( GetDlgItemText( hwndDlg, IDC_EDIT1 + i, LPWSTR( wsEdit), 128) > 0)
+                  s_sEdit[i] = wstrztoA( wsEdit) ;
+               break ;
+            }
+         }
+         // continua di seguito
+      case IDCANCEL : 
+         EndDialog( hwndDlg, wParam) ; 
+         return TRUE ; 
+      } 
+   } 
+   return FALSE ; 
+} 

 //-------------------------------------------------------------------------------
 static int
@@ -1554,13 +1240,11 @@ 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) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSplitString", LuaSplitString) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSplitStringPlus", LuaSplitStringPlus) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtReplaceString", LuaReplaceString) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSetVal", LuaSetVal) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetVal", LuaGetVal) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetUUID", LuaGetUUID) ;
@@ -1582,12 +1266,10 @@ LuaInstallGeneral( LuaMgr& luaMgr)
   bOk = bOk && luaMgr.RegisterFunction( "EgtEraseFile", LuaEraseFile) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtFindAllFiles", LuaFindAllFiles) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtCompareFilesLastWriteTime", LuaCompareFilesLastWriteTime) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtDirectoryDialog", LuaDirectoryDialog) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtExistsDirectory", LuaExistsDirectory) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtCreateDirectory", LuaCreateDirectory) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtEmptyDirectory", LuaEmptyDirectory) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtEraseDirectory", LuaEraseDirectory) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtEraseNonEmptyDirectory", LuaEraseNonEmptyDirectory) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtTextFileCompare", LuaTextFileCompare) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtBinaryFileCompare", LuaBinaryFileCompare) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetStringFromIni", LuaGetStringFromIni) ;
@@ -1599,14 +1281,11 @@ 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( "EgtSetDefaultFont", LuaSetDefaultFont) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtGetDefaultFont", LuaGetDefaultFont) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtDialogBox", LuaDialogBox) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtWinExec", LuaWinExec) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtCloseExe", LuaCloseExe) ;  
   bOk = bOk && luaMgr.RegisterFunction( "EgtCreateMutex", LuaCreateMutex) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtReleaseMutex", LuaReleaseMutex) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtDialogBox", LuaDialogBox) ;
   
   return bOk ;
 }
@@ -530,83 +530,6 @@ LuaBBoxLocToLoc( lua_State* L)
   }
 }

-//-------------------------------------------------------------------------------
-static int
-LuaQuaternionFromAxisAngle( lua_State* L)
-{
-  // 2 parametri : vtAx, dAngDeg
-   Vector3d vtAx ;
-   LuaCheckParam( L, 1, vtAx)
-   double dAngDeg ;
-   LuaCheckParam( L, 2, dAngDeg)
-   LuaClearStack( L) ;
-  // calcolo il quaternione che produce la rotazione equivalente
-   Quaternion qtQ = FromAxisAngle( vtAx, dAngDeg) ;
-   if ( ! qtQ.IsSmall())
-      LuaSetParam( L, qtQ) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaQuaternionToAxisAngle( lua_State* L)
-{
-  // 1 parametro : Quaternion
-   Quaternion qtQ ;
-   LuaCheckParam( L, 1, qtQ)
-   LuaClearStack( L) ;
-  // calcolo l'asse e l'angolo di rotazione equivalenti
-   Vector3d vtAx ;
-   double dAngDeg ;
-   bool bOk = ToAxisAngle( qtQ, vtAx, dAngDeg) ;
-   if ( bOk) {
-      LuaSetParam( L, vtAx) ;
-      LuaSetParam( L, dAngDeg) ;
-      return 2 ;
-   }
-   else {
-      LuaSetParam( L) ;
-      return 1 ;
-   }
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaQuaternionFromFrame( lua_State* L)
-{
-  // 1 parametro : Frame
-   Frame3d frFrame ;
-   LuaCheckParam( L, 1, frFrame)
-   LuaClearStack( L) ;
-  // calcolo il quaternione che produce l'orientamento di questo frame tramite rotazione dal globale
-   Quaternion qtQ = FromFrame( frFrame) ;
-   if ( ! qtQ.IsSmall())
-      LuaSetParam( L, qtQ) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaQuaternionToFrame( lua_State* L)
-{
-  // 1 parametro : Quaternion
-   Quaternion qtQ ;
-   LuaCheckParam( L, 1, qtQ)
-   LuaClearStack( L) ;
-  // calcolo il frame equivalente come orientamento a quello globale ruotato dal quaternione
-   Frame3d frFrame ;
-   bool bOk = ToFrame( qtQ, frFrame) ;
-   if ( bOk)
-      LuaSetParam( L, frFrame) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
 //-------------------------------------------------------------------------------
 bool
 LuaInstallGeoBase( LuaMgr& luaMgr)
@@ -634,9 +557,5 @@ LuaInstallGeoBase( LuaMgr& luaMgr)
   bOk = bOk && luaMgr.RegisterFunction( "EgtBBoxToGlob", LuaBBoxToGlob) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtBBoxToLoc", LuaBBoxToLoc) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtBBoxLocToLoc", LuaBBoxLocToLoc) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtQuaternionFromAxisAngle", LuaQuaternionFromAxisAngle) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtQuaternionToAxisAngle", LuaQuaternionToAxisAngle) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtQuaternionFromFrame", LuaQuaternionFromFrame) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtQuaternionToFrame", LuaQuaternionToFrame) ;
   return bOk ;
 }
@@ -111,36 +111,6 @@ LuaPointSurfTmDist( lua_State* L)
   return 3 ;
 }

-//----------------------------------------------------------------------------
-static int
-LuaPointSurfBzDist( lua_State* L)
-{
-  // 2 o 3 parametri : ptP, nSbzId, [, nRefId]
-   Point3d ptP ;
-   LuaCheckParam( L, 1, ptP)
-   int nId ;
-   LuaCheckParam( L, 2, nId)
-   int nRefType = nId ;
-   LuaGetParam( L, 3, nRefType) ;
-   LuaClearStack( L) ;
-  // calcolo la distanza
-   double dDist ;
-   Point3d ptMin ;
-   Vector3d vtN ;
-   bool bOk = ExePointSurfBzDist( ptP, nId, nRefType, &dDist, ptMin, vtN) ;
-   if ( bOk) {
-      LuaSetParam( L, dDist) ;
-      LuaSetParam( L, ptMin) ;
-      LuaSetParam( L, vtN) ;
-   }
-   else {
-      LuaSetParam( L) ;
-      LuaSetParam( L) ;
-      LuaSetParam( L) ;
-   }
-   return 3 ;
-}
-
 //-------------------------------------------------------------------------------
 bool
 LuaInstallGeoDist( LuaMgr& luaMgr)
@@ -149,6 +119,5 @@ LuaInstallGeoDist( LuaMgr& luaMgr)
   bOk = bOk && luaMgr.RegisterFunction( "EgtPointCurveDist", LuaPointCurveDist) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtPointCurveDistSide", LuaPointCurveDistSide) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtPointSurfTmDist", LuaPointSurfTmDist) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtPointSurfBzDist", LuaPointSurfBzDist) ;
   return bOk ;
 }
@@ -20,41 +20,6 @@

 using namespace std ;

-//----------------------------------------------------------------------------
-static int
-LuaLineCurveInters( lua_State* L)
-{
-  // 3 o 4 parametri : ptP, vtDir, Id, [, nRefId]
-   Point3d ptP ;
-   LuaCheckParam( L, 1, ptP)
-   Vector3d vtDir ;
-   LuaCheckParam( L, 2, vtDir)
-   int nId ;
-   LuaCheckParam( L, 3, nId)
-   int nRefType = nId ;
-   LuaGetParam( L, 4, nRefType) ;
-   LuaClearStack( L) ;
-  // recupero i punti di intersezione tra linea e curva
-   INTDBLVECTOR vInters ;
-   if ( ExeLineCurveInters( ptP, vtDir, nId, nRefType, vInters)) {
-      LuaSetParam( L, true) ;
-      INTVECTOR vType( vInters.size()) ;
-      DBLVECTOR vPar( vInters.size()) ;
-      for ( size_t i = 0 ; i < vInters.size() ; ++ i) {
-         vType[i] = vInters[i].first ;
-         vPar[i] = vInters[i].second ;
-      }
-      LuaSetParam( L, vType) ;
-      LuaSetParam( L, vPar) ;
-   }
-   else {
-      LuaSetParam( L) ;
-      LuaSetParam( L) ;
-      LuaSetParam( L) ;
-   }
-   return 3 ;
-}
-
 //----------------------------------------------------------------------------
 static int
 LuaLineBoxInters( lua_State* L)
@@ -88,6 +53,38 @@ LuaLineBoxInters( lua_State* L)
   return 3 ;
 }

+//----------------------------------------------------------------------------
+static int
+LuaPlaneBoxInters( lua_State* L)
+{
+  // 4 o 5 parametri : ptOn, vtN, b3Box, nDestGrpId [, nRefType]
+   Point3d ptOn ;
+   LuaCheckParam( L, 1, ptOn)
+   Vector3d vtN ;
+   LuaCheckParam( L, 2, vtN)
+   BBox3d b3Box ;
+   LuaCheckParam( L, 3, b3Box)
+   int nDestGrpId ;
+   LuaCheckParam( L, 4, nDestGrpId) ;
+   int nRefType = RTY_DEFAULT ;
+   LuaGetParam( L, 5, nRefType) ;
+   LuaClearStack( L) ;
+  // eseguo l'intersezione
+   int nPntCount = 0 ;
+   int nCrvCount = 0 ;
+   int nSrfCount = 0 ;
+   int nNewId = ExePlaneBoxInters( ptOn, vtN, b3Box, nDestGrpId, nRefType, &nPntCount, &nCrvCount, &nSrfCount) ;
+  // restituisco il risultato
+   if ( nNewId != GDB_ID_NULL)
+      LuaSetParam( L, nNewId) ;
+   else
+      LuaSetParam( L) ;
+   LuaSetParam( L, nPntCount) ;
+   LuaSetParam( L, nCrvCount) ;
+   LuaSetParam( L, nSrfCount) ;
+   return 4 ;
+}
+
 //----------------------------------------------------------------------------
 static int
 LuaLineSurfTmInters( lua_State* L)
@@ -123,136 +120,6 @@ LuaLineSurfTmInters( lua_State* L)
   return 3 ;
 }

-//----------------------------------------------------------------------------
-static int
-LuaLineSurfBzInters( lua_State* L)
-{
-   // 3 o 4 parametri : ptP, vtDir, Id, [, nRefId]
-   Point3d ptP ;
-   LuaCheckParam( L, 1, ptP)
-      Vector3d vtDir ;
-   LuaCheckParam( L, 2, vtDir)
-      int nId ;
-   LuaCheckParam( L, 3, nId)
-      int nRefType = nId ;
-   LuaGetParam( L, 4, nRefType) ;
-   LuaClearStack( L) ;
-   // recupero i punti di intersezione tra linea e superficie trimesh
-   INTDBLVECTOR vInters ;
-   if ( ExeLineSurfBzInters( ptP, vtDir, nId, nRefType, vInters)) {
-      LuaSetParam( L, true) ;
-      INTVECTOR vType( vInters.size()) ;
-      DBLVECTOR vPar( vInters.size()) ;
-      for ( size_t i = 0 ; i < vInters.size() ; ++ i) {
-         vType[i] = vInters[i].first ;
-         vPar[i] = vInters[i].second ;
-      }
-      LuaSetParam( L, vType) ;
-      LuaSetParam( L, vPar) ;
-   }
-   else {
-      LuaSetParam( L) ;
-      LuaSetParam( L) ;
-      LuaSetParam( L) ;
-   }
-   return 3 ;
-}
-
-//----------------------------------------------------------------------------
-static int
-LuaLineVolZmapInters( lua_State* L)
-{
-  // 3 o 4 parametri : ptP, vtDir, Id, [, nRefId]
-   Point3d ptP ;
-   LuaCheckParam( L, 1, ptP)
-   Vector3d vtDir ;
-   LuaCheckParam( L, 2, vtDir)
-   int nId ;
-   LuaCheckParam( L, 3, nId)
-   int nRefType = nId ;
-   LuaGetParam( L, 4, nRefType) ;
-   LuaClearStack( L) ;
-  // eseguo calcolo intersezione
-   INTDBLVECTOR vInters ;
-   if ( ExeLineVolZmapInters( ptP, vtDir, nId, nRefType, vInters)) {
-      LuaSetParam( L, true) ;
-      INTVECTOR vType( vInters.size()) ;
-      DBLVECTOR vPar( vInters.size()) ;
-      for ( size_t i = 0 ; i < vInters.size() ; ++ i) {
-         vType[i] = vInters[i].first ;
-         vPar[i] = vInters[i].second ;
-      }
-      LuaSetParam( L, vType) ;
-      LuaSetParam( L, vPar) ;
-   }
-   else {
-      LuaSetParam( L) ;
-      LuaSetParam( L) ;
-      LuaSetParam( L) ;
-   }
-   return 3 ;
-}
-
-//----------------------------------------------------------------------------
-static int
-LuaPlaneCurveInters( lua_State* L)
-{
-  // 4 o 5 parametri : ptOn, vtN, nId, nDestGrpId [, nRefType] 
-   Point3d ptOn ;
-   LuaCheckParam( L, 1, ptOn)
-   Vector3d vtN ;
-   LuaCheckParam( L, 2, vtN)
-   int nId ;
-   LuaCheckParam( L, 3, nId)
-   int nDestGrpId ;
-   LuaCheckParam( L, 4, nDestGrpId) ;
-   int nRefType = RTY_DEFAULT ;
-   LuaGetParam( L, 5, nRefType) ;
-   LuaClearStack( L) ;
-  // eseguo l'intersezione
-   int nCount = 0 ;
-   int nNewId = ExePlaneCurveInters( ptOn, vtN, nId, nDestGrpId, nRefType, &nCount) ;
-  // restituisco il risultato
-   if ( nNewId != GDB_ID_NULL)
-      LuaSetParam( L, nNewId) ;
-   else
-      LuaSetParam( L) ;
-   LuaSetParam( L, nCount) ;
-   return 2 ;
-}
-
-//----------------------------------------------------------------------------
-static int
-LuaPlaneBoxInters( lua_State* L)
-{
-  // 4 o 5 parametri : ptOn, vtN, b3Box, nDestGrpId [, nRefType]
-   Point3d ptOn ;
-   LuaCheckParam( L, 1, ptOn)
-   Vector3d vtN ;
-   LuaCheckParam( L, 2, vtN)
-   BBox3d b3Box ;
-   LuaCheckParam( L, 3, b3Box)
-   int nDestGrpId ;
-   LuaCheckParam( L, 4, nDestGrpId) ;
-   int nRefType = RTY_DEFAULT ;
-   LuaGetParam( L, 5, nRefType) ;
-   LuaClearStack( L) ;
-  // eseguo l'intersezione
-   int nPntCount = 0 ;
-   int nCrvCount = 0 ;
-   int nSrfCount = 0 ;
-   int nNewId = ExePlaneBoxInters( ptOn, vtN, b3Box, nDestGrpId, nRefType, &nPntCount, &nCrvCount, &nSrfCount) ;
-  // restituisco il risultato
-   if ( nNewId != GDB_ID_NULL)
-      LuaSetParam( L, nNewId) ;
-   else
-      LuaSetParam( L) ;
-   LuaSetParam( L, nPntCount) ;
-   LuaSetParam( L, nCrvCount) ;
-   LuaSetParam( L, nSrfCount) ;
-   return 4 ;
-}
-
 //----------------------------------------------------------------------------
 static int
 LuaPlaneSurfTmInters( lua_State* L)
@@ -319,91 +186,6 @@ LuaParPlanesSurfTmInters( lua_State* L)
   return 2 ;
 }

-//----------------------------------------------------------------------------
-static int
-LuaPlaneVolZmapInters( lua_State* L)
-{
-  // 4 o 5 parametri : ptP, vtN, nId, nDestGrpId [, nRefType]
-   Point3d ptP ;
-   LuaCheckParam( L, 1, ptP)
-   Vector3d vtN ;
-   LuaCheckParam( L, 2, vtN)
-   int nId ;
-   LuaCheckParam( L, 3, nId)
-   int nDestGrpId ;
-   LuaCheckParam( L, 4, nDestGrpId)
-   int nRefType = RTY_DEFAULT ;
-   LuaGetParam( L, 5, nRefType) ;
-   LuaClearStack( L) ;
-  // eseguo calcolo intersezione
-   int nCount ;
-   int nFirstId = ExePlaneVolZmapInters( ptP, vtN, nId, nDestGrpId, nRefType, &nCount) ;
-  // restituisco il risultato
-   if ( nFirstId != GDB_ID_NULL) {
-      LuaSetParam( L, nFirstId) ;
-      LuaSetParam( L, nCount) ;
-   }
-   else {
-      LuaSetParam( L) ;
-      LuaSetParam( L) ;
-   }
-   return 2 ;
-}
-
-//----------------------------------------------------------------------------
-static int
-LuaCurveCurveInters( lua_State* L)
-{
-  // 3 o 4 parametri : nId1, nId2, nDestGrpId [, bOnly3D]
-   int nId1 ;
-   LuaCheckParam( L, 1, nId1)
-   int nId2 ;
-   LuaCheckParam( L, 2, nId2)
-   int nDestGrpId ;
-   LuaCheckParam( L, 3, nDestGrpId) ;   
-   bool bOnly3D = false ;
-   LuaGetParam( L, 4, bOnly3D) ;
-   LuaClearStack( L) ;
-  // eseguo l'intersezione
-   int nPntCount = 0 ;
-   int nCrvCount = 0 ;
-   int nNewId = ExeCurveCurveInters( nId1, nId2, nDestGrpId, &nPntCount, &nCrvCount, bOnly3D) ;
-   // restituisco il risultato
-   if ( nNewId != GDB_ID_NULL)
-      LuaSetParam( L, nNewId) ;
-   else
-      LuaSetParam( L) ;
-   LuaSetParam( L, nPntCount) ;
-   LuaSetParam( L, nCrvCount) ;
-   return 3 ;
-}
-
-//----------------------------------------------------------------------------
-static int
-LuaCurveSurfTmInters( lua_State* L)
-{
-  // 3 parametri : nCrvId, nStmId, nDestGrpId
-   int nCrvId ;
-   LuaCheckParam( L, 1, nCrvId)
-   int nStmId ;
-   LuaCheckParam( L, 2, nStmId)
-   int nDestGrpId ;
-   LuaCheckParam( L, 3, nDestGrpId) ;   
-   LuaClearStack( L) ;
-  // eseguo l'intersezione
-   int nPntCount = 0 ;
-   int nCrvCount = 0 ;
-   int nNewId = ExeCurveSurfTmInters( nCrvId, nStmId, nDestGrpId, &nPntCount, &nCrvCount) ;
-   // restituisco il risultato
-   if ( nNewId != GDB_ID_NULL)
-      LuaSetParam( L, nNewId) ;
-   else
-      LuaSetParam( L) ;
-   LuaSetParam( L, nPntCount) ;
-   LuaSetParam( L, nCrvCount) ;
-   return 3 ;
-}
-
 //----------------------------------------------------------------------------
 static int
 LuaSurfTmSurfTmInters( lua_State* L)
@@ -436,22 +218,122 @@ LuaSurfTmSurfTmInters( lua_State* L)

 //----------------------------------------------------------------------------
 static int
-LuaBBoxOverlap( lua_State* L)
+LuaPlaneCurveInters( lua_State* L)
 {
-   // 4 parametri : BBoxA, frA, BBoxB, frB
-   BBox3d bboxA ;
-   LuaCheckParam( L, 1, bboxA)
-   Frame3d frA ;
-   LuaCheckParam( L, 2, frA)
-   BBox3d bboxB ;
-   LuaCheckParam( L, 3, bboxB) ;
-   Frame3d frB ;
-   LuaCheckParam( L, 4, frB) ;
+  // 4 o 5 parametri : ptOn, vtN, nId, nDestGrpId [, nRefType] 
+   Point3d ptOn ;
+   LuaCheckParam( L, 1, ptOn)
+   Vector3d vtN ;
+   LuaCheckParam( L, 2, vtN)
+   int nId ;
+   LuaCheckParam( L, 3, nId)
+   int nDestGrpId ;
+   LuaCheckParam( L, 4, nDestGrpId) ;
+   int nRefType = RTY_DEFAULT ;
+   LuaGetParam( L, 5, nRefType) ;
   LuaClearStack( L) ;
-   bool bRes = ExeBBoxOverlap( bboxA, frA, bboxB, frB) ;
+  // eseguo l'intersezione
+   int nCount = 0 ;
+   int nNewId = ExePlaneCurveInters( ptOn, vtN, nId, nDestGrpId, nRefType, &nCount) ;
  // restituisco il risultato
-   LuaSetParam( L, bRes) ;
-   return 1 ;
+   if ( nNewId != GDB_ID_NULL)
+      LuaSetParam( L, nNewId) ;
+   else
+      LuaSetParam( L) ;
+   LuaSetParam( L, nCount) ;
+   return 2 ;
+}
+
+//----------------------------------------------------------------------------
+static int
+LuaCurveCurveInters( lua_State* L)
+{
+  // 3 parametri : nId1, nId2, nDestGrpId
+   int nId1 ;
+   LuaCheckParam( L, 1, nId1)
+   int nId2 ;
+   LuaCheckParam( L, 2, nId2)
+   int nDestGrpId ;
+   LuaCheckParam( L, 3, nDestGrpId) ;   
+   LuaClearStack( L) ;
+  // eseguo l'intersezione
+   int nPntCount = 0 ;
+   int nCrvCount = 0 ;
+   int nNewId = ExeCurveCurveInters( nId1, nId2, nDestGrpId, &nPntCount, &nCrvCount) ;
+   // restituisco il risultato
+   if ( nNewId != GDB_ID_NULL)
+      LuaSetParam( L, nNewId) ;
+   else
+      LuaSetParam( L) ;
+   LuaSetParam( L, nPntCount) ;
+   LuaSetParam( L, nCrvCount) ;
+   return 3 ;
+}
+
+//----------------------------------------------------------------------------
+static int
+LuaLineVolZmapInters( lua_State* L)
+{
+  // 3 o 4 parametri : ptP, vtDir, Id, [, nRefId]
+   Point3d ptP ;
+   LuaCheckParam( L, 1, ptP)
+   Vector3d vtDir ;
+   LuaCheckParam( L, 2, vtDir)
+   int nId ;
+   LuaCheckParam( L, 3, nId)
+   int nRefType = nId ;
+   LuaGetParam( L, 4, nRefType) ;
+   LuaClearStack( L) ;
+  // eseguo calcolo intersezione
+   INTDBLVECTOR vInters ;
+   if ( ExeLineVolZmapInters( ptP, vtDir, nId, nRefType, vInters)) {
+      LuaSetParam( L, true) ;
+      INTVECTOR vType( vInters.size()) ;
+      DBLVECTOR vPar( vInters.size()) ;
+      for ( size_t i = 0 ; i < vInters.size() ; ++ i) {
+         vType[i] = vInters[i].first ;
+         vPar[i] = vInters[i].second ;
+      }
+      LuaSetParam( L, vType) ;
+      LuaSetParam( L, vPar) ;
+   }
+   else {
+      LuaSetParam( L) ;
+      LuaSetParam( L) ;
+      LuaSetParam( L) ;
+   }
+   return 3 ;
+}
+
+//----------------------------------------------------------------------------
+static int
+LuaPlaneVolZmapInters( lua_State* L)
+{
+  // 4 o 5 parametri : ptP, vtN, nId, nDestGrpId [, nRefType]
+   Point3d ptP ;
+   LuaCheckParam( L, 1, ptP)
+   Vector3d vtN ;
+   LuaCheckParam( L, 2, vtN)
+   int nId ;
+   LuaCheckParam( L, 3, nId)
+   int nDestGrpId ;
+   LuaCheckParam( L, 4, nDestGrpId)
+   int nRefType = RTY_DEFAULT ;
+   LuaGetParam( L, 5, nRefType) ;
+   LuaClearStack( L) ;
+  // eseguo calcolo intersezione
+   int nCount ;
+   int nFirstId = ExePlaneVolZmapInters( ptP, vtN, nId, nDestGrpId, nRefType, &nCount) ;
+  // restituisco il risultato
+   if ( nFirstId != GDB_ID_NULL) {
+      LuaSetParam( L, nFirstId) ;
+      LuaSetParam( L, nCount) ;
+   }
+   else {
+      LuaSetParam( L) ;
+      LuaSetParam( L) ;
+   }
+   return 2 ;
 }

 //-------------------------------------------------------------------------------
@@ -459,19 +341,15 @@ bool
 LuaInstallGeoInters( LuaMgr& luaMgr)
 {
   bool bOk = ( &luaMgr != nullptr) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtLineCurveInters", LuaLineCurveInters) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtLineBoxInters", LuaLineBoxInters) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtLineSurfTmInters", LuaLineSurfTmInters) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtLineSurfBzInters", LuaLineSurfBzInters) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtLineVolZmapInters", LuaLineVolZmapInters) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtPlaneCurveInters", LuaPlaneCurveInters) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtPlaneBoxInters", LuaPlaneBoxInters) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtLineSurfTmInters", LuaLineSurfTmInters) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtPlaneSurfTmInters", LuaPlaneSurfTmInters) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtParPlanesSurfTmInters", LuaParPlanesSurfTmInters) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtPlaneVolZmapInters", LuaPlaneVolZmapInters) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtCurveCurveInters", LuaCurveCurveInters) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtCurveSurfTmInters", LuaCurveSurfTmInters) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmSurfTmInters", LuaSurfTmSurfTmInters) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtBBoxOverlap", LuaBBoxOverlap) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtPlaneCurveInters", LuaPlaneCurveInters) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtCurveCurveInters", LuaCurveCurveInters) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtLineVolZmapInters", LuaLineVolZmapInters) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtPlaneVolZmapInters", LuaPlaneVolZmapInters) ;
   return bOk ;
-}
+}
@@ -312,16 +312,16 @@ LuaSaveFile( lua_State* L)
 static int
 LuaSaveObjToFile( lua_State* L)
 {
-  // 2 o 3 parametri : vId, path del file [, flag]
-   INTVECTOR vId ;
-   LuaCheckParam( L, 1, vId)
+  // 2 o 3 parametri : nId, path del file [, flag]
+   int nId ;
+   LuaCheckParam( L, 1, nId)
   string sFilePath ;
   LuaCheckParam( L, 2, sFilePath)
   int nFlag = GDB_SV_CMPTXT ;
   LuaGetParam( L, 3, nFlag) ;
   LuaClearStack( L) ;
  // copio il gruppo nel file
-   bool bOk = ExeSaveObjToFile( vId, sFilePath, nFlag) ; 
+   bool bOk = ExeSaveObjToFile( nId, sFilePath, nFlag) ; 
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
@@ -331,18 +331,16 @@ LuaSaveObjToFile( lua_State* L)
 static int
 LuaSaveMachGroupToFile( lua_State* L)
 {
-  // 2, 3 o 4 parametri : nMGroupId, [ vPlusId,] sFilePath [, nFlag]
+  // 2 o 3 parametri : nMGroupId, path del file [, flag]
   int nMGroupId ;
   LuaCheckParam( L, 1, nMGroupId)
-   INTVECTOR vPlusId ;
-   int nOffs = ( LuaGetParam( L, 2, vPlusId) ?1 : 0) ;
   string sFilePath ;
-   LuaCheckParam( L, 2 + nOffs, sFilePath)
+   LuaCheckParam( L, 2, sFilePath)
   int nFlag = GDB_SV_CMPTXT ;
-   LuaGetParam( L, 3 + nOffs, nFlag) ;
+   LuaGetParam( L, 3, nFlag) ;
   LuaClearStack( L) ;
  // copio il gruppo nel file
-   bool bOk = ExeSaveMachGroupToFile( nMGroupId, vPlusId, sFilePath, nFlag) ; 
+   bool bOk = ExeSaveMachGroupToFile( nMGroupId, sFilePath, nFlag) ; 
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
@@ -1,306 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2025-2025
-//----------------------------------------------------------------------------
-// File : LUA_MachOpt.cpp       Data : 02.04.25       Versione : 2.7c1
-// Contenuto : Funzioni per Ottimizzare i tempi tra le lavorazioni per LUA.
-//
-//
-//
-// Modifiche : 02.04.25 RE Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-//--------------------------- Include ----------------------------------------
-#include "stdafx.h"
-#include "LUA.h"
-#include "/EgtDev/Include/EXeExecutor.h"
-#include "/EgtDev/Include/EGkLuaAux.h"
-#include "/EgtDev/Include/EGnStringUtils.h"
-
-using namespace std ;
-
-//-------------------------------------------------------------------------------
-static int
-LuaOptMachInit( lua_State* L)
-{
-  // Nessun parametro
-   LuaClearStack( L) ;
-  // Inizializzo il calcolatore per minimizzare i tempi tra le lavorazioni
-   bool bOk = ExeOptMachInit() ;
-  // Restituisco il risultato
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaOptMachTerminate( lua_State* L)
-{
-  // Nessun parametro
-   LuaClearStack( L) ;
-  // Termino il calcolatore per minimizzare i tempi tra le lavorazioni
-   bool bOk = ExeOptMachTerminate() ;
-  // Restituisco il risultato
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaOptMachAddTool( lua_State* L)
-{
-  // Definizione 9 parametri (3 obbligatori)
-   int nId ;
-   LuaCheckParam( L, 1, nId) ;
-   double dTLoad ;
-   LuaCheckParam( L, 2, dTLoad) ;
-   double dTUnload ;
-   LuaCheckParam( L, 3, dTUnload) ;
-   double dTC_X = 0. ;
-   bool bTC_X = LuaGetParam( L, 4, dTC_X) ;
-   double dTC_Y = 0. ;
-   bool bTC_Y = LuaGetParam( L, 5, dTC_Y) ;
-   double dTC_Z = 0. ;
-   bool bTC_Z = LuaGetParam( L, 6, dTC_Z) ;
-   double dTC_A = 0. ;
-   bool bTC_A = LuaGetParam( L, 7, dTC_A) ;
-   double dTC_B = 0. ;
-   bool bTC_B = LuaGetParam( L, 8, dTC_B) ;
-   double dTC_C = 0. ;
-   bool bTC_C = LuaGetParam( L, 9, dTC_C) ;
-   LuaClearStack( L) ;
-  // Aggiungo la Lavorazione
-   bool bOk = ExeOptMachAddTool( nId, dTC_X, dTC_Y, dTC_Z, dTC_A, dTC_B, dTC_C,
-                                      bTC_X, bTC_Y, bTC_Z, bTC_A, bTC_B, bTC_C,
-                                 dTLoad, dTUnload) ;
-  // Rstituisco il risultato
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaOptMachAddMachining( lua_State* L)
-{
-  // Definizione 5 parametri
-   int nId ;
-   LuaCheckParam( L, 1, nId) ;
-   int nToolId ;
-   LuaCheckParam( L, 2, nToolId) ;
-   int nGroup ;
-   LuaCheckParam( L, 3, nGroup) ;
-   DBLVECTOR vAxStart ;
-   LuaCheckParam( L, 4, vAxStart) ;
-   DBLVECTOR vAxEnd ;
-   LuaCheckParam( L, 5, vAxEnd) ;
-   LuaClearStack( L) ;
-  // Completamento valori assi
-   while ( vAxStart.size() < 6)
-      vAxStart.push_back( 0) ;
-   while ( vAxEnd.size() < 6)
-      vAxEnd.push_back( 0) ;
-  // Aggiungo la Lavorazione
-   bool bOk = ExeOptMachAddMachining( nId, nToolId, nGroup,
-                                      vAxStart[0], vAxStart[1], vAxStart[2], vAxStart[3], vAxStart[4], vAxStart[5],
-                                      vAxEnd[0], vAxEnd[1], vAxEnd[2], vAxEnd[3], vAxEnd[4], vAxEnd[5]) ;
-  // Rstituisco il risultato
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaOptMachSetFirstMachining( lua_State* L)
-{
-   // 1 parametro : nId
-   int nId = 0 ;
-   LuaCheckParam( L, 1, nId) ;
-   LuaClearStack( L) ;
-  // Imposto la prima lavorazione
-   bool bOk = ExeOptMachSetFirstMachining( nId) ;
-  // Restituisco il risultato
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
-//------------------------------------------------------------------------------
-static int
-LuaOptMachSetLastMachining( lua_State* L)
-{
-   // 1 parametro : nId
-   int nId = 0 ;
-   LuaCheckParam( L, 1, nId) ;
-   LuaClearStack( L) ;
-  // Imposto la prima lavorazione
-   bool bOk = ExeOptMachSetLastMachining( nId) ;
-  // Restituisco il risultato
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
-//------------------------------------------------------------------------------
-static int
-LuaOptMachSetFeeds( lua_State* L)
-{
-  // 2 Parametri : dFeedL, dFeedA
-   double dFeedL = 1. ;
-   LuaCheckParam( L, 1, dFeedL) ;
-   double dFeedA = 1. ;
-   LuaCheckParam( L, 2, dFeedA) ;
-   LuaClearStack( L) ;
-  // Imposto le Feeds
-   bool bOk = ExeOptMachSetFeeds( dFeedL, dFeedA) ;
-  // Restituisco il risultato
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaOptMachAddDependence( lua_State* L)
-{
-  // 2 parametri : nIdPrev, nIdSucc
-   int nIdPrev = 0 ; int nIdNext = 0 ;
-   LuaCheckParam( L, 1, nIdPrev) ;
-   LuaCheckParam( L, 2, nIdNext) ;
-   LuaClearStack( L) ;
-  // Imposto Dipendenza obbligatoria
-   bool bOk = ExeOptMachAddDependence( nIdPrev, nIdNext) ;
-  // Restituisco il risultato
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaOptMachAddSuggestedDependence( lua_State* L)
-{
-  // 2 parametri : nIdPrev, nIdSucc
-   int nIdPrev = 0 ; int nIdNext = 0 ;
-   LuaCheckParam( L, 1, nIdPrev) ;
-   LuaCheckParam( L, 2, nIdNext) ;
-   LuaClearStack( L) ;
-  // Imposto Dipendenza suggerita
-   bool bOk = ExeOptMachAddSuggestedDependence( nIdPrev, nIdNext) ;
-  // Restituisco il risultato
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaOptMachSetAllGroupDependencesAsMandatory( lua_State* L)
-{
-  // 1 Parametro : bAllMendatory
-   bool bAllMendatory = false ;
-   LuaCheckParam( L, 1, bAllMendatory) ;
-   LuaClearStack( L) ;
-  // Imposto il Flag
-   bool bOk = ExeOptMachSetAllGroupDependencesAsMandatory( bAllMendatory) ;
-  // Restituisco il risultato
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaOptMachSetOptimizationForGroups( lua_State* L)
-{
-  // 1 Parametro : bOptForGroups
-   bool bOptForGroups = false ;
-   LuaCheckParam( L, 1, bOptForGroups) ;
-   LuaClearStack( L) ;
-  // Imposto il Flag
-   bool bOk = ExeOptMachSetOptimizationForGroups( bOptForGroups) ;
-  // Restituisco il risultato
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaOptMachSetOpenBound( lua_State* L)
-{
-  // 5 parametri : bStartVsEnd, nFlag, dX, dY, dZ
-   bool bStartVsEnd ;
-   LuaCheckParam( L, 1, bStartVsEnd) ;
-   int nFlag ;
-   LuaCheckParam( L, 2, nFlag) ;
-   double dX ;
-   LuaCheckParam( L, 3, dX) ;
-   double dY ;
-   LuaCheckParam( L, 4, dY) ;
-   double dZ ;
-   LuaCheckParam( L, 5, dZ) ;
-   LuaClearStack( L) ;
-  // Imposto la condizione
-   bool bOk = ExeOptMachSetOpenBound( bStartVsEnd, nFlag, dX, dY, dZ) ;
-  // Restituisco il risultato
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaOptMachSetOpenBoundForGroups( lua_State* L)
-{
-  // 6 parametri : nGroup, bStartVsEnd, nFlag, dX, dY, dZ
-   int nGroup ;
-   LuaCheckParam( L, 1, nGroup) ;
-   bool bStartVsEnd ;
-   LuaCheckParam( L, 2, bStartVsEnd) ;
-   int nFlag ;
-   LuaCheckParam( L, 3, nFlag) ;
-   double dX ;
-   LuaCheckParam( L, 4, dX) ;
-   double dY ;
-   LuaCheckParam( L, 5, dY) ;
-   double dZ ;
-   LuaCheckParam( L, 6, dZ) ;
-   LuaClearStack( L) ;
-  // Imposto la condizione
-   bool bOk = ExeOptMachSetOpenBoundForGroups( nGroup, bStartVsEnd, nFlag, dX, dY, dZ) ;
-  // Restituisco il risultato
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaOptMachCalculate( lua_State* L)
-{
-  // nessun parametro
-   LuaClearStack( L) ;
-  // eseguo calcolo di minimo percorso
-   INTVECTOR vOrder ;
-   bool bOk = ExeOptMachCalculate( vOrder) ;
-  // restituisco il risultato
-   if ( bOk)
-      LuaSetParam( L, vOrder) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-bool
-LuaInstallMachiningOptimization( LuaMgr& luaMgr)
-{
-   bool bOk = ( &luaMgr != nullptr) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtOptMachInit", LuaOptMachInit) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtOptMachTerminate", LuaOptMachTerminate) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtOptMachAddTool", LuaOptMachAddTool) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtOptMachAddMachining", LuaOptMachAddMachining) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtOptMachSetFirstMachining", LuaOptMachSetFirstMachining) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtOptMachSetLastMachining", LuaOptMachSetLastMachining) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtOptMachSetFeeds", LuaOptMachSetFeeds) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtOptMachAddDependence", LuaOptMachAddDependence) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtOptMachAddSuggestedDependence", LuaOptMachAddSuggestedDependence) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtOptMachSetAllGroupsDependencesAsMandatory", LuaOptMachSetAllGroupDependencesAsMandatory) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtOptMachSetOptimizationForGroups", LuaOptMachSetOptimizationForGroups) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtOptMachSetOpenBound", LuaOptMachSetOpenBound) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtOptMachSetOpenBoundForGroups", LuaOptMachSetOpenBoundForGroups) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtOptMachCalculate", LuaOptMachCalculate) ;
-   return bOk ;
-}
@@ -340,21 +340,6 @@ LuaAutoNestSetInterpartGap( lua_State* L)
   return 1 ;
 }

-//-------------------------------------------------------------------------------
-static int
-LuaAutoNestSetShearGap( lua_State* L)
-{
-  // 1 parametro : dShearGap
-   double dShearGap ;
-   LuaCheckParam( L, 1, dShearGap)
-   LuaClearStack( L) ;
-  // imposto shear gap
-   bool bOk = ExeAutoNestSetShearGap( dShearGap) ;
-  // restituisco il risultato
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
 //-------------------------------------------------------------------------------
 static int
 LuaAutoNestSetReportFile( lua_State* L)
@@ -481,28 +466,6 @@ LuaAutoNestGetOneResult( lua_State* L)
   }
 }

-//-------------------------------------------------------------------------------
-static int
-LuaAutoNestCalcShearSequence( lua_State* L)
-{
-  // 1 parametro : nNesting
-   int nNesting ;
-   LuaCheckParam( L, 1, nNesting)
-   LuaClearStack( L) ;
-  // calcolo shear sequence
-   PNTVECTOR vPtStart, vPtEnd ;   
-   bool bOk = ExeAutoNestCalcShearSequence( nNesting, vPtStart, vPtEnd) ;
-  // restituisco il risultato
-   LuaSetParam( L, bOk) ;
-   if ( bOk) {      
-      LuaSetParam( L, vPtStart) ;
-      LuaSetParam( L, vPtEnd) ;      
-      return 3 ;
-   }
-   else
-      return 1 ;
-}
-
 //-------------------------------------------------------------------------------
 bool
 LuaInstallNesting( LuaMgr& luaMgr)
@@ -525,7 +488,6 @@ LuaInstallNesting( LuaMgr& luaMgr)
   bOk = bOk && luaMgr.RegisterFunction( "EgtAutoNestSetStripYconstraintToPart", LuaAutoNestSetStripYconstraintToPart) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtAutoNestSetStripXconstraintToPart", LuaAutoNestSetStripXconstraintToPart) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtAutoNestSetInterpartGap", LuaAutoNestSetInterpartGap) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtAutoNestSetShearGap", LuaAutoNestSetShearGap) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtAutoNestSetReportFile", LuaAutoNestSetReportFile) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtAutoNestCompute", LuaAutoNestCompute) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtAutoNestCancelComputation", LuaAutoNestCancelComputation) ;
@@ -533,7 +495,6 @@ LuaInstallNesting( LuaMgr& luaMgr)
   bOk = bOk && luaMgr.RegisterFunction( "EgtAutoNestPrintResults", LuaAutoNestPrintResults) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtAutoNestGetResults", LuaAutoNestGetResults) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtAutoNestGetOneResult", LuaAutoNestGetOneResult) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtAutoNestCalcShearSequence", LuaAutoNestCalcShearSequence) ;
   
   return bOk ;
 }
@@ -1,234 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2025-2025
-//----------------------------------------------------------------------------
-// File : LUA_Redis.cpp       Data : 17.09.25        Versione : 2.7i3
-// Contenuto : Funzioni per interfacciarsi con server Redis.
-//
-//
-//
-// Modifiche : 17.09.25 RE Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-//--------------------------- Include ----------------------------------------
-#include "stdafx.h"
-#include "LUA.h"
-#include "/EgtDev/Include/EXeExecutor.h"
-#include "/EgtDev/Include/EGkLuaAux.h"
-
-using namespace std ;
-
-//-------------------------------------------------------------------------------
-static int
-LuaRedisConnect( lua_State* L)
-{
-  // 1 parametro : sConnection
-   string sConnection ;
-   LuaCheckParam( L, 1, sConnection)
-   LuaClearStack( L) ;
-  // Imposto la connessione
-   int nIdConnection = 0 ;
-   bool bOk = ExeRedisConnect( sConnection, nIdConnection) ;
-  // Restituisco il risultato
-   LuaSetParam( L, bOk) ;
-   LuaSetParam( L, nIdConnection) ;
-   return 2 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaRedisDisconnect( lua_State* L)
-{
-  // 1 parametro : nIdConnection
-   int nIdConnection = 0 ;
-   LuaCheckParam( L, 1, nIdConnection) ;
-   LuaClearStack( L) ;
-  // Imposto la connessione
-   bool bOk = ExeRedisDisconnect( nIdConnection) ;
-  // Restituisco il risultato
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaRedisSetValFromKey( lua_State* L)
-{
-  // 3 parametri : nIdConnection, sKey, sVal
-   int nIdConnection = 0 ;
-   LuaCheckParam( L, 1, nIdConnection) ;
-   string sKey ;
-   LuaCheckParam( L, 2, sKey) ;
-   string sVal ;
-   LuaCheckParam( L, 3, sVal) ;
-   LuaClearStack( L) ;
-  // Imposto il valore della chiave
-   bool bOk = ExeRedisSetValFromKey( nIdConnection, sKey, sVal) ;
-  // Restituisco il risultato
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaRedisGetValFromKey( lua_State* L)
-{
-  // 2 parametri : nIdConnection, sKey
-   int nIdConnection = 0 ;
-   LuaCheckParam( L, 1, nIdConnection) ;
-   string sKey ;
-   LuaCheckParam( L, 2, sKey)
-   LuaClearStack( L) ;
-  // Recupero il valore della chiave
-   string sVal, sType ;
-   bool bOk = ExeRedisGetValFromKey( nIdConnection, sKey, sVal) ;
-  // Restituisco il risultato
-   LuaSetParam( L, bOk) ;
-   LuaSetParam( L, sVal) ;
-   return 2 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaRedisAsyncConnect( lua_State* L)
-{
-  // 2 parametri : sConnection
-   string sConnection ;
-   LuaCheckParam( L, 1, sConnection)
-   LuaClearStack( L) ;
-  // Imposto la connessione
-   int nIdConnection = -1 ;
-   bool bOk = ExeRedisAsyncConnect( sConnection, nIdConnection) ;
-  // Restituisco il risultato
-   LuaSetParam( L, bOk) ;
-   LuaSetParam( L, nIdConnection) ;
-   return 2 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaRedisAsyncDiconnect( lua_State* L)
-{
-  // 1 parametro : nIdConnection
-   int nIdConnection = 0 ;
-   LuaCheckParam( L, 1, nIdConnection) ;
-   LuaClearStack( L) ;
-  // Imposto la connessione
-   bool bOK = ExeRedisAsyncDisconnect( nIdConnection) ;
-  // Restituisco il risultato
-   LuaSetParam( L, bOK) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaRedisAsyncPublish( lua_State* L)
-{
-  // 3 parametri : nIdConnection, sChannel, sMessage
-   int nIdConnection = 0 ;
-   LuaCheckParam( L, 1, nIdConnection) ;
-   string sChannel ;
-   LuaCheckParam( L, 2, sChannel) ;
-   string sMessage ;
-   LuaCheckParam( L, 3, sMessage) ;
-   LuaClearStack( L) ;
-  // Pubblico il messaggio sul canale
-   bool bOk = ExeRedisAsyncPublish( nIdConnection, sChannel, sMessage) ;
-  // Restituisco il risultato
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
-//--------------------------------------------------------------------------------
-static int
-LuaRedisAsyncSubscribe( lua_State* L)
-{
-  // 2 parametri : nIdConnection, sChannel
-   int nIdConnection = 0 ;
-   LuaCheckParam( L, 1, nIdConnection) ;
-   string sChannel ;
-   LuaCheckParam( L, 2, sChannel) ;
-   LuaClearStack( L) ;
-  // Iscrizione al canale
-   bool bOk = ExeRedisAsyncSubscribe( nIdConnection, sChannel) ;
-  // Restituisco il risultato
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
-//--------------------------------------------------------------------------------
-static int
-LuaRedisAsyncUnsubscribe( lua_State* L)
-{
-  // 2 parametri : nIdConnection, sChannel
-   int nIdConnection = 0 ;
-   LuaCheckParam( L, 1, nIdConnection) ;
-   string sChannel ;
-   LuaCheckParam( L, 2, sChannel) ;
-   LuaClearStack( L) ;
-  // Disiscrizione
-   bool bOk = ExeRedisAsyncUnsubscribe( nIdConnection, sChannel) ;
-  // Restituisco il risultato
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaRedisAsyncSubscribeOneMessage( lua_State* L)
-{
-  // 3 parametri : nIdConnection, sChannel, dMaxTimeOut
-   int nIdConnection = 0 ;
-   LuaCheckParam( L, 1, nIdConnection) ;
-   string sChannel ;
-   LuaCheckParam( L, 2, sChannel) ;
-   double dMaxTimeOut = 0. ;
-   LuaCheckParam( L, 3, dMaxTimeOut) ;
-   LuaClearStack( L) ;
-  // Eseguo funzione speciale di iscrizione - attesa messaggio - disiscrizione
-   string sMessage ;
-   bool bOk = ExeRedisAsyncSubscribeOneMessage( nIdConnection, sChannel, dMaxTimeOut, sMessage) ;
-  // Restituisco il risultato
-   LuaSetParam( L, bOk) ;
-   LuaSetParam( L, sMessage) ;
-   return 2 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaRedisAsyncGetMessage( lua_State* L)
-{
-   int nIdConnection = 0 ;
-   LuaCheckParam( L, 1, nIdConnection) ;
-   string sChannel ;
-   LuaCheckParam( L, 2, sChannel) ;
-  // Eseguo la funzione per leggere il messaggio
-   int nCount = 0 ;
-   string sMessage ;
-   bool bOk = ExeRedisAsyncGetMessage( nIdConnection, sChannel, nCount, sMessage) ;
-  // Restituisco il risultato
-   LuaSetParam( L, bOk) ;
-   LuaSetParam( L, nCount) ;
-   LuaSetParam( L, sMessage) ;
-   return 3 ;
-}
-
-//-------------------------------------------------------------------------------
-bool
-LuaInstallRedis( LuaMgr& luaMgr)
-{
-   bool bOk = ( &luaMgr != nullptr) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtRedisConnect", LuaRedisConnect) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtRedisDisconnect", LuaRedisDisconnect) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtRedisSetValFromKey", LuaRedisSetValFromKey) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtRedisGetValFromKey", LuaRedisGetValFromKey) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtRedisAsyncConnect", LuaRedisAsyncConnect) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtRedisAsyncDisconnect", LuaRedisAsyncDiconnect) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtRedisAsyncPublish", LuaRedisAsyncPublish) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtRedisAsyncSubscribe", LuaRedisAsyncSubscribe) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtRedisAsyncUnsubscribe", LuaRedisAsyncUnsubscribe) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtRedisAsyncSubscribeOneMessage", LuaRedisAsyncSubscribeOneMessage) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtRedisAsyncGetMessage", LuaRedisAsyncGetMessage) ;
-   return bOk ;
-}
@@ -73,19 +73,6 @@ LuaDraw( lua_State* L)
   return 1 ;
 }

-//-------------------------------------------------------------------------------
-static int
-LuaRedraw( lua_State* L)
-{
-  // nessun parametro
-   LuaClearStack( L) ;
-  // forzo ridisegno
-   bool bOk = ExeRedraw() ;
-  // restituisco il risultato
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
 //-------------------------------------------------------------------------------
 static int
 LuaSetShowMode( lua_State* L)
@@ -188,21 +175,6 @@ LuaZoomObject( lua_State* L)
   return 1 ;
 }

-//-------------------------------------------------------------------------------
-static int
-LuaSetViewOrizzOffsStep( lua_State* L)
-{
-  // 1 parametro : nDirOffsStep
-   int nDirOffsStep ;
-   LuaCheckParam( L, 1, nDirOffsStep)
-   LuaClearStack( L) ;
-  // imposto offset angolare orizzontale a step di 90° per direzione di vista
-   bool bOk = ExeSetViewOrizzOffsStep( nDirOffsStep) ;
-  // restituisco il risultato
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
 //-------------------------------------------------------------------------------
 static int
 LuaSetView( lua_State* L)
@@ -256,60 +228,6 @@ LuaSetViewCenter( lua_State* L)
   return 1 ;
 }

-//-------------------------------------------------------------------------------
-static int
-LuaGetViewOrizzOffsStep( lua_State* L)
-{
-  // nessun parametro
-   LuaClearStack( L) ;
-  // recupero offset angolare orizzontale a step di 90° per direzione di vista
-   int nDirOffsStep ;
-   bool bOk = ExeGetViewOrizzOffsStep( &nDirOffsStep) ;
-  // restituisco il risultato
-   if ( bOk)
-      LuaSetParam( L, nDirOffsStep) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaGetView( lua_State* L)
-{
-  // nessun parametro
-   LuaClearStack( L) ;
-  // recupero direzione di vista
-   int nViewDir ;
-   bool bOk = ExeGetView( &nViewDir) ;
-  // restituisco il risultato
-   if ( bOk)
-      LuaSetParam( L, nViewDir) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaGetGenericView( lua_State* L)
-{
-  // nessun parametro
-   LuaClearStack( L) ;
-  // recupero angoli della direzione di vista
-   double dAngVertDeg ;
-   double dAngHorizDeg ;
-   bool bOk = ExeGetGenericView( &dAngVertDeg, &dAngHorizDeg) ;
-  // restituisco il risultato
-   if ( bOk) {
-      LuaSetParam( L, dAngVertDeg) ;
-      LuaSetParam( L, dAngHorizDeg) ;  
-   }
-   else
-      LuaSetParam( L) ;
-   return 2 ;
-}
-
 //-------------------------------------------------------------------------------
 static int
 LuaGetImage( lua_State* L)
@@ -335,82 +253,23 @@ LuaGetImage( lua_State* L)
   return 1 ;
 }

-//-------------------------------------------------------------------------------
-static int
-LuaGetImageEx( lua_State* L)
-{
-  // 11 argomenti : nDriver, b2Buff, nColorBits, nDepthBits, nShowMode, colBackTop, colBackBottom, nCameraDir, nWidth, nHeight, sFile
-   int nDriver ;
-   LuaCheckParam( L, 1, nDriver)
-   bool b2Buff ;
-   LuaCheckParam( L, 2, b2Buff)
-   int nColorBits ;
-   LuaCheckParam( L, 3, nColorBits)
-   int nDepthBits ;
-   LuaCheckParam( L, 4, nDepthBits)
-   int nShowMode ;
-   LuaCheckParam( L, 5, nShowMode)
-   Color colBackTop ;
-   LuaCheckParam( L, 6, colBackTop)
-   Color colBackBottom ;
-   LuaCheckParam( L, 7, colBackBottom)
-   int nCameraDir ;
-   LuaCheckParam( L, 8, nCameraDir)
-   int nWidth ;
-   LuaCheckParam( L, 9, nWidth)
-   int nHeight ;
-   LuaCheckParam( L, 10, nHeight)
-   string sFile ;
-   LuaCheckParam( L, 11, sFile)
-   LuaClearStack( L) ;
-  // creo e salvo una immagine della scena
-   bool bOk = ExeGetImageEx( nDriver, b2Buff, nColorBits, nDepthBits, nShowMode,
-                             colBackTop, colBackBottom, nCameraDir, nWidth, nHeight, sFile) ;
-  // restituisco il risultato
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaSetShowSurfBezierTol( lua_State* L)
-{
-   // 1 o 2 argomenti : dLinTol [, bRedraw]
-   double dLinTol ;
-   LuaCheckParam( L, 1, dLinTol)
-   bool bRedraw = true ;
-   LuaCheckParam( L, 2, bRedraw)
-   bool bOk = ExeSetShowSurfBezierTol( dLinTol, bRedraw) ;
-
-   // restituisco il risultato
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
 //-------------------------------------------------------------------------------
 bool
 LuaInstallScene( LuaMgr& luaMgr)
 {
-   bool bOk = true ;
+   bool bOk = ( &luaMgr != nullptr) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSetBackground", LuaSetBackground) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetBackground", LuaGetBackground) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtDraw", LuaDraw) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtRedraw", LuaRedraw) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSetShowMode", LuaSetShowMode) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSetShowCurveDirection", LuaSetShowCurveDirection) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSetShowTriaAdv", LuaSetShowTriaAdv) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtZoomRadius", LuaZoomRadius) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtZoom", LuaZoom) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtZoomObject", LuaZoomObject) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSetViewOrizzOffsStep", LuaSetViewOrizzOffsStep) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSetView", LuaSetView) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSetGenericView", LuaSetGenericView) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSetViewCenter", LuaSetViewCenter) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtGetViewOrizzOffsStep", LuaGetViewOrizzOffsStep) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtGetView", LuaGetView) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtGetGenericView", LuaGetGenericView) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetImage", LuaGetImage) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtGetImageEx", LuaGetImageEx) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSetShowSurfBezierTol", LuaSetShowSurfBezierTol) ;
   return bOk ;
 }
@@ -160,7 +160,7 @@ LuaSpSetZzOwStep( lua_State* L)
   LuaCheckParam( L, 1, dStep)
   LuaClearStack( L) ;
  // imposto lo step per tipologie ZigZag e OneWay
-   bool bOk = ExeSpSetZzOwStep( dStep) ;
+   bool bOk = ExeSpSetZzOwStep( dStep) ; 
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
@@ -1,204 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2024-2024
-//----------------------------------------------------------------------------
-// File : LUA_TestObjSurface.cpp       Data : 24.03.24      Versione : 2.6c2
-// Contenuto : Funzioni di verifica intersezione tra oggetti e superfici.
-//             Oggetti = Box, Sfere, Cilindri, Coni, RectPrismoid, SurfTriMesh
-//             Superfici = SurfTriMesh, ( Bezier).
-//
-// Modifiche : 24.03.24 DS Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-//--------------------------- Include ----------------------------------------
-#include "stdafx.h"
-#include "LUA.h"
-#include "/EgtDev/Include/EXeExecutor.h"
-#include "/EgtDev/Include/EXeConst.h"
-#include "/EgtDev/Include/EGkLuaAux.h"
-#include "/EgtDev/Include/EGnStringUtils.h"
-
-using namespace std ;
-
-//-------------------------------------------------------------------------------
-static int
-LuaTestBoxSurface( lua_State* L)
-{
-  // 4 o 5 parametri : frBox, vtDiag, nSurfId, dSafeDist [, nRefType]
-   Frame3d frBox ;
-   LuaCheckParam( L, 1, frBox)
-   Vector3d vtDiag ;
-   LuaCheckParam( L, 2, vtDiag)
-   int nSurfId ;
-   LuaCheckParam( L, 3, nSurfId)
-   double dSafeDist ;
-   LuaCheckParam( L, 4, dSafeDist)
-   int nRefType = RTY_DEFAULT ;
-   LuaGetParam( L, 5, nRefType) ;
-   LuaClearStack( L) ;
-  // eseguo verifica di collisione
-   int nRes = ExeTestBoxSurface( frBox, vtDiag, nSurfId, dSafeDist, nRefType) ;
-  // restituisco il risultato
-   if ( nRes >= 0)
-      LuaSetParam( L, ( nRes != 0)) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaTestRectPrismoidSurface( lua_State* L)
-{
-  // 8 o 9 parametri : frBox, dBaseLenX, dBaseLenY, dTopLenX, dTopLenY, dHeight, nSurfId, dSafeDist [, nRefType]
-   Frame3d frBox ;
-   LuaCheckParam( L, 1, frBox)
-   double dBaseLenX ;
-   LuaCheckParam( L, 2, dBaseLenX)
-   double dBaseLenY ;
-   LuaCheckParam( L, 3, dBaseLenY)
-   double dTopLenX ;
-   LuaCheckParam( L, 4, dTopLenX)
-   double dTopLenY ;
-   LuaCheckParam( L, 5, dTopLenY)
-   double dHeight ;
-   LuaCheckParam( L, 6, dHeight)
-   int nSurfId ;
-   LuaCheckParam( L, 7, nSurfId)
-   double dSafeDist ;
-   LuaCheckParam( L, 8, dSafeDist)
-   int nRefType = RTY_DEFAULT ;
-   LuaGetParam( L, 9, nRefType) ;
-   LuaClearStack( L) ;
-  // eseguo verifica di collisione
-   int nRes = ExeTestRectPrismoidSurface( frBox, dBaseLenX, dBaseLenY, dTopLenX, dTopLenY, dHeight, nSurfId, dSafeDist, nRefType) ;
-  // restituisco il risultato
-   if ( nRes >= 0)
-      LuaSetParam( L, ( nRes != 0)) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaTestCylSurface( lua_State* L)
-{
-  // 5 o 6 parametri : frCyl, dR, dH, nSurfId, dSafeDist [, nRefType]
-   Frame3d frCyl ;
-   LuaCheckParam( L, 1, frCyl)
-   double dR ;
-   LuaCheckParam( L, 2, dR)
-   double dH ;
-   LuaCheckParam( L, 3, dH)
-   int nSurfId ;
-   LuaCheckParam( L, 4, nSurfId)
-   double dSafeDist ;
-   LuaCheckParam( L, 5, dSafeDist)
-   int nRefType = RTY_DEFAULT ;
-   LuaGetParam( L, 6, nRefType) ;
-   LuaClearStack( L) ;
-  // eseguo verifica di collisione
-   int nRes = ExeTestCylSurface( frCyl, dR, dH, nSurfId, dSafeDist, nRefType) ;
-  // restituisco il risultato
-   if ( nRes >= 0)
-      LuaSetParam( L, ( nRes != 0)) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaTestConeSurface( lua_State* L)
-{
-  // 6 o 7 parametri : frCone, dR1, dR2, dH, nSurfId, dSafeDist [, nRefType]
-   Frame3d frCone ;
-   LuaCheckParam( L, 1, frCone)
-   double dR1 ;
-   LuaCheckParam( L, 2, dR1)
-   double dR2 ;
-   LuaCheckParam( L, 3, dR2)
-   double dH ;
-   LuaCheckParam( L, 4, dH)
-   int nSurfId ;
-   LuaCheckParam( L, 5, nSurfId)
-   double dSafeDist ;
-   LuaCheckParam( L, 6, dSafeDist)
-   int nRefType = RTY_DEFAULT ;
-   LuaGetParam( L, 7, nRefType) ;
-   LuaClearStack( L) ;
-  // eseguo verifica di collisione
-   int nRes = ExeTestConeSurface( frCone, dR1, dR2, dH, nSurfId, dSafeDist, nRefType) ;
-  // restituisco il risultato
-   if ( nRes >= 0)
-      LuaSetParam( L, ( nRes != 0)) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
-//----------------------------------------------------------------------------
-static int
-LuaTestSpheSurface( lua_State* L)
-{
-  // 4 o 5 parametri : ptCen, dRad, nSurfId, dSafeDist [, nRefType]
-   Point3d ptCen ;
-   LuaCheckParam( L, 1, ptCen)
-   double dR ;
-   LuaCheckParam( L, 2, dR)
-   int nSurfId ;
-   LuaCheckParam( L, 3, nSurfId)
-   double dSafeDist ;
-   LuaCheckParam( L, 4, dSafeDist)
-   int nRefType = RTY_DEFAULT ;
-   LuaGetParam( L, 5, nRefType) ;
-   LuaClearStack( L) ;
-  // eseguo verifica di collisione
-   int nRes = ExeTestSpheSurface( ptCen, dR, nSurfId, dSafeDist, nRefType) ;
-  // restituisco il risultato
-   if ( nRes >= 0)
-      LuaSetParam( L, ( nRes != 0)) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
-//----------------------------------------------------------------------------
-static int
-LuaTestSurfaceSurface( lua_State* L)
-{
-  // 3 o 4 parametri : nSurf1Id, nSurf2Id, dSafeDist [, bTestEnclusion]
-   int nSurf1Id ;
-   LuaCheckParam( L, 1, nSurf1Id)
-   int nSurf2Id ;
-   LuaCheckParam( L, 2, nSurf2Id)
-   double dSafeDist ;
-   LuaCheckParam( L, 3, dSafeDist)
-   bool bTestEnclusion = false ;
-   LuaGetParam( L, 4, bTestEnclusion) ;
-   LuaClearStack( L) ;
-  // eseguo verifica di interferenza
-   int nRes = ExeTestSurfaceSurface( nSurf1Id, nSurf2Id, dSafeDist, bTestEnclusion) ;
-  // restituisco il risultato
-   if ( nRes >= 0)
-      LuaSetParam( L, ( nRes != 0)) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-bool
-LuaInstallTestObjSurface( LuaMgr& luaMgr)
-{
-   bool bOk = ( &luaMgr != nullptr) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtTestBoxSurface", LuaTestBoxSurface) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtTestRectPrismoidSurface", LuaTestRectPrismoidSurface) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtTestCylSurface", LuaTestCylSurface) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtTestConeSurface", LuaTestConeSurface) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtTestSpheSurface", LuaTestSpheSurface) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtTestSurfaceSurface", LuaTestSurfaceSurface) ;
-   return bOk ;
-}
@@ -1,326 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2025-2025
-//----------------------------------------------------------------------------
-// File : LUA_Trimming.cpp       Data : 23.10.25      Versione : 2.7j3
-// Contenuto : Funzioni per le lavorazioni di Trimming.
-//
-// Modifiche : 23.10.25 RE Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-//--------------------------- Include ----------------------------------------
-#include "stdafx.h"
-#include "LUA.h"
-#include "/EgtDev/Include/EXeExecutor.h"
-#include "/EgtDev/Include/EXeConst.h"
-#include "/EgtDev/Include/EGkLuaAux.h"
-#include "/EgtDev/Include/EGnStringUtils.h"
-
-using namespace std ;
-
-// ------------------------------------------------------------------------------
-static int
-LuaTrimmingGetHoleBorder( lua_State* L)
-{
-  // 7 parametri : nPartId, vSurfIds, vOtherSurfIds, dSurfLinTol, dSurfAngTol, dEdgeLinTol, dEdgeAngTol, dEdgeThick
-   int nParentId ;
-   LuaCheckParam( L, 1, nParentId) ;
-   INTVECTOR vSurfIds ;
-   LuaCheckParam( L, 2, vSurfIds) ;
-   INTVECTOR vOtherSurfIds ;
-   LuaCheckParam( L, 3, vOtherSurfIds) ;
-   double dSurfLinTol ;
-   LuaCheckParam( L, 4, dSurfLinTol) ;
-   double dSurfAngTol ;
-   LuaCheckParam( L, 5, dSurfAngTol) ;
-   double dEdgeLinTol ;
-   LuaCheckParam( L, 6, dEdgeLinTol) ;
-   double dEdgeAngTol ;
-   LuaCheckParam( L, 7, dEdgeAngTol) ;
-   double dEdgeThick ;
-   LuaCheckParam( L, 8, dEdgeThick) ;
-   LuaClearStack( L) ;
-  // Recupero le Curve per Asole e Fori
-   int nFirstId = GDB_ID_NULL, nCount = 0 ;
-   bool bOk = ExeTrimmingGetHoleBorder( nParentId, vSurfIds, vOtherSurfIds, dSurfLinTol, dSurfAngTol, dEdgeLinTol,
-                                        dEdgeAngTol, dEdgeThick, nFirstId, nCount) ;
-   LuaSetParam( L, bOk) ;
-   LuaSetParam( L, nFirstId) ;
-   LuaSetParam( L, nCount) ;
-   return 3 ;
-}
-
-// ------------------------------------------------------------------------------
-static int
-LuaTrimmingGetSurfTmFaceAdj( lua_State* L)
-{
-  // 7 parametri : nParentId, nSurfId, nTria, ptTria, dAngTol, dSize, dSizeTol
-   int nParentId ;
-   LuaCheckParam( L, 1, nParentId) ;
-   int nSurfId ;
-   LuaCheckParam( L, 2, nSurfId)
-   int nTria ;
-   LuaCheckParam( L, 3, nTria)
-   Point3d ptTria ;
-   LuaCheckParam( L, 4, ptTria)
-   double dAngTol ;
-   LuaCheckParam( L, 5, dAngTol)
-   double dSize ;
-   LuaCheckParam( L, 6, dSize)
-   double dSizeTol ;
-   LuaCheckParam( L, 7, dSizeTol)
-   LuaClearStack( L) ;
-  // Recupero le facce adiacenti in tolleranza angolare
-   INTVECTOR vOtherFaces ;
-   int nNewSurfId = ExeTrimmingGetSurfTmFaceAdj( nParentId, nSurfId, nTria, ptTria, dAngTol, dSize, dSizeTol) ;
-   LuaSetParam( L, nNewSurfId) ;
-   return 1 ;
-}
-
-// ------------------------------------------------------------------------------
-static int
-LuaTrimmingGetAdjSurfs( lua_State* L)
-{
-  // 5 parametri : nRefSfrId, vAllSurfId, dLinTol, dAngTol, dAngFaceTol
-   INTVECTOR vRefSurfId ;
-   LuaCheckParam( L, 1, vRefSurfId)
-   INTVECTOR vOtherSurfId ;
-   LuaCheckParam( L, 2, vOtherSurfId)
-   double dLinTol ;
-   LuaCheckParam( L, 3, dLinTol)
-   double dAngTol ;
-   LuaCheckParam( L, 4, dAngTol)
-   double dAngFaceTol ;
-   LuaCheckParam( L, 5, dAngFaceTol)
-   LuaClearStack( L) ;
-  // Calcolo le facce adiacenti per tolleranza
-   INTVECTOR vOtherSurf ;
-   bool bOk = ExeTrimmingGetAdjSurfs( vRefSurfId, vOtherSurfId, dLinTol, dAngTol, dAngFaceTol, vOtherSurf) ;
-  // Restituisco il risultato
-   LuaSetParam( L, bOk) ;
-   LuaSetParam( L, vOtherSurf) ;
-   return 2 ;
-}
-
-// -------------------------------------------------------------------------------
-static int
-LuaTrimmingGetBorders( lua_State* L)
-{
-  // 6 parametri : nParentId, vIds, dSurfLinTol, dSurfAngTol, dLinTol, dAngTol
-   int nParentId ;
-   LuaCheckParam( L, 1, nParentId)
-   SELVECTOR vIds ;
-   LuaCheckParam( L, 2, vIds)
-   double dSurfLinTol ;
-   LuaCheckParam( L, 3, dSurfLinTol) ;
-   double dSurfAngTol ;
-   LuaCheckParam( L, 4, dSurfAngTol) ;
-   double dLinTol ;
-   LuaCheckParam( L, 5, dLinTol)
-   double dAngTol ;
-   LuaCheckParam( L, 6, dAngTol)
-   LuaClearStack( L) ;
-  // Creo le curve di Edge grezze
-   int nFirstId = GDB_ID_NULL ;
-   int nCount = 0 ;
-   bool bOk = ExeTrimmingGetBorders( nParentId, vIds, dSurfLinTol, dSurfAngTol, dLinTol, dAngTol, nFirstId, nCount) ;
-   LuaSetParam( L, bOk) ;
-   LuaSetParam( L, nFirstId) ;
-   LuaSetParam( L, nCount) ;
-   return 3 ;
-}
-
-// -------------------------------------------------------------------------------
-static int
-LuaTrimmingGetBordersByNormals( lua_State* L)
-{
-  // 7 o 8 parametri : nParentId, vIds, dSurfLinTol, dSurfAngTol, dThickness
-   int nParentId ;
-   LuaCheckParam( L, 1, nParentId)
-   SELVECTOR vIds ;
-   LuaCheckParam( L, 2, vIds)
-   double dSurfLinTol ;
-   LuaCheckParam( L, 3, dSurfLinTol) ;
-   double dSurfAngTol ;
-   LuaCheckParam( L, 4, dSurfAngTol) ;
-   double dLinTol ;
-   LuaCheckParam( L, 5, dLinTol)
-   double dAngTol ;
-   LuaCheckParam( L, 6, dAngTol)
-   double dThickness ;
-   LuaCheckParam( L, 7, dThickness)
-   LuaClearStack( L) ;
-  // Creo le curve di Edge grezze
-   int nFirstId = GDB_ID_NULL ;
-   int nCount = 0 ;
-   bool bOk = ExeTrimmingGetBordersByNormals( nParentId, vIds, dSurfLinTol, dSurfAngTol, dLinTol, dAngTol, dThickness, nFirstId, nCount) ;
-   LuaSetParam( L, bOk) ;
-   LuaSetParam( L, nFirstId) ;
-   LuaSetParam( L, nCount) ;
-   return 3 ;
-}
-
-// -------------------------------------------------------------------------------
-static int
-LuaTrimmingGetFinalBorders( lua_State* L)
-{
-  // 4 o 5 o 6 o 7 parametri : nParentId, vCrvBezierId, dLinTol, dAngTol [,vBreakingPts] [,dThick [,dThickTol]]
-   int nParentId ;
-   LuaCheckParam( L, 1, nParentId)
-   INTVECTOR vCrvBezierId ;
-   LuaCheckParam( L, 2, vCrvBezierId)
-   double dLinTol ;
-   LuaCheckParam( L, 3, dLinTol)
-   double dAngTol ;
-   LuaCheckParam( L, 4, dAngTol)
-   PNTVECTOR vBreakingPts ;
-   int nInd = 5 ;
-   if ( LuaGetParam( L, nInd, vBreakingPts))
-      ++ nInd ;
-   double dThick = 0., dThickTol = EPS_SMALL ;
-   if ( LuaGetParam( L, nInd, dThick)) {
-      if ( ! LuaGetParam( L, nInd + 1, dThickTol)) {
-         LuaClearStack( L) ;
-         LuaSetParam( L, false) ;
-         return 1 ;
-      }
-   }
-   LuaClearStack( L) ;
-  // Creo le curve Edges
-   int nFirstId = GDB_ID_NULL ;
-   int nCount = 0 ;
-   bool bOk = ExeTrimmingGetFinalBorders( nParentId, vCrvBezierId, dLinTol, dAngTol, vBreakingPts, dThick, dThickTol,
-                                          nFirstId, nCount) ;
-   LuaSetParam( L, bOk) ;
-   LuaSetParam( L, nFirstId) ;
-   LuaSetParam( L, nCount) ;
-   return 3 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaTrimmingGetRuledBezier( lua_State* L)
-{
-  // 5 o 6 parametri : nParentId, vIds, nEdge1Id, nEdge2Id, dLinTol [,vnLineId]
-   int nParentId ;
-   LuaCheckParam( L, 1, nParentId)
-   INTVECTOR vIds ;
-   LuaCheckParam( L, 2, vIds) ; // serve per orientare la superficie rigata ( Ids delle superfici)
-   int nEdge1Id ;
-   LuaCheckParam( L, 3, nEdge1Id)
-   int nEdge2Id ;
-   LuaCheckParam( L, 4, nEdge2Id)
-   double dLinTol ;
-   LuaCheckParam( L, 5, dLinTol)
-   INTVECTOR vnLineId ;
-   LuaGetParam( L, 6, vnLineId) ;
-   LuaClearStack( L) ;
-  // Calcolo la superficie di Bezier rigata
-   int nId = ExeTrimmingGetRuledBezier( nParentId, vIds, nEdge1Id, nEdge2Id, dLinTol, vnLineId) ;
-   LuaSetParam( L, nId) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaTrimmingInterpolateSyncLines( lua_State* L)
-{
-  // 7 parametri : nParentId, nFirstSyncId, nSecondSyncId, nBorder1Id, nBorder2Id, dEdgeLinTol, dEdgeAngTol
-   int nParentId ;
-   LuaCheckParam( L, 1, nParentId) ;
-   int nSync1Id ;
-   LuaCheckParam( L, 2, nSync1Id) ;
-   int nSync2Id ;
-   LuaCheckParam( L, 3, nSync2Id) ;
-   int nBorder1Id ;
-   LuaCheckParam( L, 4, nBorder1Id) ;
-   int nBorder2Id ;
-   LuaCheckParam( L, 5, nBorder2Id) ;
-   double dEdgeLinTol ;
-   LuaCheckParam( L, 6, dEdgeLinTol) ;
-   double dEdgeAngTol ;
-   LuaCheckParam( L, 7, dEdgeAngTol) ;
-   LuaClearStack( L) ;
-  // Interpolo le curve di sincronizzazione
-   int nFirstId = GDB_ID_NULL ;
-   int nCount = 0 ;
-   bool bOk = ExeTrimmingInterpolateSyncLines( nParentId, nSync1Id, nSync2Id, nBorder1Id,
-                                               nBorder2Id, dEdgeLinTol, dEdgeAngTol, nFirstId, nCount) ;
-   LuaSetParam( L, bOk) ;
-   LuaSetParam( L, nFirstId) ;
-   LuaSetParam( L, nCount) ;
-   return 3 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaTrimmingGetSurfBzSyncPoints( lua_State* L)
-{
-  // 7 parametri : nParentId, nEdge1Id, nEdge2Id, dLinTol, dAngTol, nLinesNbr, bShowOnCorners
-   int nParentId ;
-   LuaCheckParam( L, 1, nParentId)
-   int nEdge1Id ;
-   LuaCheckParam( L, 2, nEdge1Id)
-   int nEdge2Id ;
-   LuaCheckParam( L, 3, nEdge2Id)
-   double dLinTol ;
-   LuaCheckParam( L, 4, dLinTol)
-   double dAngTol ;
-   LuaCheckParam( L, 5, dAngTol)
-   int nLineNbr ;
-   LuaCheckParam( L, 6, nLineNbr)
-   bool bShowOnCorners ;
-   LuaCheckParam( L, 7, bShowOnCorners)
-   LuaClearStack( L) ;
-  // Inserisco i tratti lineari associati ai punti di sincronizzazione
-   int nFirstId = GDB_ID_NULL ;
-   int nCount = 0 ;
-   bool bOk = ExeTrimmingGetSurfBzSyncPoints( nParentId, nEdge1Id, nEdge2Id, dLinTol, dAngTol, nLineNbr, bShowOnCorners, nFirstId, nCount) ;
-   LuaSetParam( L, bOk) ;
-   LuaSetParam( L, nFirstId) ;
-   LuaSetParam( L, nCount) ;
-   return 3 ;
-}
-
-//-------------------------------------------------------------------------------
-static int
-LuaRegolarizeSurfaceLocally( lua_State* L)
-{
-   int nSurfId = GDB_ID_NULL ;
-   LuaCheckParam( L, 1, nSurfId)
-   int nSyncStartId ;
-   LuaCheckParam( L, 2, nSyncStartId)
-   int nSyncEndId ;
-   LuaCheckParam( L, 3, nSyncEndId)
-   double dLinTol ;
-   LuaCheckParam( L, 4, dLinTol)
-   
-   bool bOk = ExeRegolarizeSurfaceLocally( nSurfId, nSyncStartId, nSyncEndId, dLinTol) ;
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
-//-------------------------------------------------------------------------------
-bool
-LuaInstallTrimming( LuaMgr& luaMgr)
-{
-   bool bOk = ( &luaMgr != nullptr) ;
-  // --- Ricerca Fori e Asole
-   bOk = bOk && luaMgr.RegisterFunction( "EgtTrimmingGetHoleBorder", LuaTrimmingGetHoleBorder) ;
-  // --- Ricerca Superifici
-   bOk = bOk && luaMgr.RegisterFunction( "EgtTrimmingGetSurfTmFaceAdj", LuaTrimmingGetSurfTmFaceAdj) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtTrimmingGetAdjSurfs", LuaTrimmingGetAdjSurfs) ;
-  // --- Estrazione dei Bordi
-   bOk = bOk && luaMgr.RegisterFunction( "EgtTrimmingGetBorders", LuaTrimmingGetBorders) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtTrimmingGetBordersByNormals", LuaTrimmingGetBordersByNormals) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtTrimmingGetFinalBorders", LuaTrimmingGetFinalBorders) ;
-  // --- Recupero Surf Bezier Ruled
-   bOk = bOk && luaMgr.RegisterFunction( "EgtTrimmingGetRuledBezier", LuaTrimmingGetRuledBezier) ;
-  // --- Recupero linee di sincronizzazione
-   bOk = bOk && luaMgr.RegisterFunction( "EgtTrimmingInterpolateSyncLines", LuaTrimmingInterpolateSyncLines) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtTrimmingGetSurfBzSyncPoints", LuaTrimmingGetSurfBzSyncPoints) ;
-  // --- Modifica della superficie
-   bOk = bOk && luaMgr.RegisterFunction( "EgtRegolarizeSurfaceLocally", LuaRegolarizeSurfaceLocally) ;
-   return bOk ;
-}
@@ -163,22 +163,8 @@ PictureObj::Load( const STRVECTOR& vString, int nBaseGdbId)
            string sOut = "Error loading image " + sOtherPath ; 
            LOG_ERROR( GetLogger(), sOut.c_str())
         }
-         return true ;
      }
-     // provo dalla path della macchina corrente
-      string sMachineDir ; 
-      if ( ExeGetCurrMachineDir( sMachineDir)) {
-         string sOtherPath = sMachineDir + "\\" + GetFileName( m_sPath) ;
-         if ( ExistsFile( sOtherPath)) {
-            if ( ! ExeLoadTexture( m_sName, sOtherPath, 0, m_dDimX, m_dDimY, TXR_CLAMP)) {
-               string sOut = "Error loading image " + sOtherPath ; 
-               LOG_ERROR( GetLogger(), sOut.c_str())
-            }
-            return true ;
-         }
-      }
-     // altrimenti errore
-      {
+      else {
         string sOut = "Error missing image " + sOtherPath ; 
         LOG_ERROR( GetLogger(), sOut.c_str())
      }
@@ -4,7 +4,6 @@
 //
 #define VS_VERSION_INFO                 1
 #define IDD_LUADLG                      101
-#define IDD_LUASCENE                    102
 #define IDC_TEXT1                       1001
 #define IDC_TEXT2                       1002
 #define IDC_TEXT3                       1003
@@ -37,15 +36,6 @@
 #define IDC_CHECK6                      1036
 #define IDC_CHECK7                      1037
 #define IDC_CHECK8                      1038
-#define IDC_COLOR1                      1041
-#define IDC_COLOR2                      1042
-#define IDC_COLOR3                      1043
-#define IDC_COLOR4                      1044
-#define IDC_COLOR5                      1045
-#define IDC_COLOR6                      1046
-#define IDC_COLOR7                      1047
-#define IDC_COLOR8                      1048
-#define IDC_PICTURE1                    1101

 // Next default values for new objects
 // 
@@ -54,6 +44,6 @@
 #define _APS_NEXT_RESOURCE_VALUE        103
 #define _APS_NEXT_COMMAND_VALUE         40001
 #define _APS_NEXT_CONTROL_VALUE         1030
-#define _APS_NEXT_SYMED_VALUE           115
+#define _APS_NEXT_SYMED_VALUE           113
 #endif
 #endif
@@ -28,10 +28,8 @@

 #include "/EgtDev/Include/EgtLibVer.h"

-#pragma comment( lib, EGTLIBDIR "EgtGeneral" EGTLIBVER ".lib")
-#pragma comment( lib, EGTLIBDIR "EgtNumKernel" EGTLIBVER ".lib")
-#pragma comment( lib, EGTLIBDIR "EgtGeomKernel" EGTLIBVER ".lib")
-#pragma comment( lib, EGTEXTDIR "Lua/Lib/Lua54" EGTLIBVER ".lib")
-#pragma comment( lib, EGTEXTDIR "hiredis/Lib/hiredis" EGTLIBVER ".lib")
-#pragma comment( lib, EGTLIBDIR "SEgtLock" EGTLIBVER ".lib")
-#pragma comment( lib, "ws2_32.lib")
+#pragma comment(lib, EGTLIBDIR "EgtGeneral" EGTLIBVER ".lib")
+#pragma comment(lib, EGTLIBDIR "EgtNumKernel" EGTLIBVER ".lib")
+#pragma comment(lib, EGTLIBDIR "EgtGeomKernel" EGTLIBVER ".lib")
+#pragma comment(lib, EGTEXTDIR "Lua/Lib/Lua54" EGTLIBVER ".lib")
+#pragma comment(lib, EGTLIBDIR "SEgtLock" EGTLIBVER ".lib")
Author	SHA1	Message	Date
Daniele Bariletti	a5a0646ddc	EgtExecutor : - correzione minore a export 3dm.	2023-10-17 11:12:09 +02:00
Daniele Bariletti	b954be810c	EgtExecutor : - aggiunte funzioni per l'Export 3dm.	2023-10-12 11:01:31 +02:00
Daniele Bariletti	8500a0467e	EgtExecutor : - aggiunta del 3dm Export.	2023-10-12 11:01:27 +02:00
Daniele Bariletti	8145b4586c	EgtExecutor : - introdotto l'uso della grafica di default per gli ExtDim importati da 3dm.	2023-10-12 11:01:20 +02:00