3dPrinting 3.1c1 :

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

.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

.vscode/settings.json

@@ -0,0 +1,34 @@
+{
+    "Lua.diagnostics.globals": [
+        "MATERIAL",
+        "EgtGetFirstNameInGroup",
+        "GDB_ID",
+        "EgtGroup",
+        "EgtSetLevel",
+        "EgtSetName",
+        "GDB_LV",
+        "EgtGetCurrMachineDir",
+        "EgtGetCurrMachineName",
+        "EgtGetStringFromIni",
+        "EgtGetFirstPart",
+        "EgtGetInfo",
+        "EgtGetNextPart",
+        "EgtGetLastNameInGroup",
+        "EgtRemoveInfo",
+        "EgtGetFirstInGroup",
+        "EgtGetName",
+        "EgtCurveLength",
+        "EgtGetNext",
+        "EgtCurveArea",
+        "EgtGetNextName",
+        "EgtSetInfo",
+        "floor",
+        "pi",
+        "pow",
+        "EgtProcessEvents",
+        "EgtEmptyGroup",
+        "EgtOutLog",
+        "EgtIf",
+        "EgtProtectGlobal"
+    ]
+}

Compile.bat

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

LuaLibs/AddManData.lua

@@ -28,8 +28,12 @@ LINK_CRV = "Link"
 FRAME_PART = "FramePart"
 START_GEOM = "Start"
 TOT_SHELL_TRIM_SURF = "TotalShellSurfForTrim"
+SHELL_SURF = "ShellSurf"
+COARSE_TRIM_SURF = "CoarseTrimSurf"
 TRIM_SURF_LOOP = "TrimSurfLoop"
 SURF_LOOP = "SurfLoop"
+LOOP_GRP = "LoopGrp"
+DIR_ARROW = "Arrow"
 
 MIN_LEN = 0.1
 MIN_AREA = 0.01
@@ -41,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"
@@ -80,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"
@@ -107,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"
@@ -134,6 +142,10 @@ KEY_RIBS_USER_LINK_CCW = "RibUserLinkCCW"
 KEY_RIBS_USER_LINK_ORDER = "RibUserLinkOrder"
 KEY_RIBS_USER_LINK_TOT = "RibsUserLinkParts"
 KEY_RIBS_INVERT_STRAND_ORDER = "RibsInvertStrandOrder"
+KEY_RIBS_MERGE_WITH_SHELLS = "RibsMergeWithShell"
+KEY_INVERT_RIBS_MERGED_SHELL_LINK = "InvertRibsMergedShellMainLink"
+KEY_RIBS_LEAD_FILLET = "RibsLeadFillet"
+KEY_RIBS_LINK_FILLET = "RibsLinkFillet"
 
 -- Regioni con diverso numero di passate
 KEY_SHELL_NBR_DIFF = "ShellNbrDifference"
@@ -170,12 +182,17 @@ 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"
@@ -194,12 +211,19 @@ KEY_INTERNAL_SRF_LOOP = "InternalSrfLoop"
 KEY_PREV_CRV = "PrevCrv"
 KEY_NEXT_CRVS = "NextCrvs"
 KEY_CRV_STRAND = "CurveStrand"
+KEY_LAYER_CNT = "LayerCnt"
+KEY_CRV_OFFSET = "CurveOffset"
+KEY_ORIG_REF = "Orig"
+KEY_WIPE_ON_CRV = "WipeOnCrv"
+KEY_FEED_COEFF = 'FeedCoeff'
+KEY_ENTITY_NAME = 'EntityName'
 
