EgtExecutor :

- aggiunta funzione per aggiornare uno Zmap con una  Trimesh
- aggiunta funzione per uniformare uno Zmap.

EXE_GdbCreateCurve.cpp

@@ -40,11 +40,12 @@
 #include "/EgtDev/Include/EGkChainCurves.h"
 #include "/EgtDev/Include/EGkCurveByInterp.h"
 #include "/EgtDev/Include/EGkCurveByApprox.h"
+#include "/EgtDev/Include/EGkCurveAux.h"
 #include "/EgtDev/Include/EGkOffsetCurve.h"
+#include "/EgtDev/Include/EGkCurveLocal.h"
 #include "/EgtDev/Include/EGkSurfTriMesh.h"
 #include "/EgtDev/Include/EGkDistPointCurve.h"
 #include "/EgtDev/Include/EGkStringUtils3d.h"
-#include "/EgtDev/Include/EGkCurveLocal.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
 
 using namespace std ;
@@ -1088,6 +1089,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,
@@ -2545,3 +2585,69 @@ CalcExtrusion( IGeomDB* pGeomDB, int nParentId, int nRefType)
       vtExtr.LocToLoc( pGeomDB->GetGridFrame(), frEnt) ;
    return vtExtr ;
 }
+
+//-------------------------------------------------------------------------------
+static int
+MyCreateCurveBezierForm( int nParentId, int nCrvId)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
+   nParentId = AdjustId( nParentId) ;
+   // recupero il riferimento della curva
+   Frame3d frCrv ;
+   if ( ! pGeomDB->GetGlobFrame( nCrvId, frCrv))
+      return GDB_ID_NULL ;
+   // recupero il riferimento di destinazione
+   Frame3d frLoc ;
+   if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frLoc))
+      return GDB_ID_NULL ;
+   // recupero la curva
+   const ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nCrvId)) ;
+   if ( pCurve == nullptr  ||  ! pCurve->IsValid())
+      return GDB_ID_NULL ;
+   // recupero il vettore estrusione della curva e lo porto in locale al gruppo destinazione
+   Vector3d vtExtr ;
+   pCurve->GetExtrusion( vtExtr) ;
+   vtExtr.LocToLoc( frCrv, frLoc) ;
+   int nType = pCurve->GetType() ;
+   PtrOwner<ICurve> pCrv ;
+   switch ( nType ) {
+   case CRV_LINE :
+      pCrv.Set( LineToBezierCurve( GetCurveLine( pCurve))) ;
+      break ;
+   case CRV_ARC :
+      pCrv.Set( ArcToBezierCurve( GetCurveArc( pCurve))) ;
+      break ;
+   case CRV_BEZIER :
+      pCrv.Set( BezierToBasicBezierCurve( GetCurveBezier( pCurve))) ;
+      break ;
+   case CRV_COMPO :
+      pCrv.Set( CompositeToBezierCurve( GetCurveComposite( pCurve))) ;
+      break ;
+   default :
+      break ;
+   }
+   // setto l'estrusione
+   pCrv->SetExtrusion( vtExtr) ;
+   // aggiungo la curva in forma di Bezier al DB
+   int nId = pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrv)) ;
+   return nId ;
+}
+
+//-------------------------------------------------------------------------------
+int
+ExeCreateCurveBezierForm( int nParentId, int nCrvId)
+{
+   // eseguo
+   int nId = MyCreateCurveBezierForm( nParentId, nCrvId) ;
+   ExeSetModified() ;
+   // se richiesto, salvo il comando Lua equivalente
+   if ( IsCmdLog()) {
+      string sLua = "EgtCreateCurveBezierForm(" + IdToString( nParentId) + "," +
+                     IdToString( nCrvId) + "," +
+                     " -- Id=" + ToString( nId) ;
+      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
+   }
+   // restituisco l'identificativo della nuova entità
+   return nId ;
+}

EXE_GdbCreateSurf.cpp

@@ -1668,8 +1668,6 @@ ExeCreateSurfBezier( int nParentId, int nDegU, int nDegV, int nSpanU, int nSpanV
       if ( ! pSurfBez->SetControlPoint( i, ptCtrl))
          bOk = false ;
    }
-  // calcolo eventuali poli
-   pSurfBez->CalcPoles() ;
   // se superficie nulla (ovvero ridotta a punto), errore
    bOk = bOk && ! pSurfBez->IsAPoint() ;
   // inserisco la superficie nel DB
@@ -1722,8 +1720,6 @@ ExeCreateSurfBezierRational( int nParentId, int nDegU, int nDegV, int nSpanU, in
       if ( ! pSurfBez->SetControlPoint( i, ptCtrl, vPntW[i].second))
          bOk = false ;
    }
-  // calcolo eventuali poli
-   pSurfBez->CalcPoles() ;
   // se superficie nulla (ovvero ridotta a punto), errore
    bOk = bOk && ! pSurfBez->IsAPoint() ;
   // inserisco la superficie nel DB
@@ -1899,7 +1895,6 @@ ExeCreateBezierSphere( int nParentId, const Point3d& ptCenter, double dR, int nR
    Point3d ptCenterLoc = GetPointLocal( pGeomDB, ptCenter, nRefType, frLoc) ;
   // Creo la superficie
    PtrOwner<ISurfBezier> pSurfBez( CreateBezierSphere( ptCenterLoc, dR)) ;
-   pSurfBez->CalcPoles() ;
    int nId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSurfBez)) : GDB_ID_NULL) ;
    ExeSetModified() ;
    // se richiesto, salvo il comando Lua equivalente

