EgtExecutor :

- spostate le funzioni EgtPocketing e EgtGetSurfFrZigZagInfill in un documento a parte (EXE_GdbGetPocketing.cpp)
- aggiornati i parametri della funzione GetSurfFrZigZagInfill.

EXE_GdbGetPocketing.cpp

@@ -0,0 +1,150 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2023-2023
+//----------------------------------------------------------------------------
+// File : Exe_GdbGetPocketing.cpp       Data : 28.11.23        Versione : 2.5k6
+// Contenuto : Funzioni di interrogazione di regioni piane del DBG per EXE.
+//
+//
+//
+// Modifiche : 29.11.23 RE Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+//--------------------------- Include ----------------------------------------
+#include "stdafx.h"
+#include "EXE.h"
+#include "EXE_Macro.h"
+#include "/EgtDev/Include/EXeExecutor.h"
+#include "/EgtDev/Include/EGkCalcPocketing.h"
+
+using namespace std ;
+
+//----------------------------------------------------------------------------
+bool
+ExePocketing( const int nId, double dRad, double dStep, double dAngle, int nType, bool bSmooth, int nDestGrpId,
+              int& nFirstId, int& nCrvCount)
+{
+  // databse geometrico
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, false) ;
+
+  // recupero la FlatRegion per i percorsi
+   const ISurfFlatRegion* pSfr = GetSurfFlatRegion( pGeomDB->GetGeoObj( nId)) ;
+   if ( pSfr == nullptr)
+      return false ;
+
+  // recupero il suo frame
+   Frame3d frSfr ;
+   if ( ! pGeomDB->GetGlobFrame( nId, frSfr))
+      return false ;
+
+  // recupero il riferimento del gruppo di destinazione
+   Frame3d frDest ;
+   if ( ! pGeomDB->GetGroupGlobFrame( nDestGrpId, frDest))
+      return false ;
+
+  // costruzione vettori di curve per Pocketing
+   ICRVCOMPOPOVECTOR vCrvCompoRes ;
+
+  // eseguo Pocketing
+   bool bOk = CalcPocketing( pSfr, dRad, dStep, dAngle, nType, bSmooth, vCrvCompoRes) ;
+   nFirstId = GDB_ID_NULL ; // primo Id da restituire
+   nCrvCount = int( vCrvCompoRes.size()) ;
+   if ( bOk  &&  int( vCrvCompoRes.size()) > 0) {
+     // scorro le curve di Pocketing ottenute
+      for ( int u = 0 ; u < int( vCrvCompoRes.size()) ; ++ u) {
+         vCrvCompoRes[u]->LocToLoc( frSfr, frDest) ;
+        // inserisco la curva nel DB Geometrico
+         int nCurrId = pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, Release( vCrvCompoRes[u])) ;
+         if ( nCurrId == GDB_ID_NULL)
+            return false ;
+         if ( u == 0)
+            nFirstId = nCurrId ; // memorizzo il primo Id da restituire
+      }
+      ExeSetModified() ;
+   }
+
+   if ( IsCmdLog()) {
+      string sLua = "EgtPocketing(" + ToString( nId) + "," +
+                                      ToString( dRad) + "," +
+                                      ToString( dStep) + "," +
+                                      ToString( dAngle) + "," +
+                                      ToString( nType) + "," +
+                                      ToString( bSmooth) + "," +
+                                      ToString( nDestGrpId) + ")" +
+                    " -- Ok=" + ToString( bOk) + " FirstId=" + ToString( nFirstId) + " CurveCount=" + ToString( nCrvCount) ;
+      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
+   }
+   return bOk ;
+}
+
+//----------------------------------------------------------------------------
+int
+ExeSurfFrGetZigZagInfill( int nId, int nDestGrpId, double dStep, double dAng, bool bSmooth, bool bRemoveOverlapLink,
+                          int* pnCount)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
+
+  // recupero la superficie FlatRegion
+   ISurfFlatRegion* pOrigSrf = GetSurfFlatRegion( pGeomDB->GetGeoObj( nId)) ;
+   if ( pOrigSrf == nullptr)
+      return GDB_ID_NULL ;
+   PtrOwner<ISurfFlatRegion> pSfr( pOrigSrf->Clone()) ;
+   bool bOk = ( ! IsNull( pSfr)) ;
+
+  // recupero il riferimento della superficie
+   Frame3d frSurf ;
+   bOk = bOk && pGeomDB->GetGlobFrame( nId, frSurf) ;
+  // recupero il riferimento di destinazione
+   Frame3d frDest ;
+   bOk = bOk && pGeomDB->GetGroupGlobFrame( nDestGrpId, frDest) ;
+
+  // creo il riferimento per il calcolo del percorso a zigzag
+   Vector3d vtN ;
+   if ( bOk) 
+      vtN = pSfr->GetNormVersor() ;
+   bOk = bOk && vtN.ToGlob( frSurf) ;
+   Frame3d frRef ; 
+   bOk = bOk && frRef.Set( ORIG, vtN) ;
+   bOk = bOk && frRef.Rotate( ORIG, vtN, dAng) ;
+
+  // calcolo il percorso a zigzag
+   bOk = bOk && pSfr->LocToLoc( frSurf, frRef) ;
+   ICRVCOMPOPOVECTOR vpCrvs ;
+   bOk = bOk  &&  CalcZigZagInfill( pSfr, dStep, bSmooth, bRemoveOverlapLink, vpCrvs) ;
+
+  // inserisco le curve risultanti nel DB
+   int nFirstId = GDB_ID_NULL ;
+   int nCount = 0 ;
+   for ( int i = 0 ; bOk  &&  i < ( int) vpCrvs.size() ; i ++) {
+     // porto la curva nel riferimento di destinazione
+      bOk = bOk  &&  vpCrvs[i]->LocToLoc( frRef, frDest) ;
+     // la inserisco nel DB geometrico
+      int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, Release( vpCrvs[i])) : GDB_ID_NULL) ;
+      bOk = bOk && ( nNewId != GDB_ID_NULL) ;
+     // aggiorno contatori
+      if ( bOk  &&  nFirstId == GDB_ID_NULL)
+         nFirstId = nNewId ;
+      if ( bOk)
+         ++ nCount ;
+   } 
+   ExeSetModified() ;
+
+  // restituisco risultati
+   if ( pnCount != nullptr)
+      *pnCount = nCount ;
+
+   if ( IsCmdLog()) {
+      string sLua = "EgtGetSurfFrZigZagInfill(" + ToString( nId) + "," +
+                                                  ToString( dStep) + "," +
+                                                  ToString( dAng) + "," +
+                                                  ToString( bSmooth) + "," +
+                                                  ToString( bRemoveOverlapLink) + "," +
+                    " -- Ok=" + ToString( bOk) + " FirstId=" + ToString( nFirstId) + " CurveCount=" + ToString( nCount) ;
+      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
+   }
+
+   return nFirstId ;
+}

