EgtExecutor :

- corretto un commento.

EXE.h

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

EXE_CDeObjSolid.cpp

@@ -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.
@@ -49,7 +49,7 @@ MyCDeBoxClosedSurfTm( const Frame3d& frBox, const Vector3d& vtDiag, int nSurfTmI
   // porto in locale alla superficie il riferimento del box (il vettore è già in questo stesso riferimento)
    Frame3d frBoxL = GetFrameLocal( pGeomDB, frBox, nRefType, frSurf) ;
   // verifico la collisione
-   return ( CDeBoxClosedSurfTm( frBoxL, vtDiag, dSafeDist, *pStm) ? 1 : 0) ;
+   return ( CDeBoxClosedSurfTm( frBoxL, vtDiag, *pStm, dSafeDist) ? 1 : 0) ;
 }
 
 //----------------------------------------------------------------------------
@@ -69,7 +69,7 @@ MyCDeBoxVolZmap( const Frame3d& frBox, const Vector3d& vtDiag, int nZmapId, doub
   // porto in locale il riferimento (il vettore è già in locale a questo stesso riferimento)
    Frame3d frBoxL = GetFrameLocal( pGeomDB, frBox, nRefType, frLoc) ;
   // verifico la collisione
-   return ( pVZM->AvoidBox( frBoxL, vtDiag, dSafeDist, false) ? 0 : 1) ;
+   return ( pVZM->CDeBox( frBoxL, vtDiag, dSafeDist, false) ? 1 : 0) ;
 }
 
 //----------------------------------------------------------------------------
@@ -118,7 +118,7 @@ MyCDeRectPrismoidClosedSurfTm( const Frame3d& frPrismoid, double dBaseLenX, doub
   // porto in locale alla superficie il riferimento del prismoide rettangolare
    Frame3d frPrismoidL = GetFrameLocal( pGeomDB, frPrismoid, nRefType, frSurf) ;
   // verifico la collisione
-   return ( CDeRectPrismoidClosedSurfTm( frPrismoidL, dBaseLenX, dBaseLenY, dTopLenX, dTopLenY, dHeight, dSafeDist, *pStm) ? 1 : 0) ;
+   return ( CDeRectPrismoidClosedSurfTm( frPrismoidL, dBaseLenX, dBaseLenY, dTopLenX, dTopLenY, dHeight, *pStm, dSafeDist) ? 1 : 0) ;
 }
 
 //----------------------------------------------------------------------------
@@ -140,7 +140,7 @@ MyCDeRectPrismoidVolZmap( const Frame3d& frPrismoid, double dBaseLenX, double dB
   // porto in locale il riferimento (il vettore è già in locale a questo stesso riferimento)
    Frame3d frPrismoidL = GetFrameLocal( pGeomDB, frPrismoid, nRefType, frLoc) ;
   // verifico la collisione
-   return ( pVZM->AvoidRectPrismoid( frPrismoidL, dBaseLenX, dBaseLenY, dTopLenX, dTopLenY, dHeight, dSafeDist, false) ? 0 : 1) ;
+   return ( pVZM->CDeRectPrismoid( frPrismoidL, dBaseLenX, dBaseLenY, dTopLenX, dTopLenY, dHeight, dSafeDist, false) ? 1 : 0) ;
 }
 
 //----------------------------------------------------------------------------
@@ -193,7 +193,7 @@ MyCDeCylClosedSurfTm( const Frame3d& frCyl, double dR, double dH, int nSurfTmId,
   // porto in locale alla superficie il riferimento del cilindro
    Frame3d frCylL = GetFrameLocal( pGeomDB, frCyl, nRefType, frSurf) ;
   // verifico la collisione
-   return ( CDeCylClosedSurfTm( frCylL, dR, dH, dSafeDist, *pStm) ? 1 : 0) ;
+   return ( CDeCylClosedSurfTm( frCylL, dR, dH, *pStm, dSafeDist) ? 1 : 0) ;
 }
 
 //----------------------------------------------------------------------------
@@ -213,7 +213,7 @@ MyCDeCylVolZmap( const Frame3d& frCyl, double dR, double dH, int nZmapId, double
   // porto in locale il riferimento
    Frame3d frCylL = GetFrameLocal( pGeomDB, frCyl, nRefType, frLoc) ;
   // verifico la collisione
-   return ( pVZM->AvoidCylinder( frCylL, dR, dH, dSafeDist, false) ? 0 : 1) ;
+   return ( pVZM->CDeCylinder( frCylL, dR, dH, dSafeDist, false) ? 1 : 0) ;
 }
 
 //----------------------------------------------------------------------------
@@ -261,7 +261,7 @@ MyCDeConeClosedSurfTm( const Frame3d& frCone, double dR1, double dR2, double dH,
   // porto in locale alla superficie il riferimento del cilindro
    Frame3d frConeL = GetFrameLocal( pGeomDB, frCone, nRefType, frSurf) ;
   // verifico la collisione
-   return ( CDeConeFrustumClosedSurfTm( frConeL, dR1, dR2, dH, dSafeDist, *pStm) ? 1 : 0) ;
+   return ( CDeConeFrustumClosedSurfTm( frConeL, dR1, dR2, dH, *pStm, dSafeDist) ? 1 : 0) ;
 }
 
 //----------------------------------------------------------------------------
@@ -281,7 +281,7 @@ MyCDeConeVolZmap( const Frame3d& frCone, double dR1, double dR2, double dH, int
   // porto in locale il riferimento
    Frame3d frConeL = GetFrameLocal( pGeomDB, frCone, nRefType, frLoc) ;
   // verifico la collisione
-   return ( pVZM->AvoidConeFrustum( frConeL, dR1, dR2, dH, dSafeDist, false) ? 0 : 1) ;
+   return ( pVZM->CDeConeFrustum( frConeL, dR1, dR2, dH, dSafeDist, false) ? 1 : 0) ;
 }
 
 //----------------------------------------------------------------------------
@@ -330,7 +330,7 @@ MyCDeSpheClosedSurfTm( const Point3d& ptCen, double dR, int nSurfTmId, double dS
   // porto in locale alla superficie il centro della sfera
    Point3d ptCenL = GetPointLocal( pGeomDB, ptCen, nRefType, frSurf) ;
   // verifico la collisione
-   return ( CDeSpheClosedSurfTm( ptCenL, dR, dSafeDist, *pStm) ? 1 : 0) ;
+   return ( CDeSpheClosedSurfTm( ptCenL, dR, *pStm, dSafeDist) ? 1 : 0) ;
 }
 
 //----------------------------------------------------------------------------
@@ -350,7 +350,7 @@ MyCDeSpheVolZmap( const Point3d& ptCen, double dRad, int nZmapId, double dSafeDi
   // porto in locale il centro della sfera
    Point3d ptCenL = GetPointLocal( pGeomDB, ptCen, nRefType, frLoc) ;
   // verifico la collisione
-   return ( pVZM->AvoidSphere( ptCenL, dRad, dSafeDist, false) ? 0 : 1) ;
+   return ( pVZM->CDeSphere( ptCenL, dRad, dSafeDist, false) ? 1 : 0) ;
 }
 
 //----------------------------------------------------------------------------
@@ -420,7 +420,7 @@ MyCDeClosedSurfTmVolZmap( int nSurfTmId, int nZmapId, double dSafeDist)
    if ( pVZM == nullptr)
       return -1 ;
   // verifico la collisione
-   return ( pVZM->AvoidSurfTm( *pStm, dSafeDist, false) ? 0 : 1) ;
+   return ( pVZM->CDeSurfTm( *pStm, dSafeDist, false) ? 1 : 0) ;
 }
 
 //----------------------------------------------------------------------------
@@ -429,10 +429,14 @@ ExeCDeSolidSolid( int nSolid1Id, int nSolid2Id, double dSafeDist)
 {
    IGeomDB* pGeomDB = GetCurrGeomDB() ;
    int nRes = -1 ;
-   if ( pGeomDB != nullptr  &&  pGeomDB->GetGeoType( nSolid1Id) == SRF_TRIMESH  &&  pGeomDB->GetGeoType( nSolid2Id) == SRF_TRIMESH)
+   if ( pGeomDB != nullptr) {
-      nRes = MyCDeClosedSurfTmClosedSurfTm( nSolid1Id, nSolid2Id, dSafeDist) ;
+      if ( pGeomDB->GetGeoType( nSolid1Id) == SRF_TRIMESH  &&  pGeomDB->GetGeoType( nSolid2Id) == SRF_TRIMESH)
-   else if ( pGeomDB != nullptr  &&  pGeomDB->GetGeoType( nSolid1Id) == SRF_TRIMESH  &&  pGeomDB->GetGeoType( nSolid2Id) == VOL_ZMAP)
+         nRes = MyCDeClosedSurfTmClosedSurfTm( nSolid1Id, nSolid2Id, dSafeDist) ;
-      nRes = MyCDeClosedSurfTmVolZmap( nSolid1Id, nSolid2Id, dSafeDist) ;
+      else if ( pGeomDB->GetGeoType( nSolid1Id) == SRF_TRIMESH  &&  pGeomDB->GetGeoType( nSolid2Id) == VOL_ZMAP)
+         nRes = MyCDeClosedSurfTmVolZmap( nSolid1Id, nSolid2Id, dSafeDist) ;
+      else if ( pGeomDB->GetGeoType( nSolid1Id) == VOL_ZMAP  &&  pGeomDB->GetGeoType( nSolid2Id) == SRF_TRIMESH)
+         nRes = MyCDeClosedSurfTmVolZmap( nSolid2Id, nSolid1Id, dSafeDist) ;
+   }
   // se richiesto, salvo il comando Lua equivalente
    if ( IsCmdLog()) {
       string sLua = "EgtCDeSolidSolid({" + IdToString( nSolid1Id) + "," +

EXE_Exchange.cpp

@@ -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
+  //// aggiungo un gruppo pezzo e un gruppo layer
-   int nPartId = pGseCtx->m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, Frame3d()) ;
+  // 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)) ;

EXE_GdbCreate.cpp

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

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 ;
@@ -362,16 +363,13 @@ CreateLineTgTwoCurves( IGeomDB* pGeomDB, int nParentId,
    if ( pCrv2 == nullptr)
       return nullptr ;
   // porto la seconda curva nel riferimento della prima
-   PtrOwner<ICurve> pCrv2Loc( pCrv2->Clone()) ;
+   CurveLocal Crv2Loc( pGeomDB, nIdF, frCrv1) ;
-   if ( IsNull( pCrv2Loc))
-      return nullptr ;
-   pCrv2Loc->LocToLoc( frCrv2, frCrv1) ;
   // porto il punto vicino al finale nel riferimento della prima curva
    Point3d ptN2loc( ptFin) ;
    ptN2loc.LocToLoc( frDest, frCrv1) ;
   // calcolo la retta tangente alle due curve
    PtrOwner<ICurveLine> pCrvLine ;
-   pCrvLine.Set( GetLineTgTwoCurves( *pCrv1, ptN1loc, *pCrv2Loc, ptN2loc)) ;
+   pCrvLine.Set( GetLineTgTwoCurves( *pCrv1, ptN1loc, *Crv2Loc, ptN2loc)) ;
    if ( IsNull( pCrvLine))
       return nullptr ;
    // porto la linea nel riferimento del gruppo destinazione
@@ -1091,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,
@@ -2548,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

@@ -1,4 +1,4 @@
-//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
 //  EgalTech 2014-2015
 //----------------------------------------------------------------------------
 // File : EXE_GdbCreateSurf.cpp       Data : 04.05.15       Versione : 1.6e1
@@ -31,8 +31,11 @@
 #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 ;
 
 //-------------------------------------------------------------------------------
@@ -79,7 +82,7 @@ ExeCreateSurfFrRectangle( int nParentId, const Point3d& ptIni, const Point3d& pt
                     " -- Id=" + ToString( nNewId) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
    }
-  // restituisco l'identificativo della nuova entità
+  // restituisco l'identificativo della nuova entità
    return nNewId ;
 }
 
@@ -130,7 +133,7 @@ ExeCreateSurfFrRectangle3P( int nParentId, const Point3d& ptIni,
                     " -- Id=" + ToString( nNewId) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
    }
-  // restituisco l'identificativo della nuova entità
+  // restituisco l'identificativo della nuova entità
    return nNewId ;
 }
 