EXE_GdbCreateVol.cpp

@@ -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,60 @@ 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 ;
 }
+
+//-------------------------------------------------------------------------------
+bool
+ExeUpdateVolZmapByAddingSurfTm( int nVolZmapId, int nStmId)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
+  // recupero lo Zmap
+   IVolZmap* pVZM = GetVolZmap( pGeomDB->GetGeoObj( nVolZmapId)) ;
+   bool bOk = ( pVZM != nullptr) ;
+  // recupero la trimesh
+   PtrOwner<ISurfTriMesh> pStm( CloneSurfTriMesh( pGeomDB->GetGeoObj( nStmId))) ;
+   bOk = bOk && !IsNull( pStm) ;
+  // recupero il frame dello Zmap e della Trimesh
+   Frame3d frZmap, frStm ;
+   bOk = bOk && pGeomDB->GetGlobFrame( nVolZmapId, frZmap) &&
+                pGeomDB->GetGlobFrame( nStmId, frStm) ;
+  // porto la Stm nel frame dello Zmap
+   bOk = bOk && pStm->LocToLoc( frStm, frZmap) ;
+  // aggiorno lo Zmap con la nuova superficie
+   bOk = bOk && pVZM->AddSurfTm( pStm) ;
+   ExeSetModified() ;
+  // se richiesto, salvo il comando Lua equivalente
+   if ( IsCmdLog()) {
+      string sLua = "EgtUpdateVolZmapByAddingSurfTm(" + ToString( nVolZmapId) + "," +
+                                                        ToString( nStmId) + ")"
+                    " -- bOk =" + ToString( bOk) ;
+      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
+   }
+   return bOk ;
+}
+
+//-------------------------------------------------------------------------------
+bool
+ExeUniformVolZmap( int nVolZmapId, double dToler)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
+  // recupero lo Zmap
+   IVolZmap* pVZM = GetVolZmap( pGeomDB->GetGeoObj( nVolZmapId)) ;
+   bool bOk = ( pVZM != nullptr) ;
+  // aggiorno lo Zmap
+   dToler = max( dToler, EPS_SMALL) ;
+   bOk = bOk && pVZM->MakeUniform( dToler) ;
+   ExeSetModified() ;
+  // se richiesto, salvo il comando Lua equivalente
+   if ( IsCmdLog()) {
+      string sLua = "EgtUniformZmap(" + ToString( nVolZmapId) + "," +
+                                        ToString( dToler) + ")"
+                    " -- bOk =" + ToString( bOk) ;
+      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
+   }
+   return bOk ;
+}

EXE_GdbGetCurve.cpp

@@ -27,6 +27,7 @@
 #include "/EgtDev/Include/EGkDistPointCurve.h"
 #include "/EgtDev/Include/EGkIntersCurves.h"
 #include "/EgtDev/Include/EGkSurfFlatRegion.h"
+#include "/EgtDev/Include/EGkGeoPoint3d.h"
 
 //----------------------------------------------------------------------------
 bool
@@ -677,3 +678,36 @@ ExeCurveCompoNormVersor( int nId, int nSimpCrv, int nRefId, Vector3d& vtNorm)
   // gestione trasformazione ( eventuale)
    return TransformVector( pGeomDB, nId, nRefId, vtNorm) ;
 }
+
+//----------------------------------------------------------------------------
+bool
+ExeShowBezierCurveControlPoints( int nCrvId, int* pnCount)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, false)
+   // recupero la curva di bezier
+   const ICurveBezier* pCrvBezier = GetCurveBezier( pGeomDB->GetGeoObj( nCrvId)) ;
+   if ( pCrvBezier == nullptr  ||  pCrvBezier->GetType() != CRV_BEZIER)
+      return false ;
+   int nParent = pGeomDB->GetParentId( nCrvId) ;
+   int nDeg = pCrvBezier->GetDegree() ;
+   bool bRat = pCrvBezier->IsRational() ;
+   int nFirstId = -1 ;
+   int nCount = 0 ;
+   for ( int i = 0 ; i < nDeg + 1 ; ++i) {
+      IGeoPoint3d* pGeoPt( CreateGeoPoint3d()) ;
+      if ( ! bRat)
+         pGeoPt->Set( pCrvBezier->GetControlPoint( i)) ;
+      else
+         pGeoPt->Set( pCrvBezier->GetControlPoint( i) * pCrvBezier->GetControlWeight( i)) ;
+      int nId = pGeomDB->AddGeoObj( GDB_ID_NULL, nParent, pGeoPt) ;
+      if ( nFirstId == GDB_ID_NULL)
+         nFirstId = nId ;
+      if ( nId != GDB_ID_NULL)
+         ++nCount ;
+   }
+   // restituisco i risultati
+   if ( pnCount != nullptr)
+      *pnCount = nCount ;
+   return nFirstId ;
+}

EXE_GdbGetSurf.cpp

@@ -1081,6 +1081,98 @@ ExeSurfTmGetFacetBBoxRef( int nId, int nFacet, int nFlag, const Frame3d& frRef,
    return pStm->GetFacetBBox( nFacet, frGlobL, b3Box, nFlag) ;
 }
 
