-- CalcPaths.lua by Egaltech s.r.l. 2022/06/28
-- Calcolo percorsi di lavoro per Stampa 3d

-- Tabella per definizione modulo
local CalcPaths = {}

-- Intestazioni
require( 'EgtBase')

EgtOutLog( ' CalcPaths started', 1)

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

---------------------------------------------------------------------
local s_nPartId

---------------------------------------------------------------------
local function GetLayerParamsForPathCalc()   
   local LayerParams = {}   
   LayerParams.nShellsNbr = EgtGetInfo( s_nPartId, KEY_SHELLS_NBR, 'i') 
   LayerParams.dStrand = EgtGetInfo( s_nPartId, KEY_STRAND, 'd')
   LayerParams.dOffs = EgtGetInfo( s_nPartId, KEY_OFFSET_SLICE, 'd')
   LayerParams.nFloorNbr = EgtGetInfo( s_nPartId, KEY_FLOOR_NBR, 'i')
   LayerParams.vtSlicing = EgtGetInfo( s_nPartId, KEY_SLICING_DIR, 'v')
   -- parametri costolature
   LayerParams.dRibsOverlap = EgtGetInfo( s_nPartId, KEY_RIBS_OVERLAP, 'd')
   LayerParams.nRibsShellsNbr = EgtGetInfo( s_nPartId, KEY_RIBS_SHELLS_NBR, 'i')
   LayerParams.bRibsInvertOrder = EgtGetInfo( s_nPartId, KEY_RIBS_INVERT_ORDER, 'b')
   return LayerParams 
end

---------------------------------------------------------------------
local function GetLayerStartPoint( nLayId)
   
   local ptStart
   -- recupero il punto di partenza usato nel layer precedente
   local nPrev = EgtGetPrev( nLayId) 
   local nCrvGrp = EgtGetFirstNameInGroup( nPrev, CONTOUR_GRP..'*') 
   local nPathGrp = EgtGetFirstNameInGroup( nCrvGrp, PATH_GRP) 
   local nCrv = EgtGetFirstInGroup( nPathGrp) 
   if nCrv then 
      ptStart = EgtSP( nCrv, GDB_ID.ROOT)
   else
      ptStart = EgtGetInfo( s_nPartId, KEY_START_POINT, 'p')  
   end  
   return ptStart
end

---------------------------------------------------------------------
local function GetPathsFromSurf( nSrfId, sName, nType, nGrpId, nLayId)
   
   local nChunks = EgtSurfFrChunkCount( nSrfId) 
   for nC = 0, nChunks - 1 do 
      -- estraggo i contorni 
      local nCrvId, nCrvCnt = EgtExtractSurfFrChunkLoops( nSrfId, nC, nGrpId)
      for nInd = 0, nCrvCnt - 1 do
         EgtSetName( nCrvId + nInd, sName)
         EgtSetInfo( nCrvId + nInd, KEY_TYPE, nType)
         
         -- se è loop interno lo inverto per averlo orientato in senso antiorario 
         if nInd > 0 then
            EgtInvertCurve( nCrvId + nInd)
         end        
         
         -- verifico soddisfi i requisiti (lunghezza e area)
         local dLen = EgtCurveLength( nCrvId + nInd)
         local _ , _ , dArea = EgtCurveArea( nCrvId + nInd) 
         if dLen < MIN_LEN or dArea < MIN_AREA then
            EgtErase( nCrvId + nInd)
            return 
         end
         
         -- scelta start point 
         local ptStart = GetLayerStartPoint( nLayId)
         EgtChangeClosedCurveStartPoint( nCrvId + nInd, ptStart, GDB_RT.GLOB)
      end 
   end   
end

