EgtExecutor :

- correzione minore a export 3dm.

DllExch3dm.cpp

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

DllExch3dm.h

@@ -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) ;

DllExchange.cpp

@@ -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.
+//             23.06.23 DB Aggiunto Import3dm.
-//             07.11.23 DB Aggiunto Import3dm.
+//             21.09.23 DB Aggiunto Export3dm.
 //
 //----------------------------------------------------------------------------
 
@@ -51,9 +51,11 @@ static const char* EEX_CREATEIMPORTDXF = "CreateImportDxf" ;
 static const char* EEX_CREATEIMPORTPNT = "CreateImportPnt" ;
 static const char* EEX_CREATEIMPORTSTL = "CreateImportStl" ;
 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" ;
@@ -72,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
@@ -92,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
@@ -318,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)
@@ -363,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)

DllExchange.h

@@ -25,9 +25,11 @@ class IImportDxf ;
 class IImportPnt ;
 class IImportStl ;
 class IImport3MF ;
+class IImport3dm ;
 class IExportDxf ;
 class IExportStl ;
 class IExport3MF ;
+class IExport3dm ;
 class IExportThreeJS ;
 class IExportSvg ;
 class IExcExecutor ;
@@ -50,9 +52,11 @@ IImportDxf* MyCreateImportDxf( void) ;
 IImportPnt* MyCreateImportPnt( void) ;
 IImportStl* MyCreateImportStl( 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) ;

EXE_CAvTool.cpp

@@ -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)

EXE_Exchange.cpp

@@ -17,7 +17,6 @@
 #include "EXE_Macro.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"
@@ -29,13 +28,13 @@
 #include "/EgtDev/Include/EExImportPnt.h"
 #include "/EgtDev/Include/EExImportBtl.h"
 #include "/EgtDev/Include/EExImportBtlx.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"
@@ -73,8 +72,6 @@ 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 == "CNC"  ||  sFileExt == "XPI"  ||  sFileExt == "MPF"  ||  sFileExt == "ISO"  ||  sFileExt == "EIA")
@@ -152,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 ;
 }
@@ -185,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 ;
 }
@@ -220,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 ;
 }
@@ -252,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 ;
 }
@@ -287,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 ;
 }
@@ -322,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 ;
 }
@@ -358,11 +325,6 @@ 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 ;
 }
@@ -393,18 +355,13 @@ ExeImport3MF( const string& sFilePath)
                     " -- 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)
@@ -412,6 +369,7 @@ ExeImport3dm( const string& sFilePath)
   // 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) ;
@@ -424,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, nPartId,
+   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())
@@ -432,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 ;
 }
@@ -548,11 +502,6 @@ ExeAdvancedImport( const string& sFilePath, double dToler)
                     " -- 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 ;
 }
@@ -569,7 +518,7 @@ ExeExportDxf( int nId, const string& sFilePath, int nFlag, int nFilter)
    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()) {
@@ -595,7 +544,7 @@ ExeExportStl( int nId, const string& sFilePath, int nFilter)
    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()) {
@@ -620,7 +569,7 @@ ExeExport3MF( int nId, const string& sFilePath, int nFilter)
    PtrOwner<IExport3MF> pExp3MF( MyCreateExport3MF()) ;
    bOk = bOk && ! IsNull( pExp3MF) ;
    // eseguo l'esportazione
-   bOk = bOk && pExp3MF->SetOptions( nFilter) ;
+   pExp3MF->SetOptions( nFilter) ;
    bOk = bOk && pExp3MF->Export( pGeomDB, nId, sFilePath) ;
   // se richiesto, salvo il comando Lua equivalente
    if ( IsCmdLog()) {
@@ -670,7 +619,7 @@ ExeExportSvg( int nId, const string& sFilePath, int nFilter)
    PtrOwner<IExportSvg> pExpSvg( MyCreateExportSvg()) ;
    bOk = bOk && ! IsNull( pExpSvg) ;
    // eseguo l'esportazione
-   bOk = bOk && pExpSvg->SetOptions( nFilter) ;
+   pExpSvg->SetOptions( nFilter) ;
    bOk = bOk && pExpSvg->Export( pGeomDB, nId, sFilePath) ;
   // se richiesto, salvo il comando Lua equivalente
    if ( IsCmdLog()) {

EXE_GdbCreateSurf.cpp

@@ -32,7 +32,7 @@
 #include "/EgtDev/Include/EGkGeoPoint3d.h"
 #include "/EgtDev/Include/EGkCurveLocal.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
-#include "/EgtDev/Include/EGkExtText.h"
+
 using namespace std ;
 
 //-------------------------------------------------------------------------------
@@ -56,7 +56,8 @@ ExeCreateSurfFrRectangle( int nParentId, const Point3d& ptIni, const Point3d& pt
    if ( ( frEnt.VersZ() * vtZL) < 0)
       frEnt.PseudoMirror( frEnt.Orig(), frEnt.VersZ()) ;
   // ricavo le dimensioni della base
-   Point3d ptCrossI = GetToLoc( ptCrossL, frEnt) ;
+   Point3d ptCrossI = ptCrossL ;
+   ptCrossI.ToLoc( frEnt) ;
    double dWidth = ptCrossI.x ;
    double dLen = ptCrossI.y ;
   // creo il rettangolo nel suo riferimento intrinseco
@@ -222,7 +223,7 @@ ExeCreateSurfFrDisk( int nParentId, const Point3d& ptOrig, double dRad, int nRef
 
 //-------------------------------------------------------------------------------
 int
-ExeCreateSurfFrFatCurve( int nParentId, int nCrvId, double dRad, bool bSquaredEnds, bool bSquaredMids, double dLinTol)
+ExeCreateSurfFrFatCurve( int nParentId, int nCrvId, double dRad, bool bSquared)
 {
    IGeomDB* pGeomDB = GetCurrGeomDB() ;
    VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
@@ -245,7 +246,7 @@ ExeCreateSurfFrFatCurve( int nParentId, int nCrvId, double dRad, bool bSquaredEn
   // eseguo la trasformazione (viene eseguita solo se i riferimenti sono diversi
    pCopCrv->LocToLoc( frCrv, frLoc) ;
   // creo la regione
-   PtrOwner<ISurfFlatRegion> pSfr( GetSurfFlatRegionFromFatCurve( Release( pCopCrv), dRad, bSquaredEnds, bSquaredMids, dLinTol)) ;
+   PtrOwner<ISurfFlatRegion> pSfr( GetSurfFlatRegionFromFatCurve( Release( pCopCrv), dRad, bSquared, bSquared)) ;
    bOk = bOk && ! IsNull( pSfr) ;
   // inserisco la superficie nel DB
    int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSfr)) : GDB_ID_NULL) ;
@@ -255,8 +256,7 @@ ExeCreateSurfFrFatCurve( int nParentId, int nCrvId, double dRad, bool bSquaredEn
       string sLua = "EgtSurfFrFatCurve(" + IdToString( nParentId) + "," +
                                            ToString( nCrvId) + "," +
                                            ToString( dRad) + "," +
-                                           ToString( bSquaredEnds) + "," +
+                                           ToString( bSquared) + ")" +
-                                           ToString( bSquaredMids) + ")" +
                     " -- Id=" + ToString( nNewId) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
    }
@@ -863,97 +863,6 @@ ExeCreateSurfTmSphere( int nParentId, const Point3d& ptOrig,
    return nNewId ;
 }
 
-//-------------------------------------------------------------------------------
-int
-ExeCreateSurfTmTriangle( int nParentId, const Point3d& ptP1, const Point3d& ptP2, const Point3d& ptP3, 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 ptP1L = GetPointLocal( pGeomDB, ptP1, nRefType, frLoc) ;
-   Point3d ptP2L = GetPointLocal( pGeomDB, ptP2, nRefType, frLoc) ;
-   Point3d ptP3L = GetPointLocal( pGeomDB, ptP3, nRefType, frLoc) ;
-  // creo la superficie trimesh
-   PtrOwner<ISurfTriMesh> pStm( CreateSurfTriMesh()) ;
-   bOk = bOk && ! IsNull( pStm) ;
-  // assegno il triangolo
-   if ( bOk) {
-      pStm->Init( 3, 1, 1) ;
-      int vV[3]{ pStm->AddVertex( ptP1L),
-                 pStm->AddVertex( ptP2L),
-                 pStm->AddVertex( ptP3L)} ;
-      bOk = ( pStm->AddTriangle( vV) != SVT_NULL) && pStm->AdjustTopology() ;
-   }
-  // inserisco la superficie nel DB
-   int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pStm)) : GDB_ID_NULL) ;
-   ExeSetModified() ;
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtSurfTmTriangle(" + IdToString( nParentId) + ",{" +
-                                           ToString( ptP1) + "},{" +
-                                           ToString( ptP2) + "},{" +
-                                           ToString( ptP3) + "}," +
-                                           RefTypeToString( nRefType) + ")" +
-                    " -- Id=" + ToString( nNewId) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-  // restituisco l'identificativo della nuova entità
-   return nNewId ;
-}
-
-//-------------------------------------------------------------------------------
-int
-ExeCreateSurfTmRectangle( int nParentId, const Point3d& ptO, const Point3d& ptL, const Point3d& ptT, 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 ptOL = GetPointLocal( pGeomDB, ptO, nRefType, frLoc) ;
-   Point3d ptLL = GetPointLocal( pGeomDB, ptL, nRefType, frLoc) ;
-   Point3d ptTL = GetPointLocal( pGeomDB, ptT, nRefType, frLoc) ;
-  // modifico il punto trasversale per metterlo perpendicolare al lato Lungo
-   ptTL -= ParallCompo( ptTL - ptOL, ptLL - ptOL) ;
-  // calcolo il quarto punto
-   Point3d ptVL = ptTL + ( ptLL - ptOL) ;
-  // creo la superficie trimesh
-   PtrOwner<ISurfTriMesh> pStm( CreateSurfTriMesh()) ;
-   bOk = bOk && ! IsNull( pStm) ;
-  // assegno il triangolo
-   if ( bOk) {
-      pStm->Init( 4, 2, 1) ;
-      int vV[4]{ pStm->AddVertex( ptOL),
-                 pStm->AddVertex( ptLL),
-                 pStm->AddVertex( ptTL),
-                 pStm->AddVertex( ptVL)} ;
-      int vV1[3]{ vV[0], vV[1], vV[2] } ;
-      int vV2[3]{ vV[2], vV[1], vV[3] } ;
-      bOk = ( pStm->AddTriangle( vV1) != SVT_NULL) && ( pStm->AddTriangle( vV2) != SVT_NULL) && pStm->AdjustTopology() ;
-   }
-  // inserisco la superficie nel DB
-   int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pStm)) : GDB_ID_NULL) ;
-   ExeSetModified() ;
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtSurfTmRectangle(" + IdToString( nParentId) + ",{" +
-                                            ToString( ptO) + "},{" +
-                                            ToString( ptL) + "},{" +
-                                            ToString( ptT) + "}," +
-                                            RefTypeToString( nRefType) + ")" +
-                    " -- Id=" + ToString( nNewId) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-  // restituisco l'identificativo della nuova entità
-   return nNewId ;
-}
-
 //-------------------------------------------------------------------------------
 int
 ExeCreateSurfTmByFlatContour( int nParentId, int nCrvId, double dLinTol)
@@ -1714,71 +1623,3 @@ ExeCreateSurfBezierRational( int nParentId, int nDegU, int nDegV, int nSpanU, in
   // restituisco l'identificativo della nuova entità
    return nId ;
 }
-
-//-------------------------------------------------------------------------------
-int
-ExeCreateSurfBezierLeaves( int nParentId, int nSurfBzId, int nTextHeight, bool bShowTrim, int* pnCount)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
-   nParentId = AdjustId( nParentId) ;
-  // recupero la superficie
-   const ISurfBezier* pSurfBez = GetSurfBezier( pGeomDB->GetGeoObj( nSurfBzId)) ;
-   if ( pSurfBez == nullptr)
-      return GDB_ID_NULL ;
-  // disegno le foglie
-   vector<tuple<int,Point3d,Point3d>> vLeaves ;
-   pSurfBez->GetLeaves( vLeaves) ;
-   double dFactor = 1 ;
-   int nFirstId = GDB_ID_NULL ;
-   int nCount = 0 ;
-   for ( int k = 0 ; k < (int)vLeaves.size() ; ++ k) {
-      Point3d ptBL = get<1>( vLeaves[k]) * dFactor ;
-      Point3d ptTR = get<2>( vLeaves[k]) * dFactor ;
-      Point3d ptBR( ptTR.x, ptBL.y) ;
-      Point3d ptTL( ptBL.x, ptTR.y) ;
-      PolyLine PL ;
-      PL.AddUPoint( 0, ptBL) ;
-      PL.AddUPoint( 1, ptBR) ;
-      PL.AddUPoint( 2, ptTR) ;
-      PL.AddUPoint( 3, ptTL) ;
-      PL.Close() ;
-     // creo la curva e la inserisco nel GDB
-      PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
-      if ( IsNull( pCrvCompo)  ||  ! pCrvCompo->FromPolyLine( PL)  ||  ! pCrvCompo->SetExtrusion( Z_AX))
-         return GDB_ID_NULL ;
-     // inserisco la curva composita nel DB
-      int nCrvId = pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvCompo)) ;
-      if ( nCrvId == GDB_ID_NULL)
-         return GDB_ID_NULL ;
-      ++ nCount ;
-      if ( nFirstId == GDB_ID_NULL)
-         nFirstId = nCrvId ;
-     // creo il testo e lo riempio
-      string sText = ToString( get<0>( vLeaves[k])) ;
-      Point3d ptCenter( ( ptBL + ptTR) / 2) ;
-      PtrOwner<IExtText> pTXT( CreateExtText()) ;
-      if ( IsNull( pTXT)  ||  ! pTXT->Set( ptCenter, Z_AX, X_AX, sText, "", false, nTextHeight))
-         return GDB_ID_NULL ;
-     // inserisco il testo nel DB
-      int nTxtId = pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pTXT)) ;
-      if ( nTxtId == GDB_ID_NULL)
-         return GDB_ID_NULL ;
-      ++ nCount ;
-   }
-  // se richiesto disegno la regione di trim
-   const ISurfFlatRegion* pSfr = pSurfBez->GetTrimRegion() ;
-   if ( bShowTrim  &&  pSfr != nullptr) {
-      PtrOwner<ISurfFlatRegion> pTrimReg( pSfr->Clone()) ;
-      if ( ! IsNull( pTrimReg)) {
-         int nTrimId = pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pTrimReg)) ;
-         if ( nTrimId == GDB_ID_NULL)
-            return GDB_ID_NULL ;
-         ++ nCount ;
-      }
-   }
-  // restituisco i risultati
-   if ( pnCount != nullptr)
-      *pnCount = nCount ;
-   return nFirstId ;
-}