@@ -179,7 +182,7 @@ ExeCreateSurfFrStadium( int nParentId, const Point3d& ptIni, const Point3d& ptCr
                     " -- Id=" + ToString( nNewId) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
    }
-  // restituisco l'identificativo della nuova entità
+  // restituisco l'identificativo della nuova entità
    return nNewId ;
 }
 
@@ -196,7 +199,7 @@ ExeCreateSurfFrDisk( int nParentId, const Point3d& ptOrig, double dRad, int nRef
   // porto in locale il punto e calcolo la normale in locale
    Point3d ptOrigL = GetPointLocal( pGeomDB, ptOrig, nRefType, frLoc) ;
    Vector3d vtNL = GetVectorLocal( pGeomDB, Z_AX, nRefType, frLoc) ;
-  // calcolo riferimento per l'entità
+  // calcolo riferimento per l'entità
    Frame3d frEnt ;
    bOk = bOk && frEnt.Set( ptOrigL, vtNL) ;
   // creo il disco nel suo riferimento intrinseco
@@ -216,7 +219,7 @@ ExeCreateSurfFrDisk( int nParentId, const Point3d& ptOrig, double dRad, int nRef
                     " -- Id=" + ToString( nNewId) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
    }
-  // restituisco l'identificativo della nuova entità
+  // restituisco l'identificativo della nuova entità
    return nNewId ;
 }
 
@@ -260,7 +263,7 @@ ExeCreateSurfFrFatCurve( int nParentId, int nCrvId, double dRad, bool bSquaredEn
                     " -- Id=" + ToString( nNewId) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
    }
-  // restituisco l'identificativo della nuova entità
+  // restituisco l'identificativo della nuova entità
    return nNewId ;
 }
 
@@ -316,7 +319,7 @@ MyCreateSurfFlatRegion( int nParentId, const INTVECTOR& vCrvIds, int* pnCount)
      // recupero la prossima superficie
       pSfr = SfrCntr.GetSurf() ;
    }
-  // restituisco l'identificativo della prima nuova entità
+  // restituisco l'identificativo della prima nuova entità
    if ( pnCount != nullptr)
       *pnCount = nCount ;
    return nFirstId ;
@@ -339,7 +342,7 @@ ExeCreateSurfFlatRegion( int nParentId, const INTVECTOR& vCrvIds, int* pnCount)
                     " -- Id=" + ToString( nFirstId) + ",Nbr=" + ToString( nCount) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
    }
-  // restituisco l'identificativo della nuova entità
+  // restituisco l'identificativo della nuova entità
    return nFirstId ;
 }
 
@@ -388,7 +391,7 @@ ExeCreateSurfTmPlaneInBBox( int nParentId, const Point3d& ptP, const Vector3d& v
                     " -- Id=" + ToString( nNewId) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
    }
-  // restituisco l'identificativo della nuova entità
+  // restituisco l'identificativo della nuova entità
    return nNewId ;
 }
 
@@ -449,7 +452,7 @@ MyCreateSewPolygon( ISurfTriMesh* pStm, const Polygon3d& Polyg)
   // verifico esistenza superficie
    if ( pStm == nullptr)
       return false ;
-  // se poligono vuoto, non devo fare alcunché
+  // se poligono vuoto, non devo fare alcunché
    if ( Polyg.GetSideCount() == 0)
       return true ;
   // creo la superficie trimesh del poligono
@@ -579,7 +582,7 @@ ExeCreateSurfTmConvexHullInBBox( int nParentId, int nId, const BBox3d& b3Box, in
                     " -- Id=" + ToString( nNewId) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
    }
-  // restituisco l'identificativo della nuova entità
+  // restituisco l'identificativo della nuova entità
    return nNewId ;
 }
 
@@ -627,7 +630,7 @@ ExeCreateSurfTmBBox( int nParentId, const BBox3d& b3Box, bool bRegular, int nRef
                     " -- Id=" + ToString( nNewId) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
    }
-  // restituisco l'identificativo della nuova entità
+  // restituisco l'identificativo della nuova entità
    return nNewId ;
 }
 
@@ -682,7 +685,7 @@ ExeCreateSurfTmBox( int nParentId, const Point3d& ptIni, const Point3d& ptCross,
                     " -- Id=" + ToString( nNewId) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
    }
-  // restituisco l'identificativo della nuova entità
+  // restituisco l'identificativo della nuova entità
    return nNewId ;
 }
 
@@ -739,7 +742,7 @@ ExeCreateSurfTmPyramid( int nParentId, const Point3d& ptIni, const Point3d& ptCr
                     " -- Id=" + ToString( nNewId) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
    }
-  // restituisco l'identificativo della nuova entità
+  // restituisco l'identificativo della nuova entità
    return nNewId ;
 }
 
@@ -781,7 +784,7 @@ ExeCreateSurfTmCylinder( int nParentId, const Point3d& ptOrig, const Vector3d& v
                     " -- Id=" + ToString( nNewId) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
    }
-  // restituisco l'identificativo della nuova entità
+  // restituisco l'identificativo della nuova entità
    return nNewId ;
 }
 
@@ -823,7 +826,7 @@ ExeCreateSurfTmCone( int nParentId, const Point3d& ptOrig, const Vector3d& vtN,
                     " -- Id=" + ToString( nNewId) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
    }
-  // restituisco l'identificativo della nuova entità
+  // restituisco l'identificativo della nuova entità
    return nNewId ;
 }
 
@@ -859,7 +862,7 @@ ExeCreateSurfTmSphere( int nParentId, const Point3d& ptOrig,
                     " -- Id=" + ToString( nNewId) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
    }
-  // restituisco l'identificativo della nuova entità
+  // restituisco l'identificativo della nuova entità
    return nNewId ;
 }
 
@@ -901,7 +904,7 @@ ExeCreateSurfTmTriangle( int nParentId, const Point3d& ptP1, const Point3d& ptP2
                     " -- Id=" + ToString( nNewId) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
    }
-  // restituisco l'identificativo della nuova entità
+  // restituisco l'identificativo della nuova entità
    return nNewId ;
 }
 
@@ -950,7 +953,7 @@ ExeCreateSurfTmRectangle( int nParentId, const Point3d& ptO, const Point3d& ptL,
                     " -- Id=" + ToString( nNewId) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
    }
-  // restituisco l'identificativo della nuova entità
+  // restituisco l'identificativo della nuova entità
    return nNewId ;
 }
 
@@ -981,7 +984,7 @@ ExeCreateSurfTmByFlatContour( int nParentId, int nCrvId, double dLinTol)
                     " -- Id=" + ToString( nNewId) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
    }
-  // restituisco l'identificativo della nuova entità
+  // restituisco l'identificativo della nuova entità
    return nNewId ;
 }
 
@@ -1027,7 +1030,7 @@ ExeCreateSurfTmByRegion( int nParentId, const INTVECTOR& vCrvIds, double dLinTol
                     " -- Id=" + ToString( nNewId) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
    }
-  // restituisco l'identificativo della nuova entità
+  // restituisco l'identificativo della nuova entità
    return nNewId ;
 }
 
@@ -1082,7 +1085,7 @@ ExeCreateSurfTmByExtrusion( int nParentId, const INTVECTOR& vCrvIds, const Vecto
                     " -- Id=" + ToString( nFirstId) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
    }
-  // restituisco l'identificativo della nuova entità
+  // restituisco l'identificativo della nuova entità
    return nFirstId ;
 }
 
@@ -1126,7 +1129,7 @@ ExeCreateSurfTmByRegionExtrusion( int nParentId, const INTVECTOR& vCrvIds, const
                     " -- Id=" + ToString( nNewId) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
    }
-  // restituisco l'identificativo della nuova entità
+  // restituisco l'identificativo della nuova entità
    return nNewId ;
 }
 
@@ -1166,7 +1169,7 @@ ExeCreateSurfTmByRevolve( int nParentId, int nCrvId,
                     " -- Id=" + ToString( nNewId) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
    }
-  // restituisco l'identificativo della nuova entità
+  // restituisco l'identificativo della nuova entità
    return nNewId ;
 }
 
@@ -1208,13 +1211,14 @@ ExeCreateSurfTmByScrewing( int nParentId, int nCrvId,
                     " -- Id=" + ToString( nNewId) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
    }
-  // restituisco l'identificativo della nuova entità
+  // restituisco l'identificativo della nuova entità
    return nNewId ;
 }
 
 //-------------------------------------------------------------------------------
 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)
@@ -1245,13 +1249,75 @@ ExeCreateSurfTmRectSwept( int nParentId, double dDimH, double dDimV, double dBev
                     " -- Id=" + ToString( nNewId) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
    }
-  // restituisco l'identificativo della nuova entità
+  // restituisco l'identificativo della nuova entità
    return nNewId ;
 }
 
 //-------------------------------------------------------------------------------
 int
