Merge commit '9e1f151bbc90bc257749d8df7cbabefa679163e1' into VmillAdditivo

EgtExecutor :
- adattamenti per Zmap con virtual additive.
2024-04-30 08:38:44 +02:00 · 2024-04-26 11:33:16 +02:00 · 2024-04-22 19:07:16 +02:00 · 2024-04-22 15:30:00 +02:00 · 2024-04-22 13:23:59 +02:00 · 2024-04-19 17:51:00 +02:00
32 changed files with 1923 additions and 260 deletions
@@ -1,9 +1,9 @@
 //----------------------------------------------------------------------------
 //  EgalTech 2020-2020
 //----------------------------------------------------------------------------
-// File : EXE_CDeObjClosedSurfTm.cpp    Data : 09.01.20      Versione : 2.2a2
+// File : EXE_CDeObjSolid.cpp    Data : 09.01.20      Versione : 2.2a2
 // Contenuto : Funzioni per verificare collisioni tra
-//             Objects e Closed SurftriMesh.
+//             Objects e Solidi (Closed SurftriMesh e Zmap).
 //
 //
 // Modifiche : 09.01.20 DS Creazione modulo.
@@ -410,8 +410,8 @@ ExeImport3dm( const string& sFilePath)
   VERIFY_CTX_GEOMDB( pGseCtx, false)
   bool bOk = true ;
  // importo il file 3dm
-  // aggiungo un gruppo pezzo e un gruppo layer
-   int nPartId = pGseCtx->m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, Frame3d()) ;
+  //// aggiungo un gruppo pezzo e un gruppo layer
+  // int nPartId = pGseCtx->m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, Frame3d()) ;
  // preparo l'importatore
   PtrOwner<IImport3dm> pImp3dm( MyCreateImport3dm()) ;
   bOk = bOk && ! IsNull( pImp3dm) ;
@@ -424,7 +424,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, GDB_ID_ROOT,
                                 dTextHeight, dExtLine, dArrLen, dTextDist, bLenIsMM, nDecDig, sFont) ;
  // aggiorno stato file corrente
   if ( pGseCtx->m_sFilePath.empty())
@@ -470,7 +470,7 @@ ExeAdvancedImportIsEnabled( void)

 //-----------------------------------------------------------------------------
 bool
-ExeAdvancedImport( const string& sFilePath, double dToler)
+ExeAdvancedImport( const string& sFilePath, double dToler, int nFlag)
 {
   GseContext* pGseCtx = GetCurrGseContext() ;
   VERIFY_CTX_GEOMDB( pGseCtx, false)
@@ -504,7 +504,7 @@ ExeAdvancedImport( const string& sFilePath, double dToler)
   #endif
   string sCmdLine = "\"" + sExec + "\" \"" + sFilePath + "\" \"" + sFileOut + "\" \"" +
                     ToString( dToler, 3) + "\" \"" +  ToString( ExeGetDebugLevel()) + "\" \"" +
-                     ExeGetKey() + "\" \"" + ExeGetLockId() + "\""   ;
+                     ExeGetKey() + "\" \"" + ExeGetLockId() + "\" \"" + ToString( nFlag) +  "\"" ;
   STARTUPINFO si ;
   PROCESS_INFORMATION pi ;
   ZeroMemory( &si, sizeof( si)) ;
@@ -583,7 +583,7 @@ ExeCreateDiametralDimension( int nParentId, int nCrvId, const Point3d& ptDim,

 //-------------------------------------------------------------------------------
 static int
-MyCreateAngularDimension( int nParentId, const Point3d& ptP1, const Point3d& ptV, const Point3d& ptP2,
+MyCreateAngularDimension( int nParentId, const Point3d& ptV, const Point3d& ptP1, const Point3d& ptP2,
                          const Point3d& ptDim, const string& sText, int nRefType)
 {
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
@@ -603,7 +603,7 @@ MyCreateAngularDimension( int nParentId, const Point3d& ptP1, const Point3d& ptV
   PtrOwner<IExtDimension> pDim( CreateExtDimension()) ;
   if ( IsNull( pDim)  ||
        ! MySetDimensionStyle( pDim )  ||
-        ! pDim->SetAngular( ptP1L, ptVL, ptP2L, ptDimL, vtNL, sText))
+        ! pDim->SetAngular( ptVL, ptP1L, ptP2L, ptDimL, vtNL, sText))
      return GDB_ID_NULL ;
  // inserisco la quota nel DB
   return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pDim)) ;
@@ -611,11 +611,11 @@ MyCreateAngularDimension( int nParentId, const Point3d& ptP1, const Point3d& ptV

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

+//-------------------------------------------------------------------------------
+static int
+MyCreateAngularDimensionEx( int nParentId, const Point3d& ptV1, const Point3d& ptP1,
+                            const Point3d& ptV2,const Point3d& ptP2, const Point3d& ptDim,
+                            const string& sText, int nRefType)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
+      nParentId = AdjustId( nParentId) ;
+  // recupero il riferimento locale
+   Frame3d frLoc ;
+   if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frLoc))
+      return GDB_ID_NULL ;
+  // porto in locale i punti e assegno i versori
+   Point3d ptV1L = GetPointLocal( pGeomDB, ptV1, nRefType, frLoc) ;
+   Point3d ptP1L = GetPointLocal( pGeomDB, ptP1, nRefType, frLoc) ;
+   Point3d ptV2L = GetPointLocal( pGeomDB, ptV2, nRefType, frLoc) ;
+   Point3d ptP2L = GetPointLocal( pGeomDB, ptP2, nRefType, frLoc) ;
+   Point3d ptDimL = GetPointLocal( pGeomDB, ptDim, nRefType, frLoc) ;
+   Vector3d vtNL = GetVectorLocal( pGeomDB, Z_AX, nRefType, frLoc) ;
+  // creo la quota
+   PtrOwner<IExtDimension> pDim( CreateExtDimension()) ;
+   if ( IsNull( pDim)  ||
+        ! MySetDimensionStyle( pDim )  ||
+        ! pDim->SetAngularEx( ptV1L, ptP1L, ptV2L, ptP2L, ptDimL, vtNL, sText))
+      return GDB_ID_NULL ;
+  // inserisco la quota nel DB
+   return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pDim)) ;
+}
+
+//-------------------------------------------------------------------------------
+int
+ExeCreateAngularDimensionEx( int nParentId, const Point3d& ptV1, const Point3d& ptP1,
+                             const Point3d& ptV2, const Point3d& ptP2, const Point3d& ptDim,
+                             const string& sText, int nRefType)
+{
+  // eseguo
+   int nId = MyCreateAngularDimensionEx( nParentId, ptV1, ptP1, ptV2, ptP2, ptDim, sText, nRefType) ;
+   ExeSetModified() ;
+  // se richiesto, salvo il comando Lua equivalente
+   if ( IsCmdLog()) {
+      string sLua = "EgtAngularDimensionEx(" + IdToString( nParentId) + ",{" +
+                                               ToString( ptV1) + "},{" +
+                                               ToString( ptP1) + "},{" +
+                                               ToString( ptV2) + "},{" +
+                                               ToString( ptP2) + "},{" +
+                                               ToString( ptDim) + "},'" +
+                                               StringToLuaString( sText) + "'," +
+                                               RefTypeToString( nRefType) + ")" +
+                    " -- Id=" + ToString( nId) ;
+      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
+   }
+  // restituisco l'identificativo del oggetto
+   return nId ;
+}
+
 //-------------------------------------------------------------------------------
 static int
 MyCreateAngularDimensionFromLines( int nParentId, INTVECTOR vLineIds, const Point3d& ptDim,
@@ -1088,6 +1088,45 @@ ExeCreateArc3P( int nParentId, const Point3d& ptP1,
   return nId ;
 }

+//-------------------------------------------------------------------------------
+int
+ExeCreateArc2PR( int nParentId, const Point3d& ptStart, const Point3d& ptEnd,
+                 double dRad, bool bCCW, int nRefType)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
+   nParentId = AdjustId( nParentId) ;
+  // recupero il riferimento locale
+   Frame3d frLoc ;
+   bool bOk = pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
+  // porto in locale i punti, il versore normale e quelloe estrusione
+   Point3d ptStartL = GetPointLocal( pGeomDB, ptStart, nRefType, frLoc) ;
+   Point3d ptEndL = GetPointLocal( pGeomDB, ptEnd, nRefType, frLoc) ;
+   Vector3d vtNormL = GetVectorLocal( pGeomDB, Z_AX, nRefType, frLoc) ;
+   Vector3d vtExtrL = GetVectorLocal( pGeomDB, Z_AX, nRefType, frLoc) ;
+  // creo l'arco
+   PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
+   bOk = bOk && ( ! IsNull( pCrvArc)  &&
+                  pCrvArc->Set2PNRS( ptStartL, ptEndL, vtNormL, dRad, bCCW)) ;
+  // assegno il versore estrusione
+   bOk = bOk && pCrvArc->SetExtrusion( vtExtrL) ;
+  // inserisco l'arco nel DB
+   int nId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvArc)) : GDB_ID_NULL) ;
+   ExeSetModified() ;
+  // se richiesto, salvo il comando Lua equivalente
+   if ( IsCmdLog()) {
+      string sLua = "EgtArc2PR(" + IdToString( nParentId) + ",{" +
+                                   ToString( ptStart) + "},{" +
+                                   ToString( ptEnd) + "}," +
+                                   ToString( dRad) + "," +
+                                   RefTypeToString( nRefType) + ")" +
+                    " -- Id=" + ToString( nId) ;
+      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
+   }
+  // restituisco l'identificativo della nuova entità
+   return nId ;
+}
+
 //-------------------------------------------------------------------------------
 int
 ExeCreateArc2PB( int nParentId, const Point3d& ptStart, const Point3d& ptEnd,
@@ -31,8 +31,10 @@
 #include "/EgtDev/Include/EGkStringUtils3d.h"
 #include "/EgtDev/Include/EGkGeoPoint3d.h"
 #include "/EgtDev/Include/EGkCurveLocal.h"
+#include "/EgtDev/Include/EGkSurfLocal.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
 #include "/EgtDev/Include/EGkExtText.h"
+#include "/EgtDev/Include/EGkSbzStandard.h"

 using namespace std ;

@@ -1215,7 +1217,8 @@ ExeCreateSurfTmByScrewing( int nParentId, int nCrvId,

 //-------------------------------------------------------------------------------
 int
-ExeCreateSurfTmRectSwept( int nParentId, double dDimH, double dDimV, double dBevelH, double dBevelV, int nGuideId, int nCapType, double dLinTol)
+ExeCreateSurfTmRectSwept( int nParentId, double dDimH, double dDimV, double dBevelH, double dBevelV,
+                          int nGuideId, int nCapType, double dLinTol)
 {
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
@@ -1252,7 +1255,8 @@ ExeCreateSurfTmRectSwept( int nParentId, double dDimH, double dDimV, double dBev

 //-------------------------------------------------------------------------------
 int
-ExeCreateSurfTmSwept( int nParentId, int nSectId, int nGuideId, bool bCapEnds, double dLinTol, Vector3d* vtStatic)
+ExeCreateSurfTmSwept( int nParentId, int nSectId, int nGuideId, const Vector3d& vtAx,
+                      bool bCapEnds, double dLinTol, int nRefType)
 {
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
@@ -1264,6 +1268,8 @@ ExeCreateSurfTmSwept( int nParentId, int nSectId, int nGuideId, bool bCapEnds, d
  // recupero la guida in locale
   CurveLocal CrvGuide( pGeomDB, nGuideId, frLoc) ;
   bOk = bOk && ( CrvGuide.Get() != nullptr) ;
+  // porto in locale vettore asse
+   Vector3d vtAxL = GetVectorLocal( pGeomDB, vtAx, nRefType, frLoc) ;
  // inizializzazione superficie e suo Id
   ISurfTriMesh* pSTM = nullptr ;
   int nNewId = GDB_ID_NULL ;
@@ -1271,38 +1277,37 @@ ExeCreateSurfTmSwept( int nParentId, int nSectId, int nGuideId, bool bCapEnds, d
   int nSecType = pGeomDB->GetGeoType( nSectId) ;

  // controllo se la sezione è definita da una curva
-   if ( nSecType == CRV_LINE  ||  nSecType ==  CRV_ARC  ||
-        nSecType == CRV_BEZIER  ||  nSecType == CRV_COMPO) {
+   if ( ( nSecType & GEO_CURVE) != 0) {
     // recupero la sezione in locale
      CurveLocal CrvSect( pGeomDB, nSectId, frLoc) ;
      bOk = bOk && ( CrvSect.Get() != nullptr) ;
     // calcolo la Swept
-      pSTM = ( bOk ? GetSurfTriMeshSwept( CrvSect, CrvGuide, bCapEnds, dLinTol, vtStatic) : nullptr) ;
+      pSTM = ( bOk ? GetSurfTriMeshSwept( CrvSect, CrvGuide, vtAxL, bCapEnds, dLinTol) : nullptr) ;
     // inserisco la superficie trimesh nel DB
      nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, pSTM) : GDB_ID_NULL) ;
   }
  // controllo se la sezione è definita da una regione piana
   else if ( nSecType == SRF_FLATRGN) {
-     // recupero la sezione e la porto nel frame corrente
-      PtrOwner<ISurfFlatRegion> pSfrSec( CloneSurfFlatRegion( pGeomDB->GetGeoObj( nSectId))) ;
-      Frame3d frSec ;
-      if ( ! IsNull( pSfrSec) &&  pGeomDB->GetGlobFrame( nSectId, frSec)  &&
-           pSfrSec->LocToLoc( frSec, frLoc)) {
-        // calcolo la Swept
-         pSTM = ( bOk ? GetSurfTriMeshSwept( pSfrSec, CrvGuide, bCapEnds, dLinTol, vtStatic) : nullptr) ;
-        // inserisco la superficie trimesh nel DB
-         nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, pSTM) : GDB_ID_NULL) ;
-      }
+     // recupero la regione sezion in locale
+      SurfLocal SrfSect( pGeomDB, nSectId, frLoc) ;
+      const ISurfFlatRegion* pSFrSect = GetSurfFlatRegion( SrfSect.Get()) ;
+      bOk = bOk && ( pSFrSect != nullptr) ;
+     // calcolo la Swept
+      pSTM = ( bOk ? GetSurfTriMeshSwept( pSFrSect, CrvGuide, vtAxL, bCapEnds, dLinTol) : nullptr) ;
+     // inserisco la superficie trimesh nel DB
+      nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, pSTM) : GDB_ID_NULL) ;
   }
-
   ExeSetModified() ;
+
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtSurfTmSwept(" + IdToString( nParentId) + "," +
                                        ToString( nSectId) + "," +
-                                        ToString( nGuideId) + "," +
+                                        ToString( nGuideId) + ",{" +
+                                        ToString( vtAx) + "}," +
                                        ( bCapEnds ? "true" : "false") + "," +
-                                        ToString( dLinTol) + ")" +
+                                        ToString( dLinTol) + "," +
+                                        RefTypeToString( nRefType) + ")" +
                    " -- Id=" + ToString( nNewId) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
@@ -1576,42 +1581,6 @@ ExeCreateSurfTmBySewing( int nParentId, const INTVECTOR& vIds, bool bErase)
   return nNewId ;
 }

-//----------------------------------------------------------------------------
-int
-ExeCreateSurfTmBySurfBezier( int nParentId, int nSbezId)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
-   nParentId = AdjustId( nParentId) ;
-  // recupero la superficie di Bezier
-   const ISurfBezier* pSbez = GetSurfBezier( pGeomDB->GetGeoObj( nSbezId)) ;
-   bool bOk = ( pSbez != nullptr) ;
-  // recupero il riferimento della superficie sorgente
-   Frame3d frSou ;
-   bOk = bOk && pGeomDB->GetGlobFrame( nSbezId, frSou) ;
-  // recupero il riferimento locale
-   Frame3d frLoc ;
-   bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
-  // copio la superficie ausiliaria della Bezier
-   const ISurfTriMesh* pAuxSurf = ( bOk ? pSbez->GetAuxSurf() : nullptr) ;
-   PtrOwner<ISurfTriMesh> pStm( pAuxSurf != nullptr ? pAuxSurf->Clone() : nullptr) ;
-   bOk = bOk && ! IsNull( pStm) ;
-  // la porto nel riferimento destinazione
-   bOk = bOk && pStm->LocToLoc( frSou, frLoc) ;
-  // inserisco la superficie trimesh 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 = "EgtSurfTmBySurfBezier(" + IdToString( nParentId) + "," +
-                                               IdToString( nSbezId) + ")" +
-                    " -- Id=" + ToString( nNewId) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-  // restituisco il risultato
-   return nNewId ;
-}
-
 //----------------------------------------------------------------------------
 int
 ExeCreateSurfTmByVolZmap( int nParentId, int nZmapId, int nPart)
@@ -1843,3 +1812,100 @@ ExeCreateSurfBezierLeaves( int nParentId, int nSurfBzId, int nTextHeight, bool b
      *pnCount = nCount ;
   return nFirstId ;
 }
+
+//-------------------------------------------------------------------------------
+int
+ExeCreateSurfBezierTria2D( 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 i triangoli
+   vector<tuple<int,Point3d,Point3d,Point3d>> vTria2D ;
+   pSurfBez->GetTriangles2D( vTria2D) ;
+   int nFirstId = GDB_ID_NULL ;
+   int nCount = 0 ;
+   bool bOk = true ;
+   for ( int k = 0 ; k < (int)vTria2D.size() ; ++ k) {
+      PtrOwner<ISurfTriMesh> pStm( CreateSurfTriMesh()) ;
+      bOk = bOk && ! IsNull( pStm) ;
+      Point3d ptP1L =  get<1>(vTria2D[k]) ;
+      Point3d ptP2L =  get<2>(vTria2D[k]) ;
+      Point3d ptP3L =  get<3>(vTria2D[k]) ;
+      // 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) ;
+      if ( nNewId == GDB_ID_NULL)
+         return GDB_ID_NULL ;
+      if ( nFirstId == GDB_ID_NULL)
+         nFirstId = nNewId ;
+      ++ nCount ;
+      
+     // creo il testo e lo riempio
+      string sText = ToString( get<0>( vTria2D[k])) ;
+      Point3d ptCenter( ( ptP1L + ptP2L + ptP3L) / 3) ;
+      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 ;
+}
+
+//-------------------------------------------------------------------------------
+int
+ExeCreateBezierSphere( int nParentId, const Point3d& ptCenter, double dR, int nRefType) {
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
+   nParentId = AdjustId( nParentId) ;
+   bool bOk = true ;
+  // recupero il riferimento di immersione della superficie
+   Frame3d frLoc ;
+   bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
+  // reucpero il punto in locale
+   Point3d ptCenterLoc = GetPointLocal( pGeomDB, ptCenter, nRefType, frLoc) ;
+  // Creo la superficie
+   PtrOwner<ISurfBezier> pSurfBez( CreateBezierSphere( ptCenterLoc, dR)) ;
+   int nId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSurfBez)) : GDB_ID_NULL) ;
+   ExeSetModified() ;
+   // se richiesto, salvo il comando Lua equivalente
+   if ( IsCmdLog()) {
+      string sLua = "EgtCreateBezierSphere(" + IdToString( nParentId) + "," +
+         ToString( ptCenter) + "," +
+         ToString( dR) + "," +
+         RefTypeToString( nRefType) + ")" +
+         " -- Id=" + ToString( nId) ;
+      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
+   }
+  // resituisco l'identificativo dell'entit� creata
+   return nId ;
+}
@@ -1,4 +1,4 @@
-//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
 //  EgalTech 2016-2016
 //----------------------------------------------------------------------------
 // File : EXE_GdbCreateVol.cpp       Data : 27.10.16       Versione : 1.6v7
