3dPrinting :

- aggiunta possibilità di definire una lavorazione diversa per estrusione orizzontale (da Ini macchina [3dPrinting] HorizExtrusion=TiltedExtrusion).
3dPrinting 3.1c3 :
2026-03-23 15:32:22 +01:00 · 2026-03-23 09:48:19 +01:00 · 2026-03-10 16:35:30 +01:00 · 2026-03-04 09:18:03 +01:00 · 2026-03-02 09:29:44 +01:00 · 2026-02-20 14:30:59 +01:00
8 changed files with 1570 additions and 341 deletions
@@ -48,7 +48,6 @@ KEY_SPIRAL_VASE = "SpiralVase"
 KEY_SPIRAL_VASE_LEN = 'SpiralVaseLen'
 KEY_SPIRAL_VASE_INTERP_LEN = 'SpiralVaseInterpLen'
 KEY_SLICING_TYPE = "SlicingType"
-KEY_SLICING_DIR = "SlicingDir"
 KEY_SLICE_STEP = "StrandH"
 KEY_SHELLS_NBR = "StrandCount"
 KEY_STRAND = "StrandW"
@@ -86,6 +85,8 @@ KEY_WIPE_LEN = "WipeLen"
 KEY_WIPE_DIR = "WipeDir"
 KEY_WIPE_FEEDPU = "WipeFeedPu"
 KEY_TOOL_DIAM = "ToolDiam"
+KEY_MAX_STRANDH_FACTOR = 'MaxStrandHFactor'
+KEY_MIN_STRANDH_FACTOR = 'MinStrandHFactor'

 -- Solid Fill
 KEY_FLOOR_NBR = "FloorCount"
@@ -177,6 +178,7 @@ KEY_AUX_SOLIDS_WIPE_DIR = "AuxSolidsWipeDir"

 -- Parametri di macchina
 SEC_3DPRINTING = "3dPrinting"
+KEY_HORIZ_EXTR = "HorizExtrusion"
 KEY_COEFF_X = "CoeffX"
 KEY_COEFF_Y = "CoeffY"
 KEY_SPEED_MIN = "SpeedMin"
@@ -189,9 +191,9 @@ KEY_LINEAR_TOL = 'LinearTol'
 KEY_MAX_H = "SlicingHeight"
 KEY_MAX_SLICES_NBR = "MaxSlicesNumber"
 KEY_SLICE_NBR = "SliceNbr"
-KEY_SLICE_Z = "SliceZ"
+KEY_SLICE_DIR = "SliceDir"
+KEY_SLICE_POS = "SlicePos"
 KEY_SLICE_DELTAZ = "DeltaZ"
-KEY_SLICE_REAL_Z = "SliceRealZ"
 KEY_ZIG_ZAG_INFILL = "ZigZagInfill"
 KEY_ZIG_ZAG_DIR = "ZigZagDir"
 KEY_INVERTED_CRV = "InvertedCrv"
@@ -215,12 +217,14 @@ KEY_CRV_OFFSET = "CurveOffset"
 KEY_ORIG_REF = "Orig"
 KEY_WIPE_ON_CRV = "WipeOnCrv"
 KEY_FEED_COEFF = 'FeedCoeff'