--------------------------------------------------------------------
local function AddFloor( nSrfId, nGrpId, LayerParams, nFloorNbr)
   
 --  local nSrfCopy = EgtCopyGlob( nSrfId, nGrpId)
 --  local dOffs = 0.5 * LayerParams.dStrand - LayerParams.dOffs + LayerParams.nShellsNbr * LayerParams.dStrand
 --  local dAng = 0
 --  
 --  if EgtSurfFrOffset( nSrfCopy, - dOffs) and EgtSurfFrChunkCount( nSrfCopy) > 0 then  
 --     local nCrvId, nCnt = EgtGetSurfFrZigZagInfill( nSrfCopy, nGrpId, LayerParams.dStrand + 10 * GEO.EPS_SMALL, dAng, false, false)
 --     for nInd = 0, nCnt - 1 do
 --        local dLen = EgtCurveLength( nCrvId + nInd)
 --        if dLen < MIN_LEN then
 --           EgtErase( nCrvId + nInd)
 --        else          
 --           EgtSetName( nCrvId + nInd, INFILL_CRV)
 --           EgtSetInfo( nCrvId + nInd, KEY_TYPE, TYPE.INFILL)
 --        end
 --     end
 --     EgtErase( nSrfCopy)
 --  end

end

--------------------------------------------------------------------
local function TrimRibsOffset( nCrv, nOffs1, nOffs2, nOffsGrp, bIn)

   local ptInt1 = EgtIP( nCrv, nOffs1, ORIG())
   local ptInt2 = EgtIP( nCrv, nOffs2, ORIG())
   local dPar1, dPar2
   if ptInt1 then dPar1 = EgtCurveParamAtPoint( nCrv, ptInt1) end
   if ptInt2 then dPar2 = EgtCurveParamAtPoint( nCrv, ptInt2) end   
   
   if dPar1 and dPar2 then
      -- la curva viene spezzata in tre parti
      if dPar1 > dPar2 then
         dPar1, dPar2 = dPar2, dPar1
      end
      local nCopy = EgtCopyGlob( nCrv, nOffsGrp)
      EgtTrimCurveEndAtParam( nCrv, dPar1)
      EgtTrimCurveStartAtParam( nCopy, dPar2)
      EgtSetInfo( nCopy, KEY_SPLIT_RIB, nCrv)

   elseif dPar1 or dPar2 then
      if bIn then
         EgtTrimCurveEndAtParam( nCrv, dPar1 or dPar2)
      else
         EgtTrimCurveStartAtParam( nCrv, dPar1 or dPar2)
      end
   end
end

--------------------------------------------------------------------
-- Funzione che sistema le intersezioni fra costolature nel caso generico
local function AdjustRibsOffsetForIntersection( nCrv1, nCrv2, LayerParams, nOffsGrp, bIn)
  
   -- calcolo gli offset della curva principale ( nCrv1) da usare per trim
   local dOffs = ( LayerParams.nRibsShellsNbr - 1) * LayerParams.dStrand / 2
   local nOffsM = EgtOffsetCurveAdv( nCrv1, - dOffs - ( 1 - LayerParams.dRibsOverlap / 100) * LayerParams.dStrand)
   local nOffsP = EgtOffsetCurveAdv( nCrv1, dOffs + ( 1 - LayerParams.dRibsOverlap / 100) * LayerParams.dStrand)
   local vSplit = {}
   
   -- recupero gli offset della curva secondaria ( nCrv2)
   local vOffs2 = EgtGetNameInGroup( nOffsGrp, EgtGetName( nCrv2))
   -- trim degli offset della curva secondaria
   for i = 1, #vOffs2 do
      TrimRibsOffset( vOffs2[i], nOffsM, nOffsP, nOffsGrp, bIn)
   end

   EgtErase( nOffsM)
   EgtErase( nOffsP)
end