@@ -64,7 +64,50 @@ ExeCreateVolZmap( int nParentId, const Point3d& ptIni, double dDimX, double dDim
                    " -- Id=" + ToString( nNewId) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
-  // restituisco l'identificativo della nuova entità
+  // restituisco l'identificativo della nuova entità
+   return nNewId ;
+}
+
+//-------------------------------------------------------------------------------
+int ExeCreateVolZmapEmpty( int nParentId, const Point3d& ptIni, double dDimX, double dDimY, double dDimZ,
+                           double dPrec, bool bTriDex, int nRefType)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
+   nParentId = AdjustId( nParentId) ;
+  // recupero il riferimento locale
+   Frame3d frLoc ;
+   bool bOk = pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
+  // porto in locale i punti
+   Point3d ptIniL = GetPointLocal( pGeomDB, ptIni, nRefType, frLoc) ;
+   Point3d ptOnXL = GetPointLocal( pGeomDB, ptIni + X_AX, nRefType, frLoc) ;
+   Point3d ptOnYL = GetPointLocal( pGeomDB, ptIni + Y_AX, nRefType, frLoc) ;
+  // ne ricavo un riferimento intrinseco
+   Frame3d frBox ;
+   bOk = bOk && frBox.Set( ptIniL, ptOnXL, ptOnYL) ;
+  // creo lo Zmap nel suo riferimento intrinseco
+   PtrOwner<IVolZmap> pVZM( CreateVolZmap()) ;
+   bOk = bOk && ! IsNull( pVZM) ;
+   bOk = bOk && pVZM->CreateEmpty( ORIG, dDimX, dDimY, dDimZ, dPrec, bTriDex) ;
+  // lo porto nel riferimento locale
+   bOk = bOk && pVZM->ToGlob( frBox) ;
+  // inserisco lo Zmap nel DB
+   int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pVZM)) : GDB_ID_NULL) ;
+   ExeSetModified() ;
+  // se richiesto, salvo il comando Lua equivalente
+   if ( IsCmdLog()) {
+      string sLua = "EgtVolZmapEmpty(" + IdToString( nParentId) + ",{" +
+                                       ToString( ptIni) + "}," +
+                                       ToString( dDimX) + "," +
+                                       ToString( dDimY) + "," +
+                                       ToString( dDimZ) + "," +
+                                       ToString( dPrec) + "," +
+                                       ( bTriDex ? "true" : "false") + "," +
+                                       RefTypeToString( nRefType) + ")" +
+                    " -- Id=" + ToString( nNewId) ;
+      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
+   }
+  // restituisco l'identificativo della nuova entità
   return nNewId ;
 }

@@ -103,7 +146,7 @@ ExeCreateVolZmapByRegionExtrusion( int nParentId, int nSfrId, double dDimZ, doub
                    " -- Id=" + ToString( nNewId) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
-  // restituisco l'identificativo della nuova entità
+  // restituisco l'identificativo della nuova entità
   return nNewId ;
 }

@@ -141,6 +184,6 @@ ExeCreateVolZmapFromSurfTm( int nParentId, int nStmId, double dPrec, bool bTriDe
                    " -- Id=" + ToString( nNewId) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
-  // restituisco l'identificativo della nuova entità
+  // restituisco l'identificativo della nuova entità
   return nNewId ;
 }
@@ -1462,25 +1462,26 @@ ExeExtractSurfBezierLoops( int nId, int nDestGrpId, int* pnCount)
  // richiedo i contorni della superficie e li inserisco nel DB
   int nFirstId = GDB_ID_NULL ;
   int nCount = 0 ;
-   int nL = 0 ;
-   PtrOwner<ICurve> pCrv( bOk ? pSbz->GetLoop( nL) : nullptr) ;
-   while ( ! IsNull( pCrv)) {
-     // porto la curva nel riferimento destinazione
-      bOk = bOk && pCrv->LocToLoc( frSurf, frDest) ;
-     // la inserisco nel DB geometrico
-      int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, Release( pCrv)) : GDB_ID_NULL) ;
+   ICRVCOMPOPOVECTOR vCC ;
+   pSbz->GetLoops( vCC , true) ;
+   for ( int i = 0 ; i < int( vCC.size()) ; ++i) {
+      if ( IsNull( vCC[i])  ||  ! vCC[i]->IsValid())
+         continue ;
+      // porto la curva nel riferimento destinazione
+      bOk = bOk && vCC[i]->LocToLoc(frSurf, frDest) ;
+      // la inserisco nel DB geometrico
+      int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, Release( vCC[i])) : GDB_ID_NULL) ;
      bOk = bOk && ( nNewId != GDB_ID_NULL) ;
-     // copio il materiale
-     if ( ! pGeomDB->CopyMaterial( nId, nNewId))
+      // copio il materiale
+      if ( ! pGeomDB->CopyMaterial( nId, nNewId))
         return GDB_ID_NULL ;
-     // aggiorno contatori
+      // aggiorno contatori
      if ( bOk  &&  nFirstId == GDB_ID_NULL)
         nFirstId = nNewId ;
      if ( bOk)
         ++ nCount ;
-     // passo alla prossima curva
-     pCrv.Set( bOk ? pSbz->GetLoop( ++nL) : nullptr) ;
   }
+
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
@@ -1493,4 +1494,4 @@ ExeExtractSurfBezierLoops( int nId, int nDestGrpId, int* pnCount)
   if ( pnCount != nullptr)
      *pnCount = nCount ;
   return nFirstId ;
-}
+}
@@ -27,6 +27,7 @@
 #include "/EgtDev/Include/EGkIntersCurves.h"
 #include "/EgtDev/Include/EGkDistPointCurve.h"
 #include "/EgtDev/Include/EGkCurveLocal.h"
+#include "/EgtDev/Include/EGkSurfLocal.h"
 #include "/EgtDev/Include/EGkCurveAux.h"
 #include "/EgtDev/Include/EGkOffsetCurve.h"
 #include "/EgtDev/Include/EGkMedialAxis.h"
@@ -38,6 +39,7 @@
 #include "/EgtDev/Include/EGkStringUtils3d.h"
 #include "/EgtDev/Include/EGkIntervals.h"
 #include "/EgtDev/Include/EGkPolygon3d.h"
+#include "/EgtDev/Include/EGkGeoPoint3d.h"
 #include "/EgtDev/Include/EGkGeoVector3d.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
 #include "/EgtDev/Include/EGkCalcPocketing.h"
@@ -2361,6 +2363,134 @@ ExeProjectCurveOnSurfTm( int nCurveId, int nSurfTmId, const Vector3d& vtDir, int

 }

+//-------------------------------------------------------------------------------
+static bool
+MyProjectCurveOnSurfTmExt( int nCurveId, int nSurfTmId, int nGuideId, int nDestGrpId,
+                           double dLinTol, double dMaxSegmLen, bool bDirFromGuide)
+{
+   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 l'entità guida (punto, curva o superficie) e il suo riferimento
+   const IGeoPoint3d* pGdePnt = nullptr ;
+   const ICurve* pGdeCrv = nullptr ;
+   const ISurfTriMesh* pGdeStm = nullptr ;
+   pGdePnt = GetGeoPoint3d( pGeomDB->GetGeoObj( nGuideId)) ;
+   if ( pGdePnt == nullptr) {
+      pGdeCrv = GetCurve( pGeomDB->GetGeoObj( nGuideId)) ;
+      if ( pGdeCrv == nullptr) {
+         pGdeStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nGuideId)) ;
+         if ( pGdeStm == nullptr)
+            return false ;
+      }
+   }
+   Frame3d frGde ;
+   if ( ! pGeomDB->GetGlobFrame( nGuideId, frGde))
+      return false ;
+  // recupero il riferimento del gruppo di destinazione
+   nDestGrpId = AdjustId( nDestGrpId) ;
+   Frame3d frDest ;
+   if ( ! pGeomDB->GetGroupGlobFrame( nDestGrpId, frDest))
+      return false ;
+  // porto la curva nel riferimento della superficie
+   CurveLocal CrvLoc( pCrv, frCrv, frStm) ;
+   if ( CrvLoc.Get() == nullptr)
+      return false ;
+  // eseguo l'opportuna proiezione dopo aver portato l'entità guida nel riferimento della superficie
+   PNT5AXVECTOR vPt5ax ;
+   if ( pGdePnt != nullptr) {
+      PtrOwner<IGeoPoint3d> pGdeLoc( pGdePnt->Clone()) ;
+      if ( pGdeLoc == nullptr)
+         return false ;
+      pGdeLoc->LocToLoc( frGde, frStm) ;
+      if ( ! ProjectCurveOnSurfTm( *CrvLoc.Get(), *pStm, *pGdeLoc, dLinTol, dMaxSegmLen, vPt5ax))
+         return false ;
+   }
+   else if ( pGdeCrv != nullptr) {
+      CurveLocal GdeLoc( pGdeCrv, frGde, frStm) ;
+      if ( GdeLoc.Get() == nullptr)
+         return false ;
+      if ( ! ProjectCurveOnSurfTm( *CrvLoc.Get(), *pStm, *GdeLoc.Get(), dLinTol, dMaxSegmLen, vPt5ax))
+         return false ;
+   }
+   else { // pGdeStm != nullptr
+      SurfLocal GdeLoc( pGdeStm, frGde, frStm) ;
+      const ISurfTriMesh* pGdeLoc = GetSurfTriMesh( GdeLoc.Get()) ;
+      if ( pGdeLoc == nullptr)
+         return false ;
+      if ( ! ProjectCurveOnSurfTm( *CrvLoc.Get(), *pStm, *pGdeLoc, dLinTol, dMaxSegmLen, 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 ;
+      Vector3d vtDir = ( bDirFromGuide ? Pt5ax.vtDir2 : Pt5ax.vtDir) ;
+      pGeoVct->Set( 10 * GetLocToLoc( vtDir, frStm, frDest), GetLocToLoc( Pt5ax.ptP, frStm, frDest)) ;
+      int nNewId = pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, Release( pGeoVct)) ;
+      if ( nNewId == GDB_ID_NULL)
+         return false ;
+      pGeomDB->SetInfo( nNewId, "Ind", nInd ++) ;
+      pGeomDB->SetInfo( nNewId, "Par", Pt5ax.dPar) ;
+      pGeomDB->SetInfo( nNewId, "Flag", Pt5ax.nFlag) ;
+   }
+
+   return true ;
+}
+
+//-------------------------------------------------------------------------------
+bool
+ExeProjectCurveOnSurfTmExt( int nCurveId, int nSurfTmId, int nGuideId, int nDestGrpId,
+                            double dLinTol, double dMaxSegmLen, bool bDirFromGuide)
+{
+   bool bOk = MyProjectCurveOnSurfTmExt( nCurveId, nSurfTmId, nGuideId, nDestGrpId, dLinTol, dMaxSegmLen, bDirFromGuide) ;
+   ExeSetModified() ;
+  // se richiesto, salvo il comando Lua equivalente
+   if ( IsCmdLog()) {
+      string sLua = "EgtProjectCurveOnSurfTmExt(" + ToString( nCurveId) + "," +
+                                                    ToString( nSurfTmId) + ",{" +
+                                                    ToString( nGuideId) + "}," +
+                                                    ToString( nDestGrpId) + "," +
+                                                    ToString( dLinTol) + "," +
+                                                    ToString( dMaxSegmLen) + "," +
+                                                    ( bDirFromGuide ? "true" : "false") + ")" +
+                    " -- Ok=" + ToString( bOk) ;
+      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
+   }
+   return bOk ;
+
+}
+
 //----------------------------------------------------------------------------
 int
 ExeCurveGetVoronoi( int nId, int nDestGrpId, int nBound, int* pnCount) 