EXE_GdbGetCurve.cpp

@@ -23,11 +23,9 @@
 #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"
-#include "EgtDev/Include/EGkVoronoi.h"
 
 //----------------------------------------------------------------------------
 bool

EXE_GdbGetPocketing.cpp

@@ -1,150 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2023-2023
-//----------------------------------------------------------------------------
-// File : Exe_GdbGetPocketing.cpp       Data : 28.11.23        Versione : 2.5k6
-// 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/EGkCalcPocketing.h"
-
-using namespace std ;
-
-//----------------------------------------------------------------------------
-bool
-ExePocketing( const int nId, double dRad, double dStep, double dAngle, int nType, bool bSmooth, int nDestGrpId,
-              int& nFirstId, int& nCrvCount)
-{
-  // databse geometrico
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false) ;
-
-  // recupero la FlatRegion per i percorsi
-   const ISurfFlatRegion* pSfr = GetSurfFlatRegion( pGeomDB->GetGeoObj( nId)) ;
-   if ( pSfr == nullptr)
-      return false ;
-
-  // 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 ;
-
-  // costruzione vettori di curve per Pocketing
-   ICRVCOMPOPOVECTOR vCrvCompoRes ;
-
-  // eseguo Pocketing
-   bool bOk = CalcPocketing( pSfr, dRad, dStep, dAngle, nType, bSmooth, vCrvCompoRes) ;
-   nFirstId = GDB_ID_NULL ; // primo Id da restituire
-   nCrvCount = int( vCrvCompoRes.size()) ;
-   if ( bOk  &&  int( vCrvCompoRes.size()) > 0) {
-     // scorro le curve di Pocketing ottenute
-      for ( int u = 0 ; u < int( vCrvCompoRes.size()) ; ++ u) {
-         vCrvCompoRes[u]->LocToLoc( frSfr, frDest) ;
-        // inserisco la curva nel DB Geometrico
-         int nCurrId = pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, Release( vCrvCompoRes[u])) ;
-         if ( nCurrId == GDB_ID_NULL)
-            return false ;
-         if ( u == 0)
-            nFirstId = nCurrId ; // memorizzo il primo Id da restituire
-      }
-      ExeSetModified() ;
-   }
-
-   if ( IsCmdLog()) {
-      string sLua = "EgtPocketing(" + ToString( nId) + "," +
-                                      ToString( dRad) + "," +
-                                      ToString( dStep) + "," +
-                                      ToString( dAngle) + "," +
-                                      ToString( nType) + "," +
-                                      ToString( bSmooth) + "," +
-                                      ToString( nDestGrpId) + ")" +
-                    " -- Ok=" + ToString( bOk) + " 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 ;
-}

EXE_GdbGetSurf.cpp

@@ -21,7 +21,6 @@
 #include "/EgtDev/Include/EXeExecutor.h"
 #include "/EgtDev/Include/EXeConst.h"
 #include "/EgtDev/Include/EGkGeoPoint3d.h"
-#include "/EgtDev/Include/EGkCurveLine.h"
 #include "/EgtDev/Include/EGkCurveBezier.h"
 #include "/EgtDev/Include/EGkCurveComposite.h"
 #include "/EgtDev/Include/EGkCurveLocal.h"
@@ -30,11 +29,6 @@
 #include "/EgtDev/Include/EGkSurfTriMesh.h"
 #include "/EgtDev/Include/EGkSurfBezier.h"
 #include "/EgtDev/Include/EGkDistPointSurfTm.h"
