3dPrinting 2.7f1 :

- aggiunta possibilità da file ini della macchina di forzare approssimazione lineare dei percorsi con tolleranza a scelta.
3dPrinting :
2025-06-20 13:16:56 +02:00 · 2025-04-29 11:54:32 +02:00 · 2025-04-28 15:07:36 +02:00 · 2025-04-22 15:10:18 +02:00 · 2025-01-31 11:05:57 +01:00 · 2024-12-13 09:15:38 +01:00
13 changed files with 2234 additions and 515 deletions
@@ -16,14 +16,14 @@ variables:
    $FileList = Get-ChildItem("*.lua")
    ForEach ($File in $FileList) {
      $FileName = Split-Path $File -leaf
-      lua54 -o bin\$FileName $FileName
-      echo "lua54 -o bin\$FileName $FileName"
+      lua54 -o bin\$FileName -s $FileName
+      echo "lua54 -o bin\$FileName -s $FileName"
    }
    $FileList = Get-ChildItem("LuaLibs\*.lua")
    ForEach ($File in $FileList) {
      $FileName = Split-Path $File -leaf
-      lua54 -o bin\LuaLibs\$FileName LuaLibs\$FileName
-      echo "lua54 -o bin\LuaLibs\$FileName LuaLibs\$FileName"
+      lua54 -o bin\LuaLibs\$FileName -s LuaLibs\$FileName
+      echo "lua54 -o bin\LuaLibs\$FileName -s LuaLibs\$FileName"
    }

 # helper copia SORGENTI verso cartella di rete R:\ dei SORGENTI
@@ -1,19 +1,21 @@

-REM Compilazione degli script 3dPrinting Egaltech                         2023.01.11
+REM Compilazione degli script 3dPrinting Egaltech                         2024.03.27
 REM Per togliere info di debug aggiungere flag -s prima del nome del file di input

 REM Compilazione 32 e 64 bit

-\EgtProg\Dll32\luac54 -o bin\LuaLibs\AddManData.lua                    LuaLibs\AddManData.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\CalcPaths.lua                     LuaLibs\CalcPaths.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\CalcSlices.lua                    LuaLibs\CalcSlices.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\CalcToolPath.lua                  LuaLibs\CalcToolPath.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\RunCalcSolids.lua                 LuaLibs\RunCalcSolids.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\RunGcodeGenerate.lua              LuaLibs\RunGcodeGenerate.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\RunMachParamFromSWCalc.lua        LuaLibs\RunMachParamFromSWCalc.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\RunSlicing.lua                    LuaLibs\RunSlicing.lua
-\EgtProg\Dll32\luac54 -o bin\CalcMachParamFromSW.lua                   CalcMachParamFromSW.lua
-\EgtProg\Dll32\luac54 -o bin\CalcSolids.lua                            CalcSolids.lua
-\EgtProg\Dll32\luac54 -o bin\GcodeGenerate.lua                         GcodeGenerate.lua
-\EgtProg\Dll32\luac54 -o bin\Slicing.lua                               Slicing.lua
-\EgtProg\Dll32\luac54 -o bin\Version.lua                               Version.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\AddManData.lua                  -s LuaLibs\AddManData.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\CalcPaths.lua                   -s LuaLibs\CalcPaths.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\CalcSlices.lua                  -s LuaLibs\CalcSlices.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\CalcToolPath.lua                -s LuaLibs\CalcToolPath.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\RunCalcSolids.lua               -s LuaLibs\RunCalcSolids.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\RunGcodeGenerate.lua            -s LuaLibs\RunGcodeGenerate.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\RunMachParamFromSWCalc.lua      -s LuaLibs\RunMachParamFromSWCalc.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\RunPrepareExport.lua            -s LuaLibs\RunPrepareExport.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\RunSlicing.lua                  -s LuaLibs\RunSlicing.lua
+\EgtProg\Dll32\luac54 -o bin\CalcMachParamFromSW.lua                 -s CalcMachParamFromSW.lua
+\EgtProg\Dll32\luac54 -o bin\CalcSolids.lua                          -s CalcSolids.lua
+\EgtProg\Dll32\luac54 -o bin\GcodeGenerate.lua                       -s GcodeGenerate.lua
+\EgtProg\Dll32\luac54 -o bin\PrepareExport.lua                       -s PrepareExport.lua
+\EgtProg\Dll32\luac54 -o bin\Slicing.lua                             -s Slicing.lua
+\EgtProg\Dll32\luac54 -o bin\Version.lua                             -s Version.lua
@@ -28,8 +28,12 @@ LINK_CRV = "Link"
 FRAME_PART = "FramePart"
 START_GEOM = "Start"
 TOT_SHELL_TRIM_SURF = "TotalShellSurfForTrim"
+SHELL_SURF = "ShellSurf"
+COARSE_TRIM_SURF = "CoarseTrimSurf"
 TRIM_SURF_LOOP = "TrimSurfLoop"
 SURF_LOOP = "SurfLoop"
+LOOP_GRP = "LoopGrp"
+DIR_ARROW = "Arrow"

 MIN_LEN = 0.1
 MIN_AREA = 0.01
@@ -134,6 +138,10 @@ KEY_RIBS_USER_LINK_CCW = "RibUserLinkCCW"
 KEY_RIBS_USER_LINK_ORDER = "RibUserLinkOrder"
 KEY_RIBS_USER_LINK_TOT = "RibsUserLinkParts"
 KEY_RIBS_INVERT_STRAND_ORDER = "RibsInvertStrandOrder"
+KEY_RIBS_MERGE_WITH_SHELLS = "RibsMergeWithShell"
+KEY_INVERT_RIBS_MERGED_SHELL_LINK = "InvertRibsMergedShellMainLink"
+KEY_RIBS_LEAD_FILLET = "RibsLeadFillet"
+KEY_RIBS_LINK_FILLET = "RibsLinkFillet"

 -- Regioni con diverso numero di passate
 KEY_SHELL_NBR_DIFF = "ShellNbrDifference"
@@ -170,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"
@@ -196,8 +207,12 @@ KEY_PREV_CRV = "PrevCrv"
 KEY_NEXT_CRVS = "NextCrvs"
 KEY_CRV_STRAND = "CurveStrand"
 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,
@@ -288,6 +303,7 @@ LAY_FRAME = "Frame"
 VIEWPARAMS = 'ViewParams'
 IMPORTED_SOLID = 'ImportedSolid'
 RESULT_READ_PROG = 'ResultReadProg'
+LAY_EXPORT = "ExportLayer"

 KEY_PART_ON_TABLE = 'PartOnTable'
 KEY_RESULT = 'Result'
@@ -120,7 +120,10 @@ local function GetRibParams( nId)
   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)
-  
+   ReadParam( nId, KEY_RIBS_MERGE_WITH_SHELLS, 'b', false, RibParam)
+   ReadParam( nId, KEY_RIBS_LEAD_FILLET, 'd', 0, RibParam)
+   ReadParam( nId, KEY_RIBS_LINK_FILLET, 'd', 0, RibParam)
+   
   return RibParam
 end

@@ -997,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
         
