-- CalcSlices.lua by Egaltech s.r.l. 2022/03/30
-- 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 function GetSliceStep()
   local nParamsGrp = EgtGetFirstNameInGroup( GDB_ID.ROOT, PARAMS_GRP) 
   local dStep = EgtGetInfo( nParamsGrp, KEY_SLICE_STEP, 'd')
   return dStep 
end

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

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

   -- costanti
   local TOLER = 0.2 
   local SMALL_TOLER = 0.02
   local BIG_TOLER = 2.0
   local MIN_LEN = 20.0
   local MIN_AREA = 25.0

   -- recupero il box della superficie 
   local b3Box = EgtGetBBoxRef( nStmId, GDB_BB.STANDARD, EgtGetGridFrame())
   if not b3Box or b3Box:isEmpty() then
      EgtOutText( 'La superficie selezionata è vuota')
      EgtPause( 1000)
      return
   end

   -- Parametri di slicing
   local dZmin = b3Box:getMin():getZ()
   local dZmax = b3Box:getMax():getZ()
   dZmax = min( dZmax, dZmin + HMax)
   ---dZmin = 740
   ---dZmax = 741

   -- se slicing già presente lo cancello
   for i = 1, 2 do
      local sFind = EgtIf( i == 1, '', '__') .. SLICE_LAYER  .. "*"
      local nOldSliceId = EgtGetFirstNameInGroup( nPartId, sFind)
      while nOldSliceId do
         EgtErase( nOldSliceId)
         nOldSliceId = EgtGetFirstNameInGroup( nPartId, sFind)
      end
   end

   -- Eseguo slicing
   local nLayCnt = 1 
   local nRecalc = 0
   local dDeltaZStart = 0.2 
   local vZSlices = ComputeZSlices( dZmin, dDeltaZStart, dZmax)
   local nLayId = EgtParPlanesSurfTmInters( Z_AX(), ORIG(), vZSlices, nStmId, nPartId, GDB_RT.GLOB, TOLER) 
   
   -- 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)
      EgtSetInfo( nLayId, KEY_SLICE_NBR, nLayCnt)      
      
      -- verifico se necessario ricalcolo 
      local nId = EgtGetLastInGroup( nLayId) 
      local bRecalc = not nId 
      local vtRecalc
      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      
      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( Point3d( 0, 0, dPosZ + dDeltaZ), Z_AX(), nStmId, nLayId, GDB_RT.GLOB, TOLER)         
      end

      -- 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, Vector3d( 0, 0, -dDeltaZ))
            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

      -- 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
         EgtApproxCurve( vClosedId[i], GDB_CA.ARCS, SMALL_TOLER)
      end   
      local nSurfFR, nSrfNbr = EgtSurfFlatRegion( nLayId, vClosedId)
      for i = 1, #vClosedId do
         EgtErase( vClosedId[i])
      end
   
      if nSurfFR then 
         local nCrv = 0 
         for j = 0, nSrfNbr - 1 do 
            -- analizzo i singoli chunks
            local nSfrId, nSfrCnt = EgtExplodeSurf( nSurfFR + j)
            for nId = nSfrId, nSfrId + nSfrCnt - 1 do
               -- per ogni chunk creo un gruppo di percorsi 
               local nGrpCrv = EgtGroup( nLayId)
               EgtSetName( nGrpCrv, CONTOUR_GRP .. EgtNumToString( nCrv, 1))
               nCrv = nCrv + 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)
                  EgtSetColor( nId2, 'BLACK')
               end
            end            
         end
      else
         -- errore
         EgtSetName( nLayId, '__' .. SLICE_LAYER .. EgtNumToString( nLayCnt))
      end  

      -- passo al layer successivo 
      nLayCnt = nLayCnt + 1 
      nLayId = EgtGetNext( nLayId)
   end
end

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