+//-----------------------------------------------------------------------------
+bool
+ExeSurfTmGetFacetOutlineInfo( int nId, int nFacet, int nRefId,
+                              int& nStatus, BOOLVECTOR& vbOpen, INTVECTOR& vnAdj, DBLVECTOR& vdLen, VCT3DVECTOR& vvtNorm, DBLVECTOR& vdElev)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, false)
+  // recupero la superficie TriMesh
+   const ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
+   if ( pStm == nullptr)
+      return false ;
+  // recupero normale della faccia
+   Vector3d vtNorm ;
+   if ( ! pStm->GetFacetNormal( nFacet, vtNorm))
+      return false ;
+  // recupero i loop come polilinee
+   POLYLINEVECTOR vPL ;
+   if ( ! pStm->GetFacetLoops( nFacet, vPL)  ||  vPL.empty())
+      return false ;
+  // calcolo lo stato
+   if ( vPL.size() == 1)
+      nStatus = 0 ;
+   else {
+      nStatus = -1 ;
+      for ( int i = 1 ; nStatus == -1 && i < int( vPL.size()) ; ++ i) {
+         double dIni, dFin ;
+         Point3d ptIni, ptFin ;
+         bool bFound = vPL[i].GetFirstULine( &dIni, &ptIni, &dFin, &ptFin) ;
+         while ( bFound) {
+            int nAdj = lround( dIni) ;
+            Vector3d vtNf ;
+            if ( nAdj >= 0  &&  pStm->GetFacetNormal( nAdj, vtNf)) {
+               Vector3d vtTg = ptFin - ptIni ;
+               vtTg.Normalize() ;
+               if ( ( vtTg ^ vtNf) * vtNorm > EPS_SMALL) {
+                  nStatus = 1 ;
+                  break ;
+               }
+            }
+            bFound = vPL[i].GetNextULine( &dIni, &ptIni, &dFin, &ptFin) ;
+         }
+      }
+   }
+  // pulisco e prealloco i vettori del risultato
+   int nDim = vPL[0].GetLineNbr() ;
+   vbOpen.clear() ; vbOpen.reserve( nDim) ;
+   vnAdj.clear() ; vnAdj.reserve( nDim) ;
+   vdLen.clear() ; vdLen.reserve( nDim) ;
+   vvtNorm.clear() ; vvtNorm.reserve( nDim) ;
+   vdElev.clear() ; vdElev.reserve( nDim) ;
+  // recupero riferimento alla lista dei punti
+   PNTULIST& lstPU = vPL[0].GetUPointList() ; 
+  // ciclo sui lati del loop esterno (il primo)
+   double dIni, dFin ;
+   Point3d ptIni, ptFin ;
+   bool bFound = vPL[0].GetFirstULine( &dIni, &ptIni, &dFin, &ptFin) ;
+   while ( bFound) {
+     // faccia adiacente
+      int nAdj = lround( dIni) ;
+     // lunghezza lato
+      double dLen = Dist( ptIni, ptFin) ;
+     // aperto se senza adiacenza o con faccia adiacente che va da parte negativa (tipo foro)
+      bool bOpen = true ;
+      Vector3d vtTg = ptFin - ptIni ;
+      vtTg.Normalize() ;
+      Vector3d vtNf ;
+      if ( nAdj >= 0  &&  pStm->GetFacetNormal( nAdj, vtNf))
+         bOpen = ((vtTg ^ vtNf) * vtNorm < EPS_SMALL) ;
+     // normale al lato (verso interno se chiuso, verso esterno se aperto)
+      Vector3d vtN = vtTg ;
+      vtN.Rotate( vtNorm, 0, ( bOpen ? -1 : 1)) ;
+     // elevazione secondo direzione della normale al lato
+      double dElev = 0 ;
+      for ( const auto& PU : lstPU) {
+         double dDist = ( PU.first - ptIni) * vtN ;
+         dElev = ( bOpen ? min( dElev, dDist) : max( dElev, dDist)) ;
+      }
+     // porto normale nel riferimento desiderato
+      TransformVector( pGeomDB, nId, nRefId, vtN) ;
+     // inserisco dati nei parametri di ritorno
+      vbOpen.emplace_back( bOpen) ;
+      vnAdj.emplace_back( nAdj) ;
+      vdLen.emplace_back( dLen) ;
+      vvtNorm.emplace_back( vtN) ;
+      vdElev.emplace_back( dElev) ;
+     // passo al prossimo lato
+      bFound = vPL[0].GetNextULine( &dIni, &ptIni, &dFin, &ptFin) ;
+   }
+
+   return true ;
+}
+
 //----------------------------------------------------------------------------
 int
 ExeSurfTmGetEdges( int nId, int nDestGrpId, bool bSmoothAng, int* pnCount)

EXE_GdbModifyCurve.cpp

@@ -20,6 +20,8 @@
 #include "GeoTools.h"
 #include "/EgtDev/Include/EXeExecutor.h"
 #include "/EgtDev/Include/EXeConst.h"
+#include "/EgtDev/Include/EGkGeoPoint3d.h"
+#include "/EgtDev/Include/EGkGeoVector3d.h"
 #include "/EgtDev/Include/EGkCurve.h"
 #include "/EgtDev/Include/EGkCurveArc.h"
 #include "/EgtDev/Include/EGkCurveBezier.h"
@@ -34,16 +36,15 @@
 #include "/EgtDev/Include/EGkChainCurves.h"
 #include "/EgtDev/Include/EGkProjectCurveSurfTm.h"
 #include "/EgtDev/Include/EGkSurfFlatRegion.h"
+#include "/EgtDev/Include/EGkSfrCreate.h"
+#include "/EgtDev/Include/EGkSurfBezier.h"
 #include "/EgtDev/Include/EGkExtTExt.h"
 #include "/EgtDev/Include/EGkGdbIterator.h"
 #include "/EgtDev/Include/EGkStringUtils3d.h"
 #include "/EgtDev/Include/EGkIntervals.h"
 #include "/EgtDev/Include/EGkPolygon3d.h"