@@ -77,7 +77,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 +104,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 +130,7 @@ MyExplodeSurfTriMesh( int nId, int& nCount)
     // restituisco risultati
      return nFirstId ;
   }
-  // non devo fare alcunch�
+  // non devo fare alcunché
   nCount = 1 ;
   return nId ;
 }
@@ -147,7 +147,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 ;
@@ -209,7 +209,7 @@ ExeExplodeSurface( int nId, int* pnCount)

 //-------------------------------------------------------------------------------
 bool
-ExeApproxSurface( int nId, double dLinTol)
+ExeApproxSurface( int nId, double dLinTol, double dTriaMinSide)
 {
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
@@ -230,8 +230,7 @@ ExeApproxSurface( int nId, double dLinTol)
   else if ( nType == SRF_BEZIER) {
     // recupero la superficie ausiliaria della Bezier
      const ISurfBezier* pSbez = GetSurfBezier( pGeomDB->GetGeoObj( nId)) ;
-      const ISurfTriMesh* pAuxSurf = ( pSbez != nullptr ? pSbez->GetAuxSurf() : nullptr) ;
-      pStm.Set( pAuxSurf != nullptr ? pAuxSurf->Clone() : nullptr) ;
+      pStm.Set( ( pSbez != nullptr ? pSbez->GetApproxSurf( dLinTol, dTriaMinSide) : nullptr)) ;
   }
   bool bOk = ( ! IsNull( pStm)) ;
  // semplificazione della trimesh
@@ -242,7 +241,8 @@ ExeApproxSurface( int nId, double dLinTol)
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtApproxSurf(" + ToString( nId) + "," +
-                                       ToString( dLinTol) + ")" +
+                                       ToString( dLinTol) + "," +
+                                       ToString( dTriaMinSide) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
@@ -296,7 +296,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 +328,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 +353,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() ;
@@ -443,11 +443,11 @@ bool
 ExeSurfTmMoveVertex( int nId, int nVert, const Point3d& ptNewVert, int nRefType, bool bUpdate)
 {
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
+   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la superficie
   ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
   bool bOk = ( pStm != nullptr) ;
-  // recupero il riferimento in cui � immersa la superficie
+  // recupero il riferimento in cui è immersa la superficie
   Frame3d frStm ;
   bOk = bOk && pGeomDB->GetGlobFrame( nId, frStm) ;
  // eseguo la modifica
@@ -475,6 +475,50 @@ ExeSurfTmMoveVertex( int nId, int nVert, const Point3d& ptNewVert, int nRefType,
   return bOk ;
 }

+//-------------------------------------------------------------------------------
+bool
+ExeSurfTmMoveFacet( int nId, int nFacet, const Vector3d& vtMove, int nRefType, bool bUpdate)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, false)
+  // recupero la superficie
+   ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
+   bool bOk = ( pStm != nullptr) ;
+  // recupero il riferimento in cui è immersa la superficie
+   Frame3d frStm ;
+   bOk = bOk && pGeomDB->GetGlobFrame( nId, frStm) ;
+  // porto in locale il movimento
+   Vector3d vtMoveL = GetVectorLocal( pGeomDB, vtMove, nRefType, frStm) ;
+  // recupero tutti i vertici della faccia
+   INTVECTOR vVert ;
+   bOk = bOk && pStm->GetAllVertInFacet( nFacet, vVert) ;
+  // sposto tutti i vertici della faccia della quantità desiderata
+   if ( bOk) {
+      for ( const auto nVert : vVert) {
+        // recupero la posizione originale del vertice
+         Point3d ptV ;
+         if ( pStm->GetVertex( nVert, ptV))
+            pStm->MoveVertex( nVert, ptV + vtMoveL) ;
+      }
+   }
+  // se richiesto, semplificazione della trimesh
+   if ( bUpdate)
+      bOk = bOk && pStm->DoCompacting() ;
+   ExeSetModified() ;
+  // se richiesto, salvo il comando Lua equivalente
+   if ( IsCmdLog()) {
+      string sLua = "EgtSurfTmMoveFacet(" + IdToString( nId) + "," +
+                                            ToString( nFacet) + ",{"  +
+                                            ToString( vtMove) + "}," +
+                                            RefTypeToString( nRefType) + "," +
+                                            ( bUpdate ? "true" : "false") + ")" +
+                    " -- Ok=" + ToString( bOk) ;
+      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
+   }
+  // restituisco risultato
+   return bOk ;
+}
+
 //-------------------------------------------------------------------------------
 static int
 MySurfTmToTriangles( int nId, int& nCount)
@@ -487,7 +531,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 ;
@@ -513,7 +557,7 @@ MySurfTmToTriangles( int nId, int& nCount)
     // restituisco risultati
      return nFirstId ;
   }
-  // non devo fare alcunch�
+  // non devo fare alcunché
   nCount = 1 ;
   return nId ;
 }
@@ -648,6 +692,41 @@ ExeCutSurfTmPlane( int nId, const Point3d& ptOn, const Vector3d& vtN, bool bSave
   return bOk ;
 }

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

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

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

 //----------------------------------------------------------------------------
 static bool 
@@ -104,10 +104,9 @@ ExeVolZmapChangeResolution( int nId, int nNewRes)
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero lo Zmap
   IVolZmap* pVZM = GetVolZmap( pGeomDB->GetGeoObj( nId)) ;
-   if ( pVZM == nullptr)
-      return false ;
+   bool bOk = ( pVZM != nullptr) ;
  // cambio la risoluzione (rapporto Voxel/Dexel, valori ammessi 1 e 2)
-   bool bOk = pVZM->ChangeResolution( nNewRes) ;
+   bOk = bOk && pVZM->ChangeResolution( nNewRes) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
@@ -120,6 +119,29 @@ ExeVolZmapChangeResolution( int nId, int nNewRes)
   return bOk ;
 }

+//----------------------------------------------------------------------------
+bool
+ExeVolZmapSetShowEdges( int nId, bool bShow)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, false)
+  // recupero lo Zmap
+   IVolZmap* pVZM = GetVolZmap( pGeomDB->GetGeoObj( nId)) ;
+   bool bOk = ( pVZM != nullptr) ;
+  // imposto lo stato di visualizzazione degli spigoli vivi
+   if ( bOk)
+      pVZM->SetShowEdges( bShow) ;
+   ExeSetModified() ;
+  // se richiesto, salvo il comando Lua equivalente
+   if ( IsCmdLog()) {
+      string sLua = "EgtVolZmapSetShowEdges(" + ToString( nId) + "," +
+                                                ToString( bShow) + ")" +
+                    " -- Ok=" + ToString( bOk) ;
+      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
+   }
+   return bOk ;
+}
+
 //-------------------------------------------------------------------------------
 bool
 ExeRemoveVolZmapPart( int nId, int nPart)
@@ -315,6 +337,34 @@ ExeVolZmapSetChiselTool( const INTVECTOR& vIds, const string& sToolName,
   return bOk ;
 }

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

+//-----------------------------------------------------------------------------
+bool
+ExeGetNetHwKey( void)
+{
+   return s_bNetHwKey ;
+}
+
 //-----------------------------------------------------------------------------
 bool
 ExeSetFont( const string& sNfeFontDir, const string& sDefaultFont)
@@ -34,6 +34,7 @@
 #include "/EgtDev/Include/EGkIntersLineSurfTm.h"
 #include "/EgtDev/Include/EGkIntersLineVolZmap.h"
 #include "/EgtDev/Include/EGkIntersPlaneBox.h"
+#include "/EgtDev/Include/EGkIntersLineSurfBez.h"
 #include "/EgtDev/Include/EGkIntersPlaneSurfTm.h"
 #include "/EgtDev/Include/EGkIntersPlaneVolZmap.h"
 #include "/EgtDev/Include/EGkIntersCurves.h"
@@ -70,7 +71,7 @@ MyLineCurveInters( const Point3d& ptP, const Vector3d& vtDir, const int nId, con
   if ( ! CrvLoc->GetLocalBBox( b3Crv))
      return false ;
   b3Crv.Expand( 100 * EPS_SMALL) ;
-  // definisco la linea (punto e direzione sono già nel riferimento di calcolo)
+  // definisco la linea (punto e direzione sono gi� nel riferimento di calcolo)
   double dLen = 2 * floor( b3Crv.MaxDistFromPoint( ptP)) ;
   double dOffs = -dLen / 2 ;
   PtrOwner<ICurveLine> pLine( CreateCurveLine()) ;
@@ -160,7 +161,7 @@ ExeLineBoxInters( const Point3d& ptP, const Vector3d& vtDir, const BBox3d& b3Box
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
-  // restituisco l'identificativo della prima nuova entità
+  // restituisco l'identificativo della prima nuova entit�
   return bOk ;
 }

@@ -193,8 +194,8 @@ MyLineSurfTmInters( const Point3d& ptP, const Vector3d& vtDir, int nId, int nRef
   ILSIVECTOR vInfo ;
   if ( ! IntersLineSurfTm( ptPL, vtDirL, dLen, *pStm, vInfo, false))
      return false ;
-
-  // filtro le intersezioni
+ 
+ // filtro le intersezioni
   FilterLineSurfTmInters( vInfo, vInters) ;

   return true ;
@@ -203,20 +204,75 @@ MyLineSurfTmInters( const Point3d& ptP, const Vector3d& vtDir, int nId, int nRef
 //-------------------------------------------------------------------------------
 bool
 ExeLineSurfTmInters( const Point3d& ptP, const Vector3d& vtDir, int nId, int nRefType,
-                     INTDBLVECTOR& vInters)
+   INTDBLVECTOR& vInters)
 {
-  // eseguo
+   // eseguo
   bool bOk = MyLineSurfTmInters( ptP, vtDir, nId, nRefType, vInters) ;
-  // se richiesto, salvo il comando Lua equivalente
+   // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtLineSurfTmInters({" + ToString( ptP) + "},{" +
+         ToString( vtDir) + "}," +
+         ToString( nId) + "," +
+         RefTypeToString( nRefType) + ")" +
+         " -- Ok=" + ToString( bOk) ;
+      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
+   }
+   // restituisco l'identificativo della prima nuova entit�
+   return bOk ;
+}
+
+//-------------------------------------------------------------------------------
+static bool
+MyLineSurfBzInters( const Point3d& ptP, const Vector3d& vtDir, int nId, int nRefType, INTDBLVECTOR& vInters)
+{
+   vInters.clear() ;
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, false)
+      // recupero la superficie Bezier
+      const ISurfBezier* pSbz = GetSurfBezier( pGeomDB->GetGeoObj( nId)) ;
+   if ( pSbz == nullptr)
+      return false ;
+   // recupero il suo riferimento globale
+   Frame3d frSurf ;
+   if ( ! pGeomDB->GetGlobFrame( nId, frSurf))
+      return false ;
+   // porto in locale il punto e la direzione della linea
+   Point3d ptPL = GetPointLocal( pGeomDB, ptP, nRefType, frSurf) ;
+   Vector3d vtDirL = GetVectorLocal( pGeomDB, vtDir, nRefType, frSurf) ;
+   vtDirL.Normalize() ;
+   // calcolo l'ingombro della Bezier
+   BBox3d b3Surf ;
+   if ( ! pSbz->GetLocalBBox( b3Surf))
+      return false ;
+   // calcolo l'intersezione
+   double dLen = b3Surf.MaxDistFromPoint( ptPL) ;
+   ILSBIVECTOR vInfo ;
+   if ( ! IntersLineSurfBz( ptPL, vtDirL, dLen, pSbz, vInfo, false))
+      return false ;
+
+   // filtro le intersezioni
+   FilterLineSurfBzInters( vInfo, vInters) ;
+
+   return true ;
+}
+
+//-------------------------------------------------------------------------------
+bool
+ExeLineSurfBzInters( const Point3d& ptP, const Vector3d& vtDir, int nId, int nRefType,
+   INTDBLVECTOR& vInters)
+{
+   // eseguo
+   bool bOk = MyLineSurfBzInters( ptP, vtDir, nId, nRefType, vInters) ;
+   // se richiesto, salvo il comando Lua equivalente
+   if ( IsCmdLog()) {
+      string sLua = "EgtLineSurfBzInters({" + ToString( ptP) + "},{" +
                                              ToString( vtDir) + "}," +
                                              ToString( nId) + "," +
                                              RefTypeToString( nRefType) + ")" +
-                    " -- Ok=" + ToString( bOk) ;
+                     " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
-  // restituisco l'identificativo della prima nuova entità
+   // restituisco l'identificativo della prima nuova entit�
   return bOk ;
 }

@@ -490,7 +546,7 @@ MyPlaneCurveInters( const Point3d& ptOn, const Vector3d& vtN, const int nId, con
                                                  EPS_SMALL, nPntCount, nCrvCount, nTmp) ;
   nCount = nPntCount + nCrvCount ;

-  // restituisco l'identificativo della prima entità creata
+  // restituisco l'identificativo della prima entit� creata
   return nFirstId ;
 }

@@ -519,7 +575,7 @@ ExePlaneCurveInters( const Point3d& ptOn, const Vector3d& vtN, const int nId, co
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }

-  // restituisco l'identificativo della prima nuova entità
+  // restituisco l'identificativo della prima nuova entit�
   return nFirstId ;
 }

@@ -690,7 +746,7 @@ MyPlaneBoxInters( const Point3d& ptOn, const Vector3d& vtN, const BBox3d& b3Box,
         nFirstId = nNewId ;
      ++ nSrfCount ;
   }
-  // restituisco l'identificativo della prima nuova entità
+  // restituisco l'identificativo della prima nuova entit�
   return nFirstId ;
 }

@@ -723,7 +779,7 @@ ExePlaneBoxInters( const Point3d& ptOn, const Vector3d& vtN, const BBox3d& b3Box
                    ", CrvNbr=" + ToString( nCrvCount) + ", SrfNbr=" + ToString( nSrfCount) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
-  // restituisco l'identificativo della prima nuova entità
+  // restituisco l'identificativo della prima nuova entit�
   return nFirstId ;
 }

@@ -762,7 +818,7 @@ MyPlaneSurfTmInters( const Point3d& ptOn, const Vector3d& vtN, int nId, int nDes
  // inserisco il risultato dell'intersezione nel DB
   int nFirstId = MyAddPlaneIntersResultToGeomDB( pGeomDB, vPnt, vBpt, vTria, frSurf, frDest, nId, nDestGrpId, plPlane.GetVersN(), dToler, 
                                                  nPntCount, nCrvCount, nSrfCount) ; 
-  // restituisco l'identificativo della prima nuova entità
+  // restituisco l'identificativo della prima nuova entit�
   return nFirstId ;
 }

@@ -796,7 +852,7 @@ ExePlaneSurfTmInters( const Point3d& ptOn, const Vector3d& vtN, int nId, int nDe
                    ", CrvNbr=" + ToString( nCrvCount) + ", SrfNbr=" + ToString( nSrfCount) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
-  // restituisco l'identificativo della prima nuova entità
+  // restituisco l'identificativo della prima nuova entit�
   return nFirstId ;
 }

@@ -885,7 +941,7 @@ ExeParPlanesSurfTmInters( const Point3d& ptOn, const Vector3d& vtN, const DBLVEC
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }

