3dPrinting 2.5e2 ;

- corretto errore nel lead in/lead out dei setti quando terminano su altro setto
- migliorie varie per lead in, lead out e link dei setti.

LuaLibs/CalcPaths.lua

@@ -86,6 +86,10 @@ local function ComputeSurfOffset( nSrf, nGrpId, dOffs, vtSlicing)
    end
    EgtRelocateGlob( nCopySrf, nGrpId)
    EgtErase( nGrpTmp)
+   
+   if not bExists then
+      nCopySrf = GDB_ID.NULL
+   end
    return bOk, bExists, nCopySrf
 end
 
@@ -642,11 +646,9 @@ local function AssignUserLinkInfo( tabUserLink, bCCW, bLoopRib, bSameSide, sName
 end
 
 ------------------------------------------------------------------------
-local function AdjustUserLinkRibs( tUserLink, vRibs, vtSlicing, nSrfInt, nSrfExt)
+local function AdjustUserLinkRibs( tUserLink, vRibs, vtSlicing, nSrfInt, nSrfExt, nGrp)
    
-   if nSrfInt == GDB_ID.NULL and nSrfExt == GDB_ID.NULL then return end
-   
-   local nGrpTmp = EgtGroup( EgtGetParent( nSrfInt))  -- gruppo temporaneo per conti
+   local nGrpTmp = EgtGroup( nGrp)  -- gruppo temporaneo per conti
    local vUsed = {}   -- setti di vRibs utilizzati per UserLink
    
    -- verifico se posso aggiungere tratti extra agli UserLink già individuati
@@ -924,10 +926,22 @@ end
 local function TrimRibs( vRibs, nRibsGrp, nSrf, dSrfOffs, vtSlicing)
    
    -- costruisco le superfici con cui fare il trim grossolano dei setti
-   local nSrfInt = EgtCopyGlob( nSrf, nRibsGrp) or GDB_ID.NULL
-   local nSrfExt = EgtCopyGlob( nSrf, nRibsGrp) or GDB_ID.NULL
-   EgtSurfFrOffset( nSrfInt, dSrfOffs)
-   EgtSurfFrOffset( nSrfExt, - dSrfOffs)
+   local nSrfInt = GDB_ID.NULL
+   local nSrfExt = GDB_ID.NULL
+   if nSrf ~= GDB_ID.NULL then
+      local bOk
+      bOk, _, nSrfInt = ComputeSurfOffset( nSrf, nRibsGrp, dSrfOffs, vtSlicing)
+      if not bOk then
+         EgtOutLog( 'Warning: coarse trim for internal ribs may be innacurate (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths')
+         nSrfInt = EgtCopyGlob( nSrf, nRibsGrp)
+      end
+      
+      bOk, _, nSrfExt = ComputeSurfOffset( nSrf, nRibsGrp, - dSrfOffs, vtSlicing)
+      if not bOk then
+         EgtOutLog( 'Warning: coarse trim for external ribs may be innacurate (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths')
+         nSrfExt = EgtCopyGlob( nSrf, nRibsGrp)
+      end
+   end
    
    -- trim dei setti
    local nTrimmedRibsGrp = EgtGroup( nRibsGrp)
@@ -962,7 +976,7 @@ local function TrimRibs( vRibs, nRibsGrp, nSrf, dSrfOffs, vtSlicing)
       end
       
       -- se errore nel calcolare trim ( nCrv = nil) riprendo il setto originario
-      if not nCrv then 
+      if not nCrv then
          nCrv = nCopyRib
          nCnt = 1
       end
@@ -997,7 +1011,7 @@ local function TrimRibs( vRibs, nRibsGrp, nSrf, dSrfOffs, vtSlicing)
    end
    
    -- verifico e sistemo UserLink
-   AdjustUserLinkRibs( tUserLink, vSingleRibs, vtSlicing, nSrfInt, nSrfExt)
+   AdjustUserLinkRibs( tUserLink, vSingleRibs, vtSlicing, nSrfInt, nSrfExt, nRibsGrp)
    
    -- verifico se necessari aggiustamenti per holes
    AdjustHoledRibs( nTrimmedRibsGrp)
@@ -1251,7 +1265,7 @@ end
 
 ---------------------------------------------------------------------------------
 -- Funzione che sistema le intersezioni fra costolature nel caso generico
-local function AdjustRibsOffsetForIntersection( nCrv1, nCrv2, LayerParams, nOffsGrp, bSaveSurf, nLoopGrp)
+local function AdjustRibsOffsetForIntersection( nCrv1, nCrv2, LayerParams, nOffsGrp, nLoopGrp, tSurfOffs, nType2)
   
    -- calcolo la superficie della curva principale ( nCrv1) da usare per trim
    local nShells = EgtGetInfo( nCrv1, KEY_RIBS_SHELLS_NBR, 'i')
@@ -1281,23 +1295,32 @@ local function AdjustRibsOffsetForIntersection( nCrv1, nCrv2, LayerParams, nOffs
       end
    end
    
-   -- se necessario salvo i loop da usare per ingressi e uscite
-   if bSaveSurf then
-      -- verifico orientamento della superficie per compatibilità ingressi ribs splittati
-      local vtN = EgtSurfFrNormVersor( nSrf)
-      if AreSameVectorApprox( vtN, LayerParams.vtSlicing) then
-         EgtInvertSurf( nSrf)
+   -- salvo i loop da usare nel toolpath per ingressi e uscite
+   local nSrfRef
+   -- recupero la superficie di bordo con lo stesso overlap
+   local nSrfTrim = tSurfOffs[nType2][nOverlap]
+   if nSrfTrim and nSrfTrim ~= GDB_ID.NULL then
+      nSrfRef = EgtCopyGlob( nSrfTrim, nLoopGrp)
+      if nType2 == RIB_TYPE.INTERNAL then
+         EgtSurfFrSubtract( nSrfRef, nSrf)
+      elseif nType2 == RIB_TYPE.EXTERNAL then
+         EgtSurfFrAdd( nSrfRef, nSrf)
       end
-      local nChunks = EgtSurfFrChunkCount( nSrf)
-      for i = 0, nChunks - 1 do
-         local nRes, nCnt = EgtExtractSurfFrChunkLoops( nSrf, i, nLoopGrp)
-         for j = nRes, nRes + nCnt - 1 do
-            EgtSetName( j, SURF_LOOP)
-         end
+      EgtErase( nSrf)
+   else
+      EgtInvertSurf( nSrf)
+      nSrfRef = nSrf
+   end
+   -- estraggo i loop
+   local nChunks = EgtSurfFrChunkCount( nSrfRef)
+   for i = 0, nChunks - 1 do
+      local nRes, nCnt = EgtExtractSurfFrChunkLoops( nSrfRef, i, nLoopGrp)
+      for j = nRes, nRes + nCnt - 1 do
+         EgtSetName( j, SURF_LOOP)
       end
    end
+   EgtErase( nSrfRef)
    
-   EgtErase( nSrf)
 end
 
 --------------------------------------------------------------------
@@ -1305,7 +1328,7 @@ end
 local function AdjustRibsOffsetForIntersection2Shells( nCrv1, nCrv2, LayerParams, nOffsGrp)
   
    -- costruisco le superfici da usare per trim
-   local nSrf1 = EgtSurfFrFatCurve( nOffsGrp, nCrv1, LayerParams.dStrand / 2, false) 
+   local nSrf1 = EgtSurfFrFatCurve( nOffsGrp, nCrv1, LayerParams.dStrand / 2, false)
    local vtN1 = EgtSurfFrNormVersor( nSrf1, GDB_ID.ROOT)
    if LayerParams.vtSlicing * vtN1 < 0 then
       EgtInvertSurf( nSrf1)
@@ -1359,7 +1382,7 @@ local function UpdateSplitOrder( nCrv, tInters, nOffsGrp)
 end
 
 ---------------------------------------------------------------------------------
-local function HandleRibsIntersections( nRibsGrp, LayerParams, nOffsGrp, nRibsPathGrp, nLoopGrp, bAllTwoStrands, vTypeSequence)
+local function HandleRibsIntersections( nRibsGrp, LayerParams, nOffsGrp, nRibsPathGrp, nLoopGrp, bAllTwoStrands, vTypeSequence, tSurfOffs)
   
    local bSpecialCase = false
    local vRibsIds = EgtGetNameInGroup( nRibsGrp, RIBS_CRV .. '*')
@@ -1424,13 +1447,10 @@ local function HandleRibsIntersections( nRibsGrp, LayerParams, nOffsGrp, nRibsPa
             end
             
             -- aggiorno tabella delle intersezioni
-            local bSaveSurf = false
             if tInters[nCrv1] then
                table.insert( tInters[nCrv1], nCrv2)
             else
                tInters[nCrv1] = {nCrv2}
-               -- è la prima volta che nCrv1 viene usata per un trim quindi devo salvare la superficie utilizzata
-               bSaveSurf = true
             end
             
             -- aggiorno ordine di split
@@ -1444,7 +1464,7 @@ local function HandleRibsIntersections( nRibsGrp, LayerParams, nOffsGrp, nRibsPa
                AdjustRibsOffsetForIntersection2Shells( nCrv1, nCrv2, LayerParams, nRibsPathGrp)
                bSpecialCase = true
             else
-               AdjustRibsOffsetForIntersection( nCrv1, nCrv2, LayerParams, nRibsPathGrp, bSaveSurf, nLoopGrp)
+               AdjustRibsOffsetForIntersection( nCrv1, nCrv2, LayerParams, nRibsPathGrp, nLoopGrp, tSurfOffs, nType2)
             end
          end
       end
@@ -1990,7 +2010,7 @@ local function CalcRibsPaths( nSliceGrp, nRibsGrp, LayerParams, vPtStart)
       end
    
       -- gestisco eventuali intersezioni fra costolature
-      local bInters, bSpecialCase = HandleRibsIntersections( nRibsGrp, LayerParams, nOffsGrp, nRibsPathGrp, nLoopGrp, bAllTwoStrands, vTypeSequence)
+      local bInters, bSpecialCase = HandleRibsIntersections( nRibsGrp, LayerParams, nOffsGrp, nRibsPathGrp, nLoopGrp, bAllTwoStrands, vTypeSequence, tSurfOffs)
       EgtSetInfo( nRibsPathGrp or GDB_ID.NULL, KEY_RIBS_INTERS, bInters)
       EgtSetInfo( nRibsPathGrp or GDB_ID.NULL, KEY_RIBS_SPECIAL_CASE, bSpecialCase)
       

LuaLibs/CalcToolPath.lua

@@ -568,323 +568,329 @@ end
 -------------------------------------------------------------------
 --------------------------- RIBS -----------------------------------
 --------------------------------------------------------------------
-local function VerifyRibsLink( nLinkId, nCurr, nNext, dStrand, nGrpTmp)
+local function VerifyRibsLink( nLinkId, nCurr, nNext, dStrand, nGrpTmp, bCheckLinked)
+
+   local dLen = EgtCurveLength( nLinkId)
+   if dLen < dStrand + GEO.EPS_SMALL then
+      return true
+   end
    
-   local nGrp = EgtGetParent( nCurr)
-   
-   -- verifico se il link interseca le due curve nell'altro estremo
-   local ptS = EgtSP( nCurr)
-   local ptE = EgtEP( nNext)
-   local dParS = EgtCurveParamAtPoint( nLinkId, ptS)
-   local dParE = EgtCurveParamAtPoint( nLinkId, ptE)
-   if nCurr ~= nNext and ( dParS or dParE) then
+   -- regione occupata dal link
+   local nLinkLoc = EgtCopyGlob( nLinkId, nGrpTmp)
+   local nOverlap = EgtGetInfo( nCurr, KEY_RIBS_OVERLAP, 'i')
+   local nSrfLink = EgtSurfFrFatCurve( nGrpTmp, nLinkId, dStrand * ( 1 - nOverlap / 100) - 100 * GEO.EPS_SMALL, false)
+   if not nSrfLink then
       return false
    end
    
-   -- verifico se si trova nella regione ammissibile
-   local nSurfId = EgtGetInfo( nCurr, KEY_ASSOCIATED_SURF, 'i')
-   local nRes = EgtCurveWithRegionClassify( nLinkId, nSurfId)
-   local nType1 = EgtGetInfo( nCurr, KEY_RIBS_TYPE, 'i')
-   local nType2 = EgtGetInfo( nNext, KEY_RIBS_TYPE, 'i')
-   if ( nType1 == RIB_TYPE.INTERNAL or nType1 == RIB_TYPE.SUPPORT) and ( nType2 == RIB_TYPE.INTERNAL or nType2 == RIB_TYPE.SUPPORT) then
-      if nRes == GDB_CRC.OUT or nRes == GDB_CRC.INTERS then
-         return false
-      end
-   elseif nType1 == RIB_TYPE.EXTERNAL and nType2 == RIB_TYPE.EXTERNAL then
-      if nRes == GDB_CRC.IN or nRes == GDB_CRC.INTERS then
-         return false
-      end
-   end
-
-   -- verifico se il link interseca una delle altre costolature
-   local vRibsIds = EgtGetNameInGroup( nGrp, RIBS_CRV .. '*')
-   local nLinkSrf = EgtSurfFrFatCurve( nGrpTmp, nLinkId, 0.5 * dStrand, false) or GDB_ID.NULL
+   -- verifico se interseca altri setti
+   local vRibsIds = EgtGetNameInGroup( EgtGetParent( nCurr), RIBS_CRV .. '*')
    for i = 1, #vRibsIds do
       if vRibsIds[i] ~= nCurr and vRibsIds[i] ~= nNext then
-         local nRes = EgtCurveWithRegionClassify( vRibsIds[i], nLinkSrf)
-         if nRes == GDB_CRC.INTERS then
+         local nRibsLoc = EgtCopyGlob( vRibsIds[i], nGrpTmp)
+         local nRes = EgtCurveWithRegionClassify( vRibsIds[i], nSrfLink)
+         if nRes ~= GDB_CRC.OUT then
             return false
          end
       end
    end
+   
+   -- eventuale verifica con setti coinvolti dal link ( da fare solo se collegamento fra passate di setti diversi)
+   if bCheckLinked and dLen > 3 * dStrand then
+      -- regione occupata dai setti
+      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)
+      -- verifico che i tratti fuori abbiano lunghezza maggiore di quelli dentro
+      local nRes, nCnt = EgtTrimCurveWithRegion( nLinkLoc, nSrfRibs, false, false)
+      if nCnt == 0 then return false end
+      local dResLen = EgtCurveLength( nRes)
+      if dResLen < ( dLen - dResLen) - GEO.EPS_SMALL then
+         return false
+      end
+      
+      -- verifico non passi per estremo errato
+      local dParTest1 = EgtCurveParamAtPoint( nLinkId, EgtSP( nCurr, GDB_ID.ROOT), 100 * GEO.EPS_SMALL, GDB_RT.GLOB) 
+      local dParTest2 = EgtCurveParamAtPoint( nLinkId, EgtEP( nNext, GDB_ID.ROOT), 100 * GEO.EPS_SMALL, GDB_RT.GLOB) 
+      if dParTest1 or dParTest2 then
+         return false
+      end
+   end
+   
+   -- verifico se si trova nella regione ammissibile ( per caso ForcedLink)
+   local nSurfId = EgtGetInfo( nCurr, KEY_ASSOCIATED_SURF, 'i')
+   if nSurfId then
+      local nSrfLoc = EgtCopyGlob( nSurfId, nGrpTmp)
+      local nRes = EgtCurveWithRegionClassify( nLinkId, nSurfId)
+      local nType = EgtGetInfo( nCurr, KEY_RIBS_TYPE, 'i')
+      if nRes == GDB_CRC.INTERS or ( ( nType == RIB_TYPE.INTERNAL or nType == RIB_TYPE.SUPPORT) and nRes == GDB_CRC.OUT) or ( nType == RIB_TYPE.EXTERNAL and nRes == GDB_CRC.IN) then
+         return false
+      end
+   end
+   
    return true
 end
 
 --------------------------------------------------------------------
-local function CalcRibsLink( nCurr, nNext, nLoopGrp, dStrand, bForceLink, vtSlicing, nGrpTmp)
+local function CalcRibsLink( nCurr, nNext, nLoopGrp, dStrand, bForceLink, bCheckLinked, vtSlicing, nGrpTmp)
    
    local ptS = EgtEP( nCurr)
    local ptE = EgtSP( nNext)
-         
-   local nCrvId = EgtGetFirstNameInGroup( nLoopGrp, TRIM_SURF_LOOP)
+   
+   local nCrvId = EgtGetFirstInGroup( nLoopGrp)
    -- recupero la curva di offset su cui calcolare link
    while nCrvId do
       local dParS = EgtCurveParamAtPoint( nCrvId, ptS, 10 * GEO.EPS_SMALL)
       local dParE = EgtCurveParamAtPoint( nCrvId, ptE, 10 * GEO.EPS_SMALL)
       if dParS and dParE then
-         local bInvert = false
-         local bClosed = EgtCurveIsClosed( nCrvId)
-         if bClosed then
-            -- se la curva è chiusa verifico i due percorsi possibili dParS->dParE e dParE->dParS
-            local nCopyId1 = EgtCopyGlob( nCrvId, nCurr, GDB_IN.AFTER)
-            local nCopyId2 = EgtCopyGlob( nCrvId, nCurr, GDB_IN.AFTER)
-            EgtTrimCurveStartEndAtParam( nCopyId1, dParS, dParE)
-            EgtTrimCurveStartEndAtParam( nCopyId2, dParE, dParS)
-            EgtInvertCurve( nCopyId2)
-            
-            local dLen1 = EgtCurveLength( nCopyId1)
-            local dLen2 = EgtCurveLength( nCopyId2)
-            if dLen1 > dLen2 then
-               bInvert = true
-               dParS, dParE = dParE, dParS
-            end
+         
+         -- verifico i due percorsi possibili dParS->dParE e dParE->dParS
+         local nCopyId1 = EgtCopyGlob( nCrvId, nCurr, GDB_IN.AFTER)
+         local nCopyId2 = EgtCopyGlob( nCrvId, nCurr, GDB_IN.AFTER)
+         EgtTrimCurveStartEndAtParam( nCopyId1, dParS, dParE)
+         EgtTrimCurveStartEndAtParam( nCopyId2, dParE, dParS)
+         EgtInvertCurve( nCopyId2)
+         
+         local nLinkId
+         local dLen1 = EgtCurveLength( nCopyId1)
+         local dLen2 = EgtCurveLength( nCopyId2)
+         if dLen1 > dLen2 then
+            nLinkId = nCopyId2
             EgtErase( nCopyId1)
+         else
+            nLinkId = nCopyId1
             EgtErase( nCopyId2)
          end
          
-         local nCopyId = EgtCopyGlob( nCrvId, nLoopGrp)
-         local nLinkId = EgtCopyGlob( nCrvId, nCurr, GDB_IN.AFTER)
-         
-         if dParS > dParE and not bClosed then
-            bInvert = true 
-            dParS, dParE = dParE, dParS
-         end
-         
-         EgtTrimCurveStartEndAtParam( nLinkId, dParS, dParE)
          EgtSetInfo( nLinkId, KEY_TYPE, TYPE.RIB)
          EgtSetName( nLinkId, LINK_CRV)
          EgtModifyCurveExtrusion( nLinkId, vtSlicing, GDB_RT.GLOB)
-         if bInvert then EgtInvertCurve( nLinkId) end
+         
          -- verifico se è valido
-         local bValid = VerifyRibsLink( nLinkId, nCurr, nNext, dStrand, nGrpTmp)
-         if not bValid then 
-            EgtErase( nLinkId)
-            EgtErase( nCopyId)
-            return
-         end
-         
-         -- elimino dalle curve di contorno il link appena trovato
-         if bClosed then
-            EgtTrimCurveStartEndAtParam( nCrvId, dParE, dParS)
-            EgtErase( nCopyId)
+         local bValid = VerifyRibsLink( nLinkId, nCurr, nNext, dStrand, nGrpTmp, bCheckLinked)
+         if bValid then
+            return nLinkId
          else
-            if dParS < GEO.EPS_SMALL then
-               -- forzare la fine della curva nel suo inizio significa cancellarla completamente
-               EgtErase( nCrvId)
-            else
-               EgtTrimCurveEndAtParam( nCrvId, dParS)
-            end
-            
-            local _, dEnd = EgtCurveDomain( nCopyId)
-            if abs( dParE - dEnd) < GEO.EPS_SMALL then
-               -- forzare l'inizio della curva nella sua fine significa cancellarla completamente
-               EgtErase( nCopyId)
-            else
-               EgtTrimCurveStartAtParam( nCopyId, dParE)
-            end
+            EgtErase( nLinkId)
          end
-         
-         return nLinkId
       end
 
-      nCrvId = EgtGetNextName( nCrvId, TRIM_SURF_LOOP)
+      nCrvId = EgtGetNext( nCrvId)
    end
    
-   -- se non ho trovato un collegamento sul bordo, creo una linea tra ptS e ptE
+   -- 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})
-      local bValid = VerifyRibsLink( nLinkId, nCurr, nNext, dStrand, nGrpTmp)
+      EgtSetInfo( nLinkId, KEY_TYPE, TYPE.RIB)
+      EgtSetName( nLinkId, LINK_CRV)
+      EgtModifyCurveExtrusion( nLinkId, vtSlicing, GDB_RT.GLOB)
+      EgtRelocateGlob( nLinkId, nCurr, GDB_IN.AFTER)
+      local bValid = VerifyRibsLink( nLinkId, nCurr, nNext, dStrand, nGrpTmp, bCheckLinked)
       if bValid then
-         EgtSetInfo( nLinkId, KEY_TYPE, TYPE.RIB)
-         EgtSetName( nLinkId, LINK_CRV)
-         EgtModifyCurveExtrusion( nLinkId, vtSlicing, GDB_RT.GLOB)
-         EgtRelocateGlob( nLinkId, nCurr, GDB_IN.AFTER)
+         return nLinkId
       else
          EgtErase( nLinkId)
+         return
       end
    end
    
+   return
 end
 
 --------------------------------------------------------------------
 local function VerifyRibsLead( nId, nRibId, dStrand, bInVsOut, nGrpTmp)
-   
-   local nGrp = EgtGetParent( nRibId)
-   local nLeadId = EgtCopyGlob( nId, nGrp)
-   if bInVsOut then
-      EgtExtendCurveStartByLen( nLeadId, dStrand * 0.5)
-   else
-      EgtExtendCurveEndByLen( nLeadId, dStrand * 0.5)
-   end
 
-   -- verifico che intersechi solo l'estremo corretto
-   if not EgtCurveIsClosed( nRibId) then
-      local pt = EgtIf( bInVsOut, EgtEP(  nRibId), EgtSP( nRibId))
-      local dPar = EgtCurveParamAtPoint( nLeadId, pt)
-      if dPar then
-         EgtErase( nLeadId)
-         return false
+   local dLen = EgtCurveLength( nId)
+   if dLen < dStrand + GEO.EPS_SMALL then
+      return true
+   end
+   
+   -- regione occupata dal lead
+   local nLeadLoc = EgtCopyGlob( nId, nGrpTmp)
+   local nOverlap = EgtGetInfo( nRibId, KEY_RIBS_OVERLAP, 'i')
+   local nSrfLead = EgtSurfFrFatCurve( nGrpTmp, nId, dStrand * ( 1 - nOverlap / 100) - 100 * GEO.EPS_SMALL, false)
+   if not nSrfLead then
+      return false
+   end
+ 
+   -- individuo eventuale lead in o link relativo al setto corrente
+   local nCurrLI
+   local nCurrLink
+   if not bInVsOut then
+      local nPrev = EgtGetPrev( nRibId)
+      if nPrev and EgtGetName( nPrev) == LEAD_IN_CRV then 
+         nCurrLI = nPrev
+      elseif nPrev and EgtGetName( nPrev) == LINK_CRV then
+         nCurrLink = nPrev
       end
    end
    
-   local pt1 = EgtIf( bInVsOut, EgtSP( nLeadId), EgtEP( nLeadId))
-   local pt2 = EgtIf( bInVsOut, EgtEP( nRibId), EgtSP( nRibId))
-   if dist( pt1, pt2) < dStrand + GEO.EPS_SMALL then
-      EgtErase( nLeadId)
-      return false
+   -- verifico se interseca altri setti, lead in, lead out o collegamenti
+   local nCurrId = EgtGetFirstNameInGroup( EgtGetParent( nRibId), RIBS_CRV .. '*')
+   -- verifico se il primo setto ha lead in da controllare
+   local nPrevId = EgtGetPrev( nCurrId)
+   if nPrevId and EgtGetName( nPrevId) == LEAD_IN_CRV then nCurrId = nPrevId end
+   while nCurrId do
+      -- salto i i wipe ( non sono materiale depositato) e i tratti relativi al setto corrente
+      if not EgtStartsWith( EgtGetName( nCurrId), WIPE_CRV) and nCurrId ~= nCurrLI and nCurrId ~= nRibId and nCurrId ~= nId and nCurrId ~= nCurrLink then
+         local nRibLoc = EgtCopyGlob( nCurrId, nGrpTmp)
+         local nRes = EgtCurveWithRegionClassify( nRibLoc, nSrfLead)
+         if nRes ~= GDB_CRC.OUT then
+            return false
+         end
+      end
+      nCurrId = EgtGetNext( nCurrId)
    end
    
-   local _, dParE = EgtCurveDomain( nLeadId)
-   local vtDir = EgtMV( nRibId)
+   -- verifiche con il setto corrente
+   -- verifico non passi da altro estremo
+   local dParTest = EgtCurveParamAtPoint( nLeadLoc, EgtIf( bInVsOut, EgtEP( nRibId, GDB_ID.ROOT), EgtSP( nRibId, GDB_ID.ROOT)), 100 * GEO.EPS_SMALL, GDB_RT.GLOB)
+   if dParTest then
+      return false
+   end
+   -- verifico se tratti lineari paralleli al setto sono sufficientemente lontani
+   local _, dParE = EgtCurveDomain( nLeadLoc)
+   local nRibLoc = EgtCopyGlob( nRibId, nGrpTmp)
+   local vtDir = EgtMV( nRibLoc)
    local dParCrv = 1
    local dTol = 10 * GEO.EPS_SMALL 
    for dParCrv = 1, dParE do
-      local vtS = EgtUV( nLeadId, dParCrv - 1, 1)
-      local vtE = EgtUV( nLeadId, dParCrv, -1)
-      -- se tratto lineare allineato con la direzione del setto verifico sia sufficientemente lontano
-      if  AreSameVectorApprox( vtS, vtE) and ( (vtS - vtDir):sqlen() < dTol * dTol or (vtS + vtDir):sqlen() < dTol * dTol) then
-         local dDist = EgtPointCurveDist( EgtUP( nLeadId, dParCrv - 0.5), nRibId)
+      local vtS = EgtUV( nLeadLoc, dParCrv - 1, 1)
+      local vtE = EgtUV( nLeadLoc, dParCrv, -1)
+      local dTol = 10 * GEO.EPS_SMALL
+      if  AreSameVectorApprox( vtS, vtE) and ( (vtS - vtDir):sqlen() < dTol * dTol or ( vtS + vtDir):sqlen() < dTol * dTol) then
+         local dDist = EgtPointCurveDist( EgtUP( nLeadLoc, dParCrv - 0.5), nRibLoc)
+         EgtPoint( nGrpTmp, EgtUP( nLeadLoc, dParCrv - 0.5))
+         EgtCopyGlob( nLeadLoc, nGrpTmp)
          if dDist < dStrand + GEO.EPS_SMALL then
-            EgtErase( nLeadId)
             return false
          end
       end
    end
    
-   -- verifico non intersechi altri setti
-   local vRibsIds = EgtGetNameInGroup( EgtGetParent( nRibId), RIBS_CRV .. '*')
-   local nLeadLoc = EgtCopyGlob( nLeadId, nGrpTmp)
-   for i = 1, #vRibsIds do
-      if vRibsIds[i] ~= nRibId then
-         local nCrvLoc = EgtCopyGlob( vRibsIds[i], nGrpTmp)
-         local ptInt = EgtIP( nLeadLoc, nCrvLoc, ORIG())
-         if ptInt then
-            EgtErase( nLeadId)
-            return false
-         end
+   -- verifiche con eventuale lead in
+   if nCurrLI then
+      local nLeadInLoc = EgtCopyGlob( nCurrLI, nGrpTmp)
+      -- verifico se intersezione fra curve
+      local _, nPnt, nCrv = EgtCurveCurveInters( nLeadLoc, nLeadInLoc, nGrpTmp)
+      if nPnt ~= 0 or nCrv ~= 0 then
+         return false
       end
-   end
-   
-   -- se lead out verifico non si sovrapponga al lead in
-   if not bInVsOut then
-      -- recupero il lead in
-      local nPrev = EgtGetPrev( nRibId)
-      if nPrev and EgtGetName( nPrev) == LEAD_IN_CRV then
-         -- il caso critico è quando hanno direzioni opposte
-         local vtSPrev = EgtSV( nPrev, GDB_ID.ROOT)
-         local vtSCurr = EgtSV( nLeadId, GDB_ID.ROOT)
-         if AreOppositeVectorApprox( vtSPrev, vtSCurr) then
-            local nSrfTot = EgtSurfFrFatCurve( EgtGetParent( nLeadId), nPrev, 0.5 * dStrand, false)
-            if nSrfTot then
-               local nRes = EgtCurveWithRegionClassify( nLeadId, nSrfTot)
-               if nRes == GDB_CRC.IN or nRes == GDB_CRC.INTERS then
-                  EgtErase( nSrfTot)
-                  EgtErase( nLeadId)
-                  return false
-               end
-            else
-               nSrfTot = EgtSurfFrFatCurve( EgtGetParent( nLeadId), nLeadId, 0.5 * dStrand, false)
-               if nSrfTot then
-                  local nRes = EgtCurveWithRegionClassify( nPrev, nSrfTot)
-                  if nRes == GDB_CRC.IN or nRes == GDB_CRC.INTERS then
-                     EgtErase( nSrfTot)
-                     EgtErase( nLeadId)
-                     return false
-                  end
-               end
+      local dLeadInLen = EgtCurveLength( nLeadInLoc)
+      if dLeadInLen > dStrand + GEO.EPS_SMALL then
+         -- verifico di avere un solo tratto esterno di lunghezza sufficiente
+         local nRes, nCnt = EgtTrimCurveWithRegion( nLeadInLoc, nSrfLead, false, false)
+         if nCnt ~= 1 then
+            return false
+         else
+            local dLen = EgtCurveLength( nRes)
+            if dLen < dStrand / 2 + GEO.EPS_SMALL then
+               return false
             end
-            EgtErase( nSrfTot)
          end
       end
    end
-   
-   EgtErase( nLeadId)
+
    return true
 end
 
--------------------------------------------------------------------
-local function FindCorrectRibsLead( dPar, nCrv, nCrvOffs, bLeadInvert, dLeadLen, dStrand, bInVsOut, nGrpTmp)
+---------------------------------------------------------------------------------
+local function PrepareRibLead( nCrvOffs, nRib, bInvert, bInVsOut, dPar, dLeadLen)
+   
+   local nLeadId = EgtCopyGlob( nCrvOffs, nRib, EgtIf( bInVsOut, GDB_IN.BEFORE, GDB_IN.AFTER))
+   EgtChangeClosedCurveStart( nLeadId, dPar)
+   -- oriento in modo che la curva parta da nRib
+   if bInvert then
+      EgtInvertCurve( nLeadId)
+   end
+   EgtTrimCurveEndAtLen( nLeadId, dLeadLen)
+   if bInVsOut then
+      -- se lead in la curva deve terminare in nRib
+      EgtInvertCurve( nLeadId)
+   end
+   return nLeadId
+   
+end
+
+---------------------------------------------------------------------------------
+local function FindCorrectRibLead( dPar, nRib, nCrvOffs, bLeadInvert, dLeadLen, dStrand, bInVsOut, nGrpTmp, bSpecialCase)
    
    local nLeadId
-   local bInvert = bLeadInvert    -- valore di default è quello settato nel file dei parametri
+   local bInvert = bLeadInvert    -- valore di default è quello dei parametri
+   local bOnlyOneSide = false
+   local dParE
    
-   local _, dParEnd = EgtCurveDomain( nCrvOffs)
-   local bClosed = EgtCurveIsClosed( nCrvOffs)
-   local bOnlyOneCurve = not bClosed and ( dPar < GEO.EPS_SMALL or abs( dPar - dParEnd) < GEO.EPS_SMALL)
-         
-   local nMainCrv = nCrvOffs  -- curva preferita da utilizzare per lead in
-   local nOtherCrv            -- altra possibile curva da ultizzare nel caso nMainCrv non sia adatta
-
-   if bClosed then
-      EgtChangeClosedCurveStart( nCrvOffs, dPar)
-      nOtherCrv = nCrvOffs
-   elseif not bOnlyOneCurve then
-      nOtherCrv = EgtSplitCurveAtParam( nCrvOffs, dPar)
+   -- verifico se ho un solo lato possibile per la presenza di altre passate
+   local nOtherRib
+   if bSpecialCase then
+      local sName = EgtGetName( nRib)
+      local nFirst = EgtGetFirstNameInGroup( EgtGetParent( nRib), sName)
+      local nLast = EgtGetLastNameInGroup( EgtGetParent( nRib), sName)
+      if bInVsOut and nRib == nFirst then
+         nOtherRib = nLast
+      elseif not bInVsOut and nRib == nLast then
+         nOtherRib = nFirst
+      end
+   else
+      local nLinkId = EgtIf( bInVsOut, EgtGetNext( nRib), EgtGetPrev( nRib))
+      if nLinkId and EgtGetName( nLinkId) == LINK_CRV then
+         nOtherRib = EgtIf( bInVsOut, EgtGetNext( nLinkId), EgtGetPrev( nLinkId))
+         local nOrigRib1 = EgtGetInfo( nRib, KEY_ORIGINAL_RIB, 'i')
+         local nOrigRib2 = EgtGetInfo( nOtherRib, KEY_ORIGINAL_RIB, 'i')
+         if nOrigRib1 ~= nOrigRib2 then
+            nOtherRib = nil
+         end
+      end
    end
-         
-   -- calcolo del parametro bInvert
-   if bOnlyOneCurve then
-      -- invert dipende dall'estremo da cui parte il setto
-      bInvert = abs( dPar - dParEnd) < GEO.EPS_SMALL
-   elseif not bClosed then
-      -- invert può essere legato anche alla lunghezza dei tratti possibili
-      local dLen1 = EgtCurveLength( nMainCrv)
-      local dLen2 = EgtCurveLength( nOtherCrv)
-      if dLen1 > dLeadLen - GEO.EPS_SMALL and dLen2 < dLeadLen - GEO.EPS_SMALL then
-         bInvert = true
-      elseif dLen1 < dLeadLen - GEO.EPS_SMALL and dLen2 > dLeadLen - GEO.EPS_SMALL then
-         bInvert = false
-      end 
-      
-      if not bInvert then
-         nMainCrv, nOtherCrv = nOtherCrv, nMainCrv
+   if nOtherRib then
+      local ptOther = EgtIf( bInVsOut, EgtEP( nOtherRib, GDB_ID.ROOT), EgtSP( nOtherRib, GDB_ID.ROOT))
+      dParE = EgtCurveParamAtPoint( nCrvOffs, ptOther, 100 * GEO.EPS_SMALL, GDB_RT.GLOB)
+      if dParE then
+         bOnlyOneSide = true
       end
    end
    
-   -- primo tentativo con la curva favorita
-   nLeadId = EgtCopyGlob( nMainCrv, nCrv, EgtIf( bInVsOut, GDB_IN.BEFORE, GDB_IN.AFTER))
-   if bInvert then EgtInvertCurve( nLeadId) end
-   EgtTrimCurveEndAtLen( nLeadId, dLeadLen)
-   if bInVsOut then EgtInvertCurve( nLeadId) end
-   if VerifyRibsLead( nLeadId, nCrv, dStrand, bInVsOut, nGrpTmp) then
-      -- se valido aggiorno le curve per prossimi lead in/out
-      if bInvert then
-         EgtTrimCurveEndAtLen( nMainCrv, EgtCurveLength( nCrvOffs) - dLeadLen)
-      else
-         EgtTrimCurveStartAtLen( nMainCrv, dLeadLen)
-       end
-   elseif not nOtherCrv then
-      -- se non è valido e non ho altre curve possibili cancello
-      EgtErase( nLeadId)
-      return nil
+   -- se un solo lato possibile
+   if bOnlyOneSide then
+      
+      -- verifico a quale valore di bInvert corrisponde l'unico lato possibile
+      local nCopyId1 = EgtCopyGlob( nCrvOffs, nGrpTmp)
+      local nCopyId2 = EgtCopyGlob( nCrvOffs, nGrpTmp)
+      EgtTrimCurveStartEndAtParam( nCopyId1, dPar, dParE)
+      EgtTrimCurveStartEndAtParam( nCopyId2, dParE, dPar)
+      local dLen1 = EgtCurveLength( nCopyId1)
+      local dLen2 = EgtCurveLength( nCopyId2)
+      bInvert = dLen1 < dLen2
+      
+      nLeadId = PrepareRibLead( nCrvOffs, nRib, bInvert, bInVsOut, dPar, dLeadLen)
+      -- verifico se lead sensato
+      if not VerifyRibsLead( nLeadId, nRib, dStrand, bInVsOut, nGrpTmp) then
+         EgtErase( nLeadId)
+         return
+      end
+      
+   -- se due lati possibili
    else
-      -- se non è valido ma ho altra curva possibile, tento con quella
-      EgtErase( nLeadId)
-      nLeadId = EgtCopyGlob( nOtherCrv, nCrv, EgtIf( bInVsOut, GDB_IN.BEFORE, GDB_IN.AFTER))
-      if not bInvert then EgtInvertCurve( nLeadId) end
-      EgtTrimCurveEndAtLen( nLeadId, dLeadLen)
-      if bInVsOut then EgtInvertCurve( nLeadId) end
-      if VerifyRibsLead( nLeadId, nCrv, dStrand, bInVsOut, nGrpTmp) then
-         if bInvert then
-            EgtTrimCurveStartAtLen( nOtherCrv, dLeadLen)
-         else
-            EgtTrimCurveEndAtLen( nOtherCrv, EgtCurveLength( nCrvOffs) - dLeadLen)
-         end
-      else
+      -- primo tentativo nella direzione individuata dal parametro bInvert
+      nLeadId = PrepareRibLead( nCrvOffs, nRib, bInvert, bInVsOut, dPar, dLeadLen)
+      if not VerifyRibsLead( nLeadId, nRib, dStrand, bInVsOut, nGrpTmp) then
+         -- secondo tentativo nell'altra direzione
          EgtErase( nLeadId)
          bInvert = not bInvert
-         return nil
+         nLeadId = PrepareRibLead( nCrvOffs, nRib, bInvert, bInVsOut, dPar, dLeadLen)
+         if not VerifyRibsLead( nLeadId, nRib, dStrand, bInVsOut, nGrpTmp) then
+            EgtErase( nLeadId)
+            return
+         end
       end
-      -- aggiorno parametro bInvert
-      bInvert = not bInvert
    end
-
+   
    return nLeadId, bInvert
 end
 
 --------------------------------------------------------------------
-local function AddRibsLeadIn( nCrv, nLoopsGrp, dStrand, vtSlicing, nGrpTmp)
-  
+local function AddRibsLeadIn( nCrv, nLoopsGrp, dStrand, vtSlicing, nGrpTmp, bForceNoSolidBorder, bSpecialCase)
+   
    local dLILen = EgtGetInfo( nCrv, KEY_RIBS_LEAD_IN_LEN, 'd')
    local bLIInvert = EgtGetInfo( nCrv, KEY_RIBS_LEAD_IN_INVERT, 'b')
    
@@ -892,27 +898,30 @@ local function AddRibsLeadIn( nCrv, nLoopsGrp, dStrand, vtSlicing, nGrpTmp)
    
    -- recupero la curva di offset su cui calcolare leadin
    local ptS = EgtSP( nCrv)
-   local nCrvOffs = EgtGetFirstInGroup( nLoopsGrp)
-   while nCrvOffs do
-      local dParS = EgtCurveParamAtPoint( nCrvOffs, ptS)
+   local vCrvOffs = {}
+   if bForceNoSolidBorder then
+      vCrvOffs = EgtGetNameInGroup( nLoopsGrp, SURF_LOOP .. '*') or {}
+   else
+      vCrvOffs = EgtGetAllInGroup( nLoopsGrp) or {}
+   end
+   
+   for i = 1, #vCrvOffs do
+      local dParS = EgtCurveParamAtPoint( vCrvOffs[i], ptS)
       if dParS then
-
-         local nLeadIn = FindCorrectRibsLead( dParS, nCrv, nCrvOffs, bLIInvert, dLILen, dStrand, true, nGrpTmp)
+         local nLeadIn = FindCorrectRibLead( dParS, nCrv, vCrvOffs[i], bLIInvert, dLILen, dStrand, true, nGrpTmp, bSpecialCase)
          -- se lead in possibile
          if nLeadIn then
             EgtModifyCurveExtrusion( nLeadIn, vtSlicing, GDB_RT.GLOB)
             EgtSetInfo( nLeadIn, KEY_TYPE, TYPE.RIB)
             EgtSetName( nLeadIn, LEAD_IN_CRV)
+            return
          end
-         return
       end
-
-      nCrvOffs = EgtGetNext( nCrvOffs)
    end
 end
 
 --------------------------------------------------------------------
-local function AddRibsLeadOut( nCrv, nTPathGrp, nLoopsGrp, vtSlicing, dStrand, nGrpTmp, bForceNoBorder)
+local function AddRibsLeadOut( nCrv, nLoopsGrp, dStrand, vtSlicing, nGrpTmp, bForceNoSolidBorder, bSpecialCase)
    
    local dRibsLOLen = EgtGetInfo( nCrv, KEY_RIBS_LEAD_OUT_LEN, 'd')
    local dRibsLOCoasting = EgtGetInfo( nCrv, KEY_RIBS_LEAD_OUT_COASTING, 'd')
@@ -921,11 +930,11 @@ local function AddRibsLeadOut( nCrv, nTPathGrp, nLoopsGrp, vtSlicing, dStrand, n
    local bRibsLOInvert = EgtGetInfo( nCrv, KEY_RIBS_LEAD_OUT_INVERT, 'b')
    
    if abs( dRibsLOLen) < GEO.EPS_SMALL and
-      abs( dRibsLOCoasting) < GEO.EPS_SMALL and 
+      abs( dRibsLOCoasting) < GEO.EPS_SMALL and
       abs( dRibsLOWipe) < GEO.EPS_SMALL then return end
    
-   -- se setto chiuso oppure non deve stare sul bordo (rib unbounded) applico la stessa uscita delle shell
-   if EgtCurveIsClosed( nCrv) or bForceNoBorder then
+   -- se setto chiuso applico la stessa uscita delle shell
+   if EgtCurveIsClosed( nCrv) then
       return AddRetraction( nCrv, vtSlicing, dRibsLOCoasting, dRibsLOWipe, dRibsLOWipeAng)
    end
    
@@ -933,9 +942,15 @@ local function AddRibsLeadOut( nCrv, nTPathGrp, nLoopsGrp, vtSlicing, dStrand, n
    local vtE = EgtEV( nCrv, GDB_ID.ROOT)
 
    -- recupero la curva di offset su cui calcolare lead out
-   local nCrvOffs = EgtGetFirstInGroup( nLoopsGrp)
-   while nCrvOffs do
-      local dParE = EgtCurveParamAtPoint( nCrvOffs, ptE, GEO.EPS_SMALL, GDB_RT.GLOB)
+   local vCrvOffs = {}
+   if bForceNoSolidBorder then
+      vCrvOffs = EgtGetNameInGroup( nLoopsGrp, SURF_LOOP .. '*') or {}
+   else
+      vCrvOffs = EgtGetAllInGroup( nLoopsGrp) or {}
+   end
+
+   for i = 1, #vCrvOffs do
+      local dParE = EgtCurveParamAtPoint( vCrvOffs[i], ptE, GEO.EPS_SMALL, GDB_RT.GLOB)
       if dParE then
          
          local nCrvLO
@@ -943,15 +958,12 @@ local function AddRibsLeadOut( nCrv, nTPathGrp, nLoopsGrp, vtSlicing, dStrand, n
          local nWipe
          
          -- trovo curva opportuna per lead out
-         local nCrvRef, bInvert = FindCorrectRibsLead( dParE, nCrv, nCrvOffs, bRibsLOInvert, dRibsLOLen + dRibsLOCoasting, dStrand, false, nGrpTmp)
+         local nCrvRef, bInvert = FindCorrectRibLead( dParE, nCrv, vCrvOffs[i], bRibsLOInvert, dRibsLOLen + dRibsLOCoasting, dStrand, false, nGrpTmp, bSpecialCase)
    
          if nCrvRef then
-            -- verifico se la curva ha lunghezza sufficiente
-            local dLen = EgtCurveLength( nCrvRef)
-            local bSkip = ( dLen - dRibsLOLen - dRibsLOCoasting < - GEO.EPS_SMALL)
    
             -- primo tratto ( segue offset con flusso aperto)
-            if dRibsLOLen > GEO.EPS_SMALL and not bSkip then
+            if dRibsLOLen > GEO.EPS_SMALL then
                nCrvLO = EgtCopyGlob( nCrvRef, nCrv, GDB_IN.AFTER)
                EgtTrimCurveEndAtLen( nCrvLO, dRibsLOLen)
                EgtModifyCurveExtrusion( nCrvLO, vtSlicing, GDB_RT.GLOB)
@@ -986,21 +998,17 @@ local function AddRibsLeadOut( nCrv, nTPathGrp, nLoopsGrp, vtSlicing, dStrand, n
                if nType == RIB_TYPE.EXTERNAL then dAng = - dAng end
                vtE:rotate( vtSlicing, EgtIf( bInvert, - dAng, dAng))
                local ptFinal = FindWipeEndPoint( ptE, vtE, dRibsLOWipe, vtSlicing)
-               nWipe = EgtCurveCompoFromPoints( nTPathGrp, { ptE, ptFinal}, GDB_RT.GLOB)
+               nWipe = EgtCurveCompoFromPoints( EgtGetParent( nCrv), { ptE, ptFinal}, GDB_RT.GLOB)
                EgtModifyCurveExtrusion( nWipe, vtSlicing, GDB_RT.GLOB)
                EgtRelocateGlob( nWipe, nCoasting or nCrvLO or nCrv, GDB_IN.AFTER)
                EgtSetName( nWipe, WIPE_CRV)
                EgtSetInfo( nWipe, KEY_TYPE, TYPE.WIPE)
                EgtSetColor( nWipe, EgtStdColor('AQUA'))
             end
-         else
-            -- aggiungo coasting e wipe come sulle shell normali
-            AddRetraction( nCrv, vtSlicing, dRibsLOCoasting, dRibsLOWipe, dRibsLOWipeAng)
+            
+            return
          end
-         return
       end
-      
-      nCrvOffs = EgtGetNext( nCrvOffs)
    end
 
    -- se non ho trovato curva sul bordo su cui fare il lead out aggiungo coasting e wipe come sulle shell normali
@@ -1055,16 +1063,12 @@ local function CalcRibsToolPath( vEntIds, nRibsGrp, nTpathGrpId, LayerParams)
             local nOrig2 = EgtGetInfo( tabRibs[i][j + 1], KEY_ORIGINAL_RIB, 'i') or 0
             local nSplitId1 = EgtGetInfo( tabRibs[i][j], KEY_SPLIT_ID, 'i') or 0
             local nSplitId2 = EgtGetInfo( tabRibs[i][j + 1], KEY_SPLIT_ID, 'i') or 0
-            local bForceLink = ( nOrig1 == nOrig2)
+            local bForceLink = ( nOrig1 == nOrig2 and nSplitId1 == nSplitId2)
+            local bCheckLinkedRibs = not bForceLink and not bUserLink
             
             if ( nOrig1 ~= nOrig2 and bUserLink) or ( nSplitId1 == nSplitId2 and nOrig1 == nOrig2) then
-               local nLinkId = CalcRibsLink( tabRibs[i][j], tabRibs[i][j + 1], nLoopGrp, LayerParams.dStrand, bForceLink, LayerParams.vtSlicing, nGrpTmp)
-               -- creo link fittizio per eliminare tratto corrispondente sulla curva di offset
-               if not bSpecialCase and bForceLink then
-                  local nFakeLink = CalcRibsLink( tabRibs[i][j + 1], tabRibs[i][j], nLoopGrp, LayerParams.dStrand, false, LayerParams.vtSlicing, nGrpTmp)
-                  EgtErase( nFakeLink)
-               end
-               
+               local nLinkId = CalcRibsLink( tabRibs[i][j], tabRibs[i][j + 1], nLoopGrp, LayerParams.dStrand, bForceLink, bCheckLinkedRibs, LayerParams.vtSlicing, nGrpTmp)
+              
                -- se LoopRib congiungo i setti in unico percorso
                if bLoopRib and nLinkId then
                   EgtAddCurveCompoCurve( tabRibs[i][j], nLinkId)
@@ -1077,7 +1081,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 = CalcRibsLink( tabRibs[i][nTotCrv], tabRibs[i][1], nLoopGrp, LayerParams.dStrand, false, LayerParams.vtSlicing, nGrpTmp)
+            local nLinkId = CalcRibsLink( tabRibs[i][nTotCrv], tabRibs[i][1], nLoopGrp, LayerParams.dStrand, false, false, LayerParams.vtSlicing, nGrpTmp)
             if nLinkId then
                -- se curva unica
                if tabRibs[i][nTotCrv] == tabRibs[i][1] then
@@ -1097,11 +1101,6 @@ local function CalcRibsToolPath( vEntIds, nRibsGrp, nTpathGrpId, LayerParams)
                end
             end
          end
-         
-         if bSpecialCase then
-            local nFakeLink = CalcRibsLink( tabRibs[i][#tabRibs[i]], tabRibs[i][1], nLoopGrp, LayerParams.dStrand, false, LayerParams.vtSlicing, nGrpTmp)
-            EgtErase( nFakeLink)
-         end
       end
    end
    
@@ -1111,36 +1110,35 @@ local function CalcRibsToolPath( vEntIds, nRibsGrp, nTpathGrpId, LayerParams)
       local bLink2 = EgtGetInfo( tabRibs[i + 1][1], KEY_RIBS_LINK, 'b')
       if bLink1 and bLink2 then
          local nCnt = #tabRibs[i]
-         CalcRibsLink( tabRibs[i][nCnt], tabRibs[i + 1][1], nLoopGrp, LayerParams.dStrand, false, LayerParams.vtSlicing, nGrpTmp)
+         CalcRibsLink( tabRibs[i][nCnt], tabRibs[i + 1][1], nLoopGrp, LayerParams.dStrand, false, true, LayerParams.vtSlicing, nGrpTmp)
       end
    end
    
    -- leadin/leadout
-   local bForceNoBorder = false
+   local bForceNoSolidBorder = false
    local nType = EgtGetInfo( vEntIds[1], KEY_RIBS_TYPE, 'i')
    if nType == RIB_TYPE.UNBOUNDED then
-      bForceNoBorder = true
+      bForceNoSolidBorder = true
    end
    local nCrvRib = nNewFirstEnt
    while nCrvRib do
       -- verifico se necessario lead in
       local nPrev = EgtGetPrev( nCrvRib)
-      if ( not nPrev or EgtGetName( nPrev) ~= LINK_CRV) and not bForceNoBorder then
-         AddRibsLeadIn( nCrvRib, nLoopGrp, LayerParams.dStrand, LayerParams.vtSlicing, nGrpTmp)
+      if not nPrev or EgtGetName( nPrev) ~= LINK_CRV then
+         AddRibsLeadIn( nCrvRib, nLoopGrp, LayerParams.dStrand, LayerParams.vtSlicing, nGrpTmp, bForceNoSolidBorder, bSpecialCase)
       end
       -- verifico se necessario lead out
       local nNext = EgtGetNext( nCrvRib)
       if not nNext or EgtGetName( nNext) ~= LINK_CRV then
-         AddRibsLeadOut( nCrvRib, nTpathGrpId, nLoopGrp, LayerParams.vtSlicing, LayerParams.dStrand, nGrpTmp, bForceNoBorder)
+         AddRibsLeadOut( nCrvRib, nLoopGrp, LayerParams.dStrand, LayerParams.vtSlicing, nGrpTmp, bForceNoSolidBorder, bSpecialCase)
       end
       nCrvRib = EgtGetNextName( nCrvRib, RIBS_CRV .. '*')
    end
    
    EgtErase( nGrpTmp)
-   
 end
 
--------------------------------------------------------------------
+--------------------------------------------------------------------
 ------------------------- SPIRAL VASE ------------------------------
 --------------------------------------------------------------------
 local function AddSpiralVaseLeadOut( nOldId, LayerParams)

Version.lua

@@ -1,4 +1,4 @@
 -- Version.lua by Egaltech s.r.l. 2023/02/28
 -- Gestione della versione di 3dPrinting
 
-VERSION = '2.5d4'
+VERSION = '2.5e2'