3dPrinting :

- correzione solidi spiral vase.

LuaLibs/AddManData.lua

@@ -45,6 +45,8 @@ SEC_DEFAULT = "Default"
 KEY_PARAMS = "Params"
 KEY_CALC_SOLIDS = "CalcSolids"
 KEY_SPIRAL_VASE = "SpiralVase"
+KEY_SPIRAL_VASE_LEN = 'SpiralVaseLen'
+KEY_SPIRAL_VASE_INTERP_LEN = 'SpiralVaseInterpLen'
 KEY_SLICING_TYPE = "SlicingType"
 KEY_SLICING_DIR = "SlicingDir"
 KEY_SLICE_STEP = "StrandH"
@@ -111,6 +113,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"
@@ -178,9 +181,13 @@ KEY_COEFF_X = "CoeffX"
 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"
@@ -207,8 +214,9 @@ KEY_LAYER_CNT = "LayerCnt"
 KEY_CRV_OFFSET = "CurveOffset"
 KEY_ORIG_REF = "Orig"
 KEY_WIPE_ON_CRV = "WipeOnCrv"
+KEY_FEED_COEFF = 'FeedCoeff'
 
-SLICING_TYPE = {
+SLICING_TYPE = {   
    VERTICAL = 1,
    DEG45_X = 2,
    DEG45_Y = 3,

LuaLibs/CalcPaths.lua

@@ -21,7 +21,7 @@ local s_vtSlicing
 local s_dOffsTol = 50 * GEO.EPS_SMALL
 
 ---------------------------------------------------------------------
-local function GetLayerParamsForPathCalc()   
+local function GetLayerParamsForPathCalc()
    local LayerParams = {}
    LayerParams.bSpiralVase = EgtGetInfo( s_nPartId, KEY_SPIRAL_VASE, 'b') or false
    LayerParams.nShellsNbr = EgtGetInfo( s_nPartId, KEY_SHELLS_NBR, 'i')
@@ -451,7 +451,8 @@ end
 ---------------------------------------------------------------------------
 local function ReorderPath( vOldIds, vNewIds)
    
-   if not vNewIds or not vOldIds then return end
+   if not vNewIds or #vNewIds == 0 then return end
+   if not vOldIds or #vOldIds == 0 then return end
    
    -- suddivido in base alla tipologia di loop ( esterno o interno)
    local tOldIds = {{}, {}}
@@ -721,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
@@ -980,7 +974,7 @@ end
 -------------------------------------------------------------------
 local function FindHoleCurve( pt, vLoopIds)
    -- trovo indice della curva di vLoopIds a cui appartiene pt ( in globale)
-   if not vLoopIds then return end
+   if not vLoopIds or #vLoopIds == 0 then return end
    for i = 1, #vLoopIds do
       local dPar = EgtCurveParamAtPoint( vLoopIds[i], pt, 100 * GEO.EPS_SMALL, GDB_RT.GLOB)
       if dPar then
@@ -1286,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
@@ -1302,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)
@@ -1423,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
@@ -1442,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
@@ -1606,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')
@@ -1618,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')
@@ -1677,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 {}
@@ -1726,13 +1727,12 @@ end
 local function HandleRibsIntersections( nRibsGrp, nOffsGrp, nRibsPathGrp, nSrfInt, nSrfExt, bAllTwoStrands, vTypeSequence, nLoopGrp, tSurfOffs)
 
    local bSpecialCase = false
-   local vOffsIds = EgtGetNameInGroup( nRibsPathGrp, RIBS_CRV .. '*')   -- passate dei setti
    local vAllRibsIds = EgtGetNameInGroup( nRibsGrp, RIBS_CRV .. '*')    -- setti originali
    local vRibsIds = {}
    -- ignoro setti che non hanno passate corrispondenti
    for i = 1, #vAllRibsIds do
       local vOffs = EgtGetNameInGroup( nRibsPathGrp, EgtGetName( vAllRibsIds[i]))
-      if vOffs then table.insert( vRibsIds, vAllRibsIds[i]) end
+      if vOffs and #vOffs > 0 then table.insert( vRibsIds, vAllRibsIds[i]) end
    end
    
    -- creo un gruppo con frame locale per calcolare le intersezioni ( è il piano XY locale dove calcolare intersezioni)
@@ -2040,6 +2040,9 @@ local function ShortestPathForRibs( vRibs, nGrp, bInvertOrder)
    if #tabRibs == 1 then
       -- se un solo gruppo ordinamento banale
       vOrd = {1}
+   elseif #tabRibs == 2 then
+      -- se due gruppi fisso l'ordinamento per evitare inversioni tra i layers
+      vOrd = { 1, 2}
    else
       -- se più gruppi ordinamento con shortest path
       EgtSpInit()
@@ -2143,6 +2146,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')
@@ -2394,7 +2398,7 @@ local function CalcRibsPaths( nSliceGrp, nRibsGrp, LayerParams, vPtStart, bIgnor
       local nSrfInt = EgtGetFirstNameInGroup( vCrvGrps[i], TOT_SHELL_TRIM_SURF) or GDB_ID.NULL
       if nTotSrfInt == GDB_ID.NULL and nSrfInt ~= GDB_ID.NULL then
          nTotSrfInt = EgtCopyGlob( nSrfInt, nRibsGrp)
-      elseif nTotSrfInt ~= GDB_ID.NULL then
+      elseif nTotSrfInt ~= GDB_ID.NULL and nSrfInt ~= GDB_ID.NULL then
          if not EgtSurfFrAdd( nTotSrfInt, nSrfInt) then
             EgtOutLog( 'Error : EgtSurfFrAdd for external ribs failed. Errors may occur with user-linked ribs (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths')
          end
@@ -2503,7 +2507,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 +2589,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
    
@@ -2807,7 +2812,7 @@ local function HandleRibsIntersectionForRibsMergedShells( vOrigRibs, nRibsGrp, n
    -- ignoro setti che non hanno passate corrispondenti
    for i = 1, #vOrigRibs do
       local vOffs = EgtGetNameInGroup( nRibsGrp, EgtGetName( vOrigRibs[i]))
-      if vOffs then table.insert( vRibsIds, vOrigRibs[i]) end
+      if vOffs and #vOffs > 0 then table.insert( vRibsIds, vOrigRibs[i]) end
    end
    
    -- creo un gruppo con frame locale per calcolare le intersezioni ( è il piano XY locale dove calcolare intersezioni)
@@ -2833,9 +2838,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')
@@ -3103,26 +3117,38 @@ end
 
 --------------------------------------------------------------------
 local function AdjustRibsMergedExtraShellLink( nLinkId, vExtraShells, nGrp)
-   
-   local frLoc = Frame3d( ORIG(), s_vtSlicing)
-   local nGrpLoc = EgtGroup( nGrp, frLoc)
+
    local vLinks = {}
    
-   -- devo conservare solo le intersezioni fra link ed extra shell
+   -- devo conservare solo i tratti comuni fra link ed extra shell
    for i = 1, #vExtraShells do
-      local nRes, nPntCnt, nCrvCnt = EgtCurveCurveInters( nLinkId, vExtraShells[i], nGrpLoc)
-      if nRes then
-         for nId = nRes + nPntCnt, nRes + nPntCnt + nCrvCnt - 1 do
-            EgtRelocateGlob( nId, nGrp)
-            EgtModifyCurveExtrusion( nId, s_vtSlicing, GDB_ID.ROOT)
-            table.insert( vLinks, nId)
+      
+      local dParS = EgtCurveParamAtPoint( nLinkId, EgtSP( vExtraShells[i]), 100 * GEO.EPS_SMALL)
+      local dParE = EgtCurveParamAtPoint( nLinkId, EgtEP( vExtraShells[i]), 100 * GEO.EPS_SMALL)
+      if dParS or dParE then
+         local nCrv = EgtCopyGlob( nLinkId, nGrp)
+         if dParS and dParE then
+            EgtTrimCurveStartEndAtParam( nCrv, dParS, dParE)
+         elseif dParS then
+            EgtTrimCurveStartAtParam( nCrv, dParS)
+         elseif dParE then
+            EgtTrimCurveEndAtParam( nCrv, dParE)
+         end
+         EgtModifyCurveExtrusion( nCrv, s_vtSlicing, GDB_ID.ROOT)
+         table.insert( vLinks, nCrv)
+      else
+         
+         -- verifico se il link originale è già corretto
+         local dPar1 = EgtCurveParamAtPoint( vExtraShells[i], EgtSP( nLinkId), 100 * GEO.EPS_SMALL)
+         local dPar2 = EgtCurveParamAtPoint( vExtraShells[i], EgtEP( nLinkId), 100 * GEO.EPS_SMALL)
+         if dPar1 and dPar2 then
+            return { nLinkId}
          end
       end
    end
    
    -- cancello il link originale
    EgtErase( nLinkId)
-   EgtErase( nGrpLoc)
    return vLinks
 end
 
@@ -3752,7 +3778,7 @@ local function ReorderExtraShells( nPathGrp, vPtStart, LayerParams)
    end
    
    local vIds = EgtGetNameInGroup( nPathGrp, EXTRA_SHELL_CRV .. '*')
-   if not vIds then return end
+   if not vIds or #vIds == 0 then return end
    
    -- eventuale inversione di tutte le curve
    if LayerParams.bPrintInvert then
@@ -4101,7 +4127,7 @@ end
 local function AddExtraZigZag( nSrf, sName, dStrand, nGrp, nSrfTrim)
    
    local vIds = EgtGetNameInGroup( nGrp, sName)
-   if not vIds then return end
+   if not vIds or #vIds == 0 then return end
    local vtDir = EgtSV( vIds[1], GDB_ID.ROOT)
    local vtYLoc = s_vtSlicing ^ vtDir
    
@@ -4308,7 +4334,7 @@ function CalcPaths.Exec( nPartId)
    s_nPartId = nPartId
 
    local vLayIds = EgtGetNameInGroup( s_nPartId, SLICE_LAYER.."*")
-   if not vLayIds then
+   if not vLayIds or #vLayIds == 0 then
       EgtOutBox( 'Error no slice', 'PathCalc')
       return true
    end

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)
@@ -1000,6 +1009,7 @@ local function SlicingWithSolid( nStmId, vZSlices, dDeltaZStart, dZmin, frSlicin
          
          if #vOpenId > 1 then
             EgtOutLog( 'Error : hole in solid (layer '.. EgtNumToString( nLayCnt) ..') - CalcSlices')
+            table.insert( s_vErr, nLayCnt)
          end
       else
          
@@ -1143,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

@@ -14,10 +14,12 @@ local AMD = require( 'AddManData')
 
 ---------------------------------------------------------------------
 local s_nPartId
-local s_nDefaultWipeAng = -90   -- angolo = 0° per wipe significa che esce ortogonalmente alla direzione del movimento
+local s_nDefaultWipeAng = -90        -- angolo = 0° per wipe significa che esce ortogonalmente alla direzione del movimento
 local s_dApproxTol = 0.1
 local s_dHSafeWipe = 2
 local s_nCurrIdx
+local s_dSpiralVaseMaxLen = 10       -- lunghezza massima dei tratti per calcolo SpiralizeAlongGuide
+local s_dSpralVaseFirstDelta = 30    -- lunghezza del tratto sul primo layer che va alzato nella modalità SpiralVaseFull
 
 ---------------------------------------------------------------------
 local function GetLayerParamsForToolPathCalc()
@@ -53,7 +55,17 @@ 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', KEY_SPIRAL_VASE_INTERP_LEN, 100.0, sIniFile)
+   LayerParams.dSpiralVaseLen = EgtGetNumberFromIni( '3dPrinting', KEY_SPIRAL_VASE_LEN, 0.0, sIniFile)
+   
    return LayerParams
 end
 
@@ -341,9 +353,12 @@ local function AddLeadIn( nCrvId, LayerParams, nGrpId)
       EgtModifyCurveExtrusion( nLeadInCrv, LayerParams.vtSlicing, GDB_RT.GLOB)
       EgtSetInfo( nLeadInCrv, KEY_TYPE, TYPE.LINK)
       EgtSetName( nLeadInCrv, LEAD_IN_CRV)
+      EgtSetColor( nLeadInCrv, EgtStdColor('GRAY'))
       local dStrand = EgtGetInfo( nCrvId, KEY_CRV_STRAND, 'd')
       EgtSetInfo( nLeadInCrv, KEY_CRV_STRAND, dStrand)
    end
+   
+   return nLeadInCrv
 end
 
 --------------------------------------------------------------------
@@ -373,6 +388,7 @@ local function AddLeadOut( nCrvId, LayerParams, nGrpId)
       EgtModifyCurveExtrusion( nLeadOutCrv, LayerParams.vtSlicing, GDB_RT.GLOB)
       EgtSetInfo( nLeadOutCrv, KEY_TYPE, TYPE.LINK)
       EgtSetName( nLeadOutCrv, LEAD_OUT_CRV)
+      EgtSetColor( nLeadOutCrv, EgtStdColor('GRAY'))
       local dStrand = EgtGetInfo( nCrvId, KEY_CRV_STRAND, 'd')
       EgtSetInfo( nLeadOutCrv, KEY_CRV_STRAND, dStrand)
    end
@@ -536,7 +552,7 @@ end
 ---------------------------------------------------------------------
 local function CalcShellsToolPath( vEntIds, nTpathGrpId, LayerParams)
    
-   if not vEntIds then return end
+   if not vEntIds or #vEntIds == 0 then return end
    
    -- aggiungo le curve nel toolpath
    local vIds = AddCurvesToToolPath( vEntIds, nTpathGrpId, LayerParams.nOrder, LayerParams.bInvert, LayerParams.vtSlicing, LayerParams.dLayHeight)
@@ -584,7 +600,7 @@ end
 ---------------------------------------------------------------------
 local function CalcExtraShellToolPath( vEntIds, nTpathGrpId, LayerParams)
    
-   if not vEntIds then return end
+   if not vEntIds or #vEntIds == 0 then return end
    -- aggiungo le curve nel toolpath
    local vIds = AddCurvesToToolPath( vEntIds, nTpathGrpId, PRINT_ORDER.EXT_INT, false, LayerParams.vtSlicing, LayerParams.dLayHeight)
    
@@ -937,7 +953,7 @@ local function JoinShellsAndSolidFills( nInfillGrp, vShellIds, vExtraShells, Lay
    
    local nFillType = EgtGetInfo( nInfillGrp, KEY_FILL_TYPE, 'i') or FILL_TYPE.NONE
    
-   if nFillType == FILL_TYPE.OFFSET and vShellIds then
+   if nFillType == FILL_TYPE.OFFSET and vShellIds and #vShellIds > 0 then
       
       -- cerco indice di realizzazione dei vari elementi di stampa
       local vTypeSequence = {}
@@ -954,7 +970,7 @@ local function JoinShellsAndSolidFills( nInfillGrp, vShellIds, vExtraShells, Lay
       end
       
       -- verifico se extra shell realizzate tra shell e infill
-      if vExtraShells and nMin < vTypeSequence[PRINT_ELEMENT.EXTRA_SHELL] and vTypeSequence[PRINT_ELEMENT.EXTRA_SHELL] < nMax then
+      if vExtraShells and #vExtraShells > 0 and nMin < vTypeSequence[PRINT_ELEMENT.EXTRA_SHELL] and vTypeSequence[PRINT_ELEMENT.EXTRA_SHELL] < nMax then
          return
       end
       
@@ -995,7 +1011,7 @@ local function CalcAuxSolidsToolPath( nAuxSolidsGrp, nAuxSolidsPathGrp, nTpathGr
       -- recupero tutti i percorsi relativi a quel solido
       local sName = EgtGetName( nSolidId)
       local vEntIds = EgtGetNameInGroup( nAuxSolidsPathGrp, sName .. '*')
-      if vEntIds then
+      if vEntIds and #vEntIds > 0 then
         
          -- recupero i parametri relativi al solido dalla curva di slicing
          local nFillType = EgtGetInfo( nSolidId, KEY_AUX_SOLIDS_INFILL, 'i')
@@ -1208,7 +1224,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
@@ -1337,8 +1354,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
@@ -1371,10 +1395,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
@@ -1400,8 +1420,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
@@ -1457,56 +1475,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)
@@ -1549,8 +1560,9 @@ local function VerifyRibsLead( nId, nRibId, bInVsOut, nGrpTmp)
       local vtE = EgtUV( nLeadLoc, dParCrv, -1)
       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)
+         local vtDist = EgtUP( nLeadLoc, dParCrv - 0.5) - EgtMP( nRibLoc)
+         local vtOrthoDist = vtDist - ( vtDist * vtDir) * vtDir
+         local dDist = vtOrthoDist:len()
          if dDist < dStrand + GEO.EPS_SMALL then
             return false
          end
@@ -1558,26 +1570,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
@@ -1838,7 +1853,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)
@@ -1864,7 +1879,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)
@@ -1987,6 +2002,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
@@ -1994,16 +2012,18 @@ local function AddSpiralVaseLeadOut( nOldId, LayerParams)
    else
       AddRetraction( nOldId, LayerParams.vtSlicing, LayerParams.dCoastingLen, LayerParams.dWipeLen, LayerParams.dWipeDir)
    end
-
 end
 
 ---------------------------------------------------------------------
-local function SpiralVase( vLayIds, LayerParams)
+local function SpiralVaseFull( vLayIds, LayerParams)
+   -- la differenza in altezza tra due layers viene distribuita uniformemente lungo tutto il percorso
+   -- la continuità tra i layers viene risolta sul layer corrente ( uniformemente su tutto il tratto o solo nella parte iniziale di lunghezza dSpiralVaseInterpLen)
+   -- gestione speciale dei primi layers per gestione dell'altezza e feed
    
    local nOldId, nOldPathId
-   local bFirst = true
+   local nRealLayer = 1
    local nSlicingType = EgtGetInfo( s_nPartId, KEY_SLICING_TYPE, 'i')
-   
+
    -- copio ultimo layer
    if nSlicingType ~= SLICING_TYPE.DEG45_X and nSlicingType ~= SLICING_TYPE.DEG45_Y then
       local nNewLay = EgtCopyGlob( vLayIds[#vLayIds], vLayIds[#vLayIds], GDB_IN.AFTER)
@@ -2017,8 +2037,7 @@ local function SpiralVase( vLayIds, LayerParams)
       local dZOld = EgtGetInfo( vLayIds[#vLayIds], KEY_SLICE_Z, 'd') or 0
       EgtSetInfo( nNewLay, KEY_SLICE_Z, dZOld + LayerParams.dLayHeight)
    end
-    
-   local b3Tot = BBox3d()
+
    -- ciclo sui layer
    for nIdx = 1, #vLayIds do
       
@@ -2030,103 +2049,184 @@ local function SpiralVase( vLayIds, LayerParams)
          return false
       end
       
-      for i = 1, #vCrvGrpIds do
-         -- recupero il gruppo dei percorsi
-         local nPathGrpId = EgtGetFirstNameInGroup( vCrvGrpIds[i], PATH_GRP)
-         if not nPathGrpId then
-            EgtOutBox( 'Error missing paths', 'ToolPathCalc')
-            return
-         else
-            EgtSetStatus( nPathGrpId, GDB_ST.OFF)
-         end
-         
-         -- recupero il gruppo dei percorsi utensile
-         local nTpathGrpId = EgtGetFirstNameInGroup( vCrvGrpIds[i], TOOLPATH_GRP)
-         if not nTpathGrpId then
-            nTpathGrpId = EgtGroup( vCrvGrpIds[i])
-            EgtSetName( nTpathGrpId, TOOLPATH_GRP)
-         else
-            EgtEmptyGroup( nTpathGrpId)
-         end
-
-         -- creo il percorso di lavoro :
-         local vEntIds = EgtGetAllInGroup( nPathGrpId)
-         if #vEntIds > 1 then
-            EgtOutBox( 'Error in spiral vase : layer ' .. tostring( nIdx) .. ' has more than one toolpath', 'ToolPathCalc')
-            return false
-         end
-         
-         local nNewEntId = EgtCopyGlob( vEntIds[1] or GDB_ID.NULL, nTpathGrpId, GDB_IN.LAST_SON)
-         
-         if nNewEntId then
-            
-            local vtMove = V_NULL()
-            -- eventuale spostamento dell'altezza layer
-            if nSlicingType == SLICING_TYPE.DEG45_X or nSlicingType == SLICING_TYPE.DEG45_Y then
-               vtMove = LayerParams.dLayHeight * LayerParams.vtSlicing
-               EgtMove( nNewEntId, vtMove, GDB_RT.GLOB)
-            end
+      -- recupero il gruppo dei percorsi
+      local nPathGrpId = EgtGetFirstNameInGroup( vCrvGrpIds[1], PATH_GRP)
+      if not nPathGrpId then
+         EgtOutBox( 'Error missing paths', 'ToolPathCalc')
+         return
+      else
+         EgtSetStatus( nPathGrpId, GDB_ST.OFF)
+      end
       
-            EgtModifyCurveExtrusion( nNewEntId, LayerParams.vtSlicing, GDB_RT.GLOB)
-            EgtSetInfo( nNewEntId, KEY_CRV_STRAND, LayerParams.dStrand)
-            
-            -- eventuale inversione
-            if LayerParams.bInvert then
-               EgtInvertCurve( nNewEntId)
-               EgtSetInfo( nNewEntId, KEY_INVERTED_CRV, 1)
+      -- recupero il gruppo dei percorsi utensile
+      local nTpathGrpId = EgtGetFirstNameInGroup( vCrvGrpIds[1], TOOLPATH_GRP)
+      if not nTpathGrpId then
+         nTpathGrpId = EgtGroup( vCrvGrpIds[1])
+         EgtSetName( nTpathGrpId, TOOLPATH_GRP)
+      else
+         EgtEmptyGroup( nTpathGrpId)
+      end
+
+      -- creo il percorso di lavoro :
+      local vEntIds = EgtGetAllInGroup( nPathGrpId)
+      if #vEntIds > 1 then
+         EgtOutBox( 'Error in spiral vase : layer ' .. tostring( nIdx) .. ' has more than one toolpath', 'ToolPathCalc')
+         return false
+      end
+      
+      local nNewEntId = EgtCopyGlob( vEntIds[1] or GDB_ID.NULL, nTpathGrpId, GDB_IN.LAST_SON)
+      if nNewEntId then
+         
+         local vtMove = V_NULL()
+         -- eventuale spostamento dell'altezza layer
+         if nSlicingType == SLICING_TYPE.DEG45_X or nSlicingType == SLICING_TYPE.DEG45_Y then
+            vtMove = LayerParams.dLayHeight * LayerParams.vtSlicing
+            EgtMove( nNewEntId, vtMove, GDB_RT.GLOB)
+         end
+      
+         EgtModifyCurveExtrusion( nNewEntId, LayerParams.vtSlicing, GDB_RT.GLOB)
+         EgtSetInfo( nNewEntId, KEY_CRV_STRAND, LayerParams.dStrand)
+         
+         -- eventuale inversione
+         if LayerParams.bInvert then
+            EgtInvertCurve( nNewEntId)
+            EgtSetInfo( nNewEntId, KEY_INVERTED_CRV, 1)
+         end
+         EgtSetColor( nNewEntId, EgtStdColor('GRAY'))
+         
+         -- se primo layer
+         if nRealLayer == 1 then
+            -- mi sposto dell'altezza layer
+            EgtMove( nNewEntId, LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB)
+            -- modifico altezza ultimo tratto
+            local dTrimPar = EgtCurveParamAtLength( nNewEntId, EgtCurveLength( nNewEntId) - s_dSpralVaseFirstDelta)
+            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
-            EgtSetColor( nNewEntId, EgtStdColor('GRAY'))
             
-            -- se primo layer
-            if bFirst then
-               -- mi sposto dell'altezza layer
-               EgtMove( nNewEntId, LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB)
-               -- eventuale lead in
-               if LayerParams.nLeadInType ~= LEAD_TYPE.NONE then
-                  EgtTrimCurveStartAtLen( nNewEntId, LayerParams.dOffsetLP)
-                  AddLeadIn( nNewEntId, LayerParams, nTpathGrpId)
+            -- eventuale lead in
+            if LayerParams.nLeadInType ~= LEAD_TYPE.NONE then
+               EgtTrimCurveStartAtLen( nNewEntId, LayerParams.dOffsetLP)
+               local nLeadInCrv = AddLeadIn( nNewEntId, LayerParams, nTpathGrpId)
+               if nLeadInCrv and LayerParams.bLinearApprox then
+                  EgtApproxCurve( nLeadInCrv, GDB_CA.LINES, LayerParams.dLinearApproxTol)
                end
-               bFirst = false
-            else
-               local ptOld = EgtEP( nOldId, GDB_ID.ROOT)
-               local ptNew = EgtSP( nNewEntId, GDB_ID.ROOT)
-               if dist( ptNew, ptOld) < LayerParams.dStrand then
-                  -- se i punti sono vicini ma non coincidenti modifico la curva per avere transizione più uniforme
-                  if not AreSamePointApprox( ptOld, ptNew) then
-                     -- recupero la curva da usare come guida
-                     local nGuideId = EgtCopyGlob( nOldPathId, nTpathGrpId)
-                     -- la porto alla stessa quota del toolpath
-                     EgtMove( nGuideId, vtMove + LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB)
-                     EgtChangeClosedCurveStartPoint( nGuideId, ptOld, GDB_RT.GLOB)
-                     
-                     EgtSpiralizeCurveAlongGuide( nNewEntId, nGuideId)
-                     EgtErase( nGuideId)
-                  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)
+            
+            -- 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)
+
                else
-                  EgtOutLog( 'Warning : in spiral vase mode no link betweeen toolpaths (layer '..tostring( nIdx)..') - CalcToolPath')
-                  -- aggiungo uscita, coasting e wipe sulla curva precedente
-                  AddSpiralVaseLeadOut( nOldId, LayerParams)
+                  -- 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
+
+            -- 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
+            
+            -- 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)
+               local nNewId = EgtSplitCurve( nNewEntId, 2)
+               EgtSpiralizeCurveAlongExtrusion( nNewId + 1, 0.5 * LayerParams.dLayHeight)
+            else
                EgtSpiralizeCurveAlongExtrusion( nNewEntId, LayerParams.dLayHeight)
             end
-            
-            -- approssimo la curva
-            if nNewEntId then
-               local ptS = EgtSP( nNewEntId, GDB_ID.ROOT)
-               EgtApproxCurve( nNewEntId, GDB_CA.ARCS, s_dApproxTol)
-               if EgtCurveIsClosed( nNewEntId) then
-                  EgtChangeClosedCurveStartPoint( nNewEntId, ptS, GDB_RT.GLOB)
-               end
-            end
-            
-            nOldPathId = vEntIds[1]
-            nOldId = nNewEntId
          end
 
-         -- aggiorno il box dei toolpath
-         local b3Box = ComputeToolPathBox( nTpathGrpId)
-         b3Tot:Add( b3Box)
+         local vTPathsCrvs = EgtGetAllInGroup( nTpathGrpId)
+         nOldPathId = vEntIds[1]
+         nOldId = vTPathsCrvs[#vTPathsCrvs]
+         
+         -- moltiplicatore per feed
+         if nRealLayer == 2 then
+            -- 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 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
+               -- 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 nFirst, nCnt = EgtExplodeCurveCompo( nNewId)
+            for nId = nFirst, nFirst + nCnt - 1 do
+               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
+         end
 
+         nRealLayer = nRealLayer + 1
       end
       
       if EgtProcessEvents( EgtIf( PRINT, 300, 0) + nIdx / #vLayIds * 100, 0) == 1 then
@@ -2135,12 +2235,198 @@ local function SpiralVase( vLayIds, LayerParams)
       end
    end
    
+   return true
+end
+
+---------------------------------------------------------------------
+local function SpiralVasePartial( vLayIds, LayerParams)
+   -- la differenza in altezza tra due layers viene distribuita solo lungo il tratto finale di lunghezza dSpiralVaseLen
+   -- la continuità tra i layers viene risolta sul tratto finale del layer percedente
+   
+   local bFirst = true
+   -- individuo l'ultimo layer ( alcuni potrebbero essere vuoti)
+   local nLastLay = 1
+   for nIdx = #vLayIds, 1, -1 do
+      local nCrvGrp = EgtGetFirstNameInGroup( vLayIds[ nIdx], CONTOUR_GRP.."*")
+      local nPathGrpId = EgtGetFirstNameInGroup( nCrvGrp, PATH_GRP) or GDB_ID_NULL
+      if EgtGetGroupObjs( nPathGrpId) > 0 then
+         nLastLay = nIdx
+         break
+      end
+   end
+    
+   -- ciclo sui layer
+   local nOldId
+   for nIdx = 1, #vLayIds do
+      
+      -- cerco i gruppi di contorni
+      local vCrvGrpIds = EgtGetNameInGroup( vLayIds[ nIdx], CONTOUR_GRP.."*")
+      if #vCrvGrpIds > 1 then
+         -- se più di un gruppo di curve errore
+         EgtOutBox( 'Error in spiral vase : layer ' .. tostring( nIdx) .. ' has more than one toolpath', 'ToolPathCalc')
+         return false
+      end
+      
+      -- recupero il gruppo dei percorsi
+      local nPathGrpId = EgtGetFirstNameInGroup( vCrvGrpIds[1], PATH_GRP)
+      if not nPathGrpId then
+         EgtOutBox( 'Error missing paths', 'ToolPathCalc')
+         return false
+      else
+         EgtSetStatus( nPathGrpId, GDB_ST.OFF)
+      end
+      
+      -- recupero il gruppo dei percorsi utensile
+      local nTpathGrpId = EgtGetFirstNameInGroup( vCrvGrpIds[1], TOOLPATH_GRP)
+      if not nTpathGrpId then
+         nTpathGrpId = EgtGroup( vCrvGrpIds[1])
+         EgtSetName( nTpathGrpId, TOOLPATH_GRP)
+      else
+         EgtEmptyGroup( nTpathGrpId)
+      end
+
+      -- creo il percorso di lavoro
+      local vEntIds = EgtGetAllInGroup( nPathGrpId)
+      if #vEntIds > 1 then
+         EgtOutBox( 'Error in spiral vase : layer ' .. tostring( nIdx) .. ' has more than one toolpath', 'ToolPathCalc')
+         return false
+      end
+      
+      local nNewEntId = EgtCopyGlob( vEntIds[1] or GDB_ID.NULL, nTpathGrpId, GDB_IN.LAST_SON)
+      if nNewEntId then
+         
+         EgtModifyCurveExtrusion( nNewEntId, LayerParams.vtSlicing, GDB_RT.GLOB)
+         EgtSetInfo( nNewEntId, KEY_CRV_STRAND, LayerParams.dStrand)
+         if LayerParams.bInvert then
+            EgtInvertCurve( nNewEntId)
+            EgtSetInfo( nNewEntId, KEY_INVERTED_CRV, 1)
+         end
+         EgtSetColor( nNewEntId, EgtStdColor('GRAY'))
+
+         -- sistemo il tratto finale del percorso precedente
+         if not bFirst then
+            local ptSOld = EgtSP( nOldId, GDB_ID.ROOT)
+            local ptEOld = EgtEP( nOldId, GDB_ID.ROOT)
+            
+            -- modifico il punto iniziale corrente per avvicinarmi il più possibile alla fine del percorso precedente
+            EgtChangeClosedCurveStartPoint( nNewEntId, ptEOld, GDB_RT.GLOB)
+            local ptNew = EgtSP( nNewEntId, GDB_ID.ROOT)
+            
+            -- a) verifico continuità tra i layers 
+            if not AreSamePointApprox( ptEOld, ptNew) then
+               -- se il punto finale del percorso precedente non coincide con quello iniziale del percorso corrente modifico il tratto finale del percorso precedente che va alzato sin modo
+               -- che termini esattamente sull'inizio del percorso corrente
+               local _, _, dStartGuide = EgtPointCurveDist( ptSOld, nNewEntId, GDB_ID.ROOT)
+               local _, dEndGuide = EgtCurveDomain( nNewEntId)
+               local nGuideId = EgtCopyParamRange( nNewEntId, dStartGuide, dEndGuide, nTpathGrpId)
+               EgtModifyCurveExtrusion( nGuideId, LayerParams.vtSlicing, GDB_RT.GLOB)
+
+               -- approssimo con tratti lineari imponendo lunghezza massima per migliorare spiralize
+               EgtApproxCurve( nGuideId, GDB_CA.SPECIAL_LINES, 0.01, s_dSpiralVaseMaxLen)
+               EgtApproxCurve( nOldId, GDB_CA.SPECIAL_LINES, 0.01, s_dSpiralVaseMaxLen)
+               
+               -- SpiralizeAlongGuide effettua una transizione dalla guida alla curva corrente, qui serve in contrario ( la curva deve arrivare sulla guida non partire da essa) 
+               -- quindi bisogna lavorare con le curve invertite
+               EgtInvertCurve( nGuideId)
+               EgtInvertCurve( nOldId)
+               EgtSpiralizeCurveAlongGuide( nOldId, nGuideId)
+               EgtInvertCurve( nOldId)
+               EgtErase( nGuideId)
+               
+               -- approssimo la curva
+               EgtApproxCurve( nOldId, GDB_CA.ARCS, s_dApproxTol)
+               if LayerParams.bLinearApprox then
+                  EgtApproxCurve( nOldId, GDB_CA.LINES, LayerParams.dLinearApproxTol)
+               end
+               -- forzo punti per garantire continuità
+               EgtModifyCurveStartPoint( nOldId, ptSOld, GDB_RT.GLOB)
+               EgtModifyCurveEndPoint( nOldId, ptNew, GDB_RT.GLOB)
+            end
+            
+            -- b) modifica graduale dell'altezza
+            EgtSpiralizeCurveAlongExtrusion( nOldId, LayerParams.dLayHeight)
+         end
+
+         -- spostamento dell'altezza layer
+         local vtMove = LayerParams.dLayHeight * LayerParams.vtSlicing
+         EgtMove( nNewEntId, vtMove, GDB_RT.GLOB)
+
+         -- approssimazione
+         if LayerParams.bLinearApprox then
+            local ptS = EgtSP( nNewEntId, GDB_ID.ROOT)
+            EgtApproxCurve( nNewEntId, GDB_CA.LINES, LayerParams.dLinearApproxTol)
+            if EgtCurveIsClosed( nNewEntId) then
+               EgtChangeClosedCurveStartPoint( nNewEntId, ptS, GDB_RT.GLOB)
+            end
+         end
+         
+         -- eventuale lead in
+         if bFirst then
+            bFirst = false
+            if LayerParams.nLeadInType ~= LEAD_TYPE.NONE then
+               EgtTrimCurveStartAtLen( nNewEntId, LayerParams.dOffsetLP)
+               local nLeadInCrv = AddLeadIn( nNewEntId, LayerParams, nTpathGrpId)
+               if nLeadInCrv and LayerParams.bLinearApprox then
+                  EgtApproxCurve( nLeadInCrv, GDB_CA.LINES, LayerParams.dLinearApproxTol)
+               end
+            end
+         end
+         
+         -- separo l'ultimo tratto che farà da collegamento con il layer successivo
+         if nIdx ~= nLastLay then
+            local dTrimLen = EgtCurveLength( nNewEntId) - LayerParams.dSpiralVaseLen
+            if dTrimLen < GEO.EPS_SMALL then
+               -- se lunghezza di trim maggiore delle dimensioni forzo un valore accettabile
+               dTrimLen = 0.5 * EgtCurveLength( nNewEntId)
+            end
+            local dTrimPar = EgtCurveParamAtLength( nNewEntId, dTrimLen)
+            nOldId = EgtSplitCurveAtParam( nNewEntId, dTrimPar)
+         end
+      end
+      
+      if EgtProcessEvents( EgtIf( PRINT, 300, 0) + nIdx / #vLayIds * 100, 0) == 1 then
+         EgtDraw()
+         return false
+      end
+   end
+   
+   return true
+end
+
+---------------------------------------------------------------------
+local function SpiralVase( vLayIds, LayerParams)
+   
+   -- verifico quale modalità di spiral vase applicare :
+   -- 1) dSpiralVaseLen = 0 : la differenza in altezza tra due layers ( dLayHeight) viene distribuita uniformemente sull'intero percorso
+   -- 2) dSpiralVaseLen > 0 : la differenza in altezza tra due layers viene distribuita solo lungo il tratto finale di lunghezza dSpiralVaseLen
+   
+   if abs( LayerParams.dSpiralVaseLen) < GEO.EPS_SMALL then
+      if not SpiralVaseFull( vLayIds, LayerParams) then
+         return false
+      end
+   else
+      if not SpiralVasePartial( vLayIds, LayerParams) then
+         return false
+      end
+   end
+      
+   -- calcolo il box dei percorsi
+   local b3Tot = BBox3d()
+   local nLastTPath
+   for i = 1, #vLayIds do
+      local vCrvGrpIds = EgtGetNameInGroup( vLayIds[i], CONTOUR_GRP.."*")
+      local nTpathGrpId = EgtGetFirstNameInGroup( vCrvGrpIds[1], TOOLPATH_GRP)
+      nLastTPath = EgtGetLastInGroup( nTpathGrpId)
+      local b3Box = ComputeToolPathBox( nTpathGrpId)
+      b3Tot:Add( b3Box)
+   end
+   
    -- aggiungo uscita, coasting e wipe su ultima curva
-   AddSpiralVaseLeadOut( nOldId, LayerParams)
+   AddSpiralVaseLeadOut( nLastTPath, LayerParams)
    
    -- correzione in z
    AddZCorrection( b3Tot, LayerParams)
-   
+
    return true
 end
 
@@ -2151,7 +2437,7 @@ function CalcToolPath.Exec( nPartId)
    
    -- Recupero i layer da processare
    local vLayIds = EgtGetNameInGroup( s_nPartId, SLICE_LAYER.."*")
-   if not vLayIds then
+   if not vLayIds or #vLayIds == 0 then
       EgtOutBox( 'Error missing slices', 'ToolPathCalc')
       return true
    end
@@ -2255,6 +2541,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/RunCalcSolids.lua

@@ -38,6 +38,14 @@ local function CalcSectionParams( dStrand, dH)
    return dBevelX, dBevelY
 end
 
+----------------------------------------------------------------------
+local function CreateStandardSolid( nCrvId, nSolidGrp, LayerParams, dStrand)
+
+   local dBevelX, dBevelY = CalcSectionParams( dStrand, LayerParams.dLayHeight)
+   local nSrfId = EgtSurfTmRectSwept( nSolidGrp, dStrand, LayerParams.dLayHeight, dBevelX, dBevelY, nCrvId, GDB_RSCT.BEVEL, s_dTol)
+   return nSrfId
+end
+
 ---------------------------------------------------------------------
 local function CreateSection( ptS, vtDir, dStrand, dH, vtSlicing, nSolidGrp)
 
@@ -112,11 +120,21 @@ local function CreateSpiralVaseSolid( nCrvId, nSolidGrp, LayerParams, dStrand)
    -- gruppo temporaneo per conti 
    local nGrpTmp = EgtGroup( nSolidGrp, Frame3d( ORIG(), LayerParams.vtSlicing, GDB_RT.GLOB))
    
+   -- accorcio leggermente la curva per evitare problemi di inconsistent orientation nel solido
+   local dLen = EgtCurveLength( nCrvId)
+   EgtTrimCurveEndAtLen( nCrvId, dLen - 20 * GEO.EPS_SMALL)
+   
    local ptS = EgtSP( nCrvId, GDB_ID.ROOT)
    local vtS = EgtSV( nCrvId, GDB_ID.ROOT)
    local ptE = EgtEP( nCrvId, GDB_ID.ROOT)
    local vtE = EgtEV( nCrvId, GDB_ID.ROOT)
    local dDelta = ( ptE - ptS) * LayerParams.vtSlicing
+   -- se non è vero spiral vase, chiamo funzione standard
+   if dDelta < GEO.EPS_SMALL then
+      EgtErase( nGrpTmp)
+      return CreateStandardSolid( nCrvId, nSolidGrp, LayerParams, dStrand)
+   end
+   
    -- appiattisco la curva
    local nCrvCopy = EgtCopyGlob( nCrvId, nGrpTmp)
    EgtModifyCurveExtrusion( nCrvCopy, LayerParams.vtSlicing, GDB_RT.GLOB)
@@ -154,7 +172,7 @@ local function CreateSpiralVaseSolid( nCrvId, nSolidGrp, LayerParams, dStrand)
       local ptRefEnd = EgtUP( nSectE, i, GDB_ID.ROOT)
       local _, _, dParMinDist = EgtPointCurveDist( ptRefEnd, vCrvs[i+1], GDB_ID.ROOT)
       local _, dParE = EgtCurveDomain( vCrvs[i+1])
-      if abs( dParE - dParMinDist) > GEO.EPS_SMALL then
+      if abs( dParE - dParMinDist) > GEO.EPS_SMALL and dParMinDist > 0.5 * dParE then
          EgtTrimCurveEndAtParam( vCrvs[i+1], dParMinDist)
       end
       EgtModifyCurveEndPoint( vCrvs[i+1], ptRefEnd, GDB_RT.GLOB)
@@ -183,14 +201,6 @@ local function CreateSpiralVaseSolid( nCrvId, nSolidGrp, LayerParams, dStrand)
    return EgtSurfTmByTriangles( nSolidGrp, { nSrfId, nCap1, nCap2})
 end
 
-----------------------------------------------------------------------
-local function CreateStandardSolid( nCrvId, nSolidGrp, LayerParams, dStrand)
-
-   local dBevelX, dBevelY = CalcSectionParams( dStrand, LayerParams.dLayHeight)
-   local nSrfId = EgtSurfTmRectSwept( nSolidGrp, dStrand, LayerParams.dLayHeight, dBevelX, dBevelY, nCrvId, GDB_RSCT.BEVEL, s_dTol)
-   return nSrfId
-end
-
 --------------------------------------------------------------------------------------
 local function CreateSolid( nCrvId, nSolidGrp, LayerParams, dStrand)
    if LayerParams.bSpiralVase then
@@ -313,7 +323,7 @@ local function CreateSolidFromCurve( nCrvId, nSolidGrp, LayerParams, nLayer)
       if not nSrfId then
          EgtOutLog( 'Warning : CreateSolid failed '.. '(layer '..tostring( nLayer)..', curve '..tostring( nCrvId)..')')
          -- ritento con strand più piccolo
-         nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams, dStrand - 50 * GEO.EPS_SMALL)         
+         nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams, dStrand - 50 * GEO.EPS_SMALL)
          
          if not nSrfId then
             EgtOutLog( 'Warning : CreateSolid_1 failed '.. '(layer '..tostring( nLayer)..', curve '..tostring( nCrvId)..')')
