DataBeam/LuaLibs/ProcessCut.lua

-- ProcessCut.lua by Egaltech s.r.l. 2019/09/04
-- Gestione calcolo singoli tagli di lama per Travi

-- Tabella per definizione modulo
local ProcessCut = {}

-- Include
require( 'EgtBase')
local BL = require( 'BeamLib')
local DC = require( 'DiceCut')

EgtOutLog( ' ProcessCut started', 1)

-- Dati
local BD = require( 'BeamData')
local ML = require( 'MachiningLib')

---------------------------------------------------------------------
-- Riconoscimento della feature
function ProcessCut.Identify( Proc)
   return ( ( Proc.Grp == 1 or Proc.Grp == 2)  and  Proc.Prc == 10)
end

---------------------------------------------------------------------
-- Classificazione della feature
function ProcessCut.Classify( Proc, b3Raw)
   local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, 0, GDB_ID.ROOT)
   if vtN:getZ() <= - 0.5 and abs( vtN:getY()) > 0.1 then
      local _, DimH, DimV = BL.GetFaceHvRefDim( Proc.Id, 0)
      if DimH > BD.MAX_DIM_DICE then
         return true, true
      end
   end
   return true, false
end

---------------------------------------------------------------------
-- Applicazione della lavorazione
function ProcessCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
   -- ingombro del grezzo
   local b3Raw = EgtGetRawPartBBox( nRawId)
   -- ingombro del pezzo
   local Ls = EgtGetFirstNameInGroup( nPartId, 'Box')
   local b3Solid = EgtGetBBoxGlob( Ls or GDB_ID.NULL, GDB_BB.STANDARD)
   if not b3Solid then
      local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' part box not found'
      EgtOutLog( sErr)
      return false, sErr
   end
   -- dati geometrici del taglio
   local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, 0, GDB_ID.ROOT)
   local bDownCut = (vtN:getZ() <= - 0.5)
   -- se taglio di testa
   if Proc.Head then
      -- se coincide con il taglio di separazione precedente, non va fatto
      if AreSameVectorApprox( vtN, X_AX())  and  abs( ptC:getX() - b3Raw:getMax():getX() + dOvmHead) < 10 * GEO.EPS_SMALL then
         return true
      end
   -- altrimenti taglio di coda
   else
      -- se coincide con taglio di separazione, non va fatto
      if AreSameVectorApprox( vtN, - X_AX())  and  abs( ptC:getX() - b3Raw:getMin():getX()) < BD.OVM_MID + 10 * GEO.EPS_SMALL then
         return true
      end
   end
   -- recupero la lavorazione
   local sCutting = ML.FindCutting( EgtIf( Proc.Head, 'HeadSide', 'TailSide'))
   if not sCutting then
      local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' cutting not found in library'
      EgtOutLog( sErr)
      return false, sErr
   end
   -- recupero i dati dell'utensile
   local dSawDiam = 400
   local dMaxDepth = 0
   if EgtMdbSetCurrMachining( sCutting) then
      local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
      if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
         dSawDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dSawDiam
         dMaxDepth = EgtTdbGetCurrToolMaxDepth() or dMaxDepth
      end
   end
   -- determino la direzione di taglio preferenziale
   local _, dCutH, dCutV = BL.GetFaceHvRefDim( Proc.Id, 0)
   local bHorizCut = (( dCutV < dMaxDepth + 10 * GEO.EPS_SMALL and dCutH > dCutV + 10 * GEO.EPS_SMALL) and not bDownCut)
   -- verifico se necessari tagli supplementari
   local vCuts = DC.GetDice( EgtGetParent( Proc.Id), b3Solid, ptC, vtN, true)
   --DC.PrintOrderCut( vCuts)
   if #vCuts > 0 then
      -- recupero gruppo per geometria addizionale
      local nAddGrpId = BL.GetAddGroup( nPartId)
      if not nAddGrpId then
         local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' missing AddGroup'
         EgtOutLog( sErr)
         return false, sErr
      end
      -- sistemo posizione nel DB e nome
      for i = 1, #vCuts do
         for j = 1, #vCuts[i] do
            EgtRelocateGlob( vCuts[i][j], nAddGrpId)
            EgtSetName( vCuts[i][j], 'AddCut_' .. tostring( Proc.Id))
            EgtSetInfo( vCuts[i][j], 'TASKID', Proc.TaskId)
         end
      end
      -- recupero la normale dei tagli ortogonali
      local vtO
      for i = 1, #vCuts, 2 do
         for j = 1, #vCuts[i] do
            _, vtO = EgtSurfTmFacetCenter( vCuts[i][j], 0, GDB_ID.ROOT)
            break
         end
         if vtO then break end
      end
      -- eseguo
      for i = 1, #vCuts do
         -- determino il modo di tagliare
         local vtOrthoO
         if vtO then
            if i % 2 == 1 then
               vtOrthoO = vtN
            else
               if #vCuts[i-1] > 0 then
                  vtOrthoO = vtO
               else
                  vtOrthoO = Z_AX()
               end
            end
         else
            if bHorizCut then
               vtOrthoO = Z_AX()
            elseif vtN:getY() > -0.02 then
               vtOrthoO = Y_AX()
            else
               vtOrthoO = -Y_AX()
            end
         end
         -- lavoro la faccia
         for j = 1, #vCuts[i] do
            -- se taglio dal basso
            if bDownCut then
               -- se strato pari composto da 1 o 2 elementi
               if i % 2 == 0 and #vCuts[i] <= 2 then
                  -- il primo elemento prende la direzione prevista, il secondo quella opposta
                  local vtNewOrthoO = vtOrthoO
                  if j ~= 1 then
                     vtNewOrthoO = -vtOrthoO
                  end
                  local bOk, sErr = BL.MakeOneFaceBySaw( vCuts[i][j], 0, sCutting, dSawDiam, vtNewOrthoO, nil, 0.1, BD.CUT_SIC, 0, 0, nil, b3Raw)
                  if not bOk then
                     return bOk, sErr
                  end
               end
               -- tutti gli altri casi vengono saltati
            -- caso generale
            else
               local bOk, sErr = BL.MakeOneFaceBySaw( vCuts[i][j], 0, sCutting, dSawDiam, vtOrthoO, nil, -0.5, BD.CUT_SIC, 0, 0, nil, b3Raw)
               if not bOk then
                  return bOk, sErr
               end
            end
         end
      end
   -- altrimenti tagli diretti della faccia
   else
      -- lavoro la faccia
      local vtOrthoO
      if bHorizCut then
         vtOrthoO = Z_AX()
      elseif vtN:getY() > -0.02 then
         vtOrthoO = Y_AX()
      else
         vtOrthoO = -Y_AX()
      end
      local bOk, sErr = BL.MakeOneFaceBySaw( Proc.Id, 0, sCutting, dSawDiam, vtOrthoO, nil, BD.CUT_EXTRA, BD.CUT_SIC, 0, 0, nil, b3Raw)
      if not bOk then
         return bOk, sErr
      end
   end
   -- eventuale segnalazione ingombro di testa o coda
   if abs( vtN:getY()) > 0.1 or ( b3Raw:getDimZ() - Proc.Box:getDimZ()) < BD.MIN_HEIGHT then
      if Proc.Head then
         local dOffs = b3Raw:getMax():getX() - dOvmHead - Proc.Box:getMin():getX()
         if vtN:getZ() > 0.5 then
            dOffs = dOffs / 2
         end
         BL.UpdateHCING( nRawId, dOffs)
      elseif Proc.Tail then
         local dOffs = Proc.Box:getMax():getX() - b3Raw:getMin():getX()
         if vtN:getZ() > 0.5 then
            dOffs = dOffs / 2
         end
         BL.UpdateTCING( nRawId, dOffs)
      end
   end
   return true
end

---------------------------------------------------------------------
return ProcessCut