EXE_GdbGetSurf.cpp

@@ -309,67 +309,6 @@ ExeExtractSurfFrChunkLoops( int nId, int nChunk, int nDestGrpId, int* pnCount)
    return nFirstId ;
 }
 
-//----------------------------------------------------------------------------
-int
-ExeSurfFrGetZigZagInfill( int nId, int nDestGrpId, double dStep, double dAng, bool bSmooth, int* pnCount)
-{
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
-
-  // recupero la superficie FlatRegion
-   ISurfFlatRegion * pOrigSrf = GetSurfFlatRegion( pGeomDB->GetGeoObj( nId)) ;
-   if ( pOrigSrf == nullptr)
-      return GDB_ID_NULL ;
-   PtrOwner<ISurfFlatRegion> pSfr( pOrigSrf->Clone()) ;
-   bool bOk = ( ! IsNull( pSfr)) ;
-
-  // recupero il riferimento della superficie
-   Frame3d frSurf ;
-   bOk = bOk && pGeomDB->GetGlobFrame( nId, frSurf) ;
-  // recupero il riferimento di destinazione
-   Frame3d frDest ;
-   bOk = bOk && pGeomDB->GetGroupGlobFrame( nDestGrpId, frDest) ;
-
-  // creo il riferimento per il calcolo del percorso a zigzag
-   Vector3d vtN ;
-   if ( bOk) 
-      vtN = pSfr->GetNormVersor() ;
-   bOk = bOk && vtN.ToGlob( frSurf) ;
-   Frame3d frRef ; 
-   bOk = bOk && frRef.Set( ORIG, vtN) ;
-   bOk = bOk && frRef.Rotate( ORIG, vtN, dAng) ;
-
-  // calcolo il percorso a zigzag
-   bOk = bOk && pSfr->LocToLoc( frSurf, frRef) ;
-   ICRVCOMPOPOVECTOR vpCrvs ;
-   bOk = bOk  &&  CalcZigZagInfill( pSfr, dStep, bSmooth, vpCrvs) ;
-
-  // inserisco le curve risultanti nel DB
-   int nFirstId = GDB_ID_NULL ;
-   int nCount = 0 ;
-   for ( int i = 0 ; bOk && i < ( int) vpCrvs.size() ; i ++) {
-     // porto la curva nel riferimento di destinazione
-      bOk = bOk && vpCrvs[i]->LocToLoc( frRef, frDest) ;
-     // la inserisco nel DB geometrico
-      int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, Release( vpCrvs[i])) : GDB_ID_NULL) ;
-      bOk = bOk && ( nNewId != GDB_ID_NULL) ;
-     // copio il materiale
-      //if ( ! pGeomDB->CopyMaterial( nId, nNewId))
-      //   return GDB_ID_NULL ;
-     // aggiorno contatori
-      if ( bOk  &&  nFirstId == GDB_ID_NULL)
-         nFirstId = nNewId ;
-      if ( bOk)
-         ++ nCount ;
-   } 
-   ExeSetModified() ;
-
-  // restituisco risultati
-   if ( pnCount != nullptr)
-      *pnCount = nCount ;
-   return nFirstId ;
-}
-
 //----------------------------------------------------------------------------
 int
 ExeSurfTmVertexCount( int nId)

