3dPrinting 3.1c1 :

- ora MinStrandHFactor e MaxStrandHFactor sono letti dalla sezione [3dPrinting] dell'ini di macchina.

LuaLibs/AddManData.lua

@@ -45,8 +45,9 @@ SEC_DEFAULT = "Default"
 KEY_PARAMS = "Params"
 KEY_CALC_SOLIDS = "CalcSolids"
 KEY_SPIRAL_VASE = "SpiralVase"
+KEY_SPIRAL_VASE_LEN = 'SpiralVaseLen'
+KEY_SPIRAL_VASE_INTERP_LEN = 'SpiralVaseInterpLen'
 KEY_SLICING_TYPE = "SlicingType"
-KEY_SLICING_DIR = "SlicingDir"
 KEY_SLICE_STEP = "StrandH"
 KEY_SHELLS_NBR = "StrandCount"
 KEY_STRAND = "StrandW"
@@ -84,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"
@@ -111,6 +114,7 @@ KEY_RIBS_STRAND = "RibsStrandW"
 KEY_RIBS_TYPE = "RibsType"
 KEY_LIMIT_UNBDD_RIBS = "LimitUnboundedRibsWithSolid"
 KEY_RIBS_OVERLAP = "RibsOverlap"
+KEY_RIBS_STRAND_OVERLAP = 'RibsStrandOverlap'
 KEY_RIBS_SHELLS_NBR = "RibsStrandCount"
 KEY_RIBS_LINK = "RibsLink"
 KEY_RIBS_INVERT_DIR = "RibsInvertDirection"
@@ -184,10 +188,11 @@ KEY_LINEAR_TOL = 'LinearTol'
 
 -- Altre chiavi
 KEY_MAX_H = "SlicingHeight"
+KEY_MAX_SLICES_NBR = "MaxSlicesNumber"
 KEY_SLICE_NBR = "SliceNbr"
-KEY_SLICE_Z = "SliceZ"
+KEY_SLICE_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"
@@ -211,12 +216,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 = {
@@ -299,6 +306,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'

LuaLibs/CalcPaths.lua

@@ -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)
@@ -722,33 +716,26 @@ local function VerifyRibsHoles( vIds)
          local ptS2 = EgtSP( vIds[i])
          local ptE2 = EgtEP( vIds[i])
          
-         local bAdd1 = dist( ptS1, ptE2) < dStrand + 10 * GEO.EPS_SMALL or dist( ptS1, ptS2) < dStrand + 10 * GEO.EPS_SMALL
-         local bAdd2 = dist( ptE1, ptS2) < dStrand + 10 * GEO.EPS_SMALL or dist( ptE1, ptE2) < dStrand + 10 * GEO.EPS_SMALL
-         local bInvert = dist( ptE1, ptE2) < dStrand + 10 * GEO.EPS_SMALL or dist( ptS1, ptS2) < dStrand + 10 * GEO.EPS_SMALL
-         
-         if bInvert then
-            EgtInvertCurve( vIds[i])
-         end
+         local bAdd1 = dist( ptS1, ptE2) < dStrand + 10 * GEO.EPS_SMALL
+         local bAdd2 = dist( ptE1, ptS2) < dStrand + 10 * GEO.EPS_SMALL
+         bAdd = bAdd1 or bAdd2
          
          if bAdd1 and bAdd2 then
-            -- se da unire in setto chiuso
-            bAdd = true
-            EgtAddCurveCompoLine( vIds[i-1], EgtEP( vIds[i]), false)
-            EgtAddCurveCompoLine( vIds[i-1], EgtSP( vIds[i]))
+            -- da unire in setto chiuso
+            EgtAddCurveCompoLine( vIds[i-1], ptE2, false)
+            EgtAddCurveCompoLine( vIds[i-1], ptS2)
             EgtAddCurveCompoCurve( vIds[i-1], vIds[i])
             table.remove( vIds, i)   -- rimuovo il setto dalla tabella
             
          elseif bAdd2 then
-            bAdd = true
             -- unisco il secondo tratto al primo
