3dprinting/LuaLibs/CalcPaths.lua

-- 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 ReorderRibs( nGrp, bInvertOrder)
   
   EgtSpInit()
   local vIds = EgtGetNameInGroup( nGrp, RIBS_CRV .. '*')
   for i = 1, #vIds do
      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
   local vOrd, dLen = EgtSpCalculate( SHP_TY.OPEN)
   EgtSpTerminate()
   
   local vOrderedRibs = {}
   if bInvertOrder then
      for i = #vOrd, 1, -1 do
         table.insert( vOrderedRibs, vIds[vOrd[i]])
      end
   else
      for i = 1, #vOrd do
         table.insert( vOrderedRibs, vIds[vOrd[i]])
      end
   end
   
   return vOrderedRibs  
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   
  
   -- riordino costolature 
   local vOrderedRibs = ReorderRibs( nOffsGrp, LayerParams.bRibsInvertOrder)
   -- 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
         for i = 1, #vOrderedRibs do
            local nNewId = EgtCopyGlob( vOrderedRibs[i], nRibsPathGrp)
            -- trim delle costole con la regione offsettata
            local nCrv, nCnt = EgtTrimCurveWithRegion( nNewId, nSrf, true, false)
            -- elimino tratti troppo corti
            for nId = nCrv, nCrv + nCnt - 1 do
               local dLen = EgtCurveLength( nId) 
               if dLen < MIN_LEN then
                  EgtErase( nId)
               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) and EgtSurfFrChunkCount( nSrfId) > 0)
            if not bOk then
               EgtErase( nSrfId)
               nSrfId = EgtCopyGlob( nSrf, nCrvGrpId)
               local dNewOffs = dOffs - 0.05
               bOk = ( EgtSurfFrOffset( nSrfId, -dNewOffs) 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])
            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])
               else
                  EgtOutLog( 'Error on IntOffset (layer '..tostring( nIdx)..') - CalcPaths')
               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