EXE_GdbModifyCurve.cpp

@@ -2357,280 +2357,6 @@ ExeProjectCurveOnSurfTm( int nCurveId, int nSurfTmId, const Vector3d& vtDir, int
 
 }
 
-//----------------------------------------------------------------------------
-static bool
-MyChainCurves( const SELVECTOR vInds, ICURVEPOVECTOR& vpCrvs, ICRVCOMPOPOVECTOR& vCrvCompo)
-{
-  // preparo i dati per il concatenamento
-   bool bFirst = true ;
-   Point3d ptNear = ORIG ;
-   double dToler = 10 * EPS_SMALL ;
-   ChainCurves chainC ;
-   chainC.Init( true, dToler, int( vpCrvs.size())) ;
-   for ( size_t i = 0 ; i < vpCrvs.size() ; ++ i) {
-     // recupero la curva e il suo riferimento
-      ICurve* pCrv = vpCrvs[i] ;
-      if ( pCrv == nullptr)
-         continue ;
-     // recupero i dati della curva necessari al concatenamento e li assegno
-      Point3d ptStart, ptEnd ;
-      Vector3d vtStart, vtEnd ;
-      if ( ! pCrv->GetStartPoint( ptStart)  ||  ! pCrv->GetStartDir( vtStart)  ||
-           ! pCrv->GetEndPoint( ptEnd)  ||  ! pCrv->GetEndDir( vtEnd))
-         return false ;
-      if ( ! chainC.AddCurve( int( i + 1), ptStart, vtStart, ptEnd, vtEnd))
-         return false ;
-     // se prima curva, assegno inizio della ricerca
-      if ( bFirst) {
-         ptNear = ptStart + 10 * EPS_SMALL * vtStart ;
-         bFirst = false ;
-      }
-   }
-  // recupero i percorsi concatenati
-   INTVECTOR vnId2 ;
-   while ( chainC.GetChainFromNear( ptNear, false, vnId2)) {
-     // creo una curva composita
-      PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
-      if ( IsNull( pCrvCompo))
-         return false ;
-     // estrusione e spessore
-      Vector3d vtExtr = Z_AX ;
-      double dThick = 0 ;
-     // vettore Id originali
-      SELVECTOR vId2 ;
-      vId2.reserve( vnId2.size()) ;
-     // recupero le curve semplici e le inserisco nella curva composita
-      for ( size_t i = 0 ; i < vnId2.size() ; ++ i) {
-         int nId = abs( vnId2[i]) - 1 ;
-         bool bInvert = ( vnId2[i] < 0) ;
-         vId2.emplace_back( vInds[nId]) ;
-        // recupero la curva
-         ICurve* pCrv = vpCrvs[nId] ;
-        // se necessario, la inverto
-         if ( bInvert)
-            pCrv->Invert() ;
-        // recupero eventuali estrusione e spessore
-         Vector3d vtTemp ;
-         if ( pCrv->GetExtrusion( vtTemp)) {
-            vtExtr = vtTemp ;
-            double dTemp ;
-            if ( pCrv->GetThickness( dTemp)  &&  abs( dTemp) > abs( dThick))
-               dThick = dTemp ;
-         }
-        // la aggiungo alla curva composta
-         if ( ! pCrvCompo->AddCurve( ::Release( vpCrvs[nId]), true, dToler))
-            return false ;
-      }
-     // se non sono state inserite curve, vado oltre
-      if ( pCrvCompo->GetCurveCount() == 0)
-         continue ;
-     // imposto estrusione e spessore
-      pCrvCompo->SetExtrusion( vtExtr) ;
-      pCrvCompo->SetThickness( dThick) ;
-     // aggiorno il nuovo punto vicino
-      pCrvCompo->GetEndPoint( ptNear) ;
-     // aggiungo la curva al vettore di curve composite concatenate
-      vCrvCompo.emplace_back( Release( pCrvCompo)) ;
-   }
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-static bool
-MyGetCurves( SelData Id, ICURVEPLIST& lstPC, Vector3d& vtN)
-{
-  // database geometrico
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false) ;
-  // ammessi : curve, testi, facce di trimesh o regioni
-   const IGeoObj* pGObj = pGeomDB->GetGeoObj( Id.nId) ;
-   if ( pGObj == nullptr)
-      return false ;
-  // ne recupero il riferimento globale
-   Frame3d frGlob ;
-   if ( ! pGeomDB->GetGlobFrame( Id.nId, frGlob))
-      return false ;
-  // se curva
-   if (( pGObj->GetType() & GEO_CURVE) != 0) {
-      PtrOwner<ICurve> pCurve ;
-     // se direttamente curva
-      if ( Id.nSub == SEL_SUB_ALL) {
-        // recupero la curva
-         const ICurve* pOriCurve = ::GetCurve( pGObj) ;
-         if ( pOriCurve == nullptr)
-            return false ;
-         pCurve.Set( pOriCurve->Clone()) ;
-      }
-      // altrimenti sottocurva di composita
-      else {
-        // recupero la composita
-         const ICurveComposite* pCompo = GetCurveComposite( pGObj) ;
-         if ( pCompo == nullptr)
-            return false ;
-        // recupero la curva semplice
-         const ICurve* pOriCurve = ::GetCurve( pCompo->GetCurve( Id.nSub)) ;
-         if ( pOriCurve == nullptr)
-            return false ;
-        // la duplico
-         pCurve.Set( pOriCurve->Clone()) ;
-      }
-      if ( IsNull( pCurve))
-         return false ;
-     // porto in globale
-      pCurve->ToGlob( frGlob) ;
-     // recupero estrusione
-       Vector3d vtExtr ;
-     // se estrusione mancante, imposto default
-      if ( ! pCurve->GetExtrusion( vtExtr)  ||  vtExtr.IsSmall())
-         pCurve->SetExtrusion( Z_AX) ;
-     // corenza con vtTool
-      if ( ! vtN.IsValid())
-         vtN = vtExtr ;
-      else if ( ! AreSameVectorApprox( vtExtr, vtN))
-         return false ;
-     // verifico sia piana e se necessario la appiattisco
-      PtrOwner<ICurve> pFlatCrv( FlattenCurve( *pCurve, 50 * EPS_SMALL, 50 * EPS_ANG_SMALL, FLTCRV_USE_EXTR)) ;
-      if ( IsNull( pFlatCrv)) {
-         Plane3d plPlane ;
-         if ( ! pCurve->IsFlat( plPlane, true, 50 * EPS_SMALL))
-            ;
-         else
-            ;
-         return false ;
-      }
-     // aggiungo alla lista
-      lstPC.emplace_back( Release( pCurve)) ;
-      return true ;
-   }
-  // se altrimenti testo
-   else if ( pGObj->GetType() == EXT_TEXT)
-      return false ;
-  // se altrimenti superficie
-   else if ( pGObj->GetType() == SRF_TRIMESH)
-      return false ;
-  // se altrimenti regione
-   else if ( pGObj->GetType() == SRF_FLATRGN) {
-     // recupero la regione
-      const ISurfFlatRegion* pReg = ::GetSurfFlatRegion( pGObj) ;
-      if ( pReg == nullptr)
-         return false ;
-      PtrOwner<ISurfFlatRegion> pSfr( CloneSurfFlatRegion( pReg)) ;
-      if ( IsNull( pSfr))
-         return false ;
-     // porto in globale
-      pSfr->ToGlob( frGlob) ;
-     // recupero la normale della regione
-      Vector3d vtN_sfr = pSfr->GetNormVersor() ;
-      if ( vtN.IsSmall())
-         return false ;
-      if ( ! vtN.IsValid())
-         vtN_sfr = vtN ;
-      else if ( ! AreSameVectorApprox( vtN, vtN_sfr))
-         return false ;
-     // determino intervallo di chunk
-      int nCstart = 0 ;
-      int nCend = pSfr->GetChunkCount() ;
-      if ( Id.nSub != SEL_SUB_ALL) {
-         nCstart = Id.nSub ;
-         nCend = nCstart + 1 ;
-      }
-     // ciclo sui chunk
-      for ( int nC = nCstart ; nC < nCend ; ++ nC) {
-        // recupero i contorni del chunk
-         for ( int nL = 0 ; nL < pSfr->GetLoopCount( nC) ; ++ nL) {
-            PtrOwner<ICurveComposite> pCrvLoop( ConvertCurveToComposite( pSfr->GetLoop( nC, nL))) ;
-            if ( IsNull( pCrvLoop))
-               return false ;
-           // unisco le eventuali parti allineate
-            pCrvLoop->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL) ;
-           // aggiungo il loop al vettore di curve
-            lstPC.emplace_back( Release( pCrvLoop)) ;
-         }
-      }
-      return true ;
-   }
-  // altrimenti errore
-   else
-      return false ;
-}
-
-//----------------------------------------------------------------------------
-bool
-ExePocketing( const INTVECTOR vId, double dRad, double dStep, double dAngle, int nType, bool bSmooth, int nDestGrpId,
-              int& nFirstId, int& nCrvCount)
-{
-  // databse geometrico
-   IGeomDB* pGeomDB = GetCurrGeomDB() ;
-   VERIFY_GEOMDB( pGeomDB, false) ;
-  // vettore puntatori alle curve
-   ICURVEPOVECTOR vpCrvs ;
-   vpCrvs.reserve( vId.size()) ;
-  // vettore selettori delle curve originali
-   SELVECTOR vInds ;
-  // scorro le entità selezionate per creare la FlatRegion da svuotare
-   PtrOwner<ISurfFlatRegion> pSfrPock( CreateSurfFlatRegion()) ;
-   if ( IsNull( pSfrPock))
-      return false ;
-   Vector3d vtN = V_INVALID ;
-   for ( auto& Id : vId) {
-     // vettore contente tutte le curve selezionate
-      ICURVEPLIST lstPC ;
-      if ( ! MyGetCurves( Id, lstPC, vtN))
-         continue ;
-      for ( auto pCrv : lstPC) {
-         vpCrvs.emplace_back( pCrv) ;
-         vInds.emplace_back( Id) ;
-      }
-   }
-  // recupero i loop per pSfrPock dal concatenamento ( se necessario)
-   ICRVCOMPOPOVECTOR vCrvCompo ;
-   if ( ! MyChainCurves( vInds, vpCrvs, vCrvCompo))
-      return false ;
-   SurfFlatRegionByContours sfrBC ;
-   for ( int u = 0 ; u < int( vCrvCompo.size()) ; ++ u)
-      sfrBC.AddCurve( Release( vCrvCompo[u])) ;
-  // aggiorno pSfrPock
-   pSfrPock.Set( sfrBC.GetSurf()) ;
-   if ( IsNull( pSfrPock)  ||  ! pSfrPock->IsValid())
-      return false ;
-  // recupero il riferimento del gruppo di destinazione
-   Frame3d frDest ;
-   if ( ! pGeomDB->GetGroupGlobFrame( nDestGrpId, frDest))
-      return false ;
-  // costruzione vettori di curve per Pocketing
-   ICRVCOMPOPOVECTOR vCrvCompoRes ;
-  // eseguo Pocketing
-   bool bOk = CalcPocketing( pSfrPock, dRad, dStep, dAngle, nType, bSmooth, vCrvCompoRes) ;
-   nFirstId = GDB_ID_NULL ; // primo Id da restituire
-   nCrvCount = int( vCrvCompoRes.size()) ;
-   if ( bOk  &&  int( vCrvCompoRes.size()) > 0) {
-     // scorro le curve di Pocketing ottenute
-      for ( int u = 0 ; u < int( vCrvCompoRes.size()) ; ++ u) {
-         vCrvCompoRes[u]->ToLoc( frDest) ;
-        // inserisco la curva nel DB Geometrico
-         int nCurrId = pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, Release( vCrvCompoRes[u])) ;
-         if ( nCurrId == GDB_ID_NULL)
-            return false ;
-         if ( u == 0)
-            nFirstId = nCurrId ; // memorizzo il primo Id da restituire
-      }
-      ExeSetModified() ;
-   }
-
-   if ( IsCmdLog()) {
-      string sLua = "EgtPocketing(" + ToString( vId) + "," +
-                                      ToString( dRad) + "," +
-                                      ToString( dStep) + "," +
-                                      ToString( dAngle) + "," +
-                                      ToString( nType) + "," +
-                                      ToString( bSmooth) + "," +
-                                      ToString( nDestGrpId) + ")" +
-                    " -- Ok=" + ToString( bOk) + " FirstId=" + ToString( nFirstId) + " CurveCount=" + ToString( nCrvCount) ;
-      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
-   }
-   return bOk ;
-}
-
 //----------------------------------------------------------------------------
 int
 ExeCurveGetVoronoi( int nId, int nDestGrpId, int nBound, int* pnCount) 