-ExeCreateSurfTmSwept( int nParentId, int nSectId, int nGuideId, bool bCapEnds, double dLinTol)
+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)
+   nParentId = AdjustId( nParentId) ;
+   bool bOk = true ;
+  // recupero il riferimento locale
+   Frame3d frLoc ;
+   bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
+  // 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 ;
+  // recupero il tipo di entità della sezione
+   int nSecType = pGeomDB->GetGeoType( nSectId) ;
+
+  // controllo se la sezione è definita da una curva
+   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, 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 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( vtAx) + "}," +
+                                        ( bCapEnds ? "true" : "false") + "," +
+                                        ToString( dLinTol) + "," +
+                                        RefTypeToString( nRefType) + ")" +
+                    " -- Id=" + ToString( nNewId) ;
+      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
+   }
+  // restituisco l'identificativo della nuova entità
+   return nNewId ;
+}
+
+//-------------------------------------------------------------------------------
+int
+ExeCreateSurfTmTransSwept( int nParentId, int nSectId, int nGuideId, bool bCapEnds, double dLinTol)
 {
    IGeomDB* pGeomDB = GetCurrGeomDB() ;
    VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
@@ -1268,21 +1334,21 @@ ExeCreateSurfTmSwept( int nParentId, int nSectId, int nGuideId, bool bCapEnds, d
    bOk = bOk && ( CrvGuide.Get() != nullptr) ;
   // creo la superficie trimesh
    ISurfTriMesh* pSTM = nullptr ;
-   pSTM = ( bOk ? GetSurfTriMeshSwept( CrvSect, CrvGuide, bCapEnds, dLinTol) : nullptr) ;
+   pSTM = ( bOk ? GetSurfTriMeshTransSwept( CrvSect, CrvGuide, bCapEnds, dLinTol) : nullptr) ;
   // inserisco la superficie trimesh nel DB
    int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, pSTM) : GDB_ID_NULL) ;
    ExeSetModified() ;
   // se richiesto, salvo il comando Lua equivalente
    if ( IsCmdLog()) {
-      string sLua = "EgtSurfTmSwept(" + IdToString( nParentId) + "," +
+      string sLua = "EgtSurfTmTransSwept(" + IdToString( nParentId) + "," +
-                                        ToString( nSectId) + "," +
+                                             ToString( nSectId) + "," +
-                                        ToString( nGuideId) + "," +
+                                             ToString( nGuideId) + "," +
-                                        ( bCapEnds ? "true" : "false") + "," +
+                                             ( bCapEnds ? "true" : "false") + "," +
-                                        ToString( dLinTol) + ")" +
+                                             ToString( dLinTol) + ")" +
                     " -- Id=" + ToString( nNewId) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
    }
-  // restituisco l'identificativo della nuova entità
+  // restituisco l'identificativo della nuova entità
    return nNewId ;
 }
 
@@ -1299,7 +1365,7 @@ ExeCreateSurfTmRuled( int nParentId, int nPtOrCrvId1, int nPtOrCrvId2, int nType
    bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
   // creo la superficie trimesh
    ISurfTriMesh* pSTM = nullptr ;
-  // se la prima entità è un punto e la seconda una curva
+  // se la prima entità è un punto e la seconda una curva
    if ( pGeomDB->GetGeoType( nPtOrCrvId1) == GEO_PNT3D  &&
         ( pGeomDB->GetGeoType( nPtOrCrvId2) & GEO_CURVE) != 0) {
      // recupero il punto in locale
@@ -1315,7 +1381,7 @@ ExeCreateSurfTmRuled( int nParentId, int nPtOrCrvId1, int nPtOrCrvId2, int nType
      // calcolo la superficie
       pSTM = ( bOk ? GetSurfTriMeshRuled( ptP, CrvLoc, dLinTol) : nullptr) ;
    }
-  // se la prima entità è una curva e la seconda un punto
+  // se la prima entità è una curva e la seconda un punto
    else if ( ( pGeomDB->GetGeoType( nPtOrCrvId1) & GEO_CURVE) != 0  &&
              pGeomDB->GetGeoType( nPtOrCrvId2) == GEO_PNT3D) {
      // recupero la curva in locale
@@ -1359,7 +1425,7 @@ ExeCreateSurfTmRuled( int nParentId, int nPtOrCrvId1, int nPtOrCrvId2, int nType
                     " -- Id=" + ToString( nNewId) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
    }
-  // restituisco l'identificativo della nuova entità
+  // restituisco l'identificativo della nuova entità
    return nNewId ;
 }
 
@@ -1470,7 +1536,7 @@ ExeCreateSurfTmBySewing( int nParentId, const INTVECTOR& vIds, bool bErase)
          bOk = bOk && pGeomDB->GetGlobFrame( nId, frStmS) ;
         // lo esprimo rispetto a quello della prima superficie
          frStmS.ToLoc( frLoc) ;
-        // se è la prima, copio
+        // se è la prima, copio
          if ( bFirst) {
             bOk = bOk && pStm->CopyFrom( pStmS) ;
             bOk = bOk && pStm->ToGlob( frStmS) ;
@@ -1515,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
-   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)
@@ -1659,7 +1689,7 @@ ExeCreateSurfBezier( int nParentId, int nDegU, int nDegV, int nSpanU, int nSpanV
                     " -- Id=" + ToString( nId) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
    }
-  // restituisco l'identificativo della nuova entità
+  // restituisco l'identificativo della nuova entità
    return nId ;
 }
 
@@ -1711,7 +1741,7 @@ ExeCreateSurfBezierRational( int nParentId, int nDegU, int nDegV, int nSpanU, in
                     " -- Id=" + ToString( nId) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
    }
-  // restituisco l'identificativo della nuova entità
+  // restituisco l'identificativo della nuova entità
    return nId ;
 }
 
@@ -1782,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 ;
+}

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,7 +27,7 @@
 #include "/EgtDev/Include/EGkDistPointCurve.h"
 #include "/EgtDev/Include/EGkIntersCurves.h"
 #include "/EgtDev/Include/EGkSurfFlatRegion.h"
-#include "EgtDev/Include/EGkVoronoi.h"
+#include "/EgtDev/Include/EGkGeoPoint3d.h"
 
 //----------------------------------------------------------------------------
 bool

EXE_GdbGetPocketing.cpp

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2023-2023
+//  EgalTech 2023-2024
 //----------------------------------------------------------------------------
-// File : Exe_GdbGetPocketing.cpp       Data : 28.11.23        Versione : 2.5k6
+// File : Exe_GdbGetPocketing.cpp     Data : 02.02.24      Versione : 2.6b1
 // Contenuto : Funzioni di interrogazione di regioni piane del DBG per EXE.
 //
 //
@@ -16,6 +16,7 @@
 #include "EXE.h"
 #include "EXE_Macro.h"
 #include "/EgtDev/Include/EXeExecutor.h"
+#include "/EgtDev/Include/EGkSfrCreate.h"
 #include "/EgtDev/Include/EGkCalcPocketing.h"
 
 using namespace std ;
@@ -25,14 +26,26 @@ bool
 ExePocketing( const int nId, double dRad, double dStep, double dAngle, int nType, bool bSmooth, int nDestGrpId,
               int& nFirstId, int& nCrvCount)
 {
-  // databse geometrico
+  // database geometrico
    IGeomDB* pGeomDB = GetCurrGeomDB() ;
    VERIFY_GEOMDB( pGeomDB, false) ;
 
-  // recupero la FlatRegion per i percorsi
+  // recupero la FlatRegion da svuotare
+   PtrOwner<ISurfFlatRegion> pMySfr ;
    const ISurfFlatRegion* pSfr = GetSurfFlatRegion( pGeomDB->GetGeoObj( nId)) ;
-   if ( pSfr == nullptr)
+   if ( pSfr == nullptr) {
-      return false ;
+     // verifico se è una curva chiusa e piana che permette di definire una regione
+      const ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( nId)) ;
+      Plane3d plPlane ;
+      if ( pCrv == nullptr  ||  ! pCrv->IsFlat( plPlane, true, 10 * EPS_SMALL))
+         return false ;
+      SurfFlatRegionByContours SfrCntr ;
+      SfrCntr.AddCurve( pCrv->Clone()) ;
+      pMySfr.Set( SfrCntr.GetSurf()) ;
+      if ( IsNull( pMySfr))
+         return false ;
+      pSfr = pMySfr ;
+   }
 
   // recupero il suo frame
    Frame3d frSfr ;
@@ -44,23 +57,21 @@ ExePocketing( const int nId, double dRad, double dStep, double dAngle, int nType
    if ( ! pGeomDB->GetGroupGlobFrame( nDestGrpId, frDest))
       return false ;
 
-  // costruzione vettori di curve per Pocketing
-   ICRVCOMPOPOVECTOR vCrvCompoRes ;
-
   // eseguo Pocketing
+   ICRVCOMPOPOVECTOR vCrvCompoRes ;
    bool bOk = CalcPocketing( pSfr, dRad, dStep, dAngle, nType, bSmooth, vCrvCompoRes) ;
-   nFirstId = GDB_ID_NULL ; // primo Id da restituire
+   nFirstId = GDB_ID_NULL ;
    nCrvCount = int( vCrvCompoRes.size()) ;
-   if ( bOk  &&  int( vCrvCompoRes.size()) > 0) {
+   if ( bOk  &&  nCrvCount > 0) {
      // scorro le curve di Pocketing ottenute
-      for ( int u = 0 ; u < int( vCrvCompoRes.size()) ; ++ u) {
+      for ( int nI = 0 ; nI < nCrvCount ; ++ nI) {
-         vCrvCompoRes[u]->LocToLoc( frSfr, frDest) ;
+         vCrvCompoRes[nI]->LocToLoc( frSfr, frDest) ;
         // inserisco la curva nel DB Geometrico
-         int nCurrId = pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, Release( vCrvCompoRes[u])) ;
+         int nCurrId = pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, Release( vCrvCompoRes[nI])) ;
          if ( nCurrId == GDB_ID_NULL)
             return false ;
-         if ( u == 0)
+         if ( nI == 0)
-            nFirstId = nCurrId ; // memorizzo il primo Id da restituire
+            nFirstId = nCurrId ;
       }
       ExeSetModified() ;
    }
@@ -73,7 +84,7 @@ ExePocketing( const int nId, double dRad, double dStep, double dAngle, int nType
                                       ToString( nType) + "," +
                                       ToString( bSmooth) + "," +
                                       ToString( nDestGrpId) + ")" +
-                    " -- Ok=" + ToString( bOk) + " FirstId=" + ToString( nFirstId) + " CurveCount=" + ToString( nCrvCount) ;
+                    " FirstId=" + ToString( nFirstId) + " CurveCount=" + ToString( nCrvCount) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
    }
    return bOk ;

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)
@@ -1462,25 +1554,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 ;
+   ICRVCOMPOPOVECTOR vCC ;
-   PtrOwner<ICurve> pCrv( bOk ? pSbz->GetLoop( nL) : nullptr) ;
+   pSbz->GetLoops( vCC , true) ;
-   while ( ! IsNull( pCrv)) {
+   for ( int i = 0 ; i < int( vCC.size()) ; ++i) {
-     // porto la curva nel riferimento destinazione
+      if ( IsNull( vCC[i])  ||  ! vCC[i]->IsValid())
-      bOk = bOk && pCrv->LocToLoc( frSurf, frDest) ;
+         continue ;
-     // la inserisco nel DB geometrico
+      // porto la curva nel riferimento destinazione
-      int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, Release( pCrv)) : GDB_ID_NULL) ;
+      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
+      // copio il materiale
-     if ( ! pGeomDB->CopyMaterial( nId, nNewId))
+      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()) {

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"
@@ -27,21 +29,22 @@
 #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"
 #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/EGkGeoVector3d.h"
-#include "/EgtDev/Include/EgtPointerOwner.h"
 #include "/EgtDev/Include/EGkCalcPocketing.h"
-#include <EgtDev/Include/EGkSfrCreate.h>
+#include "/EgtDev/Include/EgtPointerOwner.h"
 #include <functional>
 
 
@@ -186,7 +189,7 @@ ExeCurveMedialAxis( int nId)
 
 //-------------------------------------------------------------------------------
 bool
-ExeApproxCurve( int nId, int nApprType, double dLinTol)
+ExeApproxCurve( int nId, int nApprType, double dLinTol, double dMaxSegmLen)
 {
    IGeomDB* pGeomDB = GetCurrGeomDB() ;
    VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
@@ -200,7 +203,8 @@ ExeApproxCurve( int nId, int nApprType, double dLinTol)
         nApprType == APP_LEFT_LINES  ||  nApprType == APP_LEFT_CONVEX_LINES  ||
         nApprType == APP_RIGHT_LINES  ||  nApprType == APP_RIGHT_CONVEX_LINES) {
       PolyLine PL ;
-      bOk = bOk && pCurve->ApproxWithLines( dLinTol, ANG_TOL_MAX_DEG, nApprType, PL) && pCC->FromPolyLine( PL) ;
+      bOk = bOk && pCurve->ApproxWithLines( dLinTol, ANG_TOL_MAX_DEG, nApprType, PL) &&
+                   PL.AdjustForMaxSegmentLen( dMaxSegmLen) && pCC->FromPolyLine( PL) ;
      // eliminazione di small Z
       bOk = bOk && pCC->RemoveSmallDefects( 0.5 * dLinTol, ANG_TOL_STD_DEG) ;
    }
@@ -330,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) ;
@@ -2270,7 +2273,8 @@ ExeReorderCurvesInGroup( int nGroupId, const Point3d& ptNear, int nRefType)
 
 //-------------------------------------------------------------------------------
 static bool
