3dPrinting :

- ripristinata scrittura feed in toolpath.
3dPrinting :
2023-10-02 18:06:22 +02:00 · 2023-10-02 17:28:31 +02:00 · 2023-10-02 16:14:48 +02:00 · 2023-10-02 16:12:29 +02:00 · 2023-10-02 16:12:15 +02:00 · 2023-10-02 14:20:42 +02:00
11 changed files with 3898 additions and 1466 deletions
@@ -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"
+    ]
+}
@@ -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
@@ -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 = {
-   NONE = 1,
-   OFFSET = 2,
-   ZIGZAG = 3,
+FILL_CATEGORY = {
+   NONE = 0,
+   SOLID_FILL = 16,
+   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"
@@ -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
-   local k = 1
-   while k <= #vIds do
-      local nType = EgtGetType( vIds[k])
-      if nType ~= GDB_TY.SRF_MESH then
-         table.remove( vIds, k)
-      else
-         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)
+   -- recupero il gruppo dove salvare lo slicing degli oggetti
+   local nGrp = EgtGetFirstNameInGroup( nLayId, sNameGrp)
+   if not nGrp then
+      -- se gruppo non esiste lo creo
+      nGrp = EgtGroup( nLayId)
+      EgtSetName( nGrp, sNameGrp)
+      EgtSetStatus( nGrp, GDB_ST.OFF)
   end
   
-   -- taglio i setti unbounded e limitati con il solido
-   local vEraseIds = {}
-   if nType == TYPE.RIB then
-      local bLimitUnbddRibs = EgtGetInfo( s_nPartId, KEY_LIMIT_UNBDD_RIBS, 'b') or false
-      if bLimitUnbddRibs then
-         for i = 1, #vIds do
-            if vToBeDone[i] then
-               if tabParams[i][KEY_RIBS_TYPE] == RIB_TYPE.UNBOUNDED then
-                  -- creo copia e la taglio con solido
-                  local nCopy = EgtCopyGlob( vIds[i], EgtGetParent( vIds[i]))
-                  EgtSurfTmCut( nCopy, nStmId, true, true)
-                  -- lo slicing viene fatto sulla copia
-                  vIds[i] = nCopy
-                  table.insert( vEraseIds, nCopy)
+   -- recupero quota per slicing
+   local dZ = EgtGetInfo( nLayId, KEY_SLICE_REAL_Z, 'd')
+   local dDeltaZ = EgtGetInfo( nLayId, KEY_SLICE_DELTAZ, 'd')
+   local nLayCnt = EgtGetInfo( nLayId, KEY_SLICE_NBR, 'i')
+   
+   -- gruppo temporaneo per approx curve
+   local frloc = Frame3d( ORIG(), vtSlicing)
+   local nGrpTmp = EgtGroup( nLayId, frloc, GDB_RT.GLOB)
+
+   for i = 1, #vIds do
+      -- verifico che oggetto sia trimesh
+      local nTypeObj = EgtGetType( vIds[i])
+      if nTypeObj == GDB_TY.SRF_MESH then
+         -- slicing oggetto
+         local nNewId, nPntCnt, nCrvCnt, nSrfCnt = EgtPlaneSurfTmInters( ORIG() + ( dZ + dDeltaZ) * vtSlicing, vtSlicing, vIds[i], nGrp, GDB_RT.GLOB, TOLER)
+   
+         -- 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
-   end
-   
-   local nLayId = EgtGetFirstNameInGroup( s_nPartId, SLICE_LAYER .. '*')
-   while nLayId do
-      -- recupero quota per slicing
-      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
+         -- eventuale ricalcolo ( se superfici o curve aperte)
+         if nSrfCnt > 0 or bOpen then
+            EgtOutLog( 'Warning : recalc at layer '.. EgtNumToString( nLayCnt) .. ' (object)')
+            -- elimino vecchio risultato
+            for j = nNewId, nNewId + nPntCnt + nCrvCnt + nSrfCnt - 1 do
+               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

-            if nSrfCnt > 0 or bOpen then
-               -- elimino vecchio risultato
-               for j = nNewId, nNewId + nPntCnt + nCrvCnt + nSrfCnt - 1 do
-                  EgtErase( j)
-               end
-               dCorr = 0.01
-               nNewId, nPntCnt, nCrvCnt, nSrfCnt = EgtPlaneSurfTmInters( ORIG() + ( dZ + dDeltaZ + dCorr) * vtSlicing, vtSlicing, vIds[i], nGrp, GDB_RT.GLOB, TOLER)
+            -- rimuovo punti
+            for nId = nNewId, nNewId + nPntCnt -1 do
+               EgtErase( nId)
            end
            
-            if nNewId then
-               -- rimuovo punti
-               for nId = nNewId, nNewId + nPntCnt -1 do
-                  EgtErase( nId)
-               end
-               -- rinomino le curve, correggo di DeltaZ e assegno parametri
-               for nId = nNewId + nPntCnt, nNewId + nPntCnt + nCrvCnt - 1 do
-                  EgtSetName( nId, sName .. tostring( i))
-                  EgtMove( nId, - ( dDeltaZ + dCorr) * vtSlicing)
+            -- concateno le curve
+            local vChain = {}
+            for nId = nNewId + nPntCnt, nNewId + nPntCnt + nCrvCnt - 1 do
+               table.insert( vChain, nId)
+            end
+            local nChainId, nCnt = EgtCurveCompoByChain( nGrp, vChain, ORIG(), true, GDB_RT.LOC, TOLER)
+            if not nChainId then
+               -- se fallisce riprendo le curve originali
+               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
-               for nId = nNewId + nPntCnt + nCrvCnt, nNewId + nPntCnt + nCrvCnt + nSrfCnt - 1 do
-                  EgtErase( nId)
+               EgtModifyCurveExtrusion( nId, vtSlicing, GDB_RT.GLOB)
+               EgtRelocateGlob( nId, nGrpTmp)
+               EgtApproxCurve( nId, GDB_CA.ARCS, MID_TOLER)
+               EgtRelocateGlob( nId, nGrp)
+             
+               -- se ho ancora curve aperte, segnalo errore
+               if nType ~= TYPE.RIB and nType ~= TYPE.INFILL and not EgtCurveIsClosed( nId) then
+                  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
-      if not EgtGetFirstInGroup( nGrp) then
-         EgtErase( nGrp)
+   -- verifico che il gruppo non sia vuoto
+   if not EgtGetFirstInGroup( nGrp) then
+      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)
-      
-   -- 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 SlicingWithSolid( nStmId, vZSlices, dDeltaZStart, dZmin, frSlicing)

   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