-#include "/EgtDev/Include/EGkGeoPoint3d.h"
-#include "/EgtDev/Include/EGkGeoVector3d.h"
-#include "/EgtDev/Include/EgtPointerOwner.h"
 #include "/EgtDev/Include/EGkCalcPocketing.h"
-#include <EgtDev/Include/EGkSfrCreate.h>
+#include "/EgtDev/Include/EgtPointerOwner.h"
 #include <functional>
 
 
@@ -333,10 +334,9 @@ ExeChangeClosedCurveStartPoint( int nId, const Point3d& ptP, int nRefType)
   // porto in locale il punto vicino ad iniziale
    Point3d ptPL = GetPointLocal( pGeomDB, ptP, nRefType, frLoc) ;
   // recupero la posizione parametrica della proiezione di questo punto sulla curva
-   DistPointCurve distPC( ptPL, *pCurve) ;
    double dPar ;
    int nFlag ;
-   bOk = bOk && distPC.GetParamAtMinDistPoint( 0, dPar, nFlag) ;
+   bOk = bOk && DistPointCurve( ptPL, *pCurve).GetParamAtMinDistPoint( 0, dPar, nFlag) ;
   // cambio il punto iniziale
    if ( bOk  &&  pCurve->GetType() == CRV_ARC)
       bOk = bOk && GetCurveArc(pCurve)->ChangeStartPoint(dPar) ;
@@ -2491,6 +2491,230 @@ ExeProjectCurveOnSurfTmExt( int nCurveId, int nSurfTmId, int nGuideId, int nDest
 
 }
 
+//-------------------------------------------------------------------------------
+static bool
+MyProjectCurveOnSurfBz( int nCurveId, int nSurfBzId, const Vector3d& vtDir, int nDestGrpId,
+                        double dLinTol, double dMaxSegmLen, int nRefType)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, false)
+      // recupero la curva e il suo riferimento
+      const ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( nCurveId)) ;
+   if ( pCrv == nullptr)
+      return false ;
+   Frame3d frCrv ;
+   if ( ! pGeomDB->GetGlobFrame( nCurveId, frCrv))
+      return false ;
+   // recupero la superficie bezier e il suo riferimento
+   const ISurfBezier* pSbz = GetSurfBezier( pGeomDB->GetGeoObj( nSurfBzId)) ;
+   // recupero la superficie trimesh
+   const ISurfTriMesh* pStm = pSbz->GetAuxSurf() ;
+   if ( pStm == nullptr)
+      return false ;
+   Frame3d frSbz ;
+   if ( ! pGeomDB->GetGlobFrame( nSurfBzId, frSbz))
+      return false ;
+   // recupero il riferimento del gruppo di destinazione
+   nDestGrpId = AdjustId( nDestGrpId) ;
+   Frame3d frDest ;
+   if ( ! pGeomDB->GetGroupGlobFrame( nDestGrpId, frDest))
+      return false ;
+   // porto la curva e il vettore nel riferimento della superficie
+   CurveLocal CrvLoc( pCrv, frCrv, frSbz) ;
+   if ( CrvLoc.Get() == nullptr)
+      return false ;
+   Vector3d vtDirL = GetVectorLocal( pGeomDB, vtDir, nRefType, frCrv) ;
+   vtDirL.LocToLoc( frCrv, frSbz) ;
+   // eseguo la proiezione
+   PNT5AXVECTOR vPt5ax ;
+   if ( ! ProjectCurveOnSurfTm( *CrvLoc.Get(), *pStm, vtDirL, 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, frSbz, frDest)) ;
+      }
+      else
+         pCompo->AddLine( GetLocToLoc( Pt5ax.ptP, frSbz, frDest)) ;
+   }
+   int nCompoId = pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, Release( pCompo)) ;
+   if ( nCompoId == GDB_ID_NULL)
+      return false ;
+   // aggiungo i versori nel gruppo destinazione
+   int nInd = 0 ;
+   for ( const auto& Pt5ax : vPt5ax) {
+      PtrOwner<IGeoVector3d> pGeoVct( CreateGeoVector3d()) ;
+      if ( IsNull( pGeoVct))
+         return false ;
+      pGeoVct->Set( 10 * GetLocToLoc( Pt5ax.vtDir, frSbz, frDest), GetLocToLoc( Pt5ax.ptP, frSbz, 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
+ExeProjectCurveOnSurfBz( int nCurveId, int nSurfBzId, const Vector3d& vtDir, int nDestGrpId,
+                         double dLinTol, double dMaxSegmLen, int nRefType)
+{
+   bool bOk = MyProjectCurveOnSurfBz( nCurveId, nSurfBzId, vtDir, nDestGrpId, dLinTol, dMaxSegmLen, nRefType) ;
+   ExeSetModified() ;
+   // se richiesto, salvo il comando Lua equivalente
+   if ( IsCmdLog()) {
+      string sLua = "EgtProjectCurveOnSurfBz(" + ToString( nCurveId) + "," +
+         ToString( nSurfBzId) + ",{" +
+         ToString( vtDir) + "}," +
+         ToString( nDestGrpId) + "," +
+         ToString( dLinTol) + "," +
+         ToString( dMaxSegmLen) + "," +
+         RefTypeToString( nRefType) + ")" +
+         " -- Ok=" + ToString( bOk) ;
+      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
+   }
+   return bOk ;
+
+}
+
+//-------------------------------------------------------------------------------
+static bool
+MyProjectCurveOnSurfBzExt( int nCurveId, int nSurfBzId, 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 Bezier e il suo riferimento
+   const ISurfBezier* pSbz = GetSurfBezier( pGeomDB->GetGeoObj( nSurfBzId)) ;
+   // recupero la superficie trimesh
+   const ISurfTriMesh* pStm = pSbz->GetAuxSurf() ;
+   if ( pStm == nullptr)
+      return false ;
+   Frame3d frSbz ;
+   if ( ! pGeomDB->GetGlobFrame( nSurfBzId, frSbz))
+      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, frSbz) ;
+   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, frSbz) ;
+      if ( ! ProjectCurveOnSurfTm( *CrvLoc.Get(), *pStm, *pGdeLoc, dLinTol, dMaxSegmLen, vPt5ax))
+         return false ;
+   }
+   else if ( pGdeCrv != nullptr) {
+      CurveLocal GdeLoc( pGdeCrv, frGde, frSbz) ;
+      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, frSbz) ;
+      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, frSbz, frDest)) ;
+      }
+      else
+         pCompo->AddLine( GetLocToLoc( Pt5ax.ptP, frSbz, 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, frSbz, frDest), GetLocToLoc( Pt5ax.ptP, frSbz, 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
+ExeProjectCurveOnSurfBzExt( int nCurveId, int nSurfBzId, int nGuideId, int nDestGrpId,
+                            double dLinTol, double dMaxSegmLen, bool bDirFromGuide)
+{
+   bool bOk = MyProjectCurveOnSurfBzExt( nCurveId, nSurfBzId, nGuideId, nDestGrpId, dLinTol, dMaxSegmLen, bDirFromGuide) ;
+   ExeSetModified() ;
+   // se richiesto, salvo il comando Lua equivalente
+   if ( IsCmdLog()) {
+      string sLua = "EgtProjectCurveOnSurfBzExt(" + ToString( nCurveId) + "," +
+         ToString( nSurfBzId) + ",{" +
+         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) 

EXE_GdbModifySurf.cpp

@@ -1074,6 +1074,45 @@ ExeSurfTmSubtractProjectedFacesOnFace( int nSurfId, int nFaceInd, int nDestGrpId
    return bOk ;
 }
 
+//----------------------------------------------------------------------------
+bool
+ExeSurfTmSetFaceColor( int nId, int nFacet, int nColor)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, false)
+  // recupero la superficie TriMesh
+   ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
+   bool bOk = ( pStm != nullptr) ;
+  // recupero tutti i triangoli della faccia e imposto il flag opportuno per il colore
+   INTVECTOR vTria ;
+   bOk = bOk && pStm->GetAllTriaInFacet( nFacet, vTria) ;
+   for ( const auto nT : vTria)
+      pStm->SetTFlag( nT, nColor) ;
+   ExeSetModified() ;
+  // se richiesto, salvo il comando Lua equivalente
+   if ( IsCmdLog()) {
+      string sLua = "EgtSurfTmSetFaceColor(" + ToString( nId) + "," +
+                                               ToString( nFacet) + "," +
+                                               ToString( nColor) + ")" +
+                    " -- Ok=" + ToString( bOk) ;
+      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
+   }
+   return bOk ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ExeSurfTmGetTriaColor( int nId, int nTria, int& nColor)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, false)
+  // recupero la superficie TriMesh
+   ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
+   bool bOk = ( pStm != nullptr) ;
+  // recupero il colore del triangolo
+   return ( bOk && pStm->GetTFlag( nTria, nColor)) ;
+}
+
 //----------------------------------------------------------------------------
 bool
 ExeSurfTmResetTwoColors( int nId)
