3dPrinting 2.7f1 :

- aggiunta possibilità da file ini della macchina di forzare approssimazione lineare dei percorsi con tolleranza a scelta.

LuaLibs/AddManData.lua

@@ -178,6 +178,9 @@ 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"
@@ -207,8 +210,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 = {{}, {}}
@@ -980,7 +981,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
@@ -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)
@@ -2394,7 +2394,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
@@ -2807,7 +2807,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)
@@ -3752,7 +3752,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 +4101,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 +4308,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

@@ -1000,6 +1000,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
          

LuaLibs/CalcToolPath.lua

@@ -18,6 +18,8 @@ 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_dSpralVaseFirstDelta = 30    -- lunghezza del tratto sul primo layer che va alzato
 
 ---------------------------------------------------------------------
 local function GetLayerParamsForToolPathCalc()
@@ -53,6 +55,11 @@ 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)
 
    return LayerParams
 end
@@ -344,6 +351,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
 
 --------------------------------------------------------------------
@@ -536,7 +545,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 +593,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 +946,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 +963,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 +1004,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')
@@ -1549,8 +1558,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
@@ -1987,6 +1997,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
@@ -2002,6 +2015,7 @@ local function SpiralVase( vLayIds, LayerParams)
    
    local nOldId, nOldPathId
    local bFirst = true
+   local nRealLayer = 1
    local nSlicingType = EgtGetInfo( s_nPartId, KEY_SLICING_TYPE, 'i')
    
    -- copio ultimo layer
@@ -2078,55 +2092,129 @@ local function SpiralVase( vLayIds, LayerParams)
             EgtSetColor( nNewEntId, EgtStdColor('GRAY'))
             
             -- se primo layer
-            if bFirst then
+            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
+               
                -- 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
-               bFirst = false
             else
                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)
-               if dist( ptNew, ptOld) < LayerParams.dStrand then
-                  -- se i punti sono vicini ma non coincidenti modifico la curva per avere transizione più uniforme
+               -- 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, nTpathGrpId)
-                     -- la porto alla stessa quota del toolpath
+                     local nGuideId = EgtCopyGlob( nOldPathId, nPathGrpId)
+                     -- la rendo coerente con il toolpath
                      EgtMove( nGuideId, vtMove + LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB)
-                     EgtChangeClosedCurveStartPoint( nGuideId, ptNew, 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)
                      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)
                   end
-               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)
                end
-               EgtSpiralizeCurveAlongExtrusion( nNewEntId, LayerParams.dLayHeight)
-            end
-            
-            -- approssimo la curva
-            if nNewEntId then
+               
+               -- 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 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
+            end
+
+            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 ptRef = EgtEP( vEntIds[1], GDB_ID.ROOT)
+               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
+                  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 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
+                  EgtSetInfo( nId, KEY_FEED_COEFF, dFeedCoeff)
+               end
+               nOldId = nNewId + 1
             end
             
-            nOldPathId = vEntIds[1]
-            nOldId = nNewEntId
+            nRealLayer = nRealLayer + 1
+            -- aggiorno il box dei toolpath
+            local b3Box = ComputeToolPathBox( nTpathGrpId)
+            b3Tot:Add( b3Box)
          end
-
-         -- aggiorno il box dei toolpath
-         local b3Box = ComputeToolPathBox( nTpathGrpId)
-         b3Tot:Add( b3Box)
-
       end
       
       if EgtProcessEvents( EgtIf( PRINT, 300, 0) + nIdx / #vLayIds * 100, 0) == 1 then
@@ -2151,7 +2239,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 +2343,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)
 
@@ -121,6 +129,11 @@ local function CreateSpiralVaseSolid( nCrvId, nSolidGrp, LayerParams, dStrand)
    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
+      return CreateStandardSolid( nCrvId, nSolidGrp, LayerParams, dStrand)
+   end
+   
    -- appiattisco la curva
    local nCrvCopy = EgtCopyGlob( nCrvId, nGrpTmp)
    EgtModifyCurveExtrusion( nCrvCopy, LayerParams.vtSlicing, GDB_RT.GLOB)
@@ -158,7 +171,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)
@@ -187,14 +200,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
@@ -398,7 +403,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
@@ -430,12 +435,41 @@ 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)
+                     -- scorro le curve del percorso utensile per creare i solidi
+                     local vIds = EgtGetAllInGroup( nTPathGrpId)
+                     
+                     if LayerParams.bSpiralVase and #vIds > 2 and EgtGetName( vIds[#vIds]) ~= WIPE_CRV then
+                         -- nel caso a spirale gestione speciale per unire i tratti dei primi layers che sono stati spezzati per feed variabile
+                        local bHasDelta = EgtExistsInfo( vIds[#vIds], KEY_FEED_COEFF)
+                        if bHasDelta then
+                           -- prima curva è a quota costante
+                           CreateSolidFromCurve( vIds[1], nSolidGrpId, LayerParams, nLayer)
+                           -- le rimanenti curve possono essere unite
+                           local vNewIds = EgtTableFill( vIds[2], #vIds-1)
+                           local nNewCrv = EgtCurveCompo( nSolidGrpId, vNewIds, false)
+                           local dStrand = EgtGetInfo( vIds[2], 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)
+                        else
+                           local vNewIds = EgtTableFill( vIds[1], #vIds-1)
+                           local nNewCrv = EgtCurveCompo( nSolidGrpId, vNewIds, false)
+                           local dStrand = EgtGetInfo( vIds[2], 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)
+                           CreateSolidFromCurve( vIds[#vIds], nSolidGrpId, LayerParams, nLayer)
+                        end
+                        
+                     else
+                        -- caso standard
+                        for i = 1, #vIds do
+                           CreateSolidFromCurve( vIds[i], nSolidGrpId, LayerParams, nLayer)
+                        end
                      end
+                     
                   else
                      bSolidsOk = true
                      break
@@ -464,7 +498,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
@@ -219,10 +221,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

Version.lua

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