-#include "/EgtDev/Include/EGkIntersCurves.h"
-#include "/EgtDev/Include/EGkIntersLineBox.h"
-#include "/EgtDev/Include/EGkIntersLineSurfTm.h"
-#include "/EgtDev/Include/EGkCalcPocketing.h"
-#include "/EgtDev/Include/EGkPolygonElevation.h"
 #include "/EgtDev/Include/EGkSurfLocal.h"
 #include "/EgtDev/Include/EGkStringUtils3d.h"
 
@@ -311,6 +305,67 @@ ExeExtractSurfFrChunkLoops( int nId, int nChunk, int nDestGrpId, int* pnCount)
    return nFirstId ;
 }
 
+//----------------------------------------------------------------------------
+int
+ExeSurfFrGetZigZagInfill( int nId, int nDestGrpId, double dStep, double dAng, bool bStepCorrection, bool bInvert, 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 && pSfr->GetZigZagInfill( dStep, bStepCorrection, bInvert, 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) ;
+     // copio il materiale
+      if ( ! pGeomDB->CopyMaterial( nId, nNewId))
+         return GDB_ID_NULL ;
+     // aggiorno contatori
+      if ( bOk  &&  nFirstId == GDB_ID_NULL)
+         nFirstId = nNewId ;
+      if ( bOk)
+         ++ nCount ;  
+   } 
+   ExeSetModified() ;
+
+  // restituisco risultati
+   if ( pnCount != nullptr)
+      *pnCount = nCount ;
+   return nFirstId ;
+}
+
 //----------------------------------------------------------------------------
 int
 ExeSurfTmVertexCount( int nId)
@@ -532,83 +587,6 @@ ExeSurfTmFacetMinAreaRectangle( int nId, int nFacet, int nRefId, Frame3d& frRect
    return TransformFrame( pGeomDB, nId, nRefId, frRect) ;
 }
 
