3dprinting/LuaLibs/CalcSlices.lua

-- CalcSlices.lua by Egaltech s.r.l. 2023/08/28
-- Calcolo percorsi di lavoro per Stampa 3d

-- Tabella per definizione modulo
local CalcSlices = {}

-- Intestazioni
require( 'EgtBase')

EgtOutLog( ' CalcSlices started', 1)

-- Dati
local AMD = require( 'AddManData')

---------------------------------------------------------------------
local s_nPartId
local s_vErr = {}
local s_dStrand

-- costanti
local TOLER = 0.05
local MID_TOLER = 0.1
local BIG_TOLER = 2.0
local MIN_LEN = 20.0
local MIN_AREA = 25.0

---------------------------------------------------------------------
local function ComputeZSlices( dSliceStep, dZmin, dDeltaZ, dZmax)
   
   local ptSlices = { dZmin + dDeltaZ}
   local dPosZ = dZmin + dSliceStep
   while dPosZ < dZmax do
      table.insert( ptSlices, dPosZ)
      dPosZ = dPosZ + dSliceStep
   end 
   return ptSlices
end

--------------------------------------------------------------------
local function ComputeMaxH( vIds, frSlicing, dSliceStep)
   
   local HMax = EgtGetInfo( s_nPartId, KEY_MAX_H, 'd') or GEO.INFINITO
   if HMax < GEO.EPS_SMALL then
      HMax = GEO.INFINITO
   end
   
   -- calcolo il box globale
   local b3BoxGlob = BBox3d()
   for i = 1, #vIds do
      local b3Box = EgtGetBBoxGlob( vIds[i], GDB_BB.STANDARD)
      b3BoxGlob:Add( b3Box)
   end
   EgtSetInfo( s_nPartId, KEY_BOX_MIN_Z, b3BoxGlob:getMin():getZ())
   
   if b3BoxGlob:getMax():getZ() < b3BoxGlob:getMin():getZ() + HMax + GEO.EPS_SMALL then
      return GEO.INFINITO
   end
   
   if AreSameVectorApprox( frSlicing:getVersZ(), Z_AX()) then
      return HMax
   else   
      -- se slicing inclinato
      local nGrpTmp = EgtGroup( s_nPartId)
      for i = 1, #vIds do
         EgtPlaneSurfTmInters( Point3d( 0, 0, HMax), Z_AX(), vIds[i], nGrpTmp, GDB_RT.GLOB)
      end
      local b3Box = EgtGetBBoxGlob( nGrpTmp, GDB_BB.STANDARD)
      EgtErase( nGrpTmp)
      if not b3Box then
         return GEO.INFINITO
      end
      local ptMin = b3Box:getMin()
      local ptMax = b3Box:getMax()
      -- la quota dell'ultimo slice è più bassa di dSliceStep rispetto alla quota dell'ultimo toolpath
      -- ( andrebbe anche considerata dCorrZ)
      ptMin = ptMin - dSliceStep * frSlicing:getVersZ()
      ptMax = ptMax - dSliceStep * frSlicing:getVersZ()
      ptMin:toLoc( frSlicing)
      ptMax:toLoc( frSlicing)
      
      return min( ptMin:getZ(), ptMax:getZ())
   end
   
   return GEO.INFINITO
end

--------------------------------------------------------------------
local function ReadParam( nId, sKey, sType, defVal, table)
   -- verifico se info nell'oggetto specifico
   local info = EgtGetInfo( nId, sKey, sType)
   -- altrimenti recupero info dai parametri generali
   if info == nil then info = EgtGetInfo( s_nPartId, sKey, sType) end
   -- o assegno valore di default
   if info == nil then info = defVal end
   
   -- se presente, inserisco l'info nella tabella
   if table then table[sKey] = info end
   
   return info
end

-----------------------------------------------------------------------
local function GetRibParams( nId)

   local RibParam = {}
   ReadParam( nId, KEY_RIBS_STRAND, 'd', s_dStrand, RibParam)
   if RibParam[KEY_RIBS_STRAND] < GEO.EPS_SMALL then
      RibParam[KEY_RIBS_STRAND] = s_dStrand
   end
   ReadParam( nId, KEY_RIBS_SHELLS_NBR, 'i', 0, RibParam)
   ReadParam( nId, KEY_RIBS_INVERT_DIR, 'b', false, RibParam)
   ReadParam( nId, KEY_RIBS_LEAD_IN_INVERT, 'b', false, RibParam)
   ReadParam( nId, KEY_RIBS_LEAD_IN_LEN, 'd', 0, RibParam)
   ReadParam( nId, KEY_RIBS_LEAD_OUT_INVERT, 'b', false, RibParam)
   ReadParam( nId, KEY_RIBS_LEAD_OUT_LEN, 'd', 0, RibParam)
   ReadParam( nId, KEY_RIBS_LEAD_OUT_COASTING, 'd', 0, RibParam)
   ReadParam( nId, KEY_RIBS_LEAD_OUT_WIPE, 'd', 0, RibParam)
   ReadParam( nId, KEY_RIBS_LEAD_OUT_WIPE_DIR, 'd', 0, RibParam)
   ReadParam( nId, KEY_RIBS_OVERLAP, 'd', 0, RibParam)
   ReadParam( nId, KEY_RIBS_LINK, 'b', false, RibParam)
   ReadParam( nId, KEY_RIBS_TYPE, 'i', RIB_TYPE.INTERNAL, RibParam)
   ReadParam( nId, KEY_RIBS_INVERT_STRAND_ORDER, 'b', false, RibParam)
   ReadParam( nId, KEY_RIBS_MERGE_WITH_SHELLS, 'b', false, RibParam)
  
   return RibParam
end

-------------------------------------------------------------------
local function GetShellNumberParams( nId)
   
   local ShellNumberParam = {}
   ReadParam( nId, KEY_SHELL_NBR_DIFF, 'i', 0, ShellNumberParam)
   ReadParam( nId, KEY_SHELL_NBR_COASTING, 'd', 0, ShellNumberParam)
   ReadParam( nId, KEY_SHELL_NBR_WIPE, 'd', 0, ShellNumberParam)
   ReadParam( nId, KEY_SHELL_NBR_WIPE_DIR, 'd', 0, ShellNumberParam)
   
   return ShellNumberParam