--------------------------------------------------------------------
-- Funzione che sistema le intersezioni fra costolature nel caso di 2 passate 
local function AdjustRibsOffsetForIntersection2Shells( nCrv1, nCrv2, LayerParams, nOffsGrp, bIn) 
 
   -- recupero gli offset delle due curve
   local vOffs1 = EgtGetNameInGroup( nOffsGrp, EgtGetName( nCrv1))
   local vOffs2 = EgtGetNameInGroup( nOffsGrp, EgtGetName( nCrv2))
   
   local vCopy1 = {} 
   for i = 1, #vOffs1 do
      local nId = EgtCopyGlob( vOffs1[i], nOffsGrp)
      table.insert( vCopy1, nId)
   end

   -- trim degli offset di nCrv1
   for i = 1, #vOffs1 do
      -- trovo gli offset di nCrv2 coinvolti nell'intersezione
      local vIds = {}
      for j = 1, #vOffs2 do
         local ptInt = EgtIP( vOffs1[i], vOffs2[j], ORIG())
         if ptInt then table.insert( vIds, j) end
      end
      if #vIds > 0 then
         local bInCrv1 = false
         -- se viene trovata una sola intersezione devo calcolare bIn per nCrv1
         if  #vIds == 1 then 
            table.insert( vIds, EgtIf( vIds[1] == 1, 2, 1))
            local ptInt = EgtIP( nCrv1, nCrv2, ORIG())
            local dParInt = EgtCurveParamAtPoint( nCrv1, ptInt)
            local _, dParE = EgtCurveDomain( nCrv1)
            bInCrv1 = abs( dParInt - dParE) < 100 * GEO.EPS_SMALL
         end
         TrimRibsOffset( vOffs1[i], vOffs2[vIds[1]], vOffs2[vIds[2]], nOffsGrp, bInCrv1)
      end
      
   end
   -- trim degli offset di nCrv2
   for i = 1, #vOffs2 do 
      -- trovo gli offset di nCrv1 coinvolti nell'intersezione
      local vIds = {}
      for j = 1, #vCopy1 do
         local ptInt = EgtIP( vOffs2[i], vCopy1[j], ORIG())
         if ptInt then table.insert( vIds, j) end
      end
      if #vIds > 0 then
         if  #vIds == 1 then table.insert( vIds, EgtIf( vIds[1] == 1, 2, 1)) end
         TrimRibsOffset( vOffs2[i], vCopy1[vIds[1]], vCopy1[vIds[2]], nOffsGrp, bIn)
      end      
   end
   
   for i = 1, #vCopy1 do
      EgtErase( vCopy1[i])
   end
   
end
   
