3dPrinting 2.7j1 :

- in spiral vase introdotta lunghezza di interpolazione letta da file ini del programma
- migliorie varie nello spiral vase.

LuaLibs/AddManData.lua

@@ -111,6 +111,7 @@ KEY_RIBS_STRAND = "RibsStrandW"
 KEY_RIBS_TYPE = "RibsType"
 KEY_LIMIT_UNBDD_RIBS = "LimitUnboundedRibsWithSolid"
 KEY_RIBS_OVERLAP = "RibsOverlap"
+KEY_RIBS_STRAND_OVERLAP = 'RibsStrandOverlap'
 KEY_RIBS_SHELLS_NBR = "RibsStrandCount"
 KEY_RIBS_LINK = "RibsLink"
 KEY_RIBS_INVERT_DIR = "RibsInvertDirection"
@@ -179,9 +180,12 @@ KEY_COEFF_Y = "CoeffY"
 KEY_SPEED_MIN = "SpeedMin"
 KEY_SPEED_MAX = "SpeedMax"
 KEY_FEED_MAX = 'FeedMax'
+KEY_LINEAR_APPROX = 'LinearApprox'
+KEY_LINEAR_TOL = 'LinearTol'
 
 -- Altre chiavi
 KEY_MAX_H = "SlicingHeight"
+KEY_MAX_SLICES_NBR = "MaxSlicesNumber"
 KEY_SLICE_NBR = "SliceNbr"
 KEY_SLICE_Z = "SliceZ"
 KEY_SLICE_DELTAZ = "DeltaZ"

LuaLibs/CalcPaths.lua

@@ -722,33 +722,26 @@ local function VerifyRibsHoles( vIds)
          local ptS2 = EgtSP( vIds[i])
          local ptE2 = EgtEP( vIds[i])
          
-         local bAdd1 = dist( ptS1, ptE2) < dStrand + 10 * GEO.EPS_SMALL or dist( ptS1, ptS2) < dStrand + 10 * GEO.EPS_SMALL
-         local bAdd2 = dist( ptE1, ptS2) < dStrand + 10 * GEO.EPS_SMALL or dist( ptE1, ptE2) < dStrand + 10 * GEO.EPS_SMALL
-         local bInvert = dist( ptE1, ptE2) < dStrand + 10 * GEO.EPS_SMALL or dist( ptS1, ptS2) < dStrand + 10 * GEO.EPS_SMALL
-         
-         if bInvert then
-            EgtInvertCurve( vIds[i])
-         end
+         local bAdd1 = dist( ptS1, ptE2) < dStrand + 10 * GEO.EPS_SMALL
+         local bAdd2 = dist( ptE1, ptS2) < dStrand + 10 * GEO.EPS_SMALL
+         bAdd = bAdd1 or bAdd2
          
          if bAdd1 and bAdd2 then
-            -- se da unire in setto chiuso
-            bAdd = true
-            EgtAddCurveCompoLine( vIds[i-1], EgtEP( vIds[i]), false)
-            EgtAddCurveCompoLine( vIds[i-1], EgtSP( vIds[i]))
+            -- da unire in setto chiuso
+            EgtAddCurveCompoLine( vIds[i-1], ptE2, false)
+            EgtAddCurveCompoLine( vIds[i-1], ptS2)
             EgtAddCurveCompoCurve( vIds[i-1], vIds[i])
             table.remove( vIds, i)   -- rimuovo il setto dalla tabella
             
          elseif bAdd2 then
-            bAdd = true
             -- unisco il secondo tratto al primo
-            EgtAddCurveCompoLine( vIds[i-1], EgtSP( vIds[i]))
+            EgtAddCurveCompoLine( vIds[i-1], ptS2)
             EgtAddCurveCompoCurve( vIds[i-1], vIds[i])
             table.remove( vIds, i)   -- rimuovo il setto dalla tabella
             
          elseif bAdd1 then
-            bAdd = true
             -- unisco il primo tratto al secondo
-            EgtAddCurveCompoLine( vIds[i], EgtSP( vIds[i-1]))
+            EgtAddCurveCompoLine( vIds[i], ptS1)
             EgtAddCurveCompoCurve( vIds[i], vIds[i-1])
             table.remove( vIds, i-1)  -- rimuovo il setto dalla tabella
          end
@@ -1287,7 +1280,8 @@ local function ComputeRibsOrientedOffset( nRibsGrp)
          local bCCW = EgtGetInfo( vIds[i], KEY_RIBS_USER_LINK_CCW, 'b') or false
          local nLinkOrder = EgtGetInfo( vIds[i], KEY_RIBS_USER_LINK_ORDER, 'i') or 0
          local dStrand = EgtGetInfo( vIds[i], KEY_RIBS_STRAND, 'd')
-         local dOffs = ( nShellsNbr - 1) * dStrand / 2
+         local dStrandOverlap = EgtGetInfo( vIds[i], KEY_RIBS_STRAND_OVERLAP, 'd') or 0
+         local dOffs = ( nShellsNbr - 1) * ( 1 - dStrandOverlap / 100) * dStrand / 2
          
          -- ordine di realizzazione degli offset
          if not bUserLinked then
@@ -1303,7 +1297,7 @@ local function ComputeRibsOrientedOffset( nRibsGrp)
          
          local vOffsRib = {}
          for k = 0, nShellsNbr - 1 do
-            local dOffsCurr = dOffs - k * dStrand
+            local dOffsCurr = dOffs - k * ( 1 - dStrandOverlap / 100) * dStrand
             local nNewId
             if abs( dOffsCurr) < GEO.EPS_SMALL then
                nNewId = EgtCopyGlob( vIds[i], nOffsGrp)
