3dPrinting 2.6c1 :

- aggiunti fillet per setti - correzioni varie.
2024-03-27 09:51:18 +01:00
parent cdef58712f
commit f5c9890924
6 changed files with 185 additions and 46 deletions
@@ -17,6 +17,7 @@ local s_nPartId
 local s_nDefaultWipeAng = -90   -- angolo = 0° per wipe significa che esce ortogonalmente alla direzione del movimento
 local s_dApproxTol = 0.1
 local s_dHSafeWipe = 2
+local s_nCurrIdx

 ---------------------------------------------------------------------
 local function GetLayerParamsForToolPathCalc()
@@ -109,13 +110,23 @@ local function AddZCorrection( b3Box, LayerParams)
            for k = 1, #vIds do
               -- se wipe verifico se ha lunghezza sensata per non finire nella tavola
               if EgtGetInfo( vIds[k], KEY_TYPE, 'i') == TYPE.WIPE then
-                  local dLen = EgtCurveLength( vIds[k])
-                  local vtDir = EgtSV( vIds[k], GDB_ID.ROOT)
-                  local ptE = EgtEP( vIds[k], GDB_ID.ROOT)
-                  if ptE:getZ() < dHMinWipe then
-                     -- modifico la lunghezza per non finire nella tavola
-                     local dDiffLen = ( dHMinWipe - ptE:getZ()) / vtDir:getZ()
-                     EgtTrimCurveEndAtLen( vIds[k], dLen - abs( dDiffLen))
+                  -- da controllare solo se non segue l'andamento di una curva chiusa
+                  local bOnCurve = EgtGetInfo( vIds[k], KEY_WIPE_ON_CRV, 'b') or false
+                  if not bOnCurve then
+                     local dLen = EgtCurveLength( vIds[k])
+                     local vtDir = EgtSV( vIds[k], GDB_ID.ROOT)
+                     local ptE = EgtEP( vIds[k], GDB_ID.ROOT)
+                     if ptE:getZ() < dHMinWipe then
+                        -- modifico la lunghezza per non finire nella tavola
+                        local dDiffLen = abs( ( dHMinWipe - ptE:getZ()) / vtDir:getZ())
+                        if dDiffLen > dLen - GEO.EPS_SMALL then
+                           -- l'intero tratto di wipe va eliminato
+                           EgtErase( vIds[k])
+                           EgtOutLog( 'Warning : wipe was removed due to wrong direction (layer '..tostring( i)..') - CalcToolPath')
+                        else
+                           EgtTrimCurveEndAtLen( vIds[k], dLen - dDiffLen)
+                        end
+                     end
                  end
               end
            end
