DarioS
0613e4ebcf
- in LapJoint aggiunta gestione pulitura spigoli o giro completo con fresa di diametro minore.
1036 lines
42 KiB
Lua
1036 lines
42 KiB
Lua
-- BeamLib.lua by Egaltech s.r.l. 2021/06/27
|
|
-- Libreria globale per Travi
|
|
-- 2020/07/28 Corretto calcolo attacchi e uscite di lame per non uscire dalla faccia sotto.
|
|
-- 2020/08/18 Aggiunto a GetNearestParalOpposite e GetNearestOrthoOpposite parametro opzionale vtNorm.
|
|
-- 2020/11/03 Aggiunta funzione IsEndOrEnd2Phase.
|
|
-- 2020/11/18 Correzioni a GetParallelOpposite e a GetFaceElevation.
|
|
-- 2021/01/06 Cambiato limite per attacco Tg con lama e CalcLeadInOutGeom rinominata in CalcLeadInOutPerpGeom.
|
|
-- 2021/02/03 In taglio lama si accettano anche due lati con deviazione minore di 20deg.
|
|
-- 2021/02/09 In taglio lama con PF si preferisce testa in Y- quindi SCC di conseguenza.
|
|
-- 2021/02/26 In taglio lama consento attacco anche da sotto (grazie a migliorie in MachKernel).
|
|
-- 2021/03/22 Attacchi e uscite di tagli longitudinali da sotto con lama solo ortogonali.
|
|
-- 2021/04/27 Migliorati controlli per attacchi e uscite Tg con lama.
|
|
-- 2021/06/27 Aggiunta funzione GetOtherFaceElevation.
|
|
|
|
-- Tabella per definizione modulo
|
|
local BeamLib = {}
|
|
|
|
-- Include
|
|
require( 'EgtBase')
|
|
|
|
EgtOutLog( ' BeamLib started', 1)
|
|
|
|
-- Dati
|
|
local BD = require( 'BeamData')
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
-------------------------------------------------------------------------------------------------------------
|
|
function BeamLib.GetAddGroup( PartId)
|
|
-- recupero il nome del gruppo di lavoro corrente
|
|
local sMchGrp = EgtGetMachGroupName( EgtGetCurrMachGroup() or GDB_ID.NULL)
|
|
if not sMchGrp then return nil, nil end
|
|
-- cerco il gruppo aggiuntivo omonimo nel pezzo e se esiste lo restituisco
|
|
local AddGrpId = EgtGetFirstNameInGroup( PartId or GDB_ID.NULL, sMchGrp)
|
|
-- restituisco Id e Nome
|
|
return AddGrpId, sMchGrp
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
function BeamLib.CreateOrEmptyAddGroup( PartId)
|
|
-- recupero i dati del gruppo aggiuntivo
|
|
local AddGrpId, sMchGrp = BeamLib.GetAddGroup( PartId)
|
|
if not sMchGrp then return false end
|
|
-- se esiste, aggiorno riferimento al gruppo di lavoro e lo svuoto
|
|
if AddGrpId then
|
|
EgtSetInfo( AddGrpId, GDB_SI.MGRPONLY, EgtGetCurrMachGroup())
|
|
return EgtEmptyGroup( AddGrpId)
|
|
end
|
|
-- altrimenti lo creo
|
|
AddGrpId = EgtGroup( PartId or GDB_ID.NULL)
|
|
if not AddGrpId then return false end
|
|
-- assegno nome, flag di layer per gruppo di lavoro e colore
|
|
EgtSetName( AddGrpId, sMchGrp)
|
|
EgtSetInfo( AddGrpId, GDB_SI.MGRPONLY, EgtGetCurrMachGroup())
|
|
EgtSetColor( AddGrpId, Color3d( 80, 160, 160, 50))
|
|
return true
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
function BeamLib.AddPartStartFace( PartId, b3Solid)
|
|
-- recupero gruppo per geometria aggiuntiva
|
|
local AddGrpId = BeamLib.GetAddGroup( PartId)
|
|
if not AddGrpId then
|
|
local sErr = 'Error on process StartFace impossible to find AddGroup'
|
|
EgtOutLog( sErr)
|
|
return false, sErr
|
|
end
|
|
-- aggiungo nuovo taglio iniziale
|
|
local nStmId = EgtSurfTmPlaneInBBox( AddGrpId, b3Solid:getMax(), X_AX(), b3Solid, GDB_RT.GLOB)
|
|
if not nStmId then
|
|
local sErr = 'Error on process StartFace impossible to create Face'
|
|
EgtOutLog( sErr)
|
|
return false, sErr
|
|
end
|
|
-- applico gli opportuni attributi di feature
|
|
EgtSetName( nStmId, 'StartCut')
|
|
EgtSetInfo( nStmId, 'GRP', 1)
|
|
EgtSetInfo( nStmId, 'PRC', 340)
|
|
-- verifico se sostituisce un taglio di testa già presente
|
|
local nProcId = EgtGetFirstInGroup( EgtGetFirstNameInGroup( PartId, 'Processings') or GDB_ID.NULL)
|
|
while nProcId do
|
|
local nGrp = EgtGetInfo( nProcId, 'GRP', 'i') or 0
|
|
local nProc = EgtGetInfo( nProcId, 'PRC', 'i') or 0
|
|
if ( nGrp == 1 or nGrp == 2) and nProc == 10 then
|
|
local ptC, vtN = EgtSurfTmFacetCenter( nProcId, 0, GDB_ID.ROOT)
|
|
if ptC and vtN and AreSameVectorApprox( vtN, X_AX()) and abs( ptC:getX() - b3Solid:getMax():getX()) < 10 * GEO.EPS_SMALL then
|
|
EgtSetInfo( nStmId, 'ORI', nProcId)
|
|
end
|
|
end
|
|
nProcId = EgtGetNext( nProcId)
|
|
end
|
|
return true
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
function BeamLib.AddPartEndFace( PartId, b3Solid)
|
|
-- recupero gruppo per geometria aggiuntiva
|
|
local AddGrpId = BeamLib.GetAddGroup( PartId)
|
|
if not AddGrpId then
|
|
local sErr = 'Error on process EndFace impossible to find AddGroup'
|
|
EgtOutLog( sErr)
|
|
return false, sErr
|
|
end
|
|
-- aggiungo nuovo taglio finale
|
|
local nStmId = EgtSurfTmPlaneInBBox( AddGrpId, b3Solid:getMin(), -X_AX(), b3Solid, GDB_RT.GLOB)
|
|
if not nStmId then
|
|
local sErr = 'Error on process EndFace impossible to create Face'
|
|
EgtOutLog( sErr)
|
|
return false, sErr
|
|
end
|
|
-- applico gli opportuni attributi di feature
|
|
EgtSetName( nStmId, 'EndCut')
|
|
EgtSetInfo( nStmId, 'GRP', 2)
|
|
EgtSetInfo( nStmId, 'PRC', 350)
|
|
-- verifico se sostituisce un taglio di coda già presente
|
|
local nProcId = EgtGetFirstInGroup( EgtGetFirstNameInGroup( PartId, 'Processings') or GDB_ID.NULL)
|
|
while nProcId do
|
|
local nGrp = EgtGetInfo( nProcId, 'GRP', 'i') or 0
|
|
local nProc = EgtGetInfo( nProcId, 'PRC', 'i') or 0
|
|
if ( nGrp == 1 or nGrp == 2) and nProc == 10 then
|
|
local ptC, vtN = EgtSurfTmFacetCenter( nProcId, 0, GDB_ID.ROOT)
|
|
if ptC and vtN and AreSameVectorApprox( vtN, -X_AX()) and abs( ptC:getX() - b3Solid:getMin():getX()) < 10 * GEO.EPS_SMALL then
|
|
EgtSetInfo( nStmId, 'ORI', nProcId)
|
|
end
|
|
end
|
|
nProcId = EgtGetNext( nProcId)
|
|
end
|
|
return true
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
function BeamLib.AddPhaseWithRawParts( nFirstRawId, OriTR, dDeltaSucc)
|
|
EgtAddPhase()
|
|
local nRawId = nFirstRawId
|
|
local dRawMove = 0
|
|
while nRawId do
|
|
EgtKeepRawPart( nRawId)
|
|
EgtMoveToCornerRawPart( nRawId, OriTR, MCH_CR.TR)
|
|
EgtMoveRawPart( nRawId, Vector3d( - dRawMove, 0, 0))
|
|
if dRawMove == 0 then dRawMove = dRawMove + dDeltaSucc end
|
|
dRawMove = dRawMove + EgtGetRawPartBBox( nRawId):getDimX()
|
|
nRawId = EgtGetNextRawPart( nRawId)
|
|
end
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
function BeamLib.PutStartOnTop( nCrvId)
|
|
-- verifico che la curva sia chiusa
|
|
if not EgtCurveIsClosed( nCrvId) then return false end
|
|
-- cerco l'estremo più alto e lo imposto come inizio
|
|
local dUmax = 0
|
|
local dZmax = - GEO.INFINITO
|
|
local dUi, dUf = EgtCurveDomain( nCrvId)
|
|
for dU = dUi, dUf, 0.5 do
|
|
local ptP = EgtUP( nCrvId, dU, GDB_ID.ROOT)
|
|
if ptP and ptP:getZ() > dZmax + GEO.EPS_SMALL then
|
|
dZmax = ptP:getZ()
|
|
dUmax = dU
|
|
end
|
|
end
|
|
if abs( dUmax - dUi) > GEO.EPS_ZERO then
|
|
EgtChangeClosedCurveStart( nCrvId, dUmax)
|
|
end
|
|
return true
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
function BeamLib.PutStartOnLonger( nCrvId)
|
|
-- verifico che la curva sia chiusa
|
|
if not EgtCurveIsClosed( nCrvId) then return false end
|
|
-- cerco l'entità più lunga e la imposto come inizio
|
|
local dUmax = 0
|
|
local dLmax = - GEO.INFINITO
|
|
local dUi, dUf = EgtCurveDomain( nCrvId)
|
|
for dU = dUi, dUf - 1 do
|
|
local ptP1 = EgtUP( nCrvId, dU, GDB_ID.ROOT)
|
|
local ptP2 = EgtUP( nCrvId, dU + 0.5, GDB_ID.ROOT)
|
|
local ptP3 = EgtUP( nCrvId, dU + 1.0, GDB_ID.ROOT)
|
|
local dL = dist( ptP1, ptP2) + dist( ptP2, ptP3)
|
|
if dL > dLmax + GEO.EPS_SMALL then
|
|
dLmax = dL
|
|
dUmax = dU
|
|
end
|
|
end
|
|
if abs( dUmax - dUi) > GEO.EPS_ZERO then
|
|
EgtChangeClosedCurveStart( nCrvId, dUmax)
|
|
end
|
|
return true
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
function BeamLib.PutStartNearestToEdge( nCrvId, b3Raw, bDown)
|
|
-- verifico che la curva sia chiusa
|
|
if not EgtCurveIsClosed( nCrvId) then return false end
|
|
-- recupero il versore normale al piano di lavoro o estrusione
|
|
local vtN = EgtCurveExtrusion( nCrvId, GDB_ID.ROOT)
|
|
-- coefficienti per riportare la distanza nel piano di lavoro
|
|
local dCoeffX = 1 / ( sqrt( 1 - vtN:getX() * vtN:getX()))
|
|
local dCoeffY = 1 / ( sqrt( 1 - vtN:getY() * vtN:getY()))
|
|
local dCoeffZ = 1 / ( sqrt( 1 - vtN:getZ() * vtN:getZ()))
|
|
-- cerco l'estremo più vicino al box e lo imposto come inizio (se da sotto escludo Zmax e viceversa)
|
|
local dUopt = 0
|
|
local dDopt = GEO.INFINITO
|
|
local dUi, dUf = EgtCurveDomain( nCrvId)
|
|
for dU = dUi, dUf, 0.5 do
|
|
local ptP = EgtUP( nCrvId, dU, GDB_ID.ROOT)
|
|
if ptP then
|
|
local vtMin = ptP - b3Raw:getMin()
|
|
local vtMax = ptP - b3Raw:getMax()
|
|
local dD = abs( vtMin:getX()) * dCoeffX
|
|
dD = min( abs( vtMax:getX()) * dCoeffX, dD)
|
|
dD = min( abs( vtMin:getY()) * dCoeffY, dD)
|
|
dD = min( abs( vtMax:getY()) * dCoeffY, dD)
|
|
if bDown then
|
|
dD = min( abs( vtMin:getZ()) * dCoeffZ, dD)
|
|
else
|
|
dD = min( abs( vtMax:getZ()) * dCoeffZ, dD)
|
|
end
|
|
if dD < dDopt + GEO.EPS_SMALL then
|
|
dDopt = dD
|
|
dUopt = dU
|
|
end
|
|
end
|
|
end
|
|
if abs( dUopt - dUi) > GEO.EPS_ZERO then
|
|
EgtChangeClosedCurveStart( nCrvId, dUopt)
|
|
end
|
|
return true
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
function BeamLib.GetPointDirDepth( nPartId, ptP, vtDir)
|
|
-- recupero il solido del grezzo
|
|
local nSolId = EgtGetFirstNameInGroup( EgtGetFirstNameInGroup( nPartId, 'Box') or GDB_ID.NULL, 'Box')
|
|
if not nSolId then return end
|
|
-- interseco con la retta
|
|
local bOk, vType, vPar = EgtLineSurfTmInters( ptP, vtDir, nSolId, GDB_RT.GLOB)
|
|
if not bOk then return end
|
|
if not vPar or #vPar == 0 then return -2 end
|
|
local dLenIn, dLenOut
|
|
for i = 1, #vPar do
|
|
if vPar[i] < 0 then
|
|
if vType[i] == GDB_SLT.IN or vType[i] == GDB_SLT.TG_INI then
|
|
dLenIn = -1
|
|
end
|
|
if vType[i] == GDB_SLT.OUT or vType[i] == GDB_SLT.TG_FIN then
|
|
dLenIn = -2
|
|
end
|
|
else
|
|
if vType[i] == GDB_SLT.IN or vType[i] == GDB_SLT.TG_INI then
|
|
dLenIn = vPar[i]
|
|
end
|
|
if vType[i] == GDB_SLT.OUT or vType[i] == GDB_SLT.TG_FIN or vType[i] == GDB_SLT.TOUCH then
|
|
dLenOut = vPar[i]
|
|
end
|
|
end
|
|
end
|
|
return dLenIn, dLenOut
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function BeamLib.GetNearestParalOpposite( vtRef, vtNorm)
|
|
-- se definita anche la normale alla faccia, elimino la parte di vtRef parallela a questa
|
|
local vtMyRef = Vector3d( vtRef)
|
|
if vtNorm then
|
|
vtMyRef = vtMyRef - ( vtMyRef * vtNorm) * vtNorm
|
|
vtMyRef:normalize()
|
|
end
|
|
-- devo confrontare la componente orizzontale con quella verticale
|
|
local dHorSq = vtMyRef:getX() * vtMyRef:getX() + vtMyRef:getY() * vtMyRef:getY()
|
|
local dVertSq =vtMyRef:getZ() * vtMyRef:getZ()
|
|
-- se prevalente la componente orizzontale
|
|
if dHorSq >= dVertSq then
|
|
if abs( vtMyRef:getX()) > abs( vtMyRef:getY()) - GEO.EPS_SMALL then
|
|
if vtMyRef:getX() > -GEO.EPS_SMALL then
|
|
return MCH_MILL_FU.PARAL_LEFT
|
|
else
|
|
return MCH_MILL_FU.PARAL_RIGHT
|
|
end
|
|
else
|
|
if vtMyRef:getY() > -GEO.EPS_SMALL then
|
|
return MCH_MILL_FU.PARAL_FRONT
|
|
else
|
|
return MCH_MILL_FU.PARAL_BACK
|
|
end
|
|
end
|
|
-- altrimenti prevale la verticale
|
|
else
|
|
if vtMyRef:getZ() > -GEO.EPS_SMALL then
|
|
return MCH_MILL_FU.PARAL_DOWN
|
|
else
|
|
return MCH_MILL_FU.PARAL_TOP
|
|
end
|
|
end
|
|
return nil
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function BeamLib.GetNearestOrthoOpposite( vtRef, vtNorm)
|
|
-- se definita anche la normale alla faccia, elimino la parte di vtRef parallela a questa
|
|
local vtMyRef = Vector3d( vtRef)
|
|
if vtNorm then
|
|
vtMyRef = vtMyRef - ( vtMyRef * vtNorm) * vtNorm
|
|
vtMyRef:normalize()
|
|
end
|
|
-- devo confrontare la componente orizzontale con quella verticale
|
|
local dHorSq = vtMyRef:getX() * vtMyRef:getX() + vtMyRef:getY() * vtMyRef:getY()
|
|
local dVertSq = vtMyRef:getZ() * vtMyRef:getZ()
|
|
-- se prevalente la componente orizzontale
|
|
if dHorSq >= dVertSq then
|
|
if abs( vtMyRef:getX()) > abs( vtMyRef:getY()) - GEO.EPS_SMALL then
|
|
if vtMyRef:getX() > -GEO.EPS_SMALL then
|
|
return MCH_MILL_FU.ORTHO_LEFT
|
|
else
|
|
return MCH_MILL_FU.ORTHO_RIGHT
|
|
end
|
|
else
|
|
if vtMyRef:getY() > -GEO.EPS_SMALL then
|
|
return MCH_MILL_FU.ORTHO_FRONT
|
|
else
|
|
return MCH_MILL_FU.ORTHO_BACK
|
|
end
|
|
end
|
|
-- altrimenti prevale la verticale
|
|
else
|
|
if vtMyRef:getZ() > -GEO.EPS_SMALL then
|
|
return MCH_MILL_FU.ORTHO_DOWN
|
|
else
|
|
return MCH_MILL_FU.ORTHO_TOP
|
|
end
|
|
end
|
|
return nil
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function BeamLib.GetOrtupOpposite( nOrthoOpposite)
|
|
if nOrthoOpposite == MCH_MILL_FU.ORTHO_LEFT then
|
|
return MCH_MILL_FU.ORTUP_LEFT
|
|
elseif nOrthoOpposite == MCH_MILL_FU.ORTHO_RIGHT then
|
|
return MCH_MILL_FU.ORTUP_RIGHT
|
|
elseif nOrthoOpposite == MCH_MILL_FU.ORTHO_FRONT then
|
|
return MCH_MILL_FU.ORTUP_FRONT
|
|
elseif nOrthoOpposite == MCH_MILL_FU.ORTHO_BACK then
|
|
return MCH_MILL_FU.ORTUP_BACK
|
|
elseif nOrthoOpposite == MCH_MILL_FU.ORTHO_DOWN then
|
|
return MCH_MILL_FU.ORTUP_DOWN
|
|
elseif nOrthoOpposite == MCH_MILL_FU.ORTHO_TOP then
|
|
return MCH_MILL_FU.ORTUP_TOP
|
|
end
|
|
return nil
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function BeamLib.GetParallelOpposite( nOrthoOpposite)
|
|
if nOrthoOpposite == MCH_MILL_FU.ORTHO_LEFT then
|
|
return MCH_MILL_FU.PARAL_LEFT
|
|
elseif nOrthoOpposite == MCH_MILL_FU.ORTHO_RIGHT then
|
|
return MCH_MILL_FU.PARAL_RIGHT
|
|
elseif nOrthoOpposite == MCH_MILL_FU.ORTHO_FRONT then
|
|
return MCH_MILL_FU.PARAL_FRONT
|
|
elseif nOrthoOpposite == MCH_MILL_FU.ORTHO_BACK then
|
|
return MCH_MILL_FU.PARAL_BACK
|
|
elseif nOrthoOpposite == MCH_MILL_FU.ORTHO_DOWN then
|
|
return MCH_MILL_FU.PARAL_DOWN
|
|
elseif nOrthoOpposite == MCH_MILL_FU.ORTHO_TOP then
|
|
return MCH_MILL_FU.PARAL_TOP
|
|
end
|
|
return nil
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function BeamLib.GetVersRef( nOrthoOpposite)
|
|
if nOrthoOpposite == MCH_MILL_FU.ORTHO_LEFT then
|
|
return X_AX()
|
|
elseif nOrthoOpposite == MCH_MILL_FU.ORTHO_RIGHT then
|
|
return -X_AX()
|
|
elseif nOrthoOpposite == MCH_MILL_FU.ORTHO_FRONT then
|
|
return Y_AX()
|
|
elseif nOrthoOpposite == MCH_MILL_FU.ORTHO_BACK then
|
|
return -Y_AX()
|
|
elseif nOrthoOpposite == MCH_MILL_FU.ORTHO_DOWN then
|
|
return Z_AX()
|
|
elseif nOrthoOpposite == MCH_MILL_FU.ORTHO_TOP then
|
|
return -Z_AX()
|
|
end
|
|
return nil
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function BeamLib.GetBoxFaceNorm( b3Box, ptP, vtV)
|
|
local vtNx = V_NULL()
|
|
if abs( ptP:getX() - b3Box:getMin():getX()) < 10 * GEO.EPS_SMALL then
|
|
vtNx = -X_AX()
|
|
elseif abs( ptP:getX() - b3Box:getMax():getX()) < 10 * GEO.EPS_SMALL then
|
|
vtNx = X_AX()
|
|
end
|
|
local vtNy = V_NULL()
|
|
if abs( ptP:getY() - b3Box:getMin():getY()) < 10 * GEO.EPS_SMALL then
|
|
vtNy = -Y_AX()
|
|
elseif abs( ptP:getY() - b3Box:getMax():getY()) < 10 * GEO.EPS_SMALL then
|
|
vtNy = Y_AX()
|
|
end
|
|
local vtNz = V_NULL()
|
|
if abs( ptP:getZ() - b3Box:getMin():getZ()) < 10 * GEO.EPS_SMALL then
|
|
vtNz = -Z_AX()
|
|
elseif abs( ptP:getZ() - b3Box:getMax():getZ()) < 10 * GEO.EPS_SMALL then
|
|
vtNz = Z_AX()
|
|
end
|
|
local dNxDotV = vtNx * vtV
|
|
local dNyDotV = vtNy * vtV
|
|
local dNzDotV = vtNz * vtV
|
|
if dNxDotV > dNyDotV and dNxDotV > dNzDotV then
|
|
return vtNx
|
|
elseif dNyDotV > dNzDotV and dNyDotV > dNxDotV then
|
|
return vtNy
|
|
else
|
|
return vtNz
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function BeamLib.GetFaceElevation( nSurfId, nFac, nPartId)
|
|
-- centro e normale della faccia
|
|
local ptC, vtN = EgtSurfTmFacetCenter( nSurfId, nFac, GDB_ID.ROOT)
|
|
if not ptC or not vtN then return 0 end
|
|
-- riferimento OCS della faccia per ricavare elevazione rispetto alla faccia della superficie
|
|
local frOCS = Frame3d( ptC, vtN) ;
|
|
local b3Box = EgtGetBBoxRef( nSurfId, GDB_BB.STANDARD, frOCS)
|
|
local dElev = b3Box:getMax():getZ()
|
|
-- se definito identificativo di pezzo
|
|
if nPartId then
|
|
-- se superficie con più facce
|
|
if EgtSurfTmFacetCount( nSurfId) > 1 then
|
|
-- determino elevazione del centro faccia rispetto al box del pezzo
|
|
local _, dCenElev = BeamLib.GetPointDirDepth( nPartId, ptC, vtN)
|
|
if dCenElev and dCenElev > dElev then
|
|
dElev = dCenElev
|
|
end
|
|
-- altrimenti superficie ad una sola faccia
|
|
else
|
|
-- determino elevazione box del pezzo rispetto alla faccia
|
|
local b3Solid = EgtGetBBoxRef( EgtGetFirstNameInGroup( nPartId, 'Box') or GDB_ID.NULL, GDB_BB.STANDARD, frOCS)
|
|
local dSolidElev = b3Solid:getMax():getZ()
|
|
if b3Solid and dSolidElev > dElev then
|
|
dElev = dSolidElev
|
|
end
|
|
end
|
|
end
|
|
return dElev
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function BeamLib.GetOtherFaceElevation( nSurfId, nOtherSurfId, nOtherFac, nPartId)
|
|
-- centro e normale della faccia
|
|
local ptC, vtN = EgtSurfTmFacetCenter( nOtherSurfId, nOtherFac, GDB_ID.ROOT)
|
|
if not ptC or not vtN then return 0 end
|
|
-- riferimento OCS della faccia per ricavare elevazione rispetto alla faccia della superficie
|
|
local frOCS = Frame3d( ptC, vtN) ;
|
|
local b3Box = EgtGetBBoxRef( nSurfId, GDB_BB.STANDARD, frOCS)
|
|
local dElev = b3Box:getMax():getZ()
|
|
-- se definito identificativo di pezzo
|
|
if nPartId then
|
|
-- determino elevazione del centro faccia rispetto al box del pezzo
|
|
local _, dCenElev = BeamLib.GetPointDirDepth( nPartId, ptC, vtN)
|
|
if dCenElev and dCenElev > dElev then
|
|
dElev = dCenElev
|
|
end
|
|
end
|
|
return dElev
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function BeamLib.GetFaceWithMostAdj( nSurfId, nPartId, bCompare3Fc, dCosSideAng)
|
|
-- recupero il numero di facce
|
|
local nFacCnt = EgtSurfTmFacetCount( nSurfId)
|
|
if not dCosSideAng then
|
|
dCosSideAng = -0.09
|
|
end
|
|
-- recupero le normali delle facce
|
|
local vvtN = {}
|
|
for i = 1, nFacCnt do
|
|
local vtN = EgtSurfTmFacetNormVersor( nSurfId, i - 1, GDB_ID.ROOT)
|
|
vvtN[i] = vtN ;
|
|
end
|
|
-- adiacenze e sottosquadra delle facce
|
|
local vAdj = {}
|
|
local vUcut = {}
|
|
local vOrtho = {}
|
|
for i = 1, nFacCnt do
|
|
-- recupero le adiacenze del loop esterno
|
|
local vFacAdj = EgtSurfTmFacetAdjacencies( nSurfId, i - 1)[1]
|
|
-- le conto
|
|
local nCount = 0
|
|
for j = 1, #vFacAdj do
|
|
if vFacAdj[j] >= 0 then
|
|
nCount = nCount + 1
|
|
end
|
|
end
|
|
vAdj[i] = nCount
|
|
-- ne determino eventuale sottosquadra ( dal valore passato o - 3deg) e ortogonalità
|
|
local bUcut = false
|
|
local bOrtho = true
|
|
for j = 1, #vFacAdj do
|
|
if vFacAdj[j] >= 0 then
|
|
local vtN = vvtN[i]
|
|
local vtN2 = vvtN[vFacAdj[j]+1]
|
|
local dResV = vtN * vtN2
|
|
if dResV < dCosSideAng - GEO.EPS_SMALL then
|
|
bUcut = true
|
|
end
|
|
if abs( dResV) > 2 * GEO.EPS_SMALL then
|
|
bOrtho = false
|
|
end
|
|
end
|
|
end
|
|
vUcut[i] = bUcut
|
|
vOrtho[i] = bOrtho
|
|
end
|
|
-- se 4 facce tutte con adiacenza 2, allora è un tunnel
|
|
if nFacCnt == 4 then
|
|
if vAdj[1] == 2 and vAdj[2] == 2 and vAdj[3] == 2 and vAdj[4] == 2 then
|
|
-- se tutte le facce sono ortogonali tra loro esco con un flag che ne indica questa propietà
|
|
if vOrtho[1] == true and vOrtho[2] == true and vOrtho[3] == true and vOrtho[4] == true then
|
|
return -1, GEO.INFINITO, true
|
|
else
|
|
return -1, GEO.INFINITO
|
|
end
|
|
end
|
|
end
|
|
-- se 3 facce con una che ha 2 adiacenze e le altre hanno 1 adiacenza, allora è una semi-fessura
|
|
if bCompare3Fc and nFacCnt == 3 then
|
|
local nCount2Adc = 0
|
|
local nCount1Adc = 0
|
|
-- ottengo il numero di facce con due adiacenze e il numero di facce con una adiacenza
|
|
for i = 1, #vAdj do
|
|
if vAdj[i] == 2 then
|
|
nCount2Adc = nCount2Adc + 1
|
|
elseif vAdj[i] == 1 then
|
|
nCount1Adc = nCount1Adc + 1
|
|
end
|
|
end
|
|
-- se il numero di adiacenze corrisponde
|
|
if nCount2Adc == 1 and nCount1Adc == 2 then
|
|
if vOrtho[1] == true and vOrtho[2] == true and vOrtho[3] == true then
|
|
return -1, GEO.INFINITO, true
|
|
else
|
|
return -1, GEO.INFINITO
|
|
end
|
|
end
|
|
end
|
|
-- recupero le facce non in sottosquadra e con il maggior numero di adiacenze
|
|
local nFacInd = {}
|
|
local nMaxAdj = -1
|
|
local nSupAdj = -1
|
|
for i = 1, nFacCnt do
|
|
if not vUcut[i] then
|
|
if vAdj[i] > nMaxAdj then
|
|
nFacInd = {}
|
|
nFacInd[1] = i - 1
|
|
nMaxAdj = vAdj[i]
|
|
elseif vAdj[i] == nMaxAdj and nMaxAdj > 0 then
|
|
table.insert( nFacInd, i - 1)
|
|
end
|
|
end
|
|
if vAdj[i] > nSupAdj then
|
|
nSupAdj = vAdj[i]
|
|
end
|
|
end
|
|
-- verifico non ci sia una faccia in sottosquadra con adiacenza superiore
|
|
if nSupAdj > nMaxAdj then
|
|
return -2, GEO.INFINITO
|
|
end
|
|
-- premio la faccia con minore elevazione
|
|
local nFacOpt, nFacOpt2
|
|
local dMinElev, dMinElev2 = GEO.INFINITO, GEO.INFINITO
|
|
local dtElev = {}
|
|
for i = 1, #nFacInd do
|
|
local dElev = BeamLib.GetFaceElevation( nSurfId, nFacInd[i], nPartId)
|
|
table.insert( dtElev, dElev)
|
|
if dElev < dMinElev then
|
|
if dMinElev < dMinElev2 then
|
|
nFacOpt2 = nFacOpt
|
|
dMinElev2 = dMinElev
|
|
end
|
|
nFacOpt = nFacInd[i]
|
|
dMinElev = dElev
|
|
elseif dElev < dMinElev2 then
|
|
nFacOpt2 = nFacInd[i]
|
|
dMinElev2 = dElev
|
|
end
|
|
end
|
|
-- faccio una ulteriore verifica
|
|
-- se le elevazioni di max 3 facce sono in un range minimo o al di sotto dell'elevazione ritenuta fattibile,
|
|
-- premio quella che non è sottosquadra e che ha la X minore
|
|
local bDiffSmall = true
|
|
for i = 1, #dtElev do
|
|
if dtElev[i] > dMinElev + 5 or dtElev[i] > 80 then
|
|
bDiffSmall = false
|
|
end
|
|
end
|
|
-- se tutte sono nel range minimo posso prendere la faccia che ha la componente Z magiore, e se sono uguali, prendo quella con componente X minore
|
|
local dMaxZ, dMaxZ2 = -1.1, -1.1
|
|
if bDiffSmall and #nFacInd <= 3 then
|
|
for i = 1, #nFacInd do
|
|
if vvtN[nFacInd[i]+1]:getZ() > dMaxZ then
|
|
if dMaxZ > dMaxZ2 then
|
|
nFacOpt2 = nFacOpt
|
|
dMinElev2 = dMinElev
|
|
dMaxZ2 = dMaxZ
|
|
end
|
|
nFacOpt = nFacInd[i]
|
|
dMinElev = dtElev[i]
|
|
dMaxZ = vvtN[nFacInd[i]+1]:getZ()
|
|
elseif vvtN[nFacInd[i]+1]:getZ() > dMaxZ2 then
|
|
nFacOpt2 = nFacInd[i]
|
|
dMinElev2 = dtElev[i]
|
|
dMaxZ2 = vvtN[nFacInd[i]+1]:getZ()
|
|
end
|
|
end
|
|
-- se hanno uguale Z premio quella con la componente X minore
|
|
if abs( dMaxZ - dMaxZ2) < 10*GEO.EPS_SMALL then
|
|
if abs(vvtN[nFacOpt+1]:getX()) > abs(vvtN[nFacOpt2+1]:getX()) then
|
|
nFacOpt, nFacOpt2 = nFacOpt2, nFacOpt
|
|
dMinElev, dMinElev2 = dMinElev2, dMinElev
|
|
end
|
|
end
|
|
end
|
|
|
|
return nFacOpt, dMinElev, nFacOpt2, dMinElev2
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function BeamLib.GetFaceHvRefDim( nSurfId, nFacet)
|
|
-- recupero centro e normale della faccia
|
|
local ptC, vtN = EgtSurfTmFacetCenter( nSurfId, nFacet, GDB_ID.ROOT)
|
|
if not ptC or not vtN then return end
|
|
-- riferimento tipo OCS della faccia (X orizz, Y max pendenza, Z normale)
|
|
local frHV = Frame3d( ptC, vtN)
|
|
if frHV:getVersY():getZ() < 0 then
|
|
frHV:rotate( ptC, vtN, 180)
|
|
end
|
|
-- determino l'ingombro in questo riferimento
|
|
local b3HV = EgtSurfTmGetFacetBBoxRef( nSurfId, nFacet, GDB_BB.STANDARD, frHV)
|
|
-- restituisco i valori calcolati
|
|
return frHV, b3HV:getDimX(), b3HV:getDimY()
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function BeamLib.CalcLeadInOutPerpGeom( ptP1, ptP2, vtV1, vtV2, vtN, dRad, vtRef, dCutExtra, b3Box)
|
|
-- Mi assicuro che i vettori ingresso/uscita giacciano nel piano
|
|
vtV1 = vtV1 - vtV1 * vtN * vtN ; vtV1:normalize()
|
|
vtV2 = vtV2 - vtV2 * vtN * vtN ; vtV2:normalize()
|
|
-- Versore tangente al taglio
|
|
local vtTg = ptP2 - ptP1 ;
|
|
vtTg = vtTg - vtTg * vtN * vtN ; vtTg:normalize()
|
|
-- Sistema di riferimento intrinseco al taglio
|
|
local vtX = vtTg ^ vtN
|
|
local frFace = Frame3d( ptP1, vtX, vtTg, vtN)
|
|
EgtOutLog( 'Vref=' .. tostring( vtRef) .. ' V1=' .. tostring( vtV1) .. ' V2=' .. tostring( vtV2), 3)
|
|
-- Versori di attacco e uscita
|
|
local dCos1 = vtV1 * vtRef
|
|
local dCos2 = vtV2 * vtRef
|
|
local vtLi, vtLo
|
|
if abs( dCos1 - dCos2) < 0.001 then
|
|
if abs( vtV1:getZ()) < abs( vtV2:getZ()) then
|
|
vtLi = vtV1
|
|
vtLo = vtV1
|
|
else
|
|
vtLi = vtV2
|
|
vtLo = vtV2
|
|
end
|
|
elseif dCos1 > dCos2 then
|
|
vtLi = vtV1
|
|
vtLo = vtV1
|
|
else
|
|
vtLi = vtV2
|
|
vtLo = vtV2
|
|
end
|
|
local bRight = ( vtX * vtLi > 0)
|
|
-- Versori di attacco e uscita nel riferimento intrinseco al taglio
|
|
local vtLiL = Vector3d( vtLi) ; vtLiL:toLoc( frFace)
|
|
local vtLoL = Vector3d( vtLo) ; vtLoL:toLoc( frFace)
|
|
-- Spostamento punti per effetto dell'extra o della deficienza di taglio
|
|
ptP1 = ptP1 + vtX * ( EgtIf( bRight, - dCutExtra, dCutExtra))
|
|
ptP2 = ptP2 + vtX * ( EgtIf( bRight, - dCutExtra, dCutExtra))
|
|
-- Non va considerata l'uscita dalla faccia sotto, pertanto va abbassata
|
|
-- 2021/02/26 Abilito anche uscita sotto
|
|
local b3MyBox = BBox3d( b3Box) ; --b3MyBox:Add( b3MyBox:getMin() - 1000 * Z_AX())
|
|
-- Attacco
|
|
local dLiTang = 10000
|
|
local dLiPerp = 10000
|
|
local bLiOk, _, vLiPar = EgtLineBoxInters( ptP1, vtLi, b3MyBox)
|
|
if bLiOk and #vLiPar > 0 then
|
|
-- con la prima faccia di uscita
|
|
local dLen = vLiPar[#vLiPar]
|
|
local ptInt = ptP1 + vtLi * dLen
|
|
local vtFN = BeamLib.GetBoxFaceNorm( b3MyBox, ptInt, vtLi)
|
|
EgtOutLog( 'LiFaceNorm=' .. tostring( vtFN), 3)
|
|
local dAddLen = dRad * ( sqrt( 1 - ( vtN * vtFN) * ( vtN * vtFN)) - abs( vtX * vtFN)) / ( vtLi * vtFN)
|
|
local dLiLen = dLen + dAddLen
|
|
EgtOutLog( 'LeadIn Dist=' .. EgtNumToString( dLiLen), 3)
|
|
dLiTang = - dLiLen * vtLiL:getY()
|
|
dLiPerp = EgtIf( bRight, dLiLen, - dLiLen) * vtLiL:getX()
|
|
-- verifico se miglioro calcolando con faccia successiva
|
|
local b3Mod = BBox3d( b3MyBox) ; b3Mod:Add( ptInt + 1000 * vtFN)
|
|
local bLiOk2, _, vLiPar2 = EgtLineBoxInters( ptP1, vtLi, b3Mod)
|
|
if bLiOk2 and #vLiPar2 > 0 then
|
|
local dLen2 = vLiPar2[#vLiPar2]
|
|
local vtFN2 = BeamLib.GetBoxFaceNorm( b3Mod, ptP1 + vtLi * dLen2, vtLi)
|
|
EgtOutLog( 'LiFaceNorm2=' .. tostring( vtFN2), 3)
|
|
local dAddLen2 = dRad * ( sqrt( 1 - ( vtN * vtFN2) * ( vtN * vtFN2)) - abs( vtX * vtFN2)) / ( vtLi * vtFN2)
|
|
local dLiLen2 = dLen2 + dAddLen2
|
|
EgtOutLog( 'LeadIn Dist2=' .. EgtNumToString( dLiLen2), 3)
|
|
local dLiTang2 = - dLiLen2 * vtLiL:getY()
|
|
local dLiPerp2 = EgtIf( bRight, dLiLen2, - dLiLen2) * vtLiL:getX()
|
|
if dLiLen2 < dLiLen then
|
|
dLiTang = dLiTang2
|
|
dLiPerp = dLiPerp2
|
|
end
|
|
end
|
|
end
|
|
-- Lunghezza di uscita
|
|
local dLoTang = 10000
|
|
local dLoPerp = 10000
|
|
local bLoOk, _, vLoPar = EgtLineBoxInters( ptP2, vtLo, b3MyBox)
|
|
if bLoOk and #vLoPar > 0 then
|
|
-- con la prima faccia di uscita
|
|
local dLen = vLoPar[#vLoPar]
|
|
local ptInt = ptP2 + vtLo * dLen
|
|
local vtFN = BeamLib.GetBoxFaceNorm( b3MyBox, ptInt, vtLo)
|
|
EgtOutLog( 'LoFaceNorm=' .. tostring( vtFN), 3)
|
|
local dAddLen = dRad * ( sqrt( 1 - ( vtN * vtFN) * ( vtN * vtFN)) - abs( vtX * vtFN)) / ( vtLo * vtFN)
|
|
local dLoLen = dLen + dAddLen
|
|
EgtOutLog( 'LeadOut Dist=' .. EgtNumToString( dLoLen), 3)
|
|
dLoTang = dLoLen * vtLoL:getY()
|
|
dLoPerp = EgtIf( bRight, dLoLen, - dLoLen) * vtLoL:getX()
|
|
-- verifico se miglioro calcolando con faccia successiva
|
|
local b3Mod = BBox3d( b3MyBox) ; b3Mod:Add( ptInt + 1000 * vtFN)
|
|
local bLoOk2, _, vLoPar2 = EgtLineBoxInters( ptP2, vtLo, b3Mod)
|
|
if bLoOk2 and #vLoPar2 > 0 then
|
|
local dLen2 = vLoPar2[#vLoPar2]
|
|
local vtFN2 = BeamLib.GetBoxFaceNorm( b3Mod, ptP2 + vtLo * dLen2, vtLo)
|
|
EgtOutLog( 'LoFaceNorm2=' .. tostring( vtFN2), 3)
|
|
local dAddLen2 = dRad * ( sqrt( 1 - ( vtN * vtFN2) * ( vtN * vtFN2)) - abs( vtX * vtFN2)) / ( vtLo * vtFN2)
|
|
local dLoLen2 = dLen2 + dAddLen2
|
|
EgtOutLog( 'LeadOut Dist2=' .. EgtNumToString( dLoLen2), 3)
|
|
local dLoTang2 = dLoLen2 * vtLoL:getY()
|
|
local dLoPerp2 = EgtIf( bRight, dLoLen2, - dLoLen2) * vtLoL:getX()
|
|
if dLoLen2 < dLoLen then
|
|
dLoTang = dLoTang2
|
|
dLoPerp = dLoPerp2
|
|
end
|
|
end
|
|
end
|
|
return dLiTang, dLiPerp, dLoTang, dLoPerp
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function BeamLib.CalcLeadInOutTangGeom( ptP1, ptP2, vtN, dRad, vtRef, dCutExtra, b3Box)
|
|
-- Versore tangente al taglio
|
|
local vtTg = ptP2 - ptP1 ;
|
|
vtTg = vtTg - vtTg * vtN * vtN ; vtTg:normalize()
|
|
-- Sistema di riferimento intrinseco al taglio
|
|
local vtX = vtTg ^ vtN
|
|
local frFace = Frame3d( ptP1, vtX, vtTg, vtN)
|
|
if ( vtX * vtRef < 0) then
|
|
vtX = - vtX
|
|
end
|
|
EgtOutLog( 'Vref=' .. tostring( vtRef) .. ' V1=' .. tostring( vtV1) .. ' V2=' .. tostring( vtV2), 3)
|
|
-- Spostamento punti per effetto dell'extra o della deficienza di taglio
|
|
ptP1 = ptP1 - vtX * dCutExtra
|
|
ptP2 = ptP2 - vtX * dCutExtra
|
|
-- Non va considerata l'uscita dalla faccia sotto, pertanto va abbassata
|
|
-- 2021/02/26 Abilito anche uscita sotto
|
|
local b3MyBox = BBox3d( b3Box) ; --b3MyBox:Add( b3MyBox:getMin() - 1000 * Z_AX())
|
|
-- Attacco
|
|
local dLiTang = 10000
|
|
local dLiPerp = 0
|
|
local bLiOk, _, vLiPar = EgtLineBoxInters( ptP1, vtTg, b3MyBox)
|
|
if bLiOk and #vLiPar > 0 then
|
|
local dLen = vLiPar[1]
|
|
local ptInt = ptP1 + vtTg * dLen
|
|
local vtFN = BeamLib.GetBoxFaceNorm( b3MyBox, ptInt, -vtTg)
|
|
EgtOutLog( 'LiFaceNorm=' .. tostring( vtFN), 3)
|
|
local dAddLen = dRad * ( sqrt( 1 - ( vtN * vtFN) * ( vtN * vtFN)) - ( vtX * vtFN)) / ( vtTg * vtFN)
|
|
local dLiLen = dLen + dAddLen
|
|
EgtOutLog( 'LeadIn Dist=' .. EgtNumToString( dLiLen), 3)
|
|
dLiTang = - dLiLen
|
|
-- verifico se miglioro calcolando con faccia successiva
|
|
local b3Mod = BBox3d( b3MyBox) ; b3Mod:Add( ptInt + 1000 * vtFN)
|
|
local bLiOk2, _, vLiPar2 = EgtLineBoxInters( ptP1, vtTg, b3Mod)
|
|
if bLiOk2 and #vLiPar2 > 0 then
|
|
local dLen2 = vLiPar2[1]
|
|
local vtFN2 = BeamLib.GetBoxFaceNorm( b3Mod, ptP1 + vtTg * dLen2, -vtTg)
|
|
EgtOutLog( 'LiFaceNorm2=' .. tostring( vtFN2), 3)
|
|
local dAddLen2 = dRad * ( sqrt( 1 - ( vtN * vtFN2) * ( vtN * vtFN2)) - ( vtX * vtFN2)) / ( vtTg * vtFN2)
|
|
local dLiLen2 = dLen2 + dAddLen2
|
|
EgtOutLog( 'LeadIn Dist2=' .. EgtNumToString( dLiLen2), 3)
|
|
if -dLiLen2 < -dLiLen then
|
|
dLiTang = - dLiLen2
|
|
end
|
|
end
|
|
end
|
|
-- Lunghezza di uscita
|
|
local dLoTang = 10000
|
|
local dLoPerp = 0
|
|
local bLoOk, _, vLoPar = EgtLineBoxInters( ptP2, vtTg, b3MyBox)
|
|
if bLoOk and #vLoPar > 0 then
|
|
local dLen = vLoPar[#vLoPar]
|
|
local ptInt = ptP2 + vtTg * dLen
|
|
local vtFN = BeamLib.GetBoxFaceNorm( b3MyBox, ptInt, vtTg)
|
|
EgtOutLog( 'LoFaceNorm=' .. tostring( vtFN), 3)
|
|
local dAddLen = dRad * ( sqrt( 1 - ( vtN * vtFN) * ( vtN * vtFN)) - ( vtX * vtFN)) / ( vtTg * vtFN)
|
|
local dLoLen = dLen + dAddLen
|
|
EgtOutLog( 'LeadOut Dist=' .. EgtNumToString( dLoLen), 3)
|
|
dLoTang = dLoLen
|
|
-- verifico se miglioro calcolando con faccia successiva
|
|
local b3Mod = BBox3d( b3MyBox) ; b3Mod:Add( ptInt + 1000 * vtFN)
|
|
local bLoOk2, _, vLoPar2 = EgtLineBoxInters( ptP2, vtTg, b3Mod)
|
|
if bLoOk2 and #vLoPar2 > 0 then
|
|
local dLen2 = vLoPar2[#vLoPar2]
|
|
local vtFN2 = BeamLib.GetBoxFaceNorm( b3Mod, ptP2 + vtTg * dLen2, vtTg)
|
|
EgtOutLog( 'LoFaceNorm2=' .. tostring( vtFN2), 3)
|
|
local dAddLen2 = dRad * ( sqrt( 1 - ( vtN * vtFN2) * ( vtN * vtFN2)) - ( vtX * vtFN2)) / ( vtTg * vtFN2)
|
|
local dLoLen2 = dLen2 + dAddLen2
|
|
EgtOutLog( 'LeadOut Dist2=' .. EgtNumToString( dLoLen2), 3)
|
|
if dLoLen2 < dLoLen then
|
|
dLoTang = dLoLen2
|
|
end
|
|
end
|
|
end
|
|
return dLiTang, dLiPerp, dLoTang, dLoPerp
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function BeamLib.MakeOneFaceBySaw( nSurfId, nFacet, sCutting, dSawDiam, Par5, dVzLimDwnUp, dCutExtra, dCutSic, dCutOffset, dAccStart, dAccEnd, sNotes, b3Raw)
|
|
-- dati della faccia
|
|
local ptC, vtN = EgtSurfTmFacetCenter( nSurfId, nFacet, GDB_ID.ROOT)
|
|
-- risolvo parametro ambiguo
|
|
local nOrthoOpposite
|
|
local vtOrthO
|
|
if isVector3d( Par5) then
|
|
nOrthoOpposite = BeamLib.GetNearestOrthoOpposite( Par5, vtN)
|
|
vtOrthO = Vector3d( Par5)
|
|
else
|
|
nOrthoOpposite = Par5
|
|
vtOrthO = BeamLib.GetVersRef( Par5)
|
|
end
|
|
-- linea o bilinea di lavorazione (qui uso nOrthoOpposite per ripetere esattamente il calcolo del Mach)
|
|
local ptP1, ptPm, ptP2, vtV1, vtV2, dLen, dWidth = EgtSurfTmFacetOppositeSide( nSurfId, nFacet, BeamLib.GetVersRef( nOrthoOpposite), GDB_ID.ROOT)
|
|
if not dLen or dLen < 1.1 or not dWidth or dWidth < 1.1 then
|
|
local sWarn = 'Face ' .. string.format( '%d,%d', nSurfId, nFacet) .. ' skipped : too small'
|
|
EgtOutLog( sWarn, 1)
|
|
return true, ''
|
|
end
|
|
vtV1 = - vtV1
|
|
local bInvert = ( ptP2:getZ() < ptP1:getZ() - 100 * GEO.EPS_SMALL)
|
|
if bInvert then
|
|
ptP1, ptP2 = ptP2, ptP1
|
|
vtV1, vtV2 = vtV2, vtV1
|
|
end
|
|
local vtTg = ptP2 - ptP1 ; vtTg:normalize()
|
|
local dAllStart = 0
|
|
local dAllEnd = 0
|
|
-- se bilinea, scarto la parte più allineata con la direzione ortogonale (se deviazione angolare oltre 20 deg o lunghezza minore di dSawDiam/2 * cos( 20/2)) ma maggiore di un minimo
|
|
if ( ( ptPm - ptP1) - ( ptPm - ptP1) * vtTg * vtTg):len() > 100 * GEO.EPS_SMALL then
|
|
local vtTg1 = ptPm - ptP1 ; vtTg1:normalize()
|
|
local vtTg2 = ptP2 - ptPm ; vtTg2:normalize()
|
|
local dDist1 = dist( ptP1, ptPm)
|
|
local dDist2 = dist( ptP2, ptPm)
|
|
local dCosMax = 0.951 -- cos( 18°)
|
|
local dLenMin = 2
|
|
local dLenMax = 0.5 * dSawDiam * 0.17365 + 1
|
|
if vtTg1 * vtTg2 < dCosMax or ( dDist1 < dLenMax and dDist1 > dLenMin) or ( dDist2 < dLenMax and dDist2 > dLenMin) then
|
|
if abs( vtTg1 * vtOrthO) < abs( vtTg2 * vtOrthO) then
|
|
ptP2 = Point3d( ptPm)
|
|
dAllEnd = - dDist2 - 10 * GEO.EPS_SMALL
|
|
else
|
|
ptP1 = Point3d( ptPm)
|
|
dAllStart = - dDist1 - 10 * GEO.EPS_SMALL
|
|
end
|
|
vtTg = ptP2 - ptP1 ; vtTg:normalize()
|
|
end
|
|
end
|
|
-- verifico se lavorazione con lama sotto e testa sopra
|
|
if not dVzLimDwnUp then dVzLimDwnUp = -0.5 end
|
|
local bDownUp = ( vtN:getZ() < dVzLimDwnUp)
|
|
local nFaceUse = nOrthoOpposite
|
|
if bDownUp then nFaceUse = BeamLib.GetOrtupOpposite( nOrthoOpposite) end
|
|
local bWsRight = ( bInvert ~= bDownUp)
|
|
local nWorkSide = EgtIf( bWsRight, MCH_MILL_WS.RIGHT, MCH_MILL_WS.LEFT)
|
|
-- Versore di riferimento
|
|
local vtRef = Vector3d( vtTg)
|
|
vtRef:rotate( vtN, EgtIf( bInvert, -90, 90))
|
|
-- Versore esterno
|
|
local vtOut = vtRef - vtRef * vtTg * vtTg ; vtOut:normalize()
|
|
-- Versore ausiliario (direzione braccio)
|
|
local vtAux = Vector3d( vtN:getX(), vtN:getY(), 0) ; vtAux:normalize()
|
|
vtAux:rotate( Z_AX(), EgtIf( bWsRight, 90, -90))
|
|
if vtAux:isSmall() then
|
|
vtAux = Vector3d( vtOut:getX(), vtOut:getY(), 0) ; vtAux:normalize()
|
|
else
|
|
if abs( vtAux * vtOut) < GEO.EPS_SMALL then
|
|
if abs( vtTg:getZ()) > 0.5 then
|
|
if vtAux * vtRef < 0 then
|
|
vtAux = - vtAux
|
|
end
|
|
elseif vtAux * vtTg > 0 then
|
|
vtAux = - vtAux
|
|
end
|
|
elseif vtAux * vtOut < 0 then
|
|
vtAux = - vtAux
|
|
end
|
|
end
|
|
-- parametri di attacco/uscita
|
|
local b3Box = BBox3d( b3Raw)
|
|
b3Box:expand( dCutSic)
|
|
local ptP1act = ptP1 + vtN * dCutOffset
|
|
local ptP2act = ptP2 + vtN * dCutOffset
|
|
-- attacco perpendicolare
|
|
local dLiTang, dLiPerp, dLoTang, dLoPerp = BeamLib.CalcLeadInOutPerpGeom( ptP1act, ptP2act, vtV1, vtV2, vtN, dSawDiam/2, vtRef, dCutExtra, b3Box)
|
|
local dLenLi = sqrt( dLiTang * dLiTang + dLiPerp * dLiPerp)
|
|
local dLenLo = sqrt( dLoTang * dLoTang + dLoPerp * dLoPerp)
|
|
-- attacco tangente
|
|
local dLi2Tang, dLi2Perp, dLo2Tang, dLo2Perp = BeamLib.CalcLeadInOutTangGeom( ptP1act, ptP2act, vtN, dSawDiam/2, vtRef, dCutExtra, b3Box)
|
|
local dLenLi2 = abs( dLi2Tang)
|
|
local dLenLo2 = abs( dLo2Tang)
|
|
-- scelgo l'attacco più conveniente (se non taglio praticamente longitudinale)
|
|
if abs( vtTg:getX()) < 0.9848 and
|
|
( ( abs( vtTg:getZ()) < 0.17 and ( vtV1:getZ() < -0.5 or vtV2:getZ() < -0.5)) or ( 1.5*dLenLi2 < dLenLi and 1.5*dLenLo2 < dLenLo) or 1.5*( dLenLi2 + dLenLo2) < ( dLenLi + dLenLo)) then
|
|
dLiTang, dLiPerp, dLoTang, dLoPerp = dLi2Tang, dLi2Perp, dLo2Tang, dLo2Perp
|
|
end
|
|
-- posizione braccio
|
|
EgtOutLog( 'vtN=' .. tostring( vtN) .. ' vtRef=' .. tostring( vtRef) .. ' vtOut=' .. tostring( vtOut) .. ' vtAux=' .. tostring( vtAux), 3)
|
|
local nSCC = MCH_SCC.NONE
|
|
if not BD.C_SIMM or vtRef:getZ() < 0.866 then
|
|
if abs( vtAux:getX()) > abs( vtAux:getY()) - GEO.EPS_SMALL then
|
|
nSCC = EgtIf( ( vtAux:getX() > -GEO.EPS_SMALL), MCH_SCC.ADIR_XP, MCH_SCC.ADIR_XM)
|
|
else
|
|
nSCC = EgtIf( ( vtAux:getY() > -GEO.EPS_SMALL), MCH_SCC.ADIR_YP, MCH_SCC.ADIR_YM)
|
|
end
|
|
end
|
|
-- per macchine PF se possibile preferisco tenere la testa più davanti
|
|
if BD.C_SIMM and abs( vtTg:getZ()) < 0.01 then
|
|
if nSCC == MCH_SCC.ADIR_YP then
|
|
nSCC = MCH_SCC.ADIR_YM
|
|
end
|
|
end
|
|
-- inserisco la lavorazione di taglio
|
|
local sName = 'Cut_' .. ( EgtGetName( nSurfId) or tostring( nSurfId)) .. '_' .. tostring( nFacet + 1)
|
|
local nMchFId = EgtAddMachining( sName, sCutting)
|
|
if not nMchFId then
|
|
local sErr = 'Error adding machining ' .. sName .. '-' .. sCutting
|
|
EgtOutLog( sErr)
|
|
return false, sErr
|
|
end
|
|
sName = EgtGetOperationName( nMchFId)
|
|
-- aggiungo geometria
|
|
EgtSetMachiningGeometry( {{ nSurfId, nFacet}})
|
|
-- imposto uso faccia
|
|
EgtSetMachiningParam( MCH_MP.FACEUSE, nFaceUse)
|
|
-- imposto posizione braccio porta testa
|
|
EgtSetMachiningParam( MCH_MP.SCC, nSCC)
|
|
-- imposto inversione e lato correzione
|
|
EgtSetMachiningParam( MCH_MP.INVERT, bInvert)
|
|
EgtSetMachiningParam( MCH_MP.WORKSIDE, nWorkSide)
|
|
-- affondamento aggiuntivo
|
|
EgtSetMachiningParam( MCH_MP.OFFSR, -dCutExtra)
|
|
-- offset longitudinale
|
|
EgtSetMachiningParam( MCH_MP.OFFSL, EgtIf( bDownUp, -dCutOffset, dCutOffset))
|
|
-- imposto attacco/uscita
|
|
EgtSetMachiningParam( MCH_MP.LITANG, dLiTang)
|
|
EgtSetMachiningParam( MCH_MP.LIPERP, dLiPerp)
|
|
EgtSetMachiningParam( MCH_MP.LOTANG, dLoTang)
|
|
EgtSetMachiningParam( MCH_MP.LOPERP, dLoPerp)
|
|
-- imposto allungamenti iniziale e finale
|
|
EgtSetMachiningParam( MCH_MP.STARTADDLEN, dAllStart - dAccStart)
|
|
EgtSetMachiningParam( MCH_MP.ENDADDLEN, dAllEnd - dAccEnd)
|
|
-- eventuali note
|
|
if sNotes and #sNotes > 0 then EgtSetMachiningParam( MCH_MP.USERNOTES, sNotes) end
|
|
-- eseguo
|
|
if not EgtApplyMachining( true, false) then
|
|
local _, sErr = EgtGetLastMachMgrError()
|
|
EgtSetOperationMode( nMchFId, false)
|
|
return false, sErr
|
|
end
|
|
return true, sName, nMchFId
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
function BeamLib.UpdateHCING( nRawId, dHCI, dDist)
|
|
local dOldHCI = EgtGetInfo( nRawId, 'HCING', 'd') or 0
|
|
if dDist and dDist > dOldHCI + 0.1 then
|
|
return
|
|
end
|
|
if dHCI > dOldHCI then
|
|
EgtSetInfo( nRawId, 'HCING', dHCI)
|
|
end
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
function BeamLib.UpdateTCING( nRawId, dTCI)
|
|
local dOldTCI = EgtGetInfo( nRawId, 'TCING', 'd') or 0
|
|
if dTCI > dOldTCI then
|
|
EgtSetInfo( nRawId, 'TCING', dTCI)
|
|
end
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
function BeamLib.GetNzLimDownUp( b3Raw)
|
|
if not BD.C_SIMM then
|
|
return EgtIf( b3Raw:getDimZ() < 200, -0.5, -0.258)
|
|
else
|
|
return -0.484
|
|
end
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
function BeamLib.IsSplittedPartPhase( nPhase)
|
|
local sVal = BeamLib.GetPhaseType( nPhase)
|
|
return ( sVal == 'END' or sVal == 'MID2' or sVal == 'END2')
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
function BeamLib.IsPartFinalPhase( nPhase)
|
|
local sVal = BeamLib.GetPhaseType( nPhase)
|
|
return ( sVal == 'END' or sVal == 'END2')
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function BeamLib.GetPhaseType( nPhase)
|
|
return ( EgtGetInfo( EgtGetPhaseDisposition( nPhase) or GDB_ID.NULL, 'TYPE') or '')
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
return BeamLib
|