-SLICING_TYPE = {
+SLICING_TYPE = {   
    VERTICAL = 1,
    DEG45_X = 2,
    DEG45_Y = 3,
    HORIZONTAL = 4,
+   MULTIPLANAR = 5,
 }
 
 TYPE = {
@@ -282,10 +306,12 @@ 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'
 RESULT_READ_PROG = 'ResultReadProg'
+LAY_EXPORT = "ExportLayer"
 
 KEY_PART_ON_TABLE = 'PartOnTable'
 KEY_RESULT = 'Result'

LuaLibs/CalcSlices.lua

@@ -1,4 +1,4 @@
--- CalcSlices.lua by Egaltech s.r.l. 2022/10/12
+-- CalcSlices.lua by Egaltech s.r.l. 2023/08/28
 -- Calcolo percorsi di lavoro per Stampa 3d
 
 -- Tabella per definizione modulo
@@ -18,26 +18,102 @@ 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, HMax, 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
+      return GEO.INFINITO
+   end
    
    -- calcolo il box globale
    local b3BoxGlob = BBox3d()
@@ -47,14 +123,16 @@ local function ComputeMaxH( vIds, frSlicing, HMax, 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)
@@ -68,8 +146,9 @@ local function ComputeMaxH( vIds, frSlicing, HMax, 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)
       
@@ -79,7 +158,9 @@ local function ComputeMaxH( vIds, frSlicing, HMax, 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)
@@ -99,6 +180,9 @@ local function GetRibParams( nId)
 
    local RibParam = {}
    ReadParam( nId, KEY_RIBS_STRAND, 'd', s_dStrand, RibParam)
+   if RibParam[KEY_RIBS_STRAND] < GEO.EPS_SMALL then
+      RibParam[KEY_RIBS_STRAND] = s_dStrand
+   end
    ReadParam( nId, KEY_RIBS_SHELLS_NBR, 'i', 0, RibParam)
    ReadParam( nId, KEY_RIBS_INVERT_DIR, 'b', false, RibParam)
    ReadParam( nId, KEY_RIBS_LEAD_IN_INVERT, 'b', false, RibParam)
@@ -109,10 +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
 
@@ -133,6 +221,9 @@ local function GetAuxSolidsParams( nId)
    
    local AuxSolidsParam = {}
    ReadParam( nId, KEY_AUX_SOLIDS_STRAND, 'd', s_dStrand, AuxSolidsParam)
+   if AuxSolidsParam[KEY_AUX_SOLIDS_STRAND] < GEO.EPS_SMALL then
+      AuxSolidsParam[KEY_AUX_SOLIDS_STRAND] = s_dStrand
+   end
    ReadParam( nId, KEY_AUX_SOLIDS_SHELLS_NBR, 'i', 0, AuxSolidsParam)
    ReadParam( nId, KEY_AUX_SOLIDS_OVERLAP, 'd', 0, AuxSolidsParam)
    ReadParam( nId, KEY_AUX_SOLIDS_INFILL, 'i', FILL_TYPE.NONE, AuxSolidsParam)
@@ -154,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
@@ -169,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
@@ -205,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
@@ -228,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
@@ -237,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
@@ -259,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
    
@@ -317,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)
@@ -339,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
@@ -350,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
 
@@ -525,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)
 
@@ -563,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)
 
@@ -603,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
 
 --------------------------------------------------------------------
@@ -624,6 +714,9 @@ local function PrepareInfill( nStmId, vtSlicing)
    local dGridOverlap = EgtGetInfo( s_nPartId, KEY_INFILL_GRID_OVERLAP, 'd') or 0
    local dOffsStm = EgtGetInfo( s_nPartId, KEY_OFFSET_SLICE, 'd')
    local dStrand = EgtGetInfo( s_nPartId, KEY_INFILL_STRAND, 'd') or s_dStrand
+   if dStrand < GEO.EPS_SMALL then
+      dStrand = s_dStrand
+   end
    
    -- creo gruppo per infill
    local nInfillGrp = EgtGroup( s_nPartId)
@@ -634,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
 
 ----------------------------------------------------------------------
@@ -657,18 +750,21 @@ local function PrepareAuxSolidsInfill( nSolidsLay, vtSlicing)
                local dOffsY = ReadParam( vIds[i], KEY_AUX_SOLIDS_OFFSET_Y, 'd', 0)
                local dGridOverlap = ReadParam( vIds[i], KEY_AUX_SOLIDS_GRID_OVERLAP, 'd', 0)
                local dStrand = ReadParam( vIds[i], KEY_AUX_SOLIDS_STRAND, 'd', s_dStrand)
+               if dStrand < GEO.EPS_SMALL then
+                  dStrand = s_dStrand
+               end
                
                -- 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
@@ -696,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
@@ -714,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
@@ -765,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
@@ -791,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)
@@ -881,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
@@ -980,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
          
