3dPrinting :

- aggiunta possibilità di definire una lavorazione diversa per estrusione orizzontale (da Ini macchina [3dPrinting] HorizExtrusion=TiltedExtrusion).

.gitlab-ci.yml

@@ -16,14 +16,14 @@ variables:
     $FileList = Get-ChildItem("*.lua")
     ForEach ($File in $FileList) {
       $FileName = Split-Path $File -leaf
-      lua54 -o bin\$FileName $FileName
-      echo "lua54 -o bin\$FileName $FileName"
+      lua54 -o bin\$FileName -s $FileName
+      echo "lua54 -o bin\$FileName -s $FileName"
     }
     $FileList = Get-ChildItem("LuaLibs\*.lua")
     ForEach ($File in $FileList) {
       $FileName = Split-Path $File -leaf
-      lua54 -o bin\LuaLibs\$FileName LuaLibs\$FileName
-      echo "lua54 -o bin\LuaLibs\$FileName LuaLibs\$FileName"
+      lua54 -o bin\LuaLibs\$FileName -s LuaLibs\$FileName
+      echo "lua54 -o bin\LuaLibs\$FileName -s LuaLibs\$FileName"
     }
 
 # helper copia SORGENTI verso cartella di rete R:\ dei SORGENTI

Compile.bat

@@ -1,21 +1,21 @@
 
-REM Compilazione degli script 3dPrinting Egaltech                         2023.01.11
+REM Compilazione degli script 3dPrinting Egaltech                         2024.03.27
 REM Per togliere info di debug aggiungere flag -s prima del nome del file di input
 
 REM Compilazione 32 e 64 bit
 
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\AddManData.lua                    LuaLibs\AddManData.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\CalcPaths.lua                     LuaLibs\CalcPaths.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\CalcSlices.lua                    LuaLibs\CalcSlices.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\CalcToolPath.lua                  LuaLibs\CalcToolPath.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\RunCalcSolids.lua                 LuaLibs\RunCalcSolids.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\RunGcodeGenerate.lua              LuaLibs\RunGcodeGenerate.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\RunMachParamFromSWCalc.lua        LuaLibs\RunMachParamFromSWCalc.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\RunPrepareExport.lua              LuaLibs\RunPrepareExport.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\RunSlicing.lua                    LuaLibs\RunSlicing.lua
-\EgtProg\Dll32\luac54 -o bin\CalcMachParamFromSW.lua                   CalcMachParamFromSW.lua
-\EgtProg\Dll32\luac54 -o bin\CalcSolids.lua                            CalcSolids.lua
-\EgtProg\Dll32\luac54 -o bin\GcodeGenerate.lua                         GcodeGenerate.lua
-\EgtProg\Dll32\luac54 -o bin\PrepareExport.lua                         PrepareExport.lua
-\EgtProg\Dll32\luac54 -o bin\Slicing.lua                               Slicing.lua
-\EgtProg\Dll32\luac54 -o bin\Version.lua                               Version.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\AddManData.lua                  -s LuaLibs\AddManData.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\CalcPaths.lua                   -s LuaLibs\CalcPaths.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\CalcSlices.lua                  -s LuaLibs\CalcSlices.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\CalcToolPath.lua                -s LuaLibs\CalcToolPath.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\RunCalcSolids.lua               -s LuaLibs\RunCalcSolids.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\RunGcodeGenerate.lua            -s LuaLibs\RunGcodeGenerate.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\RunMachParamFromSWCalc.lua      -s LuaLibs\RunMachParamFromSWCalc.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\RunPrepareExport.lua            -s LuaLibs\RunPrepareExport.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\RunSlicing.lua                  -s LuaLibs\RunSlicing.lua
+\EgtProg\Dll32\luac54 -o bin\CalcMachParamFromSW.lua                 -s CalcMachParamFromSW.lua
+\EgtProg\Dll32\luac54 -o bin\CalcSolids.lua                          -s CalcSolids.lua
+\EgtProg\Dll32\luac54 -o bin\GcodeGenerate.lua                       -s GcodeGenerate.lua
+\EgtProg\Dll32\luac54 -o bin\PrepareExport.lua                       -s PrepareExport.lua
+\EgtProg\Dll32\luac54 -o bin\Slicing.lua                             -s Slicing.lua
+\EgtProg\Dll32\luac54 -o bin\Version.lua                             -s Version.lua

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"
@@ -140,6 +144,8 @@ KEY_RIBS_USER_LINK_TOT = "RibsUserLinkParts"
 KEY_RIBS_INVERT_STRAND_ORDER = "RibsInvertStrandOrder"
 KEY_RIBS_MERGE_WITH_SHELLS = "RibsMergeWithShell"
 KEY_INVERT_RIBS_MERGED_SHELL_LINK = "InvertRibsMergedShellMainLink"
+KEY_RIBS_LEAD_FILLET = "RibsLeadFillet"
+KEY_RIBS_LINK_FILLET = "RibsLinkFillet"
 
 -- Regioni con diverso numero di passate
 KEY_SHELL_NBR_DIFF = "ShellNbrDifference"
@@ -172,17 +178,22 @@ KEY_AUX_SOLIDS_WIPE_DIR = "AuxSolidsWipeDir"
 
 -- Parametri di macchina
 SEC_3DPRINTING = "3dPrinting"