@@ -1424,7 +1418,7 @@ local function ComputeTrimSurfWithOverlapsForRibs( vIds, nGrp, nSrfInt, nSrfExt,
             
          elseif nType == RIB_TYPE.EXTERNAL then
             if not nSrfExt then
-               -- il setto va cancellato
+               -- sono in un CrvGrp intermedio, il setto va cancellato
             elseif nSrfExt == GDB_ID.NULL then
                -- se la superficie non esiste il setto va conservato
                tSurfOffs[vIds[i]] = GDB_ID.NULL
@@ -1443,8 +1437,11 @@ local function ComputeTrimSurfWithOverlapsForRibs( vIds, nGrp, nSrfInt, nSrfExt,
             end
             
          else
-            -- se unbounded non va mai trimmato
-            tSurfOffs[vIds[i]] = GDB_ID.NULL
+            -- il setto unbounded deve comparire solo nell'ultimo CrvGrp senza alcun trim. Se nSrfExt non è definita sono in un CrvGrp intermedio e il setto va cancellato 
+            -- se nSrfExt è definita allora il setto non va trimmato
+            if nSrfExt then
+               tSurfOffs[vIds[i]] = GDB_ID.NULL
+            end
          end
          
          tOffs[vIds[i]] = dOffs
@@ -1607,10 +1604,11 @@ local function AdjustRibsOffsetForIntersection( nCrv1, nCrv2, nOffsGrp, nLoopGrp
    
    local nShells = EgtGetInfo( nCrv1, KEY_RIBS_SHELLS_NBR, 'i')
    local dStrand1 = EgtGetInfo( nCrv1, KEY_RIBS_STRAND, 'd')
+   local dStrandOverlap1 = EgtGetInfo( nCrv1, KEY_RIBS_STRAND_OVERLAP, 'd') or 0
    local dOverlap = EgtGetInfo( nCrv2, KEY_RIBS_OVERLAP, 'i')
    local dStrand2 = EgtGetInfo( nCrv2, KEY_RIBS_STRAND, 'd')
 
-   if dOverlap / 100 * dStrand2 > nShells * dStrand1 * 0.5 - GEO.EPS_SMALL then
+   if dOverlap / 100 * dStrand2 > ( nShells - 1) * ( 1 - dStrandOverlap1 / 100) * dStrand1 * 0.5 + dStrand1 * 0.5 - GEO.EPS_SMALL then
       -- non ha senso spezzare la curva, aggiorno solo split order dei suoi offset
       for i = 1, #vOffs2 do
          CopyInfo( nCrv2, vOffs2[i], KEY_SPLIT_ORDER, 'i')
@@ -1619,7 +1617,7 @@ local function AdjustRibsOffsetForIntersection( nCrv1, nCrv2, nOffsGrp, nLoopGrp
    end
    
    -- calcolo la superficie della curva principale ( nCrv1) da usare per trim
-   local dOffs = nShells * dStrand1 * 0.5 + dStrand2 * ( 0.5 - dOverlap / 100)
+   local dOffs = ( nShells - 1) * ( 1 - dStrandOverlap1 / 100) * dStrand1 * 0.5 + dStrand1 * 0.5 + dStrand2 * ( 0.5 - dOverlap / 100)
    local nSrf = EgtSurfFrFatCurve( nOffsGrp, nCrv1, dOffs, false, false, s_dOffsTol)
    if not nSrf then
       EgtOutLog( 'Error : ribs intersection failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths')
@@ -1678,9 +1676,11 @@ local function AdjustRibsOffsetForIntersection2Shells( nCrv1, nCrv2, nOffsGrp)
   
    -- costruisco le superfici da usare per trim
    local dStrand1 = EgtGetInfo( nCrv1, KEY_RIBS_STRAND, 'd')
-   local nSrf1 = EgtSurfFrFatCurve( nOffsGrp, nCrv1, dStrand1 * 0.5, false, false, s_dOffsTol)
+   local dStrandOverlap1 = EgtGetInfo( nCrv1, KEY_RIBS_STRAND_OVERLAP, 'd') or 0
+   local nSrf1 = EgtSurfFrFatCurve( nOffsGrp, nCrv1, ( 1 - dStrandOverlap1 / 100) * dStrand1 * 0.5, false, false, s_dOffsTol)
    local dStrand2 = EgtGetInfo( nCrv2, KEY_RIBS_STRAND, 'd')
-   local nSrf2 = EgtSurfFrFatCurve( nOffsGrp, nCrv2, dStrand2 * 0.5, false, false, s_dOffsTol)
+   local dStrandOverlap2 = EgtGetInfo( nCrv2, KEY_RIBS_STRAND_OVERLAP, 'd') or 0
+   local nSrf2 = EgtSurfFrFatCurve( nOffsGrp, nCrv2, ( 1 - dStrandOverlap2 / 100) * dStrand2 * 0.5, false, false, s_dOffsTol)
    
    -- trim degli offset di nCrv1
    local vOffs1 = EgtGetNameInGroup( nOffsGrp, EgtGetName( nCrv1)) or {}
@@ -2143,6 +2143,7 @@ local function ReassignInfo( nCrv, nCnt, vOrig)
                CopyInfo( vOrig[i], nId, KEY_RIBS_LEAD_IN_LEN, 'd')
                CopyInfo( vOrig[i], nId, KEY_ASSOCIATED_SURF, 'i')
                CopyInfo( vOrig[i], nId, KEY_RIBS_OVERLAP, 'd')
+               CopyInfo( vOrig[i], nId, KEY_RIBS_STRAND_OVERLAP, 'd')
                CopyInfo( vOrig[i], nId, KEY_RIBS_TYPE, 'i')
                CopyInfo( vOrig[i], nId, KEY_RIBS_LINK, 'b')
                CopyInfo( vOrig[i], nId, KEY_RIBS_LINK_FILLET, 'd')
@@ -2503,7 +2504,7 @@ local function CalcRibsPaths( nSliceGrp, nRibsGrp, LayerParams, vPtStart, bIgnor
                                                              bAllTwoStrands, vTypeSequence, nLoopGrp, tSurfOffs)
       EgtSetInfo( nRibsPathGrp or GDB_ID.NULL, KEY_RIBS_INTERS, bInters)
       EgtSetInfo( nRibsPathGrp or GDB_ID.NULL, KEY_RIBS_SPECIAL_CASE, bSpecialCase)
-      
+     
       -- riordino le costolature
       if bSpecialCase then
          -- gestione caso speciale di intersezione e 2 passate
@@ -2585,7 +2586,8 @@ local function AddFillet( nRib1, vLinks, nRib2, nGrpId)
    local nSplit2 = EgtGetInfo( nRib2, KEY_SPLIT_ID, 'i') or 0
    if nOrig1 == nOrig2 and nSplit1 == nSplit2 then
       local dStrand = EgtGetInfo( nRib1, KEY_RIBS_STRAND, 'd')
-      dFillet1 = min( dFillet1, 0.5 * dStrand)
+      local dStrandOverlap = EgtGetInfo( nRib1, KEY_RIBS_STRAND_OVERLAP, 'd')
+      dFillet1 = min( dFillet1, 0.5 * ( 1 - dStrandOverlap / 100) * dStrand)
       dFillet2 = dFillet1
    end
    
@@ -2833,9 +2835,18 @@ local function HandleRibsIntersectionForRibsMergedShells( vOrigRibs, nRibsGrp, n
                nCrv1, nCrv2 = nCrv2, nCrv1
             end
             
+            -- verifico che la curva secondaria abbia una sola passata
+            local nShells2 = EgtGetInfo( nCrv2, KEY_RIBS_SHELLS_NBR, 'i')
+            if nShells2 > 1 then
+               EgtOutLog( 'Error : shell-merged ribs intersect in a non valid way (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths')
+               table.insert( s_vErr, ' - layer ' .. EgtNumToString( s_nCurrIdx) .. ' : error in ribs-merged shells intersection')
+               return false
+            end
+            
             -- calcolo la superficie della curva principale ( nCrv1) da usare per trim
             local nShells = EgtGetInfo( nCrv1, KEY_RIBS_SHELLS_NBR, 'i')
-            local dOffs = (( nShells + 1) * 0.5 - dOverlap / 100) * dStrand
+            local dStrandOverlap = EgtGetInfo( nCrv1, KEY_RIBS_STRAND_OVERLAP, 'd')
+            local dOffs = (( nShells - 1) * ( 1 - dStrandOverlap / 100) * 0.5 + 1 - dOverlap / 100) * dStrand
             local nSrf = EgtSurfFrFatCurve( nGrpTmp, nCrv1, dOffs, false, false, s_dOffsTol)
             if not nSrf then
                EgtOutLog( 'Error : EgtSurfFrFatCurve for shell-merged ribs intersection failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths')

LuaLibs/CalcSlices.lua

@@ -27,11 +27,19 @@ local MIN_AREA = 25.0
 ---------------------------------------------------------------------
 local function ComputeZSlices( dSliceStep, dZmin, dDeltaZ, dZmax)
    
+   -- verifico se è impostato un numero massimo di slices
+   local nMaxSlicesNbr = EgtGetInfo( s_nPartId, KEY_MAX_SLICES_NBR, 'i') or 0
+   if nMaxSlicesNbr == 0 then
+      nMaxSlicesNbr = GEO.INFINITO   -- da gestire come caso illimitato
+   end
+   
+   local nCnt = 1
    local ptSlices = { dZmin + dDeltaZ}
    local dPosZ = dZmin + dSliceStep
-   while dPosZ < dZmax do
+   while dPosZ < dZmax and nCnt < nMaxSlicesNbr do
       table.insert( ptSlices, dPosZ)
       dPosZ = dPosZ + dSliceStep
+      nCnt = nCnt + 1
    end 
    return ptSlices
 end
@@ -117,6 +125,7 @@ local function GetRibParams( nId)
    ReadParam( nId, KEY_RIBS_LEAD_OUT_WIPE, 'd', 0, RibParam)
    ReadParam( nId, KEY_RIBS_LEAD_OUT_WIPE_DIR, 'd', 0, RibParam)
    ReadParam( nId, KEY_RIBS_OVERLAP, 'd', 0, RibParam)
+   ReadParam( nId, KEY_RIBS_STRAND_OVERLAP, 'd', 0, RibParam)
    ReadParam( nId, KEY_RIBS_LINK, 'b', false, RibParam)
    ReadParam( nId, KEY_RIBS_TYPE, 'i', RIB_TYPE.INTERNAL, RibParam)
    ReadParam( nId, KEY_RIBS_INVERT_STRAND_ORDER, 'b', false, RibParam)
@@ -1144,8 +1153,6 @@ function CalcSlices.Exec( nPartId, nStmId)
    local dZmax = b3Box:getMax():getZ()
    local dMaxH = ComputeMaxH( vRefIds, frSlicing, dSliceStep)
    dZmax = min( dZmax, dMaxH)
-   --dZmin = 708
-   --dZmax = 712
    
    -- Eseguo slicing
    local nLayCnt = 1

LuaLibs/CalcToolPath.lua

@@ -18,7 +18,7 @@ local s_nDefaultWipeAng = -90   -- angolo = 0° per wipe significa che esce orto
 local s_dApproxTol = 0.1
 local s_dHSafeWipe = 2
 local s_nCurrIdx
-local s_dSpiralVaseTanTol = 0.001
+local s_dSpiralVaseMaxLen = 10
 local s_dSpralVaseFirstDelta = 30    -- lunghezza del tratto sul primo layer che va alzato
 
 ---------------------------------------------------------------------
@@ -55,6 +55,15 @@ local function GetLayerParamsForToolPathCalc()
    LayerParams.dInfillCoasting = EgtGetInfo( s_nPartId, KEY_INFILL_COASTING, 'd') or 0
    LayerParams.dInfillWipe = EgtGetInfo( s_nPartId, KEY_INFILL_WIPE, 'd') or 0
    LayerParams.dInfillWipeDir = EgtGetInfo( s_nPartId, KEY_INFILL_WIPE_DIR, 'd') or 0
+   
+   -- parametri dal file macchina per eventuale approssimazione lineare dei percorsi
+   local sMachIni = EgtGetCurrMachineDir() .. '\\' .. EgtGetCurrMachineName() .. '.ini'
+   LayerParams.bLinearApprox = ( EgtGetNumberFromIni( SEC_3DPRINTING, KEY_LINEAR_APPROX, 0, sMachIni) == 1)
+   LayerParams.dLinearApproxTol = EgtGetNumberFromIni( SEC_3DPRINTING, KEY_LINEAR_TOL, 0.1, sMachIni)
+   
+   -- parametri da file ini del programma
+   local sIniFile = EgtGetIniFile()
+   LayerParams.dSpiralVaseInterpLen = EgtGetNumberFromIni( '3dPrinting', 'SpiralVaseInterpLen', 100.0, sIniFile)
 
    return LayerParams
 end
@@ -346,6 +355,8 @@ local function AddLeadIn( nCrvId, LayerParams, nGrpId)
       local dStrand = EgtGetInfo( nCrvId, KEY_CRV_STRAND, 'd')
       EgtSetInfo( nLeadInCrv, KEY_CRV_STRAND, dStrand)
    end
+   
+   return nLeadInCrv
 end
 
 --------------------------------------------------------------------
@@ -1210,7 +1221,8 @@ local function VerifyRibsLink( nLinkId, nCurr, nNext, nGrpTmp, dStrand)
          local dOffs
          if nOrigId == nOrigCurr or nOrigId == nOrigNext then
             -- 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
+            local dStrandOverlap = EgtGetInfo( vRibsIds[i], KEY_RIBS_STRAND_OVERLAP, 'd')
+            dOffs = dCurrStrand * ( 0.5 - dStrandOverlap / 100)
          else
             -- altrimenti verifico che le regioni del link e del setto non si sovrappongono ( a meno dell'overlap fissato)
             dOffs = dCurrStrand * 0.5 + ( 0.5 - dOverlap / 100) * dStrand - 50 * GEO.EPS_SMALL
@@ -1339,8 +1351,15 @@ local function CalcRibsLink( nCurr, nNext, nLoopGrp, bForceLink, vtSlicing, nGrp
    local dStrand1 = EgtGetInfo( nCurr, KEY_CRV_STRAND, 'd')
    local dStrand2 = EgtGetInfo( nNext, KEY_CRV_STRAND, 'd')
    local dStrand = max( dStrand1, dStrand2)
+   
    local dFillet1 = EgtGetInfo( nCurr, KEY_RIBS_LINK_FILLET, 'd')
    local dFillet2 = EgtGetInfo( nNext, KEY_RIBS_LINK_FILLET, 'd')
+   if bForceLink then
+      local dStrandOverlap1 = EgtGetInfo( nCurr, KEY_RIBS_STRAND_OVERLAP, 'd')
+      local dStrandOverlap2 = EgtGetInfo( nNext, KEY_RIBS_STRAND_OVERLAP, 'd')
+      dFillet1 = min( dFillet1, ( 1 - dStrandOverlap1 / 100) * dStrand1 * 0.5)
+      dFillet2 = min( dFillet2, ( 1 - dStrandOverlap2 / 100) * dStrand2 * 0.5)
+   end
    
    local vCrvIds = EgtGetAllInGroup( nLoopGrp)
    -- recupero le curve di bordo su cui poggiano i setti e i corrispondenti parametri
@@ -1373,10 +1392,6 @@ local function CalcRibsLink( nCurr, nNext, nLoopGrp, bForceLink, vtSlicing, nGrp
          
          if nLinkId then
             -- fillet
-            if bForceLink then
-               dFillet1 = min( dFillet1, dStrand1 * 0.5)
-               dFillet2 = min( dFillet2, dStrand2 * 0.5)
-            end
             AddFillet( nCurr, nLinkId, dFillet1, vtSlicing)
             AddFillet( nLinkId, nNext, dFillet2, vtSlicing)
             -- assegno le info
@@ -1402,8 +1417,6 @@ local function CalcRibsLink( nCurr, nNext, nLoopGrp, bForceLink, vtSlicing, nGrp
       local bValid = VerifyRibsLink( nLinkId, nCurr, nNext, nGrpTmp, dStrand)
       if bValid then
          -- fillet
-         dFillet1 = min( dFillet1, dStrand1 * 0.5)
-         dFillet2 = min( dFillet2, dStrand2 * 0.5)
          AddFillet( nCurr, nLinkId, dFillet1, vtSlicing)
          AddFillet( nLinkId, nNext, dFillet2, vtSlicing)
          return nLinkId
@@ -1459,56 +1472,49 @@ end
 local function VerifyRibsLead( nId, nRibId, bInVsOut, nGrpTmp)
 
    local dStrand = EgtGetInfo( nRibId, KEY_CRV_STRAND, 'd')
-   local dOverlap = EgtGetInfo( nRibId, KEY_RIBS_OVERLAP, 'd')
+   local dShellOverlap = EgtGetInfo( nRibId, KEY_RIBS_OVERLAP, 'd')
+   local dStrandOverlap = EgtGetInfo( nRibId, KEY_RIBS_STRAND_OVERLAP, 'd')
+   local dOverlap = max( dShellOverlap, dStrandOverlap)
+   local nOrigRib = EgtGetInfo( nRibId, KEY_ORIGINAL_RIB, 'i')
    local dLen = EgtCurveLength( nId)
    
    -- porto il lead nel gruppo locale
    local nLeadLoc = EgtCopyGlob( nId, nGrpTmp)
- 
-   -- individuo eventuale lead in o link relativo al setto corrente ( solo se collega due passate dello stesso setto)
-   local nCurrLI
-   local nCurrLink
-   if bInVsOut then
-      -- se è lead in devo solo verificare se seguito da un link
-      local nNext = EgtGetNext( nRibId)
-      if nNext and EgtGetName( nNext) == LINK_CRV then
-         local nNextRib = EgtGetNext( nNext)
-         local nOrigRib = EgtGetInfo( nRibId, KEY_ORIGINAL_RIB, 'i') or -1
-         local nOrigRibPrev = EgtGetInfo( nNextRib, KEY_ORIGINAL_RIB, 'i') or -1
-         if nOrigRib == nOrigRibPrev then
-            nCurrLink = nNext
-         end
-      end
-   else
-      -- se è lead out devo verificare se preceduto da lead in o da link
-      local nPrev = EgtGetPrev( nRibId)
-      if nPrev and EgtGetName( nPrev) == LEAD_IN_CRV then
-         nCurrLI = nPrev
-      elseif nPrev and EgtGetName( nPrev) == LINK_CRV then
-         local nPrevRib = EgtGetPrev( nPrev)
-         local nOrigRib = EgtGetInfo( nRibId, KEY_ORIGINAL_RIB, 'i') or -1
-         local nOrigRibPrev = EgtGetInfo( nPrevRib, KEY_ORIGINAL_RIB, 'i') or -1
-         if nOrigRib == nOrigRibPrev then
-            nCurrLink = nPrev
-         end
-      end
-   end
    
    -- 1) verifico se interseca altri setti, lead in, lead out o collegamenti
    -- recupero gli id degli elementi da controllare
    local vCheckIds = {}
    local nCurrId = EgtGetFirstInGroup( EgtGetParent( nRibId))
    while nCurrId do
-      -- 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)
+      if nCurrId ~= nRibId and nCurrId ~= nId then
+         -- 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
+            -- controllo che non sia un elemento relativo ad un'altra passata del setto corrente
+            if EgtGetName( nCurrId) == LEAD_IN_CRV then
+               -- il setto di riferimento è l'elemento successivo
+               local nCurrOrigRib = EgtGetInfo( EgtGetNext( nCurrId), KEY_ORIGINAL_RIB, 'i') or -1
+               if nOrigRib ~= nCurrOrigRib then
+                  table.insert( vCheckIds, nCurrId)
+               end
+            elseif EgtGetName( nCurrId) == LINK_CRV then
+               -- il link va controllato se non congiunge due passate del setto corrente
+               local nOrigRib1 = EgtGetInfo( EgtGetPrev( nCurrId), KEY_ORIGINAL_RIB, 'i') or -1
+               local nOrigRib2 = EgtGetInfo( EgtGetNext( nCurrId), KEY_ORIGINAL_RIB, 'i') or -1
+               if nOrigRib ~= nOrigRib1 or nOrigRib ~= nOrigRib2 then
+                  table.insert( vCheckIds, nCurrId)
+               end
+            else
+               local nCurrOrigRib = EgtGetInfo( nCurrId, KEY_ORIGINAL_RIB, 'i')
+               if nOrigRib ~= nCurrOrigRib then
+                  table.insert( vCheckIds, nCurrId)
+               end
+            end
          end
       end
       nCurrId = EgtGetNext( nCurrId)
    end
+   
    -- tra gli id da controllare devo aggiungere anche altri setti non ancora presenti nel toolpath ( tipologie di setti realizzate in seguito)
    local nCrvGrp = EgtGetParent( EgtGetParent( nRibId))
    local nRibsPathGrp = EgtGetFirstNameInGroup( nCrvGrp, RIBS_GRP)
@@ -1561,26 +1567,29 @@ local function VerifyRibsLead( nId, nRibId, bInVsOut, nGrpTmp)
    end
    
    -- 3) verifiche con eventuale lead in
-   if nCurrLI then
-      local nLeadInLoc = EgtCopyGlob( nCurrLI, nGrpTmp)
-      -- verifico se intersezione fra curve
-      local _, nPnt, nCrv = EgtCurveCurveInters( nLeadLoc, nLeadInLoc, nGrpTmp)
-      if nPnt ~= 0 or nCrv ~= 0 then
-         return false
-      end
-      local dLeadInLen = EgtCurveLength( nLeadInLoc)
-      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
-               return false
-            else
-               local dLen = EgtCurveLength( nRes)
-               if dLen < dStrand / 2 + GEO.EPS_SMALL then
+   if not bInVsOut then
+      local nCurrLI = EgtGetPrev( nRibId)
+      if nCurrLI and EgtGetName( nCurrLI) == LEAD_IN_CRV then
+         local nLeadInLoc = EgtCopyGlob( nCurrLI, nGrpTmp)
+         -- verifico se intersezione fra curve
+         local _, nPnt, nCrv = EgtCurveCurveInters( nLeadLoc, nLeadInLoc, nGrpTmp)
+         if nPnt ~= 0 or nCrv ~= 0 then
+            return false
+         end
+         local dLeadInLen = EgtCurveLength( nLeadInLoc)
+         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
                   return false
+               else
+                  local dLen = EgtCurveLength( nRes)
+                  if dLen < dStrand / 2 + GEO.EPS_SMALL then
+                     return false
+                  end
                end
             end
          end
@@ -1841,7 +1850,7 @@ local function CalcRibsToolPath( vEntIds, nRibsGrp, nTpathGrpId, LayerParams)
    local nGrpTmp = EgtGroup( nRibsGrp, frLoc, GDB_RT.GLOB)
    
    -- aggiungo le costolature nel toolpath
-   local nLastEnt = EgtGetLastInGroup( nTpathGrpId)
+   local nLastEnt = EgtGetLastInGroup( nTpathGrpId) or GDB_ID.NULL
    for i = 1, #vEntIds do
       -- copio entità nel gruppo toolpath
       local nNewEntId = EgtCopyGlob( vEntIds[i], nTpathGrpId, GDB_IN.LAST_SON)
@@ -1867,7 +1876,7 @@ local function CalcRibsToolPath( vEntIds, nRibsGrp, nTpathGrpId, LayerParams)
    
    -- recupero i gruppi delle costolature
    local tabRibs = {}
-   local nFirst = EgtGetNext( nLastEnt)
+   local nFirst = EgtGetNext( nLastEnt) or EgtGetFirstInGroup( nTpathGrpId)
    while nFirst do
       local sName = EgtGetName( nFirst)
       local vIds = EgtGetNameInGroup( nTpathGrpId, sName)
@@ -1990,6 +1999,9 @@ local function AddSpiralVaseLeadOut( nOldId, LayerParams)
       EgtTrimCurveEndAtLen( nOldId, EgtCurveLength( nOldId) - LayerParams.dOffsetLP)
       local nLeadOut = AddLeadOut( nOldId, LayerParams, EgtGetParent( nOldId))
       if nLeadOut then
+         if LayerParams.bLinearApprox then
+            EgtApproxCurve( nLeadOut, GDB_CA.LINES, LayerParams.dLinearApproxTol)
+         end
          local dDelta = LayerParams.dLayHeight / EgtCurveLength( nOldId) * EgtCurveLength( nLeadOut)
          EgtSpiralizeCurveAlongExtrusion( nLeadOut, dDelta)
       end
@@ -2090,53 +2102,83 @@ local function SpiralVase( vLayIds, LayerParams)
                local nNewPart = EgtSplitCurveAtParam( nNewEntId, dTrimPar)
                EgtSpiralizeCurveAlongExtrusion( nNewPart, 0.5 * LayerParams.dLayHeight)
                
+               if LayerParams.bLinearApprox then
+                  EgtApproxCurve( nNewEntId, GDB_CA.LINES, LayerParams.dLinearApproxTol)
+                  EgtApproxCurve( nNewPart, GDB_CA.LINES, LayerParams.dLinearApproxTol)
+               end
+               
                -- eventuale lead in
                if LayerParams.nLeadInType ~= LEAD_TYPE.NONE then
                   EgtTrimCurveStartAtLen( nNewEntId, LayerParams.dOffsetLP)
-                  AddLeadIn( nNewEntId, LayerParams, nTpathGrpId)
+                  local nLeadInCrv = AddLeadIn( nNewEntId, LayerParams, nTpathGrpId)
+                  if nLeadInCrv and LayerParams.bLinearApprox then
+                     EgtApproxCurve( nLeadInCrv, GDB_CA.LINES, LayerParams.dLinearApproxTol)
+                  end
                end
             else
+               -- a) garantisco continuità con layer precedente
                local ptOld = EgtEP( nOldId, GDB_ID.ROOT)
                if nRealLayer == 2 then
                   -- aggiusto la quota per confronto sensato
                   ptOld = ptOld - 0.5 * LayerParams.dLayHeight * LayerParams.vtSlicing
                end
                local ptNew = EgtSP( nNewEntId, GDB_ID.ROOT)
-               -- modifico la curva per avere una transizione più uniforme tra i due layers
-               if EgtCurveCompoRadius( nNewEntId, 0) == -1  and dist( ptOld, ptNew) / EgtCurveCompoLength( nNewEntId, 0) < s_dSpiralVaseTanTol then
-                  -- se i punti sono abbastanza vicini e la curva inizia con un tratto lineare sufficientemente lungo allora distribuisco la differenza tra i
-                  -- due layer solo sul primo tratto
-                  EgtModifyCurveStartPoint( nNewEntId, ptOld, GDB_RT.GLOB)
-               else
-                  -- distribuisco la differenza su tutta la curva
-                  if not AreSamePointApprox( ptOld, ptNew) then
-                     -- recupero la curva da usare come guida
-                     local nGuideId = EgtCopyGlob( nOldPathId, nPathGrpId)
-                     -- la rendo coerente con il toolpath
-                     EgtMove( nGuideId, vtMove + LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB)
-                     if LayerParams.bInvert then
-                       EgtInvertCurve( nGuideId)
-                     end
-                     -- modifico i punti iniziali affinchè coincidano con il punto finale del percorso precedente
-                     EgtChangeClosedCurveStartPoint( nGuideId, ptOld, GDB_RT.GLOB)
-                     EgtChangeClosedCurveStartPoint( nNewEntId, ptOld, GDB_RT.GLOB)
+               
+               -- se il punto di inizio non coincide con quello finale del percorso calcolato fino ad ora, modifico la curva per avere una transizione più uniforme tra i due layers
+               if not AreSamePointApprox( ptOld, ptNew) then
+                  -- recupero la curva da usare come guida
+                  local nGuideId = EgtCopyGlob( nOldPathId, nPathGrpId)
+                  -- la rendo coerente con il toolpath
+                  EgtMove( nGuideId, vtMove + LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB)
+                  if LayerParams.bInvert then
+                     EgtInvertCurve( nGuideId)
+                  end
+                  -- approssimo con tratti lineari imponendo lunghezza massima per migliorare spiralize
+                  EgtApproxCurve( nGuideId, GDB_CA.SPECIAL_LINES, 0.01, s_dSpiralVaseMaxLen)
+                  EgtApproxCurve( nNewEntId, GDB_CA.SPECIAL_LINES, 0.01, s_dSpiralVaseMaxLen)
+                  -- modifico i punti iniziali affinchè coincidano con il punto finale del percorso precedente
+                  EgtChangeClosedCurveStartPoint( nGuideId, ptOld, GDB_RT.GLOB)
+                  EgtChangeClosedCurveStartPoint( nNewEntId, ptOld, GDB_RT.GLOB)
+
+                  -- distribuisco la differenza sulla curva
+                  local dLen = EgtCurveLength( nNewEntId)
+                  if LayerParams.dSpiralVaseInterpLen < GEO.EPS_SMALL or LayerParams.dSpiralVaseInterpLen > dLen - GEO.EPS_SMALL then
+                     -- la differenza deve essere distribuita su tutta la curva
                      EgtSpiralizeCurveAlongGuide( nNewEntId, nGuideId)
                      -- forzo il punto di inizio a coincidere con il layer precedente ( non è garantito dallo spiralize con il path a causa dell'approx
                      -- con gli archi che potrebbe modificare il punto finale del tpath rispetto a quello del path associato)
                      EgtModifyCurveStartPoint( nNewEntId, ptOld, GDB_RT.GLOB)
-               
-                     EgtErase( nGuideId)
+
+                  else
+                     -- la differenza deve essere distribuita solo su un sottotratto di lunghezza LayerParams.dSpiralVaseAdjLen
+                     local dParSplit = EgtCurveParamAtLength( nNewEntId, LayerParams.dSpiralVaseInterpLen)
+                     local nNewEndId2 = EgtSplitCurveAtParam( nNewEntId, dParSplit)
+                     -- trim della curva guida
+                     local _, _, dParMinDist = EgtPointCurveDist( EgtEP( nNewEntId, GDB_ID.ROOT), nGuideId, GDB_RT.GLOB)
+                     local nGuideId2 = EgtSplitCurveAtParam( nGuideId, dParMinDist)
+                     EgtErase( nGuideId2)
+                     -- spiralize solo del primo pezzo
+                     EgtSpiralizeCurveAlongGuide( nNewEntId, nGuideId)
+                     EgtModifyCurveStartPoint( nNewEntId, ptOld, GDB_RT.GLOB)
+                     EgtModifyCurveEndPoint( nNewEntId, EgtSP( nNewEndId2, GDB_ID.ROOT), GDB_RT.GLOB)
+                     -- riassemblo la curva
+                     EgtAddCurveCompoCurve( nNewEntId, nNewEndId2)
                   end
+                  
+                  EgtErase( nGuideId)
                end
-               
-               -- approssimo
+
+               -- b) approssimo
                local ptS = EgtSP( nNewEntId, GDB_ID.ROOT)
                EgtApproxCurve( nNewEntId, GDB_CA.ARCS, s_dApproxTol)
+               if LayerParams.bLinearApprox then
+                  EgtApproxCurve( nNewEntId, GDB_CA.LINES, LayerParams.dLinearApproxTol)
+               end
                if EgtCurveIsClosed( nNewEntId) then
                   EgtChangeClosedCurveStartPoint( nNewEntId, ptS, GDB_RT.GLOB)
                end
                
-               -- modifica graduale del'altezza
+               -- c) modifica graduale dell'altezza
                if nRealLayer == 2 then
                   -- se seconda passata la prima metà deve essere a quota costante 0.5 * dLayHeight, la seconda metà deve salire gradualmente di 0.5 * dLayHeight
                   EgtMove( nNewEntId, 0.5 * LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB)
@@ -2156,33 +2198,28 @@ local function SpiralVase( vLayIds, LayerParams)
                -- il primo tratto si trova a metà altezza rispetto allo strato precedente, quindi il coefficiente moltiplicativo è due
                EgtSetInfo( vTPathsCrvs[1], KEY_FEED_COEFF, 2)
                -- nel secondo tratto l'altezza è variabile quindi devo calcolare il coefficiente per ogni sottotratto
-               local ptRef = EgtEP( vEntIds[1], GDB_ID.ROOT)
+               local dLenTot = EgtCurveLength( vTPathsCrvs[1]) + EgtCurveLength( vTPathsCrvs[2])
+               local dLen = EgtCurveLength( vTPathsCrvs[1])
                local nFirst, nCnt = EgtExplodeCurveCompo( vTPathsCrvs[2])
                for nId = nFirst, nFirst + nCnt - 1 do
-                  local dZLoc
-                  if nSlicingType == SLICING_TYPE.VERTICAL then
-                     dZLoc = ( ( EgtEP( nId, GDB_ID.ROOT) - ptRef)) * LayerParams.vtSlicing
-                  else
-                     dZLoc = ( ( EgtEP( nId, GDB_ID.ROOT) - ptRef)) * LayerParams.vtSlicing - LayerParams.dLayHeight
-                  end
-                  local dFeedCoeff = LayerParams.dLayHeight / dZLoc
+                  -- calcolo l'altezza effettiva basandomi sulla lunghezza parziale ( viene mimato il conto fatto in EgtSpiralizeCurveAlongExtrusion)
+                  dLen = dLen + EgtCurveLength( nId)
+                  local dHEff = LayerParams.dLayHeight * dLen / dLenTot
+                  local dFeedCoeff = LayerParams.dLayHeight / dHEff
                   EgtSetInfo( nId, KEY_FEED_COEFF, dFeedCoeff)
                end
                nOldId = nFirst + nCnt - 1
+               
             elseif nRealLayer == 3 then
                -- solo la prima metà si trova ad un'altezza variabile rispetto allo strato precedente
+               local dLenTot = EgtCurveLength( vTPathsCrvs[1])
+               local dLen = 0
                local nNewId = EgtSplitCurve( vTPathsCrvs[1], 2)
-               local ptRef = EgtEP( vEntIds[1], GDB_ID.ROOT)
                local nFirst, nCnt = EgtExplodeCurveCompo( nNewId)
                for nId = nFirst, nFirst + nCnt - 1 do
-                  local dZLoc
-                  if nSlicingType == SLICING_TYPE.VERTICAL then
-                     dZLoc = ( EgtEP( nId, GDB_ID.ROOT) - ptRef) * LayerParams.vtSlicing + 0.5 * LayerParams.dLayHeight
-                  else
-                     dZLoc = ( EgtEP( nId, GDB_ID.ROOT) - ptRef) * LayerParams.vtSlicing - 0.5 * LayerParams.dLayHeight
-                  end
-                  
-                  local dFeedCoeff = LayerParams.dLayHeight / dZLoc
+                  dLen = dLen + EgtCurveLength( nId)
+                  local dHeff = LayerParams.dLayHeight * ( dLen / dLenTot + 0.5)
+                  local dFeedCoeff = LayerParams.dLayHeight / dHeff
                   EgtSetInfo( nId, KEY_FEED_COEFF, dFeedCoeff)
                end
                nOldId = nNewId + 1
@@ -2321,6 +2358,15 @@ function CalcToolPath.Exec( nPartId)
             nLayCnt = nIdx
          end
          
+         -- eventuale approssimazione delle curve
+         if LayerParams.bLinearApprox then
+            local nCrvId = EgtGetFirstInGroup( nTpathGrpId)
+            while nCrvId do
+               EgtApproxCurve( nCrvId, GDB_CA.LINES, LayerParams.dLinearApproxTol)
+               nCrvId = EgtGetNext( nCrvId)
+            end
+         end
+         
          -- passo al gruppo di contorni successivo
          nCrvGrpId = EgtGetNextName( nCrvGrpId, CONTOUR_GRP.."*")
       end

LuaLibs/RunMachParamFromSWCalc.lua

@@ -189,8 +189,10 @@ function RunMachParamFromSWCalc.Exec()
             dLayerTime = dTotLayerLength / dLayerFeed * 60
          end
          dLayerWait = floor( dTMin + 0.5) - floor( dLayerTime + 0.5)
+         -- sezione dello strand
+         local dSect = max( ( dStrandMean - dSliceStep) * dSliceStep, 0) + pi * dSliceStep * dSliceStep / 4
          -- calcolo la portata
-         local Vf = dLayerFeed * ( ( dStrandMean - dSliceStep) * dSliceStep + pi * pow( dSliceStep / 2, 2)) / 1000
+         local Vf = dLayerFeed * dSect / 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
@@ -205,7 +207,7 @@ function RunMachParamFromSWCalc.Exec()
          end
          if not bSpeedOk then
             if dTotLayerLength > 0.1 then
-               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))
+               dLayerFeed = ( MATERIAL.C1 * pow( ( dSpeed / (( MATERIAL.K_EXTRUSION / 100.0) * ( MACHINING.K / 100.0))), MATERIAL.C2)) * 1000 / dSect
                dLayerTime = dTotLayerLength / dLayerFeed * 60
             end
             dLayerWait = floor( dTMin + 0.5) - floor( dLayerTime + 0.5)

Version.lua

@@ -1,4 +1,4 @@
--- Version.lua by Egaltech s.r.l. 2024/05/06
+-- Version.lua by Egaltech s.r.l. 2025/09/12
 -- Gestione della versione di 3dPrinting
 
-VERSION = '2.7d1'
+VERSION = '2.7j1'