3dPrinting 2.5f1 :

- correzioni infill
- aggiornamento versione.

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"
@@ -55,10 +56,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,7 +78,26 @@ 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_TYPE = "InfillType"
+KEY_INFILL_DENSITY = "InfillDensity"
+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_TYPE = "RibsType"
@@ -109,6 +125,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 +141,18 @@ KEY_EXTRA_SHELL_WIPE = "ExtraShellWipe"
 KEY_EXTRA_SHELL_WIPE_DIR = "ExtraShellWipeDir"
 
 -- Solidi ausiliari
+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_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"
@@ -152,9 +175,17 @@ 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"
 
 SLICING_TYPE = {
    VERTICAL = 1,
@@ -209,10 +240,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 +326,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

@@ -14,6 +14,14 @@ local AMD = require( 'AddManData')
 
 ---------------------------------------------------------------------
 local s_nPartId
+local s_vErr = {}
+
+-- 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)
@@ -70,41 +78,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,7 +93,7 @@ local function ReadParam( nId, sKey, sType, defVal, table)
    return info
 end
 
---------------------------------------------------------------------
+-----------------------------------------------------------------------
 local function GetRibParams( nId)
 
    local RibParam = {}
@@ -158,149 +131,571 @@ local function GetAuxSolidsParams( nId)
    
    local AuxSolidsParam = {}
    ReadParam( nId, KEY_AUX_SOLIDS_OVERLAP, 'i', 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_OFFSET_X, 'd', 0, AuxSolidsParam)
+   ReadParam( nId, KEY_AUX_SOLIDS_OFFSET_Y, 'd', 0, AuxSolidsParam)
+   ReadParam( nId, KEY_AUX_SOLIDS_GRID_OVERLAP, 'i', 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 nOverlapGrid = 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, nGridOverlap, 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 nGridOverlap
+   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')
+      nGridOverlap = 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 - nGridOverlap / 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 - nGridOverlap / 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
+   
+   -- 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 nGridOverlap = EgtGetInfo( s_nPartId, KEY_INFILL_GRID_OVERLAP, 'i') or 0
+   local dOffsStm = EgtGetInfo( s_nPartId, KEY_OFFSET_SLICE, 'd')
+   local dStrand = EgtGetInfo( s_nPartId, KEY_STRAND, 'd')
+   
+   -- 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, nGridOverlap, 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
+               
+               -- 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 nGridOverlap = ReadParam( vIds[i], KEY_AUX_SOLIDS_GRID_OVERLAP, 'i', 0)
+               local dStrand = EgtGetInfo( s_nPartId, KEY_STRAND, 'd')
+               
+               -- 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, nGridOverlap, 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 +707,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 +732,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 +750,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 +771,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 +787,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 +795,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 +970,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 +989,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 +1001,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,29 +1018,33 @@ 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
 
@@ -711,19 +1119,18 @@ function CalcSlices.Exec( nPartId, nStmId, HMax)
    
    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/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/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
 
 ---------------------------------------------------------------------

Version.lua

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