+KEY_HORIZ_EXTR = "HorizExtrusion"
 KEY_COEFF_X = "CoeffX"
 KEY_COEFF_Y = "CoeffY"
 KEY_SPEED_MIN = "SpeedMin"
 KEY_SPEED_MAX = "SpeedMax"
+KEY_FEED_MAX = 'FeedMax'
+KEY_LINEAR_APPROX = 'LinearApprox'
+KEY_LINEAR_TOL = 'LinearTol'
 
 -- Altre chiavi
 KEY_MAX_H = "SlicingHeight"
+KEY_MAX_SLICES_NBR = "MaxSlicesNumber"
 KEY_SLICE_NBR = "SliceNbr"
-KEY_SLICE_Z = "SliceZ"
+KEY_SLICE_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"
@@ -204,12 +215,16 @@ KEY_CRV_STRAND = "CurveStrand"
 KEY_LAYER_CNT = "LayerCnt"
 KEY_CRV_OFFSET = "CurveOffset"
 KEY_ORIG_REF = "Orig"
+KEY_WIPE_ON_CRV = "WipeOnCrv"
+KEY_FEED_COEFF = 'FeedCoeff'
+KEY_ENTITY_NAME = 'EntityName'
 
-SLICING_TYPE = {
+SLICING_TYPE = {   
    VERTICAL = 1,
    DEG45_X = 2,
    DEG45_Y = 3,
    HORIZONTAL = 4,
+   MULTIPLANAR = 5,
 }
 
 TYPE = {
@@ -292,6 +307,7 @@ LAY_RIBS = "Ribs"
 LAY_AUX_SOLIDS = "AuxSolids"
 LAY_SHELL_NBR = "ShellNumber"
 LAY_AUX = "Aux"
+SPINE_CURVE = "Spine"
 LAY_FRAME = "Frame"
 VIEWPARAMS = 'ViewParams'
 IMPORTED_SOLID = 'ImportedSolid'

LuaLibs/CalcPaths.lua

@@ -21,7 +21,7 @@ local s_vtSlicing
 local s_dOffsTol = 50 * GEO.EPS_SMALL
 
 ---------------------------------------------------------------------
-local function GetLayerParamsForPathCalc()   
+local function GetLayerParamsForPathCalc()
    local LayerParams = {}
    LayerParams.bSpiralVase = EgtGetInfo( s_nPartId, KEY_SPIRAL_VASE, 'b') or false
    LayerParams.nShellsNbr = EgtGetInfo( s_nPartId, KEY_SHELLS_NBR, 'i')
@@ -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)
@@ -184,6 +178,7 @@ local function GetPathsFromSurf( nSrfId, sName, nType, nGrpId, vPtStart)
       for nInd = 0, nCrvCnt - 1 do
          EgtSetName( nCrvId + nInd, sName)
          EgtSetInfo( nCrvId + nInd, KEY_TYPE, nType)
+         EgtModifyCurveExtrusion( nCrvId + nInd, s_vtSlicing, GDB_ID.ROOT)
          
          -- se è loop interno lo inverto per averlo orientato in senso antiorario 
          if nInd > 0 then
@@ -450,7 +445,8 @@ end
 ---------------------------------------------------------------------------
 local function ReorderPath( vOldIds, vNewIds)
    
-   if not vNewIds or not vOldIds then return end
+   if not vNewIds or #vNewIds == 0 then return end
+   if not vOldIds or #vOldIds == 0 then return end
    
    -- suddivido in base alla tipologia di loop ( esterno o interno)
    local tOldIds = {{}, {}}
@@ -720,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
@@ -979,7 +968,7 @@ end
 -------------------------------------------------------------------
 local function FindHoleCurve( pt, vLoopIds)
    -- trovo indice della curva di vLoopIds a cui appartiene pt ( in globale)
-   if not vLoopIds then return end
+   if not vLoopIds or #vLoopIds == 0 then return end
    for i = 1, #vLoopIds do
       local dPar = EgtCurveParamAtPoint( vLoopIds[i], pt, 100 * GEO.EPS_SMALL, GDB_RT.GLOB)
       if dPar then
@@ -1285,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
@@ -1301,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)
@@ -1422,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
@@ -1441,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
@@ -1605,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')
@@ -1617,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')
@@ -1676,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 {}
@@ -1725,13 +1721,12 @@ end
 local function HandleRibsIntersections( nRibsGrp, nOffsGrp, nRibsPathGrp, nSrfInt, nSrfExt, bAllTwoStrands, vTypeSequence, nLoopGrp, tSurfOffs)
 
    local bSpecialCase = false
-   local vOffsIds = EgtGetNameInGroup( nRibsPathGrp, RIBS_CRV .. '*')   -- passate dei setti
    local vAllRibsIds = EgtGetNameInGroup( nRibsGrp, RIBS_CRV .. '*')    -- setti originali
    local vRibsIds = {}
    -- ignoro setti che non hanno passate corrispondenti
    for i = 1, #vAllRibsIds do
       local vOffs = EgtGetNameInGroup( nRibsPathGrp, EgtGetName( vAllRibsIds[i]))
-      if vOffs then table.insert( vRibsIds, vAllRibsIds[i]) end
+      if vOffs and #vOffs > 0 then table.insert( vRibsIds, vAllRibsIds[i]) end
    end
    
    -- creo un gruppo con frame locale per calcolare le intersezioni ( è il piano XY locale dove calcolare intersezioni)
