3dPrinting :

- ripristinata scrittura feed in toolpath.

.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/CalcPaths.lua

@@ -25,7 +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
-   LayerParams.dInnerStrand = EgtClamp( LayerParams.dInnerStrand, 0.5 * LayerParams.dStrand, 1.5 * 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')
@@ -45,7 +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
-   LayerParams.dInfillStrand = EgtClamp( LayerParams.dInfillStrand, 0.5 * LayerParams.dStrand, 1.5 * 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
@@ -1721,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)
    
@@ -1758,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
@@ -1839,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
@@ -1855,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])

LuaLibs/CalcSlices.lua

@@ -104,7 +104,9 @@ local function GetRibParams( nId)
 
    local RibParam = {}
    ReadParam( nId, KEY_RIBS_STRAND, 'd', s_dStrand, RibParam)
-   RibParam[KEY_RIBS_STRAND] = EgtClamp( RibParam[KEY_RIBS_STRAND], 0.5 * s_dStrand, 1.5 * s_dStrand)
+   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)
@@ -139,7 +141,9 @@ local function GetAuxSolidsParams( nId)
    
    local AuxSolidsParam = {}
    ReadParam( nId, KEY_AUX_SOLIDS_STRAND, 'd', s_dStrand, AuxSolidsParam)
-   AuxSolidsParam[KEY_AUX_SOLIDS_STRAND] = EgtClamp( AuxSolidsParam[KEY_AUX_SOLIDS_STRAND], 0.5 * s_dStrand, 1.5 * s_dStrand)
+   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)
@@ -631,7 +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
-   dStrand = EgtClamp( dStrand, 0.5 * s_dStrand, 1.5 * s_dStrand)
+   if dStrand < GEO.EPS_SMALL then
+      dStrand = s_dStrand
+   end
    
    -- creo gruppo per infill
    local nInfillGrp = EgtGroup( s_nPartId)
@@ -665,7 +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)
-               dStrand = EgtClamp( dStrand, 0.5 * s_dStrand, 1.5 * s_dStrand)
+               if dStrand < GEO.EPS_SMALL then
+                  dStrand = s_dStrand
+               end
                
                -- creo gruppo associato
                local nInfillGrp = EgtGroup( s_nPartId)

LuaLibs/CalcToolPath.lua

@@ -23,7 +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
-   LayerParams.dInnerStrand = EgtClamp( LayerParams.dInnerStrand, 0.5 * LayerParams.dStrand, 1.5 * 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)
@@ -46,7 +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
-   LayerParams.dInfillStrand = EgtClamp( LayerParams.dInfillStrand, 0.5 * LayerParams.dStrand, 1.5 * 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
@@ -458,9 +458,10 @@ local function AddRetraction( nCrvId, vtSlicing, dCoastingLen, dWipeLen, dWipeDi
       end
       
       if nWipeId then
+         local dStrand = EgtGetInfo( nCrvId, KEY_CRV_STRAND, 'd')
          EgtSetName( nWipeId, WIPE_CRV)
          EgtSetInfo( nWipeId, KEY_TYPE, TYPE.WIPE)
-         EgtSetInfo( nWipeId, KEY_CRV_STRAND, 0)
+         EgtSetInfo( nWipeId, KEY_CRV_STRAND, dStrand)
          EgtSetColor( nWipeId, EgtStdColor('AQUA'))
       end
    end
@@ -1024,45 +1025,56 @@ end
 --------------------------------------------------------------------
 --------------------------- RIBS -----------------------------------
 --------------------------------------------------------------------
-local function VerifyRibsLink( nLinkId, nCurr, nNext, nGrpTmp, dStrand, bCheckLinked)
+local function VerifyRibsLink( nLinkId, nCurr, nNext, nGrpTmp, dStrand)
 
    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)
    
-   -- verifico che non entri nella tavola
+   -- 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
    
-   -- eventuale verifica con setti coinvolti dal link
-   -- verifico non passi per estremo errato
+   -- 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
-   end
-
-   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
+      
+      -- 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)
-      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
+      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
    