@@ -394,7 +404,7 @@ function RunCalcSolids.Exec()
             
             -- recupero i suoi slice
             local vLayIds = EgtGetNameInGroup( nPartId, SLICE_LAYER .. '*')
-            if not vLayIds then
+            if not vLayIds or #vLayIds == 0 then
                EgtOutBox( 'No sliced part in this project!', 'Error', 'ERROR')
                return
             end
@@ -426,11 +436,51 @@ function RunCalcSolids.Exec()
                      nSolidGrpId = EgtGroup( nCrvGrpId)
                      EgtSetName( nSolidGrpId, SOLID_GRP)
                      EgtSetLevel( nSolidGrpId, GDB_LV.TEMP)
-                     -- scorro le curve del percorso utensile
-                     local nId = EgtGetFirstInGroup( nTPathGrpId)
-                     while nId do
-                        local bOk = CreateSolidFromCurve( nId, nSolidGrpId, LayerParams, nLayer)
-                        nId = EgtGetNext( nId)
+                     local vIds = EgtGetAllInGroup( nTPathGrpId)
+                     
+                     -- spiral vase
+                     if LayerParams.bSpiralVase then
+                        -- i tratti di ingresso, uscita e quelli a quota costante vanno gestiti singolarmente, quelli a quota variabile vanno concatenati
+                        local vChainedIds = {}
+                        local vTmpIds = {}
+                        for i = 1, #vIds do
+                           local sName = EgtGetName( vIds[i])
+                           local dDelta = ( EgtEP( vIds[i], GDB_ID.ROOT) - EgtSP( vIds[i], GDB_ID.ROOT)) * LayerParams.vtSlicing
+                           if abs( dDelta) < GEO.EPS_SMALL or sName == LEAD_IN_CRV or sName == LEAD_OUT_CRV or sName == COASTING_CRV or sName == WIPE_CRV then
+                              -- inserisco il gruppo di tratti da concatenare e lo resetto
+                              if #vTmpIds > 0 then 
+                                 table.insert( vChainedIds, vTmpIds)
+                                 vTmpIds = {}
+                              end
+                              -- inserisco la curva singola corrente
+                              table.insert( vChainedIds, { vIds[i]})
+                           else
+                              table.insert( vTmpIds, vIds[i])
+                           end
+                        end
+                        -- inserisco ultimo gruppo
+                        if #vTmpIds > 0 then
+                           table.insert( vChainedIds, vTmpIds)
+                        end
+                        
+                        for i = 1, #vChainedIds do
+                           if #vChainedIds[i] == 1 then
+                              CreateSolidFromCurve( vChainedIds[i][1], nSolidGrpId, LayerParams, nLayer)
+                           else
+                              local nNewCrv = EgtCurveCompo( nSolidGrpId, vChainedIds[i], false)
+                              local dStrand = EgtGetInfo( vChainedIds[i][1], KEY_CRV_STRAND, 'd') or LayerParams.dStrand
+                              EgtSetInfo( nNewCrv, KEY_CRV_STRAND, dStrand)
+                              EgtSetInfo( nNewCrv, KEY_TYPE, TYPE.OUTER_SHELL)
+                              CreateSolidFromCurve( nNewCrv, nSolidGrpId, LayerParams, nLayer)
+                              EgtErase( nNewCrv)
+                           end
+                        end
+                        
+                     -- caso standard
+                     else
+                        for i = 1, #vIds do
+                           CreateSolidFromCurve( vIds[i], nSolidGrpId, LayerParams, nLayer)
+                        end
                      end
                   else
                      bSolidsOk = true