+KEY_ENTITY_NAME = 'EntityName'

 SLICING_TYPE = {   
   VERTICAL = 1,
   DEG45_X = 2,
   DEG45_Y = 3,
   HORIZONTAL = 4,
+   MULTIPLANAR = 5,
 }

 TYPE = {
@@ -303,6 +307,7 @@ LAY_RIBS = "Ribs"
 LAY_AUX_SOLIDS = "AuxSolids"
 LAY_SHELL_NBR = "ShellNumber"
 LAY_AUX = "Aux"
+SPINE_CURVE = "Spine"
 LAY_FRAME = "Frame"
 VIEWPARAMS = 'ViewParams'
 IMPORTED_SOLID = 'ImportedSolid'
@@ -31,7 +31,7 @@ local function GetLayerParamsForPathCalc()
   LayerParams.dLayHeight = EgtGetInfo( s_nPartId, KEY_SLICE_STEP, 'd')
   LayerParams.dStrandOverlap = EgtGetInfo( s_nPartId, KEY_STRAND_OVERLAP, 'd') or 0
   LayerParams.dOffs = EgtGetInfo( s_nPartId, KEY_OFFSET_SLICE, 'd')
-   s_vtSlicing = EgtGetInfo( s_nPartId, KEY_SLICING_DIR, 'v')
+   s_vtSlicing = EgtGetInfo( s_nPartId, KEY_SLICE_DIR, 'v')
   LayerParams.bPrintInvert = ( EgtGetInfo( s_nPartId, KEY_PRINT_DIRECTION, 'i') == PRINT_DIRECTION.CW)
   LayerParams.vPrintOrder = EgtGetInfo( s_nPartId, KEY_PRINT_ORDER, 'vi') or { 1, 2, 3, 4, 5, 6, 7, 8}
   -- parametri costolature
@@ -116,19 +116,13 @@ end

 ---------------------------------------------------------------------
 local function GetLayerStartPoint( nLayId)
-   
-   -- recupero quota layer
-   local dZ = EgtGetInfo( nLayId, KEY_SLICE_REAL_Z, 'd')
-   local dDeltaZ = EgtGetInfo( nLayId, KEY_SLICE_DELTAZ, 'd')
-   local frSlicing = Frame3d( ORIG(), s_vtSlicing)
-   local ptOn = Point3d( 0, 0, dZ + dDeltaZ)
-   ptOn:toGlob( frSlicing)
-   
+
   -- gruppo temporaneo dove salvo i risultati
   local nGrpTmp = EgtGroup( nLayId)
   
   local vPtStart = {}
   local nMachStartGrp = EgtGetFirstNameInGroup( s_nPartId, LAY_MACH_START)
+   local ptOn = EgtGetInfo( nLayId, KEY_SLICE_POS, 'p')
   local nStartId = EgtGetFirstInGroup( nMachStartGrp)
   while nStartId do
      local nType = EgtGetType( nStartId)
@@ -4343,12 +4337,17 @@ function CalcPaths.Exec( nPartId)
   local LayerParams = GetLayerParamsForPathCalc()
   local nFirstSolidLay = EgtGetInfo( s_nPartId, KEY_FIRST_SOLID_LAY, 'i') or -1
   local nLastSolidLay = EgtGetInfo( s_nPartId, KEY_LAST_SOLID_LAY, 'i') or -1
+   local nSlicingType = EgtGetInfo( s_nPartId, KEY_SLICING_TYPE, 'i')

   -- scorro tutti i suoi layer
   for nIdx = 1, #vLayIds do
       
      s_nCurrIdx = nIdx
-      
+
+      if nSlicingType == SLICING_TYPE.MULTIPLANAR then
+         s_vtSlicing = EgtGetInfo( vLayIds[nIdx], KEY_SLICE_DIR, 'v')
+      end
+
      local nRibsGrp = EgtGetFirstNameInGroup( vLayIds[nIdx], RIBS_GRP)
      local bIgnoreMergedRibs = true
      local nAuxSolidsGrp = EgtGetFirstNameInGroup( vLayIds[nIdx], AUX_SOLIDS_GRP)
@@ -18,38 +18,101 @@ local s_vErr = {}
 local s_dStrand

 -- costanti
-local TOLER = 0.05
-local MID_TOLER = 0.1
+-- recupero tolleranza dal file ini
+local INI_TOLER = EgtGetNumberFromIni( 'GeomDB', 'SurfTmToler', 0.01, EgtGetIniFile())
+local MID_TOLER = 10 * INI_TOLER
+local TOLER = 0.5 * MID_TOLER
 local BIG_TOLER = 2.0
 local MIN_LEN = 20.0
 local MIN_AREA = 25.0
+local DELTAZ = 10 * GEO.EPS_SMALL
+

 ---------------------------------------------------------------------
-local function ComputeZSlices( dSliceStep, dZmin, dDeltaZ, dZmax)
+local function ComputeSlicingData( vIds, vtSlicing, dSliceStep, dMaxH, nMaxSlicesNbr)
+   -- la direzione di slicing è vtSlicing per tutti gli slices
+   -- i valori di slicing sono le distanze dall'origine dei piani di slicing misurate in direzione vtSlicing
   
-   -- verifico se è impostato un numero massimo di slices
-   local nMaxSlicesNbr = EgtGetInfo( s_nPartId, KEY_MAX_SLICES_NBR, 'i') or 0
-   if nMaxSlicesNbr == 0 then
-      nMaxSlicesNbr = GEO.INFINITO   -- da gestire come caso illimitato
+   local vSlicingDir = { vtSlicing}
+   -- ricavo le z a cui calcolare gli slices
+   local frSlicing = Frame3d( ORIG(), vtSlicing)
+   local b3Box = BBox3d()
+   for i = 1, #vIds do
+      local b3Tmp = EgtGetBBoxRef( vIds[i], GDB_BB.STANDARD, frSlicing)
+      b3Box:Add( b3Tmp)
   end
-   
+   local dZmin = b3Box:getMin():getZ()
+   local dZmax = min( b3Box:getMax():getZ(), dMaxH)
+
   local nCnt = 1
-   local ptSlices = { dZmin + dDeltaZ}
+   local vZSlices = { dZmin + DELTAZ}
   local dPosZ = dZmin + dSliceStep
   while dPosZ < dZmax and nCnt < nMaxSlicesNbr do
-      table.insert( ptSlices, dPosZ)
+      table.insert( vZSlices, dPosZ)
      dPosZ = dPosZ + dSliceStep
      nCnt = nCnt + 1
-   end 
-   return ptSlices
+   end
+   return vZSlices, vSlicingDir
 end

+---------------------------------------------------------------------
+local function ComputeMultiplanarSlicingData( dSliceStep, nMaxSlicesNbr)
+   -- le direzioni e i valori di slicing sono le normali e i punti che definiscono i piani di slicing e vengono calcolati sulla curva "Spine"
+   
+   -- recupero la curva guida ( è la prima nel gruppo aux con info NameEntity = Spine oppure quella con nome Spine)
+   local nAuxLayId = EgtGetFirstNameInGroup( s_nPartId, LAY_AUX)
+   local vIds = EgtGetAllInGroup( nAuxLayId)
+   local nSpineId
+   for i = 1, #vIds do
+      local sNameEntity = EgtGetInfo( vIds[i], KEY_ENTITY_NAME)
+      if sNameEntity == SPINE_CURVE then
+         nSpineId = vIds[i]
+         break
+      elseif EgtGetName( vIds[i]) == SPINE_CURVE then
+         nSpineId = vIds[i]
+      end
+   end
+   if not nSpineId or ( EgtGetType( nSpineId) & GDB_FY.GEO_CURVE) == 0 then
+      EgtOutBox( "No spine for multiplanar slicing", 'Error', 'ERROR')
+      return nil
+   end
+   
+   -- verifico che la spina parta nell'origine con direzione Z_AX
+   local ptS = EgtSP( nSpineId, GDB_ID.ROOT)
+   local vtS = EgtSV( nSpineId, GDB_ID.ROOT)
+   if abs( ptS:getZ()) > GEO.EPS_SMALL then
+      EgtOutLog( 'Error : spine does not start on table')
+      EgtOutBox( "Spine not valid for multiplanar slicing", 'Error', 'ERROR')
+      return nil
+   elseif not AreSameVectorApprox( vtS, Z_AX()) then
+      EgtOutLog( 'Error : spine start direction is not vertical')
+      EgtOutBox( "Spine not valid for multiplanar slicing", 'Error', 'ERROR')
+      return nil
+   end
+   
+   local vSlicingDir = {}
+   local vSlicingPnt = {}
+   -- ciclo sulla curva
+   local nCnt = 0
+   local dCrvLen = EgtCurveLength( nSpineId)
+   for i = 0, nMaxSlicesNbr - 1 do
+      local dCurrLen = i * dSliceStep
+      if dCurrLen > dCrvLen then
+         break
+      end
+      local dU = EgtCurveParamAtLength( nSpineId, dCurrLen)
+      vSlicingDir[i+1] = EgtUV( nSpineId, dU, -1, GDB_ID.ROOT)
+      vSlicingPnt[i+1] = EgtUP( nSpineId, dU, GDB_ID.ROOT)
+   end
+   
+   return vSlicingPnt, vSlicingDir
+end
 --------------------------------------------------------------------
-local function ComputeMaxH( vIds, frSlicing, dSliceStep)
+local function ComputeMaxH( vIds, vtSlicing, dSliceStep)
   
   local HMax = EgtGetInfo( s_nPartId, KEY_MAX_H, 'd') or GEO.INFINITO
   if HMax < GEO.EPS_SMALL then
-      HMax = GEO.INFINITO
+      return GEO.INFINITO
   end
   
   -- calcolo il box globale
@@ -60,14 +123,16 @@ local function ComputeMaxH( vIds, frSlicing, dSliceStep)
   end
   EgtSetInfo( s_nPartId, KEY_BOX_MIN_Z, b3BoxGlob:getMin():getZ())
   
-   if b3BoxGlob:getMax():getZ() < b3BoxGlob:getMin():getZ() + HMax + GEO.EPS_SMALL then
+   -- se il pezzo non è più alto della quota massima, posso ignorarla
+   if b3BoxGlob:getMax():getZ() < HMax + GEO.EPS_SMALL then
      return GEO.INFINITO
   end
   
-   if AreSameVectorApprox( frSlicing:getVersZ(), Z_AX()) then
+   if AreSameVectorApprox( vtSlicing, Z_AX()) then
+      -- se slicing verticale o multiplanare l'altezza è quella letta
      return HMax
-   else   
-      -- se slicing inclinato
+   else
+       -- se slicing inclinato calcolo l'altezza massima rispetto alle quote di slicing
      local nGrpTmp = EgtGroup( s_nPartId)
      for i = 1, #vIds do
         EgtPlaneSurfTmInters( Point3d( 0, 0, HMax), Z_AX(), vIds[i], nGrpTmp, GDB_RT.GLOB)
@@ -81,8 +146,9 @@ local function ComputeMaxH( vIds, frSlicing, dSliceStep)
      local ptMax = b3Box:getMax()
      -- la quota dell'ultimo slice è più bassa di dSliceStep rispetto alla quota dell'ultimo toolpath
      -- ( andrebbe anche considerata dCorrZ)
-      ptMin = ptMin - dSliceStep * frSlicing:getVersZ()
-      ptMax = ptMax - dSliceStep * frSlicing:getVersZ()
+      ptMin = ptMin - dSliceStep * vtSlicing
+      ptMax = ptMax - dSliceStep * vtSlicing
+      local frSlicing = Frame3d( ORIG(), vtSlicing)
      ptMin:toLoc( frSlicing)
      ptMax:toLoc( frSlicing)
      
@@ -92,7 +158,9 @@ local function ComputeMaxH( vIds, frSlicing, dSliceStep)
   return GEO.INFINITO
 end

--------------------------------------------------------------------
+----------------------------------------------------------------------
+-------------------- SLICING EXTRA OBJECTS ---------------------------
+----------------------------------------------------------------------
 local function ReadParam( nId, sKey, sType, defVal, table)
   -- verifico se info nell'oggetto specifico
   local info = EgtGetInfo( nId, sKey, sType)
@@ -177,13 +245,12 @@ local function GetAuxSolidsParams( nId)
   return AuxSolidsParam
 end

----------------------------------------------------------------------
-------------------- SLICING EXTRA OBJECTS ---------------------------
----------------------------------------------------------------------
-local function SliceStm( vIds, nLayId, vtSlicing, nType, sName, sNameGrp, tabParams)
+--------------------------------------------------------------------
+local function SliceStm( vIds, nLayId, vtSlicing, ptSlicing, nType, sName, sNameGrp, tabParams)
   
   if not vIds or #vIds == 0 then return end
   
+   local nLayCnt = EgtGetInfo( nLayId, KEY_SLICE_NBR, 'i')
   -- recupero il gruppo dove salvare lo slicing degli oggetti
   local nGrp = EgtGetFirstNameInGroup( nLayId, sNameGrp)
   if not nGrp then
@@ -192,22 +259,17 @@ local function SliceStm( vIds, nLayId, vtSlicing, nType, sName, sNameGrp, tabPar
      EgtSetName( nGrp, sNameGrp)
      EgtSetStatus( nGrp, GDB_ST.OFF)
   end
-   
+
   -- recupero quota per slicing
-   local dZ = EgtGetInfo( nLayId, KEY_SLICE_REAL_Z, 'd')
   local dDeltaZ = EgtGetInfo( nLayId, KEY_SLICE_DELTAZ, 'd')
-   local nLayCnt = EgtGetInfo( nLayId, KEY_SLICE_NBR, 'i')
-   
-   -- gruppo temporaneo per approx curve
-   local frloc = Frame3d( ORIG(), vtSlicing)
-   local nGrpTmp = EgtGroup( nLayId, frloc, GDB_RT.GLOB)
+   local ptOn = ptSlicing + dDeltaZ * vtSlicing

   for i = 1, #vIds do
      -- verifico che oggetto sia trimesh
      local nTypeObj = EgtGetType( vIds[i])
      if nTypeObj == GDB_TY.SRF_MESH then
         -- slicing oggetto
-         local nNewId, nPntCnt, nCrvCnt, nSrfCnt = EgtPlaneSurfTmInters( ORIG() + ( dZ + dDeltaZ) * vtSlicing, vtSlicing, vIds[i], nGrp, GDB_RT.GLOB, TOLER)
+         local nNewId, nPntCnt, nCrvCnt, nSrfCnt = EgtPlaneSurfTmInters( ptOn, vtSlicing, vIds[i], nGrp, GDB_RT.GLOB, TOLER)
   
         -- verifico se necessario ricalcolo
         local dCorr = 0
@@ -228,7 +290,7 @@ local function SliceStm( vIds, nLayId, vtSlicing, nType, sName, sNameGrp, tabPar
               EgtErase( j)
            end
            dCorr = 0.01
-            nNewId, nPntCnt, nCrvCnt, nSrfCnt = EgtPlaneSurfTmInters( ORIG() + ( dZ + dDeltaZ + dCorr) * vtSlicing, vtSlicing, vIds[i], nGrp, GDB_RT.GLOB, TOLER)
+            nNewId, nPntCnt, nCrvCnt, nSrfCnt = EgtPlaneSurfTmInters( ptOn + dCorr * vtSlicing, vtSlicing, vIds[i], nGrp, GDB_RT.GLOB, TOLER)
         end
            
         if nNewId then
@@ -251,7 +313,7 @@ local function SliceStm( vIds, nLayId, vtSlicing, nType, sName, sNameGrp, tabPar
            end
            -- rinomino le curve, correggo di DeltaZ e assegno parametri
            for nId = nChainId, nChainId + nCnt - 1 do
-               EgtSetName( nId, sName .. tostring( i))
+               EgtSetName( nId, sName .. EgtNumToString( i))
               EgtMove( nId, - ( dDeltaZ + dCorr) * vtSlicing)
               EgtSetInfo( nId, KEY_ORIGINAL_SURF, vIds[i])
               if tabParams then
@@ -260,9 +322,7 @@ local function SliceStm( vIds, nLayId, vtSlicing, nType, sName, sNameGrp, tabPar
                  end
               end
               EgtModifyCurveExtrusion( nId, vtSlicing, GDB_RT.GLOB)
-               EgtRelocateGlob( nId, nGrpTmp)
               EgtApproxCurve( nId, GDB_CA.ARCS, MID_TOLER)
-               EgtRelocateGlob( nId, nGrp)
             
               -- se ho ancora curve aperte, segnalo errore
               if nType ~= TYPE.RIB and nType ~= TYPE.INFILL and not EgtCurveIsClosed( nId) then
@@ -282,12 +342,14 @@ local function SliceStm( vIds, nLayId, vtSlicing, nType, sName, sNameGrp, tabPar
   -- verifico che il gruppo non sia vuoto
   if not EgtGetFirstInGroup( nGrp) then
      EgtErase( nGrp)
+      nGrp = nil
   end
-   EgtErase( nGrpTmp)
+   
+   return nGrp
 end

 --------------------------------------------------------------------
-local function SlicingExtraObjects( nLay, vtSlicing, nType, sName, sNameGrp, nStmId)
+local function SlicingExtraObjects( nLay, nType, sName, sNameGrp, nStmId)
   
   if not nLay then return end
   
@@ -340,19 +402,20 @@ local function SlicingExtraObjects( nLay, vtSlicing, nType, sName, sNameGrp, nSt
   -- per ogni layer calcolo lo slicing degli oggetti
   local vLayIds = EgtGetNameInGroup( s_nPartId, SLICE_LAYER .. '*')
   for i = 1, #vLayIds do
-      SliceStm( vSliceIds, vLayIds[i], vtSlicing, nType, sName, sNameGrp, tabParams)
+      -- ricavo piano di slicing
+      local ptSlicing = EgtGetInfo( vLayIds[i], KEY_SLICE_POS, 'p')
+      local vtSlicing = EgtGetInfo( vLayIds[i], KEY_SLICE_DIR, 'v')
+      SliceStm( vSliceIds, vLayIds[i], vtSlicing, ptSlicing, nType, sName, sNameGrp, tabParams)
   end

   -- rimuovo eventuali oggetti creati per lo slicing
-   for i = 1, #vEraseIds do
-      EgtErase( vEraseIds[i])
-   end
+   EgtErase( vEraseIds)
   
   return true
 end

 ------------------------------------------------------------------------
-local function SlicingInfill( nLay, vtSlicing, sName, sNameGrp)
+local function SlicingInfill( nLay, sName, sNameGrp)
   
   -- recupero tutte le curve di infill suddivise per direzioni di riferimento
   local vInfillGrps = EgtGetAllInGroup( nLay)
@@ -362,10 +425,6 @@ local function SlicingInfill( nLay, vtSlicing, sName, sNameGrp)
      table.insert( tIds, vIds)
   end
   local nGrps = #vInfillGrps
-   
-   -- recupero quota infill
-   local ptInfill = EgtSP( tIds[1][1], GDB_ID.ROOT)
-   local dZInfill = ( ptInfill - ORIG()) * vtSlicing
  
   local vLayIds = EgtGetNameInGroup( s_nPartId, SLICE_LAYER .. '*')
   for i = 1, #vLayIds do
@@ -373,21 +432,14 @@ local function SlicingInfill( nLay, vtSlicing, sName, sNameGrp)
      -- individuo il gruppo di cui fare slicing
      local nGrpIdx = ( i - 1) % nGrps + 1
      
-      -- recupero il gruppo dove salvare gli infill
-      local nGrp = EgtGetFirstNameInGroup( vLayIds[i], sNameGrp)
-      if not nGrp then
-         -- se gruppo non esiste lo creo
-         nGrp = EgtGroup( vLayIds[i])
-         EgtSetName( nGrp, sNameGrp)
-         EgtSetStatus( nGrp, GDB_ST.OFF)
-      end
-      
-      -- copio le curve di infill e le traslo alla quota dello slicing
-      local dZ = EgtGetInfo( vLayIds[i], KEY_SLICE_REAL_Z, 'd')
-      for j = 1, #tIds[nGrpIdx] do
-         local nCrv = EgtCopyGlob( tIds[nGrpIdx][j], nGrp)
-         EgtSetName( nCrv, sName .. tostring(j))
-         EgtMove( nCrv, (dZ - dZInfill) * vtSlicing, GDB_RT.GLOB)
+      -- recupero i dati di slicing
+      local ptSlicing = EgtGetInfo( vLayIds[i], KEY_SLICE_POS, 'p')
+      local vtSlicing = EgtGetInfo( vLayIds[i], KEY_SLICE_DIR, 'v')
+      local nResultLay = SliceStm( tIds[nGrpIdx], vLayIds[i], vtSlicing, ptSlicing, TYPE.INFILL, sName, sNameGrp)
+      -- sistemo i nomi delle curve
+      local vInfillCrvs = EgtGetAllInGroup( nResultLay)
+      for j = 1, #vInfillCrvs do
+         EgtSetName( vInfillCrvs[j], sName .. EgtNumToString(j))
      end
   end

@@ -548,7 +600,7 @@ local function CalcGridFromPattern( nInfillGrp, nStmId, dOffsStm, frRef, vtOffs,
      EgtAddCurveCompoLine( nCrvBase, pt2)
   end
   CompletePatternBaseCrv( nCrvBase, dAng, dDim1, dDim2, ptMin:getY(), ptMax:getY())
-   
+
   -- preparo le altre curve
   CalcPatternCrvs( nMainGrp, nCrvBase, ptMin:getX(), ptMax:getX(), dAng, dDim1, dStrand)

@@ -586,7 +638,7 @@ end
 --------------------------------------------------------------------
 local function CalcInfill( nInfillGrp, nType, dDensity, dDir, dOffsX, dOffsY, dGridOverlap, nStmId, dOffsStm, dStrand, vtSlicing)
   
-   -- frame locale alla direzione dell'infill
+   -- frame locale alla direzione dell'infill 
   local frLoc = Frame3d( ORIG(), vtSlicing)
   frLoc:rotate( ORIG(), vtSlicing, dDir)

@@ -626,6 +678,21 @@ local function CalcInfill( nInfillGrp, nType, dDensity, dDir, dOffsX, dOffsY, dG
      local vSlicesAng = EgtIf( nType == FILL_TYPE.HONEYCOMB, {0}, {0, 60, 120})
      CalcGridFromPattern( nInfillGrp, nStmId, dOffsStm, frLoc, vtOffs, dDim1, dDim2, dAng, vSlicesAng, dRealStrand, vtSlicing)
   end
+   
+   -- calcolo le superifici a partire dalle curve ( nei casi standard è semplice estrusione)
+   local vGrps = EgtGetAllInGroup( nInfillGrp)
+   local vCrvs = {}
+   for i = 1, #vGrps do
+      EgtJoinTables( vCrvs, EgtGetAllInGroup( vGrps[i]))
+   end
+   local nLastLay = EgtGetLastNameInGroup( s_nPartId, SLICE_LAYER .. '*')
+   local ptLast = EgtGetInfo( nLastLay, KEY_SLICE_POS, 'p')
+   local dZ = ( ptLast - ORIG()) * vtSlicing
+   for i = 1, #vCrvs do
+      EgtSurfTmByExtrusion( EgtGetParent( vCrvs[i]), vCrvs[i], ( dZ + 100) * vtSlicing, GDB_RT.GLOB) 
+   end
+   EgtErase( vCrvs)
+   
 end

 --------------------------------------------------------------------
@@ -660,7 +727,7 @@ local function PrepareInfill( nStmId, vtSlicing)
   CalcInfill( nInfillGrp, nType, dDensity, dDir, dOffsX, dOffsY, dGridOverlap, nStmId, dOffsStm, dStrand, vtSlicing)
   
   -- aggiungo allo slicing
-   SlicingInfill( nInfillGrp, vtSlicing, INFILL_CRV, INFILL_GRP)
+   SlicingInfill( nInfillGrp, INFILL_CRV, INFILL_GRP)
 end

 ----------------------------------------------------------------------
@@ -689,15 +756,15 @@ local function PrepareAuxSolidsInfill( nSolidsLay, vtSlicing)
               
               -- creo gruppo associato
               local nInfillGrp = EgtGroup( s_nPartId)
-               EgtSetName( nInfillGrp, AUX_SOLIDS_INFILL_GRP .. tostring( vIds[i]))
+               EgtSetName( nInfillGrp, AUX_SOLIDS_INFILL_GRP .. EgtNumToString( vIds[i]))
               EgtSetStatus( nInfillGrp, GDB_ST.OFF)
               
               -- calcolo infill
               CalcInfill( nInfillGrp, nType, dDensity, dDir, dOffsX, dOffsY, dGridOverlap, vIds[i], 0, dStrand, vtSlicing)
               
               -- aggiungo allo slicing
-               local sName = AUX_SOLIDS_INFILL_CRV .. tostring( vIds[i]) .. '_'
-               SlicingInfill( nInfillGrp, vtSlicing, sName, AUX_SOLIDS_GRP)
+               local sName = AUX_SOLIDS_INFILL_CRV .. EgtNumToString( vIds[i]) .. '_'
+               SlicingInfill( nInfillGrp, sName, AUX_SOLIDS_GRP)
            end
         end
      end
@@ -725,7 +792,7 @@ local function ExtractRibsLoops( nRibsGrp, nStmId)
         if nCrv then
            -- assegno nome che permetta di ricondurli alla superficie da cui derivano
            for nId = nCrv, nCrv + nCnt - 1 do
-               EgtSetName( nId, SURF_LOOP .. tostring( vIds[i]))
+               EgtSetName( nId, SURF_LOOP .. EgtNumToString( vIds[i]))
            end
         end
      end
@@ -743,50 +810,191 @@ local function ValueInArray( vArr, nValue)
 end

 ---------------------------------------------------------------------
-local function SlicingNoSolid( nRibsLay, vZSlices, dDeltaZStart, dZmin, frSlicing)
-   
-   local vtSlicing = frSlicing:getVersZ()
-   
+local function SlicingNoSolid( nRibsLay, nSlicingType, dMaxH, dSliceStep, vSlicingVal, vSlicingDir)
+
   -- contatore per il calcolo delle intersezioni
   if EgtProcessEvents( 100, 0) == 1 then return false end

-   -- creo i layer dello slicing
-   for i = 1, #vZSlices do
-      local nLayGrp = EgtGroup( s_nPartId)
-      EgtSetName( nLayGrp, SLICE_LAYER .. tostring( i))
-      
-      local dDeltaZ = EgtIf( i == 1, dDeltaZStart, 0)
-      local dPosZ = vZSlices[i]- dDeltaZ
-      EgtSetInfo( nLayGrp, KEY_SLICE_Z, dPosZ - dZmin)
-      EgtSetInfo( nLayGrp, KEY_SLICE_REAL_Z, dPosZ)
-      EgtSetInfo( nLayGrp, KEY_SLICE_DELTAZ, dDeltaZ)
-      EgtSetInfo( nLayGrp, KEY_SLICE_NBR, i)
-      
-      local nGrpCrv = EgtGroup( nLayGrp)
-      EgtSetName( nGrpCrv, CONTOUR_GRP .. EgtNumToString( 0))
+   -- recupero i setti di cui fare lo slicing e i parametri associati
+   local vRibIds = EgtGetAllInGroup( nRibsLay)
+   local tabParams = {}
+   local vIds = {}
+   for i = 1, #vRibIds do
+      if EgtGetType( vRibIds[i]) == GDB_TY.SRF_MESH then
+         local vParams = GetRibParams( vRibIds[i])
+         if vParams[KEY_RIBS_SHELLS_NBR] > 0 then
+            table.insert( tabParams, vParams)
+            table.insert( vIds, vRibIds[i])
+         end
+      end
+   end
+
+   -- creo i layer dello slicing
+   for i = 1, #vSlicingVal do
+      -- creo layer e gruppo dei contorni
+      local nLayId = EgtGroup( s_nPartId)
+      EgtSetName( nLayId, SLICE_LAYER .. EgtNumToString( i))
+      EgtSetInfo( nLayId, KEY_SLICE_NBR, i)
+      local nCrvLayId = EgtGroup( nLayId)
+      EgtSetName( nCrvLayId, CONTOUR_GRP .. EgtNumToString( 0))
+      
+      -- recupero i dati del piano di slicing
+      local dDeltaZ = EgtIf( i == 1, DELTAZ, 0)
+      local ptSlicing
+      local vtSlicing
+      if nSlicingType == SLICING_TYPE.MULTIPLANAR then
+         vtSlicing = vtSlicing[i]
+         ptSlicing = vSlicingVal[i]
+      else
+         vtSlicing = vSlicingDir[1]
+         ptSlicing = ORIG() + ( vSlicingVal[i] - dDeltaZ) * vtSlicing
+      end
+      EgtSetInfo( nLayId, KEY_SLICE_POS, ptSlicing)
+      EgtSetInfo( nLayId, KEY_SLICE_DIR, vtSlicing)
+      EgtSetInfo( nLayId, KEY_SLICE_DELTAZ, dDeltaZ)
+      
+      -- slicing dei setti
+      local nResultLay = SliceStm( vIds, nLayId, vtSlicing, ptSlicing, TYPE.RIB, RIBS_CRV, RIBS_GRP, tabParams)
+      
+      -- se slicing multplanare verifico altezza massima
+      if nSlicingType == SLICING_TYPE.MULTIPLANAR and dMaxH < GEO.INFINITO then
+         local b3Box = EgtGetBBoxGlob( nResultLay, GDB_BB.STANDARD)
+         local ptMax = b3Box:getMax() + dSliceStep * vtSlicing
+         if ptMax:getZ() > dMaxH + GEO.EPS_SMALL then
+            EgtErase( nLayId)
+            break
+         end
+      end
+
+      if EgtProcessEvents( EgtIf( PRINT, 100, 0) + i / #vSlicingVal * 100, 0) == 1 then return false end
   end
-   if EgtProcessEvents( EgtIf( PRINT, 100, 0) + 20, 0) == 1 then return false end
-    
-   -- slicing dei setti
-   SlicingExtraObjects( nRibsLay, vtSlicing, TYPE.RIB, RIBS_CRV, RIBS_GRP)
-   if EgtProcessEvents( EgtIf( PRINT, 100, 0) + 100, 0) == 1 then return false end
   
   return true
 end

 ---------------------------------------------------------------------
-local function SlicingWithSolid( nStmId, vZSlices, dDeltaZStart, dZmin, frSlicing)
+local function MultiPlanarSlicing( nStmId, dMaxH, vSlicingDir, vSlicingPnt)

-   local vtSlicing = frSlicing:getVersZ()
+   local dSliceStep = EgtGetInfo( s_nPartId, KEY_SLICE_STEP, 'd')
+   -- ciclo sui piani di slicing calcolati
+   local nFirstGrpId
+   local nCnt = 0
+   for i = 1, #vSlicingPnt do
+      local vtN = vSlicingDir[i]
+      local ptOn = vSlicingPnt[i]
+      -- correzione per layer iniziale
+      if i == 1 then
+         ptOn = ptOn + DELTAZ * vtN
+      end
+      
+      local nGrpId = EgtGroup( s_nPartId)
+      if not nFirstGrpId then
+         nFirstGrpId = nGrpId
+      end
+      local nEntId = EgtPlaneSurfTmInters( ptOn, vtN, nStmId, nGrpId, GDB_RT.GLOB, TOLER)
+      -- eventuale verifica con altezza massima
+      if dMaxH < GEO.INFINITO then
+         local b3Box = EgtGetBBoxGlob( nGrpId, GDB_BB.STANDARD)
+         local ptMax = b3Box:getMax() + dSliceStep * vtN
+         if ptMax:getZ() > dMaxH + GEO.EPS_SMALL then
+            EgtErase( nGrpId)
+            break
+         end
+      end
+      nCnt = i + 1
+      -- aggiornamento progress ( per riconoscimento corretto della fase dal programma deve partire da 1)
+      if EgtProcessEvents( max( 1, 100 * i / #vSlicingPnt), 0) == 1 then
+         return nFirstGrpId, -1
+      end
+   end
+   return nFirstGrpId, nCnt
+end
+
+---------------------------------------------------------------------
+local function VerifyMultiPlanarStrand()
   
+   local vLayers = EgtGetNameInGroup( s_nPartId, SLICE_LAYER .. '*')
+   -- recupero i valori di strand massimo e minimo dal file ini
+   local sMachIni = EgtGetCurrMachineDir() .. '\\' .. EgtGetCurrMachineName() .. '.ini'
+   local dMaxStrandFactor = EgtGetNumberFromIni( '3dPrinting', KEY_MAX_STRANDH_FACTOR, 2, sMachIni)
+   local dMinStrandFactor = EgtGetNumberFromIni( '3dPrinting', KEY_MIN_STRANDH_FACTOR, 0.5, sMachIni)
+   local dSliceStep = EgtGetInfo( s_nPartId, KEY_SLICE_STEP, 'd')
+   local dMaxStrand = dMaxStrandFactor * dSliceStep
+   local dMinStrand = dMinStrandFactor * dSliceStep
+   
+   if dMaxStrand < dMinStrand + GEO.EPS_SMALL then
+      EgtOutBox( 'Max strand height is less than min strand height', 'Error', 'ERROR')
+      return false
+   end
+   
+   -- ciclo sui piani di slicing calcolati
+   local vtSlicePrev = EgtGetInfo( vLayers[1], KEY_SLICE_DIR, 'v')
+   local ptSlicePrev = EgtGetInfo( vLayers[1], KEY_SLICE_POS, 'p') + dSliceStep * vtSlicePrev
+   for i = 2, #vLayers do
+      
+      -- recupero il piano corrente
+      local vtSlice = EgtGetInfo( vLayers[i], KEY_SLICE_DIR, 'v')
+      local ptSlice = EgtGetInfo( vLayers[i], KEY_SLICE_POS, 'p') + dSliceStep * vtSlice
+      local dCosAng = vtSlicePrev * vtSlice
+      
+      -- recupero tutte le curve da verificare :
+      local vCrvs = {}
+      -- solido
+      local vCrvGrps = EgtGetNameInGroup( vLayers[i], CONTOUR_GRP .. '*')
+      for j = 1, #vCrvGrps do
+         local vSolidCrvs = EgtGetNameInGroup( vCrvGrps[j], OUTER_CRV)
+         EgtJoinTables( vCrvs, vSolidCrvs)
+      end
+      -- setti
+      local nRibsGrp = EgtGetFirstNameInGroup( vLayers[i], RIBS_GRP) or GDB_ID.NULL
+      local vRibsCrv = EgtGetNameInGroup( nRibsGrp, RIBS_CRV .. '*') or {}
+      EgtJoinTables( vCrvs, vRibsCrv)
+      -- AuxSolids
+      local nAuxSolidsGrp = EgtGetFirstNameInGroup( vLayers[i], AUX_SOLIDS_GRP) or GDB_ID.NULL
+      local vAuxSolidsCrv = EgtGetNameInGroup( nAuxSolidsGrp, AUX_SOLIDS_CRV .. '*') or {}
+      EgtJoinTables( vCrvs, vAuxSolidsCrv)
+      
+      -- verifico la distanza dal piano precedente lungo vtSlice
+      for j = 1, #vCrvs do
+         local _, dE = EgtCurveDomain( vCrvs[j])
+         for dU = 0, dE do
+            local ptCurr = EgtUP( vCrvs[j], dU, GDB_ID.ROOT) + dSliceStep * vtSlice
+            local dDist = ( ptCurr - ptSlicePrev) * vtSlicePrev / dCosAng
+            if dDist < dMinStrand - GEO.EPS_SMALL or dDist > dMaxStrand + GEO.EPS_SMALL then
+               EgtOutLog( 'Error on layer ' .. EgtNumToString( i) .. ' : strand height (' .. EgtNumToString( dDist) .. ') outside valid range (' .. EgtNumToString( dMinStrand) .. 
+                           ' - ' .. EgtNumToString( dMaxStrand) .. ')')
+               EgtOutBox( 'Strand height value ' .. EgtNumToString( dDist) .. ' in layer ' .. EgtNumToString( i) .. ' is outside valid range (' .. EgtNumToString( dMinStrand) .. 
+                           ' - ' .. EgtNumToString( dMaxStrand) .. ')', 'Error', 'ERROR')
+               return false
+            end
+         end
+      end
+      
+      -- aggiorno per layer successivo
+      vtSlicePrev = vtSlice
+      ptSlicePrev = ptSlice
+   end
+   
+   return true
+end
+
+---------------------------------------------------------------------
+local function SlicingWithSolid( nStmId, nSlicingType, dMaxH, vSlicingVal, vSlicingDir)
+
   -- calcolo delle intersezioni
-   if EgtProcessEvents( 1, 0) == 1 then return false end
-   local nLayId = EgtParPlanesSurfTmInters( ORIG(), vtSlicing, vZSlices, nStmId, s_nPartId, GDB_RT.GLOB, TOLER)
-   if EgtProcessEvents( 100, 0) == 1 then return false end
+   local nLayId, nCnt
+   if nSlicingType ~= SLICING_TYPE.MULTIPLANAR then
+      if EgtProcessEvents( 1, 0) == 1 then return false end
+      nLayId, nCnt = EgtParPlanesSurfTmInters( ORIG(), vSlicingDir[1], vSlicingVal, nStmId, s_nPartId, GDB_RT.GLOB, TOLER)
+      if EgtProcessEvents( 100, 0) == 1 then return false end
+   else
+      nLayId, nCnt = MultiPlanarSlicing( nStmId, dMaxH, vSlicingDir, vSlicingVal)
+      if nCnt == -1 then return false end
+   end
   
   local vPrevCen = {}
   local nLayCnt = 1
-   local nCounterTot = #vZSlices + 12
+   local nCounterTot = nCnt + 12
   
   local nFirstSolidLay   -- primo layer che contiene il solido
   local nLastSolidLay    -- ultimo layer che contiene il solido
@@ -794,12 +1002,25 @@ local function SlicingWithSolid( nStmId, vZSlices, dDeltaZStart, dZmin, frSlicin
   -- scorro i risultati dello slicing
   while nLayId do
      
-      local dDeltaZ = EgtIf( nLayCnt == 1, dDeltaZStart, 0)
-      local dPosZ = vZSlices[nLayCnt]- dDeltaZ
-      EgtSetInfo( nLayId, KEY_SLICE_Z, dPosZ - dZmin)
-      EgtSetInfo( nLayId, KEY_SLICE_REAL_Z, dPosZ)
      EgtSetInfo( nLayId, KEY_SLICE_NBR, nLayCnt)
      
+      -- ricavo punto e direzione del piano di slicing
+      local dDeltaZ = EgtIf( nLayCnt == 1, DELTAZ, 0)
+      local ptSlicing
+      local vtSlicing
+      if nSlicingType == SLICING_TYPE.MULTIPLANAR then
+         -- nel caso multiplanare sono i dati di slicing
+         vtSlicing = vSlicingDir[nLayCnt]
+         ptSlicing = vSlicingVal[nLayCnt]
+      else
+         -- nel caso standard la direzione è è l'unico elemento del vettore direzioni ( visto che è comune a tutti i piani) mentre i valori sono le distanze dai piani da quello
+         -- posto nell'origine
+         vtSlicing = vSlicingDir[1]
+         ptSlicing = ORIG() + ( vSlicingVal[nLayCnt] - dDeltaZ) * vtSlicing
+      end
+      EgtSetInfo( nLayId, KEY_SLICE_POS, ptSlicing)
+      EgtSetInfo( nLayId, KEY_SLICE_DIR, vtSlicing)
+      
      -- verifico se necessario ricalcolo
      local nId = EgtGetLastInGroup( nLayId)
      local bRecalc = not nId
@@ -820,9 +1041,10 @@ local function SlicingWithSolid( nStmId, vZSlices, dDeltaZStart, dZmin, frSlicin
      if bRecalc then
         nRecalc = nRecalc + 1
         EgtEmptyGroup( nLayId)
-         dDeltaZ = dDeltaZ + EgtIf( vtRecalc and vtRecalc:getZ() > 0, -0.01, 0.01)
+         dDeltaZ = dDeltaZ + EgtIf( vtRecalc and vtRecalc:getZ() > 0, - DELTAZ, DELTAZ)
         -- eseguo il ricalcolo solo a quella quota
-         EgtPlaneSurfTmInters( ORIG() + ( dPosZ + dDeltaZ) * vtSlicing, vtSlicing, nStmId, nLayId, GDB_RT.GLOB, TOLER)
+         local ptOn = ptSlicing + dDeltaZ * vtSlicing
+         EgtPlaneSurfTmInters( ptOn, vtSlicing, nStmId, nLayId, GDB_RT.GLOB, TOLER)
         EgtOutLog( 'Warning : recalc at layer '.. EgtNumToString( nLayCnt))
      end
      EgtSetInfo( nLayId, KEY_SLICE_DELTAZ, dDeltaZ)
@@ -910,13 +1132,10 @@ local function SlicingWithSolid( nStmId, vZSlices, dDeltaZStart, dZmin, frSlicin
      EgtSetColor( vOpenId or {}, 'RED')
   
      -- creo flat region a partire dalle curve chiuse ottenute con lo slicing
-      local nGrp = EgtGroup( nLayId, frSlicing, GDB_RT.GLOB)
      for i = 1, #vClosedId do
-         EgtRelocateGlob( vClosedId[i], nGrp)
+         EgtModifyCurveExtrusion( vClosedId[i], vtSlicing, GDB_RT.GLOB)
         EgtApproxCurve( vClosedId[i], GDB_CA.ARCS, MID_TOLER)
-         EgtRelocateGlob( vClosedId[i], nLayId)
      end
-      EgtErase( nGrp)
      local nSurfFR, nSrfNbr = EgtSurfFlatRegion( nLayId, vClosedId)
   
      if nSurfFR then
@@ -1056,32 +1275,69 @@ local function SlicingWithSolid( nStmId, vZSlices, dDeltaZStart, dZmin, frSlicin
   -- 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
+   SlicingExtraObjects( nRibsLay, TYPE.RIB, RIBS_CRV, RIBS_GRP, nStmId)
+   if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( nCnt + 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 + 6) / nCounterTot * 100, 0) == 1 then return false end
+      if nSlicingType ~= SLICING_TYPE.MULTIPLANAR then
+         PrepareInfill( nStmId, vSlicingDir[1])
+      end
+      if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( nCnt + 6) / nCounterTot * 100, 0) == 1 then return false end
      
      -- solidi per regioni con diverso numero di passate
      local nShellNbrLay = EgtGetFirstNameInGroup( s_nPartId, LAY_SHELL_NBR)
-      SlicingExtraObjects( nShellNbrLay, vtSlicing, TYPE.EXTRA_SHELL, SHELL_NBR_CRV, SHELL_NBR_GRP)
-      if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( #vZSlices + 9) / nCounterTot * 100, 0) == 1 then return false end
+      SlicingExtraObjects( nShellNbrLay, TYPE.EXTRA_SHELL, SHELL_NBR_CRV, SHELL_NBR_GRP)
+      if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( nCnt + 9) / nCounterTot * 100, 0) == 1 then return false end
      
      -- solidi ausiliari
      local nAuxSolidsLay = EgtGetFirstNameInGroup( s_nPartId, LAY_AUX_SOLIDS)
-      SlicingExtraObjects( nAuxSolidsLay, vtSlicing, TYPE.AUX_SOLID, AUX_SOLIDS_CRV, AUX_SOLIDS_GRP)
-      PrepareAuxSolidsInfill( nAuxSolidsLay, vtSlicing)
-      if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( #vZSlices + 12) / nCounterTot * 100, 0) == 1 then return false end
-      
+      SlicingExtraObjects( nAuxSolidsLay, TYPE.AUX_SOLID, AUX_SOLIDS_CRV, AUX_SOLIDS_GRP)
+      if nSlicingType ~= SLICING_TYPE.MULTIPLANAR then
+         PrepareAuxSolidsInfill( nAuxSolidsLay, vSlicingDir[1])
+      end
+      if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( nCnt + 12) / nCounterTot * 100, 0) == 1 then return false end
   end
   
   EgtSetInfo( s_nPartId, KEY_FIRST_SOLID_LAY, nFirstSolidLay)
   EgtSetInfo( s_nPartId, KEY_LAST_SOLID_LAY, nLastSolidLay)
   
+   -- verifico se posso eliminare gli ultimi layer senza solido. Per poterlo fare non devono contenere setti esterni o unbounded
+   local vLayers = EgtGetNameInGroup( s_nPartId, SLICE_LAYER .. '*')
+   if #vLayers ~= nLastSolidLay then
+      -- recupero l'ultimo layer con setti esterni
+      local nLastLayerIdx
+      for i = #vLayers, nLastSolidLay + 1, - 1 do
+         if nLastLayerIdx then break end
+         local nRibsGrp = EgtGetFirstNameInGroup( vLayers[i], RIBS_GRP)
+         if nRibsGrp then
+            local vRibs = EgtGetNameInGroup( nRibsGrp, RIBS_CRV .. '*')
+            for j = 1, #vRibs do
+               local nRibType = EgtGetInfo( vRibs[j], KEY_RIBS_TYPE, 'i')
+               if nRibType == RIB_TYPE.EXTERNAL or nRibType == RIB_TYPE.UNBOUNDED then
+                  nLastLayerIdx = i
+                  break
+               end
+            end
+         end
+      end
+      if not nLastLayerIdx then
+         nLastLayerIdx = nLastSolidLay
+      end
+      -- cancello eventuali layers inutile
+      for i = #vLayers, nLastLayerIdx + 1, -1 do
+         EgtErase( vLayers[i])
+      end
+   end
+   
+   -- se multiplanare verifico strand massimo e minimo
+   if nSlicingType == SLICING_TYPE.MULTIPLANAR then
+      if not VerifyMultiPlanarStrand() then
+         return false
+      end
+   end
+   
   return true
 end

@@ -1105,10 +1361,26 @@ function CalcSlices.Exec( nPartId, nStmId)
      vtSlicing = VectorFromSpherical( 1, 45, dHorAng)
   elseif nSlicingType == SLICING_TYPE.HORIZONTAL then
      vtSlicing = X_AX()
+   elseif nSlicingType == SLICING_TYPE.MULTIPLANAR then
+      -- la direzione può cambiare da un piano all'altro
+      vtSlicing = Z_AX()
   end

-   EgtSetInfo( s_nPartId, KEY_SLICING_DIR, vtSlicing)
-   local frSlicing = Frame3d( ORIG(), vtSlicing)
+   EgtSetInfo( s_nPartId, KEY_SLICE_DIR, vtSlicing)
+   -- per compatibilità con vecchie macchine
+   EgtSetInfo( s_nPartId, 'SlicingDir', vtSlicing)
+   
+   -- recupero parametri di slicing
+   local dSliceStep = EgtGetInfo( s_nPartId, KEY_SLICE_STEP, 'd') or 10000
+   if dSliceStep < GEO.EPS_SMALL then
+      EgtOutLog( 'Warning : SliceStep is 0')
+      return
+   end
+   s_dStrand = EgtGetInfo( s_nPartId, KEY_STRAND, 'd')
+   local nMaxSlicesNbr = EgtGetInfo( s_nPartId, KEY_MAX_SLICES_NBR, 'i') or 0
+   if nMaxSlicesNbr == 0 then
+      nMaxSlicesNbr = GEO.INFINITO   -- da gestire come caso illimitato
+   end
   
   -- recupero la superficie ed eventuali setti esterni/unbounded da usare come riferimenti per quote slicing
   local vRefIds = {}
@@ -1116,6 +1388,10 @@ function CalcSlices.Exec( nPartId, nStmId)
   local nRibsLay = EgtGetFirstNameInGroup( s_nPartId, LAY_RIBS)
   local vRibsIds = EgtGetAllInGroup( nRibsLay)
   local bLimitUnbddRibs = EgtGetInfo( s_nPartId, KEY_LIMIT_UNBDD_RIBS, 'b') or false
+   if bLimitUnbddRibs and not nStmId then
+      EgtOutBox( "No solid to limit unbounded ribs!", 'Error', 'ERROR')
+      return
+   end
   for i = 1, #vRibsIds do
      if EgtGetType( vRibsIds[i]) == GDB_TY.SRF_MESH then
         local nType = ReadParam( vRibsIds[i], KEY_RIBS_TYPE, 'i', RIB_TYPE.INTERNAL)
@@ -1124,58 +1400,40 @@ function CalcSlices.Exec( nPartId, nStmId)
         end
      end
   end
-   
-   if bLimitUnbddRibs and not nStmId then
-      EgtOutBox( "No solid to limit unbounded ribs!", 'Error', 'ERROR')
-      return
-   end
-   
-   -- recupero il box
-   local b3Box = BBox3d()
-   for i = 1, #vRefIds do
-      local b3Tmp = EgtGetBBoxRef( vRefIds[i], GDB_BB.STANDARD, frSlicing)
-      b3Box:Add( b3Tmp)
-   end
-   if not b3Box or b3Box:isEmpty() then
+   if #vRefIds == 0 then
      EgtOutBox( "No part to be sliced!", 'Error', 'ERROR')
-      return
+      return false
   end
-   
-   -- Parametri di slicing
-   local dSliceStep = EgtGetInfo( s_nPartId, KEY_SLICE_STEP, 'd') or 10000
-   if dSliceStep < GEO.EPS_SMALL then
-      EgtOutLog( 'Warning : SliceStep is 0')
-      return
-   end
-   s_dStrand = EgtGetInfo( s_nPartId, KEY_STRAND, 'd')

-   local dZmin = b3Box:getMin():getZ()
-   local dZmax = b3Box:getMax():getZ()
-   local dMaxH = ComputeMaxH( vRefIds, frSlicing, dSliceStep)
-   dZmax = min( dZmax, dMaxH)
+   -- calcolo i dati dello slicing
+   local dMaxH = ComputeMaxH( vRefIds, vtSlicing, dSliceStep)
+   local vSlicingVal = {}
+   local vSlicingDir = {}
+   if nSlicingType == SLICING_TYPE.MULTIPLANAR then
+      vSlicingVal, vSlicingDir = ComputeMultiplanarSlicingData( dSliceStep, nMaxSlicesNbr)
+   else
+      vSlicingVal, vSlicingDir = ComputeSlicingData( vRefIds, vtSlicing, dSliceStep, dMaxH, nMaxSlicesNbr)
+   end
+   if not vSlicingVal then
+      return false
+   end
   
   -- Eseguo slicing
-   local nLayCnt = 1
-   local nRecalc = 0
-   local dDeltaZStart = 0.2
-   
-   local vZSlices = ComputeZSlices( dSliceStep, dZmin, dDeltaZStart, dZmax)
-
   local bOk = true
   if not nStmId then
      -- caso senza solido e solo setti
-      bOk = SlicingNoSolid( nRibsLay, vZSlices, dDeltaZStart, dZmin, frSlicing)
+      bOk = SlicingNoSolid( nRibsLay, nSlicingType, dMaxH, dSliceStep, vSlicingVal, vSlicingDir)
   else
      -- caso con solido
-      bOk = SlicingWithSolid( nStmId, vZSlices, dDeltaZStart, dZmin, frSlicing)
+      bOk = SlicingWithSolid( nStmId, nSlicingType, dMaxH, vSlicingVal, vSlicingDir)
   end
   
   -- eventuale segnalazione errori
   if bOk and #s_vErr > 0 then
      EgtOutBox( 'Slicing Error on layers :\n' .. table.concat( s_vErr, ','), 'SlicingCalc')
-    end
+   end
    
-    return bOk
+   return bOk
 end

 ---------------------------------------------------------------------
@@ -1,4 +1,4 @@
-- CalcToolPath.lua by Egaltech s.r.l. 2022/12/20
+-- CalcToolPath.lua by Egaltech s.r.l. 2026/02/16
 -- Calcolo percorsi di lavoro per Stampa 3d

 -- Tabella per definizione modulo
@@ -25,6 +25,7 @@ local s_dSpralVaseFirstDelta = 30    -- lunghezza del tratto sul primo layer che
 local function GetLayerParamsForToolPathCalc()
   local LayerParams = {}
   LayerParams.bSpiralVase = EgtGetInfo( s_nPartId, KEY_SPIRAL_VASE, 'b') or false
+   LayerParams.dSpiralVaseLen = EgtGetInfo( s_nPartId, KEY_SPIRAL_VASE_LEN, 'd') or 0
   LayerParams.dStrand = EgtGetInfo( s_nPartId, KEY_STRAND, 'd')
   LayerParams.dInnerStrand = EgtGetInfo( s_nPartId, KEY_INNER_STRAND, 'd') or LayerParams.dStrand
   if LayerParams.dInnerStrand < GEO.EPS_SMALL then LayerParams.dInnerStrand = LayerParams.dStrand end
@@ -46,7 +47,7 @@ local function GetLayerParamsForToolPathCalc()
   LayerParams.dCoastingLen = EgtGetInfo( s_nPartId, KEY_COASTING_LEN, 'd')
   LayerParams.dWipeLen = EgtGetInfo( s_nPartId, KEY_WIPE_LEN, 'd')
   LayerParams.dWipeDir = EgtGetInfo( s_nPartId, KEY_WIPE_DIR, 'd') or 0.0
-   LayerParams.vtSlicing = EgtGetInfo( s_nPartId, KEY_SLICING_DIR, 'v')
+   LayerParams.vtSlicing = EgtGetInfo( s_nPartId, KEY_SLICE_DIR, 'v')
   LayerParams.dTDiam = EgtGetInfo( s_nPartId, KEY_TOOL_DIAM, 'd')
   -- parametri infill
   LayerParams.dInfillStrand = EgtGetInfo( s_nPartId, KEY_INFILL_STRAND, 'd') or LayerParams.dStrand
@@ -64,56 +65,103 @@ local function GetLayerParamsForToolPathCalc()
   -- parametri da file ini del programma
   local sIniFile = EgtGetIniFile()
   LayerParams.dSpiralVaseInterpLen = EgtGetNumberFromIni( '3dPrinting', KEY_SPIRAL_VASE_INTERP_LEN, 100.0, sIniFile)
-   LayerParams.dSpiralVaseLen = EgtGetNumberFromIni( '3dPrinting', KEY_SPIRAL_VASE_LEN, 0.0, sIniFile)
   
   return LayerParams
 end

 ------------------------------------------------------------------
-local function ComputeToolPathBox( nTpathGrpId)
-   
-   -- calcolo il box del toolpath (escludendo i wipe)
+local function ComputeToolPathBox( nLayerId)
+   -- calcolo il box di tutti i toolpath del layer escludendo i wipe
   local b3Box = BBox3d()
-   local nEntId = EgtGetFirstInGroup( nTpathGrpId)
-   while nEntId do
-      if EgtGetInfo( nEntId, KEY_TYPE, 'i') ~= TYPE.WIPE then
-         local b3Ent = EgtGetBBoxGlob( nEntId, GDB_BB.STANDARD)
-         b3Box:Add( b3Ent)
+   local vCrvGrpIds = EgtGetNameInGroup( nLayerId, CONTOUR_GRP .. '*')
+   for i = 1, #vCrvGrpIds do
+      -- recupero tutti gli elementi del toolpath
+      local nTPathGrpId = EgtGetFirstNameInGroup( vCrvGrpIds[i], TOOLPATH_GRP)
+      local nEntId = EgtGetFirstInGroup( nTPathGrpId)
+      while nEntId do
+         if EgtGetInfo( nEntId, KEY_TYPE, 'i') ~= TYPE.WIPE then
+            local b3Ent = EgtGetBBoxGlob( nEntId, GDB_BB.STANDARD)
+            b3Box:Add( b3Ent)
+         end
+         nEntId = EgtGetNext( nEntId)
      end
-      nEntId = EgtGetNext( nEntId)
   end
-   
   return b3Box
 end

 ------------------------------------------------------------------
-local function AddZCorrection( b3Box, LayerParams)
+local function AddZCorrection( LayerParams)
   
-   local dNxy = sqrt( LayerParams.vtSlicing:getX() * LayerParams.vtSlicing:getX() + LayerParams.vtSlicing:getY() * LayerParams.vtSlicing:getY())
-   local dNz = LayerParams.vtSlicing:getZ()
-   -- altezza necessaria per lo strand
-   local dHStrand = 0.5 * LayerParams.dStrand * dNxy + LayerParams.dLayHeight * dNz
-   -- altezza necessaria per il tool
-   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() - max( dHBox, 0)
-   
-   local dCorrZ = max( 0, max( dHStrand, dHTool) - dHDisp)
-   
-   -- applico la correzione al pezzo
-   local vtMove = dCorrZ * Z_AX()
-   EgtMove( s_nPartId, vtMove, GDB_RT.GLOB)
-   EgtSetInfo( s_nPartId, KEY_MOVED_PART2, vtMove)
-   -- correggo la posizione del riferimento
-   local nFrameId = EgtGetFirstNameInGroup( s_nPartId, LAY_FRAME)
-   EgtMove( nFrameId, - vtMove, GDB_RT.GLOB)
-   
-   -- 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.."*")
+   local nSlicingType = EgtGetInfo( s_nPartId, KEY_SLICING_TYPE, 'i')
+   
+   -- 1) correzione per il pezzo
+   local dHBox = EgtGetInfo( s_nPartId, KEY_BOX_MIN_Z, 'i') or 0
+   local dCorrZ = 0
+   
+   -- se slicing multiplanare vtSlicing cambia ad ogni layer quindi la correzione deve essere calcolata sul singolo layer
+   if nSlicingType == SLICING_TYPE.MULTIPLANAR then
+      for i = 1, #vLayIds do
+         -- calcolo i valori legati a vtSlicing per il layer corrente
+         local vtSlicing = EgtGetInfo( vLayIds[i], KEY_SLICE_DIR, 'v')
+         local dNxy = sqrt( vtSlicing:getX() * vtSlicing:getX() + vtSlicing:getY() * vtSlicing:getY())
+         local dNz = vtSlicing:getZ()
+         -- altezza necessaria per lo strand non serve perchè l'altezza viene adattata lungo il percorso
+         -- altezza necessaria per il tool
+         local dHTool = LayerParams.dTDiam / 2 * dNxy
+         -- altezza disponibile
+         local b3Layer = ComputeToolPathBox( vLayIds[i])
+         local dHDisp = b3Layer:getMin():getZ() - max( dHBox, 0)
+
+         local dCurrCorrZ = max( 0, dHTool - dHDisp)
+         dCorrZ = max( dCorrZ, dCurrCorrZ)
+      end
+
+   -- se slicing standard la correzione può essere calcolata sull'intero pezzo
+   else
+      local dNxy = sqrt( LayerParams.vtSlicing:getX() * LayerParams.vtSlicing:getX() + LayerParams.vtSlicing:getY() * LayerParams.vtSlicing:getY())
+      local dNz = LayerParams.vtSlicing:getZ()
+      -- altezza necessaria per lo strand
+      local dHStrand = 0.5 * LayerParams.dStrand * dNxy + LayerParams.dLayHeight * dNz
+      -- altezza necessaria per il tool
+      local dHTool = LayerParams.dTDiam / 2 * dNxy
+      -- altezza disponibile
+      -- calcolo il box complessivo dei percorsi
+      local b3Tot = BBox3d()
+      for i = 1, #vLayIds do
+         local b3Curr = ComputeToolPathBox( vLayIds[i])
+         b3Tot:Add( b3Curr)
+      end
+      local dHDisp = b3Tot:getMin():getZ() - max( dHBox, 0)
+   
+      dCorrZ = max( 0, max( dHStrand, dHTool) - dHDisp)
+   end
+
+   -- applico la correzione al pezzo
+   if dCorrZ > GEO.EPS_SMALL then
+      local vtMove = dCorrZ * Z_AX()
+      EgtMove( s_nPartId, vtMove, GDB_RT.GLOB)
+      EgtSetInfo( s_nPartId, KEY_MOVED_PART2, vtMove)
+      -- correggo la posizione del riferimento
+      local nFrameId = EgtGetFirstNameInGroup( s_nPartId, LAY_FRAME)
+      EgtMove( nFrameId, - vtMove, GDB_RT.GLOB)
+   end
+   
+   -- 2) correzione per i wipe
+   -- altezza minima necessaria per i wipe. Se slicing multiplanare l'altezza minima per il wipe cambia ad ogni layer, altrimenti è un valore comune
+   local dHMinWipe
+   if nSlicingType ~= SLICING_TYPE.MULTIPLANAR then
+      local dNxy = sqrt( LayerParams.vtSlicing:getX() * LayerParams.vtSlicing:getX() + LayerParams.vtSlicing:getY() * LayerParams.vtSlicing:getY())
+      dHMinWipe = LayerParams.dTDiam / 2 * dNxy + max( dHBox, 0) + s_dHSafeWipe
+   end
+   
   for i = 1, #vLayIds do
+      if nSlicingType == SLICING_TYPE.MULTIPLANAR then
+         local vtSlicing = EgtGetInfo( vLayIds[i], KEY_SLICE_DIR, 'v')
+         local dNxy = sqrt( vtSlicing:getX() * vtSlicing:getX() + vtSlicing:getY() * vtSlicing:getY())
+         dHMinWipe = LayerParams.dTDiam / 2 * dNxy + max( dHBox, 0) + s_dHSafeWipe
+      end
+
      local vCrvGrps = EgtGetNameInGroup( vLayIds[i], CONTOUR_GRP.."*")
      for j = 1, #vCrvGrps do
         local nTPath = EgtGetFirstNameInGroup( vCrvGrps[j], TOOLPATH_GRP)
@@ -364,6 +412,7 @@ end
 --------------------------------------------------------------------
 local function AddLeadOut( nCrvId, LayerParams, nGrpId)

+   local vtSlicing = EgtCurveExtrusion( nCrvId, GDB_ID.ROOT)
   local ptS = EgtEP( nCrvId, GDB_ID.ROOT)
   local vtTang = EgtEV( nCrvId, GDB_ID.ROOT)
   local vtOrtho = Vector3d( vtTang)
@@ -373,7 +422,7 @@ local function AddLeadOut( nCrvId, LayerParams, nGrpId)
      dAng = 90
   end
   
-   vtOrtho:rotate( LayerParams.vtSlicing, dAng)
+   vtOrtho:rotate( vtSlicing, dAng)
   local ptE = ptS + LayerParams.dLeadOutTangDist * vtTang + LayerParams.dLeadOutOrthoDist * vtOrtho
   
   local nLeadOutCrv
@@ -385,7 +434,7 @@ local function AddLeadOut( nCrvId, LayerParams, nGrpId)
   
   if nLeadOutCrv then
      EgtRelocate( nLeadOutCrv, nCrvId, GDB_IN.AFTER)
-      EgtModifyCurveExtrusion( nLeadOutCrv, LayerParams.vtSlicing, GDB_RT.GLOB)
+      EgtModifyCurveExtrusion( nLeadOutCrv, vtSlicing, GDB_RT.GLOB)
      EgtSetInfo( nLeadOutCrv, KEY_TYPE, TYPE.LINK)
      EgtSetName( nLeadOutCrv, LEAD_OUT_CRV)
      EgtSetColor( nLeadOutCrv, EgtStdColor('GRAY'))
@@ -396,9 +445,10 @@ local function AddLeadOut( nCrvId, LayerParams, nGrpId)
 end

 --------------------------------------------------------------------
-local function AddRetraction( nCrvId, vtSlicing, dCoastingLen, dWipeLen, dWipeDir)
+local function AddRetraction( nCrvId, dCoastingLen, dWipeLen, dWipeDir)

   -- recupero i parametri per retrazione
+   local vtSlicing = EgtCurveExtrusion( nCrvId, GDB_ID.ROOT)
   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
@@ -529,22 +579,22 @@ end
 local function AddRetractionOnLastCrv( nCrvId, nTpathGrpId, LayerParams, dCoastingLen, dWipeLen, dWipeDir)
   
   if LayerParams.nLeadOutType == LEAD_TYPE.NONE then
-      AddRetraction( nCrvId, LayerParams.vtSlicing, dCoastingLen, dWipeLen, dWipeDir)
+      AddRetraction( nCrvId, dCoastingLen, dWipeLen, dWipeDir)
   else
      local nLeadOutId = EgtGetLastInGroup( nTpathGrpId)
      local dLen = EgtCurveLength( nLeadOutId)
      if dLen > dCoastingLen - 500 * GEO.EPS_SMALL then
         -- coinvolge solo la curva di lead out
         local dNewCoastingLen = EgtIf( abs( dCoastingLen - dLen) < 500 * GEO.EPS_SMALL, dLen, dCoastingLen)   -- verifico se interamente coinvolta 
-         AddRetraction( nLeadOutId, LayerParams.vtSlicing, dNewCoastingLen, dWipeLen, dWipeDir)
+         AddRetraction( nLeadOutId, dNewCoastingLen, dWipeLen, dWipeDir)
      else
         -- coinvolge parte dell'ultima shell crv
         local dNewCoastingLen = dCoastingLen - dLen
-         local nCoastingId = AddRetraction( nCrvId, LayerParams.vtSlicing, dNewCoastingLen, 0.0, dWipeDir)
+         local nCoastingId = AddRetraction( nCrvId, dNewCoastingLen, 0.0, dWipeDir)
         EgtAddCurveCompoCurve( nCoastingId, nLeadOutId)
         EgtSetInfo( nCoastingId, KEY_CLOSED_CRV, 0)
         -- wipe
-         AddRetraction( nCoastingId, LayerParams.vtSlicing, 0, dWipeLen, dWipeDir)
+         AddRetraction( nCoastingId, 0, dWipeLen, dWipeDir)
      end
   end
 end
@@ -589,7 +639,7 @@ local function CalcShellsToolPath( vEntIds, nTpathGrpId, LayerParams)
   for i = 1, #vIds - 1 do
      local nNextId = EgtGetNext( vIds[i])
      if EgtGetInfo( nNextId, KEY_TYPE, 'i') ~= TYPE.LINK then
-         AddRetraction( vIds[i], LayerParams.vtSlicing, LayerParams.dCoastingLen, LayerParams.dWipeLen, LayerParams.dWipeDir)
+         AddRetraction( vIds[i], LayerParams.dCoastingLen, LayerParams.dWipeLen, LayerParams.dWipeDir)
      end
   end
   -- sull'ultima curva gestione speciale per eventuale lead out
@@ -673,7 +723,7 @@ local function CalcExtraShellToolPath( vEntIds, nTpathGrpId, LayerParams)
            dWipeDir = LayerParams.dWipeDir
         end

-         AddRetraction( vIds[i], LayerParams.vtSlicing, dCoastingLen, dWipeLen, dWipeDir)
+         AddRetraction( vIds[i], dCoastingLen, dWipeLen, dWipeDir)
      end
   end
 end
@@ -900,7 +950,7 @@ local function CalcInfillToolPath( nInfillGrp, nTpathGrpId, LayerParams)
   for i = 1, #vIds do
      local nNext = EgtGetNext( vIds[i])
      if not nNext or EgtGetName( nNext) ~= LINK_CRV then
-         AddRetraction( vIds[i], LayerParams.vtSlicing, LayerParams.dInfillCoasting, LayerParams.dInfillWipe, LayerParams.dInfillWipeDir)
+         AddRetraction( vIds[i], LayerParams.dInfillCoasting, LayerParams.dInfillWipe, LayerParams.dInfillWipeDir)
      end
   end
 end
@@ -943,7 +993,7 @@ local function CalcSolidFillToolPath( nInfillGrp, nTpathGrpId, LayerParams)
   for i = 1, #vIds do
      local nNextId = EgtGetNext( vIds[i])
      if not nNextId or EgtGetInfo( nNextId, KEY_TYPE, 'i') ~= TYPE.LINK then
-         AddRetraction( vIds[i], LayerParams.vtSlicing, LayerParams.dInfillCoasting, LayerParams.dInfillWipe, LayerParams.dInfillWipeDir)
+         AddRetraction( vIds[i], LayerParams.dInfillCoasting, LayerParams.dInfillWipe, LayerParams.dInfillWipeDir)
      end
   end
 end
@@ -1066,7 +1116,7 @@ local function CalcAuxSolidsToolPath( nAuxSolidsGrp, nAuxSolidsPathGrp, nTpathGr
         for i = 1, #vIds do
            local nNextId = EgtGetNext( vIds[i])
            if not nNextId or EgtGetName( nNextId) ~= LINK_CRV then
-               AddRetraction( vIds[i], LayerParams.vtSlicing, dCoastingLen, dWipeLen, dWipeDir)
+               AddRetraction( vIds[i], dCoastingLen, dWipeLen, dWipeDir)
            end
         end
      end
@@ -1752,7 +1802,7 @@ local function AddRibsLeadOut( nCrv, nLoopsGrp, vtSlicing, nGrpTmp, bForceNoSoli
   
   -- se setto chiuso applico la stessa uscita delle shell
   if EgtCurveIsClosed( nCrv) then
-      return AddRetraction( nCrv, vtSlicing, dRibsLOCoasting, dRibsLOWipe, dRibsLOWipeAng)
+      return AddRetraction( nCrv, dRibsLOCoasting, dRibsLOWipe, dRibsLOWipeAng)
   end
   
   local ptE = EgtEP( nCrv, GDB_ID.ROOT)
@@ -1839,7 +1889,7 @@ local function AddRibsLeadOut( nCrv, nLoopsGrp, vtSlicing, nGrpTmp, bForceNoSoli
   end

   -- se non ho trovato curva sul bordo su cui fare il lead out aggiungo coasting e wipe come sulle shell normali
-   AddRetraction( nCrv, vtSlicing, dRibsLOCoasting, dRibsLOWipe, dRibsLOWipeAng)
+   AddRetraction( nCrv, dRibsLOCoasting, dRibsLOWipe, dRibsLOWipeAng)

 end

@@ -2010,32 +2060,299 @@ local function AddSpiralVaseLeadOut( nOldId, LayerParams)
      end
      AddRetractionOnLastCrv( nOldId, EgtGetParent( nOldId), LayerParams, LayerParams.dCoastingLen, LayerParams.dWipeLen, LayerParams.dWipeDir)
   else
-      AddRetraction( nOldId, LayerParams.vtSlicing, LayerParams.dCoastingLen, LayerParams.dWipeLen, LayerParams.dWipeDir)
+      AddRetraction( nOldId, LayerParams.dCoastingLen, LayerParams.dWipeLen, LayerParams.dWipeDir)
   end
 end

+---------------------------------------------------------------------
+local function SpiralVaseFullMultiPlanar( vLayIds, LayerParams)
+   -- la differenza in altezza viene distribuita uniformemente lungo tutto il percorso. Tale differenza non è costante per tutti i punti della curva ma varia da punto a punto
+   -- la continuità tra i layers viene risolta sul layer corrente ( uniformemente su tutto il tratto o solo nella parte iniziale di lunghezza dSpiralVaseInterpLen)
+   -- gestione speciale per i primi due layers
+   -- aggiunta passata extra finale piana alla quota dell'ultimo layer
+   
+   local nOldId, nOldPathId
+   local nRealLayer = 1
+
+   -- ciclo sui layer
+   for nIdx = 1, #vLayIds do
+      
+      -- recupero il piano di slicing
+      local vtSlicing = EgtGetInfo( vLayIds[nIdx], KEY_SLICE_DIR, 'v')
+      local ptSlicing = EgtGetInfo( vLayIds[nIdx], KEY_SLICE_POS, 'p')
+      
+      -- cerco i gruppi di contorni
+      local vCrvGrpIds = EgtGetNameInGroup( vLayIds[ nIdx], CONTOUR_GRP.."*")
+      if #vCrvGrpIds > 1 then
+         -- se più di un gruppo di curve errore
+         EgtOutBox( 'Error in spiral vase : layer ' .. tostring( nIdx) .. ' has more than one toolpath', 'ToolPathCalc')
+         return false
+      end
+      
+      -- recupero il gruppo dei percorsi
+      local nPathGrpId = EgtGetFirstNameInGroup( vCrvGrpIds[1], PATH_GRP)
+      if not nPathGrpId then
+         EgtOutBox( 'Error missing paths', 'ToolPathCalc')
+         return
+      else
+         EgtSetStatus( nPathGrpId, GDB_ST.OFF)
+      end
+      
+      -- recupero il gruppo dei percorsi utensile
+      local nTpathGrpId = EgtGetFirstNameInGroup( vCrvGrpIds[1], TOOLPATH_GRP)
+      if not nTpathGrpId then
+         nTpathGrpId = EgtGroup( vCrvGrpIds[1])
+         EgtSetName( nTpathGrpId, TOOLPATH_GRP)
+      else
+         EgtEmptyGroup( nTpathGrpId)
+      end
+
+      -- creo il percorso di lavoro :
+      local vEntIds = EgtGetAllInGroup( nPathGrpId)
+      if #vEntIds > 1 then
+         EgtOutBox( 'Error in spiral vase : layer ' .. tostring( nIdx) .. ' has more than one toolpath', 'ToolPathCalc')
+         return false
+      end
+      
+      local nNewEntId = EgtCopyGlob( vEntIds[1] or GDB_ID.NULL, nTpathGrpId, GDB_IN.LAST_SON)
+      if nNewEntId then
+
+         EgtModifyCurveExtrusion( nNewEntId, vtSlicing, GDB_RT.GLOB)
+         EgtSetInfo( nNewEntId, KEY_CRV_STRAND, LayerParams.dStrand)
+         -- eventuale inversione
+         if LayerParams.bInvert then
+            EgtInvertCurve( nNewEntId)
+            EgtSetInfo( nNewEntId, KEY_INVERTED_CRV, 1)
+         end
+         EgtSetColor( nNewEntId, EgtStdColor('GRAY'))
+         
+         -- se primo layer
+         if nRealLayer == 1 then
+            -- mi sposto dell'altezza layer
+            EgtMove( nNewEntId, LayerParams.dLayHeight * vtSlicing, GDB_RT.GLOB)
+            
+            -- eventuale lead in
+            if LayerParams.nLeadInType ~= LEAD_TYPE.NONE then
+               EgtTrimCurveStartAtLen( nNewEntId, LayerParams.dOffsetLP)
+               local nLeadInCrv = AddLeadIn( nNewEntId, LayerParams, nTpathGrpId)
+               if nLeadInCrv and LayerParams.bLinearApprox then
+                  EgtApproxCurve( nLeadInCrv, GDB_CA.LINES, LayerParams.dLinearApproxTol)
+               end
+            end
+         
+         else
+            -- recupero il piano precedente
+            local vtSlicingPrev = EgtGetInfo( vLayIds[nIdx-1], KEY_SLICE_DIR, 'v')
+            local ptSlicingPrev = EgtGetInfo( vLayIds[nIdx-1], KEY_SLICE_POS, 'p') + LayerParams.dLayHeight * vtSlicingPrev
+            local dCosAng = vtSlicing * vtSlicingPrev
+
+            -- a) continuità dei percorsi
+            local ptEPrev = EgtEP( nOldId, GDB_ID.ROOT)
+            local ptEProj = ptEPrev - ( ptEPrev - ptSlicing) * vtSlicing * vtSlicing
+
+            -- tento di creare la continuità spostando il punto ( caso in cui ptEProj poggia su nNewEntId)
+            EgtChangeClosedCurveStartPoint( nNewEntId, ptEProj, GDB_RT.GLOB)
+            if not AreSamePointApprox( ptEPrev, EgtSP( nNewEntId, GDB_ID.ROOT)) then
+               -- se i percorsi non sono in continuità modifico percorso corrente usando come guida la proiezione ortogonale del percorso precedente
+               -- sul piano corrente ( SpiralizeAlongGuide lavora con curve piane complanari)
+               
+               local nProjCrv = EgtCopyGlob( nOldPathId, nPathGrpId)
+               if LayerParams.bInvert then
+                  EgtInvertCurve( nProjCrv)
+               end
+               EgtMove( nProjCrv, LayerParams.dLayHeight * vtSlicingPrev, GDB_RT.GLOB)
+               EgtProjectCurveOnPlane( nProjCrv, ptSlicing, vtSlicing, GDB_RT.GLOB)
+               EgtChangeClosedCurveStartPoint( nProjCrv, ptEProj, GDB_RT.GLOB)
+
+               -- approssimo con tratti lineari imponendo lunghezza massima per migliorare spiralize
+               EgtApproxCurve( nProjCrv, GDB_CA.SPECIAL_LINES, 0.01, s_dSpiralVaseMaxLen)
+               EgtApproxCurve( nNewEntId, GDB_CA.SPECIAL_LINES, 0.01, s_dSpiralVaseMaxLen)
+               
+               -- 1) la differenza va distribuita su tutta la curva
+               local dLen = EgtCurveLength( nNewEntId)
+               if LayerParams.dSpiralVaseInterpLen < GEO.EPS_SMALL or LayerParams.dSpiralVaseInterpLen > dLen - GEO.EPS_SMALL then
+                  EgtSpiralizeCurveAlongGuide( nNewEntId, nProjCrv)
+               
+               -- 2) la differenza va distribuita solo su un sottotratto
+               else
+                  local dParSplit = EgtCurveParamAtLength( nNewEntId, LayerParams.dSpiralVaseInterpLen)
+                  local nNewEndId2 = EgtSplitCurveAtParam( nNewEntId, dParSplit)
+                  -- trim della curva guida
+                  local _, _, dParMinDist = EgtPointCurveDist( EgtEP( nNewEntId, GDB_ID.ROOT), nProjCrv, GDB_RT.GLOB)
+                  local nGuideId2 = EgtSplitCurveAtParam( nProjCrv, dParMinDist)
+                  EgtErase( nGuideId2)
+                  -- spiralize solo del primo pezzo e riassemblo la curva
+                  EgtSpiralizeCurveAlongGuide( nNewEntId, nProjCrv)
+                  EgtAddCurveCompoCurve( nNewEntId, nNewEndId2)
+               end
+               -- forzo il punto
+               EgtModifyCurveStartPoint( nNewEntId, ptEProj, GDB_RT.GLOB)
+               EgtErase( nProjCrv)
+            end
+            
+            -- b) spostamento verticale : alzo la curva e, per creare una transizione uniforme dal layer precedente, abbasso i suoi punti in modo graduale sul valore della distanza dal
+            -- dal layer precedente
+            EgtMove( nNewEntId, LayerParams.dLayHeight * vtSlicing, GDB_RT.GLOB)
+            
+            -- approssimazione lineare per migliorare il calcolo delle quote
+            EgtApproxCurve( nNewEntId, GDB_CA.SPECIAL_LINES, 0.01, s_dSpiralVaseMaxLen)
+            
+            if nRealLayer == 2 then
+               -- per non collassare sul layer precedente che è piatto alzo la prima metà della curva sempre di 0.5 * Delta
+               local dLen = EgtCurveLength( nNewEntId)
+               local dParMid = EgtCurveParamAtLength( nNewEntId, 0.5 * dLen)
+               EgtAddCurveCompoJoint( nNewEntId, dParMid)
+               local vDelta = {}
+               local _, dE = EgtCurveDomain( nNewEntId)
+               for dU = 0, dE - 1 do
+                  local ptCurr = EgtUP( nNewEntId, dU, GDB_ID.ROOT)
+                  local dDist = ( ( ptCurr - ptSlicingPrev) * vtSlicingPrev) / dCosAng    -- distanza dal piano precedente lungo vtSlicing
+                  local dCurrLen = EgtCurveLengthAtParam( nNewEntId, dU)
+                  if dCurrLen < 0.5 * dLen then
+                     vDelta[dU] = - dDist * 0.5
+                  else
+                     vDelta[dU] = - dDist * ( dLen - dCurrLen) / dLen
+                  end
+               end
+               
+               EgtModifyCurveStartPoint( nNewEntId, EgtSP( nNewEntId, GDB_ID.ROOT) + vDelta[0] * vtSlicing, GDB_RT.GLOB)
+               for dU = 1, dE - 1 do
+                  local ptCurr = EgtUP( nNewEntId, dU, GDB_ID.ROOT)
+                  EgtModifyCurveCompoJoint( nNewEntId, dU, ptCurr + vDelta[dU] * vtSlicing, GDB_RT.GLOB) 
+               end
+                
+               -- alzo l'ultimo tratto del layer precedente con una proiezione ortogonale "graduale" sul piano corrente
+               -- ricavo il tratto sulla curva precedente da alzare
+               local dTrimPar = EgtCurveParamAtLength( nOldId, EgtCurveLength( nOldId) - s_dSpralVaseFirstDelta)
+               local nLastId = EgtSplitCurveAtParam( nOldId, dTrimPar)
+               EgtApproxCurve( nLastId, GDB_CA.SPECIAL_LINES, 0.01, s_dSpiralVaseMaxLen)
+               -- alzo in maniera graduale
+               local _, dEOld = EgtCurveDomain( nLastId)
+               local vDeltaOld = {}
+               local dLenOld = EgtCurveLength( nLastId)
+               for dU = 0, dEOld do
+                  local dCurrLen = EgtCurveLengthAtParam( nLastId, dU)
+                  vDeltaOld[dU] = abs( vDelta[0]) * dCurrLen / dLenOld
+               end
+               for dU = 0, dEOld - 1 do
+                  local ptCurr = EgtUP( nLastId, dU, GDB_ID.ROOT)
+                  EgtModifyCurveCompoJoint( nLastId, dU, ptCurr + vDeltaOld[dU] * vtSlicing, GDB_RT.GLOB)
+               end
+               EgtModifyCurveEndPoint( nLastId, EgtEP( nLastId, GDB_ID.ROOT) + vDeltaOld[dEOld] * vtSlicing, GDB_RT.GLOB)
+               
+               -- approssimo
+               EgtApproxCurve( nLastId, GDB_CA.ARCS, s_dApproxTol)
+               if LayerParams.bLinearApprox then
+                  EgtApproxCurve( nLastId, GDB_CA.LINES, LayerParams.dLinearApproxTol)
+               end
+               EgtModifyCurveEndPoint( nLastId, EgtSP( nNewEntId, GDB_ID.ROOT), GDB_RT.GLOB)
+            
+            else
+
+               local dLen = EgtCurveLength( nNewEntId)
+               local _, dE = EgtCurveDomain( nNewEntId)
+               local vDelta = {}
+               for dU = 0, dE - 1 do
+                  local dCurrLen = EgtCurveLengthAtParam( nNewEntId, dU)
+                  local ptCurr = EgtUP( nNewEntId, dU, GDB_ID.ROOT)
+                  local dDist = ( ( ptCurr - ptSlicingPrev) * vtSlicingPrev) / dCosAng   -- distanza dal piano precedente lungo vtSlicing
+                  vDelta[dU] = - dDist * ( dLen - dCurrLen) / dLen
+               end
+               
+               EgtModifyCurveStartPoint( nNewEntId, EgtSP( nNewEntId, GDB_ID.ROOT) + vDelta[0] * vtSlicing, GDB_RT.GLOB)
+               for dU = 1, dE - 1 do
+                  local ptCurr = EgtUP( nNewEntId, dU, GDB_ID.ROOT)
+                  EgtModifyCurveCompoJoint( nNewEntId, dU, ptCurr + vDelta[dU] * vtSlicing, GDB_RT.GLOB)
+               end
+            end
+      
+            -- c) 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
+         end
+
+         local vTPathsCrvs = EgtGetAllInGroup( nTpathGrpId)
+         nOldId = vTPathsCrvs[#vTPathsCrvs]
+         nOldPathId = vEntIds[1]
+         nRealLayer = nRealLayer + 1
+      end
+
+      if EgtProcessEvents( EgtIf( PRINT, 300, 0) + nIdx / #vLayIds * 100, 0) == 1 then
+         EgtDraw()
+         return false
+      end
+   end
+
+   -- creo un un layer extra piano alla quota finale
+   local nLastLay = EgtCopyGlob( vLayIds[#vLayIds], vLayIds[#vLayIds], GDB_IN.AFTER)
+   -- aggiorno nome e numero slice
+   local nSliceNbr = EgtGetInfo( nLastLay, KEY_SLICE_NBR, 'i') + 1
+   EgtSetName( nLastLay, SLICE_LAYER .. EgtNumToString( nSliceNbr))
+   EgtSetInfo( nLastLay, KEY_SLICE_NBR, nSliceNbr)
+   -- creo la curva di toolpath alla quota finale
+   local nCrvGrpId = EgtGetFirstNameInGroup( nLastLay, CONTOUR_GRP.."*")
+   local nPathGrpId = EgtGetFirstNameInGroup( nCrvGrpId, PATH_GRP)
+   local nTpathGrpId = EgtGetFirstNameInGroup( nCrvGrpId, TOOLPATH_GRP)
+   EgtEmptyGroup( nTpathGrpId)
+   local nId = EgtCopyGlob( EgtGetFirstInGroup( nPathGrpId), nTpathGrpId)
+   local vtSlicing = EgtGetInfo( nLastLay, KEY_SLICE_DIR, 'v')
+   EgtMove( nId, LayerParams.dLayHeight * vtSlicing, GDB_RT.GLOB)
+   
+   local ptS = EgtEP( nOldId, GDB_ID.ROOT)
+   EgtChangeClosedCurveStartPoint( nId, ptS, GDB_RT.GLOB)
+   EgtModifyCurveExtrusion( nId, vtSlicing, GDB_RT.GLOB)
+   EgtSetInfo( nId, KEY_CRV_STRAND, LayerParams.dStrand)
+   if LayerParams.bInvert then
+      EgtInvertCurve( nId)
+      EgtSetInfo( nId, KEY_INVERTED_CRV, 1)
+   end
+   EgtSetColor( nId, EgtStdColor('GRAY'))
+   
+   -- approssimo
+   EgtApproxCurve( nId, GDB_CA.ARCS, s_dApproxTol)
+   if LayerParams.bLinearApprox then
+      EgtApproxCurve( nId, GDB_CA.LINES, LayerParams.dLinearApproxTol)
+   end
+   if EgtCurveIsClosed( nId) then
+      EgtChangeClosedCurveStartPoint( nId, ptS, GDB_RT.GLOB)
+   end
+
+   return true
+end
+
 ---------------------------------------------------------------------
 local function SpiralVaseFull( vLayIds, LayerParams)
   -- la differenza in altezza tra due layers viene distribuita uniformemente lungo tutto il percorso
   -- la continuità tra i layers viene risolta sul layer corrente ( uniformemente su tutto il tratto o solo nella parte iniziale di lunghezza dSpiralVaseInterpLen)
   -- gestione speciale dei primi layers per gestione dell'altezza e feed
   
+   local nSlicingType = EgtGetInfo( s_nPartId, KEY_SLICING_TYPE, 'i')
+   if nSlicingType == SLICING_TYPE.MULTIPLANAR then
+      return SpiralVaseFullMultiPlanar( vLayIds, LayerParams)
+   end
+   
   local nOldId, nOldPathId
   local nRealLayer = 1
-   local nSlicingType = EgtGetInfo( s_nPartId, KEY_SLICING_TYPE, 'i')

   -- copio ultimo layer
   if nSlicingType ~= SLICING_TYPE.DEG45_X and nSlicingType ~= SLICING_TYPE.DEG45_Y then
      local nNewLay = EgtCopyGlob( vLayIds[#vLayIds], vLayIds[#vLayIds], GDB_IN.AFTER)
      table.insert( vLayIds, nNewLay)
+      -- aggiorno nome e numero slice
+      local nSliceNbr = EgtGetInfo( nNewLay, KEY_SLICE_NBR, 'i') + 1
+      EgtSetName( nNewLay, SLICE_LAYER .. EgtNumToString( nSliceNbr))
+      EgtSetInfo( nNewLay, KEY_SLICE_NBR, nSliceNbr)
+      -- porto alla nuova quota
      EgtMove( nNewLay, LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB)
-      -- aggiorno nome e info
-      local sOldIdx = string.sub( EgtGetName( vLayIds[#vLayIds]), 6)
-      local nNewIdx = tonumber( sOldIdx) + 1
-      EgtSetName( nNewLay, SLICE_LAYER .. EgtNumToString( nNewIdx))
-      EgtSetInfo( nNewLay, KEY_SLICE_NBR, nNewIdx)
-      local dZOld = EgtGetInfo( vLayIds[#vLayIds], KEY_SLICE_Z, 'd') or 0
-      EgtSetInfo( nNewLay, KEY_SLICE_Z, dZOld + LayerParams.dLayHeight)
+      local ptSlice = EgtGetInfo( nNewLay, KEY_SLICE_POS, 'p')
+      ptSlice = ptSlice + LayerParams.dLayHeight * LayerParams.vtSlicing
+      EgtSetInfo( nNewLay, KEY_SLICE_POS, ptSlice)
   end

   -- ciclo sui layer
@@ -2228,6 +2545,194 @@ local function SpiralVaseFull( vLayIds, LayerParams)

         nRealLayer = nRealLayer + 1
      end
+     
+      if EgtProcessEvents( EgtIf( PRINT, 300, 0) + nIdx / #vLayIds * 100, 0) == 1 then
+         EgtDraw()
+         return false
+      end
+   end
+   
+   return true
+end
+
+---------------------------------------------------------------------
+local function SpiralVasePartialMultiPlanar( vLayIds, LayerParams)
+   -- la differenza in altezza tra due layers viene distribuita solo lungo il tratto finale di lunghezza dSpiralVaseLen
+   -- la continuità tra i layers viene risolta sul tratto finale del layer percedente
+   
+   local bFirst = true
+   -- individuo l'ultimo layer ( alcuni potrebbero essere vuoti)
+   local nLastLay = 1
+   for nIdx = #vLayIds, 1, -1 do
+      local nCrvGrp = EgtGetFirstNameInGroup( vLayIds[ nIdx], CONTOUR_GRP.."*")
+      local nPathGrpId = EgtGetFirstNameInGroup( nCrvGrp, PATH_GRP) or GDB_ID_NULL
+      if EgtGetGroupObjs( nPathGrpId) > 0 then
+         nLastLay = nIdx
+         break
+      end
+   end
+    
+   -- ciclo sui layer
+   local nOldId
+   for nIdx = 1, #vLayIds do
+      
+      -- piano di slicing
+      local vtSlicing = EgtGetInfo( vLayIds[nIdx], KEY_SLICE_DIR, 'v')
+      local ptSlicing = EgtGetInfo( vLayIds[nIdx], KEY_SLICE_POS, 'p')
+
+      -- cerco i gruppi di contorni
+      local vCrvGrpIds = EgtGetNameInGroup( vLayIds[ nIdx], CONTOUR_GRP.."*")
+      if #vCrvGrpIds > 1 then
+         -- se più di un gruppo di curve errore
+         EgtOutBox( 'Error in spiral vase : layer ' .. tostring( nIdx) .. ' has more than one toolpath', 'ToolPathCalc')
+         return false
+      end
+      
+      -- recupero il gruppo dei percorsi
+      local nPathGrpId = EgtGetFirstNameInGroup( vCrvGrpIds[1], PATH_GRP)
+      if not nPathGrpId then
+         EgtOutBox( 'Error missing paths', 'ToolPathCalc')
+         return false
+      else
+         EgtSetStatus( nPathGrpId, GDB_ST.OFF)
+      end
+      
+      -- recupero il gruppo dei percorsi utensile
+      local nTpathGrpId = EgtGetFirstNameInGroup( vCrvGrpIds[1], TOOLPATH_GRP)
+      if not nTpathGrpId then
+         nTpathGrpId = EgtGroup( vCrvGrpIds[1])
+         EgtSetName( nTpathGrpId, TOOLPATH_GRP)
+      else
+         EgtEmptyGroup( nTpathGrpId)
+      end
+
+      -- creo il percorso di lavoro
+      local vEntIds = EgtGetAllInGroup( nPathGrpId)
+      if #vEntIds > 1 then
+         EgtOutBox( 'Error in spiral vase : layer ' .. tostring( nIdx) .. ' has more than one toolpath', 'ToolPathCalc')
+         return false
+      end
+      
+      local nNewEntId = EgtCopyGlob( vEntIds[1] or GDB_ID.NULL, nTpathGrpId, GDB_IN.LAST_SON)
+      if nNewEntId then
+         
+         EgtModifyCurveExtrusion( nNewEntId, vtSlicing, GDB_RT.GLOB)
+         EgtSetInfo( nNewEntId, KEY_CRV_STRAND, LayerParams.dStrand)
+         if LayerParams.bInvert then
+            EgtInvertCurve( nNewEntId)
+            EgtSetInfo( nNewEntId, KEY_INVERTED_CRV, 1)
+         end
+         EgtSetColor( nNewEntId, EgtStdColor('GRAY'))
+
+         -- sistemo il tratto finale del percorso precedente
+         if not bFirst then
+            
+            local ptSOld = EgtSP( nOldId, GDB_ID.ROOT)
+            local ptEOld = EgtEP( nOldId, GDB_ID.ROOT)
+            -- proiezione ortogonale dei punti sul piano di slicing corrente
+            local ptSProj = ptSOld - ( ( ptSOld - ptSlicing) * vtSlicing) * vtSlicing
+            local ptEProj = ptEOld - ( ( ptEOld - ptSlicing) * vtSlicing) * vtSlicing
+
+            -- a) continuità tra i layers 
+            -- modifico il punto iniziale corrente per avvicinarmi il più possibile alla fine del percorso precedente
+            EgtChangeClosedCurveStartPoint( nNewEntId, ptEProj, GDB_RT.GLOB)
+            local ptCurrStart = EgtSP( nNewEntId, GDB_ID.ROOT)
+            if not AreSamePointApprox( ptEProj, ptCurrStart) then
+               -- se i percorsi non sono in continuità modifico il tratto finale del percorso precedente in modo da farlo arrivare sul punto di inizio del percorso corrente
+               -- usando come guida la proiezione obliqua del percorso corrente sul piano precedente ( SpiralizeAlongGuide lavora con curve piane complanari)
+               
+               local nProjCrv = EgtCopyGlob( vEntIds[1], nPathGrpId)
+               if LayerParams.bInvert then
+                  EgtInvertCurve( nProjCrv)
+               end
+               -- conservo solo il sottotratto corrispondente a nOldId
+               local _, _, dStartGuide = EgtPointCurveDist( ptSProj, nProjCrv, GDB_ID.ROOT)
+               local _, _, dEndGuide = EgtPointCurveDist( ptEProj, nProjCrv, GDB_ID.ROOT)
+               EgtTrimCurveStartEndAtParam( nProjCrv, dStartGuide, dEndGuide)
+               -- proiezione sul piano precedente ( ptSlicingPrev, vtSlicingPrev) lungo vtSlicing
+               local vtSlicingPrev = EgtGetInfo( vLayIds[nIdx-1], KEY_SLICE_DIR, 'v')
+               local ptSlicingPrev = EgtGetInfo( vLayIds[nIdx-1], KEY_SLICE_POS, 'p') + LayerParams.dLayHeight * vtSlicingPrev
+               local _, dE = EgtCurveDomain( nProjCrv)
+               for dU = 0, dE do
+                  local pt = EgtUP( nProjCrv, dU, GDB_ID.ROOT)
+                  local dDist = ( pt - ptSlicingPrev) * vtSlicingPrev / ( vtSlicingPrev * vtSlicing)
+                  EgtModifyCurveCompoJoint( nProjCrv, dU, pt - dDist * vtSlicing, GDB_RT.GLOB)
+               end
+               -- approssimazione dei tratti per migliorare la qualità dello spiralize
+               EgtApproxCurve( nProjCrv, GDB_CA.SPECIAL_LINES, 0.01, s_dSpiralVaseMaxLen)
+               EgtApproxCurve( nOldId, GDB_CA.SPECIAL_LINES, 0.01, s_dSpiralVaseMaxLen)
+               -- spiralize
+               EgtInvertCurve( nProjCrv)
+               EgtInvertCurve( nOldId)
+               EgtSpiralizeCurveAlongGuide( nOldId, nProjCrv)
+               EgtInvertCurve( nOldId)
+               
+               EgtErase( nProjCrv)
+            end
+
+            -- b) proiezione ortogonale graduale sul piano corrente
+            -- delta che va applicato ( è la distanza ortogonale del punto finale di nOldId dal piano del toolpath corrente)
+            local dDist = ( EgtEP( nOldId, GDB_ID.ROOT) - ( ptSlicing + LayerParams.dLayHeight * vtSlicing)) * vtSlicing
+            EgtApproxCurve( nOldId, GDB_CA.SPECIAL_LINES, 0.01, s_dSpiralVaseMaxLen)
+            local _, dE = EgtCurveDomain( nOldId)
+            local vDelta = {}
+            local dLen = EgtCurveLength( nOldId)
+            for dU = 0, dE do
+               local dCurrLen = EgtCurveLengthAtParam( nOldId, dU)
+               vDelta[dU] = abs( dDist) * dCurrLen / dLen
+            end
+            for dU = 0, dE do
+               local ptCurr = EgtUP( nOldId, dU, GDB_ID.ROOT)
+               EgtModifyCurveCompoJoint( nOldId, dU, ptCurr + vDelta[dU] * vtSlicing, GDB_RT.GLOB)
+            end
+            
+            -- c) approssimazione della curva
+            EgtApproxCurve( nOldId, GDB_CA.ARCS, s_dApproxTol)
+            if LayerParams.bLinearApprox then
+               EgtApproxCurve( nOldId, GDB_CA.LINES, LayerParams.dLinearApproxTol)
+            end
+            -- forzo punti per garantire continuità
+            EgtModifyCurveStartPoint( nOldId, ptSOld, GDB_RT.GLOB)
+            EgtModifyCurveEndPoint( nOldId, ptCurrStart + LayerParams.dLayHeight * vtSlicing, GDB_RT.GLOB)
+         end
+
+         -- spostamento dell'altezza layer
+         local vtMove = LayerParams.dLayHeight * vtSlicing
+         EgtMove( nNewEntId, vtMove, GDB_RT.GLOB)
+         EgtCopyGlob( nNewEntId, nPathGrpId)
+         
+         -- approssimazione
+         if LayerParams.bLinearApprox then
+            local ptS = EgtSP( nNewEntId, GDB_ID.ROOT)
+            EgtApproxCurve( nNewEntId, GDB_CA.LINES, LayerParams.dLinearApproxTol)
+            if EgtCurveIsClosed( nNewEntId) then
+               EgtChangeClosedCurveStartPoint( nNewEntId, ptS, GDB_RT.GLOB)
+            end
+         end
+         
+         -- eventuale lead in
+         if bFirst then
+            bFirst = false
+            if LayerParams.nLeadInType ~= LEAD_TYPE.NONE then
+               EgtTrimCurveStartAtLen( nNewEntId, LayerParams.dOffsetLP)
+               local nLeadInCrv = AddLeadIn( nNewEntId, LayerParams, nTpathGrpId)
+               if nLeadInCrv and LayerParams.bLinearApprox then
+                  EgtApproxCurve( nLeadInCrv, GDB_CA.LINES, LayerParams.dLinearApproxTol)
+               end
+            end
+         end
+
+         -- separo l'ultimo tratto che farà da collegamento con il layer successivo
+         if nIdx ~= nLastLay then
+            local dTrimLen = EgtCurveLength( nNewEntId) - LayerParams.dSpiralVaseLen
+            if dTrimLen < GEO.EPS_SMALL then
+               -- se lunghezza di trim maggiore delle dimensioni forzo un valore accettabile
+               dTrimLen = 0.5 * EgtCurveLength( nNewEntId)
+            end
+            local dTrimPar = EgtCurveParamAtLength( nNewEntId, dTrimLen)
+            nOldId = EgtSplitCurveAtParam( nNewEntId, dTrimPar)
+         end
+      end
      
      if EgtProcessEvents( EgtIf( PRINT, 300, 0) + nIdx / #vLayIds * 100, 0) == 1 then
         EgtDraw()
@@ -2243,6 +2748,11 @@ local function SpiralVasePartial( vLayIds, LayerParams)
   -- la differenza in altezza tra due layers viene distribuita solo lungo il tratto finale di lunghezza dSpiralVaseLen
   -- la continuità tra i layers viene risolta sul tratto finale del layer percedente
   
+   local nSlicingType = EgtGetInfo( s_nPartId, KEY_SLICING_TYPE, 'i')
+   if nSlicingType == SLICING_TYPE.MULTIPLANAR then
+      return SpiralVasePartialMultiPlanar( vLayIds, LayerParams)
+   end
+   
   local bFirst = true
   -- individuo l'ultimo layer ( alcuni potrebbero essere vuoti)
   local nLastLay = 1
@@ -2409,23 +2919,16 @@ local function SpiralVase( vLayIds, LayerParams)
         return false
      end
   end
-      
-   -- calcolo il box dei percorsi
-   local b3Tot = BBox3d()
-   local nLastTPath
-   for i = 1, #vLayIds do
-      local vCrvGrpIds = EgtGetNameInGroup( vLayIds[i], CONTOUR_GRP.."*")
-      local nTpathGrpId = EgtGetFirstNameInGroup( vCrvGrpIds[1], TOOLPATH_GRP)
-      nLastTPath = EgtGetLastInGroup( nTpathGrpId)
-      local b3Box = ComputeToolPathBox( nTpathGrpId)
-      b3Tot:Add( b3Box)
-   end
-   
+
   -- aggiungo uscita, coasting e wipe su ultima curva
+   local nLastLayer = EgtGetLastNameInGroup( s_nPartId, SLICE_LAYER .. '*')
+   local vCrvGrpIds = EgtGetNameInGroup( nLastLayer, CONTOUR_GRP.."*")
+   local nTpathGrpId = EgtGetFirstNameInGroup( vCrvGrpIds[1], TOOLPATH_GRP)
+   local nLastTPath = EgtGetLastInGroup( nTpathGrpId)
   AddSpiralVaseLeadOut( nLastTPath, LayerParams)
   
   -- correzione in z
-   AddZCorrection( b3Tot, LayerParams)
+   AddZCorrection( LayerParams)

   return true
 end
@@ -2444,19 +2947,23 @@ function CalcToolPath.Exec( nPartId)

   -- recupero i parametri per calcolo dei toolpath
   local LayerParams = GetLayerParamsForToolPathCalc()
+   local nSlicingType = EgtGetInfo( s_nPartId, KEY_SLICING_TYPE, 'i')
   
   -- caso spiral vase
   if LayerParams.bSpiralVase then
      return SpiralVase( vLayIds, LayerParams)
   end

-   local b3Tot = BBox3d() -- box dei toolpath
   local nLayCnt = 1
   -- Ciclo sui layer
   for nIdx = 1, #vLayIds do
      
      s_nCurrIdx = nIdx
-      
+
+      if nSlicingType == SLICING_TYPE.MULTIPLANAR then
+         LayerParams.vtSlicing = EgtGetInfo( vLayIds[nIdx], KEY_SLICE_DIR, 'v')
+      end
+
      -- scorro tutti i gruppi di contorni
      local nCrvGrpId = EgtGetFirstNameInGroup( vLayIds[ nIdx], CONTOUR_GRP.."*")
      while nCrvGrpId do
@@ -2532,10 +3039,6 @@ function CalcToolPath.Exec( nPartId)
            end
         end
         
-         -- aggiorno il box dei toolpath
-         local b3Box = ComputeToolPathBox( nTpathGrpId)
-         b3Tot:Add( b3Box)
-         
         -- verifico non sia vuoto per aggiornare il numero di layers
         if EgtGetFirstInGroup( nTpathGrpId) then
            nLayCnt = nIdx
@@ -2561,7 +3064,7 @@ function CalcToolPath.Exec( nPartId)
   end
   
   -- correzione in z
-   AddZCorrection( b3Tot, LayerParams)
+   AddZCorrection( LayerParams)
   
   -- setto info con numero di layers effettivi
   EgtSetInfo( nPartId, KEY_LAYER_CNT, nLayCnt)
@@ -15,13 +15,16 @@ local AMD = require( 'AddManData')
 --------------------------------------------------------------------
 local s_dTol = 0.1
 local s_nSimplifiedSection = 0
+local s_dMultiPlanarH = 0
+local s_dColorFactor = 0.9
+local s_nPartId

 ---------------------------------------------------------------------
 local function GetLayerParamsForSolidCalc( nPartId)
   local LayerParams = {}
   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.vtSlicing = EgtGetInfo( nPartId, KEY_SLICE_DIR, 'v') or EgtGetInfo( nPartId, 'SlicingDir', 'v')
   LayerParams.dStrand = EgtGetInfo( nPartId, KEY_STRAND, 'd')
   return LayerParams
 end
@@ -39,10 +42,10 @@ local function CalcSectionParams( dStrand, dH)
 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)
+local function CreateStandardSolid( nCrvId, nSolidGrp, dH, dStrand)
+   
+   local dBevelX, dBevelY = CalcSectionParams( dStrand, dH)
+   local nSrfId = EgtSurfTmRectSwept( nSolidGrp, dStrand, dH, dBevelX, dBevelY, nCrvId, GDB_RSCT.BEVEL, s_dTol)
   return nSrfId
 end

@@ -105,9 +108,7 @@ local function CreateSpiralVaseCap( nSectId, vtDir, nSolidGrp)
   local nCapSrf = EgtSurfTmByTriangles( nSolidGrp, vSurfs)
   
   -- cancello curve di costruzione
-   for i = 1, #vCrvs do
-      EgtErase( vCrvs[i])
-   end
+   EgtErase( vCrvs)
   EgtErase( nCrvTop)
   EgtErase( nCrvBottom)
   
@@ -115,10 +116,10 @@ local function CreateSpiralVaseCap( nSectId, vtDir, nSolidGrp)
 end

 -------------------------------------------------------------------------------
-local function CreateSpiralVaseSolid( nCrvId, nSolidGrp, LayerParams, dStrand)
+local function CreateSpiralVaseSolid( nCrvId, nSolidGrp, vtSlicing, dH, dStrand)
   
   -- gruppo temporaneo per conti 
-   local nGrpTmp = EgtGroup( nSolidGrp, Frame3d( ORIG(), LayerParams.vtSlicing, GDB_RT.GLOB))
+   local nGrpTmp = EgtGroup( nSolidGrp, Frame3d( ORIG(), vtSlicing, GDB_RT.GLOB))
   
   -- accorcio leggermente la curva per evitare problemi di inconsistent orientation nel solido
   local dLen = EgtCurveLength( nCrvId)
@@ -128,28 +129,28 @@ local function CreateSpiralVaseSolid( nCrvId, nSolidGrp, LayerParams, dStrand)
   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
+   local dDelta = ( ptE - ptS) * vtSlicing
   -- se non è vero spiral vase, chiamo funzione standard
   if dDelta < GEO.EPS_SMALL then
      EgtErase( nGrpTmp)
-      return CreateStandardSolid( nCrvId, nSolidGrp, LayerParams, dStrand)
+      return CreateStandardSolid( nCrvId, nSolidGrp, dH, dStrand)
   end
   
   -- appiattisco la curva
   local nCrvCopy = EgtCopyGlob( nCrvId, nGrpTmp)
-   EgtModifyCurveExtrusion( nCrvCopy, LayerParams.vtSlicing, GDB_RT.GLOB)
-   EgtProjectCurveOnPlane( nCrvCopy, ptS, LayerParams.vtSlicing, GDB_RT.GLOB)
+   EgtModifyCurveExtrusion( nCrvCopy, vtSlicing, GDB_RT.GLOB)
+   EgtProjectCurveOnPlane( nCrvCopy, ptS, vtSlicing, GDB_RT.GLOB)
   EgtMergeCurvesInCurveCompo( nCrvCopy)
   EgtChangeClosedCurveStartPoint( nCrvCopy, ptS, GDB_RT.GLOB)
  
   -- calcolo la sezione iniziale
   local vtDir = EgtSV( nCrvCopy, GDB_ID.ROOT)
-   vtDir:rotate( LayerParams.vtSlicing, 90)
-   local nSectId = CreateSection( ptS, vtDir, dStrand, LayerParams.dLayHeight, LayerParams.vtSlicing, nGrpTmp)
+   vtDir:rotate( vtSlicing, 90)
+   local nSectId = CreateSection( ptS, vtDir, dStrand, dH, vtSlicing, nGrpTmp)
   -- creo la sezione finale
   local vtDir2 = EgtEV( nCrvCopy, GDB_ID.ROOT)
-   vtDir2:rotate( LayerParams.vtSlicing, 90)
-   local nSectE = CreateSection( ptE, vtDir2, dStrand, LayerParams.dLayHeight, LayerParams.vtSlicing, nGrpTmp)
+   vtDir2:rotate( vtSlicing, 90)
+   local nSectE = CreateSection( ptE, vtDir2, dStrand, dH, vtSlicing, nGrpTmp)
   
   -- creo il solido aperto (tubo)
   local vCrvs = {}
@@ -162,8 +163,8 @@ local function CreateSpiralVaseSolid( nCrvId, nSolidGrp, LayerParams, dStrand)
         EgtErase( nGrpTmp)
         return nil
      end
-      local dMove = ( ptRef - ptS) * LayerParams.vtSlicing
-      EgtMove( vCrvs[i+1], LayerParams.vtSlicing * dMove, GDB_RT.GLOB)
+      local dMove = ( ptRef - ptS) * vtSlicing
+      EgtMove( vCrvs[i+1], vtSlicing * dMove, GDB_RT.GLOB)
      EgtSpiralizeCurveAlongExtrusion( vCrvs[i+1], dDelta)

      -- modifico la curva per congiungerla ai caps
@@ -186,32 +187,32 @@ local function CreateSpiralVaseSolid( nCrvId, nSolidGrp, LayerParams, dStrand)
         return nil
      end
   end
-
-   local nSrfId = EgtSurfTmByTriangles( nSolidGrp, vSurfs)
-  
+   
   -- creazione del mezzo disco iniziale
-   local nCap1 = CreateSpiralVaseCap( nSectId, - vtS, nSolidGrp)
+   vSurfs[#vCrvs] = CreateSpiralVaseCap( nSectId, - vtS, nSolidGrp)
   -- creazione del mezzo disco finale
-   local nCap2 = CreateSpiralVaseCap( nSectE, vtE, nSolidGrp)
-   EgtInvertSurf( nCap2)
+   vSurfs[#vCrvs+1] = CreateSpiralVaseCap( nSectE, vtE, nSolidGrp)
+   EgtInvertSurf( vSurfs[#vCrvs+1])

+   local nSolidId = EgtSurfTmByTriangles( nSolidGrp, vSurfs)
+   
   -- cancello le curve usate per la costruzione
   EgtErase( nGrpTmp)

-   return EgtSurfTmByTriangles( nSolidGrp, { nSrfId, nCap1, nCap2})
+   return nSolidId
 end

 --------------------------------------------------------------------------------------
-local function CreateSolid( nCrvId, nSolidGrp, LayerParams, dStrand)
+local function CreateSolid( nCrvId, nSolidGrp, LayerParams, dH, dStrand)
   if LayerParams.bSpiralVase then
-      return CreateSpiralVaseSolid( nCrvId, nSolidGrp, LayerParams, dStrand)
+      return CreateSpiralVaseSolid( nCrvId, nSolidGrp, LayerParams.vtSlicing, dH, dStrand)
   else
-      return CreateStandardSolid( nCrvId, nSolidGrp, LayerParams, dStrand)
+      return CreateStandardSolid( nCrvId, nSolidGrp, dH, dStrand)
   end
 end

 ---------------------------------------------------------------------
-local function CreateDirectionArrow( nCrvId, nSolidGrp, vtSlicing, dStrand, nLayer)
+local function CreateDirectionArrow( nCrvId, nSolidGrp, vtSlicing, dStrand, nSliceNbr)
   
   local ptS = EgtSP( nCrvId, GDB_RT.GLOB)
   local vtS = EgtSV( nCrvId, GDB_RT.GLOB)
@@ -233,7 +234,7 @@ local function CreateDirectionArrow( nCrvId, nSolidGrp, vtSlicing, dStrand, nLay
   local nSrf = EgtSurfFlatRegion( nSolidGrp, { nCompo})
   EgtErase( nCompo)
   EgtSetColor( nSrf, RED())
-   EgtSetInfo( nSrf, KEY_SLICE_NBR, nLayer)
+   EgtSetInfo( nSrf, KEY_SLICE_NBR, nSliceNbr)
   EgtSetStatus( nSrf, GDB_ST.OFF)
   EgtSetMode( nSrf, GDB_MD.HIDDEN)
   EgtSetName( nSrf, DIR_ARROW)
@@ -241,10 +242,10 @@ local function CreateDirectionArrow( nCrvId, nSolidGrp, vtSlicing, dStrand, nLay
 end

 ---------------------------------------------------------------------
-local function CreateRecursiveSolid( nCrvId, vSurfs, nSolidGrp, LayerParams, dStrand)
+local function CreateRecursiveSolid( nCrvId, vSurfs, nSolidGrp, LayerParams, dH, dStrand)

   -- tento la creazione del solido
-   local nSurf = CreateSolid( nCrvId, nSolidGrp, LayerParams, dStrand - 50 * GEO.EPS_SMALL)
+   local nSurf = CreateSolid( nCrvId, nSolidGrp, LayerParams, dH, dStrand - 50 * GEO.EPS_SMALL)
   if nSurf then
      EgtErase( nCrvId)
      table.insert( vSurfs, nSurf)
@@ -264,16 +265,66 @@ local function CreateRecursiveSolid( nCrvId, vSurfs, nSolidGrp, LayerParams, dSt
         EgtErase( nCrvId)
         return false
      end
-      local bOk = CreateRecursiveSolid( nCrvId, vSurfs, nSolidGrp, LayerParams, dStrand)
-      bOk = bOk and CreateRecursiveSolid( nCrvSplit, vSurfs, nSolidGrp, LayerParams, dStrand)
+      local bOk = CreateRecursiveSolid( nCrvId, vSurfs, nSolidGrp, LayerParams, dH, dStrand)
+      bOk = bOk and CreateRecursiveSolid( nCrvSplit, vSurfs, nSolidGrp, LayerParams, dH, dStrand)
      return bOk
   end
 end

 ---------------------------------------------------------------------
-local function CreateSolidFromCurve( nCrvId, nSolidGrp, LayerParams, nLayer)
+local function CalcSolidGuides( nCrvId, dStrand, nSolidGrp)
+   
+   -- suddivido la curva in modo opportuno
+   local nCopyId = EgtCopyGlob( nCrvId, nSolidGrp)
+   local nId
+   local nParts = 1
+   local LEN_REF = 100
+   local bZigZagInfill = EgtGetInfo( nCopyId, KEY_ZIG_ZAG_INFILL, 'b') or false
+   if bZigZagInfill then
+      nId, nParts = EgtSplitCurveAtCorners( nCopyId, 80)
+   else
+      local dLen = EgtCurveLength( nCrvId)
+      if dLen > LEN_REF and nType ~= TYPE.LINK and nType ~= TYPE.COASTING then
+         nParts = EgtClamp( floor( dLen / LEN_REF), 1, 10)
+      end
+      nId = EgtSplitCurve( nCopyId, nParts)
+   end
+   
+   if not nId then return end
+   
+   -- verifico in modo euristico se la curva torna indietro su se stessa come se fossero due shell collegate ( verifico se è presente un sottotratto di lunghezza 
+   -- circa pari allo strand non in tangenza con i sottotratti vicini). Nel caso la spezzo per evitare problemi nel calcolo di solidi swept
+   local vGuideIds = {}
+   for nInd = 0, nParts - 1 do
+      local nGuideId = nId + nInd
+      table.insert( vGuideIds, nGuideId)
+      if EgtGetType( nGuideId) == GDB_TY.CRV_COMPO then
+         local _, dE = EgtCurveDomain( nGuideId)
+         for dU = 1, dE - 2 do
+            local dLen = EgtCurveCompoLength( nGuideId, dU)
+            if abs( dLen - dStrand) < 500 * GEO.EPS_SMALL then
+               -- verifico gli angoli
+               local vtPrev = EgtUV( nGuideId, dU, -1, GDB_ID.ROOT)
+               local vtCurrS = EgtUV( nGuideId, dU, 1, GDB_ID.ROOT)
+               local vtCurrE = EgtUV( nGuideId, dU + 1, -1, GDB_ID.ROOT)
+               local vtNext = EgtUV( nGuideId, dU + 1, 1, GDB_ID.ROOT)
+               if vtPrev * vtCurrS < GEO.EPS_SMALL or vtCurrE * vtNext < GEO.EPS_SMALL then
+                  local nNewId = EgtSplitCurveAtParam( nGuideId, dU + 0.5)
+                  table.insert( vGuideIds, nNewId)
+                  break
+               end
+            end
+         end
+      end
+   end
+   
+   return vGuideIds
+end
+
+---------------------------------------------------------------------
+local function CreateSolidFromCurve( nCrvId, nSolidGrp, LayerParams, nSliceNbr, dLayerH)
  
-   local nType = EgtGetInfo( nCrvId, KEY_TYPE, 'i')   
+   local nType = EgtGetInfo( nCrvId, KEY_TYPE, 'i')
   if nType == TYPE.WIPE then return true end 
   -- scelta del colore
   local Color = EgtStdColor( 'GRAY')
@@ -292,52 +343,48 @@ 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') or LayerParams.dStrand
   
-   local nCopyId = EgtCopyGlob( nCrvId, nSolidGrp)
-   local nId = GDB_ID.NULL
-   local nParts = 1
-   local LEN_REF = 100
-   local bZigZagInfill = EgtGetInfo( nCopyId, KEY_ZIG_ZAG_INFILL, 'b') or false
-   if bZigZagInfill then
-      nId, nParts = EgtSplitCurveAtCorners( nCopyId, 80)
-   else
-      local dLen = EgtCurveLength( nCrvId)
-      if dLen > LEN_REF and nType ~= TYPE.LINK and nType ~= TYPE.COASTING then
-         nParts = EgtClamp( floor( dLen / LEN_REF), 1, 10)
-      end
-      nId = EgtSplitCurve( nCopyId, nParts)
+   if s_nSimplifiedSection == 1 and nSliceNbr % 2 == 0 then
+      Color = Color3d( s_dColorFactor * Color:getRed(), s_dColorFactor * Color:getGreen(), s_dColorFactor * Color:getBlue())
   end
   
+   -- parametri della passata
+   local dStrand = EgtGetInfo( nCrvId, KEY_CRV_STRAND, 'd') or LayerParams.dStrand
+   local dH = dLayerH or LayerParams.dLayHeight
+
   -- 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)
+      CreateDirectionArrow( nCrvId, nSolidGrp, LayerParams.vtSlicing, dStrand, nSliceNbr)
   end
   
-   if nId == GDB_ID.NULL then return false end
+   -- spezzo la curva guida in diversi sottotratti per i quali calcolare i solidi
+   local vGuideIds = CalcSolidGuides( nCrvId, dStrand, nSolidGrp)
+   if not vGuideIds then
+      return false
+   end
+
   local bOk = true
-   for nInd = 0, nParts - 1 do
-      local nGuideId = nId + nInd
-      local nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams, dStrand - 5 * GEO.EPS_SMALL)
+   for i = 1, #vGuideIds do
+      local nSrfId = CreateSolid( vGuideIds[i], nSolidGrp, LayerParams, dH, dStrand - 5 * GEO.EPS_SMALL)
      if not nSrfId then
-         EgtOutLog( 'Warning : CreateSolid failed '.. '(layer '..tostring( nLayer)..', curve '..tostring( nCrvId)..')')
+         EgtOutLog( 'Warning : CreateSolid failed '.. '(layer '..tostring( nSliceNbr)..', curve '..tostring( nCrvId)..')')
         -- ritento con strand più piccolo
-         nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams, dStrand - 50 * GEO.EPS_SMALL)
+         nSrfId = CreateSolid( vGuideIds[i], nSolidGrp, LayerParams, dH, dStrand - 50 * GEO.EPS_SMALL)
         
         if not nSrfId then
-            EgtOutLog( 'Warning : CreateSolid_1 failed '.. '(layer '..tostring( nLayer)..', curve '..tostring( nCrvId)..')')
+            EgtOutLog( 'Warning : CreateSolid_1 failed '.. '(layer '..tostring( nSliceNbr)..', 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 i < #vGuideIds then
+               local nCopyId = EgtCopy( vGuideIds[i] + 1, vGuideIds[i], 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)
+                  local bOk2 = EgtAddCurveCompoCurve( vGuideIds[i], nCopyId)
+                  local bOk3 = EgtTrimCurveStartAtLen( vGuideIds[i] + 1, LEN_TRIM)
+                  nSrfId = CreateSolid( vGuideIds[i], nSolidGrp, LayerParams, dH, dStrand - 5 * GEO.EPS_SMALL)
                  if not nSrfId then
-                     nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams, dStrand - 50 * GEO.EPS_SMALL)
+                     nSrfId = CreateSolid( vGuideIds[i], nSolidGrp, LayerParams, dH, dStrand - 50 * GEO.EPS_SMALL)
                  end
               end
            end
@@ -347,12 +394,12 @@ local function CreateSolidFromCurve( nCrvId, nSolidGrp, LayerParams, nLayer)
         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)
+            EgtRelocateGlob( vGuideIds[i], nGrp)
+            EgtApproxCurve( vGuideIds[i], GDB_CA.LINES, 100 * GEO.EPS_SMALL)
+            EgtRelocateGlob( vGuideIds[i], nSolidGrp)

            local vSurfs = {}
-            local bOk = CreateRecursiveSolid( nGuideId, vSurfs, nSolidGrp, LayerParams, dStrand)
+            local bOk = CreateRecursiveSolid( vGuideIds[i], vSurfs, nSolidGrp, LayerParams, dH, dStrand)
            if #vSurfs > 0 then
               nSrfId = EgtSurfTmByTriangles( nSolidGrp, vSurfs)
            end
@@ -366,17 +413,381 @@ local function CreateSolidFromCurve( nCrvId, nSolidGrp, LayerParams, nLayer)
      if nSrfId then
         EgtSetColor( nSrfId, Color)
         EgtSetInfo( nSrfId, KEY_TYPE, nType)
-         EgtSetInfo( nSrfId, KEY_SLICE_NBR, nLayer)
+         EgtSetInfo( nSrfId, KEY_SLICE_NBR, nSliceNbr)
      else
         bOk = false
         EgtOutLog( 'Warning : CreateSolid_Sewing failed')
      end
-      EgtErase( nGuideId)
-   end 
-
+      EgtErase( vGuideIds[i])
+   end
+   
   return bOk
 end

+--------------------------------------------------------------------
+------------------------- MULTIPLANAR ------------------------------
+--------------------------------------------------------------------
+local function CreateMultiPlanarSolids( vIds, nSolidGrpId, LayerParams, nLayerId)
+   
+   -- creo solidi standard con spessore massimo ammesso ( tranne nel primo layer che viene fatto ad altezza costante)
+   local nSliceNbr = EgtGetInfo( nLayerId, KEY_SLICE_NBR, 'i')
+   local dH = EgtIf( nSliceNbr == 1, LayerParams.dLayHeight, s_dMultiPlanarH)
+   for i = 1, #vIds do
+      CreateSolidFromCurve( vIds[i], nSolidGrpId, LayerParams, nSliceNbr, dH)
+   end
+   
+   -- deformo i solidi per rispettare l'altezza reale della passata
+   if nSliceNbr > 1 then
+      local ptSlicing = EgtGetInfo( nLayerId, KEY_SLICE_POS, 'p') + LayerParams.vtSlicing * LayerParams.dLayHeight
+      local nPrevLayerId = EgtGetPrev( nLayerId)
+      local vtSlicingPrev = EgtGetInfo( nPrevLayerId, KEY_SLICE_DIR, 'v') 
+      local ptSlicingPrev = EgtGetInfo( nPrevLayerId, KEY_SLICE_POS, 'p') + vtSlicingPrev * LayerParams.dLayHeight
+      local dCosAng = vtSlicingPrev * LayerParams.vtSlicing
+      
+      local vSolids = EgtGetAllInGroup( nSolidGrpId)
+      for i = 1, #vSolids do
+         local nVertexCnt = EgtSurfTmVertexCount( vSolids[i])
+         for j = 0, nVertexCnt - 1 do
+            local ptVertex = EgtSurfTmGetVertex( vSolids[i], j, GDB_RT.GLOB)
+            -- distanza dal piano di slicing corrente e precedente lungo vtSlicing
+            local dDistCurr = abs( ( ptVertex - ptSlicing) * LayerParams.vtSlicing)
+            local dDistPrev = ( ptVertex - ptSlicingPrev) * vtSlicingPrev / dCosAng
+            -- calcolo la nuova posizione sapendo che l'altezza dello strand passa da s_dMultiPlanarH a dNewH
+            local dNewH = dDistCurr + dDistPrev
+            local dDelta = dDistCurr - dDistCurr * dNewH / s_dMultiPlanarH
+            local ptNew = ptVertex + dDelta * LayerParams.vtSlicing
+            EgtSurfTmMoveVertex( vSolids[i], j, ptNew, GDB_RT.GLOB, ( j == nVertexCnt - 1))
+         end
+      end
+   end
+end
+
+---------------------------------------------------------------------
+local function CreatePartialSpiralVaseMultiPlanarSolids( vIds, nSolidGrpId, LayerParams, nLayerId)
+   
+   -- 1) le prime curve sono solidi multiplanari standard
+   for i = 1, #vIds - 1 do
+      CreateMultiPlanarSolids( { vIds[i]}, nSolidGrpId, LayerParams, nLayerId)
+   end
+   
+   -- 2) l'ultima curva è il tratto che si alza fino al layer successivo
+   local nGrpTmp = EgtGroup( nSolidGrpId)
+   local dStrand = EgtGetInfo( vIds[#vIds], KEY_CRV_STRAND, 'd') or LayerParams.dStrand
+   
+   -- a) calcolo il solido
+   -- appiattisco la curva ( proiezione obliqua sul piano corrente lungo vtSlicing del piano successivo)
+   local nNextLayerId = EgtGetNext( nLayerId)
+   local vtSlicingNext = EgtGetInfo( nNextLayerId, KEY_SLICE_DIR, 'v')
+   local ptSlicing = EgtGetInfo( nLayerId, KEY_SLICE_POS, 'p') + LayerParams.dLayHeight * LayerParams.vtSlicing
+   local nProjCrv = EgtCopyGlob( vIds[#vIds], nGrpTmp)
+   local _, dE = EgtCurveDomain( nProjCrv)
+   for dU = 0, dE do
+      local ptCurr = EgtUP( nProjCrv, dU, GDB_ID.ROOT)
+      local dDist = ( ptCurr - ptSlicing) * LayerParams.vtSlicing / ( vtSlicingNext * LayerParams.vtSlicing)
+      EgtModifyCurveCompoJoint( nProjCrv, dU, ptCurr - dDist * vtSlicingNext, GDB_RT.GLOB)
+   end
+  
+   -- calcolo la sezione iniziale
+   local ptS = EgtSP( vIds[#vIds], GDB_ID.ROOT)
+   local ptE = EgtEP( vIds[#vIds], GDB_ID.ROOT)
+   local vtDir = EgtSV( nProjCrv, GDB_ID.ROOT)
+   vtDir:rotate( LayerParams.vtSlicing, 90)
+   local nSectId = CreateSection( ptS, vtDir, dStrand, s_dMultiPlanarH, LayerParams.vtSlicing, nGrpTmp)
+   -- creo la sezione finale
+   local vtDir2 = EgtEV( nProjCrv, GDB_ID.ROOT)
+   vtDir2:rotate( LayerParams.vtSlicing, 90)
+   local nSectE = CreateSection( ptE, vtDir2, dStrand, s_dMultiPlanarH, LayerParams.vtSlicing, nGrpTmp)
+   
+   -- creo le guide per il solido aperto ( tubo)
+   local dMaxDist = ( EgtEP( vIds[#vIds], GDB_ID.ROOT) - ptSlicing) * LayerParams.vtSlicing / ( vtSlicingNext * LayerParams.vtSlicing)
+   local vCrvs = {}
+   local _, dParE = EgtCurveDomain( nSectId)
+   for i = 0, dParE do
+      local ptRef = EgtUP( nSectId, i, GDB_ID.ROOT)
+      local dOffs = ( ptS - ptRef) * vtDir
+      vCrvs[i+1] = EgtOffsetCurveAdv( nProjCrv, dOffs)
+      if not vCrvs[i+1] or vCrvs[i+1] == GDB_ID.NULL then
+         EgtErase( nGrpTmp)
+         return false
+      end
+
+      -- proiezione obliqua "graduale"
+      EgtApproxCurve( vCrvs[i+1], GDB_CA.SPECIAL_LINES, 0.01)
+      local _, dE = EgtCurveDomain( vCrvs[i+1])
+      local dLen = EgtCurveLength( vCrvs[i+1])
+      local vDelta = {}
+      for dU = 0, dE do
+         local dCurrLen = EgtCurveLengthAtParam( vCrvs[i+1], dU) 
+         vDelta[dU] = dMaxDist * dCurrLen / dLen
+      end
+      for dU = 0, dE do
+         local ptCurr = EgtUP( vCrvs[i+1], dU, GDB_ID.ROOT)
+         EgtModifyCurveCompoJoint( vCrvs[i+1], dU, ptCurr + vDelta[dU] * vtSlicingNext, GDB_RT.GLOB)
+      end
+
+      local dMove = ( ptRef - ptS) * LayerParams.vtSlicing
+      EgtMove( vCrvs[i+1], LayerParams.vtSlicing * dMove, GDB_RT.GLOB)
+   end
+   -- creazione delle superfici del tubo
+   local vSurfs = {}
+   for i = 1, #vCrvs - 1 do
+      vSurfs[i] = EgtSurfTmRuled( nGrpTmp, vCrvs[i], vCrvs[i+1], GDB_RUL.MINDIST, s_dTol)
+      if not vSurfs[i] or vSurfs[i] == GDB_ID.NULL then
+         EgtErase( nGrpTmp)
+         return false
+      end
+   end
+   -- creazione del mezzo disco iniziale e finale
+   vSurfs[#vCrvs] = CreateSpiralVaseCap( nSectId, - EgtSV( vIds[#vIds], GDB_ID.ROOT), nSolidGrpId)
+   vSurfs[#vCrvs + 1] = CreateSpiralVaseCap( nSectE, EgtEV( vIds[#vIds], GDB_ID.ROOT), nSolidGrpId)
+   EgtInvertSurf( vSurfs[#vSurfs])
+   local nSolidId = EgtSurfTmByTriangles( nSolidGrpId, vSurfs)
+
+   -- b) deformo il solido per limitarlo al piano di slicing precedente
+   local ptSlicingPrev
+   local vtSlicingPrev
+   local nSliceNbr = EgtGetInfo( nLayerId, KEY_SLICE_NBR, 'i')
+   if nSliceNbr == 1 then
+      vtSlicingPrev = LayerParams.vtSlicing
+      ptSlicingPrev = ptSlicing - LayerParams.dLayHeight * LayerParams.vtSlicing
+   else
+      local nPrevLayId = EgtGetPrev( nLayerId)
+      vtSlicingPrev = EgtGetInfo( nPrevLayId, KEY_SLICE_DIR, 'v')
+      ptSlicingPrev = EgtGetInfo( nPrevLayId, KEY_SLICE_POS, 'p') + vtSlicingPrev * LayerParams.dLayHeight
+   end
+   local dCosAng = vtSlicingPrev * LayerParams.vtSlicing
+   
+   -- estendo la curva proiettata per gestire correttamente la deformazione dei caps
+   local nProjExtCrv = EgtCopyGlob( nProjCrv, nGrpTmp)
+   EgtExtendCurveStartByLen( nProjExtCrv, dStrand)
+   EgtExtendCurveEndByLen( nProjExtCrv, dStrand)
+   local dLen = EgtCurveLength( nProjCrv)
+
+   local nVertexCnt = EgtSurfTmVertexCount( nSolidId)
+   for j = 0, nVertexCnt - 1 do
+      
+      local ptVertex = EgtSurfTmGetVertex( nSolidId, j, GDB_RT.GLOB)
+
+      -- calcolo la distanza dal piano precedente lungo vtSlicing
+      local dDistPrevPlane = ( ptVertex - ptSlicingPrev) * vtSlicingPrev / dCosAng
+      -- calcolo la distanza approssimata dalla curva del toolpath
+      local _, ptMinDist, dMinPar = EgtPointCurveDist( ptVertex, nProjExtCrv, GDB_ID.ROOT)
+      local dCurrLen = EgtCurveLengthAtParam( nProjExtCrv, dMinPar) - dStrand
+      local ptRef = ptMinDist + dMaxDist * dCurrLen / dLen * vtSlicingNext
+      local dDistCrv = ( ptRef - ptVertex) * LayerParams.vtSlicing
+
+      -- calcolo la nuova posizione sapendo che l'altezza dello strand passa da s_dMultiPlanarH a dNewH
+      local dNewH = dDistCrv + dDistPrevPlane
+      local dDelta = dDistCrv - dDistCrv * dNewH / s_dMultiPlanarH
+      local ptNew = ptVertex + dDelta * LayerParams.vtSlicing
+      EgtSurfTmMoveVertex( nSolidId, j, ptNew, GDB_RT.GLOB, ( j == nVertexCnt - 1))
+   end
+   
+   local Color = EgtStdColor( 'TEAL')
+   if s_nSimplifiedSection == 1 and nSliceNbr % 2 == 0 then
+      Color = Color3d( s_dColorFactor * Color:getRed(), s_dColorFactor * Color:getGreen(), s_dColorFactor * Color:getBlue())
+   end
+   EgtSetColor( nSolidId, Color)
+   
+   EgtErase( nGrpTmp)
+end
+
+---------------------------------------------------------------------
+local function CreateFullSpiralVaseMultiPlanarSolids( vIds, nSolidGrpId, LayerParams, nLayerId)
+   
+   local nSliceNbr = EgtGetInfo( nLayerId, KEY_SLICE_NBR, 'i')
+   local ptSlicing = EgtGetInfo( nLayerId, KEY_SLICE_POS, 'p') + LayerParams.dLayHeight * LayerParams.vtSlicing
+  
+   -- recupero il piano precedente e il suo toolpath
+   local nPrevLayerId = EgtGetPrev( nLayerId)
+   local vtSlicingPrev = EgtGetInfo( nPrevLayerId, KEY_SLICE_DIR, 'v')
+   local ptSlicingPrev = EgtGetInfo( nPrevLayerId, KEY_SLICE_POS, 'p') + LayerParams.dLayHeight * vtSlicingPrev
+   local dCosAng = vtSlicingPrev * LayerParams.vtSlicing
+   local nPrevCrvGrp = EgtGetFirstNameInGroup( nPrevLayerId, CONTOUR_GRP .. '*')
+   local nPrevTPathGrp = EgtGetFirstNameInGroup( nPrevCrvGrp, TOOLPATH_GRP)
+   local nPrevTPath = EgtGetFirstNameInGroup( nPrevTPathGrp, SHELL_CRV .. '*')
+   
+   -- gruppo temporaneo per conti
+   local nGrpTmp = EgtGroup( nSolidGrpId)
+      
+   for i = 1, #vIds do
+      local dStrand = EgtGetInfo( vIds[i], KEY_CRV_STRAND, 'd') or LayerParams.dStrand
+      
+      -- creo la freccia direzionale
+      CreateDirectionArrow( vIds[i], nSolidGrpId, LayerParams.vtSlicing, dStrand, nSliceNbr)
+      
+      -- appiattisco la curva ( proiezione sul piano di slicing)
+      local nProjCrv = EgtCopyGlob( vIds[i], nGrpTmp)
+      EgtProjectCurveOnPlane( nProjCrv, ptSlicing, LayerParams.vtSlicing, GDB_RT.GLOB)
+      local dLen = EgtCurveLength( nProjCrv)
+     
+      -- suddivido la curva piana
+      local vGuideIds = CalcSolidGuides( nProjCrv, dStrand, nGrpTmp)
+      local dCumLen = 0
+      for k = 1, #vGuideIds do
+         
+         -- calcolo il solido sulla porzione della curva di proiezione
+         local nSolidId = CreateStandardSolid( vGuideIds[k], nSolidGrpId, s_dMultiPlanarH, dStrand)
+         
+         -- estendo la guida per gestire al meglio i caps
+         local nCrvRef = EgtCopyGlob( vGuideIds[k], nGrpTmp)
+         EgtExtendCurveStartByLen( nCrvRef, dStrand)
+         EgtExtendCurveEndByLen( nCrvRef, dStrand)
+         
+         -- recupero la curva precedente. Se estremi la limito per gestire al meglio la corrispondenza tra i toolpath
+         local nPrevTPathRef = nPrevTPath
+         if k == 1 then
+            nPrevTPathRef = EgtCopyGlob( nPrevTPath, nGrpTmp)
+            EgtTrimCurveEndAtLen( nPrevTPathRef, 0.5 * EgtCurveLength( nPrevTPathRef))
+         elseif k == #vGuideIds then
+            nPrevTPathRef = EgtCopyGlob( nPrevTPath, nGrpTmp)
+            EgtTrimCurveStartAtLen( nPrevTPathRef, 0.5 * EgtCurveLength( nPrevTPathRef))
+         end
+
+         -- deformo i solidi :
+         -- 1) traslazione dei vertici per portarli alla quota corretta del toolpath corrente
+         -- 2) deformazione della sezione in base alla distanza dal toolpath precedente
+         local nVertexCnt = EgtSurfTmVertexCount( nSolidId)
+         for j = 0, nVertexCnt - 1 do
+            local ptVertex = EgtSurfTmGetVertex( nSolidId, j, GDB_RT.GLOB)
+               
+            -- ricavo il punto di riferimento sulla proiezione del toolpath
+            local _, ptMinDist, dParMinDist = EgtPointCurveDist( ptVertex, nCrvRef, GDB_ID.ROOT)
+            local dCurrLen = EgtCurveLengthAtParam( nCrvRef, dParMinDist) - dStrand + dCumLen
+
+            -- 1) proietto il punto sul piano corrente e calcolo la traslazione da applicare in base alla distanza dal piano precedente ( analogamente a CalcToolPath)
+            local dDistCrv = ( ptSlicing - ptVertex) * LayerParams.vtSlicing
+            local ptProj = ptVertex + dDistCrv * LayerParams.vtSlicing
+            local dDistPlanePrev = ( ptProj - ptSlicingPrev) * vtSlicingPrev / dCosAng  
+            local dDeltaPos
+            if nSliceNbr == 2 and dCurrLen < 0.5 * dLen then
+               dDeltaPos = 0.5 * dDistPlanePrev
+            else
+               dDeltaPos = dDistPlanePrev * ( dLen - dCurrLen) / dLen
+            end
+            
+            -- 2) per calcolare la vera altezza del solido calcolo la distanza dal toolpath precedente guardando il punto di riferimento sul percorso corrente
+            local dNewH 
+            if nSliceNbr == 2 then
+               -- il primo layer è ad altezza costante quindi è semplice distanza dal piano precedente lungo vtSlicing
+               dNewH = ( ptProj - ptSlicingPrev) * vtSlicingPrev / dCosAng - dDeltaPos
+            else
+               local _, ptMinDistPrev = EgtPointCurveDist( ptMinDist, nPrevTPathRef, GDB_ID.ROOT)
+               local dDistPlanePrev2 = ( ptMinDist - ptSlicingPrev) * vtSlicingPrev / dCosAng
+               local dDeltaPos2
+               if nSliceNbr == 2 and dCurrLen < 0.5 * dLen then
+                  dDeltaPos2 = 0.5 * dDistPlanePrev2
+               else
+                  dDeltaPos2 = dDistPlanePrev2 * ( dLen - dCurrLen) / dLen
+               end
+               dNewH = ( ptMinDist - ptMinDistPrev) * LayerParams.vtSlicing - dDeltaPos2
+               -- aggiungo un piccolo extra per tener conto che la distanza è stata calcolata sulle curve centrali del solido
+               local dExtra = ( LayerParams.vtSlicing ^ vtSlicingPrev):len() / dCosAng * dStrand * 0.5
+               dNewH = dNewH + dExtra
+            end
+
+            local dDelta = dDistCrv - dDistCrv * dNewH / s_dMultiPlanarH
+            local ptNew = ptVertex + ( dDelta - dDeltaPos) * LayerParams.vtSlicing
+            EgtSurfTmMoveVertex( nSolidId, j, ptNew, GDB_RT.GLOB, ( j == nVertexCnt - 1))
+         end
+      
+         -- imposto colore
+         local Color = EgtStdColor( 'TEAL')
+         if s_nSimplifiedSection == 1 and nSliceNbr % 2 == 0 then
+            Color = Color3d( s_dColorFactor * Color:getRed(), s_dColorFactor * Color:getGreen(), s_dColorFactor * Color:getBlue())
+         end
+         EgtSetColor( nSolidId, Color)
+         
+         dCumLen = dCumLen + EgtCurveLength( vGuideIds[i])
+      end
+   end
+    
+   EgtErase( nGrpTmp)
+end
+
+---------------------------------------------------------------------
+local function CreateFullSpiralVaseMultiPlanarSolidsLastLayer( vIds, nSolidGrpId, LayerParams, nLayerId)
+   -- le curve sono piane quindi i solidi possono essere calcolati nel modo classico
+   -- i solidi della shell sono deformati in base alla distanza dalla curva precedente
+   -- eventuali solidi di lead out e coasting sono calcolati con un valore di altezza costante pari all'ultimo valore di altezza dei solidi della shell
+   
+   local nSliceNbr = EgtGetInfo( nLayerId, KEY_SLICE_NBR, 'i')
+   
+   local nPrevLayerId = EgtGetPrev( EgtGetPrev( nLayerId))
+   local vtSlicingPrev = EgtGetInfo( nPrevLayerId, KEY_SLICE_DIR, 'v')
+   local ptSlicingPrev = EgtGetInfo( nPrevLayerId, KEY_SLICE_POS, 'p') + vtSlicingPrev * LayerParams.dLayHeight
+   local ptSlicing = EgtGetInfo( nLayerId, KEY_SLICE_POS, 'p') + LayerParams.vtSlicing * LayerParams.dLayHeight
+   local dCosAng = vtSlicingPrev * LayerParams.vtSlicing
+   
+   -- 1) curva shell
+   local nGrpTmp = EgtGroup( nSolidGrpId)
+   local dStrand = EgtGetInfo( vIds[1], KEY_CRV_STRAND, 'd') or LayerParams.dStrand
+   local vShellGuides = CalcSolidGuides( vIds[1], dStrand, nGrpTmp)
+   
+   local dLen = EgtCurveLength( vIds[1])
+   -- se non c'è lead out alla lunghezza totale della shell devo aggiungere anche quella del coasting
+   if EgtGetInfo( s_nPartId, KEY_LEAD_OUT_TYPE, 'i') == LEAD_TYPE.NONE then
+      dLen = dLen + EgtGetInfo( s_nPartId, KEY_COASTING_LEN, 'd')
+   end
+   local dCumLen = 0
+   
+   -- creo la freccia direzionale
+   CreateDirectionArrow( vIds[1], nSolidGrpId, LayerParams.vtSlicing, dStrand, nSliceNbr)
+      
+   for i = 1, #vShellGuides do
+     
+      -- calcolo il solido associato
+      local nSolidId = CreateStandardSolid( vShellGuides[i], nSolidGrpId, s_dMultiPlanarH, dStrand)
+      
+      -- estensione della guida per gestire meglio i caps
+      local nCrvRef = EgtCopyGlob( vShellGuides[i], nGrpTmp)
+      EgtExtendCurveStartByLen( nCrvRef, dStrand)
+      EgtExtendCurveEndByLen( nCrvRef, dStrand)
+      
+      -- deformo in base alla distanza dalla curva precedente
+      local nVertexCnt = EgtSurfTmVertexCount( nSolidId)
+      for j = 0, nVertexCnt - 1 do
+         local ptVertex = EgtSurfTmGetVertex( nSolidId, j, GDB_RT.GLOB)
+         
+         -- ricavo il punto di riferimento sulla guida
+         local _, _, dParMinDist = EgtPointCurveDist( ptVertex, nCrvRef, GDB_ID.ROOT)
+         local dCurrLen = EgtCurveLengthAtParam( nCrvRef, dParMinDist) - dStrand + dCumLen
+
+         -- calcolo la nuova altezza del solido in base alla distanza dalla curva precedente
+         local dDistCurr = ( ptSlicing - ptVertex) * LayerParams.vtSlicing
+         local ptProj = ptVertex + dDistCurr * LayerParams.vtSlicing
+         local dDistPrev = ( ptProj - ptSlicingPrev) * vtSlicingPrev / dCosAng
+         local dNewH = dDistPrev * ( dLen - dCurrLen) / dLen
+         dNewH = max( dNewH, 500 * GEO.EPS_SMALL)
+         
+         -- calcolo la nuova posizione sapendo che l'altezza dello strand passa da s_dMultiPlanarH a dNewH
+         local dDelta = dDistCurr - dDistCurr * dNewH / s_dMultiPlanarH
+         local ptNew = ptVertex + dDelta * LayerParams.vtSlicing
+         EgtSurfTmMoveVertex( nSolidId, j, ptNew, GDB_RT.GLOB, ( j == nVertexCnt - 1))
+      end
+
+      dCumLen = dCumLen + EgtCurveLength( vShellGuides[i])
+      
+      -- imposto colore
+      local Color = EgtStdColor( 'TEAL')
+      if s_nSimplifiedSection == 1 and nSliceNbr % 2 == 0 then
+         Color = Color3d( s_dColorFactor * Color:getRed(), s_dColorFactor * Color:getGreen(), s_dColorFactor * Color:getBlue())
+      end
+      EgtSetColor( nSolidId, Color)
+   end
+   
+   -- 2) curve di uscita
+   -- calcolo altezza finale del solido shell
+   local ptE = EgtEP( vIds[1], GDB_ID.ROOT)
+   local dH = ( ( ptE - ptSlicingPrev) * vtSlicingPrev / dCosAng) * ( dLen - EgtCurveLength( vIds[1])) / dLen
+   dH = max( dH, 500 * GEO.EPS_SMALL)
+   for i = 2, #vIds do
+      CreateSolidFromCurve( vIds[i], nSolidGrpId, LayerParams, nSliceNbr, dH)
+   end
+   
+   EgtErase( nGrpTmp)
+end
+
 ---------------------------------------------------------------------
 function RunCalcSolids.Exec()

@@ -391,6 +802,7 @@ function RunCalcSolids.Exec()
   local nPartId = EgtGetFirstNameInGroup( GDB_ID.ROOT, PART .. nPartIndex) or EgtGetFirstNameInGroup( GDB_ID.ROOT, PART)
   while nPartId do

+      s_nPartId = nPartId
      if EgtGetInfo( nPartId, KEY_PART_ON_TABLE, 'b') then
         -- verifico se necessario calcolare il solido
         local bCalcSolid = EgtGetInfo( nPartId, KEY_CALC_SOLIDS, 'b') or false
@@ -410,15 +822,24 @@ function RunCalcSolids.Exec()
            end

            EgtSetInfo( nPartId, KEY_HAS_SOLIDS, 1)
+            local nSlicingType = EgtGetInfo( nPartId, KEY_SLICING_TYPE, 'i')

            -- recupero i parametri necessari al calcolo dei solidi 
            local LayerParams = GetLayerParamsForSolidCalc( nPartId)
+            
+            -- se slicing multiplanare considero come altezza standard quella massima ammessa
+            if nSlicingType == SLICING_TYPE.MULTIPLANAR then
+               local sMachIni = EgtGetCurrMachineDir() .. '\\' .. EgtGetCurrMachineName() .. '.ini'
+               local dMaxFactor = EgtGetNumberFromIni( '3dPrinting', KEY_MAX_STRANDH_FACTOR, 2, sMachIni)
+               s_dMultiPlanarH = min( dMaxFactor, 5) * LayerParams.dLayHeight
+            end

            for nIdx = 1, #vLayIds do
+               
               -- flag di interruzione perchè trovati solidi già ok
               local bSolidsOk = false
-               -- indice layer (per log)
-               local nLayer = EgtGetInfo( vLayIds[ nIdx], KEY_SLICE_NBR, 'i')
+               -- indice layer ( per log)
+               local nSliceNbr = EgtGetInfo( vLayIds[ nIdx], KEY_SLICE_NBR, 'i')
               -- scorro tutti i gruppi di contorni
               local nCrvGrpId = EgtGetFirstNameInGroup( vLayIds[ nIdx], CONTOUR_GRP.."*") or GDB_ID.NULL
               while nCrvGrpId ~= GDB_ID.NULL do
@@ -436,10 +857,43 @@ function RunCalcSolids.Exec()
                     nSolidGrpId = EgtGroup( nCrvGrpId)
                     EgtSetName( nSolidGrpId, SOLID_GRP)
                     EgtSetLevel( nSolidGrpId, GDB_LV.TEMP)
+                     
                     local vIds = EgtGetAllInGroup( nTPathGrpId)
                     
-                     -- spiral vase
-                     if LayerParams.bSpiralVase then
+                     -- slicing multiplanare
+                     if nSlicingType == SLICING_TYPE.MULTIPLANAR then
+                        LayerParams.vtSlicing = EgtGetInfo( vLayIds[nIdx], KEY_SLICE_DIR, 'v')
+                        
+                        if LayerParams.bSpiralVase then
+                           local dTransitionLen = EgtGetInfo( nPartId, KEY_SPIRAL_VASE_LEN, 'd') or 0
+                           -- a) spiral vase completo ( con transizione in altezza su tutto il layer)
+                           if dTransitionLen < GEO.EPS_SMALL then
+                              if nIdx == 1 then
+                                 -- il primo layer va gestito come uno spiral vase con transizione parziale ( curva a quota costante e ultimo tratto che si alza)
+                                 CreatePartialSpiralVaseMultiPlanarSolids( vIds, nSolidGrpId, LayerParams, vLayIds[nIdx])
+                              elseif nIdx == #vLayIds then
+                                 -- gestione speciale per lead out e coasting
+                                 CreateFullSpiralVaseMultiPlanarSolidsLastLayer( vIds, nSolidGrpId, LayerParams, vLayIds[nIdx])
+                              else
+                                 CreateFullSpiralVaseMultiPlanarSolids( vIds, nSolidGrpId, LayerParams, vLayIds[nIdx])
+                              end
+                              
+                           -- b) spiral vase con transizione parziale
+                           else
+                              if nIdx == #vLayIds then
+                                 -- ultimo layer è un multiplanare standard perchè non ha tratto finale che si alza
+                                 CreateMultiPlanarSolids( vIds, nSolidGrpId, LayerParams, vLayIds[nIdx])
+                              else
+                                 CreatePartialSpiralVaseMultiPlanarSolids( vIds, nSolidGrpId, LayerParams, vLayIds[nIdx])
+                              end
+                           end
+                        -- c) multiplanare standard
+                        else
+                           CreateMultiPlanarSolids( vIds, nSolidGrpId, LayerParams, vLayIds[nIdx])
+                        end
+                        
+                     -- slicing standard spiral vase
+                     elseif LayerParams.bSpiralVase then
                        -- i tratti di ingresso, uscita e quelli a quota costante vanno gestiti singolarmente, quelli a quota variabile vanno concatenati
                        local vChainedIds = {}
                        local vTmpIds = {}
@@ -465,21 +919,21 @@ function RunCalcSolids.Exec()
                        
                        for i = 1, #vChainedIds do
                           if #vChainedIds[i] == 1 then
-                              CreateSolidFromCurve( vChainedIds[i][1], nSolidGrpId, LayerParams, nLayer)
+                              CreateSolidFromCurve( vChainedIds[i][1], nSolidGrpId, LayerParams, nSliceNbr)
                           else
                              local nNewCrv = EgtCurveCompo( nSolidGrpId, vChainedIds[i], false)
                              local dStrand = EgtGetInfo( vChainedIds[i][1], KEY_CRV_STRAND, 'd') or LayerParams.dStrand
                              EgtSetInfo( nNewCrv, KEY_CRV_STRAND, dStrand)
                              EgtSetInfo( nNewCrv, KEY_TYPE, TYPE.OUTER_SHELL)
-                              CreateSolidFromCurve( nNewCrv, nSolidGrpId, LayerParams, nLayer)
+                              CreateSolidFromCurve( nNewCrv, nSolidGrpId, LayerParams, nSliceNbr)
                              EgtErase( nNewCrv)
                           end
                        end
                        
-                     -- caso standard
+                     -- slicing standard
                     else
                        for i = 1, #vIds do
-                           CreateSolidFromCurve( vIds[i], nSolidGrpId, LayerParams, nLayer)
+                           CreateSolidFromCurve( vIds[i], nSolidGrpId, LayerParams, nSliceNbr)
                        end
                     end
                  else
@@ -33,6 +33,7 @@ function RunGcodeGenerate.Exec()
      EgtOutBox( 'Error missing part', 'GcodeGenerate')
      return 
   end
+   local nSlicingType = EgtGetInfo( nPartId, KEY_SLICING_TYPE, 'i')

   -- Recupero i layer da processare
   local vLayIds = EgtGetNameInGroup( nPartId, SLICE_LAYER.."*") 
@@ -89,8 +90,15 @@ function RunGcodeGenerate.Exec()
   -- Rimuovo eventuali precedenti lavorazioni
   EgtRemoveAllOperations()

+   -- Determino lavorazione di libreria
+   local sExtrName = 'Extrusion'
+   if nSlicingType == SLICING_TYPE.HORIZONTAL then
+      local sMachIni = EgtGetCurrMachineDir() .. '\\' .. EgtGetCurrMachineName() .. '.ini'
+      sExtrName = EgtGetStringFromIni( SEC_3DPRINTING, KEY_HORIZ_EXTR, sExtrName, sMachIni)
+   end
+
   -- Aggiungo la lavorazione
-   local nMchId = EgtAddMachining( 'Extrusion 1', 'Extrusion')
+   local nMchId = EgtAddMachining( 'Extrusion 1', sExtrName)
   if not nMchId then
      EgtOutBox( 'Error adding Extrusion', 'GcodeGenerate')
      return
@@ -100,7 +100,7 @@ local function CalcCurves( nSliceId, nDestGrp, vtSlicing, dStrandBase)
 end

 ------------------------------------------------------------------
-local function CalcSpiralVase( nSliceId, nDestGrp)
+local function GetSolids( nSliceId, nDestGrp)
   
   -- scorro tutti i gruppi di curve
   local vCrvs = EgtGetNameInGroup( nSliceId, CONTOUR_GRP .. '*')
@@ -156,10 +156,11 @@ function RunPrepareExport.Exec()
   -- 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 vtSlicing = EgtGetInfo( nPartId, KEY_SLICE_DIR, 'v') or EgtGetInfo( nPartId, "SlicingDir", 'v')
+   EgtSetInfo( nPnt, "SlicingDir", vtSlicing)
   local bSpiralVase = EgtGetInfo( nPartId, KEY_SPIRAL_VASE, 'b') or false
   EgtSetInfo( nPnt, KEY_SPIRAL_VASE, bSpiralVase)
+   local nSlicingType = EgtGetInfo( nPartId, KEY_SLICING_TYPE, 'i')
   
   -- recupero lo strand dai parametri generale nel caso non fosse definito sulle singole curve
   local dStrandBase = EgtGetInfo( nPartId, KEY_STRAND, 'd') or 0
@@ -195,8 +196,9 @@ function RunPrepareExport.Exec()
      EgtSetName( nDestGrp, EgtGetName( vSlices[i]))
      EgtSetStatus( nDestGrp, GDB_ST.OFF)
      
-      if bSpiralVase then
-         CalcSpiralVase( vSlices[i], nDestGrp)
+      -- se multiplanare o spiral vase esporto direttamente i solidi altrimenti esporto le curve che verranno estruse nel visualizzatore
+      if nSlicingType == SLICING_TYPE.MULTIPLANAR or bSpiralVase then
+         GetSolids( vSlices[i], nDestGrp)
      else
         CalcCurves( vSlices[i], nDestGrp, vtSlicing, dStrandBase)
      end
@@ -1,4 +1,4 @@
-- Version.lua by Egaltech s.r.l. 2025/09/12
+-- Version.lua by Egaltech s.r.l. 2026/03/23
 -- Gestione della versione di 3dPrinting

-VERSION = '3.1a1'
+VERSION = '3.1c3'
Author	SHA1	Message	Date
Dario Sassi	c9e5a558d9	3dPrinting : - aggiunta possibilità di definire una lavorazione diversa per estrusione orizzontale (da Ini macchina [3dPrinting] HorizExtrusion=TiltedExtrusion).	2026-03-23 15:32:22 +01:00
Dario Sassi	d615530519	3dPrinting 3.1c3 : - aggiunta scrittura di 'SlicingDir' nel pezzo per compatibilità con vecchie macchine.	2026-03-23 09:48:19 +01:00
SaraP	5be6539a1e	3dPrinting 3.1c2 : - piccola correzione per gestire compatibilià con vecchi progetti che hanno info "SlicingDir" e non "SliceDir".	2026-03-10 16:35:30 +01:00
Dario Sassi	7c7fa77608	3dPrinting 3.1c1 : - ora MinStrandHFactor e MaxStrandHFactor sono letti dalla sezione [3dPrinting] dell'ini di macchina.	2026-03-04 09:18:03 +01:00
SaraP	5ad54c18f1	3dPrinting: - sistemato spiral vase completo nel caso multiplanare - sistemata correzione in z per caso multiplanare - migliorie varie nei solidi - gestione multicolore per solidi con strand semplificato.	2026-03-02 09:29:44 +01:00
SaraP	07b9a60a25	3dPrinting : - correzione spiral vase multiplanare.	2026-02-20 14:30:59 +01:00
SaraP	6f625c46ae	3dPrinting : - tolleranze per lo slicing legate alla tolleranza impostata nel programma - corretti solidi multiplanari.	2026-02-20 12:34:46 +01:00
SaraP	33048785f9	3dPrinting : - sistemato spiral vase con transizione nel caso multiplanare - calcolo solidi nel caso multiplanare ( standard e spiral vase con transizione) - sistemato esportatore icrx per multiplanar.	2026-02-20 11:35:00 +01:00
SaraP	cad4045171	3dPrinting : - in multiplanar aggiunto controllo strand max > strand min - migliorata segnalazione errori.	2026-02-19 08:22:37 +01:00
SaraP	b19415b030	3dPrinting : - piccola correzione.	2026-02-18 12:32:43 +01:00
SaraP	dd2e8f357a	3dPrinting : - nel caso multiplanare aggiunto controllo su strand massimo e minimo ( dati letti dal file ini programma).	2026-02-18 11:14:42 +01:00
SaraP	415eb4d32a	3dPrinting : - migliorata gestione spina per caso multiplanare - eliminati eventuali slices senza curve.	2026-02-18 09:44:27 +01:00
SaraP	752d307cde	3dPrinting : - piccola correzione progress bar per slicing multiplanare.	2026-02-17 10:16:58 +01:00
Dario Sassi	7b14c98461	3dPrinting : - piccola miglioria per progressbar in multiplanare.	2026-02-17 09:53:59 +01:00
Dario Sassi	a0314f3222	3dPrinting 3.1b2 : - SpiralVaseLen ora è un parametro della lavorazione.	2026-02-16 11:38:14 +01:00
SaraP	6a60cd2b5e	3dPrinting : - riorganizzato CalcSlices per MultiPlanar - nello spiral vase MultiPlanar aggiunto layer extra finale a quota costante.	2026-02-13 16:23:09 +01:00
Dario Sassi	9df7f78665	3dPrinting : - altra piccola correzione per multiplanare.	2026-02-13 16:16:45 +01:00
Dario Sassi	6211c6d873	3dPrinting : - cambiate costanti KEY_SLICING_DIR e KEY_SLICING_POS in KEY_SLICE_DIR e KEY_SLICE_POS.	2026-02-13 10:34:52 +01:00
Dario Sassi	4b97a5b949	3dPrinting : - piccole modifiche per MultiPlanar.	2026-02-12 16:44:30 +01:00
Dario Sassi	eed869c997	3dPrinting 3.1b1 : - prime modifiche per slicing Multi Planare.	2026-02-11 18:16:46 +01:00