-            EgtAddCurveCompoLine( vIds[i-1], EgtSP( vIds[i]))
+            EgtAddCurveCompoLine( vIds[i-1], ptS2)
             EgtAddCurveCompoCurve( vIds[i-1], vIds[i])
             table.remove( vIds, i)   -- rimuovo il setto dalla tabella
             
          elseif bAdd1 then
-            bAdd = true
             -- unisco il primo tratto al secondo
-            EgtAddCurveCompoLine( vIds[i], EgtSP( vIds[i-1]))
+            EgtAddCurveCompoLine( vIds[i], ptS1)
             EgtAddCurveCompoCurve( vIds[i], vIds[i-1])
             table.remove( vIds, i-1)  -- rimuovo il setto dalla tabella
          end
@@ -1287,7 +1274,8 @@ local function ComputeRibsOrientedOffset( nRibsGrp)
          local bCCW = EgtGetInfo( vIds[i], KEY_RIBS_USER_LINK_CCW, 'b') or false
          local nLinkOrder = EgtGetInfo( vIds[i], KEY_RIBS_USER_LINK_ORDER, 'i') or 0
          local dStrand = EgtGetInfo( vIds[i], KEY_RIBS_STRAND, 'd')
-         local dOffs = ( nShellsNbr - 1) * dStrand / 2
+         local dStrandOverlap = EgtGetInfo( vIds[i], KEY_RIBS_STRAND_OVERLAP, 'd') or 0
+         local dOffs = ( nShellsNbr - 1) * ( 1 - dStrandOverlap / 100) * dStrand / 2
          
          -- ordine di realizzazione degli offset
          if not bUserLinked then
@@ -1303,7 +1291,7 @@ local function ComputeRibsOrientedOffset( nRibsGrp)
          
          local vOffsRib = {}
          for k = 0, nShellsNbr - 1 do
-            local dOffsCurr = dOffs - k * dStrand
+            local dOffsCurr = dOffs - k * ( 1 - dStrandOverlap / 100) * dStrand
             local nNewId
             if abs( dOffsCurr) < GEO.EPS_SMALL then
                nNewId = EgtCopyGlob( vIds[i], nOffsGrp)