@@ -1118,6 +1157,20 @@ ExeSurfTmSetShowEdges( int nId, bool bShow)
    return bOk ;
 }
 
+//----------------------------------------------------------------------------
+bool
+ExeSurfTmGetShowEdges( int nId, bool& bShow)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, false)
+  // recupero la superficie trimesh
+   ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
+   bool bOk = ( pStm != nullptr) ;
+  // recupero lo stato di visualizzazione degli spigoli vivi
+   bShow = ( bOk && pStm->GetShowEdges()) ;
+   return bOk ;
+}
+
 //----------------------------------------------------------------------------
 static bool 
 MySurfBzTrim( int nId, int nTrimmerId)

EXE_GdbModifyVol.cpp

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

EXE_MachMgr.cpp

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

LUA_GdbCreateCurve.cpp

@@ -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)
@@ -1063,6 +1091,26 @@ LuaCreateCirclesAlongCurve( lua_State* L)
    return 2 ;
 }
 
+//-------------------------------------------------------------------------------
+static int
+LuaCreateCurveBezierForm( lua_State* L)
+{
+  // 2 parametri : ParentId, nCrvId
+   int nParentId ;
+   LuaCheckParam( L, 1, nParentId)
+   int nCrvId ;
+   LuaCheckParam( L, 2, nCrvId)
+
+  // creo la versione bezier della curva
+   int nId = ExeCreateCurveBezierForm( nParentId, nCrvId) ;
+  // restituisco il risultato
+   if ( nId != GDB_ID_NULL)
+      LuaSetParam( L, nId) ;
+   else
+      LuaSetParam( L) ;
+   return 1 ;
+}
+
 //-------------------------------------------------------------------------------
 bool
 LuaInstallGdbCreateCurve( LuaMgr& luaMgr)