@@ -380,18 +391,26 @@ local function AddRetraction( nCrvId, vtSlicing, dCoastingLen, dWipeLen, dWipeDi
   -- curva ausiliaria per generare correttamente wipe
   local nCopyId = EgtCopyGlob( nCrvId, nCrvId, GDB_IN.AFTER)
   if not EgtCurveIsClosed( nCopyId) then
-      local ptNewStart = EgtEP( nCrvId)
-      local dPar = EgtCurveParamAtPoint( nCopyId, ptNewStart)
-      local _, dParE = EgtCurveDomain( nCopyId)
-      if abs( dPar - dParE) < GEO.EPS_SMALL then
-         EgtCloseCurveCompo( nCopyId)
-         EgtChangeClosedCurveStartPoint( nCopyId, ptNewStart)
-      else
+      local ptNewStart = EgtEP( nCopyId, GDB_ID.ROOT)
+      -- mi posiziono in un frame locale per fare i conti
+      local nGrp = EgtGroup( EgtGetParent( nCrvId), Frame3d( ORIG(), vtSlicing), GDB_RT.GLOB)
+      EgtRelocateGlob( nCopyId, nGrp)
+      local nInters = EgtCurveSelfIntersCount( nCopyId)
+      local nCrvCnt
+      if nInters > 0 then
         -- caso con sovrapposizione
-         EgtTrimCurveStartAtParam( nCopyId, dPar)
+         nCopyId, nCrvCnt = EgtSplitCurveAtSelfInters( nCopyId)
+         for nIdx = 1, nCrvCnt - 2 do
+            EgtAddCurveCompoCurve( nCopyId, nCopyId + nIdx)
+         end
+         EgtErase( nCopyId + nCrvCnt - 1)
      end
+      EgtCloseCurveCompo( nCopyId)
+      EgtChangeClosedCurveStartPoint( nCopyId, ptNewStart, GDB_RT.GLOB)
+      EgtRelocateGlob( nCopyId, nCrvId, GDB_IN.AFTER)
+      EgtErase( nGrp)
   end
-   
+
   local nCoastingId
   if dCoastingLen > GEO.EPS_SMALL then
      nCoastingId = EgtCopyGlob( nCrvId, nCrvId, GDB_IN.AFTER)
@@ -422,6 +441,7 @@ local function AddRetraction( nCrvId, vtSlicing, dCoastingLen, dWipeLen, dWipeDi
         nWipeId = nCopyId
         nCopyId = nil
         EgtTrimCurveEndAtLen( nWipeId, dWipeLen)
+         EgtSetInfo( nWipeId, KEY_WIPE_ON_CRV, true)
      else
         -- se extra shell, infill, spiral vase o rib che non termina sulla parete
         local ptS = EgtEP( nCoastingId or nCrvId, GDB_ID.ROOT)
@@ -519,7 +539,7 @@ local function CalcShellsToolPath( vEntIds, nTpathGrpId, LayerParams)
   -- aggiungo le curve nel toolpath
   local vIds = AddCurvesToToolPath( vEntIds, nTpathGrpId, LayerParams.nOrder, LayerParams.bInvert, LayerParams.vtSlicing, LayerParams.dLayHeight)
   local nFirstCopy = EgtCopyGlob( vIds[1], nTpathGrpId)   -- necessaria per corretto offset lead point sulla shell esterna
-   
+
   -- assegno lo strand
   for i = 1, #vIds do
      local nType = EgtGetInfo( vIds[i], KEY_TYPE, 'i')
@@ -531,7 +551,7 @@ local function CalcShellsToolPath( vEntIds, nTpathGrpId, LayerParams)
         EgtSetInfo( vIds[i], KEY_CRV_STRAND, LayerParams.dInfillStrand)
      end
   end
-   
+
   -- aggiungo gli opportuni raccordi
   AddLink( vIds, nTpathGrpId, LayerParams.nLinkType, LayerParams.dLinkParam, LayerParams.dSPOffs, LayerParams.nOrder, LayerParams.vtSlicing)
   
@@ -1041,6 +1061,74 @@ end

 --------------------------------------------------------------------
 --------------------------- RIBS -----------------------------------
+--------------------------------------------------------------------
+local function AddFillet( nCrv1, nCrv2, dFillet, vtSlicing)
+   
+   local nRefPosId = EgtGetPrev( nCrv1)
+   local nRefGrpId = EgtGetParent( nCrv1)
+   local vsInfo1 = EgtGetAllInfo( nCrv1)
+   local vsInfo2 = EgtGetAllInfo( nCrv2)
+   
+   -- creo un gruppo con riferimento locale allo slicing per i conti del fillet
+   local nGrpTmp = EgtGroup( EgtGetParent( nCrv1), Frame3d( ORIG(), vtSlicing), GDB_RT.GLOB)
+   
+   -- creo il fillet
+   local dParRef1 = EgtCurveParamAtLength( nCrv1, EgtCurveLength( nCrv1) - 100 * GEO.EPS_SMALL)
+   local dParRef2 = EgtCurveParamAtLength( nCrv2, 100 * GEO.EPS_SMALL)
+   local nFillet = EgtCurveFillet( nGrpTmp, nCrv1, EgtUP( nCrv1, dParRef1, nGrpTmp), nCrv2, EgtUP( nCrv2, dParRef2, nGrpTmp), dFillet, true, GDB_RT.LOC)
+   if not nFillet then
+      -- ritento con valore di fillet leggermente inferiore
+      nFillet = EgtCurveFillet( nGrpTmp, nCrv1, EgtUP( nCrv1, dParRef1, nGrpTmp), nCrv2, EgtUP( nCrv2, dParRef2, nGrpTmp), dFillet - 50 * GEO.EPS_SMALL, true, GDB_RT.LOC)
+   end
+
+   -- spezzo a metà il fillet per assegnarlo alle due curve
+   if nFillet then
+      
+      local nNewFillet = EgtSplitCurve( nFillet, 2)
+      
+      -- aggiungo a nCrv1
+      if EgtExistsObj( nCrv1) then
+         EgtAddCurveCompoArcTg( nCrv1, EgtEP( nNewFillet, GDB_ID.ROOT), true, GDB_RT.GLOB)
+         EgtErase( nNewFillet)
+      else
+         -- nCrv1 viene sostutuita completamente dal fillet
+         local nNewCrv = EgtCurveCompo( nRefGrpId, {nNewFillet})
+         -- riposiziono dopo il precedente di nCrv1 ( se esiste) oppure in testa al gruppo
+         if nRefPosId ~= GDB_ID.NULL then
+            EgtRelocateGlob( nNewFillet, nRefPosId, GDB_IN.AFTER)
+         else
+            EgtRelocateGlob( nNewFillet, nRefGrpId, GDB_IN.FIRST_SON)
+         end
+         -- modifico l'id per conservare quello di nCrv1
+         EgtChangeId( nNewCrv, nCrv1)
+         -- riassegno le info
+         for i = 1, #vsInfo1 do
+            local vsInfo = EgtSplitString( vsInfo1[i], '=')
+            EgtSetInfo( nCrv1, vsInfo[1], vsInfo[2])
+         end
+      end
+      
+      -- aggiungo a nCrv2
+      if EgtExistsObj( nCrv2) then
+         EgtAddCurveCompoArcTg( nCrv2, EgtSP( nNewFillet + 1, GDB_ID.ROOT), false, GDB_RT.GLOB)
+         EgtErase( nNewFillet + 1)
+      else
+         -- nCrv2 viene sostutuita completamente dal fillet
+         local nNewCrv = EgtCurveCompo( nRefGrpId, {nNewFillet + 1})
+         EgtRelocateGlob( nNewCrv, nCrv1, GDB_IN.AFTER)
+         EgtChangeId( nNewCrv, nCrv2)
+         for i = 1, #vsInfo2 do
+            local vsInfo = EgtSplitString( vsInfo2[i], '=')
+            EgtSetInfo( nCrv2, vsInfo[1], vsInfo[2])
+         end
+      end
+   else
+      EgtOutLog( 'Warning : ribs fillet not possible (layer '..tostring( s_nCurrIdx)..') - CalcToolPath')
+   end
+   
+   EgtErase( nGrpTmp)
+end
+
 --------------------------------------------------------------------
 local function VerifyRibsLink( nLinkId, nCurr, nNext, nGrpTmp, dStrand)

@@ -1075,7 +1163,7 @@ local function VerifyRibsLink( nLinkId, nCurr, nNext, nGrpTmp, dStrand)
      end
      
      -- se collegamento non ottimale verifico che abbia una parte esterna alla regione occupata dai setti abbsatanza lunga ( > 20% della lunghezza totale)
-      if dist( EgtEP( nCurr, GDB_ID.ROOT), EgtSP( nNext, GDB_ID.ROOT)) > dist( EgtEP( nCurr, GDB_ID.ROOT), EgtEP( nNext, GDB_ID.ROOT)) + GEO.EPS_SMALL then
+      if dist( EgtEP( nCurr, GDB_ID.ROOT), EgtSP( nNext, GDB_ID.ROOT)) > dist( EgtEP( nCurr, GDB_ID.ROOT), EgtEP( nNext, GDB_ID.ROOT)) + 1000 * GEO.EPS_SMALL then
         local nSrfRibs = EgtSurfFrFatCurve( nGrpTmp, nCurr, dStrand, false) or GDB_ID.NULL
         local nSrfRibs2 = EgtSurfFrFatCurve( nGrpTmp, nNext, dStrand, false) or GDB_ID.NULL
         EgtSurfFrAdd( nSrfRibs, nSrfRibs2)
@@ -1117,7 +1205,7 @@ local function VerifyRibsLink( nLinkId, nCurr, nNext, nGrpTmp, dStrand)
            dOffs = dCurrStrand * 0.5
         else
            -- altrimenti verifico che le regioni del link e del setto non si sovrappongono ( a meno dell'overlap fissato)
-            dOffs = dCurrStrand * 0.5 + ( 0.5 - dOverlap / 100) * dStrand - 10 * GEO.EPS_SMALL
+            dOffs = dCurrStrand * 0.5 + ( 0.5 - dOverlap / 100) * dStrand - 50 * GEO.EPS_SMALL
         end
         
         if dOffs > GEO.EPS_SMALL then
@@ -1243,6 +1331,8 @@ local function CalcRibsLink( nCurr, nNext, nLoopGrp, bForceLink, vtSlicing, nGrp
   local dStrand1 = EgtGetInfo( nCurr, KEY_CRV_STRAND, 'd')
   local dStrand2 = EgtGetInfo( nNext, KEY_CRV_STRAND, 'd')
   local dStrand = max( dStrand1, dStrand2)
+   local dFillet1 = EgtGetInfo( nCurr, KEY_RIBS_LINK_FILLET, 'd')
+   local dFillet2 = EgtGetInfo( nNext, KEY_RIBS_LINK_FILLET, 'd')
   
   local vCrvIds = EgtGetAllInGroup( nLoopGrp)
   -- recupero le curve di bordo su cui poggiano i setti e i corrispondenti parametri
@@ -1274,6 +1364,14 @@ local function CalcRibsLink( nCurr, nNext, nLoopGrp, bForceLink, vtSlicing, nGrp
         end
         
         if nLinkId then
+            -- fillet
+            if bForceLink then
+               dFillet1 = min( dFillet1, dStrand1 * 0.5)
+               dFillet2 = min( dFillet2, dStrand2 * 0.5)
+            end
+            AddFillet( nCurr, nLinkId, dFillet1, vtSlicing)
+            AddFillet( nLinkId, nNext, dFillet2, vtSlicing)
+            -- assegno le info
            EgtRelocateGlob( nLinkId, nCurr, GDB_IN.AFTER)
            EgtSetInfo( nLinkId, KEY_TYPE, TYPE.RIB)
            EgtSetName( nLinkId, LINK_CRV)
@@ -1287,6 +1385,7 @@ local function CalcRibsLink( nCurr, nNext, nLoopGrp, bForceLink, vtSlicing, nGrp
   -- se non ho trovato un collegamento lungo bordi ma link deve esserci creo una linea tra ptS e ptE
   if bForceLink then
      local nLinkId = EgtCurveCompoFromPoints( EgtGetParent( nCurr), {ptS, ptE})
+      -- assegno le info
      EgtSetInfo( nLinkId, KEY_TYPE, TYPE.RIB)
      EgtSetName( nLinkId, LINK_CRV)
      EgtModifyCurveExtrusion( nLinkId, vtSlicing, GDB_RT.GLOB)
@@ -1294,6 +1393,11 @@ local function CalcRibsLink( nCurr, nNext, nLoopGrp, bForceLink, vtSlicing, nGrp
      EgtSetInfo( nLinkId, KEY_CRV_STRAND, dStrand)
      local bValid = VerifyRibsLink( nLinkId, nCurr, nNext, nGrpTmp, dStrand)
      if bValid then
+         -- fillet
+         dFillet1 = min( dFillet1, dStrand1 * 0.5)
+         dFillet2 = min( dFillet2, dStrand2 * 0.5)
+         AddFillet( nCurr, nLinkId, dFillet1, vtSlicing)
+         AddFillet( nLinkId, nNext, dFillet2, vtSlicing)
         return nLinkId
      else
         EgtErase( nLinkId)
@@ -1305,12 +1409,13 @@ local function CalcRibsLink( nCurr, nNext, nLoopGrp, bForceLink, vtSlicing, nGrp
 end

 --------------------------------------------------------------------
-local function CalcLoopRibLink( nCurr, nNext, nLoopGrp, vtSlicing, nGrpTmp)
+local function CalcLoopRibLink( nCurr, nNext, nLoopGrp, vtSlicing, nGrpTmp, bForceLink)
   
   local ptS = EgtEP( nCurr)
   local ptE = EgtSP( nNext)
   if AreSamePointApprox( ptS, ptE) then return end
   local dStrand = EgtGetInfo( nCurr, KEY_CRV_STRAND, 'd')
+   local dFillet = EgtGetInfo( nCurr, KEY_RIBS_LINK_FILLET, 'd')
   
   local vCrvIds = EgtGetAllInGroup( nLoopGrp)
   -- scorro le curve di bordo e verifico se posso creare il link
@@ -1326,6 +1431,12 @@ local function CalcLoopRibLink( nCurr, nNext, nLoopGrp, vtSlicing, nGrpTmp)
            EgtModifyCurveExtrusion( nLinkId, vtSlicing, GDB_RT.GLOB)
            EgtSetInfo( nLinkId, KEY_CRV_STRAND, dStrand)
            if VerifyRibsLink( nLinkId, nCurr, nNext, nGrpTmp, dStrand) then
+               -- fillet
+               if bForceLink then
+                  dFillet = min( dFillet, dStrand * 0.5)
+               end
+               AddFillet( nCurr, nLinkId, dFillet, vtSlicing)
+               AddFillet( nLinkId, nNext, dFillet, vtSlicing)
               return nLinkId
            else
               EgtErase( nLinkId)
@@ -1403,7 +1514,7 @@ local function VerifyRibsLead( nId, nRibId, bInVsOut, nGrpTmp)
   -- controllo se intersezione
   for i = 1, #vCheckIds do
      local dCurrStrand = EgtGetInfo( vCheckIds[i], KEY_CRV_STRAND, 'd') or EgtGetInfo( vCheckIds[i], KEY_RIBS_STRAND, 'd')
-      local dCurrOffs = dCurrStrand * 0.5 + ( 0.5 - dOverlap / 100) * dStrand - 10 * GEO.EPS_SMALL
+      local dCurrOffs = dCurrStrand * 0.5 + ( 0.5 - dOverlap / 100) * dStrand - 50 * GEO.EPS_SMALL
      if dCurrOffs > GEO.EPS_SMALL then
         local nSrfCurr = EgtSurfFrFatCurve( nGrpTmp, vCheckIds[i], dCurrOffs, false)
         if nSrfCurr then
@@ -1572,6 +1683,7 @@ local function AddRibsLeadIn( nCrv, nLoopsGrp, vtSlicing, nGrpTmp, bForceNoSolid
   local dLILen = EgtGetInfo( nCrv, KEY_RIBS_LEAD_IN_LEN, 'd')
   local bLIInvert = EgtGetInfo( nCrv, KEY_RIBS_LEAD_IN_INVERT, 'b')
   local dStrand = EgtGetInfo( nCrv, KEY_CRV_STRAND, 'd')
+   local dFillet = EgtGetInfo( nCrv, KEY_RIBS_LEAD_FILLET, 'd')
   
   if dLILen < GEO.EPS_SMALL then return end
   
@@ -1590,6 +1702,8 @@ local function AddRibsLeadIn( nCrv, nLoopsGrp, vtSlicing, nGrpTmp, bForceNoSolid
         local nLeadIn = FindCorrectRibLead( dParS, nCrv, vCrvOffs[i], bLIInvert, dLILen, true, nGrpTmp, bSpecialCase)
         -- se lead in possibile
         if nLeadIn then
+            AddFillet( nLeadIn, nCrv, dFillet, vtSlicing)
+            
            EgtModifyCurveExtrusion( nLeadIn, vtSlicing, GDB_RT.GLOB)
            EgtSetInfo( nLeadIn, KEY_TYPE, TYPE.RIB)
            EgtSetName( nLeadIn, LEAD_IN_CRV)
@@ -1609,6 +1723,7 @@ local function AddRibsLeadOut( nCrv, nLoopsGrp, vtSlicing, nGrpTmp, bForceNoSoli
   local dRibsLOWipeAng = EgtGetInfo( nCrv, KEY_RIBS_LEAD_OUT_WIPE_DIR, 'd')
   local bRibsLOInvert = EgtGetInfo( nCrv, KEY_RIBS_LEAD_OUT_INVERT, 'b')
   local dStrand = EgtGetInfo( nCrv, KEY_CRV_STRAND, 'd')
+   local dFillet = EgtGetInfo( nCrv, KEY_RIBS_LEAD_FILLET, 'd')
   
   if abs( dRibsLOLen) < GEO.EPS_SMALL and
      abs( dRibsLOCoasting) < GEO.EPS_SMALL and
@@ -1642,7 +1757,12 @@ local function AddRibsLeadOut( nCrv, nLoopsGrp, vtSlicing, nGrpTmp, bForceNoSoli
         local nCrvRef, bInvert = FindCorrectRibLead( dParE, nCrv, vCrvOffs[i], bRibsLOInvert, dRibsLOLen + dRibsLOCoasting, false, nGrpTmp, bSpecialCase)
   
         if nCrvRef then
-   
+            
+            -- aggiungo il fillet ( potrebbe coinvolgere sia lead out sia coasting)
+            AddFillet( nCrv, nCrvRef, dFillet, vtSlicing)
+            -- calcolo la nuova lunghezza per il lead out per conservare la lunghezza del coasting dopo il fillet
+            dRibsLOLen = EgtCurveLength( nCrvRef) - dRibsLOCoasting
+            
            -- primo tratto ( segue offset con flusso aperto)
            if dRibsLOLen > GEO.EPS_SMALL then
               nCrvLO = EgtCopyGlob( nCrvRef, nCrv, GDB_IN.AFTER)
@@ -1712,7 +1832,7 @@ local function CalcRibsToolPath( vEntIds, nRibsGrp, nTpathGrpId, LayerParams)
   local nGrpTmp = EgtGroup( nRibsGrp, frLoc, GDB_RT.GLOB)
   
   -- aggiungo le costolature nel toolpath
-   local nNewFirstEnt
+   local nLastEnt = EgtGetLastInGroup( nTpathGrpId)
   for i = 1, #vEntIds do
      -- copio entità nel gruppo toolpath
      local nNewEntId = EgtCopyGlob( vEntIds[i], nTpathGrpId, GDB_IN.LAST_SON)
@@ -1734,13 +1854,11 @@ local function CalcRibsToolPath( vEntIds, nRibsGrp, nTpathGrpId, LayerParams)
      
      EgtSetInfo( nNewEntId, KEY_ASSOCIATED_P_CRV, vEntIds[i])
      EgtSetInfo( vEntIds[i], KEY_ASSOCIATED_TP_CRV, nNewEntId)
-     
-      if i == 1 then nNewFirstEnt = nNewEntId end
   end
   
   -- recupero i gruppi delle costolature
   local tabRibs = {}
-   local nFirst = nNewFirstEnt
+   local nFirst = EgtGetNext( nLastEnt)
   while nFirst do
      local sName = EgtGetName( nFirst)
      local vIds = EgtGetNameInGroup( nTpathGrpId, sName)
@@ -1772,12 +1890,17 @@ local function CalcRibsToolPath( vEntIds, nRibsGrp, nTpathGrpId, LayerParams)
               if not bLoopRib then
                  CalcRibsLink( tabRibs[i][j], tabRibs[i][j + 1], nLoopGrp, bForceLink, LayerParams.vtSlicing, nGrpTmp)
               else
-                  local nLinkId = CalcLoopRibLink( tabRibs[i][j], tabRibs[i][j + 1], nLoopGrp, LayerParams.vtSlicing, nGrpTmp)
+                  local nLinkId = CalcLoopRibLink( tabRibs[i][j], tabRibs[i][j + 1], nLoopGrp, LayerParams.vtSlicing, nGrpTmp, bForceLink)
                  -- se collegamento congiungo i setti in unico percorso
                  if nLinkId then
-                     EgtAddCurveCompoCurve( tabRibs[i][j], nLinkId)
-                     EgtAddCurveCompoCurve( tabRibs[i][j], tabRibs[i][j + 1])
-                     tabRibs[i][j+1] = tabRibs[i][j] -- aggiorno id nel vettore dei setti per gestire correttamente la curva allo step successivo
+                     EgtAddCurveCompoCurve( tabRibs[i][j+1], nLinkId, true, false)
+                     EgtAddCurveCompoCurve( tabRibs[i][j+1], tabRibs[i][j], true, false)
+                     -- aggiorno id nel vettore dei setti per gestire correttamente le curve negli step successivi
+                     for k = 0, j do
+                        if tabRibs[i][k] == tabRibs[i][j] then
+                           tabRibs[i][k] = tabRibs[i][j+1]
+                        end
+                     end
                  end
               end
            end
@@ -1786,7 +1909,7 @@ local function CalcRibsToolPath( vEntIds, nRibsGrp, nTpathGrpId, LayerParams)
         -- se LoopRib aggiungo collegamento tra primo e ultimo setto del gruppo
         if bLoopRib then
            local nTotCrv = #tabRibs[i]
-            local nLinkId = CalcLoopRibLink( tabRibs[i][nTotCrv], tabRibs[i][1], nLoopGrp, LayerParams.vtSlicing, nGrpTmp)
+            local nLinkId = CalcLoopRibLink( tabRibs[i][nTotCrv], tabRibs[i][1], nLoopGrp, LayerParams.vtSlicing, nGrpTmp, false)
            if nLinkId then
               -- se curva unica
               if tabRibs[i][nTotCrv] == tabRibs[i][1] then
@@ -1831,7 +1954,7 @@ local function CalcRibsToolPath( vEntIds, nRibsGrp, nTpathGrpId, LayerParams)
   if nType == RIB_TYPE.UNBOUNDED then
      bForceNoSolidBorder = true
   end
-   local nCrvRib = nNewFirstEnt
+   local nCrvRib = EgtGetNext( nLastEnt)
   while nCrvRib do
      -- verifico se necessario lead in
      local nPrev = EgtGetPrev( nCrvRib)
@@ -2040,6 +2163,8 @@ function CalcToolPath.Exec( nPartId)
   -- Ciclo sui layer
   for nIdx = 1, #vLayIds do
      
+      s_nCurrIdx = nIdx
+      
      -- scorro tutti i gruppi di contorni
      local nCrvGrpId = EgtGetFirstNameInGroup( vLayIds[ nIdx], CONTOUR_GRP.."*")
      while nCrvGrpId do