end

--------------------------------------------------------------------
local function GetAuxSolidsParams( nId)
   
   local AuxSolidsParam = {}
   ReadParam( nId, KEY_AUX_SOLIDS_STRAND, 'd', s_dStrand, AuxSolidsParam)
   if AuxSolidsParam[KEY_AUX_SOLIDS_STRAND] < GEO.EPS_SMALL then
      AuxSolidsParam[KEY_AUX_SOLIDS_STRAND] = s_dStrand
   end
   ReadParam( nId, KEY_AUX_SOLIDS_SHELLS_NBR, 'i', 0, AuxSolidsParam)
   ReadParam( nId, KEY_AUX_SOLIDS_OVERLAP, 'd', 0, AuxSolidsParam)
   ReadParam( nId, KEY_AUX_SOLIDS_INFILL, 'i', FILL_TYPE.NONE, AuxSolidsParam)
   ReadParam( nId, KEY_AUX_SOLIDS_PRINT_ORDER, 'i', PRINT_ORDER.EXT_INT, AuxSolidsParam)
   ReadParam( nId, KEY_AUX_SOLIDS_LINK_TYPE, 'i', LINK_TYPE.NONE, AuxSolidsParam)
   ReadParam( nId, KEY_AUX_SOLIDS_LINK_PARAM, 'd', 0, AuxSolidsParam)
   ReadParam( nId, KEY_AUX_SOLIDS_SP_OFFSET, 'd', 0, AuxSolidsParam)
   ReadParam( nId, KEY_AUX_SOLIDS_LP_OFFSET, 'd', 0, AuxSolidsParam)
   ReadParam( nId, KEY_AUX_SOLIDS_DENSITY, 'd', 0, AuxSolidsParam)
   ReadParam( nId, KEY_AUX_SOLIDS_DIR, 'd', 0, AuxSolidsParam)
   ReadParam( nId, KEY_AUX_SOLIDS_INFILL_LINK, 'b', false, AuxSolidsParam)
   ReadParam( nId, KEY_AUX_SOLIDS_OFFSET_X, 'd', 0, AuxSolidsParam)
   ReadParam( nId, KEY_AUX_SOLIDS_OFFSET_Y, 'd', 0, AuxSolidsParam)
   ReadParam( nId, KEY_AUX_SOLIDS_GRID_OVERLAP, 'd', 0, AuxSolidsParam)
   ReadParam( nId, KEY_AUX_SOLIDS_COASTING_LEN, 'd', 0, AuxSolidsParam)
   ReadParam( nId, KEY_AUX_SOLIDS_WIPE_LEN, 'd', 0, AuxSolidsParam)
   ReadParam( nId, KEY_AUX_SOLIDS_WIPE_DIR, 'd', 0, AuxSolidsParam)
   
   return AuxSolidsParam
end

----------------------------------------------------------------------
-------------------- SLICING EXTRA OBJECTS ---------------------------
----------------------------------------------------------------------
local function SliceStm( vIds, nLayId, vtSlicing, nType, sName, sNameGrp, tabParams)
   
   if not vIds or #vIds == 0 then return end
   
   -- 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
   
   -- 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
         -- 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

            -- 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, TOLER)
            if not nChainId then
               -- se fallisce riprendo le curve originali
               nChainId = nNewId + nPntCnt
               nCnt = nCrvCnt
            end
            -- rinomino le curve, correggo di DeltaZ e assegno parametri
            for nId = nChainId, nChainId + nCnt - 1 do
               EgtSetName( nId, sName .. tostring( i))
               EgtMove( nId, - ( dDeltaZ + dCorr) * vtSlicing)
               EgtSetInfo( nId, KEY_ORIGINAL_SURF, vIds[i])
               if tabParams then
                  for sKey, sVal in pairs( tabParams[i]) do
                     EgtSetInfo( nId, sKey, sVal)
                  end
               end
               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)
   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
   end
   
   -- per ogni layer calcolo lo slicing degli oggetti
   local vLayIds = EgtGetNameInGroup( s_nPartId, SLICE_LAYER .. '*')
   for i = 1, #vLayIds do
      SliceStm( vSliceIds, vLayIds[i], vtSlicing, nType, sName, sNameGrp, tabParams)
   end

   -- rimuovo eventuali oggetti creati per lo slicing
   for i = 1, #vEraseIds do
      EgtErase( vEraseIds[i])
   end
   
   return true
end

------------------------------------------------------------------------
local function SlicingInfill( nLay, vtSlicing, sName, sNameGrp)
   
   -- recupero tutte le curve di infill suddivise per direzioni di riferimento
   local vInfillGrps = EgtGetAllInGroup( nLay)
   local tIds = {}
   for i = 1, #vInfillGrps do
      local vIds = EgtGetAllInGroup( vInfillGrps[i])
      table.insert( tIds, vIds)
   end
   local nGrps = #vInfillGrps
   
   -- recupero quota infill
   local ptInfill = EgtSP( tIds[1][1], GDB_ID.ROOT)
   local dZInfill = ( ptInfill - ORIG()) * vtSlicing
  
   local vLayIds = EgtGetNameInGroup( s_nPartId, SLICE_LAYER .. '*')
   for i = 1, #vLayIds do
      
      -- individuo il gruppo di cui fare slicing
      local nGrpIdx = ( i - 1) % nGrps + 1
      
      -- recupero il gruppo dove salvare gli infill
      local nGrp = EgtGetFirstNameInGroup( vLayIds[i], sNameGrp)
      if not nGrp then
         -- se gruppo non esiste lo creo
         nGrp = EgtGroup( vLayIds[i])
         EgtSetName( nGrp, sNameGrp)
         EgtSetStatus( nGrp, GDB_ST.OFF)
      end
      
      -- copio le curve di infill e le traslo alla quota dello slicing
      local dZ = EgtGetInfo( vLayIds[i], KEY_SLICE_REAL_Z, 'd')
      for j = 1, #tIds[nGrpIdx] do
         local nCrv = EgtCopyGlob( tIds[nGrpIdx][j], nGrp)
         EgtSetName( nCrv, sName .. tostring(j))
         EgtMove( nCrv, (dZ - dZInfill) * vtSlicing, GDB_RT.GLOB)
      end
   end

   return true