-  // restituisco l'identificativo della prima nuova entità
+  // restituisco l'identificativo della prima nuova entit�
   return nFirstId ;
 }

@@ -930,7 +986,7 @@ MyPlaneVolZmapInters( const Point3d& ptOn, const Vector3d& vtN, int nId, int nDe
         nFirstId = nNewId ;
      ++ nCount ;
   }
-  // restituisco l'identificativo della prima nuova entità
+  // restituisco l'identificativo della prima nuova entit�
   return nFirstId ;
 }

@@ -954,7 +1010,7 @@ ExePlaneVolZmapInters( const Point3d& ptOn, const Vector3d& vtN, int nId, int nD
                    " -- Id=" + ToString( nFirstId) + ",Nbr=" + ToString( nCount) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
-  // restituisco l'identificativo della prima nuova entità
+  // restituisco l'identificativo della prima nuova entit�
   return nFirstId ;
 }

@@ -1048,7 +1104,7 @@ ExeCurveCurveInters( const int nId1, const int nId2, const int nDestGrpId, int*
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }

-  // restituisco l'identificativo della prima nuova entità
+  // restituisco l'identificativo della prima nuova entit�
   return nFirstId ;
 }

@@ -1175,7 +1231,7 @@ ExeCurveSurfTmInters( const int nCrvId, const int nStmId, const int nDestGrpId,
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }

-  // restituisco l'identificativo della prima nuova entità
+  // restituisco l'identificativo della prima nuova entit�
   return nFirstId ;
 }

@@ -1308,7 +1364,7 @@ MySurfTmSurfTmInters( int nId1, int nId2, int nDestGrpId, double dToler,
   const ISurfTriMesh* pStm2L = GetSurfTriMesh( Surf2Loc) ;
   if ( pStm2L == nullptr)
      return GDB_ID_NULL ;
-  // eseguo l'intersezione (già espressa nel riferimento destinazione)
+  // eseguo l'intersezione (gi� espressa nel riferimento destinazione)
   PNTVECTOR vPnt ;
   BIPNTVECTOR vBpt ;
   TRIA3DVECTOR vTria ;
@@ -1364,7 +1420,7 @@ MySurfTmSurfTmInters( int nId1, int nId2, int nDestGrpId, double dToler,
         nFirstId = nNewId ;
      ++ nSrfCount ;
   }
-  // restituisco l'identificativo della prima nuova entità
+  // restituisco l'identificativo della prima nuova entit�
   return nFirstId ;
 }

@@ -1396,6 +1452,6 @@ ExeSurfTmSurfTmInters( int nId1, int nId2, int nDestGrpId, double dToler,
                    ", CrvNbr=" + ToString( nCrvCount) + ", SrfNbr=" + ToString( nSrfCount) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
-  // restituisco l'identificativo della prima nuova entità
+  // restituisco l'identificativo della prima nuova entit�
   return nFirstId ;
 }
@@ -2914,6 +2914,16 @@ ExeGetClEntIndex( int nEntId, int& nIndex)
   return pMachMgr->GetClEntIndex( nEntId, nIndex) ;
 }

+//-----------------------------------------------------------------------------
+bool
+ExeGetClEntAxesMask( int nEntId, int& nMask)
+{
+   IMachMgr* pMachMgr = GetCurrMachMgr() ;
+   VERIFY_MACHMGR( pMachMgr, false)
+  // recupero la mascheratura del movimento assi
+   return pMachMgr->GetClEntAxesMask( nEntId, nMask) ;
+}
+
 //-----------------------------------------------------------------------------
 bool
 ExeGetClEntAxesVal( int nEntId, DBLVECTOR& vAxes)
@@ -3202,16 +3212,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)
@@ -3222,6 +3222,16 @@ ExeSetRotAxisBlock( const string& sAxis, double dVal)
   return pMachMgr->SetRotAxisBlock( sAxis, dVal) ;
 }

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

+//-----------------------------------------------------------------------------
+bool
+ExeGetAllCurrAxesNames( STRVECTOR& vAxName)
+{
+   IMachMgr* pMachMgr = GetCurrMachMgr() ;
+   VERIFY_MACHMGR( pMachMgr, false)
+  // recupero gli assi correnti derivanti dalla scelta di tavola e utensile
+   return pMachMgr->GetAllCurrAxesNames( vAxName) ;
+}
+
 //----------------------------------------------------------------------------
 bool
 ExeGetRotAxisBlocked( int nInd, string& sAxis, double& dVal)
@@ -3401,6 +3421,16 @@ ExeGetHeadExitCount( const string& sHead)
   return pMachMgr->GetHeadExitCount( sHead) ;
 }

+//-----------------------------------------------------------------------------
+int
+ExeGetExitId( const string& sHead, int nExit)
+{
+   IMachMgr* pMachMgr = GetCurrMachMgr() ;
+   VERIFY_MACHMGR( pMachMgr, GDB_ID_NULL)
+  // restituisco identificativo dell'uscita della testa indicata nella macchina della macchinata corrente
+   return pMachMgr->GetExitId( sHead, nExit) ;
+}
+
 //-----------------------------------------------------------------------------
 int
 ExeGetTcPosId( const string& sTcPos)
@@ -3461,6 +3491,16 @@ ExeGetAllTablesNames( STRVECTOR& vNames)
   return pMachMgr->GetAllTablesNames( vNames) ;
 }

+//-----------------------------------------------------------------------------
+bool
+ExeGetAllAxesNames( STRVECTOR& vNames)
+{
+   IMachMgr* pMachMgr = GetCurrMachMgr() ;
+   VERIFY_MACHMGR( pMachMgr, false)
+  // recupero l'elenco degli assi
+   return pMachMgr->GetAllAxesNames( vNames) ;
+}
+
 //-----------------------------------------------------------------------------
 bool
 ExeGetAllHeadsNames( STRVECTOR& vNames)
@@ -0,0 +1,316 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2024-2024
+//----------------------------------------------------------------------------
+// File : EXE_TestObjSurface.cpp    Data : 24.03.24      Versione : 2.6c2
+// Contenuto : Funzioni per verificare collisioni tra
+//             Objects e Superfici (TriMesh).
+//
+//
+// Modifiche : 09.01.20 DS Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+//--------------------------- Include ----------------------------------------
+#include "stdafx.h"
+#include "EXE.h"
+#include "EXE_Macro.h"
+#include "EXE_Const.h"
+#include "AuxTools.h"
+#include "GeoTools.h"
+#include "/EgtDev/Include/EXeExecutor.h"
+#include "/EgtDev/Include/EXeConst.h"
+#include "/EgtDev/Include/EGkCDeBoxClosedSurfTm.h"
+#include "/EgtDev/Include/EGkCDeRectPrismoidClosedSurfTm.h"
+#include "/EgtDev/Include/EGkCDeCylClosedSurfTm.h"
+#include "/EgtDev/Include/EGkCDeConeFrustumClosedSurfTm.h"
+#include "/EgtDev/Include/EGkCDeSpheClosedSurfTm.h"
+#include "/EgtDev/Include/EGkCDeClosedSurfTmClosedSurfTm.h"
+#include "/EgtDev/Include/EGkSurfLocal.h"
+#include "/EgtDev/Include/EGkStringUtils3d.h"
+
+using namespace std ;
+
+//----------------------------------------------------------------------------
+static int
+MyTestBoxSurfTm( const Frame3d& frBox, const Vector3d& vtDiag, int nSurfTmId, double dSafeDist, int nRefType)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, -1)
+  // recupero la superficie TriMesh
+   const ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nSurfTmId)) ;
+   if ( pStm == nullptr)
+      return -1 ;
+  // recupero il riferimento della superficie
+   Frame3d frSurf ;
+   if ( ! pGeomDB->GetGlobFrame( nSurfTmId, frSurf))
+      return -1 ;
+  // porto in locale alla superficie il riferimento del box (il vettore è già in questo stesso riferimento)
+   Frame3d frBoxL = GetFrameLocal( pGeomDB, frBox, nRefType, frSurf) ;
+   // verifico l'a collisione'interferenza
+   return ( TestBoxSurfTm( frBoxL, vtDiag, *pStm, dSafeDist) ? 1 : 0) ;
+}
+
+//----------------------------------------------------------------------------
+int
+ExeTestBoxSurface( const Frame3d& frBox, const Vector3d& vtDiag, int nSurfId, double dSafeDist, int nRefType)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   int nRes = -1 ;
+   if ( pGeomDB != nullptr  &&  pGeomDB->GetGeoType( nSurfId) == SRF_TRIMESH)
+      nRes = MyTestBoxSurfTm( frBox, vtDiag, nSurfId, dSafeDist, nRefType) ;
+   // è da aggiungere il test con le superfici di Bezier
+  // se richiesto, salvo il comando Lua equivalente
+   if ( IsCmdLog()) {
+      string sLua = "EgtTestBoxSurface({{" + ToString( frBox.Orig()) + "},{" +
+                                             ToString( frBox.VersX()) + "},{" +
+                                             ToString( frBox.VersY()) + "},{" +
+                                             ToString( frBox.VersZ()) + "}},{" +
+                                             ToString( vtDiag) + "}," +
+                                             IdToString( nSurfId) + "," +
+                                             ToString( dSafeDist) + "," +
+                                             RefTypeToString( nRefType) + ")" +
+                    " -- Res=" + ToString( nRes) ;
+      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
+   }
+  // restituisco risultato
+   return nRes ;
+}
+
+//----------------------------------------------------------------------------
+static int
+MyTestRectPrismoidSurfTm( const Frame3d& frPrismoid, double dBaseLenX, double dBaseLenY,
+                          double dTopLenX, double dTopLenY, double dHeight,
+                          int nSurfTmId, double dSafeDist, int nRefType)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, -1)
+  // recupero la superficie TriMesh
+   const ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nSurfTmId)) ;
+   if ( pStm == nullptr)
+      return -1 ;
+  // recupero il riferimento della superficie
+   Frame3d frSurf ;
+   if ( ! pGeomDB->GetGlobFrame( nSurfTmId, frSurf))
+      return -1 ;
+  // porto in locale alla superficie il riferimento del prismoide rettangolare
+   Frame3d frPrismoidL = GetFrameLocal( pGeomDB, frPrismoid, nRefType, frSurf) ;
+   // verifico l'a collisione'interferenza
+   return ( TestRectPrismoidSurfTm( frPrismoidL, dBaseLenX, dBaseLenY, dTopLenX, dTopLenY, dHeight, *pStm, dSafeDist) ? 1 : 0) ;
+}
+
+//----------------------------------------------------------------------------
+int
+ExeTestRectPrismoidSurface( const Frame3d& frPrismoid, double dBaseLenX, double dBaseLenY,
+                            double dTopLenX, double dTopLenY, double dHeight,
+                            int nSurfId, double dSafeDist, int nRefType)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   int nRes = -1 ;
+   if ( pGeomDB != nullptr  &&  pGeomDB->GetGeoType( nSurfId) == SRF_TRIMESH)
+      nRes = MyTestRectPrismoidSurfTm( frPrismoid, dBaseLenX, dBaseLenY, dTopLenX, dTopLenY, dHeight, nSurfId, dSafeDist, nRefType) ;
+   // è da aggiungere il test con le superfici di Bezier
+  // se richiesto, salvo il comando Lua equivalente
+   if ( IsCmdLog()) {
+      string sLua = "EgtTestRectPrismoidSurface({{" + ToString( frPrismoid.Orig()) + "},{" +
+                                                      ToString( frPrismoid.VersX()) + "},{" +
+                                                      ToString( frPrismoid.VersY()) + "},{" +
+                                                      ToString( frPrismoid.VersZ()) + "}}," +
+                                                      ToString( dBaseLenX) + "," +
+                                                      ToString( dBaseLenY) + "," +
+                                                      ToString( dTopLenX) + "," +
+                                                      ToString( dTopLenY) + "," +
+                                                      ToString( dHeight) + "," +
+                                                      IdToString( nSurfId) + "," +
+                                                      ToString( dSafeDist) + "," +
+                                                      RefTypeToString( nRefType) + ")" +
+                    " -- Res=" + ToString( nRes) ;
+      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
+   }
+  // restituisco risultato
+   return nRes ;
+}
+
+//----------------------------------------------------------------------------
+static int
+MyTestCylSurfTm( const Frame3d& frCyl, double dR, double dH, int nSurfTmId, double dSafeDist, int nRefType)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, -1)
+  // recupero la superficie TriMesh
+   const ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nSurfTmId)) ;
+   if ( pStm == nullptr)
+      return -1 ;
+  // recupero il riferimento della superficie
+   Frame3d frSurf ;
+   if ( ! pGeomDB->GetGlobFrame( nSurfTmId, frSurf))
+      return -1 ;
+  // porto in locale alla superficie il riferimento del cilindro
+   Frame3d frCylL = GetFrameLocal( pGeomDB, frCyl, nRefType, frSurf) ;
+  // verifico l'interferenza
+   return ( TestCylSurfTm( frCylL, dR, dH, *pStm, dSafeDist) ? 1 : 0) ;
+}
+
+//----------------------------------------------------------------------------
+int
+ExeTestCylSurface( const Frame3d& frCyl, double dR, double dH, int nSurfId, double dSafeDist, int nRefType)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   int nRes = -1 ;
+   if ( pGeomDB != nullptr  &&  pGeomDB->GetGeoType( nSurfId) == SRF_TRIMESH)
+      nRes = MyTestCylSurfTm( frCyl, dR, dH, nSurfId, dSafeDist, nRefType) ;
+   // è da aggiungere il test con le superfici di Bezier
+  // se richiesto, salvo il comando Lua equivalente
+   if ( IsCmdLog()) {
+      string sLua = "EgtTestCylSurface({{" + ToString( frCyl.Orig()) + "},{" +
+                                             ToString( frCyl.VersX()) + "},{" +
+                                             ToString( frCyl.VersY()) + "},{" +
+                                             ToString( frCyl.VersZ()) + "}}," +
+                                             ToString( dR) + "," +
+                                             ToString( dH) + "," +
+                                             IdToString( nSurfId) + "," +
+                                             ToString( dSafeDist) + "," +
+                                             RefTypeToString( nRefType) + ")" +
+                    " -- Res=" + ToString( nRes) ;
+      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
+   }
+  // restituisco risultato
+   return nRes ;
+}
+
+//----------------------------------------------------------------------------
+static int
+MyTestConeSurfTm( const Frame3d& frCone, double dR1, double dR2, double dH, int nSurfTmId, double dSafeDist, int nRefType)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, -1)
+  // recupero la superficie TriMesh
+   const ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nSurfTmId)) ;
+   if ( pStm == nullptr)
+      return -1 ;
+  // recupero il riferimento della superficie
+   Frame3d frSurf ;
+   if ( ! pGeomDB->GetGlobFrame( nSurfTmId, frSurf))
+      return -1 ;
+  // porto in locale alla superficie il riferimento del cilindro
+   Frame3d frConeL = GetFrameLocal( pGeomDB, frCone, nRefType, frSurf) ;
+  // verifico l'interferenza
+   return ( TestConeFrustumSurfTm( frConeL, dR1, dR2, dH, *pStm, dSafeDist) ? 1 : 0) ;
+}
+
+//----------------------------------------------------------------------------
+int
+ExeTestConeSurface( const Frame3d& frCone, double dR1, double dR2, double dH, int nSurfId, double dSafeDist, int nRefType)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   int nRes = -1 ;
+   if ( pGeomDB != nullptr  &&  pGeomDB->GetGeoType( nSurfId) == SRF_TRIMESH)
+      nRes = MyTestConeSurfTm( frCone, dR1, dR2, dH, nSurfId, dSafeDist, nRefType) ;
+   // è da aggiungere il test con le superfici di Bezier
+  // se richiesto, salvo il comando Lua equivalente
+   if ( IsCmdLog()) {
+      string sLua = "EgtTestConeSurface({{" + ToString( frCone.Orig()) + "},{" +
+                                              ToString( frCone.VersX()) + "},{" +
+                                              ToString( frCone.VersY()) + "},{" +
+                                              ToString( frCone.VersZ()) + "}}," +
+                                              ToString( dR1) + "," +
+                                              ToString( dR2) + "," +
+                                              ToString( dH) + "," +
+                                              IdToString( nSurfId) + "," +
+                                              ToString( dSafeDist) + "," +
+                                              RefTypeToString( nRefType) + ")" +
+                    " -- Res=" + ToString( nRes) ;
+      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
+   }
+  // restituisco risultato
+   return nRes ;
+}
+
+//----------------------------------------------------------------------------
+static int
+MyTestSpheSurfTm( const Point3d& ptCen, double dR, int nSurfTmId, double dSafeDist, int nRefType)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, -1)
+  // recupero la superficie TriMesh
+   const ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nSurfTmId)) ;
+   if ( pStm == nullptr)
+      return -1 ;
+  // recupero il riferimento della superficie
+   Frame3d frSurf ;
+   if ( ! pGeomDB->GetGlobFrame( nSurfTmId, frSurf))
+      return -1 ;
+  // porto in locale alla superficie il centro della sfera
+   Point3d ptCenL = GetPointLocal( pGeomDB, ptCen, nRefType, frSurf) ;
+   // verifico l'a collisione'interferenza
+   return ( TestSpheSurfTm( ptCenL, dR, *pStm, dSafeDist) ? 1 : 0) ;
+}
+
+//----------------------------------------------------------------------------
+int
+ExeTestSpheSurface( const Point3d& ptCen, double dR, int nSurfId, double dSafeDist, int nRefType)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   int nRes = -1 ;
+   if ( pGeomDB != nullptr  &&  pGeomDB->GetGeoType( nSurfId) == SRF_TRIMESH)
+      nRes = MyTestSpheSurfTm( ptCen, dR, nSurfId, dSafeDist, nRefType) ;
+   // è da aggiungere il test con le superfici di Bezier
+  // se richiesto, salvo il comando Lua equivalente
+   if ( IsCmdLog()) {
+      string sLua = "EgtTestSpheSurface({" + ToString( ptCen) + "}," +
+                                             ToString( dR) + "," +
+                                             IdToString( nSurfId) + "," +
+                                             ToString( dSafeDist) + "," +
+                                             RefTypeToString( nRefType) + ")" +
+                    " -- Res=" + ToString( nRes) ;
+      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
+   }
+  // restituisco risultato
+   return nRes ;
+}
+
+//----------------------------------------------------------------------------
+static int
+MyTestSurfTmSurfTm( int nSurfTm1Id, int nSurfTm2Id, double dSafeDist)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, -1)
+  // recupero il riferimento della seconda superficie
+   Frame3d frSurf2 ;
+   if ( ! pGeomDB->GetGlobFrame( nSurfTm2Id, frSurf2))
+      return -1 ;
+  // recupero la prima superficie in locale alla seconda
+   SurfLocal Surf1Loc( pGeomDB, nSurfTm1Id, frSurf2) ;
+   const ISurfTriMesh* pStm1 = GetSurfTriMesh( Surf1Loc) ;
+   if ( pStm1 == nullptr)
+      return -1 ;
+  // recupero la seconda superficie TriMesh
+   const ISurfTriMesh* pStm2 = GetSurfTriMesh( pGeomDB->GetGeoObj( nSurfTm2Id)) ;
+   if ( pStm2 == nullptr)
+      return -1 ;
+   // verifico l'a collisione'interferenza
+   return ( TestSurfTmSurfTm( *pStm1, *pStm2, dSafeDist) ? 1 : 0) ;
+}
+
+//----------------------------------------------------------------------------
+int
+ExeTestSurfaceSurface( int nSurf1Id, int nSurf2Id, double dSafeDist)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   int nRes = -1 ;
+   if ( pGeomDB != nullptr) {
+      if ( pGeomDB->GetGeoType( nSurf1Id) == SRF_TRIMESH  &&  pGeomDB->GetGeoType( nSurf2Id) == SRF_TRIMESH)
+         nRes = MyTestSurfTmSurfTm( nSurf1Id, nSurf2Id, dSafeDist) ;
+   // è da aggiungere il test con le superfici di Bezier
+   }
+  // se richiesto, salvo il comando Lua equivalente
+   if ( IsCmdLog()) {
+      string sLua = "EgtTestSurfaceSurface({" + IdToString( nSurf1Id) + "," +
+                                                IdToString( nSurf2Id) + "," +
+                                                ToString( dSafeDist) + ")" +
+                    " -- Res=" + ToString( nRes) ;
+      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
+   }
+  // restituisco risultato
+   return nRes ;
+}
@@ -293,6 +293,7 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
    <ClCompile Include="EXE_Picture.cpp" />
    <ClCompile Include="EXE_Scene.cpp" />
    <ClCompile Include="EXE_ShortestPath.cpp" />
