DataBeam/LuaLibs/ProcessLongDoubleCut.lua

-- ProcessLongDoubleCut.lua by Egaltech s.r.l. 2019/03/22
-- Gestione calcolo doppio taglio longitudinale per Travi

-- Tabella per definizione modulo
local ProcessLong2Cut = {}

-- Include
require( 'EgtBase')

EgtOutLog( ' ProcessLongDoubleCut started', 1)

-- Dati
local BD = require( 'BeamData')
local Millings = require( 'MillingData')

---------------------------------------------------------------------
-- Riconoscimento della feature
function ProcessLong2Cut.Identify( Proc)
   return ( Proc.Grp == 0  and  Proc.Prc == 12)
end

---------------------------------------------------------------------
-- Classificazione della feature
function ProcessLong2Cut.Classify( Proc)
   -- verifico le normali delle facce
   local nFacetCnt = EgtSurfTmFacetCount( Proc.Id)
   for i = 1, nFacetCnt do
      local vtN = EgtSurfTmFacetNormVersor( Proc.Id, i-1, GDB_ID.ROOT)
      if vtN:getZ() < - 0.707 then
         return true, true
      end
   end
   return true, false
end

---------------------------------------------------------------------
local function FindMilling( sType)
   for i = 1, #Millings do
      local Milling = Millings[i]
      if Milling.Type == sType then
         return i, Milling.Name
      end   
   end
   return 0
end