end

----------------------------------------------------------------------
----------------------------- INFILL ---------------------------------
----------------------------------------------------------------------
local function CalcLinesInfill( nInfillGrp, nStmId, dOffsStm, frLoc, vtOffs, dDist)
   
   -- box locale
   local b3Loc = EgtGetBBoxRef( nStmId, GDB_BB.STANDARD, frLoc)
   b3Loc:expand( dOffsStm)
   local ptMin = b3Loc:getMin()
   local ptMax = b3Loc:getMax()
   local dZ = ptMin:getZ()
   
   local nGrp = EgtGroup( nInfillGrp, frLoc, GDB_RT.GLOB)
   
   -- calcolo la prima quota a cui tracciare la linea
   local dY = ptMin:getY() + vtOffs:getY() % dDist
   
   -- calcolo le linee
   while dY < ptMax:getY() + GEO.EPS_SMALL do
      local ptS = Point3d( ptMin:getX(), dY, dZ)
      local ptE = Point3d( ptMax:getX(), dY, dZ)
      EgtCurveCompoFromPoints( nGrp, {ptS, ptE})
      dY = dY + dDist
   end
end

--------------------------------------------------------------------
local function CalcSimpleGridInfill( nInfillGrp, nStmId, dOffsStm, frLoc, vtOffs, dDist)
    
   -- box locale
   local b3Loc = EgtGetBBoxRef( nStmId, GDB_BB.STANDARD, frLoc)
   b3Loc:expand( dOffsStm)
   local ptMin = b3Loc:getMin()
   local ptMax = b3Loc:getMax()
   local dZ = ptMin:getZ()
   
   -- direzione principale
   local nMainGrp = EgtGroup( nInfillGrp, frLoc, GDB_RT.GLOB)
   local dY = ptMin:getY() + vtOffs:getY() % dDist
   while dY < ptMax:getY() + GEO.EPS_SMALL do
      local ptS = Point3d( ptMin:getX(), dY, dZ)
      local ptE = Point3d( ptMax:getX(), dY, dZ)
      EgtCurveCompoFromPoints( nMainGrp, {ptS, ptE})
      dY = dY + dDist
   end
   
   -- direzione secondaria ( ortogonale alla principale)
   local nOtherGrp = EgtGroup( nInfillGrp, frLoc, GDB_RT.GLOB)
   local dX = ptMin:getX() + vtOffs:getX() % dDist
   while dX < ptMax:getX() + GEO.EPS_SMALL do
      local ptS = Point3d( dX, ptMin:getY(), dZ)
      local ptE = Point3d( dX, ptMax:getY(), dZ)
      EgtCurveCompoFromPoints( nOtherGrp, {ptS, ptE})
      dX = dX + dDist
   end
end

--------------------------------------------------------------------
local function CompletePatternBaseCrv( nCrvBase, dAng, dDim1, dDim2, dMinY, dMaxY)
   
   local vtDir1 = VectorFromPolar( 1, dAng)
   local vtDir2 = VectorFromPolar( 1, 180 - dAng)
   
   -- completo la curva base in Y+
   local ptNext = EgtEP( nCrvBase)
   while ptNext:getY() < dMaxY do
      ptNext = ptNext + dDim1 * vtDir1
      EgtAddCurveCompoLine( nCrvBase, ptNext)
      ptNext = ptNext + dDim2 * Y_AX()
      EgtAddCurveCompoLine( nCrvBase, ptNext)
      ptNext = ptNext + dDim1 * vtDir2
      EgtAddCurveCompoLine( nCrvBase, ptNext)
      ptNext = ptNext + dDim2 * Y_AX()
      EgtAddCurveCompoLine( nCrvBase, ptNext)
   end
   
   -- completo la curva base in Y-
   ptNext = EgtSP( nCrvBase)
   while ptNext:getY() > dMinY do
      ptNext = ptNext - dDim1 * vtDir2
      EgtAddCurveCompoLine( nCrvBase, ptNext, false)
      ptNext = ptNext - dDim2 * Y_AX()
      EgtAddCurveCompoLine( nCrvBase, ptNext, false)
      ptNext = ptNext - dDim1 * vtDir1
      EgtAddCurveCompoLine( nCrvBase, ptNext, false)
      ptNext = ptNext - dDim2 * Y_AX()
      EgtAddCurveCompoLine( nCrvBase, ptNext, false)
   end
   
   return nCrvBase
end

--------------------------------------------------------------------
local function CalcPatternCrvs( nGrp, nCrvBase, dMinX, dMaxX, dAng, dDim1, dStrand)
   
   local ptRef = EgtSP( nCrvBase)
   local dReflDist = dDim1 * cos( dAng) + dStrand * 0.5
   
   -- rifletto la curva base in X+
   local nPrevCrv = nCrvBase
   local dXRefl = ptRef:getX() + dReflDist
   while dXRefl < dMaxX do
      local nCurrCrv = EgtCopyGlob( nPrevCrv, nGrp, GDB_IN.LAST_SON)
      -- riflessione
      local ptRefl = Point3d( dXRefl, ptRef:getY(), ptRef:getZ())
      EgtMirror( nCurrCrv, ptRefl, X_AX())
      -- aggiorno per iterazione successiva
      nPrevCrv = nCurrCrv
      dXRefl = dXRefl + dReflDist + 0.5 * dStrand
   end

   -- rifletto la curva base in X-
   nPrevCrv = nCrvBase
   dXRefl = ptRef:getX() - dStrand / 2
   while dXRefl > dMinX do
      local nCurrCrv = EgtCopyGlob( nPrevCrv, nGrp, GDB_IN.FIRST_SON)
      -- riflessione
      local ptRefl = Point3d( dXRefl, ptRef:getY(), ptRef:getZ())
      EgtMirror( nCurrCrv, ptRefl, X_AX())
      -- aggiorno per iterazione successiva
      nPrevCrv = nCurrCrv
      dXRefl = dXRefl - dReflDist - 0.5 * dStrand
   end
end

