Egalware/DataBeam
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

DataBeam :

Browse Source 
- allineamento tra master e develop
- modifiche per lavorazioni in doppio su PF1250.
This commit is contained in:
DarioS
2023-01-07 11:05:04 +01:00
parent 4445ce4f11
commit 4cb7dce121
7 changed files with 504 additions and 241 deletions
Download Patch File Download Diff File Expand all files Collapse all files
LuaLibs/BeamExec.lua
+198 -89
View File
@@ -1,4 +1,4 @@
-- BeamExec.lua by Egaltech s.r.l. 2022/12/23
-- BeamExec.lua by Egaltech s.r.l. 2022/12/28
-- Libreria esecuzione lavorazioni per Travi
-- 2019/07/11 Aggiunta gestione stato rotazione di feature per TS3.
-- 2019/09/04 Corretto controllo feature di testa e coda con sovramateriale di testa elevato.
@@ -38,6 +38,7 @@
-- 2022/09/28 I fori vengono sempre fatti prima delle tacche.
-- 2022/09/29 Aggiunta la ricerca di feature specchiate, al momento solo per DtMortise, con le relative funzioni.
-- 2022/12/23 Corrette rotazioni 90 deg per macchine con carico da destra.
-- 2022/12/28 Implementata gestione forature e code di rondine in doppio.
-- Tabella per definizione modulo
@@ -954,8 +955,8 @@ local function ClassifyFeatures( vProc, b3Raw, Stats)
table.Insert ( vMachineBeforeIntersectingDrillingsId, Proc.Id)
end
-- se senza geometria (già disabilitato
if Proc.Flg == 0 then
-- se senza geometria (già disabilitato)
if Proc.Flg == 0 and not Proc.Double then
bOk = false
-- se intestatura
elseif Hcut.Identify( Proc) then
@@ -1370,103 +1371,203 @@ local function MoveDrillsOnTenon( vProc)
end
end
-------------------------------------------------------------------------------------------------------------
-- Estrazione parametri P da lavorazioni di tipo DtMortise
local function GetPParametersDtMortise( Proc)
local vPParameters = {
{ 'P01', 'd'},
{ 'P02', 'd'},
{ 'P03', 'd'},
{ 'P04', 'i'},
{ 'P05', 'i'},
{ 'P06', 'd'},
{ 'P07', 'd'},
{ 'P09', 'd'},
{ 'P10', 'd'},
{ 'P11', 'd'},
{ 'P12', 'd'},
{ 'P13', 'd'},
{ 'P14', 'd'},
{ 'P15', 'd'}
}
for i = 1, #vPParameters do
vPParameter = vPParameters[i]
vPParameter[3] = EgtGetInfo( Proc.Id, vPParameter[1], vPParameter[2])
end
return vPParameters
end
-------------------------------------------------------------------------------------------------------------
-- Controlla se la feature ProcMirror è la specchiata di Proc, per feature di tipo DtMortise
local function CheckMirrorDtMortise( Proc, ProcMirror, dHBeam)
local function CheckMirrorDtMortise( Proc, ProcMirror, b3Raw, AuxId)
-- recupero i dati geometrici della curva Proc
local vtExtr = EgtCurveExtrusion( AuxId, GDB_RT.GLOB)
local ptBC = EgtGP( AuxId, GDB_RT.GLOB)
local rfDtMrt = EgtSurfTmFacetMinAreaRectangle( Proc.Id, 0, GDB_RT.GLOB)
local b3DtMrt = EgtGetBBoxRef( Proc.Id, GDB_BB.STANDARD, rfDtMrt)
-- determino l'asse della curva Proc
local vtAx = EgtEV( AuxId, GDB_RT.GLOB) - EgtSV( AuxId, GDB_RT.GLOB)
-- recupero e verifico l'entità curva ProcMirror
local AuxIdMirror = EgtGetInfo( ProcMirror.Id, 'AUXID', 'i')
if AuxIdMirror then AuxIdMirror = AuxIdMirror + ProcMirror.Id end
if not AuxIdMirror or ( EgtGetType( AuxIdMirror) & GDB_FY.GEO_CURVE) == 0 then
return false
end
-- recupero i dati geometrici della curva ProcMirror
local vtExtrMirror = EgtCurveExtrusion( AuxIdMirror, GDB_RT.GLOB)
local ptBCMirror = EgtGP( AuxIdMirror, GDB_RT.GLOB)
local b3DtMrtMirror = EgtGetBBoxRef( ProcMirror.Id, GDB_BB.STANDARD, rfDtMrt)
-- determino l'asse della curva ProcMirror
local vtAxMirror = EgtEV( AuxIdMirror, GDB_RT.GLOB) - EgtSV( AuxIdMirror, GDB_RT.GLOB)
-- verifico se le mortase sono specchiate
local bIsMirror = true
local vPParametersProc = GetPParametersDtMortise( Proc)
local vPParametersMirror = GetPParametersDtMortise( ProcMirror)
local nP02, nP06 = 2, 6
-- controllo che i parametri P delle due feature, tranne P02 e P06, siano uguali
for i = 1, #vPParametersProc do
local vPParameterProc = vPParametersProc[i]
local vPParameterMirror = vPParametersMirror[i]
if vPParameterProc[1] ~= 'P02' and vPParameterProc[1] ~= 'P06'then
bIsMirror = ( abs( vPParameterProc[3] - vPParameterMirror[3]) < 100 * GEO.EPS_SMALL)
if bIsMirror == false then break end
elseif vPParameterProc[1] == 'P02' then
nP02 = i
elseif vPParameterProc[1] == 'P06' then
nP06 = i
end
end
-- se gli altri parametri P sono uguali, verifico che P02 e P06 siano compatibili con feature specchiate
if bIsMirror == true then
bIsMirror = ( ( vPParametersProc[nP02][3] == 0 and abs( vPParametersMirror[nP02][3] - dHBeam) < 100 * GEO.EPS_SMALL) and
( vPParametersProc[nP06][3] == 90 and vPParametersMirror[nP06][3] == -90)) or
( ( vPParametersMirror[nP02][3] == 0 and abs( vPParametersProc[nP02][3] - dHBeam) < 100 * GEO.EPS_SMALL) and
( vPParametersMirror[nP06][3] == 90 and vPParametersProc[nP06][3] == -90))
local vtDisplacement = ptBC - ptBCMirror
local ptCenRaw = b3Raw:getCenter()
-- controllo che il centro delle due mortase sia allineato e che queste siano equidistanti dalla mezzeria della trave
if AreSameOrOppositeVectorApprox( vtExtr, Y_AX()) then
bIsMirror = abs( vtDisplacement:getX()) < 500 * GEO.EPS_SMALL and abs( vtDisplacement:getZ()) < 500 * GEO.EPS_SMALL and
( abs( ptBC:getY() - ptCenRaw:getY()) - abs( ptBCMirror:getY() - ptCenRaw:getY())) < 500 * GEO.EPS_SMALL
elseif AreSameOrOppositeVectorApprox( vtExtr, Z_AX()) then
bIsMirror = abs( vtDisplacement:getX()) < 500 * GEO.EPS_SMALL and abs( vtDisplacement:getY()) < 500 * GEO.EPS_SMALL and
( abs( ptBC:getZ() - ptCenRaw:getZ()) - abs( ptBCMirror:getZ() - ptCenRaw:getZ())) < 500 * GEO.EPS_SMALL
end
-- controllo che le dimensioni dei due box siano le stesse
bIsMirror = bIsMirror and abs( b3DtMrt:getDimX() - b3DtMrtMirror:getDimX()) < 500 * GEO.EPS_SMALL and
abs( b3DtMrt:getDimY() - b3DtMrtMirror:getDimY()) < 500 * GEO.EPS_SMALL and
abs( b3DtMrt:getDimZ() - b3DtMrtMirror:getDimZ()) < 500 * GEO.EPS_SMALL
-- controllo che l'asse delle due mortase sia allineato
bIsMirror = bIsMirror and AreSameVectorApprox( vtAx, vtAxMirror)
return bIsMirror
end
-------------------------------------------------------------------------------------------------------------
-- Cerca se esiste una feature specchiata di Proc e nel caso ne restituisce la posizione in vProc
local function FindMirrorFeature( vProc, Proc, sFeatureType, dHBeam)
local nProcMirror
-- se mortasa a coda di rondine
if sFeatureType == 'DtMortise' then
Proc.Side = EgtGetInfo( Proc.Id, 'SIDE', 'i')
for i = 1, #vProc do
local ProcMirror = vProc[i]
if DtMortise.SideIdentify(ProcMirror) then
ProcMirror.Side = EgtGetInfo( ProcMirror.Id, 'SIDE', 'i')
if ( Proc.Side == 1 and ProcMirror.Side == 3) or ( Proc.Side == 3 and ProcMirror.Side == 1) or
( Proc.Side == 2 and ProcMirror.Side == 4) or ( Proc.Side == 4 and ProcMirror.Side == 2) then
local bIsMirror = CheckMirrorDtMortise( Proc, ProcMirror, dHBeam)
if bIsMirror then nProcMirror = i end
-- Verifica se Proc (mortasa a coda di rondine) è lavorabile in doppio e nel caso ne imposta i dati.
local function VerifyDtMortiseMirrored( Proc, vProc, b3Raw)
-- verifico se con tasca
local bPocket = ( EgtGetInfo( Proc.Id, 'P05', 'i') == 1)
if bPocket then
return
end
-- recupero e verifico l'entità curva ausiliaria
local AuxId = EgtGetInfo( Proc.Id, 'AUXID', 'i')
if AuxId then AuxId = AuxId + Proc.Id end
if not AuxId or ( EgtGetType( AuxId) & GDB_FY.GEO_CURVE) == 0 then
return
end
local vtExtr = EgtCurveExtrusion( AuxId, GDB_RT.GLOB)
-- recupero il raggio minimo della mortasa
local dMinRad = 1000
local nSt, nEnd = EgtCurveDomain( AuxId)
for i = nSt, nEnd - 1 do
local dRad = EgtCurveCompoRadius( AuxId, i)
if dRad > 0 and dRad < dMinRad then
dMinRad = dRad
end
end
-- recupero lavorazione adatta
local dMaxDiam = 2 * dMinRad
local sMilling = ML.FindMilling( 'DtMortise', nil, nil, dMaxDiam, nil, true, false, true)
if not sMilling or not EgtMdbSetCurrMachining( sMilling) then
return
end
-- recupero il suo utensile
if not EgtTdbSetCurrTool( EgtMdbGetCurrMachiningParam( MCH_MP.TOOL) or '') then
return
end
-- recupero eventuale utensile in doppio e suo diametro
local sToolDoubleName = EgtTdbGetCurrToolValInNotes( MCH_TP.USERNOTES, 'DOUBLE', 's')
if not sToolDoubleName or not EgtTdbSetCurrTool( sToolDoubleName) or not EgtTdbGetCurrToolParam( MCH_TP.ACTIVE) then
return
end
local dToolDoubleDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM, 'd')
-- verifico se possibile in doppio (diametro utensile e direzione feaure)
if dToolDoubleDiam < dMaxDiam + GEO.EPS_SMALL and ( AreSameOrOppositeVectorApprox( vtExtr, Y_AX()) or AreSameVectorApprox( vtExtr, Z_AX())) then
for i = 1, #vProc do
local ProcMirror = vProc[i]
if DtMortise.SideIdentify( ProcMirror) and ProcMirror.Id ~= Proc.Id and ProcMirror.Flg ~= 0 then
if CheckMirrorDtMortise( Proc, ProcMirror, b3Raw, AuxId) then
if ( not BD.DOWN_HEAD and AreSameVectorApprox( vtExtr, Y_AX())) or
( BD.DOWN_HEAD and AreOppositeVectorApprox( vtExtr, Y_AX())) then
Proc.Double = 2
Proc.MirrorId = ProcMirror.Id
Proc.MirrorCurId = ProcMirror.CutId
Proc.MirrorTaskId = ProcMirror.TaskId
ProcMirror.Flg = 0
ProcMirror.Double = 0
elseif BD.DOWN_HEAD and AreSameVectorApprox( vtExtr, Z_AX()) then
Proc.Double = 3
Proc.MirrorId = ProcMirror.Id
Proc.MirrorCurId = ProcMirror.CutId
Proc.MirrorTaskId = ProcMirror.TaskId
ProcMirror.Flg = 0
ProcMirror.Double = 0
end
break
end
end
end
end
-- se foratura (da implementare)
return nProcMirror
end
-------------------------------------------------------------------------------------------------------------
-- Cerca in vProc la presenza di feature specchiate. Se le trova scrive in Proc e nelle info l'Id della specchiata.
local function SetMirroredFeatures( vProc, dHBeam)
-- Disabilita la foratura dall'altra parte dello stesso foro
local function DisableOtherDrilling( Proc, vProc)
local ProcMirror
for i = 1, #vProc do
if vProc[i].Id == Proc.Id and not vProc[i].Double then
ProcMirror = vProc[i]
break
end
end
if ProcMirror then
ProcMirror.Flg = 0
ProcMirror.Double = 0
end
end
-------------------------------------------------------------------------------------------------------------
-- Verifica se Proc (foratura) è lavorabile in doppio e nel caso ne restituisce la direzione di specchiatura.
local function VerifyDrillMirrored( Proc, vProc, b3Raw)
-- recupero e verifico l'entità foro
local AuxId = EgtGetInfo( Proc.Id, 'AUXID', 'i')
if AuxId then AuxId = AuxId + Proc.Id end
if not AuxId or EgtGetType( AuxId) ~= GDB_TY.CRV_ARC then
return
end
-- recupero direzione e dimensioni del foro
local vtExtr = EgtCurveExtrusion( AuxId, GDB_RT.GLOB)
local dDiam = 2 * EgtArcRadius( AuxId)
local dLen = abs( EgtCurveThickness( AuxId))
local dMachiningDepth = dLen / 2 + BD.DRILL_OVERLAP
-- recupero lavorazione adatta
local sDrilling, sType, dMaxDepth = ML.FindDrilling( dDiam, dMachiningDepth, true, false, true)
if not sDrilling then
sDrilling, sType, dMaxDepth = ML.FindDrilling( dDiam, 0, true, false, true)
dMachiningDepth = dMaxDepth or dMachiningDepth
end
if not sDrilling or sType ~= 'Drill' or not EgtMdbSetCurrMachining( sDrilling) then
return
end
-- recupero il suo utensile
if not EgtTdbSetCurrTool( EgtMdbGetCurrMachiningParam( MCH_MP.TOOL) or '') then
return
end
-- recupero eventuale utensile in doppio, suo diametro e massima lavorazione
local sToolDoubleName = EgtTdbGetCurrToolValInNotes( MCH_TP.USERNOTES, 'DOUBLE', 's')
if not sToolDoubleName or not EgtTdbSetCurrTool( sToolDoubleName) or not EgtTdbGetCurrToolParam( MCH_TP.ACTIVE) then
return
end
local dToolDoubleDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM, 'd')
local dToolDoubleMaxDepth = EgtTdbGetCurrToolParam( MCH_TP.MAXMAT)
-- verifico se in doppio
dMachiningDepth = min( dMachiningDepth, dToolDoubleMaxDepth)
if abs( Proc.Flg) == 2 and dToolDoubleDiam < dDiam + 10 * GEO.EPS_SMALL and dToolDoubleDiam > dDiam - BD.DRILL_TOL - 10 * GEO.EPS_SMALL then
if Proc.Fce ~= 0 then
if Proc.Flg == -2 then vtExtr = -vtExtr end
if ( not BD.DOWN_HEAD and AreSameVectorApprox( vtExtr, Y_AX())) or
( BD.DOWN_HEAD and AreOppositeVectorApprox( vtExtr, Y_AX())) then
Proc.Double = 2
Proc.MachDepthDouble = dMachiningDepth
DisableOtherDrilling( Proc, vProc)
elseif BD.DOWN_HEAD and AreSameVectorApprox( vtExtr, Z_AX()) then
Proc.Double = 3
Proc.MachDepthDouble = dMachiningDepth
DisableOtherDrilling( Proc, vProc)
end
end
end
end
-------------------------------------------------------------------------------------------------------------
-- Cerca in vProc la presenza di feature da lavorare in doppio. Se le trova scrive in Proc la direzione di specchiatura e l'utensile da utilizzare.
local function SetMirroredFeatures( vProc, b3Raw)
for i = 1, #vProc do
local Proc = vProc[i]
local sFeatureType
if DtMortise.SideIdentify(Proc) then
sFeatureType = 'DtMortise'
elseif Drill.Identify(Proc) then
sFeatureType = 'Drill'
end
if ( sFeatureType == 'DtMortise' or sFeatureType == 'Drill') and not Proc.MirrorId then
local nProcMirror = FindMirrorFeature( vProc, Proc, sFeatureType, dHBeam)
if nProcMirror then
Proc.MirrorId = vProc[nProcMirror].Id
vProc[nProcMirror].MirrorId = Proc.Id
EgtSetInfo( Proc.Id, 'MIRRORID', vProc[nProcMirror].Id)
EgtSetInfo( vProc[nProcMirror].Id, 'MIRRORID', Proc.Id)
if Proc.Flg ~= 0 then
-- Proc.Double -> 0: nessuna specchiatura, 1: specchiatura X, 2: specchiatura Y, 3: specchiatura Z
-- Proc.MirrorId -> Id della feature mirrorata
if DtMortise.SideIdentify( Proc) and BD.DOUBLE_HEAD_DOVETAIL then
VerifyDtMortiseMirrored( Proc, vProc, b3Raw)
elseif Drill.Identify( Proc) and BD.DOUBLE_HEAD_DRILLING then
VerifyDrillMirrored( Proc, vProc, b3Raw)
end
end
end
@@ -1567,9 +1668,8 @@ function BeamExec.ProcessFeatures()
SetDrillingsToMachineAfterHeadOrTailCut( vProc, vMachineBeforeIntersectingDrillings)
end
-- verifica presenza di feature specchiate per eventuali lavorazioni simultanee
local bConcurrentDoubleHead = BD.DOUBLE_HEAD_MIRRORED_FEATURES and ( BD.TWO_EQUAL_HEADS or BD.TWO_UP_DOWN_HEADS)
if bConcurrentDoubleHead then
SetMirroredFeatures( vProc, EgtGetRawPartBBox( nRawId):getDimZ())
if BD.TWO_EQUAL_HEADS or BD.DOWN_HEAD then
SetMirroredFeatures( vProc, b3Raw)
end
-- le ordino lungo X
OrderFeatures( vProc, b3Raw)
@@ -1614,6 +1714,9 @@ function BeamExec.ProcessFeatures()
table.insert( Stats, {Err=-1, Msg=sMsg, Rot=-2, CutId=Proc.CutId, TaskId=Proc.TaskId})
else
table.insert( Stats, {Err=0, Msg='', Rot=-2, CutId=Proc.CutId, TaskId=Proc.TaskId})
if Proc.Double == 2 or Proc.Double == 3 then
table.insert( Stats, {Err=0, Msg='', Rot=-2, CutId=Proc.MirrorCurId, TaskId=Proc.MirrorTaskId})
end
end
-- se è taglio di separazione, verifico se ha già aggiunto una nuova fase oppure se è da creare
if nNewPhase > 0 then
@@ -1679,11 +1782,14 @@ function BeamExec.ProcessFeatures()
local bOk, sMsg, nNewPhase = AddFeatureMachining( Proc, nPhase, nRawId, nPartId, dCurrOvmH, false, b3Raw, nOrd, sDownOrSideOrStd, bPreMove, vtMove, dCurrOvmT)
if not bOk then
nTotErr = nTotErr + 1
table.insert( Stats, {Err=1, Msg=sMsg, Rot=-2, CutId=Proc.CutId, TaskId=Proc.TaskId})
table.insert( Stats, {Err=1, Msg=sMsg, Rot=-1, CutId=Proc.CutId, TaskId=Proc.TaskId})
elseif sMsg and #sMsg > 0 then
table.insert( Stats, {Err=-1, Msg=sMsg, Rot=-2, CutId=Proc.CutId, TaskId=Proc.TaskId})
table.insert( Stats, {Err=-1, Msg=sMsg, Rot=-1, CutId=Proc.CutId, TaskId=Proc.TaskId})
else
table.insert( Stats, {Err=0, Msg='', Rot=-2, CutId=Proc.CutId, TaskId=Proc.TaskId})
table.insert( Stats, {Err=0, Msg='', Rot=-1, CutId=Proc.CutId, TaskId=Proc.TaskId})
if Proc.Double == 2 or Proc.Double == 3 then
table.insert( Stats, {Err=0, Msg='', Rot=-1, CutId=Proc.MirrorCurId, TaskId=Proc.MirrorTaskId})
end
end
if bOk then nSideMchOk = nSideMchOk + 1 end
-- se era taglio di separazione, aggiungo nuova fase
@@ -1742,6 +1848,9 @@ function BeamExec.ProcessFeatures()
table.insert( Stats, {Err=-1, Msg=sMsg, Rot=0, CutId=Proc.CutId, TaskId=Proc.TaskId})
else
table.insert( Stats, {Err=0, Msg='', Rot=0, CutId=Proc.CutId, TaskId=Proc.TaskId})
if Proc.Double == 2 or Proc.Double == 3 then
table.insert( Stats, {Err=0, Msg='', Rot=0, CutId=Proc.MirrorCurId, TaskId=Proc.MirrorTaskId})
end
end
-- se era taglio di separazione, aggiungo nuova fase
if nNewPhase > 0 then