@@ -1023,56 +1272,113 @@ local function SlicingWithSolid( nStmId, vZSlices, dDeltaZStart, dZmin, frSlicin
       nLayId = EgtGetNext( nLayId)
    end
 
+   -- costolature
+   local nRibsLay = EgtGetFirstNameInGroup( s_nPartId, LAY_RIBS)
+   ExtractRibsLoops( nRibsLay, nStmId)
+   SlicingExtraObjects( nRibsLay, 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 + 3) / nCounterTot * 100, 0) == 1 then return false end
-
-      -- costolature
-      local nRibsLay = EgtGetFirstNameInGroup( s_nPartId, LAY_RIBS)
-      ExtractRibsLoops( nRibsLay, nStmId)
-      SlicingExtraObjects( nRibsLay, vtSlicing, TYPE.RIB, RIBS_CRV, RIBS_GRP, nStmId)
-      if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( #vZSlices + 6) / nCounterTot * 100, 0) == 1 then return false end
+      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
 
 ---------------------------------------------------------------------
-function CalcSlices.Exec( nPartId, nStmId, HMax)
+function CalcSlices.Exec( nPartId, nStmId)
 
    s_nPartId = nPartId
 
+   local sMachIni = EgtGetCurrMachineDir() .. '\\' .. EgtGetCurrMachineName() .. '.ini'
+
    -- recupero la direzione dello slicing
    local vtSlicing = Z_AX()
    local nSlicingType = EgtGetInfo( s_nPartId, KEY_SLICING_TYPE, 'i')
    if nSlicingType == SLICING_TYPE.DEG45_X then
-      vtSlicing =  VectorFromSpherical( 1, 45, 0)
+      local nDir = EgtGetNumberFromIni( '3dPrinting', 'Dir45degX', 0, sMachIni)
+      local dHorAng = EgtIf( nDir == -1, 180, 0)
+      vtSlicing =  VectorFromSpherical( 1, 45, dHorAng)
    elseif nSlicingType == SLICING_TYPE.DEG45_Y then
-      vtSlicing = VectorFromSpherical( 1, 45, -90)
+      local nDir = EgtGetNumberFromIni( '3dPrinting', 'Dir45degY', 0, sMachIni)
+      local dHorAng = EgtIf( nDir == 2, 90, -90)
+      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 = {}
@@ -1080,6 +1386,10 @@ function CalcSlices.Exec( nPartId, nStmId, HMax)
    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)
@@ -1088,60 +1398,40 @@ function CalcSlices.Exec( nPartId, nStmId, HMax)
          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, HMax, 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

@@ -36,7 +36,7 @@ function RunGcodeGenerate.Exec()
 
    -- Recupero i layer da processare
    local vLayIds = EgtGetNameInGroup( nPartId, SLICE_LAYER.."*") 
-   if not vLayIds then
+   if not vLayIds or #vLayIds == 0 then
    EgtOutBox( 'Error missing slices', 'GcodeGenerate')
       return 
    end

LuaLibs/RunMachParamFromSWCalc.lua

@@ -1,4 +1,4 @@
--- RunMachParamFromSWCalc.lua by Egaltech s.r.l. 2022/12/28
+-- RunMachParamFromSWCalc.lua by Egaltech s.r.l. 2024/01/30
 -- Calcolo dei parametri di stampa
 
 -- Tabella per definizione modulo
@@ -53,6 +53,8 @@ function RunMachParamFromSWCalc.Exec()
    local sMachIni = EgtGetCurrMachineDir() .. '\\' .. EgtGetCurrMachineName() .. '.ini'
    local dSMin = tonumber( EgtGetStringFromIni( SEC_3DPRINTING, KEY_SPEED_MIN, 0, sMachIni))
    local dSMax = tonumber( EgtGetStringFromIni( SEC_3DPRINTING, KEY_SPEED_MAX, 50000, sMachIni))
+   -- recupero Feed massima dalla macchina
+   local dFLimit = tonumber( EgtGetStringFromIni( SEC_3DPRINTING, KEY_FEED_MAX, 10000, sMachIni))
    -- massa materiale utilizzato
    local dPrintMass = 0
    -- massimo indice di layer calcolato
@@ -62,7 +64,7 @@ function RunMachParamFromSWCalc.Exec()
    while nPartId do
       if not EgtGetInfo( nPartId, KEY_PART_ON_TABLE, 'b') then
          nPartId = EgtGetNextPart( nPartId)
-         goto continue 
+         goto continue
       end
       -- recupero i parametri di lavorazione del pezzo
       local dSliceStep = EgtGetInfo( nPartId, KEY_SLICE_STEP, 'd')