--------------------------------------------------------------------
local function CalcGridFromPattern( nInfillGrp, nStmId, dOffsStm, frRef, vtOffs, dDim1, dDim2, dAng, vSlicesAng, dStrand, vtSlicing)
   
   -- direzione principale
   local frLoc = Frame3d( frRef)
   frLoc:rotate( ORIG(), vtSlicing, vSlicesAng[1])
   local nMainGrp = EgtGroup( nInfillGrp, frLoc, GDB_RT.GLOB)
   
   -- recupero il box del pezzo nel frame della direzione principale
   local b3Loc = EgtGetBBoxRef( nStmId, GDB_BB.STANDARD, frLoc)
   b3Loc:expand( dOffsStm)
   local ptMin = b3Loc:getMin()
   local ptMax = b3Loc:getMax()
   
   -- creo la curva base
   vtOffs:locToLoc( frRef, frLoc)
   local pt1 = ptMin + vtOffs
   local pt2 = pt1 + dDim2 * Y_AX()
   local nCrvBase = EgtCurveCompoFromPoints( nMainGrp, {pt1, pt2})
   if not nCrvBase then
      -- caso zigzag con dOverlapGrid = 100 ( dDim2 = 0)
      local vtDir1 = VectorFromPolar( 1, dAng)
      local vtDir2 = VectorFromPolar( 1, 180 - dAng)
      pt2 = pt1 + vtDir1 * dDim1
      nCrvBase = EgtCurveCompoFromPoints( nMainGrp, {pt1, pt2})
      pt2 = pt2 + vtDir2 * dDim1
      EgtAddCurveCompoLine( nCrvBase, pt2)
   end
   CompletePatternBaseCrv( nCrvBase, dAng, dDim1, dDim2, ptMin:getY(), ptMax:getY())
   
   -- preparo le altre curve
   CalcPatternCrvs( nMainGrp, nCrvBase, ptMin:getX(), ptMax:getX(), dAng, dDim1, dStrand)

   -- calcolo centro di rotazione
   local dDimPattern = 2 * dDim2 + 2 * dDim1 * sin( dAng)
   local dDimTot = ( EgtEP( nCrvBase):getY() - EgtSP( nCrvBase):getY()) - dDim2
   local dExtra = floor( dDimTot / dDimPattern * 0.5) * dDimPattern
   local ptCen = EgtSP( nCrvBase) + ( 3/2 * dDim2 + sin( dAng) * dDim1) * Y_AX() - dStrand * 0.5 * X_AX() + dExtra * Y_AX()

   for i = 2, #vSlicesAng do
      
      -- calcolo il nuovo riferimento
      local frLoc2 = Frame3d( frRef)
      frLoc2:rotate( ORIG(), vtSlicing, vSlicesAng[i])
      local nGrp = EgtGroup( nInfillGrp, frLoc2, GDB_RT.GLOB)
      
      -- calcolo il box del pezzo nel nuovo riferimento
      local b3Loc2 = EgtGetBBoxRef( nStmId, GDB_BB.STANDARD, frLoc2)
      b3Loc2:expand( dOffsStm)
      local ptMin2 = b3Loc2:getMin()
      local ptMax2 = b3Loc2:getMax()
      
      -- creo curva base ruotando la curva base della direzione principale
      local nCrvBase2 = EgtCopyGlob( nCrvBase, nMainGrp)
      EgtRotate( nCrvBase2, ptCen, Z_AX(), vSlicesAng[i] - vSlicesAng[1])
      EgtRelocateGlob( nCrvBase2, nGrp)
      CompletePatternBaseCrv( nCrvBase2, dAng, dDim1, dDim2, ptMin2:getY(), ptMax2:getY())
      
      -- preparo le altre curve
      CalcPatternCrvs( nGrp, nCrvBase2, ptMin2:getX(), ptMax2:getX(), dAng, dDim1, dStrand)
   end
   
end

--------------------------------------------------------------------
local function CalcInfill( nInfillGrp, nType, dDensity, dDir, dOffsX, dOffsY, dGridOverlap, nStmId, dOffsStm, dStrand, vtSlicing)
   
   -- frame locale alla direzione dell'infill
   local frLoc = Frame3d( ORIG(), vtSlicing)
   frLoc:rotate( ORIG(), vtSlicing, dDir)

   -- distanza fra le varie passate
   local dDist = 100 / dDensity * dStrand
   
   -- offset in X e Y
   local vtOffs = Vector3d( dOffsX, dOffsY, 0)
   vtOffs:toLoc( frLoc)
   
   -- eventuale correzione di dGridOverlap
   if nType ~= FILL_TYPE.LINES and nType ~= FILL_TYPE.GRID and dDensity > 85 then
      EgtOutLog( 'Warning: InfillGridOverlap is ignored due to high infill density - CalcSlices')
      dGridOverlap = 0
   end
   
   -- creo le curve di infill
   if nType == FILL_TYPE.LINES then
      CalcLinesInfill( nInfillGrp, nStmId, dOffsStm, frLoc, vtOffs, dDist)
      
   elseif nType == FILL_TYPE.GRID then
      CalcSimpleGridInfill( nInfillGrp, nStmId, dOffsStm, frLoc, vtOffs, dDist)
      
   elseif nType == FILL_TYPE.ZIG_ZAG_GRID then
      local dRealStrand = ( 1 - dGridOverlap / 100) * dStrand
      local dAng = 45
      local dDim1 = ( dDist - dStrand) * sqrt(2)
      local dDim2 = dRealStrand
      local vSlicesAng = {-45, 45}
      CalcGridFromPattern( nInfillGrp, nStmId, dOffsStm, frLoc, vtOffs, dDim1, dDim2, dAng, vSlicesAng, dRealStrand, vtSlicing)

   elseif nType == FILL_TYPE.HONEYCOMB or nType == FILL_TYPE.HONEYCOMB_GRID then
      local dRealStrand = ( 1 - dGridOverlap / 100) * dStrand
      local dAng = 30
      local dDim1 = ( dDist - dStrand) / cos(30)
      local dDim2 = dDim1 + sqrt(3) * dRealStrand
      local vSlicesAng = EgtIf( nType == FILL_TYPE.HONEYCOMB, {0}, {0, 60, 120})
      CalcGridFromPattern( nInfillGrp, nStmId, dOffsStm, frLoc, vtOffs, dDim1, dDim2, dAng, vSlicesAng, dRealStrand, vtSlicing)
   end