EgtExecutor.vcxproj

@@ -257,6 +257,7 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClCompile Include="EXE_GdbCreateVol.cpp" />
     <ClCompile Include="EXE_GdbGet.cpp" />
     <ClCompile Include="EXE_GdbGetCurve.cpp" />
+    <ClCompile Include="EXE_GdbGetPocketing.cpp" />
     <ClCompile Include="EXE_GdbGetSurf.cpp" />
     <ClCompile Include="EXE_GdbGetVol.cpp" />
     <ClCompile Include="EXE_GdbModifyVol.cpp" />
@@ -307,6 +308,7 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClCompile Include="LUA_CDeObjSolid.cpp" />
     <ClCompile Include="LUA_GdbGet.cpp" />
     <ClCompile Include="LUA_GdbGetCurve.cpp" />
+    <ClCompile Include="LUA_GdbGetPocketing.cpp" />
     <ClCompile Include="LUA_GdbGetSurf.cpp" />
     <ClCompile Include="LUA_GdbGetVol.cpp" />
     <ClCompile Include="LUA_GeoDist.cpp" />

EgtExecutor.vcxproj.filters

@@ -395,6 +395,12 @@
     <ClCompile Include="DllExch3dm.cpp">
       <Filter>File di origine\Optional Dll</Filter>
     </ClCompile>
