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

Merge commit 'b5ef9ae6dc7564e172af1a7558348e60b5da6a0f' into svuotature

Browse Source
This commit is contained in:
Riccardo Elitropi
2024-01-03 09:32:55 +01:00
parent 4c25e19753 b5ef9ae6dc
commit d845442ebd
12 changed files with 990 additions and 369 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Operation.cpp
+44 -97
View File
@@ -317,7 +317,7 @@ Operation::GetElevation( int nPhase, const Point3d& ptP1, const Point3d& ptP2,
double dElevS = 0 ;
// faccio test con un insieme di punti ( !!! sostituire con intersezione tra rettangolo e trimesh !!!)
const double STEP = 50 ;
int nStep = max( (int) ceil( ApproxDist( ptP1L, ptP2L) / STEP), 3) ;
int nStep = max( (int) ceil( ApproxDist( ptP1L, ptP2L) / STEP), 2) ;
for ( int i = 0 ; i <= nStep ; ++ i) {
// calcolo punto di test
double dFraz = i / (double) nStep ;
@@ -380,90 +380,6 @@ Operation::GetElevation( int nPhase, const Point3d& ptP1, const Point3d& ptP2, c
return true ;
}
#if 1
//----------------------------------------------------------------------------
bool
Operation::GetElevation( int nPhase, const Point3d& ptP, const Vector3d& vtTool, double dRad,
const Vector3d& vtDir, double& dElev) const
{
if ( m_pMchMgr == nullptr || m_pGeomDB == nullptr)
return false ;
// vettore grezzi interessati
INTVECTOR vRawStmId ;
// considero il punto centrale
if ( ! GetElevation( nPhase, ptP, vtDir, dElev, vRawStmId))
return false ;
// considero più posizioni sulla circonferenza
const int MIN_STEP = 9 ;
const int MAX_STEP = 127 ;
const double LEN_STEP = 12.5 ;
int nStep = Clamp( 2 * int( ( PIGRECO * dRad) / LEN_STEP) + 1, MIN_STEP, MAX_STEP) ;
Vector3d vtRad = FromUprightOrtho( vtTool) * dRad ;
for ( int i = 0 ; i < nStep ; ++ i) {
double dElevT = 0 ;
if ( ! GetElevation( nPhase, ptP + vtRad, vtDir, dElevT, vRawStmId))
return false ;
dElev = max( dElev, dElevT) ;
// passo alla direzione successiva
vtRad.Rotate( vtTool, ANG_FULL / nStep) ;
}
// considero i vertici che cadono entro il cilindro positivo spazzato dal fondo utensile
for ( auto nRawStmId : vRawStmId) {
// recupero la superficie
const ISurfTriMesh* pStm = GetSurfTriMesh( m_pGeomDB->GetGeoObj( nRawStmId)) ;
if ( pStm != nullptr) {
// recupero il riferimento della trimesh
Frame3d frStm ;
m_pGeomDB->GetGlobFrame( nRawStmId, frStm) ;
// ciclo sui vertici
Point3d ptV ;
int nV = pStm->GetFirstVertex( ptV) ;
while ( nV != SVT_NULL) {
ptV.ToGlob( frStm) ;
double dDist = ( ptV - ptP) * vtDir ;
if ( dDist > EPS_ZERO) {
if ( AreSameOrOppositeVectorApprox( vtTool, vtDir)) {
Vector3d vtOrtho = OrthoCompo( ptV - ptP, vtDir) ;
if ( vtOrtho.SqLen() < dRad * dRad + EPS_ZERO)
dElev = max( dElev, dDist) ;
}
else {
Vector3d vtOrtho = OrthoCompo( ptV - ptP, vtDir) ;
Vector3d vtMajAx = vtTool ^ vtDir ; vtMajAx.Normalize( EPS_ZERO) ;
Vector3d vtMajOrt = ParallCompo( vtOrtho, vtMajAx) ;
Vector3d vtMinOrt = ( vtOrtho - vtMajOrt) / abs( vtTool * vtDir) ;
if ( vtMajOrt.SqLen() + vtMinOrt.SqLen() < dRad * dRad + EPS_ZERO)
dElev = max( dElev, dDist) ;
}
}
nV = pStm->GetNextVertex( nV, ptV) ;
}
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
Operation::GetElevation( int nPhase, const Point3d& ptP, const Vector3d& vtTool, double dRad, double dLen,
const Vector3d& vtDir, double& dElev) const
{
if ( m_pMchMgr == nullptr || m_pGeomDB == nullptr)
return false ;
// sopra e sotto
double dElev1, dElev2 ;
if ( ! GetElevation( nPhase, ptP, vtTool, dRad, vtDir, dElev1))
return false ;
if ( ! GetElevation( nPhase, ptP + dLen * vtTool, vtTool, dRad, vtDir, dElev2))
return false ;
dElev = max( dElev1, dElev2) ;
return true ;
}
#else
//----------------------------------------------------------------------------
bool
Operation::GetElevation( int nPhase, const Point3d& ptP, const Vector3d& vtTool, double dRad,
@@ -508,10 +424,18 @@ Operation::GetElevation( int nPhase, const Point3d& ptP, const Vector3d& vtTool,
pCAvTlStm->SetStdTool( dLen, dRad, 0) ;
pCAvTlStm->SetSurfTm( *pStm) ;
double dDist = 0 ;
// per Collision Avoid il punto di riferimento non è il tip dell'utensile ma il naso mandrino
if ( ! pCAvTlStm->TestPosition( ptPL + dLen * vtToolL, vtToolL, vtDirL, dDist))
return false ;
if ( dDist > 0)
// non è ammesso un angolo oltre 90deg tra direzione utensile e vettore movimento
if ( vtToolL * vtDirL < 0) {
// il tip utensile è qui il naso mandrino per Collision Avoid
if ( ! pCAvTlStm->TestPosition( ptPL, -vtToolL, vtDirL, dDist))
return false ;
}
else {
// per Collision Avoid il punto di riferimento non è il tip dell'utensile ma il naso mandrino
if ( ! pCAvTlStm->TestPosition( ptPL + dLen * vtToolL, vtToolL, vtDirL, dDist))
return false ;
}
if ( dDist > EPS_SMALL)
vRawElev.emplace_back( nStmId, dDist) ;
}
}
@@ -541,7 +465,7 @@ Operation::GetElevation( int nPhase, const Point3d& ptP, const Vector3d& vtTool,
}
b3Tool.Expand( MAX_DIST_RAW) ;
// verifico la reale interferenza dell'utensile con i diversi grezzi
for ( int i = 0 ; i < vRawElev.size() ; ++ i) {
for ( int i = 0 ; i < int( vRawElev.size()) ; ++ i) {
// box del grezzo
BBox3d b3Raw ;
m_pGeomDB->GetGlobalBBox( vRawElev[i].first, b3Raw) ;
@@ -556,7 +480,30 @@ Operation::GetElevation( int nPhase, const Point3d& ptP, const Vector3d& vtTool,
return true ;
}
#endif
//----------------------------------------------------------------------------
bool
Operation::GetElevation( int nPhase, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtTool, double dRad, double dLen,
const Vector3d& vtDir, double& dElev) const
{
// risultato di default
bool bOk = false ;
dElev = 0 ;
// faccio test sui punti dall'inizio alla fine
const double STEP = 50 ;
int nStep = max( (int) ceil( ApproxDist( ptS, ptE) / STEP), 2) ;
for ( int i = 0 ; i <= nStep ; ++ i) {
// calcolo punto di test
double dFraz = i / (double) nStep ;
Point3d ptP = Media( ptS, ptE, dFraz) ;
// eseguo il calcolo
double dCurrElev ;
if ( GetElevation( nPhase, ptP, vtTool, dRad, dLen, vtDir, dCurrElev)) {
bOk = true ;
dElev = max( dElev, dCurrElev) ;
}
}
return bOk ;
}
//----------------------------------------------------------------------------
bool
@@ -597,17 +544,17 @@ Operation::GetAhPointUnderRaw( const Point3d& ptP, const Vector3d& vtTool, doubl
// determino elevazione del punto rispetto al grezzo a metà altezza
Point3d ptTest( ptP.x, ptP.y, dRawCentZ) ;
double dNewElev ;
if ( GetElevation( m_nPhase, ptTest - 10 * EPS_SMALL * vtTool, vtTool, dToolRadForElev, vtMyDir, dNewElev))
if ( GetElevation( m_nPhase, ptTest, vtTool, dToolRadForElev, vtMyDir, dNewElev))
dElev = max( dElev, dNewElev) ;
// se direzione di fuga quasi orizzontale (max 30 deg) e ingombro utensile rilevante rispetto ad altezza grezzo
if ( vtMyDir.z < 0.5 && dToolDimZ > dRawDimZ / 2) {
// determino elevazione del punto rispetto al grezzo a metà altezza più metà ingombro utensile
ptTest = Point3d( ptP.x, ptP.y, dRawCentZ + dToolDimZ / 2) ;
if ( GetElevation( m_nPhase, ptTest - 10 * EPS_SMALL * vtTool, vtTool, dToolRadForElev, vtMyDir, dNewElev))
if ( GetElevation( m_nPhase, ptTest, vtTool, dToolRadForElev, vtMyDir, dNewElev))
dElev = max( dElev, dNewElev) ;
// determino elevazione del punto rispetto al grezzo a metà altezza meno metà ingombro utensile
ptTest = Point3d( ptP.x, ptP.y, dRawCentZ - dToolDimZ / 2) ;
if ( GetElevation( m_nPhase, ptTest - 10 * EPS_SMALL * vtTool, vtTool, dToolRadForElev, vtMyDir, dNewElev))
if ( GetElevation( m_nPhase, ptTest, vtTool, dToolRadForElev, vtMyDir, dNewElev))
dElev = max( dElev, dNewElev) ;
}
return true ;
@@ -920,17 +867,17 @@ Operation::GetUhPointAboveRaw( const Point3d& ptP, const Vector3d& vtTool, doubl
// determino elevazione del punto rispetto al grezzo a metà altezza
Point3d ptTest( ptP.x, ptP.y, dRawCentZ) ;
double dNewElev ;
if ( GetElevation( m_nPhase, ptTest - 10 * EPS_SMALL * vtTool, vtTool, dToolRadForElev, vtMyDir, dNewElev))
if ( GetElevation( m_nPhase, ptTest, vtTool, dToolRadForElev, vtMyDir, dNewElev))
dElev = max( dElev, dNewElev) ;
// se direzione di fuga quasi orizzontale (max 30 deg) e ingombro utensile rilevante rispetto ad altezza grezzo
if ( vtMyDir.z > -0.5 && dToolDimZ > dRawDimZ / 2) {
// determino elevazione del punto rispetto al grezzo a metà altezza più metà ingombro utensile
ptTest = Point3d( ptP.x, ptP.y, dRawCentZ + dToolDimZ / 2) ;
if ( GetElevation( m_nPhase, ptTest - 10 * EPS_SMALL * vtTool, vtTool, dToolRadForElev, vtMyDir, dNewElev))
if ( GetElevation( m_nPhase, ptTest, vtTool, dToolRadForElev, vtMyDir, dNewElev))
dElev = max( dElev, dNewElev) ;
// determino elevazione del punto rispetto al grezzo a metà altezza meno metà ingombro utensile
ptTest = Point3d( ptP.x, ptP.y, dRawCentZ - dToolDimZ / 2) ;
if ( GetElevation( m_nPhase, ptTest - 10 * EPS_SMALL * vtTool, vtTool, dToolRadForElev, vtMyDir, dNewElev))
if ( GetElevation( m_nPhase, ptTest, vtTool, dToolRadForElev, vtMyDir, dNewElev))
dElev = max( dElev, dNewElev) ;
}
return true ;