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
-- recupero tolleranza dal file ini
local INI_TOLER = EgtGetNumberFromIni( 'GeomDB', 'SurfTmToler', 0.01, EgtGetIniFile())
local MID_TOLER = 10 * INI_TOLER
local TOLER = 0.5 * MID_TOLER
local BIG_TOLER = 2.0
local MIN_LEN = 20.0
local MIN_AREA = 25.0
local DELTAZ = 10 * GEO.EPS_SMALL


---------------------------------------------------------------------
local function ComputeSlicingData( vIds, vtSlicing, dSliceStep, dMaxH, nMaxSlicesNbr)
   -- la direzione di slicing è vtSlicing per tutti gli slices
   -- i valori di slicing sono le distanze dall'origine dei piani di slicing misurate in direzione vtSlicing
   
   local vSlicingDir = { vtSlicing}
   -- ricavo le z a cui calcolare gli slices
   local frSlicing = Frame3d( ORIG(), vtSlicing)
   local b3Box = BBox3d()
   for i = 1, #vIds do
      local b3Tmp = EgtGetBBoxRef( vIds[i], GDB_BB.STANDARD, frSlicing)
      b3Box:Add( b3Tmp)
   end
   local dZmin = b3Box:getMin():getZ()
   local dZmax = min( b3Box:getMax():getZ(), dMaxH)

   local nCnt = 1
   local vZSlices = { dZmin + DELTAZ}
   local dPosZ = dZmin + dSliceStep
   while dPosZ < dZmax and nCnt < nMaxSlicesNbr do
      table.insert( vZSlices, dPosZ)
      dPosZ = dPosZ + dSliceStep
      nCnt = nCnt + 1
   end
   return vZSlices, vSlicingDir
end

---------------------------------------------------------------------
local function ComputeMultiplanarSlicingData( dSliceStep, nMaxSlicesNbr, nSlicingType)
   -- le direzioni e i valori di slicing sono le normali e i punti che definiscono i piani di slicing e vengono calcolati sulla curva "Spine"
   
   -- recupero la curva guida ( è la prima nel gruppo aux con info NameEntity = Spine oppure quella con nome Spine)
   local nAuxLayId = EgtGetFirstNameInGroup( s_nPartId, LAY_AUX)
   local vIds = EgtGetAllInGroup( nAuxLayId)
   local nSpineId
   for i = 1, #vIds do
      local sNameEntity = EgtGetInfo( vIds[i], KEY_ENTITY_NAME)
      if sNameEntity == SPINE_CURVE then
         nSpineId = vIds[i]
         break
      elseif EgtGetName( vIds[i]) == SPINE_CURVE then
         nSpineId = vIds[i]
      end
   end
   if not nSpineId or ( EgtGetType( nSpineId) & GDB_FY.GEO_CURVE) == 0 then
      EgtOutBox( "No spine for multiplanar slicing", 'Error', 'ERROR')
      return nil
   end

   if nSlicingType == SLICING_TYPE.MULTIPLANAR then
      -- verifico che la spina parta nell'origine con direzione Z_AX
      local ptS = EgtSP( nSpineId, GDB_ID.ROOT)
      local vtS = EgtSV( nSpineId, GDB_ID.ROOT)
      if abs( ptS:getZ()) > GEO.EPS_SMALL then
         EgtOutLog( 'Error : spine does not start on table')
         EgtOutBox( "Spine not valid for multiplanar slicing", 'Error', 'ERROR')
         return nil
      elseif not AreSameVectorApprox( vtS, Z_AX()) then
         EgtOutLog( 'Error : spine start direction is not vertical')
         EgtOutBox( "Spine not valid for multiplanar slicing", 'Error', 'ERROR')
         return nil
      end
   end
   
   local vSlicingDir = {}
   local vSlicingPnt = {}
   if nSlicingType == SLICING_TYPE.MULTIPLANAR_DEG45 then
      dSliceStep = dSliceStep / ( sqrt( 2) / 2)
   end
   
   -- ciclo sulla curva
   local dCrvLen = EgtCurveLength( nSpineId)
   for i = 0, nMaxSlicesNbr - 1 do
      local dCurrLen = i * dSliceStep
      if dCurrLen > dCrvLen then
         break
      end
      local dU = EgtCurveParamAtLength( nSpineId, dCurrLen)
      local vtTang = EgtUV( nSpineId, dU, -1, GDB_ID.ROOT)
      if nSlicingType == SLICING_TYPE.MULTIPLANAR_DEG45 then
         local vtOrth = VectorFromRotated( vtTang, Z_AX(), -90)
         vtTang:rotate( vtOrth, 45)
      end
      vSlicingDir[i+1] = vtTang
      vSlicingPnt[i+1] = EgtUP( nSpineId, dU, GDB_ID.ROOT)
   end
   
   return vSlicingPnt, vSlicingDir
