- gestito calcolo F e S con strand di differente larghezza

- sistemata gestione degli strand variabili con valore nullo.

.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

@@ -16,3 +16,4 @@ REM Compilazione 32 e 64 bit
 \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

LuaLibs/AddManData.lua

@@ -34,6 +34,7 @@ SURF_LOOP = "SurfLoop"
 MIN_LEN = 0.1
 MIN_AREA = 0.01
 MIN_RIBS_LEN = 2
+MIN_INFILL_LEN = 2
 
 -- Parametri di lavorazione
 SEC_DEFAULT = "Default"
@@ -45,6 +46,7 @@ KEY_SLICING_DIR = "SlicingDir"
 KEY_SLICE_STEP = "StrandH"
 KEY_SHELLS_NBR = "StrandCount"
 KEY_STRAND = "StrandW"
+KEY_INNER_STRAND = "InnerStrandW"
 KEY_STRAND_OVERLAP = "StrandOverlap"
 KEY_OFFSET_SLICE = "Offset"
 KEY_SP_OFFSET_ON_SLICE = "StartPointOffsetOnSlice"
@@ -55,10 +57,6 @@ KEY_TYPE = "Type"
 KEY_LINK_TYPE = "LinkType"
 KEY_LINK_PARAM = "LinkParam"
 KEY_LINK_ZUP = "LinkZup"
-KEY_FLOOR_NBR = "FloorCount"
-KEY_FLOOR_TYPE = "FloorType"
-KEY_CEIL_NBR = "CeilCount"
-KEY_CEIL_TYPE = "CeilType"
 KEY_SPEED = "Speed"
 KEY_FEED = "Feed"
 KEY_EXT_FEED = "ExtFeed"
@@ -81,9 +79,31 @@ KEY_COASTING_FEED = "CoastingFeed"
 KEY_WIPE_LEN = "WipeLen"
 KEY_WIPE_DIR = "WipeDir"
 KEY_WIPE_FEEDPU = "WipeFeedPu"
-KEY_TOOL_DIAM = "ToolDiam" 
+KEY_TOOL_DIAM = "ToolDiam"
+
+-- Solid Fill
+KEY_FLOOR_NBR = "FloorCount"
+KEY_FLOOR_TYPE = "FloorType"
+KEY_CEIL_NBR = "CeilCount"
+KEY_CEIL_TYPE = "CeilType"
+KEY_FILL_TYPE = "FillType"
+
+-- Infill
+KEY_INFILL_STRAND = "InfillStrandW"
+KEY_INFILL_TYPE = "InfillType"
+KEY_INFILL_DENSITY = "InfillDensity"
+KEY_INFILL_LINK = "InfillLink"
+KEY_INFILL_OVERLAP = "InfillOverlap"
+KEY_INFILL_GRID_OVERLAP = "InfillGridOverlap"
+KEY_INFILL_DIR = "InfillDirection"
+KEY_INFILL_OFFSET_X = "InfillOffsetX"
+KEY_INFILL_OFFSET_Y = "InfillOffsetY"
+KEY_INFILL_COASTING = "InfillCoasting"
+KEY_INFILL_WIPE = "InfillWipe"
+KEY_INFILL_WIPE_DIR = "InfillWipeDir"
 
 -- Ribs
+KEY_RIBS_STRAND = "RibsStrandW"
 KEY_RIBS_TYPE = "RibsType"
 KEY_LIMIT_UNBDD_RIBS = "LimitUnboundedRibsWithSolid"
 KEY_RIBS_OVERLAP = "RibsOverlap"
@@ -109,6 +129,7 @@ KEY_START_RIB = "StartRib"
 KEY_ORIGINAL_RIB = "OriginalRib"
 KEY_LOOP_RIB = "LoopRib"
 KEY_RIBS_USER_LINK = "RibWithUserLink"
+KEY_RIBS_USER_LINK_SAME_SIDE = "RibUserLinkOnSameSide"
 KEY_RIBS_USER_LINK_CCW = "RibUserLinkCCW"
 KEY_RIBS_USER_LINK_ORDER = "RibUserLinkOrder"
 KEY_RIBS_USER_LINK_TOT = "RibsUserLinkParts"
@@ -124,12 +145,21 @@ KEY_EXTRA_SHELL_WIPE = "ExtraShellWipe"
 KEY_EXTRA_SHELL_WIPE_DIR = "ExtraShellWipeDir"
 
 -- Solidi ausiliari
+KEY_AUX_SOLIDS_STRAND = "AuxSolidsStrandW"
+KEY_AUX_SOLIDS_SHELLS_NBR = "AuxSolidsStrandCount"
+KEY_AUX_SOLIDS_OVERLAP = "AuxSolidsOverlap"
 KEY_AUX_SOLIDS_INFILL = "AuxSolidsInfill"
 KEY_AUX_SOLIDS_PRINT_ORDER = "AuxSolidsStrandOrder"
-KEY_AUX_SOLIDS_OVERLAP = "AuxSolidsOverlap"
 KEY_AUX_SOLIDS_LINK_TYPE = "AuxSolidsLinkType"
-KEY_AUX_SOLIDS_SP_OFFSET = "AuxSolidsStartPointOffsetOnSlice"
 KEY_AUX_SOLIDS_LINK_PARAM = "AuxSolidsLinkParam"
+KEY_AUX_SOLIDS_SP_OFFSET = "AuxSolidsStartPointOffsetOnSlice"
+KEY_AUX_SOLIDS_LP_OFFSET = "AuxSolidsOffsetLeadPoint"
+KEY_AUX_SOLIDS_INFILL_LINK = "AuxSolidsInfillLink"
+KEY_AUX_SOLIDS_DENSITY = "AuxSolidsDensity"
+KEY_AUX_SOLIDS_DIR = "AuxSolidsDirection"
+KEY_AUX_SOLIDS_OFFSET_X = "AuxSolidsOffsetX"
+KEY_AUX_SOLIDS_OFFSET_Y = "AuxSolidsOffsetY"
+KEY_AUX_SOLIDS_GRID_OVERLAP = "AuxSolidsGridOverlap"
 KEY_AUX_SOLIDS_COASTING_LEN = "AuxSolidsCoastingLen"
 KEY_AUX_SOLIDS_WIPE_LEN = "AuxSolidsWipeLen"
 KEY_AUX_SOLIDS_WIPE_DIR = "AuxSolidsWipeDir"
@@ -142,6 +172,7 @@ KEY_SPEED_MIN = "SpeedMin"
 KEY_SPEED_MAX = "SpeedMax"
 
 -- Altre chiavi
+KEY_MAX_H = "SlicingHeight"
 KEY_SLICE_NBR = "SliceNbr"
 KEY_SLICE_Z = "SliceZ"
 KEY_SLICE_DELTAZ = "DeltaZ"
@@ -152,9 +183,19 @@ KEY_INVERTED_CRV = "InvertedCrv"
 KEY_CLOSED_CRV = "ClosedCrv"
 KEY_ASSOCIATED_SURF = "AssociatedSurf"
 KEY_ASSOCIATED_CRVS = "AssociatedCrvs"
+KEY_ORIGINAL_SURF = "OriginalSurf"
 KEY_HAS_SOLIDS = "Solids"
 KEY_BOX_MIN_Z = "PartBoxMinZ"
