Egalware/DataBeam
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
03e256a2f2b1fa5ca7385607ab02f123b6838f4e
DataBeam/LuaLibs/BeamExec.lua
T
Dario Sassi 6eaba8a577 DataBeam : 
- primo rilascio.
2019-04-01 15:18:51 +00:00

738 lines
31 KiB
Lua
Raw Blame History

-- BeamExec.lua by Egaltech s.r.l. 2019/01/07
-- Libreria esecuzione lavorazioni per Travi
-- Tabella per definizione modulo
local BeamExec = {}
-- Include
require( 'EgtBase')
-- Carico i dati globali e libero tutti gli altri
_G.package.loaded.BeamData = nil
_G.package.loaded.CutData = nil
_G.package.loaded.MillingData = nil
_G.package.loaded.PocketingData = nil
_G.package.loaded.DrillData = nil
local BD = require( 'BeamData')
-- Carico le librerie
_G.package.loaded.BeamLib = nil
local BL = require( 'BeamLib')
_G.package.loaded.DiceCut = nil
local DC = require( 'DiceCut')
_G.package.loaded.TwoFacesBySaw = nil
local DC = require( 'TwoFacesBySaw')
_G.package.loaded.ProcessHeadCut = nil
local Hcut= require( 'ProcessHeadCut')
_G.package.loaded.ProcessSplit = nil
local Split = require( 'ProcessSplit')
_G.package.loaded.ProcessCut = nil
local Cut = require( 'ProcessCut')
_G.package.loaded.ProcessDoubleCut = nil
local DoubleCut = require( 'ProcessDoubleCut')
_G.package.loaded.ProcessLongCut = nil
local LongCut = require( 'ProcessLongCut')
_G.package.loaded.ProcessLongDoubleCut = nil
local Long2Cut = require( 'ProcessLongDoubleCut')
_G.package.loaded.ProcessBirdsMouth = nil
local BirdsMouth = require( 'ProcessBirdsMouth')
_G.package.loaded.ProcessRidgeLap = nil
local RidgeLap = require( 'ProcessRidgeLap')
_G.package.loaded.ProcessLapJoint = nil
local LapJoint = require( 'ProcessLapJoint')
_G.package.loaded.ProcessChamfer = nil
local Chamfer = require( 'ProcessChamfer')
_G.package.loaded.ProcessPocket = nil
local Pocket = require( 'ProcessPocket')
_G.package.loaded.ProcessDrill = nil
local Drill = require( 'ProcessDrill')
_G.package.loaded.ProcessTenon = nil
local Tenon = require( 'ProcessTenon')
_G.package.loaded.ProcessMortise = nil
local Mortise = require( 'ProcessMortise')
_G.package.loaded.ProcessDtTenon = nil
local DtTenon = require( 'ProcessDtTenon')
_G.package.loaded.ProcessDtMortise = nil
local DtMortise = require( 'ProcessDtMortise')
_G.package.loaded.ProcessMark = nil
local Mark = require( 'ProcessMark')
_G.package.loaded.ProcessText = nil
local Text = require( 'ProcessText')
_G.package.loaded.ProcessSimpleScarf = nil
local Scarf = require( 'ProcessSimpleScarf')
_G.package.loaded.ProcessProfFront = nil
local ProfFront = require( 'ProcessProfFront')
_G.package.loaded.ProcessProfConcave = nil
local ProfConcave = require( 'ProcessProfConcave')
_G.package.loaded.ProcessProfConvex = nil
local ProfConvex = require( 'ProcessProfConvex')
_G.package.loaded.ProcessProfCamb = nil
local ProfCamb = require( 'ProcessProfCamb')
_G.package.loaded.ProcessProfHead = nil
local ProfHead = require( 'ProcessProfHead')
_G.package.loaded.ProcessRoundArch = nil
local RoundArch = require( 'ProcessRoundArch')
_G.package.loaded.ProcessFreeContour = nil
local FreeContour = require( 'ProcessFreeContour')
_G.package.loaded.ProcessDecor = nil
local Decor = require( 'ProcessDecor')
EgtOutLog( ' BeamExec started', 1)
-------------------------------------------------------------------------------------------------------------
-- *** Inserimento delle travi nel grezzo ***
-------------------------------------------------------------------------------------------------------------
function BeamExec.ProcessBeams( dRawW, dRawH, dRawL, dOvmHead, vBeam)
-- Determinazione minimo grezzo scaricabile
if dRawW * dRawH > 40000 then
BD.MinRaw = BD.MINRAW_L
elseif dRawW * dRawH > 14500 then
BD.MinRaw = BD.MINRAW_M
else
BD.MinRaw = BD.MINRAW_S
end
-- Creazione nuovo gruppo di lavoro
local sMgName = EgtGetMachGroupNewName( 'Mach_1')
local NewMgId = EgtAddMachGroup( sMgName)
if not NewMgId then
local sOut = 'Errore nella creazione del gruppo di lavoro ' .. sMgName
return false, sOut
end
-- Impostazione della tavola
EgtSetTable( 'Tab')
-- Area tavola
local b3Tab = EgtGetTableArea()
-- Calcolo posizione estremo TR della tavola rispetto a sua origine in BL
BD.OriTR = Point3d( b3Tab:getDimX(), b3Tab:getDimY(), 0)
-- Impostazione dell'attrezzaggio di default
EgtImportSetup()
-- Inserimento dei pezzi con il loro grezzo
local Cnt = 0
local Len = dRawL
local DeltaS = dOvmHead
local DeltaE = BD.OVM_MID
for i = 1, #vBeam do
-- assegno identificativo pezzo
local Pz = vBeam[i].Id
-- dati del pezzo
local b3Part = EgtGetBBoxGlob( Pz or GDB_ID.NULL, GDB_BB.EXACT)
local b3Solid = vBeam[i].Box
if b3Part:isEmpty() or b3Solid:isEmpty() then break end
EgtOutLog( 'PartSez=' .. EgtNumToString( b3Part:getDimY(), 1) .. 'x' .. EgtNumToString( b3Part:getDimZ(), 1), 3)
-- se sezione compatibile e lunghezza disponibile sufficiente
local PartLen = b3Solid:getDimX()
local PartWidth = b3Solid:getDimY()
local PartHeight = b3Solid:getDimZ()
local NextLen = Len - DeltaS - DeltaE - PartLen
if (( abs( PartWidth - dRawW) < 10 * GEO.EPS_SMALL and abs( PartHeight - dRawH) < 10 * GEO.EPS_SMALL) or
( abs( PartHeight - dRawW) < 10 * GEO.EPS_SMALL and abs( PartWidth - dRawH) < 10 * GEO.EPS_SMALL)) and
NextLen >= 0 then
-- dimensioni del grezzo
local CrawLen = PartLen + DeltaS + DeltaE
local Delta = DeltaE
-- creo e posiziono il grezzo
local nRaw = EgtAddRawPart( Point3d(0,0,0), CrawLen, dRawW, dRawH, BD.RAWCOL)
EgtMoveToCornerRawPart( nRaw, BD.OriTR, MCH_CR.TR)
EgtMoveRawPart( nRaw, Vector3d( Len - dRawL, 0, 0))
-- assegno ordine in lavorazione
Cnt = Cnt + 1
EgtSetInfo( nRaw, 'ORD', Cnt)
-- creo o pulisco gruppo geometrie aggiuntive
if not BL.CreateOrEmptyAddGroup( Pz) then
local sOut = 'Error creating Additional Group in Part ' .. tostring( Pz)
return false, sOut
end
-- se primo pezzo con sovramateriale, aggiungo faccia per taglio iniziale al pezzo
if i == 1 and dOvmHead > 1. then
BL.AddPartStartFace( Pz, b3Solid)
EgtSetInfo( nRaw, 'HOVM', DeltaS)
end
-- aggiungo faccia per taglio finale al pezzo
BL.AddPartEndFace( Pz, b3Solid)
-- inserisco il pezzo nel grezzo
EgtDeselectPartObjs( Pz)
local ptPos = b3Part:getMin() - b3Solid:getMin() + Vector3d( Delta, ( dRawW - PartWidth) / 2, ( dRawH - PartHeight) / 2)
EgtAddPartToRawPart( Pz, ptPos, nRaw)
if abs( PartWidth - dRawW) > 10 * GEO.EPS_SMALL then
-- rotazione attorno a centro geometria complessiva del pezzo
EgtRotatePartInRawPart( Pz, X_AX(), 90)
-- correggo per eccentricità solido rispetto a geometria complessiva del pezzo
local vtEccOri = b3Solid:getCenter() - b3Part:getCenter()
local vtEccRot = Vector3d( vtEccOri)
vtEccRot:rotate( X_AX(), 90)
EgtMovePartInRawPart( Pz, ( vtEccOri - vtEccRot))
end
-- aggiorno la lunghezza residua della barra
Len = Len - CrawLen
end
-- se rimasto troppo poco grezzo, esco
if Len < BD.MinRaw then break end
DeltaS = 0
end
-- Se rimasto materiale aggiungo grezzo dell'avanzo
if Len > 10 then
local nRaw = EgtAddRawPart( Point3d(0,0,0), Len, dRawW, dRawH, BD.RAWCOL)
EgtMoveToCornerRawPart( nRaw, BD.OriTR, MCH_CR.TR)
EgtMoveRawPart( nRaw, Vector3d( Len - dRawL, 0, 0))
-- assegno ordine in lavorazione
Cnt = Cnt + 1
EgtSetInfo( nRaw, 'ORD', Cnt)
end
return true
end
-------------------------------------------------------------------------------------------------------------
-- *** Inserimento delle lavorazioni nelle travi ***
-------------------------------------------------------------------------------------------------------------
local function IsHeadFeature( Proc, b3Raw, dCurrOvmH)
-- feature sempre di testa o coda per il gruppo
if Proc.Grp == 1 or Proc.Grp == 2 then
return ( Proc.Box:getCenter():getX() > b3Raw:getCenter():getX())
end
-- feature sempre di testa o coda nonostante il gruppo
if ( Proc.Grp == 3 or Proc.Grp == 4) and
( Proc.Prc == 51 or Proc.Prc == 56 or Proc.Prc == 100 or Proc.Prc == 101 or Proc.Prc == 102 or Proc.Prc == 103 or Proc.Prc == 106) then
return ( Proc.Box:getCenter():getX() > b3Raw:getCenter():getX())
end
-- gestioni speciali
if BirdsMouth.Identify( Proc) then
return BirdsMouth.IsHeadFeature( Proc, b3Raw, dCurrOvmH)
end
if LapJoint.Identify( Proc) then
return LapJoint.IsHeadFeature( Proc, b3Raw, dCurrOvmH)
end
if Drill.Identify( Proc) then
return Drill.IsHeadFeature( Proc, b3Raw, dCurrOvmH)
end
if RoundArch.Identify( Proc) then
return RoundArch.IsHeadFeature( Proc, b3Raw, dCurrOvmH)
end
if FreeContour.Identify( Proc) then
return FreeContour.IsHeadFeature( Proc, b3Raw, dCurrOvmH)
end
-- non è di testa
return false
end
-------------------------------------------------------------------------------------------------------------
local function IsTailFeature( Proc, b3Raw)
-- feature sempre di testa o coda per il gruppo
if Proc.Grp == 1 or Proc.Grp == 2 then
return ( Proc.Box:getCenter():getX() < b3Raw:getCenter():getX())
end
-- feature sempre di testa o coda nonostante il gruppo
if ( Proc.Grp == 3 or Proc.Grp == 4) and
( Proc.Prc == 51 or Proc.Prc == 56 or Proc.Prc == 100 or Proc.Prc == 101 or Proc.Prc == 102 or Proc.Prc == 103 or Proc.Prc == 106) then
return ( Proc.Box:getCenter():getX() < b3Raw:getCenter():getX())
end
-- gestioni speciali
if BirdsMouth.Identify( Proc) then
return BirdsMouth.IsTailFeature( Proc, b3Raw)
end
if LapJoint.Identify( Proc) then
return LapJoint.IsTailFeature( Proc, b3Raw)
end
if RoundArch.Identify( Proc) then
return RoundArch.IsTailFeature( Proc, b3Raw)
end
if Drill.Identify( Proc) then
return Drill.IsTailFeature( Proc, b3Raw)
end
if FreeContour.Identify( Proc) then
return FreeContour.IsTailFeature( Proc, b3Raw)
end
-- non è di coda
return false
end
-------------------------------------------------------------------------------------------------------------
local function CollectFeatures( PartId, b3Raw, dCurrOvmH)
-- recupero le feature
local vProc = {}
local LayerId = {}
LayerId[1] = BL.GetAddGroup( PartId)
LayerId[2] = EgtGetFirstNameInGroup( PartId or GDB_ID.NULL, 'Processings')
for nInd = 1, 2 do
local ProcId = EgtGetFirstInGroup( LayerId[nInd] or GDB_ID.NULL)
while ProcId do
local nEntType = EgtGetType( ProcId)
if nEntType == GDB_TY.SRF_MESH or nEntType == GDB_TY.EXT_TEXT or
nEntType == GDB_TY.CRV_LINE or nEntType == GDB_TY.CRV_ARC or nEntType == GDB_TY.CRV_BEZ or nEntType == GDB_TY.CRV_COMPO then
local nGrp = EgtGetInfo( ProcId, 'GRP', 'i')
local nPrc = EgtGetInfo( ProcId, 'PRC', 'i')
local nDo = EgtGetInfo( ProcId, 'DO', 'i') or 1
if nGrp and nPrc and nDo == 1 then
local Proc = {}
Proc.Id = ProcId
Proc.Grp = nGrp
Proc.Prc = nPrc
Proc.Flg = 1
Proc.Box = EgtGetBBoxGlob( ProcId, GDB_BB.STANDARD)
Proc.Fct = EgtSurfTmFacetCount( ProcId) or 0
Proc.Head = IsHeadFeature( Proc, b3Raw, dCurrOvmH)
Proc.Tail = IsTailFeature( Proc, b3Raw)
Proc.Fcs = 0
Proc.Fce = 0
table.insert( vProc, Proc)
-- se foro
if Drill.Identify( Proc) then
-- assegno faccia di entrata e uscita (dati tabelle sempre per riferimento)
Proc.Fcs = EgtGetInfo( Proc.Id, 'FCS', 'i') or 0
Proc.Fce = EgtGetInfo( Proc.Id, 'FCE', 'i') or 0
-- verifico se necessaria seconda lavorazione da parte opposta per foro più lungo della punta
if Drill.Split( Proc) then
-- aggiorno flag prima parte foro (dati tabelle sempre per riferimento)
Proc.Flg = 2
-- definisco dati seconda parte
local Proc2 = {}
Proc2.Id = ProcId
Proc2.Grp = nGrp
Proc2.Prc = nPrc
Proc2.Flg = -2
Proc2.Box = BBox3d( Proc.Box)
Proc2.Fct = Proc.Fct
Proc2.Head = Proc.Head
Proc2.Tail = Drill.IsTailFeature( Proc2, b3Raw)
Proc2.Fcs = Proc.Fce
Proc2.Fce = Proc.Fcs
table.insert( vProc, Proc2)
end
end
end
end
ProcId = EgtGetNext( ProcId)
end
end
return vProc
end
-------------------------------------------------------------------------------------------------------------
local function OrderFeatures( vProc, b3Raw)
-- funzione di confronto
-- secondo centro box in X (taglio di intestazione prima di altri tagli di testa e taglio di separazione però prima di altri tagli di coda)
local function CompareFeatures( B1, B2)
-- se primo è feature di testa e l'altro è intestazione
if B1.Head and Hcut.Identify( B2) then
return false
end
-- se secondo è feature di testa e l'altro è intestazione
if B2.Head and Hcut.Identify( B1) then
return true
end
-- se primo è feature di coda e l'altro è separazione o non è feature di coda
if B1.Tail and ( Split.Identify( B2) or not B2.Tail) then
return false
end
-- se secondo è feature di coda e l'altro è separazione o non è feature di coda
if B2.Tail and ( Split.Identify( B1) or not B1.Tail) then
return true
end
-- se primo è foro e l'altro no, lo penalizzo
if B1.Prc == 40 and B2.Prc ~= 40 then
return B1.Box:getCenter():getX() - 300 > B2.Box:getCenter():getX()
end
-- se secondo è foro e l'altro no, lo penalizzo
if B2.Prc == 40 and B1.Prc ~= 40 then
return B1.Box:getCenter():getX() + 300 > B2.Box:getCenter():getX()
end
-- se sono fori e hanno posizione praticamente uguale ordino secondo la faccia di inizio (Fcs)
if B1.Prc == 40 and B2.Prc == 40 and abs( B1.Box:getCenter():getX() - B2.Box:getCenter():getX()) < 300 then
if B1.Fcs == B2.Fcs then
return B1.Box:getCenter():getX() > B2.Box:getCenter():getX()
else
return B1.Fcs > B2.Fcs
end
end
-- se primo è taglio longitudinale completo, dopo tutte le altre feature non di coda
if abs( B1.Box:getDimX() - b3Raw:getDimX()) < 100.0 then
return B1.Box:getMin():getX() + 200.0 > B2.Box:getCenter():getX()
end
-- se secondo è taglio longitudinale completo, dopo tutte le altre feature non di coda
if abs( B2.Box:getDimX() - b3Raw:getDimX()) < 100.0 then
return B1.Box:getCenter():getX() > B2.Box:getMin():getX() + 200.0
end
-- se entrambi tenoni e si intersecano, metto prima tenone vero e poi base tenone
if Tenon.Identify( B1) and Tenon.Identify( B2) and
B1.Box:getMin():getX() < B2.Box:getMax():getX() + 100 * GEO.EPS_SMALL and B2.Box:getMin():getX() < B1.Box:getMax():getX() + 100 * GEO.EPS_SMALL then
return ( B1.Prc == 50 and B2.Prc == 52)
end
-- confronto standard
if abs( B1.Box:getCenter():getX() - B2.Box:getCenter():getX()) > 1.0 then
return B1.Box:getCenter():getX() > B2.Box:getCenter():getX()
elseif abs( B1.Box:getCenter():getY() - B2.Box:getCenter():getY()) > 1.0 then
return B1.Box:getCenter():getY() > B2.Box:getCenter():getY()
else
return B1.Box:getCenter():getZ() > B2.Box:getCenter():getZ()
end
end
-- eseguo ordinamento
table.sort( vProc, CompareFeatures)
end
-------------------------------------------------------------------------------------------------------------
local function ClassifyFeatures( vProc, b3Raw)
local bAllOk = true
local bSomeDown = false
local nHeading
for i = 1, #vProc do
local Proc = vProc[i]
local bOk = true
local bDown = false
-- se intestatura
if Hcut.Identify( Proc) then
nHeading = i
-- se doppio taglio
elseif DoubleCut.Identify( Proc) then
bOk, bDown = DoubleCut.Classify( Proc)
-- se taglio longitudinale
elseif LongCut.Identify( Proc) then
bOk, bDown = LongCut.Classify( Proc)
-- se doppio taglio longitudinale
elseif Long2Cut.Identify( Proc) then
bOk, bDown = Long2Cut.Classify( Proc)
-- se tacca
elseif BirdsMouth.Identify( Proc) then
bOk, bDown = BirdsMouth.Classify( Proc)
-- se mezzo-legno di testa
elseif RidgeLap.Identify( Proc) then
bOk, bDown = RidgeLap.Classify( Proc)
-- se mezzo-legno
elseif LapJoint.Identify( Proc) then
bOk, bDown = LapJoint.Classify( Proc)
-- se tasca
elseif Pocket.Identify( Proc) then
bOk, bDown = Pocket.Classify( Proc)
-- se foratura
elseif Drill.Identify( Proc) then
bOk, bDown = Drill.Classify( Proc, b3Raw)
-- se tenone
elseif Tenon.Identify( Proc) then
bOk, bDown = Tenon.Classify( Proc)
-- se mortasa (anche frontale)
elseif Mortise.Identify( Proc) then
bOk, bDown = Mortise.Classify( Proc)
-- se tenone a coda di rondine
elseif DtTenon.Identify( Proc) then
bOk, bDown = DtTenon.Classify( Proc)
-- se mortasa a coda di rondine (anche frontale)
elseif DtMortise.Identify( Proc) then
bOk, bDown = DtMortise.Classify( Proc)
-- se marcatura
elseif Mark.Identify( Proc) then
bOk, bDown = Mark.Classify( Proc)
-- se testo
elseif Text.Identify( Proc) then
bOk, bDown = Text.Classify( Proc)
-- se giunto Gerber
elseif Scarf.Identify( Proc) then
bOk, bDown = Scarf.Classify( Proc)
-- se arco
elseif RoundArch.Identify( Proc) then
bOk, bDown = RoundArch.Classify( Proc)
-- se contorno libero
elseif FreeContour.Identify( Proc) then
bOk, bDown = FreeContour.Classify( Proc)
-- se decorazione
elseif Decor.Identify( Proc) then
bOk, bDown = Decor.Classify( Proc)
end
-- assegno risultato
if bOk then
-- non ammessa feature di testa o di coda da lavorare ribaltata
if ( Proc.Head or Proc.Tail) and bDown then
Proc.On = false
Proc.Down = true
bAllOk = false
-- caso normale
else
Proc.On = true
Proc.Down = bDown
if bDown then bSomeDown = true end
end
else
Proc.On = false
bAllOk = false
end
end
-- se necessario ribaltamento, assegno intestatura alla fase ribaltata
if bSomeDown and nHeading then
vProc[nHeading].Down = true
end
return bAllOk, bSomeDown
end
-------------------------------------------------------------------------------------------------------------
local function PrintFeatures( vProc, b3Raw)
EgtOutLog( ' RawBox=' .. tostring( b3Raw))
for i = 1, #vProc do
EgtOutLog( ' Proc=' .. string.format( '%3d', vProc[i].Id) .. ' Grp=' .. string.format( '%1d', vProc[i].Grp) .. ' Prc=' .. string.format( '%3d', vProc[i].Prc) ..
' On=' .. EgtIf( vProc[i].On, 'T', 'F') .. ' Flg=' .. string.format( '%2d', vProc[i].Flg) .. ' Fcse=' .. string.format( '%1d,%1d', vProc[i].Fcs, vProc[i].Fce) ..
' Down=' .. EgtIf( vProc[i].Down, 'T', 'F') .. ' Head=' .. EgtIf( vProc[i].Head, 'T', 'F') .. ' Tail=' .. EgtIf( vProc[i].Tail, 'T', 'F') ..
' Fct=' .. string.format( '%2d', vProc[i].Fct) .. ' Box=' .. tostring( vProc[i].Box))
end
return vProc
end
-------------------------------------------------------------------------------------------------------------
local function AddFeatureMachining( Proc, nPhase, nRawId, nPartId, dCurrOvmH, b3Raw)
local bOk = true
local sErr = ''
local bNewPhase = false
-- se intestatura ( 1-340-X )
if Hcut.Identify( Proc) then
-- esecuzione taglio di testa
bOk, sErr = Hcut.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
-- se separazione ( 2-350-X )
elseif Split.Identify( Proc) then
-- esecuzione separazione o eliminazione grezzo residuo
bOk, _, sErr = Split.Make( Proc, nPhase, nRawId, nPartId)
-- richiedo il passaggio alla seconda fase di lavorazione di questa trave
bNewPhase = true
-- se taglio ( 1/2-010-X)
elseif Cut.Identify( Proc) then
-- esecuzione taglio
bOk, sErr = Cut.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
-- se doppio taglio ( 1/2-011-X)
elseif DoubleCut.Identify( Proc) then
-- se due facce, eseguo doppio taglio
if Proc.Fct == 2 then
bOk, sErr = DoubleCut.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
-- altrimenti eseguo singolo taglio
else
bOk, sErr = Cut.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
end
-- se taglio longitudinale ( 0/3/4-010-X)
elseif LongCut.Identify( Proc) then
-- esecuzione taglio longitudinale
bOk, sErr = LongCut.Make( Proc, nPhase, nRawId, nPartId)
-- se doppio taglio longitudinale ( 0-012-X)
elseif Long2Cut.Identify( Proc) then
-- se due facce, eseguo doppio taglio longitudinale
if Proc.Fct == 2 then
bOk, sErr = Long2Cut.Make( Proc, nPhase, nRawId, nPartId)
-- altrimenti eseguo singolo taglio longitudinale
else
bOk, sErr = LongCut.Make( Proc, nPhase, nRawId, nPartId)
end
-- se tacca ( 3/4-020-X)
elseif BirdsMouth.Identify( Proc) then
-- esecuzione tacca
bOk, sErr = BirdsMouth.Make( Proc, nPhase, nRawId, nPartId)
-- se mezzo-legno di testa ( 1/2-030-X)
elseif RidgeLap.Identify( Proc) then
-- esecuzione mezzo-legno di testa
bOk, sErr = RidgeLap.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
-- se mezzo-legno ( 3/4-030-X) o scanalatura ( 3/4-016-X)
elseif LapJoint.Identify( Proc) then
-- esecuzione mezzo-legno o scanalatura
bOk, sErr = LapJoint.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
-- se smusso ( 3/4-036-X)
elseif Chamfer.Identify( Proc) then
-- esecuzione smusso
bOk, sErr = Chamfer.Make( Proc, nPhase, nRawId, nPartId)
-- se tasca ( 4-039-X) o ( 3/4-032-X)
elseif Pocket.Identify( Proc) then
-- esecuzione tasca
bOk, sErr = Pocket.Make( Proc, nPhase, nRawId, nPartId)
-- se foratura ( 3/4-040-X)
elseif Drill.Identify( Proc) then
-- esecuzione foratura
bOk, sErr = Drill.Make( Proc, nPhase, nRawId, nPartId)
-- se tenone ( 1/2-050-X)
elseif Tenon.Identify( Proc) then
-- esecuzione tenone
bOk, sErr = Tenon.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
-- se mortasa ( 3/4-050-X) anche frontale ( 3/4-051-X)
elseif Mortise.Identify( Proc) then
-- esecuzione mortasa
bOk, sErr = Mortise.Make( Proc, nPhase, nRawId, nPartId)
-- se tenone a coda di rondine ( 1/2-055-X)
elseif DtTenon.Identify( Proc) then
-- esecuzione tenone
bOk, sErr = DtTenon.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
-- se mortasa a coda di rondine ( 3/4-055-X) anche frontale ( 3/4-056-X)
elseif DtMortise.Identify( Proc) then
-- esecuzione mortasa
bOk, sErr = DtMortise.Make( Proc, nPhase, nRawId, nPartId)
-- se marcatura ( 3/4-060-X)
elseif Mark.Identify( Proc) then
-- esecuzione marcatura
bOk, sErr = Mark.Make( Proc, nPhase, nRawId, nPartId)
-- se testo ( 4-061-X)
elseif Text.Identify( Proc) then
-- esecuzione testo
bOk, sErr = Text.Make( Proc, nPhase, nRawId, nPartId)
-- se giunto Gerber ( 1/2-070-X)
elseif Scarf.Identify( Proc) then
-- esecuzione giunto Gerber
bOk, sErr = Scarf.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
-- se profilo Front ( 3/4-100-X)
elseif ProfFront.Identify( Proc) then
-- esecuzione profilo
bOk, sErr = ProfFront.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
-- se profilo concavo ( 3/4-101-X)
elseif ProfConcave.Identify( Proc) then
-- esecuzione profilo
bOk, sErr = ProfConcave.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
-- se profilo convesso ( 3/4-102-X)
elseif ProfConvex.Identify( Proc) then
-- esecuzione profilo
bOk, sErr = ProfConvex.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
-- se profilo caudato ( 3/4-103-X)
elseif ProfCamb.Identify( Proc) then
-- esecuzione profilo
bOk, sErr = ProfCamb.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
-- se arco ( 4-104-X)
elseif RoundArch.Identify( Proc) then
-- esecuzione arco
bOk, sErr = RoundArch.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
-- se profilo Head ( 3/4-106-X)
elseif ProfHead.Identify( Proc) then
-- esecuzione profilo
bOk, sErr = ProfHead.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
-- se contorno libero ( 0/3/4-250-X)
elseif FreeContour.Identify( Proc) then
-- esecuzione contorno
bOk, sErr = FreeContour.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
-- se decorazione ( 0/3/4-959-X)
elseif Decor.Identify( Proc) then
-- esecuzione decorazione
bOk, sErr = Decor.Make( Proc, nPhase, nRawId, nPartId)
-- altrimenti feature sconosciuta
else
sErr = 'Error on process ' .. tostring( Proc.Id) .. ' unknown type (' .. tonumber( Proc.Grp) .. '-' .. tonumber( Proc.Prc) .. ')'
EgtOutLog( sErr)
bOk = false
end
return bOk, sErr, bNewPhase
end
-------------------------------------------------------------------------------------------------------------
function BeamExec.ProcessFeatures()
local bAddOk = true
local sAddErrors = ''
local nCutId
local nTaskId
local nOrd = 1
local nRawId = EgtGetFirstRawPart()
while nRawId do
-- verifico che il grezzo contenga pezzi oppure sia abbastanza lungo da essere scaricato coi carrelli
local nPartId = EgtGetFirstPartInRawPart( nRawId)
if not nPartId and EgtGetRawPartBBox( nRawId):getDimX() < BD.MinRaw then break end
-- aggiungo la fase, se non è la prima
if nOrd == 1 then
EgtSetCurrPhase( 1)
else
BL.AddPhaseWithRawParts( nRawId, BD.OriTR, 0)
end
local nPhase = EgtGetCurrPhase()
local nDispId = EgtGetPhaseDisposition( nPhase)
EgtSetInfo( nDispId, 'TYPE', EgtIf( nPartId, 'START', 'REST'))
EgtSetInfo( nDispId, 'ORD', nOrd)
EgtOutLog( 'Phase=' .. tostring( nPhase) .. ' Raw=' .. tostring( nRawId) .. ' Part=' .. tostring( nPartId), 1)
-- ingombro del grezzo e sovramateriale di testa
local b3Raw = EgtGetRawPartBBox( nRawId)
local dCurrOvmH = EgtGetInfo( nRawId, 'HOVM', 'd') or 0
-- recupero le feature di lavorazione della trave
vProc = CollectFeatures( nPartId, b3Raw, dCurrOvmH)
-- le ordino lungo X
OrderFeatures( vProc, b3Raw)
-- le classifico
local bOk, bSomeDown = ClassifyFeatures( vProc, b3Raw)
if not bOk then
bAddOk = false
sAddErrors = 'Warning : some feature not machinable due to orientation '
end
-- debug
if EgtGetDebugLevel() >= 1 then
PrintFeatures( vProc, b3Raw)
end
-- se richiesto ribaltamento
if bSomeDown then
-- ribalto le travi della fase corrente
local nRId = nRawId
while nRId do
EgtRotateRawPart( nRId, X_AX(), 180)
nRId = EgtGetNextRawPart( nRId)
end
EgtSetInfo( nDispId, 'ROT', -2)
-- inserisco le lavorazioni da lavorare ribaltate
for i = 1, #vProc do
-- creo la lavorazione
local Proc = vProc[i]
if Proc.On and Proc.Down then
local bOk, sErr = AddFeatureMachining( Proc, nPhase, nRawId, nPartId, dCurrOvmH, b3Raw)
if not bOk then
bAddOk = false
sAddErrors = sAddErrors .. sErr .. '\n'
if not nCutId then
nCutId = EgtGetInfo( EgtGetParent( EgtGetParent( Proc.Id)), 'CUTID', 'i')
nTaskId = EgtGetInfo( Proc.Id, 'TASKID', 'i')
end
end
end
end
-- aggiungo nuova fase con le travi in posizione standard
BL.AddPhaseWithRawParts( nRawId, BD.OriTR, 0)
nPhase = EgtGetCurrPhase()
nDispId = EgtGetPhaseDisposition( nPhase)
EgtSetInfo( nDispId, 'TYPE', 'MID')
EgtSetInfo( nDispId, 'ORD', nOrd)
end
-- inserisco le lavorazioni non ribaltate della trave
for i = 1, #vProc do
-- creo la lavorazione
local Proc = vProc[i]
if Proc.On and not Proc.Down then
local bOk, sErr, bNewPhase = AddFeatureMachining( Proc, nPhase, nRawId, nPartId, dCurrOvmH, b3Raw)
if not bOk then
bAddOk = false
sAddErrors = sAddErrors .. sErr .. '\n'
if not nCutId then
nCutId = EgtGetInfo( EgtGetParent( EgtGetParent( Proc.Id)), 'CUTID', 'i')
nTaskId = EgtGetInfo( Proc.Id, 'TASKID', 'i')
end
end
-- se era taglio di separazione, aggiungo nuova fase
if bNewPhase then
BL.AddPhaseWithRawParts( nRawId, BD.OriTR, BD.RAW_OFFSET)
-- se grezzo successivo senza pezzi e finale, va tolto
local nNextRawId = EgtGetNextRawPart( nRawId)
if nNextRawId and EgtGetPartInRawPartCount( nNextRawId) == 0 and EgtGetRawPartBBox( nNextRawId):getDimX() < BD.MinRaw then
EgtRemoveRawPartFromCurrPhase( nNextRawId)
end
nPhase = EgtGetCurrPhase()
nDispId = EgtGetPhaseDisposition( nPhase)
EgtSetInfo( nDispId, 'TYPE', 'END')
EgtSetInfo( nDispId, 'ORD', nOrd)
end
end
end
-- passo al grezzo successivo
nOrd = nOrd + 1
nRawId = EgtGetNextRawPart( nRawId)
end
-- Aggiornamento finale di tutto
EgtSetCurrPhase( 1)
local bApplOk, sApplErrors = EgtApplyAllMachinings()
if not bAddOk or not bApplOk then
local sErrors = ( sAddErrors or '') .. ( sApplErrors or '')
return false, sErrors, nCutId, nTaskId
end
return true
end
-------------------------------------------------------------------------------------------------------------
return BeamExec
Reference in New Issue View Git Blame Copy Permalink