+    <ClCompile Include="EXE_GdbGetPocketing.cpp">
+      <Filter>File di origine\EXE</Filter>
+    </ClCompile>
+    <ClCompile Include="LUA_GdbGetPocketing.cpp">
+      <Filter>File di origine\LUA</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="EgtExecutor.rc">

LUA.h

@@ -54,6 +54,9 @@ bool LuaInstallGdbModifyVol( LuaMgr& luaMgr) ;
 //-------------------------- GdbGet ------------------------------------------
 bool LuaInstallGdbGet( LuaMgr& luaMgr) ;
 
+//-------------------------- GdbGetPocketing ---------------------------------
+bool LuaInstallGdbGetPocketing( LuaMgr& luaMgr) ;
+
 //-------------------------- GdbGetCurve -------------------------------------
 bool LuaInstallGdbGetCurve( LuaMgr& luaMgr) ;
 
@@ -62,7 +65,7 @@ bool LuaInstallGdbGetSurf( LuaMgr& luaMgr) ;
 
 //-------------------------- GdbGetVol ---------------------------------------
 bool LuaInstallGdbGetVol( LuaMgr& luaMgr) ;
-                                              
+
 //-------------------------- GdbPartLayer ------------------------------------
 bool LuaInstallGdbPartLayer( LuaMgr& luaMgr) ;
 