end

--------------------------------------------------------------------
local function PrepareInfill( nStmId, vtSlicing)
   
   -- verifco se richiesto infill
   local nShells = EgtGetInfo( s_nPartId, KEY_SHELLS_NBR, 'i')
   if nShells == 0 then return end
   local nType = EgtGetInfo( s_nPartId, KEY_INFILL_TYPE, 'i') or FILL_TYPE.NONE
   if nType == FILL_TYPE.NONE then return end
   local dDensity = EgtGetInfo( s_nPartId, KEY_INFILL_DENSITY, 'd') or 0
   if dDensity < GEO.EPS_SMALL then return end
   dDensity = EgtClamp( dDensity, 0, 90)
   
   -- recupero i parametri per infill
   local dDir = EgtGetInfo( s_nPartId, KEY_INFILL_DIR, 'd') or 0
   local dOffsX = EgtGetInfo( s_nPartId, KEY_INFILL_OFFSET_X, 'd') or 0
   local dOffsY = EgtGetInfo( s_nPartId, KEY_INFILL_OFFSET_Y, 'd') or 0
   local dGridOverlap = EgtGetInfo( s_nPartId, KEY_INFILL_GRID_OVERLAP, 'd') or 0
   local dOffsStm = EgtGetInfo( s_nPartId, KEY_OFFSET_SLICE, 'd')
   local dStrand = EgtGetInfo( s_nPartId, KEY_INFILL_STRAND, 'd') or s_dStrand
   if dStrand < GEO.EPS_SMALL then
      dStrand = s_dStrand
   end
   
   -- creo gruppo per infill
   local nInfillGrp = EgtGroup( s_nPartId)
   EgtSetName( nInfillGrp, INFILL_GRP)
   EgtSetStatus( nInfillGrp, GDB_ST.OFF)
   
   -- calcolo infill
   CalcInfill( nInfillGrp, nType, dDensity, dDir, dOffsX, dOffsY, dGridOverlap, nStmId, dOffsStm, dStrand, vtSlicing)
   
   -- aggiungo allo slicing
   SlicingInfill( nInfillGrp, vtSlicing, INFILL_CRV, INFILL_GRP)
end

----------------------------------------------------------------------
local function PrepareAuxSolidsInfill( nSolidsLay, vtSlicing)
   
   local vIds = EgtGetAllInGroup( nSolidsLay)
   -- scorro tutti gli AuxSolids
   for i = 1, #vIds do
      if EgtGetType( vIds[i]) == GDB_TY.SRF_MESH then
         -- verifico se da realizzare con infill e non con solidfill
         local nType = ReadParam( vIds[i], KEY_AUX_SOLIDS_INFILL, 'i', FILL_TYPE.NONE)
         if nType & FILL_CATEGORY.INFILL ~= 0 then
            local dDensity = ReadParam( vIds[i], KEY_AUX_SOLIDS_DENSITY, 'd', 0)
            if dDensity > GEO.EPS_SMALL then
               dDensity = EgtClamp( dDensity, 0, 90)
               
               -- recupero i parametri per infill
               local dDir = ReadParam( vIds[i], KEY_AUX_SOLIDS_DIR, 'd', 0)
               local dOffsX = ReadParam( vIds[i], KEY_AUX_SOLIDS_OFFSET_X, 'd', 0)
               local dOffsY = ReadParam( vIds[i], KEY_AUX_SOLIDS_OFFSET_Y, 'd', 0)
               local dGridOverlap = ReadParam( vIds[i], KEY_AUX_SOLIDS_GRID_OVERLAP, 'd', 0)
               local dStrand = ReadParam( vIds[i], KEY_AUX_SOLIDS_STRAND, 'd', s_dStrand)
               if dStrand < GEO.EPS_SMALL then
                  dStrand = s_dStrand
               end
               
               -- creo gruppo associato
               local nInfillGrp = EgtGroup( s_nPartId)
               EgtSetName( nInfillGrp, AUX_SOLIDS_INFILL_GRP .. tostring( vIds[i]))
               EgtSetStatus( nInfillGrp, GDB_ST.OFF)
               
               -- calcolo infill
               CalcInfill( nInfillGrp, nType, dDensity, dDir, dOffsX, dOffsY, dGridOverlap, vIds[i], 0, dStrand, vtSlicing)
               
               -- aggiungo allo slicing
               local sName = AUX_SOLIDS_INFILL_CRV .. tostring( vIds[i]) .. '_'
               SlicingInfill( nInfillGrp, vtSlicing, sName, AUX_SOLIDS_GRP)
            end
         end
      end
   end
end

--------------------------------------------------------------------
local function ExtractRibsLoops( nRibsGrp, nStmId)
   
   local nLoopGrp = EgtGroup( s_nPartId)
   EgtSetName( nLoopGrp, RIBS_LOOP_GRP)
   EgtSetStatus( nLoopGrp, GDB_ST.OFF)
   
   -- recupero tutti i setti
   local vIds = EgtGetAllInGroup( nRibsGrp)
   for i = 1, #vIds do
      -- se trimesh
      if EgtGetType( vIds[i]) == GDB_TY.SRF_MESH then
         -- trim con il solido
         local nCopy = EgtCopyGlob( vIds[i], nLoopGrp)
         local nType = ReadParam( vIds[i], KEY_RIBS_TYPE, 'i', RIB_TYPE.INTERNAL)
         EgtSurfTmCut( nCopy, nStmId, nType ~= RIB_TYPE.EXTERNAL, false)
         -- estraggo i contorni
         local nCrv, nCnt = EgtExtractSurfTmLoops( nCopy, nLoopGrp)
         if nCrv then
            -- assegno nome che permetta di ricondurli alla superficie da cui derivano
            for nId = nCrv, nCrv + nCnt - 1 do
               EgtSetName( nId, SURF_LOOP .. tostring( vIds[i]))
            end
         end
      end
   end
end

---------------------------------------------------------------------
local function ValueInArray( vArr, nValue)
   for _, val in ipairs( vArr) do
      if val == nValue then
         return true
      end
   end
   return false
end