-//----------------------------------------------------------------------------
-bool
-ExeSurfTmFacetElevationInBBox( int nId, int nFacet, const BBox3d& b3Box, bool bAcceptOutFacet, int nRefId, double& dElev)
-{
-  // La faccia deve essere tutta contenuta nel Box
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-  // recupero la superficie trimesh e il suo riferimento
-   const ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
-   if ( pStm == nullptr)
-      return false ;
-   Frame3d frStm ;
-   if ( ! pGeomDB->GetGlobFrame( nId, frStm))
-      return false ;
-  // verifico il box e ne recupero il riferimento
-   if ( b3Box.IsEmpty())
-      return false ;
-   Frame3d frBox ;
-   if ( nRefId == GDB_ID_ROOT)
-      frBox = GLOB_FRM ;
-   else if ( nRefId == GDB_ID_GRID)
-      frBox = pGeomDB->GetGridFrame() ;
-   else {
-     // nRefId può essere un gruppo o una entità
-      if ( ! pGeomDB->GetGroupGlobFrame( nRefId, frBox)  &&
-           ! pGeomDB->GetGlobFrame( nRefId, frBox))
-         return false ;
-   }
-  // recupero il contorno esterno della faccia e lo porto nel riferimento del box
-   POLYLINEVECTOR vPL ;
-   pStm->GetFacetLoops( nFacet, vPL) ;
-   if ( vPL.empty())
-      return false ;
-   vPL[0].LocToLoc( frStm, frBox) ;
-  // ne derivo il poligono
-   Polygon3d pgFacet ;
-   if ( ! pgFacet.FromPolyLine( vPL[0]))
-      return false ;
-  // calcolo l'elevazione
-   return PolygonElevationInBBox( pgFacet, b3Box, bAcceptOutFacet, dElev) ;
-}
-
-//----------------------------------------------------------------------------
-bool
-ExeSurfTmFacetElevationInClosedSurfTm( int nFacetStmId, int nFacet, int nClosedStmId, bool bAcceptOutFacet, double& dElev)
-{
-  // La faccia deve essere tutta contenuta nel Box
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-  // recupero la superficie trimesh della faccia e il suo riferimento
-   const ISurfTriMesh* pFacStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nFacetStmId)) ;
-   if ( pFacStm == nullptr)
-      return false ;
-   Frame3d frFacStm ;
-   if ( ! pGeomDB->GetGlobFrame( nFacetStmId, frFacStm))
-      return false ;
-  // recupero la superficie trimesh chiusa (volume)
-   const ISurfTriMesh* pCldStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nClosedStmId)) ;
-   if ( pCldStm == nullptr)
-      return false ;
-   Frame3d frCldStm ;
-   if ( ! pGeomDB->GetGlobFrame( nClosedStmId, frCldStm))
-      return false ;
-  // recupero il contorno esterno della faccia e lo porto nel riferimento della superficie chiusa
-   POLYLINEVECTOR vPL ;
-   pFacStm->GetFacetLoops( nFacet, vPL) ;
-   if ( vPL.empty())
-      return false ;
-   vPL[0].LocToLoc( frFacStm, frCldStm) ;
-  // ne derivo il poligono
-   Polygon3d pgFacet ;
-   if ( ! pgFacet.FromPolyLine( vPL[0]))
-      return false ;
-  // calcolo l'elevazione
-   return PolygonElevationInClosedSurfTm( pgFacet, *pCldStm, bAcceptOutFacet, dElev) ;
-}
-
 //----------------------------------------------------------------------------
 bool
 ExeSurfTmFacetOppositeSide( int nId, int nFacet, const Vector3d& vtDir, int nRefId,
@@ -856,8 +834,7 @@ ExeExtractSurfTmLoops( int nId, int nDestGrpId, int* pnCount)
 
 //----------------------------------------------------------------------------
 int
-ExeGetSurfTmSilhouette( int nId, const Vector3d& vtDir, double dToler, int nDestGrpId, int nRefType,
+ExeGetSurfTmSilhouette( int nId, const Vector3d& vtDir, double dToler, int nDestGrpId, int nRefType, int* pnCount)
-                        int* pnCount, bool bAllTria)
 {
    IGeomDB* pGeomDB = GetCurrGeomDB() ;
    VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
@@ -874,7 +851,7 @@ ExeGetSurfTmSilhouette( int nId, const Vector3d& vtDir, double dToler, int nDest
    Vector3d vtDirL = GetVectorLocal( pGeomDB, vtDir, nRefType, frSurf) ;
   // recupero i loop come polilinee
    POLYLINEVECTOR vPL ;
-   bOk = bOk && pStm->GetSilhouette( vtDirL, dToler, vPL, bAllTria) ;
+   bOk = bOk && pStm->GetSilhouette( vtDirL, dToler, vPL) ;
   // dalle polilinee creo le curve e le inserisco nel DB
    int nFirstId = GDB_ID_NULL ;
    int nCount = 0 ;
@@ -902,8 +879,7 @@ ExeGetSurfTmSilhouette( int nId, const Vector3d& vtDir, double dToler, int nDest
       string sLua = "EgtGetSurfTmSilhouette(" + ToString( nId) + ",{" +
                                                 ToString( vtDir) + "}," +
                                                 ToString( nDestGrpId) + "," +
-                                                RefTypeToString( nRefType) + "," +
+                                                RefTypeToString( nRefType) + ")" +
-                                                ToString( bAllTria) + ")" +
                     " -- Id1=" + ToString( nFirstId) + ",Nbr=" + ToString( nCount) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
    }
@@ -1054,7 +1030,7 @@ ExeSurfTmGetFacetBBoxGlob( int nId, int nFacet, int nFlag, BBox3d& b3Box)
       return false ;
   // recupero il riferimento globale del gruppo cui appartiene
    Frame3d frGlob ;
-   if ( ! pGeomDB->GetGlobFrame( nId, frGlob))
+   if ( nId != GDB_ID_ROOT  &&  ! pGeomDB->GetGroupGlobFrame( pGeomDB->GetParentId( nId), frGlob))
       return false ;
   // recupero il bounding box della faccia dell'oggetto in globale
    return pStm->GetFacetBBox( nFacet, frGlob, b3Box, nFlag) ;
@@ -1072,7 +1048,7 @@ ExeSurfTmGetFacetBBoxRef( int nId, int nFacet, int nFlag, const Frame3d& frRef,
       return false ;
   // recupero il riferimento globale del gruppo cui appartiene
    Frame3d frGlob ;
-   if ( ! pGeomDB->GetGlobFrame( nId, frGlob))
+   if ( nId != GDB_ID_ROOT  &&  ! pGeomDB->GetGroupGlobFrame( pGeomDB->GetParentId( nId), frGlob))
       return false ;
   // porto il riferimento di espressione in quello della superficie
    Frame3d frGlobL = frGlob ;
@@ -1081,63 +1057,6 @@ ExeSurfTmGetFacetBBoxRef( int nId, int nFacet, int nFlag, const Frame3d& frRef,
    return pStm->GetFacetBBox( nFacet, frGlobL, b3Box, nFlag) ;
 }
 
-//----------------------------------------------------------------------------
-int
-ExeSurfTmGetEdges( int nId, int nDestGrpId, bool bSmoothAng, int* pnCount)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
-  // recupero la superficie TriMesh
-   const ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
-   bool bOk = ( pStm != nullptr) ;
-  // recupero il riferimento globale del gruppo cui appartiene
-   Frame3d frSurf ;
-   bOk = bOk && pGeomDB->GetGlobFrame( nId, frSurf) ;
-  // recupero il riferimento di destinazione
-   Frame3d frDest ;
-   bOk = bOk && pGeomDB->GetGroupGlobFrame( nDestGrpId, frDest) ;
-  // ne determino gli spigoli
-   ICURVEPOVECTOR vpCurve ;
-   bOk = bOk  &&  pStm->GetEdges( vpCurve) ;
-  // inserisco gli spigoli come curve nel DB
-   int nFirstId = GDB_ID_NULL ;
-   int nCount = 0 ;
-   for ( int i = 0 ; i < int( vpCurve.size()) ; ++ i) {
-     // se richiesto, verifico l'angolo tra le facce adiacenti (0=allineate)
-      if ( bSmoothAng) {
-         double dAngInt = vpCurve[i]->GetTempParam() ;
-         if ( abs( dAngInt) < pStm->GetSmoothAngle())
-            continue ;
-      }
-     // lo porto nel riferimento destinazione
-      bOk = bOk && vpCurve[i]->LocToLoc( frSurf, frDest) ;
-     // lo inserisco nel DB geometrico
-      int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, Release( vpCurve[i])) : GDB_ID_NULL) ;
-      bOk = bOk && ( nNewId != GDB_ID_NULL) ;
-     // copio il materiale
-      bOk = bOk && pGeomDB->CopyMaterial( nId, nNewId) ;
-     // aggiorno contatori
-      if ( bOk  &&  nFirstId == GDB_ID_NULL)
-         nFirstId = nNewId ;
-      if ( bOk)
-         ++ nCount ;
-   }
-   if ( ! bOk)
-      nCount = -1 ;
-   ExeSetModified() ;
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtSurfTmGetEdges(" + ToString( nId) + ",{" +
-                                           ToString( nDestGrpId) + ")" +
-                    " -- Id1=" + ToString( nFirstId) + ",Nbr=" + ToString( nCount) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-  // restituisco risultati
-   if ( pnCount != nullptr)
-      *pnCount = nCount ;
-   return nFirstId ;
-}
-
 //----------------------------------------------------------------------------
 bool
 ExeSurfBezierGetPoint( int nSurfId, double dU, double dV, int nRefId, Point3d& ptP)

EXE_GdbGetVol.cpp

@@ -250,7 +250,7 @@ ExeVolZmapGetEdges( int nId, int nDestGrpId, int* pnCount)
    ExeSetModified() ;
   // se richiesto, salvo il comando Lua equivalente
    if ( IsCmdLog()) {
-      string sLua = "EgtVolZmapGetEdges(" + ToString( nId) + ",{" +
+      string sLua = "EgtGetSurfTmSilhouette(" + ToString( nId) + ",{" +
                                                 ToString( nDestGrpId) + ")" +
                     " -- Id1=" + ToString( nFirstId) + ",Nbr=" + ToString( nCount) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;

EXE_GdbModifyCurve.cpp

@@ -31,20 +31,15 @@
 #include "/EgtDev/Include/EGkOffsetCurve.h"
 #include "/EgtDev/Include/EGkMedialAxis.h"
 #include "/EgtDev/Include/EGkChainCurves.h"
-#include "/EgtDev/Include/EGkProjectCurveSurfTm.h"
 #include "/EgtDev/Include/EGkSurfFlatRegion.h"
 #include "/EgtDev/Include/EGkExtTExt.h"
 #include "/EgtDev/Include/EGkGdbIterator.h"
 #include "/EgtDev/Include/EGkStringUtils3d.h"
 #include "/EgtDev/Include/EGkIntervals.h"
 #include "/EgtDev/Include/EGkPolygon3d.h"
-#include "/EgtDev/Include/EGkGeoVector3d.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
-#include "/EgtDev/Include/EGkCalcPocketing.h"
-#include <EgtDev/Include/EGkSfrCreate.h>
 #include <functional>
 
-
 using namespace std ;
 
 //----------------------------------------------------------------------------
@@ -102,14 +97,14 @@ ExeOffsetCurve( int nId, double dDist, int nType)
 
 //----------------------------------------------------------------------------
 int
-ExeOffsetCurveAdv( int nId, double dDist, int nType, int* pnCount, double dLinTol)
+ExeOffsetCurveAdv( int nId, double dDist, int nType, int* pnCount)
 {
    IGeomDB* pGeomDB = GetCurrGeomDB() ;
    VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
   // recupero la curva
    const ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
   // eseguo l'offset
-   OffsetCurve OffsCrv( dLinTol) ;
+   OffsetCurve OffsCrv ;
    bool bOk = OffsCrv.Make( pCurve, dDist, nType) ;
   // salvo le curve di offset
    int nRefId = nId ;
@@ -2140,7 +2135,7 @@ bool
 ExeMergeCurvesInCurveCompo( int nId, double dLinTol, bool bStartEnd)
 {
    IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
+   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
   // recupero la curva composita
    ICurveComposite* pCompo = GetCurveComposite( pGeomDB->GetGeoObj( nId)) ;
    bool bOk = ( pCompo != nullptr) ;
@@ -2163,7 +2158,7 @@ bool
 ExeRemoveCurveCompoUndercutOnY( int nId, double dLinTol)
 {
    IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
+   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
   // recupero la curva composita
    ICurveComposite* pCompo = GetCurveComposite( pGeomDB->GetGeoObj( nId)) ;
    bool bOk = ( pCompo != nullptr) ;
@@ -2185,7 +2180,7 @@ static bool
 MyChainCurvesInGroup( int nGroupId, const Point3d& ptNear, bool bAllowInvert, int nRefType)
 {
    IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
+   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
    nGroupId = AdjustId( nGroupId) ;
   // recupero il riferimento del gruppo
    Frame3d frGrp ;
@@ -2242,7 +2237,7 @@ ExeChainCurvesInGroup( int nGroupId, const Point3d& ptNear, int nRefType)
    ExeSetModified() ;
   // se richiesto, salvo il comando Lua equivalente
    if ( IsCmdLog()) {
-      string sLua = "EgtChainCurvesInGroup(" + ToString( nGroupId) + ",{" +
+      string sLua = "EgtChainCurvesInGroup(" + ToString( nGroupId) + "," +
                                                ToString( ptNear) + "}," +
                                                RefTypeToString( nRefType) + ")" +
                     " -- Ok=" + ToString( bOk) ;
@@ -2259,7 +2254,7 @@ ExeReorderCurvesInGroup( int nGroupId, const Point3d& ptNear, int nRefType)
    ExeSetModified() ;
   // se richiesto, salvo il comando Lua equivalente
    if ( IsCmdLog()) {
-      string sLua = "EgtReorderCurvesInGroup(" + ToString( nGroupId) + ",{" +
+      string sLua = "EgtReorderCurvesInGroup(" + ToString( nGroupId) + "," +
                                                  ToString( ptNear) + "}," +
                                                  RefTypeToString( nRefType) + ")" +
                     " -- Ok=" + ToString( bOk) ;
@@ -2267,243 +2262,3 @@ ExeReorderCurvesInGroup( int nGroupId, const Point3d& ptNear, int nRefType)
    }
    return bOk ;
 }
-
-//-------------------------------------------------------------------------------
-static bool
-MyProjectCurveOnSurfTm( int nCurveId, int nSurfTmId, const Vector3d& vtDir, int nDestGrpId, double dLinTol, int nRefType)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false)
-  // recupero la curva e il suo riferimento
-   const ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( nCurveId)) ;
-   if ( pCrv == nullptr)
-      return false ;
-   Frame3d frCrv ;
-   if ( ! pGeomDB->GetGlobFrame( nCurveId, frCrv))
-      return false ;
-  // recupero la superficie trimesh e il suo riferimento
-   const ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nSurfTmId)) ;
-   if ( pStm == nullptr)
-      return false ;
-   Frame3d frStm ;
-   if ( ! pGeomDB->GetGlobFrame( nSurfTmId, frStm))
-      return false ;
-  // recupero il riferimento del gruppo di destinazione
-   nDestGrpId = AdjustId( nDestGrpId) ;
-   Frame3d frDest ;
-   if ( ! pGeomDB->GetGroupGlobFrame( nDestGrpId, frDest))
-      return false ;
-  // porto la curva e il vettore nel riferimento della superficie
-   CurveLocal CrvLoc( pCrv, frCrv, frStm) ;
-   if ( CrvLoc.Get() == nullptr)
-      return false ;
-   Vector3d vtDirL = GetVectorLocal( pGeomDB, vtDir, nRefType, frCrv) ;
-   vtDirL.LocToLoc( frCrv, frStm) ;
-  // eseguo la proiezione
-   PNT5AXVECTOR vPt5ax ;
-   if ( ! ProjectCurveOnSurfTm( *CrvLoc.Get(), *pStm, vtDirL, dLinTol, vPt5ax))
-      return false ;
-  // inserisco la composita nel gruppo destinazione
-   PtrOwner<ICurveComposite> pCompo ;
-   for ( const auto& Pt5ax : vPt5ax) {
-      if ( IsNull( pCompo)) {
-         pCompo.Set( CreateCurveComposite()) ;
-         if ( IsNull( pCompo))
-            return false ;
-         pCompo->AddPoint( GetLocToLoc( Pt5ax.ptP, frStm, frDest)) ;
-      }
-      else
-         pCompo->AddLine( GetLocToLoc( Pt5ax.ptP, frStm, frDest)) ;
-   }
-   int nCompoId = pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, Release( pCompo)) ;
-   if ( nCompoId == GDB_ID_NULL)
-      return false ;
-  // aggiungo i versori nel gruppo destinazione
-   int nInd = 0 ;
-   for ( const auto& Pt5ax : vPt5ax) {
-      PtrOwner<IGeoVector3d> pGeoVct( CreateGeoVector3d()) ;
-      if ( IsNull( pGeoVct))
-         return false ;
-      pGeoVct->Set( 10 * GetLocToLoc( Pt5ax.vtDir, frStm, frDest), GetLocToLoc( Pt5ax.ptP, frStm, frDest)) ;
-      int nNewId = pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, Release( pGeoVct)) ;
-      if ( nNewId == GDB_ID_NULL)
-         return false ;
-      pGeomDB->SetInfo( nNewId, "Ind", nInd ++) ;
-      pGeomDB->SetInfo( nNewId, "Par", Pt5ax.dPar) ;
-      pGeomDB->SetInfo( nNewId, "Flag", Pt5ax.nFlag) ;
-   }
-
-   return true ;
-}
-
-//-------------------------------------------------------------------------------
-bool
-ExeProjectCurveOnSurfTm( int nCurveId, int nSurfTmId, const Vector3d& vtDir, int nDestGrpId, double dLinTol, int nRefType)
-{
-   bool bOk = MyProjectCurveOnSurfTm( nCurveId, nSurfTmId, vtDir, nDestGrpId, dLinTol, nRefType) ;
-   ExeSetModified() ;
-  // se richiesto, salvo il comando Lua equivalente
-   if ( IsCmdLog()) {
-      string sLua = "EgtProjectCurveOnSurfTm(" + ToString( nCurveId) + "," +
-                                                 ToString( nSurfTmId) + ",{" +
-                                                 ToString( vtDir) + "}," +
-                                                 ToString( nDestGrpId) + "," +
-                                                 ToString( dLinTol) + "," +
-                                                 RefTypeToString( nRefType) + ")" +
-                    " -- Ok=" + ToString( bOk) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-   return bOk ;
-
-}
-
-//----------------------------------------------------------------------------
-int
-ExeCurveGetVoronoi( int nId, int nDestGrpId, int nBound, int* pnCount) 
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
-  // recupero la curva
-   const ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( nId)) ;
-   if ( pCrv == nullptr)
-      return GDB_ID_NULL ;
-  // recupero il riferimento della curva
-   Frame3d frCrv ;
-   if ( ! pGeomDB->GetGlobFrame( nId, frCrv))
-      return GDB_ID_NULL ;
-  // recupero il riferimento di destinazione
-   Frame3d frDest ;
-   if ( ! pGeomDB->GetGroupGlobFrame( nDestGrpId, frDest))
-      return GDB_ID_NULL ;
-
-  // Calcolo diagramma di Voronoi
-   ICURVEPOVECTOR vCrv ;
-   CalcCurveVoronoiDiagram( *pCrv, vCrv, nBound) ;
-
-  // inserisco i risultati nel DB geometrico
-   int nFirstId = GDB_ID_NULL ;
-   int nCount = 0 ;
-   for ( int i = 0 ; i < int( vCrv.size()) ; i++) {
-      vCrv[i]->LocToLoc( frCrv, frDest) ;
-      int nId = pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, Release( vCrv[i])) ;
-      if ( nId != GDB_ID_NULL) {
-        nCount ++ ;
-        if ( nFirstId == GDB_ID_NULL)
-           nFirstId = nId ;      
-      }  
-   }
-   ExeSetModified() ;
-
-   if ( IsCmdLog()) {
-      string sLua = "EgtCurveGetVoronoi(" + ToString( nId) + "," +
-                                            ToString( nDestGrpId) + ")" +
-                    " FirstId=" + ToString( nFirstId) + " nCurveCount=" + ToString( nCount) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-
-  // restituisco risultati
-   if ( pnCount != nullptr)
-      *pnCount = nCount ;
-   return nFirstId ;
-}
-
-//----------------------------------------------------------------------------
-int
-ExeCurveGetMedialAxis( int nId, int nDestGrpId, int nSide, int* pnCount) 
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
-  // recupero la curva
-   const ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( nId)) ;
-   if ( pCrv == nullptr)
-      return GDB_ID_NULL ;
-  // recupero il riferimento della curva
-   Frame3d frCrv ;
-   if ( ! pGeomDB->GetGlobFrame( nId, frCrv))
-      return GDB_ID_NULL ;
-  // recupero il riferimento di destinazione
-   Frame3d frDest ;
-   if ( ! pGeomDB->GetGroupGlobFrame( nDestGrpId, frDest))
-      return GDB_ID_NULL ;
-
-  // Calcolo il Medial Axis
-   ICURVEPOVECTOR vCrv ;
-   CalcCurveMedialAxis( *pCrv, vCrv, nSide) ;
-
-  // inserisco i risultati nel DB geometrico
-   int nFirstId = GDB_ID_NULL ;
-   int nCount = 0 ;
-   for ( int i = 0 ; i < int( vCrv.size()) ; i++) {
-      vCrv[i]->LocToLoc( frCrv, frDest) ;
-      int nId = pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, Release( vCrv[i])) ;
-      if ( nId != GDB_ID_NULL) {
-        nCount ++ ;
-        if ( nFirstId == GDB_ID_NULL)
-           nFirstId = nId ;      
-      }  
-   }
-   ExeSetModified() ;
-
-   if ( IsCmdLog()) {
-      string sLua = "EgtCurveMedialAxisAdv(" + ToString( nId) + "," +
-                                               ToString( nSide) + "," +
-                                               ToString( nDestGrpId) + ")" +
-                    " FirstId=" + ToString( nFirstId) + " nCurveCount=" + ToString( nCount) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-
-  // restituisco risultati
-   if ( pnCount != nullptr)
-      *pnCount = nCount ;
-   return nFirstId ;
-}
-
-//----------------------------------------------------------------------------
-int
-ExeCurveGetFatCurve( int nId, int nDestGrpId, double dRad, bool bSquareEnds, bool bSquareMids, int* pnCount) 
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
-  // recupero la curva
-   const ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( nId)) ;
-   if ( pCrv == nullptr)
-      return GDB_ID_NULL ;
-  // recupero il riferimento della curva
-   Frame3d frCrv ;
-   if ( ! pGeomDB->GetGlobFrame( nId, frCrv))
-      return GDB_ID_NULL ;
-  // recupero il riferimento di destinazione
-   Frame3d frDest ;
-   if ( ! pGeomDB->GetGroupGlobFrame( nDestGrpId, frDest))
-      return GDB_ID_NULL ;
-
-  // Calcolo la curva ingrossata
-   ICURVEPOVECTOR vCrv ;
-   CalcCurveFatCurve( *pCrv, vCrv, dRad, bSquareEnds, bSquareMids) ;
-
-  // inserisco i risultati nel DB geometrico
-   int nFirstId = GDB_ID_NULL ;
-   int nCount = 0 ;
-   for ( int i = 0 ; i < int( vCrv.size()) ; i++) {     
-      vCrv[i]->LocToLoc( frCrv, frDest) ;
-      int nId = pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, Release( vCrv[i])) ;
-      if ( nId != GDB_ID_NULL) {
-         nCount ++ ;
-         if ( nFirstId == GDB_ID_NULL)
-            nFirstId = nId ;      
-      }  
-   }
-   ExeSetModified() ;
-
-   if ( IsCmdLog()) {
-      string sLua = "EgtCurveGetFatCurve(" + ToString( nId) + "," +
-                                             ToString( nDestGrpId) + ")" +
-                    " FirstId=" + ToString( nFirstId) + " nCurveCount=" + ToString( nCount) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-
-  // restituisco risultati
-   if ( pnCount != nullptr)
-      *pnCount = nCount ;
-   return nFirstId ;
-}