@@ -1424,7 +1412,7 @@ local function ComputeTrimSurfWithOverlapsForRibs( vIds, nGrp, nSrfInt, nSrfExt,
             
          elseif nType == RIB_TYPE.EXTERNAL then
             if not nSrfExt then
-               -- il setto va cancellato
+               -- sono in un CrvGrp intermedio, il setto va cancellato
             elseif nSrfExt == GDB_ID.NULL then
                -- se la superficie non esiste il setto va conservato
                tSurfOffs[vIds[i]] = GDB_ID.NULL
@@ -1443,8 +1431,11 @@ local function ComputeTrimSurfWithOverlapsForRibs( vIds, nGrp, nSrfInt, nSrfExt,
             end
             
          else
-            -- se unbounded non va mai trimmato
-            tSurfOffs[vIds[i]] = GDB_ID.NULL
+            -- il setto unbounded deve comparire solo nell'ultimo CrvGrp senza alcun trim. Se nSrfExt non è definita sono in un CrvGrp intermedio e il setto va cancellato 
+            -- se nSrfExt è definita allora il setto non va trimmato
+            if nSrfExt then
+               tSurfOffs[vIds[i]] = GDB_ID.NULL
+            end
          end
          
          tOffs[vIds[i]] = dOffs
@@ -1607,10 +1598,11 @@ local function AdjustRibsOffsetForIntersection( nCrv1, nCrv2, nOffsGrp, nLoopGrp
    
    local nShells = EgtGetInfo( nCrv1, KEY_RIBS_SHELLS_NBR, 'i')
    local dStrand1 = EgtGetInfo( nCrv1, KEY_RIBS_STRAND, 'd')
+   local dStrandOverlap1 = EgtGetInfo( nCrv1, KEY_RIBS_STRAND_OVERLAP, 'd') or 0
    local dOverlap = EgtGetInfo( nCrv2, KEY_RIBS_OVERLAP, 'i')
    local dStrand2 = EgtGetInfo( nCrv2, KEY_RIBS_STRAND, 'd')
 
-   if dOverlap / 100 * dStrand2 > nShells * dStrand1 * 0.5 - GEO.EPS_SMALL then
+   if dOverlap / 100 * dStrand2 > ( nShells - 1) * ( 1 - dStrandOverlap1 / 100) * dStrand1 * 0.5 + dStrand1 * 0.5 - GEO.EPS_SMALL then
       -- non ha senso spezzare la curva, aggiorno solo split order dei suoi offset
       for i = 1, #vOffs2 do
          CopyInfo( nCrv2, vOffs2[i], KEY_SPLIT_ORDER, 'i')
@@ -1619,7 +1611,7 @@ local function AdjustRibsOffsetForIntersection( nCrv1, nCrv2, nOffsGrp, nLoopGrp
    end
    
    -- calcolo la superficie della curva principale ( nCrv1) da usare per trim
-   local dOffs = nShells * dStrand1 * 0.5 + dStrand2 * ( 0.5 - dOverlap / 100)
+   local dOffs = ( nShells - 1) * ( 1 - dStrandOverlap1 / 100) * dStrand1 * 0.5 + dStrand1 * 0.5 + dStrand2 * ( 0.5 - dOverlap / 100)
    local nSrf = EgtSurfFrFatCurve( nOffsGrp, nCrv1, dOffs, false, false, s_dOffsTol)
    if not nSrf then
       EgtOutLog( 'Error : ribs intersection failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths')
@@ -1678,9 +1670,11 @@ local function AdjustRibsOffsetForIntersection2Shells( nCrv1, nCrv2, nOffsGrp)
   
    -- costruisco le superfici da usare per trim
    local dStrand1 = EgtGetInfo( nCrv1, KEY_RIBS_STRAND, 'd')
-   local nSrf1 = EgtSurfFrFatCurve( nOffsGrp, nCrv1, dStrand1 * 0.5, false, false, s_dOffsTol)
+   local dStrandOverlap1 = EgtGetInfo( nCrv1, KEY_RIBS_STRAND_OVERLAP, 'd') or 0
+   local nSrf1 = EgtSurfFrFatCurve( nOffsGrp, nCrv1, ( 1 - dStrandOverlap1 / 100) * dStrand1 * 0.5, false, false, s_dOffsTol)
    local dStrand2 = EgtGetInfo( nCrv2, KEY_RIBS_STRAND, 'd')
-   local nSrf2 = EgtSurfFrFatCurve( nOffsGrp, nCrv2, dStrand2 * 0.5, false, false, s_dOffsTol)
+   local dStrandOverlap2 = EgtGetInfo( nCrv2, KEY_RIBS_STRAND_OVERLAP, 'd') or 0
+   local nSrf2 = EgtSurfFrFatCurve( nOffsGrp, nCrv2, ( 1 - dStrandOverlap2 / 100) * dStrand2 * 0.5, false, false, s_dOffsTol)
    
    -- trim degli offset di nCrv1
    local vOffs1 = EgtGetNameInGroup( nOffsGrp, EgtGetName( nCrv1)) or {}
@@ -2040,6 +2034,9 @@ local function ShortestPathForRibs( vRibs, nGrp, bInvertOrder)
    if #tabRibs == 1 then
       -- se un solo gruppo ordinamento banale
       vOrd = {1}
+   elseif #tabRibs == 2 then
+      -- se due gruppi fisso l'ordinamento per evitare inversioni tra i layers
+      vOrd = { 1, 2}
    else
       -- se più gruppi ordinamento con shortest path
       EgtSpInit()
@@ -2143,6 +2140,7 @@ local function ReassignInfo( nCrv, nCnt, vOrig)
                CopyInfo( vOrig[i], nId, KEY_RIBS_LEAD_IN_LEN, 'd')
                CopyInfo( vOrig[i], nId, KEY_ASSOCIATED_SURF, 'i')
                CopyInfo( vOrig[i], nId, KEY_RIBS_OVERLAP, 'd')
+               CopyInfo( vOrig[i], nId, KEY_RIBS_STRAND_OVERLAP, 'd')
                CopyInfo( vOrig[i], nId, KEY_RIBS_TYPE, 'i')
                CopyInfo( vOrig[i], nId, KEY_RIBS_LINK, 'b')
                CopyInfo( vOrig[i], nId, KEY_RIBS_LINK_FILLET, 'd')
@@ -2503,7 +2501,7 @@ local function CalcRibsPaths( nSliceGrp, nRibsGrp, LayerParams, vPtStart, bIgnor
                                                              bAllTwoStrands, vTypeSequence, nLoopGrp, tSurfOffs)
       EgtSetInfo( nRibsPathGrp or GDB_ID.NULL, KEY_RIBS_INTERS, bInters)
       EgtSetInfo( nRibsPathGrp or GDB_ID.NULL, KEY_RIBS_SPECIAL_CASE, bSpecialCase)
-      
+     
       -- riordino le costolature
       if bSpecialCase then
          -- gestione caso speciale di intersezione e 2 passate
@@ -2585,7 +2583,8 @@ local function AddFillet( nRib1, vLinks, nRib2, nGrpId)
    local nSplit2 = EgtGetInfo( nRib2, KEY_SPLIT_ID, 'i') or 0
    if nOrig1 == nOrig2 and nSplit1 == nSplit2 then
       local dStrand = EgtGetInfo( nRib1, KEY_RIBS_STRAND, 'd')
-      dFillet1 = min( dFillet1, 0.5 * dStrand)
+      local dStrandOverlap = EgtGetInfo( nRib1, KEY_RIBS_STRAND_OVERLAP, 'd')
+      dFillet1 = min( dFillet1, 0.5 * ( 1 - dStrandOverlap / 100) * dStrand)
       dFillet2 = dFillet1
    end
    
@@ -2833,9 +2832,18 @@ local function HandleRibsIntersectionForRibsMergedShells( vOrigRibs, nRibsGrp, n
                nCrv1, nCrv2 = nCrv2, nCrv1
             end
             
+            -- verifico che la curva secondaria abbia una sola passata
+            local nShells2 = EgtGetInfo( nCrv2, KEY_RIBS_SHELLS_NBR, 'i')
+            if nShells2 > 1 then
+               EgtOutLog( 'Error : shell-merged ribs intersect in a non valid way (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths')
+               table.insert( s_vErr, ' - layer ' .. EgtNumToString( s_nCurrIdx) .. ' : error in ribs-merged shells intersection')
+               return false
+            end
+            
             -- calcolo la superficie della curva principale ( nCrv1) da usare per trim
             local nShells = EgtGetInfo( nCrv1, KEY_RIBS_SHELLS_NBR, 'i')
-            local dOffs = (( nShells + 1) * 0.5 - dOverlap / 100) * dStrand
+            local dStrandOverlap = EgtGetInfo( nCrv1, KEY_RIBS_STRAND_OVERLAP, 'd')
+            local dOffs = (( nShells - 1) * ( 1 - dStrandOverlap / 100) * 0.5 + 1 - dOverlap / 100) * dStrand
             local nSrf = EgtSurfFrFatCurve( nGrpTmp, nCrv1, dOffs, false, false, s_dOffsTol)
             if not nSrf then
                EgtOutLog( 'Error : EgtSurfFrFatCurve for shell-merged ribs intersection failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths')
@@ -3103,26 +3111,38 @@ end
 
 --------------------------------------------------------------------
 local function AdjustRibsMergedExtraShellLink( nLinkId, vExtraShells, nGrp)
-   
-   local frLoc = Frame3d( ORIG(), s_vtSlicing)
-   local nGrpLoc = EgtGroup( nGrp, frLoc)
+
    local vLinks = {}
    
-   -- devo conservare solo le intersezioni fra link ed extra shell
+   -- devo conservare solo i tratti comuni fra link ed extra shell
    for i = 1, #vExtraShells do
-      local nRes, nPntCnt, nCrvCnt = EgtCurveCurveInters( nLinkId, vExtraShells[i], nGrpLoc)
-      if nRes then
-         for nId = nRes + nPntCnt, nRes + nPntCnt + nCrvCnt - 1 do
-            EgtRelocateGlob( nId, nGrp)
-            EgtModifyCurveExtrusion( nId, s_vtSlicing, GDB_ID.ROOT)
-            table.insert( vLinks, nId)
+      
+      local dParS = EgtCurveParamAtPoint( nLinkId, EgtSP( vExtraShells[i]), 100 * GEO.EPS_SMALL)
+      local dParE = EgtCurveParamAtPoint( nLinkId, EgtEP( vExtraShells[i]), 100 * GEO.EPS_SMALL)
+      if dParS or dParE then
+         local nCrv = EgtCopyGlob( nLinkId, nGrp)
+         if dParS and dParE then
+            EgtTrimCurveStartEndAtParam( nCrv, dParS, dParE)
+         elseif dParS then
+            EgtTrimCurveStartAtParam( nCrv, dParS)
+         elseif dParE then
+            EgtTrimCurveEndAtParam( nCrv, dParE)
+         end
+         EgtModifyCurveExtrusion( nCrv, s_vtSlicing, GDB_ID.ROOT)
+         table.insert( vLinks, nCrv)
+      else
+         
+         -- verifico se il link originale è già corretto
+         local dPar1 = EgtCurveParamAtPoint( vExtraShells[i], EgtSP( nLinkId), 100 * GEO.EPS_SMALL)
+         local dPar2 = EgtCurveParamAtPoint( vExtraShells[i], EgtEP( nLinkId), 100 * GEO.EPS_SMALL)
+         if dPar1 and dPar2 then
+            return { nLinkId}
          end
       end
    end
    
    -- cancello il link originale
    EgtErase( nLinkId)
-   EgtErase( nGrpLoc)
    return vLinks
 end
 
@@ -4317,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)

LuaLibs/CalcSlices.lua

@@ -18,30 +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
    
-   local ptSlices = { dZmin + dDeltaZ}
+   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 vZSlices = { dZmin + DELTAZ}
    local dPosZ = dZmin + dSliceStep
-   while dPosZ < dZmax do
-      table.insert( ptSlices, dPosZ)
+   while dPosZ < dZmax and nCnt < nMaxSlicesNbr do
+      table.insert( vZSlices, dPosZ)
       dPosZ = dPosZ + dSliceStep
-   end 
-   return ptSlices
+      nCnt = nCnt + 1
+   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
@@ -52,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)
@@ -73,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)
       
@@ -84,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)
@@ -117,6 +193,7 @@ local function GetRibParams( nId)
    ReadParam( nId, KEY_RIBS_LEAD_OUT_WIPE, 'd', 0, RibParam)
    ReadParam( nId, KEY_RIBS_LEAD_OUT_WIPE_DIR, 'd', 0, RibParam)
    ReadParam( nId, KEY_RIBS_OVERLAP, 'd', 0, RibParam)
+   ReadParam( nId, KEY_RIBS_STRAND_OVERLAP, 'd', 0, RibParam)
    ReadParam( nId, KEY_RIBS_LINK, 'b', false, RibParam)
    ReadParam( nId, KEY_RIBS_TYPE, 'i', RIB_TYPE.INTERNAL, RibParam)
    ReadParam( nId, KEY_RIBS_INVERT_STRAND_ORDER, 'b', false, RibParam)
@@ -168,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
@@ -183,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
@@ -219,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
@@ -242,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
@@ -251,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
@@ -273,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
    
@@ -331,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)
@@ -353,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
@@ -364,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
 
