3dprinting/LuaLibs/CalcPaths.lua

-- CalcPaths.lua by Egaltech s.r.l. 2022/04/13
-- 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 function GetLayerParamsForPathCalc()   
   local nParamsGrp = EgtGetFirstNameInGroup( GDB_ID.ROOT, PARAMS_GRP)
   local LayerParams = {}   
   LayerParams.nShellsNbr = EgtGetInfo( nParamsGrp, KEY_SHELLS_NBR, 'i') 
   LayerParams.dStrand = EgtGetInfo( nParamsGrp, KEY_STRAND, 'd')
   LayerParams.dOffs = EgtGetInfo( nParamsGrp, KEY_OFFSET_SLICE, 'd')
   LayerParams.nFloorNbr = EgtGetInfo( nParamsGrp, KEY_FLOOR_NBR, 'i')
   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
      local nParamsGrp = EgtGetFirstNameInGroup( GDB_ID.ROOT, PARAMS_GRP)
      ptStart = EgtGetInfo( nParamsGrp, KEY_START_POINT, 'p')  
   end  
   return ptStart
end

---------------------------------------------------------------------
local function GetPathsFromSurf( nSrfId, sName, nType, nGrpId, nLayId, dStrand)
   
   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

---------------------------------------------------------------------
function CalcPaths.Exec( nPartId)
   
   local vLayIds = EgtGetNameInGroup( 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    

      -- 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) and EgtSurfFrChunkCount( nSrfId) > 0)
            if not bOk then
               EgtErase( nSrfId)
               nSrfId = EgtCopyGlob( nSrf, nCrvGrpId)
               bOk = ( EgtSurfFrOffset( nSrfId, -dOffs + 0.05) and EgtSurfFrChunkCount( nSrfId) > 0)
            end
            -- se offset riuscito, estraggo i contorni (pareti esterne)
            if bOk then
               GetPathsFromSurf( nSrfId, SHELL_CRV..'0', TYPE.OUTER_SHELL, nGrpId, vLayIds[nIdx], LayerParams.dStrand)               
            else
               EgtOutLog( 'Error on ExtOffset (layer '..tostring( nIdx)..') - CalcPaths')
            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) and EgtSurfFrChunkCount( nSrfId) > 0) 
               if not bOk then
                  EgtErase( nSrfId)
                  nSrfId = EgtCopyGlob( nSrf, nCrvGrpId)
                  bOk = ( EgtSurfFrOffset( nSrfId, -dOffs + 0.05 - nInd2 * LayerParams.dStrand) and EgtSurfFrChunkCount( nSrfId) > 0)
               end
               -- se offset riuscito, estraggo i contorni ( pareti interne)
               if bOk then
                  GetPathsFromSurf( nSrfId, SHELL_CRV..tostring( nInd2), TYPE.INNER_SHELL, nGrpId, vLayIds[nIdx], LayerParams.dStrand)
               else
                  EgtOutLog( 'Error on IntOffset (layer '..tostring( nIdx)..') - CalcPaths')
               end
               EgtErase( nSrfId)
            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

      if EgtProcessEvents( nIdx / #vLayIds * 100, 0) == 1 then
         EgtDraw()
         return 
      end

   end
end


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