end

--------------------------------------------------------------------
local function ComputeMaxH( vIds, vtSlicing, dSliceStep)
   
   local HMax = EgtGetInfo( s_nPartId, KEY_MAX_H, 'd') or GEO.INFINITO
   if HMax < GEO.EPS_SMALL then
      return 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())
   
   -- se il pezzo non è più alto della quota massima, posso ignorarla
   if b3BoxGlob:getMax():getZ() < HMax + GEO.EPS_SMALL then
      return GEO.INFINITO
   end
   
   if AreSameVectorApprox( vtSlicing, Z_AX()) then
      -- se slicing verticale o multiplanare l'altezza è quella letta
      return HMax
   else
       -- se slicing inclinato calcolo l'altezza massima rispetto alle quote di slicing
      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 * vtSlicing
      ptMax = ptMax - dSliceStep * vtSlicing
      local frSlicing = Frame3d( ORIG(), vtSlicing)
      ptMin:toLoc( frSlicing)
      ptMax:toLoc( frSlicing)
      
      return min( ptMin:getZ(), ptMax:getZ())
   end
   
   return GEO.INFINITO
end

----------------------------------------------------------------------
-------------------- SLICING EXTRA OBJECTS ---------------------------
----------------------------------------------------------------------
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_STRAND_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)
   ReadParam( nId, KEY_RIBS_LEAD_FILLET, 'd', 0, RibParam)
   ReadParam( nId, KEY_RIBS_LINK_FILLET, 'd', 0, 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

--------------------------------------------------------------------
local function SlicingExtraObjects( nLay, vSlicingDir, vSlicingVal, nSlicingType, 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 vEraseIds = {}
   if nStmId then
      local bLimitUnbddRibs = EgtGetInfo( s_nPartId, KEY_LIMIT_UNBDD_RIBS, 'b') or false
      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
   end
   
   local vLayIds = EgtGetNameInGroup( s_nPartId, SLICE_LAYER .. '*')

   for i = 1, #vSliceIds do
      -- effettuo lo slicing in layer separati ( analogamente a quanto avviene con il solido)
      local nResId
      if nSlicingType ~= SLICING_TYPE.MULTIPLANAR and nSlicingType ~= SLICING_TYPE.MULTIPLANAR_DEG45 and nSlicingType ~= SLICING_TYPE.MULTIPLANAR_HOR then
         nResId = EgtParPlanesSurfTmInters( ORIG(), vSlicingDir[1], vSlicingVal, vSliceIds[i], s_nPartId, GDB_RT.GLOB, TOLER)
      else
         for j = 1, #vSlicingVal do
            local vtN = vSlicingDir[j]
            local ptOn = vSlicingVal[j]
            if j == 1 then
               ptOn = ptOn + DELTAZ * vtN
            end
      
            local nGrpId = EgtGroup( s_nPartId)
            if not nResId then
               nResId = nGrpId
            end
            EgtPlaneSurfTmInters( ptOn, vtN, vSliceIds[i], nGrpId, GDB_RT.GLOB, TOLER)
         end
      end

      -- recupero i risultati e li sposto nei layers opportuni
      local j = 1
      while nResId do
         local vtSlicing = vSlicingDir[j] or vSlicingDir[1]
         
         -- recupero il gruppo nel layer dove salvare lo slicing degli oggetti o lo creo se non esiste
         local nGrp = EgtGetFirstNameInGroup( vLayIds[j], sNameGrp)
         if not nGrp then
            nGrp = EgtGroup( vLayIds[j])
            EgtSetName( nGrp, sNameGrp)
            EgtSetStatus( nGrp, GDB_ST.OFF)
         end
         
         -- verifico se necessario ricalcolo
         local nId = EgtGetLastInGroup( nResId)
         local bRecalc = false
         local vtRecalc
         while nId and not bRecalc do
            local nGeoType = EgtGetType( nId)
            if nGeoType == GDB_TY.SRF_MESH then
               bRecalc = true
               vtRecalc = EgtSurfTmFacetNormVersor( nId, 0)
            elseif nGeoType == GDB_TY.GEO_POINT then
               bRecalc = true
            elseif nType ~= TYPE.RIB and nType ~= TYPE.INFILL and not EgtCurveIsClosed( nId) then
               bRecalc = true
            end
            nId = EgtGetPrev( nId)
         end
         
         -- eseguo eventuale ricalcolo
         local dDeltaZ = EgtIf( j == 1, DELTAZ, 0)
         if bRecalc then
            EgtEmptyGroup( nResId)
            dDeltaZ =  dDeltaZ + EgtIf( vtRecalc and vtRecalc:getZ() > 0, - DELTAZ, DELTAZ)
            -- eseguo il ricalcolo solo a quella quota
            local ptSlicing = EgtGetInfo( vLayIds[j], KEY_SLICE_POS, 'p')
            local ptOn = ptSlicing + dDeltaZ * vtSlicing
            EgtPlaneSurfTmInters( ptOn, vtSlicing, vSliceIds[i], nResId, GDB_RT.GLOB, TOLER)
            EgtOutLog( 'Warning : recalc at layer '.. EgtNumToString( j))
         end
         
         -- recupero tutte le curve
         local vAllIds = EgtGetAllInGroup( nResId)
         local vCrvIds = {}
         for k = 1, #vAllIds do
            local nGeoType = EgtGetType( nId)
            if nGeoType ~= GDB_TY.SRF_MESH and nGeoType ~= GDB_TY.GEO_POINT then
               table.insert( vCrvIds, vAllIds[k])
            end
         end
         
         if #vCrvIds > 0 then
            -- concateno le curve, le rinomino, correggo di DeltaZ e assegno i parametri
            local nChainId, nCnt = EgtCurveCompoByChain( nGrp, vCrvIds, ORIG(), true, GDB_RT.LOC, TOLER)
            for nId = nChainId, nChainId + nCnt - 1 do
               EgtSetName( nId, sName .. EgtNumToString( i))
               EgtMove( nId, - dDeltaZ * vtSlicing)
               EgtSetInfo( nId, KEY_ORIGINAL_SURF, vSliceIds[i])
               if tabParams then
                  for sKey, sVal in pairs( tabParams[i]) do
                     EgtSetInfo( nId, sKey, sVal)
                  end
               end
               EgtModifyCurveExtrusion( nId, vtSlicing, GDB_RT.GLOB)
               EgtApproxCurve( nId, GDB_CA.ARCS, MID_TOLER)
            
               -- 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( j) ..') - CalcSlices')
                  table.insert( s_vErr, j)
               end
            end
         end
         
         local nOldId = nResId
         nResId = EgtGetNext( nResId)
         j = j + 1
         EgtErase( nOldId)
      end
   end
   
   -- rimuovo eventuali oggetti creati per lo slicing
   EgtErase( vEraseIds)
   
   return true
end

------------------------------------------------------------------------
local function SlicingInfill( nLay, 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
  
   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 i dati di slicing
      local ptSlicing = EgtGetInfo( vLayIds[i], KEY_SLICE_POS, 'p')
      local vtSlicing = EgtGetInfo( vLayIds[i], KEY_SLICE_DIR, 'v')
      
      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
      
      local vInfillIds = tIds[nGrpIdx]
      for j = 1, #vInfillIds do
         -- verifico che oggetto sia trimesh
         local nTypeObj = EgtGetType( vInfillIds[j])
         if nTypeObj == GDB_TY.SRF_MESH then
            -- slicing
            local nNewId, nPntCnt, nCrvCnt, nSrfCnt = EgtPlaneSurfTmInters( ptSlicing, vtSlicing, vInfillIds[j], nGrp, GDB_RT.GLOB, TOLER)

            -- 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)
            -- sistemo le curve
            for nId = nChainId, nChainId + nCnt - 1 do
               EgtSetName( nId, sName .. EgtNumToString(j))
               EgtSetInfo( nId, KEY_ORIGINAL_SURF, vInfillIds[j])
               EgtModifyCurveExtrusion( nId, vtSlicing, GDB_RT.GLOB)
               EgtApproxCurve( nId, GDB_CA.ARCS, MID_TOLER)
            end
            
            -- rimuovo superfici
            for nId = nNewId + nPntCnt + nCrvCnt, nNewId + nPntCnt + nCrvCnt + nSrfCnt - 1 do
               EgtErase( nId)
            end
         end
      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
   
   -- calcolo le superifici a partire dalle curve ( nei casi standard è semplice estrusione)
   local vGrps = EgtGetAllInGroup( nInfillGrp)
   local vCrvs = {}
   for i = 1, #vGrps do
      EgtJoinTables( vCrvs, EgtGetAllInGroup( vGrps[i]))
   end
   local nLastLay = EgtGetLastNameInGroup( s_nPartId, SLICE_LAYER .. '*')
   local ptLast = EgtGetInfo( nLastLay, KEY_SLICE_POS, 'p')
   local dZ = ( ptLast - ORIG()) * vtSlicing
   for i = 1, #vCrvs do
      EgtSurfTmByExtrusion( EgtGetParent( vCrvs[i]), vCrvs[i], ( dZ + 100) * vtSlicing, 0.05, GDB_RT.GLOB)
   end
   EgtErase( vCrvs)
   
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, 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 .. EgtNumToString( 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 .. EgtNumToString( vIds[i]) .. '_'
               SlicingInfill( nInfillGrp, 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 estraggo i contorni
      if EgtGetType( vIds[i]) == GDB_TY.SRF_MESH then
         local nCrv, nCnt = EgtExtractSurfTmLoops(  vIds[i], 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 .. EgtNumToString( 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 VerifyMultiPlanarStrand()
   
   local vLayers = EgtGetNameInGroup( s_nPartId, SLICE_LAYER .. '*')
   -- recupero i valori di strand massimo e minimo dal file ini
   local sMachIni = EgtGetCurrMachineDir() .. '\\' .. EgtGetCurrMachineName() .. '.ini'
   local dMaxStrandFactor = EgtGetNumberFromIni( '3dPrinting', KEY_MAX_STRANDH_FACTOR, 2, sMachIni)
   local dMinStrandFactor = EgtGetNumberFromIni( '3dPrinting', KEY_MIN_STRANDH_FACTOR, 0.5, sMachIni)
   local dSliceStep = EgtGetInfo( s_nPartId, KEY_SLICE_STEP, 'd')
   local dMaxStrand = dMaxStrandFactor * dSliceStep
   local dMinStrand = dMinStrandFactor * dSliceStep
   
   if dMaxStrand < dMinStrand + GEO.EPS_SMALL then
      EgtOutBox( 'Max strand height is less than min strand height', 'Error', 'ERROR')
      return false
   end
   
   -- ciclo sui piani di slicing calcolati
   local vtSlicePrev = V_NULL()
   local ptSlicePrev = ORIG()
   local bFirst = true
   local dTotMaxDist = dSliceStep
   local dTotMinDist = dSliceStep
   local nLayMin = 1
   local nLayMax = 1
   for i = 1, #vLayers do
      
      -- recupero il piano corrente
      local vtSlice = EgtGetInfo( vLayers[i], KEY_SLICE_DIR, 'v')
      local ptSlice = EgtGetInfo( vLayers[i], KEY_SLICE_POS, 'p') + dSliceStep * vtSlice
      local dCosAng = vtSlicePrev * vtSlice
      
      -- recupero tutte le curve da verificare :
      local vCrvs = {}
      -- solido
      local vCrvGrps = EgtGetNameInGroup( vLayers[i], CONTOUR_GRP .. '*')
      for j = 1, #vCrvGrps do
         local vSolidCrvs = EgtGetNameInGroup( vCrvGrps[j], OUTER_CRV)
         EgtJoinTables( vCrvs, vSolidCrvs)
      end
      -- setti
      local nRibsGrp = EgtGetFirstNameInGroup( vLayers[i], RIBS_GRP) or GDB_ID.NULL
      local vRibsCrv = EgtGetNameInGroup( nRibsGrp, RIBS_CRV .. '*') or {}
      EgtJoinTables( vCrvs, vRibsCrv)
      -- AuxSolids
      local nAuxSolidsGrp = EgtGetFirstNameInGroup( vLayers[i], AUX_SOLIDS_GRP) or GDB_ID.NULL
      local vAuxSolidsCrv = EgtGetNameInGroup( nAuxSolidsGrp, AUX_SOLIDS_CRV .. '*') or {}
      EgtJoinTables( vCrvs, vAuxSolidsCrv)
      
      if #vCrvs > 0 and not bFirst then
         -- verifico la distanza dal piano precedente lungo vtSlice
         local dMinDist = GEO.INFINITO
         local dMaxDist = - GEO.INFINITO
         for j = 1, #vCrvs do
            local _, dE = EgtCurveDomain( vCrvs[j])
            for dU = 0, dE do
               local ptCurr = EgtUP( vCrvs[j], dU, GDB_ID.ROOT) + dSliceStep * vtSlice
               local dDist = ( ptCurr - ptSlicePrev) * vtSlicePrev / dCosAng
               if dDist < dMinStrand - GEO.EPS_SMALL or dDist > dMaxStrand + GEO.EPS_SMALL then
                  EgtOutLog( 'Error on layer ' .. EgtNumToString( i) .. ' : strand height (' .. EgtNumToString( dDist) .. ') outside valid range (' .. EgtNumToString( dMinStrand) .. 
                              ' - ' .. EgtNumToString( dMaxStrand) .. ')')
                  EgtOutBox( 'Strand height value ' .. EgtNumToString( dDist) .. ' in layer ' .. EgtNumToString( i) .. ' is outside valid range (' .. EgtNumToString( dMinStrand) .. 
                              ' - ' .. EgtNumToString( dMaxStrand) .. ')', 'Error', 'ERROR')
                  return false
               end
               
               if dDist < dMinDist then
                  dMinDist = dDist
               end
               if dDist > dMaxDist then
                  dMaxDist = dDist
               end
            end
         end
         EgtSetInfo( vLayers[i], KEY_MULTIPLANAR_MAX_H, dMaxDist)
         EgtSetInfo( vLayers[i], KEY_MULTIPLANAR_MIN_H, dMinDist)
         
         if dMinDist < dTotMinDist then
            dTotMinDist = dMinDist
            nLayMin = i
         end
         if dMaxDist > dTotMaxDist then
            dTotMaxDist = dMaxDist
            nLayMax = i
         end
      end
      
      -- aggiorno per layer successivo
      vtSlicePrev = vtSlice
      ptSlicePrev = ptSlice
      if #vCrvs > 0 then
         bFirst = false
      end
   end
   
   EgtOutLog( 'MinStrandH = ' .. EgtNumToString( dTotMinDist) .. ' (layer ' .. EgtNumToString( nLayMin) .. ')')
   EgtOutLog( 'MaxStrandH = ' .. EgtNumToString( dTotMaxDist) .. ' (layer ' .. EgtNumToString( nLayMax) .. ')')

   return true
end

---------------------------------------------------------------------
local function SlicingNoSolid( nRibsLay, nSlicingType, dMaxH, dSliceStep, vSlicingVal, vSlicingDir)

   -- contatore per il calcolo delle intersezioni
   if EgtProcessEvents( 100, 0) == 1 then return false end

   -- creo i layer dello slicing
   for i = 1, #vSlicingVal do
      -- creo layer e gruppo dei contorni
      local nLayId = EgtGroup( s_nPartId)
      EgtSetName( nLayId, SLICE_LAYER .. EgtNumToString( i))
      EgtSetInfo( nLayId, KEY_SLICE_NBR, i)
      local nCrvLayId = EgtGroup( nLayId)
      EgtSetName( nCrvLayId, CONTOUR_GRP .. EgtNumToString( 0))
      
      -- recupero i dati del piano di slicing
      local dDeltaZ = EgtIf( i == 1, DELTAZ, 0)
      local ptSlicing
      local vtSlicing
      if nSlicingType == SLICING_TYPE.MULTIPLANAR or nSlicingType == SLICING_TYPE.MULTIPLANAR_DEG45 or nSlicingType == SLICING_TYPE.MULTIPLANAR_HOR then
         vtSlicing = vSlicingDir[i]
         ptSlicing = vSlicingVal[i]
      else
         vtSlicing = vSlicingDir[1]
         ptSlicing = ORIG() + ( vSlicingVal[i] - dDeltaZ) * vtSlicing
      end
      EgtSetInfo( nLayId, KEY_SLICE_POS, ptSlicing)
      EgtSetInfo( nLayId, KEY_SLICE_DIR, vtSlicing)
      EgtSetInfo( nLayId, KEY_SLICE_DELTAZ, dDeltaZ)

      if EgtProcessEvents( EgtIf( PRINT, 100, 0) + i / #vSlicingVal * 100, 0) == 1 then return false end
   end
   
   -- slicing dei setti
   SlicingExtraObjects( nRibsLay, vSlicingDir, vSlicingVal, nSlicingType, TYPE.RIB, RIBS_CRV, RIBS_GRP)

   -- se slicing multplanare verifico altezza massima e strand
   if nSlicingType == SLICING_TYPE.MULTIPLANAR or nSlicingType == SLICING_TYPE.MULTIPLANAR_DEG45 or nSlicingType == SLICING_TYPE.MULTIPLANAR_HOR then
      if dMaxH < GEO.INFINITO then
         local vLayIds = EgtGetNameInGroup( s_nPartId, SLICE_LAYER .. '*')
         for i = 1, #vLayIds do
            local nCurrRibsLay = EgtGetFirstNameInGroup( vLayIds[i], RIBS_GRP)
            local b3Box = EgtGetBBoxGlob( nCurrRibsLay, GDB_BB.STANDARD)
            local ptMax = b3Box:getMax() + dSliceStep * vSlicingDir[i]
            if ptMax:getZ() > dMaxH + GEO.EPS_SMALL then
               -- elimino tutti i layer da questo punto
               for j = i, #vLayIds do
                  EgtErase( vLayIds[j])
               end
               break
            end
         end
      end
      VerifyMultiPlanarStrand()
   end
   
   return true
end

---------------------------------------------------------------------
local function MultiPlanarSlicing( nStmId, dMaxH, vSlicingDir, vSlicingPnt)

   local dSliceStep = EgtGetInfo( s_nPartId, KEY_SLICE_STEP, 'd')
   -- ciclo sui piani di slicing calcolati
   local nFirstGrpId
   local nCnt = 0
   for i = 1, #vSlicingPnt do
      local vtN = vSlicingDir[i]
      local ptOn = vSlicingPnt[i]
      -- correzione per layer iniziale
      if i == 1 then
         ptOn = ptOn + DELTAZ * vtN
      end
      
      local nGrpId = EgtGroup( s_nPartId)
      if not nFirstGrpId then
         nFirstGrpId = nGrpId
      end
      local nEntId = EgtPlaneSurfTmInters( ptOn, vtN, nStmId, nGrpId, GDB_RT.GLOB, TOLER)
      -- eventuale verifica con altezza massima
      if dMaxH < GEO.INFINITO then
         local b3Box = EgtGetBBoxGlob( nGrpId, GDB_BB.STANDARD)
         local ptMax = b3Box:getMax() + dSliceStep * vtN
         if ptMax:getZ() > dMaxH + GEO.EPS_SMALL then
            EgtErase( nGrpId)
            break
         end
      end
      nCnt = i + 1
      -- aggiornamento progress ( per riconoscimento corretto della fase dal programma deve partire da 1)
      if EgtProcessEvents( max( 1, 100 * i / #vSlicingPnt), 0) == 1 then
         return nFirstGrpId, -1
      end
   end
   return nFirstGrpId, nCnt
end

---------------------------------------------------------------------
local function SlicingWithSolid( nStmId, nSlicingType, dMaxH, vSlicingVal, vSlicingDir)

   -- calcolo delle intersezioni
   local nLayId, nCnt
   if nSlicingType ~= SLICING_TYPE.MULTIPLANAR and nSlicingType ~= SLICING_TYPE.MULTIPLANAR_DEG45 and nSlicingType ~= SLICING_TYPE.MULTIPLANAR_HOR then
      if EgtProcessEvents( 1, 0) == 1 then return false end
      nLayId, nCnt = EgtParPlanesSurfTmInters( ORIG(), vSlicingDir[1], vSlicingVal, nStmId, s_nPartId, GDB_RT.GLOB, TOLER)
      if EgtProcessEvents( 100, 0) == 1 then return false end
   else
      nLayId, nCnt = MultiPlanarSlicing( nStmId, dMaxH, vSlicingDir, vSlicingVal)
      if nCnt == -1 then return false end
   end
   
   local vPrevCen = {}
   local nLayCnt = 1
   local nCounterTot = nCnt + 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
      
      EgtSetInfo( nLayId, KEY_SLICE_NBR, nLayCnt)
      
      -- ricavo punto e direzione del piano di slicing
      local dDeltaZ = EgtIf( nLayCnt == 1, DELTAZ, 0)
      local ptSlicing
      local vtSlicing
      if nSlicingType == SLICING_TYPE.MULTIPLANAR or nSlicingType == SLICING_TYPE.MULTIPLANAR_DEG45 or nSlicingType == SLICING_TYPE.MULTIPLANAR_HOR then
         -- nel caso multiplanare sono i dati di slicing
         vtSlicing = vSlicingDir[nLayCnt]
         ptSlicing = vSlicingVal[nLayCnt]
      else
         -- nel caso standard la direzione è è l'unico elemento del vettore direzioni ( visto che è comune a tutti i piani) mentre i valori sono le distanze dai piani da quello
         -- posto nell'origine
         vtSlicing = vSlicingDir[1]
         ptSlicing = ORIG() + ( vSlicingVal[nLayCnt] - dDeltaZ) * vtSlicing
      end
      EgtSetInfo( nLayId, KEY_SLICE_POS, ptSlicing)
      EgtSetInfo( nLayId, KEY_SLICE_DIR, vtSlicing)
      
      -- 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, - DELTAZ, DELTAZ)
         -- eseguo il ricalcolo solo a quella quota
         local ptOn = ptSlicing + dDeltaZ * vtSlicing
         EgtPlaneSurfTmInters( ptOn, 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)

      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
      for i = 1, #vClosedId do
         EgtModifyCurveExtrusion( vClosedId[i], vtSlicing, GDB_RT.GLOB)
         EgtApproxCurve( vClosedId[i], GDB_CA.ARCS, MID_TOLER)
      end
      local nSurfFR, nSrfNbr = EgtSurfFlatRegion( nLayId, vClosedId)
   
      if nSurfFR then
         
         -- se slicing del solido valido aggiorno i valori dei layer estremi che lo contengono
         if not nFirstSolidLay then nFirstSolidLay = nLayCnt end
         nLastSolidLay = nLayCnt
         
         -- 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')
            table.insert( s_vErr, nLayCnt)
         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, vSlicingDir, vSlicingVal, nSlicingType, TYPE.RIB, RIBS_CRV, RIBS_GRP, nStmId)
   if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( nCnt + 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
      if nSlicingType ~= SLICING_TYPE.MULTIPLANAR and nSlicingType ~= SLICING_TYPE.MULTIPLANAR_DEG45 and nSlicingType ~= SLICING_TYPE.MULTIPLANAR_HOR then
         PrepareInfill( nStmId, vSlicingDir[1])
      end
      if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( nCnt + 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, vSlicingDir, vSlicingVal, nSlicingType, TYPE.EXTRA_SHELL, SHELL_NBR_CRV, SHELL_NBR_GRP)
      if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( nCnt + 9) / nCounterTot * 100, 0) == 1 then return false end
      
      -- solidi ausiliari
      local nAuxSolidsLay = EgtGetFirstNameInGroup( s_nPartId, LAY_AUX_SOLIDS)
      SlicingExtraObjects( nAuxSolidsLay, vSlicingDir, vSlicingVal, nSlicingType, TYPE.AUX_SOLID, AUX_SOLIDS_CRV, AUX_SOLIDS_GRP)
      if nSlicingType ~= SLICING_TYPE.MULTIPLANAR and nSlicingType ~= SLICING_TYPE.MULTIPLANAR_DEG45 and nSlicingType ~= SLICING_TYPE.MULTIPLANAR_HOR then
         PrepareAuxSolidsInfill( nAuxSolidsLay, vSlicingDir[1])
      end
      if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( nCnt + 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)
   
   -- verifico se posso eliminare gli ultimi layer senza solido. Per poterlo fare non devono contenere setti esterni o unbounded
   local vLayers = EgtGetNameInGroup( s_nPartId, SLICE_LAYER .. '*')
   if #vLayers ~= nLastSolidLay then
      -- recupero l'ultimo layer con setti esterni
      local nLastLayerIdx
      for i = #vLayers, nLastSolidLay + 1, - 1 do
         if nLastLayerIdx then break end
         local nRibsGrp = EgtGetFirstNameInGroup( vLayers[i], RIBS_GRP)
         if nRibsGrp then
            local vRibs = EgtGetNameInGroup( nRibsGrp, RIBS_CRV .. '*')
            for j = 1, #vRibs do
               local nRibType = EgtGetInfo( vRibs[j], KEY_RIBS_TYPE, 'i')
               if nRibType == RIB_TYPE.EXTERNAL or nRibType == RIB_TYPE.UNBOUNDED then
                  nLastLayerIdx = i
                  break
               end
            end
         end
      end
      if not nLastLayerIdx then
         nLastLayerIdx = nLastSolidLay
      end
      -- cancello eventuali layers inutile
      for i = #vLayers, nLastLayerIdx + 1, -1 do
         EgtErase( vLayers[i])
      end
   end
   
   -- se multiplanare verifico strand massimo e minimo
   if nSlicingType == SLICING_TYPE.MULTIPLANAR or nSlicingType == SLICING_TYPE.MULTIPLANAR_DEG45 or nSlicingType == SLICING_TYPE.MULTIPLANAR_HOR then
      if not VerifyMultiPlanarStrand() then
         return false
      end
   end
   
   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()
   elseif nSlicingType == SLICING_TYPE.MULTIPLANAR or nSlicingType == SLICING_TYPE.MULTIPLANAR_DEG45 or nSlicingType == SLICING_TYPE.MULTIPLANAR_HOR then
      -- la direzione può cambiare da un piano all'altro
      vtSlicing = Z_AX()
   end

   EgtSetInfo( s_nPartId, KEY_SLICE_DIR, vtSlicing)
   -- per compatibilità con vecchie macchine
   EgtSetInfo( s_nPartId, 'SlicingDir', vtSlicing)
   
   -- recupero 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 nMaxSlicesNbr = EgtGetInfo( s_nPartId, KEY_MAX_SLICES_NBR, 'i') or 0
   if nMaxSlicesNbr == 0 then
      nMaxSlicesNbr = GEO.INFINITO   -- da gestire come caso illimitato
   end
   
   -- 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
   if bLimitUnbddRibs and not nStmId then
      EgtOutBox( "No solid to limit unbounded ribs!", 'Error', 'ERROR')
      return
   end
   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 #vRefIds == 0 then
      EgtOutBox( "No part to be sliced!", 'Error', 'ERROR')
      return false
   end

   -- calcolo i dati dello slicing
   local dMaxH = ComputeMaxH( vRefIds, vtSlicing, dSliceStep)
   local vSlicingVal = {}
   local vSlicingDir = {}
   if nSlicingType == SLICING_TYPE.MULTIPLANAR or nSlicingType == SLICING_TYPE.MULTIPLANAR_DEG45 or nSlicingType == SLICING_TYPE.MULTIPLANAR_HOR then
      vSlicingVal, vSlicingDir = ComputeMultiplanarSlicingData( dSliceStep, nMaxSlicesNbr, nSlicingType)
   else
      vSlicingVal, vSlicingDir = ComputeSlicingData( vRefIds, vtSlicing, dSliceStep, dMaxH, nMaxSlicesNbr)
   end
   if not vSlicingVal then
      return false
   end
   
   -- Eseguo slicing
   local bOk = true
   if not nStmId then
      -- caso senza solido e solo setti
      bOk = SlicingNoSolid( nRibsLay, nSlicingType, dMaxH, dSliceStep, vSlicingVal, vSlicingDir)
   else
      -- caso con solido
      bOk = SlicingWithSolid( nStmId, nSlicingType, dMaxH, vSlicingVal, vSlicingDir)
   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