-KEY_START_POINT = "StartPoint"
+KEY_ORIGINAL_START_POINT = "OriginalStartPoint"
+KEY_FIRST_SOLID_LAY = "FirstSolidLay"
+KEY_LAST_SOLID_LAY = "LastSolidLay"
+KEY_ASSOCIATED_TP_CRV = "AssociatedToolPathCrv"
+KEY_ASSOCIATED_P_CRV = "AssociatedPathCrv"
+KEY_INTERNAL_SRF_LOOP = "InternalSrfLoop"
+KEY_PREV_CRV = "PrevCrv"
+KEY_NEXT_CRVS = "NextCrvs"
+KEY_CRV_STRAND = "CurveStrand"
+KEY_LAYER_CNT = "LayerCnt"
 
 SLICING_TYPE = {
    VERTICAL = 1,
@@ -200,7 +241,7 @@ PRINT_DIRECTION = {
 LINK_TYPE = {
    NONE = 1,
    LINEAR = 2,
-   BIARC = 3,   
+   BIARC = 3,
 }
 
 LEAD_TYPE = {
@@ -209,10 +250,21 @@ LEAD_TYPE = {
    ARC = 3,
 }
 
-INFILL_TYPE = {
+FILL_CATEGORY = {
-   NONE = 1,
+   NONE = 0,
-   OFFSET = 2,
+   SOLID_FILL = 16,
-   ZIGZAG = 3,
+   INFILL = 32,
+}
+
+FILL_TYPE = {
+   NONE = 0,
+   OFFSET = 16,
+   ZIGZAG = 17,
+   LINES = 32,
+   GRID = 33,
+   ZIG_ZAG_GRID = 34,
+   HONEYCOMB = 35,
+   HONEYCOMB_GRID = 36,
 }
 
 RIB_TYPE = {
@@ -284,15 +336,21 @@ SLICE_ADV_TYPE = {
 ---------------------------------------------------------------------
 RIBS_GRP = "Ribs"
 RIBS_CRV = "Rib"
+RIBS_LOOP_GRP = "RibsLoops"
 
 SHELL_NBR_GRP = "ShellNbrRegions"
 SHELL_NBR_CRV = "ShellNbrRegion"
 SHELL_NBR_SURF = "ShellNbrSurf"
 
 AUX_SOLIDS_GRP = "AuxSolids"
+AUX_SOLIDS_INFILL_GRP = "InfillAuxSolids"
 AUX_SOLIDS_CRV = "AuxSolid"
+AUX_SOLIDS_INFILL_CRV = "InfillAuxSolid"
 AUX_SOLIDS_SRF = "SrfAuxSolid"
 
+INFILL_GRP = "Infill"
+INFILL_CRV = "InfillCrv"
+
 ---------------------------------------------------------------------
 -- parametri calcolo tempi, F ed S
 LAY_TFSCALC = "TFSCalc"

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
@@ -14,6 +14,15 @@ local AMD = require( 'AddManData')
 
 ---------------------------------------------------------------------
 local s_nPartId
+local s_vErr = {}
+local s_dStrand
+
+-- costanti
+local TOLER = 0.05
+local MID_TOLER = 0.1
+local BIG_TOLER = 2.0
+local MIN_LEN = 20.0
+local MIN_AREA = 25.0
 
 ---------------------------------------------------------------------
 local function ComputeZSlices( dSliceStep, dZmin, dDeltaZ, dZmax)
@@ -28,7 +37,12 @@ local function ComputeZSlices( dSliceStep, dZmin, dDeltaZ, dZmax)
 end
 
 --------------------------------------------------------------------
-local function ComputeMaxH( vIds, frSlicing, HMax, dSliceStep)
+local function ComputeMaxH( vIds, frSlicing, dSliceStep)
+   
+   local HMax = EgtGetInfo( s_nPartId, KEY_MAX_H, 'd') or GEO.INFINITO
+   if HMax < GEO.EPS_SMALL then
+      HMax = GEO.INFINITO
+   end
    
    -- calcolo il box globale
    local b3BoxGlob = BBox3d()
@@ -70,41 +84,6 @@ local function ComputeMaxH( vIds, frSlicing, HMax, dSliceStep)
    return GEO.INFINITO
 end
 
---------------------------------------------------------------------
-local function AdjustAuxSolids( nSolidsLay)
-   
-   -- gestisce intersezioni fra solidi ausiliari unendoli
-   local nCurr = EgtGetFirstInGroup( nSolidsLay or GDB_ID.NULL)
-   if not nCurr then return end
-   
-   local nGrpTmp = EgtGroup( nSolidsLay)
-   while nCurr do
-      if EgtGetType( nCurr) == GDB_TY.SRF_MESH then 
-         -- verifico se interseca uno dei solidi successivi
-         local bInters = true -- per entrare nel loop
-         while bInters do
-            bInters = false
-            local nNext = EgtGetNext( nCurr)
-            while nNext do
-               if EgtGetType( nNext) == GDB_TY.SRF_MESH then
-                  -- verifico se le due superfici si intersecano
-                  local nFirst = EgtSurfTmSurfTmInters( nCurr, nNext, nGrpTmp)
-                  -- se intersezione unisco i due solidi e ripeto il check
-                  if nFirst then
-                     EgtSurfTmAdd( nCurr, nNext)
-                     EgtErase( nNext)
-                     bInters = true
-                  end
-               end
-               nNext = EgtGetNext( nNext)
-            end
-         end
-      end
-      nCurr = EgtGetNext( nCurr)
-   end
-   EgtErase( nGrpTmp)
-end
-
 --------------------------------------------------------------------
 local function ReadParam( nId, sKey, sType, defVal, table)
    -- verifico se info nell'oggetto specifico
@@ -120,10 +99,14 @@ local function ReadParam( nId, sKey, sType, defVal, table)
    return info
 end
 
---------------------------------------------------------------------
+-----------------------------------------------------------------------
 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)
@@ -133,7 +116,7 @@ local function GetRibParams( nId)
    ReadParam( nId, KEY_RIBS_LEAD_OUT_COASTING, 'd', 0, RibParam)
    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, 'i', 0, RibParam)
+   ReadParam( nId, KEY_RIBS_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)
@@ -157,150 +140,586 @@ end
 local function GetAuxSolidsParams( nId)
    
    local AuxSolidsParam = {}
-   ReadParam( nId, KEY_AUX_SOLIDS_OVERLAP, 'i', 0, 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)
+   ReadParam( nId, KEY_AUX_SOLIDS_PRINT_ORDER, 'i', PRINT_ORDER.EXT_INT, AuxSolidsParam)
+   ReadParam( nId, KEY_AUX_SOLIDS_LINK_TYPE, 'i', LINK_TYPE.NONE, AuxSolidsParam)
    ReadParam( nId, KEY_AUX_SOLIDS_LINK_PARAM, 'd', 0, AuxSolidsParam)
    ReadParam( nId, KEY_AUX_SOLIDS_SP_OFFSET, 'd', 0, AuxSolidsParam)
+   ReadParam( nId, KEY_AUX_SOLIDS_LP_OFFSET, 'd', 0, AuxSolidsParam)
+   ReadParam( nId, KEY_AUX_SOLIDS_DENSITY, 'd', 0, AuxSolidsParam)
+   ReadParam( nId, KEY_AUX_SOLIDS_DIR, 'd', 0, AuxSolidsParam)
+   ReadParam( nId, KEY_AUX_SOLIDS_INFILL_LINK, 'b', false, AuxSolidsParam)
+   ReadParam( nId, KEY_AUX_SOLIDS_OFFSET_X, 'd', 0, AuxSolidsParam)
+   ReadParam( nId, KEY_AUX_SOLIDS_OFFSET_Y, 'd', 0, AuxSolidsParam)
+   ReadParam( nId, KEY_AUX_SOLIDS_GRID_OVERLAP, 'd', 0, AuxSolidsParam)
    ReadParam( nId, KEY_AUX_SOLIDS_COASTING_LEN, 'd', 0, AuxSolidsParam)
    ReadParam( nId, KEY_AUX_SOLIDS_WIPE_LEN, 'd', 0, AuxSolidsParam)
    ReadParam( nId, KEY_AUX_SOLIDS_WIPE_DIR, 'd', 0, AuxSolidsParam)
-   ReadParam( nId, KEY_AUX_SOLIDS_INFILL, 'i', INFILL_TYPE.NONE, AuxSolidsParam)
+   
-   ReadParam( nId, KEY_AUX_SOLIDS_PRINT_ORDER, 'i', PRINT_ORDER.EXT_INT, AuxSolidsParam)
-   ReadParam( nId, KEY_AUX_SOLIDS_LINK_TYPE, 'i', LINK_TYPE.NONE, AuxSolidsParam)
-  
    return AuxSolidsParam
 end
 
---------------------------------------------------------------------
+----------------------------------------------------------------------
-local function SlicingExtraObjects( vtSlicing, nLay, nType, sNameGrp, sName, nStmId)
+-------------------- SLICING EXTRA OBJECTS ---------------------------
+----------------------------------------------------------------------
+local function SliceStm( vIds, nLayId, vtSlicing, nType, sName, sNameGrp, tabParams)
    
-   -- recupero gli oggeti di cui fare slicing
-   local vIds = EgtGetAllInGroup( nLay)
    if not vIds or #vIds == 0 then return end
    
-   -- rimuovo gli indici che non corrispondono a trimesh
+   -- recupero il gruppo dove salvare lo slicing degli oggetti
-   local k = 1
+   local nGrp = EgtGetFirstNameInGroup( nLayId, sNameGrp)
-   while k <= #vIds do
+   if not nGrp then
-      local nType = EgtGetType( vIds[k])
+      -- se gruppo non esiste lo creo
-      if nType ~= GDB_TY.SRF_MESH then
+      nGrp = EgtGroup( nLayId)
-         table.remove( vIds, k)
+      EgtSetName( nGrp, sNameGrp)
-      else
+      EgtSetStatus( nGrp, GDB_ST.OFF)
-         k = k + 1
-      end
-   end
-   if #vIds == 0 then return end
- 
-   -- recupero i parametri di ogni oggetto
-   local tabParams = {}
-   local vToBeDone = {}
-   for i = 1, #vIds do
-      local vParams = {}
-      local bToBeDone = true
-      if nType == TYPE.RIB then
-         vParams = GetRibParams( vIds[i])
-         if vParams[ KEY_RIBS_SHELLS_NBR] == 0 then bToBeDone = false end
-      elseif nType == TYPE.EXTRA_SHELL then
-         vParams = GetShellNumberParams( vIds[i])
-         if vParams[KEY_SHELL_NBR_DIFF] == 0 then bToBeDone = false end
-      elseif nType == TYPE.AUX_SOLID then
-         vParams = GetAuxSolidsParams( vIds[i])
-         if vParams[KEY_AUX_SOLIDS_INFILL] == INFILL_TYPE.NONE then bToBeDone = false end
-      end
-      table.insert( tabParams, vParams)
-      table.insert( vToBeDone, bToBeDone)
    end
    
-   -- taglio i setti unbounded e limitati con il solido
+   -- recupero quota per slicing
-   local vEraseIds = {}
+   local dZ = EgtGetInfo( nLayId, KEY_SLICE_REAL_Z, 'd')
-   if nType == TYPE.RIB then
+   local dDeltaZ = EgtGetInfo( nLayId, KEY_SLICE_DELTAZ, 'd')
-      local bLimitUnbddRibs = EgtGetInfo( s_nPartId, KEY_LIMIT_UNBDD_RIBS, 'b') or false
+   local nLayCnt = EgtGetInfo( nLayId, KEY_SLICE_NBR, 'i')
-      if bLimitUnbddRibs then
+   
-         for i = 1, #vIds do
+   -- gruppo temporaneo per approx curve
-            if vToBeDone[i] then
+   local frloc = Frame3d( ORIG(), vtSlicing)
-               if tabParams[i][KEY_RIBS_TYPE] == RIB_TYPE.UNBOUNDED then
+   local nGrpTmp = EgtGroup( nLayId, frloc, GDB_RT.GLOB)
-                  -- creo copia e la taglio con solido
+
-                  local nCopy = EgtCopyGlob( vIds[i], EgtGetParent( vIds[i]))
+   for i = 1, #vIds do
-                  EgtSurfTmCut( nCopy, nStmId, true, true)
+      -- verifico che oggetto sia trimesh
-                  -- lo slicing viene fatto sulla copia
+      local nTypeObj = EgtGetType( vIds[i])
-                  vIds[i] = nCopy
+      if nTypeObj == GDB_TY.SRF_MESH then
-                  table.insert( vEraseIds, nCopy)
+         -- slicing oggetto
+         local nNewId, nPntCnt, nCrvCnt, nSrfCnt = EgtPlaneSurfTmInters( ORIG() + ( dZ + dDeltaZ) * vtSlicing, vtSlicing, vIds[i], nGrp, GDB_RT.GLOB, TOLER)
+   
+         -- verifico se necessario ricalcolo
+         local dCorr = 0
+         local bOpen = false
+         if nType ~= TYPE.RIB and nType ~= TYPE.INFILL and nNewId then
+            for nId = nNewId + nPntCnt, nNewId + nPntCnt + nCrvCnt - 1 do
+               if not EgtCurveIsClosed( nId) then
+                  bOpen = true
+                  break
                end
             end
          end
-      end
+         -- eventuale ricalcolo ( se superfici o curve aperte)
-   end
+         if nSrfCnt > 0 or bOpen then
-   
+            EgtOutLog( 'Warning : recalc at layer '.. EgtNumToString( nLayCnt) .. ' (object)')
-   local nLayId = EgtGetFirstNameInGroup( s_nPartId, SLICE_LAYER .. '*')
+            -- elimino vecchio risultato
-   while nLayId do
+            for j = nNewId, nNewId + nPntCnt + nCrvCnt + nSrfCnt - 1 do
-      -- recupero quota per slicing
+               EgtErase( j)
-      local dZ = EgtGetInfo( nLayId, KEY_SLICE_REAL_Z, 'd')
-      local dDeltaZ = EgtGetInfo( nLayId, KEY_SLICE_DELTAZ, 'd')
-      -- creo gruppo per le costolature
-      local nGrp = EgtGroup( nLayId)
-      EgtSetName( nGrp, sNameGrp)
-      EgtSetStatus( nGrp, GDB_ST.OFF)
-
-      for i = 1, #vIds do
-         if vToBeDone[i] then
-            -- slicing oggetto
-            local nNewId, nPntCnt, nCrvCnt, nSrfCnt = EgtPlaneSurfTmInters( ORIG() + ( dZ + dDeltaZ) * vtSlicing, vtSlicing, vIds[i], nGrp, GDB_RT.GLOB, TOLER)
-            
-            -- verifico se necessario ricalcolo
-            local dCorr = 0
-            local bOpen = false
-            if nType ~= TYPE.RIB and nNewId then
-               for nId = nNewId + nPntCnt, nNewId + nPntCnt + nCrvCnt - 1 do
-                  if not EgtCurveIsClosed( nId) then
-                     bOpen = true
-                     break
-                  end
-               end
             end
+            dCorr = 0.01
+            nNewId, nPntCnt, nCrvCnt, nSrfCnt = EgtPlaneSurfTmInters( ORIG() + ( dZ + dDeltaZ + dCorr) * vtSlicing, vtSlicing, vIds[i], nGrp, GDB_RT.GLOB, TOLER)
+         end
+            
+         if nNewId then
 
-            if nSrfCnt > 0 or bOpen then
+            -- rimuovo punti
-               -- elimino vecchio risultato
+            for nId = nNewId, nNewId + nPntCnt -1 do
-               for j = nNewId, nNewId + nPntCnt + nCrvCnt + nSrfCnt - 1 do
+               EgtErase( nId)
-                  EgtErase( j)
-               end
-               dCorr = 0.01
-               nNewId, nPntCnt, nCrvCnt, nSrfCnt = EgtPlaneSurfTmInters( ORIG() + ( dZ + dDeltaZ + dCorr) * vtSlicing, vtSlicing, vIds[i], nGrp, GDB_RT.GLOB, TOLER)
             end
             
-            if nNewId then
+            -- concateno le curve
-               -- rimuovo punti
+            local vChain = {}
-               for nId = nNewId, nNewId + nPntCnt -1 do
+            for nId = nNewId + nPntCnt, nNewId + nPntCnt + nCrvCnt - 1 do
-                  EgtErase( nId)
+               table.insert( vChain, nId)
-               end
+            end
-               -- rinomino le curve, correggo di DeltaZ e assegno parametri
+            local nChainId, nCnt = EgtCurveCompoByChain( nGrp, vChain, ORIG(), true, GDB_RT.LOC, TOLER)
-               for nId = nNewId + nPntCnt, nNewId + nPntCnt + nCrvCnt - 1 do
+            if not nChainId then
-                  EgtSetName( nId, sName .. tostring( i))
+               -- se fallisce riprendo le curve originali
-                  EgtMove( nId, - ( dDeltaZ + dCorr) * vtSlicing)
+               nChainId = nNewId + nPntCnt
+               nCnt = nCrvCnt
+            end
+            -- rinomino le curve, correggo di DeltaZ e assegno parametri
+            for nId = nChainId, nChainId + nCnt - 1 do
+               EgtSetName( nId, sName .. tostring( i))
+               EgtMove( nId, - ( dDeltaZ + dCorr) * vtSlicing)
+               EgtSetInfo( nId, KEY_ORIGINAL_SURF, vIds[i])
+               if tabParams then
                   for sKey, sVal in pairs( tabParams[i]) do
                      EgtSetInfo( nId, sKey, sVal)
                   end
                end
-               -- rimuovo superfici
+               EgtModifyCurveExtrusion( nId, vtSlicing, GDB_RT.GLOB)
-               for nId = nNewId + nPntCnt + nCrvCnt, nNewId + nPntCnt + nCrvCnt + nSrfCnt - 1 do
+               EgtRelocateGlob( nId, nGrpTmp)
-                  EgtErase( nId)
+               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
+                  EgtOutLog( 'Error : hole in object (layer '.. EgtNumToString( nLayCnt) ..') - CalcSlices')
+                  table.insert( s_vErr, nLayCnt)
                end
             end
+            
+            -- rimuovo superfici
+            for nId = nNewId + nPntCnt + nCrvCnt, nNewId + nPntCnt + nCrvCnt + nSrfCnt - 1 do
+               EgtErase( nId)
+            end
          end
       end
+   end
 
-      -- verifico che il gruppo non sia vuoto
+   -- verifico che il gruppo non sia vuoto
-      if not EgtGetFirstInGroup( nGrp) then
+   if not EgtGetFirstInGroup( nGrp) then
-         EgtErase( nGrp)
+      EgtErase( nGrp)
+   end
+   EgtErase( nGrpTmp)
+end
+
+--------------------------------------------------------------------
+local function SlicingExtraObjects( nLay, vtSlicing, nType, sName, sNameGrp, nStmId)
+   
+   if not nLay then return end
+   
+   -- recupero gli oggetti di cui fare slicing
+   local vIds = EgtGetAllInGroup( nLay)
+   if not vIds or #vIds == 0 then return end
+ 
+   -- recupero i parametri di ogni oggetto e verifico se da considerare per lo slicing
+   local tabParams = {}
+   local vSliceIds = {}
+   for i = 1, #vIds do
+      -- verifico se trimesh
+      if EgtGetType( vIds[i]) == GDB_TY.SRF_MESH then
+         local bToBeDone = true
+         -- recupero i parametri
+         local vParams = {}
+         if nType == TYPE.RIB then
+            vParams = GetRibParams( vIds[i])
+            if vParams[KEY_RIBS_SHELLS_NBR] == 0 then bToBeDone = false end
+         elseif nType == TYPE.EXTRA_SHELL then
+            vParams = GetShellNumberParams( vIds[i])
+            if vParams[KEY_SHELL_NBR_DIFF] == 0 then bToBeDone = false end
+         elseif nType == TYPE.AUX_SOLID then
+            vParams = GetAuxSolidsParams( vIds[i])
+         end
+         -- se da fare lo aggiungo nei vettori
+         if bToBeDone then
+            table.insert( tabParams, vParams)
+            table.insert( vSliceIds, vIds[i])
+         end
+      end
+   end
+
+   -- taglio i setti unbounded e limitati con il solido
+   local bLimitUnbddRibs = EgtGetInfo( s_nPartId, KEY_LIMIT_UNBDD_RIBS, 'b') or false
+   local vEraseIds = {}
+   if nType == TYPE.RIB and bLimitUnbddRibs then
+      for i = 1, #vSliceIds do
+         if tabParams[i][KEY_RIBS_TYPE] == RIB_TYPE.UNBOUNDED then
+            -- creo copia e la taglio con solido
+            local nCopy = EgtCopyGlob( vSliceIds[i], EgtGetParent( vSliceIds[i]))
+            EgtSurfTmCut( nCopy, nStmId, true, true)
+            -- lo slicing va fatto sulla copia
+            vSliceIds[i] = nCopy
+            table.insert( vEraseIds, nCopy)
+         end
       end
-      nLayId = EgtGetNextName( nLayId, SLICE_LAYER .. '*')
    end
    
-   -- rimuovo eventuali copie create per lo slicing
+   -- 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)
+   end
+
+   -- rimuovo eventuali oggetti creati per lo slicing
    for i = 1, #vEraseIds do
       EgtErase( vEraseIds[i])
    end
+   
+   return true
+end
+
+------------------------------------------------------------------------
+local function SlicingInfill( nLay, vtSlicing, sName, sNameGrp)
+   
+   -- recupero tutte le curve di infill suddivise per direzioni di riferimento
+   local vInfillGrps = EgtGetAllInGroup( nLay)
+   local tIds = {}
+   for i = 1, #vInfillGrps do
+      local vIds = EgtGetAllInGroup( vInfillGrps[i])
+      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
+      
+      -- 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)
+      end
+   end
 
    return true
 end
 
+----------------------------------------------------------------------
+----------------------------- INFILL ---------------------------------
+----------------------------------------------------------------------
+local function CalcLinesInfill( nInfillGrp, nStmId, dOffsStm, frLoc, vtOffs, dDist)
+   
+   -- box locale
+   local b3Loc = EgtGetBBoxRef( nStmId, GDB_BB.STANDARD, frLoc)
+   b3Loc:expand( dOffsStm)
+   local ptMin = b3Loc:getMin()
+   local ptMax = b3Loc:getMax()
+   local dZ = ptMin:getZ()
+   
+   local nGrp = EgtGroup( nInfillGrp, frLoc, GDB_RT.GLOB)
+   
+   -- calcolo la prima quota a cui tracciare la linea
+   local dY = ptMin:getY() + vtOffs:getY() % dDist
+   
+   -- calcolo le linee
+   while dY < ptMax:getY() + GEO.EPS_SMALL do
+      local ptS = Point3d( ptMin:getX(), dY, dZ)
+      local ptE = Point3d( ptMax:getX(), dY, dZ)
+      EgtCurveCompoFromPoints( nGrp, {ptS, ptE})
+      dY = dY + dDist
+   end
+end
+
+--------------------------------------------------------------------
+local function CalcSimpleGridInfill( nInfillGrp, nStmId, dOffsStm, frLoc, vtOffs, dDist)
+    
+   -- box locale
+   local b3Loc = EgtGetBBoxRef( nStmId, GDB_BB.STANDARD, frLoc)
+   b3Loc:expand( dOffsStm)
+   local ptMin = b3Loc:getMin()
+   local ptMax = b3Loc:getMax()
+   local dZ = ptMin:getZ()
+   
+   -- direzione principale
+   local nMainGrp = EgtGroup( nInfillGrp, frLoc, GDB_RT.GLOB)
+   local dY = ptMin:getY() + vtOffs:getY() % dDist
+   while dY < ptMax:getY() + GEO.EPS_SMALL do
+      local ptS = Point3d( ptMin:getX(), dY, dZ)
+      local ptE = Point3d( ptMax:getX(), dY, dZ)
+      EgtCurveCompoFromPoints( nMainGrp, {ptS, ptE})
+      dY = dY + dDist
+   end
+   
+   -- direzione secondaria ( ortogonale alla principale)
+   local nOtherGrp = EgtGroup( nInfillGrp, frLoc, GDB_RT.GLOB)
+   local dX = ptMin:getX() + vtOffs:getX() % dDist
+   while dX < ptMax:getX() + GEO.EPS_SMALL do
+      local ptS = Point3d( dX, ptMin:getY(), dZ)
+      local ptE = Point3d( dX, ptMax:getY(), dZ)
+      EgtCurveCompoFromPoints( nOtherGrp, {ptS, ptE})
+      dX = dX + dDist
+   end
+end
+
+--------------------------------------------------------------------
+local function CompletePatternBaseCrv( nCrvBase, dAng, dDim1, dDim2, dMinY, dMaxY)
+   
+   local vtDir1 = VectorFromPolar( 1, dAng)
+   local vtDir2 = VectorFromPolar( 1, 180 - dAng)
+   
+   -- completo la curva base in Y+
+   local ptNext = EgtEP( nCrvBase)
+   while ptNext:getY() < dMaxY do
+      ptNext = ptNext + dDim1 * vtDir1
+      EgtAddCurveCompoLine( nCrvBase, ptNext)
+      ptNext = ptNext + dDim2 * Y_AX()
+      EgtAddCurveCompoLine( nCrvBase, ptNext)
+      ptNext = ptNext + dDim1 * vtDir2
+      EgtAddCurveCompoLine( nCrvBase, ptNext)
+      ptNext = ptNext + dDim2 * Y_AX()
+      EgtAddCurveCompoLine( nCrvBase, ptNext)
+   end
+   
+   -- completo la curva base in Y-
+   ptNext = EgtSP( nCrvBase)
+   while ptNext:getY() > dMinY do
+      ptNext = ptNext - dDim1 * vtDir2
+      EgtAddCurveCompoLine( nCrvBase, ptNext, false)
+      ptNext = ptNext - dDim2 * Y_AX()
+      EgtAddCurveCompoLine( nCrvBase, ptNext, false)
+      ptNext = ptNext - dDim1 * vtDir1
+      EgtAddCurveCompoLine( nCrvBase, ptNext, false)
+      ptNext = ptNext - dDim2 * Y_AX()
+      EgtAddCurveCompoLine( nCrvBase, ptNext, false)
+   end
+   
+   return nCrvBase
+end
+
+--------------------------------------------------------------------
+local function CalcPatternCrvs( nGrp, nCrvBase, dMinX, dMaxX, dAng, dDim1, dStrand)
+   
+   local ptRef = EgtSP( nCrvBase)
+   local dReflDist = dDim1 * cos( dAng) + dStrand * 0.5
+   
+   -- rifletto la curva base in X+
+   local nPrevCrv = nCrvBase
+   local dXRefl = ptRef:getX() + dReflDist
+   while dXRefl < dMaxX do
+      local nCurrCrv = EgtCopyGlob( nPrevCrv, nGrp, GDB_IN.LAST_SON)
+      -- riflessione
+      local ptRefl = Point3d( dXRefl, ptRef:getY(), ptRef:getZ())
+      EgtMirror( nCurrCrv, ptRefl, X_AX())
+      -- aggiorno per iterazione successiva
+      nPrevCrv = nCurrCrv
+      dXRefl = dXRefl + dReflDist + 0.5 * dStrand
+   end
+
+   -- rifletto la curva base in X-
+   nPrevCrv = nCrvBase
+   dXRefl = ptRef:getX() - dStrand / 2
+   while dXRefl > dMinX do
+      local nCurrCrv = EgtCopyGlob( nPrevCrv, nGrp, GDB_IN.FIRST_SON)
+      -- riflessione
+      local ptRefl = Point3d( dXRefl, ptRef:getY(), ptRef:getZ())
+      EgtMirror( nCurrCrv, ptRefl, X_AX())
+      -- aggiorno per iterazione successiva
+      nPrevCrv = nCurrCrv
+      dXRefl = dXRefl - dReflDist - 0.5 * dStrand
+   end
+end
+
+--------------------------------------------------------------------
+local function CalcGridFromPattern( nInfillGrp, nStmId, dOffsStm, frRef, vtOffs, dDim1, dDim2, dAng, vSlicesAng, dStrand, vtSlicing)
+   
+   -- direzione principale
+   local frLoc = Frame3d( frRef)
+   frLoc:rotate( ORIG(), vtSlicing, vSlicesAng[1])
+   local nMainGrp = EgtGroup( nInfillGrp, frLoc, GDB_RT.GLOB)
+   
+   -- recupero il box del pezzo nel frame della direzione principale
+   local b3Loc = EgtGetBBoxRef( nStmId, GDB_BB.STANDARD, frLoc)
+   b3Loc:expand( dOffsStm)
+   local ptMin = b3Loc:getMin()
+   local ptMax = b3Loc:getMax()
+   
+   -- creo la curva base
+   vtOffs:locToLoc( frRef, frLoc)
+   local pt1 = ptMin + vtOffs
+   local pt2 = pt1 + dDim2 * Y_AX()
+   local nCrvBase = EgtCurveCompoFromPoints( nMainGrp, {pt1, pt2})
+   if not nCrvBase then
+      -- caso zigzag con dOverlapGrid = 100 ( dDim2 = 0)
+      local vtDir1 = VectorFromPolar( 1, dAng)
+      local vtDir2 = VectorFromPolar( 1, 180 - dAng)
+      pt2 = pt1 + vtDir1 * dDim1
+      nCrvBase = EgtCurveCompoFromPoints( nMainGrp, {pt1, pt2})
+      pt2 = pt2 + vtDir2 * dDim1
+      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)
+
+   -- calcolo centro di rotazione
+   local dDimPattern = 2 * dDim2 + 2 * dDim1 * sin( dAng)
+   local dDimTot = ( EgtEP( nCrvBase):getY() - EgtSP( nCrvBase):getY()) - dDim2
+   local dExtra = floor( dDimTot / dDimPattern * 0.5) * dDimPattern
+   local ptCen = EgtSP( nCrvBase) + ( 3/2 * dDim2 + sin( dAng) * dDim1) * Y_AX() - dStrand * 0.5 * X_AX() + dExtra * Y_AX()
+
+   for i = 2, #vSlicesAng do
+      
+      -- calcolo il nuovo riferimento
+      local frLoc2 = Frame3d( frRef)
+      frLoc2:rotate( ORIG(), vtSlicing, vSlicesAng[i])
+      local nGrp = EgtGroup( nInfillGrp, frLoc2, GDB_RT.GLOB)
+      
+      -- calcolo il box del pezzo nel nuovo riferimento
+      local b3Loc2 = EgtGetBBoxRef( nStmId, GDB_BB.STANDARD, frLoc2)
+      b3Loc2:expand( dOffsStm)
+      local ptMin2 = b3Loc2:getMin()
+      local ptMax2 = b3Loc2:getMax()
+      
+      -- creo curva base ruotando la curva base della direzione principale
+      local nCrvBase2 = EgtCopyGlob( nCrvBase, nMainGrp)
+      EgtRotate( nCrvBase2, ptCen, Z_AX(), vSlicesAng[i] - vSlicesAng[1])
+      EgtRelocateGlob( nCrvBase2, nGrp)
+      CompletePatternBaseCrv( nCrvBase2, dAng, dDim1, dDim2, ptMin2:getY(), ptMax2:getY())
+      
+      -- preparo le altre curve
+      CalcPatternCrvs( nGrp, nCrvBase2, ptMin2:getX(), ptMax2:getX(), dAng, dDim1, dStrand)
+   end
+   
+end
+
+--------------------------------------------------------------------
+local function CalcInfill( nInfillGrp, nType, dDensity, dDir, dOffsX, dOffsY, dGridOverlap, nStmId, dOffsStm, dStrand, vtSlicing)
+   
+   -- frame locale alla direzione dell'infill
+   local frLoc = Frame3d( ORIG(), vtSlicing)
+   frLoc:rotate( ORIG(), vtSlicing, dDir)
+
+   -- distanza fra le varie passate
+   local dDist = 100 / dDensity * dStrand
+   
+   -- offset in X e Y
+   local vtOffs = Vector3d( dOffsX, dOffsY, 0)
+   vtOffs:toLoc( frLoc)
+   
+   -- eventuale correzione di dGridOverlap
+   if nType ~= FILL_TYPE.LINES and nType ~= FILL_TYPE.GRID and dDensity > 85 then
+      EgtOutLog( 'Warning: InfillGridOverlap is ignored due to high infill density - CalcSlices')
+      dGridOverlap = 0
+   end
+   
+   -- creo le curve di infill
+   if nType == FILL_TYPE.LINES then
+      CalcLinesInfill( nInfillGrp, nStmId, dOffsStm, frLoc, vtOffs, dDist)
+      
+   elseif nType == FILL_TYPE.GRID then
+      CalcSimpleGridInfill( nInfillGrp, nStmId, dOffsStm, frLoc, vtOffs, dDist)
+      
+   elseif nType == FILL_TYPE.ZIG_ZAG_GRID then
+      local dRealStrand = ( 1 - dGridOverlap / 100) * dStrand
+      local dAng = 45
+      local dDim1 = ( dDist - dStrand) * sqrt(2)
+      local dDim2 = dRealStrand
+      local vSlicesAng = {-45, 45}
+      CalcGridFromPattern( nInfillGrp, nStmId, dOffsStm, frLoc, vtOffs, dDim1, dDim2, dAng, vSlicesAng, dRealStrand, vtSlicing)
+
+   elseif nType == FILL_TYPE.HONEYCOMB or nType == FILL_TYPE.HONEYCOMB_GRID then
+      local dRealStrand = ( 1 - dGridOverlap / 100) * dStrand
+      local dAng = 30
+      local dDim1 = ( dDist - dStrand) / cos(30)
+      local dDim2 = dDim1 + sqrt(3) * dRealStrand
+      local vSlicesAng = EgtIf( nType == FILL_TYPE.HONEYCOMB, {0}, {0, 60, 120})
+      CalcGridFromPattern( nInfillGrp, nStmId, dOffsStm, frLoc, vtOffs, dDim1, dDim2, dAng, vSlicesAng, dRealStrand, vtSlicing)
+   end
+end
+
+--------------------------------------------------------------------
+local function PrepareInfill( nStmId, vtSlicing)
+   
+   -- verifco se richiesto infill
+   local nShells = EgtGetInfo( s_nPartId, KEY_SHELLS_NBR, 'i')
+   if nShells == 0 then return end
+   local nType = EgtGetInfo( s_nPartId, KEY_INFILL_TYPE, 'i') or FILL_TYPE.NONE
+   if nType == FILL_TYPE.NONE then return end
+   local dDensity = EgtGetInfo( s_nPartId, KEY_INFILL_DENSITY, 'd') or 0
+   if dDensity < GEO.EPS_SMALL then return end
+   dDensity = EgtClamp( dDensity, 0, 90)
+   
+   -- recupero i parametri per infill
+   local dDir = EgtGetInfo( s_nPartId, KEY_INFILL_DIR, 'd') or 0
+   local dOffsX = EgtGetInfo( s_nPartId, KEY_INFILL_OFFSET_X, 'd') or 0
+   local dOffsY = EgtGetInfo( s_nPartId, KEY_INFILL_OFFSET_Y, 'd') or 0
+   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)
+   EgtSetName( nInfillGrp, INFILL_GRP)
+   EgtSetStatus( nInfillGrp, GDB_ST.OFF)
+   
+   -- calcolo infill
+   CalcInfill( nInfillGrp, nType, dDensity, dDir, dOffsX, dOffsY, dGridOverlap, nStmId, dOffsStm, dStrand, vtSlicing)
+   
+   -- aggiungo allo slicing
+   SlicingInfill( nInfillGrp, vtSlicing, INFILL_CRV, INFILL_GRP)
+end
+
+----------------------------------------------------------------------
+local function PrepareAuxSolidsInfill( nSolidsLay, vtSlicing)
+   
+   local vIds = EgtGetAllInGroup( nSolidsLay)
+   -- scorro tutti gli AuxSolids
+   for i = 1, #vIds do
+      if EgtGetType( vIds[i]) == GDB_TY.SRF_MESH then
+         -- verifico se da realizzare con infill e non con solidfill
+         local nType = ReadParam( vIds[i], KEY_AUX_SOLIDS_INFILL, 'i', FILL_TYPE.NONE)
+         if nType & FILL_CATEGORY.INFILL ~= 0 then
+            local dDensity = ReadParam( vIds[i], KEY_AUX_SOLIDS_DENSITY, 'd', 0)
+            if dDensity > GEO.EPS_SMALL then
+               dDensity = EgtClamp( dDensity, 0, 90)
+               
+               -- recupero i parametri per infill
+               local dDir = ReadParam( vIds[i], KEY_AUX_SOLIDS_DIR, 'd', 0)
+               local dOffsX = ReadParam( vIds[i], KEY_AUX_SOLIDS_OFFSET_X, 'd', 0)
+               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]))
+               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)
+            end
+         end
+      end
+   end
+end
+
+--------------------------------------------------------------------
+local function ExtractRibsLoops( nRibsGrp, nStmId)
+   
+   local nLoopGrp = EgtGroup( s_nPartId)
+   EgtSetName( nLoopGrp, RIBS_LOOP_GRP)
+   EgtSetStatus( nLoopGrp, GDB_ST.OFF)
+   
+   -- recupero tutti i setti
+   local vIds = EgtGetAllInGroup( nRibsGrp)
+   for i = 1, #vIds do
+      -- se trimesh
+      if EgtGetType( vIds[i]) == GDB_TY.SRF_MESH then
+         -- trim con il solido
+         local nCopy = EgtCopyGlob( vIds[i], nLoopGrp)
+         local nType = ReadParam( vIds[i], KEY_RIBS_TYPE, 'i', RIB_TYPE.INTERNAL)
+         EgtSurfTmCut( nCopy, nStmId, nType ~= RIB_TYPE.EXTERNAL, false)
+         -- estraggo i contorni
+         local nCrv, nCnt = EgtExtractSurfTmLoops( nCopy, nLoopGrp)
+         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]))
+            end
+         end
+      end
+   end
+end
+
 ---------------------------------------------------------------------
 local function ValueInArray( vArr, nValue)
    for _, val in ipairs( vArr) do