LUA_Base.cpp

@@ -78,6 +78,10 @@ LuaInstallEgtFunctions( LuaMgr& LuaMgr)
       LOG_ERROR( GetLogger(), "Error in LuaInstallGdbGet (LuaInstallEgtFunctions)")
       return false ;
    }
+   if ( ! LuaInstallGdbGetPocketing( LuaMgr)) {
+      LOG_ERROR( GetLogger(), "Error in LuaInstallGdbGetPocketing (LuaInstallEgtFunctions)")
+      return false ;
+   }
    if ( ! LuaInstallGdbGetCurve( LuaMgr)) {
       LOG_ERROR( GetLogger(), "Error in LuaInstallGdbGetCurve (LuaInstallEgtFunctions)")
       return false ;

LUA_GdbGetPocketing.cpp

@@ -0,0 +1,90 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2023-2023
+//----------------------------------------------------------------------------
+// File : LUA_GdbGetPocketing.cpp       Data : 28.11.23        Versione : 2.5k6
+// Contenuto : Funzioni di creazione percorsi di svuotatura o infill per LUA.
+//
+//
+//
+// Modifiche : 29.11.23 RE Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+//--------------------------- Include ----------------------------------------
+#include "stdafx.h"
+#include "LUA.h"
+#include "/EgtDev/Include/EXeExecutor.h"
+
+using namespace std ;
+
+//----------------------------------------------------------------------------
+static int
+LuaPocketing( lua_State* L) {
+  // 7 parametri : vId, dRad, dStep, dAngle, nType, bSmooth, nDestGrpId
+   int nId ;
+   LuaCheckParam( L, 1, nId) ;
+   double dRad ;
+   LuaCheckParam( L, 2, dRad) ;
+   double dStep ;
+   LuaCheckParam( L, 3, dStep) ;
+   double dAngle ;
+   LuaCheckParam( L, 4, dAngle) ;
+   int nType ;
+   LuaCheckParam( L, 5, nType) ;
+   bool bSmooth ;
+   LuaCheckParam( L, 6, bSmooth) ;
+   int nDestGrpId ;
+   LuaCheckParam( L, 7, nDestGrpId) ;
+   LuaClearStack( L) ;
+  // calcolo delle curve elementari di svuotatura
+   int nFirstId = GDB_ID_NULL ;
+   int nCrvCount = 0 ;
+   bool bOk = ExePocketing( nId, dRad, dStep, dAngle, nType, bSmooth, nDestGrpId, nFirstId, nCrvCount) ;
+   if ( ! bOk)
+      LuaSetParam( L) ;
+   else
+      LuaSetParam( L, nFirstId) ;
+   LuaSetParam( L, nCrvCount) ;
+   return 2 ;
+}
+
+//----------------------------------------------------------------------------
+static int
+LuaSurfFrGetZigZagInfill( lua_State* L)
+{
+  // 6 parametri : nId, nDestGrpId, dSideStep, dAng, bSmooth, bRemoveOverlapLink
+   int nId ;
+   LuaCheckParam( L, 1, nId)
+   int nDestGrpId ;
+   LuaCheckParam( L, 2, nDestGrpId)
+   double dStep ;
+   LuaCheckParam( L, 3, dStep)
+   double dAng ;
+   LuaCheckParam( L, 4, dAng) ;
+   bool bSmooth ;
+   LuaCheckParam( L, 5, bSmooth) ;
+   bool bRemoveOverlapLink ;
+   LuaCheckParam( L, 6, bRemoveOverlapLink) ;
+   LuaClearStack( L) ;
+  // recupero i contorni della superficie
+   int nCount = 0 ;
+   int nNewId = ExeSurfFrGetZigZagInfill( nId, nDestGrpId, dStep, dAng, bSmooth, bRemoveOverlapLink, &nCount) ;
+  // restituisco il risultato
+   if ( nNewId != GDB_ID_NULL)
+      LuaSetParam( L, nNewId) ;
+   else
+      LuaSetParam( L) ;
+   LuaSetParam( L, nCount) ;
+   return 2 ;
+}
+
+//-------------------------------------------------------------------------------
+bool
+LuaInstallGdbGetPocketing( LuaMgr& luaMgr)
+{
+   bool bOk = ( &luaMgr != nullptr) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtPocketing", LuaPocketing) ;
+   bOk = bOk && luaMgr.RegisterFunction( "EgtGetSurfFrZigZagInfill", LuaSurfFrGetZigZagInfill) ;
+   return bOk ;
+}

LUA_GdbGetSurf.cpp

@@ -237,35 +237,6 @@ LuaSurfFrRotateSimpleNoCollision( lua_State* L)
    return 1 ;
 }
 