-MyProjectCurveOnSurfTm( int nCurveId, int nSurfTmId, const Vector3d& vtDir, int nDestGrpId, double dLinTol, int nRefType)
+MyProjectCurveOnSurfTm( int nCurveId, int nSurfTmId, const Vector3d& vtDir, int nDestGrpId,
+                        double dLinTol, double dMaxSegmLen, int nRefType)
 {
    IGeomDB* pGeomDB = GetCurrGeomDB() ;
    VERIFY_GEOMDB( pGeomDB, false)
@@ -2301,7 +2305,7 @@ MyProjectCurveOnSurfTm( int nCurveId, int nSurfTmId, const Vector3d& vtDir, int
    vtDirL.LocToLoc( frCrv, frStm) ;
   // eseguo la proiezione
    PNT5AXVECTOR vPt5ax ;
-   if ( ! ProjectCurveOnSurfTm( *CrvLoc.Get(), *pStm, vtDirL, dLinTol, vPt5ax))
+   if ( ! ProjectCurveOnSurfTm( *CrvLoc.Get(), *pStm, vtDirL, dLinTol, dMaxSegmLen, vPt5ax))
       return false ;
   // inserisco la composita nel gruppo destinazione
    PtrOwner<ICurveComposite> pCompo ;
@@ -2338,9 +2342,10 @@ MyProjectCurveOnSurfTm( int nCurveId, int nSurfTmId, const Vector3d& vtDir, int
 
 //-------------------------------------------------------------------------------
 bool
-ExeProjectCurveOnSurfTm( int nCurveId, int nSurfTmId, const Vector3d& vtDir, int nDestGrpId, double dLinTol, int nRefType)
+ExeProjectCurveOnSurfTm( int nCurveId, int nSurfTmId, const Vector3d& vtDir, int nDestGrpId,
+                         double dLinTol, double dMaxSegmLen, int nRefType)
 {
-   bool bOk = MyProjectCurveOnSurfTm( nCurveId, nSurfTmId, vtDir, nDestGrpId, dLinTol, nRefType) ;
+   bool bOk = MyProjectCurveOnSurfTm( nCurveId, nSurfTmId, vtDir, nDestGrpId, dLinTol, dMaxSegmLen, nRefType) ;
    ExeSetModified() ;
   // se richiesto, salvo il comando Lua equivalente
    if ( IsCmdLog()) {
@@ -2349,6 +2354,7 @@ ExeProjectCurveOnSurfTm( int nCurveId, int nSurfTmId, const Vector3d& vtDir, int
                                                  ToString( vtDir) + "}," +
                                                  ToString( nDestGrpId) + "," +
                                                  ToString( dLinTol) + "," +
+                                                 ToString( dMaxSegmLen) + "," +
                                                  RefTypeToString( nRefType) + ")" +
                     " -- Ok=" + ToString( bOk) ;
       LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
@@ -2357,6 +2363,358 @@ 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 ;
+
+}
+
+//-------------------------------------------------------------------------------
+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

@@ -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( ( pSbez != nullptr ? pSbez->GetApproxSurf( dLinTol, dTriaMinSide) : nullptr)) ;
-      pStm.Set( pAuxSurf != nullptr ? pAuxSurf->Clone() : 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() ;
@@ -368,6 +368,32 @@ ExeSurfFrOffset( int nId, double dDist, int nType)
    return bOk ;
 }
 
+//----------------------------------------------------------------------------
+bool
+ExeSurfFrOffsetAdv( int nId, double dDist, int nType, int& nNewId)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
+  // recupero la superficie FlatRegion
+   ISurfFlatRegion* pSfr = GetSurfFlatRegion( pGeomDB->GetGeoObj( nId)) ;
+   if ( pSfr == nullptr)
+      return false ;      
+  // eseguo l'offset
+   PtrOwner<ISurfFlatRegion> pSfrOffs( pSfr->CreateOffsetSurf( dDist, nType)) ;
+   if ( IsNull( pSfrOffs))
+      return false ;
+  // salvo la superficie di offset
+   nNewId = GDB_ID_NULL ;
+   if ( pSfr->GetChunkCount() > 0) {
+     // inserisco nel DB geometrico
+      nNewId = pGeomDB->InsertGeoObj( GDB_ID_NULL, nId, GDB_AFTER, Release( pSfrOffs)) ;
+     // copio gli attributi
+      pGeomDB->CopyAttributes( nId, nNewId) ;
+      ExeSetModified() ;
+   }
+   return true ;
+}
+
 //----------------------------------------------------------------------------
 bool
 ExeSurfFrMoveSimpleNoCollision( int nId1, int nId2, const Vector3d& vtDir, double& dLen, int nRefType)
@@ -417,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
@@ -449,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)
@@ -461,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 ;
@@ -487,7 +557,7 @@ MySurfTmToTriangles( int nId, int& nCount)
      // restituisco risultati
       return nFirstId ;
    }
-  // non devo fare alcunch�
+  // non devo fare alcunché
    nCount = 1 ;
    return nId ;
 }
@@ -622,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)
@@ -758,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)
@@ -990,6 +1074,102 @@ 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)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, false)
+  // recupero la superficie TriMesh
+   ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
+   bool bOk = ( pStm != nullptr) ;
+  // reset dei flag sui triangoli per i due colori
+   bOk = bOk && pStm->ResetTFlags() ;
+   ExeSetModified() ;
+  // se richiesto, salvo il comando Lua equivalente
+   if ( IsCmdLog()) {
+      string sLua = "EgtSurfTmResetTwoColors(" + ToString( nId) + ")" +
+                    " -- Ok=" + ToString( bOk) ;
+      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
+   }
+   return bOk ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ExeSurfTmSetShowEdges( int nId, bool bShow)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, false)
+  // recupero la superficie trimesh
+   ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
+   bool bOk = ( pStm != nullptr) ;
+  // imposto lo stato di visualizzazione degli spigoli vivi
+   if ( bOk)
+      pStm->SetShowEdges( bShow) ;
+   ExeSetModified() ;
+  // se richiesto, salvo il comando Lua equivalente
+   if ( IsCmdLog()) {
+      string sLua = "EgtSurfTmSetShowEdges(" + ToString( nId) + "," +
+                                               ToString( bShow) + ")" +
+                    " -- Ok=" + ToString( bOk) ;
+      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
+   }
+   return bOk ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ExeSurfTmGetShowEdges( int nId, bool& bShow)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, false)
+  // recupero la superficie trimesh
+   ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
+   bool bOk = ( pStm != nullptr) ;
+  // recupero lo stato di visualizzazione degli spigoli vivi
+   bShow = ( bOk && pStm->GetShowEdges()) ;
+   return bOk ;
+}
 
 //----------------------------------------------------------------------------
 static bool 
@@ -1034,3 +1214,24 @@ ExeSurfBzTrim( int nId, int nCutterId)
    }
    return bOk ;
 }
+
+//----------------------------------------------------------------------------
+bool
+ExeSurfTmSetSmoothAng( int nId, double dAngDeg)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, false)
+   // recupero la superficie trimseh da trimmare
+   ISurfTriMesh* pSrfTm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
+   if ( pSrfTm == nullptr)
+      return false ;
+   pSrfTm->SetSmoothAngle( dAngDeg) ;
+   ExeSetModified() ;
+   // se richiesto, salvo il comando Lua equivalente
+   if ( IsCmdLog()) {
+      string sLua = "EgtSurfTmSetSmoothAng(" + ToString( nId) + "," +
+                                             ToString( dAngDeg) ;
+      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
+   }
+   return true ;
+}

EXE_GdbModifyVol.cpp

@@ -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)
+   bool bOk = ( pVZM != nullptr) ;
-      return false ;
   // 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)

EXE_General.cpp

@@ -35,6 +35,7 @@
 #include "/EgtDev/Include/EgtIniFile.h"
 #include "/EgtDev/Include/EgtLogger.h"
 #include "/EgtDev/Include/EgtStringConverter.h"
+#include "/EgtDev/Include/EgtKeyCodes.h"
 #include "/EgtDev/Include/SELkLockId.h"
 #include "/EgtDev/Include/SELkKeyProc.h"
 #include <fstream>
@@ -52,6 +53,7 @@ static string  s_sKey ;
 static int     s_nKeyType = KEY_LOCK_TYPE_ANY ;
 static bool    s_bNetHwKey = false ;
 static int     s_nKeyExpDays = 0 ;
+static int     s_nKeyAssExpDays = 0 ;
 static int     s_nKeyOptExpDays = 0 ;
 static string  s_sNestKey ;
 static string  s_sLockId ;
@@ -344,6 +346,41 @@ ExeSetNetHwKey( bool bNetHwKey, int nUserId, const string& sAddrPort)
    return SetNetHwKey( s_bNetHwKey, nUserId, sAddrPort) ;
 }
 