@@ -77,6 +79,8 @@ function RunMachParamFromSWCalc.Exec()
       while nLayerId do
          -- rimuovo eventuale info precedente del tempo di attesa
          EgtRemoveInfo( nLayerId, KEY_WAITING_TIME)
+         -- divido curve in base alla larghezza strand
+         local LengthCrvList = {}
          -- calcolo lunghezza totale del layer
          local dTotLayerLength = 0
          local dTotLayerLengthForMass = 0
@@ -84,14 +88,29 @@ function RunMachParamFromSWCalc.Exec()
          local nCrvId = EgtGetFirstNameInGroup( nLayerId, CONTOUR_GRP .. '*')
          while nCrvId do
             local nToolPathId = EgtGetFirstNameInGroup( nCrvId, TOOLPATH_GRP)
-            -- sommo lunghezze percorsi
+            -- recupero lunghezze percorsi
             local dTotCrvLength = 0
             local dTotCrvLengthForMass = 0
-            nShellId = EgtGetFirstInGroup( nToolPathId)
+            local nShellId = EgtGetFirstInGroup( nToolPathId)
             while nShellId do
-               dTotCrvLength = dTotCrvLength + EgtCurveLength( nShellId)
+               local dShellWidth = EgtGetInfo( nShellId, KEY_CRV_STRAND, "d")
+               local dShellLength = EgtCurveLength( nShellId)
+               local bFound = false
+               for LengthIndex = 1, #LengthCrvList do
+                  if LengthCrvList[LengthIndex].Width == dShellWidth then
+                     table.insert( LengthCrvList[LengthIndex].IdList, nShellId) 
+                     LengthCrvList[LengthIndex].Length = LengthCrvList[LengthIndex].Length + dShellLength
+                     bFound = true
+                     break
+                  end
+               end
+               if not bFound then
+                  table.insert( LengthCrvList, { Width = dShellWidth, IdList = { nShellId}, Length = dShellLength})
+               end
+               -- sommo per lunghezza totale
+               dTotCrvLength = dTotCrvLength + dShellLength
                if EgtGetName( nShellId) ~= WIPE_CRV then
-                  dTotCrvLengthForMass = dTotCrvLengthForMass + EgtCurveLength( nShellId)
+                  dTotCrvLengthForMass = dTotCrvLengthForMass + dShellLength
                end
                nShellId = EgtGetNext( nShellId)
             end
@@ -132,11 +151,17 @@ function RunMachParamFromSWCalc.Exec()
             table.insert( nOrigLayers, nLayerId)
          end
          EgtSetInfo( nLayerResultId, KEY_SLICEID, nOrigLayers)
+         -- calcolo strand medio (media ponderata sulla lunghezza)
+         local dStrandMean = 0
+         for nMeanIndex = 1, #LengthCrvList do
+            dStrandMean = dStrandMean + LengthCrvList[nMeanIndex].Width * LengthCrvList[nMeanIndex].Length
+         end
+         dStrandMean = dStrandMean / EgtIf( dTotLayerLength > 0.1, dTotLayerLength, 1)
          -- calcolo costante MF
          local dMF = 1
          local dSC = 1
          if dTotLayerArea > 1 then
-            dMF = dTotLayerLength * dStrand / dTotLayerArea * 100
+            dMF = dTotLayerLength * dStrandMean / dTotLayerArea * 100
             dSC = dStrandCount
          else
             dMF = 100
@@ -151,12 +176,12 @@ function RunMachParamFromSWCalc.Exec()
             end
          end
          -- calcolo tempi stimati del layer
