- gestito calcolo F e S con strand di differente larghezza

- sistemata gestione degli strand variabili con valore nullo.

.vscode/settings.json

@@ -0,0 +1,34 @@
+{
+    "Lua.diagnostics.globals": [
+        "MATERIAL",
+        "EgtGetFirstNameInGroup",
+        "GDB_ID",
+        "EgtGroup",
+        "EgtSetLevel",
+        "EgtSetName",
+        "GDB_LV",
+        "EgtGetCurrMachineDir",
+        "EgtGetCurrMachineName",
+        "EgtGetStringFromIni",
+        "EgtGetFirstPart",
+        "EgtGetInfo",
+        "EgtGetNextPart",
+        "EgtGetLastNameInGroup",
+        "EgtRemoveInfo",
+        "EgtGetFirstInGroup",
+        "EgtGetName",
+        "EgtCurveLength",
+        "EgtGetNext",
+        "EgtCurveArea",
+        "EgtGetNextName",
+        "EgtSetInfo",
+        "floor",
+        "pi",
+        "pow",
+        "EgtProcessEvents",
+        "EgtEmptyGroup",
+        "EgtOutLog",
+        "EgtIf",
+        "EgtProtectGlobal"
+    ]
+}

LuaLibs/AddManData.lua

@@ -172,6 +172,7 @@ KEY_SPEED_MIN = "SpeedMin"
 KEY_SPEED_MAX = "SpeedMax"
 
 -- Altre chiavi
+KEY_MAX_H = "SlicingHeight"
 KEY_SLICE_NBR = "SliceNbr"
 KEY_SLICE_Z = "SliceZ"
 KEY_SLICE_DELTAZ = "DeltaZ"
@@ -194,6 +195,7 @@ KEY_INTERNAL_SRF_LOOP = "InternalSrfLoop"
 KEY_PREV_CRV = "PrevCrv"
 KEY_NEXT_CRVS = "NextCrvs"
 KEY_CRV_STRAND = "CurveStrand"