+    <ClCompile Include="EXE_TestObjSurface.cpp" />
    <ClCompile Include="EXE_TscExec.cpp" />
    <ClCompile Include="AuxTools.cpp" />
    <ClCompile Include="DllExchange.cpp" />
@@ -316,6 +317,7 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
    <ClCompile Include="LUA_MaxFiller.cpp" />
    <ClCompile Include="LUA_Picture.cpp" />
    <ClCompile Include="LUA_PolynomialRoots.cpp" />
+    <ClCompile Include="LUA_TestObjSurface.cpp" />
    <ClCompile Include="PictureObj.cpp" />
    <ClCompile Include="LUA_Base.cpp" />
    <ClCompile Include="LUA_GdbCreateCurve.cpp" />
@@ -401,6 +401,12 @@
    <ClCompile Include="LUA_GdbGetPocketing.cpp">
      <Filter>File di origine\LUA</Filter>
    </ClCompile>
+    <ClCompile Include="EXE_TestObjSurface.cpp">
+      <Filter>File di origine\EXE</Filter>
+    </ClCompile>
+    <ClCompile Include="LUA_TestObjSurface.cpp">
+      <Filter>File di origine\LUA</Filter>
+    </ClCompile>
  </ItemGroup>
  <ItemGroup>
    <ResourceCompile Include="EgtExecutor.rc">
@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2014-2015
+//  EgalTech 2014-2024
 //----------------------------------------------------------------------------
-// File : LUA.h             Data : 16.01.15        Versione : 1.6a3
+// File : LUA.h             Data : 24.03.24        Versione : 2.6c2
 // Contenuto : Dichiarazioni locali per moduli LUA.
 //
 //
@@ -93,6 +93,9 @@ bool LuaInstallGeoInters( LuaMgr& luaMgr) ;
 //-------------------------- Collision Detection -----------------------------
 bool LuaInstallCDeObjSolid( LuaMgr& luaMgr) ;

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

@@ -130,6 +130,10 @@ LuaInstallEgtFunctions( LuaMgr& LuaMgr)
      LOG_ERROR( GetLogger(), "Error in LuaInstallCDeObjSolid (LuaInstallEgtFunctions)")
      return false ;
   }
+   if ( ! LuaInstallTestObjSurface( LuaMgr)) {
+      LOG_ERROR( GetLogger(), "Error in LuaInstallTestObjSurface (LuaInstallEgtFunctions)")
+      return false ;
+   }
   if ( ! LuaInstallMachMgr( LuaMgr)) {
      LOG_ERROR( GetLogger(), "Error in LuaInstallMachMgr (LuaInstallEgtFunctions)")
      return false ;
@@ -188,14 +188,16 @@ LuaImport3dm( lua_State* L)
 static int
 LuaAdvancedImport( lua_State* L)
 {
-  // 1 o 2 parametri : path del file da importare [, dLinToler]
+  // 1 o 2 o 3 parametri : path del file da importare [, dLinToler] [, nFlag]
   string sFilePath ;
   LuaCheckParam( L, 1, sFilePath)
   double dLinToler = 0.1 ;
   LuaGetParam( L, 2, dLinToler) ;
+   int nFlag = 0 ;
+   LuaGetParam( L, 3, nFlag) ;
   LuaClearStack( L) ;
  // apro il file
-   bool bOk = ExeAdvancedImport( sFilePath, dLinToler) ; 
+   bool bOk = ExeAdvancedImport( sFilePath, dLinToler, nFlag) ; 
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
@@ -400,13 +400,13 @@ LuaCreateDiametralDimension( lua_State* L )
 static int
 LuaCreateAngularDimension(lua_State* L)
 {
-   // 6 o 7 parametri : ParentId, ptP1, ptV, ptP2, ptDim, Text [, nRefType]
+   // 6 o 7 parametri : ParentId, ptV, ptP1, ptP2, ptDim, Text [, nRefType]
    int nParentId ;
    LuaCheckParam( L, 1, nParentId)
-    Point3d ptP1 ;
-    LuaCheckParam( L, 2, ptP1) ;
    Point3d ptV ;
-    LuaCheckParam( L, 3, ptV) ;
+    LuaCheckParam( L, 2, ptV) ;
+    Point3d ptP1 ;
+    LuaCheckParam( L, 3, ptP1) ;
    Point3d ptP2 ;
    LuaCheckParam( L, 4, ptP2) ;
    Point3d ptDim ;
@@ -417,7 +417,39 @@ LuaCreateAngularDimension(lua_State* L)
    LuaGetParam( L, 7, nRefType) ;
    LuaClearStack( L) ;
   // creo la quota angolare
-    int nId = ExeCreateAngularDimension( nParentId, ptP1, ptV, ptP2, ptDim, sText, nRefType) ;
+    int nId = ExeCreateAngularDimension( nParentId, ptV, ptP1, ptP2, ptDim, sText, nRefType) ;
+   // restituisco il risultato
+    if ( nId != GDB_ID_NULL)
+        LuaSetParam( L, nId) ;
+    else
+        LuaSetParam( L) ;
+    return 1 ;
+}
+
+//-------------------------------------------------------------------------------
+static int
+LuaCreateAngularDimensionEx(lua_State* L)
+{
+   // 7 o 8 parametri : ParentId, ptV1, ptP1, ptV2, ptP2, ptDim, Text [, nRefType]
+    int nParentId ;
+    LuaCheckParam( L, 1, nParentId)
+    Point3d ptV1 ;
+    LuaCheckParam( L, 2, ptV1) ;
+    Point3d ptP1 ;
+    LuaCheckParam( L, 3, ptP1) ;
+    Point3d ptV2 ;
+    LuaCheckParam( L, 4, ptV2) ;
+    Point3d ptP2 ;
+    LuaCheckParam( L, 5, ptP2) ;
+    Point3d ptDim ;
+    LuaCheckParam( L, 6, ptDim) ;
+    string sText ;
+    LuaCheckParam( L, 7, sText) ;
+    int nRefType = RTY_DEFAULT ;
+    LuaGetParam( L, 8, nRefType) ;
+    LuaClearStack( L) ;
+   // creo la quota angolare
+    int nId = ExeCreateAngularDimensionEx( nParentId, ptV1, ptP1, ptV2, ptP2, ptDim, sText, nRefType) ;
   // restituisco il risultato
    if ( nId != GDB_ID_NULL)
        LuaSetParam( L, nId) ;
@@ -497,7 +529,8 @@ LuaInstallGdbCreate( LuaMgr& luaMgr)
   bOk = bOk && luaMgr.RegisterFunction( "EgtAlignedDimension", LuaCreateAlignedDimension) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtRadialDimension", LuaCreateRadialDimension) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtDiametralDimension", LuaCreateDiametralDimension) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtAngularDimension", LuaCreateAngularDimension);
+   bOk = bOk && luaMgr.RegisterFunction( "EgtAngularDimension", LuaCreateAngularDimension) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtAngularDimensionEx", LuaCreateAngularDimensionEx) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtAngularDimensionFromLines", LuaCreateAngularDimensionFromLines) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtAngularDimensionFromArc", LuaCreateAngularDimensionFromArc) ;
   return bOk ;
@@ -425,6 +425,34 @@ LuaCreateArc3P( lua_State* L)
   return 1 ;
 }

+//-------------------------------------------------------------------------------
+static int
+LuaCreateArc2PR( lua_State* L)
+{
+  // 5 o 6 parametri : ParentId, PtStart, PtEnd, dRad, bCCW [, nRefType]
+   int nParentId ;
+   LuaCheckParam( L, 1, nParentId)
+   Point3d ptStart ;
+   LuaCheckParam( L, 2, ptStart)
+   Point3d ptEnd ;
+   LuaCheckParam( L, 3, ptEnd)
+   double dRad ;
+   LuaCheckParam( L, 4, dRad)
+   bool bCCW ;
+   LuaCheckParam( L, 5, bCCW) ;
+   int nRefType = RTY_DEFAULT ;
+   LuaGetParam( L, 6, nRefType) ;
+   LuaClearStack( L) ;
+  // creo l'arco
+   int nId = ExeCreateArc2PR( nParentId, ptStart, ptEnd, dRad, bCCW, nRefType) ;
+  // restituisco il risultato
+   if ( nId != GDB_ID_NULL)
+      LuaSetParam( L, nId) ;
+   else
+      LuaSetParam( L) ;
+   return 1 ;
+}
+
 //-------------------------------------------------------------------------------
 static int
 LuaCreateArc2PB( lua_State* L)
@@ -1083,6 +1111,7 @@ LuaInstallGdbCreateCurve( LuaMgr& luaMgr)
   bOk = bOk && luaMgr.RegisterFunction( "EgtArcC2P", LuaCreateArcC2P) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtArcC2PEx", LuaCreateArcC2PEx) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtArc3P", LuaCreateArc3P) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtArc2PR", LuaCreateArc2PR) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtArc2PB", LuaCreateArc2PB) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtArc2PD", LuaCreateArc2PD) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtArc2PDEx", LuaCreateArc2PDEx) ;
@@ -660,24 +660,29 @@ LuaCreateSurfTmRectSwept( lua_State* L)
 static int
 LuaCreateSurfTmSwept( lua_State* L)
 {
-  // 4, 5 o 6 parametri : ParentId, SectId, GuideId, bCapEnds [, dTol] [, vtStatic]
+  // 4, 5, 6 o 7 parametri : ParentId, SectId, GuideId [, vtAx], bCapEnds [, dTol] [, nRefType]
   int nParentId ;
   LuaCheckParam( L, 1, nParentId)
   int nSectId ;
   LuaCheckParam( L, 2, nSectId)
   int nGuideId ;
   LuaCheckParam( L, 3, nGuideId)
+   int nPar = 4 ;
+   Vector3d vtAx = V_NULL ;
+   if ( LuaGetParam( L, nPar, vtAx))
+      ++ nPar ;
   bool bCapEnds ;
-   LuaCheckParam( L, 4, bCapEnds)
+   LuaCheckParam( L, nPar, bCapEnds)
+   ++ nPar ;
   double dLinTol = LIN_TOL_SRF ;
-   Vector3d vtStatic = V_INVALID ;
-   if ( LuaGetParam( L, 5, dLinTol)) {
-      LuaGetParam( L, 6, vtStatic) ;
-   }
+   if ( LuaGetParam( L, nPar, dLinTol))
+      ++ nPar ;
+   int nRefType = RTY_DEFAULT ;
+   if ( LuaGetParam( L, nPar, nRefType))
+      ++ nPar ;
   LuaClearStack( L) ;
  // creo STM swept
-   int nId = ExeCreateSurfTmSwept( nParentId, nSectId, nGuideId, bCapEnds, dLinTol,
-                                   vtStatic.IsValid() ? &vtStatic : nullptr) ;
+   int nId = ExeCreateSurfTmSwept( nParentId, nSectId, nGuideId, vtAx, bCapEnds, dLinTol, nRefType) ;
  // restituisco il risultato
   if ( nId != GDB_ID_NULL)
      LuaSetParam( L, nId) ;
@@ -791,26 +796,6 @@ LuaCreateSurfTmBySewing( lua_State* L)
   return 1 ;
 }

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