-         SlicingExtraObjects( vtSlicing, nRibsLay, TYPE.RIB, RIBS_GRP, RIBS_CRV, nStmId)
-      end
-      if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( #vZSlices + 1) / ( #vZSlices + 3) * 100, 0) == 1 then return false end
+      ExtractRibsLoops( nRibsLay, nStmId)
+      SlicingExtraObjects( nRibsLay, vtSlicing, TYPE.RIB, RIBS_CRV, RIBS_GRP, nStmId)
+      if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( #vZSlices + 6) / nCounterTot * 100, 0) == 1 then return false end
      
      -- solidi per regioni con diverso numero di passate
      local nShellNbrLay = EgtGetFirstNameInGroup( s_nPartId, LAY_SHELL_NBR)
-      if nShellNbrLay then
-         SlicingExtraObjects( vtSlicing, nShellNbrLay, TYPE.EXTRA_SHELL, SHELL_NBR_GRP, SHELL_NBR_CRV, nStmId)
-      end
-      if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( #vZSlices + 2) / ( #vZSlices + 3) * 100, 0) == 1 then return false end
+      SlicingExtraObjects( nShellNbrLay, vtSlicing, TYPE.EXTRA_SHELL, SHELL_NBR_CRV, SHELL_NBR_GRP)
+      if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( #vZSlices + 9) / nCounterTot * 100, 0) == 1 then return false end
      
      -- solidi ausiliari
      local nAuxSolidsLay = EgtGetFirstNameInGroup( s_nPartId, LAY_AUX_SOLIDS)
-      if nAuxSolidsLay then
-         AdjustAuxSolids( nAuxSolidsLay)
-         SlicingExtraObjects( vtSlicing, nAuxSolidsLay, TYPE.AUX_SOLID, AUX_SOLIDS_GRP, AUX_SOLIDS_CRV, nStmId)
-      end
-      if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( #vZSlices + 3) / ( #vZSlices + 3) * 100, 0) == 1 then return false end
+      SlicingExtraObjects( nAuxSolidsLay, vtSlicing, TYPE.AUX_SOLID, AUX_SOLIDS_CRV, AUX_SOLIDS_GRP)
+      PrepareAuxSolidsInfill( nAuxSolidsLay, vtSlicing)
+      if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( #vZSlices + 12) / nCounterTot * 100, 0) == 1 then return false end
+      
   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
-      EgtOutBox( 'Slicing Error on layers :\n' .. table.concat( vErr, ','), 'SlicingCalc')
+   if bOk and #s_vErr > 0 then
+      EgtOutBox( 'Slicing Error on layers :\n' .. table.concat( s_vErr, ','), 'SlicingCalc')
    end
    
    return bOk
@@ -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 
@@ -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()

@@ -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 dTTrg = ( MATERIAL.K_LAYERTIME / 100.0) * ( dMF + MATERIAL.ATrg) / MATERIAL.BTrg * pow( 0.25 * dStrand, MATERIAL.KW) * pow( dSliceStep, MATERIAL.KZ) * pow( dSC, MATERIAL.KN)
-         local dTMax = ( MATERIAL.K_LAYERTIME / 100.0) * ( dMF + MATERIAL.AMax) / MATERIAL.BMax * pow( 0.25 * dStrand, MATERIAL.KW) * pow( dSliceStep, MATERIAL.KZ) * pow( dSC, MATERIAL.KN)
+         local dTMin = ( MATERIAL.K_LAYERTIME / 100.0) * ( dMF + MATERIAL.AMin) / MATERIAL.BMin * pow( 0.25 * dStrandMean, MATERIAL.KW) * pow( dSliceStep, MATERIAL.KZ) * pow( dSC, MATERIAL.KN)
+         local dTTrg = ( MATERIAL.K_LAYERTIME / 100.0) * ( dMF + MATERIAL.ATrg) / MATERIAL.BTrg * pow( 0.25 * dStrandMean, MATERIAL.KW) * pow( dSliceStep, MATERIAL.KZ) * pow( dSC, MATERIAL.KN)
+         local dTMax = ( MATERIAL.K_LAYERTIME / 100.0) * ( dMF + MATERIAL.AMax) / MATERIAL.BMax * pow( 0.25 * dStrandMean, MATERIAL.KW) * pow( dSliceStep, MATERIAL.KZ) * pow( dSC, MATERIAL.KN)
         local dFMin = dTotLayerLength / 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,16 +241,28 @@ 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
@@ -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)
@@ -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
@@ -1,4 +1,4 @@
-- Version.lua by Egaltech s.r.l. 2023/02/28
+-- Version.lua by Egaltech s.r.l. 2023/10/02
 -- Gestione della versione di 3dPrinting

-VERSION = '2.5c2'
+VERSION = '2.5j1'
Author	SHA1	Message	Date
Dario Sassi	9f6dda3079	3dPrinting : - ripristinata scrittura feed in toolpath.	2023-10-02 18:06:22 +02:00
SaraP	f3b3704f3b	3dPrinting : - aggunta info di strand anche sulle curve di wipe.	2023-10-02 17:28:31 +02:00
Dario Sassi	1b67ca3559	3dPrinting 2.5j1 : - aggiornamento versione.	2023-10-02 16:14:48 +02:00
Dario Sassi	86d4000455	Merge commit 'd343e36e77aa38c73c98d75d79b715861b30797b'	2023-10-02 16:12:29 +02:00
Dario Sassi	3d5b7522bd	Merge remote-tracking branch 'origin/Feature/CalcTFSDifferentW'	2023-10-02 16:12:15 +02:00
SaraP	d343e36e77	3dPrinting : - corretto errore ingressi e uscite setti.	2023-10-02 14:20:42 +02:00
Emmanuele Sassi	87d2641ab1	- gestito calcolo F e S con strand di differente larghezza	2023-09-25 15:48:10 +02:00
SaraP	b610f1f5e1	3dPrinting 2.5i1 : - sistemata gestione degli strand variabili con valore nullo.	2023-09-20 15:59:58 +02:00
SaraP	d83b571883	3dPrinting : - correzioni nel collegamento tra ribs che terminano esattamente sul pezzo - migliorie varie nei ribs.	2023-09-01 17:03:25 +02:00
SaraP	a595fcdb98	3dPrinting : - corretto collegamento fra ribs esterni che passa sotto il solido.	2023-08-30 09:52:28 +02:00
Dario Sassi	43949d7f13	3dPrinting 2.5h1 : - aggiunta direzione su estrusioni a 45deg in X e Y (X+/- e Y+/-).	2023-08-28 19:52:40 +02:00
SaraP	00700f3194	3dPrinting : - lettura di HMax per slicing dai parametri - correzione slicing filled solids.	2023-08-25 09:25:14 +02:00
SaraP	28686fe6b6	3dPrinting : - introdotta info con numero totale di layers.	2023-08-09 17:34:16 +02:00
SaraP	4a4a7d648b	3dPrinting : - aggiunta chiusura dei percorsi di extra shell - aggiunto clamp sui valori di strand width.	2023-07-20 12:44:32 +02:00
SaraP	03c1768afe	3dPrinting 2.5g1 : - aggiunto numero di passate per Filled Solids.	2023-07-03 10:23:37 +02:00
SaraP	ba9470ee88	3dPrinting : - aggiunto collegamento infill.	2023-06-30 12:52:39 +02:00
SaraP	e629f1b12d	3dPrinting 2.5f2 : - gestione strand variabili per entità.	2023-06-21 09:21:17 +02:00
SaraP	451f3a2939	3dPrinting 2.5f1 : - correzioni infill - aggiornamento versione.	2023-06-15 10:17:29 +02:00
SaraP	bc3cf3b3a9	3dPrinting : - corretto errore reduced shell number di area nulla.	2023-06-08 10:34:42 +02:00
SaraP	4225985a61	3dPrinting : - aggiunta approssimazione delle curve dopo slicing ( per evitare caso di fallimento offset) - migliorata segnalazione errori.	2023-06-06 17:11:09 +02:00
SaraP	fcd61efd53	3dPrinting : - piccole correzioni nei setti per evitare interruzione calcolo.	2023-06-01 17:31:43 +02:00
SaraP	01711d2925	3dPrinting 2.5e3 : - infill prima versione ( lineari, griglia, zigzag, nido d'ape) - aggiunto riempimento ad infill anche nei solidi ausiliari - migliorie varie nella gestione dei riempimenti pieni - migliorie nei link e in StartPointOffsetOnLayer.	2023-05-26 15:20:27 +02:00
SaraP	e015136592	3dPrinting 2.5e2 ; - corretto errore nel lead in/lead out dei setti quando terminano su altro setto - migliorie varie per lead in, lead out e link dei setti.	2023-05-24 08:26:27 +02:00
SaraP	72d1b61c6a	3dPrinting 2.5d5 : - corretto errore nel trim dei setti.	2023-04-28 14:38:45 +02:00
SaraP	02fe05d5e1	3dPrinting 2.5d4 : - corretto errore nel calcolo del lead out per setti.	2023-04-20 12:03:45 +02:00
SaraP	3c839716f8	3dPrinting : - corretto errore nel collegamento setti.	2023-04-18 11:29:46 +02:00
SaraP	2fc63b0d25	3dPrinting : - piccola correzione slicing.	2023-04-17 17:47:02 +02:00
SaraP	9c42a70c6a	3dPrinting 2.5d3 : - migliorata gestione di setti con fori - gestione di setti con link disegnato dall'utente dallo stesso lato del solido.	2023-04-17 17:17:59 +02:00
DarioS	922c5510c0	3dPrinting : - in Generazione CN al salvataggio progetto si impone la nuova estensione "icrs".	2023-04-11 13:16:17 +02:00
DarioS	56ff8468f0	3dPrinting : - aggiunto Version.lua alla compilazione.	2023-04-11 11:43:25 +02:00
SaraP	63efafde60	3dPrinting 2.5d1 : - migliorata segnalazione errori.	2023-04-04 08:59:33 +02:00
SaraP	49c8361bc5	3dPrinting : - nei FilledSolid il riempimento di tipo none viene realizzato con unica passata lungo il perimetro.	2023-03-22 11:52:45 +01:00
SaraP	a7c7bd63ed	3dPrinting : - migliorie nei riempimenti a zigzag per SolidFill - gestione SolidFill con buchi.	2023-03-21 12:14:39 +01:00
Samuele Locatelli	4da4b8cf4d	Merge branch 'develop'	2023-03-20 15:16:59 +01:00