@@ -1083,6 +1131,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) ;
@@ -1106,5 +1155,6 @@ LuaInstallGdbCreateCurve( LuaMgr& luaMgr)
    bOk = bOk && luaMgr.RegisterFunction( "EgtPolygonFromApothem", LuaCreatePolygonFromApothem) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtPolygonFromSide", LuaCreatePolygonFromSide) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtCirclesAlongCurve", LuaCreateCirclesAlongCurve) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtCurveBezierForm", LuaCreateCurveBezierForm) ;
    return bOk ;
 }

LUA_GdbCreateVol.cpp

@@ -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)
@@ -104,13 +140,47 @@ LuaCreateVolZmapFromSurfTm( lua_State* L)
    return 1 ;
 }
 
+//-------------------------------------------------------------------------------
+static int
+LuaUpdateVolZmapByAddingSurfTm( lua_State* L)
+{
+  // 2 parametri : nVolZmapId, StmId,
+   int nVolZmapId ;
+   LuaCheckParam( L, 1, nVolZmapId) ;
+   int nStmId ;
+   LuaCheckParam( L, 2, nStmId) ;
+   LuaClearStack( L) ;
+   bool bOk = ExeUpdateVolZmapByAddingSurfTm( nVolZmapId, nStmId) ;
+   LuaSetParam( L, bOk) ;
+   return 1 ;
+}
+
+//-------------------------------------------------------------------------------
+static int
+LuaUniformVolZmap( lua_State* L)
+{
+  // 1 o 2 parametri : nVolZmapId [, dToler]
+   int nVolZmapId ;
+   LuaCheckParam( L, 1, nVolZmapId) ;
+   double dToler = EPS_SMALL ;
+   LuaGetParam( L, 2, dToler) ;
+   LuaClearStack( L) ;
+   bool bOk = ExeUniformVolZmap( nVolZmapId, dToler) ;
+   LuaSetParam( L, bOk) ;
+   return 1 ;
+}
+
+
 //-------------------------------------------------------------------------------
 bool
 LuaInstallGdbCreateVol( LuaMgr& luaMgr)
 {
    bool bOk = ( &luaMgr != nullptr) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtVolZmapBox", LuaCreateVolZmapBox) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtVolZmapEmpty", LuaCreateVolZmapEmpty) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtVolZmapByRegionExtrusion", LuaCreateVolZmapByRegionExtrusion) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtVolZmapFromSurfTm", LuaCreateVolZmapFromSurfTm) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtUpdateVolZmapByAddingSurfTm", LuaUpdateVolZmapByAddingSurfTm ) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtUniformZmap", LuaUniformVolZmap) ;
    return bOk ;
 }

LUA_GdbGetCurve.cpp

@@ -531,6 +531,28 @@ LuaCurveCompoNormVersor( lua_State* L)
    return 1 ;
 }
 
+//----------------------------------------------------------------------------
+static int
+LuaShowBezierCurveControlPoint( lua_State* L)
+{
+   // 1 parametro : nCrvId
+   int nCrvId ;
+   LuaCheckParam( L, 1, nCrvId)
+   LuaClearStack( L) ;
+   int nCount = 0 ;
+   int nId = ExeShowBezierCurveControlPoints( nCrvId, &nCount) ;
+   // restituisco il risultato
+   if ( nId != GDB_ID_NULL) {
+      LuaSetParam( L, nId) ;
+      LuaSetParam( L, nCount) ;  
+   }
+   else {
+      LuaSetParam( L) ;
+      LuaSetParam( L) ;
+   }
+   return 2 ;
+}
+
 //-------------------------------------------------------------------------------
 bool
 LuaInstallGdbGetCurve( LuaMgr& luaMgr)
@@ -562,5 +584,6 @@ LuaInstallGdbGetCurve( LuaMgr& luaMgr)
    bOk = bOk && luaMgr.RegisterFunction( "EgtCurveCompoRadius", LuaCurveCompoRadius) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtCurveCompoAngCenter", LuaCurveCompoAngCenter) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtCurveCompoNormVersor", LuaCurveCompoNormVersor) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtShowBezierCurveControlPoints", LuaShowBezierCurveControlPoint) ;
    return bOk ;
 }

LUA_GdbGetSurf.cpp

@@ -443,6 +443,42 @@ LuaSurfTmGetFacetBBoxRef( lua_State* L)
    return 1 ;
 }
 
+//----------------------------------------------------------------------------
+static int
+LuaSurfTmGetFacetOutlineInfo( lua_State* L)
+{
+  // 2 o 3 parametri : Id, nFacet [, nRefId]
+   int nId ;
+   LuaCheckParam( L, 1, nId)
+   int nFacet ;
+   LuaCheckParam( L, 2, nFacet)
+   int nRefId = nId ;
+   LuaGetParam( L, 3, nRefId) ;
+   LuaClearStack( L) ;
+  // recupero le informazioni
+   int nStatus ;
+   BOOLVECTOR vbOpen ;
+   INTVECTOR vnAdj ;
+   VCT3DVECTOR vvtNorm ;
+   DBLVECTOR vdElev ;
+   DBLVECTOR vdLen ;
+   bool bOk = ExeSurfTmGetFacetOutlineInfo( nId, nFacet, nRefId, nStatus, vbOpen, vnAdj, vdLen, vvtNorm, vdElev) ;
+  // restituisco il risultato
+   if ( bOk) {
+      LuaSetParam( L, nStatus) ;
+      LuaSetParam( L, vbOpen) ;
+      LuaSetParam( L, vnAdj) ;
+      LuaSetParam( L, vdLen) ;
+      LuaSetParam( L, vvtNorm) ;
+      LuaSetParam( L, vdElev) ;
+      return 6 ;
+   }
+   else {
+      LuaSetParam( L) ;
+      return 1 ;
+   }
+}
+
 //----------------------------------------------------------------------------
 static int
 LuaSurfTmFacetAdjacencies( lua_State* L)