+//-------------------------------------------------------------------------------
+static int
+LuaCreateSurfBezierTria2D( lua_State* L)
+{
+   // 2, 3 o 4 parametri : ParentId, nId [, nTextHeight] [, bShowTrim]
+   int nParentId ;
+   LuaCheckParam( L, 1, nParentId)
+      int nSurfBzId ;
+   LuaCheckParam( L, 2, nSurfBzId)
+      int nTextHeight = 50 ;
+   bool bShowTrim = false ;
+   if ( LuaGetParam( L, 3, nTextHeight))
+      LuaGetParam( L, 4, bShowTrim) ;
+   else
+      LuaGetParam( L, 3, bShowTrim) ;
+   LuaClearStack( L) ;
+   // creo la superficie
+   int nCount = 0 ;
+   int nId = ExeCreateSurfBezierTria2D( nParentId, nSurfBzId, nTextHeight, bShowTrim, &nCount) ;
+   // restituisco il risultato
+   if ( nId != GDB_ID_NULL) {
+      LuaSetParam( L, nId) ;
+      LuaSetParam( L, nCount) ;  
+   }
+   else {
+      LuaSetParam( L) ;
+      LuaSetParam( L) ;
+   }
+   return 2 ;
+}
+
+//-------------------------------------------------------------------------------
+static int
+LuaCreateBezierSphere( lua_State* L)
+{
+   // 3 o 4 parametri : ParentId, ptCenter, dRad [, nRefType]
+   int nParentId ;
+   LuaCheckParam( L, 1, nParentId)
+   Point3d ptCenter ;
+   LuaCheckParam( L, 2, ptCenter)
+   double dRad ;
+   LuaCheckParam( L, 3, dRad)
+   int nRefType = RTY_DEFAULT ;
+   LuaGetParam( L, 4, nRefType) ;
+   // creo la superficie
+   int nCount = 0 ;
+   int nId = ExeCreateBezierSphere( nParentId, ptCenter, dRad, nRefType) ;
+   // restituisco il risultato
+   if ( nId != GDB_ID_NULL) {
+      LuaSetParam( L, nId) ;
+      LuaSetParam( L, nCount) ;  
+   }
+   else {
+      LuaSetParam( L) ;
+      LuaSetParam( L) ;
+   }
+   return 2 ;
+}
+
 //-------------------------------------------------------------------------------
 bool
 LuaInstallGdbCreateSurf( LuaMgr& luaMgr)
@@ -966,10 +1010,11 @@ LuaInstallGdbCreateSurf( LuaMgr& luaMgr)
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmRuled", LuaCreateSurfTmRuled) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmByTriangles", LuaCreateSurfTmByTriangles) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmBySewing", LuaCreateSurfTmBySewing) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmBySurfBezier", LuaCreateSurfTmBySurfBezier) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmByVolZmap", LuaCreateSurfTmByVolZmap) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBezier", LuaCreateSurfBezier) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBezierRat", LuaCreateSurfBezierRational) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBezierLeaves", LuaCreateSurfBezierLeaves) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBezierTria2D", LuaCreateSurfBezierTria2D) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtCreateBezierSphere", LuaCreateBezierSphere) ;
   return bOk ;
 }
@@ -54,6 +54,42 @@ LuaCreateVolZmapBox( lua_State* L)
   return 1 ;
 }

+//-------------------------------------------------------------------------------
+static int
+LuaCreateVolZmapEmpty( lua_State* L)
+{
+  // 6 o 7 o 8 parametri : ParentId, PtIni, dDimX, dDimY, dDimZ, dPrec [, bTriDex] [, nRefType]
+   int nParentId ;
+   LuaCheckParam( L, 1, nParentId)
+   Point3d ptIni ;
+   LuaCheckParam( L, 2, ptIni)
+   double dDimX ;
+   LuaCheckParam( L, 3, dDimX)
+   double dDimY ;
+   LuaCheckParam( L, 4, dDimY)
+   double dDimZ ;
+   LuaCheckParam( L, 5, dDimZ)
+   double dPrec ;
+   LuaCheckParam( L, 6, dPrec)
+   bool bTriDex = true ;
+   int nRefType = RTY_DEFAULT ;
+   if ( ! LuaGetParam( L, 7, bTriDex))
+      LuaGetParam( L, 7, nRefType) ;
+   else
+      LuaGetParam( L, 8, nRefType) ;
+   LuaClearStack( L) ;
+  // creo VZM parallelepipedo
+   int nId = ExeCreateVolZmapEmpty( nParentId, ptIni, dDimX, dDimY, dDimZ, dPrec, bTriDex, nRefType) ;
+  // restituisco il risultato
+   if ( nId != GDB_ID_NULL)
+      LuaSetParam( L, nId) ;
+   else
+      LuaSetParam( L) ;
+   return 1 ;
+}
+
+
+
 //-------------------------------------------------------------------------------
 static int
 LuaCreateVolZmapByRegionExtrusion( lua_State* L)
@@ -110,6 +146,7 @@ LuaInstallGdbCreateVol( LuaMgr& luaMgr)
 {
   bool bOk = ( &luaMgr != nullptr) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtVolZmapBox", LuaCreateVolZmapBox) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtVolZmapEmpty", LuaCreateVolZmapEmpty) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtVolZmapByRegionExtrusion", LuaCreateVolZmapByRegionExtrusion) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtVolZmapFromSurfTm", LuaCreateVolZmapFromSurfTm) ;
   return bOk ;
@@ -975,6 +975,32 @@ LuaProjectCurveOnSurfTm( lua_State* L)
   return 1 ;
 }

+//----------------------------------------------------------------------------
+static int
+LuaProjectCurveOnSurfTmExt( lua_State* L)
+{
+  // 4, 5, 6 o 7 parametri : nCurveId, nSurfTmId, nGuideId, nDestGrpId [, dLinTol [, dMaxSegmLen] [, bDirFromGuide]]
+   int nCurveId ;
+   LuaCheckParam( L, 1, nCurveId)
+   int nSurfTmId ;
+   LuaCheckParam( L, 2, nSurfTmId)
+   int nGuideId ;
+   LuaCheckParam( L, 3, nGuideId)
+   int nDestGrpId ;
+   LuaCheckParam( L, 4, nDestGrpId)
+   double dLinTol = 0.01 ;
+   double dMaxSegmLen = INFINITO ;
+   bool bDirFromGuide = false ;
+   if ( LuaGetParam( L, 5, dLinTol)  &&
+        LuaGetParam( L, 6, dMaxSegmLen))
+      LuaGetParam( L, 7, bDirFromGuide) ;
+   LuaClearStack( L) ;
+  // proietto la curva su una trimesh secondo la direzione data
+   bool bOk = ExeProjectCurveOnSurfTmExt( nCurveId, nSurfTmId, nGuideId, nDestGrpId, dLinTol, dMaxSegmLen, bDirFromGuide) ;
+   LuaSetParam( L, bOk) ;
+   return 1 ;
+}
+
 //----------------------------------------------------------------------------
 static int
 LuaCurveGetVoronoi( lua_State* L)
@@ -1107,6 +1133,7 @@ LuaInstallGdbModifyCurve( LuaMgr& luaMgr)
   bOk = bOk && luaMgr.RegisterFunction( "EgtChainCurvesInGroup", LuaChainCurvesInGroup) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtReorderCurvesInGroup", LuaReorderCurvesInGroup) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtProjectCurveOnSurfTm", LuaProjectCurveOnSurfTm) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtProjectCurveOnSurfTmExt", LuaProjectCurveOnSurfTmExt) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtCurveGetVoronoi", LuaCurveGetVoronoi) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtCurveMedialAxisAdv", LuaCurveMedialAxisAdv) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtCurveGetFatCurve", LuaCurveGetFatCurve) ;
@@ -23,7 +23,6 @@

 using namespace std ;

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

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

+//----------------------------------------------------------------------------
+static int
+LuaCutSurfBzPlane( lua_State* L)
+{
+  // 4 o 5 parametri : Id, ptOn, vtN, bSaveOnEq [, nRefType]
+   int nId ;
+   LuaCheckParam( L, 1, nId)
+   Point3d ptOn ;
+   LuaCheckParam( L, 2, ptOn)
+   Vector3d vtN ;
+   LuaCheckParam( L, 3, vtN)
+   bool bSaveOnEq ;
+   LuaGetParam( L, 4, bSaveOnEq) ;
+   int nRefType = RTY_DEFAULT ;
+   LuaGetParam( L, 5, nRefType) ;
+   LuaClearStack( L) ;
+  // taglio la superficie con ilpiano
+   bool bOk = ExeCutSurfBzPlane( nId, ptOn, vtN, bSaveOnEq, nRefType) ;
+  // restituisco il risultato
+   LuaSetParam( L, bOk) ;
+   return 1 ;
+}
+
 //----------------------------------------------------------------------------
 static int
 LuaCutSurfTmClosedCurve( lua_State* L)
@@ -356,20 +404,6 @@ LuaSurfTmIntersect( lua_State* L)
   return 1 ;
 }

-//-------------------------------------------------------------------------------
-static int
-LuaSurfTmResetTwoColors( lua_State* L)
-{
-  // 1 parametro : Id
-   int nId ;
-   LuaCheckParam( L, 1, nId)
-   LuaClearStack( L) ;
-  // eseguo reset TFlag per annullare due colori
-   bool bOk = ExeSurfTmResetTwoColors( nId) ;
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
 //-------------------------------------------------------------------------------
 static int
 LuaSurfTmSplit( lua_State* L)
@@ -445,18 +479,48 @@ LuaSurfTmSubtractProjectedFacesOnFace( lua_State* L)
   return 4 ;
 }

+//-------------------------------------------------------------------------------
+static int
+LuaSurfTmResetTwoColors( lua_State* L)
+{
+  // 1 parametro : Id
+   int nId ;
+   LuaCheckParam( L, 1, nId)
+   LuaClearStack( L) ;
+  // eseguo reset TFlag per annullare due colori
+   bool bOk = ExeSurfTmResetTwoColors( nId) ;
+   LuaSetParam( L, bOk) ;
+   return 1 ;
+}
+
+//-------------------------------------------------------------------------------
+static int
+LuaSurfTmSetShowEdges( lua_State* L)
+{
+  // 2 parametri : Id, bShow
+   int nId ;
+   LuaCheckParam( L, 1, nId)
+   bool bShow ;
+   LuaCheckParam( L, 2, bShow) ;
+   LuaClearStack( L) ;
+  // imposto flag visualizzazione spigoli vivi
+   bool bOk = ExeSurfTmSetShowEdges( nId, bShow) ;
+  // restituisco il risultato
+   LuaSetParam( L, bOk) ;
+   return 1 ;
+}
+
 //-------------------------------------------------------------------------------
 static int
 LuaSurfBzTrim( lua_State* L)
 {
-   // 2 parametri : nId, nCutterId
+  // 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) ;
+  // taglio la prima superficie in base alla seconda
   bool bOk = ExeSurfBzTrim( nId, nCutterId) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
@@ -476,19 +540,22 @@ LuaInstallGdbModifySurf( LuaMgr& luaMgr)
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfFrOffset", LuaSurfFrOffset) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfFrOffsetAdv", LuaSurfFrOffsetAdv) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmMoveVertex", LuaSurfTmMoveVertex) ;  
+   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmMoveFacet", LuaSurfTmMoveFacet) ;  
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmToTriangles", LuaSurfTmToTriangles) ;  
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmRemoveFacet", LuaSurfTmRemoveFacet) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmSwapFacets", LuaSurfTmSwapFacets) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmRemovePart", LuaSurfTmRemovePart) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtCutSurfTmPlane", LuaCutSurfTmPlane) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtCutSurfBzPlane", LuaCutSurfBzPlane) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtCutSurfTmClosedCurve", LuaCutSurfTmClosedCurve) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmAdd", LuaSurfTmAdd) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmSubtract", LuaSurfTmSubtract) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmIntersect", LuaSurfTmIntersect) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmResetTwoColors", LuaSurfTmResetTwoColors) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmSplit", LuaSurfTmSplit) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmCut", LuaSurfTmCut) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmSubtractProjectedFacesOnFace", LuaSurfTmSubtractProjectedFacesOnFace) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmResetTwoColors", LuaSurfTmResetTwoColors) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmSetShowEdges", LuaSurfTmSetShowEdges) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBzTrim", LuaSurfBzTrim) ;
   return bOk ;
 }
@@ -56,6 +56,23 @@ LuaVolZmapChangeResolution( lua_State* L)
   return 1 ;
 }

+//-------------------------------------------------------------------------------
+static int
+LuaVolZmapSetShowEdges( lua_State* L)
+{
+  // 2 parametri : Id, bShow
+   int nId ;
+   LuaCheckParam( L, 1, nId)
+   bool bShow ;
+   LuaCheckParam( L, 2, bShow) ;
+   LuaClearStack( L) ;
+  // imposto flag visualizzazione spigoli vivi
+   bool bOk = ExeVolZmapSetShowEdges( nId, bShow) ;
+  // restituisco il risultato
+   LuaSetParam( L, bOk) ;
+   return 1 ;
+}
+
 //----------------------------------------------------------------------------
 static int
 LuaRemoveVolZmapPart( lua_State* L)