@@ -312,7 +731,7 @@ local function ValueInArray( vArr, nValue)
 end
 
 ---------------------------------------------------------------------
-local function SlicingNoSolid( nRibsLay, vZSlices, dDeltaZStart, dZmin, frSlicing, vErr)
+local function SlicingNoSolid( nRibsLay, vZSlices, dDeltaZStart, dZmin, frSlicing)
    
    local vtSlicing = frSlicing:getVersZ()
    
@@ -337,21 +756,14 @@ local function SlicingNoSolid( nRibsLay, vZSlices, dDeltaZStart, dZmin, frSlicin
    if EgtProcessEvents( EgtIf( PRINT, 100, 0) + 20, 0) == 1 then return false end
     
    -- slicing dei setti
-   SlicingExtraObjects( vtSlicing, nRibsLay, TYPE.RIB, RIBS_GRP, RIBS_CRV)
+   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, vErr)
+local function SlicingWithSolid( nStmId, vZSlices, dDeltaZStart, dZmin, frSlicing)
-      
-   -- costanti
-   local TOLER = 0.05 
-   local MID_TOLER = 0.1
-   local BIG_TOLER = 2.0
-   local MIN_LEN = 20.0
-   local MIN_AREA = 25.0
 
    local vtSlicing = frSlicing:getVersZ()
    
