From 32a0e1d2b5071e7b4d9d4895ae57ed5ab09013f1 Mon Sep 17 00:00:00 2001 From: Daniele Bariletti Date: Wed, 10 Apr 2024 09:21:49 +0200 Subject: [PATCH] EgtGeomKernel : - gestiti i loop di trim di sup di Bezier che escono dal parametrico. - corretto un errore di triangolazione per sup di Bezier. --- Tree.cpp | 58 +++++++++++++++++++++++++++++++++++++++----------------- Tree.h | 3 ++- 2 files changed, 43 insertions(+), 18 deletions(-) diff --git a/Tree.cpp b/Tree.cpp index 12568fd..b27bf97 100644 --- a/Tree.cpp +++ b/Tree.cpp @@ -24,6 +24,7 @@ #include "/EgtDev/Include/EGkDistPointCurve.h" #include "/EgtDev/Include/EGkCurve.h" #include "DistPointCrvComposite.h" +#include "/EgtDev/Include/EGkSfrCreate.h" #include using namespace std ; @@ -60,6 +61,38 @@ Tree::Tree( const Point3d ptBl, const Point3d ptTr) m_mTree.insert( pair< int, Cell>( -1, cRoot)) ; } +//---------------------------------------------------------------------------- +bool +Tree::LimitLoop( PolyLine& pl, POLYLINEVECTOR& vPl) const +{ + // creo la flat region di trim, quella del parametrico e li interseco + PtrOwner pSfrTrim( GetSurfFlatRegionFromPolyLine( pl)) ; + bool bInverted = false ; + if ( ! pSfrTrim->GetNormVersor().IsZplus()) { + pSfrTrim->Invert() ; + bInverted = true ; + } + PtrOwner pParamTrim( GetSurfFlatRegionRectangle( SBZ_TREG_COEFF * m_nSpanU, SBZ_TREG_COEFF * m_nSpanV)) ; + if ( ! pParamTrim->Intersect( *pSfrTrim) || ! pParamTrim->IsValid()) + return false ; + + // ricostruisco la curva tenendo solo le parti dentro lo spazio parametrico + // devo recuperare la polyline dei bordi dei vari chunk creati + for ( int c = 0 ; c < int( pParamTrim->GetChunkCount()) ; ++c) { + PtrOwner pCrv ( pParamTrim->GetLoop( c, 0)) ; + if ( bInverted) + pCrv->Invert() ; + PolyLine plApprox ; + double dLinTol = 10 * EPS_SMALL, dAngTolDeg = 5 ; + int nType = 0 ; + pCrv->ApproxWithLines( dLinTol, dAngTolDeg, nType, plApprox) ; + // aggiungo la polyline del chunk + vPl.push_back( plApprox) ; + } + + return false ; +} + //---------------------------------------------------------------------------- void Tree::SetSurf( const SurfBezier* pSrfBz, bool bSplitPatches, const Point3d& ptMin, const Point3d& ptMax) @@ -71,7 +104,6 @@ Tree::SetSurf( const SurfBezier* pSrfBz, bool bSplitPatches, const Point3d& ptMi m_vLoop.clear() ; m_mChunk.clear() ; m_vPlApprox.clear() ; - m_vChunk.clear() ; m_vPolygons.clear() ; m_vPlLoop2D.clear() ; @@ -93,8 +125,6 @@ Tree::SetSurf( const SurfBezier* pSrfBz, bool bSplitPatches, const Point3d& ptMi // recupero i loop di trim e li divido per chunk if ( m_bTrimmed) { int nLoop = 0 ; - INTVECTOR vChunk ; - // recupero la superficie di trim per avere accesso diretto ai loop e mantenendo le informazioni sui chunk PtrOwner pTrimReg( m_pSrfBz->GetTrimRegion()->Clone()) ; double dLinTol = 0.01 ; // questo è riferito allo spazio parametrico @@ -102,7 +132,7 @@ Tree::SetSurf( const SurfBezier* pSrfBz, bool bSplitPatches, const Point3d& ptMi for ( int i = 0 ; i < pTrimReg->GetChunkCount() ; ++ i) { PtrOwner pChunk( pTrimReg->CloneChunk( i)) ; for ( int j = 0 ; j < pChunk->GetLoopCount( 0) ; ++ j) { - vChunk.push_back( nLoop) ; + //vChunk.push_back( nLoop) ; // i chunk della falt region sono ancora flat region composte da 1 chunk PtrOwner pLoop ( pChunk->GetLoop( 0, j)) ; // rimuovo i difetti dei loop prima di salvarli @@ -127,21 +157,13 @@ Tree::SetSurf( const SurfBezier* pSrfBz, bool bSplitPatches, const Point3d& ptMi bCCW = true ; else bCCW = false ; - m_vPlApprox.push_back( tuple(plApprox,bCCW)) ; + // limito il loop allo spazio parametrico // potrei ottenere più loop a partire da quello originale + POLYLINEVECTOR vPlLimited ; + LimitLoop( plApprox, vPlLimited) ; + for ( int k = 0 ; k < int( vPlLimited.size()) ; ++k) + m_vPlApprox.push_back( tuple(vPlLimited[k], bCCW)) ; } - // li riordino dal più grande al più piccolo - sort(vChunk.begin(), vChunk.end(), [this]( const int& a, const int& b) { double dArea1, dArea2 ; - m_vLoop[a]->GetAreaXY( dArea1) ; - m_vLoop[b]->GetAreaXY( dArea2) ; - return dArea1 > dArea2 ; }) ; - m_vChunk.push_back( vChunk) ; - vChunk.clear() ; } - // li riordino dal più grande al più piccolo - sort(m_vChunk.begin(), m_vChunk.end(), [this]( const INTVECTOR& a, const INTVECTOR& b) { double dArea1, dArea2 ; - m_vLoop[a[0]]->GetAreaXY( dArea1) ; - m_vLoop[b[0]]->GetAreaXY( dArea2) ; - return dArea1 > dArea2 ;}) ; } // salvo i vertici 3d della cella root Point3d ptTop( nSpanU * SBZ_TREG_COEFF, nSpanV * SBZ_TREG_COEFF) ; @@ -3509,6 +3531,8 @@ Tree::CheckIfBetween( const Inters& inA, const Inters& inB) const } else if ( nEdge == 7) nEdge = 0 ; + if ( AreSameEdge( inA.nIn, inA.nOut) && ! CheckIfBefore( inA.nIn, inA.vpt[0], inA.vpt.back())) + vEdges.push_back( nEdge) ; // creo la sequenza di Edges da scorrere per trovare i possibili validNextStart while ( ! AreSameEdge( nEdge, inA.nIn) || (int) vEdges.size() == 0) { vEdges.push_back( nEdge) ; diff --git a/Tree.h b/Tree.h index 8c45bc7..22dc08c 100644 --- a/Tree.h +++ b/Tree.h @@ -254,6 +254,7 @@ class Tree std::vector GetPoles( void) { return m_vbPole ;} ; // funzione che restituisce i flag che indicano se i lati sono collassati in dei poli private : + bool LimitLoop( PolyLine& pl, POLYLINEVECTOR& vPl) const ; // funzione che limita i loop di trim allo spazio parametrico bool Split( int nId, double dSplitValue) ; // funzione di split di una cella al parametro indicato nella direzione data da bVert bool Split( int nId) ; // funzione di split di una cella dell'albero a met� nella direzione data da bVert void Balance( void) ; // creo rami in modo che tutte tutte le foglie abbiano come adiacenti foglie ad una profondit� di +- 1 @@ -290,7 +291,7 @@ class Tree const SurfBezier* m_pSrfBz ; // superficie di bezier DBLVECTOR m_vDim ; // distanze tra i vertici della superficie di bezier in 3d in ordine antiorario a partire da ptP00 bool m_bTrimmed ; // superficie trimmata - INTMATRIX m_vChunk ; // elenco dei loop divisi per chunk + //INTMATRIX m_vChunk ; // elenco dei loop divisi per chunk std::map m_mChunk ; // mappa in cui vengono salvati chunk di appartenza per ogni loop di trim ICURVEPOVECTOR m_vLoop ; // curve di loop std::vector> m_vPlApprox ; // vettore contenente le approssimazioni dei loop // il bool indica se la curva è CCW