--------------------------------------------------------------------
local function HandleRibsIntersections( nRibsGrp, LayerParams, nOffsGrp, nRibsPathGrp)
   
   local nCrvGrp = EgtGetParent( nRibsPathGrp)
   local nSrf = EgtGetFirstInGroup( nCrvGrp)
   
   local vRibsIds = {}
   local vOrigRibs = EgtGetNameInGroup( nRibsGrp, RIBS_CRV .. '*')
   local nTrimmedRibsGrp = EgtGroup( nRibsPathGrp)
   for i = 1, #vOrigRibs do
      local nCopyId = EgtCopyGlob( vOrigRibs[i], nTrimmedRibsGrp)
      local nCrv, nCnt = EgtTrimCurveWithRegion( nCopyId, nSrf, true, false)
      for j = nCrv, nCrv + nCnt - 1 do
         table.insert( vRibsIds, j)
      end
      -- copio i suoi offset nel RibsPathGrp
      local vOffsRib = EgtGetNameInGroup( nOffsGrp, EgtGetName( vOrigRibs[i]))
      for i = 1, #vOffsRib do
         EgtCopyGlob( vOffsRib[i], nRibsPathGrp)
      end
   end
   
   local bInters = false 
   local vSplit = {}
   for i = 1, #vRibsIds do
      -- verifico se interseca uno dei setti successivi
      for j = i + 1, #vRibsIds do
         local ptInt = EgtIP( vRibsIds[i], vRibsIds[j], ORIG())
         if ptInt then
            bInters = true
            
            local dPar1 = EgtCurveParamAtPoint( vRibsIds[i], ptInt)
            local dPar2 = EgtCurveParamAtPoint( vRibsIds[j], ptInt)
            local _, dParE1 =  EgtCurveDomain( vRibsIds[i])
            local _, dParE2 =  EgtCurveDomain( vRibsIds[j])           
            
            local bIn = abs( dPar1 - dParE1) < 50 * GEO.EPS_SMALL or abs( dPar2 - dParE2) < 50 * GEO.EPS_SMALL
            local nCrv1 = vRibsIds[i]   -- curva principale che non viene tagliata
            local nCrv2 = vRibsIds[j]   -- curve secondaria da modificare
            if dPar1 < 50 * GEO.EPS_SMALL or abs( dPar1 - dParE1) < 50 * GEO.EPS_SMALL then
               nCrv1, nCrv2 = nCrv2, nCrv1
            end
            
            if LayerParams.nRibsShellsNbr == 2 then
               -- nel caso di 2 passate gestione speciale
               AdjustRibsOffsetForIntersection2Shells( nCrv1, nCrv2, LayerParams, nRibsPathGrp, bIn)
            else
               AdjustRibsOffsetForIntersection( nCrv1, nCrv2, LayerParams, nRibsPathGrp, bIn)
            end
         end
      end
   end
   
   EgtErase( nTrimmedRibsGrp)
   
   -- nel caso di intersezione sistemo i nomi in modo da gestire separatamente le costolature divise
   if bInters then 
      local vRibsNames = {}
      for i = 1, #vOrigRibs do
         local sName = EgtGetName( vOrigRibs[i])
         table.insert( vRibsNames, sName)
      end
      local kMax = tonumber( string.sub( vRibsNames[#vRibsNames], 4)) + 1
      
      for i = 1, #vRibsNames do
         local vIds = EgtGetNameInGroup( nRibsPathGrp, vRibsNames[i])         
         for j = 2, #vIds do
            local ptM = EgtMP( vIds[j])
            local dDist = EgtPointCurveDist( ptM, vIds[j-1])
            if abs( dDist - LayerParams.dStrand) < 10 * GEO.EPS_SMALL then
               -- se le costolatura è vicina alla precedente avrà lo stesso nome
               EgtSetName( vIds[j], EgtGetName( vIds[j-1]))
            else
               -- se la costolatura dista troppo dalla precedente le cambio il nome
               EgtSetName( vIds[j], RIBS_CRV .. tostring( kMax))
               kMax = kMax + 1
            end
         end
      end
   end

   return bInters
end

--------------------------------------------------------------------
-- Funzione che riordina le costolature nel caso generico
local function ReorderRibs( nGrp, bInvertOrder, nShells)
   
   EgtSpInit()
   local vIds = EgtGetNameInGroup( nGrp, RIBS_CRV .. '*')
   local vSplitRibs = {}
   for i = 1, #vIds do
      local nInfo = EgtGetInfo( vIds[i], KEY_SPLIT_RIB, 'i')
      -- se è ottenuto dalla divisione di una costolatura non va considerato per il TSP ( viene aggiunto in seguito)
      if nInfo and nShells == 1 then
         table.insert( vSplitRibs, vIds[i])
      else
         local pt = EgtMP( vIds[i], GDB_RT.GLOB)
         EgtSpAddPoint( pt:getX(), pt:getY(), pt:getZ(), 0, 0, pt:getX(), pt:getY(), pt:getZ(), 0, 0)
      end
   end
   local vOrd, dLen = EgtSpCalculate( SHP_TY.OPEN)
   EgtSpTerminate()
   
   EgtRelocateGlob( vIds[vOrd[1]], nGrp, EgtIf( bInvertOrder, GDB_IN.LAST, GDB_IN.FIRST))
   for i = 2, #vOrd do
      EgtRelocateGlob( vIds[vOrd[i]], vIds[vOrd[i-1]], EgtIf( bInvertOrder, GDB_IN.BEFORE, GDB_IN.AFTER))
   end
   
   -- aggiusto tutte le costolature divise
   for i = 1, #vSplitRibs do
      local nPrevId = EgtGetInfo( vSplitRibs[i], KEY_SPLIT_RIB, 'i')
      -- aggiungo come successiva alla costolatura da cui si è generata
      EgtRelocateGlob( vSplitRibs[i], nPrevId, GDB_IN.AFTER)
   end
   
end

---------------------------------------------------------------------------------------------
-- Funzione che riordina le costolature nel caso di intersezioni e 2 passate
local function ReorderRibsInters2Shells( nOffsGrp, dStrand)
   
   local vOffs = EgtGetNameInGroup( nOffsGrp, RIBS_CRV .. '*')
   -- concateno le curve
   local nCrv, nCnt = EgtCurveCompoByChain( nOffsGrp, vOffs, ORIG())
   
   local vIds = {}
   for i = nCrv, nCrv + nCnt - 1 do
      EgtSetInfo( i, KEY_TYPE, TYPE.RIB)
      table.insert( vIds, i)
   end

   local k = 0   -- indice da utilizzare per i nomi
   while #vIds > 0 do
      k = k + 1
      -- prendo la prima tra le curve a disposizione
      nCurrCrv = vIds[1]
      table.remove( vIds, 1)
      EgtSetName( nCurrCrv, RIBS_CRV .. tostring(k))      
      local pt = EgtEP( nCurrCrv)
      local nCnt = 0
      -- scorro alla ricerca di una curva che posso collegare alla corrente
      while nCurrCrv do
         local bFound = false
         for j = 1, #vIds do
            if vIds[j] ~= nCrv then 
               local ptS = EgtSP( vIds[j])
               local ptE = EgtEP( vIds[j])
               
               local bAddNoInvert = dist( pt, ptS) < dStrand + 10 * GEO.EPS_SMALL
               local bAddWithInvert = dist( pt, ptE) < dStrand + 10 * GEO.EPS_SMALL
               if bAddNoInvert or bAddWithInvert then
                  bFound = true
                  nCnt = nCnt + 1
                  EgtRelocateGlob( vIds[j], nCurrCrv, GDB_IN.AFTER)
                  EgtSetName( vIds[j], RIBS_CRV .. tostring( k))
                  -- eventuale inversione della curva
                  if bAddWithInvert then EgtInvertCurve( vIds[j]) end
                  
                  -- aggiorno per collegamento successivo
                  pt = EgtIf( bAddNoInvert, ptE, ptS)
                  nCurrCrv = vIds[j]
                  -- elimino la curva dal vettore di curve da considerare
                  table.remove( vIds, j)
                  break
               end
            end
         end
         -- se non ho più curve da collegare
         if not bFound then
            -- se il percorso è fatto da una sola curva, riprovo a cercare collegamenti invertendola
            if nCnt == 0 then
               EgtInvertCurve( nCurrCrv)
               pt = EgtEP( nCurrCrv)
               nCnt = 1  -- per evitare di finire in un loop 
            else
               nCurrCrv = nil
            end
         end 
      end
   end
end

--------------------------------------------------------------------
local function CalcRibsPaths( nSliceGrp, nRibsGrp, LayerParams, nStmId)

   -- calcolo gli offset
   local dOffs = ( LayerParams.nRibsShellsNbr - 1) * LayerParams.dStrand / 2
   local nOffsGrp = EgtGroup( nRibsGrp)
   local vRibs = EgtGetNameInGroup( nRibsGrp, RIBS_CRV .. '*')
   for i = 1, #vRibs do
      for k = 0, LayerParams.nRibsShellsNbr - 1 do
         local nNewId = EgtOffsetCurveAdv( vRibs[i], - dOffs + k * LayerParams.dStrand)
         EgtSetName( nNewId, EgtGetName( vRibs[i]))
         EgtSetInfo( nNewId, KEY_TYPE, TYPE.RIB)
         EgtRelocateGlob( nNewId, nOffsGrp)
      end
   end
   
   -- scorro i gruppi di curve
   local nCrvGrp = EgtGetFirstNameInGroup( nSliceGrp, CONTOUR_GRP .. '*')
   while nCrvGrp do
      local nRibsPathGrp = EgtGetFirstNameInGroup( nCrvGrp, RIBS_GRP)
      local nSrf = EgtGetFirstNameInGroup( nRibsPathGrp, LAYER_SRF)
      if nSrf then         
         -- gestisco eventuali intersezioni fra costolature
         local bInters = HandleRibsIntersections( nRibsGrp, LayerParams, nOffsGrp, nRibsPathGrp)
         EgtSetInfo( nRibsPathGrp or GDB_ID.NULL, KEY_RIBS_INTERS, bInters)
         
         -- riordino le costolature
         if LayerParams.nRibsShellsNbr == 2 and bInters then
            -- gestione caso speciale di intersezione e 2 passate
            ReorderRibsInters2Shells( nRibsPathGrp, LayerParams.dStrand)
         else
            ReorderRibs( nRibsPathGrp, LayerParams.bRibsInvertOrder, LayerParams.nRibsShellsNbr)
         end
         
         -- eseguo il trim delle costole con la regione offsettata
         local vErased = {}
         local vOrderedRibs = EgtGetNameInGroup( nRibsPathGrp, RIBS_CRV .. '*')
         for i = 1, #vOrderedRibs do            
            local nCrv, nCnt = EgtTrimCurveWithRegion( vOrderedRibs[i], nSrf, true, false)            
            if nCnt == 0 then
               -- lo aggiungo nella tabella delle costolature eliminate
               vErased[vOrderedRibs[i]] = 1 
            end
            -- elimino tratti troppo corti
            for nId = nCrv, nCrv + nCnt - 1 do
               local dLen = EgtCurveLength( nId)
               if dLen < 10 * MIN_LEN then
                  EgtErase( nId)
                  -- lo aggiungo nella tabella delle costolature eliminate
                  vErased[vOrderedRibs[i]] = 1
               else
                  local nInfo = EgtGetInfo( nId, KEY_SPLIT_RIB, 'i')
                  -- se la costolatura da cui deriva è stata eliminata, tolgo l'info che le associava
                  if nInfo and vErased[nInfo] then
                     EgtRemoveInfo( nId, KEY_SPLIT_RIB)
                  end
               end
            end
         end
      end

      if not EgtGetFirstNameInGroup( nRibsPathGrp, RIBS_CRV .. '*') then 
         EgtErase( nRibsPathGrp) 
      end
      nCrvGrp = EgtGetNextName( nCrvGrp, CONTOUR_GRP .. '*')
   end
end

---------------------------------------------------------------------
function CalcPaths.Exec( nPartId, nStmId)
   
   s_nPartId = nPartId

   local vLayIds = EgtGetNameInGroup( s_nPartId, SLICE_LAYER.."*") 
   if not vLayIds then
      EgtOutBox( 'Error no slice', 'PathCalc')
     return 
   end

   -- recupero i parametri per calcolo dei path
   local LayerParams = GetLayerParamsForPathCalc()
   -- scorro tutti i suoi layer
   for nIdx = 1, #vLayIds do
      
      local nRibsGrp = EgtGetFirstNameInGroup( vLayIds[nIdx], RIBS_GRP)
     
      -- scorro tutti i gruppi di contorni
      local nCrvGrpId = EgtGetFirstNameInGroup( vLayIds[nIdx], CONTOUR_GRP.."*") or GDB_ID.NULL
      while nCrvGrpId ~= GDB_ID.NULL do
         
         -- verifico se il path e il solido sono già stati calcolati
         local nGrpId = EgtGetFirstNameInGroup( nCrvGrpId, PATH_GRP) or GDB_ID.NULL
         if nGrpId == GDB_ID.NULL then
            nGrpId = EgtGroup( nCrvGrpId)
            EgtSetName( nGrpId, PATH_GRP)
         else
            EgtEmptyGroup( nGrpId)
            EgtSetStatus( nGrpId, GDB_ST.ON)
         end
         local nSolidGrpId = EgtGetFirstNameInGroup( nCrvGrpId, SOLID_GRP) or GDB_ID.NULL
         if nSolidGrpId ~= GDB_ID.NULL then
            EgtErase( nSolidGrpId)
         end
         
         -- recupero la superficie ottenuta dallo slicing
         local nSrf = EgtGetFirstNameInGroup( nCrvGrpId, LAYER_SRF)         
         if nSrf then
            -- esterno
            local nSrfId = EgtCopyGlob( nSrf, nCrvGrpId)
            local dOffs = 0.5 * LayerParams.dStrand - LayerParams.dOffs
            local bOk = EgtSurfFrOffset( nSrfId, -dOffs) 
            local bExists = EgtSurfFrChunkCount( nSrfId) > 0
            if not bOk then
               EgtErase( nSrfId)
               nSrfId = EgtCopyGlob( nSrf, nCrvGrpId)
               local dNewOffs = dOffs - 0.05
               bOk = EgtSurfFrOffset( nSrfId, -dNewOffs) 
               bExists = EgtSurfFrChunkCount( nSrfId) > 0
            end
            -- se offset riuscito, estraggo i contorni (pareti esterne)
            if not bOk then
               EgtOutLog( 'Error on ExtOffset (layer '..tostring( nIdx)..') - CalcPaths')
            elseif not bExists then
               EgtOutLog( 'Warning : ExtOffset not possible (layer '..tostring( nIdx)..') - CalcPaths')
            else
               GetPathsFromSurf( nSrfId, SHELL_CRV..'0', TYPE.OUTER_SHELL, nGrpId, vLayIds[nIdx])
            end
            EgtErase( nSrfId)
            
            -- calcolo pareti interne
            for nInd2 = 1, LayerParams.nShellsNbr - 1 do
               -- offset della superficie originale
               local nSrfId = EgtCopy( nSrf, nGrpId)
               local bOk = EgtSurfFrOffset( nSrfId, - dOffs - nInd2 * LayerParams.dStrand)
               local bExists = EgtSurfFrChunkCount( nSrfId) > 0
               if not bOk then
                  EgtErase( nSrfId)
                  nSrfId = EgtCopyGlob( nSrf, nCrvGrpId)
                  bOk = EgtSurfFrOffset( nSrfId, -dOffs + 0.05 - nInd2 * LayerParams.dStrand) 
                  bExists = EgtSurfFrChunkCount( nSrfId) > 0
               end
               -- se offset riuscito, estraggo i contorni ( pareti interne)
               if not bOk then
                  EgtOutLog( 'Error on IntOffset (layer '..tostring( nIdx)..') - CalcPaths')
               elseif not bExists then
                  EgtOutLog( 'Warning : IntOffset not possible (layer '..tostring( nIdx)..') - CalcPaths')
               else
                  GetPathsFromSurf( nSrfId, SHELL_CRV..tostring( nInd2), TYPE.INNER_SHELL, nGrpId, vLayIds[nIdx])                
               end
               EgtErase( nSrfId)
            end
            
            -- costolature
            if nRibsGrp then
               
               -- creo o svuoto il gruppo per le costolature
               local nRibsPathGrp = EgtGetFirstNameInGroup( nCrvGrpId, RIBS_GRP)
               if not nRibsPathGrp then
                  nRibsPathGrp = EgtGroup( nCrvGrpId)
                  EgtSetName( nRibsPathGrp, RIBS_GRP)
                  EgtSetStatus( nRibsPathGrp, GDB_ST.OFF)
               else
                  EgtEmptyGroup( nRibsPathGrp)
               end
         
               -- calcolo superficie di offset da usare per le costolature
               local nSrfId = EgtCopy( nSrf, nRibsPathGrp)
               local dOffs = 0.5 * LayerParams.dStrand - LayerParams.dOffs + ( LayerParams.nShellsNbr - 1) * LayerParams.dStrand + ( 1 - LayerParams.dRibsOverlap / 100) * LayerParams.dStrand
               local bOk = EgtSurfFrOffset( nSrfId, - dOffs)
               local bExists = ( bOk and EgtSurfFrChunkCount( nSrfId) > 0)
               if not bOk then
                  EgtErase( nSrfId)
                  nSrfId = EgtCopyGlob( nSrf, nRibsPathGrp)
                  bOk = EgtSurfFrOffset( nSrfId, - dOffs + 0.05)
                  bExists = ( bOk and EgtSurfFrChunkCount( nSrfId) > 0)
               end
               -- se non ho una superficie errore ed elimino il gruppo delle costolature
               if not bOk then
                  EgtErase( nRibsPathGrp)
                  EgtOutLog( 'Error on Offset (Ribs) (layer '..tostring( nIdx)..') - CalcPaths')
               elseif not bExists then
                  EgtErase( nRibsPathGrp)
                  EgtOutLog( 'Warning : Ribs not possible (layer '..tostring( nIdx)..') - CalcPaths')
               end
               
            end
            
            -- gestione eventuale floor 
            if nIdx <= LayerParams.nFloorNbr then
               AddFloor( nSrf, nGrpId, LayerParams, nIdx)
            end
         end
         
         -- passo al gruppo di contorni successivo
         nCrvGrpId = EgtGetNextName( nCrvGrpId, CONTOUR_GRP.."*") or GDB_ID.NULL
      end

      -- sistemo eventuali costolature
      if nRibsGrp then
         CalcRibsPaths( vLayIds[nIdx], nRibsGrp, LayerParams, nStmId)
      end
      
      if EgtProcessEvents( nIdx / #vLayIds * 100, 0) == 1 then
         EgtDraw()
         return 
      end
   end
end


---------------------------------------------------------------------
return CalcPaths