---------------------------------------------------------------------
local function SlicingNoSolid( nRibsLay, vZSlices, dDeltaZStart, dZmin, frSlicing)
   
   local vtSlicing = frSlicing:getVersZ()
   
   -- contatore per il calcolo delle intersezioni
   if EgtProcessEvents( 100, 0) == 1 then return false end

   -- creo i layer dello slicing
   for i = 1, #vZSlices do
      local nLayGrp = EgtGroup( s_nPartId)
      EgtSetName( nLayGrp, SLICE_LAYER .. tostring( i))
      
      local dDeltaZ = EgtIf( i == 1, dDeltaZStart, 0)
      local dPosZ = vZSlices[i]- dDeltaZ
      EgtSetInfo( nLayGrp, KEY_SLICE_Z, dPosZ - dZmin)
      EgtSetInfo( nLayGrp, KEY_SLICE_REAL_Z, dPosZ)
      EgtSetInfo( nLayGrp, KEY_SLICE_DELTAZ, dDeltaZ)
      EgtSetInfo( nLayGrp, KEY_SLICE_NBR, i)
      
      local nGrpCrv = EgtGroup( nLayGrp)
      EgtSetName( nGrpCrv, CONTOUR_GRP .. EgtNumToString( 0))
   end
   if EgtProcessEvents( EgtIf( PRINT, 100, 0) + 20, 0) == 1 then return false end
    
   -- slicing dei setti
   SlicingExtraObjects( nRibsLay, vtSlicing, TYPE.RIB, RIBS_CRV, RIBS_GRP)
   if EgtProcessEvents( EgtIf( PRINT, 100, 0) + 100, 0) == 1 then return false end
   
   return true
end