+//-----------------------------------------------------------------------------
+bool
+ExeGetNetHwKey( void)
+{
+   return s_bNetHwKey ;
+}
+
+//-----------------------------------------------------------------------------
+bool
+ExeVerifyKeyOption( int nOptInd)
+{
+  // recupero le opzioni abilitate
+   unsigned int nOpt1, nOpt2 ;
+   int nOptExpDays ;
+   int nRet = GetEGnKeyOptions( KEY_BASELIB_PROD, KEY_BASELIB_VER, KEY_BASELIB_LEV,
+                                nOpt1, nOpt2, nOptExpDays) ;
+   if ( ! ExeGetNetHwKey())
+      nRet = GetKeyOptions( ExeGetKey(), KEY_BASELIB_PROD, KEY_BASELIB_VER, KEY_BASELIB_LEV,
+                            nOpt1, nOpt2, nOptExpDays) ;
+  // verifico validità chiave con licenza
+   if ( nRet != KEY_OK  ||  nOptExpDays < GetCurrDay())
+      return false ;
+  // verifico le opzioni (nOptInd = 100 -> bit 0 di Opt1 ... = 200 -> bit 0 di Opt2 ... = 231 -> bit 31 di Opt2)
+   if ( nOptInd >= 100  &&  nOptInd <= 131) {
+      unsigned int nOptVal = ( 1 << ( nOptInd - 100)) ;
+      return ( ( nOpt1 & nOptVal) != 0) ;
+   }
+   else if ( nOptInd >= 200  &&  nOptInd <= 231) {
+      unsigned int nOptVal = ( 1 << ( nOptInd - 200)) ;
+      return ( ( nOpt2 & nOptVal) != 0) ;
+   }
+   else
+      return false ;
+}
+
 //-----------------------------------------------------------------------------
 bool
 ExeSetFont( const string& sNfeFontDir, const string& sDefaultFont)
@@ -519,7 +556,7 @@ bool
 ExeGetKeyLevel( int nProd, int nVer, int nLev, int& nKLev)
 {
   // verifico la chiave e il livello
-   int nRet = GetKeyLevel( s_sKey, nProd, nVer, nLev, nKLev, s_nKeyExpDays) ;
+   int nRet = GetKeyLevelEx( s_sKey, nProd, nVer, nLev, nKLev, s_nKeyExpDays, s_nKeyAssExpDays) ;
    SetEGnKeyLevel( nRet, nKLev, s_nKeyExpDays) ;
    if ( nRet != KEY_OK) {
       string sErr = "Error on Key (EGKL/" + ToString( nRet) + ")" ;
@@ -527,7 +564,6 @@ ExeGetKeyLevel( int nProd, int nVer, int nLev, int& nKLev)
       nKLev = - nRet ;
       return false ;
    }
-
    return true ;
 }
 
@@ -551,7 +587,6 @@ ExeGetKeyOptions( int nProd, int nVer, int nLev, unsigned int& nOpt2)
       LOG_ERROR( s_pGenLog, sErr.c_str()) ;
       return true ;
    }
-
    return true ;
 }
 
@@ -565,6 +600,16 @@ ExeGetKeyLeftDays( int& nLeftDays)
    return true ;
 }
 
+//-----------------------------------------------------------------------------
+bool
+ExeGetKeyAssLeftDays( int& nAssLeftDays)
+{
+   if ( s_nKeyAssExpDays == 0)
+      return false ;
+   nAssLeftDays = s_nKeyAssExpDays - GetCurrDay() ;
+   return true ;
+}
+
 //-----------------------------------------------------------------------------
 bool
 ExeGetKeyOptLeftDays( int& nOptLeftDays)

EXE_MachMgr.cpp

@@ -284,6 +284,26 @@ ExeRemoveMachGroup( int nMGroupId)
    return bOk ;
 }
 
+//-----------------------------------------------------------------------------
+bool
+ExeChangeMachGroupName( int nId, const string& sNewName)
+{
+   IMachMgr* pMachMgr = GetCurrMachMgr() ;
+   VERIFY_MACHMGR( pMachMgr, false)
+  // cambia il nome della macchinata
+   bool bOk = pMachMgr->ChangeMachGroupName( nId, sNewName) ;
+   ExeSetModified() ;
+  // se richiesto, salvo il comando Lua equivalente
+   if ( IsCmdLog()) {
+      string sLua = "EgtChangeMachGroupName(" + ToString( nId) + ",'" +
+                                                sNewName + "')" +
+                    " -- Ok=" + ToString( bOk) ;
+      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
+   }
+  // restituisco il risultato
+   return bOk ;
+}
+
 //-----------------------------------------------------------------------------
 bool
 ExeGetMachGroupName( int nId, string& sName)
@@ -2894,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)
@@ -3182,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)
@@ -3202,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)
@@ -3212,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)
@@ -3381,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)
@@ -3441,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)

EXE_NstCreateFlatParts.cpp

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

EXE_Scene.cpp

@@ -640,6 +640,15 @@ ExeZoomWin( int nPrevX, int nPrevY, int nCurrX, int nCurrY, bool bRedraw)
    return true ;
 }
 
+//-----------------------------------------------------------------------------
+bool
+ExeSetViewOrizzOffsStep( int nDirOffsStep)
+{
+   IEGrScene* pScene = GetCurrScene() ;
+   VERIFY_SCENE( pScene, false)
+   return pScene->SetCameraDirOrizzOffset( nDirOffsStep) ;
+}
+
 //-----------------------------------------------------------------------------
 bool
 ExeSetView( int nDir, bool bRedraw)
@@ -709,6 +718,19 @@ ExeRotateView( int nPrevX, int nPrevY, int nCurrX, int nCurrY, bool bRedraw)
    return true ;
 }
 
+//-----------------------------------------------------------------------------
+bool
+ExeGetViewOrizzOffsStep( int* pnDirOffsStep)
+{
+   IEGrScene* pScene = GetCurrScene() ;
+   VERIFY_SCENE( pScene, false)
+  // recupero offset direzione di vista
+   if ( pnDirOffsStep == nullptr)
+      return false ;
+   *pnDirOffsStep = pScene->GetCameraDirOrizzOffset() ;
+   return true ;
+}
+
 //-----------------------------------------------------------------------------
 bool
 ExeGetView( int* pnDir)

EXE_TestObjSurface.cpp

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

EgtExecutor.vcxproj

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

EgtExecutor.vcxproj.filters

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

LUA.h

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

LUA_Base.cpp

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

LUA_Exchange.cpp

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

LUA_GdbCreate.cpp

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

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_GdbCreateSurf.cpp

@@ -659,6 +659,41 @@ LuaCreateSurfTmRectSwept( lua_State* L)
 //-------------------------------------------------------------------------------
 static int
 LuaCreateSurfTmSwept( lua_State* L)
+{
+  // 4, 5, 6 o 7 parametri : ParentId, SectId, GuideId [, vtAx], bCapEnds [, dTol] [, nRefType]
+   int nParentId ;
+   LuaCheckParam( L, 1, nParentId)
+   int nSectId ;
+   LuaCheckParam( L, 2, nSectId)
+   int nGuideId ;
+   LuaCheckParam( L, 3, nGuideId)
+   int nPar = 4 ;
+   Vector3d vtAx = V_NULL ;
+   if ( LuaGetParam( L, nPar, vtAx))
+      ++ nPar ;
+   bool bCapEnds ;
+   LuaCheckParam( L, nPar, bCapEnds)
+   ++ nPar ;
+   double dLinTol = LIN_TOL_SRF ;
+   if ( LuaGetParam( L, nPar, dLinTol))
+      ++ nPar ;
+   int nRefType = RTY_DEFAULT ;
+   if ( LuaGetParam( L, nPar, nRefType))
+      ++ nPar ;
+   LuaClearStack( L) ;
+  // creo STM swept
+   int nId = ExeCreateSurfTmSwept( nParentId, nSectId, nGuideId, vtAx, bCapEnds, dLinTol, nRefType) ;
+  // restituisco il risultato
+   if ( nId != GDB_ID_NULL)
+      LuaSetParam( L, nId) ;
+   else
+      LuaSetParam( L) ;
+   return 1 ;
+}
+
+//-------------------------------------------------------------------------------
+static int
+LuaCreateSurfTmTransSwept( lua_State* L)
 {
   // 4 o 5 parametri : ParentId, SectId, GuideId, bCapEnds [, dTol]
    int nParentId ;
@@ -672,8 +707,8 @@ LuaCreateSurfTmSwept( lua_State* L)
    double dLinTol = LIN_TOL_SRF ;
    LuaGetParam( L, 5, dLinTol) ;
    LuaClearStack( L) ;
-  // creo STM swept
+  // creo STM swept di traslazione
-   int nId = ExeCreateSurfTmSwept( nParentId, nSectId, nGuideId, bCapEnds, dLinTol) ;
+   int nId = ExeCreateSurfTmTransSwept( nParentId, nSectId, nGuideId, bCapEnds, dLinTol) ;
   // restituisco il risultato
    if ( nId != GDB_ID_NULL)
       LuaSetParam( L, nId) ;
@@ -761,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)
@@ -903,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)
@@ -932,13 +1006,15 @@ LuaInstallGdbCreateSurf( LuaMgr& luaMgr)
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmByScrewing", LuaCreateSurfTmByScrewing) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmRectSwept", LuaCreateSurfTmRectSwept) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmSwept", LuaCreateSurfTmSwept) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmTransSwept", LuaCreateSurfTmTransSwept) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmRuled", LuaCreateSurfTmRuled) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmByTriangles", LuaCreateSurfTmByTriangles) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmBySewing", LuaCreateSurfTmBySewing) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmBySurfBezier", LuaCreateSurfTmBySurfBezier) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmByVolZmap", LuaCreateSurfTmByVolZmap) ;
    bOk = bOk && luaMgr.RegisterFunction( "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 ;
 }

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

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

LUA_GdbGetPocketing.cpp