@@ -362,6 +774,10 @@ local function SlicingWithSolid( nStmId, vZSlices, dDeltaZStart, dZmin, frSlicin
    
    local vPrevCen = {}
    local nLayCnt = 1
+   local nCounterTot = #vZSlices + 12
+   
+   local nFirstSolidLay   -- primo layer che contiene il solido
+   local nLastSolidLay    -- ultimo layer che contiene il solido
    
    -- scorro i risultati dello slicing
    while nLayId do
@@ -379,7 +795,7 @@ local function SlicingWithSolid( nStmId, vZSlices, dDeltaZStart, dZmin, frSlicin
       local nRecalc = 0
       while nId and not bRecalc do
          local nType = EgtGetType( nId)
-         if nType == GDB_TY.SRF_MESH then 
+         if nType == GDB_TY.SRF_MESH then
             bRecalc = true
             vtRecalc = EgtSurfTmFacetNormVersor( nId, 0)
          elseif nType == GDB_TY.GEO_POINT then
@@ -395,7 +811,7 @@ local function SlicingWithSolid( nStmId, vZSlices, dDeltaZStart, dZmin, frSlicin
          dDeltaZ = dDeltaZ + EgtIf( vtRecalc and vtRecalc:getZ() > 0, -0.01, 0.01)
          -- eseguo il ricalcolo solo a quella quota
          EgtPlaneSurfTmInters( ORIG() + ( dPosZ + dDeltaZ) * vtSlicing, vtSlicing, nStmId, nLayId, GDB_RT.GLOB, TOLER)
-         EgtOutLog( 'Warning : Recalc at Lay'.. EgtNumToString( nLayCnt))
+         EgtOutLog( 'Warning : recalc at layer '.. EgtNumToString( nLayCnt))
       end
       EgtSetInfo( nLayId, KEY_SLICE_DELTAZ, dDeltaZ)
    
@@ -403,6 +819,13 @@ local function SlicingWithSolid( nStmId, vZSlices, dDeltaZStart, dZmin, frSlicin
       local vClosedId = {}
       local vOpenId = {}
       nId = EgtGetFirstInGroup( nLayId)
+      
+      -- se slicing del solido aggiorno i valori dei layer estremi che lo contengono
+      if nId then
+         if not nFirstSolidLay then nFirstSolidLay = nLayCnt end
+         nLastSolidLay = nLayCnt
+      end
+
       while nId do 
          if EgtGetType( nId) == GDB_TY.GEO_POINT or EgtGetType( nId) == GDB_TY.SRF_MESH then
             -- se punto o superficie lo elimino
@@ -571,6 +994,10 @@ local function SlicingWithSolid( nStmId, vZSlices, dDeltaZStart, dZmin, frSlicin
                EgtSetColor( nId2, 'BLACK')
             end
          end
+         
+         if #vOpenId > 1 then
+            EgtOutLog( 'Error : hole in solid (layer '.. EgtNumToString( nLayCnt) ..') - CalcSlices')
+         end
       else
          
          local bErr = true
@@ -586,7 +1013,8 @@ local function SlicingWithSolid( nStmId, vZSlices, dDeltaZStart, dZmin, frSlicin
          
          -- se vero errore lo segnalo
          if bErr then
-            table.insert( vErr, nLayCnt)
+            EgtOutLog( 'Error : hole in solid (layer '.. EgtNumToString( nLayCnt) ..') - CalcSlices')
+            table.insert( s_vErr, nLayCnt)
             -- cambio nome al layer
             EgtSetName( nLayId, '__' .. SLICE_LAYER .. EgtNumToString( nLayCnt))
          else
@@ -597,7 +1025,7 @@ local function SlicingWithSolid( nStmId, vZSlices, dDeltaZStart, dZmin, frSlicin
       end
       
       -- passo al layer successivo
-      if EgtProcessEvents( EgtIf( PRINT, 100, 0) + nLayCnt / ( #vZSlices + 3) * 100, 0) == 1 then
+      if EgtProcessEvents( EgtIf( PRINT, 100, 0) + nLayCnt / nCounterTot * 100, 0) == 1 then
          -- elimino i layer non ancora analizzati
          local nNext = EgtGetNext( nLayId)
          while nNext do
@@ -614,44 +1042,54 @@ local function SlicingWithSolid( nStmId, vZSlices, dDeltaZStart, dZmin, frSlicin
 
    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)
-      if nRibsLay then
+      ExtractRibsLoops( nRibsLay, nStmId)
-         SlicingExtraObjects( vtSlicing, nRibsLay, TYPE.RIB, RIBS_GRP, RIBS_CRV, nStmId)
+      SlicingExtraObjects( nRibsLay, vtSlicing, TYPE.RIB, RIBS_CRV, RIBS_GRP, nStmId)
-      end
+      if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( #vZSlices + 6) / nCounterTot * 100, 0) == 1 then return false end
-      if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( #vZSlices + 1) / ( #vZSlices + 3) * 100, 0) == 1 then return false end
       
       -- solidi per regioni con diverso numero di passate
       local nShellNbrLay = EgtGetFirstNameInGroup( s_nPartId, LAY_SHELL_NBR)
-      if nShellNbrLay then
+      SlicingExtraObjects( nShellNbrLay, vtSlicing, TYPE.EXTRA_SHELL, SHELL_NBR_CRV, SHELL_NBR_GRP)
-         SlicingExtraObjects( vtSlicing, nShellNbrLay, TYPE.EXTRA_SHELL, SHELL_NBR_GRP, SHELL_NBR_CRV, nStmId)
+      if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( #vZSlices + 9) / nCounterTot * 100, 0) == 1 then return false end
-      end
-      if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( #vZSlices + 2) / ( #vZSlices + 3) * 100, 0) == 1 then return false end
       
       -- solidi ausiliari
       local nAuxSolidsLay = EgtGetFirstNameInGroup( s_nPartId, LAY_AUX_SOLIDS)
-      if nAuxSolidsLay then
+      SlicingExtraObjects( nAuxSolidsLay, vtSlicing, TYPE.AUX_SOLID, AUX_SOLIDS_CRV, AUX_SOLIDS_GRP)
-         AdjustAuxSolids( nAuxSolidsLay)
+      PrepareAuxSolidsInfill( nAuxSolidsLay, vtSlicing)
-         SlicingExtraObjects( vtSlicing, nAuxSolidsLay, TYPE.AUX_SOLID, AUX_SOLIDS_GRP, AUX_SOLIDS_CRV, nStmId)
+      if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( #vZSlices + 12) / nCounterTot * 100, 0) == 1 then return false end
-      end
+      
-      if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( #vZSlices + 3) / ( #vZSlices + 3) * 100, 0) == 1 then return false end
    end
    
+   EgtSetInfo( s_nPartId, KEY_FIRST_SOLID_LAY, nFirstSolidLay)
+   EgtSetInfo( s_nPartId, KEY_LAST_SOLID_LAY, nLastSolidLay)
+   
    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()
    end
@@ -696,34 +1134,34 @@ function CalcSlices.Exec( nPartId, nStmId, HMax)
       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)
+   local dMaxH = ComputeMaxH( vRefIds, frSlicing, dSliceStep)
    dZmax = min( dZmax, dMaxH)
    --dZmin = 708
    --dZmax = 712
    
    -- Eseguo slicing
-   local nLayCnt = 1 
+   local nLayCnt = 1
    local nRecalc = 0
    local dDeltaZStart = 0.2
    
    local vZSlices = ComputeZSlices( dSliceStep, dZmin, dDeltaZStart, dZmax)
 
-   local vErr = {}
    local bOk = true
    if not nStmId then
       -- caso senza solido e solo setti
-      bOk = SlicingNoSolid( nRibsLay, vZSlices, dDeltaZStart, dZmin, frSlicing, vErr)
+      bOk = SlicingNoSolid( nRibsLay, vZSlices, dDeltaZStart, dZmin, frSlicing)
    else
       -- caso con solido
-      bOk = SlicingWithSolid( nStmId, vZSlices, dDeltaZStart, dZmin, frSlicing, vErr)
+      bOk = SlicingWithSolid( nStmId, vZSlices, dDeltaZStart, dZmin, frSlicing)
    end
    
    -- eventuale segnalazione errori
-   if bOk and #vErr > 0 then
+   if bOk and #s_vErr > 0 then
-      EgtOutBox( 'Slicing Error on layers :\n' .. table.concat( vErr, ','), 'SlicingCalc')
+      EgtOutBox( 'Slicing Error on layers :\n' .. table.concat( s_vErr, ','), 'SlicingCalc')
     end
     
     return bOk

LuaLibs/RunCalcSolids.lua

@@ -20,7 +20,6 @@ local function GetLayerParamsForSolidCalc( nPartId)
    local LayerParams = {}
    LayerParams.bSpiralVase = EgtGetInfo( nPartId, KEY_SPIRAL_VASE, 'b') or false
    LayerParams.dLayHeight = EgtGetInfo( nPartId, KEY_SLICE_STEP, 'd')
-   LayerParams.dStrand = EgtGetInfo( nPartId, KEY_STRAND, 'd')
    LayerParams.vtSlicing = EgtGetInfo( nPartId, KEY_SLICING_DIR, 'v')
    return LayerParams
 end
@@ -192,7 +191,7 @@ local function CreateSolidFromCurve( nCrvId, nSolidGrp, LayerParams, nLayer)
    local nType = EgtGetInfo( nCrvId, KEY_TYPE, 'i')   
    if nType == TYPE.WIPE then return true end 
    -- scelta del colore
-   local Color = EgtStdColor( 'GRAY') 
+   local Color = EgtStdColor( 'GRAY')
    if nType == TYPE.OUTER_SHELL or nType == TYPE.EXTRA_OUTER_SHELL then 
       Color = EgtStdColor( 'TEAL')
    elseif nType == TYPE.INNER_SHELL or nType == TYPE.EXTRA_SHELL then
@@ -203,14 +202,13 @@ local function CreateSolidFromCurve( nCrvId, nSolidGrp, LayerParams, nLayer)
       Color = EgtStdColor( 'YELLOW')
    elseif nType == TYPE.COASTING then
       Color = EgtStdColor( 'BLUE')
-   elseif nType == TYPE.WIPE then
-      Color = EgtStdColor( 'LIME')
    elseif nType == TYPE.RIB then
       Color = EgtStdColor( 'OLIVE')
    elseif nType == TYPE.AUX_SOLID then
       Color = EgtStdColor( 'AQUA')
    end
-
+   local dStrand = EgtGetInfo( nCrvId, KEY_CRV_STRAND, 'd')
+   
    local nCopyId = EgtCopyGlob( nCrvId, nSolidGrp)
    local nId = GDB_ID.NULL
    local nParts = 1
@@ -230,7 +228,7 @@ local function CreateSolidFromCurve( nCrvId, nSolidGrp, LayerParams, nLayer)
    local bOk = true
    for nInd = 0, nParts - 1 do
       local nGuideId = nId + nInd
-      local nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams, LayerParams.dStrand - 5 * GEO.EPS_SMALL)
+      local nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams, dStrand - 5 * GEO.EPS_SMALL)
       if not nSrfId then
          EgtOutLog( 'Warning : CreateSolid failed '.. '(layer '..tostring( nLayer)..', curve '..tostring( nCrvId)..')')
          -- se non ultima, provo a spostare l'estremità finale
@@ -241,9 +239,9 @@ local function CreateSolidFromCurve( nCrvId, nSolidGrp, LayerParams, nLayer)
                local bOk1 = EgtTrimCurveEndAtLen( nCopyId, LEN_TRIM)
                local bOk2 = EgtAddCurveCompoCurve( nGuideId, nCopyId)
                local bOk3 = EgtTrimCurveStartAtLen( nGuideId + 1, LEN_TRIM)
-               nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams, LayerParams.dStrand - 5 * GEO.EPS_SMALL)
+               nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams, dStrand - 5 * GEO.EPS_SMALL)
                if not nSrfId then
-                  nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams, LayerParams.dStrand - 50 * GEO.EPS_SMALL)
+                  nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams, dStrand - 50 * GEO.EPS_SMALL)
                end
             end
          end
@@ -258,7 +256,7 @@ local function CreateSolidFromCurve( nCrvId, nSolidGrp, LayerParams, nLayer)
             if nFirstCrv and nCrvNbr > 1 then
                local nSrfIds = {}
                for nInd2 = 0, nCrvNbr-1 do
-                  local nSrfId2 = CreateSolid( nFirstCrv + nInd2, nSolidGrp, LayerParams, LayerParams.dStrand - 50 * GEO.EPS_SMALL)
+                  local nSrfId2 = CreateSolid( nFirstCrv + nInd2, nSolidGrp, LayerParams, dStrand - 50 * GEO.EPS_SMALL)
                   EgtErase( nFirstCrv + nInd2)
                   if nSrfId2 then
                      table.insert( nSrfIds, nSrfId2)
@@ -279,6 +277,7 @@ local function CreateSolidFromCurve( nCrvId, nSolidGrp, LayerParams, nLayer)
       if nSrfId then
          EgtSetColor( nSrfId, Color)
          EgtSetInfo( nSrfId, KEY_TYPE, nType)
+         EgtSetInfo( nSrfId, KEY_SLICE_NBR, nLayer)
       else 
          bOk = false
          EgtOutLog( 'Warning : CreateSolid_Sewing failed')
@@ -330,7 +329,7 @@ function RunCalcSolids.Exec()
                   local nTPathGrpId = EgtGetFirstNameInGroup( nCrvGrpId, TOOLPATH_GRP) or GDB_ID.NULL
                   if nTPathGrpId == GDB_ID.NULL then
                      EgtOutBox( 'Error no tool paths', 'SolidCalc')
-                     return 
+                     return
                   end
 
                   -- recupero il gruppo dei solidi 

LuaLibs/RunGcodeGenerate.lua

@@ -1,4 +1,4 @@
--- RunGcodeGenerate.lua by Egaltech s.r.l. 2023/02/02
+-- RunGcodeGenerate.lua by Egaltech s.r.l. 2023/04/11
 -- Calcoli prima fase per Stampa 3d
 
 -- Tabella per definizione modulo
@@ -131,7 +131,7 @@ function RunGcodeGenerate.Exec()
 
    -- Salvo il progetto
    local sFilePath = EgtGetCurrFilePath()
-   sFilePath = EgtChangePathExtension( sFilePath, 'nge')
+   sFilePath = EgtChangePathExtension( sFilePath, 'icrs')
    EgtSetCurrFilePath( sFilePath)
    EgtSaveFile()
 

LuaLibs/RunMachParamFromSWCalc.lua

@@ -62,7 +62,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 +77,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 +86,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
@@ -109,6 +126,44 @@ function RunMachParamFromSWCalc.Exec()
             end
             nCrvId = EgtGetNextName( nCrvId, CONTOUR_GRP .. '*')
          end
+
+
+         -- -- rimuovo eventuale info precedente del tempo di attesa
+         -- EgtRemoveInfo( nLayerId, KEY_WAITING_TIME)
+         -- -- calcolo lunghezza totale del layer
+         -- local dTotLayerLength = 0
+         -- local dTotLayerLengthForMass = 0
+         -- local dTotLayerArea = 0
+         -- local nCrvId = EgtGetFirstNameInGroup( nLayerId, CONTOUR_GRP .. '*')
+         -- while nCrvId do
+         --    local nToolPathId = EgtGetFirstNameInGroup( nCrvId, TOOLPATH_GRP)
+         --    -- sommo lunghezze percorsi
+         --    local dTotCrvLength = 0
+         --    local dTotCrvLengthForMass = 0
+         --    local nShellId = EgtGetFirstInGroup( nToolPathId)
+         --    while nShellId do
+         --       dTotCrvLength = dTotCrvLength + EgtCurveLength( nShellId)
+         --       if EgtGetName( nShellId) ~= WIPE_CRV then
+         --          dTotCrvLengthForMass = dTotCrvLengthForMass + EgtCurveLength( nShellId)
+         --       end
+         --       nShellId = EgtGetNext( nShellId)
+         --    end
+         --    dTotLayerLength = dTotLayerLength + dTotCrvLength
+         --    dTotLayerLengthForMass = dTotLayerLengthForMass + dTotCrvLengthForMass
+         --    -- recupero area
+         --    local nOuterCrvId = EgtGetFirstNameInGroup( nCrvId, OUTER_CRV)
+         --    if nOuterCrvId and dStrandCount > 0.5 then
+         --       local _, _, dTotCrvArea = EgtCurveArea( nOuterCrvId)
+         --       local dOuterLength = EgtCurveLength( nOuterCrvId)
+         --       -- recupero offset del part per aggiungerlo all'area interna
+         --       local dOffset = EgtGetInfo( nPartId, KEY_OFFSET_SLICE, 'd')
+         --       dTotCrvArea = dTotCrvArea + ( dOffset * dOuterLength)
+         --       dTotLayerArea = dTotLayerArea + dTotCrvArea
+         --    end
+         --    nCrvId = EgtGetNextName( nCrvId, CONTOUR_GRP .. '*')
+         -- end
+
+
          -- recupero feed del layer
          local dLayerFeed = 0
          local dLayerWait = 0
@@ -132,11 +187,18 @@ 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 / dTotLayerLength
          -- calcolo costante MF
          local dMF = 1
          local dSC = 1
          if dTotLayerArea > 1 then
-            dMF = dTotLayerLength * dStrand / dTotLayerArea * 100
+            -- dMF = dTotLayerLength * dStrand / dTotLayerArea * 100
+            dMF = dTotLayerLength * dStrandMean / dTotLayerArea * 100
             dSC = dStrandCount
          else
             dMF = 100
@@ -151,9 +213,9 @@ 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 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 * 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 * 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 * 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 * dStrandMean, MATERIAL.KW) * pow( dSliceStep, MATERIAL.KZ) * pow( dSC, MATERIAL.KN)
          local dFMin = dTotLayerLength / dTMax * 60
          local dFTrg = dTotLayerLength / dTTrg * 60
          local dFMax = dTotLayerLength / dTMin * 60
@@ -165,7 +227,7 @@ function RunMachParamFromSWCalc.Exec()
          end
          dLayerWait = floor( dTMin + 0.5) - floor( dLayerTime + 0.5)
          -- calcolo la portata
-         local Vf = dLayerFeed * ( ( dStrand - dSliceStep) * dSliceStep + pi * pow( dSliceStep / 2, 2)) / 1000
+         local Vf = dLayerFeed * ( ( dStrandMean - dSliceStep) * dSliceStep + pi * pow( dSliceStep / 2, 2)) / 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,20 +241,32 @@ 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))
+            dLayerFeed = ( MATERIAL.C1 * pow( ( dSpeed / (( MATERIAL.K_EXTRUSION / 100.0) * ( MACHINING.K / 100.0))), MATERIAL.C2)) * 1000 / ( ( dStrandMean - dSliceStep) * dSliceStep + pi * pow( dSliceStep / 2, 2))
             dLayerTime = dTotLayerLength / dLayerFeed * 60
             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
+               EgtSetInfo( CurrWidth.IdList[nCurveIdIndex], KEY_FEED, CurrFeed)               
+            end
+            if CurrFeed > dFeedMax then
+               dFeedMax = CurrFeed
+            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
-            EgtSetInfo( nToolPathId, KEY_FEED, dLayerFeed)
+            -- EgtSetInfo( nToolPathId, KEY_FEED, dLayerFeed)
             EgtSetInfo( nToolPathId, KEY_SPEED, dSpeed)
             nCrvId = EgtGetNextName( nCrvId, CONTOUR_GRP .. '*')
          end
@@ -206,9 +280,11 @@ function RunMachParamFromSWCalc.Exec()
          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_FMIN, dFMin)
+         -- EgtSetInfo( nLayerResultId, KEY_FTRG, dFTrg)
+         -- EgtSetInfo( nLayerResultId, KEY_FMAX, dFMax)
          EgtSetInfo( nLayerResultId, KEY_TCUR, dLayerTime)
          EgtSetInfo( nLayerResultId, KEY_FCUR, dLayerFeed)
          EgtSetInfo( nLayerResultId, KEY_LENGTH, dTotLayerLength)

LuaLibs/RunSlicing.lua

@@ -66,6 +66,19 @@ local function RemoveOldSlices( nPartId)
          EgtErase( vOldSliceId[i])
       end
    end
+   
+   -- rimuovo gruppo con i loop dei setti
+   local nRibsLoopsGrp = EgtGetFirstNameInGroup( nPartId, RIBS_LOOP_GRP)
+   if nRibsLoopsGrp then
+      EgtErase( nRibsLoopsGrp)
+   end
+   
+   -- rimuovo eventuali gruppi di infill (anche per aux solids)
+   local nInfillId = EgtGetFirstNameInGroup( nPartId, INFILL_GRP .. '*')
+   while nInfillId do
+      EgtErase( nInfillId)
+      nInfillId = EgtGetFirstNameInGroup( nPartId, INFILL_GRP .. '*')
+   end
 end
 
 ---------------------------------------------------------------------
@@ -144,10 +157,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)
    
@@ -158,7 +167,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

Version.lua

@@ -1,4 +1,4 @@
--- Version.lua by Egaltech s.r.l. 2023/02/28
+-- Version.lua by Egaltech s.r.l. 2023/08/28
 -- Gestione della versione di 3dPrinting
 
-VERSION = '2.5c2'
+VERSION = '2.5i1'