@@ -539,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)
 
@@ -577,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)
 
@@ -617,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
 
 --------------------------------------------------------------------
@@ -651,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
 
 ----------------------------------------------------------------------
@@ -680,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
@@ -716,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
@@ -734,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
@@ -785,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
@@ -811,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)
@@ -901,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
@@ -1047,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
 
@@ -1096,10 +1361,24 @@ 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)
+   
+   -- 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 = {}
@@ -1107,6 +1386,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)
@@ -1115,60 +1398,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)
-   --dZmin = 708
-   --dZmax = 712
+   -- 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
 
 ---------------------------------------------------------------------

LuaLibs/RunCalcSolids.lua

@@ -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')
    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,27 +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
-      return CreateStandardSolid( nCrvId, nSolidGrp, LayerParams, dStrand)
+      EgtErase( nGrpTmp)
+      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 = {}
@@ -161,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
@@ -185,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)
@@ -232,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)
@@ -240,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)
@@ -263,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')
@@ -291,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
@@ -346,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
@@ -365,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()
 
@@ -390,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
@@ -409,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
@@ -435,41 +857,85 @@ function RunCalcSolids.Exec()
                      nSolidGrpId = EgtGroup( nCrvGrpId)
                      EgtSetName( nSolidGrpId, SOLID_GRP)
                      EgtSetLevel( nSolidGrpId, GDB_LV.TEMP)