---------------------------------------------------------------------
-- Applicazione della lavorazione
function ProcessLong2Cut.Make( Proc, nPhase, nRawId, nPartId)
   -- dati delle facce
   local ptC = {}
   local vtN = {}
   ptC[1], vtN[1] = EgtSurfTmFacetCenter( Proc.Id, 0, GDB_ID.ROOT)
   ptC[2], vtN[2] = EgtSurfTmFacetCenter( Proc.Id, 1, GDB_ID.ROOT)
   local dLen = EgtGetBBoxGlob( Proc.Id, GDB_BB.STANDARD):getDimX()
   -- verifico che il doppio taglio longitudinale non sia orientato verso il basso
   if vtN[1]:getZ() < - 0.707 or vtN[2]:getZ() < - 0.707 then
      local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' Longitudinal Double Cut from bottom impossible'
      EgtOutLog( sErr)
      return false, sErr
   end
   -- verifico se sopra o sui lati
   local bTop = ( vtN[1]:getZ() > 0 and vtN[2]:getZ() > 0)
   -- angolo diedro per stabilire se taglio convesso
   local _, ptP1, ptP2, dAng = EgtSurfTmFacetsContact( Proc.Id, 0, 1, GDB_ID.ROOT)
   local ptM = ( ptP1 + ptP2) / 2
   local bConvex = ( dAng >= 0)
   -- analisi del taglio
   local vOrd = {}
   local vFaceUse = {}
   if bTop then
      vOrd = EgtIf( ptC[1]:getY() < ptM:getY(), { 1, 2}, { 2, 1})
      vFaceUse = {[vOrd[1]] = MCH_MILL_FU.ORTHO_BACK, [vOrd[2]] = MCH_MILL_FU.ORTHO_FRONT}
   else
      local bFront = ( vtN[1]:getY() < 0)
      if bFront then
         vOrd = EgtIf( ptC[1]:getZ() < ptM:getZ(), { 1, 2}, { 2, 1})
         vFaceUse = {[vOrd[1]] = MCH_MILL_FU.ORTHO_TOP, [vOrd[2]] = MCH_MILL_FU.ORTHO_DOWN}
      else
         vOrd = EgtIf( ptC[1]:getZ() < ptM:getZ(), { 2, 1}, { 1, 2})
         vFaceUse = {[vOrd[1]] = MCH_MILL_FU.ORTHO_DOWN, [vOrd[2]] = MCH_MILL_FU.ORTHO_TOP}
      end
   end
   local vWidth = {}
   local vtDiff1 = ptC[vOrd[1]] - ptM
   vWidth[vOrd[1]] = 2 * sqrt( vtDiff1:getY() * vtDiff1:getY() + vtDiff1:getZ() * vtDiff1:getZ())
   local vtDiff2 = ptC[vOrd[2]] - ptM
   vWidth[vOrd[2]] = 2 * sqrt( vtDiff1:getY() * vtDiff1:getY() + vtDiff1:getZ() * vtDiff1:getZ())
   -- recupero la lavorazione
   local nMill, sMilling = FindMilling( 'Long2Cut')
   if not sMilling then
      local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' milling not found in library'
      EgtOutLog( sErr)
      return false, sErr
   end
   -- recupero i dati dell'utensile
   local dMillDiam = 0
   local dMaxDepth = 0
   if EgtMdbSetCurrMachining( sMilling) then
      local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
      if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
         dMillDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dMillDiam
         dMaxDepth = EgtTdbGetCurrToolMaxDepth() or dMaxDepth
      end
   end
   -- determino il numero di parti in cui dividere la lavorazione
   local dEndLen = BD.LONGCUT_ENDLEN
   if dLen < 2 * dEndLen + BD.LONGCUT_MAXLEN then
      dEndLen = dLen / 3
   end
   local nC = ceil( ( dLen - 2 * dEndLen) / BD.LONGCUT_MAXLEN)
   local dC = 0
   if nC > 0 then dC = ( dLen - 2 * dEndLen) / nC end
   nC = nC + 2
   -- ciclo sulle parti
   local nM = 0
   for j = 1, nC do
      -- su entrambe le facce
      for i = 1, 2 do
         -- Limitazioni della lavorazione
         local nPos = EgtIf( i == 1, j, nC - j + 1)
         local dSal = EgtIf( nPos == 1, 0, - dEndLen - ( nPos - 2) * dC)
         local dEal = EgtIf( nPos == nC, 0, - dEndLen - ( nC - nPos - 1) * dC)
         -- Posizione braccio portatesta
         local nSCC = EgtIf( ( j == 1 or j == nC - 1), MCH_SCC.ADIR_XP, MCH_SCC.ADIR_XM)
         -- ciclo sulle passate
         local nO = 1
         local dStep = 0
         if vWidth[vOrd[i]] > 0.75 * dMillDiam then 
            nO = ceil( vWidth[vOrd[i]] * 2 / dMillDiam)
            dStep = vWidth[vOrd[i]] / nO
         end
         for k = 1, nO do
            -- determino direzione di movimento
            local bToLeft = ( i == 1)
            -- inserisco le parti di lavorazione
            nM = nM + 1
            local sNameF = 'L2C_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) .. '_' .. tostring( nM)
            local nMchFId = EgtAddMachining( sNameF, sMilling)
            if not nMchFId then
               local sErr = 'Error adding machining ' .. sNameF .. '-' .. sMilling
               EgtOutLog( sErr)
               return false, sErr
            end
            -- aggiungo geometria
            EgtSetMachiningGeometry( {{ Proc.Id, vOrd[i] - 1}})
            -- limito opportunamente la lavorazione
            EgtSetMachiningParam( MCH_MP.STARTADDLEN, dSal)
            EgtSetMachiningParam( MCH_MP.ENDADDLEN, dEal)
            -- imposto posizione braccio porta testa per non ingombrare agli estremi
            EgtSetMachiningParam( MCH_MP.SCC, nSCC)
            -- imposto uso faccia
            EgtSetMachiningParam( MCH_MP.FACEUSE, vFaceUse[vOrd[i]])
            -- imposto lato di lavoro e inversione
            EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT)
            EgtSetMachiningParam( MCH_MP.INVERT, false)
            -- imposto offset radiale (nullo se concavo)
            if k < nO then
               EgtSetMachiningParam( MCH_MP.OFFSR, ( nO - k) * dStep)
            else
               EgtSetMachiningParam( MCH_MP.OFFSR, EgtIf( bConvex, - BD.CUT_EXTRA, 0))
            end
            -- eseguo
            if not EgtApplyMachining( true, false) then
               local _, sErr = EgtGetLastMachMgrError()
               EgtSetOperationMode( nMchFId, false)
               return false, sErr
            end
         end
      end
   end
   return true
end   

---------------------------------------------------------------------
return ProcessLong2Cut