EXE_GdbModifySurf.cpp

@@ -29,10 +29,8 @@
 #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 ;
@@ -104,7 +102,7 @@ MyExplodeSurfTriMesh( int nId, int& nCount)
    }
   // 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 ;
@@ -130,7 +128,7 @@ MyExplodeSurfTriMesh( int nId, int& nCount)
      // restituisco risultati
       return nFirstId ;
    }
-  // non devo fare alcunch�
+  // non devo fare alcunché
    nCount = 1 ;
    return nId ;
 }
@@ -147,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 ;
@@ -296,7 +294,7 @@ 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
+  // se il risultato è vuoto, cancello la FlatRegion
    if ( bOk  && ! pSfr1->IsValid())
       pGeomDB->Erase( nId1) ;
    ExeSetModified() ;
@@ -328,7 +326,7 @@ 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
+  // se il risultato è vuoto, cancello la FlatRegion
    if ( bOk  && ! pSfr1->IsValid())
       pGeomDB->Erase( nId1) ;
    ExeSetModified() ;
@@ -353,7 +351,7 @@ 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
+  // se il risultato è vuoto, cancello la FlatRegion
    if ( bOk  && ! pSfr->IsValid())
       pGeomDB->Erase( nId) ;
    ExeSetModified() ;
@@ -421,7 +419,7 @@ ExeSurfTmMoveVertex( int nId, int nVert, const Point3d& ptNewVert, int nRefType,
   // 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
@@ -461,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 ;
@@ -487,7 +485,7 @@ MySurfTmToTriangles( int nId, int& nCount)
      // restituisco risultati
       return nFirstId ;
    }