-                     -- scorro le curve del percorso utensile per creare i solidi
+                     
                      local vIds = EgtGetAllInGroup( nTPathGrpId)
                      
-                     if LayerParams.bSpiralVase and #vIds > 2 and EgtGetName( vIds[#vIds]) ~= WIPE_CRV then
-                         -- nel caso a spirale gestione speciale per unire i tratti dei primi layers che sono stati spezzati per feed variabile
-                        local bHasDelta = EgtExistsInfo( vIds[#vIds], KEY_FEED_COEFF)
-                        if bHasDelta then
-                           -- prima curva è a quota costante
-                           CreateSolidFromCurve( vIds[1], nSolidGrpId, LayerParams, nLayer)
-                           -- le rimanenti curve possono essere unite
-                           local vNewIds = EgtTableFill( vIds[2], #vIds-1)
-                           local nNewCrv = EgtCurveCompo( nSolidGrpId, vNewIds, false)
-                           local dStrand = EgtGetInfo( vIds[2], KEY_CRV_STRAND, 'd') or LayerParams.dStrand
-                           EgtSetInfo( nNewCrv, KEY_CRV_STRAND, dStrand)
-                           EgtSetInfo( nNewCrv, KEY_TYPE, TYPE.OUTER_SHELL)
-                           CreateSolidFromCurve( nNewCrv, nSolidGrpId, LayerParams, nLayer)
-                           EgtErase( nNewCrv)
+                     -- 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
-                           local vNewIds = EgtTableFill( vIds[1], #vIds-1)
-                           local nNewCrv = EgtCurveCompo( nSolidGrpId, vNewIds, false)
-                           local dStrand = EgtGetInfo( vIds[2], KEY_CRV_STRAND, 'd') or LayerParams.dStrand
-                           EgtSetInfo( nNewCrv, KEY_CRV_STRAND, dStrand)
-                           EgtSetInfo( nNewCrv, KEY_TYPE, TYPE.OUTER_SHELL)
-                           CreateSolidFromCurve( nNewCrv, nSolidGrpId, LayerParams, nLayer)
-                           EgtErase( nNewCrv)
-                           CreateSolidFromCurve( vIds[#vIds], nSolidGrpId, LayerParams, nLayer)
+                           CreateMultiPlanarSolids( vIds, nSolidGrpId, LayerParams, vLayIds[nIdx])
                         end
                         
-                     else
-                        -- caso standard
+                     -- 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 = {}
                         for i = 1, #vIds do
-                           CreateSolidFromCurve( vIds[i], nSolidGrpId, LayerParams, nLayer)
+                           local sName = EgtGetName( vIds[i])
+                           local dDelta = ( EgtEP( vIds[i], GDB_ID.ROOT) - EgtSP( vIds[i], GDB_ID.ROOT)) * LayerParams.vtSlicing
+                           if abs( dDelta) < GEO.EPS_SMALL or sName == LEAD_IN_CRV or sName == LEAD_OUT_CRV or sName == COASTING_CRV or sName == WIPE_CRV then
+                              -- inserisco il gruppo di tratti da concatenare e lo resetto
+                              if #vTmpIds > 0 then 
+                                 table.insert( vChainedIds, vTmpIds)
+                                 vTmpIds = {}
+                              end
+                              -- inserisco la curva singola corrente
+                              table.insert( vChainedIds, { vIds[i]})
+                           else
+                              table.insert( vTmpIds, vIds[i])
+                           end
+                        end
+                        -- inserisco ultimo gruppo
+                        if #vTmpIds > 0 then
+                           table.insert( vChainedIds, vTmpIds)
+                        end
+                        
+                        for i = 1, #vChainedIds do
+                           if #vChainedIds[i] == 1 then
+                              CreateSolidFromCurve( vChainedIds[i][1], nSolidGrpId, LayerParams, 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, nSliceNbr)
+                              EgtErase( nNewCrv)
+                           end
+                        end
+                        
+                     -- slicing standard
+                     else
+                        for i = 1, #vIds do
+                           CreateSolidFromCurve( vIds[i], nSolidGrpId, LayerParams, nSliceNbr)
                         end
                      end
-                     
                   else
                      bSolidsOk = true
                      break

LuaLibs/RunMachParamFromSWCalc.lua

@@ -189,8 +189,10 @@ function RunMachParamFromSWCalc.Exec()
             dLayerTime = dTotLayerLength / dLayerFeed * 60
          end
          dLayerWait = floor( dTMin + 0.5) - floor( dLayerTime + 0.5)
+         -- sezione dello strand
+         local dSect = max( ( dStrandMean - dSliceStep) * dSliceStep, 0) + pi * dSliceStep * dSliceStep / 4
          -- calcolo la portata
-         local Vf = dLayerFeed * ( ( dStrandMean - dSliceStep) * dSliceStep + pi * pow( dSliceStep / 2, 2)) / 1000
+         local Vf = dLayerFeed * dSect / 1000
          -- calcolo speed
          local dSpeed = ( MATERIAL.K_EXTRUSION / 100.0) * ( MACHINING.K / 100.0) * pow( Vf / MATERIAL.C1, 1 / MATERIAL.C2)
          -- verifico se speed esce da minimo e massimo della macchina
@@ -205,7 +207,7 @@ function RunMachParamFromSWCalc.Exec()
          end
          if not bSpeedOk then
             if dTotLayerLength > 0.1 then
-               dLayerFeed = ( MATERIAL.C1 * pow( ( dSpeed / (( MATERIAL.K_EXTRUSION / 100.0) * ( MACHINING.K / 100.0))), MATERIAL.C2)) * 1000 / ( ( dStrandMean - dSliceStep) * dSliceStep + pi * pow( dSliceStep / 2, 2))
+               dLayerFeed = ( MATERIAL.C1 * pow( ( dSpeed / (( MATERIAL.K_EXTRUSION / 100.0) * ( MACHINING.K / 100.0))), MATERIAL.C2)) * 1000 / dSect
                dLayerTime = dTotLayerLength / dLayerFeed * 60
             end
             dLayerWait = floor( dTMin + 0.5) - floor( dLayerTime + 0.5)

LuaLibs/RunPrepareExport.lua

@@ -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 .. '*')
@@ -108,9 +108,14 @@ local function CalcSpiralVase( nSliceId, nDestGrp)
       -- recupero il solido dal gruppo
       local nSolidGrp = EgtGetFirstNameInGroup( vCrvs[j], SOLID_GRP)
       if nSolidGrp then
+         -- copio solo la prima freccia direzionale
+         local nArrow = EgtGetFirstNameInGroup( nSolidGrp, DIR_ARROW) or GDB_ID.NULL
+         EgtCopyGlob( nArrow, nDestGrp)
          local vSolids = EgtGetAllInGroup( nSolidGrp)
          for i = 1, #vSolids do
-            EgtCopyGlob( vSolids[i], nDestGrp)
+            if EgtGetName( vSolids[i]) ~= DIR_ARROW then
+               EgtCopyGlob( vSolids[i], nDestGrp)
+            end
          end
       end
    end
@@ -151,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')
+   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
@@ -190,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

Version.lua

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