-
-//----------------------------------------------------------------------------
-static int
-LuaSurfFrGetZigZagInfill( lua_State* L)
-{
-  // 5 parametri : nId, nDestGrpId, dSideStep, dAng, bSmooth
-   int nId ;
-   LuaCheckParam( L, 1, nId)
-   int nDestGrpId ;
-   LuaCheckParam( L, 2, nDestGrpId)
-   double dStep ;
-   LuaCheckParam( L, 3, dStep)
-   double dAng ;
-   LuaCheckParam( L, 4, dAng) ;
-   bool bSmooth ;
-   LuaCheckParam( L, 5, bSmooth) ;
-   LuaClearStack( L) ;
-  // recupero i contorni della superficie
-   int nCount = 0 ;
-   int nNewId = ExeSurfFrGetZigZagInfill( nId, nDestGrpId, dStep, dAng, bSmooth, &nCount) ;
-  // restituisco il risultato
-   if ( nNewId != GDB_ID_NULL)
-      LuaSetParam( L, nNewId) ;
-   else
-      LuaSetParam( L) ;
-   LuaSetParam( L, nCount) ;
-   return 2 ;
-}
-
 //----------------------------------------------------------------------------
 static int
 LuaSurfTmVertexCount( lua_State* L)
@@ -1074,7 +1045,6 @@ LuaInstallGdbGetSurf( LuaMgr& luaMgr)
    bOk = bOk && luaMgr.RegisterFunction( "EgtExtractSurfFrChunkLoops", LuaExtractSurfFrChunkLoops) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfFrMoveSimpleNoCollision", LuaSurfFrMoveSimpleNoCollision) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfFrRotateSimpleNoCollision", LuaSurfFrRotateSimpleNoCollision) ;