-  // non devo fare alcunch�
+  // non devo fare alcunché
    nCount = 1 ;
    return nId ;
 }
@@ -702,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 ;
@@ -739,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 ;
@@ -926,111 +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 ;
-}
-
-
-//----------------------------------------------------------------------------
-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 = "EgtSurfTmCut(" + ToString( nId) + "," +
-         ToString( nCutterId) + "," +
-         " -- Ok=" + ToString( bOk) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-   return bOk ;
-}

EXE_GdbObjects.cpp

@@ -15,7 +15,6 @@
 #include "stdafx.h"
 #include "EXE.h"
 #include "EXE_Macro.h"
-#include "GeoTools.h"
 #include "AuxTools.h"
 #include "/EgtDev/Include/EXeExecutor.h"
 #include "/EgtDev/Include/EGkStringUtils3d.h"
@@ -255,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) ;
@@ -266,11 +264,11 @@ ExeCopy( int nSouId, int nRefId, int nSonBeforeAfter)
       string sLua ;
       if ( nSonBeforeAfter == GDB_LAST_SON)
          sLua = "EgtCopy(" + ToString( nSouId) + "," +
-                             IdToString( nRefId) + ")" +
+                             ToString( nRefId) + ")" +
                 " -- Id=" + ToString( nNewId) ;
       else
          sLua = "EgtCopy(" + ToString( nSouId) + "," +
-                             IdToString( nRefId) + "," +
+                             ToString( nRefId) + "," +
                              InsToString( nSonBeforeAfter) + ")" +
                 " -- Id=" + ToString( nNewId) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
@@ -285,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) ;
@@ -296,11 +293,11 @@ ExeCopyGlob( int nSouId, int nRefId, int nSonBeforeAfter)
       string sLua ;
       if ( nSonBeforeAfter == GDB_LAST_SON)
          sLua = "EgtCopyGlob(" + ToString( nSouId) + "," +
-                                 IdToString( nRefId) + ")" +
+                                 ToString( nRefId) + ")" +
                 " -- Id=" + ToString( nNewId) ;
       else
          sLua = "EgtCopyGlob(" + ToString( nSouId) + "," +
-                                 IdToString( nRefId) + "," +
+                                 ToString( nRefId) + "," +
                                  InsToString( nSonBeforeAfter) + ")" +
                 " -- Id=" + ToString( nNewId) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
@@ -315,7 +312,6 @@ 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() ;
@@ -324,11 +320,11 @@ ExeRelocate( int nSouId, int nRefId, int nSonBeforeAfter)
       string sLua ;
       if ( nSonBeforeAfter == GDB_LAST_SON)
          sLua = "EgtRelocate(" + ToString( nSouId) + "," +
-                                 IdToString( nRefId) + ")" +
+                                 ToString( nRefId) + ")" +
                 " -- Ok=" + ToString( bOk) ;
       else
          sLua = "EgtRelocate(" + ToString( nSouId) + "," +
-                                 IdToString( nRefId) + "," +
+                                 ToString( nRefId) + "," +
                                  InsToString( nSonBeforeAfter) + ")" +
                 " -- Ok=" + ToString( bOk) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
@@ -343,7 +339,6 @@ 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() ;
@@ -352,11 +347,11 @@ ExeRelocateGlob( int nSouId, int nRefId, int nSonBeforeAfter)
       string sLua ;
       if ( nSonBeforeAfter == GDB_LAST_SON)
          sLua = "EgtRelocateGlob(" + ToString( nSouId) + "," +
-                                     IdToString( nRefId) + ")" +
+                                     ToString( nRefId) + ")" +
                 " -- Ok=" + ToString( bOk) ;
       else
          sLua = "EgtRelocateGlob(" + ToString( nSouId) + "," +
-                                     IdToString( nRefId) + "," +
+                                     ToString( nRefId) + "," +
                                      InsToString( nSonBeforeAfter) + ")" +
                 " -- Ok=" + ToString( bOk) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;

EXE_GdbPartLayers.cpp

@@ -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 ( ExeIsDuplo( vnRef[i]))
-      if ( IsDuplo( pGeomDB, vnRef[i], bInDuploGroup))
          ++ 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
+  // Recupero il gruppo base dei duplicati
-   bool bPartVsGhost ;
+   int nDuploBaseId = GetDuploBase( pGeomDB) ;
-   return IsDuplo( pGeomDB, nDupId, bPartVsGhost) ;
+   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 ;  
 }
 
 //-----------------------------------------------------------------------------

EXE_General.cpp

@@ -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.
+//             28.11.19 DS Aggiunto caricamento opzionale del Nesting.
-//             14.11.23 DS Aggiunto caricamento opzionale di Exchange 3dm.
 //
 //----------------------------------------------------------------------------
 
@@ -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"
@@ -57,7 +55,6 @@ static string  s_sNestKey ;
 static string  s_sLockId ;
 static string  s_sIniFile ;
 static bool    s_bEnableUI = true ;
-static pfOnTerminateProcess s_pFunOnTerminateProcess = nullptr ;
 static pfProcEvents s_pFunProcEvents = nullptr ;
 static pfOutText    s_pFunOutText = nullptr ;
 static HWND    s_hMainWnd = nullptr ;
@@ -73,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 ;
@@ -116,10 +112,6 @@ ExeInit( int nDebug, const string& sLogFile, const string& sLogMsg)
    if ( LoadExchangeDll( s_pGenLog, s_sKey, s_bNetHwKey))
       LOG_INFO( s_pGenLog, MyGetEExVersion())
 
-  // carico libreria exchange 3dm opzionale
-   if ( LoadExch3dmDll( s_pGenLog, s_sKey, s_bNetHwKey))
-      LOG_INFO( s_pGenLog, MyGetEE3Version())
-
   // carico libreria di lavorazione opzionale
    if ( LoadMachKernelDll( s_pGenLog, s_sKey, s_bNetHwKey))
       LOG_INFO( s_pGenLog, MyGetEMkVersion())
@@ -176,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 ;
@@ -207,30 +197,6 @@ ExeExit( void)
    return true ;
 }
 
-//-----------------------------------------------------------------------------
-bool
-ExeSetOnTerminateProcess( pfOnTerminateProcess 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)
@@ -312,13 +278,10 @@ ExeSetLockId( const string& sLockId)
       bOk = ( s_nKeyType != KEY_LOCK_TYPE_HW) ;
       break ;
    case KEY_LOCK_TYPE_HW :
-      {  string sAddrPort ;
+      ExeSetNetHwKey( bNetKey, nUserId) ;
-         GetLockIdStringNetData( sLockId, sAddrPort) ;
-         ExeSetNetHwKey( bNetKey, nUserId, sAddrPort) ;
       bOk = true ;
       break ;
    }
-   }
    if ( bOk)
       s_sLockId = sLockId ;
    else
@@ -337,11 +300,11 @@ 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) ;
+   return SetNetHwKey( s_bNetHwKey, nUserId) ;
 }
 
 //-----------------------------------------------------------------------------
@@ -472,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() ;

EXE_GeoInters.cpp

@@ -1020,10 +1020,7 @@ MyCurveCurveInters( const int nId1, const int nId2, const int nDestGrpId, int& n
       return GDB_ID_NULL ;
 
   // recupero le curve e le porto nel riferimento del gruppo di destinazione
-   ICurve* pOrigCrv1 = GetCurve( pGeomDB->GetGeoObj( nId1)) ;
+   PtrOwner<ICurve> pCrv1( GetCurve( pGeomDB->GetGeoObj( nId1))->Clone()) ;
-   if ( pOrigCrv1 == nullptr)
-      return GDB_ID_NULL ;
-   PtrOwner<ICurve> pCrv1( pOrigCrv1->Clone()) ;
    if ( IsNull( pCrv1))
       return GDB_ID_NULL ;
    Frame3d frCrv1 ;
@@ -1031,10 +1028,7 @@ MyCurveCurveInters( const int nId1, const int nId2, const int nDestGrpId, int& n
       return GDB_ID_NULL ;
    pCrv1->LocToLoc( frCrv1, frDest) ;
 
-   ICurve* pOrigCrv2 = GetCurve( pGeomDB->GetGeoObj( nId2)) ;
+   PtrOwner<ICurve> pCrv2( GetCurve( pGeomDB->GetGeoObj( nId2))->Clone()) ;
-   if ( pOrigCrv2 == nullptr)
-      return GDB_ID_NULL ;
-   PtrOwner<ICurve> pCrv2( pOrigCrv2->Clone()) ;
    if ( IsNull( pCrv2))
       return GDB_ID_NULL ;
    Frame3d frCrv2 ;

EXE_GeomDB.cpp

@@ -277,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 ;
 }
@@ -318,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 ;
 }
@@ -454,11 +447,6 @@ 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 ;
 }

EXE_MachMgr.cpp

@@ -311,8 +311,8 @@ int
 ExeGetMachGroupId( const string& sName)
 {
    IMachMgr* pMachMgr = GetCurrMachMgr() ;
-   VERIFY_MACHMGR( pMachMgr, GDB_ID_NULL)
+   VERIFY_MACHMGR( pMachMgr, false)
-  // recupero l'identificativo della macchinata
+  // recupero l'indice della macchinata
    return pMachMgr->GetMachGroupId( sName) ;
 }
 