-         local dTMin = ( MATERIAL.K_LAYERTIME / 100.0) * ( dMF + MATERIAL.AMin) / MATERIAL.BMin * pow( 0.25 * dStrand, MATERIAL.KW) * pow( dSliceStep, MATERIAL.KZ) * pow( dSC, MATERIAL.KN)
-         local dTTrg = ( MATERIAL.K_LAYERTIME / 100.0) * ( dMF + MATERIAL.ATrg) / MATERIAL.BTrg * pow( 0.25 * dStrand, MATERIAL.KW) * pow( dSliceStep, MATERIAL.KZ) * pow( dSC, MATERIAL.KN)
-         local dTMax = ( MATERIAL.K_LAYERTIME / 100.0) * ( dMF + MATERIAL.AMax) / MATERIAL.BMax * pow( 0.25 * dStrand, MATERIAL.KW) * pow( dSliceStep, MATERIAL.KZ) * pow( dSC, MATERIAL.KN)
-         local dFMin = dTotLayerLength / dTMax * 60
-         local dFTrg = dTotLayerLength / dTTrg * 60
-         local dFMax = dTotLayerLength / dTMin * 60
+         local dTMin = ( MATERIAL.K_LAYERTIME / 100.0) * ( dMF + MATERIAL.AMin) / MATERIAL.BMin * pow( 0.25 * dStrandMean, MATERIAL.KW) * pow( dSliceStep, MATERIAL.KZ) * pow( dSC, MATERIAL.KN)
+         local dTTrg = ( MATERIAL.K_LAYERTIME / 100.0) * ( dMF + MATERIAL.ATrg) / MATERIAL.BTrg * pow( 0.25 * dStrandMean, MATERIAL.KW) * pow( dSliceStep, MATERIAL.KZ) * pow( dSC, MATERIAL.KN)
+         local dTMax = ( MATERIAL.K_LAYERTIME / 100.0) * ( dMF + MATERIAL.AMax) / MATERIAL.BMax * pow( 0.25 * dStrandMean, MATERIAL.KW) * pow( dSliceStep, MATERIAL.KZ) * pow( dSC, MATERIAL.KN)
+         local dFMin = dTotLayerLength / EgtIf( dTMax > 0.1, dTMax, 1) * 60
+         local dFTrg = dTotLayerLength / EgtIf( dTTrg > 0.1, dTTrg, 1) * 60
+         local dFMax = dTotLayerLength / EgtIf( dTMin > 0.1, dTMin, 1) * 60
          local dLayerTime = dTTrg
          if dLayerFeed == 0 then
             dLayerFeed = dFTrg