-   bOk = bOk && luaMgr.RegisterFunction( "EgtGetSurfFrZigZagInfill", LuaSurfFrGetZigZagInfill) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmVertexCount", LuaSurfTmVertexCount) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmFacetCount", LuaSurfTmFacetCount) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmPartCount", LuaSurfTmPartCount) ;

LUA_GdbModifyCurve.cpp

@@ -969,37 +969,6 @@ LuaProjectCurveOnSurfTm( lua_State* L)
    return 1 ;
 }
 
-//----------------------------------------------------------------------------
-static int
-LuaPocketing( lua_State* L) {
-  // 7 parametri : vId, dRad, dStep, dAngle, nType, bSmooth, nDestGrpId
-   INTVECTOR vId ;
-   LuaCheckParam( L, 1, vId) ;
-   double dRad ;
-   LuaCheckParam( L, 2, dRad) ;
-   double dStep ;
-   LuaCheckParam( L, 3, dStep) ;
-   double dAngle ;
-   LuaCheckParam( L, 4, dAngle) ;
-   int nType ;
-   LuaCheckParam( L, 5, nType) ;
-   bool bSmooth ;
-   LuaCheckParam( L, 6, bSmooth) ;
-   int nDestGrpId ;
-   LuaCheckParam( L, 7, nDestGrpId) ;
-   LuaClearStack( L) ;
-  // calcolo delle curve elementari di svuotatura
-   int nFirstId = GDB_ID_NULL ;
-   int nCrvCount = 0 ;
-   bool bOk = ExePocketing( vId, dRad, dStep, dAngle, nType, bSmooth, nDestGrpId, nFirstId, nCrvCount) ;
-   if ( ! bOk)
-      LuaSetParam( L) ;
-   else
-      LuaSetParam( L, nFirstId) ;
-   LuaSetParam( L, nCrvCount) ;
-   return 2 ;
-}
-
 //----------------------------------------------------------------------------
 static int
 LuaCurveGetVoronoi( lua_State* L)
@@ -1132,7 +1101,6 @@ 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( "EgtPocketing", LuaPocketing) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtCurveGetVoronoi", LuaCurveGetVoronoi) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtCurveMedialAxisAdv", LuaCurveMedialAxisAdv) ;
    bOk = bOk && luaMgr.RegisterFunction( "EgtCurveGetFatCurve", LuaCurveGetFatCurve) ;