@@ -460,7 +510,7 @@ function RunCalcSolids.Exec()
                   for i = 1, #vLayIds do
                      local vGrpId = EgtGetNameInGroup( vLayIds[i], CONTOUR_GRP .. '*') or {}
                      for j = 1, #vGrpId do
-                        local nSolidId = EgtGetNameInGroup( vGrpId[j], SOLID_GRP .. '*') or GDB_ID.NULL
+                        local nSolidId = EgtGetFirstNameInGroup( vGrpId[j], SOLID_GRP .. '*') or GDB_ID.NULL
                         EgtErase( nSolidId)
                      end
                   end

LuaLibs/RunGcodeGenerate.lua

@@ -36,7 +36,7 @@ function RunGcodeGenerate.Exec()
 
    -- Recupero i layer da processare
    local vLayIds = EgtGetNameInGroup( nPartId, SLICE_LAYER.."*") 
-   if not vLayIds then
+   if not vLayIds or #vLayIds == 0 then
    EgtOutBox( 'Error missing slices', 'GcodeGenerate')
       return 
    end

LuaLibs/RunMachParamFromSWCalc.lua

@@ -53,6 +53,8 @@ function RunMachParamFromSWCalc.Exec()
    local sMachIni = EgtGetCurrMachineDir() .. '\\' .. EgtGetCurrMachineName() .. '.ini'
    local dSMin = tonumber( EgtGetStringFromIni( SEC_3DPRINTING, KEY_SPEED_MIN, 0, sMachIni))
    local dSMax = tonumber( EgtGetStringFromIni( SEC_3DPRINTING, KEY_SPEED_MAX, 50000, sMachIni))