@@ -21,7 +21,7 @@ using namespace std ;
 //----------------------------------------------------------------------------
 static int
 LuaPocketing( lua_State* L) {
-  // 7 parametri : vId, dRad, dStep, dAngle, nType, bSmooth, nDestGrpId
+  // 7 parametri : nId, dRad, dStep, dAngle, nType, bSmooth, nDestGrpId
    int nId ;
    LuaCheckParam( L, 1, nId) ;
    double dRad ;

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

@@ -105,16 +105,18 @@ LuaCurveMedialAxis( lua_State* L)
 static int
 LuaApproxCurve( lua_State* L)
 {
-  // 2 o 3 parametri : Id, nApprType [, dLinTol]
+  // 2 o 3 o 4 parametri : Id, nApprType [, dLinTol [, dMaxSegmLen]]
    int nId ;
    LuaCheckParam( L, 1, nId)
    int nApprType ;
    LuaCheckParam( L, 2, nApprType)
    double dLinTol = 0.01 ;
-   LuaGetParam( L, 3, dLinTol) ;
+   double dMaxSegmLen = INFINITO ;
+   if ( LuaGetParam( L, 3, dLinTol))
+      LuaGetParam( L, 4, dMaxSegmLen) ;
    LuaClearStack( L) ;
   // approssimazione della curva con rette
-   bool bOk = ExeApproxCurve( nId, nApprType, dLinTol) ;
+   bool bOk = ExeApproxCurve( nId, nApprType, dLinTol, dMaxSegmLen) ;
    LuaSetParam( L, bOk) ;
    return 1 ;
 }
@@ -951,7 +953,7 @@ LuaReorderCurvesInGroup( lua_State* L)
 static int
 LuaProjectCurveOnSurfTm( lua_State* L)
 {
-  // 4, 5 o 6 parametri : nCurveId, nSurfTmId, vtDir, nDestGrpId [, dLinTol [, nRefType]]
+  // 4, 5, 6 o 7 parametri : nCurveId, nSurfTmId, vtDir, nDestGrpId [, dLinTol [, dMaxSegmLen] [, nRefType]]
    int nCurveId ;
    LuaCheckParam( L, 1, nCurveId)
    int nSurfTmId ;
@@ -961,12 +963,92 @@ LuaProjectCurveOnSurfTm( lua_State* L)
    int nDestGrpId ;
    LuaCheckParam( L, 4, nDestGrpId)
    double dLinTol = 0.01 ;
+   double dMaxSegmLen = INFINITO ;
    int nRefType = RTY_DEFAULT ;
-   if ( LuaGetParam( L, 5, dLinTol))
+   if ( LuaGetParam( L, 5, dLinTol)  &&
-      LuaGetParam( L, 6, nRefType) ;
+        LuaGetParam( L, 6, dMaxSegmLen))
+      LuaGetParam( L, 7, nRefType) ;
    LuaClearStack( L) ;
   // proietto la curva su una trimesh secondo la direzione data
-   bool bOk = ExeProjectCurveOnSurfTm( nCurveId, nSurfTmId, vtDir, nDestGrpId, dLinTol, nRefType) ;
+   bool bOk = ExeProjectCurveOnSurfTm( nCurveId, nSurfTmId, vtDir, nDestGrpId, dLinTol, dMaxSegmLen, nRefType) ;
+   LuaSetParam( L, bOk) ;
+   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
+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 ;
 }
@@ -980,7 +1062,7 @@ LuaCurveGetVoronoi( lua_State* L)
    LuaCheckParam( L, 1, nId)
    int nDestGrpId ;
    LuaCheckParam( L, 2, nDestGrpId)
-   int nBound = VORONOI_STD_BOUND ;
+   int nBound = 3 ;      // VORONOI_STD_BOUND
    LuaGetParam( L, 3, nBound) ;
    LuaClearStack( L) ;
   // eseguo
@@ -1004,7 +1086,7 @@ LuaCurveMedialAxisAdv( lua_State* L)
    LuaCheckParam( L, 1, nId)
    int nDestGrpId ;
    LuaCheckParam( L, 2, nDestGrpId)
-   int nSide = Voronoi::WMAT_LEFT ;
+   int nSide = 1 ;         // WMAT_LEFT
    LuaGetParam( L, 3, nSide) ;
    LuaClearStack( L) ;
   // eseguo
@@ -1103,8 +1185,11 @@ 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) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtProjectCurveOnSurfBz", LuaProjectCurveOnSurfBz) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtProjectCurveOnSurfBzExt", LuaProjectCurveOnSurfBzExt) ;
    return bOk ;
 }

LUA_GdbModifySurf.cpp

@@ -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 ;
@@ -141,6 +142,29 @@ LuaSurfFrOffset( lua_State* L)
    return 1 ;
 }
 
+//-------------------------------------------------------------------------------
+static int
+LuaSurfFrOffsetAdv( lua_State* L)
+{
+  // 3 parametri : Id, dDist, nType
+   int nId ;
+   LuaCheckParam( L, 1, nId)
+   double dDist ;
+   LuaCheckParam( L, 2, dDist)
+   int nType = ICurve::OFF_FILLET ;
+   LuaGetParam( L, 3, nType) ;
+   LuaClearStack( L) ;
+  // eseguo l'offset della regione
+   int nNewId = GDB_ID_NULL ;
+   bool bOk = ExeSurfFrOffsetAdv( nId, dDist, nType, nNewId) ;
+   if ( bOk) 
+      LuaSetParam( L, nNewId) ;
+   else
+      LuaSetParam( L) ;
+
+   return 1 ;
+}
+
 //----------------------------------------------------------------------------
 static int
 LuaSurfTmMoveVertex( lua_State* L)
@@ -165,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)
@@ -260,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)
@@ -333,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)
@@ -422,23 +479,125 @@ 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)
+{
+  // 1 parametro : Id
+   int nId ;
+   LuaCheckParam( L, 1, nId)
+   LuaClearStack( L) ;
+  // eseguo reset TFlag per annullare due colori
+   bool bOk = ExeSurfTmResetTwoColors( nId) ;
+   LuaSetParam( L, bOk) ;
+   return 1 ;
+}
+
+//-------------------------------------------------------------------------------
+static int
+LuaSurfTmSetShowEdges( lua_State* L)
+{
+  // 2 parametri : Id, bShow
+   int nId ;
+   LuaCheckParam( L, 1, nId)
+   bool bShow ;
+   LuaCheckParam( L, 2, bShow) ;
+   LuaClearStack( L) ;
+  // imposto flag visualizzazione spigoli vivi
+   bool bOk = ExeSurfTmSetShowEdges( nId, bShow) ;
+  // restituisco il risultato
+   LuaSetParam( L, bOk) ;
+   return 1 ;
+}
+
+//-------------------------------------------------------------------------------
+static int
+LuaSurfTmGetShowEdges( lua_State* L)
+{
+  // 1 parametro : Id
+   int nId ;
+   LuaCheckParam( L, 1, nId)
+   LuaClearStack( L) ;
+  // recupero il flag di visualizzazione degli spigoli vivi della superficie TM
+   bool bShow ;
+   bool bOk = ExeSurfTmGetShowEdges( nId, bShow) ;
+   if ( bOk)
+      LuaSetParam( L, bShow) ;
+   else
+      LuaSetParam( L) ;
+   return 1 ;
+}
+
 //-------------------------------------------------------------------------------
 static int
 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
+  // taglio la prima superficie in base alla seconda
-   //bool bOk = ExeSurfTmCut( nId, nCutterId, bInVsOut, bOn) ;
    bool bOk = ExeSurfBzTrim( nId, nCutterId) ;
    LuaSetParam( L, bOk) ;
    return 1 ;
 }
 
+//-------------------------------------------------------------------------------
+static int
+LuaSurfTmSetSmoothAng( lua_State* L)
+{
+  // 2 parametri : nId, nCutterId
+   int nId ;
+   LuaCheckParam( L, 1, nId)
+   double dAngDeg ;
+   LuaCheckParam( L, 2, dAngDeg)
+   LuaClearStack( L) ;
+  // aggiorno lo smooth angle della superficie
+   bool bOk = ExeSurfTmSetSmoothAng( nId, dAngDeg) ;
+   LuaSetParam( L, bOk) ;
+   return 1 ;
+}
+
 //-------------------------------------------------------------------------------
 bool
 LuaInstallGdbModifySurf( LuaMgr& luaMgr)
@@ -451,20 +610,28 @@ LuaInstallGdbModifySurf( LuaMgr& luaMgr)
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfFrSubtract", LuaSurfFrSubtract) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfFrIntersect", LuaSurfFrIntersect) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfFrOffset", LuaSurfFrOffset) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfFrOffsetAdv", LuaSurfFrOffsetAdv) ;
    bOk = bOk && luaMgr.RegisterFunction( "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( "EgtSurfTmSetFaceColor", LuaSurfTmSetFaceColor) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmGetTriaColor", LuaSurfTmGetTriaColor) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmResetTwoColors", LuaSurfTmResetTwoColors) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmSetShowEdges", LuaSurfTmSetShowEdges) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmGetShowEdges", LuaSurfTmGetShowEdges) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBzTrim", LuaSurfBzTrim) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmSetSmoothAng", LuaSurfTmSetSmoothAng) ;
    return bOk ;
 }

LUA_GdbModifyVol.cpp

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

LUA_General.cpp

@@ -31,6 +31,7 @@
 #include "/EgtDev/Include/EgtNumUtils.h"
 #include "/EgtDev/Include/EgtStringConverter.h"
 #include "Windowsx.h"
+#include "shlobj.h"
 
 using namespace std ;
 
@@ -106,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)
@@ -756,6 +775,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)
@@ -1003,6 +1083,20 @@ LuaGetMsg( lua_State* L)
    return 1 ;
 }
 
+//-------------------------------------------------------------------------------
+static int
+LuaVerifyKeyOption( lua_State* L)
+{
+  // 1 parametro : nOptInd
+   int nOptInd ;
+   LuaCheckParam( L, 1, nOptInd)
+   LuaClearStack( L) ;
+  // verifico l'abilitazione dell'opzione (da chiave + licenza)
+   bool bOk = ExeVerifyKeyOption( nOptInd) ;
+   LuaSetParam( L, bOk) ;
+   return 1 ;
+}
+
 //-------------------------------------------------------------------------------
 static int
 LuaWinExec( lua_State* L)
@@ -1260,6 +1354,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) ;
@@ -1287,6 +1382,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) ;
@@ -1302,6 +1398,7 @@ LuaInstallGeneral( LuaMgr& luaMgr)
    bOk = bOk && luaMgr.RegisterFunction( "EgtIs64bit", LuaIs64bit) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtGetLanguage", LuaGetLanguage) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtMsg", LuaGetMsg) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtVerifyKeyOption", LuaVerifyKeyOption) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtDialogBox", LuaDialogBox) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtWinExec", LuaWinExec) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtCloseExe", LuaCloseExe) ;  

LUA_GeoBase.cpp

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

LUA_GeoInters.cpp

@@ -20,6 +20,41 @@
 
 using namespace std ;
 
+//----------------------------------------------------------------------------
+static int
+LuaLineCurveInters( lua_State* L)
+{
+  // 3 o 4 parametri : ptP, vtDir, Id, [, nRefId]
+   Point3d ptP ;
+   LuaCheckParam( L, 1, ptP)
+   Vector3d vtDir ;
+   LuaCheckParam( L, 2, vtDir)
+   int nId ;
+   LuaCheckParam( L, 3, nId)
+   int nRefType = nId ;
+   LuaGetParam( L, 4, nRefType) ;
+   LuaClearStack( L) ;
+  // recupero i punti di intersezione tra linea e curva
+   INTDBLVECTOR vInters ;
+   if ( ExeLineCurveInters( ptP, vtDir, nId, nRefType, vInters)) {
+      LuaSetParam( L, true) ;
+      INTVECTOR vType( vInters.size()) ;
+      DBLVECTOR vPar( vInters.size()) ;
+      for ( size_t i = 0 ; i < vInters.size() ; ++ i) {
+         vType[i] = vInters[i].first ;
+         vPar[i] = vInters[i].second ;
+      }
+      LuaSetParam( L, vType) ;
+      LuaSetParam( L, vPar) ;
+   }
+   else {
+      LuaSetParam( L) ;
+      LuaSetParam( L) ;
+      LuaSetParam( L) ;
+   }
+   return 3 ;
+}
+
 //----------------------------------------------------------------------------
 static int
 LuaLineBoxInters( lua_State* L)
@@ -53,38 +88,6 @@ LuaLineBoxInters( lua_State* L)
    return 3 ;
 }
 