@@ -373,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 ;
 }
 
 //-----------------------------------------------------------------------------
@@ -471,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) ;
 }
@@ -1585,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)
@@ -2876,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
+  // recupero il flag
-   return pMachMgr->GetClEntFlag( nEntId, nFlag, nFlag2) ;
+   return pMachMgr->GetClEntFlag( nEntId, nFlag) ;
 }
 
 //-----------------------------------------------------------------------------
@@ -2894,16 +2884,6 @@ ExeGetClEntIndex( int nEntId, int& nIndex)
    return pMachMgr->GetClEntIndex( nEntId, nIndex) ;
 }
 
-//-----------------------------------------------------------------------------
-bool
-ExeGetClEntAxesVal( int nEntId, DBLVECTOR& vAxes)
-{
-   IMachMgr* pMachMgr = GetCurrMachMgr() ;
-   VERIFY_MACHMGR( pMachMgr, false)
-  // recupero il valore degli assi
-   return pMachMgr->GetClEntAxesVal( nEntId, vAxes) ;
-}
-
 //-----------------------------------------------------------------------------
 //    Simulazione
 //-----------------------------------------------------------------------------
@@ -3182,16 +3162,6 @@ ExeSetCalcTool( const string& sTool, const string& sHead, int nExit)
    return pMachMgr->SetCalcTool( sTool, sHead, nExit) ;
 }
 
-//-----------------------------------------------------------------------------
-bool
-ExeGetAllCurrAxesName( STRVECTOR& vAxName)
-{
-   IMachMgr* pMachMgr = GetCurrMachMgr() ;
-   VERIFY_MACHMGR( pMachMgr, false)
-  // recupero gli assi correnti derivanti dalla scelta di tavola e utensile
-   return pMachMgr->GetAllCurrAxesName( vAxName) ;
-}
-
 //----------------------------------------------------------------------------
 bool
 ExeSetRotAxisBlock( const string& sAxis, double dVal)

EXE_Scene.cpp

@@ -183,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)

EgtExecutor.vcxproj

@@ -200,7 +200,7 @@ copy $(TargetPath) \EgtProg\Dll32</Command>
       <OpenMPSupport>false</OpenMPSupport>
       <EnableFiberSafeOptimizations>false</EnableFiberSafeOptimizations>
       <EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
-      <EnableEnhancedInstructionSet>NotSet</EnableEnhancedInstructionSet>
+      <EnableEnhancedInstructionSet>AdvancedVectorExtensions2</EnableEnhancedInstructionSet>
       <LanguageStandard>stdcpp17</LanguageStandard>
       <AdditionalOptions>-Wno-tautological-undefined-compare</AdditionalOptions>
     </ClCompile>
@@ -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,7 +248,6 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClInclude Include="stdafx.h" />
   </ItemGroup>
   <ItemGroup>
-    <ClCompile Include="DllExch3dm.cpp" />
     <ClCompile Include="DllNesting.cpp" />
     <ClCompile Include="EXE_BeamMgr.cpp" />
     <ClCompile Include="EXE_CAvTool.cpp" />
@@ -257,7 +255,6 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <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" />
@@ -308,7 +305,6 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <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" />

EgtExecutor.vcxproj.filters

@@ -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,15 +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>
   </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="EgtExecutor.rc">

LUA.h

@@ -54,9 +54,6 @@ bool LuaInstallGdbModifyVol( LuaMgr& luaMgr) ;
 //-------------------------- GdbGet ------------------------------------------
 bool LuaInstallGdbGet( LuaMgr& luaMgr) ;
 
-//-------------------------- GdbGetPocketing ---------------------------------
-bool LuaInstallGdbGetPocketing( LuaMgr& luaMgr) ;
-
 //-------------------------- GdbGetCurve -------------------------------------
 bool LuaInstallGdbGetCurve( LuaMgr& luaMgr) ;
 

LUA_Base.cpp

@@ -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 ;

LUA_CAvTool.cpp

@@ -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 ;

LUA_Exchange.cpp

@@ -173,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 ;
@@ -254,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 ;
@@ -273,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 ;

LUA_GdbCreateSurf.cpp

@@ -147,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 ;
@@ -156,13 +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) ;
+   int nId = ExeCreateSurfFrFatCurve( nParentId, nCrvId, dRad, bSquared) ;
   // restituisco il risultato
    if ( nId != GDB_ID_NULL)
       LuaSetParam( L, nId) ;
@@ -389,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)
@@ -399,58 +395,6 @@ LuaCreateSurfTmSphere( lua_State* 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
 LuaCreateSurfTmByFlatContour( lua_State* L)
@@ -872,37 +816,6 @@ LuaCreateSurfBezierRational( lua_State* L)
    return 1 ;
 }
 
-//-------------------------------------------------------------------------------
-static int
-LuaCreateSurfBezierLeaves( 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 = ExeCreateSurfBezierLeaves( 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 ;
-}
-
 //-------------------------------------------------------------------------------
 bool
 LuaInstallGdbCreateSurf( LuaMgr& luaMgr)
@@ -922,8 +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( "EgtSurfTmTriangle", LuaCreateSurfTmTriangle) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmRectangle", LuaCreateSurfTmRectangle) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmByFlatContour", LuaCreateSurfTmByFlatContour) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmByRegion", LuaCreateSurfTmByRegion) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmByExtrusion", LuaCreateSurfTmByExtrusion) ;
@@ -939,6 +850,5 @@ LuaInstallGdbCreateSurf( LuaMgr& luaMgr)
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmByVolZmap", LuaCreateSurfTmByVolZmap) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBezier", LuaCreateSurfBezier) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBezierRat", LuaCreateSurfBezierRational) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBezierLeaves", LuaCreateSurfBezierLeaves) ;
    return bOk ;
 }

LUA_GdbGetCurve.cpp

@@ -18,7 +18,6 @@
 #include "/EgtDev/Include/EXeExecutor.h"
 #include "/EgtDev/Include/EXeConst.h"
 #include "/EgtDev/Include/EGkLuaAux.h"
-#include "/EgtDev/Include/EGkVoronoi.h"
 
 //----------------------------------------------------------------------------
 static int

LUA_GdbGetPocketing.cpp

@@ -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 : vId, 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 ;
-}

LUA_GdbGetSurf.cpp

@@ -237,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)
@@ -594,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)
@@ -744,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 ;
@@ -754,15 +733,11 @@ LuaGetSurfTmSilhouette( lua_State* L)
    int nDestGrpId ;
    LuaCheckParam( L, 4, nDestGrpId)
    int nRefType = RTY_DEFAULT ;
-   bool bAllTria = false ;
+   LuaGetParam( L, 5, nRefType) ;
-   if ( LuaGetParam( L, 5, nRefType))
-      LuaGetParam( L, 6, bAllTria) ;
-   else
-      LuaGetParam( L, 5, bAllTria) ;
    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) ;
@@ -818,33 +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
 LuaSurfBezierGetPoint( lua_State* L)
@@ -1096,6 +1044,7 @@ LuaInstallGdbGetSurf( LuaMgr& luaMgr)
    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) ;
@@ -1112,15 +1061,12 @@ LuaInstallGdbGetSurf( LuaMgr& luaMgr)
    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( "EgtExtractSurfTmFacetLoops", LuaExtractSurfTmFacetLoops) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtCopySurfTmFacet", LuaCopySurfTmFacet) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmGetEdges", LuaSurfTmGetEdges) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBezierGetPoint", LuaSurfBezierGetPoint) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBezierGetPointD1", LuaSurfBezierGetPointD1) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBezierGetPointNrmD1", LuaSurfBezierGetPointNrmD1) ;

LUA_GdbGetVol.cpp

@@ -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

LUA_GdbModifyCurve.cpp

@@ -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) ;
@@ -947,106 +944,6 @@ LuaReorderCurvesInGroup( lua_State* L)
    return 1 ;
 }
 