+KEY_LAYER_CNT = "LayerCnt"
 
 SLICING_TYPE = {
    VERTICAL = 1,

LuaLibs/CalcPaths.lua

@@ -25,6 +25,7 @@ local function GetLayerParamsForPathCalc()
    LayerParams.nShellsNbr = EgtGetInfo( s_nPartId, KEY_SHELLS_NBR, 'i')
    LayerParams.dStrand = EgtGetInfo( s_nPartId, KEY_STRAND, 'd')
    LayerParams.dInnerStrand = EgtGetInfo( s_nPartId, KEY_INNER_STRAND, 'd') or LayerParams.dStrand
+   if LayerParams.dInnerStrand < GEO.EPS_SMALL then LayerParams.dInnerStrand = LayerParams.dStrand end
    LayerParams.dLayHeight = EgtGetInfo( s_nPartId, KEY_SLICE_STEP, 'd')
    LayerParams.dStrandOverlap = EgtGetInfo( s_nPartId, KEY_STRAND_OVERLAP, 'd') or 0
    LayerParams.dOffs = EgtGetInfo( s_nPartId, KEY_OFFSET_SLICE, 'd')
@@ -44,6 +45,7 @@ local function GetLayerParamsForPathCalc()
    LayerParams.nCeilType = EgtGetInfo( s_nPartId, KEY_CEIL_TYPE, 'i') or FILL_TYPE.OFFSET
    -- parametri infill
    LayerParams.dInfillStrand = EgtGetInfo( s_nPartId, KEY_INFILL_STRAND, 'd') or LayerParams.dStrand
+   if LayerParams.dInfillStrand < GEO.EPS_SMALL then LayerParams.dInfillStrand = LayerParams.dStrand end
    LayerParams.bInfillLink = EgtGetInfo( s_nPartId, KEY_INFILL_LINK, 'b') or false
    LayerParams.dInfillOverlap = EgtGetInfo( s_nPartId, KEY_INFILL_OVERLAP, 'd') or 0
    LayerParams.nInfillType = EgtGetInfo( s_nPartId, KEY_INFILL_TYPE, 'i') or FILL_TYPE.NONE
@@ -1719,6 +1721,122 @@ local function HandleRibsIntersections( nRibsGrp, nOffsGrp, nRibsPathGrp, vtSlic
    return bInters, bSpecialCase
 end
 
+---------------------------------------------------------------------
+local function VerifySplitAssociation( nRib1, nRib2, dStrand)
+   
+   local dDist1 = EgtPointCurveDist( EgtMP( nRib1), nRib2)
+   local dDist2 = EgtPointCurveDist( EgtMP( nRib2), nRib1)
+   -- verifico siano sufficientemente vicini
+   if dDist1 < dStrand + 10 * GEO.EPS_SMALL or dDist2 < dStrand + 10 * GEO.EPS_SMALL then
+      
+      -- verifico nel caso di setti splittati dopo il trim che siano compatibili
+      local bUserLink = EgtGetInfo( nRib2, KEY_RIBS_USER_LINK, 'b') or false
+      local bSplitAfterTrim1 = EgtGetInfo( nRib1, KEY_SPLIT_AFTER_TRIM, 'b') or false
+      local bSplitAfterTrim2 = EgtGetInfo( nRib2, KEY_SPLIT_AFTER_TRIM, 'b') or false
+      if bSplitAfterTrim1 ~= bSplitAfterTrim2 then
+         if not bSplitAfterTrim2 and bSplitAfterTrim1 then
+            local nOrd = EgtGetInfo( nRib2, KEY_SPLIT_AFTER_TRIM_ORDER, 'i')
+            if nOrd == 0 then
+               return true
+            end
+         end
+         if bSplitAfterTrim1 then
+            local nOrd = EgtGetInfo( nRib1, KEY_SPLIT_AFTER_TRIM_ORDER, 'i')
+            local nTot = EgtGetInfo( nRib1, KEY_SPLIT_AFTER_TRIM_TOT, 'i')
+            if nOrd == nTot - 1 then
+               return true
+            end
+         end
+      else
+         return true
+      end
+   end
+   
+   return false
+end
+
+---------------------------------------------------------------------
+local function FindAssociatedSplitRibs( vRibs, dStrand)
+   
+   local vAssociatedRibs = {}
+   
+   -- vettore di flag per indicare se corrispondente elemento di vRibs è già stato associato ad un gruppo
+   local vUsed = {}
+   for i = 1, #vRibs do
+      vUsed[i] = false
+   end
+   
+   local nCurrId = vRibs[1]
+   vUsed[1] = true
+   while nCurrId do
+      -- definisco un nuovo gruppo di setti associati
+      local vCurrGrp = { nCurrId}
+      local bFound = true
+      while bFound do
+         -- appena aggiungo un nuovo elemento al gruppo riparto a controllare tutti i setti non ancora associati per vedere quale posso aggiungere
+         bFound = false
+         for i = 2, #vRibs do
+            if bFound then break end
+            if not vUsed[i] then
+               for j = 1, #vCurrGrp do
+                  if VerifySplitAssociation( vCurrGrp[j], vRibs[i], dStrand) then
+                     bFound = true
+                     table.insert( vCurrGrp, vRibs[i])
+                     vUsed[i] = true
+                     break
+                  end
+               end
+            end
+         end
+      end
+      -- quando non ho più setti da aggiungere al gruppo corrente
+      -- riordino il gruppo appena individuato
+      if #vCurrGrp == 2 then
+         -- lascio l'ordinamento 1,2
+         EgtRelocateGlob( vCurrGrp[2], vCurrGrp[1], GDB_IN.AFTER)
+      
+      elseif #vCurrGrp > 2 then
+         -- calcolo ordinamento ottimale con shorest path
+         EgtSpInit()
+         for i = 1, #vCurrGrp do
+            local ptS = EgtSP( vCurrGrp[i], GDB_ID.ROOT)
+            local ptE = EgtEP( vCurrGrp[i], GDB_ID.ROOT)
+            EgtSpAddPoint( ptS:getX(), ptS:getY(), ptS:getZ(), 0, 0, ptE:getX(), ptE:getY(), ptE:getZ(), 0, 0)
+         end
+         local vOrd = EgtSpCalculate( SHP_TY.OPEN)
+         EgtSpTerminate()
+         local vNewOrd = {}
+         for i = 1, #vOrd do
+            table.insert( vNewOrd, vCurrGrp[vOrd[i]])
+         end
+         -- riposiziono il primo elemento ( solo se è cambiato)
+         if vOrd[1] ~= 1 then
+            EgtRelocateGlob( vNewOrd[1], vCurrGrp[1], GDB_IN.AFTER)
+         end
+         -- riposiziono gli altri elementi
+         for i = 2, #vNewOrd do
+            EgtRelocateGlob( vNewOrd[i], vNewOrd[i-1], GDB_IN.AFTER)
+         end
+         vCurrGrp = vNewOrd
+      end
+      
+      -- inserisco nella tabella il gruppo trovato
+      table.insert( vAssociatedRibs, vCurrGrp)
+      
+      -- cerco il prossimo setto per un nuovo gruppo
+      nCurrId = nil
+      for i = 1, #vRibs do
+         if not vUsed[i] then
+            nCurrId = vRibs[i]
+            vUsed[i] = true
+            break
+         end
+      end
+   end
+
+   return vAssociatedRibs
+end
+
 ---------------------------------------------------------------------
 local function ReorderSplitRibs( vIds, bParamInvertOrder)
    
@@ -1756,58 +1874,8 @@ local function ReorderSplitRibs( vIds, bParamInvertOrder)
          
          else
             -- associo le curve dello split
-            local tAssociatedRibs = {}
-            while #tabVal > 0 do
-               local nCurrId = tabVal[1]
-               table.remove( tabVal, 1)
-               table.insert( tAssociatedRibs, { nCurrId})
-               local bCurrSplitAfterTrim = EgtGetInfo( nCurrId, KEY_SPLIT_AFTER_TRIM, 'b') or false
-               while nCurrId do
-                  local ptCurr = EgtMP( nCurrId)
-                  local bFound = false
-                  for j = 1, #tabVal do
-                     local dDist1 = EgtPointCurveDist( ptCurr, tabVal[j])
-                     local dDist2 = EgtPointCurveDist( EgtMP( tabVal[j]), nCurrId)
-                     if dDist1 < dStrand + 10 * GEO.EPS_SMALL or dDist2 < dStrand + 10 * GEO.EPS_SMALL then
-                        
-                        -- verifico nel caso di setti splittati dopo il trim che siano compatibili
-                        local bUserLink = EgtGetInfo( tabVal[j], KEY_RIBS_USER_LINK, 'b') or false
-                        local bSplitAfterTrim = EgtGetInfo( tabVal[j], KEY_SPLIT_AFTER_TRIM, 'b') or false
-                        if bSplitAfterTrim ~= bCurrSplitAfterTrim then
-                           if not bCurrSplitAfterTrim and bSplitAfterTrim then
-                              local nOrd = EgtGetInfo( tabVal[j], KEY_SPLIT_AFTER_TRIM_ORDER, 'i')
-                              if nOrd == 0 then
-                                 bFound = true
-                              end
-                           end
-                           if bCurrSplitAfterTrim then
-                              local nOrd = EgtGetInfo( nCurrId, KEY_SPLIT_AFTER_TRIM_ORDER, 'i')
-                              local nTot = EgtGetInfo( nCurrId, KEY_SPLIT_AFTER_TRIM_TOT, 'i')
-                              if nOrd == nTot - 1 then
-                                 bFound = true
-                              end
-                           end
-                        else
-                           bFound = true
-                        end
-                        
-                        if bFound then
-                           EgtRelocateGlob( tabVal[j], nCurrId, GDB_IN.AFTER)
-                           nCurrId = tabVal[j]
-                           bCurrSplitAfterTrim = bSplitAfterTrim
-                           table.remove( tabVal, j)
-                           table.insert( tAssociatedRibs[#tAssociatedRibs], nCurrId)
-                           break
-                        end
-                     end
-                  end
-                  
-                  if not bFound then
-                     nCurrId = nil
-                  end
-               end
-            end
-            
+            local tAssociatedRibs = FindAssociatedSplitRibs( tabVal, dStrand)
+
             -- assegno splitid per gestire correttamente il link nel CalcToolPath
             for i = 1, #tAssociatedRibs do
                for j = 1, #tAssociatedRibs[i] do
@@ -1837,9 +1905,7 @@ local function ReorderSplitRibs( vIds, bParamInvertOrder)
                   
                else
                   -- ordinamento
-                  if ( nTotParts % 2 == 0 and bInvertOrder and nLinkOrder % 2 ~= 0 ) or
-                     ( nTotParts % 2 == 0 and not bInvertOrder and nLinkOrder % 2 == 0) or
-                     ( nTotParts % 2 ~= 0 and nLinkOrder % 2 == 0) then
+                  if ( bInvertOrder and nLinkOrder % 2 ~= 0 ) or ( not bInvertOrder and nLinkOrder % 2 == 0) then
                      local vLastGrp = tAssociatedRibs[#tAssociatedRibs]
                      local nPrevId = vLastGrp[#vLastGrp]
                      for i = #tAssociatedRibs - 1, 1, -1 do
@@ -1853,8 +1919,7 @@ local function ReorderSplitRibs( vIds, bParamInvertOrder)
                   
                   -- direzione
                   if ( nTotParts % 2 == 0 and nLinkOrder > 0 and nLinkOrder < nTotParts - 1) or
-                     ( nTotParts % 2 ~= 0 and not bInvertOrder and nLinkOrder > 0) or
-                     ( nTotParts % 2 ~= 0 and bInvertOrder and nLinkOrder < nTotParts - 1) then
+                     ( nTotParts % 2 ~= 0 and nLinkOrder > 0) then
                      local vLastGrp = tAssociatedRibs[#tAssociatedRibs]
                      for j = 1, #vLastGrp do
                         EgtInvertCurve( vLastGrp[j])
@@ -2577,7 +2642,9 @@ end
 
 ---------------------------------------------------------------------
 local function ReorderExtraShells( nPathGrp, vPtStart, LayerParams)
-  
+   
+   local dAlpha = 1.2
+   
    -- verifico se posso unire due tratti consecutivi della stessa shell
    local nFirst = EgtGetFirstNameInGroup( nPathGrp, EXTRA_SHELL_CRV .. '*')
    while nFirst do
@@ -2588,7 +2655,7 @@ local function ReorderExtraShells( nPathGrp, vPtStart, LayerParams)
       local dStrand = EgtIf( nType == TYPE.EXTRA_OUTER_SHELL, LayerParams.dStrand, LayerParams.dInnerStrand)
       local nCurr = vShells[1]
       for i = 2, #vShells do
-         if dist( EgtEP( nCurr), EgtSP( vShells[i])) < dStrand + GEO.EPS_SMALL then
+         if dist( EgtEP( nCurr), EgtSP( vShells[i])) < dAlpha * dStrand + GEO.EPS_SMALL then
             -- unisco le curve
             EgtAddCurveCompoLine( nCurr, EgtSP( vShells[i]))
             EgtAddCurveCompoCurve( nCurr, vShells[i])
@@ -2597,7 +2664,7 @@ local function ReorderExtraShells( nPathGrp, vPtStart, LayerParams)
          end
       end
       -- check su prima e ultima curva
-      if nCurr ~= nFirst and dist( EgtEP( nCurr), EgtSP( nFirst)) < dStrand + GEO.EPS_SMALL then
+      if nCurr ~= nFirst and dist( EgtEP( nCurr), EgtSP( nFirst)) < dAlpha * dStrand + GEO.EPS_SMALL then
          -- unisco le curve
          EgtAddCurveCompoLine( nCurr, EgtSP( nFirst))
          EgtAddCurveCompoCurve( nCurr, nFirst)
@@ -2607,7 +2674,7 @@ local function ReorderExtraShells( nPathGrp, vPtStart, LayerParams)
       vShells = EgtGetNameInGroup( nPathGrp, sName)
       for i = 1, #vShells do
          if not EgtCurveIsClosed( vShells[i]) then
-            if dist( EgtSP( vShells[i]), EgtEP( vShells[i])) < dStrand + GEO.EPS_SMALL then
+            if dist( EgtSP( vShells[i]), EgtEP( vShells[i])) < dAlpha * dStrand + GEO.EPS_SMALL then
                EgtCloseCurveCompo( vShells[i])
             end
          end
@@ -2628,38 +2695,42 @@ local function ReorderExtraShells( nPathGrp, vPtStart, LayerParams)
    end
 
    -- cerco di creare percorsi
-   local k = 0   -- indice da utilizzare per i nomi
-   while #vIds > 0 do
-      k = k + 1
-      -- prendo la prima tra le curve a disposizione
-      local nCurrCrv = vIds[1]
-      table.remove( vIds, 1)
-      EgtSetName( nCurrCrv, EXTRA_SHELL_CRV .. tostring(k))
-
+   local k = 1 -- indice da utilizzare per i nomi
+   local vUsed = {} -- flag per indicare se corrispondente elemento di vIds è già stato considerato
+   for i = 1, #vIds do
+      vUsed[i] = false
+   end
+   
+   local nCurr = vIds[1]
+   vUsed[1] = true
+   EgtSetName( nCurr, EXTRA_SHELL_CRV .. tostring(k))
+   while nCurr do
+      local bEndChain = false
       local nCnt = 0
-      -- se curva è chiusa
-      if EgtCurveIsClosed( nCurrCrv) then
-         ModifyStartPoint( nCurrCrv, vPtStart)
-         -- setto a nil per ripartire subito con curva successiva
-         nCurrCrv = nil
+      local vLinkedShells = { nCurr}
+      local dCurrStrand
+      local bSameStrand = true
+      
+      if EgtCurveIsClosed( nCurr) then
+         ModifyStartPoint( nCurr, vPtStart)
+         -- se è chiusa costituisce già una catena
+         bEndChain = true
       end
       
-      -- scorro alla ricerca di una curva che posso collegare alla corrente
-      while nCurrCrv do
-         local ptSCurr = EgtSP( nCurrCrv)
-         local ptECurr = EgtEP( nCurrCrv)
+      while not bEndChain do
+         local ptSCurr = EgtSP( nCurr)
+         local ptECurr = EgtEP( nCurr)
+         local nCurrType = EgtGetInfo( nCurr, KEY_TYPE, 'i')
+         dCurrStrand = EgtIf( nCurrType == TYPE.EXTRA_OUTER_SHELL, LayerParams.dStrand, LayerParams.dInnerStrand)
+         
          local bFound = false
-         local nCurrType = EgtGetInfo( nCurrCrv, KEY_TYPE, 'i')
-         local dCurrStrand = EgtIf( nCurrType == TYPE.EXTRA_OUTER_SHELL, LayerParams.dStrand, LayerParams.dInnerStrand)
          for j = 1, #vIds do
- 
-            if not EgtCurveIsClosed( vIds[j]) then
+            if not vUsed[j] and not EgtCurveIsClosed( vIds[j]) then
                local ptS = EgtSP( vIds[j])
                local ptE = EgtEP( vIds[j])
-               
                local nTypeJ = EgtGetInfo( vIds[j], KEY_TYPE, 'i')
                local dStrandJ = EgtIf( nTypeJ == TYPE.EXTRA_OUTER_SHELL, LayerParams.dStrand, LayerParams.dInnerStrand)
-               local dVal = 1.5 * max( dCurrStrand, dStrandJ)
+               local dVal = dAlpha * max( dCurrStrand, dStrandJ)
                
                local bLink = false
                if dist( ptECurr, ptE) < dVal then
@@ -2672,30 +2743,60 @@ local function ReorderExtraShells( nPathGrp, vPtStart, LayerParams)
                   bLink = true
                elseif nCnt == 0 and dist( ptSCurr, ptS) < dVal then
                   -- congiungo start-start
-                  EgtInvertCurve( nCurrCrv)
-                  UpdateInvertInfo( nCurrCrv)
+                  EgtInvertCurve( nCurr)
+                  UpdateInvertInfo( nCurr)
                   bLink = true
                end
                
                if bLink then
                   nCnt = nCnt + 1
-                  EgtRelocateGlob( vIds[j], nCurrCrv, GDB_IN.AFTER)
+                  EgtRelocateGlob( vIds[j], nCurr, GDB_IN.AFTER)
                   EgtSetName( vIds[j], EXTRA_SHELL_CRV .. tostring( k))
+                  table.insert( vLinkedShells, vIds[j])
+                  if abs( dStrandJ - dCurrStrand) > GEO.EPS_SMALL then
+                     bSameStrand = false
+                  end
                   
                   -- aggiorno per collegamento successivo
                   bFound = true
-                  nCurrCrv = vIds[j]
-                  table.remove( vIds, j)
+                  nCurr = vIds[j]
+                  vUsed[j] = true
                   break
                end
             end
          end
-         -- se non ho più curve da collegare
-         if not bFound then
-            nCurrCrv = nil
+         
+         -- se non ho trovato setti da collegare la catena è finita, altrimenti posso cercare successivo
+         bEndChain = not bFound
+      end
+
+      -- verifico se posso unire tutti i tratti appena trovati
+      if #vLinkedShells > 1 and bSameStrand and EgtGetInfo( vLinkedShells[1], KEY_TYPE, 'i') == TYPE.EXTRA_OUTER_SHELL and
+            dist( EgtSP( vLinkedShells[1]), EgtEP( vLinkedShells[#vLinkedShells])) < dAlpha * dCurrStrand + GEO.EPS_SMALL then
+         -- unisco le curve
+         for i = 2, #vLinkedShells do
+            EgtAddCurveCompoLine( vLinkedShells[1], EgtSP( vLinkedShells[i]))
+            EgtAddCurveCompoCurve( vLinkedShells[1], vLinkedShells[i])
+         end
+         EgtCloseCurveCompo( vLinkedShells[1])
+
+         ModifyStartPoint( vLinkedShells[1], vPtStart)
+         EgtSetInfo( vLinkedShells[1], KEY_CLOSED_CRV, true)
+      end
+         
+      -- cerco il prossimo da cui partire
+      nCurr = nil
+      for i = 1, #vIds do
+         if not vUsed[i] then
+            nCurr = vIds[i]
+            vUsed[i] = true
+            k = k + 1
+            EgtSetName( nCurr, EXTRA_SHELL_CRV .. tostring(k))
+            break
          end
       end
    end
+   
 end
 
 --------------------------------------------------------------------
@@ -2772,6 +2873,14 @@ local function CalcExtraShellsPath( nMaxShellNbrDiff, nShellNbrGrp, nCrvGrpId, d
                   
                   local nCrv, nCnt = EgtTrimCurveWithRegion( nCrvOffs, nTrimSurf, true, true)
                   if nCrv and nCnt ~= 0 then
+                     -- verifico se posso unire primo e ultimo tratto
+                     if nCrv and nCnt > 1 and AreSamePointApprox( EgtEP( nCrv + nCnt - 1), EgtSP( nCrv)) then
+                        EgtRelocateGlob( nCrv + nCnt - 1, nCrv, GDB_IN.AFTER)
+                        EgtAddCurveCompoCurve( nCrv + nCnt - 1, nCrv)
+                        EgtChangeId( nCrv + nCnt - 1, nCrv)
+                        nCnt = nCnt - 1
+                     end
+                     
                      for nId = nCrv, nCrv + nCnt - 1 do
                         local dLen = EgtCurveLength( nId)
                         local bValid = true

LuaLibs/CalcSlices.lua

@@ -1,4 +1,4 @@
--- CalcSlices.lua by Egaltech s.r.l. 2022/10/12
+-- CalcSlices.lua by Egaltech s.r.l. 2023/08/28
 -- Calcolo percorsi di lavoro per Stampa 3d
 
 -- Tabella per definizione modulo
@@ -37,7 +37,12 @@ local function ComputeZSlices( dSliceStep, dZmin, dDeltaZ, dZmax)
 end
 
 --------------------------------------------------------------------
-local function ComputeMaxH( vIds, frSlicing, HMax, dSliceStep)
+local function ComputeMaxH( vIds, frSlicing, dSliceStep)
+   
+   local HMax = EgtGetInfo( s_nPartId, KEY_MAX_H, 'd') or GEO.INFINITO
+   if HMax < GEO.EPS_SMALL then
+      HMax = GEO.INFINITO
+   end
    
    -- calcolo il box globale
    local b3BoxGlob = BBox3d()
@@ -99,6 +104,9 @@ local function GetRibParams( nId)
 
    local RibParam = {}
    ReadParam( nId, KEY_RIBS_STRAND, 'd', s_dStrand, RibParam)
+   if RibParam[KEY_RIBS_STRAND] < GEO.EPS_SMALL then
+      RibParam[KEY_RIBS_STRAND] = s_dStrand
+   end
    ReadParam( nId, KEY_RIBS_SHELLS_NBR, 'i', 0, RibParam)
    ReadParam( nId, KEY_RIBS_INVERT_DIR, 'b', false, RibParam)
    ReadParam( nId, KEY_RIBS_LEAD_IN_INVERT, 'b', false, RibParam)
@@ -133,6 +141,9 @@ local function GetAuxSolidsParams( nId)
    
    local AuxSolidsParam = {}
    ReadParam( nId, KEY_AUX_SOLIDS_STRAND, 'd', s_dStrand, AuxSolidsParam)
+   if AuxSolidsParam[KEY_AUX_SOLIDS_STRAND] < GEO.EPS_SMALL then
+      AuxSolidsParam[KEY_AUX_SOLIDS_STRAND] = s_dStrand
+   end
    ReadParam( nId, KEY_AUX_SOLIDS_SHELLS_NBR, 'i', 0, AuxSolidsParam)
    ReadParam( nId, KEY_AUX_SOLIDS_OVERLAP, 'd', 0, AuxSolidsParam)
    ReadParam( nId, KEY_AUX_SOLIDS_INFILL, 'i', FILL_TYPE.NONE, AuxSolidsParam)
@@ -624,6 +635,9 @@ local function PrepareInfill( nStmId, vtSlicing)
    local dGridOverlap = EgtGetInfo( s_nPartId, KEY_INFILL_GRID_OVERLAP, 'd') or 0
    local dOffsStm = EgtGetInfo( s_nPartId, KEY_OFFSET_SLICE, 'd')
    local dStrand = EgtGetInfo( s_nPartId, KEY_INFILL_STRAND, 'd') or s_dStrand
+   if dStrand < GEO.EPS_SMALL then
+      dStrand = s_dStrand
+   end
    
    -- creo gruppo per infill
    local nInfillGrp = EgtGroup( s_nPartId)
@@ -657,6 +671,9 @@ local function PrepareAuxSolidsInfill( nSolidsLay, vtSlicing)
                local dOffsY = ReadParam( vIds[i], KEY_AUX_SOLIDS_OFFSET_Y, 'd', 0)
                local dGridOverlap = ReadParam( vIds[i], KEY_AUX_SOLIDS_GRID_OVERLAP, 'd', 0)
                local dStrand = ReadParam( vIds[i], KEY_AUX_SOLIDS_STRAND, 'd', s_dStrand)
+               if dStrand < GEO.EPS_SMALL then
+                  dStrand = s_dStrand
+               end
                
                -- creo gruppo associato
                local nInfillGrp = EgtGroup( s_nPartId)
@@ -1056,17 +1073,23 @@ local function SlicingWithSolid( nStmId, vZSlices, dDeltaZStart, dZmin, frSlicin
 end
 
 ---------------------------------------------------------------------
-function CalcSlices.Exec( nPartId, nStmId, HMax)
+function CalcSlices.Exec( nPartId, nStmId)
 
    s_nPartId = nPartId
 
+   local sMachIni = EgtGetCurrMachineDir() .. '\\' .. EgtGetCurrMachineName() .. '.ini'
+
    -- recupero la direzione dello slicing
    local vtSlicing = Z_AX()
    local nSlicingType = EgtGetInfo( s_nPartId, KEY_SLICING_TYPE, 'i')
    if nSlicingType == SLICING_TYPE.DEG45_X then
-      vtSlicing =  VectorFromSpherical( 1, 45, 0)
+      local nDir = EgtGetNumberFromIni( '3dPrinting', 'Dir45degX', 0, sMachIni)
+      local dHorAng = EgtIf( nDir == -1, 180, 0)
+      vtSlicing =  VectorFromSpherical( 1, 45, dHorAng)
    elseif nSlicingType == SLICING_TYPE.DEG45_Y then
-      vtSlicing = VectorFromSpherical( 1, 45, -90)
+      local nDir = EgtGetNumberFromIni( '3dPrinting', 'Dir45degY', 0, sMachIni)
+      local dHorAng = EgtIf( nDir == 2, 90, -90)
+      vtSlicing = VectorFromSpherical( 1, 45, dHorAng)
    elseif nSlicingType == SLICING_TYPE.HORIZONTAL then
       vtSlicing = X_AX()
    end
@@ -1115,7 +1138,7 @@ function CalcSlices.Exec( nPartId, nStmId, HMax)
 
    local dZmin = b3Box:getMin():getZ()
    local dZmax = b3Box:getMax():getZ()
-   local dMaxH = ComputeMaxH( vRefIds, frSlicing, HMax, dSliceStep)
+   local dMaxH = ComputeMaxH( vRefIds, frSlicing, dSliceStep)
    dZmax = min( dZmax, dMaxH)
    --dZmin = 708
    --dZmax = 712

LuaLibs/CalcToolPath.lua

@@ -23,6 +23,7 @@ local function GetLayerParamsForToolPathCalc()
    LayerParams.bSpiralVase = EgtGetInfo( s_nPartId, KEY_SPIRAL_VASE, 'b') or false
    LayerParams.dStrand = EgtGetInfo( s_nPartId, KEY_STRAND, 'd')
    LayerParams.dInnerStrand = EgtGetInfo( s_nPartId, KEY_INNER_STRAND, 'd') or LayerParams.dStrand
+   if LayerParams.dInnerStrand < GEO.EPS_SMALL then LayerParams.dInnerStrand = LayerParams.dStrand end
    LayerParams.dLayHeight = EgtGetInfo( s_nPartId, KEY_SLICE_STEP, 'd')
    LayerParams.dOffs = EgtGetInfo( s_nPartId, KEY_OFFSET_SLICE, 'd')
    LayerParams.bInvert = ( EgtGetInfo( s_nPartId, KEY_PRINT_DIRECTION, 'i') == PRINT_DIRECTION.CW)
@@ -45,6 +46,7 @@ local function GetLayerParamsForToolPathCalc()
    LayerParams.dTDiam = EgtGetInfo( s_nPartId, KEY_TOOL_DIAM, 'd')
    -- parametri infill
    LayerParams.dInfillStrand = EgtGetInfo( s_nPartId, KEY_INFILL_STRAND, 'd') or LayerParams.dStrand
+   if LayerParams.dInfillStrand < GEO.EPS_SMALL then LayerParams.dInfillStrand = LayerParams.dStrand end
    LayerParams.bInfillLink = EgtGetInfo( s_nPartId, KEY_INFILL_LINK, 'b') or false
    LayerParams.dInfillCoasting = EgtGetInfo( s_nPartId, KEY_INFILL_COASTING, 'd') or 0
    LayerParams.dInfillWipe = EgtGetInfo( s_nPartId, KEY_INFILL_WIPE, 'd') or 0
@@ -582,7 +584,15 @@ local function CalcExtraShellToolPath( vEntIds, nTpathGrpId, LayerParams)
       end
       sPrevName = sCurrName
    end
-
+   
+   -- aggiungo offset lead point sulle extra shell chiuse
+   for i = 1, #vIds do
+      if EgtCurveIsClosed( vIds[i]) then
+         local nCopy = EgtCopyGlob( nTpathGrpId, vIds[i])
+         AddOffsetLeadPoint( {vIds[i]}, nCopy, LayerParams.dOffsetLP, LINK_TYPE.NONE)
+      end
+   end
+   
    -- aggiungo coasting/wipe
    for i = 1, #vIds do
       -- verifico non sia collegato al successivo tramite link
@@ -702,8 +712,8 @@ local function VerifyInfillLink( nLinkId, nCurr, nNext, vIds, dStrand, nGrpTmp)
             -- se tratto lineare allineato come curva corrente
             if AreSameVectorApprox( vtS, vtE) and vtS * vtDirCurr < - 1 + GEO.EPS_SMALL then
                -- verifico distanza
-               local nCrvTest = EgtCurveCompoFromPoints( nGrpTmp, { EgtUP( nCurrLoc, dPar), EgtUP( nCurrLoc, dPar + 1)})
-               local dDist = EgtPointCurveDist( EgtUP( nLinkLoc, dParCrv - 0.5), nNextLoc)
+               local nCrvTest = EgtCurveCompoFromPoints( nGrpTmp, { EgtUP( nNextLoc, dPar), EgtUP( nNextLoc, dPar + 1)})
+               local dDist = EgtPointCurveDist( EgtUP( nLinkLoc, dParCrv - 0.5), nCrvTest)
                if dDist < dMinDist + GEO.EPS_SMALL then 
                   return false 
                end
@@ -1014,18 +1024,57 @@ end
 --------------------------------------------------------------------
 --------------------------- RIBS -----------------------------------
 --------------------------------------------------------------------
-local function VerifyRibsLink( nLinkId, nCurr, nNext, nGrpTmp, bCheckLinked)
+local function VerifyRibsLink( nLinkId, nCurr, nNext, nGrpTmp, dStrand)
 
-   local dStrand = EgtGetInfo( nLinkId, KEY_CRV_STRAND, 'd')
    local dOverlap1 = EgtGetInfo( nCurr, KEY_RIBS_OVERLAP, 'd')
    local dOverlap2 = EgtGetInfo( nNext, KEY_RIBS_OVERLAP, 'd')
    local dOverlap = max( dOverlap1, dOverlap2)
    local dLen = EgtCurveLength( nLinkId)
    
-   -- porto il link nel gruppo locale
-   local nLinkLoc = EgtCopyGlob( nLinkId, nGrpTmp)
+   -- 1) verifico che non entri nella tavola
+   local b3Box = EgtGetBBoxGlob( nLinkId, GDB_BB.STANDARD)
+   if b3Box:getMin():getZ() < - GEO.EPS_SMALL then
+      return false
+   end
    
-   -- verifico se interseca altri setti ( considerando anche le tipologie del PathGrp non ancora realizzate)
+   -- 2) verifica con setti coinvolti dal link
+   if nCurr ~= nNext then
+      -- 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
+      
+      -- verifico non intersechi i setti in altri punti oltre agli estremi
+      local nCurrLoc = EgtCopyGlob( nCurr, nGrpTmp)
+      local nNextLoc = EgtCopyGlob( nNext, nGrpTmp)
+      local nLinkLoc = EgtCopyGlob( nLinkId, nGrpTmp)
+      EgtTrimCurveEndAtLen( nLinkLoc, EgtCurveLength( nLinkLoc) - 100 * GEO.EPS_SMALL)
+      EgtTrimCurveStartAtLen( nLinkLoc, 100 * GEO.EPS_SMALL)
+      if EgtIP( nLinkLoc, nCurrLoc, ORIG()) or EgtIP( nLinkLoc, nNextLoc, ORIG()) then
+         return false
+      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
+         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)
+         -- EgtSetStatus( nSrfRibs, GDB_ST.OFF)
+         -- EgtSetStatus( nSrfRibs2, GDB_ST.OFF)
+         local nLinkLoc = EgtCopyGlob( nLinkId, nGrpTmp)
+         local nRes, nCnt = EgtTrimCurveWithRegion( nLinkLoc, nSrfRibs, false, false)
+         if nCnt == 0 then return false end
+         local dResLen = EgtCurveLength( nRes)
+         if dResLen < 0.2 * dLen - GEO.EPS_SMALL then
+            return false
+         end
+      end
+   end
+   
+   -- 3) verifiche con altri setti ( considerando anche le tipologie del PathGrp non ancora realizzate)
+   local nLinkLoc = EgtCopyGlob( nLinkId, nGrpTmp)
    local nOrigCurr = EgtGetInfo( nCurr, KEY_ORIGINAL_RIB, 'i')
    local nOrigNext = EgtGetInfo( nNext, KEY_ORIGINAL_RIB, 'i')
    local vRibsIds = EgtGetNameInGroup( EgtGetParent( nCurr), RIBS_CRV .. '*')
@@ -1041,61 +1090,39 @@ local function VerifyRibsLink( nLinkId, nCurr, nNext, nGrpTmp, bCheckLinked)
    
    for i = 1, #vRibsIds do
       if vRibsIds[i] ~= nCurr and vRibsIds[i] ~= nNext then
+         -- verifico se sovrapposizione tra le passate
          local dCurrStrand = EgtGetInfo( vRibsIds[i], KEY_RIBS_STRAND, 'd')
          local nOrigId = EgtGetInfo( vRibsIds[i], KEY_ORIGINAL_RIB, 'i')
+         local dOffs
          if nOrigId == nOrigCurr or nOrigId == nOrigNext then
-            -- se passate relative ad un setto coinvolto verifico se sovrapposizione con la curva
-            local ptS = EgtSP( vRibsIds[i], GDB_ID.ROOT)
-            local dParS = EgtCurveParamAtPoint( nLinkLoc, ptS, dCurrStrand * 0.5, GDB_RT.GLOB)
-            if dParS then return false end
-            local ptE = EgtEP( vRibsIds[i], GDB_ID.ROOT)
-            local dParE = EgtCurveParamAtPoint( nLinkLoc, ptE, dCurrStrand * 0.5, GDB_RT.GLOB)
-            if dParE then return false end
+            -- se passata relativa ad un setto coinvolto nel link verifico soltanto che il percorso del link non entri nella regione occupata dal setto
+            dOffs = dCurrStrand * 0.5
          else
-            -- verifico se sovrapposizione con la passata
-            local dOffs = dCurrStrand * 0.5 + ( 0.5 - dOverlap / 100) * dStrand - 10 * GEO.EPS_SMALL
-            if dOffs > GEO.EPS_SMALL then
-               local nSrfCurr = EgtSurfFrFatCurve( nGrpTmp, vRibsIds[i], dOffs, false)
-               if nSrfCurr then
-                  local nRes = EgtCurveWithRegionClassify( nLinkLoc, nSrfCurr)
-                  if nRes ~= GDB_CRC.OUT then
-                     return false
-                  end
+            -- 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
+         end
+         
+         if dOffs > GEO.EPS_SMALL then
+            local nSrfCurr = EgtSurfFrFatCurve( nGrpTmp, vRibsIds[i], dOffs, false)
+            if nSrfCurr then
+               -- EgtSetStatus( nSrfCurr, GDB_ST.OFF)
+               local nRes = EgtCurveWithRegionClassify( nLinkLoc, nSrfCurr)
+               if nRes ~= GDB_CRC.OUT then
+                  return false
                end
             end
          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 almeno in una regione ammissibile ( per caso ForcedLink)
+   -- 4) verifico se si trova in almeno una regione ammissibile ( per caso ForcedLink)
    local nType = EgtGetInfo( nCurr, KEY_RIBS_TYPE, 'i')
    local nOut = 0
    for i = 1, 2 do
       local nSurfId = EgtGetInfo( EgtIf( i == 1, nCurr, nNext), KEY_ASSOCIATED_SURF, 'i')
       if nSurfId and nSurfId ~= -1 then
          local nSrfLoc = EgtCopyGlob( nSurfId, nGrpTmp)
+         -- EgtSetStatus( nSrfLoc, GDB_ST.OFF)
          local nRes = EgtCurveWithRegionClassify( nLinkId, nSrfLoc)
          if ( ( nType == RIB_TYPE.INTERNAL or nType == RIB_TYPE.SUPPORT) and ( nRes == GDB_CRC.OUT or nRes == GDB_CRC.INTERS)) or 
             ( nType == RIB_TYPE.EXTERNAL and ( nRes == GDB_CRC.IN or nRes == GDB_CRC.INTERS)) then
@@ -1117,29 +1144,79 @@ local function VerifyRibsLink( nLinkId, nCurr, nNext, nGrpTmp, bCheckLinked)
 end
 
 --------------------------------------------------------------------
-local function ComputeRibsLinkOnDiffCrvs( nCrvS, nCrvE, dParS, dParE)
+local function ComputeRibsLinkOnSameCrv( nCrvId, dParS, dParE, nCurr, nNext, nGrpTmp, dStrand)
    
-   -- recupero il tratto interessato sulla curva1
-   local _, _, dParFinal = EgtPointCurveDist( EgtUP( nCrvE, dParE, GDB_ID.ROOT), nCrvS, GDB_ID.ROOT) 
-   local nCrv1 = ComputeShortestCrv( nCrvS, dParS, dParFinal)
+   local nParentId = EgtGetParent( nCrvId)
+
+   local nShortest = EgtCopyGlob( nCrvId, nParentId, GDB_IN.AFTER)
+   local nLongest = EgtCopyGlob( nCrvId, nParentId, GDB_IN.AFTER)
+   EgtTrimCurveStartEndAtParam( nShortest, dParS, dParE)
+   EgtTrimCurveStartEndAtParam( nLongest, dParE, dParS)
+   EgtInvertCurve( nLongest)
+   if EgtCurveLength( nShortest) > EgtCurveLength( nLongest) + GEO.EPS_SMALL then
+      nShortest, nLongest = nLongest, nShortest
+   end
    
-   -- recupero il tratto interessato sulla cruva2
-   local _, _, dParStart = EgtPointCurveDist( EgtUP( nCrvS, dParS, GDB_ID.ROOT), nCrvE, GDB_ID.ROOT) 
-   local nCrv2 = ComputeShortestCrv( nCrvE, dParStart, dParE)
-   
-   -- modifico nCrv2 per avere una transizione uniforme da nCrv1
-   if EgtSpiralizeCurveAlongGuide( nCrv2, nCrv1) then
-      EgtErase( nCrv1)
-      return nCrv2
+   -- verifico il percorso più corto
+   if VerifyRibsLink( nShortest, nCurr, nNext, nGrpTmp, dStrand) then
+      EgtErase( nLongest)
+      return nShortest
    else
-      EgtErase( nCrv1)
-      EgtErase( nCrv2)
-      return nil
+      -- se non valido tento con il percorso più lungo
+      EgtErase( nShortest)
+      if VerifyRibsLink( nLongest, nCurr, nNext, nGrpTmp, dStrand) then
+         return nLongest
+      else
+         EgtErase( nLongest)
+         return
+      end
    end
 end
 
 --------------------------------------------------------------------
-local function CalcRibsLink( nCurr, nNext, nLoopGrp, bForceLink, bCheckLinked, vtSlicing, nGrpTmp)
+local function ComputeRibsLinkOnDiffCrvs( nCrvS, nCrvE, dParS, dParE, nCurr, nNext, nGrpTmp, dStrand)
+   
+   local nParentId = EgtGetParent( nCrvS)
+   
+   local _, _, dParFinal = EgtPointCurveDist( EgtUP( nCrvE, dParE, GDB_ID.ROOT), nCrvS, GDB_ID.ROOT)
+   local _, _, dParStart = EgtPointCurveDist( EgtUP( nCrvS, dParS, GDB_ID.ROOT), nCrvE, GDB_ID.ROOT)
+   
+   -- tento con il tratto dParS->dParE
+   -- recupero il tratto interessato sulla curva1
+   local nCrv1 = EgtCopyGlob( nCrvS, nParentId, GDB_IN.AFTER)
+   EgtTrimCurveStartEndAtParam( nCrv1, dParS, dParFinal)
+   -- recupero il tratto interessato sulla curva2  
+   local nCrv2 = EgtCopyGlob( nCrvE, nParentId, GDB_IN.AFTER)
+   EgtTrimCurveStartEndAtParam( nCrv2, dParStart, dParE)
+   -- modifico nCrv2 per avere una transizione uniforme da nCrv1
+   EgtSpiralizeCurveAlongGuide( nCrv2, nCrv1)
+   EgtErase( nCrv1)
+   -- verifico se valida
+   if VerifyRibsLink( nCrv2, nCurr, nNext, nGrpTmp, dStrand) then
+      return nCrv2
+      
+   else
+      -- tento con il tratto dParE->dParS
+      EgtErase( nCrv2)
+      nCrv1 = EgtCopyGlob( nCrvS, nParentId, GDB_IN.AFTER)   -- tratto interessato sulla curva1
+      EgtTrimCurveStartEndAtParam( nCrv1, dParFinal, dParS)
+      EgtInvertCurve( nCrv1)
+      nCrv2 = EgtCopyGlob( nCrvE, nParentId, GDB_IN.AFTER)   -- tratto interessato sulla curva2
+      EgtTrimCurveStartEndAtParam( nCrv2, dParE, dParStart)
+      EgtInvertCurve( nCrv2)
+      EgtSpiralizeCurveAlongGuide( nCrv2, nCrv1) -- transizione uniforme da nCrv1
+      EgtErase( nCrv1)
+      if VerifyRibsLink( nCrv2, nCurr, nNext, nGrpTmp, dStrand) then
+         return nCrv2
+      else
+         EgtErase( nCrv2)
+         return
+      end
+   end
+end
+
+--------------------------------------------------------------------
+local function CalcRibsLink( nCurr, nNext, nLoopGrp, bForceLink, vtSlicing, nGrpTmp)
    
    local ptS = EgtEP( nCurr)
    local ptE = EgtSP( nNext)
@@ -1172,10 +1249,10 @@ local function CalcRibsLink( nCurr, nNext, nLoopGrp, bForceLink, bCheckLinked, v
          local nLinkId
          if vIdsS[i] == vIdsE[j] then
             -- link su una sola curva
-            nLinkId = ComputeShortestCrv( vCrvIds[vIdsS[i]], vParS[i], vParE[j])
+            nLinkId = ComputeRibsLinkOnSameCrv( vCrvIds[vIdsS[i]], vParS[i], vParE[j], nCurr, nNext, nGrpTmp, dStrand)
          else
             -- link tra due curve distinte
-            nLinkId = ComputeRibsLinkOnDiffCrvs( vCrvIds[vIdsS[i]], vCrvIds[vIdsE[j]], vParS[i], vParE[j])
+            nLinkId = ComputeRibsLinkOnDiffCrvs( vCrvIds[vIdsS[i]], vCrvIds[vIdsE[j]], vParS[i], vParE[j], nCurr, nNext, nGrpTmp, dStrand)
          end
          
          if nLinkId then
@@ -1184,13 +1261,7 @@ local function CalcRibsLink( nCurr, nNext, nLoopGrp, bForceLink, bCheckLinked, v
             EgtSetName( nLinkId, LINK_CRV)
             EgtModifyCurveExtrusion( nLinkId, vtSlicing, GDB_RT.GLOB)
             EgtSetInfo( nLinkId, KEY_CRV_STRAND, dStrand)
-            -- verifico se valido
-            local bValid = VerifyRibsLink( nLinkId, nCurr, nNext, nGrpTmp, bCheckLinked)
-            if bValid then
-               return nLinkId
-            else
-               EgtErase( nLinkId)
-            end
+            return nLinkId
          end
       end
    end
@@ -1203,7 +1274,7 @@ local function CalcRibsLink( nCurr, nNext, nLoopGrp, bForceLink, bCheckLinked, v
       EgtModifyCurveExtrusion( nLinkId, vtSlicing, GDB_RT.GLOB)
       EgtRelocateGlob( nLinkId, nCurr, GDB_IN.AFTER)
       EgtSetInfo( nLinkId, KEY_CRV_STRAND, dStrand)
-      local bValid = VerifyRibsLink( nLinkId, nCurr, nNext, nGrpTmp, bCheckLinked)
+      local bValid = VerifyRibsLink( nLinkId, nCurr, nNext, nGrpTmp, dStrand)
       if bValid then
          return nLinkId
       else
@@ -1215,6 +1286,38 @@ local function CalcRibsLink( nCurr, nNext, nLoopGrp, bForceLink, bCheckLinked, v
    return
 end
 
+--------------------------------------------------------------------
+local function CalcLoopRibLink( nCurr, nNext, nLoopGrp, vtSlicing, nGrpTmp)
+   
+   local ptS = EgtEP( nCurr)
+   local ptE = EgtSP( nNext)
+   if AreSamePointApprox( ptS, ptE) then return end
+   local dStrand = EgtGetInfo( nCurr, KEY_CRV_STRAND, 'd')
+   
+   local vCrvIds = EgtGetAllInGroup( nLoopGrp)
+   -- scorro le curve di bordo e verifico se posso creare il link
+   for i = 1, #vCrvIds do
+      local dParS = EgtCurveParamAtPoint( vCrvIds[i], ptS, 10 * GEO.EPS_SMALL)
+      local dParE = EgtCurveParamAtPoint( vCrvIds[i], ptE, 10 * GEO.EPS_SMALL)
+      if dParS and dParE then
+         local nLinkId = ComputeShortestCrv( vCrvIds[i], dParS, dParE)
+         if nLinkId then
+            EgtRelocateGlob( nLinkId, nCurr, GDB_IN.AFTER)
+            EgtSetInfo( nLinkId, KEY_TYPE, TYPE.RIB)
+            EgtSetName( nLinkId, LINK_CRV)
+            EgtModifyCurveExtrusion( nLinkId, vtSlicing, GDB_RT.GLOB)
+            EgtSetInfo( nLinkId, KEY_CRV_STRAND, dStrand)
+            if VerifyRibsLink( nLinkId, nCurr, nNext, nGrpTmp, dStrand) then
+               return nLinkId
+            else
+               EgtErase( nLinkId)
+            end
+         end
+      end
+   end
+   return
+end
+
 --------------------------------------------------------------------
 local function VerifyRibsLead( nId, nRibId, bInVsOut, nGrpTmp)
 
@@ -1242,17 +1345,18 @@ local function VerifyRibsLead( nId, nRibId, bInVsOut, nGrpTmp)
       end
    end
    
-   -- verifico se interseca altri setti, lead in, lead out o collegamenti
+   -- 1) verifico se interseca altri setti, lead in, lead out o collegamenti
    -- recupero gli id degli elementi da controllare
    local vCheckIds = {}
-   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
+   local nCurrId = EgtGetFirstInGroup( EgtGetParent( nRibId))
    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
-         table.insert( vCheckIds, nCurrId)
+      -- considero solo i setti e gli elementi a loro associati ( tranne i wipe perchè non corrispondono a materiale depositato)
+      local nType = EgtGetInfo( nCurrId, KEY_TYPE, 'i')
+      if nType == TYPE.RIB or ( nType == TYPE.COASTING and EgtGetInfo( EgtGetPrev( nCurrId), KEY_TYPE, 'i') == TYPE.RIB) then
+         -- verifico non sia un tratto relativo al setto corrente
+         if nCurrId ~= nCurrLI and nCurrId ~= nRibId and nCurrId ~= nId and nCurrId ~= nCurrLink then
+            table.insert( vCheckIds, nCurrId)
+         end
       end
       nCurrId = EgtGetNext( nCurrId)
    end
@@ -1273,6 +1377,7 @@ local function VerifyRibsLead( nId, nRibId, bInVsOut, nGrpTmp)
       if dCurrOffs > GEO.EPS_SMALL then
          local nSrfCurr = EgtSurfFrFatCurve( nGrpTmp, vCheckIds[i], dCurrOffs, false)
          if nSrfCurr then
+            -- EgtSetStatus( nSrfCurr, GDB_ST.OFF)
             local nRes = EgtCurveWithRegionClassify( nLeadLoc, nSrfCurr)
             if nRes ~= GDB_CRC.OUT then
                return false
@@ -1281,7 +1386,7 @@ local function VerifyRibsLead( nId, nRibId, bInVsOut, nGrpTmp)
       end
    end
   
-   -- verifiche con il setto corrente
+   -- 2) 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
@@ -1306,7 +1411,7 @@ local function VerifyRibsLead( nId, nRibId, bInVsOut, nGrpTmp)
       end
    end
    
-   -- verifiche con eventuale lead in
+   -- 3) verifiche con eventuale lead in
    if nCurrLI then
       local nLeadInLoc = EgtCopyGlob( nCurrLI, nGrpTmp)
       -- verifico se intersezione fra curve
@@ -1318,6 +1423,7 @@ local function VerifyRibsLead( nId, nRibId, bInVsOut, nGrpTmp)
       if dLeadInLen > dStrand + GEO.EPS_SMALL then
          local nSrfLeadIn = EgtSurfFrFatCurve( nGrpTmp, nId, dStrand * ( 1 - dOverlap / 100), false)
          if nSrfLeadIn then
+            -- EgtSetStatus( nSrfLeadIn, GDB_ST.OFF)
             -- verifico di avere un solo tratto esterno di lunghezza sufficiente
             local nRes, nCnt = EgtTrimCurveWithRegion( nLeadInLoc, nSrfLeadIn, false, false)
             if nCnt ~= 1 then
@@ -1615,21 +1721,25 @@ local function CalcRibsToolPath( vEntIds, nRibsGrp, nTpathGrpId, LayerParams)
          local bLoopRib = EgtGetInfo( tabRibs[i][1], KEY_LOOP_RIB, 'b') or false
          for j = 1, #tabRibs[i] - 1 do
             local bUserLink = ( EgtGetInfo( tabRibs[i][j], KEY_RIBS_USER_LINK, 'b') or false) and ( EgtGetInfo( tabRibs[i][j+1], KEY_RIBS_USER_LINK, 'b') or false)
+            local bSplitAfterTrim = EgtGetInfo( tabRibs[i][1], KEY_SPLIT_AFTER_TRIM, 'b') or false
             local nOrig1 = EgtGetInfo( tabRibs[i][j], KEY_ORIGINAL_RIB, 'i') or 0
             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 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, bForceLink, bCheckLinkedRibs, LayerParams.vtSlicing, nGrpTmp)
-              
-               -- se LoopRib congiungo i setti in unico percorso
-               if bLoopRib and 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
+            -- creo collegamento se userlink, passate dello stesso setto o passate divise dopo trim
+            if ( nOrig1 ~= nOrig2 and bUserLink) or ( nSplitId1 == nSplitId2 and nOrig1 == nOrig2) or ( nOrig1 == nOrig2 and bSplitAfterTrim) then
+               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)
+                  -- 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
+                  end
                end
             end
          end
@@ -1637,7 +1747,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, false, false, LayerParams.vtSlicing, nGrpTmp)
+            local nLinkId = CalcLoopRibLink( tabRibs[i][nTotCrv], tabRibs[i][1], nLoopGrp, LayerParams.vtSlicing, nGrpTmp)
             if nLinkId then
                -- se curva unica
                if tabRibs[i][nTotCrv] == tabRibs[i][1] then
@@ -1668,9 +1778,11 @@ local function CalcRibsToolPath( vEntIds, nRibsGrp, nTpathGrpId, LayerParams)
    for i = 1, #tabRibs - 1 do
       local bLink1 = EgtGetInfo( tabRibs[i][1], KEY_RIBS_LINK, 'b')
       local bLink2 = EgtGetInfo( tabRibs[i + 1][1], KEY_RIBS_LINK, 'b')
-      if bLink1 and bLink2 then
+      local bLoop1 = EgtGetInfo( tabRibs[i][1], KEY_LOOP_RIB, 'b') or false
+      local bLoop2 = EgtGetInfo( tabRibs[i + 1][1], KEY_LOOP_RIB, 'b') or false
+      if bLink1 and bLink2 and not bLoop1 and not bLoop2 then
          local nCnt = #tabRibs[i]
-         CalcRibsLink( tabRibs[i][nCnt], tabRibs[i + 1][1], nLoopGrp, false, true, LayerParams.vtSlicing, nGrpTmp)
+         CalcRibsLink( tabRibs[i][nCnt], tabRibs[i + 1][1], nLoopGrp, false, LayerParams.vtSlicing, nGrpTmp)
       end
    end
    
@@ -1875,7 +1987,7 @@ function CalcToolPath.Exec( nPartId)
    end
 
    local b3Tot = BBox3d() -- box dei toolpath
-   
+   local nLayCnt = 1
    -- Ciclo sui layer
    for nIdx = 1, #vLayIds do
       
@@ -1958,6 +2070,11 @@ function CalcToolPath.Exec( nPartId)
          local b3Box = ComputeToolPathBox( nTpathGrpId)
          b3Tot:Add( b3Box)
          
+         -- verifico non sia vuoto per aggiornare il numero di layers
+         if EgtGetFirstInGroup( nTpathGrpId) then
+            nLayCnt = nIdx
+         end
+         
          -- passo al gruppo di contorni successivo
          nCrvGrpId = EgtGetNextName( nCrvGrpId, CONTOUR_GRP.."*")
       end
@@ -1971,6 +2088,9 @@ function CalcToolPath.Exec( nPartId)
    -- correzione in z
    AddZCorrection( b3Tot, LayerParams)
    
+   -- setto info con numero di layers effettivi
+   EgtSetInfo( nPartId, KEY_LAYER_CNT, nLayCnt)
+      
    return true
 end
 

LuaLibs/RunMachParamFromSWCalc.lua

@@ -62,7 +62,7 @@ function RunMachParamFromSWCalc.Exec()
    while nPartId do
       if not EgtGetInfo( nPartId, KEY_PART_ON_TABLE, 'b') then
          nPartId = EgtGetNextPart( nPartId)
-         goto continue 
+         goto continue
       end
       -- recupero i parametri di lavorazione del pezzo
       local dSliceStep = EgtGetInfo( nPartId, KEY_SLICE_STEP, 'd')
@@ -77,6 +77,8 @@ function RunMachParamFromSWCalc.Exec()
       while nLayerId do
          -- rimuovo eventuale info precedente del tempo di attesa
          EgtRemoveInfo( nLayerId, KEY_WAITING_TIME)
+         -- divido curve in base alla larghezza strand
+         local LengthCrvList = {}
          -- calcolo lunghezza totale del layer
          local dTotLayerLength = 0
          local dTotLayerLengthForMass = 0
@@ -84,14 +86,29 @@ function RunMachParamFromSWCalc.Exec()
          local nCrvId = EgtGetFirstNameInGroup( nLayerId, CONTOUR_GRP .. '*')
          while nCrvId do
             local nToolPathId = EgtGetFirstNameInGroup( nCrvId, TOOLPATH_GRP)
-            -- sommo lunghezze percorsi
+            -- recupero lunghezze percorsi
             local dTotCrvLength = 0
             local dTotCrvLengthForMass = 0
-            nShellId = EgtGetFirstInGroup( nToolPathId)
+            local nShellId = EgtGetFirstInGroup( nToolPathId)
             while nShellId do
-               dTotCrvLength = dTotCrvLength + EgtCurveLength( nShellId)
+               local dShellWidth = EgtGetInfo( nShellId, KEY_CRV_STRAND, "d")
+               local dShellLength = EgtCurveLength( nShellId)
+               local bFound = false
+               for LengthIndex = 1, #LengthCrvList do
+                  if LengthCrvList[LengthIndex].Width == dShellWidth then
+                     table.insert( LengthCrvList[LengthIndex].IdList, nShellId) 
+                     LengthCrvList[LengthIndex].Length = LengthCrvList[LengthIndex].Length + dShellLength
+                     bFound = true
+                     break
+                  end
+               end
+               if not bFound then
+                  table.insert( LengthCrvList, { Width = dShellWidth, IdList = { nShellId}, Length = dShellLength})
+               end
+               -- sommo per lunghezza totale
+               dTotCrvLength = dTotCrvLength + dShellLength
                if EgtGetName( nShellId) ~= WIPE_CRV then
-                  dTotCrvLengthForMass = dTotCrvLengthForMass + EgtCurveLength( nShellId)
+                  dTotCrvLengthForMass = dTotCrvLengthForMass + dShellLength
                end
                nShellId = EgtGetNext( nShellId)
             end
@@ -109,6 +126,44 @@ function RunMachParamFromSWCalc.Exec()
             end
             nCrvId = EgtGetNextName( nCrvId, CONTOUR_GRP .. '*')
          end
+
+
+         -- -- rimuovo eventuale info precedente del tempo di attesa
+         -- EgtRemoveInfo( nLayerId, KEY_WAITING_TIME)
+         -- -- calcolo lunghezza totale del layer
+         -- local dTotLayerLength = 0
+         -- local dTotLayerLengthForMass = 0
+         -- local dTotLayerArea = 0
+         -- local nCrvId = EgtGetFirstNameInGroup( nLayerId, CONTOUR_GRP .. '*')
+         -- while nCrvId do
+         --    local nToolPathId = EgtGetFirstNameInGroup( nCrvId, TOOLPATH_GRP)
+         --    -- sommo lunghezze percorsi
+         --    local dTotCrvLength = 0
+         --    local dTotCrvLengthForMass = 0
+         --    local nShellId = EgtGetFirstInGroup( nToolPathId)
+         --    while nShellId do
+         --       dTotCrvLength = dTotCrvLength + EgtCurveLength( nShellId)
+         --       if EgtGetName( nShellId) ~= WIPE_CRV then
+         --          dTotCrvLengthForMass = dTotCrvLengthForMass + EgtCurveLength( nShellId)
+         --       end
+         --       nShellId = EgtGetNext( nShellId)
+         --    end
+         --    dTotLayerLength = dTotLayerLength + dTotCrvLength
+         --    dTotLayerLengthForMass = dTotLayerLengthForMass + dTotCrvLengthForMass
+         --    -- recupero area
+         --    local nOuterCrvId = EgtGetFirstNameInGroup( nCrvId, OUTER_CRV)
+         --    if nOuterCrvId and dStrandCount > 0.5 then
+         --       local _, _, dTotCrvArea = EgtCurveArea( nOuterCrvId)
+         --       local dOuterLength = EgtCurveLength( nOuterCrvId)
+         --       -- recupero offset del part per aggiungerlo all'area interna
+         --       local dOffset = EgtGetInfo( nPartId, KEY_OFFSET_SLICE, 'd')
+         --       dTotCrvArea = dTotCrvArea + ( dOffset * dOuterLength)
+         --       dTotLayerArea = dTotLayerArea + dTotCrvArea
+         --    end
+         --    nCrvId = EgtGetNextName( nCrvId, CONTOUR_GRP .. '*')
+         -- end
+
+
          -- recupero feed del layer
          local dLayerFeed = 0
          local dLayerWait = 0
@@ -132,11 +187,18 @@ function RunMachParamFromSWCalc.Exec()
             table.insert( nOrigLayers, nLayerId)
          end
          EgtSetInfo( nLayerResultId, KEY_SLICEID, nOrigLayers)
+         -- calcolo strand medio (media ponderata sulla lunghezza)
+         local dStrandMean = 0
+         for nMeanIndex = 1, #LengthCrvList do
+            dStrandMean = dStrandMean + LengthCrvList[nMeanIndex].Width * LengthCrvList[nMeanIndex].Length
+         end
+         dStrandMean = dStrandMean / dTotLayerLength
          -- calcolo costante MF
          local dMF = 1
          local dSC = 1
          if dTotLayerArea > 1 then
-            dMF = dTotLayerLength * dStrand / dTotLayerArea * 100
+            -- dMF = dTotLayerLength * dStrand / dTotLayerArea * 100
+            dMF = dTotLayerLength * dStrandMean / dTotLayerArea * 100
             dSC = dStrandCount
          else
             dMF = 100
@@ -151,9 +213,9 @@ function RunMachParamFromSWCalc.Exec()
             end
          end
          -- calcolo tempi stimati del layer
-         local dTMin = ( MATERIAL.K_LAYERTIME / 100.0) * ( dMF + MATERIAL.AMin) / MATERIAL.BMin * pow( 0.25 * dStrand, MATERIAL.KW) * pow( dSliceStep, MATERIAL.KZ) * pow( dSC, MATERIAL.KN)
-         local dTTrg = ( MATERIAL.K_LAYERTIME / 100.0) * ( dMF + MATERIAL.ATrg) / MATERIAL.BTrg * pow( 0.25 * dStrand, MATERIAL.KW) * pow( dSliceStep, MATERIAL.KZ) * pow( dSC, MATERIAL.KN)
-         local dTMax = ( MATERIAL.K_LAYERTIME / 100.0) * ( dMF + MATERIAL.AMax) / MATERIAL.BMax * pow( 0.25 * dStrand, MATERIAL.KW) * pow( dSliceStep, MATERIAL.KZ) * pow( dSC, MATERIAL.KN)
+         local dTMin = ( MATERIAL.K_LAYERTIME / 100.0) * ( dMF + MATERIAL.AMin) / MATERIAL.BMin * pow( 0.25 * dStrandMean, MATERIAL.KW) * pow( dSliceStep, MATERIAL.KZ) * pow( dSC, MATERIAL.KN)
+         local dTTrg = ( MATERIAL.K_LAYERTIME / 100.0) * ( dMF + MATERIAL.ATrg) / MATERIAL.BTrg * pow( 0.25 * dStrandMean, MATERIAL.KW) * pow( dSliceStep, MATERIAL.KZ) * pow( dSC, MATERIAL.KN)
+         local dTMax = ( MATERIAL.K_LAYERTIME / 100.0) * ( dMF + MATERIAL.AMax) / MATERIAL.BMax * pow( 0.25 * dStrandMean, MATERIAL.KW) * pow( dSliceStep, MATERIAL.KZ) * pow( dSC, MATERIAL.KN)
          local dFMin = dTotLayerLength / dTMax * 60
          local dFTrg = dTotLayerLength / dTTrg * 60
          local dFMax = dTotLayerLength / dTMin * 60
@@ -165,7 +227,7 @@ function RunMachParamFromSWCalc.Exec()
          end
          dLayerWait = floor( dTMin + 0.5) - floor( dLayerTime + 0.5)
          -- calcolo la portata
-         local Vf = dLayerFeed * ( ( dStrand - dSliceStep) * dSliceStep + pi * pow( dSliceStep / 2, 2)) / 1000
+         local Vf = dLayerFeed * ( ( dStrandMean - dSliceStep) * dSliceStep + pi * pow( dSliceStep / 2, 2)) / 1000
          -- calcolo speed
          local dSpeed = ( MATERIAL.K_EXTRUSION / 100.0) * ( MACHINING.K / 100.0) * pow( Vf / MATERIAL.C1, 1 / MATERIAL.C2)
          -- verifico se speed esce da minimo e massimo della macchina
@@ -179,20 +241,32 @@ function RunMachParamFromSWCalc.Exec()
             dSpeed = dSMax
          end
          if not bSpeedOk then
-            dLayerFeed = ( MATERIAL.C1 * pow( ( dSpeed / (( MATERIAL.K_EXTRUSION / 100.0) * ( MACHINING.K / 100.0))), MATERIAL.C2)) * 1000 / ( ( dStrand - dSliceStep) * dSliceStep + pi * pow( dSliceStep / 2, 2))
+            dLayerFeed = ( MATERIAL.C1 * pow( ( dSpeed / (( MATERIAL.K_EXTRUSION / 100.0) * ( MACHINING.K / 100.0))), MATERIAL.C2)) * 1000 / ( ( dStrandMean - dSliceStep) * dSliceStep + pi * pow( dSliceStep / 2, 2))
             dLayerTime = dTotLayerLength / dLayerFeed * 60
             dLayerWait = floor( dTMin + 0.5) - floor( dLayerTime + 0.5)
          end
          -- calcolo massa dello strato
-         local dLayerMass = dTotLayerLengthForMass * dSliceStep * dStrand * MATERIAL.Density * 1e-6
+         local dLayerMass = dTotLayerLengthForMass * dSliceStep * dStrandMean * MATERIAL.Density * 1e-6
          if dLayerMass and dLayerMass > 0 then
             dPrintMass = dPrintMass + dLayerMass
          end
-         -- scrivo info feed e speed in group toolpath
+         -- scrivo info feed su tutti i tratti
+         local dFeedMax = 0
+         for nWidthIndex = 1, #LengthCrvList do
+            local CurrWidth = LengthCrvList[nWidthIndex]
+            local CurrFeed = EgtIf( CurrWidth.Width > 0, dLayerFeed * dStrandMean / CurrWidth.Width, dLayerFeed) 
+            for nCurveIdIndex = 1, #CurrWidth.IdList do
+               EgtSetInfo( CurrWidth.IdList[nCurveIdIndex], KEY_FEED, CurrFeed)               
+            end
+            if CurrFeed > dFeedMax then
+               dFeedMax = CurrFeed
+            end
+         end
+         -- scrivo info speed in group toolpath
          nCrvId = EgtGetFirstNameInGroup( nLayerId, CONTOUR_GRP .. '*')
          while nCrvId do
             local nToolPathId = EgtGetFirstNameInGroup( nCrvId, TOOLPATH_GRP) or GDB_ID.NULL
-            EgtSetInfo( nToolPathId, KEY_FEED, dLayerFeed)
+            -- EgtSetInfo( nToolPathId, KEY_FEED, dLayerFeed)
             EgtSetInfo( nToolPathId, KEY_SPEED, dSpeed)
             nCrvId = EgtGetNextName( nCrvId, CONTOUR_GRP .. '*')
          end
@@ -206,9 +280,11 @@ function RunMachParamFromSWCalc.Exec()
          EgtSetInfo( nLayerResultId, KEY_TMIN, dTMin)
          EgtSetInfo( nLayerResultId, KEY_TTRG, dTTrg)
          EgtSetInfo( nLayerResultId, KEY_TMAX, dTMax)
-         EgtSetInfo( nLayerResultId, KEY_FMIN, dFMin)
          EgtSetInfo( nLayerResultId, KEY_FTRG, dFTrg)
-         EgtSetInfo( nLayerResultId, KEY_FMAX, dFMax)
+         EgtSetInfo( nLayerResultId, KEY_FMAX, dFeedMax)
+         -- EgtSetInfo( nLayerResultId, KEY_FMIN, dFMin)
+         -- EgtSetInfo( nLayerResultId, KEY_FTRG, dFTrg)
+         -- EgtSetInfo( nLayerResultId, KEY_FMAX, dFMax)
          EgtSetInfo( nLayerResultId, KEY_TCUR, dLayerTime)
          EgtSetInfo( nLayerResultId, KEY_FCUR, dLayerFeed)
          EgtSetInfo( nLayerResultId, KEY_LENGTH, dTotLayerLength)

LuaLibs/RunSlicing.lua

@@ -157,10 +157,6 @@ function RunSlicing.Exec()
    EgtRemoveAllOperations()
    EgtResetCurrMachGroup()
 
-   -- Lettura dati macchina
-   local sMachIni = EgtGetCurrMachineDir() .. '\\' .. EgtGetCurrMachineName() .. '.ini'
-   local HMax = tonumber( EgtGetStringFromIni( '3dPrinting', 'HMax', 500, sMachIni))
-
    -- Eventuale ripristino posizione originaria
    RestoreOriginalPosition( nPartId)
    
@@ -171,7 +167,7 @@ function RunSlicing.Exec()
    RemoveOldTFS()
   
    -- Calcolo delle fette
-   local bOk = CSLICES.Exec( nPartId, nStmId, HMax)
+   local bOk = CSLICES.Exec( nPartId, nStmId)
    EgtDraw()
 
    -- Calcolo dei percorsi sul centro strand in basso

Version.lua

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