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

EgtMachKernel :

Browse Source 
- merge file mancanti.
This commit is contained in:
Riccardo Elitropi
2023-06-23 09:19:28 +02:00
parent 4711734998
commit fac69a1d65
4 changed files with 141 additions and 374 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Operation.cpp
+8 -293
View File
@@ -22,7 +22,6 @@
#include "/EgtDev/Include/EGkAngle.h"
#include "/EgtDev/Include/EGkBBox1d.h"
#include "/EgtDev/Include/EGkGeoPoint3d.h"
#include "/EgtDev/Include/EGkGeoVector3d.h"
#include "/EgtDev/Include/EGkCurveLine.h"
#include "/EgtDev/Include/EGkCurveArc.h"
#include "/EgtDev/Include/EGkArcSpecial.h"
@@ -37,7 +36,6 @@
#include "/EgtDev/Include/EXeConst.h"
#include "/EgtDev/Include/EgtNumUtils.h"
#include "/EgtDev/Include/EgtPointerOwner.h"
#include "/EgtDev/Include/EGkDistPointSurfTm.h"
using namespace std ;
@@ -519,269 +517,6 @@ Operation::GetAhPointUnderRaw( const Point3d& ptP, const Vector3d& vtTool, doubl
return false ;
}
bool IsPointOnBox( BBox3d BBox, Point3d pt) {
if( BBox.IsEmpty())
return false ;
int nCheck = 0 ;
if(( pt.x - BBox.GetMin().x) < EPS_SMALL)
++nCheck ;
if(( pt.y - BBox.GetMin().y) < EPS_SMALL)
++nCheck ;
if(( pt.z - BBox.GetMin().z) < EPS_SMALL)
++nCheck ;
if(( pt.x - BBox.GetMax().x) < EPS_SMALL)
++nCheck ;
if(( pt.y - BBox.GetMax().y) < EPS_SMALL)
++nCheck ;
if(( pt.z - BBox.GetMax().z) < EPS_SMALL)
++nCheck ;
if( nCheck >= 2)
return true ;
return false ;
}
//----------------------------------------------------------------------------
bool
Operation::GetSignedDistFromStmRaw( int nPhase, const Point3d ptP, const Vector3d vtDir,
double& dDist, Vector3d& vtNorm) const
{
// controllo MachManager e database geometrico
if ( m_pMchMgr == nullptr || m_pGeomDB == nullptr)
return false ;
// la distanza è negativa se il punto è interno, positiva se esterno, 0 se sulla suprificie
const double RAY_LEN = 100000 ;
bool bIsInside = false ; // se punto interno ad un RawPart
bool bIsPointOn = false ; // se il punto è stato trovato su una faccia
bool bIsOnLoop = false ; // se il punto è su un loop
bool bIsOnBox = false ; // se il punto è su un Box3D
bool bSkip = false ; // se salto controlli sui bordi
// vettore dei grezzi
ISURFTMPOVECTOR vSrfRawPart ;
int nRawId = m_pMchMgr->GetFirstRawPart() ;
while( nRawId != GDB_ID_NULL) {
// verifico che il grezzo compaia nella fase
if ( m_pMchMgr->VerifyRawPartPhase( nRawId, nPhase)) {
// recupero l'oggetto dal database con tale Id
int nRawSolidId = m_pGeomDB->GetFirstNameInGroup( nRawId, MACH_RAW_SOLID) ;
const IGeoObj* pGObj = m_pGeomDB->GetGeoObj( nRawSolidId) ;
// recupero il frame in cui si trova
Frame3d frRaw ;
m_pGeomDB->GetGlobFrame( nRawSolidId, frRaw) ;
if ( pGObj == nullptr)
return false ;
// controllo che sia una Trimesh
if ( pGObj->GetType() == SRF_TRIMESH) {
// Trimesh della parte p-esima
PtrOwner<ISurfTriMesh> pStmRawPart( CloneSurfTriMesh( GetSurfTriMesh( pGObj))) ;
if( IsNull( pStmRawPart))
return false ;
// porto la trimesh in globale
pStmRawPart->ToGlob( frRaw) ;
// salvo la superificie
vSrfRawPart.emplace_back( pStmRawPart->Clone()) ;
// distanza dalla parte p-esima
double dCurrDist = 0 ;
// recupero la distanza tra il punto e la parte p-esima
DistPointSurfTm distPtStm( ptP, *pStmRawPart) ;
if ( ! distPtStm.GetDist( dCurrDist))
return false ;
// controllo se il punto è dentro al grezzo
if ( distPtStm.IsPointInside()) {
bIsInside = true ;
bSkip = true ;
}
if ( dCurrDist < EPS_SMALL && !bSkip) {
// controllo se sono su un Loop
POLYLINEVECTOR vP ;
bool bIsCurrOnLoop = false ;
for ( int i = 0 ; i < pStmRawPart->GetFacetCount() ; ++ i) {
pStmRawPart->GetFacetLoops( i, vP) ;
for ( int j = 0 ; j < ( int)vP.size() && !bIsCurrOnLoop ; ++ j) {
PtrOwner<ICurveComposite> pCrvEdge( CreateCurveComposite()) ;
if ( IsNull( pCrvEdge))
return false ;
pCrvEdge->FromPolyLine( vP[j]) ;
if ( !pCrvEdge->IsValid() || pCrvEdge->GetCurveCount() == 0)
return false ;
if( pCrvEdge->IsPointOn( ptP))
bIsCurrOnLoop = true ;
}
}
// se il punto sta sulla curva...
if ( bIsCurrOnLoop) {
if ( bIsOnLoop) { // se ho già trovato una curva che contiene il punto ...
BBox3d bCurrBox ;
if ( ! pStmRawPart->GetBBox( GLOB_FRM, bCurrBox))
return false ;
if ( IsPointOnBox( bCurrBox, ptP)) { // se il punto sta sul Box
if ( bIsOnBox) { // se il punto stava già su un altro Box
bIsInside = false ;
bSkip = true ;
}
else // se il punto non stava già su un box
bIsInside = true ;
bSkip = true ;
}
else // se il punto non sta sul box
bIsInside = true ;
}
else { // se è la prima curva a contenere il punto
bIsPointOn = true ;
// controllo se il punto sta sulla faccia del box del grezzo corrente
BBox3d bCurrBox ;
if ( ! pStmRawPart->GetBBox( GLOB_FRM, bCurrBox))
return false ;
// controllo se il punto sta su una faccia del box
if ( IsPointOnBox( bCurrBox, ptP))
bIsOnBox = true ;
}
}
// se il punto non sta sulla curva ...
else {
if ( bIsPointOn) {
bIsInside = true ;
bSkip = true ;
}
else
bIsPointOn = true ;
}
}
}
}
// passo al grezzo successivo
nRawId = m_pMchMgr->GetNextRawPart( nRawId) ;
}
if ( bSkip) {
bIsPointOn = false ;
bIsOnLoop = false ;
bIsOnBox = false ;
}
double dCurrDist = bIsInside ? -INFINITO : INFINITO ; // distanza attuale
dDist = dCurrDist ;
double dTmpCurrDist = 0 ;
for ( int i = 0 ; i < ( int)vSrfRawPart.size() ; ++ i) {
ILSIVECTOR vInfo ; // info
Triangle3d Tria ; // triangolo della trimesh intersecato
// recupero la distanza tra il punto e la parte p-esima
if ( IntersLineSurfTm( ptP, vtDir, RAY_LEN, *vSrfRawPart[i], vInfo)) {
if (( int)vInfo.size() == 0)
continue ;
DistPointSurfTm distPtStm( ptP, *vSrfRawPart[i]) ;
if( ! distPtStm.GetDist( dTmpCurrDist))
return false ;
if (( bIsPointOn && !bIsInside)) { // punto sulla superificie totale dei grezzi
// se è il grezzo è quello giusto ...
if ( dTmpCurrDist < EPS_SMALL) {
dDist = 0 ;
vSrfRawPart[i]->GetTriangle( vInfo[0].nT, Tria) ;
vtNorm = Tria.GetN() ;
return true ;
}
else { // se sono su un altro ... ( prima o poi ritorno al controllo sopra ...)
}
}
else if (( int)vInfo.size() == 1 && bIsInside) {
if ( distPtStm.IsPointInside() || dTmpCurrDist < EPS_SMALL) {
// se punto interno alla grezzo corrente
double dUCurr = vInfo[0].dU ;
// se direzione || ad una faccia faccia, ma punto non interno al grezzo corrente
if ( vInfo[0].nILTT == ILTT_SEGM || vInfo[0].nILTT == ILTT_EDGE)
double dUCurr = - vInfo[0].dU2 ;
if ( dUCurr > dCurrDist) {
dCurrDist = dUCurr ;
vSrfRawPart[i]->GetTriangle( vInfo[0].nT, Tria) ;
vtNorm = Tria.GetN() ;
}
}
else { // se interno ma non al grezzo corrente ( prima o poi ritono al controllo sopra )
}
}
else if (( int)vInfo.size() > 1) { // se la linea trapassa il grezzo corrente (entra ed esce)...
if ( bIsInside) { // e il punto è interno ( quindi non al grezzo corrente )
double dUCurr = 0 ;
int nT ;
for ( int j = 0 ; j < ( int)vInfo.size() ; ++ j) {
IntLinStmInfo Info = vInfo[j] ;
if ( Info.nILTT == ILTT_SEGM || Info.nILTT == ILTT_SEGM_ON_EDGE) {
// se prosegue un tratto precedente, non devo controllare sia minimo
dUCurr = Info.dU2 ;
nT = Info.nT ;
//break ; ???????
}
// se altrimenti intersezione puntuale, verifico che esca (coseno >= 0)
else if ( Info.dCosDN > - COS_ORTO_ANG_ZERO) {
dUCurr = Info.dU ;
nT = Info.nT ;
break ;
}
// se altrimenti è la prima ed entra ( non la considero ...)
else {
}
}
if ( dUCurr > dCurrDist) { // tengo la distanza più grande
dCurrDist = dUCurr ;
vSrfRawPart[i]->GetTriangle( nT, Tria) ;
vtNorm = Tria.GetN() ;
}
}
else { // se invece è un punto esterno a tutto
if ( vInfo[0].dU < dCurrDist) { // tengo la distanza ( positiva) più grande
dCurrDist = vInfo[0].dU ;
vSrfRawPart[i]->GetTriangle( vInfo[0].nT, Tria) ;
vtNorm = Tria.GetN() ;
}
}
}
}
}
if ( dCurrDist > INFINITO - 1 && ! bIsInside) // non ho intersecato mai nessun grezzo
dDist = INFINITO ;
if ( dCurrDist < -INFINITO + 1 && bIsInside) // sono interno ma non interseco un grezzo ... errore
return false ;
dDist = bIsInside ? - dCurrDist : dCurrDist ;
return true ;
}
//----------------------------------------------------------------------------
bool
Operation::GetUhPointAboveRaw( const Point3d& ptP, const Vector3d& vtTool, double dToolRad, double dToolRadForElev,
@@ -1038,25 +773,13 @@ Operation::GetDistanceFromRawBottom( int nPhase, int nPathId, double dToler, dou
{
if ( m_pMchMgr == nullptr || m_pGeomDB == nullptr)
return false ;
// ricerco grezzi interessati dal percorso
BBox3d b3Compo ;
if ( ! m_pGeomDB->GetGlobalBBox( nPathId, b3Compo))
return false ;
return GetDistanceFromRawBottom( nPhase, b3Compo, dToler, dRbDist, dAllRbDist) ;
}
//----------------------------------------------------------------------------
bool
Operation::GetDistanceFromRawBottom( int nPhase, BBox3d& b3Test, double dToler, double& dRbDist, double& dAllRbDist) const
{
if ( m_pMchMgr == nullptr || m_pGeomDB == nullptr)
return false ;
// recupero distanza da fondo dei grezzi interessati o no dal percorso
dRbDist = 0 ;
dAllRbDist = 0 ;
b3Test.Expand( dToler, dToler, 0) ;
BBox3d b3Compo ;
if ( ! m_pGeomDB->GetGlobalBBox( nPathId, b3Compo))
return false ;
b3Compo.Expand( dToler, dToler, 0) ;
int nRawId = m_pMchMgr->GetFirstRawPart() ;
while ( nRawId != GDB_ID_NULL) {
// verifico che il grezzo compaia nella fase
@@ -1064,8 +787,8 @@ Operation::GetDistanceFromRawBottom( int nPhase, BBox3d& b3Test, double dToler,
BBox3d b3Raw ;
int nRawSolidId = m_pGeomDB->GetFirstNameInGroup( nRawId, MACH_RAW_SOLID) ;
if ( m_pGeomDB->GetGlobalBBox( nRawSolidId, b3Raw)) {
double dDist = b3Test.GetMax().z - b3Raw.GetMin().z ;
if ( b3Test.OverlapsXY( b3Raw) && dDist > dRbDist)
double dDist = b3Compo.GetMax().z - b3Raw.GetMin().z ;
if ( b3Compo.OverlapsXY( b3Raw) && dDist > dRbDist)
dRbDist = dDist ;
if ( dDist > dAllRbDist)
dAllRbDist = dDist ;
@@ -1345,9 +1068,6 @@ Operation::ApproxWithArcsIfUseful( ICurveComposite* pCompo, bool bCareTempProp)
pCompo->GetExtrusion( vtExtr) ;
double dThick = 0 ;
pCompo->GetThickness( dThick) ;
// recupero le tmp prop della composita
int nProp0 = pCompo->GetTempProp( 0) ;
int nProp1 = pCompo->GetTempProp( 1) ;
// verifico se ci sono tante linee corte
int nSmallLineCnt = 0 ;
const ICurve* pCrv = pCompo->GetFirstCurve() ;
@@ -1443,11 +1163,6 @@ Operation::ApproxWithArcsIfUseful( ICurveComposite* pCompo, bool bCareTempProp)
pCompo->SetExtrusion( vtExtr) ;
pCompo->SetThickness( dThick) ;
// riassegno temp prop alla composita
pCompo->SetTempProp( nProp0, 0) ;
pCompo->SetTempProp( nProp1, 1) ;
return true ;
}
@@ -1837,7 +1552,7 @@ Operation::SetBlockedRotAxis( const string& sBlockedAxis) const
for ( int i = 0 ; i < nRotAxes && ! bFound ; ++ i) {
string sAxToken ;
if ( m_pMchMgr->GetCurrMachine()->GetCurrAxisToken( i + nLinAxes, sAxToken) &&
sKey == Trim( sAxToken)) {
sKey == Trim( sAxToken, " \t\r\n=")) {
string sAxis ;
m_pMchMgr->GetCurrMachine()->GetCurrAxisName( i + nLinAxes, sAxis) ;
m_pMchMgr->SetRotAxisBlock( sAxis, dVal) ;
@@ -1915,7 +1630,7 @@ Operation::CalculateAxesValues( const string& sHint, bool bRotContOnNext, bool b
for ( int i = 0 ; i < nRotAxes ; ++ i) {
string sAxToken ;
if ( m_pMchMgr->GetCurrMachine()->GetCurrAxisToken( nLinAxes + i, sAxToken) &&
szKey == Trim( sAxToken)) {
szKey == Trim( sAxToken, " \t\r\n=")) {
double dVal ;
if ( FromString( szVal, dVal)) {
double dOffset = 0 ;