@@ -135,7 +152,7 @@ LuaVolZmapSetAdvTool( lua_State* L)
 static int
 LuaVolZmapSetSawTool( lua_State* L)
 {
-  // 7 o 8 parametri : vIds, sToolName, dLen, dDiam, dThick, dStemDiam, dCornR, nFlag
+  // 7 o 8 parametri : vIds, sToolName, dLen, dDiam, dThick, dStemDiam, dCornR [, nFlag]
   INTVECTOR vIds ;
   LuaCheckParam( L, 1, vIds)
   string sToolName ;
@@ -164,7 +181,7 @@ LuaVolZmapSetSawTool( lua_State* L)
 static int
 LuaVolZmapSetGenTool( lua_State* L)
 {
-  // 3 o 4 parametri : vIds, sToolName, ToolSectId, nFlag
+  // 3 o 4 parametri : vIds, sToolName, ToolSectId [, nFlag]
   INTVECTOR vIds ;
   LuaCheckParam( L, 1, vIds)
   string sToolName ;
@@ -185,7 +202,7 @@ LuaVolZmapSetGenTool( lua_State* L)
 static int
 LuaVolZmapSetMortiserTool( lua_State* L)
 {
-  // 6 o 7 parametri : Id, sToolName, dLen, dWidth, dThick, dCornR, nFlag
+  // 6 o 7 parametri : Id, sToolName, dLen, dWidth, dThick, dCornR [, nFlag]
   INTVECTOR vIds ;
   LuaCheckParam( L, 1, vIds)
   string sToolName ;
@@ -212,7 +229,7 @@ LuaVolZmapSetMortiserTool( lua_State* L)
 static int
 LuaVolZmapSetChiselTool( lua_State* L)
 {
-  // 5 o 6 parametri : vIds, sToolName, dLen, dWidth, dThick, nFlag
+  // 5 o 6 parametri : vIds, sToolName, dLen, dWidth, dThick [, nFlag]
   INTVECTOR vIds ;
   LuaCheckParam( L, 1, vIds)
   string sToolName ;
@@ -233,6 +250,31 @@ LuaVolZmapSetChiselTool( lua_State* L)
   return 1 ;
 }

+//----------------------------------------------------------------------------
+static int
+LuaVolZmapSetAdditiveTool( lua_State* L)
+{
+  // 5 o 6 parametri : vIds, sToolName, dLen, dDiam, dCornR [, nFlag]
+   INTVECTOR vIds ;
+   LuaCheckParam( L, 1, vIds)
+   string sToolName ;
+   LuaCheckParam( L, 2, sToolName)
+   double dLen ;
+   LuaCheckParam( L, 3, dLen)
+   double dDiam ;
+   LuaCheckParam( L, 4, dDiam)
+   double dCornR ;
+   LuaCheckParam( L, 5, dCornR)
+   int nFlag = 1 ;
+   LuaGetParam( L, 6, nFlag) ;
+   LuaClearStack( L) ;
+  // imposto utensile additivo a Zmap indicati
+   bool bOk = ExeVolZmapSetAdditiveTool( vIds, sToolName, dLen, dDiam, dCornR, nFlag, true) ;
+  // restituisco il risultato
+   LuaSetParam( L, bOk) ;
+   return 1 ;
+}
+
 //----------------------------------------------------------------------------
 static int
 LuaVolZmapResetTool( lua_State* L)
@@ -350,6 +392,7 @@ LuaInstallGdbModifyVol( LuaMgr& luaMgr)
   bool bOk = ( &luaMgr != nullptr) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtExplodeVolume", LuaExplodeVolume) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtVolZmapChangeResolution", LuaVolZmapChangeResolution) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtVolZmapSetShowEdges", LuaVolZmapSetShowEdges) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtRemoveVolZmapPart", LuaRemoveVolZmapPart) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtVolZmapSetStdTool", LuaVolZmapSetStdTool) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtVolZmapSetAdvTool", LuaVolZmapSetAdvTool) ;
@@ -357,6 +400,7 @@ LuaInstallGdbModifyVol( LuaMgr& luaMgr)
   bOk = bOk && luaMgr.RegisterFunction( "EgtVolZmapSetGenTool", LuaVolZmapSetGenTool) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtVolZmapSetMortiserTool", LuaVolZmapSetMortiserTool) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtVolZmapSetChiselTool", LuaVolZmapSetChiselTool) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtVolZmapSetAdditiveTool", LuaVolZmapSetAdditiveTool) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtVolZmapResetTool", LuaVolZmapResetTool) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtVolZmapGetToolOutline", LuaVolZmapGetToolOutline) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtVolZmapMillingStep", LuaVolZmapMillingStep) ;
@@ -31,6 +31,7 @@
 #include "/EgtDev/Include/EgtNumUtils.h"
 #include "/EgtDev/Include/EgtStringConverter.h"
 #include "Windowsx.h"
+#include "shlobj.h"

 using namespace std ;

@@ -756,6 +757,67 @@ LuaCompareFilesLastWriteTime( lua_State* L)
   return 1 ;
 }

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

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

+//----------------------------------------------------------------------------
+static int
+LuaLineSurfBzInters( lua_State* L)
+{
+   // 3 o 4 parametri : ptP, vtDir, Id, [, nRefId]
+   Point3d ptP ;
+   LuaCheckParam( L, 1, ptP)
+      Vector3d vtDir ;
+   LuaCheckParam( L, 2, vtDir)
+      int nId ;
+   LuaCheckParam( L, 3, nId)
+      int nRefType = nId ;
+   LuaGetParam( L, 4, nRefType) ;
+   LuaClearStack( L) ;
+   // recupero i punti di intersezione tra linea e superficie trimesh
+   INTDBLVECTOR vInters ;
+   if ( ExeLineSurfBzInters( ptP, vtDir, nId, nRefType, vInters)) {
+      LuaSetParam( L, true) ;
+      INTVECTOR vType( vInters.size()) ;
+      DBLVECTOR vPar( vInters.size()) ;
+      for ( size_t i = 0 ; i < vInters.size() ; ++ i) {
+         vType[i] = vInters[i].first ;
+         vPar[i] = vInters[i].second ;
+      }
+      LuaSetParam( L, vType) ;
+      LuaSetParam( L, vPar) ;
+   }
+   else {
+      LuaSetParam( L) ;
+      LuaSetParam( L) ;
+      LuaSetParam( L) ;
+   }
+   return 3 ;
+}
+
 //----------------------------------------------------------------------------
 static int
 LuaLineVolZmapInters( lua_State* L)
@@ -405,6 +440,7 @@ LuaInstallGeoInters( LuaMgr& luaMgr)
   bOk = bOk && luaMgr.RegisterFunction( "EgtLineCurveInters", LuaLineCurveInters) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtLineBoxInters", LuaLineBoxInters) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtLineSurfTmInters", LuaLineSurfTmInters) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtLineSurfBzInters", LuaLineSurfBzInters) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtLineVolZmapInters", LuaLineVolZmapInters) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtPlaneCurveInters", LuaPlaneCurveInters) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtPlaneBoxInters", LuaPlaneBoxInters) ;
@@ -3030,6 +3030,25 @@ LuaGetClEntIndex( lua_State* L)
   return 1 ;
 }

+//-----------------------------------------------------------------------------
+static int
+LuaGetClEntAxesMask( lua_State* L)
+{
+  // 1 parametro : nEntId
+   int nEntId ;
+   LuaGetParam( L, 1, nEntId) ;
+   LuaClearStack( L) ;
+  // recupero la mascheratura del movimento assi
+   int nMask ;
+   bool bOk = ExeGetClEntAxesMask( nEntId, nMask) ;
+  // restituisco il risultato
+   if ( bOk)
+      LuaSetParam( L, nMask) ;
+   else
+      LuaSetParam( L) ;
+   return 1 ;
+}
+
 //-----------------------------------------------------------------------------
 static int
 LuaGetClEntAxesVal( lua_State* L)
@@ -3335,23 +3354,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)
@@ -3371,26 +3373,19 @@ LuaSetRotAxisBlock( lua_State* L)

 //-------------------------------------------------------------------------------
 static int
-LuaGetRotAxisBlocked( lua_State* L)
+LuaGetCalcTable( lua_State* L)
 {
-  // 1 parametro : nInd ( 0-based)
-   int nInd ;
-   LuaCheckParam( L, 1, nInd)
+  // nessun parametro
   LuaClearStack( L) ;
-  // recupero dati bloccaggio asse in posizione nInd
-   string sAxis ;
-   double dVal ;
-   bool bOk = ExeGetRotAxisBlocked( nInd, sAxis, dVal) ;
+  // recupero la tavola correnti
+   string sTable ;
+   bool bOk = ExeGetCalcTable( sTable) ;
  // restituisco il risultato
-   if ( bOk) {
-      LuaSetParam( L, sAxis) ;
-      LuaSetParam( L, dVal) ;
-   }
-   else {
+   if ( bOk)
+      LuaSetParam( L, sTable) ;
+   else
      LuaSetParam( L) ;
-      LuaSetParam( L) ;
-   }
-   return 2 ;
+   return 1 ;
 }

 //-------------------------------------------------------------------------------
@@ -3418,6 +3413,47 @@ LuaGetCalcTool( lua_State* L)
   return 3 ;
 }

+//-------------------------------------------------------------------------------
+static int
+LuaGetAllCurrAxesNames( lua_State* L)
+{
+  // nessun parametro
+   LuaClearStack( L) ;
+  // imposto l'utensile corrente per il calcolo
+   STRVECTOR vAxName ;
+   bool bOk = ExeGetAllCurrAxesNames( vAxName) ;
+  // restituisco il risultato
+   if ( bOk)
+      LuaSetParam( L, vAxName) ;
+   else
+      LuaSetParam( L) ;
+   return 1 ;
+}
+
+//-------------------------------------------------------------------------------
+static int
+LuaGetRotAxisBlocked( lua_State* L)
+{
+  // 1 parametro : nInd ( 0-based)
+   int nInd ;
+   LuaCheckParam( L, 1, nInd)
+   LuaClearStack( L) ;
+  // recupero dati bloccaggio asse in posizione nInd
+   string sAxis ;
+   double dVal ;
+   bool bOk = ExeGetRotAxisBlocked( nInd, sAxis, dVal) ;
+  // restituisco il risultato
+   if ( bOk) {
+      LuaSetParam( L, sAxis) ;
+      LuaSetParam( L, dVal) ;
+   }
+   else {
+      LuaSetParam( L) ;
+      LuaSetParam( L) ;
+   }
+   return 2 ;
+}
+
 //-------------------------------------------------------------------------------
 static int
 LuaGetCalcAngles( lua_State* L)