+   -- recupero Feed massima dalla macchina
+   local dFLimit = tonumber( EgtGetStringFromIni( SEC_3DPRINTING, KEY_FEED_MAX, 10000, sMachIni))
    -- massa materiale utilizzato
    local dPrintMass = 0
    -- massimo indice di layer calcolato
@@ -187,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
@@ -203,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)
@@ -219,10 +223,22 @@ function RunMachParamFromSWCalc.Exec()
             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
+               local dNewFeed = CurrFeed
+               -- verifico se coefficiente moltiplicativo per feed
+               local dCoeff = EgtGetInfo( CurrWidth.IdList[nCurveIdIndex], KEY_FEED_COEFF, 'd')
+               if dCoeff then
+                  dNewFeed = dCoeff * CurrFeed
+                  if dNewFeed > dFLimit then
+                     local dNewSpeed = dSpeed * dFLimit / dNewFeed
+                     dNewSpeed = EgtClamp( dNewSpeed, dSMin, dSMax)
+                     dNewFeed = dFLimit
+                     EgtSetInfo( CurrWidth.IdList[nCurveIdIndex], KEY_SPEED, dNewSpeed)
+                  end
+               end
+               EgtSetInfo( CurrWidth.IdList[nCurveIdIndex], KEY_FEED, dNewFeed)
+               if dNewFeed > dFeedMax then
+                  dFeedMax = dNewFeed
+               end
             end
          end
          -- scrivo info speed in group toolpath