@@ -1040,17 +1044,17 @@ local function SlicingWithSolid( nStmId, vZSlices, dDeltaZStart, dZmin, frSlicin
      nLayId = EgtGetNext( nLayId)
   end

+   -- costolature
+   local nRibsLay = EgtGetFirstNameInGroup( s_nPartId, LAY_RIBS)
+   ExtractRibsLoops( nRibsLay, nStmId)
+   SlicingExtraObjects( nRibsLay, vtSlicing, TYPE.RIB, RIBS_CRV, RIBS_GRP, nStmId)
+   if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( #vZSlices + 3) / nCounterTot * 100, 0) == 1 then return false end
+   
   local bSpiralVase = EgtGetInfo( s_nPartId, KEY_SPIRAL_VASE, 'b') or false
   if not bSpiralVase then
      
      -- infill
      PrepareInfill( nStmId, vtSlicing)
-      if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( #vZSlices + 3) / nCounterTot * 100, 0) == 1 then return false end
-
-      -- costolature
-      local nRibsLay = EgtGetFirstNameInGroup( s_nPartId, LAY_RIBS)
-      ExtractRibsLoops( nRibsLay, nStmId)
-      SlicingExtraObjects( nRibsLay, vtSlicing, TYPE.RIB, RIBS_CRV, RIBS_GRP, nStmId)
      if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( #vZSlices + 6) / nCounterTot * 100, 0) == 1 then return false end
      
      -- solidi per regioni con diverso numero di passate
@@ -15,7 +15,11 @@ 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_dHMin
+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()
@@ -51,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
@@ -83,7 +92,7 @@ local function AddZCorrection( b3Box, LayerParams)
   local dHTool = LayerParams.dTDiam / 2 * dNxy
   -- altezza disponibile
   local dHBox = EgtGetInfo( s_nPartId, KEY_BOX_MIN_Z, 'i') or 0
-   local dHDisp = b3Box:getMin():getZ() - dHBox
+   local dHDisp = b3Box:getMin():getZ() - max( dHBox, 0)
   
   local dCorrZ = max( 0, max( dHStrand, dHTool) - dHDisp)
   
@@ -95,21 +104,42 @@ local function AddZCorrection( b3Box, LayerParams)
   local nFrameId = EgtGetFirstNameInGroup( s_nPartId, LAY_FRAME)
   EgtMove( nFrameId, - vtMove, GDB_RT.GLOB)
   
-end
-
------------------------------------------------------------------
-local function FindWipeEndPoint( ptS, vtDir, dLen, vtSlicing)
-   
-   local ptE = ptS + vtDir * dLen
-   -- verifico soddisfi altezza minima per non entrare nella tavola
-   local k = 1
-   while ptE:getZ() < s_dHMin + GEO.EPS_SMALL and k < 36 do
-      vtDir:rotate( vtSlicing, 10)
-      ptE = ptS + vtDir * dLen
-      k = k + 1
+   -- correzione per i wipe
+   -- altezza minima necessaria per i wipe
+   local dHMinWipe = LayerParams.dTDiam / 2 * dNxy + max( dHBox, 0) + s_dHSafeWipe
+   local vLayIds = EgtGetNameInGroup( s_nPartId, SLICE_LAYER.."*")
+   for i = 1, #vLayIds do
+      local vCrvGrps = EgtGetNameInGroup( vLayIds[i], CONTOUR_GRP.."*")
+      for j = 1, #vCrvGrps do
+         local nTPath = EgtGetFirstNameInGroup( vCrvGrps[j], TOOLPATH_GRP)
+         if nTPath then
+            local vIds = EgtGetAllInGroup( nTPath)
+            for k = 1, #vIds do
+               -- se wipe verifico se ha lunghezza sensata per non finire nella tavola
+               if EgtGetInfo( vIds[k], KEY_TYPE, 'i') == TYPE.WIPE then
+                  -- da controllare solo se non segue l'andamento di una curva chiusa
+                  local bOnCurve = EgtGetInfo( vIds[k], KEY_WIPE_ON_CRV, 'b') or false
+                  if not bOnCurve then
+                     local dLen = EgtCurveLength( vIds[k])
+                     local vtDir = EgtSV( vIds[k], GDB_ID.ROOT)
+                     local ptE = EgtEP( vIds[k], GDB_ID.ROOT)
+                     if ptE:getZ() < dHMinWipe then
+                        -- modifico la lunghezza per non finire nella tavola
+                        local dDiffLen = abs( ( dHMinWipe - ptE:getZ()) / vtDir:getZ())
+                        if dDiffLen > dLen - GEO.EPS_SMALL then
+                           -- l'intero tratto di wipe va eliminato
+                           EgtErase( vIds[k])
+                           EgtOutLog( 'Warning : wipe was removed due to wrong direction (layer '..tostring( i)..') - CalcToolPath')
+                        else
+                           EgtTrimCurveEndAtLen( vIds[k], dLen - dDiffLen)
+                        end
+                     end
+                  end
+               end
+            end
+         end
+      end
   end
-   
-   return ptE
 end

 -------------------------------------------------------------------
@@ -131,7 +161,7 @@ local function AddCurvesToToolPath( vEntIds, nTpathGrpId, nOrder, bInvert, vtSli
      
      -- mi sposto dell'altezza layer
      EgtMove( vIds[nIdx], dLayHeight * vtSlicing, GDB_RT.GLOB)
-      
+     
      if EgtCurveIsClosed( vIds[nIdx]) then
         EgtSetInfo( vIds[nIdx], KEY_CLOSED_CRV, 1)
         -- eventuale inversione
@@ -140,6 +170,13 @@ local function AddCurvesToToolPath( vEntIds, nTpathGrpId, nOrder, bInvert, vtSli
            EgtSetInfo( vIds[nIdx], KEY_INVERTED_CRV, 1)
         end
      end
+      
+      -- approssimo la curva e ne risetto il punto iniziale
+      local ptS = EgtSP( vIds[nIdx], GDB_ID.ROOT)
+      EgtApproxCurve( vIds[nIdx], GDB_CA.ARCS, s_dApproxTol)
+      if EgtCurveIsClosed( vIds[nIdx]) then
+         EgtChangeClosedCurveStartPoint( vIds[nIdx], ptS, GDB_RT.GLOB)
+      end

      EgtSetInfo( vEntIds[i], KEY_ASSOCIATED_TP_CRV, vIds[nIdx])
      EgtSetInfo( vIds[nIdx], KEY_ASSOCIATED_P_CRV, vEntIds[i])
@@ -297,8 +334,6 @@ local function AddLeadIn( nCrvId, LayerParams, nGrpId)

   vtOrtho:rotate( LayerParams.vtSlicing, dAng)
   local ptS = ptE - LayerParams.dLeadInTangDist * vtTang + LayerParams.dLeadInOrthoDist * vtOrtho
-   -- verifico che non affondi nella tavola
-   if ptS:getZ() < s_dHMin + GEO.EPS_SMALL then return end

   local nLeadInCrv
   if LayerParams.nLeadInType == LEAD_TYPE.LINEAR then
@@ -316,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

 --------------------------------------------------------------------
@@ -358,22 +395,33 @@ local function AddRetraction( nCrvId, vtSlicing, dCoastingLen, dWipeLen, dWipeDi
   local nType = EgtGetInfo( nCrvId, KEY_TYPE, 'i')
   local bClosed = EgtGetInfo( nCrvId, KEY_CLOSED_CRV, 'b') or false
   local bInverted = EgtGetInfo( nCrvId, KEY_INVERTED_CRV, 'b') or false
-
+   local dStrand = EgtGetInfo( nCrvId, KEY_CRV_STRAND, 'd')
+   
   -- curva ausiliaria per generare correttamente wipe
   local nCopyId = EgtCopyGlob( nCrvId, nCrvId, GDB_IN.AFTER)
-   if not EgtCurveIsClosed( nCopyId) then
-      local ptNewStart = EgtEP( nCrvId)
-      local dPar = EgtCurveParamAtPoint( nCopyId, ptNewStart)
-      local _, dParE = EgtCurveDomain( nCopyId)
-      if abs( dPar - dParE) < GEO.EPS_SMALL then
-         EgtCloseCurveCompo( nCopyId)
-         EgtChangeClosedCurveStartPoint( nCopyId, ptNewStart)
-      else
+   if not EgtCurveIsClosed( nCopyId) and EgtCurveIsFlat( nCopyId) then
+      local ptNewStart = EgtEP( nCopyId, GDB_ID.ROOT)
+      -- mi posiziono in un frame locale per fare i conti
+      local nGrp = EgtGroup( EgtGetParent( nCrvId), Frame3d( ORIG(), vtSlicing), GDB_RT.GLOB)
+      EgtRelocateGlob( nCopyId, nGrp)
+      local nInters = EgtCurveSelfIntersCount( nCopyId)
+      local nCrvCnt
+      if nInters > 0 then
         -- caso con sovrapposizione
-         EgtTrimCurveStartAtParam( nCopyId, dPar)
+         nCopyId, nCrvCnt = EgtSplitCurveAtSelfInters( nCopyId)
+         for nIdx = 1, nCrvCnt - 2 do
+            EgtAddCurveCompoCurve( nCopyId, nCopyId + nIdx)
+         end
+         if nCrvCnt > 1 then 
+            EgtErase( nCopyId + nCrvCnt - 1)
+         end
      end
+      EgtCloseCurveCompo( nCopyId)
+      EgtChangeClosedCurveStartPoint( nCopyId, ptNewStart, GDB_RT.GLOB)
+      EgtRelocateGlob( nCopyId, nCrvId, GDB_IN.AFTER)
+      EgtErase( nGrp)
   end
-   
+
   local nCoastingId
   if dCoastingLen > GEO.EPS_SMALL then
      nCoastingId = EgtCopyGlob( nCrvId, nCrvId, GDB_IN.AFTER)
@@ -404,6 +452,7 @@ local function AddRetraction( nCrvId, vtSlicing, dCoastingLen, dWipeLen, dWipeDi
         nWipeId = nCopyId
         nCopyId = nil
         EgtTrimCurveEndAtLen( nWipeId, dWipeLen)
+         EgtSetInfo( nWipeId, KEY_WIPE_ON_CRV, true)
      else
         -- se extra shell, infill, spiral vase o rib che non termina sulla parete
         local ptS = EgtEP( nCoastingId or nCrvId, GDB_ID.ROOT)
@@ -451,14 +500,13 @@ local function AddRetraction( nCrvId, vtSlicing, dCoastingLen, dWipeLen, dWipeDi
         end
         
         vtDir:rotate( vtSlicing, EgtIf( bChangeSign, - dAng, dAng))
-         local ptE = FindWipeEndPoint( ptS, vtDir, dWipeLen, vtSlicing)
+         local ptE = ptS + vtDir * dWipeLen
         nWipeId = EgtCurveCompoFromPoints( EgtGetParent( nCoastingId or nCrvId), {ptS, ptE}, GDB_RT.GLOB)
         EgtModifyCurveExtrusion( nWipeId, vtSlicing, GDB_RT.GLOB)
         EgtRelocateGlob( nWipeId, nCoastingId or nCrvId, GDB_IN.AFTER)
      end
      
      if nWipeId then
-         local dStrand = EgtGetInfo( nCrvId, KEY_CRV_STRAND, 'd')
         EgtSetName( nWipeId, WIPE_CRV)
         EgtSetInfo( nWipeId, KEY_TYPE, TYPE.WIPE)
         EgtSetInfo( nWipeId, KEY_CRV_STRAND, dStrand)
@@ -497,12 +545,12 @@ 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)
   local nFirstCopy = EgtCopyGlob( vIds[1], nTpathGrpId)   -- necessaria per corretto offset lead point sulla shell esterna
-   
+
   -- assegno lo strand
   for i = 1, #vIds do
      local nType = EgtGetInfo( vIds[i], KEY_TYPE, 'i')
@@ -514,7 +562,7 @@ local function CalcShellsToolPath( vEntIds, nTpathGrpId, LayerParams)
         EgtSetInfo( vIds[i], KEY_CRV_STRAND, LayerParams.dInfillStrand)
      end
   end
-   
+
   -- aggiungo gli opportuni raccordi
   AddLink( vIds, nTpathGrpId, LayerParams.nLinkType, LayerParams.dLinkParam, LayerParams.dSPOffs, LayerParams.nOrder, LayerParams.vtSlicing)
   
@@ -545,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)
   
@@ -898,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 = {}
@@ -915,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
      
@@ -956,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')
@@ -1024,6 +1072,78 @@ end

 --------------------------------------------------------------------
 --------------------------- RIBS -----------------------------------
+--------------------------------------------------------------------
+local function AddFillet( nCrv1, nCrv2, dFillet, vtSlicing)
+   
+   if dFillet < GEO.EPS_SMALL then
+      return
+   end
+   
+   local nRefPosId = EgtGetPrev( nCrv1)
+   local nRefGrpId = EgtGetParent( nCrv1)
+   local vsInfo1 = EgtGetAllInfo( nCrv1)
+   local vsInfo2 = EgtGetAllInfo( nCrv2)
+   
+   -- creo un gruppo con riferimento locale allo slicing per i conti del fillet
+   local nGrpTmp = EgtGroup( EgtGetParent( nCrv1), Frame3d( ORIG(), vtSlicing), GDB_RT.GLOB)
+   
+   -- creo il fillet
+   local dParRef1 = EgtCurveParamAtLength( nCrv1, EgtCurveLength( nCrv1) - 100 * GEO.EPS_SMALL)
+   local dParRef2 = EgtCurveParamAtLength( nCrv2, 100 * GEO.EPS_SMALL)
+   local nFillet = EgtCurveFillet( nGrpTmp, nCrv1, EgtUP( nCrv1, dParRef1, nGrpTmp), nCrv2, EgtUP( nCrv2, dParRef2, nGrpTmp), dFillet, true, GDB_RT.LOC)
+   if not nFillet then
+      -- ritento con valore di fillet leggermente inferiore
+      nFillet = EgtCurveFillet( nGrpTmp, nCrv1, EgtUP( nCrv1, dParRef1, nGrpTmp), nCrv2, EgtUP( nCrv2, dParRef2, nGrpTmp), dFillet - 50 * GEO.EPS_SMALL, true, GDB_RT.LOC)
+   end
+
+   -- spezzo a metà il fillet per assegnarlo alle due curve
+   if nFillet then
+      
+      local nNewFillet = EgtSplitCurve( nFillet, 2)
+      
+      -- aggiungo a nCrv1
+      if EgtExistsObj( nCrv1) then
+         EgtAddCurveCompoArcTg( nCrv1, EgtEP( nNewFillet, GDB_ID.ROOT), true, GDB_RT.GLOB)
+         EgtErase( nNewFillet)
+      else
+         -- nCrv1 viene sostituita completamente dal fillet
+         local nNewCrv = EgtCurveCompo( nRefGrpId, {nNewFillet})
+         -- riposiziono dopo il precedente di nCrv1 ( se esiste) oppure in testa al gruppo
+         if nRefPosId ~= GDB_ID.NULL then
+            EgtRelocateGlob( nNewFillet, nRefPosId, GDB_IN.AFTER)
+         else
+            EgtRelocateGlob( nNewFillet, nRefGrpId, GDB_IN.FIRST_SON)
+         end
+         -- modifico l'id per conservare quello di nCrv1
+         EgtChangeId( nNewCrv, nCrv1)
+         -- riassegno le info
+         for i = 1, #vsInfo1 do
+            local vsInfo = EgtSplitString( vsInfo1[i], '=')
+            EgtSetInfo( nCrv1, vsInfo[1], vsInfo[2])
+         end
+      end
+      
+      -- aggiungo a nCrv2
+      if EgtExistsObj( nCrv2) then
+         EgtAddCurveCompoArcTg( nCrv2, EgtSP( nNewFillet + 1, GDB_ID.ROOT), false, GDB_RT.GLOB)
+         EgtErase( nNewFillet + 1)
+      else
+         -- nCrv2 viene sostituita completamente dal fillet
+         local nNewCrv = EgtCurveCompo( nRefGrpId, {nNewFillet + 1})
+         EgtRelocateGlob( nNewCrv, nCrv1, GDB_IN.AFTER)
+         EgtChangeId( nNewCrv, nCrv2)
+         for i = 1, #vsInfo2 do
+            local vsInfo = EgtSplitString( vsInfo2[i], '=')
+            EgtSetInfo( nCrv2, vsInfo[1], vsInfo[2])
+         end
+      end
+   else
+      EgtOutLog( 'Warning : ribs fillet not possible (layer '..tostring( s_nCurrIdx)..') - CalcToolPath')
+   end
+   
+   EgtErase( nGrpTmp)
+end
+
 --------------------------------------------------------------------
 local function VerifyRibsLink( nLinkId, nCurr, nNext, nGrpTmp, dStrand)

@@ -1058,7 +1178,7 @@ local function VerifyRibsLink( nLinkId, nCurr, nNext, nGrpTmp, dStrand)
      end
      
      -- se collegamento non ottimale verifico che abbia una parte esterna alla regione occupata dai setti abbsatanza lunga ( > 20% della lunghezza totale)
-      if dist( EgtEP( nCurr, GDB_ID.ROOT), EgtSP( nNext, GDB_ID.ROOT)) > dist( EgtEP( nCurr, GDB_ID.ROOT), EgtEP( nNext, GDB_ID.ROOT)) + GEO.EPS_SMALL then
+      if dist( EgtEP( nCurr, GDB_ID.ROOT), EgtSP( nNext, GDB_ID.ROOT)) > dist( EgtEP( nCurr, GDB_ID.ROOT), EgtEP( nNext, GDB_ID.ROOT)) + 1000 * GEO.EPS_SMALL then
         local nSrfRibs = EgtSurfFrFatCurve( nGrpTmp, nCurr, dStrand, false) or GDB_ID.NULL
         local nSrfRibs2 = EgtSurfFrFatCurve( nGrpTmp, nNext, dStrand, false) or GDB_ID.NULL
         EgtSurfFrAdd( nSrfRibs, nSrfRibs2)
@@ -1100,7 +1220,7 @@ local function VerifyRibsLink( nLinkId, nCurr, nNext, nGrpTmp, dStrand)
            dOffs = dCurrStrand * 0.5
         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 - 10 * GEO.EPS_SMALL
+            dOffs = dCurrStrand * 0.5 + ( 0.5 - dOverlap / 100) * dStrand - 50 * GEO.EPS_SMALL
         end
         
         if dOffs > GEO.EPS_SMALL then
@@ -1226,6 +1346,8 @@ 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')
   
   local vCrvIds = EgtGetAllInGroup( nLoopGrp)
   -- recupero le curve di bordo su cui poggiano i setti e i corrispondenti parametri
@@ -1257,6 +1379,14 @@ local function CalcRibsLink( nCurr, nNext, nLoopGrp, bForceLink, vtSlicing, nGrp
         end
         
         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
            EgtRelocateGlob( nLinkId, nCurr, GDB_IN.AFTER)
            EgtSetInfo( nLinkId, KEY_TYPE, TYPE.RIB)
            EgtSetName( nLinkId, LINK_CRV)
@@ -1270,6 +1400,7 @@ local function CalcRibsLink( nCurr, nNext, nLoopGrp, bForceLink, vtSlicing, nGrp
   -- se non ho trovato un collegamento lungo bordi ma link deve esserci creo una linea tra ptS e ptE
   if bForceLink then
      local nLinkId = EgtCurveCompoFromPoints( EgtGetParent( nCurr), {ptS, ptE})
+      -- assegno le info
      EgtSetInfo( nLinkId, KEY_TYPE, TYPE.RIB)
      EgtSetName( nLinkId, LINK_CRV)
      EgtModifyCurveExtrusion( nLinkId, vtSlicing, GDB_RT.GLOB)
@@ -1277,6 +1408,11 @@ local function CalcRibsLink( nCurr, nNext, nLoopGrp, bForceLink, vtSlicing, nGrp
      EgtSetInfo( nLinkId, KEY_CRV_STRAND, dStrand)
      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
      else
         EgtErase( nLinkId)
@@ -1288,12 +1424,13 @@ local function CalcRibsLink( nCurr, nNext, nLoopGrp, bForceLink, vtSlicing, nGrp
 end

 --------------------------------------------------------------------
-local function CalcLoopRibLink( nCurr, nNext, nLoopGrp, vtSlicing, nGrpTmp)
+local function CalcLoopRibLink( nCurr, nNext, nLoopGrp, vtSlicing, nGrpTmp, bForceLink)
   
   local ptS = EgtEP( nCurr)
   local ptE = EgtSP( nNext)
   if AreSamePointApprox( ptS, ptE) then return end
   local dStrand = EgtGetInfo( nCurr, KEY_CRV_STRAND, 'd')
+   local dFillet = EgtGetInfo( nCurr, KEY_RIBS_LINK_FILLET, 'd')
   
   local vCrvIds = EgtGetAllInGroup( nLoopGrp)
   -- scorro le curve di bordo e verifico se posso creare il link
@@ -1309,6 +1446,12 @@ local function CalcLoopRibLink( nCurr, nNext, nLoopGrp, vtSlicing, nGrpTmp)
            EgtModifyCurveExtrusion( nLinkId, vtSlicing, GDB_RT.GLOB)
            EgtSetInfo( nLinkId, KEY_CRV_STRAND, dStrand)
            if VerifyRibsLink( nLinkId, nCurr, nNext, nGrpTmp, dStrand) then
+               -- fillet
+               if bForceLink then
+                  dFillet = min( dFillet, dStrand * 0.5)
+               end
+               AddFillet( nCurr, nLinkId, dFillet, vtSlicing)
+               AddFillet( nLinkId, nNext, dFillet, vtSlicing)
               return nLinkId
            else
               EgtErase( nLinkId)
@@ -1332,7 +1475,19 @@ local function VerifyRibsLead( nId, nRibId, bInVsOut, nGrpTmp)
   -- individuo eventuale lead in o link relativo al setto corrente ( solo se collega due passate dello stesso setto)
   local nCurrLI
   local nCurrLink
-   if not bInVsOut then
+   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
@@ -1374,7 +1529,7 @@ local function VerifyRibsLead( nId, nRibId, bInVsOut, nGrpTmp)
   -- controllo se intersezione
   for i = 1, #vCheckIds do
      local dCurrStrand = EgtGetInfo( vCheckIds[i], KEY_CRV_STRAND, 'd') or EgtGetInfo( vCheckIds[i], KEY_RIBS_STRAND, 'd')
-      local dCurrOffs = dCurrStrand * 0.5 + ( 0.5 - dOverlap / 100) * dStrand - 10 * GEO.EPS_SMALL
+      local dCurrOffs = dCurrStrand * 0.5 + ( 0.5 - dOverlap / 100) * dStrand - 50 * GEO.EPS_SMALL
      if dCurrOffs > GEO.EPS_SMALL then
         local nSrfCurr = EgtSurfFrFatCurve( nGrpTmp, vCheckIds[i], dCurrOffs, false)
         if nSrfCurr then
@@ -1403,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
@@ -1543,6 +1699,7 @@ local function AddRibsLeadIn( nCrv, nLoopsGrp, vtSlicing, nGrpTmp, bForceNoSolid
   local dLILen = EgtGetInfo( nCrv, KEY_RIBS_LEAD_IN_LEN, 'd')
   local bLIInvert = EgtGetInfo( nCrv, KEY_RIBS_LEAD_IN_INVERT, 'b')
   local dStrand = EgtGetInfo( nCrv, KEY_CRV_STRAND, 'd')
+   local dFillet = EgtGetInfo( nCrv, KEY_RIBS_LEAD_FILLET, 'd')
   
   if dLILen < GEO.EPS_SMALL then return end
   
@@ -1556,11 +1713,13 @@ local function AddRibsLeadIn( nCrv, nLoopsGrp, vtSlicing, nGrpTmp, bForceNoSolid
   end
   
   for i = 1, #vCrvOffs do
-      local dParS = EgtCurveParamAtPoint( vCrvOffs[i], ptS)
+      local dParS = EgtCurveParamAtPoint( vCrvOffs[i], ptS, 100 * GEO.EPS_SMALL)
      if dParS then
         local nLeadIn = FindCorrectRibLead( dParS, nCrv, vCrvOffs[i], bLIInvert, dLILen, true, nGrpTmp, bSpecialCase)
         -- se lead in possibile
         if nLeadIn then
+            AddFillet( nLeadIn, nCrv, dFillet, vtSlicing)
+            
            EgtModifyCurveExtrusion( nLeadIn, vtSlicing, GDB_RT.GLOB)
            EgtSetInfo( nLeadIn, KEY_TYPE, TYPE.RIB)
            EgtSetName( nLeadIn, LEAD_IN_CRV)
@@ -1580,6 +1739,7 @@ local function AddRibsLeadOut( nCrv, nLoopsGrp, vtSlicing, nGrpTmp, bForceNoSoli
   local dRibsLOWipeAng = EgtGetInfo( nCrv, KEY_RIBS_LEAD_OUT_WIPE_DIR, 'd')
   local bRibsLOInvert = EgtGetInfo( nCrv, KEY_RIBS_LEAD_OUT_INVERT, 'b')
   local dStrand = EgtGetInfo( nCrv, KEY_CRV_STRAND, 'd')
+   local dFillet = EgtGetInfo( nCrv, KEY_RIBS_LEAD_FILLET, 'd')
   
   if abs( dRibsLOLen) < GEO.EPS_SMALL and
      abs( dRibsLOCoasting) < GEO.EPS_SMALL and
@@ -1613,7 +1773,12 @@ local function AddRibsLeadOut( nCrv, nLoopsGrp, vtSlicing, nGrpTmp, bForceNoSoli
         local nCrvRef, bInvert = FindCorrectRibLead( dParE, nCrv, vCrvOffs[i], bRibsLOInvert, dRibsLOLen + dRibsLOCoasting, false, nGrpTmp, bSpecialCase)
   
         if nCrvRef then
-   
+            
+            -- aggiungo il fillet ( potrebbe coinvolgere sia lead out sia coasting)
+            AddFillet( nCrv, nCrvRef, dFillet, vtSlicing)
+            -- calcolo la nuova lunghezza per il lead out per conservare la lunghezza del coasting dopo il fillet
+            dRibsLOLen = EgtCurveLength( nCrvRef) - dRibsLOCoasting
+            
            -- primo tratto ( segue offset con flusso aperto)
            if dRibsLOLen > GEO.EPS_SMALL then
               nCrvLO = EgtCopyGlob( nCrvRef, nCrv, GDB_IN.AFTER)
@@ -1651,7 +1816,7 @@ local function AddRibsLeadOut( nCrv, nLoopsGrp, vtSlicing, nGrpTmp, bForceNoSoli
               local nType = EgtGetInfo( nCrv, KEY_RIBS_TYPE, 'i')
               if nType == RIB_TYPE.EXTERNAL then dAng = - dAng end
               vtE:rotate( vtSlicing, EgtIf( bInvert, - dAng, dAng))
-               local ptFinal = FindWipeEndPoint( ptE, vtE, dRibsLOWipe, vtSlicing)
+               local ptFinal = ptE + vtE * dRibsLOWipe
               nWipe = EgtCurveCompoFromPoints( EgtGetParent( nCrv), { ptE, ptFinal}, GDB_RT.GLOB)
               if nWipe then
                  EgtModifyCurveExtrusion( nWipe, vtSlicing, GDB_RT.GLOB)
@@ -1683,12 +1848,20 @@ local function CalcRibsToolPath( vEntIds, nRibsGrp, nTpathGrpId, LayerParams)
   local nGrpTmp = EgtGroup( nRibsGrp, frLoc, GDB_RT.GLOB)
   
   -- aggiungo le costolature nel toolpath
-   local nNewFirstEnt
+   local nLastEnt = EgtGetLastInGroup( nTpathGrpId)
   for i = 1, #vEntIds do
      -- copio entità nel gruppo toolpath
      local nNewEntId = EgtCopyGlob( vEntIds[i], nTpathGrpId, GDB_IN.LAST_SON)
      -- mi sposto dell'altezza layer
      EgtMove( nNewEntId, LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB)
+      
+      -- approssimo la curva e ne risetto punto iniziale (se chiusa)
+      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
+      
      EgtModifyCurveExtrusion( nNewEntId, LayerParams.vtSlicing, GDB_RT.GLOB)
      EgtSetColor( nNewEntId, EgtStdColor('MAROON'))
      
@@ -1697,13 +1870,11 @@ local function CalcRibsToolPath( vEntIds, nRibsGrp, nTpathGrpId, LayerParams)
      
      EgtSetInfo( nNewEntId, KEY_ASSOCIATED_P_CRV, vEntIds[i])
      EgtSetInfo( vEntIds[i], KEY_ASSOCIATED_TP_CRV, nNewEntId)
-     
-      if i == 1 then nNewFirstEnt = nNewEntId end
   end
   
   -- recupero i gruppi delle costolature
   local tabRibs = {}
-   local nFirst = nNewFirstEnt
+   local nFirst = EgtGetNext( nLastEnt)
   while nFirst do
      local sName = EgtGetName( nFirst)
      local vIds = EgtGetNameInGroup( nTpathGrpId, sName)
@@ -1723,7 +1894,7 @@ local function CalcRibsToolPath( vEntIds, nRibsGrp, nTpathGrpId, LayerParams)
         local bLoopRib = EgtGetInfo( tabRibs[i][1], KEY_LOOP_RIB, 'b') or false
         for j = 1, #tabRibs[i] - 1 do
            local bUserLink = ( EgtGetInfo( tabRibs[i][j], KEY_RIBS_USER_LINK, 'b') or false) and ( EgtGetInfo( tabRibs[i][j+1], KEY_RIBS_USER_LINK, 'b') or false)
-            local bSplitAfterTrim = EgtGetInfo( tabRibs[i][1], KEY_SPLIT_AFTER_TRIM, 'b') or false
+            local bSplitAfterTrim = ( EgtGetInfo( tabRibs[i][j], KEY_SPLIT_AFTER_TRIM, 'b') or false) and ( EgtGetInfo( tabRibs[i][j+1], KEY_SPLIT_AFTER_TRIM, 'b') or false)
            local nOrig1 = EgtGetInfo( tabRibs[i][j], KEY_ORIGINAL_RIB, 'i') or 0
            local nOrig2 = EgtGetInfo( tabRibs[i][j + 1], KEY_ORIGINAL_RIB, 'i') or 0
            local nSplitId1 = EgtGetInfo( tabRibs[i][j], KEY_SPLIT_ID, 'i') or 0
@@ -1735,12 +1906,17 @@ local function CalcRibsToolPath( vEntIds, nRibsGrp, nTpathGrpId, LayerParams)
               if not bLoopRib then
                  CalcRibsLink( tabRibs[i][j], tabRibs[i][j + 1], nLoopGrp, bForceLink, LayerParams.vtSlicing, nGrpTmp)
               else
-                  local nLinkId = CalcLoopRibLink( tabRibs[i][j], tabRibs[i][j + 1], nLoopGrp, LayerParams.vtSlicing, nGrpTmp)
+                  local nLinkId = CalcLoopRibLink( tabRibs[i][j], tabRibs[i][j + 1], nLoopGrp, LayerParams.vtSlicing, nGrpTmp, bForceLink)
                  -- se collegamento congiungo i setti in unico percorso
                  if nLinkId then
-                     EgtAddCurveCompoCurve( tabRibs[i][j], nLinkId)
-                     EgtAddCurveCompoCurve( tabRibs[i][j], tabRibs[i][j + 1])
-                     tabRibs[i][j+1] = tabRibs[i][j] -- aggiorno id nel vettore dei setti per gestire correttamente la curva allo step successivo
+                     EgtAddCurveCompoCurve( tabRibs[i][j+1], nLinkId, true, false)
+                     EgtAddCurveCompoCurve( tabRibs[i][j+1], tabRibs[i][j], true, false)
+                     -- aggiorno id nel vettore dei setti per gestire correttamente le curve negli step successivi
+                     for k = 0, j do
+                        if tabRibs[i][k] == tabRibs[i][j] then
+                           tabRibs[i][k] = tabRibs[i][j+1]
+                        end
+                     end
                  end
               end
            end
@@ -1749,7 +1925,7 @@ local function CalcRibsToolPath( vEntIds, nRibsGrp, nTpathGrpId, LayerParams)
         -- se LoopRib aggiungo collegamento tra primo e ultimo setto del gruppo
         if bLoopRib then
            local nTotCrv = #tabRibs[i]
-            local nLinkId = CalcLoopRibLink( tabRibs[i][nTotCrv], tabRibs[i][1], nLoopGrp, LayerParams.vtSlicing, nGrpTmp)
+            local nLinkId = CalcLoopRibLink( tabRibs[i][nTotCrv], tabRibs[i][1], nLoopGrp, LayerParams.vtSlicing, nGrpTmp, false)
            if nLinkId then
               -- se curva unica
               if tabRibs[i][nTotCrv] == tabRibs[i][1] then
@@ -1794,7 +1970,7 @@ local function CalcRibsToolPath( vEntIds, nRibsGrp, nTpathGrpId, LayerParams)
   if nType == RIB_TYPE.UNBOUNDED then
      bForceNoSolidBorder = true
   end
-   local nCrvRib = nNewFirstEnt
+   local nCrvRib = EgtGetNext( nLastEnt)
   while nCrvRib do
      -- verifico se necessario lead in
      local nPrev = EgtGetPrev( nCrvRib)
@@ -1817,10 +1993,13 @@ end
 --------------------------------------------------------------------
 local function AddSpiralVaseLeadOut( nOldId, LayerParams)
   
-    if LayerParams.nLeadOutType ~= LEAD_TYPE.NONE then
+   if LayerParams.nLeadOutType ~= LEAD_TYPE.NONE then
      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
@@ -1836,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
@@ -1860,7 +2040,8 @@ local function SpiralVase( vLayIds, LayerParams)
      local vCrvGrpIds = EgtGetNameInGroup( vLayIds[ nIdx], CONTOUR_GRP.."*")
      if #vCrvGrpIds > 1 then
         -- se più di un gruppo di curve warning
-         EgtOutLog( 'Warning : in spiral vase mode more than one curve (layer '..tostring( nIdx)..') - CalcToolPath')
+         EgtOutBox( 'Error in spiral vase : layer ' .. tostring( nIdx) .. ' has more than one toolpath', 'ToolPathCalc')
+         return false
      end
      
      for i = 1, #vCrvGrpIds do
@@ -1883,9 +2064,15 @@ local function SpiralVase( vLayIds, LayerParams)
         end

         -- creo il percorso di lavoro :
-         local nEntId = EgtGetFirstInGroup( nPathGrpId)
-         while nEntId do
-            local nNewEntId = EgtCopyGlob( nEntId, nTpathGrpId, GDB_IN.LAST_SON)
+         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
@@ -1893,7 +2080,7 @@ local function SpiralVase( vLayIds, LayerParams)
               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)
            
@@ -1905,47 +2092,129 @@ local function SpiralVase( vLayIds, LayerParams)
            EgtSetColor( nNewEntId, EgtStdColor('GRAY'))
            
            -- se primo layer
-            if bFirst and nNewEntId 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)
+                     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)
+               
+               -- 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 = nEntId
-            nOldId = nNewEntId
-            nEntId = EgtGetNext( nEntId)
+            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
@@ -1970,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
@@ -1978,11 +2247,6 @@ function CalcToolPath.Exec( nPartId)
   -- recupero i parametri per calcolo dei toolpath
   local LayerParams = GetLayerParamsForToolPathCalc()
   
-   -- altezza necessaria per correzione wipe
-   local dNxy = sqrt( LayerParams.vtSlicing:getX() * LayerParams.vtSlicing:getX() + LayerParams.vtSlicing:getY() * LayerParams.vtSlicing:getY())
-   local dHBox = EgtGetInfo( s_nPartId, KEY_BOX_MIN_Z, 'i') or 0
-   s_dHMin = LayerParams.dTDiam / 2 * dNxy + dHBox
-   
   -- caso spiral vase
   if LayerParams.bSpiralVase then
      return SpiralVase( vLayIds, LayerParams)
@@ -1993,6 +2257,8 @@ function CalcToolPath.Exec( nPartId)
   -- Ciclo sui layer
   for nIdx = 1, #vLayIds do
      
+      s_nCurrIdx = nIdx
+      
      -- scorro tutti i gruppi di contorni
      local nCrvGrpId = EgtGetFirstNameInGroup( vLayIds[ nIdx], CONTOUR_GRP.."*")
      while nCrvGrpId do
@@ -2077,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
@@ -14,6 +14,7 @@ local AMD = require( 'AddManData')

 --------------------------------------------------------------------
 local s_dTol = 0.1
+local s_nSimplifiedSection = 0

 ---------------------------------------------------------------------
 local function GetLayerParamsForSolidCalc( nPartId)
@@ -21,51 +22,46 @@ local function GetLayerParamsForSolidCalc( nPartId)
   LayerParams.bSpiralVase = EgtGetInfo( nPartId, KEY_SPIRAL_VASE, 'b') or false
   LayerParams.dLayHeight = EgtGetInfo( nPartId, KEY_SLICE_STEP, 'd')
   LayerParams.vtSlicing = EgtGetInfo( nPartId, KEY_SLICING_DIR, 'v')
+   LayerParams.dStrand = EgtGetInfo( nPartId, KEY_STRAND, 'd')
   return LayerParams
 end

 ---------------------------------------------------------------------
 local function CalcSectionParams( dStrand, dH)
-   local dL = dStrand
-   local dLm = dStrand / 10
-   local dHm = dH / 6
-   local dD1 = 0.5 * dL - dLm
-   local dD2 = 0.5 * dL - dD1 
-   local dD3 = dHm
-   local dD4 = dH - 2 * dD3
-   return dD1, dD2, dD3, dD4
+   local dBevelX = 0
+   local dBevelY = 0
+   if s_nSimplifiedSection == 0 then
+      -- sezione ottagonale
+      dBevelX = dStrand / 10
+      dBevelY = dH / 6
+   end
+   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)

-   local dD1, dD2, dD3, dD4 = CalcSectionParams( dStrand, dH)
-   local ptA = ptS - dH * vtSlicing + dD1 * vtDir
-   local ptB = ptA + dD2 * vtDir + dD3 *vtSlicing
-   local ptC = ptB + dD4 * vtSlicing
+   local dBevelX, dBevelY = CalcSectionParams( dStrand, dH)
+   local ptA = ptS - dH * vtSlicing  + ( 0.5 * dStrand - dBevelX) * vtDir
+   local ptB = ptA + dBevelY * vtSlicing + dBevelX * vtDir
+   local ptC = ptB + ( dH - 2 * dBevelY) * vtSlicing
   local ptD = ptA + dH * vtSlicing
-   local ptE = ptD - 2 * dD1 * vtDir 
-   local ptF = ptC - 2 * ( dD1 + dD2) * vtDir
-   local ptG = ptB - 2 * ( dD1 + dD2) * vtDir
-   local ptH = ptA - 2 * dD1 * vtDir 
+   local ptE = ptD - ( dStrand - 2 * dBevelX) * vtDir
+   local ptF = ptC - dStrand * vtDir
+   local ptG = ptB - dStrand * vtDir
+   local ptH = ptA - ( dStrand - 2 * dBevelX) * vtDir
   
   local nId = EgtCurveCompoFromPoints( nSolidGrp, {ptA, ptB, ptC, ptD, ptE, ptF, ptG, ptH, ptA}, GDB_RT.GLOB)
   EgtInvertCurve( nId)
   
-   return nId 
-end
-
---------------------------------------------------------------------
-local function CreateHalfSection( ptS, vtDir, dStrand, dH, vtSlicing, nSolidGrp)
-
-   local dD1, dD2, dD3, dD4 = CalcSectionParams( dStrand, dH)
-   local ptA = ptS - dH * vtSlicing + dD1 * vtDir
-   local ptB = ptA + dD2 * vtDir + dD3 * vtSlicing
-   local ptC = ptB + dD4 * vtSlicing
-   local ptD = ptA + dH * vtSlicing
- 
-   local nId = EgtCurveCompoFromPoints( nSolidGrp, { ptS - dH * vtSlicing, ptA, ptB, ptC, ptD, ptS}, GDB_RT.GLOB)
-   
   return nId
 end

@@ -73,30 +69,48 @@ end
 local function CreateSpiralVaseCap( nSectId, vtDir, nSolidGrp)
   
   local vPt = {}
-   for i = 0, 7 do
+   local nLast = EgtIf( s_nSimplifiedSection == 1, 3, 7)
+   for i = 0, nLast do
      vPt[i + 1] = EgtUP( nSectId, i, GDB_ID.ROOT)
   end
   
   local vCrvs = {}
-   vCrvs[1] = EgtArc2PV( nSolidGrp, vPt[1], vPt[2], vtDir, GDB_RT.GLOB)
-   vCrvs[2] = EgtArc2PV( nSolidGrp, vPt[8], vPt[3], vtDir, GDB_RT.GLOB)
-   vCrvs[3] = EgtArc2PV( nSolidGrp, vPt[7], vPt[4], vtDir, GDB_RT.GLOB)
-   vCrvs[4] = EgtArc2PV( nSolidGrp, vPt[6], vPt[5], vtDir, GDB_RT.GLOB)
-   vCrvs[5] = EgtCurveCompo( nSolidGrp, {vCrvs[1]}, false, GDB_RT.GLOB)
-   EgtCloseCurveCompo( vCrvs[5])
-   vCrvs[6] = EgtCurveCompo( nSolidGrp, {vCrvs[4]}, false, GDB_RT.GLOB)
-   EgtCloseCurveCompo( vCrvs[6])
-   local nSurf1 = EgtSurfTmRuled( nSolidGrp, vCrvs[1], vCrvs[2], GDB_RUL.ISOPAR, s_dTol)
-   local nSurf2 = EgtSurfTmRuled( nSolidGrp, vCrvs[2], vCrvs[3], GDB_RUL.ISOPAR, s_dTol)
-   local nSurf3 = EgtSurfTmRuled( nSolidGrp, vCrvs[3], vCrvs[4], GDB_RUL.ISOPAR, s_dTol)
-   local nSurf4 = EgtSurfTmByRegion( nSolidGrp, vCrvs[5], s_dTol)
-   local nSurf5 = EgtSurfTmByRegion( nSolidGrp, vCrvs[6], s_dTol)
-   local nCapSrf = EgtSurfTmBySewing( nSolidGrp, {nSurf1, nSurf2, nSurf3, nSurf4, nSurf5})
-
+   -- calcolo gli archi che definiscono la superficie laterale
+   if s_nSimplifiedSection == 1 then
+      -- sezione quadrata
+      vCrvs[1] = EgtArc2PV( nSolidGrp, vPt[1], vPt[2], vtDir, GDB_RT.GLOB)
+      vCrvs[2] = EgtArc2PV( nSolidGrp, vPt[4], vPt[3], vtDir, GDB_RT.GLOB)
+   else
+      -- sezione ottagonale
+      vCrvs[1] = EgtArc2PV( nSolidGrp, vPt[1], vPt[2], vtDir, GDB_RT.GLOB)
+      vCrvs[2] = EgtArc2PV( nSolidGrp, vPt[8], vPt[3], vtDir, GDB_RT.GLOB)
+      vCrvs[3] = EgtArc2PV( nSolidGrp, vPt[7], vPt[4], vtDir, GDB_RT.GLOB)
+      vCrvs[4] = EgtArc2PV( nSolidGrp, vPt[6], vPt[5], vtDir, GDB_RT.GLOB)
+   end
+   -- creo le rigate
+   local vSurfs = {}
+   for i = 1, #vCrvs - 1 do
+      vSurfs[i] = EgtSurfTmRuled( nSolidGrp, vCrvs[i], vCrvs[i+1], GDB_RUL.ISOPAR, s_dTol)
+   end
+   -- calcolo le superfici top e bottom del cap
+   local nCrvBottom = EgtCurveCompo( nSolidGrp, {vCrvs[1]}, false, GDB_RT.GLOB)
+   EgtCloseCurveCompo( nCrvBottom)
+   local nSurfBottom = EgtSurfTmByRegion( nSolidGrp, nCrvBottom, s_dTol)
+   local nCrvTop = EgtCurveCompo( nSolidGrp, {vCrvs[#vCrvs]}, false, GDB_RT.GLOB)
+   EgtCloseCurveCompo( nCrvTop)
+   local nSurfTop = EgtSurfTmByRegion( nSolidGrp, nCrvTop, s_dTol)
+   table.insert( vSurfs, nSurfTop)
+   table.insert( vSurfs, nSurfBottom)
+   
+   local nCapSrf = EgtSurfTmByTriangles( nSolidGrp, vSurfs)
+   
+   -- cancello curve di costruzione
   for i = 1, #vCrvs do
      EgtErase( vCrvs[i])
   end
-
+   EgtErase( nCrvTop)
+   EgtErase( nCrvBottom)
+   
   return nCapSrf
 end

@@ -104,16 +118,26 @@ end
 local function CreateSpiralVaseSolid( nCrvId, nSolidGrp, LayerParams, dStrand)
   
   -- gruppo temporaneo per conti 
-   local nGrpTmp = EgtGroup( nSolidGrp)
+   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
+      return CreateStandardSolid( nCrvId, nSolidGrp, LayerParams, dStrand)
+   end
+   
   -- appiattisco la curva
   local nCrvCopy = EgtCopyGlob( nCrvId, nGrpTmp)
-   local dDelta = ( ptE - ptS) * LayerParams.vtSlicing
-   EgtSpiralizeCurveAlongExtrusion( nCrvCopy, - dDelta)
+   EgtModifyCurveExtrusion( nCrvCopy, LayerParams.vtSlicing, GDB_RT.GLOB)
+   EgtProjectCurveOnPlane( nCrvCopy, ptS, LayerParams.vtSlicing, GDB_RT.GLOB)
   EgtMergeCurvesInCurveCompo( nCrvCopy)
   EgtChangeClosedCurveStartPoint( nCrvCopy, ptS, GDB_RT.GLOB)
  
@@ -140,12 +164,19 @@ local function CreateSpiralVaseSolid( nCrvId, nSolidGrp, LayerParams, dStrand)
      local dMove = ( ptRef - ptS) * LayerParams.vtSlicing
      EgtMove( vCrvs[i+1], LayerParams.vtSlicing * dMove, GDB_RT.GLOB)
      EgtSpiralizeCurveAlongExtrusion( vCrvs[i+1], dDelta)
-      
+
      -- modifico la curva per congiungerla ai caps
-      EgtAddCurveCompoLine( vCrvs[i+1], ptRef, false, GDB_RT.GLOB)
+      EgtApproxCurve( vCrvs[i+1], GDB_CA.LINES, s_dTol)
+      EgtModifyCurveStartPoint( vCrvs[i+1], ptRef, GDB_RT.GLOB)
      local ptRefEnd = EgtUP( nSectE, i, GDB_ID.ROOT)
-      EgtAddCurveCompoLine( vCrvs[i+1], ptRefEnd, true, GDB_RT.GLOB)
+      local _, _, dParMinDist = EgtPointCurveDist( ptRefEnd, vCrvs[i+1], GDB_ID.ROOT)
+      local _, dParE = EgtCurveDomain( vCrvs[i+1])
+      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)
   end
+   
   local vSurfs = {}
   for i = 1, #vCrvs - 1 do
      vSurfs[i] = EgtSurfTmRuled( nGrpTmp, vCrvs[i], vCrvs[i+1], GDB_RUL.MINDIST, s_dTol)
@@ -154,7 +185,8 @@ local function CreateSpiralVaseSolid( nCrvId, nSolidGrp, LayerParams, dStrand)
         return nil
      end
   end
-   local nSrfId = EgtSurfTmBySewing( nSolidGrp, vSurfs)
+
+   local nSrfId = EgtSurfTmByTriangles( nSolidGrp, vSurfs)
  
   -- creazione del mezzo disco iniziale
   local nCap1 = CreateSpiralVaseCap( nSectId, - vtS, nSolidGrp)
@@ -165,15 +197,7 @@ local function CreateSpiralVaseSolid( nCrvId, nSolidGrp, LayerParams, dStrand)
   -- cancello le curve usate per la costruzione
   EgtErase( nGrpTmp)

-   return EgtSurfTmBySewing( nSolidGrp, { nSrfId, nCap1, nCap2})
-end
-
----------------------------------------------------------------------
-local function CreateStandardSolid( nCrvId, nSolidGrp, LayerParams, dStrand)
-
-   local dD1, dD2, dD3, dD4 = CalcSectionParams( dStrand, LayerParams.dLayHeight)
-   local nSrfId = EgtSurfTmRectSwept( nSolidGrp, dStrand, LayerParams.dLayHeight, dD2, dD3, nCrvId, GDB_RSCT.BEVEL, s_dTol)
-   return nSrfId
+   return EgtSurfTmByTriangles( nSolidGrp, { nSrfId, nCap1, nCap2})
 end

 --------------------------------------------------------------------------------------
@@ -185,6 +209,66 @@ local function CreateSolid( nCrvId, nSolidGrp, LayerParams, dStrand)
   end
 end

+---------------------------------------------------------------------
+local function CreateDirectionArrow( nCrvId, nSolidGrp, vtSlicing, dStrand, nLayer)
+   
+   local ptS = EgtSP( nCrvId, GDB_RT.GLOB)
+   local vtS = EgtSV( nCrvId, GDB_RT.GLOB)
+   local dCrvLen = EgtCurveLength( nCrvId)
+   if dCrvLen > 2 * dStrand then
+      local dPar = EgtCurveParamAtLength( nCrvId, 4/5 * dStrand)
+      ptS = EgtUP( nCrvId, dPar, GDB_RT.GLOB)
+      vtS = EgtUV( nCrvId, dPar, -1, GDB_RT.GLOB)
+   end
+      
+   local vt2 = Vector3d( vtS)
+   vt2:rotate( vtSlicing, 90)
+   local dLen = 4/5 * dStrand
+   local pt1 = ptS + 0.5 * dLen * vt2
+   local pt2 = ptS - 0.5 * dLen * vt2
+   local pt3 = ptS + vtS * dLen
+   local nCompo = EgtCurveCompoFromPoints( nSolidGrp, { pt1, pt2, pt3, pt1}, GDB_RT.GLOB)
+   EgtMove( nCompo, 100 * GEO.EPS_SMALL * vtSlicing, GDB_RT.GLOB)
+   local nSrf = EgtSurfFlatRegion( nSolidGrp, { nCompo})
+   EgtErase( nCompo)
+   EgtSetColor( nSrf, RED())
+   EgtSetInfo( nSrf, KEY_SLICE_NBR, nLayer)
+   EgtSetStatus( nSrf, GDB_ST.OFF)
+   EgtSetMode( nSrf, GDB_MD.HIDDEN)
+   EgtSetName( nSrf, DIR_ARROW)
+   
+end
+
+---------------------------------------------------------------------
+local function CreateRecursiveSolid( nCrvId, vSurfs, nSolidGrp, LayerParams, dStrand)
+
+   -- tento la creazione del solido
+   local nSurf = CreateSolid( nCrvId, nSolidGrp, LayerParams, dStrand - 50 * GEO.EPS_SMALL)
+   if nSurf then
+      EgtErase( nCrvId)
+      table.insert( vSurfs, nSurf)
+      return true
+   else
+      -- se curva singola esco perchè non è possibile spezzare ulteriormente
+      local _, dParE = EgtCurveDomain( nCrvId)
+      if abs( dParE - 1) < GEO.EPS_SMALL then
+         EgtErase( nCrvId)
+         return false
+      end
+      -- se non si tratta di curva singola, spezzo a metà e tento sulle due sottocurve
+      local dParSplit = floor( dParE / 2 + 0.5)
+      local nCrvSplit = EgtSplitCurveAtParam( nCrvId, dParSplit)
+      if not nCrvSplit then
+         -- errore nello split
+         EgtErase( nCrvId)
+         return false
+      end
+      local bOk = CreateRecursiveSolid( nCrvId, vSurfs, nSolidGrp, LayerParams, dStrand)
+      bOk = bOk and CreateRecursiveSolid( nCrvSplit, vSurfs, nSolidGrp, LayerParams, dStrand)
+      return bOk
+   end
+end
+
 ---------------------------------------------------------------------
 local function CreateSolidFromCurve( nCrvId, nSolidGrp, LayerParams, nLayer)
  
@@ -207,7 +291,7 @@ local function CreateSolidFromCurve( nCrvId, nSolidGrp, LayerParams, nLayer)
   elseif nType == TYPE.AUX_SOLID then
      Color = EgtStdColor( 'AQUA')
   end
-   local dStrand = EgtGetInfo( nCrvId, KEY_CRV_STRAND, 'd')
+   local dStrand = EgtGetInfo( nCrvId, KEY_CRV_STRAND, 'd') or LayerParams.dStrand
   
   local nCopyId = EgtCopyGlob( nCrvId, nSolidGrp)
   local nId = GDB_ID.NULL
@@ -224,6 +308,12 @@ local function CreateSolidFromCurve( nCrvId, nSolidGrp, LayerParams, nLayer)
      nId = EgtSplitCurve( nCopyId, nParts)
   end
   
+   -- freccia direzionale
+   local sName = EgtGetName( nCrvId)
+   if nType ~= TYPE.COASTING and nType ~= TYPE.LINK and sName ~= LEAD_IN_CRV and sName ~= LEAD_OUT_CRV and sName ~= LINK_CRV then
+      CreateDirectionArrow( nCrvId, nSolidGrp, LayerParams.vtSlicing, dStrand, nLayer)
+   end
+   
   if nId == GDB_ID.NULL then return false end
   local bOk = true
   for nInd = 0, nParts - 1 do
@@ -231,44 +321,42 @@ local function CreateSolidFromCurve( nCrvId, nSolidGrp, LayerParams, nLayer)
      local nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams, dStrand - 5 * GEO.EPS_SMALL)
      if not nSrfId then
         EgtOutLog( 'Warning : CreateSolid failed '.. '(layer '..tostring( nLayer)..', curve '..tostring( nCrvId)..')')
-         -- se non ultima, provo a spostare l'estremità finale
-         if nInd < nParts - 1 then
-            local nCopyId = EgtCopy( nGuideId + 1, nGuideId, GDB_IN.AFTER)
-            if nCopyId then
-               local LEN_TRIM = 10
-               local bOk1 = EgtTrimCurveEndAtLen( nCopyId, LEN_TRIM)
-               local bOk2 = EgtAddCurveCompoCurve( nGuideId, nCopyId)
-               local bOk3 = EgtTrimCurveStartAtLen( nGuideId + 1, LEN_TRIM)
-               nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams, dStrand - 5 * GEO.EPS_SMALL)
-               if not nSrfId then
-                  nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams, dStrand - 50 * GEO.EPS_SMALL)
+         -- ritento con strand più piccolo
+         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)..')')
+            -- se non ultima, provo a spostare l'estremità finale
+            if nInd < nParts - 1 then
+               local nCopyId = EgtCopy( nGuideId + 1, nGuideId, GDB_IN.AFTER)
+               if nCopyId then
+                  local LEN_TRIM = 10
+                  local bOk1 = EgtTrimCurveEndAtLen( nCopyId, LEN_TRIM)
+                  local bOk2 = EgtAddCurveCompoCurve( nGuideId, nCopyId)
+                  local bOk3 = EgtTrimCurveStartAtLen( nGuideId + 1, LEN_TRIM)
+                  nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams, dStrand - 5 * GEO.EPS_SMALL)
+                  if not nSrfId then
+                     nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams, dStrand - 50 * GEO.EPS_SMALL)
+                  end
               end
            end
         end
-         -- ritento spezzando la curva
+         
+         -- ritento spezzando la curva in modo ricorsivo fino ad inidividuare delle sottocurve su cui è possibile calcolare il solido
         if not nSrfId then
            EgtOutLog( 'Warning : CreateSolid_2 failed')
            local nGrp = EgtGroup( nSolidGrp, Frame3d( ORIG(), LayerParams.vtSlicing), GDB_RT.GLOB)
            EgtRelocateGlob( nGuideId, nGrp)
            EgtApproxCurve( nGuideId, GDB_CA.LINES, 100 * GEO.EPS_SMALL)
            EgtRelocateGlob( nGuideId, nSolidGrp)
-            local nFirstCrv, nCrvNbr = EgtSplitCurveAtCorners( nGuideId, 30)
-            if nFirstCrv and nCrvNbr > 1 then
-               local nSrfIds = {}
-               for nInd2 = 0, nCrvNbr-1 do
-                  local nSrfId2 = CreateSolid( nFirstCrv + nInd2, nSolidGrp, LayerParams, dStrand - 50 * GEO.EPS_SMALL)
-                  EgtErase( nFirstCrv + nInd2)
-                  if nSrfId2 then
-                     table.insert( nSrfIds, nSrfId2)
-                  end
-               end
-               if #nSrfIds == nCrvNbr then
-                  nSrfId = EgtSurfTmBySewing( nSolidGrp, nSrfIds)
-               else
-                  EgtOutLog( 'Warning : CreateSolid_3 failed')
-               end
-            else
-               EgtErase( nFirstCrv)
+
+            local vSurfs = {}
+            local bOk = CreateRecursiveSolid( nGuideId, vSurfs, nSolidGrp, LayerParams, dStrand)
+            if #vSurfs > 0 then
+               nSrfId = EgtSurfTmByTriangles( nSolidGrp, vSurfs)
+            end
+            if not nSrfId or bOk == false then
+               EgtOutLog( 'Warning : CreateSolid_3 failed')
            end
            EgtErase( nGrp)
         end
@@ -278,7 +366,7 @@ local function CreateSolidFromCurve( nCrvId, nSolidGrp, LayerParams, nLayer)
         EgtSetColor( nSrfId, Color)
         EgtSetInfo( nSrfId, KEY_TYPE, nType)
         EgtSetInfo( nSrfId, KEY_SLICE_NBR, nLayer)
-      else 
+      else
         bOk = false
         EgtOutLog( 'Warning : CreateSolid_Sewing failed')
      end
@@ -293,6 +381,10 @@ function RunCalcSolids.Exec()

   -- per determinare il tempo di calcolo
   EgtStartCounter()
+   
+   -- verifico se richiesta sezione semplificata ( rettangolare)
+   local sIniFile = EgtGetIniFile()
+   s_nSimplifiedSection = EgtGetNumberFromIni( 'Solids', 'SimplifiedSection', 0, sIniFile)

   local nPartIndex = 1
   local nPartId = EgtGetFirstNameInGroup( GDB_ID.ROOT, PART .. nPartIndex) or EgtGetFirstNameInGroup( GDB_ID.ROOT, PART)
@@ -304,9 +396,14 @@ function RunCalcSolids.Exec()

         if bCalcSolid then

+            -- recupero il suo frame
+            local nFrameId = EgtGetFirstNameInGroup( EgtGetFirstNameInGroup( nPartId, 'Frame'), 'FramePart')
+            local ptOrig = EgtSP( nFrameId or GDB_ID.NULL, GDB_ID.ROOT)
+            EgtSetInfo( nPartId, KEY_ORIG_REF, ptOrig)
+            
            -- 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
@@ -338,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
@@ -372,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
@@ -389,9 +515,8 @@ function RunCalcSolids.Exec()
               EgtSetInfo( nViewId, SOLID_GRP, true)
            end
         end
-
      end
-
+      
      nPartIndex = nPartIndex + 1
      nPartId = EgtGetFirstNameInGroup( GDB_ID.ROOT, PART .. nPartIndex) or EgtGetNextName( nPartId, PART)
   end
@@ -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
@@ -1,4 +1,4 @@
-- RunMachParamFromSWCalc.lua by Egaltech s.r.l. 2022/12/28
+-- RunMachParamFromSWCalc.lua by Egaltech s.r.l. 2024/01/30
 -- Calcolo dei parametri di stampa

 -- Tabella per definizione modulo
@@ -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
@@ -126,44 +128,6 @@ function RunMachParamFromSWCalc.Exec()
            end
            nCrvId = EgtGetNextName( nCrvId, CONTOUR_GRP .. '*')
         end
-
-
-         -- -- rimuovo eventuale info precedente del tempo di attesa
-         -- EgtRemoveInfo( nLayerId, KEY_WAITING_TIME)
-         -- -- calcolo lunghezza totale del layer
-         -- local dTotLayerLength = 0
-         -- local dTotLayerLengthForMass = 0
-         -- local dTotLayerArea = 0
-         -- local nCrvId = EgtGetFirstNameInGroup( nLayerId, CONTOUR_GRP .. '*')
-         -- while nCrvId do
-         --    local nToolPathId = EgtGetFirstNameInGroup( nCrvId, TOOLPATH_GRP)
-         --    -- sommo lunghezze percorsi
-         --    local dTotCrvLength = 0
-         --    local dTotCrvLengthForMass = 0
-         --    local nShellId = EgtGetFirstInGroup( nToolPathId)
-         --    while nShellId do
-         --       dTotCrvLength = dTotCrvLength + EgtCurveLength( nShellId)
-         --       if EgtGetName( nShellId) ~= WIPE_CRV then
-         --          dTotCrvLengthForMass = dTotCrvLengthForMass + EgtCurveLength( nShellId)
-         --       end
-         --       nShellId = EgtGetNext( nShellId)
-         --    end
-         --    dTotLayerLength = dTotLayerLength + dTotCrvLength
-         --    dTotLayerLengthForMass = dTotLayerLengthForMass + dTotCrvLengthForMass
-         --    -- recupero area
-         --    local nOuterCrvId = EgtGetFirstNameInGroup( nCrvId, OUTER_CRV)
-         --    if nOuterCrvId and dStrandCount > 0.5 then
-         --       local _, _, dTotCrvArea = EgtCurveArea( nOuterCrvId)
-         --       local dOuterLength = EgtCurveLength( nOuterCrvId)
-         --       -- recupero offset del part per aggiungerlo all'area interna
-         --       local dOffset = EgtGetInfo( nPartId, KEY_OFFSET_SLICE, 'd')
-         --       dTotCrvArea = dTotCrvArea + ( dOffset * dOuterLength)
-         --       dTotLayerArea = dTotLayerArea + dTotCrvArea
-         --    end
-         --    nCrvId = EgtGetNextName( nCrvId, CONTOUR_GRP .. '*')
-         -- end
-
-
         -- recupero feed del layer
         local dLayerFeed = 0
         local dLayerWait = 0
@@ -192,12 +156,11 @@ function RunMachParamFromSWCalc.Exec()
         for nMeanIndex = 1, #LengthCrvList do
            dStrandMean = dStrandMean + LengthCrvList[nMeanIndex].Width * LengthCrvList[nMeanIndex].Length
         end
-         dStrandMean = dStrandMean / dTotLayerLength
+         dStrandMean = dStrandMean / EgtIf( dTotLayerLength > 0.1, dTotLayerLength, 1)
         -- calcolo costante MF
         local dMF = 1
         local dSC = 1
         if dTotLayerArea > 1 then
-            -- dMF = dTotLayerLength * dStrand / dTotLayerArea * 100
            dMF = dTotLayerLength * dStrandMean / dTotLayerArea * 100
            dSC = dStrandCount
         else
@@ -216,9 +179,9 @@ function RunMachParamFromSWCalc.Exec()
         local dTMin = ( MATERIAL.K_LAYERTIME / 100.0) * ( dMF + MATERIAL.AMin) / MATERIAL.BMin * pow( 0.25 * dStrandMean, MATERIAL.KW) * pow( dSliceStep, MATERIAL.KZ) * pow( dSC, MATERIAL.KN)
         local dTTrg = ( MATERIAL.K_LAYERTIME / 100.0) * ( dMF + MATERIAL.ATrg) / MATERIAL.BTrg * pow( 0.25 * dStrandMean, MATERIAL.KW) * pow( dSliceStep, MATERIAL.KZ) * pow( dSC, MATERIAL.KN)
         local dTMax = ( MATERIAL.K_LAYERTIME / 100.0) * ( dMF + MATERIAL.AMax) / MATERIAL.BMax * pow( 0.25 * dStrandMean, MATERIAL.KW) * pow( dSliceStep, MATERIAL.KZ) * pow( dSC, MATERIAL.KN)
-         local dFMin = dTotLayerLength / dTMax * 60
-         local dFTrg = dTotLayerLength / dTTrg * 60
-         local dFMax = dTotLayerLength / dTMin * 60
+         local dFMin = dTotLayerLength / EgtIf( dTMax > 0.1, dTMax, 1) * 60
+         local dFTrg = dTotLayerLength / EgtIf( dTTrg > 0.1, dTTrg, 1) * 60
+         local dFMax = dTotLayerLength / EgtIf( dTMin > 0.1, dTMin, 1) * 60
         local dLayerTime = dTTrg
         if dLayerFeed == 0 then
            dLayerFeed = dFTrg
@@ -241,8 +204,10 @@ function RunMachParamFromSWCalc.Exec()
            dSpeed = dSMax
         end
         if not bSpeedOk then
-            dLayerFeed = ( MATERIAL.C1 * pow( ( dSpeed / (( MATERIAL.K_EXTRUSION / 100.0) * ( MACHINING.K / 100.0))), MATERIAL.C2)) * 1000 / ( ( dStrandMean - dSliceStep) * dSliceStep + pi * pow( dSliceStep / 2, 2))
-            dLayerTime = dTotLayerLength / dLayerFeed * 60
+            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))
+               dLayerTime = dTotLayerLength / dLayerFeed * 60
+            end
            dLayerWait = floor( dTMin + 0.5) - floor( dLayerTime + 0.5)
         end
         -- calcolo massa dello strato
@@ -256,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
@@ -276,15 +253,11 @@ function RunMachParamFromSWCalc.Exec()
            EgtSetInfo( nLayerResultId, KEY_WAITING_TIME, dLayerWait)
         end
         -- scrivo valori in struttura dati
-         --local nLayerResultId = EgtGetFirstNameInGroup( nResultLayerId, nLayerIndex)
         EgtSetInfo( nLayerResultId, KEY_TMIN, dTMin)
         EgtSetInfo( nLayerResultId, KEY_TTRG, dTTrg)
         EgtSetInfo( nLayerResultId, KEY_TMAX, dTMax)
         EgtSetInfo( nLayerResultId, KEY_FTRG, dFTrg)
         EgtSetInfo( nLayerResultId, KEY_FMAX, dFeedMax)
-         -- EgtSetInfo( nLayerResultId, KEY_FMIN, dFMin)
-         -- EgtSetInfo( nLayerResultId, KEY_FTRG, dFTrg)
-         -- EgtSetInfo( nLayerResultId, KEY_FMAX, dFMax)
         EgtSetInfo( nLayerResultId, KEY_TCUR, dLayerTime)
         EgtSetInfo( nLayerResultId, KEY_FCUR, dLayerFeed)
         EgtSetInfo( nLayerResultId, KEY_LENGTH, dTotLayerLength)
@@ -296,11 +269,12 @@ function RunMachParamFromSWCalc.Exec()
            EgtEmptyGroup( nResultLayerId)
            return
         end
-         
+         -- passo al layer successivo
         nLayerIndex = nLayerIndex + 1
         nLayerId = EgtGetFirstNameInGroup( nPartId, SLICE_LAYER .. nLayerIndex) or EgtGetFirstNameInGroup( nPartId, "__" .. SLICE_LAYER .. nLayerIndex)
      end
      if nMaxIndex < nLayerIndex then nMaxIndex = nLayerIndex end
+      -- passo al pezzo successivo
      nPartId = EgtGetNextPart( nPartId)
      ::continue::
   end
@@ -0,0 +1,204 @@
+-- RunPrepareExport.lua by Egaltech s.r.l. 2023/10/19
+-- Creo le geometrie da esportare con 3dm
+
+-- Tabella per definizione modulo
+local RunPrepareExport = {}
+
+-- Intestazioni
+require( 'EgtBase')
+
+EgtOutLog( ' RunPreprareExport started', 1)
+
+-- Dati
+local AMD = require( 'AddManData')
+
+------------------------------------------------------------------
+local function CalcCurves( nSliceId, nDestGrp, vtSlicing, dStrandBase)
+   
+   -- scorro tutti i gruppi di curve
+   local vCrvs = EgtGetNameInGroup( nSliceId, CONTOUR_GRP .. '*')
+   for j = 1, #vCrvs do
+      -- cerco il gruppo del toolpath
+      local nTPath = EgtGetFirstNameInGroup( vCrvs[j], TOOLPATH_GRP)
+      if nTPath then
+         local nId = EgtGetFirstInGroup( nTPath)
+         while nId do
+            -- se non è wipe creo la fat curve da estrudere per creare il solido
+            local nType = EgtGetInfo( nId, KEY_TYPE, 'i')
+            if nType ~= TYPE.WIPE then
+               local dStrand = EgtGetInfo( nId, KEY_CRV_STRAND, 'd') or dStrandBase
+               
+               -- 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 nSurf = EgtSurfFrFatCurve( nDestGrp, nCopy, 0.5 * dStrand, false)
+               -- se fallisce ritento con valore leggermente diverso
+               if not nSurf or nSurf == GDB_ID.NULL then
+                  nSurf = EgtSurfFrFatCurve( nDestGrp, nCopy, 0.5 * dStrand - 0.05, false)
+               end
+               EgtErase( nCopy)
+                 
+               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
+                  EgtErase( nSurf)
+               end
+            end
+            
+            nId = EgtGetNext( nId)
+         end
+      end
+
+      -- copio le frecce direzione dal gruppo dei solidi
+      local nSolidGrp = EgtGetFirstNameInGroup( vCrvs[j], SOLID_GRP)
+      if nSolidGrp then
+         local nId = EgtGetFirstNameInGroup( nSolidGrp, DIR_ARROW)
+         while nId do
+            local nCopy = EgtCopyGlob( nId, nDestGrp)
+            EgtSetMode( nCopy, GDB_MD.STD)
+            EgtSetStatus( nCopy, GDB_ST.ON)
+            nId = EgtGetNextName( nId, DIR_ARROW)
+         end
+      end
+   end
+end
+
+------------------------------------------------------------------
+local function CalcSpiralVase( nSliceId, nDestGrp)
+   
+   -- scorro tutti i gruppi di curve
+   local vCrvs = EgtGetNameInGroup( nSliceId, CONTOUR_GRP .. '*')
+   for j = 1, #vCrvs do
+      -- recupero il solido dal gruppo
+      local nSolidGrp = EgtGetFirstNameInGroup( vCrvs[j], SOLID_GRP)
+      if nSolidGrp then
+         local vSolids = EgtGetAllInGroup( nSolidGrp)
+         for i = 1, #vSolids do
+            EgtCopyGlob( vSolids[i], nDestGrp)
+         end
+      end
+   end
+end
+
+------------------------------------------------------------------
+function RunPrepareExport.Exec()
+
+   local nPartId = EgtGetFirstNameInGroup( GDB_ID.ROOT, PART .. '*')
+   if not nPartId then 
+      EgtOutBox( 'Error : no part', 'Export')
+      return GDB_ID.NULL
+   end
+   
+   -- creo o recupero il gruppo per l'esportazione
+   local nGrp = EgtGetFirstNameInGroup( GDB_ID.ROOT, LAY_EXPORT)
+   if not nGrp then
+      -- se non esiste creo il gruppo
+      nGrp = EgtGroup( GDB_ID.ROOT)
+      EgtSetName( nGrp, LAY_EXPORT)
+      EgtSetStatus( nGrp, GDB_ST.OFF)
+      EgtSetLevel( nGrp, GDB_LV.TEMP)
+   else
+      -- se il gruppo esiste già non devo fare nulla
+      return nGrp
+   end
+   
+   -- creo il punto di origine del riferimento
+   local ptRef = EgtGetInfo( nPartId, KEY_ORIG_REF, 'p')
+   if not ptRef then
+      local nFrameId = EgtGetFirstNameInGroup( EgtGetFirstNameInGroup( nPartId, LAY_FRAME), FRAME_PART)
+      ptRef = EgtSP( nFrameId or GDB_ID.NULL, GDB_ID.ROOT)
+   end
+   local nPnt = EgtPoint( nGrp, ptRef, GDB_RT.GLOB)
+   EgtSetName( nPnt, KEY_ORIG_REF)
+   EgtSetStatus( nPnt, GDB_ST.OFF)
+   
+   -- recupero alcune info utili e le assegno al punto per poterle leggere da ThreeJS
+   local dH = EgtGetInfo( nPartId, KEY_SLICE_STEP, 'd')
+   EgtSetInfo( nPnt, KEY_SLICE_STEP, dH)
+   local vtSlicing = EgtGetInfo( nPartId, KEY_SLICING_DIR, 'v')
+   EgtSetInfo( nPnt, KEY_SLICING_DIR, vtSlicing)
+   local bSpiralVase = EgtGetInfo( nPartId, KEY_SPIRAL_VASE, 'b') or false
+   EgtSetInfo( nPnt, KEY_SPIRAL_VASE, bSpiralVase)
+   
+   -- recupero lo strand dai parametri generale nel caso non fosse definito sulle singole curve
+   local dStrandBase = EgtGetInfo( nPartId, KEY_STRAND, 'd') or 0
+   
+   -- recupero gli slices
+   local vSlices = EgtGetNameInGroup( nPartId, SLICE_LAYER .. '*') or {}
+   if #vSlices == 0 then
+      EgtOutBox( 'Error : no slices', 'Export')
+      return GDB_ID.NULL
+   end
+   
+   -- verifico che nel primo slice siano presenti sia i toolpath sia i solidi
+   local nCrvGrp = EgtGetFirstNameInGroup( vSlices[1], CONTOUR_GRP .. '*')
+   if not nCrvGrp then
+      EgtOutBox( 'Error : no toolpaths', 'Export')
+      return GDB_ID.NULL
+   end
+   local nTPath = EgtGetFirstNameInGroup( nCrvGrp, TOOLPATH_GRP)
+   if not nTPath then
+      EgtOutBox( 'Error : no toolpaths', 'Export')
+      return GDB_ID.NULL
+   end
+   local nSolid = EgtGetFirstNameInGroup( nCrvGrp, SOLID_GRP)
+   if not nSolid then
+       EgtOutBox( 'Error : no solids', 'Export')
+      return GDB_ID.NULL
+   end
+
+   for i = 1, #vSlices do
+     
+      -- creo il gruppo corrispondente
+      local nDestGrp = EgtGroup( nGrp)
+      EgtSetName( nDestGrp, EgtGetName( vSlices[i]))
+      EgtSetStatus( nDestGrp, GDB_ST.OFF)
+      
+      if bSpiralVase then
+         CalcSpiralVase( vSlices[i], nDestGrp)
+      else
+         CalcCurves( vSlices[i], nDestGrp, vtSlicing, dStrandBase)
+      end
+   end
+   
+   return nGrp
+end
+
+---------------------------------------------------------------------
+return RunPrepareExport
@@ -79,6 +79,13 @@ local function RemoveOldSlices( nPartId)
      EgtErase( nInfillId)
      nInfillId = EgtGetFirstNameInGroup( nPartId, INFILL_GRP .. '*')
   end
+   
+   -- rimuovo gruppo per export
+   local nExportGrpId = EgtGetFirstNameInGroup( GDB_ID.ROOT, LAY_EXPORT)
+   if nExportGrpId then
+      EgtErase( nExportGrpId)
+   end
+   
 end

 ---------------------------------------------------------------------
@@ -0,0 +1,17 @@
+-- PrepareExport.lua by Egaltech s.r.l. 2023/10/19
+-- Creo le geometrie da esportare con 3dm
+
+-- Intestazioni
+require( 'EgtBase')
+_ENV = EgtProtectGlobal()
+EgtEnableDebug( false)
+
+-- Imposto direttorio libreria specializzata per Stampa 3d
+EgtAddToPackagePath( PRINT.BASEDIR .. '\\LuaLibs\\?.lua')
+
+-- Librerie
+_G.package.loaded.RunPrepareExport = nil
+local RPE = require( 'RunPrepareExport')
+
+-- Calcolo
+PRINT.EXPORTLAYER = RPE.Exec()
@@ -1,4 +1,4 @@
-- Version.lua by Egaltech s.r.l. 2023/10/02
+-- Version.lua by Egaltech s.r.l. 2024/05/06
 -- Gestione della versione di 3dPrinting

-VERSION = '2.5j1'
+VERSION = '2.7f1'
Author	SHA1	Message	Date
SaraP	c718593585	3dPrinting 2.7f1 : - aggiunta possibilità da file ini della macchina di forzare approssimazione lineare dei percorsi con tolleranza a scelta.	2025-06-20 13:16:56 +02:00
SaraP	29f1243c91	3dPrinting : - in spiral vase corretto errore su punti di inizio non coincidenti tra layer consecutivi.	2025-04-29 11:54:32 +02:00
SaraP	ad44ff7c5a	3dPrinting : - in spiral vase spostata approssimazione delle curve per farla sempre su curva piana.	2025-04-28 15:07:36 +02:00
SaraP	bcaf1c56a4	3dPrinting 2.7d1 : - modifiche per nuova modalità di stampa dei primi layers nel caso a spirale.	2025-04-22 15:10:18 +02:00
SaraP	000bd0091f	3dPrinting 2.7a1 : - modificati i controlli per il valore di ritorno di EgtGetNameInGroup.	2025-01-31 11:05:57 +01:00
SaraP	b0ebb4a871	3dPrinting 2.6l1 : - sistemata segnalazione errore slicing.	2024-12-13 09:15:38 +01:00
SaraP	3d6f9f2b85	3dPrinting 2.6k1 : - correzioni spiral vase per transizione tra layers.	2024-11-28 12:44:03 +01:00
SaraP	898d065fe1	3dPrinting : - nel caso spiral vase corretta la gestione dei punti iniziali delle curve.	2024-07-31 14:23:36 +02:00
SaraP	54d809508d	3dPrinting 2.6g2 : - correzione lead out invertiti.	2024-07-29 15:18:13 +02:00
SaraP	1596869230	3dPrinting 2.6f1 : - correzione nell'unione delle curve per esportazione 3dm.	2024-06-10 17:37:26 +02:00
SaraP	68caeb21b2	3dPrinting : - correzioni spiral vase.	2024-05-16 15:38:34 +02:00
SaraP	eb955244b3	3dPrinting : - corretto errore nel calcolo dei solidi.	2024-05-10 16:34:09 +02:00
SaraP	2215fc2240	3dPrinting : - possibilità di realizzare i solidi con sezione semplificata ( rettangolare) da parametro nel file ini.	2024-05-10 09:34:23 +02:00
SaraP	78b722b236	3dPrinting : - migliorata chiusura solidi nel caso spiral vase.	2024-05-08 11:09:12 +02:00
SaraP	4d342b56c2	3dPrinting : - corretto errore nel calcolo solidi con spiral vase - nel calcolo solidi migliorata gestione caso problematico con split ricorsivo della curva guida.	2024-05-06 17:05:37 +02:00
Dario Sassi	f12d8b56c8	3dPrinting : - unite le modifiche.	2024-05-06 08:57:59 +02:00
Dario Sassi	c7cbe66299	3dPrinting 2.6e1 : - correzione a AddRetraction per autointersezioni strane.	2024-05-06 08:46:58 +02:00
SaraP	baaf137cb4	3dPrinting 2.6d1 : - sistemati fillet per setti anche nel caso di ribs-merged shells - correzioni varie.	2024-04-16 09:58:54 +02:00
Dario Sassi	cfe7de8123	3dPrinting : - in compilazione ora vengono tolte le informazioni di debug.	2024-03-27 16:59:29 +01:00
SaraP	f5c9890924	3dPrinting 2.6c1 : - aggiunti fillet per setti - correzioni varie.	2024-03-27 09:51:18 +01:00
SaraP	cdef58712f	3dPrinting : - aggiunta altezza minima di sicurezza per wipe.	2024-02-14 15:29:47 +01:00
Dario Sassi	94b02be20a	3dPrinting 2.6b1 : - aggiornata versione.	2024-02-13 14:53:06 +01:00
SaraP	a15593303f	3dPrinting : - corretto errore.	2024-02-12 12:06:46 +01:00
SaraP	011f049c43	3dPrinting : - migliorie in PrepareExport con utilizzo della fat curve di Voronoi.	2024-02-12 12:05:04 +01:00
SaraP	e214e5a766	3dPrinting : - corretta approssimazione toolpath in spiral vase.	2024-01-31 10:11:08 +01:00
Dario Sassi	e4c696c498	3dPrinting : - correzioni a calcolo TFS per layer vuoti (tipicamente primi e ultimi con estrusione a 45 gradi).	2024-01-31 09:08:18 +01:00
SaraP	e37a2f8e85	3dPrinting : - modifiche per utilizzare la nuova funzione per il calcolo degli offset di flat regions ( per Voronoi).	2024-01-29 14:43:43 +01:00
Dario Sassi	5619072e46	3dPrinting 2.6a1 : - cambio versione.	2024-01-26 16:06:34 +01:00
SaraP	ff59ee3e5b	3dPrinting : - sistemate le tolleranze nel calcolo delle superfici per gestire errore con extra shell spezzata.	2024-01-18 10:39:46 +01:00
SaraP	af03fe39d8	3dPrinting : - nel calcolo dei toopath riassegnato punto di inizio dopo approssimazione delle curve.	2024-01-15 15:34:06 +01:00
SaraP	775d0c9329	3dPrinting : - modificato parametro tolleranza offset.	2024-01-10 10:26:53 +01:00
SaraP	6669803e53	3dPrinting : - aggiunto parametro per tolleranza nel calcolo offset.	2024-01-10 10:14:38 +01:00
SaraP	2827ba9ac0	3dPrinting 2.5l1 : - unione dei setti alla shell interna - migliorie nel riordino extra shells.	2023-12-19 14:40:29 +01:00
SaraP	30368edd88	3dPrinting : - modificato valore di correzione offset in CalcPath.	2023-12-12 11:20:23 +01:00
SaraP	b420905b7a	3dPrinting : - sistemata approssimazione dei toolpath nel caso spiral vase - corretto errore calcolo solidi spiral vase.	2023-12-11 17:13:10 +01:00
SaraP	36a867ef4a	3dPrinting : - aggiunta approssimazione delle curve nel toolpath per eliminare piccoli tratti.	2023-12-04 14:50:14 +01:00
SaraP	7cebcd4b0e	3dPrinting : - modifiche in RunPrepareExport per gestire assenza dello strand sulle singole curve.	2023-11-23 10:17:01 +01:00
SaraP	fa7f51d02e	3dPrinting : - gestita la generazione dei solidi nel caso in cui lo strand non sia definito sulle singole curve.	2023-11-23 10:02:03 +01:00
SaraP	eac6b2da77	3dPrinting : - migliorie gestione extra shells.	2023-11-16 15:21:35 +01:00
SaraP	995ed10a0a	3dPrinting : - corretto errore extra shell spezzata.	2023-11-14 15:07:19 +01:00
SaraP	6c2e16a13e	3dPrinting : - modifica della lunghezza dei wipe che entrano nella tavola mantenendo la direzione scelta.	2023-11-06 09:43:57 +01:00
SaraP	3cdb99f795	3dPrinting : - aggiunto PrepareExport e RunPrepareExport alla compilazione.	2023-10-24 15:34:09 +02:00
SaraP	973eba6379	3dPrinting : - aggiunto PrepareExport per creare le geometrie necessarie all'esportazione in 3dm.	2023-10-24 15:21:07 +02:00
SaraP	c2163ebf3f	3dPrinting : - modifiche in CalcSolids per esportazione in 3MF.	2023-10-20 14:15:32 +02:00
SaraP	3f9628121c	3dPrinting 2.5j2 : - aggiunta possibilità di unire i setti alla shell interna - migliorie varie.	2023-10-17 14:38:52 +02:00
SaraP	d97543fbf9	3dPrinting : - corretto errore collegamento ribs.	2023-10-06 17:16:09 +02:00
SaraP	85bbeb8523	3dPrinting : - corretta la gestione dei setti esterni in caso di solidi con più gruppi di curve - migliorie varie.	2023-10-06 12:33:41 +02:00