@@ -1106,6 +1142,7 @@ LuaInstallGdbGetSurf( LuaMgr& luaMgr)
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmGetFacetBBox", LuaSurfTmGetFacetBBox) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmGetFacetBBoxGlob", LuaSurfTmGetFacetBBoxGlob) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmGetFacetBBoxRef", LuaSurfTmGetFacetBBoxRef) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmGetFacetOutlineInfo", LuaSurfTmGetFacetOutlineInfo) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmFacetAdjacencies", LuaSurfTmFacetAdjacencies) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmFacetNearestEndPoint", LuaSurfTmFacetNearestEndPoint) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmFacetNearestMidPoint", LuaSurfTmFacetNearestMidPoint) ;

LUA_GdbModifyCurve.cpp

@@ -1001,6 +1001,58 @@ LuaProjectCurveOnSurfTmExt( lua_State* L)
    return 1 ;
 }
 
+//----------------------------------------------------------------------------
+static int
+LuaProjectCurveOnSurfBz( lua_State* L)
+{
+   // 4, 5, 6 o 7 parametri : nCurveId, nSurfBzId, vtDir, nDestGrpId [, dLinTol [, dMaxSegmLen] [, nRefType]]
+   int nCurveId ;
+   LuaCheckParam( L, 1, nCurveId)
+      int nSurfBzId ;
+   LuaCheckParam( L, 2, nSurfBzId)
+      Vector3d vtDir ;
+   LuaCheckParam( L, 3, vtDir)
+      int nDestGrpId ;
+   LuaCheckParam( L, 4, nDestGrpId)
+      double dLinTol = 0.01 ;
+   double dMaxSegmLen = INFINITO ;
+   int nRefType = RTY_DEFAULT ;
+   if ( LuaGetParam( L, 5, dLinTol)  &&
+      LuaGetParam( L, 6, dMaxSegmLen))
+      LuaGetParam( L, 7, nRefType) ;
+   LuaClearStack( L) ;
+   // proietto la curva su una trimesh secondo la direzione data
+   bool bOk = ExeProjectCurveOnSurfBz( nCurveId, nSurfBzId, vtDir, nDestGrpId, dLinTol, dMaxSegmLen, nRefType) ;
+   LuaSetParam( L, bOk) ;
+   return 1 ;
+}
+
+//----------------------------------------------------------------------------
+static int
+LuaProjectCurveOnSurfBzExt( lua_State* L)
+{
+   // 4, 5, 6 o 7 parametri : nCurveId, nSurfBzId, nGuideId, nDestGrpId [, dLinTol [, dMaxSegmLen] [, bDirFromGuide]]
+   int nCurveId ;
+   LuaCheckParam( L, 1, nCurveId)
+      int nSurfBzId ;
+   LuaCheckParam( L, 2, nSurfBzId)
+      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 = ExeProjectCurveOnSurfBzExt( nCurveId, nSurfBzId, nGuideId, nDestGrpId, dLinTol, dMaxSegmLen, bDirFromGuide) ;
+   LuaSetParam( L, bOk) ;
+   return 1 ;
+}
+
 //----------------------------------------------------------------------------
 static int
 LuaCurveGetVoronoi( lua_State* L)
@@ -1137,5 +1189,7 @@ LuaInstallGdbModifyCurve( LuaMgr& luaMgr)
    bOk = bOk && luaMgr.RegisterFunction( "EgtCurveGetVoronoi", LuaCurveGetVoronoi) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtCurveMedialAxisAdv", LuaCurveMedialAxisAdv) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtCurveGetFatCurve", LuaCurveGetFatCurve) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtProjectCurveOnSurfBz", LuaProjectCurveOnSurfBz) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtProjectCurveOnSurfBzExt", LuaProjectCurveOnSurfBzExt) ;
    return bOk ;
 }

LUA_GdbModifySurf.cpp

@@ -479,6 +479,44 @@ LuaSurfTmSubtractProjectedFacesOnFace( lua_State* L)
    return 4 ;
 }
 
+//-------------------------------------------------------------------------------
+static int
+LuaSurfTmSetFaceColor( lua_State* L)
+{
+  // 3 parametri : Id, nFacet, nColor
+   int nId ;
+   LuaCheckParam( L, 1, nId)
+   int nFacet ;
+   LuaCheckParam( L, 2, nFacet)
+   int nColor ;
+   LuaCheckParam( L, 3, nColor)
+   LuaClearStack( L) ;
+  // imposto il colore alla faccia della superficie TM
+   bool bOk = ExeSurfTmSetFaceColor( nId, nFacet, nColor) ;
+   LuaSetParam( L, bOk) ;
+   return 1 ;
+}
+
+//-------------------------------------------------------------------------------
+static int
+LuaSurfTmGetTriaColor( lua_State* L)
+{
+  // 2 parametri : Id, nTria
+   int nId ;
+   LuaCheckParam( L, 1, nId)
+   int nTria ;
+   LuaCheckParam( L, 2, nTria)
+   LuaClearStack( L) ;
+  // recupero il flag di colore del triangolo della superficie TM
+   int nColor ;
+   bool bOk = ExeSurfTmGetTriaColor( nId, nTria, nColor) ;
+   if ( bOk)
+      LuaSetParam( L, nColor) ;
+   else
+      LuaSetParam( L) ;
+   return 1 ;
+}
+
 //-------------------------------------------------------------------------------
 static int
 LuaSurfTmResetTwoColors( lua_State* L)
