3dPrinting 2.5f1 :

- correzioni infill - aggiornamento versione.
3dPrinting :
2023-06-15 10:17:29 +02:00 · 2023-06-08 10:34:42 +02:00 · 2023-06-06 17:11:09 +02:00 · 2023-06-01 17:31:43 +02:00 · 2023-05-26 15:20:27 +02:00 · 2023-05-24 08:26:27 +02:00
6 changed files with 1602 additions and 822 deletions
@@ -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"
@@ -125,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"
@@ -156,7 +178,14 @@ 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,
@@ -211,10 +240,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 = {
@@ -293,9 +333,14 @@ 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"
@@ -27,10 +27,6 @@ local function GetLayerParamsForPathCalc()
   LayerParams.dLayHeight = EgtGetInfo( s_nPartId, KEY_SLICE_STEP, 'd')
   LayerParams.nStrandOverlap = EgtGetInfo( s_nPartId, KEY_STRAND_OVERLAP, 'i') or 0
   LayerParams.dOffs = EgtGetInfo( s_nPartId, KEY_OFFSET_SLICE, 'd')
-   LayerParams.nFloorNbr = EgtGetInfo( s_nPartId, KEY_FLOOR_NBR, 'i') or 0
-   LayerParams.nFloorType = EgtGetInfo( s_nPartId, KEY_FLOOR_TYPE, 'i') or INFILL_TYPE.ZIGZAG
-   LayerParams.nCeilNbr = EgtGetInfo( s_nPartId, KEY_CEIL_NBR, 'i') or 0
-   LayerParams.nCeilType = EgtGetInfo( s_nPartId, KEY_CEIL_TYPE, 'i') or INFILL_TYPE.ZIGZAG
   LayerParams.vtSlicing = EgtGetInfo( s_nPartId, KEY_SLICING_DIR, 'v')
   LayerParams.bPrintInvert = ( EgtGetInfo( s_nPartId, KEY_PRINT_DIRECTION, 'i') == PRINT_DIRECTION.CW)
   LayerParams.vPrintOrder = EgtGetInfo( s_nPartId, KEY_PRINT_ORDER, 'vi') or { 1, 2, 3, 4, 5, 6, 7, 8}
@@ -40,6 +36,14 @@ local function GetLayerParamsForPathCalc()
   LayerParams.dShellNbrCoasting = EgtGetInfo( s_nPartId, KEY_SHELL_NBR_COASTING, 'd')
   LayerParams.dShellNbrWipe = EgtGetInfo( s_nPartId, KEY_SHELL_NBR_WIPE, 'd')
   LayerParams.dShellNbrWipeDir = EgtGetInfo( s_nPartId, KEY_SHELL_NBR_WIPE_DIR, 'd')
+   -- parametri solid fill
+   LayerParams.nFloorNbr = EgtGetInfo( s_nPartId, KEY_FLOOR_NBR, 'i') or 0
+   LayerParams.nFloorType = EgtGetInfo( s_nPartId, KEY_FLOOR_TYPE, 'i') or FILL_TYPE.OFFSET
+   LayerParams.nCeilNbr = EgtGetInfo( s_nPartId, KEY_CEIL_NBR, 'i') or 0
+   LayerParams.nCeilType = EgtGetInfo( s_nPartId, KEY_CEIL_TYPE, 'i') or FILL_TYPE.OFFSET
+   -- parametri infill
+   LayerParams.nInfillOverlap = EgtGetInfo( s_nPartId, KEY_INFILL_OVERLAP, 'i') or 0
+   LayerParams.nInfillType = EgtGetInfo( s_nPartId, KEY_INFILL_TYPE, 'i') or FILL_TYPE.NONE

   -- eventuale modifica dei parametri per gestire correttamente il caso spiral vase
   if LayerParams.bSpiralVase then
@@ -72,11 +76,13 @@ local function UpdateInvertInfo( nId)
 end

 ----------------------------------------------------------------------
-local function ComputeSurfOffset( nSrf, nGrpId, dOffs, vtSlicing)
+local function ComputeSurfOffset( nSrf, nGrpId, dOffs, vtSlicing, nOffsType)
+   -- tipologia di offset
+   if not nOffsType then nOffsType = GDB_OT.FILLET end
   -- gruppo temporaneo locale
   local nGrpTmp = EgtGroup( nGrpId, Frame3d( ORIG(), vtSlicing), GDB_RT.GLOB)
   local nCopySrf = EgtCopyGlob( nSrf, nGrpTmp) or GDB_ID.NULL
-   local bOk = EgtSurfFrOffset( nCopySrf, dOffs)
+   local bOk = EgtSurfFrOffset( nCopySrf, dOffs, nOffsType)
   local bExists = EgtSurfFrChunkCount( nCopySrf) > 0
   if not bOk or not bExists then
      EgtErase( nCopySrf)
@@ -167,6 +173,7 @@ local function GetPathsFromSurf( nSrfId, sName, nType, nGrpId, vPtStart)
         -- se è loop interno lo inverto per averlo orientato in senso antiorario 
         if nInd > 0 then
            EgtInvertCurve( nCrvId + nInd)
+            EgtSetInfo( nCrvId + nInd, KEY_INTERNAL_SRF_LOOP, true)
         end
         
         -- verifico soddisfi i requisiti (lunghezza e area)
@@ -190,7 +197,8 @@ local function VerifyPath( nCrvId, dStrand, vtSlicing, nGrp)
   
   local _, _, dArea = EgtCurveArea( nCrvId)
   
-   -- verifico se esiste l'offset (permetto una piccola sovrapposizione)
+   -- verifico se esiste l'offset ( permetto una piccola sovrapposizione)
+   -- TODO migliorare il controllo per verificare se sovrapposizione
   local dAllowedOverlap = 1
   local nRes, nCnt = EgtOffsetCurveAdv( nCrvId, - dStrand / 2 + dAllowedOverlap)
   -- se errore ritento con valore leggermente modificato
@@ -211,7 +219,7 @@ local function VerifyPath( nCrvId, dStrand, vtSlicing, nGrp)
         EgtRelocateGlob( nCrvId, nGrpTmp)
         local frLoc, dDimX, dDimY = EgtCurveMinAreaRectangleXY( nCrvId)
         if dDimY < 0.5 then
-            -- TODO  curva generica
+            -- TODO curva generica
            local dZ = EgtSP( nCrvId):getZ()
            -- creo la curva che corrisponde alla sigola passata
            local ptS = frLoc:getOrigin() - dDimX / 2 * frLoc:getVersX() + dZ * Z_AX()
@@ -232,6 +240,21 @@ local function VerifyPath( nCrvId, dStrand, vtSlicing, nGrp)
      end
      -- se non è fattibile con unica passata lo cancello
      if not bSingleStrand then
+         -- verifico se devo eliminarlo dalle info della curva precedente
+         local nPrev = EgtGetInfo( nCrvId, KEY_PREV_CRV, 'i')
+         if nPrev then
+            local vNext = EgtGetInfo( nPrev, KEY_NEXT_CRVS, 'vi')
+            if vNext then
+               for k = 1, #vNext do
+                  if vNext[k] == nCrvId then
+                     table.remove( vNext, k)
+                     break
+                  end
+               end
+               EgtSetInfo( nPrev, KEY_NEXT_CRVS, vNext)
+            end
+         end
+         -- cancello
         EgtErase( nCrvId)
         return false
      end
@@ -241,128 +264,185 @@ local function VerifyPath( nCrvId, dStrand, vtSlicing, nGrp)
 end

 --------------------------------------------------------------------
--------------------- RIEMPIMENTI PIENI ----------------------------
+------------------------- INFILL -----------------------------------
 --------------------------------------------------------------------
-local function AdjustSurfForFloorCeil( nStrandDiff, nSrfTrim, nShellNbrSurfGrp)
-   
-   if EgtSurfFrChunkCount( nSrfTrim) == 0 then return end
+local function CalcInfillPaths( nLayId, nInfillGrp, LayerParams)

-   local nSurf = EgtCopyGlob( nSrfTrim, EgtGetParent( nSrfTrim))
+   if not nInfillGrp then return end
   
-   if nShellNbrSurfGrp then
-      local nIdx = nStrandDiff
-      local nShellSurf = EgtGetFirstNameInGroup( nShellNbrSurfGrp, SHELL_NBR_SURF .. tostring( nIdx))
-      while nShellSurf do
-         EgtSurfFrSubtract( nSurf, nShellSurf)
-         nIdx = nIdx + 1
-         nShellSurf = EgtGetFirstNameInGroup( nShellNbrSurfGrp, SHELL_NBR_SURF .. tostring( nIdx))
-      end
-   end
+   -- recupero le curve di infill
+   local vIds = EgtGetAllInGroup( nInfillGrp)
+   if not vIds or #vIds == 0 then return end
   
-   return nSurf
-end
-
--------------------------------------------------------------------
-local function ReorderPath( vOldIds, vNewIds)
-   
-   if not vNewIds then return end 
-   if #vOldIds == 1 and #vNewIds == 1 then
-      EgtRelocateGlob( vNewIds[1], vOldIds[1], GDB_IN.AFTER)
-      return
-   end
-   
-   -- associo ad ogni elemento di vOldIds gli elementi di vNewIds che contiene
-   local vOrdered = {}
-   if #vOldIds == 1 then
-      vOrdered[vOldIds[1]] = vNewIds
-   else      
-      local nGrp = EgtGetParent( vOldIds[1])
-      -- creo le superifici a partire dalle curve in vOldIds
-      local vOldSurf = {}
-      for i = 1, #vOldIds do         
-         local nSrf = EgtSurfFlatRegion( nGrp, {vOldIds[i]})
-         table.insert( vOldSurf, EgtIf( nSrf, nSrf, GDB_ID.NULL))
-      end
+   -- scorro i gruppi di curve
+   local vCrvGrps = EgtGetNameInGroup( nLayId, CONTOUR_GRP .. '*')
+   for i = 1, #vCrvGrps do
      
-      for i = 1, #vNewIds do
-         for j = 1, #vOldSurf do
-            if vOldSurf[j] ~= GDB_ID.NULL then
-               if not EgtSurfFrTestExternal( vOldSurf[j], vNewIds[i]) then
-                  if vOrdered[vOldIds[j]] then
-                     table.insert( vOrdered[vOldIds[j]], vNewIds[i])
-                  else
-                     vOrdered[vOldIds[j]] = {vNewIds[i]}
-                  end
-                  break
+      -- creo il gruppo per infill
+      local nInfillPathGrp = EgtGroup( vCrvGrps[i])
+      EgtSetName( nInfillPathGrp, INFILL_GRP)
+      EgtSetStatus( nInfillPathGrp, GDB_ST.OFF)
+      EgtSetInfo( nInfillPathGrp, KEY_FILL_TYPE, LayerParams.nInfillType)
+      
+      -- recupero la superficie con cui fare trim
+      local nSrf = EgtGetFirstNameInGroup( vCrvGrps[i], TOT_SHELL_TRIM_SURF)
+      if not nSrf then
+         -- se non esiste non c'è spazio per infill
+         EgtOutLog( 'Warning: Infill not possibile (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths')
+      else
+         local bOk, bExists, nTrimSrf = ComputeSurfOffset( nSrf, nInfillPathGrp, LayerParams.nInfillOverlap / 100 * LayerParams.dStrand, LayerParams.vtSlicing, GDB_OT.EXTEND)
+         if not bOk then
+            -- eseguo trim senza overlap
+            EgtOutLog( 'Warning: Infill without correct overlap (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths')
+            nTrimSrf = EgtCopyGlob( nSrf, nInfillPathGrp)
+         end
+      
+         for i = 1, #vIds do
+            local nNewId = EgtCopyGlob( vIds[i], nInfillPathGrp)
+            -- faccio trim con la superficie
+            local nRes, nCnt = EgtTrimCurveWithRegion( nNewId, nTrimSrf, true, true)
+            for nId = nRes, nRes + nCnt - 1 do
+               -- verifico se lunghezza minima
+               local dLen = EgtCurveLength( nId)
+               if dLen < MIN_INFILL_LEN then
+                  EgtErase( nId)
+               else
+                  EgtSetName( nId, INFILL_CRV)
+                  EgtSetInfo( nId, KEY_TYPE, TYPE.INFILL)
+                  EgtSetInfo( nId, KEY_ASSOCIATED_SURF, nTrimSrf)
+                  EgtModifyCurveExtrusion( nId, LayerParams.vtSlicing)
               end
            end
         end
+         
+         -- avendo riempito la regione con gli infill, la TotShellTrimSurf non deve esistere
+         EgtErase( nSrf)
      end
      
-      for i = 1, #vOldSurf do
-         EgtErase( vOldSurf[i])
+      -- se gruppo vuoto lo cancello
+      if not EgtGetFirstNameInGroup( nInfillPathGrp, INFILL_CRV .. '*') then
+         EgtErase( nInfillPathGrp)
      end
   end
   
-   -- riordino
-   for nParentIdx, vChildren in pairs( vOrdered) do      
-      if #vChildren == 1 then
-         -- se racchiude solo una curva
-         EgtRelocateGlob( vChildren[1], nParentIdx, GDB_IN.AFTER)
-      else
-         EgtSpInit() 
-         -- se racchiude più curve uso shortest path per ordinarle
-         for j = 1, #vChildren do
-            local pt = EgtGP( vChildren[j])
-            EgtSpAddPoint( pt:getX(), pt:getY(), pt:getZ(), 0, 0, pt:getX(), pt:getY(), pt:getZ(), 0, 0)
+   return true
+end
+
+--------------------------------------------------------------------
+------------------------ SOLID FILL --------------------------------
+--------------------------------------------------------------------
+local function AssignChildrenCurves( vParentIds, vChildrenIds, vOrdered)
+   
+   if not vParentIds or not vChildrenIds then return end
+  
+   if #vParentIds == 1 then
+      vOrdered[vParentIds[1]] = vChildrenIds
+   else
+      -- recupero i centroidi di tutte le curve padre
+      local vPtCParent = {}
+      for i = 1, #vParentIds do
+         table.insert( vPtCParent, EgtGP( vParentIds[i]))
+      end
+      
+      -- associo ad ogni elemento di vParentIds gli elementi di vChildrenIds che ha generato
+      for i = 1, #vChildrenIds do
+         -- individuo la curva di vParentIds con il centroiode più vicino
+         local ptC = EgtGP( vChildrenIds[i])
+         local dDistMin = GEO.INFINITO
+         local nParentId = -1
+         for j = 1, #vPtCParent do
+            local dCurrDist = dist( ptC, vPtCParent[j])
+            if dCurrDist < dDistMin - GEO.EPS_SMALL then
+               dDistMin = dCurrDist
+               nParentId = vParentIds[j]
+            end
         end
-         local ptS = EgtSP( nParentIdx)
-         EgtSpSetOpenBound( true, SHP_OB.NEAR_PNT, ptS:getX(), ptS:getY(), ptS:getZ(), 0, 0)
-         local vOrd, _ = EgtSpCalculate( SHP_TY.OPEN)
-         EgtSpTerminate()
         
-         for j = #vOrd, 1, -1 do
-            EgtRelocateGlob( vChildren[vOrd[j]], nParentIdx, GDB_IN.AFTER)
+         -- la aggiungo tra i figli della curva di vParentIds trovata
+         if not vOrdered[nParentId] then
+            vOrdered[nParentId] = {vChildrenIds[i]}
+         else
+            table.insert( vOrdered[nParentId], vChildrenIds[i])
         end
      end
   end
 end

 ---------------------------------------------------------------------------
-local function ComputeOffsetInfill( nSrf, dStrand, vtSlicing, sName, nType, vPtStart, nGrp)
+local function ReorderPath( vOldIds, vNewIds)
   
-   local nChunk = EgtSurfFrChunkCount( nSrf)
-   if nChunk == 0 then return end
+   if not vNewIds or not vOldIds then return end
+   
+   -- suddivido in base alla tipologia di loop ( esterno o interno)
+   local tOldIds = {{}, {}}
+   for i = 1, #vOldIds do
+      local bIntLoop = EgtGetInfo( vOldIds[i], KEY_INTERNAL_SRF_LOOP, 'b') or false
+      local nTabInd = EgtIf( bIntLoop, 2, 1)
+      table.insert( tOldIds[nTabInd], vOldIds[i])
+   end
+   
+   local tNewIds = {{}, {}}
+   for i = 1, #vNewIds do
+      local bIntLoop = EgtGetInfo( vNewIds[i], KEY_INTERNAL_SRF_LOOP, 'b') or false
+      local nTabInd = EgtIf( bIntLoop, 2, 1)
+      table.insert( tNewIds[nTabInd], vNewIds[i])
+   end
+   
+   -- assegno ad ogni curva di vOldIds le curve di vNewIds che ha generato
+   local vOrdered = {}
+   AssignChildrenCurves( tOldIds[1], tNewIds[1], vOrdered)   -- loop esterni
+   AssignChildrenCurves( tOldIds[2], tNewIds[2], vOrdered)   -- loop interni
+
+   -- assegno le info e riordino
+   local vNewOrder = {}
+   local nGrp = EgtGetParent( vNewIds[1])
+   for i = 1, #vOldIds do
+      local vChildrenIds = vOrdered[vOldIds[i]] or {}
+      EgtSetInfo( vOldIds[i], KEY_NEXT_CRVS, vChildrenIds)
+      for j = 1, #vChildrenIds do
+         EgtRelocateGlob( vChildrenIds[j], nGrp, GDB_IN.LAST_SON)
+         table.insert( vNewOrder, vChildrenIds[j])
+         EgtSetInfo( vChildrenIds[j], KEY_PREV_CRV, vOldIds[i])
+      end
+   end
+   
+   return vNewOrder
+end
+
+---------------------------------------------------------------------------
+local function ComputeOffsetSolidFill( nSrf, dStrand, vtSlicing, sName, nType, nGrp, vPtStart, vOldIds)
+
+   -- nSrf è già la prima superficie da cui estrarre i bordi, quindi il primo offset non va fatto
+   local dOffs = 0
+   local nSrfOffs = EgtCopyGlob( nSrf, nGrp)
+   local bOk = true
+   local bExists = ( EgtSurfFrChunkCount( nSrf) > 0)
   
-   -- estraggo i contorni della superficie
-   local vOldIds = GetPathsFromSurf( nSrf, sName, nType, nGrp, vPtStart)
-   local dOffs = - dStrand
-   local bOk, bExists, nSrfOffs = ComputeSurfOffset( nSrf, nGrp, dOffs, vtSlicing)
   while bOk and bExists do
      -- estraggo i contorni
      local vNewIds = GetPathsFromSurf( nSrfOffs, sName, nType, nGrp, vPtStart)
      if vNewIds then
         -- riordino
-         ReorderPath( vOldIds, vNewIds)
+         local vNewOrder = ReorderPath( vOldIds, vNewIds) or vNewIds
+         
         -- verifico fattibilità
         local k = 1
-         while k <= #vNewIds do
-            if VerifyPath( vNewIds[k], dStrand, vtSlicing, nGrp) then
+         while k <= #vNewOrder do
+            if VerifyPath( vNewOrder[k], dStrand, vtSlicing, nGrp) then
               k = k + 1
            else
               -- se non è fattibile lo rimuovo dalla table per non ritrovarlo nello step successivo
-               table.remove( vNewIds, k)
+               table.remove( vNewOrder, k)
            end
         end
-         vOldIds = vNewIds
+         vOldIds = vNewOrder
      end
      
-      EgtErase( nSrfOffs)
      -- offset successivo
+      EgtErase( nSrfOffs)
      dOffs = dOffs - dStrand
      bOk, bExists, nSrfOffs = ComputeSurfOffset( nSrf, nGrp, dOffs, vtSlicing)
   end
-
 end

 ------------------------------------------------------------------
@@ -374,47 +454,50 @@ local function FindOptimalZigZagDirection( nSrfId, nBorderSurf, dStrand, nGrp, f
   local nGrpTmp = EgtGroup( nGrp, frLoc, GDB_RT.GLOB)  -- gruppo temporaneo per i conti
   local dTol = 1 + GEO.EPS_SMALL
   
-   -- recupero i contorni della curva di bordo
-   local vBorderIds = GetPathsFromSurf( nBorderSurf, 'TmpBorder', 0, nGrpTmp)
-   
   -- recupero tutti i lati della superficie da riempire
   local vCrvIds = GetPathsFromSurf( nSrfId, 'Tmp', 0, nGrpTmp)
   local nId, nCnt = EgtExplodeCurveCompo( vCrvIds[1])
-   
-   -- individuo i lati a distanza minima dal bordo tra cui cercare quello a lunghezza massima
-   local vCheckIds = {}
   local vAllIds = {}
-   local dMinDist = GEO.INFINITO
   for i = nId, nId + nCnt - 1 do
+      table.insert( vAllIds, i)
+   end
+   local vCheckIds = {}
+   
+   -- se ho superficie che contiene nSrfId ( caso AuxSolid) cerco il lato di lunghezza massima tra quelli a distanza minima dal bordo
+   if nBorderSurf then
+      -- recupero i contorni della curva di bordo
+      local vBorderIds = GetPathsFromSurf( nBorderSurf, 'TmpBorder', 0, nGrpTmp)
      
-      -- trovo la distanza minima dalle curve di bordo
-      local dDist
-      if #vBorderIds == 1 then
-         dDist = EgtPointCurveDist( EgtMP( i), vBorderIds[1])
-      else
-         dDist = GEO.INFINITO
-         for j = 1, #vBorderIds do
-            local dCurrDist = EgtPointCurveDist( EgtMP( i), vBorderIds[j])
-            if dCurrDist < dDist then
-               dDist = dCurrDist
+      local dMinDist = GEO.INFINITO
+      for i = nId, nId + nCnt - 1 do
+         
+         -- trovo la distanza minima dalle curve di bordo
+         local dDist
+         if #vBorderIds == 1 then
+            dDist = EgtPointCurveDist( EgtMP( i), vBorderIds[1])
+         else
+            dDist = GEO.INFINITO
+            for j = 1, #vBorderIds do
+               local dCurrDist = EgtPointCurveDist( EgtMP( i), vBorderIds[j])
+               if dCurrDist < dDist then
+                  dDist = dCurrDist
+               end
+            end
+         end
+         
+         -- se tratto sufficientemente vicino al bordo verifico se a distanza minima ( entro tolleranza dTol)
+         if dDist < dStrand + GEO.EPS_SMALL then
+            if abs( dDist - dMinDist) < dTol then
+               table.insert( vCheckIds, i)
+            elseif dDist < dMinDist - dTol then
+               dMinDist = dDist
+               vCheckIds = {i}
            end
         end
      end
-      
-      -- se tratto sufficientemente vicino al bordo verifico se a distanza minima ( entro tolleranza dTol)
-      if dDist < dStrand + GEO.EPS_SMALL then
-         if abs( dDist - dMinDist) < dTol then
-            table.insert( vCheckIds, i)
-         elseif dDist < dMinDist - dTol then
-            dMinDist = dDist
-            vCheckIds = {i}
-         end
-      end
-      
-      table.insert( vAllIds, i)
   end
   
-   -- se non ci sono curve sufficientemente vicine al bordo allora cerco il più lungo tra tutti i lati indipendentemente dalla loro distanza dal bordo
+   -- se non ho id specifici da controllare considero tutti i lati
   if #vCheckIds == 0 then
      vCheckIds = vAllIds
   end
@@ -439,7 +522,7 @@ local function FindOptimalZigZagDirection( nSrfId, nBorderSurf, dStrand, nGrp, f
 end

 --------------------------------------------------------------------
-local function ComputeZigZagInfill( nSrf, dStrand, vtSlicing, sName, nType, vPtStart, nGrp, nBorderSurf)
+local function ComputeZigZagSolidFill( nSrf, dStrand, vtSlicing, sName, nType, nGrp, nBorderSurf)

   if EgtSurfFrChunkCount( nSrf) == 0 then return end
   
@@ -462,14 +545,63 @@ local function ComputeZigZagInfill( nSrf, dStrand, vtSlicing, sName, nType, vPtS
            EgtSetName( j, sName)
            EgtSetInfo( j, KEY_TYPE, nType)
            EgtSetInfo( j, KEY_ZIG_ZAG_DIR, vtDir)
-            EgtSetInfo( j, KEY_ZIG_ZAG_INFILL, 1)
+            EgtSetInfo( j, KEY_ZIG_ZAG_INFILL, true)
            EgtModifyCurveExtrusion( j, vtSlicing, GDB_RT.GLOB)
            table.insert( vIds, j)
         end
      end
      EgtErase( nSrfId)
   end
-   
+end
+
+------------------------------------------------------------------
+local function CalcSolidFillPath( nLayId, LayerParams, vPtStart, nFillType)
+
+   -- scorro i gruppi di curve
+   local vCrvGrps = EgtGetNameInGroup( nLayId, CONTOUR_GRP .. '*')
+   for i = 1, #vCrvGrps do
+      
+      -- creo il gruppo per infill
+      local nInfillPathGrp = EgtGroup( vCrvGrps[i])
+      EgtSetName( nInfillPathGrp, INFILL_GRP)
+      EgtSetStatus( nInfillPathGrp, GDB_ST.OFF)
+      EgtSetInfo( nInfillPathGrp, KEY_FILL_TYPE, nFillType)
+      
+      -- recupero la superficie da riempire
+      local nSrf = EgtGetFirstNameInGroup( vCrvGrps[i], TOT_SHELL_TRIM_SURF)
+      if not nSrf then
+         -- se non esiste non c'è spazio per solid fill
+         EgtOutLog( 'Warning: SolidFill not possibile (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths')
+      else
+         local bOk, bExists, nSrfToFill = ComputeSurfOffset( nSrf, nInfillPathGrp, LayerParams.nInfillOverlap / 100 * LayerParams.dStrand, LayerParams.vtSlicing)
+         if not bOk then
+            -- eseguo trim senza overlap
+            EgtOutLog( 'Warning: SolidFill without correct overlap (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths')
+            nSrfToFill = EgtCopyGlob( nSrf, nInfillPathGrp)
+         end
+         
+         -- distanza tra passate tenendo conto dell'overlap indicato
+         local dDist = ( 1 - LayerParams.nStrandOverlap / 100) * LayerParams.dStrand
+         -- inserisco il riempimento
+         if nFillType == FILL_TYPE.OFFSET then
+            -- recupero le shell precedenti dal PathGrp
+            local nPathGrp = EgtGetFirstNameInGroup( vCrvGrps[i], PATH_GRP)
+            local nLast = EgtGetLastNameInGroup( nPathGrp, SHELL_CRV .. '*') or EgtGetLastNameInGroup( nPathGrp, EXTRA_SHELL_CRV .. '*')
+            local vOldIds = EgtGetNameInGroup( nPathGrp, EgtGetName( nLast))
+            ComputeOffsetSolidFill( nSrfToFill, dDist, LayerParams.vtSlicing, INFILL_CRV, TYPE.INFILL, nInfillPathGrp, vPtStart, vOldIds)
+         elseif nFillType == FILL_TYPE.ZIGZAG then
+            ComputeZigZagSolidFill( nSrfToFill, dDist, LayerParams.vtSlicing, INFILL_CRV, TYPE.INFILL, nInfillPathGrp)
+         end
+         
+         -- avendo riempito la regione, la TotShellTrimSurf non deve esistere
+         EgtErase( nSrf)
+      end
+      
+      -- se gruppo vuoto lo cancello
+      if not EgtGetFirstInGroup( nInfillPathGrp) then
+         EgtErase( nInfillPathGrp)
+      end
+   end
 end

 --------------------------------------------------------------------
@@ -539,6 +671,7 @@ local function FindRibsUserLinkDirection( nCrv1, nCrv2, vtSlicing)
   -- costruisco la superficie "definita" dal setto di partenza con i primi due setti che lo definiscono
   local nGrpTmp = EgtGroup( EgtGetParent( nCrv1))
   local nSrfLoop = EgtCurveCompoFromPoints( nGrpTmp, {EgtEP( nCrv1), EgtSP( nCrv2)})
+   if not nSrfLoop then return false end
   EgtAddCurveCompoLine( nSrfLoop, EgtSP( nCrv2) + 100 * EgtSV( nCrv2))
   EgtAddCurveCompoLine( nSrfLoop, EgtEP( nCrv1) - 100 * EgtEV( nCrv1))
   EgtCloseCurveCompo( nSrfLoop)
@@ -594,7 +727,7 @@ local function FindAssociatedUserLinkParts( nStartRib, vRibs, vUsed, nGrpTmp, nT
      end
   end
   
-   return tabUserLink 
+   return tabUserLink
 end

 -----------------------------------------------------------------------
@@ -688,7 +821,6 @@ local function AdjustUserLinkRibs( tUserLink, vRibs, vtSlicing, nSrfInt, nSrfExt
         
         -- verifico se trovo setti associati ( e quindi definisce UserLink)
         local nStartRib = EgtGetInfo( vRibs[i], KEY_START_RIB, 'i')
-         local vSingleRibs = {}
         local nType = EgtGetInfo( vRibs[i], KEY_RIBS_TYPE, 'i')
         local nSrfTest = EgtIf( nType == RIB_TYPE.EXTERNAL, nSrfExt, nSrfInt)
         local tabUserLink = FindAssociatedUserLinkParts( nStartRib, vRibs, vUsed, nGrpTmp, nType, nSrfTest)
@@ -749,6 +881,7 @@ end
 -------------------------------------------------------------------
 local function FindHoleCurve( pt, vLoopIds)
   -- trovo indice della curva di vLoopIds a cui appartiene pt ( in globale)
+   if not vLoopIds then return end
   for i = 1, #vLoopIds do
      local dPar = EgtCurveParamAtPoint( vLoopIds[i], pt, GEO.EPS_SMALL, GDB_RT.GLOB)
      if dPar then
@@ -1265,7 +1398,7 @@ end

 ---------------------------------------------------------------------------------
 -- Funzione che sistema le intersezioni fra costolature nel caso generico
-local function AdjustRibsOffsetForIntersection( nCrv1, nCrv2, LayerParams, nOffsGrp, bSaveSurf, nLoopGrp)
+local function AdjustRibsOffsetForIntersection( nCrv1, nCrv2, LayerParams, nOffsGrp, nLoopGrp, tSurfOffs, nType2)
  
   -- calcolo la superficie della curva principale ( nCrv1) da usare per trim
   local nShells = EgtGetInfo( nCrv1, KEY_RIBS_SHELLS_NBR, 'i')
@@ -1295,23 +1428,32 @@ local function AdjustRibsOffsetForIntersection( nCrv1, nCrv2, LayerParams, nOffs
      end
   end
   
-   -- se necessario salvo i loop da usare per ingressi e uscite
-   if bSaveSurf then
-      -- verifico orientamento della superficie per compatibilità ingressi ribs splittati
-      local vtN = EgtSurfFrNormVersor( nSrf)
-      if AreSameVectorApprox( vtN, LayerParams.vtSlicing) then
-         EgtInvertSurf( nSrf)
+   -- salvo i loop da usare nel toolpath per ingressi e uscite
+   local nSrfRef
+   -- recupero la superficie di bordo con lo stesso overlap
+   local nSrfTrim = tSurfOffs[nType2][nOverlap]
+   if nSrfTrim and nSrfTrim ~= GDB_ID.NULL then
+      nSrfRef = EgtCopyGlob( nSrfTrim, nLoopGrp)
+      if nType2 == RIB_TYPE.INTERNAL then
+         EgtSurfFrSubtract( nSrfRef, nSrf)
+      elseif nType2 == RIB_TYPE.EXTERNAL then
+         EgtSurfFrAdd( nSrfRef, nSrf)
      end
-      local nChunks = EgtSurfFrChunkCount( nSrf)
-      for i = 0, nChunks - 1 do
-         local nRes, nCnt = EgtExtractSurfFrChunkLoops( nSrf, i, nLoopGrp)
-         for j = nRes, nRes + nCnt - 1 do
-            EgtSetName( j, SURF_LOOP)
-         end
+      EgtErase( nSrf)
+   else
+      EgtInvertSurf( nSrf)
+      nSrfRef = nSrf
+   end
+   -- estraggo i loop
+   local nChunks = EgtSurfFrChunkCount( nSrfRef)
+   for i = 0, nChunks - 1 do
+      local nRes, nCnt = EgtExtractSurfFrChunkLoops( nSrfRef, i, nLoopGrp)
+      for j = nRes, nRes + nCnt - 1 do
+         EgtSetName( j, SURF_LOOP)
      end
   end
+   EgtErase( nSrfRef)
   
-   EgtErase( nSrf)
 end

 --------------------------------------------------------------------
@@ -1319,7 +1461,7 @@ end
 local function AdjustRibsOffsetForIntersection2Shells( nCrv1, nCrv2, LayerParams, nOffsGrp)
  
   -- costruisco le superfici da usare per trim
-   local nSrf1 = EgtSurfFrFatCurve( nOffsGrp, nCrv1, LayerParams.dStrand / 2, false) 
+   local nSrf1 = EgtSurfFrFatCurve( nOffsGrp, nCrv1, LayerParams.dStrand / 2, false)
   local vtN1 = EgtSurfFrNormVersor( nSrf1, GDB_ID.ROOT)
   if LayerParams.vtSlicing * vtN1 < 0 then
      EgtInvertSurf( nSrf1)
@@ -1373,7 +1515,7 @@ local function UpdateSplitOrder( nCrv, tInters, nOffsGrp)
 end

 ---------------------------------------------------------------------------------
-local function HandleRibsIntersections( nRibsGrp, LayerParams, nOffsGrp, nRibsPathGrp, nLoopGrp, bAllTwoStrands, vTypeSequence)
+local function HandleRibsIntersections( nRibsGrp, LayerParams, nOffsGrp, nRibsPathGrp, nLoopGrp, bAllTwoStrands, vTypeSequence, tSurfOffs)
  
   local bSpecialCase = false
   local vRibsIds = EgtGetNameInGroup( nRibsGrp, RIBS_CRV .. '*')
@@ -1438,13 +1580,10 @@ local function HandleRibsIntersections( nRibsGrp, LayerParams, nOffsGrp, nRibsPa
            end
            
            -- aggiorno tabella delle intersezioni
-            local bSaveSurf = false
            if tInters[nCrv1] then
               table.insert( tInters[nCrv1], nCrv2)
            else
               tInters[nCrv1] = {nCrv2}
-               -- è la prima volta che nCrv1 viene usata per un trim quindi devo salvare la superficie utilizzata
-               bSaveSurf = true
            end
            
            -- aggiorno ordine di split
@@ -1458,7 +1597,7 @@ local function HandleRibsIntersections( nRibsGrp, LayerParams, nOffsGrp, nRibsPa
               AdjustRibsOffsetForIntersection2Shells( nCrv1, nCrv2, LayerParams, nRibsPathGrp)
               bSpecialCase = true
            else
-               AdjustRibsOffsetForIntersection( nCrv1, nCrv2, LayerParams, nRibsPathGrp, bSaveSurf, nLoopGrp)
+               AdjustRibsOffsetForIntersection( nCrv1, nCrv2, LayerParams, nRibsPathGrp, nLoopGrp, tSurfOffs, nType2)
            end
         end
      end
@@ -2004,7 +2143,7 @@ local function CalcRibsPaths( nSliceGrp, nRibsGrp, LayerParams, vPtStart)
      end
   
      -- gestisco eventuali intersezioni fra costolature
-      local bInters, bSpecialCase = HandleRibsIntersections( nRibsGrp, LayerParams, nOffsGrp, nRibsPathGrp, nLoopGrp, bAllTwoStrands, vTypeSequence)
+      local bInters, bSpecialCase = HandleRibsIntersections( nRibsGrp, LayerParams, nOffsGrp, nRibsPathGrp, nLoopGrp, bAllTwoStrands, vTypeSequence, tSurfOffs)
      EgtSetInfo( nRibsPathGrp or GDB_ID.NULL, KEY_RIBS_INTERS, bInters)
      EgtSetInfo( nRibsPathGrp or GDB_ID.NULL, KEY_RIBS_SPECIAL_CASE, bSpecialCase)
      
@@ -2106,19 +2245,25 @@ local function CreateShellNbrSurfaces( nGrp, nShellsNbr)
   local nCrvId = EgtGetFirstNameInGroup( nGrp, SHELL_NBR_CRV .. '*')
   while nCrvId do
      if EgtCurveIsClosed( nCrvId) then
-         -- recupero info sul gap
-         local nShellNbrDiff = EgtGetInfo( nCrvId, KEY_SHELL_NBR_DIFF, 'i')
-         -- aggiorno eventuale massimo
-         if nMaxShellNbrDiff < nShellNbrDiff then nMaxShellNbrDiff = nShellNbrDiff end
-         -- salvo gli id delle curve
-         if not tDiffCrvs[nShellNbrDiff] then
-            tDiffCrvs[nShellNbrDiff]  = { nCrvId}
+         -- verifico se area significativa
+         local _, _, dArea = EgtCurveArea( nCrvId)
+         if dArea and dArea > GEO.EPS_SMALL then
+            -- recupero info sul gap
+            local nShellNbrDiff = EgtGetInfo( nCrvId, KEY_SHELL_NBR_DIFF, 'i')
+            -- aggiorno eventuale massimo
+            if nMaxShellNbrDiff < nShellNbrDiff then nMaxShellNbrDiff = nShellNbrDiff end
+            -- salvo gli id delle curve
+            if not tDiffCrvs[nShellNbrDiff] then
+               tDiffCrvs[nShellNbrDiff]  = { nCrvId}
+            else
+               table.insert( tDiffCrvs[nShellNbrDiff], nCrvId)
+            end
         else
-            table.insert( tDiffCrvs[nShellNbrDiff], nCrvId)
+            EgtOutLog( 'Warning: ReducedShellNumber is too small (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths')
         end
      else
         EgtOutLog( 'Error: ReducedShellNumber is not closed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths')
-         table.insert( s_vErr, EgtNumToString( s_nCurrIdx) .. ' : ReducedShellNumber is not closed')
+         table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : ReducedShellNumber is not closed')
      end
      
      nCrvId = EgtGetNextName( nCrvId, SHELL_NBR_CRV .. '*')
@@ -2156,13 +2301,14 @@ local function CreateShellNbrSurfaces( nGrp, nShellsNbr)
         end
         if not bOk then
            EgtOutLog( 'Error: ReducedShellNumber is not considered (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths')
-            table.insert( s_vErr, EgtNumToString( s_nCurrIdx) .. ' : ReducedShellNumber is not considered')
+            table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : ReducedShellNumber is not considered')
         end
      end
-      EgtSetName( nSrfId, SHELL_NBR_SURF .. EgtNumToString( nDiff))
-      -- salvo come info gli id delle curve che la definiscono
-      EgtSetInfo( nSrfId, KEY_ASSOCIATED_CRVS, vCrvIds)
-
+      if nSrfId then
+         EgtSetName( nSrfId, SHELL_NBR_SURF .. EgtNumToString( nDiff))
+         -- salvo come info gli id delle curve che la definiscono
+         EgtSetInfo( nSrfId, KEY_ASSOCIATED_CRVS, vCrvIds)
+      end
   end
 end

@@ -2270,7 +2416,8 @@ local function ReorderExtraShells( nPathGrp, dStrand, vPtStart, bPrintInvert)
   local nFirst = EgtGetFirstNameInGroup( nPathGrp, EXTRA_SHELL_CRV .. '*')
   while nFirst do
      -- recupero tratti appartenenti alla stessa shell
-      local vShells = EgtGetNameInGroup( nPathGrp, EgtGetName( nFirst))     
+      local sName = EgtGetName( nFirst)
+      local vShells = EgtGetNameInGroup( nPathGrp, sName)
      local nCurr = vShells[1]
      for i = 2, #vShells do
         if dist( EgtEP( nCurr), EgtSP( vShells[i])) < dStrand + GEO.EPS_SMALL then
@@ -2288,6 +2435,16 @@ local function ReorderExtraShells( nPathGrp, dStrand, vPtStart, bPrintInvert)
         EgtAddCurveCompoCurve( nCurr, nFirst)
      end
      
+      -- verifico se le curve si possono chiudere
+      vShells = EgtGetNameInGroup( nPathGrp, sName)
+      for i = 1, #vShells do
+         if not EgtCurveIsClosed( vShells[i]) then
+            if dist( EgtSP( vShells[i]), EgtEP( vShells[i])) < dStrand + GEO.EPS_SMALL then
+               EgtCloseCurveCompo( vShells[i])
+            end
+         end
+      end
+      
      nFirst = EgtGetNextName( nCurr, EXTRA_SHELL_CRV .. '*')
   end
   
@@ -2392,7 +2549,7 @@ local function CalcExtraShellsPath( nMaxShellNbrDiff, nShellNbrGrp, nCrvGrpId, d
            -- calcolo offset della curva ( è il percorso della shell) 
            EgtModifyCurveExtrusion( nCrvT, LayerParams.vtSlicing, GDB_RT.GLOB)
            local nOffs, nOffsCnt = EgtOffsetCurveAdv( nCrvT, - dOffs)
-            EgtErase( nCrvT)              
+            EgtErase( nCrvT)
            for nCrvOffs = nOffs, nOffs + nOffsCnt - 1 do
               -- trim con la regione già occupata dal altre shell
               local nCrv, nCnt = EgtTrimCurveWithRegion( nCrvOffs, nSrfTrim, true, true)
@@ -2479,11 +2636,11 @@ local function UpdateTrimSurfWithAuxSolidsOffset( nSrfSolid, nSrfBase, dStrand,
   local bOk, bExists, nSrfOffs = ComputeSurfOffset( nSrfSolid, nCrvGrp, dStrand, vtSlicing)
   if not bOk then
      EgtOutLog( 'Error : creation of AuxSolid region for TotTrimSurfRegion failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths')
-      table.insert( s_vErr, EgtNumToString( s_nCurrIdx) .. ' : error in computing region for internal elements')
+      table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : error in computing region for internal elements')
   elseif nSrfOffs then
      if not EgtSurfFrSubtract( nSrfBase, nSrfOffs) then
         EgtOutLog( 'Error : EgtSurfFrSubtract with AuxSolid for TotTrimSurfRegion failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths')
-         table.insert( s_vErr, EgtNumToString( s_nCurrIdx) .. ' : error in computing region for internal elements')
+         table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : error in computing region for internal elements')
      end
      EgtErase( nSrfOffs)
   end
@@ -2555,7 +2712,7 @@ local function UpdateTrimSurfWithAuxSolidsZigZag( nAuxSolidsGrp, sName, nSrfBase
      -- aggiorno la TotShellSurfForTrim
      if not EgtSurfFrSubtract( nSrfBase, nSrfZigZag) then
         EgtOutLog( 'Error : EgtSurfFrSubtract with AuxSolid for TotTrimSurfRegion failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths')
-         table.insert( s_vErr, EgtNumToString( s_nCurrIdx) .. ' : error in computing region for internal elements')
+         table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : error in computing region for internal elements')
      end
   end
   EgtErase( nGrpTmp)
@@ -2596,17 +2753,57 @@ local function AddExtraZigZag( nSrf, sName, dStrand, vtSlicing, nGrp, nSrfTrim)
   
 end

+-------------------------------------------------------------------
+local function ComputeAuxSolidsGenericInfill( nSrf, dStrand, vtSlicing, sName, nPathGrp, vPtStart, nOrigSurf, nOverlap, nAuxSolidsGrp)
+   
+   -- estraggo i contorni della superficie ( perimetro)
+   GetPathsFromSurf( nSrf, sName, TYPE.AUX_SOLID, nPathGrp, vPtStart)
+   
+   -- preparo la superficie con cui fare trim degli infill
+   local dOffs = dStrand * ( nOverlap / 100 - 0.5)
+   local bOk, bExists, nSrfTrim = ComputeSurfOffset( nSrf, nPathGrp, dOffs, vtSlicing)
+   if not bOk then
+      EgtOutLog( 'Warning: AuxSolid Infill without correct overlap (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths')
+      nSrfTrim = EgtCopyGlob( nSrf, nPathGrp)
+   elseif not bExists then
+      EgtOutLog( 'Warning: AuxSolid Infill not possibile (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths')
+      return
+   end
+   
+   -- recupero gli infill associati
+   local sNameInfill = AUX_SOLIDS_INFILL_CRV .. tostring( nOrigSurf)
+   local vInfillIds = EgtGetNameInGroup( nAuxSolidsGrp, sNameInfill .. '*') or {}
+   
+   -- eseguo trim con la superficie
+   for i = 1, #vInfillIds do
+      local nCrv = EgtCopyGlob( vInfillIds[i], nPathGrp)
+      local nRes, nCnt = EgtTrimCurveWithRegion( nCrv, nSrfTrim, true, true)
+      for nId = nRes, nRes + nCnt - 1 do
+         -- verifico se lunghezza minima
+         local dLen = EgtCurveLength( nId)
+         if dLen < MIN_INFILL_LEN then
+            EgtErase( nId)
+         else
+            EgtSetName( nId, sName)
+            EgtSetInfo( nId, KEY_TYPE, TYPE.INFILL)
+            EgtSetInfo( nId, KEY_ASSOCIATED_SURF, nSrfTrim)
+            EgtModifyCurveExtrusion( nId, vtSlicing)
+         end
+      end
+   end
+end
+
 --------------------------------------------------------------------
 local function CalcAuxSolidsPaths( nSliceGrp, nSolidGrp, LayerParams, vPtStart)
   
   -- recupero i solidi ausiliari dividendoli per nome
   local vSolidIds = {}
-   local nFirst = EgtGetFirstInGroup( nSolidGrp)
+   local nFirst = EgtGetFirstNameInGroup( nSolidGrp, AUX_SOLIDS_CRV .. '*')
   while nFirst do
      local sName = EgtGetName( nFirst)
      local vIds = EgtGetNameInGroup( nSolidGrp, sName)
      table.insert( vSolidIds, vIds)
-      nFirst = EgtGetNext( vIds[#vIds])
+      nFirst = EgtGetNextName( vIds[#vIds], AUX_SOLIDS_CRV .. '*')
   end
   
   -- scorro i gruppi di curve
@@ -2634,6 +2831,7 @@ local function CalcAuxSolidsPaths( nSliceGrp, nSolidGrp, LayerParams, vPtStart)
            -- creo la flat region corrispondente al solido ausiliario
            local sName = EgtGetName( vSolidIds[i][1])
            local nOverlap = EgtGetInfo( vSolidIds[i][1], KEY_AUX_SOLIDS_OVERLAP, 'i')
+            local nOrigSurf = EgtGetInfo( vSolidIds[i][1], KEY_ORIGINAL_SURF, 'i')
            local nSrfId = EgtSurfFlatRegion( nSolidPathGrp, vSolidIds[i])
            
            if nSrfId then
@@ -2645,26 +2843,34 @@ local function CalcAuxSolidsPaths( nSliceGrp, nSolidGrp, LayerParams, vPtStart)
               for j = 0, nCnt - 1 do
                  local sNewName = sName .. EgtIf( j == 0, '', '_' .. tostring( j))
                  local nInfillType = EgtGetInfo( vSolidIds[i][1], KEY_AUX_SOLIDS_INFILL, 'i')
-                  if nInfillType == INFILL_TYPE.NONE then
+                  
+                  if nInfillType == FILL_TYPE.NONE then
                     -- estraggo i contorni della superficie ( serve solo perimetro)
                     GetPathsFromSurf( nFirst + j, sNewName, TYPE.AUX_SOLID, nSolidPathGrp, vPtStart)
                     -- aggiorno la trim surf
                     UpdateTrimSurfWithAuxSolidsOffset( nFirst + j, nSrfBase, LayerParams.dStrand, nSolidPathGrp, LayerParams.vtSlicing)
-                  elseif nInfillType == INFILL_TYPE.OFFSET then
-                     ComputeOffsetInfill( nFirst + j, LayerParams.dStrand, LayerParams.vtSlicing, sNewName, TYPE.AUX_SOLID, vPtStart, nSolidPathGrp)
+                     
+                  elseif nInfillType == FILL_TYPE.OFFSET then
+                     ComputeOffsetSolidFill( nFirst + j, LayerParams.dStrand, LayerParams.vtSlicing, sNewName, TYPE.AUX_SOLID, nSolidPathGrp, vPtStart)
                     -- aggiorno la trim surf
                     UpdateTrimSurfWithAuxSolidsOffset( nFirst + j, nSrfBase, LayerParams.dStrand, nSolidPathGrp, LayerParams.vtSlicing)
-                  else
-                     ComputeZigZagInfill( nFirst + j, LayerParams.dStrand, LayerParams.vtSlicing, sNewName, TYPE.AUX_SOLID, vPtStart, nSolidPathGrp, vSurfOffs[nOverlap])
+                     
+                  elseif nInfillType == FILL_TYPE.ZIGZAG then
+                     ComputeZigZagSolidFill( nFirst + j, LayerParams.dStrand, LayerParams.vtSlicing, sNewName, TYPE.AUX_SOLID, nSolidPathGrp, vSurfOffs[nOverlap])
                     -- aggiungo eventuale passata extra
                     AddExtraZigZag( nFirst + j, sNewName, LayerParams.dStrand, LayerParams.vtSlicing, nSolidPathGrp, vSurfOffs[nOverlap])
                     -- aggiorno la trim surf
                     UpdateTrimSurfWithAuxSolidsZigZag( nSolidPathGrp, sNewName, nSrfBase, LayerParams.dStrand, nFirst + j)
+                     
+                  else
+                     ComputeAuxSolidsGenericInfill( nFirst + j, LayerParams.dStrand, LayerParams.vtSlicing, sNewName, nSolidPathGrp, vPtStart, nOrigSurf, nOverlap, nSolidGrp)
+                     -- aggiorno la trim surf
+                     UpdateTrimSurfWithAuxSolidsOffset( nFirst + j, nSrfBase, LayerParams.dStrand, nSolidPathGrp, LayerParams.vtSlicing)
                  end
               end
            else
               EgtOutLog( 'Error : creation of AuxSolid region failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths')
-               table.insert( s_vErr, EgtNumToString( s_nCurrIdx) .. ' : creation of AuxSolid region failed')
+               table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : creation of AuxSolid region failed')
            end
         end
      end
@@ -2692,6 +2898,9 @@ function CalcPaths.Exec( nPartId)

   -- recupero i parametri per calcolo dei path
   local LayerParams = GetLayerParamsForPathCalc()
+   local nFirstSolidLay = EgtGetInfo( s_nPartId, KEY_FIRST_SOLID_LAY, 'i') or -1
+   local nLastSolidLay = EgtGetInfo( s_nPartId, KEY_LAST_SOLID_LAY, 'i') or -1
+
   -- scorro tutti i suoi layer
   for nIdx = 1, #vLayIds do

@@ -2699,6 +2908,7 @@ function CalcPaths.Exec( nPartId)
      
      local nRibsGrp = EgtGetFirstNameInGroup( vLayIds[nIdx], RIBS_GRP)
      local nAuxSolidsGrp = EgtGetFirstNameInGroup( vLayIds[nIdx], AUX_SOLIDS_GRP)
+      local nInfillGrp = EgtGetFirstNameInGroup( vLayIds[nIdx], INFILL_GRP)
     
      -- regioni con diverso numero di passate
      local nShellNbrGrp = EgtGetFirstNameInGroup( vLayIds[nIdx], SHELL_NBR_GRP)
@@ -2731,6 +2941,7 @@ function CalcPaths.Exec( nPartId)
            nMaxShellNbrDiff = min( nMaxShellNbrDiff, LayerParams.nShellsNbr)
            
            -- parete esterna
+            local vOldIds
            local bPrevExists = true
            local dOffs = - LayerParams.dOffs - 0.5 * LayerParams.dStrand
            if nMaxShellNbrDiff < LayerParams.nShellsNbr then
@@ -2738,12 +2949,12 @@ function CalcPaths.Exec( nPartId)
               local bOk, bExists, nSrfId = ComputeSurfOffset( nSrf, nCrvGrpId, - dOffs, LayerParams.vtSlicing)
               if not bOk then
                  EgtOutLog( 'Error : ExtOffset failed (layer '.. EgtNumToString( nIdx) ..') - CalcPaths')
-                  table.insert( s_vErr, EgtNumToString( nIdx) .. ' : creation of OuterShell failed')
+                  table.insert( s_vErr, 'layer ' .. EgtNumToString( nIdx) .. ' : creation of OuterShell failed')
               elseif not bExists then
                  EgtOutLog( 'Warning : ExtOffset not possible (layer '.. EgtNumToString( nIdx) ..') - CalcPaths')
               else
                  -- se offset riuscito, estraggo i contorni (pareti esterne)
-                  GetPathsFromSurf( nSrfId, SHELL_CRV ..'0', TYPE.OUTER_SHELL, nGrpId, vPtStart)
+                  vOldIds = GetPathsFromSurf( nSrfId, SHELL_CRV ..'0', TYPE.OUTER_SHELL, nGrpId, vPtStart)
               end
               bPrevExists = bExists
               EgtErase( nSrfId)
@@ -2755,7 +2966,6 @@ function CalcPaths.Exec( nPartId)
               table.insert( vPtInnerStart, EgtSP( vOuterShell[i]))
            end
            if #vPtInnerStart == 0 then vPtInnerStart = vPtStart end
-            EgtSetInfo( nCrvGrpId, KEY_START_POINT, vPtInnerStart[1])
            
            -- pareti interne complete
            for nInd = 1, LayerParams.nShellsNbr - 1 - nMaxShellNbrDiff do
@@ -2764,18 +2974,20 @@ function CalcPaths.Exec( nPartId)
               local bOk, bExists, nSrfId = ComputeSurfOffset( nSrf, nCrvGrpId, - dOffs, LayerParams.vtSlicing)
               if not bOk then
                  EgtOutLog( 'Error : IntOffset failed (layer '.. EgtNumToString( nIdx) ..') - CalcPaths')
-                  table.insert( s_vErr, EgtNumToString( nIdx) .. ' : creation of InnerShell failed')
+                  table.insert( s_vErr, 'layer ' .. EgtNumToString( nIdx) .. ' : creation of InnerShell failed')
               elseif not bExists then
                  EgtOutLog( 'Warning : IntOffset ' .. EgtNumToString( nInd) .. ' not possible (layer '.. EgtNumToString( nIdx) ..') - CalcPaths')
               else
                  -- se offset riuscito, estraggo i contorni ( pareti interne)
-                  GetPathsFromSurf( nSrfId, SHELL_CRV..tostring( nInd), TYPE.INNER_SHELL, nGrpId, vPtInnerStart)
+                  local vNewIds = GetPathsFromSurf( nSrfId, SHELL_CRV..tostring( nInd), TYPE.INNER_SHELL, nGrpId, vPtInnerStart)
+                  ReorderPath( vOldIds, vNewIds)
+                  vOldIds = vNewIds
                  
                  -- se questo offset esiste ma il precedente no, allora il precedente è un errore da segnalare
                  if not bPrevExists then
                     local sElement = EgtIf( nInd > 1, 'IntOffset ' .. EgtNumToString( nInd - 1), 'ExtOffset')
                     EgtOutLog( 'Error :' .. sElement .. ' failed (layer '.. EgtNumToString( nIdx) ..') - CalcPaths')
-                     table.insert( s_vErr, EgtNumToString( nIdx) .. ' : creation of ' .. EgtIf( nInd > 1, 'InnerShell', 'OuterShell') .. ' failed')
+                     table.insert( s_vErr, 'layer ' .. EgtNumToString( nIdx) .. ' : creation of ' .. EgtIf( nInd > 1, 'InnerShell', 'OuterShell') .. ' failed')
                  end
               end
               
@@ -2792,7 +3004,7 @@ function CalcPaths.Exec( nPartId)
            local bOkTrim, bExistsTrim, nSrfTrim = ComputeSurfOffset( nSrf, nCrvGrpId, - dSurfTrimOffs, LayerParams.vtSlicing)
            if not bOkTrim then
               EgtOutLog( 'Error : IntOffset for TotTrimSurfRegion failed (layer '.. EgtNumToString( nIdx) ..') - CalcPaths')
-               table.insert( s_vErr, EgtNumToString( nIdx) .. ' : error in computing region for internal elements')
+               table.insert( s_vErr, 'layer ' .. EgtNumToString( nIdx) .. ' : error in computing region for internal elements')
            elseif bExistsTrim then
               EgtSetName( nSrfTrim, TOT_SHELL_TRIM_SURF)
               EgtSetStatus( nSrfTrim, GDB_ST.OFF)
@@ -2800,7 +3012,7 @@ function CalcPaths.Exec( nPartId)
               -- se questo offset esiste ma il precedente no, allora il precedente è un errore da segnalare
               if not bPrevExists then
                  EgtOutLog( 'Error : IntOffset' .. EgtNumToString( LayerParams.nShellsNbr - 1 - nMaxShellNbrDiff) .. ' failed (layer '.. EgtNumToString( nIdx) ..') - CalcPaths')
-                  table.insert( s_vErr, EgtNumToString( nIdx) .. ' : creation of InnerShell failed')
+                  table.insert( s_vErr, 'layer ' .. EgtNumToString( nIdx) .. ' : creation of InnerShell failed')
               end
            end
  
@@ -2808,44 +3020,36 @@ function CalcPaths.Exec( nPartId)
            if nMaxShellNbrDiff > 0 then
               CalcExtraShellsPath( nMaxShellNbrDiff, nShellNbrSurfGrp, nCrvGrpId, dOffs, LayerParams, vPtInnerStart)
            end
-            
-            -- gestione eventuale floor/ceil
-            if nIdx <= LayerParams.nFloorNbr then
-               local nSurfInfill = AdjustSurfForFloorCeil( LayerParams.nFloorNbr - nIdx + 1, nSrfTrim, nShellNbrSurfGrp) or nSrfTrim
-               if LayerParams.nFloorType == INFILL_TYPE.OFFSET then
-                  ComputeOffsetInfill( nSurfInfill, LayerParams.dStrand, LayerParams.vtSlicing, INFILL_CRV, TYPE.INFILL, vPtStart, nGrpId)
-               elseif LayerParams.nFloorType == INFILL_TYPE.ZIGZAG then
-                  ComputeZigZagInfill( nSurfInfill, LayerParams.dStrand, LayerParams.vtSlicing, INFILL_CRV, TYPE.INFILL, vPtStart, nGrpId, nSurfInfill)
-               end
-               EgtErase( nSurfInfill)
-            elseif nIdx > #vLayIds - LayerParams.nCeilNbr then
-               local nSurfInfill = AdjustSurfForFloorCeil( LayerParams.nCeilNbr - ( #vLayIds - nIdx), nSrfTrim, nShellNbrSurfGrp) or nSrfTrim
-               if LayerParams.nCeilType == INFILL_TYPE.OFFSET then
-                  ComputeOffsetInfill( nSurfInfill, LayerParams.dStrand, LayerParams.vtSlicing, INFILL_CRV, TYPE.INFILL, vPtStart, nGrpId)
-               elseif LayerParams.nCeilType == INFILL_TYPE.ZIGZAG then
-                  ComputeZigZagInfill( nSurfInfill, LayerParams.dStrand, LayerParams.vtSlicing, INFILL_CRV, TYPE.INFILL, vPtStart, nGrpId)
-               end
-               EgtErase( nSurfInfill)
-            end
         end
         
         -- passo al gruppo di contorni successivo
         nCrvGrpId = EgtGetNextName( nCrvGrpId, CONTOUR_GRP.."*") or GDB_ID.NULL
      end
      
-      if nIdx > LayerParams.nFloorNbr and nIdx <= #vLayIds - LayerParams.nCeilNbr then
-         
-         -- sistemo eventuali solidi ausiliari
-         if nAuxSolidsGrp then
-            CalcAuxSolidsPaths( vLayIds[nIdx], nAuxSolidsGrp, LayerParams, vPtStart)
-         end
-
-         -- sistemo eventuali costolature
-         if nRibsGrp then
-            CalcRibsPaths( vLayIds[nIdx], nRibsGrp, LayerParams, vPtStart)
+      -- gestione solidi ausiliari ( se no floor o ceil)
+      if nAuxSolidsGrp and ( nFirstSolidLay + LayerParams.nFloorNbr <= nIdx and nIdx <= nLastSolidLay - LayerParams.nCeilNbr or LayerParams.nShellsNbr == 0) then
+         CalcAuxSolidsPaths( vLayIds[nIdx], nAuxSolidsGrp, LayerParams, vPtStart)
+      end
+      
+      -- gestione riempimenti
+      if LayerParams.nShellsNbr > 0 then
+         -- infill
+         if nFirstSolidLay + LayerParams.nFloorNbr <= nIdx and nIdx <= nLastSolidLay - LayerParams.nCeilNbr then
+            CalcInfillPaths( vLayIds[nIdx], nInfillGrp, LayerParams)
+         -- floor
+         elseif nFirstSolidLay <= nIdx and nIdx < nFirstSolidLay + LayerParams.nFloorNbr then
+            CalcSolidFillPath( vLayIds[nIdx], LayerParams, vPtStart, LayerParams.nFloorType)
+         -- ceil
+         elseif nLastSolidLay - LayerParams.nCeilNbr < nIdx and nIdx <= nLastSolidLay then
+            CalcSolidFillPath( vLayIds[nIdx], LayerParams, vPtStart, LayerParams.nCeilType)
         end
      end
      
+      -- gestione costolature
+      if nRibsGrp then
+         CalcRibsPaths( vLayIds[nIdx], nRibsGrp, LayerParams, vPtStart)
+      end
+      
      if EgtProcessEvents( EgtIf( PRINT, 200, 0) + nIdx / #vLayIds * 100, 0) == 1 then
         EgtDraw()
         return false
@@ -2853,7 +3057,7 @@ function CalcPaths.Exec( nPartId)
   end
   
   if #s_vErr > 0 then
-      EgtOutBox( 'CalcPath Error on layers :\n' .. table.concat( s_vErr, '\n'), 'Calculating Paths')
+      EgtOutBox( 'CalcPath Error on :\n' .. table.concat( s_vErr, '\n'), 'Calculating Paths')
   end
   
   return true
@@ -14,6 +14,7 @@ local AMD = require( 'AddManData')

 ---------------------------------------------------------------------
 local s_nPartId
+local s_vErr = {}

 -- costanti
 local TOLER = 0.05
@@ -92,70 +93,7 @@ local function ReadParam( nId, sKey, sType, defVal, table)
   return info
 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 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 GetRibParams( nId)

   local RibParam = {}
@@ -193,166 +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, vErr, 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])
-      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')
-      local nLayCnt = EgtGetInfo( nLayId, KEY_SLICE_NBR, 'i')
-      -- creo gruppo per gli oggetti
-      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
-               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)
+            -- 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
-               
-               -- 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, BIG_TOLER)
-               -- 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)
-                  EgtSetInfo( nId, KEY_ORIGINAL_SURF, vIds[i])
+            -- 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
-                  
-                  -- se ho ancora curve aperte, segnalo errore
-                  if nType ~= TYPE.RIB and not EgtCurveIsClosed( nId) then
-                     EgtOutLog( 'Error : hole in object (layer '.. EgtNumToString( nLayCnt) ..') - CalcSlices')
-                     table.insert( vErr, nLayCnt)
-                  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 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
@@ -364,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()
   
@@ -389,14 +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, vErr)
+   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)

   local vtSlicing = frSlicing:getVersZ()
   
@@ -407,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
@@ -424,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
@@ -448,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
@@ -616,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
@@ -632,7 +990,7 @@ local function SlicingWithSolid( nStmId, vZSlices, dDeltaZStart, dZmin, frSlicin
         -- se vero errore lo segnalo
         if bErr then
            EgtOutLog( 'Error : hole in solid (layer '.. EgtNumToString( nLayCnt) ..') - CalcSlices')
-            table.insert( vErr, nLayCnt)
+            table.insert( s_vErr, nLayCnt)
            -- cambio nome al layer
            EgtSetName( nLayId, '__' .. SLICE_LAYER .. EgtNumToString( nLayCnt))
         else
@@ -643,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
@@ -660,30 +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, vErr, 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, vErr, 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, vErr, 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

@@ -758,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
-      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
@@ -72,6 +72,13 @@ local function RemoveOldSlices( nPartId)
   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

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

-VERSION = '2.5d5'
+VERSION = '2.5f1'
Author	SHA1	Message	Date
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