-//----------------------------------------------------------------------------
-static int
-LuaProjectCurveOnSurfTm( lua_State* L)
-{
-  // 4, 5 o 6 parametri : nCurveId, nSurfTmId, vtDir, nDestGrpId [, dLinTol [, nRefType]]
-   int nCurveId ;
-   LuaCheckParam( L, 1, nCurveId)
-   int nSurfTmId ;
-   LuaCheckParam( L, 2, nSurfTmId)
-   Vector3d vtDir ;
-   LuaCheckParam( L, 3, vtDir)
-   int nDestGrpId ;
-   LuaCheckParam( L, 4, nDestGrpId)
-   double dLinTol = 0.01 ;
-   int nRefType = RTY_DEFAULT ;
-   if ( LuaGetParam( L, 5, dLinTol))
-      LuaGetParam( L, 6, nRefType) ;
-   LuaClearStack( L) ;
-  // proietto la curva su una trimesh secondo la direzione data
-   bool bOk = ExeProjectCurveOnSurfTm( nCurveId, nSurfTmId, vtDir, nDestGrpId, dLinTol, nRefType) ;
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
-//----------------------------------------------------------------------------
-static int
-LuaCurveGetVoronoi( lua_State* L)
-{
-  // 2 o 3 parametri : Id, nDestGrpId [, nBound]
-   int nId ;
-   LuaCheckParam( L, 1, nId)
-   int nDestGrpId ;
-   LuaCheckParam( L, 2, nDestGrpId)
-   int nBound = VORONOI_STD_BOUND ;
-   LuaGetParam( L, 3, nBound) ;
-   LuaClearStack( L) ;
-  // eseguo
-   int nCount = 0 ;
-   int nNewId = ExeCurveGetVoronoi( nId, 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, nDestGrpId [, nSide]
-   int nId ;
-   LuaCheckParam( L, 1, nId)
-   int nDestGrpId ;
-   LuaCheckParam( L, 2, nDestGrpId)
-   int nSide = Voronoi::WMAT_LEFT ;
-   LuaGetParam( L, 3, nSide) ;
-   LuaClearStack( L) ;
-  // eseguo
-   int nCount = 0 ;
-   int nNewId = ExeCurveGetMedialAxis( nId, 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 ;
-}
-
 //-------------------------------------------------------------------------------
 bool
 LuaInstallGdbModifyCurve( LuaMgr& luaMgr)
@@ -1102,9 +999,5 @@ LuaInstallGdbModifyCurve( LuaMgr& luaMgr)
    bOk = bOk && luaMgr.RegisterFunction( "EgtRemoveCurveCompoUndercutOnY", LuaRemoveCurveCompoUndercutOnY) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtChainCurvesInGroup", LuaChainCurvesInGroup) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtReorderCurvesInGroup", LuaReorderCurvesInGroup) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtProjectCurveOnSurfTm", LuaProjectCurveOnSurfTm) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtCurveGetVoronoi", LuaCurveGetVoronoi) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtCurveMedialAxisAdv", LuaCurveMedialAxisAdv) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtCurveGetFatCurve", LuaCurveGetFatCurve) ;
    return bOk ;
 }

LUA_GdbModifySurf.cpp

@@ -388,57 +388,6 @@ 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
-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 = ExeSurfTmCut( nId, nCutterId, bInVsOut, bOn) ;
-   bool bOk = ExeSurfBzTrim( nId, nCutterId) ;
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
 //-------------------------------------------------------------------------------
 bool
 LuaInstallGdbModifySurf( LuaMgr& luaMgr)
@@ -464,7 +413,5 @@ LuaInstallGdbModifySurf( LuaMgr& luaMgr)
    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( "EgtSurfBzTrim", LuaSurfBzTrim) ;
    return bOk ;
 }

LUA_GdbObjAttribs.cpp

@@ -520,7 +520,9 @@ LuaSetInfo( lua_State* L)
    case LUA_TTABLE :
       {  Frame3d frVal ;
          BBox3d b3Val ;
-         DBLVECTOR vdVal ;    // va bene anche per Vector3d, Point3d, vnVal
+         Vector3d vtVal ;     // va bene anche per Point3d
+         INTVECTOR vnVal ;
+         DBLVECTOR vdVal ;
          STRVECTOR vsVal ;
          if ( LuaGetParam( L, 3, frVal)) {
             LuaClearStack( L) ;
@@ -530,6 +532,14 @@ LuaSetInfo( lua_State* L)
             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) ;

LUA_GdbPartLayers.cpp

@@ -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) ;

LUA_General.cpp

@@ -178,11 +178,11 @@ LuaSplitStringPlus( lua_State* L)
   // 2 parametri : sVal, sHea
    string sVal ;
    string sHea ;
-   bool bOk = LuaGetParam( L, 1, sVal)  &&
+   bool bFound = LuaGetParam( L, 1, sVal) ;
-              LuaGetParam( L, 2, sHea) ;
+   LuaCheckParam( L, 2, sHea)
    LuaClearStack( L) ;
-  // se ricevute stringhe, divido la prima in parti con intestazioni della seconda (che conservo)
+  // se ricevuta stringa, la divido in parti conservandone le intestazioni
-   if ( bOk) {
+   if ( bFound) {
       STRVECTOR vsVal ;
       TokenizePlus( sVal, sHea, vsVal) ;
      // ritorno il risultato
@@ -194,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)
@@ -1034,10 +1015,9 @@ LuaCloseExe( lua_State* L)
    LuaGetParam( L, 1, nExitCode) ;
    LuaClearStack( L) ;
   // eseguo chiusura forzata
-   if ( ExeOnTerminateProcess( nExitCode))
+   bool bOk = ( TerminateProcess( GetCurrentProcess(), abs( nExitCode)) != FALSE) ;
-      TerminateProcess( GetCurrentProcess(), abs( nExitCode)) ;
+  // restituisco il risultato (in realtà il programma si è già concluso)
-  // restituisco il risultato (se arrivo qui vuol dire che non è consnetito terminare l'esecuzione)
+   LuaSetParam( L, bOk) ;
-   LuaSetParam( L, false) ;
    return 1 ;
 }
 
@@ -1265,7 +1245,6 @@ LuaInstallGeneral( LuaMgr& luaMgr)
    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) ;

LUA_MachMgr.cpp

@@ -1734,12 +1734,10 @@ LuaFindToolInCurrSetup( lua_State* L)
    string sTool ;
    LuaGetParam( L, 1, sTool) ;
    LuaClearStack( L) ;
-  // verifico attrezzaggio utensile e ne recupero l'eventuale posizione
+  // verifico l'attrezzaggio della macchinata corrente
-   string sTcPos ;
+   bool bOk = ExeFindToolInCurrSetup( sTool) ;
-   bool bOk = ExeGetToolSetupPosInCurrSetup( sTool, sTcPos) ;
    LuaSetParam( L, bOk) ;
-   LuaSetParam( L, sTcPos) ;
+   return 1 ;
-   return 2 ;
 }
 
 //-----------------------------------------------------------------------------
@@ -2979,18 +2977,14 @@ LuaGetClEntFlag( lua_State* L)
    LuaGetParam( L, 1, nEntId) ;
    LuaClearStack( L) ;
   // recupero il flag
-   int nFlag, nFlag2 ;
+   int nFlag ;
-   bool bOk = ExeGetClEntFlag( nEntId, nFlag, nFlag2) ;
+   bool bOk = ExeGetClEntFlag( nEntId, nFlag) ;
   // restituisco il risultato
-   if ( bOk) {
+   if ( bOk)
       LuaSetParam( L, nFlag) ;
-      LuaSetParam( L, nFlag2) ;  
+   else
-   }
-   else {
       LuaSetParam( L) ;
-      LuaSetParam( L) ;
+   return 1 ;
-   }
-   return 2 ;
 }
 
 //-----------------------------------------------------------------------------
@@ -3012,25 +3006,6 @@ LuaGetClEntIndex( lua_State* L)
    return 1 ;
 }
 
-//-----------------------------------------------------------------------------
-static int
-LuaGetClEntAxesVal( lua_State* L)
-{
-  // 1 parametro : nEntId
-   int nEntId ;
-   LuaGetParam( L, 1, nEntId) ;
-   LuaClearStack( L) ;
-  // recupero il valore degli assi
-   DBLVECTOR vAxes ;
-   bool bOk = ExeGetClEntAxesVal( nEntId, vAxes) ;
-  // restituisco il risultato
-   if ( bOk)
-      LuaSetParam( L, vAxes) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
 //-------------------------------------------------------------------------------
 //    Simulation
 //-------------------------------------------------------------------------------
@@ -3317,23 +3292,6 @@ LuaSetCalcTool( lua_State* L)
    return 1 ;
 }
 
-//-------------------------------------------------------------------------------
-static int
-LuaGetAllCurrAxesName( lua_State* L)
-{
-  // nessun parametro
-   LuaClearStack( L) ;
-  // imposto l'utensile corrente per il calcolo
-   STRVECTOR vAxName ;
-   bool bOk = ExeGetAllCurrAxesName( vAxName) ;
-  // restituisco il risultato
-   if ( bOk)
-      LuaSetParam( L, vAxName) ;
-   else
-      LuaSetParam( L) ;
-   return 1 ;
-}
-
 //-------------------------------------------------------------------------------
 static int
 LuaSetRotAxisBlock( lua_State* L)
@@ -4203,7 +4161,6 @@ LuaInstallMachMgr( LuaMgr& luaMgr)
    bOk = bOk && luaMgr.RegisterFunction( "EgtGetClEntMove", LuaGetClEntMove) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtGetClEntFlag", LuaGetClEntFlag) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtGetClEntIndex", LuaGetClEntIndex) ;  
-   bOk = bOk && luaMgr.RegisterFunction( "EgtGetClEntAxesVal", LuaGetClEntAxesVal) ;  
    // Simulation
    bOk = bOk && luaMgr.RegisterFunction( "EgtSimInit", LuaSimInit) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSimStart", LuaSimStart) ;
@@ -4237,7 +4194,6 @@ LuaInstallMachMgr( LuaMgr& luaMgr)
    // Machine Calc
    bOk = bOk && luaMgr.RegisterFunction( "EgtSetCalcTable", LuaSetCalcTable) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSetCalcTool", LuaSetCalcTool) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtGetAllCurrAxesName", LuaGetAllCurrAxesName) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSetRotAxisBlock", LuaSetRotAxisBlock) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtGetRotAxisBlocked", LuaGetRotAxisBlocked) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtGetCalcTool", LuaGetCalcTool) ;