@@ -510,6 +548,24 @@ LuaSurfTmSetShowEdges( lua_State* L)
    return 1 ;
 }
 
+//-------------------------------------------------------------------------------
+static int
+LuaSurfTmGetShowEdges( lua_State* L)
+{
+  // 1 parametro : Id
+   int nId ;
+   LuaCheckParam( L, 1, nId)
+   LuaClearStack( L) ;
+  // recupero il flag di visualizzazione degli spigoli vivi della superficie TM
+   bool bShow ;
+   bool bOk = ExeSurfTmGetShowEdges( nId, bShow) ;
+   if ( bOk)
+      LuaSetParam( L, bShow) ;
+   else
+      LuaSetParam( L) ;
+   return 1 ;
+}
+
 //-------------------------------------------------------------------------------
 static int
 LuaSurfBzTrim( lua_State* L)
@@ -554,8 +610,11 @@ LuaInstallGdbModifySurf( LuaMgr& luaMgr)
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmSplit", LuaSurfTmSplit) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmCut", LuaSurfTmCut) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmSubtractProjectedFacesOnFace", LuaSurfTmSubtractProjectedFacesOnFace) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmSetFaceColor", LuaSurfTmSetFaceColor) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmGetTriaColor", LuaSurfTmGetTriaColor) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmResetTwoColors", LuaSurfTmResetTwoColors) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmSetShowEdges", LuaSurfTmSetShowEdges) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmGetShowEdges", LuaSurfTmGetShowEdges) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBzTrim", LuaSurfBzTrim) ;
    return bOk ;
 }

LUA_GdbModifyVol.cpp

@@ -152,7 +152,7 @@ LuaVolZmapSetAdvTool( lua_State* L)
 static int
 LuaVolZmapSetSawTool( lua_State* L)
 {
-  // 7 o 8 parametri : vIds, sToolName, dLen, dDiam, dThick, dStemDiam, dCornR, nFlag
+  // 7 o 8 parametri : vIds, sToolName, dLen, dDiam, dThick, dStemDiam, dCornR [, nFlag]
    INTVECTOR vIds ;
    LuaCheckParam( L, 1, vIds)
    string sToolName ;
@@ -181,7 +181,7 @@ LuaVolZmapSetSawTool( lua_State* L)
 static int
 LuaVolZmapSetGenTool( lua_State* L)
 {
-  // 3 o 4 parametri : vIds, sToolName, ToolSectId, nFlag
+  // 3 o 4 parametri : vIds, sToolName, ToolSectId [, nFlag]
    INTVECTOR vIds ;
    LuaCheckParam( L, 1, vIds)
    string sToolName ;
@@ -202,7 +202,7 @@ LuaVolZmapSetGenTool( lua_State* L)
 static int
 LuaVolZmapSetMortiserTool( lua_State* L)
 {
-  // 6 o 7 parametri : Id, sToolName, dLen, dWidth, dThick, dCornR, nFlag
+  // 6 o 7 parametri : Id, sToolName, dLen, dWidth, dThick, dCornR [, nFlag]
    INTVECTOR vIds ;
    LuaCheckParam( L, 1, vIds)
    string sToolName ;
@@ -229,7 +229,7 @@ LuaVolZmapSetMortiserTool( lua_State* L)
 static int
 LuaVolZmapSetChiselTool( lua_State* L)
 {
-  // 5 o 6 parametri : vIds, sToolName, dLen, dWidth, dThick, nFlag
+  // 5 o 6 parametri : vIds, sToolName, dLen, dWidth, dThick [, nFlag]
    INTVECTOR vIds ;
    LuaCheckParam( L, 1, vIds)
    string sToolName ;
@@ -250,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)
@@ -375,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) ;

LUA_General.cpp

@@ -107,6 +107,24 @@ LuaPause( lua_State* L)
    return 1 ;
 }
 
+//-------------------------------------------------------------------------------
+static int
+LuaGetKeyPressed( lua_State* L)
+{
+  // 1 parametro : nKeyCode
+   int nKeyCode ;
+   LuaCheckParam( L, 1, nKeyCode)
+   LuaClearStack( L) ;
+  // se abilitata UI, controllo se il tasto indicato è premuto
+   bool bPressed = false ;
+   if ( ExeGetEnableUI()) {
+      bPressed = (( GetAsyncKeyState( nKeyCode) & 0x8000) != 0) ;
+   }
+  // restituisco il risultato
+   LuaSetParam( L, bPressed) ;
+   return 1 ;
+}
+
 //-------------------------------------------------------------------------------
 static int
 LuaStartCounter( lua_State* L)
@@ -1322,6 +1340,7 @@ LuaInstallGeneral( LuaMgr& luaMgr)
    bOk = bOk && luaMgr.RegisterFunction( "print", MyPrint) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtEvalNumExpr", LuaEvalNumExpr) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtPause", LuaPause) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtGetKeyPressed", LuaGetKeyPressed) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtStartCounter", LuaStartCounter) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtStopCounter", LuaStopCounter) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtNumToString", LuaNumToString) ;

LUA_MachMgr.cpp

@@ -3737,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)
@@ -4299,6 +4319,7 @@ 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) ;