-//----------------------------------------------------------------------------
-static int
-LuaPlaneBoxInters( lua_State* L)
-{
-  // 4 o 5 parametri : ptOn, vtN, b3Box, nDestGrpId [, nRefType]
-   Point3d ptOn ;
-   LuaCheckParam( L, 1, ptOn)
-   Vector3d vtN ;
-   LuaCheckParam( L, 2, vtN)
-   BBox3d b3Box ;
-   LuaCheckParam( L, 3, b3Box)
-   int nDestGrpId ;
-   LuaCheckParam( L, 4, nDestGrpId) ;
-   int nRefType = RTY_DEFAULT ;
-   LuaGetParam( L, 5, nRefType) ;
-   LuaClearStack( L) ;
-  // eseguo l'intersezione
-   int nPntCount = 0 ;
-   int nCrvCount = 0 ;
-   int nSrfCount = 0 ;
-   int nNewId = ExePlaneBoxInters( ptOn, vtN, b3Box, nDestGrpId, nRefType, &nPntCount, &nCrvCount, &nSrfCount) ;
-  // restituisco il risultato
-   if ( nNewId != GDB_ID_NULL)
-      LuaSetParam( L, nNewId) ;
-   else
-      LuaSetParam( L) ;
-   LuaSetParam( L, nPntCount) ;
-   LuaSetParam( L, nCrvCount) ;
-   LuaSetParam( L, nSrfCount) ;
-   return 4 ;
-}
-
 //----------------------------------------------------------------------------
 static int
 LuaLineSurfTmInters( lua_State* L)
@@ -120,6 +123,136 @@ LuaLineSurfTmInters( lua_State* L)
    return 3 ;
 }
 
+//----------------------------------------------------------------------------
+static int
+LuaLineSurfBzInters( lua_State* L)
+{
+   // 3 o 4 parametri : ptP, vtDir, Id, [, nRefId]
+   Point3d ptP ;
+   LuaCheckParam( L, 1, ptP)
+      Vector3d vtDir ;
+   LuaCheckParam( L, 2, vtDir)
+      int nId ;
+   LuaCheckParam( L, 3, nId)
+      int nRefType = nId ;
+   LuaGetParam( L, 4, nRefType) ;
+   LuaClearStack( L) ;
+   // recupero i punti di intersezione tra linea e superficie trimesh
+   INTDBLVECTOR vInters ;
+   if ( ExeLineSurfBzInters( ptP, vtDir, nId, nRefType, vInters)) {
+      LuaSetParam( L, true) ;
+      INTVECTOR vType( vInters.size()) ;
+      DBLVECTOR vPar( vInters.size()) ;
+      for ( size_t i = 0 ; i < vInters.size() ; ++ i) {
+         vType[i] = vInters[i].first ;
+         vPar[i] = vInters[i].second ;
+      }
+      LuaSetParam( L, vType) ;
+      LuaSetParam( L, vPar) ;
+   }
+   else {
+      LuaSetParam( L) ;
+      LuaSetParam( L) ;
+      LuaSetParam( L) ;
+   }
+   return 3 ;
+}
+
+//----------------------------------------------------------------------------
+static int
+LuaLineVolZmapInters( lua_State* L)
+{
+  // 3 o 4 parametri : ptP, vtDir, Id, [, nRefId]
+   Point3d ptP ;
+   LuaCheckParam( L, 1, ptP)
+   Vector3d vtDir ;
+   LuaCheckParam( L, 2, vtDir)
+   int nId ;
+   LuaCheckParam( L, 3, nId)
+   int nRefType = nId ;
+   LuaGetParam( L, 4, nRefType) ;
+   LuaClearStack( L) ;
+  // eseguo calcolo intersezione
+   INTDBLVECTOR vInters ;
+   if ( ExeLineVolZmapInters( ptP, vtDir, nId, nRefType, vInters)) {
+      LuaSetParam( L, true) ;
+      INTVECTOR vType( vInters.size()) ;
+      DBLVECTOR vPar( vInters.size()) ;
+      for ( size_t i = 0 ; i < vInters.size() ; ++ i) {
+         vType[i] = vInters[i].first ;
+         vPar[i] = vInters[i].second ;
+      }
+      LuaSetParam( L, vType) ;
+      LuaSetParam( L, vPar) ;
+   }
+   else {
+      LuaSetParam( L) ;
+      LuaSetParam( L) ;
+      LuaSetParam( L) ;
+   }
+   return 3 ;
+}
+
+//----------------------------------------------------------------------------
+static int
+LuaPlaneCurveInters( lua_State* L)
+{
+  // 4 o 5 parametri : ptOn, vtN, nId, nDestGrpId [, nRefType] 
+   Point3d ptOn ;
+   LuaCheckParam( L, 1, ptOn)
+   Vector3d vtN ;
+   LuaCheckParam( L, 2, vtN)
+   int nId ;
+   LuaCheckParam( L, 3, nId)
+   int nDestGrpId ;
+   LuaCheckParam( L, 4, nDestGrpId) ;
+   int nRefType = RTY_DEFAULT ;
+   LuaGetParam( L, 5, nRefType) ;
+   LuaClearStack( L) ;
+  // eseguo l'intersezione
+   int nCount = 0 ;
+   int nNewId = ExePlaneCurveInters( ptOn, vtN, nId, nDestGrpId, nRefType, &nCount) ;
+  // restituisco il risultato
+   if ( nNewId != GDB_ID_NULL)
+      LuaSetParam( L, nNewId) ;
+   else
+      LuaSetParam( L) ;
+   LuaSetParam( L, nCount) ;
+   return 2 ;
+}
+
+//----------------------------------------------------------------------------
+static int
+LuaPlaneBoxInters( lua_State* L)
+{
+  // 4 o 5 parametri : ptOn, vtN, b3Box, nDestGrpId [, nRefType]
+   Point3d ptOn ;
+   LuaCheckParam( L, 1, ptOn)
+   Vector3d vtN ;
+   LuaCheckParam( L, 2, vtN)
+   BBox3d b3Box ;
+   LuaCheckParam( L, 3, b3Box)
+   int nDestGrpId ;
+   LuaCheckParam( L, 4, nDestGrpId) ;
+   int nRefType = RTY_DEFAULT ;
+   LuaGetParam( L, 5, nRefType) ;
+   LuaClearStack( L) ;
+  // eseguo l'intersezione
+   int nPntCount = 0 ;
+   int nCrvCount = 0 ;
+   int nSrfCount = 0 ;
+   int nNewId = ExePlaneBoxInters( ptOn, vtN, b3Box, nDestGrpId, nRefType, &nPntCount, &nCrvCount, &nSrfCount) ;
+  // restituisco il risultato
+   if ( nNewId != GDB_ID_NULL)
+      LuaSetParam( L, nNewId) ;
+   else
+      LuaSetParam( L) ;
+   LuaSetParam( L, nPntCount) ;
+   LuaSetParam( L, nCrvCount) ;
+   LuaSetParam( L, nSrfCount) ;
+   return 4 ;
+}
+
 //----------------------------------------------------------------------------
 static int
 LuaPlaneSurfTmInters( lua_State* L)
@@ -188,59 +321,32 @@ LuaParPlanesSurfTmInters( lua_State* L)
 
 //----------------------------------------------------------------------------
 static int
-LuaSurfTmSurfTmInters( lua_State* L)
+LuaPlaneVolZmapInters( lua_State* L)
 {
-  // 3 o 4 parametri : Id1, nId2, nDestGrpId [, dToler]
+  // 4 o 5 parametri : ptP, vtN, nId, nDestGrpId [, nRefType]
-   int nId1 ;
+   Point3d ptP ;
-   LuaCheckParam( L, 1, nId1)
+   LuaCheckParam( L, 1, ptP)
-   int nId2 ;
-   LuaCheckParam( L, 2, nId2)
-   int nDestGrpId ;
-   LuaCheckParam( L, 3, nDestGrpId) ;
-   double dToler = 20 * EPS_SMALL ;
-   LuaGetParam( L, 4, dToler) ;
-   LuaClearStack( L) ;
-  // eseguo l'intersezione
-   int nPntCount = 0 ;
-   int nCrvCount = 0 ;
-   int nSrfCount = 0 ;
-   int nNewId = ExeSurfTmSurfTmInters( nId1, nId2, nDestGrpId, dToler, &nPntCount, &nCrvCount, &nSrfCount) ;
-  // restituisco il risultato
-   if ( nNewId != GDB_ID_NULL)
-      LuaSetParam( L, nNewId) ;
-   else
-      LuaSetParam( L) ;
-   LuaSetParam( L, nPntCount) ;
-   LuaSetParam( L, nCrvCount) ;
-   LuaSetParam( L, nSrfCount) ;
-   return 4 ;
-}
-
-//----------------------------------------------------------------------------
-static int
-LuaPlaneCurveInters( lua_State* L)
-{
-  // 4 o 5 parametri : ptOn, vtN, nId, nDestGrpId [, nRefType] 
-   Point3d ptOn ;
-   LuaCheckParam( L, 1, ptOn)
    Vector3d vtN ;
    LuaCheckParam( L, 2, vtN)
    int nId ;
    LuaCheckParam( L, 3, nId)
    int nDestGrpId ;
-   LuaCheckParam( L, 4, nDestGrpId) ;
+   LuaCheckParam( L, 4, nDestGrpId)
    int nRefType = RTY_DEFAULT ;
    LuaGetParam( L, 5, nRefType) ;
    LuaClearStack( L) ;
-  // eseguo l'intersezione
+  // eseguo calcolo intersezione
-   int nCount = 0 ;
+   int nCount ;
-   int nNewId = ExePlaneCurveInters( ptOn, vtN, nId, nDestGrpId, nRefType, &nCount) ;
+   int nFirstId = ExePlaneVolZmapInters( ptP, vtN, nId, nDestGrpId, nRefType, &nCount) ;
   // restituisco il risultato
-   if ( nNewId != GDB_ID_NULL)
+   if ( nFirstId != GDB_ID_NULL) {
-      LuaSetParam( L, nNewId) ;
+      LuaSetParam( L, nFirstId) ;
-   else
+      LuaSetParam( L, nCount) ;
+   }
+   else {
       LuaSetParam( L) ;
-   LuaSetParam( L, nCount) ;
+      LuaSetParam( L) ;
+   }
    return 2 ;
 }
 
@@ -272,68 +378,58 @@ LuaCurveCurveInters( lua_State* L)
 
 //----------------------------------------------------------------------------
 static int
-LuaLineVolZmapInters( lua_State* L)
+LuaCurveSurfTmInters( lua_State* L)
 {
-  // 3 o 4 parametri : ptP, vtDir, Id, [, nRefId]
+  // 3 parametri : nCrvId, nStmId, nDestGrpId
-   Point3d ptP ;
+   int nCrvId ;
-   LuaCheckParam( L, 1, ptP)
+   LuaCheckParam( L, 1, nCrvId)
-   Vector3d vtDir ;
+   int nStmId ;
-   LuaCheckParam( L, 2, vtDir)
+   LuaCheckParam( L, 2, nStmId)
-   int nId ;
+   int nDestGrpId ;
-   LuaCheckParam( L, 3, nId)
+   LuaCheckParam( L, 3, nDestGrpId) ;   
-   int nRefType = nId ;
-   LuaGetParam( L, 4, nRefType) ;
    LuaClearStack( L) ;
-  // eseguo calcolo intersezione
+  // eseguo l'intersezione
-   INTDBLVECTOR vInters ;
+   int nPntCount = 0 ;
-   if ( ExeLineVolZmapInters( ptP, vtDir, nId, nRefType, vInters)) {
+   int nCrvCount = 0 ;
-      LuaSetParam( L, true) ;
+   int nNewId = ExeCurveSurfTmInters( nCrvId, nStmId, nDestGrpId, &nPntCount, &nCrvCount) ;
-      INTVECTOR vType( vInters.size()) ;
+   // restituisco il risultato
-      DBLVECTOR vPar( vInters.size()) ;
+   if ( nNewId != GDB_ID_NULL)
-      for ( size_t i = 0 ; i < vInters.size() ; ++ i) {
+      LuaSetParam( L, nNewId) ;
-         vType[i] = vInters[i].first ;
+   else
-         vPar[i] = vInters[i].second ;
-      }
-      LuaSetParam( L, vType) ;
-      LuaSetParam( L, vPar) ;
-   }
-   else {
       LuaSetParam( L) ;
-      LuaSetParam( L) ;
+   LuaSetParam( L, nPntCount) ;
-      LuaSetParam( L) ;
+   LuaSetParam( L, nCrvCount) ;
-   }
    return 3 ;
 }
 
 //----------------------------------------------------------------------------
 static int