@@ -164,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 * ( ( dStrand - 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
@@ -179,16 +206,42 @@ function RunMachParamFromSWCalc.Exec()
             dSpeed = dSMax
          end
          if not bSpeedOk then
-            dLayerFeed = ( MATERIAL.C1 * pow( ( dSpeed / (( MATERIAL.K_EXTRUSION / 100.0) * ( MACHINING.K / 100.0))), MATERIAL.C2)) * 1000 / ( ( dStrand - dSliceStep) * dSliceStep + pi * pow( dSliceStep / 2, 2))
-            dLayerTime = dTotLayerLength / dLayerFeed * 60
+            if dTotLayerLength > 0.1 then
+               dLayerFeed = ( MATERIAL.C1 * pow( ( dSpeed / (( MATERIAL.K_EXTRUSION / 100.0) * ( MACHINING.K / 100.0))), MATERIAL.C2)) * 1000 / dSect
+               dLayerTime = dTotLayerLength / dLayerFeed * 60
+            end
             dLayerWait = floor( dTMin + 0.5) - floor( dLayerTime + 0.5)
          end
          -- calcolo massa dello strato
-         local dLayerMass = dTotLayerLengthForMass * dSliceStep * dStrand * MATERIAL.Density * 1e-6
+         local dLayerMass = dTotLayerLengthForMass * dSliceStep * dStrandMean * MATERIAL.Density * 1e-6
          if dLayerMass and dLayerMass > 0 then
             dPrintMass = dPrintMass + dLayerMass
          end
-         -- scrivo info feed e speed in group toolpath
+         -- scrivo info feed su tutti i tratti
+         local dFeedMax = 0
+         for nWidthIndex = 1, #LengthCrvList do
+            local CurrWidth = LengthCrvList[nWidthIndex]
+            local CurrFeed = EgtIf( CurrWidth.Width > 0, dLayerFeed * dStrandMean / CurrWidth.Width, dLayerFeed) 
+            for nCurveIdIndex = 1, #CurrWidth.IdList do
+               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
          nCrvId = EgtGetFirstNameInGroup( nLayerId, CONTOUR_GRP .. '*')
          while nCrvId do
             local nToolPathId = EgtGetFirstNameInGroup( nCrvId, TOOLPATH_GRP) or GDB_ID.NULL
@@ -202,13 +255,11 @@ function RunMachParamFromSWCalc.Exec()
             EgtSetInfo( nLayerResultId, KEY_WAITING_TIME, dLayerWait)
          end
          -- scrivo valori in struttura dati
-         --local nLayerResultId = EgtGetFirstNameInGroup( nResultLayerId, nLayerIndex)
          EgtSetInfo( nLayerResultId, KEY_TMIN, dTMin)
          EgtSetInfo( nLayerResultId, KEY_TTRG, dTTrg)
          EgtSetInfo( nLayerResultId, KEY_TMAX, dTMax)
-         EgtSetInfo( nLayerResultId, KEY_FMIN, dFMin)
          EgtSetInfo( nLayerResultId, KEY_FTRG, dFTrg)
-         EgtSetInfo( nLayerResultId, KEY_FMAX, dFMax)
+         EgtSetInfo( nLayerResultId, KEY_FMAX, dFeedMax)
          EgtSetInfo( nLayerResultId, KEY_TCUR, dLayerTime)
          EgtSetInfo( nLayerResultId, KEY_FCUR, dLayerFeed)
          EgtSetInfo( nLayerResultId, KEY_LENGTH, dTotLayerLength)
@@ -220,11 +271,12 @@ function RunMachParamFromSWCalc.Exec()
             EgtEmptyGroup( nResultLayerId)
             return
          end
-         
+         -- passo al layer successivo
          nLayerIndex = nLayerIndex + 1
          nLayerId = EgtGetFirstNameInGroup( nPartId, SLICE_LAYER .. nLayerIndex) or EgtGetFirstNameInGroup( nPartId, "__" .. SLICE_LAYER .. nLayerIndex)
       end
       if nMaxIndex < nLayerIndex then nMaxIndex = nLayerIndex end
+      -- passo al pezzo successivo
       nPartId = EgtGetNextPart( nPartId)
       ::continue::
    end

LuaLibs/RunPrepareExport.lua

@@ -0,0 +1,211 @@
+-- RunPrepareExport.lua by Egaltech s.r.l. 2023/10/19
+-- Creo le geometrie da esportare con 3dm
+
+-- Tabella per definizione modulo
+local RunPrepareExport = {}
+
+-- Intestazioni
+require( 'EgtBase')
+
+EgtOutLog( ' RunPreprareExport started', 1)
+
+-- Dati
+local AMD = require( 'AddManData')
+
+------------------------------------------------------------------
+local function CalcCurves( nSliceId, nDestGrp, vtSlicing, dStrandBase)
+   
+   -- scorro tutti i gruppi di curve
+   local vCrvs = EgtGetNameInGroup( nSliceId, CONTOUR_GRP .. '*')
+   for j = 1, #vCrvs do
+      -- cerco il gruppo del toolpath
+      local nTPath = EgtGetFirstNameInGroup( vCrvs[j], TOOLPATH_GRP)
+      if nTPath then
+         local nId = EgtGetFirstInGroup( nTPath)
+         while nId do
+            -- se non è wipe creo la fat curve da estrudere per creare il solido
+            local nType = EgtGetInfo( nId, KEY_TYPE, 'i')
+            if nType ~= TYPE.WIPE then
+               local dStrand = EgtGetInfo( nId, KEY_CRV_STRAND, 'd') or dStrandBase
+               
+               -- calcolo fat region a partire da una copia della curva ( in questo modo nel DB geometrico non restano
+               -- salvati i diagrammi di Voronoi che non servono per conti futuri)
+               local nCopy = EgtCopyGlob( nId, nDestGrp)
+               local nSurf = EgtSurfFrFatCurve( nDestGrp, nCopy, 0.5 * dStrand, false)
+               -- se fallisce ritento con valore leggermente diverso
+               if not nSurf or nSurf == GDB_ID.NULL then
+                  nSurf = EgtSurfFrFatCurve( nDestGrp, nCopy, 0.5 * dStrand - 0.05, false)
+               end
+               EgtErase( nCopy)
+                 
+               if nSurf then
+                  local nChunks = EgtSurfFrChunkCount( nSurf)
+                  for k = 0, nChunks - 1 do
+                     -- estraggo i loop associati
+                     local nCrv, nCnt = EgtExtractSurfFrChunkLoops( nSurf, k, nDestGrp)
+                     -- eventuali aggiustamenti per creare un percorso unico
+                     if nCnt > 1 then
+                        for nLoopId = nCrv + 1, nCrv + nCnt - 1 do
+                           local dLen = EgtCurveLength( nLoopId)
+                           local dPar1 = EgtCurveParamAtLength( nLoopId, dLen * 0.5)
+                           local dPar2 = EgtCurveParamAtLength( nLoopId, dLen * 0.5 + 2 * GEO.EPS_SMALL)
+                           local ptM = EgtUP( nLoopId, dPar1)
+                           local ptM2 = EgtUP( nLoopId, dPar2)
+                           local _, _, dParRef1 = EgtPointCurveDist( ptM2, nCrv)
+                           local _, _, dParRef2 = EgtPointCurveDist( ptM, nCrv)
+                           EgtTrimCurveStartEndAtParam( nCrv, dParRef2, dParRef1)
+                           EgtTrimCurveStartEndAtParam( nLoopId, dPar2, dPar1)
+                           EgtAddCurveCompoLine( nCrv, EgtSP( nLoopId))
+                           EgtAddCurveCompoCurve( nCrv, nLoopId)
+                           EgtCloseCurveCompo( nCrv)
+                        end
+                     end
+                     
+                     if nType == TYPE.OUTER_SHELL or nType == TYPE.EXTRA_OUTER_SHELL then 
+                        EgtSetColor( nCrv, EgtStdColor( 'TEAL'))
+                     elseif nType == TYPE.INNER_SHELL or nType == TYPE.EXTRA_SHELL then
+                        EgtSetColor( nCrv, EgtStdColor( 'ORANGE'))
+                     elseif nType == TYPE.LINK then
+                        EgtSetColor( nCrv, EgtStdColor( 'GRAY'))
+                     elseif nType == TYPE.INFILL then
+                        EgtSetColor( nCrv, EgtStdColor( 'YELLOW'))
+                     elseif nType == TYPE.COASTING then
+                        EgtSetColor( nCrv, EgtStdColor( 'BLUE'))
+                     elseif nType == TYPE.RIB then
+                        EgtSetColor( nCrv, EgtStdColor( 'OLIVE'))
+                     elseif nType == TYPE.AUX_SOLID then
+                        EgtSetColor( nCrv, EgtStdColor( 'AQUA'))
+                     end
+                  end
+                  EgtErase( nSurf)
+               end
+            end
+            
+            nId = EgtGetNext( nId)
+         end
+      end
+
+      -- copio le frecce direzione dal gruppo dei solidi
+      local nSolidGrp = EgtGetFirstNameInGroup( vCrvs[j], SOLID_GRP)
+      if nSolidGrp then
+         local nId = EgtGetFirstNameInGroup( nSolidGrp, DIR_ARROW)
+         while nId do
+            local nCopy = EgtCopyGlob( nId, nDestGrp)
+            EgtSetMode( nCopy, GDB_MD.STD)
+            EgtSetStatus( nCopy, GDB_ST.ON)
+            nId = EgtGetNextName( nId, DIR_ARROW)
+         end
+      end
+   end
+end
+
+------------------------------------------------------------------
+local function GetSolids( nSliceId, nDestGrp)
+   
+   -- scorro tutti i gruppi di curve
+   local vCrvs = EgtGetNameInGroup( nSliceId, CONTOUR_GRP .. '*')
+   for j = 1, #vCrvs do
+      -- recupero il solido dal gruppo
+      local nSolidGrp = EgtGetFirstNameInGroup( vCrvs[j], SOLID_GRP)
+      if nSolidGrp then
+         -- 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
+            if EgtGetName( vSolids[i]) ~= DIR_ARROW then
+               EgtCopyGlob( vSolids[i], nDestGrp)
+            end
+         end
+      end
+   end
+end
+
+------------------------------------------------------------------
+function RunPrepareExport.Exec()
+
+   local nPartId = EgtGetFirstNameInGroup( GDB_ID.ROOT, PART .. '*')
+   if not nPartId then 
+      EgtOutBox( 'Error : no part', 'Export')
+      return GDB_ID.NULL
+   end
+   
+   -- creo o recupero il gruppo per l'esportazione
+   local nGrp = EgtGetFirstNameInGroup( GDB_ID.ROOT, LAY_EXPORT)
+   if not nGrp then
+      -- se non esiste creo il gruppo
+      nGrp = EgtGroup( GDB_ID.ROOT)
+      EgtSetName( nGrp, LAY_EXPORT)
+      EgtSetStatus( nGrp, GDB_ST.OFF)
+      EgtSetLevel( nGrp, GDB_LV.TEMP)
+   else
+      -- se il gruppo esiste già non devo fare nulla
+      return nGrp
+   end
+   
+   -- creo il punto di origine del riferimento
+   local ptRef = EgtGetInfo( nPartId, KEY_ORIG_REF, 'p')
+   if not ptRef then
+      local nFrameId = EgtGetFirstNameInGroup( EgtGetFirstNameInGroup( nPartId, LAY_FRAME), FRAME_PART)
+      ptRef = EgtSP( nFrameId or GDB_ID.NULL, GDB_ID.ROOT)
+   end
+   local nPnt = EgtPoint( nGrp, ptRef, GDB_RT.GLOB)
+   EgtSetName( nPnt, KEY_ORIG_REF)
+   EgtSetStatus( nPnt, GDB_ST.OFF)
+   
+   -- recupero alcune info utili e le assegno al punto per poterle leggere da ThreeJS
+   local dH = EgtGetInfo( nPartId, KEY_SLICE_STEP, 'd')
+   EgtSetInfo( nPnt, KEY_SLICE_STEP, dH)
+   local vtSlicing = EgtGetInfo( nPartId, KEY_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
+   
+   -- recupero gli slices
+   local vSlices = EgtGetNameInGroup( nPartId, SLICE_LAYER .. '*') or {}
+   if #vSlices == 0 then
+      EgtOutBox( 'Error : no slices', 'Export')
+      return GDB_ID.NULL
+   end
+   
+   -- verifico che nel primo slice siano presenti sia i toolpath sia i solidi
+   local nCrvGrp = EgtGetFirstNameInGroup( vSlices[1], CONTOUR_GRP .. '*')
+   if not nCrvGrp then
+      EgtOutBox( 'Error : no toolpaths', 'Export')
+      return GDB_ID.NULL
+   end
+   local nTPath = EgtGetFirstNameInGroup( nCrvGrp, TOOLPATH_GRP)
+   if not nTPath then
+      EgtOutBox( 'Error : no toolpaths', 'Export')
+      return GDB_ID.NULL
+   end
+   local nSolid = EgtGetFirstNameInGroup( nCrvGrp, SOLID_GRP)
+   if not nSolid then
+       EgtOutBox( 'Error : no solids', 'Export')
+      return GDB_ID.NULL
+   end
+
+   for i = 1, #vSlices do
+     
+      -- creo il gruppo corrispondente
+      local nDestGrp = EgtGroup( nGrp)
+      EgtSetName( nDestGrp, EgtGetName( vSlices[i]))
+      EgtSetStatus( nDestGrp, GDB_ST.OFF)
+      
+      -- 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
+   end
+   
+   return nGrp
+end
+
+---------------------------------------------------------------------
+return RunPrepareExport

LuaLibs/RunSlicing.lua

@@ -79,6 +79,13 @@ local function RemoveOldSlices( nPartId)
       EgtErase( nInfillId)
       nInfillId = EgtGetFirstNameInGroup( nPartId, INFILL_GRP .. '*')
    end
+   
+   -- rimuovo gruppo per export
+   local nExportGrpId = EgtGetFirstNameInGroup( GDB_ID.ROOT, LAY_EXPORT)
+   if nExportGrpId then
+      EgtErase( nExportGrpId)
+   end
+   
 end
 
 ---------------------------------------------------------------------
@@ -157,10 +164,6 @@ function RunSlicing.Exec()
    EgtRemoveAllOperations()
    EgtResetCurrMachGroup()
 
-   -- Lettura dati macchina
-   local sMachIni = EgtGetCurrMachineDir() .. '\\' .. EgtGetCurrMachineName() .. '.ini'
-   local HMax = tonumber( EgtGetStringFromIni( '3dPrinting', 'HMax', 500, sMachIni))
-
    -- Eventuale ripristino posizione originaria
    RestoreOriginalPosition( nPartId)
    
@@ -171,7 +174,7 @@ function RunSlicing.Exec()
    RemoveOldTFS()
   
    -- Calcolo delle fette
-   local bOk = CSLICES.Exec( nPartId, nStmId, HMax)
+   local bOk = CSLICES.Exec( nPartId, nStmId)
    EgtDraw()
 
    -- Calcolo dei percorsi sul centro strand in basso

PrepareExport.lua

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

Version.lua

@@ -1,4 +1,4 @@
--- Version.lua by Egaltech s.r.l. 2023/02/28
+-- Version.lua by Egaltech s.r.l. 2026/03/04
 -- Gestione della versione di 3dPrinting
 
-VERSION = '2.5g1'
+VERSION = '3.1c1'