luca.mazzoleni
547 lines
24 KiB
Lua
547 lines
24 KiB
Lua
-- PreSimulationLib.lua by Egalware s.r.l. 2025/11/24
|
|
-- Libreria stima collisioni per travi
|
|
|
|
-- Tabella per definizione modulo
|
|
local PreSimulationLib = {}
|
|
|
|
-- Include
|
|
require( 'EgtBase')
|
|
local BeamLib = require( 'BeamLib')
|
|
local BeamData = require( 'BeamDataNew')
|
|
|
|
EgtOutLog( ' PreSimulationLib started', 1)
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
local function GetMachineAxes()
|
|
|
|
local LinearAxes = {}
|
|
local RotativeAxes = {}
|
|
|
|
-- si recuperano tutti gli assi, lineari e rotativi
|
|
local AxesNames = EgtGetAllCurrAxesNames()
|
|
for i = 1, #AxesNames do
|
|
-- EgtGetAxisType restituisce vero se asse lineare, false se asse rotativo
|
|
if EgtGetAxisType( AxesNames[i]) then
|
|
LinearAxes[#LinearAxes + 1] = {}
|
|
LinearAxes[#LinearAxes].sName = AxesNames[i]
|
|
else
|
|
RotativeAxes[#RotativeAxes + 1] = {}
|
|
RotativeAxes[#RotativeAxes].sName = AxesNames[i]
|
|
end
|
|
end
|
|
|
|
return LinearAxes, RotativeAxes
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
local function LogOutstroke( sToolName, ptOnToolTipCenter, vtHead, OptionalParameters)
|
|
|
|
-- parametri opzionali
|
|
OptionalParameters = OptionalParameters or {}
|
|
local LinearAxesValues = OptionalParameters.LinearAxesValues
|
|
local RotativeAxesValues = OptionalParameters.RotativeAxesValues
|
|
|
|
-- gruppo per geometrie temporanee
|
|
local idTempGroup = BeamLib.GetTempGroup()
|
|
|
|
-- si disegnano punto e vettore
|
|
local idPoint = EgtPoint( idTempGroup, ptOnToolTipCenter, GDB_RT.GLOB)
|
|
local idVector = EgtVector( idTempGroup, vtHead, ptOnToolTipCenter, GDB_RT.GLOB)
|
|
EgtSetColor( idPoint, RED())
|
|
EgtSetColor( idVector, RED())
|
|
|
|
-- nome utensile
|
|
EgtOutLog( 'Tool ' .. sToolName)
|
|
|
|
-- si loggano valori di punto e vettore
|
|
EgtOutLog( ' Presimulation : OutStroke, Tip Point = ' .. tostring( ptOnToolTipCenter) .. ', id = ' .. idPoint .. ', vtHead = ' .. tostring( vtHead) .. ', id = ' .. idVector)
|
|
|
|
-- se disponibili, si loggano anche i valori calcolati degli assi
|
|
if LinearAxesValues then
|
|
EgtOutLog( ' ' .. 'Lin1' .. ' = ' .. tostring( LinearAxesValues[1]) .. ', ' .. 'Lin2' .. ' = ' .. tostring( LinearAxesValues[2]) .. ', ' .. 'Lin3' .. ' = ' .. tostring( LinearAxesValues[3]))
|
|
end
|
|
if RotativeAxesValues then
|
|
EgtOutLog( ' ' .. 'Rot1' .. ' = ' .. tostring( RotativeAxesValues[1]) .. ', ' .. 'Rot2' .. ' = ' .. tostring( RotativeAxesValues[2]) .. ', ' .. 'Rot3' .. ' = ' .. tostring( RotativeAxesValues[3]))
|
|
end
|
|
|
|
return
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
-- costruzione trimesh del grezzo restante in testa o in coda
|
|
local function GetRestlengthSurfTm( Part, sSide)
|
|
|
|
-- si costruisce il box in globale
|
|
local b3RestLength
|
|
if sSide == 'Head' then
|
|
local b3PartWithOvermaterial = BeamLib.GetPartBoxWithHeadTail( Part, sSide)
|
|
local ptStartRestLength = Point3d( Part.b3Part:getMax():getX(), Part.b3Part:getMax():getY(), Part.b3Part:getMax():getZ())
|
|
local ptEndRestLength = Point3d( b3PartWithOvermaterial:getMax():getX(), Part.b3Part:getMin():getY(), Part.b3Part:getMin():getZ())
|
|
b3RestLength = BBox3d( ptStartRestLength, ptEndRestLength)
|
|
elseif sSide == 'Tail' then
|
|
local b3PartWithOvermaterial = BeamLib.GetPartBoxWithHeadTail( Part, sSide)
|
|
local dXMin = b3PartWithOvermaterial:getMin():getX()
|
|
-- si evita sempre di lavorare col motore dietro la coda della barra (potrebbe succedere con barra restante molto corta): in quel caso si deve sempre separare prima
|
|
dXMin = min( dXMin, Part.b3Part:getMin():getX() - 2000)
|
|
local ptStartRestLength = Point3d( Part.b3Part:getMin():getX(), Part.b3Part:getMax():getY(), Part.b3Part:getMax():getZ())
|
|
local ptEndRestLength = Point3d( dXMin, Part.b3Part:getMin():getY(), Part.b3Part:getMin():getZ())
|
|
b3RestLength = BBox3d( ptStartRestLength, ptEndRestLength)
|
|
-- caso non testato, non dovrebbe mai finire qui (il default che arriva da fuori è Tail)
|
|
else
|
|
return nil
|
|
end
|
|
|
|
-- si crea la trimesh dal box
|
|
local idRestLengthBoxTm = EgtSurfTmBBox( Part.idTempGroup, b3RestLength , false, GDB_RT.GLOB)
|
|
|
|
return idRestLengthBoxTm
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
function PreSimulationLib.GetPointOnToolTipCenter( ptPointAtDepth, vtHead, vtNFace, vtToolOffset, Tool)
|
|
|
|
return ptPointAtDepth + vtToolOffset * Tool.dDiameter / 2 + vtNFace * EgtIf( AreSameVectorApprox( vtHead, vtNFace), 0, Tool.dThickness)
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
-- calcolo punto sull'uscita testa a partire dal punto di lavorazione o di attacco sul diametro utensile
|
|
local function GetToolExitPoint( ptMachining, vtNEdge, vtHead, Tool, bIsDownUp)
|
|
|
|
local ptToolExitPoint = Point3d( ptMachining + vtNEdge * Tool.dDiameter / 2) + vtHead * EgtIf( bIsDownUp, ( Tool.dLength - Tool.dThickness), Tool.dLength)
|
|
|
|
return ptToolExitPoint
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
-- calcolo pivot in riferimento globale, dati punto sull'uscita utensile e direzioni
|
|
local function GetGlobalPivot( ptToolExit, vtC, vtHead, vtMovePivot)
|
|
|
|
-- frame solidale all'utensile (lo stesso in cui vtMovePivot è definito)
|
|
local frTool = Frame3d( ptToolExit, vtHead, vtC)
|
|
local vtMovePivotGlob = Vector3d( vtMovePivot)
|
|
vtMovePivotGlob:toGlob( frTool)
|
|
local ptPivot = ptToolExit + vtMovePivotGlob
|
|
|
|
return ptPivot
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
-- restituisce i punti notevoli della lavorazioni in cui fare il controllo
|
|
local function GetCollisionPointsToCheck( Edge, dDepthToMachine)
|
|
|
|
local PointsToCheck = {}
|
|
|
|
-- punti notevoli
|
|
local ptStart = Edge.ptStart + Edge.vtN * ( Edge.dElevation - dDepthToMachine)
|
|
local ptEnd = Edge.ptEnd + Edge.vtN * ( Edge.dElevation - dDepthToMachine)
|
|
local ptMid = Point3d( ( ptStart + ptEnd) / 2)
|
|
|
|
-- caso ottimizzato: lato parallelo ad una direzione principale
|
|
local bIsEdgeParallelToMainDirection =
|
|
AreSameOrOppositeVectorApprox( Edge.vtEdge, X_AX())
|
|
or AreSameOrOppositeVectorApprox( Edge.vtEdge, Y_AX())
|
|
or AreSameOrOppositeVectorApprox( Edge.vtEdge, Z_AX())
|
|
|
|
-- aggiunta punti
|
|
table.insert( PointsToCheck, ptStart)
|
|
if not bIsEdgeParallelToMainDirection then
|
|
table.insert( PointsToCheck, ptMid)
|
|
end
|
|
table.insert( PointsToCheck, ptEnd)
|
|
|
|
return PointsToCheck
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
local function CheckOutOfStrokePoint( ptOnToolTipCenter, vtHead, nSCC, Tool, vtAux, sBlockedAxis)
|
|
|
|
-- impostazione utensile
|
|
local bOkTool = EgtSetCalcTool( Tool.sName, Tool.sHead, Tool.nExit)
|
|
if not bOkTool then
|
|
error( 'CheckOutOfStrokePoint : cannot set calc tool')
|
|
end
|
|
|
|
-- settaggio SCC per discriminare soluzioni multiple
|
|
EgtSetCalcSolCh( nSCC)
|
|
|
|
-- se presente, settaggio asse bloccato
|
|
if sBlockedAxis and type( sBlockedAxis) == "string" then
|
|
local BlockedAxis = EgtSplitString( sBlockedAxis, '=')
|
|
EgtSetRotAxisBlock( BlockedAxis[1], tonumber( BlockedAxis[2]))
|
|
end
|
|
|
|
-- calcolo assi rotativi
|
|
local bOkAngles, nSolutionsAngles, RotativeAxesValues = EgtGetCalcAnglesEx( vtHead, vtAux)
|
|
local dRotative1 = RotativeAxesValues[1]
|
|
local dRotative2 = RotativeAxesValues[2]
|
|
local dRotative3 = RotativeAxesValues[3]
|
|
|
|
if not bOkAngles then
|
|
error( ' CheckOutOfStrokePoint : error')
|
|
end
|
|
|
|
-- se nessuna soluzione dagli assi rotativi, è in extracorsa
|
|
if nSolutionsAngles == 0 then
|
|
|
|
if EgtGetDebugLevel() >= 3 then
|
|
LogOutstroke( Tool.sName, ptOnToolTipCenter, vtHead, { RotativeAxesValues = { dRotative1, dRotative2, dRotative3}})
|
|
end
|
|
return true
|
|
end
|
|
|
|
-- calcolo assi lineari
|
|
local bOkPositions, _, dLinear1, dLinear2, dLinear3 = EgtGetCalcPositions( ptOnToolTipCenter, dRotative1, dRotative2, dRotative3)
|
|
|
|
if not bOkPositions then
|
|
|
|
error( ' CheckOutOfStrokePoint : error')
|
|
end
|
|
|
|
-- verifica finecorsa per assi lineari (assi rotativi già verificati)
|
|
local bAllAxesInStroke = EgtVerifyOutstroke( dLinear1, dLinear2, dLinear3)
|
|
|
|
-- extracorsa
|
|
if not bAllAxesInStroke then
|
|
|
|
if EgtGetDebugLevel() >= 3 then
|
|
LogOutstroke( Tool.sName, ptOnToolTipCenter, vtHead, { LinearAxesValues = { dLinear1, dLinear2, dLinear3}, RotativeAxesValues = { dRotative1, dRotative2, dRotative3}})
|
|
end
|
|
return true
|
|
end
|
|
|
|
-- EgtSetAxisPos( 'T', dT)
|
|
-- EgtSetAxisPos( 'Y', dY)
|
|
-- EgtSetAxisPos( 'Z', dZ)
|
|
-- EgtSetAxisPos( 'C', dC1)
|
|
-- EgtSetAxisPos( 'A', dA1)
|
|
|
|
-- se si arriva qui, il punto non è in finecorsa
|
|
return false
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
-- check extracorsa da punti sul tip dell'utensile
|
|
function PreSimulationLib.CheckOutOfStrokeFromPoints( PointsOnToolTipCenter, vtHead, nSCC, Tool, vtAux, sBlockedAxis)
|
|
|
|
for i = 1, #PointsOnToolTipCenter do
|
|
|
|
local bOutOfStroke = CheckOutOfStrokePoint( PointsOnToolTipCenter[i], vtHead, nSCC, Tool, vtAux, sBlockedAxis)
|
|
|
|
-- se trovato extracorsa inutile procedere con gli altri punti
|
|
if bOutOfStroke then
|
|
return true
|
|
end
|
|
end
|
|
|
|
-- se arrivati qui, nessun extracorsa
|
|
return false
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
-- check extracorsa da geometria
|
|
-- TODO da considerare anche gli attacchi
|
|
function PreSimulationLib.CheckOutOfStrokeFromGeometry( idGeometry, vtHead, nSCC, Tool, vtAux, sBlockedAxis)
|
|
|
|
local b3GeomMaxOffset = EgtGetBBoxGlob( idGeometry, GDB_BB.STANDARD)
|
|
local ptBoxCenter = b3GeomMaxOffset:getCenter()
|
|
local dBoxDimX = b3GeomMaxOffset:getDimX()
|
|
local dBoxDimY = b3GeomMaxOffset:getDimY()
|
|
local dBoxDimZ = b3GeomMaxOffset:getDimZ()
|
|
|
|
-- si controlla il finecorsa nei punti al centro delle 6 facce del box
|
|
local PointsOnToolTipCenter = {}
|
|
-- X+
|
|
table.insert( PointsOnToolTipCenter, Point3d( ptBoxCenter + dBoxDimX / 2 * X_AX()))
|
|
-- X-
|
|
table.insert( PointsOnToolTipCenter, Point3d( ptBoxCenter - dBoxDimX / 2 * X_AX()))
|
|
-- Y+
|
|
table.insert( PointsOnToolTipCenter, Point3d( ptBoxCenter + dBoxDimY / 2 * Y_AX()))
|
|
-- Y-
|
|
table.insert( PointsOnToolTipCenter, Point3d( ptBoxCenter - dBoxDimY / 2 * Y_AX()))
|
|
-- Z+
|
|
table.insert( PointsOnToolTipCenter, Point3d( ptBoxCenter + dBoxDimZ / 2 * Z_AX()))
|
|
-- Z-
|
|
table.insert( PointsOnToolTipCenter, Point3d( ptBoxCenter - dBoxDimZ / 2 * Z_AX()))
|
|
|
|
local bOutOfStroke = PreSimulationLib.CheckOutOfStrokeFromPoints( PointsOnToolTipCenter, vtHead, nSCC, Tool, vtAux, sBlockedAxis)
|
|
|
|
return bOutOfStroke
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
local function MoveMachineAxesToPosition( ptOnToolTipCenter, vtHead, vtAux)
|
|
|
|
-- calcolo assi rotativi
|
|
local bOkAngles, nSolutionsAngles, RotativeAxesValues = EgtGetCalcAnglesEx( vtHead, vtAux)
|
|
local dRotative1 = RotativeAxesValues[1]
|
|
local dRotative2 = RotativeAxesValues[2]
|
|
local dRotative3 = RotativeAxesValues[3]
|
|
|
|
if not bOkAngles then
|
|
error( ' MoveMachineAxesToPosition : error')
|
|
end
|
|
|
|
-- calcolo assi lineari
|
|
local bOkPositions, _, dLinear1, dLinear2, dLinear3 = EgtGetCalcPositions( ptOnToolTipCenter, dRotative1, dRotative2, dRotative3)
|
|
|
|
if not bOkPositions then
|
|
|
|
error( ' MoveMachineAxesToPosition : error')
|
|
end
|
|
|
|
local AxesNames = EgtGetAllCurrAxesNames()
|
|
local dTHome = EgtGetAxisHomePos( AxesNames[1])
|
|
|
|
-- spostamento assi in posizione (la T non si sposta perchè si sposta il pezzo)
|
|
EgtSetAxisPos( AxesNames[2], dLinear2)
|
|
EgtSetAxisPos( AxesNames[3], dLinear3)
|
|
EgtSetAxisPos( AxesNames[4], dRotative1)
|
|
EgtSetAxisPos( AxesNames[5], dRotative2)
|
|
if dRotative3 then
|
|
EgtSetAxisPos( AxesNames[6], dRotative3)
|
|
end
|
|
|
|
return dLinear1 - dTHome
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
local function CheckCollisionPoint( sAxis, ptOnToolTipCenter, vtHead, vtAux, Part, bCannotSplitRestLength, sRestLengthSideForPreSimulation, bCheckOnlyRestlength)
|
|
|
|
-- spostamento assi macchina in posizione
|
|
local dDeltaXHeadOffset = MoveMachineAxesToPosition( ptOnToolTipCenter, vtHead, vtAux)
|
|
|
|
-- si recuperano gli id delle geometrie dell'asse con cui controllare la collisione
|
|
local idCollisionGroup = EgtGetFirstNameInGroup( EgtGetAxisId( sAxis), 'COLLISION')
|
|
local idCollisionGroupOther = EgtGetFirstNameInGroup( EgtGetAxisId( sAxis), 'OTHER_COLLISION') or GDB_ID.NULL
|
|
local CollisionGroupEntitiesId = EgtGetAllInGroup( idCollisionGroup)
|
|
local CollisionGroupOtherEntitiesId = EgtGetAllInGroup( idCollisionGroupOther)
|
|
-- si tengono solo gli elementi trimesh
|
|
local CollisionSurfTmId = {}
|
|
for i = 1, #CollisionGroupEntitiesId do
|
|
if EgtGetType( CollisionGroupEntitiesId[i]) == GDB_TY.SRF_MESH then
|
|
local idCollisionSurfTmCopy = EgtCopyGlob( CollisionGroupEntitiesId[i], Part.idTempGroup)
|
|
EgtMove( idCollisionSurfTmCopy, Vector3d( dDeltaXHeadOffset, 0, 0), GDB_RT.GLOB)
|
|
table.insert( CollisionSurfTmId, idCollisionSurfTmCopy)
|
|
end
|
|
end
|
|
-- se presenti geometrie nel gruppo other si aggiungono anche quelle
|
|
if CollisionGroupOtherEntitiesId and #CollisionGroupOtherEntitiesId > 0 then
|
|
for i = 1, #CollisionGroupOtherEntitiesId do
|
|
if EgtGetType( CollisionGroupOtherEntitiesId[i]) == GDB_TY.SRF_MESH then
|
|
local idCollisionOtherSurfTmCopy = EgtCopyGlob( CollisionGroupOtherEntitiesId[i], Part.idTempGroup)
|
|
EgtMove( idCollisionOtherSurfTmCopy, Vector3d( dDeltaXHeadOffset, 0, 0), GDB_RT.GLOB)
|
|
table.insert( CollisionSurfTmId, idCollisionOtherSurfTmCopy)
|
|
end
|
|
end
|
|
end
|
|
|
|
-- check collisione con pezzo
|
|
local bCollisionFoundPiece = false
|
|
if not bCheckOnlyRestlength then
|
|
local idCheckCollisionTm = Part.idBoxTm
|
|
-- se testa o coda attaccate, si considerano nella superficie di collisione
|
|
if bCannotSplitRestLength then
|
|
local b3CheckCollision = BeamLib.GetPartBoxWithHeadTail( Part, sRestLengthSideForPreSimulation)
|
|
idCheckCollisionTm = EgtSurfTmBBox( Part.idTempGroup, b3CheckCollision, false, GDB_RT.GLOB)
|
|
end
|
|
for i = 1, #CollisionSurfTmId do
|
|
bCollisionFoundPiece = EgtCDeSolidSolid( idCheckCollisionTm, CollisionSurfTmId[i], BeamData.COLL_SIC)
|
|
if not type( bCollisionFoundPiece) == "boolean" then
|
|
error( 'Presimulation fail')
|
|
end
|
|
if EgtGetDebugLevel() >= 3 and bCollisionFoundPiece then
|
|
EgtSetColor( CollisionSurfTmId[i], RED())
|
|
end
|
|
if bCollisionFoundPiece then
|
|
break
|
|
end
|
|
end
|
|
|
|
-- se trovata collisione con pezzo è inutile procedere con il grezzo
|
|
if bCollisionFoundPiece then
|
|
|
|
return true
|
|
end
|
|
end
|
|
|
|
-- check collisione con grezzo restante, se con il pezzo non c'è collisione e non è un taglio di testa o coda
|
|
local bCollisionFoundRestLength = false
|
|
if not ( bCollisionFoundPiece or bCannotSplitRestLength) then
|
|
local idRestLengthSurfFr = GetRestlengthSurfTm( Part, sRestLengthSideForPreSimulation)
|
|
if idRestLengthSurfFr then
|
|
for i = 1, #CollisionSurfTmId do
|
|
bCollisionFoundRestLength = EgtCDeSolidSolid( idRestLengthSurfFr, CollisionSurfTmId[i], BeamData.COLL_SIC)
|
|
if not type( bCollisionFoundRestLength) == "boolean" then
|
|
error( 'Presimulation fail')
|
|
end
|
|
if EgtGetDebugLevel() >= 3 and bCollisionFoundRestLength then
|
|
EgtSetColor( CollisionSurfTmId[i], ORANGE())
|
|
end
|
|
if bCollisionFoundRestLength then
|
|
break
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
return false, bCollisionFoundRestLength
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
-- controllo collisione con verifica intersezione trimesh e geometrie da macchina
|
|
local function CheckCollisionWithAxis( sAxis, MachiningParameters, OptionalParameters)
|
|
|
|
-- parametri obbligatori
|
|
local Edge = MachiningParameters.Edge
|
|
local vtNFace = MachiningParameters.vtNFace
|
|
local vtHead = MachiningParameters.vtHead
|
|
local Part = MachiningParameters.Part
|
|
local Tool = MachiningParameters.Tool
|
|
local dDepthToMachine = MachiningParameters.dDepthToMachine
|
|
|
|
-- parametri opzionali
|
|
OptionalParameters = OptionalParameters or {}
|
|
local bCheckOnlyRestlength = OptionalParameters.bCheckOnlyRestlength or false
|
|
local sRestLengthSideForPreSimulation = OptionalParameters.sRestLengthSideForPreSimulation or 'Tail'
|
|
local bCannotSplitRestLength = OptionalParameters.bCannotSplitRestLength or false
|
|
local vtAux = OptionalParameters.vtAux
|
|
|
|
-- se normale faccia non parallela a direzione testa c'è qualcosa che non va
|
|
if not AreSameOrOppositeVectorApprox( vtNFace, vtHead) then
|
|
error( 'CheckCollisionWithAxis : invalid directions')
|
|
end
|
|
|
|
-- punti notevoli della lavorazione in cui fare il check
|
|
local PointsToCheck = OptionalParameters.PointsToCheck or GetCollisionPointsToCheck( Edge, dDepthToMachine)
|
|
|
|
-- punti sul tip dell'utensile, in centro
|
|
local PointsOnToolTipCenter = {}
|
|
for i = 1, #PointsToCheck do
|
|
PointsOnToolTipCenter[i] = PreSimulationLib.GetPointOnToolTipCenter( PointsToCheck[i], vtHead, vtNFace, Edge.vtN, Tool)
|
|
end
|
|
|
|
local bMoveAfterSplit = false
|
|
|
|
-- se almeno in un punto c'è collisione con il pezzo si ritorna collisione
|
|
-- se non si trova collisione si ritorna se è necessario separare prima di effettuare la lavorazione (ossia non c'è collisione con il pezzo ma c'è con il grezzo restante)
|
|
for i = 1, #PointsOnToolTipCenter do
|
|
|
|
local bCollisionFoundPiece, bCollisionFoundRestLength = CheckCollisionPoint( sAxis, PointsOnToolTipCenter[i], vtHead, vtAux, Part, bCannotSplitRestLength, sRestLengthSideForPreSimulation, bCheckOnlyRestlength)
|
|
|
|
-- se trovata collisione con pezzo è inutile controllare gli altri punti
|
|
if bCollisionFoundPiece then
|
|
|
|
return true
|
|
|
|
-- se trovata collisione con grezzo si setta che la lavorazione è da fare dopo separazione e si prosegue con gli altri punti
|
|
elseif bCollisionFoundRestLength then
|
|
|
|
bMoveAfterSplit = true
|
|
end
|
|
end
|
|
|
|
-- se si arriva qui significa che non è stata trovata alcuna collisione con pezzo
|
|
return false, bMoveAfterSplit
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
function PreSimulationLib.CheckCollision( sBladeEngagement, Parameters, OptionalParameters)
|
|
|
|
local bCollisionFound
|
|
local bMoveAfterSplitL3, bMoveAfterSplitR3, bMoveAfterSplitR2, bMoveAfterSplitR1
|
|
|
|
-- parametri obbligatori
|
|
local Edge = Parameters.Edge
|
|
local vtNFace = Parameters.vtNFace
|
|
local Tool = Parameters.Tool
|
|
|
|
-- parametri opzionali, in parte da far transitare
|
|
OptionalParameters = OptionalParameters or {}
|
|
|
|
local OptionalParametersCheckCollisionWithAxis = {}
|
|
OptionalParametersCheckCollisionWithAxis.bCheckOnlyRestlength = false
|
|
OptionalParametersCheckCollisionWithAxis.PointsToCheck = OptionalParameters.PointsToCheck or nil
|
|
OptionalParametersCheckCollisionWithAxis.sRestLengthSideForPreSimulation = OptionalParameters.sRestLengthSideForPreSimulation or 'Tail'
|
|
OptionalParametersCheckCollisionWithAxis.bCannotSplitRestLength = OptionalParameters.bCannotSplitRestLength or false
|
|
OptionalParametersCheckCollisionWithAxis.sBlockedAxis = OptionalParameters.sBlockedAxis
|
|
OptionalParametersCheckCollisionWithAxis.vtAux = OptionalParameters.vtAux
|
|
|
|
local sBlockedAxis = OptionalParameters.sBlockedAxis
|
|
local bIsDicing = OptionalParameters.bIsDicing or false
|
|
local bDisableRealElevationCheck = OptionalParameters.bDisableRealElevationCheck or false
|
|
local bCheckOnlyRestlengthForAxisABC = false
|
|
|
|
-- se cubetti in modalità standard (no DownUp) gli assi AB e C si controllano solo con grezzo (ci sarebbe collisione con il materiale già rimosso controllando AB e C con pezzo)
|
|
if bIsDicing and ( sBladeEngagement == 'Standard') then
|
|
bCheckOnlyRestlengthForAxisABC = true
|
|
-- se l'elevazione reale (rispetto al pezzo + eventuale materiale in testa/coda) è maggiore del massimo materiale è sempre collisione
|
|
-- TODO rifare con funzione
|
|
elseif not bDisableRealElevationCheck then
|
|
local Edge = Parameters.Edge
|
|
local vtNFace = Parameters.vtNFace
|
|
local dDepthToMachine = Parameters.dDepthToMachine
|
|
local b3BoxForElevationCheck = BBox3d( Parameters.Part.b3Part)
|
|
-- se è un taglio di testa o coda va aggiunto il sovramateriale
|
|
if OptionalParametersCheckCollisionWithAxis.bCannotSplitRestLength then
|
|
b3BoxForElevationCheck = BeamLib.GetPartBoxWithHeadTail( Parameters.Part, OptionalParametersCheckCollisionWithAxis.sRestLengthSideForPreSimulation)
|
|
end
|
|
-- trimesh rettangolare con un lato corrispondente al lato da lavorare e larghezza come spessore utensile
|
|
local idTrimesh = EgtSurfTmRectangle( Parameters.Part.idTempGroup, Edge.ptStart, Edge.ptEnd, Edge.ptEnd + vtNFace * Parameters.Tool.dThickness, GDB_RT.GLOB)
|
|
local vtNTrimesh = EgtSurfTmFacetNormVersor( idTrimesh, 0, GDB_ID.ROOT)
|
|
-- se trimesh con normale opposta a quella del lato, si inverte (non si sa a priori che verso avrà)
|
|
if not AreSameVectorApprox( Edge.vtN, vtNTrimesh) then
|
|
EgtInvertSurf( idTrimesh)
|
|
end
|
|
local dRealElevation = EgtSurfTmFacetElevationInBBox( idTrimesh, 0, b3BoxForElevationCheck, true, GDB_ID.ROOT)
|
|
local dRealDepthToMachine = ( dRealElevation - Parameters.Edge.dElevation + dDepthToMachine)
|
|
if dRealDepthToMachine > Parameters.Tool.dMaxDepth + 10 * GEO.EPS_SMALL then
|
|
return true
|
|
end
|
|
end
|
|
|
|
-- SCC
|
|
local nSCC = Tool.SetupInfo.GetSCC( Edge.vtN, Edge.vtEdge, vtNFace)
|
|
|
|
-- si settano utensile, SCC e asse bloccato per il controllo collisione
|
|
local bOkTool = EgtSetCalcTool( Tool.sName, Tool.sHead, Tool.nExit)
|
|
if not bOkTool then
|
|
error( 'CheckCollisionWithAxis : cannot set calc tool')
|
|
end
|
|
EgtSetCalcSolCh( nSCC)
|
|
if sBlockedAxis and type( sBlockedAxis) == "string" then
|
|
local BlockedAxis = EgtSplitString( sBlockedAxis, '=')
|
|
EgtSetRotAxisBlock( BlockedAxis[1], tonumber( BlockedAxis[2]))
|
|
end
|
|
|
|
-- nomi degli assi con cui controllare la collisione
|
|
local AxesNames = EgtGetAllCurrAxesNames()
|
|
local sL3 = AxesNames[3]
|
|
local sR3 = AxesNames[6]
|
|
local sR2 = AxesNames[5]
|
|
local sR1 = AxesNames[4]
|
|
|
|
-- ultimo asse lineare prima dei rotativi (solitamente Z) si controlla sempre
|
|
bCollisionFound, bMoveAfterSplitL3 = CheckCollisionWithAxis( sL3, Parameters, OptionalParametersCheckCollisionWithAxis)
|
|
|
|
-- assi rotativi: se richiesto si controlla la collisione solo col grezzo
|
|
OptionalParametersCheckCollisionWithAxis.bCheckOnlyRestlength = bCheckOnlyRestlengthForAxisABC
|
|
|
|
if sR3 and not bCollisionFound then
|
|
bCollisionFound, bMoveAfterSplitR3 = CheckCollisionWithAxis( sR3, Parameters, OptionalParametersCheckCollisionWithAxis)
|
|
end
|
|
|
|
if not bCollisionFound then
|
|
bCollisionFound, bMoveAfterSplitR2 = CheckCollisionWithAxis( sR2, Parameters, OptionalParametersCheckCollisionWithAxis)
|
|
end
|
|
|
|
if not bCollisionFound then
|
|
bCollisionFound, bMoveAfterSplitR1 = CheckCollisionWithAxis( sR1, Parameters, OptionalParametersCheckCollisionWithAxis)
|
|
end
|
|
|
|
local bMoveAfterSplit = bMoveAfterSplitL3 or bMoveAfterSplitR3 or bMoveAfterSplitR2 or bMoveAfterSplitR1
|
|
|
|
return bCollisionFound, bMoveAfterSplit
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
return PreSimulationLib |