---------------------------------------------------------------------
local function SlicingWithSolid( nStmId, vZSlices, dDeltaZStart, dZmin, frSlicing)

   local vtSlicing = frSlicing:getVersZ()
   
   -- calcolo delle intersezioni
   if EgtProcessEvents( 1, 0) == 1 then return false end
   local nLayId = EgtParPlanesSurfTmInters( ORIG(), vtSlicing, vZSlices, nStmId, s_nPartId, GDB_RT.GLOB, TOLER)
   if EgtProcessEvents( 100, 0) == 1 then return false end
   
   local 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
      
      local dDeltaZ = EgtIf( nLayCnt == 1, dDeltaZStart, 0)
      local dPosZ = vZSlices[nLayCnt]- dDeltaZ
      EgtSetInfo( nLayId, KEY_SLICE_Z, dPosZ - dZmin)
      EgtSetInfo( nLayId, KEY_SLICE_REAL_Z, dPosZ)
      EgtSetInfo( nLayId, KEY_SLICE_NBR, nLayCnt)
      
      -- verifico se necessario ricalcolo
      local nId = EgtGetLastInGroup( nLayId)
      local bRecalc = not nId
      local vtRecalc
      local nRecalc = 0
      while nId and not bRecalc do
         local nType = EgtGetType( nId)
         if nType == GDB_TY.SRF_MESH then
            bRecalc = true
            vtRecalc = EgtSurfTmFacetNormVersor( nId, 0)
         elseif nType == GDB_TY.GEO_POINT then
            bRecalc = true
         end 
         nId = EgtGetPrev( nId)
      end
      -- eseguo eventuale ricalcolo
      ::RECALC::
      if bRecalc then
         nRecalc = nRecalc + 1
         EgtEmptyGroup( nLayId)
         dDeltaZ = dDeltaZ + EgtIf( vtRecalc and vtRecalc:getZ() > 0, -0.01, 0.01)
         -- eseguo il ricalcolo solo a quella quota
         EgtPlaneSurfTmInters( ORIG() + ( dPosZ + dDeltaZ) * vtSlicing, vtSlicing, nStmId, nLayId, GDB_RT.GLOB, TOLER)
         EgtOutLog( 'Warning : recalc at layer '.. EgtNumToString( nLayCnt))
      end
      EgtSetInfo( nLayId, KEY_SLICE_DELTAZ, dDeltaZ)
   
      -- salvo i risultati nel layer
      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
            EgtErase( nId)
         else
            -- correggo eventuali spostamenti in Z
            if abs( dDeltaZ) > GEO.EPS_SMALL then 
               EgtMove( nId, - dDeltaZ * vtSlicing)
            end
            -- verifico presenza contorni aperti
            if EgtCurveIsClosed( nId) then
               table.insert( vClosedId, nId)
            else
               table.insert( vOpenId, nId)
            end
         end  
         
         nId = EgtGetNext( nId)
      end     
      
      -- se presenti percorsi aperti, provo a concatenarli
      if #vOpenId > 0 then
         local nRordId, nRordCnt = EgtCurveCompoByReorder( nLayId, vOpenId, ORIG(), true, GDB_RT.LOC, BIG_TOLER)
         if nRordId then
            vOpenId = {}
            for nId = nRordId, nRordId + nRordCnt - 1 do
               if EgtCurveIsClosed( nId) then
                  table.insert( vClosedId, nId)
               else
                  table.insert( vOpenId, nId)
               end
            end
         end
      end
      -- chiudo percorsi aperti praticamente chiusi ed elimino quelli troppo corti
      for i = #vOpenId, 1, -1 do
         local ptStart = EgtSP( vOpenId[i])
         local ptEnd = EgtEP( vOpenId[i])
         if EgtCurveLength( vOpenId[i]) < MIN_LEN then
            EgtErase( vOpenId[i])
            table.remove( vOpenId, i)
         elseif AreSamePointEpsilon( ptStart, ptEnd, BIG_TOLER) then
            local ptMid = ( ptStart + ptEnd) / 2
            EgtModifyCurveStartPoint( vOpenId[i], ptMid)
            EgtModifyCurveEndPoint( vOpenId[i], ptMid)
            table.insert( vClosedId, vOpenId[i])
            table.remove( vOpenId, i)
         end
      end
      local bAllClosed = ( #vOpenId == 0)
      -- elimino percorsi chiusi di area troppo piccola
      for i = #vClosedId, 1, -1 do
         local _, _, dArea = EgtCurveArea( vClosedId[i])
         if dArea and dArea < MIN_AREA then
            EgtErase( vClosedId[i])
            table.remove( vClosedId, i)
         end
      end
   
      -- se necessario e possibile, torno a ricalcolo
      if not bAllClosed and nRecalc < 2 then
         bRecalc = true
         goto RECALC
      end
   
      -- imposto dati ausiliari
      EgtSetName( nLayId, EgtIf( bAllClosed, '', '__') .. SLICE_LAYER .. EgtNumToString( nLayCnt))
      EgtSetInfo( nLayId, 'CrvCnt', #vClosedId + #vOpenId)
      EgtSetColor( vClosedId or {}, 'TEAL')
      EgtSetColor( vOpenId or {}, 'RED')
   
      -- creo flat region a partire dalle curve chiuse ottenute con lo slicing
      local nGrp = EgtGroup( nLayId, frSlicing, GDB_RT.GLOB)
      for i = 1, #vClosedId do
         EgtRelocateGlob( vClosedId[i], nGrp)
         EgtApproxCurve( vClosedId[i], GDB_CA.ARCS, MID_TOLER)
         EgtRelocateGlob( vClosedId[i], nLayId)
      end
      EgtErase( nGrp)
      local nSurfFR, nSrfNbr = EgtSurfFlatRegion( nLayId, vClosedId)
   
      if nSurfFR then
         -- verifico orientamento della normale
         local vtN = EgtSurfFrNormVersor( nSurfFR, GDB_ID.ROOT)
         if AreOppositeVectorApprox( vtN, vtSlicing) then
            EgtInvertSurf( nSurfFR)
         end
         -- elimino le curve originali
         for i = 1, #vClosedId do
            EgtErase( vClosedId[i])
         end
         -- esplodo in superfici elementari
         local vSrfId = {}
         for j = 1, nSrfNbr do
            local nCurrSfrId = nSurfFR + j - 1
            local nSfrId, nSfrCnt = EgtExplodeSurf( nCurrSfrId)
            for nId = nSfrId, nSfrId + nSfrCnt - 1 do
               table.insert( vSrfId, nId)
            end
         end
         -- calcolo i centri delle superfici
         local vCen = {}
         for j = 1, #vSrfId do
            local nId = vSrfId[j]
            local ptCen = EgtCP( nId, GDB_ID.ROOT)
            table.insert( vCen, ptCen)
         end
         -- ordino le superfici rispetto ai centri del layer precedente
         local vOrd = {}
         if #vPrevCen > 1 then
            for j = 1, #vPrevCen do
               local nMin = 0
               local dMinDist = GEO.INFINITO
               for k = 1, #vCen do
                  if not ValueInArray( vOrd, k) then
                     local dDist = dist( vPrevCen[j], vCen[k])
                     if dDist < dMinDist then
                        dMinDist = dDist
                        nMin = k
                     end
                  end
               end
               if nMin ~= 0 then
                  vOrd[j] = nMin
               end
            end
            -- se necessario, completo il vettore di ordine
            if #vOrd < #vSrfId then
               for j = 1, #vSrfId do
                  if not ValueInArray( vOrd, j) then
                     table.insert( vOrd, j)
                  end
               end
            end
         else
            EgtSpInit()
            for j = 1, #vSrfId do
               EgtSpAddPoint( vCen[j]:getX(), vCen[j]:getY())
            end
            vOrd = EgtSpCalculate( SHP_TY.OPEN)
            EgtSpTerminate()
            if not vOrd then
               for j = 1, #vSrfId do
                  vOrd[j] = j
               end
            end
         end
         -- salvo i nuovi centri
         for j = 1, #vSrfId do
            vPrevCen[j] = vCen[vOrd[j]]
         end
         -- creo i gruppi di percorsi
         for j = 1, #vSrfId do
            local nId = vSrfId[vOrd[j]]
            -- per ogni chunk creo un gruppo di percorsi 
            local nGrpCrv = EgtGroup( nLayId)
            EgtSetName( nGrpCrv, CONTOUR_GRP .. EgtNumToString( j, 1))
            EgtRelocateGlob( nId, nGrpCrv)
            EgtSetName( nId, LAYER_SRF)
            EgtSetStatus( nId, GDB_ST.OFF)
            -- estraggo i contorni della superficie
            local nCsId, nCsCnt = EgtExtractSurfFrChunkLoops( nId, 0, nGrpCrv) 
            for nId2 = nCsId, nCsId + nCsCnt - 1 do
               EgtSetName( nId2, OUTER_CRV)
               EgtSetStatus( nId2, GDB_ST.OFF)
               EgtSetColor( nId2, 'BLACK')
            end
         end
         
         if #vOpenId > 1 then
            EgtOutLog( 'Error : hole in solid (layer '.. EgtNumToString( nLayCnt) ..') - CalcSlices')
         end
      else
         
         local bErr = true
         -- se nessuna curva
         if #vClosedId == 0 and #vOpenId == 0 then
            bErr = false
         -- se una sola curva, ne verifico larghezza media
         elseif #vClosedId == 1 then
            local dLen = EgtCurveLength( vClosedId[1])
            local _, _, dArea = EgtCurveArea( vClosedId[1])
            if not dArea or dArea / dLen < MID_TOLER then bErr = false end
         end
         
         -- se vero errore lo segnalo
         if bErr then
            EgtOutLog( 'Error : hole in solid (layer '.. EgtNumToString( nLayCnt) ..') - CalcSlices')
            table.insert( s_vErr, nLayCnt)
            -- cambio nome al layer
            EgtSetName( nLayId, '__' .. SLICE_LAYER .. EgtNumToString( nLayCnt))
         else
            -- altrimenti creo il CrvGrp da utilizzare nel CalcPath
            local nGrpCrv = EgtGroup( nLayId)
            EgtSetName( nGrpCrv, CONTOUR_GRP .. EgtNumToString( 1))
         end
      end
      
      -- passo al layer successivo
      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
            local nCurr = nNext
            nNext = EgtGetNext( nCurr)
            EgtErase( nCurr)
         end
         return false
      end
      
      nLayCnt = nLayCnt + 1
      nLayId = EgtGetNext( nLayId)
   end

   -- costolature
   local nRibsLay = EgtGetFirstNameInGroup( s_nPartId, LAY_RIBS)
   ExtractRibsLoops( nRibsLay, nStmId)
   SlicingExtraObjects( nRibsLay, vtSlicing, TYPE.RIB, RIBS_CRV, RIBS_GRP, nStmId)
   if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( #vZSlices + 3) / nCounterTot * 100, 0) == 1 then return false end
   
   local bSpiralVase = EgtGetInfo( s_nPartId, KEY_SPIRAL_VASE, 'b') or false
   if not bSpiralVase then
      
      -- infill
      PrepareInfill( nStmId, vtSlicing)
      if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( #vZSlices + 6) / nCounterTot * 100, 0) == 1 then return false end
      
      -- solidi per regioni con diverso numero di passate
      local nShellNbrLay = EgtGetFirstNameInGroup( s_nPartId, LAY_SHELL_NBR)
      SlicingExtraObjects( nShellNbrLay, vtSlicing, TYPE.EXTRA_SHELL, SHELL_NBR_CRV, SHELL_NBR_GRP)
      if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( #vZSlices + 9) / nCounterTot * 100, 0) == 1 then return false end
      
      -- solidi ausiliari
      local nAuxSolidsLay = EgtGetFirstNameInGroup( s_nPartId, LAY_AUX_SOLIDS)
      SlicingExtraObjects( nAuxSolidsLay, vtSlicing, TYPE.AUX_SOLID, AUX_SOLIDS_CRV, AUX_SOLIDS_GRP)
      PrepareAuxSolidsInfill( nAuxSolidsLay, vtSlicing)
      if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( #vZSlices + 12) / nCounterTot * 100, 0) == 1 then return false end
      
   end
   
   EgtSetInfo( s_nPartId, KEY_FIRST_SOLID_LAY, nFirstSolidLay)
   EgtSetInfo( s_nPartId, KEY_LAST_SOLID_LAY, nLastSolidLay)
   
   return true
end

---------------------------------------------------------------------
function CalcSlices.Exec( nPartId, nStmId)

   s_nPartId = nPartId

   local sMachIni = EgtGetCurrMachineDir() .. '\\' .. EgtGetCurrMachineName() .. '.ini'

   -- recupero la direzione dello slicing
   local vtSlicing = Z_AX()
   local nSlicingType = EgtGetInfo( s_nPartId, KEY_SLICING_TYPE, 'i')
   if nSlicingType == SLICING_TYPE.DEG45_X then
      local nDir = EgtGetNumberFromIni( '3dPrinting', 'Dir45degX', 0, sMachIni)
      local dHorAng = EgtIf( nDir == -1, 180, 0)
      vtSlicing =  VectorFromSpherical( 1, 45, dHorAng)
   elseif nSlicingType == SLICING_TYPE.DEG45_Y then
      local nDir = EgtGetNumberFromIni( '3dPrinting', 'Dir45degY', 0, sMachIni)
      local dHorAng = EgtIf( nDir == 2, 90, -90)
      vtSlicing = VectorFromSpherical( 1, 45, dHorAng)
   elseif nSlicingType == SLICING_TYPE.HORIZONTAL then
      vtSlicing = X_AX()
   end

   EgtSetInfo( s_nPartId, KEY_SLICING_DIR, vtSlicing)
   local frSlicing = Frame3d( ORIG(), vtSlicing)
   
   -- recupero la superficie ed eventuali setti esterni/unbounded da usare come riferimenti per quote slicing
   local vRefIds = {}
   if nStmId then table.insert( vRefIds, nStmId) end
   local nRibsLay = EgtGetFirstNameInGroup( s_nPartId, LAY_RIBS)
   local vRibsIds = EgtGetAllInGroup( nRibsLay)
   local bLimitUnbddRibs = EgtGetInfo( s_nPartId, KEY_LIMIT_UNBDD_RIBS, 'b') or false
   for i = 1, #vRibsIds do
      if EgtGetType( vRibsIds[i]) == GDB_TY.SRF_MESH then
         local nType = ReadParam( vRibsIds[i], KEY_RIBS_TYPE, 'i', RIB_TYPE.INTERNAL)
         if nType == RIB_TYPE.EXTERNAL or ( nType == RIB_TYPE.UNBOUNDED and not bLimitUnbddRibs) then
            table.insert( vRefIds, vRibsIds[i])
         end
      end
   end
   
   if bLimitUnbddRibs and not nStmId then
      EgtOutBox( "No solid to limit unbounded ribs!", 'Error', 'ERROR')
      return
   end
   
   -- recupero il box
   local b3Box = BBox3d()
   for i = 1, #vRefIds do
      local b3Tmp = EgtGetBBoxRef( vRefIds[i], GDB_BB.STANDARD, frSlicing)
      b3Box:Add( b3Tmp)
   end
   if not b3Box or b3Box:isEmpty() then
      EgtOutBox( "No part to be sliced!", 'Error', 'ERROR')
      return
   end
   
   -- Parametri di slicing
   local dSliceStep = EgtGetInfo( s_nPartId, KEY_SLICE_STEP, 'd') or 10000
   if dSliceStep < GEO.EPS_SMALL then
      EgtOutLog( 'Warning : SliceStep is 0')
      return
   end
   s_dStrand = EgtGetInfo( s_nPartId, KEY_STRAND, 'd')

   local dZmin = b3Box:getMin():getZ()
   local dZmax = b3Box:getMax():getZ()
   local dMaxH = ComputeMaxH( vRefIds, frSlicing, dSliceStep)
   dZmax = min( dZmax, dMaxH)
   --dZmin = 708
   --dZmax = 712
   
   -- Eseguo slicing
   local nLayCnt = 1
   local nRecalc = 0
   local dDeltaZStart = 0.2
   
   local vZSlices = ComputeZSlices( dSliceStep, dZmin, dDeltaZStart, dZmax)

   local bOk = true
   if not nStmId then
      -- caso senza solido e solo setti
      bOk = SlicingNoSolid( nRibsLay, vZSlices, dDeltaZStart, dZmin, frSlicing)
   else
      -- caso con solido
      bOk = SlicingWithSolid( nStmId, vZSlices, dDeltaZStart, dZmin, frSlicing)
   end
   
   -- eventuale segnalazione errori
   if bOk and #s_vErr > 0 then
      EgtOutBox( 'Slicing Error on layers :\n' .. table.concat( s_vErr, ','), 'SlicingCalc')
    end
    
    return bOk
end

---------------------------------------------------------------------
return CalcSlices