-LuaPlaneVolZmapInters( lua_State* L)
+LuaSurfTmSurfTmInters( lua_State* L)
 {
-  // 4 o 5 parametri : ptP, vtN, nId, nDestGrpId [, nRefType]
+  // 3 o 4 parametri : Id1, nId2, nDestGrpId [, dToler]
-   Point3d ptP ;
+   int nId1 ;
-   LuaCheckParam( L, 1, ptP)
+   LuaCheckParam( L, 1, nId1)
-   Vector3d vtN ;
+   int nId2 ;
-   LuaCheckParam( L, 2, vtN)
+   LuaCheckParam( L, 2, nId2)
-   int nId ;
-   LuaCheckParam( L, 3, nId)
    int nDestGrpId ;
-   LuaCheckParam( L, 4, nDestGrpId)
+   LuaCheckParam( L, 3, nDestGrpId) ;
-   int nRefType = RTY_DEFAULT ;
+   double dToler = 20 * EPS_SMALL ;
-   LuaGetParam( L, 5, nRefType) ;
+   LuaGetParam( L, 4, dToler) ;
    LuaClearStack( L) ;
-  // eseguo calcolo intersezione
+  // eseguo l'intersezione
-   int nCount ;
+   int nPntCount = 0 ;
-   int nFirstId = ExePlaneVolZmapInters( ptP, vtN, nId, nDestGrpId, nRefType, &nCount) ;
+   int nCrvCount = 0 ;
+   int nSrfCount = 0 ;
+   int nNewId = ExeSurfTmSurfTmInters( nId1, nId2, nDestGrpId, dToler, &nPntCount, &nCrvCount, &nSrfCount) ;
   // restituisco il risultato
-   if ( nFirstId != GDB_ID_NULL) {
+   if ( nNewId != GDB_ID_NULL)
-      LuaSetParam( L, nFirstId) ;
+      LuaSetParam( L, nNewId) ;
-      LuaSetParam( L, nCount) ;
+   else
-   }
-   else {
       LuaSetParam( L) ;
-      LuaSetParam( L) ;
+   LuaSetParam( L, nPntCount) ;
-   }
+   LuaSetParam( L, nCrvCount) ;
-   return 2 ;
+   LuaSetParam( L, nSrfCount) ;
+   return 4 ;
 }
 
 //-------------------------------------------------------------------------------
@@ -341,15 +437,18 @@ bool
 LuaInstallGeoInters( LuaMgr& luaMgr)
 {
    bool bOk = ( &luaMgr != nullptr) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtLineCurveInters", LuaLineCurveInters) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtLineBoxInters", LuaLineBoxInters) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtPlaneBoxInters", LuaPlaneBoxInters) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtLineSurfTmInters", LuaLineSurfTmInters) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtLineSurfBzInters", LuaLineSurfBzInters) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtLineVolZmapInters", LuaLineVolZmapInters) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtPlaneCurveInters", LuaPlaneCurveInters) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtPlaneBoxInters", LuaPlaneBoxInters) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtPlaneSurfTmInters", LuaPlaneSurfTmInters) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtParPlanesSurfTmInters", LuaParPlanesSurfTmInters) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmSurfTmInters", LuaSurfTmSurfTmInters) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtPlaneCurveInters", LuaPlaneCurveInters) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtCurveCurveInters", LuaCurveCurveInters) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtLineVolZmapInters", LuaLineVolZmapInters) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtPlaneVolZmapInters", LuaPlaneVolZmapInters) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtCurveCurveInters", LuaCurveCurveInters) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtCurveSurfTmInters", LuaCurveSurfTmInters) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmSurfTmInters", LuaSurfTmSurfTmInters) ;
    return bOk ;
 }

LUA_MachMgr.cpp

@@ -262,6 +262,24 @@ LuaRemoveMachGroup( lua_State* L)
    return 1 ;
 }
 
+//-------------------------------------------------------------------------------
+static int
+LuaChangeMachGroupName( lua_State* L)
+{
+  // 2 parametri : identificativo del gruppo, nuovo nome
+   int nMGroupInd ;
+   LuaCheckParam( L, 1, nMGroupInd)
+   string sNewName ;
+   LuaCheckParam( L, 2, sNewName)
+   LuaClearStack( L) ;
+  // cambio il nome della macchinata
+   string sName ;
+   bool bOk = ExeChangeMachGroupName( nMGroupInd, sNewName) ; 
+  // restituisco il risultato
+   LuaSetParam( L, bOk) ;
+   return 1 ;
+}
+
 //-------------------------------------------------------------------------------
 static int
 LuaGetMachGroupName( lua_State* L)
@@ -3012,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)
@@ -3317,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)
@@ -3353,26 +3373,19 @@ LuaSetRotAxisBlock( lua_State* L)
 
 //-------------------------------------------------------------------------------
 static int
-LuaGetRotAxisBlocked( lua_State* L)
+LuaGetCalcTable( lua_State* L)
 {
-  // 1 parametro : nInd ( 0-based)
+  // nessun parametro
-   int nInd ;
-   LuaCheckParam( L, 1, nInd)
    LuaClearStack( L) ;
-  // recupero dati bloccaggio asse in posizione nInd
+  // recupero la tavola correnti
-   string sAxis ;
+   string sTable ;
-   double dVal ;
+   bool bOk = ExeGetCalcTable( sTable) ;
-   bool bOk = ExeGetRotAxisBlocked( nInd, sAxis, dVal) ;
   // restituisco il risultato
-   if ( bOk) {
+   if ( bOk)
-      LuaSetParam( L, sAxis) ;
+      LuaSetParam( L, sTable) ;
-      LuaSetParam( L, dVal) ;
+   else
-   }
-   else {
       LuaSetParam( L) ;
-      LuaSetParam( L) ;
+   return 1 ;
-   }
-   return 2 ;
 }
 
 //-------------------------------------------------------------------------------
@@ -3400,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)
@@ -3467,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 ;
@@ -3476,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) ;
@@ -3501,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) ;
@@ -3526,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) ;
@@ -3683,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)
@@ -3794,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)
@@ -4047,6 +4138,7 @@ LuaInstallMachMgr( LuaMgr& luaMgr)
    bOk = bOk && luaMgr.RegisterFunction( "EgtAddMachGroup", LuaAddMachGroup) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtCopyMachGroup", LuaCopyMachGroup) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtRemoveMachGroup", LuaRemoveMachGroup) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtChangeMachGroupName", LuaChangeMachGroupName) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtGetMachGroupName", LuaGetMachGroupName) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtGetMachGroupMachineName", LuaGetMachGroupMachineName) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtGetMachGroupId", LuaGetMachGroupId) ;
@@ -4203,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) ;
@@ -4226,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) ;

LUA_Scene.cpp

@@ -175,6 +175,21 @@ LuaZoomObject( lua_State* L)
    return 1 ;
 }
 
+//-------------------------------------------------------------------------------
+static int
+LuaSetViewOrizzOffsStep( lua_State* L)
+{
+  // 1 parametro : nDirOffsStep
+   int nDirOffsStep ;
+   LuaCheckParam( L, 1, nDirOffsStep)
+   LuaClearStack( L) ;
+  // imposto offset angolare orizzontale a step di 90° per direzione di vista
+   bool bOk = ExeSetViewOrizzOffsStep( nDirOffsStep) ;
+  // restituisco il risultato
+   LuaSetParam( L, bOk) ;
+   return 1 ;
+}
+
 //-------------------------------------------------------------------------------
 static int
 LuaSetView( lua_State* L)
@@ -228,6 +243,60 @@ LuaSetViewCenter( lua_State* L)
    return 1 ;
 }
 
+//-------------------------------------------------------------------------------
+static int
+LuaGetViewOrizzOffsStep( lua_State* L)
+{
+  // nessun parametro
+   LuaClearStack( L) ;
+  // recupero offset angolare orizzontale a step di 90° per direzione di vista
+   int nDirOffsStep ;
+   bool bOk = ExeGetViewOrizzOffsStep( &nDirOffsStep) ;
+  // restituisco il risultato
+   if ( bOk)
+      LuaSetParam( L, nDirOffsStep) ;
+   else
+      LuaSetParam( L) ;
+   return 1 ;
+}
+
+//-------------------------------------------------------------------------------
+static int
+LuaGetView( lua_State* L)
+{
+  // nessun parametro
+   LuaClearStack( L) ;
+  // recupero direzione di vista
+   int nViewDir ;
+   bool bOk = ExeGetView( &nViewDir) ;
+  // restituisco il risultato
+   if ( bOk)
+      LuaSetParam( L, nViewDir) ;
+   else
+      LuaSetParam( L) ;
+   return 1 ;
+}
+
+//-------------------------------------------------------------------------------
+static int
+LuaGetGenericView( lua_State* L)
+{
+  // nessun parametro
+   LuaClearStack( L) ;
+  // recupero angoli della direzione di vista
+   double dAngVertDeg ;
+   double dAngHorizDeg ;
+   bool bOk = ExeGetGenericView( &dAngVertDeg, &dAngHorizDeg) ;
+  // restituisco il risultato
+   if ( bOk) {
+      LuaSetParam( L, dAngVertDeg) ;
+      LuaSetParam( L, dAngHorizDeg) ;  
+   }
+   else
+      LuaSetParam( L) ;
+   return 2 ;
+}
+
 //-------------------------------------------------------------------------------
 static int
 LuaGetImage( lua_State* L)
@@ -267,9 +336,13 @@ LuaInstallScene( LuaMgr& luaMgr)
    bOk = bOk && luaMgr.RegisterFunction( "EgtZoomRadius", LuaZoomRadius) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtZoom", LuaZoom) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtZoomObject", LuaZoomObject) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtSetViewOrizzOffsStep", LuaSetViewOrizzOffsStep) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSetView", LuaSetView) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSetGenericView", LuaSetGenericView) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSetViewCenter", LuaSetViewCenter) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtGetViewOrizzOffsStep", LuaGetViewOrizzOffsStep) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtGetView", LuaGetView) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtGetGenericView", LuaGetGenericView) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtGetImage", LuaGetImage) ;
    return bOk ;
 }

LUA_TestObjSurface.cpp

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