@@ -2039,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()
@@ -2142,8 +2140,11 @@ 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')
+               CopyInfo( vOrig[i], nId, KEY_RIBS_LEAD_FILLET, 'd')
                bStart = true
             end
             -- verifico se corrisponde al suo end
@@ -2391,7 +2392,7 @@ local function CalcRibsPaths( nSliceGrp, nRibsGrp, LayerParams, vPtStart, bIgnor
       local nSrfInt = EgtGetFirstNameInGroup( vCrvGrps[i], TOT_SHELL_TRIM_SURF) or GDB_ID.NULL
       if nTotSrfInt == GDB_ID.NULL and nSrfInt ~= GDB_ID.NULL then
          nTotSrfInt = EgtCopyGlob( nSrfInt, nRibsGrp)
-      elseif nTotSrfInt ~= GDB_ID.NULL then
+      elseif nTotSrfInt ~= GDB_ID.NULL and nSrfInt ~= GDB_ID.NULL then
          if not EgtSurfFrAdd( nTotSrfInt, nSrfInt) then
             EgtOutLog( 'Error : EgtSurfFrAdd for external ribs failed. Errors may occur with user-linked ribs (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths')
          end
@@ -2500,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
@@ -2526,6 +2527,90 @@ end
 
 --------------------------------------------------------------------
 --------------------- RIBS-MERGED SHELLS ---------------------------
+--------------------------------------------------------------------
+local function CalcFillet( nCrv1, nCrv2, dFillet, nGrpId, nGrpTmp)
+
+   if dFillet < GEO.EPS_SMALL then return end
+   
+   -- creo il fillet
+   local dParRef1 = EgtCurveParamAtLength( nCrv1, EgtCurveLength( nCrv1) - 100 * GEO.EPS_SMALL)
+   local dParRef2 = EgtCurveParamAtLength( nCrv2, 100 * GEO.EPS_SMALL)
+   local nFillet = EgtCurveFillet( nGrpTmp, nCrv1, EgtUP( nCrv1, dParRef1, nGrpTmp), nCrv2, EgtUP( nCrv2, dParRef2, nGrpTmp), dFillet, true, GDB_RT.LOC)
+   if not nFillet then
+      -- ritento con valore di fillet leggermente inferiore
+      nFillet = EgtCurveFillet( nGrpTmp, nCrv1, EgtUP( nCrv1, dParRef1, nGrpTmp), nCrv2, EgtUP( nCrv2, dParRef2, nGrpTmp), dFillet - 50 * GEO.EPS_SMALL, true, GDB_RT.LOC)
+   end
+
+   -- spezzo a metà il fillet per assegnarlo alle due curve
+   if nFillet then
+      local nNewFillet = EgtSplitCurve( nFillet, 2)
+      
+      -- aggiungo a nCrv1
+      if EgtExistsObj( nCrv1) then
+         EgtAddCurveCompoArcTg( nCrv1, EgtEP( nNewFillet, GDB_ID.ROOT), true, GDB_RT.GLOB)
+         EgtErase( nNewFillet)
+      else
+         -- nCrv1 viene sostituita completamente dal fillet
+         local nNewCrv = EgtCurveCompo( nGrpId, {nNewFillet})
+         EgtChangeId( nNewCrv, nCrv1)
+      end
+      
+      -- aggiungo a nCrv2
+      if EgtExistsObj( nCrv2) then
+         EgtAddCurveCompoArcTg( nCrv2, EgtSP( nNewFillet + 1, GDB_ID.ROOT), false, GDB_RT.GLOB)
+         EgtErase( nNewFillet + 1)
+      else
+         -- nCrv2 viene sostituita completamente dal fillet
+         local nNewCrv = EgtCurveCompo( nGrpId, {nNewFillet + 1})
+         EgtChangeId( nNewCrv, nCrv2)
+      end
+   else
+      EgtOutLog( 'Warning : ribs-merged shells fillet not possible (layer '..tostring( s_nCurrIdx)..') - CalcPath')
+   end
+   
+   EgtRelocateGlob( nFillet or GDB_ID.NULL, nGrpId)
+end
+
+--------------------------------------------------------------------
+local function AddFillet( nRib1, vLinks, nRib2, nGrpId)
+   
+   local dFillet1 = EgtGetInfo( nRib1, KEY_RIBS_LINK_FILLET, 'd')
+   local dFillet2 = EgtGetInfo( nRib2, KEY_RIBS_LINK_FILLET, 'd')
+   -- verifico se necessaria correzione per passate dello stesso setto
+   local nOrig1 = EgtGetInfo( nRib1, KEY_ORIGINAL_RIB, 'i')
+   local nOrig2 = EgtGetInfo( nRib2, KEY_ORIGINAL_RIB, 'i')
+   local nSplit1 = EgtGetInfo( nRib1, KEY_SPLIT_ID, 'i') or 0
+   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')
+      local dStrandOverlap = EgtGetInfo( nRib1, KEY_RIBS_STRAND_OVERLAP, 'd')
+      dFillet1 = min( dFillet1, 0.5 * ( 1 - dStrandOverlap / 100) * dStrand)
+      dFillet2 = dFillet1
+   end
+   
+   -- creo un gruppo con riferimento locale allo slicing per i conti del fillet
+   local nGrpTmp = EgtGroup( nGrpId, Frame3d( ORIG(), s_vtSlicing), GDB_RT.GLOB)
+   
+   -- calcolo il primo fillet
+   local ptRib1 = EgtEP( nRib1, GDB_ID.ROOT)
+   for i = 1, #vLinks do
+      if AreSamePointApprox( ptRib1, EgtSP( vLinks[i], GDB_ID.ROOT)) then
+         CalcFillet( nRib1, vLinks[i], dFillet1, nGrpId, nGrpTmp)
+         break
+      end
+   end
+   -- calcolo il secondo fillet
+   local ptRib2 = EgtSP( nRib2, GDB_ID.ROOT)
+   for i = 1, #vLinks do
+      if AreSamePointApprox( EgtEP( vLinks[i], GDB_ID.ROOT), ptRib2) then
+         CalcFillet( vLinks[i], nRib2, dFillet2, nGrpId, nGrpTmp)
+         break
+      end
+   end
+
+   EgtErase( nGrpTmp)
+end
+
 --------------------------------------------------------------------
 local function ComputeShortestLinkOnCurve( nCrv, dParS, dParE, nGrp)
    
@@ -2721,7 +2806,7 @@ local function HandleRibsIntersectionForRibsMergedShells( vOrigRibs, nRibsGrp, n
    -- ignoro setti che non hanno passate corrispondenti
    for i = 1, #vOrigRibs do
       local vOffs = EgtGetNameInGroup( nRibsGrp, EgtGetName( vOrigRibs[i]))
-      if vOffs then table.insert( vRibsIds, vOrigRibs[i]) end
+      if vOffs and #vOffs > 0 then table.insert( vRibsIds, vOrigRibs[i]) end
    end
    
    -- creo un gruppo con frame locale per calcolare le intersezioni ( è il piano XY locale dove calcolare intersezioni)
@@ -2747,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')
@@ -2776,6 +2870,8 @@ local function HandleRibsIntersectionForRibsMergedShells( vOrigRibs, nRibsGrp, n
                      if nLinkId then
                         local nRes = EgtCurveWithRegionClassify( nLinkId, nShellSrf)
                         if nRes == GDB_CRC.IN then
+                           -- fillet
+                           AddFillet( nCrv, {nLinkId}, nCrv + 1, nRibsGrp)
                            EgtAddCurveCompoCurve( nCrv + 1, nLinkId, true, false)
                            EgtAddCurveCompoCurve( nCrv + 1, nCrv, true, false)
                         else
@@ -2881,6 +2977,7 @@ local function CreateRibsMergedShellLastLink( vShells, vRibs, nGrp, bInvert)
          if bInvert then
             -- conservo tratto dParS->dParE
             EgtTrimCurveStartEndAtParam( nLink, dParS, dParE)
+            EgtInvertCurve( nLink)
          else
             -- conservo tratto dParE->dParS
             EgtTrimCurveStartEndAtParam( nLink, dParE, dParS)
@@ -2923,6 +3020,8 @@ local function CreateRibsMergedShellLastLink( vShells, vRibs, nGrp, bInvert)
                            end
                         end
                         if nPartLink then
+                           -- fillet
+                           AddFillet( vRibs[i], {nPartLink}, nOtherPart, nGrp)
                            EgtAddCurveCompoCurve( vRibs[i], nPartLink)
                            EgtAddCurveCompoCurve( vRibs[i], nOtherPart)
                         end
@@ -3012,23 +3111,39 @@ end
 
 --------------------------------------------------------------------
 local function AdjustRibsMergedExtraShellLink( nLinkId, vExtraShells, nGrp)
+
+   local vLinks = {}
    
-   local frLoc = Frame3d( ORIG(), s_vtSlicing)
-   local nGrpLoc = EgtGroup( nGrp, frLoc)
-   
-   -- 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)
+      
+      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
 
 --------------------------------------------------------------------
@@ -3070,7 +3185,7 @@ local function CreateRibsMergedShellCurve( nGrp, nRibsGrp, vShells, vOrigShells,
       -- creo il link
       local nLinkId = CreateRibsMergedShellLink( nCurr, nNext, nGrp, EgtIf( bLinkOnShell, vLoopsShell, vLoopsTrim), nRibsGrp)
       if not nLinkId then
-         return false 
+         return false
       end
 
       -- se link fatto sulla shell verifico non si sovrapponga al last link 
@@ -3092,16 +3207,24 @@ local function CreateRibsMergedShellCurve( nGrp, nRibsGrp, vShells, vOrigShells,
       end
       
       -- verifico se necessari aggiustamenti per extra shell
+      local vLinks
       if bExtraShell and bLinkOnShell then
-         AdjustRibsMergedExtraShellLink( nLinkId, vOrigShells, nGrp)
+         vLinks = AdjustRibsMergedExtraShellLink( nLinkId, vOrigShells, nGrp)
       end
       
+      -- fillet
+      AddFillet( nCurr, vLinks or {nLinkId}, nNext, nGrp)
+      
    end
    
    -- eventuali aggiustamenti del last link per extra shell
+   local vLastLinks
    if bExtraShell then
-       AdjustRibsMergedExtraShellLink( nLastLink, vOrigShells, nGrp)
+      vLastLinks = AdjustRibsMergedExtraShellLink( nLastLink, vOrigShells, nGrp)
    end
+   
+   -- fillet sul last link
+   AddFillet( vRibs[#vRibs], vLastLinks or {nLastLink}, vRibs[1], nGrp)
 
    -- elimino le curve inutili e le superfici
    EgtErase( nRibsGrp)
@@ -3649,7 +3772,7 @@ local function ReorderExtraShells( nPathGrp, vPtStart, LayerParams)
    end
    
    local vIds = EgtGetNameInGroup( nPathGrp, EXTRA_SHELL_CRV .. '*')
-   if not vIds then return end
+   if not vIds or #vIds == 0 then return end
    
    -- eventuale inversione di tutte le curve
    if LayerParams.bPrintInvert then
@@ -3998,7 +4121,7 @@ end
 local function AddExtraZigZag( nSrf, sName, dStrand, nGrp, nSrfTrim)
    
    local vIds = EgtGetNameInGroup( nGrp, sName)
-   if not vIds then return end
+   if not vIds or #vIds == 0 then return end
    local vtDir = EgtSV( vIds[1], GDB_ID.ROOT)
    local vtYLoc = s_vtSlicing ^ vtDir
    
@@ -4205,7 +4328,7 @@ function CalcPaths.Exec( nPartId)
    s_nPartId = nPartId
 
    local vLayIds = EgtGetNameInGroup( s_nPartId, SLICE_LAYER.."*")
-   if not vLayIds then
+   if not vLayIds or #vLayIds == 0 then
       EgtOutBox( 'Error no slice', 'PathCalc')
       return true
    end
@@ -4214,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,11 +193,14 @@ 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)
    ReadParam( nId, KEY_RIBS_MERGE_WITH_SHELLS, 'b', false, RibParam)
-  
+   ReadParam( nId, KEY_RIBS_LEAD_FILLET, 'd', 0, RibParam)
+   ReadParam( nId, KEY_RIBS_LINK_FILLET, 'd', 0, RibParam)
+   
    return RibParam
 end
 
@@ -166,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
@@ -181,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
@@ -217,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
@@ -240,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
@@ -249,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
@@ -271,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
    
@@ -329,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)
@@ -351,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
@@ -362,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
 
@@ -537,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)
 
@@ -575,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)
 
@@ -615,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
 
 --------------------------------------------------------------------
@@ -649,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
 
 ----------------------------------------------------------------------
@@ -678,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
@@ -714,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
@@ -732,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
@@ -783,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
@@ -809,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)
@@ -899,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
@@ -998,6 +1228,7 @@ local function SlicingWithSolid( nStmId, vZSlices, dDeltaZStart, dZmin, frSlicin
          
          if #vOpenId > 1 then
             EgtOutLog( 'Error : hole in solid (layer '.. EgtNumToString( nLayCnt) ..') - CalcSlices')
+            table.insert( s_vErr, nLayCnt)
          end
       else
          
@@ -1044,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
 
@@ -1093,10 +1361,26 @@ function CalcSlices.Exec( nPartId, nStmId)
       vtSlicing = VectorFromSpherical( 1, 45, dHorAng)
    elseif nSlicingType == SLICING_TYPE.HORIZONTAL then
       vtSlicing = X_AX()
+   elseif nSlicingType == SLICING_TYPE.MULTIPLANAR then
+      -- la direzione può cambiare da un piano all'altro
+      vtSlicing = Z_AX()
    end
 
-   EgtSetInfo( s_nPartId, KEY_SLICING_DIR, vtSlicing)
-   local frSlicing = Frame3d( ORIG(), vtSlicing)
+   EgtSetInfo( s_nPartId, KEY_SLICE_DIR, vtSlicing)
+   -- per compatibilità con vecchie macchine
+   EgtSetInfo( s_nPartId, 'SlicingDir', vtSlicing)
+   
+   -- recupero parametri di slicing
+   local dSliceStep = EgtGetInfo( s_nPartId, KEY_SLICE_STEP, 'd') or 10000
+   if dSliceStep < GEO.EPS_SMALL then
+      EgtOutLog( 'Warning : SliceStep is 0')
+      return
+   end
+   s_dStrand = EgtGetInfo( s_nPartId, KEY_STRAND, 'd')
+   local nMaxSlicesNbr = EgtGetInfo( s_nPartId, KEY_MAX_SLICES_NBR, 'i') or 0
+   if nMaxSlicesNbr == 0 then
+      nMaxSlicesNbr = GEO.INFINITO   -- da gestire come caso illimitato
+   end
    
    -- recupero la superficie ed eventuali setti esterni/unbounded da usare come riferimenti per quote slicing
    local vRefIds = {}
@@ -1104,6 +1388,10 @@ function CalcSlices.Exec( nPartId, nStmId)
    local nRibsLay = EgtGetFirstNameInGroup( s_nPartId, LAY_RIBS)
    local vRibsIds = EgtGetAllInGroup( nRibsLay)
    local bLimitUnbddRibs = EgtGetInfo( s_nPartId, KEY_LIMIT_UNBDD_RIBS, 'b') or false
+   if bLimitUnbddRibs and not nStmId then
+      EgtOutBox( "No solid to limit unbounded ribs!", 'Error', 'ERROR')
+      return
+   end
    for i = 1, #vRibsIds do
       if EgtGetType( vRibsIds[i]) == GDB_TY.SRF_MESH then
          local nType = ReadParam( vRibsIds[i], KEY_RIBS_TYPE, 'i', RIB_TYPE.INTERNAL)
@@ -1112,60 +1400,40 @@ function CalcSlices.Exec( nPartId, nStmId)
          end
       end
    end
-   
-   if bLimitUnbddRibs and not nStmId then
-      EgtOutBox( "No solid to limit unbounded ribs!", 'Error', 'ERROR')
-      return
-   end
-   
-   -- recupero il box
-   local b3Box = BBox3d()
-   for i = 1, #vRefIds do
-      local b3Tmp = EgtGetBBoxRef( vRefIds[i], GDB_BB.STANDARD, frSlicing)
-      b3Box:Add( b3Tmp)
-   end
-   if not b3Box or b3Box:isEmpty() then
+   if #vRefIds == 0 then
       EgtOutBox( "No part to be sliced!", 'Error', 'ERROR')
-      return
+      return false
    end
-   
-   -- Parametri di slicing
-   local dSliceStep = EgtGetInfo( s_nPartId, KEY_SLICE_STEP, 'd') or 10000
-   if dSliceStep < GEO.EPS_SMALL then
-      EgtOutLog( 'Warning : SliceStep is 0')
-      return
-   end
-   s_dStrand = EgtGetInfo( s_nPartId, KEY_STRAND, 'd')
 
-   local dZmin = b3Box:getMin():getZ()
-   local dZmax = b3Box:getMax():getZ()
-   local dMaxH = ComputeMaxH( vRefIds, frSlicing, dSliceStep)
-   dZmax = min( dZmax, dMaxH)
-   --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/RunGcodeGenerate.lua

@@ -33,10 +33,11 @@ function RunGcodeGenerate.Exec()
       EgtOutBox( 'Error missing part', 'GcodeGenerate')
       return 
    end
+   local nSlicingType = EgtGetInfo( nPartId, KEY_SLICING_TYPE, 'i')
 
    -- Recupero i layer da processare
    local vLayIds = EgtGetNameInGroup( nPartId, SLICE_LAYER.."*") 
-   if not vLayIds then
+   if not vLayIds or #vLayIds == 0 then
    EgtOutBox( 'Error missing slices', 'GcodeGenerate')
       return 
    end
@@ -89,8 +90,15 @@ function RunGcodeGenerate.Exec()
    -- Rimuovo eventuali precedenti lavorazioni
    EgtRemoveAllOperations()
 
+   -- Determino lavorazione di libreria
+   local sExtrName = 'Extrusion'
+   if nSlicingType == SLICING_TYPE.HORIZONTAL then
+      local sMachIni = EgtGetCurrMachineDir() .. '\\' .. EgtGetCurrMachineName() .. '.ini'
+      sExtrName = EgtGetStringFromIni( SEC_3DPRINTING, KEY_HORIZ_EXTR, sExtrName, sMachIni)
+   end
+
    -- Aggiungo la lavorazione
-   local nMchId = EgtAddMachining( 'Extrusion 1', 'Extrusion')
+   local nMchId = EgtAddMachining( 'Extrusion 1', sExtrName)
    if not nMchId then
       EgtOutBox( 'Error adding Extrusion', 'GcodeGenerate')
       return

LuaLibs/RunMachParamFromSWCalc.lua

@@ -53,6 +53,8 @@ function RunMachParamFromSWCalc.Exec()
    local sMachIni = EgtGetCurrMachineDir() .. '\\' .. EgtGetCurrMachineName() .. '.ini'
    local dSMin = tonumber( EgtGetStringFromIni( SEC_3DPRINTING, KEY_SPEED_MIN, 0, sMachIni))
    local dSMax = tonumber( EgtGetStringFromIni( SEC_3DPRINTING, KEY_SPEED_MAX, 50000, sMachIni))
+   -- recupero Feed massima dalla macchina
+   local dFLimit = tonumber( EgtGetStringFromIni( SEC_3DPRINTING, KEY_FEED_MAX, 10000, sMachIni))
    -- massa materiale utilizzato
    local dPrintMass = 0
    -- massimo indice di layer calcolato
@@ -187,8 +189,10 @@ function RunMachParamFromSWCalc.Exec()
             dLayerTime = dTotLayerLength / dLayerFeed * 60
          end
          dLayerWait = floor( dTMin + 0.5) - floor( dLayerTime + 0.5)
+         -- sezione dello strand
+         local dSect = max( ( dStrandMean - dSliceStep) * dSliceStep, 0) + pi * dSliceStep * dSliceStep / 4
          -- calcolo la portata
-         local Vf = dLayerFeed * ( ( dStrandMean - dSliceStep) * dSliceStep + pi * pow( dSliceStep / 2, 2)) / 1000
+         local Vf = dLayerFeed * dSect / 1000
          -- calcolo speed
          local dSpeed = ( MATERIAL.K_EXTRUSION / 100.0) * ( MACHINING.K / 100.0) * pow( Vf / MATERIAL.C1, 1 / MATERIAL.C2)
          -- verifico se speed esce da minimo e massimo della macchina
@@ -203,7 +207,7 @@ function RunMachParamFromSWCalc.Exec()
          end
          if not bSpeedOk then
             if dTotLayerLength > 0.1 then
-               dLayerFeed = ( MATERIAL.C1 * pow( ( dSpeed / (( MATERIAL.K_EXTRUSION / 100.0) * ( MACHINING.K / 100.0))), MATERIAL.C2)) * 1000 / ( ( dStrandMean - dSliceStep) * dSliceStep + pi * pow( dSliceStep / 2, 2))
+               dLayerFeed = ( MATERIAL.C1 * pow( ( dSpeed / (( MATERIAL.K_EXTRUSION / 100.0) * ( MACHINING.K / 100.0))), MATERIAL.C2)) * 1000 / dSect
                dLayerTime = dTotLayerLength / dLayerFeed * 60
             end
             dLayerWait = floor( dTMin + 0.5) - floor( dLayerTime + 0.5)
@@ -219,10 +223,22 @@ function RunMachParamFromSWCalc.Exec()
             local CurrWidth = LengthCrvList[nWidthIndex]
             local CurrFeed = EgtIf( CurrWidth.Width > 0, dLayerFeed * dStrandMean / CurrWidth.Width, dLayerFeed) 
             for nCurveIdIndex = 1, #CurrWidth.IdList do
-               EgtSetInfo( CurrWidth.IdList[nCurveIdIndex], KEY_FEED, CurrFeed)               
-            end
-            if CurrFeed > dFeedMax then
-               dFeedMax = CurrFeed
+               local dNewFeed = CurrFeed
+               -- verifico se coefficiente moltiplicativo per feed
+               local dCoeff = EgtGetInfo( CurrWidth.IdList[nCurveIdIndex], KEY_FEED_COEFF, 'd')
+               if dCoeff then
+                  dNewFeed = dCoeff * CurrFeed
+                  if dNewFeed > dFLimit then
+                     local dNewSpeed = dSpeed * dFLimit / dNewFeed
+                     dNewSpeed = EgtClamp( dNewSpeed, dSMin, dSMax)
+                     dNewFeed = dFLimit
+                     EgtSetInfo( CurrWidth.IdList[nCurveIdIndex], KEY_SPEED, dNewSpeed)
+                  end
+               end
+               EgtSetInfo( CurrWidth.IdList[nCurveIdIndex], KEY_FEED, dNewFeed)
+               if dNewFeed > dFeedMax then
+                  dFeedMax = dNewFeed
+               end
             end
          end
          -- scrivo info speed in group toolpath

LuaLibs/RunPrepareExport.lua

@@ -28,52 +28,56 @@ local function CalcCurves( nSliceId, nDestGrp, vtSlicing, dStrandBase)
             if nType ~= TYPE.WIPE then
                local dStrand = EgtGetInfo( nId, KEY_CRV_STRAND, 'd') or dStrandBase
                
-               -- calcolo fat curve a partire da una copia della curva ( in questo modo nel DB geometrico non restano
+               -- calcolo fat region a partire da una copia della curva ( in questo modo nel DB geometrico non restano
                -- salvati i diagrammi di Voronoi che non servono per conti futuri)
                local nCopy = EgtCopyGlob( nId, nDestGrp)
-               local nCrv, nCnt = EgtCurveGetFatCurve( nCopy, nDestGrp, 0.5 * dStrand, false)
+               local nSurf = EgtSurfFrFatCurve( nDestGrp, nCopy, 0.5 * dStrand, false)
                -- se fallisce ritento con valore leggermente diverso
-               if not nCrv or nCnt == 0 then
-                  nCrv, nCnt = EgtCurveGetFatCurve( nCopy, nDestGrp, 0.5 * dStrand - 0.05, false)
+               if not nSurf or nSurf == GDB_ID.NULL then
+                  nSurf = EgtSurfFrFatCurve( nDestGrp, nCopy, 0.5 * dStrand - 0.05, false)
                end
                EgtErase( nCopy)
                  
-               if nCrv and nCnt > 0 then
-                  -- se sono curve chiuse piccoli aggistamenti per creare un percorso unico
-                  if nCnt > 1 then
-                     for nLoopId = nCrv + 1, nCrv + nCnt - 1 do
-                        EgtInvertCurve( nLoopId)
-                        local dLen = EgtCurveLength( nLoopId)
-                        local dPar1 = EgtCurveParamAtLength( nLoopId, dLen * 0.5)
-                        local dPar2 = EgtCurveParamAtLength( nLoopId, dLen * 0.5 + 2 * GEO.EPS_SMALL)
-                        local ptM = EgtUP( nLoopId, dPar1)
-                        local ptM2 = EgtUP( nLoopId, dPar2)
-                        local _, _, dParRef1 = EgtPointCurveDist( ptM, nCrv)
-                        local _, _, dParRef2 = EgtPointCurveDist( ptM, nCrv)
-                        EgtTrimCurveStartEndAtParam( nCrv, dParRef2, dParRef1)
-                        EgtTrimCurveStartEndAtParam( nLoopId, dPar2, dPar1)
-                        EgtInvertCurve( nLoopId)
-                        EgtAddCurveCompoLine( nCrv, EgtSP( nLoopId))
-                        EgtAddCurveCompoCurve( nCrv, nLoopId)
-                        EgtCloseCurveCompo( nCrv)
+               if nSurf then
+                  local nChunks = EgtSurfFrChunkCount( nSurf)
+                  for k = 0, nChunks - 1 do
+                     -- estraggo i loop associati
+                     local nCrv, nCnt = EgtExtractSurfFrChunkLoops( nSurf, k, nDestGrp)
+                     -- eventuali aggiustamenti per creare un percorso unico
+                     if nCnt > 1 then
+                        for nLoopId = nCrv + 1, nCrv + nCnt - 1 do
+                           local dLen = EgtCurveLength( nLoopId)
+                           local dPar1 = EgtCurveParamAtLength( nLoopId, dLen * 0.5)
+                           local dPar2 = EgtCurveParamAtLength( nLoopId, dLen * 0.5 + 2 * GEO.EPS_SMALL)
+                           local ptM = EgtUP( nLoopId, dPar1)
+                           local ptM2 = EgtUP( nLoopId, dPar2)
+                           local _, _, dParRef1 = EgtPointCurveDist( ptM2, nCrv)
+                           local _, _, dParRef2 = EgtPointCurveDist( ptM, nCrv)
+                           EgtTrimCurveStartEndAtParam( nCrv, dParRef2, dParRef1)
+                           EgtTrimCurveStartEndAtParam( nLoopId, dPar2, dPar1)
+                           EgtAddCurveCompoLine( nCrv, EgtSP( nLoopId))
+                           EgtAddCurveCompoCurve( nCrv, nLoopId)
+                           EgtCloseCurveCompo( nCrv)
+                        end
+                     end
+                     
+                     if nType == TYPE.OUTER_SHELL or nType == TYPE.EXTRA_OUTER_SHELL then 
+                        EgtSetColor( nCrv, EgtStdColor( 'TEAL'))
+                     elseif nType == TYPE.INNER_SHELL or nType == TYPE.EXTRA_SHELL then
+                        EgtSetColor( nCrv, EgtStdColor( 'ORANGE'))
+                     elseif nType == TYPE.LINK then
+                        EgtSetColor( nCrv, EgtStdColor( 'GRAY'))
+                     elseif nType == TYPE.INFILL then
+                        EgtSetColor( nCrv, EgtStdColor( 'YELLOW'))
+                     elseif nType == TYPE.COASTING then
+                        EgtSetColor( nCrv, EgtStdColor( 'BLUE'))
+                     elseif nType == TYPE.RIB then
+                        EgtSetColor( nCrv, EgtStdColor( 'OLIVE'))
+                     elseif nType == TYPE.AUX_SOLID then
+                        EgtSetColor( nCrv, EgtStdColor( 'AQUA'))
                      end
                   end
-                  
-                  if nType == TYPE.OUTER_SHELL or nType == TYPE.EXTRA_OUTER_SHELL then 
-                     EgtSetColor( nCrv, EgtStdColor( 'TEAL'))
-                  elseif nType == TYPE.INNER_SHELL or nType == TYPE.EXTRA_SHELL then
-                     EgtSetColor( nCrv, EgtStdColor( 'ORANGE'))
-                  elseif nType == TYPE.LINK then
-                     EgtSetColor( nCrv, EgtStdColor( 'GRAY'))
-                  elseif nType == TYPE.INFILL then
-                     EgtSetColor( nCrv, EgtStdColor( 'YELLOW'))
-                  elseif nType == TYPE.COASTING then
-                     EgtSetColor( nCrv, EgtStdColor( 'BLUE'))
-                  elseif nType == TYPE.RIB then
-                     EgtSetColor( nCrv, EgtStdColor( 'OLIVE'))
-                  elseif nType == TYPE.AUX_SOLID then
-                     EgtSetColor( nCrv, EgtStdColor( 'AQUA'))
-                  end
+                  EgtErase( nSurf)
                end
             end
             
@@ -96,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 .. '*')
@@ -104,9 +108,14 @@ local function CalcSpiralVase( nSliceId, nDestGrp)
       -- recupero il solido dal gruppo
       local nSolidGrp = EgtGetFirstNameInGroup( vCrvs[j], SOLID_GRP)
       if nSolidGrp then
+         -- copio solo la prima freccia direzionale
+         local nArrow = EgtGetFirstNameInGroup( nSolidGrp, DIR_ARROW) or GDB_ID.NULL
+         EgtCopyGlob( nArrow, nDestGrp)
          local vSolids = EgtGetAllInGroup( nSolidGrp)
          for i = 1, #vSolids do
-            EgtCopyGlob( vSolids[i], nDestGrp)
+            if EgtGetName( vSolids[i]) ~= DIR_ARROW then
+               EgtCopyGlob( vSolids[i], nDestGrp)
+            end
          end
       end
    end
@@ -147,10 +156,11 @@ function RunPrepareExport.Exec()
    -- recupero alcune info utili e le assegno al punto per poterle leggere da ThreeJS
    local dH = EgtGetInfo( nPartId, KEY_SLICE_STEP, 'd')
    EgtSetInfo( nPnt, KEY_SLICE_STEP, dH)
-   local vtSlicing = EgtGetInfo( nPartId, KEY_SLICING_DIR, 'v')
-   EgtSetInfo( nPnt, KEY_SLICING_DIR, vtSlicing)
+   local vtSlicing = EgtGetInfo( nPartId, KEY_SLICE_DIR, 'v') or EgtGetInfo( nPartId, "SlicingDir", 'v')
+   EgtSetInfo( nPnt, "SlicingDir", vtSlicing)
    local bSpiralVase = EgtGetInfo( nPartId, KEY_SPIRAL_VASE, 'b') or false
    EgtSetInfo( nPnt, KEY_SPIRAL_VASE, bSpiralVase)
+   local nSlicingType = EgtGetInfo( nPartId, KEY_SLICING_TYPE, 'i')
    
    -- recupero lo strand dai parametri generale nel caso non fosse definito sulle singole curve
    local dStrandBase = EgtGetInfo( nPartId, KEY_STRAND, 'd') or 0
@@ -186,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/02/13
+-- Version.lua by Egaltech s.r.l. 2026/03/23
 -- Gestione della versione di 3dPrinting
 
-VERSION = '2.6b1'
+VERSION = '3.1c3'