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

EgtGeomKernel 1.6h3 :

Browse Source 
- migliorata approssimazione curve per riconoscimento di tratti rettilinei
- aggiunta CopyMaterial a GeomDB
- correzioni a IntersCurveCurve per le curve approssimate
- aggiunte a Intervals Union, Intersection e Difference
- correzioni a SelfIntersCurve per curve approssimate
- aggiunte funzioni di creazione Regioni (Rectangle, Stadium, Disk e da zuppa di curve)
- migliorie varie a Regioni e introduzione dei componenti connessi (chunk).
This commit is contained in:
Dario Sassi
2015-08-18 07:30:08 +00:00
parent f4b88af3e1
commit bab45eb4f3
28 changed files with 1049 additions and 346 deletions
Download Patch File Download Diff File Expand all files Collapse all files
IntersCurveCurve.cpp
+62 -39
View File
@@ -1,13 +1,13 @@
//----------------------------------------------------------------------------
// EgalTech 2014-2014
// EgalTech 2015-2015
//----------------------------------------------------------------------------
// File : IntersCurveCurve.cpp Data : 20.06.14 Versione : 1.5f6
// File : IntersCurveCurve.cpp Data : 17.08.15 Versione : 1.6h3
// Contenuto : Implementazione della classe intersezione curva/curva.
//
//
//
// Modifiche : 15.06.14 DS Creazione modulo.
//
// 17.08.15 DS Modifiche per curve approssimate.
//
//----------------------------------------------------------------------------
@@ -37,71 +37,78 @@ IntersCurveCurve::IntersCurveCurve( const ICurve& CurveA, const ICurve& CurveB,
// inizializzazioni
m_bOverlaps = false ;
m_nNumInters = 0 ;
m_pOriCrv[0] = &CurveA ;
m_pOriCrv[1] = &CurveB ;
m_pCurve[0] = &CurveA ;
m_pCurve[1] = &CurveB ;
// puntatori alle curve usate nei calcoli (originali o temporanee)
const ICurve* pCalcCrv[2] ;
// per eventuale esplosione temporanea delle curve
PtrOwner<ICurve> pTmpCrv[2] ;
// ciclo sulle curve per verificare se da approssimare
for ( int i = 0 ; i < 2 ; ++ i) {
// se curva è arco da approssimare oppure è curva di Bezier
if ( ( m_pOriCrv[i]->GetType() == CRV_ARC && IsArcToApprox( *m_pOriCrv[i])) ||
m_pOriCrv[i]->GetType() == CRV_BEZ) {
if ( ( m_pCurve[i]->GetType() == CRV_ARC && IsArcToApprox( *m_pCurve[i])) ||
m_pCurve[i]->GetType() == CRV_BEZ) {
// approssimo con rette
PolyLine PL ;
if ( ! m_pOriCrv[i]->ApproxWithLines( EPS_SMALL, ANG_TOL_STD_DEG, ICurve::APL_STD, PL))
if ( ! m_pCurve[i]->ApproxWithLines( EPS_SMALL, ANG_TOL_STD_DEG, ICurve::APL_STD, PL))
return ;
m_pTmpCrv[i].Set( CreateBasicCurveComposite()) ;
if ( IsNull( m_pTmpCrv[i]))
pTmpCrv[i].Set( CreateBasicCurveComposite()) ;
if ( IsNull( pTmpCrv[i]))
return ;
if ( ! GetBasicCurveComposite( Get( m_pTmpCrv[i]))->FromPolyLine( PL))
if ( ! GetBasicCurveComposite( Get( pTmpCrv[i]))->FromPolyLine( PL))
return ;
m_pCurve[i] = Get( m_pTmpCrv[i]) ;
pCalcCrv[i] = Get( pTmpCrv[i]) ;
}
else
m_pCurve[i] = m_pOriCrv[i] ;
pCalcCrv[i] = m_pCurve[i] ;
}
// chiamo calcolatore opportuno
switch ( m_pCurve[0]->GetType()) {
switch ( pCalcCrv[0]->GetType()) {
case CRV_LINE :
switch ( m_pCurve[1]->GetType()) {
switch ( pCalcCrv[1]->GetType()) {
case CRV_LINE :
LineLineCalculate( *m_pCurve[0], *m_pCurve[1], bAreSegments) ;
LineLineCalculate( *pCalcCrv[0], *pCalcCrv[1], bAreSegments) ;
break ;
case CRV_ARC :
LineArcCalculate( *m_pCurve[0], *m_pCurve[1]) ;
LineArcCalculate( *pCalcCrv[0], *pCalcCrv[1]) ;
break ;
case CRV_COMPO :
LineCrvCompoCalculate( *m_pCurve[0], *m_pCurve[1]) ;
LineCrvCompoCalculate( *pCalcCrv[0], *pCalcCrv[1]) ;
break ;
}
break ;
case CRV_ARC :
switch ( m_pCurve[1]->GetType()) {
switch ( pCalcCrv[1]->GetType()) {
case CRV_LINE :
ArcLineCalculate( *m_pCurve[0], *m_pCurve[1]) ;
ArcLineCalculate( *pCalcCrv[0], *pCalcCrv[1]) ;
break ;
case CRV_ARC :
ArcArcCalculate( *m_pCurve[0], *m_pCurve[1]) ;
ArcArcCalculate( *pCalcCrv[0], *pCalcCrv[1]) ;
break ;
case CRV_COMPO :
ArcCrvCompoCalculate( *m_pCurve[0], *m_pCurve[1]) ;
ArcCrvCompoCalculate( *pCalcCrv[0], *pCalcCrv[1]) ;
break ;
}
break ;
case CRV_COMPO :
switch ( m_pCurve[1]->GetType()) {
switch ( pCalcCrv[1]->GetType()) {
case CRV_LINE :
CrvCompoLineCalculate( *m_pCurve[0], *m_pCurve[1]) ;
CrvCompoLineCalculate( *pCalcCrv[0], *pCalcCrv[1]) ;
break ;
case CRV_ARC :
CrvCompoArcCalculate( *m_pCurve[0], *m_pCurve[1]) ;
CrvCompoArcCalculate( *pCalcCrv[0], *pCalcCrv[1]) ;
break ;
case CRV_COMPO :
CrvCompoCrvCompoCalculate( *m_pCurve[0], *m_pCurve[1]) ;
CrvCompoCrvCompoCalculate( *pCalcCrv[0], *pCalcCrv[1]) ;
break ;
}
break ;
}
// per curve approssimate, sistemo...
AdjustIntersParams( ( pCalcCrv[0] != m_pCurve[0]), ( pCalcCrv[1] != m_pCurve[1])) ;
}
//----------------------------------------------------------------------------
@@ -233,6 +240,35 @@ IntersCurveCurve::CrvCompoCrvCompoCalculate( const ICurve& CurveA, const ICurve&
}
}
//----------------------------------------------------------------------------
bool
IntersCurveCurve::AdjustIntersParams( bool bAdjCrvA, bool bAdjCrvB)
{
// se non ci sono intersezioni, non va fatto alcunché
if ( m_Info.size() == 0)
return true ;
// se le curve originali non sono state approssimate, non va fatto alcunché
if ( ! bAdjCrvA && ! bAdjCrvB)
return true ;
// procedo ad aggiustare
for ( auto& aInfo : m_Info) {
// se curve originali approssimate, devo ricalcolare i parametri dei punti di intersezione
if ( bAdjCrvA) {
if ( ! m_pCurve[0]->GetParamAtPoint( aInfo.IciA[0].ptI, aInfo.IciA[0].dU, 10 * EPS_SMALL))
return false ;
if ( aInfo.bOverlap && ! m_pCurve[0]->GetParamAtPoint( aInfo.IciA[1].ptI, aInfo.IciA[1].dU, 10 * EPS_SMALL))
return false ;
}
if ( bAdjCrvB) {
if ( ! m_pCurve[1]->GetParamAtPoint( aInfo.IciB[0].ptI, aInfo.IciB[0].dU, 10 * EPS_SMALL))
return false ;
if ( aInfo.bOverlap && ! m_pCurve[1]->GetParamAtPoint( aInfo.IciB[1].ptI, aInfo.IciB[1].dU, 10 * EPS_SMALL))
return false ;
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
IntersCurveCurve::GetOverlaps( void)
@@ -254,19 +290,6 @@ IntersCurveCurve::GetIntCrvCrvInfo( int nInd, IntCrvCrvInfo& aInfo)
if ( nInd < 0 || nInd >= m_nNumInters)
return false ;
aInfo = m_Info[nInd] ;
// se curve originali approssimate, devo ricalcolare i parametri dei punti di intersezione
if ( m_pCurve[0] != m_pOriCrv[0]) {
if ( ! m_pOriCrv[0]->GetParamAtPoint( aInfo.IciA[0].ptI, aInfo.IciA[0].dU, 10 * EPS_SMALL))
return false ;
if ( aInfo.bOverlap && ! m_pOriCrv[0]->GetParamAtPoint( aInfo.IciA[1].ptI, aInfo.IciA[1].dU, 10 * EPS_SMALL))
return false ;
}
if ( m_pCurve[1] != m_pOriCrv[1]) {
if ( ! m_pOriCrv[1]->GetParamAtPoint( aInfo.IciB[0].ptI, aInfo.IciB[0].dU, 10 * EPS_SMALL))
return false ;
if ( aInfo.bOverlap && ! m_pOriCrv[1]->GetParamAtPoint( aInfo.IciB[1].ptI, aInfo.IciB[1].dU, 10 * EPS_SMALL))
return false ;
}
return true ;
}