@@ -3485,7 +3521,7 @@ LuaGetCalcPositions( lua_State* L)
 static int
 LuaGetCalcTipFromPositions( lua_State* L)
 {
-  // da 5 a 8 parametri : dX, dY, dZ, dAngA [, dAngB] [, dAngC] [, dAngD], bBottom
+  // da 5 a 10 parametri : dX, dY, dZ, dAngR1[, dAngR2][, dAngR3][, dAngR4][, dAngR5][, dAngR6], bBottom
   double dX ;
   LuaCheckParam( L, 1, dX)
   double dY ;
@@ -3494,7 +3530,7 @@ LuaGetCalcTipFromPositions( lua_State* L)
   LuaCheckParam( L, 3, dZ)
   DBLVECTOR vAng ;
   int i ;
-   for ( i = 4 ; i <= 7 ; ++ i) {
+   for ( i = 4 ; i <= 9 ; ++ i) {
      double dAng ;
      if ( LuaGetParam( L, i, dAng))
         vAng.emplace_back( dAng) ;
@@ -3519,9 +3555,9 @@ LuaGetCalcTipFromPositions( lua_State* L)
 static int
 LuaGetCalcToolDirFromAngles( lua_State* L)
 {
-  // da 1 a 4 parametri : dAngA, dAngB, dAngC, dAngD
+  // da 1 a 6 parametri : dAngR1, dAngR2, dAngR3, dAngR4, dAngR5, dAngR6
   DBLVECTOR vAng ;
-   for ( int i = 1 ; i <= 4 ; ++ i) {
+   for ( int i = 1 ; i <= 6 ; ++ i) {
      double dAng ;
      if ( LuaGetParam( L, i, dAng))
         vAng.emplace_back( dAng) ;
@@ -3544,9 +3580,9 @@ LuaGetCalcToolDirFromAngles( lua_State* L)
 static int
 LuaGetCalcAuxDirFromAngles( lua_State* L)
 {
-  // da 1 a 4 parametri : dAngA, dAngB, dAngC, dAngD
+  // da 1 a 6 parametri : dAngR1, dAngR2, dAngR3, dAngR4, dAngR5, dAngR6 
   DBLVECTOR vAng ;
-   for ( int i = 1 ; i <= 4 ; ++ i) {
+   for ( int i = 1 ; i <= 6 ; ++ i) {
      double dAng ;
      if ( LuaGetParam( L, i, dAng))
         vAng.emplace_back( dAng) ;
@@ -3701,6 +3737,26 @@ LuaGetHeadExitCount( lua_State* L)
   return 1 ;
 }

+//-------------------------------------------------------------------------------
+static int
+LuaGetExitId( lua_State* L)
+{
+  // 2 parametri : sHead, nExit
+   string sHead ;
+   LuaCheckParam( L, 1, sHead)
+   int nExit ;
+   LuaCheckParam( L, 2, nExit)
+   LuaClearStack( L) ;
+  // recupero l'identificativo dell'Uscita della Testa indicata della macchina
+   int nId = ExeGetExitId( sHead, nExit) ;
+  // restituisco il risultato
+   if ( nId != GDB_ID_NULL)
+      LuaSetParam( L, nId) ;
+   else
+      LuaSetParam( L) ;
+   return 1 ;
+}
+
 //-------------------------------------------------------------------------------
 static int
 LuaGetTcPosId( lua_State* L)
@@ -3812,6 +3868,23 @@ LuaGetAllTablesNames( lua_State* L)
   return 1 ;
 }

+//-------------------------------------------------------------------------------
+static int
+LuaGetAllAxesNames( lua_State* L)
+{
+  // nessun parametro
+   LuaClearStack( L) ;
+  // recupero l'elenco degli assi della macchina corrente
+   STRVECTOR vNames ;
+   bool bOk = ExeGetAllAxesNames( vNames) ;
+  // restituisco il risultato
+   if ( bOk)
+      LuaSetParam( L, vNames) ;
+   else
+      LuaSetParam( L) ;
+   return 1 ;
+}
+
 //-------------------------------------------------------------------------------
 static int
 LuaGetAllHeadsNames( lua_State* L)
@@ -4222,6 +4295,7 @@ 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( "EgtGetClEntAxesMask", LuaGetClEntAxesMask) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetClEntAxesVal", LuaGetClEntAxesVal) ;  
   // Simulation
   bOk = bOk && luaMgr.RegisterFunction( "EgtSimInit", LuaSimInit) ;
@@ -4245,21 +4319,24 @@ LuaInstallMachMgr( LuaMgr& luaMgr)
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetAxisId", LuaGetAxisId) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetHeadId", LuaGetHeadId) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetHeadExitCount", LuaGetHeadExitCount) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtGetExitId", LuaGetExitId) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetTcPosId", LuaGetTcPosId) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetAxisToken", LuaGetAxisToken) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetAxisType", LuaGetAxisType) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetAxisInvert", LuaGetAxisInvert) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetAxisOffset", LuaGetAxisOffset) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetAllTablesNames", LuaGetAllTablesNames) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtGetAllAxesNames", LuaGetAllAxesNames) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetAllHeadsNames", LuaGetAllHeadsNames) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetAllTcPosNames", LuaGetAllTcPosNames) ;
   // 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( "EgtGetCalcTable", LuaGetCalcTable) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetCalcTool", LuaGetCalcTool) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtGetAllCurrAxesNames", LuaGetAllCurrAxesNames) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtGetRotAxisBlocked", LuaGetRotAxisBlocked) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetCalcAngles", LuaGetCalcAngles) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetCalcPositions", LuaGetCalcPositions) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetCalcTipFromPositions", LuaGetCalcTipFromPositions) ;
@@ -0,0 +1,202 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2024-2024
+//----------------------------------------------------------------------------
+// File : LUA_TestObjSurface.cpp       Data : 24.03.24      Versione : 2.6c2
+// Contenuto : Funzioni di verifica intersezione tra oggetti e superfici.
+//             Oggetti = Box, Sfere, Cilindri, Coni, RectPrismoid, SurfTriMesh
+//             Superfici = SurfTriMesh, ( Bezier).
+//
+// Modifiche : 24.03.24 DS Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+//--------------------------- Include ----------------------------------------
+#include "stdafx.h"
+#include "LUA.h"
+#include "/EgtDev/Include/EXeExecutor.h"
+#include "/EgtDev/Include/EXeConst.h"
+#include "/EgtDev/Include/EGkLuaAux.h"
+#include "/EgtDev/Include/EGnStringUtils.h"
+
+using namespace std ;
+
+//-------------------------------------------------------------------------------
+static int
+LuaTestBoxSurface( lua_State* L)
+{
+  // 4 o 5 parametri : frBox, vtDiag, nSurfId, dSafeDist [, nRefType]
+   Frame3d frBox ;
+   LuaCheckParam( L, 1, frBox)
+   Vector3d vtDiag ;
+   LuaCheckParam( L, 2, vtDiag)
+   int nSurfId ;
+   LuaCheckParam( L, 3, nSurfId)
+   double dSafeDist ;
+   LuaCheckParam( L, 4, dSafeDist)
+   int nRefType = RTY_DEFAULT ;
+   LuaGetParam( L, 5, nRefType) ;
+   LuaClearStack( L) ;
+  // eseguo verifica di collisione
+   int nRes = ExeTestBoxSurface( frBox, vtDiag, nSurfId, dSafeDist, nRefType) ;
+  // restituisco il risultato
+   if ( nRes >= 0)
+      LuaSetParam( L, ( nRes != 0)) ;
+   else
+      LuaSetParam( L) ;
+   return 1 ;
+}
+
+//-------------------------------------------------------------------------------
+static int
+LuaTestRectPrismoidSurface( lua_State* L)
+{
+  // 8 o 9 parametri : frBox, dBaseLenX, dBaseLenY, dTopLenX, dTopLenY, dHeight, nSurfId, dSafeDist [, nRefType]
+   Frame3d frBox ;
+   LuaCheckParam( L, 1, frBox)
+   double dBaseLenX ;
+   LuaCheckParam( L, 2, dBaseLenX)
+   double dBaseLenY ;
+   LuaCheckParam( L, 3, dBaseLenY)
+   double dTopLenX ;
+   LuaCheckParam( L, 4, dTopLenX)
+   double dTopLenY ;
+   LuaCheckParam( L, 5, dTopLenY)
+   double dHeight ;
+   LuaCheckParam( L, 6, dHeight)
+   int nSurfId ;
+   LuaCheckParam( L, 7, nSurfId)
+   double dSafeDist ;
+   LuaCheckParam( L, 8, dSafeDist)
+   int nRefType = RTY_DEFAULT ;
+   LuaGetParam( L, 9, nRefType) ;
+   LuaClearStack( L) ;
+  // eseguo verifica di collisione
+   int nRes = ExeTestRectPrismoidSurface( frBox, dBaseLenX, dBaseLenY, dTopLenX, dTopLenY, dHeight, nSurfId, dSafeDist, nRefType) ;
+  // restituisco il risultato
+   if ( nRes >= 0)
+      LuaSetParam( L, ( nRes != 0)) ;
+   else
+      LuaSetParam( L) ;
+   return 1 ;
+}
+
+//-------------------------------------------------------------------------------
+static int
+LuaTestCylSurface( lua_State* L)
+{
+  // 5 o 6 parametri : frCyl, dR, dH, nSurfId, dSafeDist [, nRefType]
+   Frame3d frCyl ;
+   LuaCheckParam( L, 1, frCyl)
+   double dR ;
+   LuaCheckParam( L, 2, dR)
+   double dH ;
+   LuaCheckParam( L, 3, dH)
+   int nSurfId ;
+   LuaCheckParam( L, 4, nSurfId)
+   double dSafeDist ;
+   LuaCheckParam( L, 5, dSafeDist)
+   int nRefType = RTY_DEFAULT ;
+   LuaGetParam( L, 6, nRefType) ;
+   LuaClearStack( L) ;
+  // eseguo verifica di collisione
+   int nRes = ExeTestCylSurface( frCyl, dR, dH, nSurfId, dSafeDist, nRefType) ;
+  // restituisco il risultato
+   if ( nRes >= 0)
+      LuaSetParam( L, ( nRes != 0)) ;
+   else
+      LuaSetParam( L) ;
+   return 1 ;
+}
+
+//-------------------------------------------------------------------------------
+static int
+LuaTestConeSurface( lua_State* L)
+{
+  // 6 o 7 parametri : frCone, dR1, dR2, dH, nSurfId, dSafeDist [, nRefType]
+   Frame3d frCone ;
+   LuaCheckParam( L, 1, frCone)
+   double dR1 ;
+   LuaCheckParam( L, 2, dR1)
+   double dR2 ;
+   LuaCheckParam( L, 3, dR2)
+   double dH ;
+   LuaCheckParam( L, 4, dH)
+   int nSurfId ;
+   LuaCheckParam( L, 5, nSurfId)
+   double dSafeDist ;
+   LuaCheckParam( L, 6, dSafeDist)
+   int nRefType = RTY_DEFAULT ;
+   LuaGetParam( L, 7, nRefType) ;
+   LuaClearStack( L) ;
+  // eseguo verifica di collisione
+   int nRes = ExeTestConeSurface( frCone, dR1, dR2, dH, nSurfId, dSafeDist, nRefType) ;
+  // restituisco il risultato
+   if ( nRes >= 0)
+      LuaSetParam( L, ( nRes != 0)) ;
+   else
+      LuaSetParam( L) ;
+   return 1 ;
+}
+
+//----------------------------------------------------------------------------
+static int
+LuaTestSpheSurface( lua_State* L)
+{
+  // 4 o 5 parametri : ptCen, dRad, nSurfId, dSafeDist [, nRefType]
+   Point3d ptCen ;
+   LuaCheckParam( L, 1, ptCen)
+   double dR ;
+   LuaCheckParam( L, 2, dR)
+   int nSurfId ;
+   LuaCheckParam( L, 3, nSurfId)
+   double dSafeDist ;
+   LuaCheckParam( L, 4, dSafeDist)
+   int nRefType = RTY_DEFAULT ;
+   LuaGetParam( L, 5, nRefType) ;
+   LuaClearStack( L) ;
+  // eseguo verifica di collisione
+   int nRes = ExeTestSpheSurface( ptCen, dR, nSurfId, dSafeDist, nRefType) ;
+  // restituisco il risultato
+   if ( nRes >= 0)
+      LuaSetParam( L, ( nRes != 0)) ;
+   else
+      LuaSetParam( L) ;
+   return 1 ;
+}
+
+//----------------------------------------------------------------------------
+static int
+LuaTestSurfaceSurface( lua_State* L)
+{
+  // 3 parametri : nSurf1Id, nSurf2Id, dSafeDist
+   int nSurf1Id ;
+   LuaCheckParam( L, 1, nSurf1Id)
+   int nSurf2Id ;
+   LuaCheckParam( L, 2, nSurf2Id)
+   double dSafeDist ;
+   LuaCheckParam( L, 3, dSafeDist)
+   LuaClearStack( L) ;
+  // eseguo verifica di interferenza
+   int nRes = ExeTestSurfaceSurface( nSurf1Id, nSurf2Id, dSafeDist) ;
+  // restituisco il risultato
+   if ( nRes >= 0)
+      LuaSetParam( L, ( nRes != 0)) ;
+   else
+      LuaSetParam( L) ;
+   return 1 ;
+}
+
+//-------------------------------------------------------------------------------
+bool
+LuaInstallTestObjSurface( LuaMgr& luaMgr)
+{
+   bool bOk = ( &luaMgr != nullptr) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtTestBoxSurface", LuaTestBoxSurface) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtTestRectPrismoidSurface", LuaTestRectPrismoidSurface) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtTestCylSurface", LuaTestCylSurface) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtTestConeSurface", LuaTestConeSurface) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtTestSpheSurface", LuaTestSpheSurface) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtTestSurfaceSurface", LuaTestSurfaceSurface) ;
+   return bOk ;
+}
Author	SHA1	Message	Date
Riccardo Elitropi	6b5dc3fc30	Merge commit '9e1f151bbc90bc257749d8df7cbabefa679163e1' into VmillAdditivo	2024-04-30 08:38:44 +02:00
Dario Sassi	9e1f151bbc	EgtExecutor : - adattamenti per Zmap con virtual additive.	2024-04-26 11:33:16 +02:00
Dario Sassi	ed6c8fb11d	Merge commit '22774303af440f13f3db243c23798652b2fa7cc4'	2024-04-22 19:07:16 +02:00
Dario Sassi	9ef30272b4	EgtExecutor : - aggiunta funzione Exe/Lua GetExitId.	2024-04-22 15:30:00 +02:00
Riccardo Elitropi	22774303af	EgtExecutor : - aggiunte funzioni per Vmill additivo.	2024-04-22 13:23:59 +02:00
Dario Sassi	a3c905c33a	EgtExecutor : - adattamenti per Surf Bezier - aggiunta funzione Exe/Lua CreateArc2PR.	2024-04-19 17:51:00 +02:00
Dario Sassi	66a72c92b2	EgtExecutor : - nelle funzioni Lua EgtGetCalcTipFromPositions, EgtGetCalcToolDirFromAngles e EgtGetCalcAuxDirFromAngles ammessi sino a 6 assi rotanti (per robot).	2024-04-17 06:55:09 +02:00
Daniele Bariletti	8c0b0a97b8	EgtExecutor : - corretto bug.	2024-04-15 12:35:17 +02:00
Daniele Bariletti	f444c189d4	EgtExecutor : - aggiunto anche alla funzione LUA dell' AdvancedImport il parametro nFlag.	2024-04-15 12:21:07 +02:00
Dario Sassi	4f79e4baf9	EgtExecutor 2.6d4 : - aggiunta di alcune funzioni lua per i Quaternion.	2024-04-14 18:18:13 +02:00
Dario Sassi	e66cfb74c0	EgtExecutor : - eliminate funzioni Exe e Lua CreateSurfTmBySurfBezier perchè doppioni di ApproxSurface a cui è stato aggiunto il parametro dTriaMinSide.	2024-04-13 17:20:57 +02:00
Daniele Bariletti	2d2954f983	EgtExecutor : - cambio versione.	2024-04-12 10:34:47 +02:00
Daniele Bariletti	bea2a9f938	EgtExecutor : - aggiunti i default per la chiamata della SurfTmByBezier.	2024-04-12 10:32:23 +02:00
Daniele Bariletti	bcc44a5592	EgtExecutor : - modificata l'importazione layer da file 3dm.	2024-04-12 10:31:55 +02:00
Daniele Bariletti	e587f23dad	EgtExecutor : - aggiunti parametri per ottenere la trimesh di una Bezier con precisione richiesta.	2024-04-11 17:39:20 +02:00
Dario Sassi	f4542dd7db	Merge branch 'master' of https://gitlab.steamware.net/egaltech/EgtExecutor	2024-04-11 00:19:37 +02:00
Dario Sassi	1f66473764	EgtExecutor : - aggiunto parametro Flag in AdvancedImport.	2024-04-11 00:18:34 +02:00
Daniele Bariletti	b98e4ea359	EgtExecutor : - errato commit precedente.	2024-04-10 18:34:16 +02:00
Daniele Bariletti	504e1d5472	EgtExecutor : - modifica della funzione per l'estrazione dei loop aperti di una superficie di Bezier.	2024-04-10 18:08:54 +02:00
Dario Sassi	f8bc7083a9	EgtExecutor 2.6d2 : - estensione gestione chiave di rete per meglio identificare l'eventuale problema - migliorie a proiezione di curva su superficie - ricompilazione per modifiche a EgtLock.	2024-04-09 14:49:24 +02:00
Dario Sassi	c4b4a12b9a	EgtExecutor : - aggiunta funzione Exe/Lua ProjectCurveOnSurfTmExt.	2024-04-08 09:42:02 +02:00
Dario Sassi	9473e5813d	EgtExecutor : aggiunta la funzione Lua EgtDirectoryDialog per la scelta di un direttorio.	2024-04-05 19:24:04 +02:00
Dario Sassi	fd9e53711b	EgtExecutor : - modifiche a Exe e Lua CreateSurfTmSwept.	2024-04-05 16:56:41 +02:00
Dario Sassi	6c153c3db4	Merge commit '824e6e3ba1ff03936d2150d5660a8e1ff27b24e6'	2024-04-04 14:49:51 +02:00
Dario Sassi	841c0f6cfc	EgtExecutor : - aggiunta funzione Exe/Lua GetClEntAxesMask.	2024-04-03 08:12:19 +02:00
Dario Sassi	3990934446	EgtExecutor 2.6d1 : - aggiunta funzione Exe e Lua GetAllAxesName.	2024-04-02 15:38:40 +02:00
Dario Sassi	399556a9a6	EgtExecutor 2.6c3 : - cambio versione.	2024-03-27 16:43:26 +01:00
Daniele Bariletti	69f2c3d029	Merge branch 'CmdCreateSurfBezier'	2024-03-27 11:06:29 +01:00
Dario Sassi	f1f23a3cf4	EgtExecutor : - aggiunte funzioni Exe e Lua TestBoxSurface, TestRectPrismoidSurface, TestCylSurface, TestConeSurface, TestSpheSurface, TestSurfaceSurface.	2024-03-25 09:05:21 +01:00
Daniele Bariletti	73db521008	Merge branch 'master' into CmdCreateSurfBezier	2024-03-21 15:07:08 +01:00
Daniele Bariletti	82d1465ecd	EgtExecutor : - modificata la funzione per richiedere gli edge di una Bezier.	2024-03-21 15:01:35 +01:00
Dario Sassi	047bff2f11	EgtExecutor : - aggiunta funzione exe e lua CreateAngularDimensionEx.	2024-03-14 20:02:39 +01:00
Dario Sassi	611c08bb4c	EgtExecutor : - aggiunta funzione Exe e Lua SurfTmMoveFacet.	2024-03-13 09:24:16 +01:00
Dario Sassi	c69036ef2c	EgtExecutor 2.6c2 : - aggiunte funzioni Exe e Lua SurfTmSetShowEdges e VolZmapSetShowEdges.	2024-03-10 10:25:36 +01:00
Daniele Bariletti	b0c1ba14e8	Merge branch 'master' into CmdCreateSurfBezier	2024-03-08 16:37:46 +01:00
Dario Sassi	66a232a6a0	EgtExecutor 2.6c1 : - ricompilazione con cambio versione.	2024-03-05 08:56:19 +01:00
Daniele Bariletti	89e8b02316	EgtExecutor : - spostato il filtro delle intersezioni line-SurfBz in GeomKernel.	2024-02-28 10:31:54 +01:00
Daniele Bariletti	d1cb3d7de7	Merge branch 'master' into CmdCreateSurfBezier	2024-02-28 09:33:06 +01:00
Daniele Bariletti	49d2600cc7	EgtExecutor : - correzione del merge.	2024-02-27 17:30:38 +01:00
Daniele Bariletti	ce92c8f6c9	Merge branch 'master' into CmdCreateSurfBezier	2024-02-27 17:06:46 +01:00
Daniele Bariletti	303b7d8f0e	EgtExecutor : - aggiunta della funzione per disegnare i triangoli nello spazio parametrico di una superifcie Bezier - aggiunto il calcolo dei punti di polo nelle funzioni che creano superfici di Bezier.	2024-02-27 16:36:08 +01:00
Daniele Bariletti	95ec7a83ef	EgtExecutor : - aggiunta funzione per tagliare una superficie bezier con un piano.	2024-02-20 12:30:43 +01:00
Daniele Bariletti	e82c7417b6	Merge branch 'Dist-Inters_Bezier' into CmdCreateSurfBezier	2024-02-14 14:43:33 +01:00
Daniele Bariletti	a3fa91244d	EgtExecutor : - aggiunta la funzione per creare una sfera come superficie bezier.	2024-02-14 14:42:16 +01:00
Daniele Bariletti	abbc5415ab	Merge branch 'master' into Dist-Inters_Bezier	2024-02-12 13:00:08 +01:00
Daniele Bariletti	603cb083cc	EgtExecutor : - aggiunte le funzioni per l'intersezione tra linea e sup. Bezier.	2024-02-12 12:59:43 +01:00