LuaLibs/RunPrepareExport.lua

@@ -28,52 +28,56 @@ local function CalcCurves( nSliceId, nDestGrp, vtSlicing, dStrandBase)
             if nType ~= TYPE.WIPE then
                local dStrand = EgtGetInfo( nId, KEY_CRV_STRAND, 'd') or dStrandBase
                
-               -- calcolo fat curve a partire da una copia della curva ( in questo modo nel DB geometrico non restano
+               -- calcolo fat region a partire da una copia della curva ( in questo modo nel DB geometrico non restano
                -- salvati i diagrammi di Voronoi che non servono per conti futuri)
                local nCopy = EgtCopyGlob( nId, nDestGrp)
-               local nCrv, nCnt = EgtCurveGetFatCurve( nCopy, nDestGrp, 0.5 * dStrand, false)
+               local nSurf = EgtSurfFrFatCurve( nDestGrp, nCopy, 0.5 * dStrand, false)
                -- se fallisce ritento con valore leggermente diverso
-               if not nCrv or nCnt == 0 then
-                  nCrv, nCnt = EgtCurveGetFatCurve( nCopy, nDestGrp, 0.5 * dStrand - 0.05, false)
+               if not nSurf or nSurf == GDB_ID.NULL then
+                  nSurf = EgtSurfFrFatCurve( nDestGrp, nCopy, 0.5 * dStrand - 0.05, false)
                end
                EgtErase( nCopy)
                  
-               if nCrv and nCnt > 0 then
-                  -- se sono curve chiuse piccoli aggistamenti per creare un percorso unico
-                  if nCnt > 1 then
-                     for nLoopId = nCrv + 1, nCrv + nCnt - 1 do
-                        EgtInvertCurve( nLoopId)
-                        local dLen = EgtCurveLength( nLoopId)
-                        local dPar1 = EgtCurveParamAtLength( nLoopId, dLen * 0.5)
-                        local dPar2 = EgtCurveParamAtLength( nLoopId, dLen * 0.5 + 2 * GEO.EPS_SMALL)
-                        local ptM = EgtUP( nLoopId, dPar1)
-                        local ptM2 = EgtUP( nLoopId, dPar2)
-                        local _, _, dParRef1 = EgtPointCurveDist( ptM, nCrv)
-                        local _, _, dParRef2 = EgtPointCurveDist( ptM, nCrv)
-                        EgtTrimCurveStartEndAtParam( nCrv, dParRef2, dParRef1)
-                        EgtTrimCurveStartEndAtParam( nLoopId, dPar2, dPar1)
-                        EgtInvertCurve( nLoopId)
-                        EgtAddCurveCompoLine( nCrv, EgtSP( nLoopId))
-                        EgtAddCurveCompoCurve( nCrv, nLoopId)
-                        EgtCloseCurveCompo( nCrv)
+               if nSurf then
+                  local nChunks = EgtSurfFrChunkCount( nSurf)
+                  for k = 0, nChunks - 1 do
+                     -- estraggo i loop associati
+                     local nCrv, nCnt = EgtExtractSurfFrChunkLoops( nSurf, k, nDestGrp)
+                     -- eventuali aggiustamenti per creare un percorso unico
+                     if nCnt > 1 then
+                        for nLoopId = nCrv + 1, nCrv + nCnt - 1 do
+                           local dLen = EgtCurveLength( nLoopId)
+                           local dPar1 = EgtCurveParamAtLength( nLoopId, dLen * 0.5)
+                           local dPar2 = EgtCurveParamAtLength( nLoopId, dLen * 0.5 + 2 * GEO.EPS_SMALL)
+                           local ptM = EgtUP( nLoopId, dPar1)
+                           local ptM2 = EgtUP( nLoopId, dPar2)
+                           local _, _, dParRef1 = EgtPointCurveDist( ptM2, nCrv)
+                           local _, _, dParRef2 = EgtPointCurveDist( ptM, nCrv)
+                           EgtTrimCurveStartEndAtParam( nCrv, dParRef2, dParRef1)
+                           EgtTrimCurveStartEndAtParam( nLoopId, dPar2, dPar1)
+                           EgtAddCurveCompoLine( nCrv, EgtSP( nLoopId))
+                           EgtAddCurveCompoCurve( nCrv, nLoopId)
+                           EgtCloseCurveCompo( nCrv)
+                        end
+                     end
+                     
+                     if nType == TYPE.OUTER_SHELL or nType == TYPE.EXTRA_OUTER_SHELL then 
+                        EgtSetColor( nCrv, EgtStdColor( 'TEAL'))
+                     elseif nType == TYPE.INNER_SHELL or nType == TYPE.EXTRA_SHELL then
+                        EgtSetColor( nCrv, EgtStdColor( 'ORANGE'))
+                     elseif nType == TYPE.LINK then
+                        EgtSetColor( nCrv, EgtStdColor( 'GRAY'))
+                     elseif nType == TYPE.INFILL then
+                        EgtSetColor( nCrv, EgtStdColor( 'YELLOW'))
+                     elseif nType == TYPE.COASTING then
+                        EgtSetColor( nCrv, EgtStdColor( 'BLUE'))
+                     elseif nType == TYPE.RIB then
+                        EgtSetColor( nCrv, EgtStdColor( 'OLIVE'))
+                     elseif nType == TYPE.AUX_SOLID then
+                        EgtSetColor( nCrv, EgtStdColor( 'AQUA'))
                      end
                   end
-                  
-                  if nType == TYPE.OUTER_SHELL or nType == TYPE.EXTRA_OUTER_SHELL then 
-                     EgtSetColor( nCrv, EgtStdColor( 'TEAL'))
-                  elseif nType == TYPE.INNER_SHELL or nType == TYPE.EXTRA_SHELL then
-                     EgtSetColor( nCrv, EgtStdColor( 'ORANGE'))
-                  elseif nType == TYPE.LINK then
-                     EgtSetColor( nCrv, EgtStdColor( 'GRAY'))
-                  elseif nType == TYPE.INFILL then
-                     EgtSetColor( nCrv, EgtStdColor( 'YELLOW'))
-                  elseif nType == TYPE.COASTING then
-                     EgtSetColor( nCrv, EgtStdColor( 'BLUE'))
-                  elseif nType == TYPE.RIB then
-                     EgtSetColor( nCrv, EgtStdColor( 'OLIVE'))
-                  elseif nType == TYPE.AUX_SOLID then
-                     EgtSetColor( nCrv, EgtStdColor( 'AQUA'))
-                  end
+                  EgtErase( nSurf)
                end
             end
             
@@ -104,9 +108,14 @@ local function CalcSpiralVase( nSliceId, nDestGrp)
       -- recupero il solido dal gruppo
       local nSolidGrp = EgtGetFirstNameInGroup( vCrvs[j], SOLID_GRP)
       if nSolidGrp then
+         -- copio solo la prima freccia direzionale
+         local nArrow = EgtGetFirstNameInGroup( nSolidGrp, DIR_ARROW) or GDB_ID.NULL
+         EgtCopyGlob( nArrow, nDestGrp)
          local vSolids = EgtGetAllInGroup( nSolidGrp)
          for i = 1, #vSolids do
-            EgtCopyGlob( vSolids[i], nDestGrp)
+            if EgtGetName( vSolids[i]) ~= DIR_ARROW then
+               EgtCopyGlob( vSolids[i], nDestGrp)
+            end
          end
       end
    end

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.6e1'
+VERSION = '3.1a1'