-   -- verifico se interseca altri setti ( considerando anche le tipologie del PathGrp non ancora realizzate)
+   -- 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')
@@ -1079,39 +1091,39 @@ local function VerifyRibsLink( nLinkId, nCurr, nNext, nGrpTmp, dStrand, bCheckLi
    
    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
    
-   -- 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
@@ -1133,31 +1145,37 @@ local function VerifyRibsLink( nLinkId, nCurr, nNext, nGrpTmp, dStrand, bCheckLi
 end
 
 --------------------------------------------------------------------
-local function ComputeRibsLinkOnSameCrv( nCrvId, dParS, dParE, nCurr, nNext, nGrpTmp, dStrand, bCheckLinked)
+local function ComputeRibsLinkOnSameCrv( nCrvId, dParS, dParE, nCurr, nNext, nGrpTmp, dStrand)
    
    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
    
-   -- verifico il percorso dParS->dParE
-   local nCopyId = EgtCopyGlob( nCrvId, nParentId, GDB_IN.AFTER)
-   EgtTrimCurveStartEndAtParam( nCopyId, dParS, dParE)
-   if VerifyRibsLink( nCopyId, nCurr, nNext, nGrpTmp, dStrand, bCheckLinked) then
-      return nCopyId
+   -- verifico il percorso più corto
+   if VerifyRibsLink( nShortest, nCurr, nNext, nGrpTmp, dStrand) then
+      EgtErase( nLongest)
+      return nShortest
    else
-      -- se non valido tento con il percorso dParE->dParS
-      EgtErase( nCopyId)
-      nCopyId = EgtCopyGlob( nCrvId, nParentId, GDB_IN.AFTER)
-      EgtTrimCurveStartEndAtParam( nCopyId, dParE, dParS)
-      EgtInvertCurve( nCopyId)
-      if VerifyRibsLink( nCopyId, nCurr, nNext, nGrpTmp, dStrand, bCheckLinked) then
-         return nCopyId
+      -- 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 ComputeRibsLinkOnDiffCrvs( nCrvS, nCrvE, dParS, dParE, nCurr, nNext, nGrpTmp, dStrand, bCheckLinked)
+local function ComputeRibsLinkOnDiffCrvs( nCrvS, nCrvE, dParS, dParE, nCurr, nNext, nGrpTmp, dStrand)
    
    local nParentId = EgtGetParent( nCrvS)
    
@@ -1175,7 +1193,7 @@ local function ComputeRibsLinkOnDiffCrvs( nCrvS, nCrvE, dParS, dParE, nCurr, nNe
    EgtSpiralizeCurveAlongGuide( nCrv2, nCrv1)
    EgtErase( nCrv1)
    -- verifico se valida
-   if VerifyRibsLink( nCrv2, nCurr, nNext, nGrpTmp, dStrand, bCheckLinked) then
+   if VerifyRibsLink( nCrv2, nCurr, nNext, nGrpTmp, dStrand) then
       return nCrv2
       
    else
@@ -1189,7 +1207,7 @@ local function ComputeRibsLinkOnDiffCrvs( nCrvS, nCrvE, dParS, dParE, nCurr, nNe
       EgtInvertCurve( nCrv2)
       EgtSpiralizeCurveAlongGuide( nCrv2, nCrv1) -- transizione uniforme da nCrv1
       EgtErase( nCrv1)
-      if VerifyRibsLink( nCrv2, nCurr, nNext, nGrpTmp, dStrand, bCheckLinked) then
+      if VerifyRibsLink( nCrv2, nCurr, nNext, nGrpTmp, dStrand) then
          return nCrv2
       else
          EgtErase( nCrv2)
@@ -1199,7 +1217,7 @@ local function ComputeRibsLinkOnDiffCrvs( nCrvS, nCrvE, dParS, dParE, nCurr, nNe
 end
 
 --------------------------------------------------------------------
-local function CalcRibsLink( nCurr, nNext, nLoopGrp, bForceLink, bCheckLinked, vtSlicing, nGrpTmp)
+local function CalcRibsLink( nCurr, nNext, nLoopGrp, bForceLink, vtSlicing, nGrpTmp)
    
    local ptS = EgtEP( nCurr)
    local ptE = EgtSP( nNext)
@@ -1232,10 +1250,10 @@ local function CalcRibsLink( nCurr, nNext, nLoopGrp, bForceLink, bCheckLinked, v
          local nLinkId
          if vIdsS[i] == vIdsE[j] then
             -- link su una sola curva
-            nLinkId = ComputeRibsLinkOnSameCrv( vCrvIds[vIdsS[i]], vParS[i], vParE[j], nCurr, nNext, nGrpTmp, dStrand, bCheckLinked)
+            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], nCurr, nNext, nGrpTmp, dStrand, bCheckLinked)
+            nLinkId = ComputeRibsLinkOnDiffCrvs( vCrvIds[vIdsS[i]], vCrvIds[vIdsE[j]], vParS[i], vParE[j], nCurr, nNext, nGrpTmp, dStrand)
          end
          
          if nLinkId then
@@ -1257,7 +1275,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, dStrand, bCheckLinked)
+      local bValid = VerifyRibsLink( nLinkId, nCurr, nNext, nGrpTmp, dStrand)
       if bValid then
          return nLinkId
       else
@@ -1290,7 +1308,7 @@ local function CalcLoopRibLink( nCurr, nNext, nLoopGrp, vtSlicing, nGrpTmp)
             EgtSetName( nLinkId, LINK_CRV)
             EgtModifyCurveExtrusion( nLinkId, vtSlicing, GDB_RT.GLOB)
             EgtSetInfo( nLinkId, KEY_CRV_STRAND, dStrand)
-            if VerifyRibsLink( nLinkId, nCurr, nNext, nGrpTmp, dStrand, false) then
+            if VerifyRibsLink( nLinkId, nCurr, nNext, nGrpTmp, dStrand) then
                return nLinkId
             else
                EgtErase( nLinkId)
@@ -1328,17 +1346,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
@@ -1359,6 +1378,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
@@ -1367,7 +1387,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
@@ -1378,12 +1398,11 @@ local function VerifyRibsLead( nId, nRibId, bInVsOut, nGrpTmp)
    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( nLeadLoc, dParCrv - 1, 1)
       local vtE = EgtUV( nLeadLoc, dParCrv, -1)
-      local dTol = 10 * GEO.EPS_SMALL
-      if AreSameVectorApprox( vtS, vtE) and vtS * vtDir < - 1 + GEO.EPS_SMALL then
+      local dLenCrv = EgtCurveCompoLength( nLeadLoc, dParCrv - 1)
+      if AreSameVectorApprox( vtS, vtE) and vtS * vtDir < - 1 + GEO.EPS_SMALL and dLenCrv > dStrand + GEO.EPS_SMALL then
          local dDist = EgtPointCurveDist( EgtUP( nLeadLoc, dParCrv - 0.5), nRibLoc)
          EgtCopyGlob( nLeadLoc, nGrpTmp)
          if dDist < dStrand + GEO.EPS_SMALL then
@@ -1392,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
@@ -1404,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
@@ -1464,7 +1484,9 @@ local function FindCorrectRibLead( dPar, nRib, nCrvOffs, bLeadInvert, dLeadLen,
          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
+         local nSplitId1 = EgtGetInfo( nRib, KEY_SPLIT_ID, 'i') or 0
+         local nSplitId2 = EgtGetInfo( nOtherRib, KEY_SPLIT_ID, 'i') or 0
+         if nOrigRib1 ~= nOrigRib2 or ( nOrigRib1 == nOrigRib2 and nSplitId1 ~= nSplitId2) then
             nOtherRib = nil
          end
       end
@@ -1636,7 +1658,7 @@ local function AddRibsLeadOut( nCrv, nLoopsGrp, vtSlicing, nGrpTmp, bForceNoSoli
                   EgtRelocateGlob( nWipe, nCoasting or nCrvLO or nCrv, GDB_IN.AFTER)
                   EgtSetName( nWipe, WIPE_CRV)
                   EgtSetInfo( nWipe, KEY_TYPE, TYPE.WIPE)
-                  EgtSetInfo( nWipe, KEY_CRV_STRAND, 0)
+                  EgtSetInfo( nWipe, KEY_CRV_STRAND, dStrand)
                   EgtSetColor( nWipe, EgtStdColor('AQUA'))
                end
             end
@@ -1701,16 +1723,17 @@ 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
+            -- 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, bCheckLinkedRibs, LayerParams.vtSlicing, nGrpTmp)
+                  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
@@ -1761,7 +1784,7 @@ local function CalcRibsToolPath( vEntIds, nRibsGrp, nTpathGrpId, LayerParams)
       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
    

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,16 +241,28 @@ 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
@@ -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)

Version.lua

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