From 5fc04c2791da468840e0e5d4968859bb4af30f9b Mon Sep 17 00:00:00 2001 From: Daniele Bariletti Date: Wed, 2 Apr 2025 12:52:55 +0200 Subject: [PATCH] EgtGeomKernel : - passaggio da mutex a shared_mutex nelle Bezier. --- SurfBezier.cpp | 745 +++++++++++++++++++++++++------------------------ Tree.cpp | 349 +++++++++++------------ 2 files changed, 548 insertions(+), 546 deletions(-) diff --git a/SurfBezier.cpp b/SurfBezier.cpp index f33f4bf..dd71711 100644 --- a/SurfBezier.cpp +++ b/SurfBezier.cpp @@ -40,6 +40,7 @@ #include "/EgtDev/Include/EGkGeoPoint3d.h" #include "/EgtDev/Include/EGkIntervals.h" #include "/EgtDev/Extern/Eigen/Dense" +#include using namespace std ; @@ -56,7 +57,7 @@ static unordered_map m_mBernCache ; // mapp //---------------------------------------------------------------------------- SurfBezier::SurfBezier( void) : m_pSTM( nullptr), m_nStatus( TO_VERIFY), m_nDegU(), m_nDegV(), m_nSpanU(), m_nSpanV(), m_bRat( false), - m_bTrimmed( false), m_bClosedU( false), m_bClosedV( false), m_pTrimReg(nullptr), m_nTempProp{0,0}, m_dTempParam{0.0,0.0} + m_bTrimmed( false), m_bClosedU( false), m_bClosedV( false), m_pTrimReg(nullptr), m_nTempProp{0,0}, m_dTempParam{0.0,0.0} { } @@ -72,11 +73,11 @@ SurfBezier::~SurfBezier( void) bool SurfBezier::Init( int nDegU, int nDegV, int nSpanU, int nSpanV, bool bIsRational) { - // verifico validità grado + // verifico validità grado if ( nDegU < 1 || nDegU > MAXDEG || nDegV < 1 || nDegV > MAXDEG || nSpanU < 1 || nSpanV < 1) return false ; - // imposto gradi e flag di razionale + // imposto gradi e flag di razionale m_nDegU = nDegU ; m_nDegV = nDegV ; m_nSpanU = nSpanU ; @@ -85,7 +86,7 @@ SurfBezier::Init( int nDegU, int nDegV, int nSpanU, int nSpanV, bool bIsRational m_bTrimmed = false ; ResetTrimRegion() ; - // dimensiono i vettori dei punti e dei pesi + // dimensiono i vettori dei punti e dei pesi m_vPtCtrl.assign( GetDim(), ORIG) ; if ( bIsRational) m_vWeCtrl.assign( GetDim(), 1) ; @@ -94,7 +95,7 @@ SurfBezier::Init( int nDegU, int nDegV, int nSpanU, int nSpanV, bool bIsRational m_nStatus = TO_VERIFY ; m_nIsPlanar = NOT_CALCULATED ; - // setto la dimensione dei vettori + // setto la dimensione dei vettori m_vBernU.resize( m_nDegU + 1) ; m_vBernV.resize( m_nDegV + 1) ; //if (! m_bRat) @@ -105,10 +106,10 @@ SurfBezier::Init( int nDegU, int nDegV, int nSpanU, int nSpanV, bool bIsRational // m_vPtWCtrlLoc.resize( GetLocDim()) ; // m_vWeCtrlLoc.resize( GetLocDim()) ; //} - - // imposto ricalcolo della grafica + + // imposto ricalcolo della grafica ResetAuxSurf() ; m_OGrMgr.Reset() ; @@ -119,18 +120,18 @@ SurfBezier::Init( int nDegU, int nDegV, int nSpanU, int nSpanV, bool bIsRational bool SurfBezier::SetControlPoint( int nInd, const Point3d& ptCtrl) { - // verifico validità indice + // verifico validità indice if ( m_nStatus != OK || m_bRat || nInd < 0 || nInd >= GetDim()) return false ; - // assegno il valore + // assegno il valore m_vPtCtrl[nInd] = ptCtrl ; - // se razionale, metto il peso a 1 + // se razionale, metto il peso a 1 if ( m_bRat) m_vWeCtrl[nInd] = 1 ; - // imposto ricalcolo della grafica + // imposto ricalcolo della grafica ResetAuxSurf() ; m_OGrMgr.Reset() ; @@ -141,19 +142,19 @@ SurfBezier::SetControlPoint( int nInd, const Point3d& ptCtrl) bool SurfBezier::SetControlPoint( int nInd, const Point3d& ptCtrl, double dW) { - // verifico validità, razionalità e indice + // verifico validità, razionalità e indice if ( m_nStatus != OK || ! m_bRat || nInd < 0 || nInd >= GetDim()) return false ; - // verifico che il peso non sia nullo o negativo + // verifico che il peso non sia nullo o negativo if ( dW < EPS_SMALL) return false ; - // assegno il valore e il peso + // assegno il valore e il peso m_vPtCtrl[nInd] = ptCtrl ; m_vWeCtrl[nInd] = dW ; - // imposto ricalcolo della grafica + // imposto ricalcolo della grafica ResetAuxSurf() ; m_OGrMgr.Reset() ; @@ -166,13 +167,13 @@ SurfBezier::SetTrimRegion( ISurfFlatRegion& sfrTrimReg, bool bIntersectOrSubtrac { // controllo se aveo trim precedenti ed eventualmente faccio un'intersezione con lo spazio esistente - // verifico la regione passata + // verifico la regione passata if ( &sfrTrimReg == nullptr || ! sfrTrimReg.IsValid()) return false ; - // se la normale ha z negativa ribalto la superficie, sennò le operazioni di intersect e subtract non funzionano + // se la normale ha z negativa ribalto la superficie, sennò le operazioni di intersect e subtract non funzionano if ( sfrTrimReg.GetNormVersor().z < 0) sfrTrimReg.Invert() ; - // limito la regione allo spazio parametrico della superficie + // limito la regione allo spazio parametrico della superficie PtrOwner< ISurfFlatRegion> pSfrTrim( GetSurfFlatRegionRectangle( SBZ_TREG_COEFF * m_nSpanU, SBZ_TREG_COEFF * m_nSpanV)) ; // bIntersectOrSubtract == true per ottenere lo spazio parametrico trimmato devo fare l'INTERSEZIONE tra il rettangolo totale e l'area passata if ( bIntersectOrSubtract) { @@ -195,7 +196,7 @@ SurfBezier::SetTrimRegion( ISurfFlatRegion& sfrTrimReg, bool bIntersectOrSubtrac } } ResetAuxSurf() ; - // assegno la regione di trim + // assegno la regione di trim if ( m_pTrimReg != nullptr ) { if ( ! m_pTrimReg->Intersect( *pSfrTrim)) return false ; @@ -222,10 +223,10 @@ SurfBezier::GetTrimRegion( void) const bool SurfBezier::GetInfo( int& nDegU, int& nDegV, int& nSpanU, int& nSpanV, bool& bIsRat, bool& bTrimmed) const { - // verifico validità superficie + // verifico validità superficie if ( m_nStatus != OK) return false ; - // restituisco gradi e flag di razionale + // restituisco gradi e flag di razionale nDegU = m_nDegU ; nDegV = m_nDegV ; nSpanU = m_nSpanU ; @@ -239,13 +240,13 @@ SurfBezier::GetInfo( int& nDegU, int& nDegV, int& nSpanU, int& nSpanV, bool& bIs const Point3d& SurfBezier::GetControlPoint( int nInd, bool* pbOk) const { - // verifico validità e indice + // verifico validità e indice if ( m_nStatus != OK || nInd < 0 || nInd >= GetDim()) { if ( pbOk != NULL) *pbOk = false ; return ORIG ; } - // ritorno i dati + // ritorno i dati if ( pbOk != NULL) *pbOk = true ; return m_vPtCtrl[nInd] ; @@ -255,13 +256,13 @@ SurfBezier::GetControlPoint( int nInd, bool* pbOk) const double SurfBezier::GetControlWeight( int nInd, bool* pbOk) const { - // verifico validità, razionalità e indice + // verifico validità, razionalità e indice if ( m_nStatus != OK || ! m_bRat || nInd < 0 || nInd >= GetDim()) { if ( pbOk != NULL) *pbOk = false ; return 0 ; } - // ritorno i dati + // ritorno i dati if ( pbOk != NULL) *pbOk = true ; return m_vWeCtrl[nInd] ; @@ -271,15 +272,15 @@ SurfBezier::GetControlWeight( int nInd, bool* pbOk) const bool SurfBezier::IsAPoint( void) const { - // verifico lo stato + // verifico lo stato if ( m_nStatus != OK) return false ; - // ciclo sui punti + // ciclo sui punti for ( int i = 1 ; i < GetDim() ; ++ i) { if ( ! AreSamePointApprox( m_vPtCtrl[0], m_vPtCtrl[i])) return false ; } - + return true ; } @@ -287,12 +288,12 @@ SurfBezier::IsAPoint( void) const bool SurfBezier::GetArea( double& dArea) const { - // controllo parametro di ritorno + // controllo parametro di ritorno if ( &dArea == nullptr) return false ; - // inizio con area nulla + // inizio con area nulla dArea = 0 ; - // calcolo l'area + // calcolo l'area if ( m_pSTM == nullptr) if ( ! GetAuxSurf()) return false ; @@ -303,19 +304,19 @@ SurfBezier::GetArea( double& dArea) const bool SurfBezier::GetCentroid( Point3d& ptCen) const { - // controllo parametro di ritorno + // controllo parametro di ritorno if ( &ptCen == nullptr) return false ; - // inizio con centro nell'origine + // inizio con centro nell'origine ptCen = ORIG ; - // calcolo il baricentro + // calcolo il baricentro if ( m_pSTM == nullptr) if ( ! GetAuxSurf()) return false ; return m_pSTM->GetCentroid( ptCen) ; } -mutex mapBernstein ; +shared_mutex mapBernstein ; //---------------------------------------------------------------------------- bool @@ -324,19 +325,19 @@ SurfBezier::GetBernstein( double dU, int nDegU, DBLVECTOR& vBernU) const INTINT key( nDegU, int( dU * pow(2,24))) ; bool bCalculated = false ; { - lock_guard lock( mapBernstein) ; + shared_lock lock( mapBernstein) ; bCalculated = m_mBernCache.find( key) != m_mBernCache.end() ; } if ( ! bCalculated) { DBLVECTOR vBern( nDegU + 1) ; GetAllBernstein( dU, nDegU, vBern) ; { - lock_guard lock( mapBernstein) ; + unique_lock lock( mapBernstein) ; m_mBernCache[key] = vBern ; } } { - lock_guard lock( mapBernstein) ; + shared_lock lock( mapBernstein) ; vBernU = m_mBernCache.at( key) ; } return true ; @@ -452,18 +453,18 @@ SurfBezier::GetPoint( double dU, double dV, Side nUs, Side nVs,Point3d& ptPos) c //---------------------------------------------------------------------------- bool SurfBezier::GetPointD1D2( double dU, double dV, Side nUs, Side nVs, - Point3d& ptPos, - Vector3d* pvtDerU, Vector3d* pvtDerV, Vector3d* pvtDerUU, Vector3d* pvtDerVV, Vector3d* pvtDerUV) const + Point3d& ptPos, + Vector3d* pvtDerU, Vector3d* pvtDerV, Vector3d* pvtDerUU, Vector3d* pvtDerVV, Vector3d* pvtDerUV) const { - // la curva deve essere validata + // la curva deve essere validata if ( m_nStatus != OK) return false ; - // i parametri U e V devono essere compresi tra 0 e il corrispondente numero di Span + // i parametri U e V devono essere compresi tra 0 e il corrispondente numero di Span dU = Clamp( dU, 0., double( m_nSpanU)) ; dV = Clamp( dV, 0., double( m_nSpanV)) ; - // determino gli intervalli di span e riduco i parametri in essi + // determino gli intervalli di span e riduco i parametri in essi int nBsU = min( int( dU), m_nSpanU - 1) ; double dLocU = dU - nBsU ; if ( abs( dLocU) < 5 * EPS_PARAM && nBsU > 0 && nUs == ISurfBezier::FROM_MINUS) { @@ -487,26 +488,26 @@ SurfBezier::GetPointD1D2( double dU, double dV, Side nUs, Side nVs, } int nOffsV = nBsV * m_nDegV ; - // se forma polinomiale (o integrale) + // se forma polinomiale (o integrale) if ( ! m_bRat) { - // calcolo dei polinomi di Bernstein per U di grado opportuno + // calcolo dei polinomi di Bernstein per U di grado opportuno DBLVECTOR vBernU( m_nDegU + 1) ; GetAllBernstein( dLocU, m_nDegU - 2, vBernU) ; - //// se richiesto, calcolo della derivata seconda - // if ( pvtDer2 != nullptr && pvtDer1 != nullptr) { - // *pvtDer2 = V_NULL ; - // for ( int i = 0 ; i <= m_nDeg - 2 ; ++ i) { - // *pvtDer2 += vBern[i] * ( m_vPtCtrl[i+2] + m_vPtCtrl[i] - 2 * m_vPtCtrl[i+1]) ; - // } - // *pvtDer2 *= m_nDeg * ( m_nDeg - 1) ; - // } + //// se richiesto, calcolo della derivata seconda + // if ( pvtDer2 != nullptr && pvtDer1 != nullptr) { + // *pvtDer2 = V_NULL ; + // for ( int i = 0 ; i <= m_nDeg - 2 ; ++ i) { + // *pvtDer2 += vBern[i] * ( m_vPtCtrl[i+2] + m_vPtCtrl[i] - 2 * m_vPtCtrl[i+1]) ; + // } + // *pvtDer2 *= m_nDeg * ( m_nDeg - 1) ; + // } - // aumento il grado + // aumento il grado IncreaseAllBernsteinOneDegree( dLocU, m_nDegU - 1, vBernU) ; - // se richiesto, calcolo dei vettori intermedi per la derivata prima rispetto ad U + // se richiesto, calcolo dei vettori intermedi per la derivata prima rispetto ad U VCT3DVECTOR vtTemp1( m_nDegV + 1, V_NULL) ; if ( pvtDerU != nullptr) { for ( int j = 0 ; j <= m_nDegV ; ++ j) { @@ -516,21 +517,21 @@ SurfBezier::GetPointD1D2( double dU, double dV, Side nUs, Side nVs, } } - // aumento il grado + // aumento il grado IncreaseAllBernsteinOneDegree( dLocU, m_nDegU, vBernU) ; - // calcolo dei punti intermedi + // calcolo dei punti intermedi PNTVECTOR ptTemp( m_nDegV + 1, ORIG) ; for ( int j = 0 ; j <= m_nDegV ; ++ j) { for ( int i = 0 ; i <= m_nDegU ; ++ i) ptTemp[j] += vBernU[i] * m_vPtCtrl[GetInd( nOffsU + i, nOffsV + j)] ; } - // calcolo dei polinomi di Bernstein per V di grado opportuno + // calcolo dei polinomi di Bernstein per V di grado opportuno DBLVECTOR vBernV( m_nDegV + 1) ; GetAllBernstein( dLocV, m_nDegV - 1, vBernV) ; - // se richiesto, calcolo della derivata prima rispetto a V + // se richiesto, calcolo della derivata prima rispetto a V if ( pvtDerV != nullptr) { *pvtDerV = V_NULL ; for ( int j = 0 ; j <= m_nDegV - 1 ; ++ j) @@ -538,15 +539,15 @@ SurfBezier::GetPointD1D2( double dU, double dV, Side nUs, Side nVs, *pvtDerV *= m_nDegV ; } - // aumento il grado + // aumento il grado IncreaseAllBernsteinOneDegree( dLocV, m_nDegV, vBernV) ; - // calcolo del punto + // calcolo del punto ptPos = ORIG ; for ( int j = 0 ; j <= m_nDegV ; ++ j) ptPos += vBernV[j] * ptTemp[j] ; - // se richiesto, calcolo della derivata prima rispetto a U + // se richiesto, calcolo della derivata prima rispetto a U if ( pvtDerU != nullptr) { *pvtDerU = V_NULL ; for ( int j = 0 ; j <= m_nDegV ; ++ j) @@ -554,10 +555,10 @@ SurfBezier::GetPointD1D2( double dU, double dV, Side nUs, Side nVs, } } - // altrimenti forma razionale + // altrimenti forma razionale else { - // porto i punti in forma omogenea moltiplicandoli per i pesi + // porto i punti in forma omogenea moltiplicandoli per i pesi PNTVECTOR vPtWCtrl( GetLocDim()) ; DBLVECTOR vWeCtrl( GetLocDim()) ; for ( int j = 0 ; j <= m_nDegV ; ++ j) { @@ -567,26 +568,26 @@ SurfBezier::GetPointD1D2( double dU, double dV, Side nUs, Side nVs, } } - // calcolo dei polinomi di Bernstein di grado opportuno + // calcolo dei polinomi di Bernstein di grado opportuno DBLVECTOR vBernU( m_nDegU + 1) ; GetAllBernstein( dLocU, m_nDegU - 2, vBernU) ; - //// se richiesto, calcolo della derivata seconda - // double dW2 = 0 ; - // if ( pvtDer2 != nullptr && pvtDer1 != nullptr) { - // *pvtDer2 = V_NULL ; - // for ( int i = 0 ; i <= m_nDeg - 2 ; ++ i) { - // *pvtDer2 += vBern[i] * ( vPtWCtrl[i+2] + vPtWCtrl[i] - 2 * vPtWCtrl[i+1]) ; - // dW2 += vBern[i] * ( m_vWeCtrl[i+2] + m_vWeCtrl[i] - 2 * m_vWeCtrl[i+1]) ; - // } - // *pvtDer2 *= m_nDeg * ( m_nDeg - 1) ; - // dW2 *= m_nDeg * ( m_nDeg - 1) ; - // } + //// se richiesto, calcolo della derivata seconda + // double dW2 = 0 ; + // if ( pvtDer2 != nullptr && pvtDer1 != nullptr) { + // *pvtDer2 = V_NULL ; + // for ( int i = 0 ; i <= m_nDeg - 2 ; ++ i) { + // *pvtDer2 += vBern[i] * ( vPtWCtrl[i+2] + vPtWCtrl[i] - 2 * vPtWCtrl[i+1]) ; + // dW2 += vBern[i] * ( m_vWeCtrl[i+2] + m_vWeCtrl[i] - 2 * m_vWeCtrl[i+1]) ; + // } + // *pvtDer2 *= m_nDeg * ( m_nDeg - 1) ; + // dW2 *= m_nDeg * ( m_nDeg - 1) ; + // } - // aumento il grado + // aumento il grado IncreaseAllBernsteinOneDegree( dLocU, m_nDegU - 1, vBernU) ; - // se richiesto, calcolo dei vettori intermedi per la derivata prima rispetto ad U + // se richiesto, calcolo dei vettori intermedi per la derivata prima rispetto ad U VCT3DVECTOR vtTemp1( m_nDegV + 1, V_NULL) ; DBLVECTOR dTemp1( m_nDegV + 1, 0) ; if ( pvtDerU != nullptr) { @@ -600,10 +601,10 @@ SurfBezier::GetPointD1D2( double dU, double dV, Side nUs, Side nVs, } } - // aumento il grado + // aumento il grado IncreaseAllBernsteinOneDegree( dLocU, m_nDegU, vBernU) ; - // calcolo dei punti e pesi intermedi + // calcolo dei punti e pesi intermedi PNTVECTOR ptTempW( m_nDegV + 1, ORIG) ; DBLVECTOR dTempW( m_nDegV + 1, 0) ; for ( int j = 0 ; j <= m_nDegV ; ++ j) { @@ -613,11 +614,11 @@ SurfBezier::GetPointD1D2( double dU, double dV, Side nUs, Side nVs, } } - // calcolo dei polinomi di Bernstein per V di grado opportuno + // calcolo dei polinomi di Bernstein per V di grado opportuno DBLVECTOR vBernV( m_nDegV + 1) ; GetAllBernstein( dLocV, m_nDegV - 1, vBernV) ; - // se richiesto, calcolo della derivata prima rispetto a V + // se richiesto, calcolo della derivata prima rispetto a V double dW1v = 0 ; if ( pvtDerV != nullptr) { *pvtDerV = V_NULL ; @@ -629,10 +630,10 @@ SurfBezier::GetPointD1D2( double dU, double dV, Side nUs, Side nVs, dW1v *= m_nDegV ; } - // aumento il grado + // aumento il grado IncreaseAllBernsteinOneDegree( dLocV, m_nDegV, vBernV) ; - // calcolo del punto + // calcolo del punto double dW = 0 ; ptPos = ORIG ; for ( int j = 0 ; j <= m_nDegV ; ++ j) { @@ -640,11 +641,11 @@ SurfBezier::GetPointD1D2( double dU, double dV, Side nUs, Side nVs, dW += vBernV[j] * dTempW[j] ; } - // ritrasformo da forma omogenea a forma standard + // ritrasformo da forma omogenea a forma standard double dInvW = 1 / ( ( dW > EPS_ZERO) ? dW : EPS_ZERO) ; ptPos *= dInvW ; - // se richiesto, calcolo della derivata prima rispetto a U + // se richiesto, calcolo della derivata prima rispetto a U if ( pvtDerU != nullptr) { *pvtDerU = V_NULL ; double dW1u = 0 ; @@ -656,7 +657,7 @@ SurfBezier::GetPointD1D2( double dU, double dV, Side nUs, Side nVs, *pvtDerU = ( *pvtDerU - dW1u * vtPos) * dInvW ; } - // se richiesto, completo il calcolo della derivata prima rispetto a V + // se richiesto, completo il calcolo della derivata prima rispetto a V if ( pvtDerV != nullptr) { Vector3d vtPos( ptPos.x, ptPos.y, ptPos.z) ; *pvtDerV = ( *pvtDerV - dW1v * vtPos) * dInvW ; @@ -676,18 +677,18 @@ SurfBezier::GetPointD1D2( double dU, double dV, Side nUs, Side nVs, //---------------------------------------------------------------------------- bool SurfBezier::GetPointNrmD1D2( double dU, double dV, Side nUs, Side nVs, - Point3d& ptPos, Vector3d& vtN, - Vector3d* pvtDerU, Vector3d* pvtDerV, Vector3d* pvtDerUU, Vector3d* pvtDerVV, Vector3d* pvtDerUV) const + Point3d& ptPos, Vector3d& vtN, + Vector3d* pvtDerU, Vector3d* pvtDerV, Vector3d* pvtDerUU, Vector3d* pvtDerVV, Vector3d* pvtDerUV) const { - // la superficie deve essere validata + // la superficie deve essere validata if ( m_nStatus != OK) return false ; - // i parametri U e V devono essere compresi tra 0 e il corrispondente numero di Span + // i parametri U e V devono essere compresi tra 0 e il corrispondente numero di Span dU = Clamp( dU, 0., double( m_nSpanU)) ; dV = Clamp( dV, 0., double( m_nSpanV)) ; - // eseguo calcolo del punto con le derivate prime + // eseguo calcolo del punto con le derivate prime Vector3d vtDerU ; if ( pvtDerU == nullptr) pvtDerU = &vtDerU ; @@ -696,12 +697,12 @@ SurfBezier::GetPointNrmD1D2( double dU, double dV, Side nUs, Side nVs, pvtDerV = &vtDerV ; GetPointD1D2( dU, dV, nUs, nVs, ptPos, pvtDerU, pvtDerV) ; - // calcolo la normale e la verifico + // calcolo la normale e la verifico vtN = *pvtDerU ^ *pvtDerV ; if ( vtN.Normalize()) return true ; - // se solo una delle due derivate è piccola, mi sposto lungo il relativo parametro e uso le tangenti + // se solo una delle due derivate è piccola, mi sposto lungo il relativo parametro e uso le tangenti if ( pvtDerU->Len() < EPS_SMALL && pvtDerV->Len() > 10 * EPS_SMALL) { double dCoeff = ( dU - 1000 * EPS_PARAM < 0. ? 1 : -1) ; double dUm = dU + 1000 * EPS_PARAM * dCoeff ; @@ -723,7 +724,7 @@ SurfBezier::GetPointNrmD1D2( double dU, double dV, Side nUs, Side nVs, return true ; } - // ricalcolo con una piccola variazione di entrambi i parametri + // ricalcolo con una piccola variazione di entrambi i parametri double dUm ; if ( dU - 100 * EPS_PARAM < 0.) dUm = dU + 100 * EPS_PARAM ; @@ -822,22 +823,22 @@ SurfBezier::GetTitle( void) const bool SurfBezier::Dump( string& sOut, bool bMM, const char* szNewLine) const { - // verifico validità superficie + // verifico validità superficie if ( m_nStatus != OK) sOut += string( "Status=Invalid") + szNewLine ; - // area + // area double dArea ; GetArea( dArea) ; sOut += "Area=" + ToString( GetAreaInUiUnits( dArea, bMM),1) + szNewLine ; - // parametri : flag razionale + // parametri : flag razionale sOut += ( m_bRat ? "Rat" : "Int") ; - // flag trimmata + // flag trimmata sOut += ( m_bTrimmed ? " Trim " : " Full") ; - // gradi in U e V + // gradi in U e V sOut += " DegU=" + ToString( m_nDegU) + " DegV=" + ToString( m_nDegV) ; - // pezze in U e V + // pezze in U e V sOut += " SpanU=" + ToString( m_nSpanU) + " SpanV=" + ToString( m_nSpanV) + szNewLine ; - // ciclo sui punti di controllo ( con pesi se razionale) + // ciclo sui punti di controllo ( con pesi se razionale) for ( int i = 0 ; i < GetDim() ; ++ i) { sOut += "PC(" + ToString( GetInUiUnits( m_vPtCtrl[i], bMM), 3) ; if ( m_bRat) @@ -859,21 +860,21 @@ SurfBezier::GetNgeId( void) const bool SurfBezier::Save( NgeWriter& ngeOut) const { - // flag razionale + // flag razionale if ( ! ngeOut.WriteBool( m_bRat, ";")) return false ; - // flag trimmata + // flag trimmata if ( ! ngeOut.WriteBool( m_bTrimmed, ";")) return false ; - // gradi + // gradi if ( ! ngeOut.WriteInt( m_nDegU, ",") || - ! ngeOut.WriteInt( m_nDegV, ";", false)) + ! ngeOut.WriteInt( m_nDegV, ";", false)) return false ; - // pezze + // pezze if ( ! ngeOut.WriteInt( m_nSpanU, ",") || - ! ngeOut.WriteInt( m_nSpanV, ";", true)) + ! ngeOut.WriteInt( m_nSpanV, ";", true)) return false ; - // ciclo sui punti di controllo ( con pesi se razionale) + // ciclo sui punti di controllo ( con pesi se razionale) for ( int i = 0 ; i < GetDim() ; ++ i) { if ( ! m_bRat) { if ( ! ngeOut.WritePoint( m_vPtCtrl[i], ";", true)) @@ -884,13 +885,13 @@ SurfBezier::Save( NgeWriter& ngeOut) const return false ; } } - // se trimmata, scrittura della regione + // se trimmata, scrittura della regione if ( m_bTrimmed) { - // recupero il gestore di lettura/scrittura della regione + // recupero il gestore di lettura/scrittura della regione const IGeoObjRW* pSFrRW = dynamic_cast( m_pTrimReg) ; if ( pSFrRW == nullptr) return false ; - // salvataggio della regione + // salvataggio della regione if ( ! pSFrRW->Save( ngeOut)) return false ; } @@ -902,73 +903,73 @@ SurfBezier::Save( NgeWriter& ngeOut) const bool SurfBezier::Load( NgeReader& ngeIn) { - // imposto ricalcolo della grafica + // imposto ricalcolo della grafica ResetAuxSurf() ; m_OGrMgr.Reset() ; - // leggo la prossima linea ( 3 parametri) - // recupero il flag razionale + // leggo la prossima linea ( 3 parametri) + // recupero il flag razionale bool bIsRat ; if ( ! ngeIn.ReadBool( bIsRat, ";")) return false ; - // recupero il flag trimmata + // recupero il flag trimmata bool bTrimmed ; if ( ! ngeIn.ReadBool( bTrimmed, ";")) return false ; - // recupero i gradi + // recupero i gradi int nDegU, nDegV ; if ( ! ngeIn.ReadInt( nDegU, ",") || - ! ngeIn.ReadInt( nDegV, ";")) + ! ngeIn.ReadInt( nDegV, ";")) return false ; - // recupero le pezze + // recupero le pezze int nSpanU, nSpanV ; if ( ! ngeIn.ReadInt( nSpanU, ",") || - ! ngeIn.ReadInt( nSpanV, ";", true)) + ! ngeIn.ReadInt( nSpanV, ";", true)) return false ; - // inizializzo la superficie di Bezier + // inizializzo la superficie di Bezier if ( ! Init( nDegU, nDegV, nSpanU, nSpanV, bIsRat)) return false ; - // se integrale + // se integrale if ( ! bIsRat) { - // recupero e setto punti di controllo + // recupero e setto punti di controllo Point3d ptP ; for ( int i = 0 ; i < GetDim() ; ++ i) { - // leggo la prossima linea ( un punto) + // leggo la prossima linea ( un punto) if ( ! ngeIn.ReadPoint( ptP, ";", true)) return false ; - // lo assegno + // lo assegno if ( ! SetControlPoint( i, ptP)) return false ; } } - // altrimenti razionale + // altrimenti razionale else { - // recupero e setto punti di controllo + // recupero e setto punti di controllo Point3d ptP ; double dW ; for ( int i = 0 ; i < GetDim() ; ++ i) { - // leggo la prossima linea ( un punto con peso) + // leggo la prossima linea ( un punto con peso) if ( ! ngeIn.ReadPointW( ptP, dW, ";", true)) return false ; - // lo assegno + // lo assegno if ( ! SetControlPoint( i, ptP, dW)) return false ; } } - // se trimmata, lettura della regione + // se trimmata, lettura della regione if ( bTrimmed) { - // creo l'oggetto + // creo l'oggetto ResetTrimRegion() ; m_pTrimReg = CreateBasicSurfFlatRegion() ; if ( m_pTrimReg == nullptr) return false ; - // ne leggo i dati + // ne leggo i dati IGeoObjRW* pGObjRW = dynamic_cast( m_pTrimReg) ; if ( pGObjRW == nullptr || ! pGObjRW->Load( ngeIn)) return false ; m_bTrimmed = true ; } - // eseguo validazione + // eseguo validazione return Validate() ; } @@ -996,11 +997,11 @@ SurfBezier::GetLocalBBox( BBox3d& b3Loc, int nFlag) const } // deve essere preciso else { - // verifico esistenza trimesh associata + // verifico esistenza trimesh associata if ( m_pSTM == nullptr) if ( ! GetAuxSurf()) return false ; - // calcolo il box della trimesh + // calcolo il box della trimesh return m_pSTM->GetLocalBBox( b3Loc, nFlag) ; } } @@ -1020,11 +1021,11 @@ SurfBezier::GetBBox( const Frame3d& frRef, BBox3d& b3Ref, int nFlag) const } // deve essere preciso else { - // verifico esistenza trimesh associata + // verifico esistenza trimesh associata if ( m_pSTM == nullptr) if ( ! GetAuxSurf()) return false ; - // calcolo il box della trimesh + // calcolo il box della trimesh return m_pSTM->GetBBox( frRef, b3Ref, nFlag) ; } } @@ -1033,15 +1034,15 @@ SurfBezier::GetBBox( const Frame3d& frRef, BBox3d& b3Ref, int nFlag) const bool SurfBezier::Translate( const Vector3d& vtMove) { - // la superficie deve essere validata + // la superficie deve essere validata if ( m_nStatus != OK) return false ; - // imposto ricalcolo della grafica + // imposto ricalcolo della grafica ResetAuxSurf() ; m_OGrMgr.Reset() ; - // traslo i punti di controllo + // traslo i punti di controllo for ( auto& ptP : m_vPtCtrl) ptP.Translate( vtMove) ; @@ -1052,18 +1053,18 @@ SurfBezier::Translate( const Vector3d& vtMove) bool SurfBezier::Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAng, double dSinAng) { - // la superficie deve essere validata + // la superficie deve essere validata if ( m_nStatus != OK) return false ; - // verifico validità dell'asse di rotazione + // verifico validità dell'asse di rotazione if ( vtAx.IsSmall()) return false ; - // imposto ricalcolo della grafica + // imposto ricalcolo della grafica ResetAuxSurf() ; m_OGrMgr.Reset() ; - // ruoto i punti di controllo + // ruoto i punti di controllo for ( auto& ptP : m_vPtCtrl) ptP.Rotate( ptAx, vtAx, dCosAng, dSinAng) ; @@ -1074,15 +1075,15 @@ SurfBezier::Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAng, d bool SurfBezier::Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, double dCoeffZ) { - // la superficie deve essere validata + // la superficie deve essere validata if ( m_nStatus != OK) return false ; - // verifico non sia nulla + // verifico non sia nulla if ( abs( dCoeffX) < EPS_ZERO && abs( dCoeffY) < EPS_ZERO && abs( dCoeffZ) < EPS_ZERO) return false ; - // calcolo bbox allineato con riferimento di scalatura e senza tener conto dello spessore - // lo scalo per verificare se tutto si riduce a un punto o una linea (solo se diretta come assi ref) + // calcolo bbox allineato con riferimento di scalatura e senza tener conto dello spessore + // lo scalo per verificare se tutto si riduce a un punto o una linea (solo se diretta come assi ref) BBox3d b3Ref ; if ( ! GetBBox( frRef, b3Ref)) return false ; @@ -1093,11 +1094,11 @@ SurfBezier::Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, double if ( ( bZeroX && bZeroY) || ( bZeroX && bZeroZ) || ( bZeroY && bZeroZ)) return false ; - // imposto ricalcolo della grafica + // imposto ricalcolo della grafica ResetAuxSurf() ; m_OGrMgr.Reset() ; - // scalo i punti di controllo + // scalo i punti di controllo for ( auto& ptP : m_vPtCtrl) ptP.Scale( frRef, dCoeffX, dCoeffY, dCoeffZ) ; @@ -1108,22 +1109,22 @@ SurfBezier::Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, double bool SurfBezier::Mirror( const Point3d& ptOn, const Vector3d& vtNorm) { - // la superficie deve essere validata + // la superficie deve essere validata if ( m_nStatus != OK) return false ; - // verifico validità del piano di specchiatura + // verifico validità del piano di specchiatura if ( vtNorm.IsSmall()) return false ; - // imposto ricalcolo della grafica + // imposto ricalcolo della grafica ResetAuxSurf() ; m_OGrMgr.Reset() ; - // specchio i punti di controllo + // specchio i punti di controllo for ( auto& ptP : m_vPtCtrl) ptP.Mirror( ptOn, vtNorm) ; - // eseguo invert per mantenere l'orientazione + // eseguo invert per mantenere l'orientazione return Invert() ; } @@ -1131,18 +1132,18 @@ SurfBezier::Mirror( const Point3d& ptOn, const Vector3d& vtNorm) bool SurfBezier::Shear( const Point3d& ptOn, const Vector3d& vtNorm, const Vector3d& vtDir, double dCoeff) { - // la superficie deve essere validata + // la superficie deve essere validata if ( m_nStatus != OK) return false ; - // verifico validità dei parametri + // verifico validità dei parametri if ( vtNorm.IsSmall() || vtDir.IsSmall()) return false ; - // imposto ricalcolo della grafica + // imposto ricalcolo della grafica ResetAuxSurf() ; m_OGrMgr.Reset() ; - // eseguo scorrimento dei punti di controllo + // eseguo scorrimento dei punti di controllo for ( auto& ptP : m_vPtCtrl) ptP.Shear( ptOn, vtNorm, vtDir, dCoeff) ; @@ -1153,22 +1154,22 @@ SurfBezier::Shear( const Point3d& ptOn, const Vector3d& vtNorm, const Vector3d& bool SurfBezier::ToGlob( const Frame3d& frRef) { - // la superficie deve essere validata + // la superficie deve essere validata if ( m_nStatus != OK) return false ; - // verifico validità del frame + // verifico validità del frame if ( frRef.GetType() == Frame3d::ERR) return false ; - // se frame identità, non devo fare alcunché + // se frame identità, non devo fare alcunché if ( IsGlobFrame( frRef)) return true ; - // imposto ricalcolo della grafica + // imposto ricalcolo della grafica ResetAuxSurf() ; m_OGrMgr.Reset() ; - // trasformo i punti di controllo + // trasformo i punti di controllo for ( auto& ptP : m_vPtCtrl) ptP.ToGlob( frRef) ; @@ -1179,22 +1180,22 @@ SurfBezier::ToGlob( const Frame3d& frRef) bool SurfBezier::ToLoc( const Frame3d& frRef) { - // la superficie deve essere validata + // la superficie deve essere validata if ( m_nStatus != OK) return false ; - // verifico validità del frame + // verifico validità del frame if ( frRef.GetType() == Frame3d::ERR) return false ; - // se frame identità, non devo fare alcunché + // se frame identità, non devo fare alcunché if ( IsGlobFrame( frRef)) return true ; - // imposto ricalcolo della grafica + // imposto ricalcolo della grafica ResetAuxSurf() ; m_OGrMgr.Reset() ; - // trasformo i punti di controllo + // trasformo i punti di controllo for ( auto& ptP : m_vPtCtrl) ptP.ToLoc( frRef) ; @@ -1205,22 +1206,22 @@ SurfBezier::ToLoc( const Frame3d& frRef) bool SurfBezier::LocToLoc( const Frame3d& frOri, const Frame3d& frDest) { - // la superficie deve essere validata + // la superficie deve essere validata if ( m_nStatus != OK) return false ; - // verifico validità dei frame + // verifico validità dei frame if ( frOri.GetType() == Frame3d::ERR || frDest.GetType() == Frame3d::ERR) return false ; - // se i due riferimenti coincidono, non devo fare alcunché + // se i due riferimenti coincidono, non devo fare alcunché if ( AreSameFrame( frOri, frDest)) return true ; - // imposto ricalcolo della grafica + // imposto ricalcolo della grafica ResetAuxSurf() ; m_OGrMgr.Reset() ; - // trasformo i punti di controllo + // trasformo i punti di controllo for ( auto& ptP : m_vPtCtrl) ptP.LocToLoc( frOri, frDest) ; @@ -1231,17 +1232,17 @@ SurfBezier::LocToLoc( const Frame3d& frOri, const Frame3d& frDest) bool SurfBezier::Invert( void) { - // la superficie deve essere validata + // la superficie deve essere validata if ( m_nStatus != OK) return false ; - // imposto ricalcolo della grafica + // imposto ricalcolo della grafica ResetAuxSurf() ; m_OGrMgr.Reset() ; - // inverto i punti del parametro U + // inverto i punti del parametro U PNTVECTOR vPtCtrl_inv( m_vPtCtrl.size()) ; - + for ( int j = 0 ; j < m_nDegV * m_nSpanV + 1; ++j) { for ( int i = 0 ; i < m_nDegU * m_nSpanU + 1; ++i) { vPtCtrl_inv[ i + j * ( m_nDegU * m_nSpanU + 1)] = m_vPtCtrl[ ( m_nDegU * m_nSpanU - i) + j * ( m_nDegU * m_nSpanU + 1)] ; @@ -1250,8 +1251,8 @@ SurfBezier::Invert( void) m_vPtCtrl = vPtCtrl_inv ; if ( m_bTrimmed) { - // inverto la flat region di trim - //( la specchio rispetto all'asse verticale) + // inverto la flat region di trim + //( la specchio rispetto all'asse verticale) Point3d pt( m_nSpanU * SBZ_TREG_COEFF/2, 0, 0) ; Vector3d vt( 1, 0, 0) ; m_pTrimReg->Mirror( pt, vt) ; @@ -1276,60 +1277,60 @@ SurfBezier::GetSteps( int nDeg, int nSpan, double dLen, int nQuality) const CurveComposite* SurfBezier::GetCurveOnU( double dV) const { - // controlli + // controlli if ( dV < - EPS_PARAM || dV > m_nSpanV + EPS_PARAM) return nullptr ; dV = Clamp( dV, 0., double( m_nSpanV)) ; - // determino l'intervallo di span in V e riduco i parametri in essi + // determino l'intervallo di span in V e riduco i parametri in essi int nBsV = min( int( dV), m_nSpanV - 1) ; double dLocV = dV - nBsV ; int nOffsV = nBsV * m_nDegV ; - // se forma polinomiale (o integrale) + // se forma polinomiale (o integrale) if ( ! m_bRat) { - // preparazione della curva composita + // preparazione della curva composita PtrOwner pCrvCo( CreateBasicCurveComposite()) ; - // ciclo sugli intervalli + // ciclo sugli intervalli for ( int k = 0 ; k < m_nSpanU ; ++ k) { - // preparazione della curva di Bezier + // preparazione della curva di Bezier PtrOwner pCbz( CreateBasicCurveBezier()) ; if ( IsNull( pCbz) || ! pCbz->Init( m_nDegU, false)) return nullptr ; - // calcolo dei polinomi di Bernstein per V di grado opportuno + // calcolo dei polinomi di Bernstein per V di grado opportuno DBLVECTOR vBernV( m_nDegV + 1) ; GetAllBernstein( dLocV, m_nDegV, vBernV) ; - // calcolo offset in U + // calcolo offset in U int nOffsU = k * m_nDegU ; - // calcolo dei punti di controllo della curva + // calcolo dei punti di controllo della curva for ( int i = 0 ; i <= m_nDegU ; ++ i) { Point3d ptP = ORIG ; for ( int j = 0 ; j <= m_nDegV ; ++ j) ptP += vBernV[j] * m_vPtCtrl[GetInd( nOffsU + i, nOffsV + j)] ; pCbz->SetControlPoint( i, ptP) ; } - // inserisco la curva della pezza in quella complessiva + // inserisco la curva della pezza in quella complessiva if ( ! IsNull( pCbz)) pCrvCo->AddCurve( Release( pCbz)) ; } return Release( pCrvCo) ; } - // altrimenti forma razionale + // altrimenti forma razionale else { - // preparazione della curva composita + // preparazione della curva composita PtrOwner pCrvCo( CreateBasicCurveComposite()) ; - // ciclo sugli intervalli + // ciclo sugli intervalli for ( int k = 0 ; k < m_nSpanU ; ++ k) { - // preparazione della curva di Bezier + // preparazione della curva di Bezier PtrOwner pCbz( CreateBasicCurveBezier()) ; if ( IsNull( pCbz) || ! pCbz->Init( m_nDegU, true)) return nullptr ; - // calcolo dei polinomi di Bernstein per V di grado opportuno + // calcolo dei polinomi di Bernstein per V di grado opportuno DBLVECTOR vBernV( m_nDegV + 1) ; GetAllBernstein( dLocV, m_nDegV, vBernV) ; - // calcolo offset in U + // calcolo offset in U int nOffsU = k * m_nDegU ; - // porto i punti in forma omogenea moltiplicandoli per i pesi + // porto i punti in forma omogenea moltiplicandoli per i pesi PNTVECTOR vPtWCtrl( GetLocDim()) ; DBLVECTOR vWeCtrl( GetLocDim()) ; for ( int j = 0 ; j <= m_nDegV ; ++ j) { @@ -1338,7 +1339,7 @@ SurfBezier::GetCurveOnU( double dV) const vWeCtrl[GetLocInd( i, j)] = m_vWeCtrl[GetInd( nOffsU + i, nOffsV + j)] ; } } - // calcolo dei punti di controllo della curva + // calcolo dei punti di controllo della curva for ( int i = 0 ; i <= m_nDegU ; ++ i) { Point3d ptP = ORIG ; double dW = 0 ; @@ -1349,7 +1350,7 @@ SurfBezier::GetCurveOnU( double dV) const double dInvW = 1 / ( ( dW > EPS_ZERO) ? dW : EPS_ZERO) ; pCbz->SetControlPoint( i, ptP * dInvW, dW) ; } - // inserisco la curva della pezza in quella complessiva + // inserisco la curva della pezza in quella complessiva if ( ! IsNull( pCbz)) pCrvCo->AddCurve( Release( pCbz)) ; } @@ -1361,60 +1362,60 @@ SurfBezier::GetCurveOnU( double dV) const CurveComposite* SurfBezier::GetCurveOnV( double dU) const { - // controlli + // controlli if ( dU < - EPS_PARAM || dU > m_nSpanU + EPS_PARAM) return nullptr ; dU = Clamp( dU, 0., double( m_nSpanU)) ; - // determino l'intervallo di span in U e riduco i parametri in essi + // determino l'intervallo di span in U e riduco i parametri in essi int nBsU = min( int( dU), m_nSpanU - 1) ; double dLocU = dU - nBsU ; int nOffsU = nBsU * m_nDegU ; - // se forma polinomiale (o integrale) + // se forma polinomiale (o integrale) if ( ! m_bRat) { - // preparazione della curva composita + // preparazione della curva composita PtrOwner pCrvCo( CreateBasicCurveComposite()) ; - // ciclo sugli intervalli + // ciclo sugli intervalli for ( int k = 0 ; k < m_nSpanV ; ++ k) { - // preparazione della curva di Bezier + // preparazione della curva di Bezier PtrOwner pCbz( CreateBasicCurveBezier()) ; if ( IsNull( pCbz) || ! pCbz->Init( m_nDegV, false)) return nullptr ; - // calcolo dei polinomi di Bernstein per U di grado opportuno + // calcolo dei polinomi di Bernstein per U di grado opportuno DBLVECTOR vBernU( m_nDegU + 1) ; GetAllBernstein( dLocU, m_nDegU, vBernU) ; - // calcolo offset in V + // calcolo offset in V int nOffsV = k * m_nDegV ; - // calcolo dei punti di controllo della curva + // calcolo dei punti di controllo della curva for ( int j = 0 ; j <= m_nDegV ; ++ j) { Point3d ptP = ORIG ; for ( int i = 0 ; i <= m_nDegU ; ++ i) ptP += vBernU[i] * m_vPtCtrl[GetInd( nOffsU + i, nOffsV + j)] ; pCbz->SetControlPoint( j, ptP) ; } - // inserisco la curva della pezza in quella complessiva + // inserisco la curva della pezza in quella complessiva if ( ! IsNull( pCbz)) pCrvCo->AddCurve( Release( pCbz)) ; } return Release( pCrvCo) ; } - // altrimenti forma razionale + // altrimenti forma razionale else { - // preparazione della curva composita + // preparazione della curva composita PtrOwner pCrvCo( CreateBasicCurveComposite()) ; - // ciclo sugli intervalli + // ciclo sugli intervalli for ( int k = 0 ; k < m_nSpanV ; ++ k) { - // preparazione della curva di Bezier + // preparazione della curva di Bezier PtrOwner pCbz( CreateBasicCurveBezier()) ; if ( IsNull( pCbz) || ! pCbz->Init( m_nDegV, true)) return nullptr ; - // calcolo dei polinomi di Bernstein per U di grado opportuno + // calcolo dei polinomi di Bernstein per U di grado opportuno DBLVECTOR vBernU( m_nDegU + 1) ; GetAllBernstein( dLocU, m_nDegU, vBernU) ; - // calcolo offset in V + // calcolo offset in V int nOffsV = k * m_nDegV ; - // porto i punti in forma omogenea moltiplicandoli per i pesi + // porto i punti in forma omogenea moltiplicandoli per i pesi PNTVECTOR vPtWCtrl( GetLocDim()) ; DBLVECTOR vWeCtrl( GetLocDim()) ; for ( int j = 0 ; j <= m_nDegV ; ++ j) { @@ -1423,7 +1424,7 @@ SurfBezier::GetCurveOnV( double dU) const vWeCtrl[GetLocInd( i, j)] = m_vWeCtrl[GetInd( nOffsU + i, nOffsV + j)] ; } } - // calcolo dei punti di controllo della curva + // calcolo dei punti di controllo della curva for ( int j = 0 ; j <= m_nDegV ; ++ j) { Point3d ptP = ORIG ; double dW = 0 ; @@ -1434,7 +1435,7 @@ SurfBezier::GetCurveOnV( double dU) const double dInvW = 1 / ( ( dW > EPS_ZERO) ? dW : EPS_ZERO) ; pCbz->SetControlPoint( j, ptP * dInvW, dW) ; } - // inserisco la curva della pezza in quella complessiva + // inserisco la curva della pezza in quella complessiva if ( ! IsNull( pCbz)) pCrvCo->AddCurve( Release( pCbz)) ; } @@ -1508,16 +1509,16 @@ SurfBezier::GetLoop( int nLoop) const bool SurfBezier::GetCurveOnU( double dV, int nStep, PolyLine& plCrvU) const { - // controlli + // controlli plCrvU.Clear() ; if ( dV < - EPS_PARAM || dV > m_nSpanV + EPS_PARAM) return false ; dV = Clamp( dV, 0., double( m_nSpanV)) ; - // recupero la curva + // recupero la curva PtrOwner pCrvCo( GetCurveOnU( dV)) ; if ( IsNull( pCrvCo)) return false ; - // ciclo sulle curve componenti (tutte curve di Bezier) + // ciclo sulle curve componenti (tutte curve di Bezier) int i = 0 ; const ICurve* pSCrv = pCrvCo->GetFirstCurve() ; while ( pSCrv != nullptr) { @@ -1544,16 +1545,16 @@ SurfBezier::GetCurveOnU( double dV, int nStep, PolyLine& plCrvU) const bool SurfBezier::GetCurveOnV( double dU, int nStep, PolyLine& plCrvV) const { - // controlli + // controlli plCrvV.Clear() ; if ( dU < - EPS_PARAM || dU > m_nSpanU + EPS_PARAM) return false ; dU = Clamp( dU, 0., double( m_nSpanU)) ; - // recupero la curva + // recupero la curva PtrOwner pCrvCo( GetCurveOnV( dU)) ; if ( IsNull( pCrvCo)) return false ; - // ciclo sulle curve componenti (tutte curve di Bezier) + // ciclo sulle curve componenti (tutte curve di Bezier) int i = 0 ; const ICurve* pSCrv = pCrvCo->GetFirstCurve() ; while ( pSCrv != nullptr) { @@ -1628,15 +1629,15 @@ SurfBezier::GetCurveOnVApproxLen( double dU) const const SurfTriMesh* SurfBezier::GetAuxSurf( void) const { - // la superficie deve essere validata + // la superficie deve essere validata if ( m_nStatus != OK) { ResetAuxSurf() ; return nullptr ; } - // se già calcolata, la restituisco + // se già calcolata, la restituisco if ( m_pSTM != nullptr) return m_pSTM ; - // eseguo calcolo + // eseguo calcolo m_pSTM = GetApproxSurf( 50 * EPS_SMALL, 100 * EPS_SMALL) ; return m_pSTM ; } @@ -1645,16 +1646,16 @@ SurfBezier::GetAuxSurf( void) const SurfTriMesh* SurfBezier::GetApproxSurf( double dTol, double dSideMin) const { - // la superficie deve essere validata + // la superficie deve essere validata if ( m_nStatus != OK) return nullptr ; - // se c'è ausiliaria e richiesta con gli stessi parametri, ne restituisco una copia + // se c'è ausiliaria e richiesta con gli stessi parametri, ne restituisco una copia if ( m_pSTM != nullptr && - abs( dTol - 50 * EPS_SMALL) < EPS_SMALL && abs( dSideMin - 100 * EPS_SMALL) < EPS_SMALL) + abs( dTol - 50 * EPS_SMALL) < EPS_SMALL && abs( dSideMin - 100 * EPS_SMALL) < EPS_SMALL) return m_pSTM->Clone() ; - - // costruttore della superficie + + // costruttore della superficie POLYLINEMATRIX vvPL ; POLYLINEMATRIX vvPL3d ; //POLYLINEVECTOR vPL ; // per usare i polygon basic @@ -1685,28 +1686,28 @@ SurfBezier::GetApproxSurf( double dTol, double dSideMin) const continue ; //Tree.GetPolygonsBasic( vPL, true) ; // per usare i polygon basic - // aggiorno la chiusura della superficie + // aggiorno la chiusura della superficie m_bClosedU = m_bClosedU || Tree.IsClosedU() ; m_bClosedV = m_bClosedV || Tree.IsClosedV() ; - //// salvo i bordi in 3d, che servono in caso si voglia trimmare la superficie DOPO aver costruito la trimesh ausiliaria - // UpdateEdgesFromTree( Tree) ; + //// salvo i bordi in 3d, che servono in caso si voglia trimmare la superficie DOPO aver costruito la trimesh ausiliaria + // UpdateEdgesFromTree( Tree) ; } - //// per usare i polygon basic////////////////////// + //// per usare i polygon basic////////////////////// //for (int k = 0 ; k < (int)vPL.size(); ++k) { // vvPL.emplace_back() ; // vvPL.back().push_back(vPL[k]) ; //} - //// per usare i polygon basic/////////////////// + //// per usare i polygon basic/////////////////// if ( vvPL.empty()) LOG_DBG_ERR( GetEGkLogger(), "ERROR : Bezier Surface couldn't be triangulated") ; - + StmFromTriangleSoup stmSoup ; if ( ! stmSoup.Start()) return nullptr ; - // prendo i punti di ogni polyline dell'albero, li triangolo e li porto in 3d + // prendo i punti di ogni polyline dell'albero, li triangolo e li porto in 3d int c = 0 ; for ( POLYLINEVECTOR& vPL : vvPL) { PNTVECTOR vPnt ; @@ -1716,7 +1717,7 @@ SurfBezier::GetApproxSurf( double dTol, double dSideMin) const LOG_DBG_ERR( GetEGkLogger(), "ERROR : Triangulation failed in Bezier Surface") ; return nullptr ; } - + POLYLINEVECTOR vPL3d = vvPL3d[c] ; PNTVECTOR vPnt3d ; @@ -1819,18 +1820,18 @@ SurfBezier::GetApproxSurf( double dTol, double dSideMin) const int nTria = int( vTria.size()) / 3 ; for ( int i = 0 ; i < nTria ; ++i) { if ( ! stmSoup.AddTriangle( vPnt3d[vTria[3*i]], vPnt3d[vTria[3*i+1]], vPnt3d[vTria[3*i+2]], - vPnt[vTria[3*i]].x, vPnt[vTria[3*i]].y, - vPnt[vTria[3*i+1]].x, vPnt[vTria[3*i+1]].y, - vPnt[vTria[3*i+2]].x, vPnt[vTria[3*i+2]].y)) + vPnt[vTria[3*i]].x, vPnt[vTria[3*i]].y, + vPnt[vTria[3*i+1]].x, vPnt[vTria[3*i+1]].y, + vPnt[vTria[3*i+2]].x, vPnt[vTria[3*i+2]].y)) return nullptr ; } ++c ; } - // termino + // termino if ( ! stmSoup.End()) return nullptr ; - // restituisco + // restituisco return GetBasicSurfTriMesh( stmSoup.GetSurf()) ; } @@ -1898,13 +1899,13 @@ SurfBezier::ReorderPntVector( const POLYLINEVECTOR& vPL, bool bTriangulatedIn3D, vPLToOrd[nPoly].GetFirstPoint( ptPoly) ; vPntToRotate.push_back( ptPoly) ; while ( vPLToOrd[nPoly].GetNextPoint( ptPoly)) - vPntToRotate.push_back( ptPoly) ; + vPntToRotate.push_back( ptPoly) ; } else { vPLToOrd[nPoly].GetLastPoint( ptPoly) ; vPntToRotate.push_back( ptPoly) ; while ( vPLToOrd[nPoly].GetPrevPoint( ptPoly)) - vPntToRotate.push_back( ptPoly) ; + vPntToRotate.push_back( ptPoly) ; } vPntToRotate.pop_back() ; rotate( vPntToRotate.begin(), vPntToRotate.begin() + nInd, vPntToRotate.end()) ; @@ -1976,7 +1977,7 @@ SurfBezier::GetLeaves( vector>& vLeaves) const //Tree.BuildTree( 5 * LIN_TOL_FINE, 1) ; // per debug } else { - Tree.BuildTree( 100 * LIN_TOL_FINE, 0.1) ; + Tree.BuildTree( 5 * LIN_TOL_FINE, 0.1) ; } vector vCells ; Tree.GetLeaves( vCells) ; @@ -2045,7 +2046,7 @@ SurfBezier::IncreaseUV( Point3d& ptUV, Vector3d vtH , Point3d* ptUVCopy, bool bM IncreaseUV( ptUV.x, vtH.x, true, nullptr, bModifyOrig) ; IncreaseUV( ptUV.y, vtH.y, true, nullptr, bModifyOrig) ; } - + return true ; } @@ -2062,18 +2063,18 @@ SurfBezier::IncreaseUV( double& dUV, double dxy, bool bUOrV, double* dUVCopy, bo dUV += dxy ; dUVTest = dUV ; } - + if ( bUOrV) { if ( dUVTest < 0) - dUVTest = 0 ; + dUVTest = 0 ; else if ( dUVTest > m_nSpanU * SBZ_TREG_COEFF ) - dUVTest = m_nSpanU * SBZ_TREG_COEFF ; + dUVTest = m_nSpanU * SBZ_TREG_COEFF ; } else { if ( dUVTest < 0) - dUVTest = 0 ; + dUVTest = 0 ; else if ( dUVTest > m_nSpanV * SBZ_TREG_COEFF ) - dUVTest = m_nSpanV * SBZ_TREG_COEFF ; + dUVTest = m_nSpanV * SBZ_TREG_COEFF ; } if ( bModifyOrig) dUV = dUVTest ; @@ -2162,7 +2163,7 @@ SurfBezier::UnprojectCurveFromStm( const ICurveComposite* pCC, ICRVCOMPOPVECTOR& // se mi accorgo che sto per tracciare un taglio lungo un bordo posso semplicemente evitarlo double dDelta = 10 * EPS_SMALL ; if ( ( 1 - abs( vtDir.x) < SQ_EPS_SMALL && ( pt2D.y < dDelta || m_nSpanV * SBZ_TREG_COEFF - pt2D.y < dDelta)) || // parallelo agli edge 0 e 2 e su uno di questi - ( 1 - abs( vtDir.y) < SQ_EPS_SMALL && ( pt2D.x < dDelta || m_nSpanU * SBZ_TREG_COEFF - pt2D.x < dDelta))) { // parallello agli edge 1 e 3 e su uno di questi + ( 1 - abs( vtDir.y) < SQ_EPS_SMALL && ( pt2D.x < dDelta || m_nSpanU * SBZ_TREG_COEFF - pt2D.x < dDelta))) { // parallello agli edge 1 e 3 e su uno di questi ++ nRejected ; continue ; } @@ -2175,7 +2176,7 @@ SurfBezier::UnprojectCurveFromStm( const ICurveComposite* pCC, ICRVCOMPOPVECTOR& // potrei star tracciando un taglio sul bordo di chiusura // controllo se sto tracciando una linea che unisce due lati di chiusura, allora in realtà sdtarei tracciando un taglio sull'edge e quindi posso non tracciarlo if ( ( abs( vtDir.x) > abs( vtDir.y) && Dist( pt2D, pt2DPrev) > dParamL * 0.5) || - ( abs( vtDir.y) > abs( vtDir.x) && Dist( pt2D, pt2DPrev) > dParamH * 0.5)) { + ( abs( vtDir.y) > abs( vtDir.x) && Dist( pt2D, pt2DPrev) > dParamH * 0.5)) { ++ nRejected ; continue ; } @@ -2204,7 +2205,7 @@ SurfBezier::UnprojectCurveFromStm( const ICurveComposite* pCC, ICRVCOMPOPVECTOR& Point3d ptEnd = vBPnt[nInd].second ; // provo ad accodarlo alla composita bAdded = ( Dist( ptStart, ptEnd) > dToler / 2 && - pLine->Set( ptStart, ptEnd)) ; + pLine->Set( ptStart, ptEnd)) ; bAdded = bAdded && pCC2D->AddCurve( Release( pLine), true, dToler) ; ptNear = ( bAdded ? ptEnd : ptStart) ; } @@ -2218,31 +2219,31 @@ SurfBezier::UnprojectCurveFromStm( const ICurveComposite* pCC, ICRVCOMPOPVECTOR& bool SurfBezier::AddCurveCompoToCuts( ICurveComposite* pCrvCompo, ICRVCOMPOPOVECTOR& vpCCOpen, ICRVCOMPOPOVECTOR& vpCCClosed, double dToler, const Plane3d* pPlCut) const { - // se lunghezza curva inferiore a 5 volte la tolleranza, la ignoro e sposto il punto finale nel punto di fine della curva che sto ignorando + // se lunghezza curva inferiore a 5 volte la tolleranza, la ignoro e sposto il punto finale nel punto di fine della curva che sto ignorando double dCrvLen ; if ( ! pCrvCompo->GetLength( dCrvLen) || dCrvLen < 5. * dToler) return true ; - // se curva chiusa entro 5 volte la tolleranza ma considerata aperta, la chiudo bene + // se curva chiusa entro 5 volte la tolleranza ma considerata aperta, la chiudo bene Point3d ptStart, ptEnd ; if ( pCrvCompo->GetStartPoint( ptStart) && - pCrvCompo->GetEndPoint( ptEnd) && - AreSamePointEpsilon( ptStart, ptEnd, 5 * dToler) && - ! AreSamePointApprox( ptStart, ptEnd)) { - // porto il punto finale a coincidere esattamente con l'inizio + pCrvCompo->GetEndPoint( ptEnd) && + AreSamePointEpsilon( ptStart, ptEnd, 5 * dToler) && + ! AreSamePointApprox( ptStart, ptEnd)) { + // porto il punto finale a coincidere esattamente con l'inizio pCrvCompo->ModifyEnd( ptStart) ; } - // unisco segmenti allineati + // unisco segmenti allineati pCrvCompo->MergeCurves( 0.5 * dToler, ANG_TOL_STD_DEG) ; - // porto la curva nello spazio parametrico + // porto la curva nello spazio parametrico ICRVCOMPOPVECTOR vCC ; if ( ! UnprojectCurveFromStm( pCrvCompo, vCC, pPlCut)) return false ; for ( int i = 0 ; i < int( vCC.size()); ++i) { - // le curve aperte le tengo da parte per giuntarle alla fine col bordo + // le curve aperte le tengo da parte per giuntarle alla fine col bordo if ( ! vCC[i]->IsClosed() ) vpCCOpen.emplace_back( vCC[i]) ; - // le curve chiuse le metto tutte insieme subito + // le curve chiuse le metto tutte insieme subito else vpCCClosed.emplace_back( vCC[i]) ; } @@ -2265,32 +2266,32 @@ struct hash { ISurfFlatRegion* SurfBezier::CreateTrimRegionFromCuts( ICRVCOMPOPOVECTOR& vpCCOpen, ICRVCOMPOPOVECTOR& vpCCClosed) const { - // comincio a creare la superficie aggiungendo i tagli aperti ai bordi attualmente esistenti + // comincio a creare la superficie aggiungendo i tagli aperti ai bordi attualmente esistenti SurfFlatRegionByContours sfrContour ; if ( int(vpCCOpen.size()) != 0 ) { - // recupero la regione attuale + // recupero la regione attuale PtrOwner pNewTrim( CreateBasicSurfFlatRegion()) ; if ( m_bTrimmed) pNewTrim.Set( GetTrimRegion()->Clone()) ; else pNewTrim.Set( GetSurfFlatRegionRectangle( SBZ_TREG_COEFF * m_nSpanU, SBZ_TREG_COEFF * m_nSpanV)) ; - // costruisco la mappa delle intersezioni, trovando tutte le intersezioni tra i trim e i loop dei vari chunk della falr region + // costruisco la mappa delle intersezioni, trovando tutte le intersezioni tra i trim e i loop dei vari chunk della falr region unordered_map mInters ; int nInters = 0 ; bool bStartFound = false ; bool bEndFound = false ; - // trim + // trim for ( int t = 0 ; t < int( vpCCOpen.size()); ++t) { nInters = 0 ; bStartFound = false ; bEndFound = false ; - // chunk + // chunk for ( int c = 0 ; c < pNewTrim->GetChunkCount() ; ++c) { - // loop + // loop for ( int l = 0 ; l < pNewTrim->GetLoopCount( c) ; ++l) { PtrOwner pLoop( pNewTrim->GetLoop( c, l)) ; - // prima curva è il loop, seconda curva è il trim + // prima curva è il loop, seconda curva è il trim IntersCurveCurve icc( *pLoop, *vpCCOpen[t]) ; if ( icc.GetIntersCount() != 0) { ICCIVECTOR vICC ; @@ -2315,7 +2316,7 @@ SurfBezier::CreateTrimRegionFromCuts( ICRVCOMPOPOVECTOR& vpCCOpen, ICRVCOMPOPOVE } } if ( nInters != 2) { - // se un trim non fa 2 intersezioni allora devo estendere la curva allo start e/o all'end per creare le intersezioni + // se un trim non fa 2 intersezioni allora devo estendere la curva allo start e/o all'end per creare le intersezioni Point3d ptStart ; vpCCOpen[t]->GetStartPoint( ptStart) ; Point3d ptEnd ; vpCCOpen[t]->GetEndPoint( ptEnd) ; PtrOwner pCrv( vpCCOpen[t]->Clone()) ; @@ -2326,19 +2327,19 @@ SurfBezier::CreateTrimRegionFromCuts( ICRVCOMPOPOVECTOR& vpCCOpen, ICRVCOMPOPOVE if ( ! bEndFound) pCrv->ExtendEndByLen( dExtension) ; double dDistStart = 1e6, dDistEnd = 1e6 ; - // vettore per l'intersezione di start + // vettore per l'intersezione di start ICCIVECTOR vICCStart ; vICCStart.emplace_back() ; - // vettore per l'intersezione di end + // vettore per l'intersezione di end ICCIVECTOR vICCEnd ; vICCEnd.emplace_back() ; TRINT tStart, tEnd ; - // chunk + // chunk for ( int c = 0 ; c < pNewTrim->GetChunkCount() ; ++c) { - // loop + // loop for ( int l = 0 ; l < pNewTrim->GetLoopCount( c) ; ++l) { PtrOwner pLoop( pNewTrim->GetLoop( c, l)) ; - // prima curva è il loop, seconda curva è il trim + // prima curva è il loop, seconda curva è il trim IntersCurveCurve icc( *pLoop, *pCrv) ; if ( icc.GetIntersCount() != 0) { for ( int i = 0 ; i < int( icc.GetIntersCount()); ++i) { @@ -2358,29 +2359,29 @@ SurfBezier::CreateTrimRegionFromCuts( ICRVCOMPOPOVECTOR& vpCCOpen, ICRVCOMPOPOVE } } - // ricostruisco gli elementi per la mappa mInters + // ricostruisco gli elementi per la mappa mInters if ( ! bStartFound && ! bEndFound) { - // ridefinisco il taglio aperto con la sua versione estesa che arriva a toccare i loop dello spazio parametrico + // ridefinisco il taglio aperto con la sua versione estesa che arriva a toccare i loop dello spazio parametrico vpCCOpen[t].Set( GetCurveComposite(pCrv->CopyParamRange( vICCStart[0].IciB->dU, vICCEnd[0].IciB->dU))) ; - // correggo il parametro dell'intersezione allo start + // correggo il parametro dell'intersezione allo start vICCStart[0].IciB->dU = 0 ; if ( tStart == tEnd) { - // se ho intersezione con un loop solo allora accorpo i due vettori delle intersezioni + // se ho intersezione con un loop solo allora accorpo i due vettori delle intersezioni vICCStart.emplace_back( vICCEnd[0]) ; mInters.insert( pair(tStart, vICCStart)) ; } else{ - // se ho intersezione con due loop diverse due entry diverse le inserisco + // se ho intersezione con due loop diverse due entry diverse le inserisco mInters.insert( pair(tStart, vICCStart)) ; mInters.insert( pair(tEnd, vICCEnd)) ; } } else { - // devo verificare se avevo già trovato una delle due intersezioni e se era sullo stesso loop o no + // devo verificare se avevo già trovato una delle due intersezioni e se era sullo stesso loop o no if ( ! bStartFound) { pCrv->TrimStartAtParam( vICCStart[0].IciB->dU) ; vpCCOpen[t].Set( GetCurveComposite( Release( pCrv))) ; - // correggo il parametro dell'intersezione allo start + // correggo il parametro dell'intersezione allo start vICCStart[0].IciB->dU = 0 ; if ( mInters.count( tStart) == 1) mInters[tStart].emplace_back( vICCStart[0]) ; @@ -2399,21 +2400,21 @@ SurfBezier::CreateTrimRegionFromCuts( ICRVCOMPOPOVECTOR& vpCCOpen, ICRVCOMPOPOVE } } - // vettore di flag che mi indica quali tagli aperti sono stati aggiunti al nuovo bordo + // vettore di flag che mi indica quali tagli aperti sono stati aggiunti al nuovo bordo BOOLVECTOR vbAdded( vpCCOpen.size()) ; fill( vbAdded.begin(), vbAdded.end(), false) ; PtrOwner pCCNewEdge( CreateCurveComposite()) ; PtrOwner pCL( CreateCurveLine()) ; TRINT tiFirstInters ; - // parto aggiungendo il primo taglio + // parto aggiungendo il primo taglio int nNewToAdd = 0 ; bool bFirstCurveOfEdge = true ; while ( nNewToAdd != -1) { - // aggiungo il taglio + // aggiungo il taglio pCCNewEdge->AddCurve( Release( vpCCOpen[nNewToAdd])) ; - // aggiorno la lista degli aggiunti + // aggiorno la lista degli aggiunti vbAdded[nNewToAdd] = true ; - // di questo taglio mi salvo il chunk e loop di start e end + // di questo taglio mi salvo il chunk e loop di start e end TRINT tiStart, tiEnd ; for (const auto& pair : mInters) { if ( get<2>(pair.first) == nNewToAdd ) { @@ -2421,7 +2422,7 @@ SurfBezier::CreateTrimRegionFromCuts( ICRVCOMPOPOVECTOR& vpCCOpen, ICRVCOMPOPOVE if ( pair.second[p].IciB->dU < EPS_SMALL) { tiStart = pair.first ; if ( bFirstCurveOfEdge){ - // salvo l'inizio del taglio che è la prima curva di questa curva compo + // salvo l'inizio del taglio che è la prima curva di questa curva compo tiFirstInters = pair.first ; bFirstCurveOfEdge = false ; } @@ -2432,22 +2433,22 @@ SurfBezier::CreateTrimRegionFromCuts( ICRVCOMPOPOVECTOR& vpCCOpen, ICRVCOMPOPOVE } } - // devo trovare fino a che punto seguire il loop che ho trovato come prosecuzione del taglio corrente - // devo quindi trovare la prossima intersezione con un taglio + // devo trovare fino a che punto seguire il loop che ho trovato come prosecuzione del taglio corrente + // devo quindi trovare la prossima intersezione con un taglio int nInters = -1 ; double dNextCut = INFINITO ; double dEndCurrentCut ; for ( int i = 0 ; i < int( mInters[tiEnd].size()); ++i) { - // se ho trovato l'intersezione con la fine del taglio corrente, salvo il parametro sul loop + // se ho trovato l'intersezione con la fine del taglio corrente, salvo il parametro sul loop if ( mInters[tiEnd][i].IciB->dU > EPS_SMALL) dEndCurrentCut = mInters[tiEnd][i].IciA->dU ; } - // se non trovo nessuna altra intersezione prima della fine del loop allora devo ripetere tutto cercando a partire dall'inizio del loop + // se non trovo nessuna altra intersezione prima della fine del loop allora devo ripetere tutto cercando a partire dall'inizio del loop for ( const auto& pair : mInters) { if ( get<0>(pair.first) == get<0>(tiEnd) && get<1>(pair.first) == get<1>(tiEnd)) { for ( int i = 0 ; i < int(pair.second.size()); ++i ) { - // se trovo una nuova intersezione che incontro prima di quella che mi ero salvato precedentemente allora - // mi salvo questa nuova che ho trovato + // se trovo una nuova intersezione che incontro prima di quella che mi ero salvato precedentemente allora + // mi salvo questa nuova che ho trovato if ( pair.second[i].IciA->dU < dNextCut && pair.second[i].IciA->dU > dEndCurrentCut) { dNextCut = pair.second[i].IciA->dU ; nInters = get<2>(pair.first) ; @@ -2460,8 +2461,8 @@ SurfBezier::CreateTrimRegionFromCuts( ICRVCOMPOPOVECTOR& vpCCOpen, ICRVCOMPOPOVE for ( const auto& pair : mInters) { if ( get<0>(pair.first) == get<0>(tiEnd) && get<1>(pair.first) == get<1>(tiEnd)) { for ( int i = 0 ; i < int(pair.second.size()); ++i ) { - // se trovo una nuova intersezione che incontro prima di quella che mi ero salvato precedentemente allora - // mi salvo questa nuova che ho trovato + // se trovo una nuova intersezione che incontro prima di quella che mi ero salvato precedentemente allora + // mi salvo questa nuova che ho trovato if ( pair.second[i].IciA->dU < dNextCut) { dNextCut = pair.second[i].IciA->dU ; nInters = get<2>(pair.first) ; @@ -2471,19 +2472,19 @@ SurfBezier::CreateTrimRegionFromCuts( ICRVCOMPOPOVECTOR& vpCCOpen, ICRVCOMPOPOVE } } - // se tutto va bene queste due righe sostituiscono tutto il casino qua sotto + // se tutto va bene queste due righe sostituiscono tutto il casino qua sotto PtrOwner pLoopTrimmed( pNewTrim->GetLoop( get<0>(tiEnd), get<1>(tiEnd))) ; pCCNewEdge->AddCurve(pLoopTrimmed->CopyParamRange( dEndCurrentCut, dNextCut)) ; - // se il prossimo taglio identificato è quello da cui sono partito allora aggiungo il bordo ricostruito fino a questo momento - // alla flat region e comincio a costruire un altro bordo - // altrimenti continuo ad aggiungere curve al bordo corrente + // se il prossimo taglio identificato è quello da cui sono partito allora aggiungo il bordo ricostruito fino a questo momento + // alla flat region e comincio a costruire un altro bordo + // altrimenti continuo ad aggiungere curve al bordo corrente if ( nInters == get<2>(tiFirstInters) ) { pCCNewEdge->Close() ; sfrContour.AddCurve( Release( pCCNewEdge)) ; pCCNewEdge.Set( CreateBasicCurveComposite()) ; bFirstCurveOfEdge = true ; - // trovo il prossimo taglio ancora da aggiungere + // trovo il prossimo taglio ancora da aggiungere nNewToAdd = -1 ; for ( int b = 0 ; b < int(vbAdded.size()) ; ++b ) { if ( ! vbAdded[b]) { @@ -2497,7 +2498,7 @@ SurfBezier::CreateTrimRegionFromCuts( ICRVCOMPOPOVECTOR& vpCCOpen, ICRVCOMPOPOVE } } - // devo verificare se devo aggiungere anche il bordo ( basta verificare se il primo loop chiuso è CCW) + // devo verificare se devo aggiungere anche il bordo ( basta verificare se il primo loop chiuso è CCW) double dArea ; if ( ! vpCCClosed.empty()) { vpCCClosed[0]->GetAreaXY( dArea) ; @@ -2551,7 +2552,7 @@ SurfBezier::Cut( const Plane3d& plPlane, bool bSaveOnEq) if ( ! chainC.AddCurve( i + 1, vBPnt[i].first, vtDir, vBPnt[i].second, vtDir)) return false ; } - // GESTIONE DELLE CURVE OTTENUTE DALL'INTERSEZIONE + // GESTIONE DELLE CURVE OTTENUTE DALL'INTERSEZIONE // recupero i percorsi concatenati Point3d ptNear = ( vBPnt.empty() ? ORIG : vBPnt[0].first) ; @@ -2587,7 +2588,7 @@ SurfBezier::Cut( const Plane3d& plPlane, bool bSaveOnEq) return false ; } - //GESTIONE DEI TRIANGOLI RISULTANTI DALL'INTERSEZIONE + //GESTIONE DEI TRIANGOLI RISULTANTI DALL'INTERSEZIONE StmFromTriangleSoup StmFts ; if ( ! StmFts.Start()) return GDB_ID_NULL ; @@ -2611,7 +2612,7 @@ SurfBezier::Cut( const Plane3d& plPlane, bool bSaveOnEq) } // ora posso chiamare la costruzione dello spazio parametrico trimmato - + PtrOwner pSFR( CreateTrimRegionFromCuts( vpCCOpen, vpCCClosed)) ; if ( IsNull( pSFR) || ! pSFR->IsValid()) return false ; @@ -2627,16 +2628,16 @@ SurfBezier::Cut( const Plane3d& plPlane, bool bSaveOnEq) double dAreaMin = 1e30 ; bool bPos = false ; for ( int c = 0 ; c < int( pSFR->GetChunkCount()); ++c) { - for ( int l = 0 ; l < pSFR->GetLoopCount( c); ++l) { - PtrOwner pCrv( pSFR->GetLoop( c, l)) ; - double dArea ; pCrv->GetAreaXY( dArea) ; - if ( abs( dArea) < dAreaMin) { - nChunkMin = c ; - nLoopMin = l ; - dAreaMin = abs( dArea) ; - bPos = dArea > 0 ; - } + for ( int l = 0 ; l < pSFR->GetLoopCount( c); ++l) { + PtrOwner pCrv( pSFR->GetLoop( c, l)) ; + double dArea ; pCrv->GetAreaXY( dArea) ; + if ( abs( dArea) < dAreaMin) { + nChunkMin = c ; + nLoopMin = l ; + dAreaMin = abs( dArea) ; + bPos = dArea > 0 ; } + } } // aggiorno la superficie di trim @@ -3122,14 +3123,14 @@ SurfBezier::CalcPoles( void) const { if ( ! m_vbPole.empty()) return true ; - // la funzione identifica se degli edge della superficie non trimmata sono in realtà dei poli + // la funzione identifica se degli edge della superficie non trimmata sono in realtà dei poli for ( int i = 0 ; i < 4 ; ++i) m_vbPole.emplace_back( true) ; - // scorro i punti di controllo e vedo subito + // scorro i punti di controllo e vedo subito bool bOk = false ; bool bPole0 = true, bPole1 = true ; Point3d ptU0, ptU1 ; - // controllo l'edge 0 e 2 per vedere se tutti i punti dell'edge sono coincidenti + // controllo l'edge 0 e 2 per vedere se tutti i punti dell'edge sono coincidenti Point3d ptP00 = GetControlPoint( 0, &bOk) ; Point3d ptP10 = GetControlPoint( m_nDegU * m_nSpanU, &bOk) ; for ( int i = 1 ; i < m_nDegV * m_nSpanV + 1 ; ++ i) { @@ -3142,7 +3143,7 @@ SurfBezier::CalcPoles( void) const } m_vbPole[1] = bPole0 ; // u = 0 corrisponde all'edge 1 m_vbPole[3] = bPole1 ; // u = 1 corrisponde all'edge 3 - // controllo l'edge 1 e 3 per vedere se tutti i punti dell'edge sono coincidenti + // controllo l'edge 1 e 3 per vedere se tutti i punti dell'edge sono coincidenti Point3d ptV0, ptV1 ; Point3d ptP01 = GetControlPoint( ( m_nDegU * m_nSpanU + 1) * ( m_nDegV * m_nSpanV), &bOk) ; bPole0 = true ; @@ -3173,29 +3174,29 @@ SurfBezier::GetLoops( ICRVCOMPOPOVECTOR& vCC, bool bLineOrBezier, int nEdge) con // se bOpenOrAll è true allora restituisco solo gli edge aperti e che non sono di polo if ( m_pSTM == nullptr) GetAuxSurf() ; - + // se la superficie non è trimmata mi basta recuperare gli edge della superficie if ( ! m_bTrimmed) { // se decidessi di non restituire gli edge chiusi e i poli posso discriminare qui if ( nEdge == -1 ) { - vCC = ICRVCOMPOPOVECTOR(4) ; - if ( ! m_bClosedV ) { - if ( ! m_vbPole[0]) - vCC[0].Set( GetSingleEdge3D( bLineOrBezier, 0)) ; - if ( ! m_vbPole[2]) - vCC[2].Set( GetSingleEdge3D( bLineOrBezier, 2)) ; - } - if ( ! m_bClosedU ) { - if ( ! m_vbPole[1]) - vCC[1].Set( GetSingleEdge3D( bLineOrBezier, 1)) ; - if ( ! m_vbPole[3]) - vCC[3].Set( GetSingleEdge3D( bLineOrBezier, 3)) ; - } - //// se li volessi restituire tutti - //vCC.emplace_back( GetSingleEdge3D( bLineOrBezier, 0)) ; - //vCC.emplace_back( GetSingleEdge3D( bLineOrBezier, 1)) ; - //vCC.emplace_back( GetSingleEdge3D( bLineOrBezier, 2)) ; - //vCC.emplace_back( GetSingleEdge3D( bLineOrBezier, 3)) ; + vCC = ICRVCOMPOPOVECTOR(4) ; + if ( ! m_bClosedV ) { + if ( ! m_vbPole[0]) + vCC[0].Set( GetSingleEdge3D( bLineOrBezier, 0)) ; + if ( ! m_vbPole[2]) + vCC[2].Set( GetSingleEdge3D( bLineOrBezier, 2)) ; + } + if ( ! m_bClosedU ) { + if ( ! m_vbPole[1]) + vCC[1].Set( GetSingleEdge3D( bLineOrBezier, 1)) ; + if ( ! m_vbPole[3]) + vCC[3].Set( GetSingleEdge3D( bLineOrBezier, 3)) ; + } + //// se li volessi restituire tutti + //vCC.emplace_back( GetSingleEdge3D( bLineOrBezier, 0)) ; + //vCC.emplace_back( GetSingleEdge3D( bLineOrBezier, 1)) ; + //vCC.emplace_back( GetSingleEdge3D( bLineOrBezier, 2)) ; + //vCC.emplace_back( GetSingleEdge3D( bLineOrBezier, 3)) ; } else { if ( (((nEdge == 0 || nEdge == 2) && ! m_bClosedV) || ((nEdge == 1 || nEdge == 3) && ! m_bClosedU)) && ! m_vbPole[nEdge]) @@ -3279,7 +3280,7 @@ SurfBezier::GetLoops( ICRVCOMPOPOVECTOR& vCC, bool bLineOrBezier, int nEdge) con if ( ptStart2.x < ptEnd2.x) swap( ptStart2, ptEnd2) ; if ( (( ptEnd0.x - EPS_SMALL< ptStart2.x && ptStart2.x < ptStart0.x + EPS_SMALL) || ( ptEnd0.x - EPS_SMALL < ptEnd2.x && ptEnd2.x < ptStart0.x + EPS_SMALL)) || - (( ptEnd2.x - EPS_SMALL < ptStart0.x && ptStart0.x < ptStart2.x + EPS_SMALL) || ( ptEnd2.x - EPS_SMALL < ptEnd0.x && ptEnd0.x < ptStart2.x + EPS_SMALL))) { + (( ptEnd2.x - EPS_SMALL < ptStart0.x && ptStart0.x < ptStart2.x + EPS_SMALL) || ( ptEnd2.x - EPS_SMALL < ptEnd0.x && ptEnd0.x < ptStart2.x + EPS_SMALL))) { PtrOwner pCL( CreateBasicCurveLine()) ; pCL->Set( ptStart0, ptEnd0) ; // devo scorrere su tutte le curve che sono state ottenute dallo split del loop originale @@ -3315,7 +3316,7 @@ SurfBezier::GetLoops( ICRVCOMPOPOVECTOR& vCC, bool bLineOrBezier, int nEdge) con else if ( bDoneB) m_vCCLoop[nIndex2].Set( pCC2b) ; } - + // per togliere la parte comune al loop corrente devo riportare i punti di intersezione sull'edge di partenza Point3d ptOverlapS = iccInfo.IciB[0].ptI ; Point3d ptOverlapE = iccInfo.IciB[1].ptI ; @@ -3444,7 +3445,7 @@ SurfBezier::GetLoops( ICRVCOMPOPOVECTOR& vCC, bool bLineOrBezier, int nEdge) con ICurveComposite* pCC1b( GetCurveComposite( m_vCCLoop[nIndex1]->Clone())) ; bool bDoneB = pCC1b->TrimStartAtParam( dStart1) ; if ( bDoneA) { - m_vCCLoop[nIndex1].Set( pCC1a) ; + m_vCCLoop[nIndex1].Set( pCC1a) ; if ( bDoneB) { m_vCCLoop.emplace_back( pCC1b) ; mSplitLoop[vInters1.first].push_back( m_vCCLoop.size() - 1) ; @@ -3839,14 +3840,14 @@ SurfBezier::CreateByExtrusion( const ICurve* pCrv, const Vector3d& vtExtr, bool int nSpanU = pCC->GetCurveCount() ; int nSpanV = 1 ; Init(nDegU, nDegV, nSpanU, nSpanV, bRat) ; - + for ( int k = 0 ; k < nSpanU ; ++k) { const ICurveBezier* pCrvBezier = static_cast( pCC->GetCurve( k)) ; for ( int i = 0 ; i < nDegU + 1 ; ++i) { if ( k != 0 && i == 0) continue ; Point3d ptCtrl = pCrvBezier->GetControlPoint( i) ; - + int nInd = k * nDegU + i ; if ( bRat) { double dW = pCrvBezier->GetControlWeight( i) ; @@ -3987,7 +3988,7 @@ SurfBezier::CreateByScrewing( const ICurve* pCurve, const Point3d& ptAx, const V continue ; Point3d ptCtrlU = pSubCrvBezU->GetControlPoint( i) ; double dWU = pSubCrvBezU->GetControlWeight( i) ; - + PtrOwner pCrvV( CreateCurveComposite()) ; // verifico se il punto di controllo sta sull'asse // in tal caso anziché una spirale creo semplicemente una linea lungo l'asse @@ -4027,7 +4028,7 @@ SurfBezier::CreateByScrewing( const ICurve* pCurve, const Point3d& ptAx, const V if( ! pCrvV->IsValid()) return false ; - + // aggiungo i punti di controllo // scorro le sottocurve della spirale for ( int j = 0 ; j < nSpanV ; ++j) { @@ -4072,7 +4073,7 @@ SurfBezier::CreateByPointCurve( const Point3d& pt, const ICurve* pCurve) const ICurveBezier* pSubCrvU = GetCurveBezier( pCrvU->GetCurve( k)) ; // scorro i punti di controllo in U for ( int i = 0 ; i < nDegU + 1 ; ++i ) { - + double dW = pSubCrvU->GetControlWeight( i) ; Point3d ptCtrl = i == 0 ? pSubCrvU->GetControlPoint( i) : pt ; // scorro sul parametro V // do per scontato di avere una patch di grado 1 ( quindi nel parametro V ho solo due punti) @@ -4307,7 +4308,7 @@ SurfBezier::CreateByTwoCurves( const ICurve* pCurve0, const ICurve* pCurve1, int // numero di span aggiunte su U0 e U1 nCount0 = 0 ; nCount1 = 0 ; - + // scorro gli estremi delle sottocurve della curva U0 for ( int i = 0 ; i < int( vPnt0Match.size() - 1) ; ++i) { nIndMatch = vPnt0Match[i].second ; @@ -4377,7 +4378,7 @@ SurfBezier::CreateByTwoCurves( const ICurve* pCurve0, const ICurve* pCurve1, int } ++ nCount0 ; } - + // aggiungo tutte le sottocurve che ho balzato della curva U1 for( int k = 0 ; k < nIndMatchNext - nIndMatch ; ++k) { @@ -4444,7 +4445,7 @@ SurfBezier::CreateByTwoCurves( const ICurve* pCurve0, const ICurve* pCurve1, int int nLong = 0 ; // prendo la polyline con più punti e scelgo a quali punti dell'altra polyline vanno associati FindMatchByParam( plU0, plU1, vMatch,nLong) ; - + for( int i = 0 ; i < int( vMatch.size() - 1) ; ++i) { int nCount = i ; // span in U aggiunte // scorro i punti della polyline più lunga @@ -4724,15 +4725,15 @@ SurfBezier::CreateByTwoCurves( const ICurve* pCurve0, const ICurve* pCurve1, int pCrvU1->AddJoint( dSplit) ; switch( vnAddedOrNextIsRep0[z]) { case 0 : if( vbRep1[nSplit]) - ++ nRep1 ; - // di default aggiungerei false, ma se il successivo è già un Rep allora anche questo deve esserlo - vbRep1.insert( vbRep1.begin() + nSplit, vbRep1[nSplit]) ; break ; + ++ nRep1 ; + // di default aggiungerei false, ma se il successivo è già un Rep allora anche questo deve esserlo + vbRep1.insert( vbRep1.begin() + nSplit, vbRep1[nSplit]) ; break ; case 1 : vbRep1.insert( vbRep1.begin() + nSplit, true) ; break ; case 2 : if ( vbRep1[nSplit]) - --nRep1 ; - else - vbRep1[nSplit] = true ; - vbRep1.insert( vbRep1.begin() + nSplit, false) ; break ; + --nRep1 ; + else + vbRep1[nSplit] = true ; + vbRep1.insert( vbRep1.begin() + nSplit, false) ; break ; } } if( ! vdSplit1.empty()) @@ -4749,15 +4750,15 @@ SurfBezier::CreateByTwoCurves( const ICurve* pCurve0, const ICurve* pCurve1, int pCrvU0->AddJoint( dSplit) ; switch( vnAddedOrNextIsRep1[z]) { case 0 : if( vbRep0[nSplit]) - ++ nRep0 ; - // di default aggiungerei false, ma se il successivo è già un Rep allora anche questo deve esserlo - vbRep0.insert( vbRep0.begin() + nSplit, vbRep0[nSplit]) ; break ; + ++ nRep0 ; + // di default aggiungerei false, ma se il successivo è già un Rep allora anche questo deve esserlo + vbRep0.insert( vbRep0.begin() + nSplit, vbRep0[nSplit]) ; break ; case 1 : vbRep0.insert( vbRep0.begin() + nSplit, true) ; break ; case 2 : if( vbRep0[nSplit]) - -- nRep0 ; - else - vbRep0[nSplit] = true ; - vbRep0.insert( vbRep0.begin() + nSplit, false) ; break ; + -- nRep0 ; + else + vbRep0[nSplit] = true ; + vbRep0.insert( vbRep0.begin() + nSplit, false) ; break ; } } @@ -4810,7 +4811,7 @@ SurfBezier::CreateByTwoCurves( const ICurve* pCurve0, const ICurve* pCurve1, int nSecondRowInd = nDegU * nSpanU + 1 ; // inizializzo la superficie Init( nDegU, nDegV, nSpanU, nSpanV, bRat) ; - + // aggiungo i punti di controllo scorrendo in contemporanea le due curve nAddedSpan = 0 ; nCrv0 = 0 ; @@ -5082,7 +5083,7 @@ SurfBezier::CreateBySetOfCurves( const ICURVEPOVECTOR& vCrvBez, bool bReduceToDe vPntCrvs.push_back( vPntCtrl0) ; vPntCrvs.push_back( vPntCtrl1) ; } - + ////versione nuova //for ( int j = 0 ; j < nSpanU ; ++j ) { // for( int z = j== 0 ? 0 : 1 ; z < nDegU + 1 ; ++z) { @@ -5184,10 +5185,10 @@ SurfBezier::CreateBySetOfCurves( const ICURVEPOVECTOR& vCrvBez, bool bReduceToDe mA.col(1) << pt0.x, pt1.x , pt2.x ; mA.col(2) << 1, 1, 1 ; if( abs( mA.determinant()) < EPS_SMALL) - return false ; + return false ; Eigen::Vector3d b ( pt0.y, pt1.y, pt2.y) ; Eigen::Vector3d coeff = mA.fullPivLu().solve(b) ; - + // pendenze e termini noti nei punti di contatto double dm0 = 2 * coeff.x() * pt0.x + coeff.y() ; double dm1 = 2 * coeff.x() * pt1.x + coeff.y() ; @@ -5204,7 +5205,7 @@ SurfBezier::CreateBySetOfCurves( const ICURVEPOVECTOR& vCrvBez, bool bReduceToDe // porto i punti in globale e trovo i punti medi ptI1.ToGlob( frParab) ; ptI2.ToGlob( frParab) ; - + ptP3 = ( ptP0 + ptI1) / 2 ; ptP4 = ( ptP1 + ptI1) / 2 ; ptP5 = ( ptP1 + ptI2) / 2 ; diff --git a/Tree.cpp b/Tree.cpp index c911a49..16f490f 100644 --- a/Tree.cpp +++ b/Tree.cpp @@ -33,6 +33,7 @@ #include #include #include +#include using namespace std ; @@ -41,7 +42,7 @@ atomic CellCounter( 0) ; //---------------------------------------------------------------------------- Tree::Tree( void) : m_pSrfBz( nullptr), m_bTrimmed( false), m_bBilinear( false), m_bMulti( false), m_bClosedU( false), m_bClosedV( false), m_vbPole( { false, false, false, false}), - m_bSplitPatches( true), m_bTestMode( false) + m_bSplitPatches( true), m_bTestMode( false) { Point3d ptBl( 0, 0), ptTr ( 1 * SBZ_TREG_COEFF, 1 * SBZ_TREG_COEFF) ; Cell cRoot( ptBl, ptTr) ; @@ -56,7 +57,7 @@ Tree::~Tree( void) //---------------------------------------------------------------------------- Tree::Tree( const Point3d ptBl, const Point3d ptTr) : m_pSrfBz( nullptr), m_bTrimmed( false), m_bBilinear( false), m_bMulti( false), m_bClosedU( false), m_bClosedV( false), m_vbPole( { false, false, false, false}), - m_bSplitPatches( true), m_bTestMode( false) + m_bSplitPatches( true), m_bTestMode( false) { Cell cRoot( ptBl, ptTr) ; m_mTree.insert( pair< int, Cell>( -1, cRoot)) ; @@ -106,7 +107,7 @@ Tree::AdjustLoop( PolyLine& pl, POLYLINEVECTOR& vPl, BOOLVECTOR& vbOrientation) return true ; } -mutex map3DMutex ; +shared_mutex map3DMutex ; //---------------------------------------------------------------------------- bool @@ -116,19 +117,19 @@ Tree::GetPoint( double dU, double dV, Point3d& pt) const bool bOk = true ; bool bCalculated = false ; { - lock_guard lock( map3DMutex) ; + shared_lock lock( map3DMutex) ; bCalculated = m_mPt3d.find( key) != m_mPt3d.end() ; } if ( ! bCalculated) { bOk = bOk && m_pSrfBz->GetPoint( dU / SBZ_TREG_COEFF, dV / SBZ_TREG_COEFF, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, pt) ; { - lock_guard lock( map3DMutex) ; + unique_lock lock( map3DMutex) ; m_mPt3d[key] = pt ; } } { - lock_guard lock( map3DMutex) ; - pt = m_mPt3d[key] ; + shared_lock lock( map3DMutex) ; + pt = m_mPt3d.at( key) ; } return bOk ; } @@ -140,11 +141,11 @@ Tree::SavePoint( double dU, double dV, Point3d& pt) pair key (static_cast(dU * pow(2,15)), static_cast(dV * pow(2,15))) ; bool bCalculated = true ; { - lock_guard lock( map3DMutex) ; + shared_lock lock( map3DMutex) ; bCalculated = m_mPt3d.find( key) != m_mPt3d.end() ; } if ( ! bCalculated){ - lock_guard lock( map3DMutex) ; + unique_lock lock( map3DMutex) ; m_mPt3d[key] = pt ; } return true ; @@ -156,7 +157,7 @@ Tree::SetSurf( const SurfBezier* pSrfBz, bool bSplitPatches, const Point3d& ptMi { if ( pSrfBz == nullptr || ! pSrfBz->IsValid()) return false ; - // pulisco i vettori membri + // pulisco i vettori membri m_mTree.clear() ; m_vnLeaves.clear() ; m_vnParents.clear() ; @@ -168,7 +169,7 @@ Tree::SetSurf( const SurfBezier* pSrfBz, bool bSplitPatches, const Point3d& ptMi m_pSrfBz = pSrfBz ; m_bSplitPatches = bSplitPatches ; - // le coordinate delle celle sono nello spazio parametrico + // le coordinate delle celle sono nello spazio parametrico int nDegU, nDegV, nSpanU, nSpanV ; bool bIsRat, bTrimmed ; m_pSrfBz->GetInfo( nDegU, nDegV, nSpanU, nSpanV, bIsRat, bTrimmed) ; @@ -181,7 +182,7 @@ Tree::SetSurf( const SurfBezier* pSrfBz, bool bSplitPatches, const Point3d& ptMi m_bBilinear = true ; if ( nSpanU * nSpanV != 1) m_bMulti = true ; - // creo la cella Root + // creo la cella Root Point3d ptTop( nSpanU * SBZ_TREG_COEFF, nSpanV * SBZ_TREG_COEFF) ; bool bLimited = false ; if ( ! AreSamePointXYExact( ptMax,ORIG)) { @@ -191,27 +192,27 @@ Tree::SetSurf( const SurfBezier* pSrfBz, bool bSplitPatches, const Point3d& ptMi } Cell cRoot( ptMin, ptTop) ; m_mTree.insert( pair< int, Cell>( -1, cRoot)) ; - // recupero i loop di trim e li divido per chunk + // recupero i loop di trim e li divido per chunk if ( m_bTrimmed) { int nLoop = 0 ; - // recupero la superficie di trim per avere accesso diretto ai loop e mantenendo le informazioni sui chunk + // 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 double dAngTolDeg = 5 ; for ( int i = 0 ; i < pTrimReg->GetChunkCount() ; ++ i) { PtrOwner pChunk( pTrimReg->CloneChunk( i)) ; for ( int j = 0 ; j < pChunk->GetLoopCount( 0) ; ++ j) { - // i chunk della falt region sono ancora flat region composte da 1 chunk + // i chunk della falt region sono ancora flat region composte da 1 chunk // rimuovo i difetti dei loop prima di salvarli PtrOwner pLoop( GetBasicCurveComposite( pChunk->GetLoop( 0, j))) ; pLoop->MergeCurves( dLinTol, dAngTolDeg) ; pLoop->RemoveSmallDefects( dLinTol, dAngTolDeg, true) ; pLoop->RemoveSmallParts( dLinTol, dAngTolDeg) ; - // approssimo i loop di trim con delle spezzate + // approssimo i loop di trim con delle spezzate PolyLine plApprox ; int nType = 0 ; pLoop->ApproxWithLines( dLinTol,dAngTolDeg, nType, plApprox) ; - // calcolo se il loop è CCW o CW + // calcolo se il loop è CCW o CW double dArea ; Plane3d plExtPlane ; bool bCCW ; @@ -229,13 +230,13 @@ Tree::SetSurf( const SurfBezier* pSrfBz, bool bSplitPatches, const Point3d& ptMi nLoop = int ( m_vPlApprox.size()) ; for ( int k = 0 ; k < int( vPlAdjusted.size()) ; ++k ) m_vPlApprox.push_back( tuple(vPlAdjusted[k], vbOrientation[k])) ; - // aggiorno la mappa del chunk di appartenenza per tutti i loop aggiunti // do per scontato che siano tutti dello stesso chunk anche se li ho separati + // aggiorno la mappa del chunk di appartenenza per tutti i loop aggiunti // do per scontato che siano tutti dello stesso chunk anche se li ho separati for ( int k = nLoop ; k < int( m_vPlApprox.size()); ++k) m_mChunk[k] = i ; } } } - // salvo i vertici 3d della cella root + // salvo i vertici 3d della cella root Point3d ptP00, ptP10, ptP11, ptP01 ; bool bOk = false ; if ( ! bLimited) { @@ -254,7 +255,7 @@ Tree::SetSurf( const SurfBezier* pSrfBz, bool bSplitPatches, const Point3d& ptMi GetPoint( ptMax.x, ptMax.y, ptP11) ; GetPoint( ptMin.x, ptMax.y, ptP01) ; } - // se richiesto divido preliminarmente le patches + // se richiesto divido preliminarmente le patches m_vnParents.clear() ; bool bIsPlanar = m_pSrfBz->IsPlanar() ; if( ! bIsPlanar || m_bMulti) { @@ -307,13 +308,13 @@ Tree::SetSurf( const SurfBezier* pSrfBz, bool bSplitPatches, const Point3d& ptMi } vLeaves.clear() ; } - // controllo se la superficie è chiusa. - // se è chiusa e non ho già fatto split preliminare, splitto sul parametro su cui è chiusa - // e sistemo le adiacenze + // controllo se la superficie è chiusa. + // se è chiusa e non ho già fatto split preliminare, splitto sul parametro su cui è chiusa + // e sistemo le adiacenze if ( ( AreSamePointApprox( ptP00, ptP01) || AreSamePointApprox( ptP10, ptP11)) || - ( AreSamePointApprox( ptP00, ptP10) || AreSamePointApprox( ptP01, ptP11))) { + ( AreSamePointApprox( ptP00, ptP10) || AreSamePointApprox( ptP01, ptP11))) { if ( ( AreSamePointApprox( ptP00, ptP01) || AreSamePointApprox( ptP10, ptP11))) { - + ////questo in teoria non serve più perché lo faccio appena sopra if( int( m_mTree.size()) == 1) { if ( AreSamePointApprox( ptP00, ptP01) && AreSamePointApprox( ptP10, ptP11)) { @@ -326,13 +327,13 @@ Tree::SetSurf( const SurfBezier* pSrfBz, bool bSplitPatches, const Point3d& ptMi } //////// - // qui devo fare il controllo capped ( chiusura a semisfera) - // devo controllare se i punti ai parametri U=0 e U=1 sono tutti coincidenti - // in caso devo fare uno split nell'altra direzione + // qui devo fare il controllo capped ( chiusura a semisfera) + // devo controllare se i punti ai parametri U=0 e U=1 sono tutti coincidenti + // in caso devo fare uno split nell'altra direzione bool bOk = false ; bool bPole0 = true, bPole1 = true ; Point3d ptU0, ptU1 ; - // controllo se tutti i punti di controllo sull'isoparametrica sono uguali + // controllo se tutti i punti di controllo sull'isoparametrica sono uguali for ( int i = 1 ; i < nDegV * nSpanV + 1 ; ++ i) { ptU0 = m_pSrfBz->GetControlPoint( i * ( nDegU * nSpanU + 1), &bOk) ; bPole0 = bPole0 && AreSamePointApprox( ptP00, ptU0) ; @@ -348,9 +349,9 @@ Tree::SetSurf( const SurfBezier* pSrfBz, bool bSplitPatches, const Point3d& ptMi Split( 1, m_mTree) ; } } - // nella condizione di questo if non controllo eventuali divisioni preliminari, perché ne tengo conto dopo + // nella condizione di questo if non controllo eventuali divisioni preliminari, perché ne tengo conto dopo if ( AreSamePointApprox( ptP00, ptP10) || AreSamePointApprox( ptP01, ptP11)) { - + //// questo in teoria non serve più perché lo faccio sopra if ( m_mTree.size() == 1) { if ( AreSamePointApprox( ptP00, ptP10) && AreSamePointApprox( ptP01, ptP11)) { @@ -383,7 +384,7 @@ Tree::SetSurf( const SurfBezier* pSrfBz, bool bSplitPatches, const Point3d& ptMi m_mTree[1].SetSplitDirVert( false) ; Split( 1, m_mTree) ; } - // se ho fatto solo 1 split orizzontale e ho due celle foglie nId = 0 e nId = 1 + // se ho fatto solo 1 split orizzontale e ho due celle foglie nId = 0 e nId = 1 if ( int( m_mTree.size() == 3) && ! m_mTree.at(-1).IsSplitVert()) { m_mTree[0].m_nLeft = -1 ; m_mTree[0].m_nRight = -1 ; @@ -401,8 +402,8 @@ Tree::SetSurf( const SurfBezier* pSrfBz, bool bSplitPatches, const Point3d& ptMi INTVECTOR vLeaves ; GetHeightLeaves( -1, vLeaves) ; m_vnParents = vLeaves ; - - // calcolo e salvo la lunghezza reale delle curve di bezier di bordo + + // calcolo e salvo la lunghezza reale delle curve di bezier di bordo PtrOwner pCrvV0( m_pSrfBz->GetCurveOnU( 0)) ; PtrOwner pCrvV1( m_pSrfBz->GetCurveOnU( double(nSpanV))) ; PtrOwner pCrvU0( m_pSrfBz->GetCurveOnV( 0)) ; @@ -449,15 +450,15 @@ AddOrMergeBBox( const BBox3d& bBox3dA, vector& vBBox, bool bAdd = true, for ( int b = 0 ; b < (int)vBBox.size() ; ++b) { BBox3d bBox3dB = vBBox[b] ; BBox3d b3Int ; - // se sono celle diverse e ho un'intersezione faccio il merge + // se sono celle diverse e ho un'intersezione faccio il merge if ( ! ( AreSamePointXYExact( ptMin, bBox3dB.GetMin()) && AreSamePointXYExact( ptMax, bBox3dB.GetMax())) && - bBox3dA.FindIntersectionXY( bBox3dB, b3Int)) { + bBox3dA.FindIntersectionXY( bBox3dB, b3Int)) { vBBox[b].Add( bBox3dA) ; if ( ! bAdd ) { vBBox.erase( vBBox.begin() + nInd) ; -- b ; } - // se ho fatto un merge devo controllare se ora la nuova bbox ha delle intersezioni + // se ho fatto un merge devo controllare se ora la nuova bbox ha delle intersezioni AddOrMergeBBox( vBBox[b], vBBox, false, b) ; bAdded = true ; break ; @@ -476,21 +477,21 @@ Tree::GetIndependentTrees( BIPNTVECTOR& vTrees) vTrees.emplace_back( ORIG, ORIG) ; } else { - // se ho dei loop di trim trovo le loro BBox3d per costruire l'albero solo all'interno di queste BBox + // se ho dei loop di trim trovo le loro BBox3d per costruire l'albero solo all'interno di queste BBox BOXVECTOR vBBox ; for ( int i = 0 ; i < int( m_vPlApprox.size()) ; ++ i) { PolyLine& plLoop = get<0>( m_vPlApprox[i]) ; - // calcolo la BBox3d + // calcolo la BBox3d Point3d ptP ; plLoop.GetFirstPoint( ptP) ; BBox3d bBox3dA( ptP) ; while ( plLoop.GetNextPoint( ptP)) bBox3dA.Add( ptP) ; - // controllo se ho intersezioni con altre bbox - // se ho intersezioni unisco le bbox, altrimenti le lascio indipendenti + // controllo se ho intersezioni con altre bbox + // se ho intersezioni unisco le bbox, altrimenti le lascio indipendenti AddOrMergeBBox( bBox3dA, vBBox) ; } - // controllo se dopo aver unito le bbox ho ottenuto Root + // controllo se dopo aver unito le bbox ho ottenuto Root bool bIsRoot = false ; Point3d ptTR( m_nSpanU * SBZ_TREG_COEFF, m_nSpanV * SBZ_TREG_COEFF) ; for ( int i = 0 ; i < int( vBBox.size()) ; ++ i) { @@ -500,7 +501,7 @@ Tree::GetIndependentTrees( BIPNTVECTOR& vTrees) break ; } } - // restituisco le celle parent di partenza a partire dalle bbox che ho ottenuto + // restituisco le celle parent di partenza a partire dalle bbox che ho ottenuto if ( ! bIsRoot) { for ( int i = 0 ; i < int( vBBox.size()) ; ++ i) { Point3d ptMin = vBBox[i].GetMin() ; @@ -519,12 +520,12 @@ bool Tree::Split( int nId, double dSplitValue, unordered_map& mBranch) { Cell& cToSplit = mBranch.at(nId) ; - // controllo che lo split non venga fatto sul lato della cella + // controllo che lo split non venga fatto sul lato della cella if ( ( cToSplit.IsSplitVert() && dSplitValue > cToSplit.GetBottomLeft().x + EPS_SMALL && - dSplitValue < cToSplit.GetTopRight().x - EPS_SMALL) || - ( ! cToSplit.IsSplitVert() && dSplitValue > cToSplit.GetBottomLeft().y + EPS_SMALL && - dSplitValue < cToSplit.GetTopRight().y - EPS_SMALL)) { - // quando si implementerà lo split a parametro libero bisognerà impedire che si facciano split troppo vicini al bordo della cella!!!!!!!!!!!!!!!!!!! + dSplitValue < cToSplit.GetTopRight().x - EPS_SMALL) || + ( ! cToSplit.IsSplitVert() && dSplitValue > cToSplit.GetBottomLeft().y + EPS_SMALL && + dSplitValue < cToSplit.GetTopRight().y - EPS_SMALL)) { + // quando si implementerà lo split a parametro libero bisognerà impedire che si facciano split troppo vicini al bordo della cella!!!!!!!!!!!!!!!!!!! cToSplit.m_dSplit = dSplitValue ; Cell cChild1, cChild2 ; cChild1.m_nDepth = cToSplit.m_nDepth + 1 ; @@ -701,7 +702,7 @@ Tree::BuildTree( double dLinTol, double dSideMin, double dSideMax) condition_variable cv ; vector> vBranches( nStartingLeaves) ; INTVECTOR vFirstCells ; - + // creo la coda dei task queue> qTasks ; bool done = false ; @@ -714,7 +715,7 @@ Tree::BuildTree( double dLinTol, double dSideMin, double dSideMax) qTasks.emplace([this, i, &vBranches, dLinTol, dSideMin, dSideMax, nFirst] {Tree::BuildBranch( nFirst, vBranches[i], dLinTol, dSideMin, dSideMax) ;} ) ; } - + // Create worker threads vector workers ; for (int i = 0 ; i < nThreadMax ; ++i) @@ -757,7 +758,7 @@ Tree::BuildTree( double dLinTol, double dSideMin, double dSideMax) [&](auto& map) { size_t index = &map - &vBranches[0]; // Get the index of the current map vectorBranches[index].assign( make_move_iterator(map.begin()), - make_move_iterator(map.end())); + make_move_iterator(map.end())); }) ; // Step 2: Precompute total size and allocate final vector @@ -819,7 +820,7 @@ Tree::BuildBranch( int nFirstCell, unordered_map& mBranch, double dLi GetPoint(pcToSplit->GetTopRight().x, pcToSplit->GetTopRight().y, ptP11) ; GetPoint(pcToSplit->GetBottomLeft().x, pcToSplit->GetTopRight().y, ptP01) ; if ( dLenParU <= 1. / m_nDegV || dLenParV <= 1. / m_nDegU || Dist(ptP00, ptP11) < dSideMin * 2 - || Dist(ptP10, ptP01) < dSideMin * 2) { + || Dist(ptP10, ptP01) < dSideMin * 2) { double dU = ( pcToSplit->GetTopRight().x + pcToSplit->GetBottomLeft().x) / 2 ; double dV = ( pcToSplit->GetTopRight().y + pcToSplit->GetBottomLeft().y) / 2 ; double dULoc = 0.5, dVLoc = 0.5 ; @@ -977,7 +978,7 @@ Tree::BuildBranch( int nFirstCell, unordered_map& mBranch, double dLi } // calcolo le diagonali per controllare la dimensione massima dei triangoli in cui dividerei la cella dSideMaxVal = max( Dist( ptP00, ptP11), Dist( ptP10, ptP01)) ; - + // se la cella è abbastanza grande da poter essere divisa ancora, calcolo l'errore di approssimazione bool bSplit = false ; // dSideMinVal potrebbe essere zero se entrambi i lati che dovrei splittare sono collassati in un punto, ma questo non vuol @@ -1003,7 +1004,7 @@ Tree::BuildBranch( int nFirstCell, unordered_map& mBranch, double dLi double dU = double ( u) / double ( nStepsU - 1) ; double dULoc = ( ( 1 - dU) * pcToSplit->GetBottomLeft().x + dU * pcToSplit->GetTopRight().x) ; if ( ! GetPoint( dULoc, pcToSplit->GetBottomLeft().y, ptBz0) || - ! GetPoint( dULoc, pcToSplit->GetTopRight().y, ptBz1)) + ! GetPoint( dULoc, pcToSplit->GetTopRight().y, ptBz1)) return false ; // verifico che la cella non sia uno spicchio in verticale, cioè con ptP00 == ptP01 && ptP10 == ptP11 // ( vedi disegno sotto per uno spicchio verticale) @@ -1032,15 +1033,15 @@ Tree::BuildBranch( int nFirstCell, unordered_map& mBranch, double dLi double dDist ; dpc.GetDist( dDist) ; // se la cella è uno spicchio, quindi con due lati collassati, devo calcolare in modo diverso dist - // ptP00 == ptP01 - // / \ - // / \ + // ptP00 == ptP01 + // / \ + // / \ // / \ // ( ) - // \ / - // \ / - // \ / - // ptP10 == ptP11 +// \ / +// \ / +// \ / +// ptP10 == ptP11 if ( ! clV.IsValid() && AreSamePointApprox( ptP00, ptP01) && AreSamePointApprox( ptP10, ptP11)) { DistPointCurve dpcSlice( ptBzV, cl0010) ; dpcSlice.GetDist( dDist) ; @@ -1078,9 +1079,9 @@ Tree::BuildBranch( int nFirstCell, unordered_map& mBranch, double dLi pcToSplit->SetProcessed() ; // risalgo i parent finché non trovo il primo Child2 da processare nCToSplit = pcToSplit->m_nParent ; - pcToSplit = &mBranch[nCToSplit] ; if ( nCToSplit == nBranchRoot) return true ; + pcToSplit = &mBranch.at(nCToSplit) ; if ( mBranch[pcToSplit->m_nChild1].IsProcessed() && mBranch[pcToSplit->m_nChild2].IsProcessed()) pcToSplit->SetProcessed() ; while ( mBranch[pcToSplit->m_nChild2].IsProcessed()) { @@ -1093,7 +1094,7 @@ Tree::BuildBranch( int nFirstCell, unordered_map& mBranch, double dLi if ( mBranch[pcToSplit->m_nChild1].IsProcessed() && mBranch[pcToSplit->m_nChild2].IsProcessed()) pcToSplit->SetProcessed() ; if ( nCToSplit == -1 && mBranch[pcToSplit->m_nChild2].IsProcessed()) - break ; + break ; } nCToSplit = pcToSplit->m_nChild2 ; pcToSplit = &mBranch[nCToSplit] ; @@ -1121,7 +1122,7 @@ Tree::BuildBranch( int nFirstCell, unordered_map& mBranch, double dLi double dLen1 = Dist( ptP10, ptP11) ; double dLen2 = Dist( ptP01, ptP11) ; double dLen3 = Dist( ptP00, ptP01) ; - + bool bVert = false ; ///per capire in quale direzione splittare devo guardare quale coppia di lati opposti è più sghemba Vector3d vtU0 = ptP01 - ptP00 ; @@ -1140,12 +1141,12 @@ Tree::BuildBranch( int nFirstCell, unordered_map& mBranch, double dLi bVert = false ; else bVert = true ; - - // verifico che la cella sia abbastanza grande da poter essere splittata + + // verifico che la cella sia abbastanza grande da poter essere splittata double dSideMinVal = ( bVert ? max( dLen0, dLen2) : max( dLen1, dLen3)) ; - // calcolo le diagonali per controllare la dimensione massima dei triangoli in cui dividerei la cella + // calcolo le diagonali per controllare la dimensione massima dei triangoli in cui dividerei la cella double dSideMaxVal = max( Dist( ptP00, ptP11), Dist( ptP10, ptP01)) ; - + double dErr = 0 ; if ( m_bMulti) { Point3d ptPSrf ; @@ -1190,9 +1191,9 @@ Tree::BuildBranch( int nFirstCell, unordered_map& mBranch, double dLi pcToSplit->SetProcessed() ; // risalgo i parent finché non trovo il primo Child2 da processare nCToSplit = pcToSplit->m_nParent ; - pcToSplit = &mBranch[nCToSplit] ; if ( nCToSplit == nBranchRoot) return true ; + pcToSplit = &mBranch[nCToSplit] ; if ( mBranch[pcToSplit->m_nChild1].IsProcessed() && mBranch[pcToSplit->m_nChild2].IsProcessed()) pcToSplit->SetProcessed() ; while ( mBranch[pcToSplit->m_nChild2].IsProcessed()) { @@ -1246,16 +1247,16 @@ Tree::GetTopNeigh( int nId, INTVECTOR& vTopNeighs) const vTopNeighs.push_back( cell.m_nTop) ; else { if ( m_mTree.at( cell.m_nTop).IsSplitVert()) { - // se la cella vicina è più piccola della cella indagata, allora entrambi i figli saranno vicini di quest'ultima + // se la cella vicina è più piccola della cella indagata, allora entrambi i figli saranno vicini di quest'ultima if ( m_mTree.at( cell.m_nTop).GetTopRight().x - m_mTree.at( cell.m_nTop).GetBottomLeft().x <= cell.GetTopRight().x - cell.GetBottomLeft().x) { vTopNeighs.push_back( m_mTree.at( cell.m_nTop).m_nChild1) ; vTopNeighs.push_back( m_mTree.at( cell.m_nTop).m_nChild2) ; } - // altrimenti solo uno dei figli lo sarà + // altrimenti solo uno dei figli lo sarà else { if ( m_mTree.at( m_mTree.at( cell.m_nTop).m_nChild1).GetTopRight().x <= cell.GetBottomLeft().x || - m_mTree.at( m_mTree.at( cell.m_nTop).m_nChild1).GetBottomLeft().x >= cell.GetTopRight().x ) + m_mTree.at( m_mTree.at( cell.m_nTop).m_nChild1).GetBottomLeft().x >= cell.GetTopRight().x ) vTopNeighs.push_back( m_mTree.at( cell.m_nTop).m_nChild2) ; else vTopNeighs.push_back( m_mTree.at( cell.m_nTop).m_nChild1) ; @@ -1271,7 +1272,7 @@ Tree::GetTopNeigh( int nId, INTVECTOR& vTopNeighs) const bAllLeaves = false ; } if ( ! bAllLeaves) - // almeno una cella tra i vicini trovati non è leaf quindi devo richiamare ricorsivamente questa funzione per trovare i suoi child + // almeno una cella tra i vicini trovati non è leaf quindi devo richiamare ricorsivamente questa funzione per trovare i suoi child GetTopNeigh( nId, vTopNeighs) ; } else { @@ -1280,17 +1281,17 @@ Tree::GetTopNeigh( int nId, INTVECTOR& vTopNeighs) const if ( m_mTree.at( i).IsLeaf()) continue ; else { - // se la cella non è leaf la tolgo dal vettore delle foglie e aggiungo invece i suoi child + // se la cella non è leaf la tolgo dal vettore delle foglie e aggiungo invece i suoi child vTopNeighs.erase( remove( vTopNeighs.begin(),vTopNeighs.end(),i)) ; -- j ; if ( m_mTree.at( i).IsSplitVert()) { - // se la cella è più piccola della cella indagata, allora entrambi i figli saranno vicini di quest'ultima + // se la cella è più piccola della cella indagata, allora entrambi i figli saranno vicini di quest'ultima if ( m_mTree.at( i).GetTopRight().x - m_mTree.at( i).GetBottomLeft().x <= cell.GetTopRight().x - cell.GetBottomLeft().x) { vTopNeighs.push_back( m_mTree.at( i).m_nChild1) ; vTopNeighs.push_back( m_mTree.at( i).m_nChild2) ; } - // altrimenti solo uno dei figli lo sarà + // altrimenti solo uno dei figli lo sarà else { if ( m_mTree.at( m_mTree.at( i).m_nChild1).GetTopRight().x <= cell.GetBottomLeft().x || m_mTree.at( m_mTree.at( i).m_nChild1).GetBottomLeft().x >= cell.GetTopRight().x ) @@ -1329,13 +1330,13 @@ Tree::GetBottomNeigh( int nId, INTVECTOR& vBottomNeighs) const vBottomNeighs.push_back( cell.m_nBottom) ; else { if ( m_mTree.at( cell.m_nBottom).IsSplitVert()) { - // se la cella vicina è più piccola della cella indagata, allora entrambi i figli saranno vicini di quest'ultima + // se la cella vicina è più piccola della cella indagata, allora entrambi i figli saranno vicini di quest'ultima if ( m_mTree.at( cell.m_nBottom).GetTopRight().x - m_mTree.at( cell.m_nBottom).GetBottomLeft().x <= cell.GetTopRight().x - cell.GetBottomLeft().x) { vBottomNeighs.push_back( m_mTree.at( cell.m_nBottom).m_nChild1) ; vBottomNeighs.push_back( m_mTree.at( cell.m_nBottom).m_nChild2) ; } - // altrimenti solo uno dei figli lo sarà + // altrimenti solo uno dei figli lo sarà else{ if ( m_mTree.at( m_mTree.at( cell.m_nBottom).m_nChild1).GetTopRight().x <= cell.GetBottomLeft().x || m_mTree.at( m_mTree.at( cell.m_nBottom).m_nChild1).GetBottomLeft().x >= cell.GetTopRight().x ) @@ -1354,7 +1355,7 @@ Tree::GetBottomNeigh( int nId, INTVECTOR& vBottomNeighs) const bAllLeaves = false ; } if ( ! bAllLeaves) - // almeno una cella tra i vicini trovati non è leaf quindi devo richiamare ricorsivamente questa funzione per trovare i suoi child + // almeno una cella tra i vicini trovati non è leaf quindi devo richiamare ricorsivamente questa funzione per trovare i suoi child GetBottomNeigh( nId, vBottomNeighs) ; } else { @@ -1363,17 +1364,17 @@ Tree::GetBottomNeigh( int nId, INTVECTOR& vBottomNeighs) const if ( m_mTree.at( i).IsLeaf()) continue ; else { - // se la cella non è leaf la tolgo dal vettore delle foglie e aggiungo invece i suoi child + // se la cella non è leaf la tolgo dal vettore delle foglie e aggiungo invece i suoi child vBottomNeighs.erase( remove( vBottomNeighs.begin(),vBottomNeighs.end(),i)) ; -- j ; if ( m_mTree.at( i).IsSplitVert()) { - // se la cella è più piccola della cella indagata, allora entrambi i figli saranno vicini di quest'ultima + // se la cella è più piccola della cella indagata, allora entrambi i figli saranno vicini di quest'ultima if ( m_mTree.at( i).GetTopRight().x - m_mTree.at( i).GetBottomLeft().x <= cell.GetTopRight().x - cell.GetBottomLeft().x) { vBottomNeighs.push_back( m_mTree.at( i).m_nChild1) ; vBottomNeighs.push_back( m_mTree.at( i).m_nChild2) ; } - // altrimenti solo uno dei figli lo sarà + // altrimenti solo uno dei figli lo sarà else { if ( m_mTree.at( m_mTree.at( i).m_nChild1).GetTopRight().x <= cell.GetBottomLeft().x || m_mTree.at( m_mTree.at( i).m_nChild1).GetBottomLeft().x >= cell.GetTopRight().x) @@ -1410,25 +1411,25 @@ Tree::GetLeftNeigh( int nId, INTVECTOR& vLeftNeighs) const if ( m_mTree.at( cell.m_nLeft).IsLeaf()) vLeftNeighs.push_back( cell.m_nLeft) ; else { - if ( ! m_mTree.at( cell.m_nLeft).IsSplitVert()) { - // se la cella vicina è più piccola della cella indagata, allora entrambi i figli saranno vicini di quest'ultima - if ( m_mTree.at( cell.m_nLeft).GetTopRight().y - m_mTree.at( cell.m_nLeft).GetBottomLeft().y <= - cell.GetTopRight().y - cell.GetBottomLeft().y) { - vLeftNeighs.push_back( m_mTree.at( cell.m_nLeft).m_nChild1) ; - vLeftNeighs.push_back( m_mTree.at( cell.m_nLeft).m_nChild2) ; - } - // altrimenti solo uno dei figli lo sarà - else{ - if ( m_mTree.at( m_mTree.at( cell.m_nLeft).m_nChild1).GetTopRight().y <= cell.GetBottomLeft().y || - m_mTree.at( m_mTree.at( cell.m_nLeft).m_nChild1).GetBottomLeft().y >= cell.GetTopRight().y) - vLeftNeighs.push_back( m_mTree.at( cell.m_nLeft).m_nChild2) ; - else - vLeftNeighs.push_back( m_mTree.at( cell.m_nLeft).m_nChild1) ; - } - } - else { + if ( ! m_mTree.at( cell.m_nLeft).IsSplitVert()) { + // se la cella vicina è più piccola della cella indagata, allora entrambi i figli saranno vicini di quest'ultima + if ( m_mTree.at( cell.m_nLeft).GetTopRight().y - m_mTree.at( cell.m_nLeft).GetBottomLeft().y <= + cell.GetTopRight().y - cell.GetBottomLeft().y) { + vLeftNeighs.push_back( m_mTree.at( cell.m_nLeft).m_nChild1) ; vLeftNeighs.push_back( m_mTree.at( cell.m_nLeft).m_nChild2) ; } + // altrimenti solo uno dei figli lo sarà + else{ + if ( m_mTree.at( m_mTree.at( cell.m_nLeft).m_nChild1).GetTopRight().y <= cell.GetBottomLeft().y || + m_mTree.at( m_mTree.at( cell.m_nLeft).m_nChild1).GetBottomLeft().y >= cell.GetTopRight().y) + vLeftNeighs.push_back( m_mTree.at( cell.m_nLeft).m_nChild2) ; + else + vLeftNeighs.push_back( m_mTree.at( cell.m_nLeft).m_nChild1) ; + } + } + else { + vLeftNeighs.push_back( m_mTree.at( cell.m_nLeft).m_nChild2) ; + } } bool bAllLeaves = true ; for ( int i : vLeftNeighs) { @@ -1436,7 +1437,7 @@ Tree::GetLeftNeigh( int nId, INTVECTOR& vLeftNeighs) const bAllLeaves = false ; } if ( ! bAllLeaves) - // almeno una cella tra i vicini trovati non è leaf quindi devo richiamare ricorsivamente questa funzione per trovare i suoi child + // almeno una cella tra i vicini trovati non è leaf quindi devo richiamare ricorsivamente questa funzione per trovare i suoi child GetLeftNeigh( nId, vLeftNeighs) ; } else { @@ -1445,20 +1446,20 @@ Tree::GetLeftNeigh( int nId, INTVECTOR& vLeftNeighs) const if ( m_mTree.at( i).IsLeaf()) continue ; else { - // se la cella non è leaf la tolgo dal vettore delle foglie e aggiungo invece i suoi child + // se la cella non è leaf la tolgo dal vettore delle foglie e aggiungo invece i suoi child vLeftNeighs.erase( remove( vLeftNeighs.begin(),vLeftNeighs.end(),i)) ; -- j ; if ( ! m_mTree.at( i).IsSplitVert()) { - // se la cella è più piccola della cella indagata, allora entrambi i figli saranno vicini di quest'ultima + // se la cella è più piccola della cella indagata, allora entrambi i figli saranno vicini di quest'ultima if ( m_mTree.at( i).GetTopRight().y - m_mTree.at( i).GetBottomLeft().y <= - cell.GetTopRight().y - cell.GetBottomLeft().y) { + cell.GetTopRight().y - cell.GetBottomLeft().y) { vLeftNeighs.push_back( m_mTree.at( i).m_nChild1) ; vLeftNeighs.push_back( m_mTree.at( i).m_nChild2) ; } - // altrimenti solo uno dei figli lo sarà + // altrimenti solo uno dei figli lo sarà else { if ( m_mTree.at( m_mTree.at( i).m_nChild1).GetTopRight().y <= cell.GetBottomLeft().y || - m_mTree.at( m_mTree.at( i).m_nChild1).GetBottomLeft().y >= cell.GetTopRight().y) + m_mTree.at( m_mTree.at( i).m_nChild1).GetBottomLeft().y >= cell.GetTopRight().y) vLeftNeighs.push_back( m_mTree.at( i).m_nChild2) ; else vLeftNeighs.push_back( m_mTree.at( i).m_nChild1) ; @@ -1493,16 +1494,16 @@ Tree::GetRightNeigh( int nId, INTVECTOR& vRightNeighs) const vRightNeighs.push_back( cell.m_nRight) ; else { if ( ! m_mTree.at( cell.m_nRight).IsSplitVert()) { - // se la cella vicina è più piccola della cella indagata, allora entrambi i figli saranno vicini di quest'ultima + // se la cella vicina è più piccola della cella indagata, allora entrambi i figli saranno vicini di quest'ultima if ( m_mTree.at( cell.m_nRight).GetTopRight().y - m_mTree.at( cell.m_nRight).GetBottomLeft().y <= - cell.GetTopRight().y - cell.GetBottomLeft().y) { + cell.GetTopRight().y - cell.GetBottomLeft().y) { vRightNeighs.push_back( m_mTree.at( cell.m_nRight).m_nChild1) ; vRightNeighs.push_back( m_mTree.at( cell.m_nRight).m_nChild2) ; } - // altrimenti solo uno dei figli lo sarà + // altrimenti solo uno dei figli lo sarà else{ if ( m_mTree.at( m_mTree.at( cell.m_nRight).m_nChild1).GetTopRight().y <= cell.GetBottomLeft().y || - m_mTree.at( m_mTree.at( cell.m_nRight).m_nChild1).GetBottomLeft().y >= cell.GetTopRight().y) + m_mTree.at( m_mTree.at( cell.m_nRight).m_nChild1).GetBottomLeft().y >= cell.GetTopRight().y) vRightNeighs.push_back( m_mTree.at( cell.m_nRight).m_nChild2) ; else vRightNeighs.push_back( m_mTree.at( cell.m_nRight).m_nChild1) ; @@ -1518,7 +1519,7 @@ Tree::GetRightNeigh( int nId, INTVECTOR& vRightNeighs) const bAllLeaves = false ; } if ( ! bAllLeaves) - // almeno una cella tra i vicini trovati non è leaf quindi devo richiamare ricorsivamente questa funzione per trovare i suoi child + // almeno una cella tra i vicini trovati non è leaf quindi devo richiamare ricorsivamente questa funzione per trovare i suoi child GetRightNeigh( nId, vRightNeighs) ; } else { @@ -1527,20 +1528,20 @@ Tree::GetRightNeigh( int nId, INTVECTOR& vRightNeighs) const if ( m_mTree.at( i).IsLeaf()) continue ; else { - // se la cella non è leaf la tolgo dal vettore delle foglie e aggiungo invece i suoi child + // se la cella non è leaf la tolgo dal vettore delle foglie e aggiungo invece i suoi child vRightNeighs.erase( remove( vRightNeighs.begin(),vRightNeighs.end(), i)) ; -- j ; if ( ! m_mTree.at( i).IsSplitVert()) { - // se la cella è più piccola della cella indagata, allora entrambi i figli saranno vicini di quest'ultima + // se la cella è più piccola della cella indagata, allora entrambi i figli saranno vicini di quest'ultima if ( m_mTree.at( i).GetTopRight().y - m_mTree.at( i).GetBottomLeft().y <= - cell.GetTopRight().y - cell.GetBottomLeft().y) { + cell.GetTopRight().y - cell.GetBottomLeft().y) { vRightNeighs.push_back( m_mTree.at( i).m_nChild1) ; vRightNeighs.push_back( m_mTree.at( i).m_nChild2) ; } - // altrimenti solo uno dei figli lo sarà + // altrimenti solo uno dei figli lo sarà else { if ( m_mTree.at( m_mTree.at( i).m_nChild1).GetTopRight().y <= cell.GetBottomLeft().y || - m_mTree.at( m_mTree.at( i).m_nChild1).GetBottomLeft().y >= cell.GetTopRight().y) + m_mTree.at( m_mTree.at( i).m_nChild1).GetBottomLeft().y >= cell.GetTopRight().y) vRightNeighs.push_back( m_mTree.at( i).m_nChild2) ; else vRightNeighs.push_back( m_mTree.at( i).m_nChild1) ; @@ -1622,7 +1623,7 @@ Tree::GetHeightLeaves( int nId, INTVECTOR& vnLeaves, int d) const vnLeaves.push_back( m_mTree.at( nId).m_nChild1) ; vnLeaves.push_back( m_mTree.at( nId).m_nChild2) ; if ( ! m_mTree.at( m_mTree.at( nId).m_nChild1).IsLeaf() || ! m_mTree.at( m_mTree.at( nId).m_nChild2).IsLeaf()) - // almeno un child non è leaf quindi devo richiamare ricorsivamente questa funzione sui child in questione + // almeno un child non è leaf quindi devo richiamare ricorsivamente questa funzione sui child in questione d = GetHeightLeaves( nId, vnLeaves, m_mTree.at( m_mTree.at( nId).m_nChild1).m_nDepth) ; } } @@ -1633,7 +1634,7 @@ Tree::GetHeightLeaves( int nId, INTVECTOR& vnLeaves, int d) const continue ; } else { - // se la cella non è leaf la tolgo dal vettore delle foglie e aggiungo invece i suoi child + // se la cella non è leaf la tolgo dal vettore delle foglie e aggiungo invece i suoi child vnLeaves.erase( remove( vnLeaves.begin(),vnLeaves.end(),i)) ; -- j ; vnLeaves.push_back( m_mTree.at( i).m_nChild1) ; @@ -1669,7 +1670,7 @@ Tree::GetPolygons( POLYLINEMATRIX& vvPolygons, POLYLINEMATRIX& vvPolygons3d, vec POLYLINEVECTOR vPolygonsBasic3d ; if ( ! m_bTrimmed) { vvPolygons.clear() ; - + GetPolygonsBasic( vPolygonsBasic, vPolygonsCorrected, vPolygonsBasic3d) ; if (vPolygonsBasic.empty()) return false ; @@ -2106,11 +2107,11 @@ Tree::FindCell( const Point3d& ptToAssign, const CurveLine& clTrim, bool bRecurs // verifico che il punto sia all'interno dello spazio parametrico // allargo i bordi in modo da tenere anche i punti sul bordo dello spazio parametrico if ( ptToAssign.x < m_mTree.at( -1).GetBottomLeft().x - EPS_SMALL || ptToAssign.x > m_mTree.at( -1).GetTopRight().x + EPS_SMALL|| - ptToAssign.y < m_mTree.at( -1).GetBottomLeft().y - EPS_SMALL || ptToAssign.y > m_mTree.at( -1).GetTopRight().y + EPS_SMALL) { + ptToAssign.y < m_mTree.at( -1).GetBottomLeft().y - EPS_SMALL || ptToAssign.y > m_mTree.at( -1).GetTopRight().y + EPS_SMALL) { //nCells.push_back( - 2) ; return nCells ; } - + // se ho diviso preliminarmente le patches e in uno dei due parametri ho un numero dispari di patches devo individuare a mano la cella parent // in cui individuare la foglia giusta if ( (m_bSplitPatches && ( m_nSpanU > 1 || m_nSpanV > 1)) || m_bTestMode) { @@ -2151,7 +2152,7 @@ Tree::FindCell( const Point3d& ptToAssign, const CurveLine& clTrim, bool bRecurs Point3d ptBr( m_mTree.at( nId).GetTopRight().x , m_mTree.at( nId).GetBottomLeft().y) ; Point3d ptTl( m_mTree.at( nId).GetBottomLeft().x , m_mTree.at( nId).GetTopRight().y) ; if ( abs( ptToAssign.x - ptTl.x) < EPS_SMALL || abs( ptToAssign.x - ptBr.x) < EPS_SMALL || - abs( ptToAssign.y - ptTl.y) < EPS_SMALL || abs( ptToAssign.y - ptBr.y) < EPS_SMALL) + abs( ptToAssign.y - ptTl.y) < EPS_SMALL || abs( ptToAssign.y - ptBr.y) < EPS_SMALL) { Vector3d vtDir ; clTrim.GetStartDir( vtDir) ; @@ -2445,8 +2446,8 @@ Tree::TraceLoopLabelCell( const POLYLINEVECTOR& vplPolygons) else if ( nId == nFirstCell) { int nOut = pCell->m_vInters[nPass].nOut ; pCell->m_vInters.back().vpt.insert( pCell->m_vInters.back().vpt.end(), - pCell->m_vInters[nPass].vpt.begin(), - pCell->m_vInters[nPass].vpt.end()) ; + pCell->m_vInters[nPass].vpt.begin(), + pCell->m_vInters[nPass].vpt.end()) ; pCell->m_vInters[nPass] = pCell->m_vInters.back() ; pCell->m_vInters.pop_back() ; // sistemo il lato d'uscita @@ -2502,7 +2503,7 @@ Tree::TraceLoopLabelCell( const POLYLINEVECTOR& vplPolygons) m_mTree[nCell].m_nFlag2 = 1 ; CategorizeCell( nCell) ; } - + if ( ! m_mTree[nCell].IsProcessed()) { // guardo i vicini a destra per passare alla prossima cella vNeigh.clear() ; @@ -3015,7 +3016,7 @@ Tree::FindInters( int& nId, const CurveLine& clTrim, const PolyLine& plPolygon, //---------------------------------------------------------------------------- bool Tree::CreateCellPolygons( int nLeafId, POLYLINEMATRIX& vPolygons, POLYLINEMATRIX& vPolygons3d, INTVECTOR& vToCheck, int& nPoly, INTVECTOR& vnParentChunk, - const PolyLine& plCell, const PolyLine& plCell3d) + const PolyLine& plCell, const PolyLine& plCell3d) { // conto quanti vertici in più ho per lato e creo un vettore dei vertici per lato int nId = m_vnLeaves[nLeafId] ; @@ -3093,7 +3094,7 @@ Tree::CreateCellPolygons( int nLeafId, POLYLINEMATRIX& vPolygons, POLYLINEMATRIX plCell3d.GetNextPoint( pt3d) ; } } - + // comincio a costruire il poligono INTVECTOR vToCheckNow = vToCheck ; // costruisco i poligoni partendo dal vettore delle intersezioni, come spiegato a pag15 di Cripps @@ -3142,37 +3143,37 @@ Tree::CreateCellPolygons( int nLeafId, POLYLINEMATRIX& vPolygons, POLYLINEMATRIX if ( (nEdge == 0 || nEdge == 7) && nEdge == nEdgeLast) { vEdge.Set( 1,0,0) ; if ( AreOppositeVectorApprox( vLast, vEdge)) { - plTrimmedPoly.EraseLastUPoint() ; - plTrimmedPoly3d.EraseLastUPoint() ; - nEdge = 0 ; - bNotEquiverseOverlap = true ; + plTrimmedPoly.EraseLastUPoint() ; + plTrimmedPoly3d.EraseLastUPoint() ; + nEdge = 0 ; + bNotEquiverseOverlap = true ; } } else if ( ( nEdge == 1 || nEdge == 4 ) && nEdge == nEdgeLast) { vEdge.Set( 0,-1,0) ; if ( AreOppositeVectorApprox( vLast, vEdge)) { - plTrimmedPoly.EraseLastUPoint() ; - plTrimmedPoly3d.EraseLastUPoint() ; - nEdge = 1 ; - bNotEquiverseOverlap = true ; + plTrimmedPoly.EraseLastUPoint() ; + plTrimmedPoly3d.EraseLastUPoint() ; + nEdge = 1 ; + bNotEquiverseOverlap = true ; } } else if ( ( nEdge == 2 || nEdge == 5) && nEdge == nEdgeLast) { vEdge.Set( -1,0,0) ; if ( AreOppositeVectorApprox( vLast, vEdge)) { - plTrimmedPoly.EraseLastUPoint() ; - plTrimmedPoly3d.EraseLastUPoint() ; - nEdge = 2 ; - bNotEquiverseOverlap = true ; + plTrimmedPoly.EraseLastUPoint() ; + plTrimmedPoly3d.EraseLastUPoint() ; + nEdge = 2 ; + bNotEquiverseOverlap = true ; } } else if ( ( nEdge == 3 || nEdge == 6) && nEdge == nEdgeLast) { vEdge.Set( 0,1,0) ; if ( AreOppositeVectorApprox( vLast, vEdge)) { - plTrimmedPoly.EraseLastUPoint() ; - plTrimmedPoly3d.EraseLastUPoint() ; - nEdge = 3 ; - bNotEquiverseOverlap = true ; + plTrimmedPoly.EraseLastUPoint() ; + plTrimmedPoly3d.EraseLastUPoint() ; + nEdge = 3 ; + bNotEquiverseOverlap = true ; } } @@ -3251,7 +3252,7 @@ Tree::CreateCellPolygons( int nLeafId, POLYLINEMATRIX& vPolygons, POLYLINEMATRIX Point3d ptLast ; plTrimmedPoly.GetLastPoint( ptLast) ; for ( int p = nEdge == nEdgeWithVertexSkipped ? 0 : 1 ; p < (int) vEdgeVertex[nEdge].size() ; ++ p) { if ( CheckIfBefore( nEdge, vEdgeVertex[nEdge][p], cCell.m_vInters[vToCheckNow[nNext]].vpt[0]) && - CheckIfBefore( nEdge, ptLast, vEdgeVertex[nEdge][p])) { + CheckIfBefore( nEdge, ptLast, vEdgeVertex[nEdge][p])) { plTrimmedPoly.AddUPoint( c, vEdgeVertex[nEdge][p]) ; plTrimmedPoly3d.AddUPoint( c, vEdgeVertex3d[nEdge][p]) ; ++ c ; @@ -3350,7 +3351,7 @@ Tree::CreateCellPolygons( int nLeafId, POLYLINEMATRIX& vPolygons, POLYLINEMATRIX //---------------------------------------------------------------------------- bool Tree::CreateIslandAndHoles( int nLeafId, POLYLINEMATRIX& vPolygons, POLYLINEMATRIX& vPolygons3d, int& nPoly, INTVECTOR& vnParentChunk, - const PolyLine& plPolygonsBasic, const PolyLine& plPolygonsBasic3d) + const PolyLine& plPolygonsBasic, const PolyLine& plPolygonsBasic3d) { // costruisco i poligoni partendo dal vettore delle intersezioni int nId = m_vnLeaves[nLeafId] ; @@ -3565,8 +3566,8 @@ Tree::CheckIfBefore( int nEdge1, const Point3d& ptP1, int nEdge2, const Point3d& bool Tree::CheckIfBefore( int nEdge, const Point3d& ptP1, const Point3d& ptP2, int nEdge2) const { - // i punti devono essere sullo stesso lato nEdge - // nEdge2 è di backup, in caso nEdge sia un vertice, per capire di quale lato si tratta + // i punti devono essere sullo stesso lato nEdge + // nEdge2 è di backup, in caso nEdge sia un vertice, per capire di quale lato si tratta int nEdgeRef = -1 ; if ( nEdge != nEdge2 && nEdge2 != -1) { if ( min( nEdge, nEdge2) < 4) @@ -3582,8 +3583,8 @@ Tree::CheckIfBefore( int nEdge, const Point3d& ptP1, const Point3d& ptP2, int nE } else nEdgeRef = nEdge ; - // sul lato nEdge controllo se ptP1 viene prima di ptP2. - // i lati vengono percorsi in senso antiorario + // sul lato nEdge controllo se ptP1 viene prima di ptP2. + // i lati vengono percorsi in senso antiorario if ( AreSameEdge( nEdgeRef, 0)) { return ( ptP1.x > ptP2.x) ; } @@ -3626,20 +3627,20 @@ Tree::AreSameEdge( int nEdge1, int nEdge2) const //---------------------------------------------------------------------------- bool Tree::AddVertex( int nId, const PNTMATRIX& vEdgeVertex, const PNTMATRIX& vEdgeVertex3d, PolyLine& plTrimmedPoly, int& c, - const Point3d& ptToAdd, PolyLine& plTrimmedPoly3d, bool bForTriangulation, Point3d& ptLast) const + const Point3d& ptToAdd, PolyLine& plTrimmedPoly3d, bool bForTriangulation, Point3d& ptLast) const { Point3d ptBr = m_mTree.at(nId).GetBottomRight() ; Point3d ptTR = m_mTree.at(nId).GetTopRight() ; Point3d ptTl = m_mTree.at(nId).GetTopLeft() ; Point3d ptBL = m_mTree.at(nId).GetBottomLeft() ; int nVertToSkip = m_mTree.at(nId).m_nVertToErase ; - // se è il primo punto della PolyLine lo aggiungo + // se è il primo punto della PolyLine lo aggiungo if ( plTrimmedPoly.GetPointNbr() == 0) { // se cerco di aggiungere il vertice che devo saltare, non faccio nulla if( ( nVertToSkip == 0 && AreSamePointXYApprox( ptToAdd, ptBL)) || - ( nVertToSkip == 1 && AreSamePointXYApprox( ptToAdd, ptBr)) || - ( nVertToSkip == 2 && AreSamePointXYApprox( ptToAdd, ptTR)) || - ( nVertToSkip == 3 && AreSamePointXYApprox( ptToAdd, ptTl))) { + ( nVertToSkip == 1 && AreSamePointXYApprox( ptToAdd, ptBr)) || + ( nVertToSkip == 2 && AreSamePointXYApprox( ptToAdd, ptTR)) || + ( nVertToSkip == 3 && AreSamePointXYApprox( ptToAdd, ptTl))) { // aggiorno l'ultimo punto aggiunto ptLast.Set( ptToAdd.x, ptToAdd.y, 0) ; return true ; @@ -3657,13 +3658,13 @@ Tree::AddVertex( int nId, const PNTMATRIX& vEdgeVertex, const PNTMATRIX& vEdgeVe return true ; } - // verifico di essere allineato con un lato, sennò aggiungo e basta + // verifico di essere allineato con un lato, sennò aggiungo e basta Vector3d vDir ; if ( ! AreSamePointXYApprox( ptToAdd, ptLast)) vDir = ptToAdd - ptLast ; else return false ; - // se non riesco a normalizzare perché sono troppo vicino ad un vertice allora aggiungo direttamente il vertice + // se non riesco a normalizzare perché sono troppo vicino ad un vertice allora aggiungo direttamente il vertice if ( ! vDir.Normalize()) { plTrimmedPoly.EraseLastUPoint() ; plTrimmedPoly3d.EraseLastUPoint() ; @@ -3700,8 +3701,8 @@ Tree::AddVertex( int nId, const PNTMATRIX& vEdgeVertex, const PNTMATRIX& vEdgeVe return true ; } if ( abs( vDir.x) > 1 - EPS_SMALL || abs( vDir.y) > 1 - EPS_SMALL) { - // se su un edge devo fare dei controlli - // edge 0 + // se su un edge devo fare dei controlli + // edge 0 if ( ptToAdd.x >= ptBL.x && ptToAdd.x <= ptTR.x && ptToAdd.y == ptTR.y && abs( vDir.x) > 1 - EPS_SMALL) { for ( int t = nVertToSkip == 2 ? 0 : 1 ; t < (int)vEdgeVertex[0].size() ; ++ t) { Point3d ptIntermed = vEdgeVertex[0][t] ; @@ -3722,7 +3723,7 @@ Tree::AddVertex( int nId, const PNTMATRIX& vEdgeVertex, const PNTMATRIX& vEdgeVe ++ c ; } } - // edge 1 + // edge 1 else if ( ptToAdd.y >= ptBL.y && ptToAdd.y <= ptTR.y && ptToAdd.x == ptBL.x && abs( vDir.y) > 1 - EPS_SMALL) { for ( int t = nVertToSkip == 3 ? 0 : 1 ; t < (int)vEdgeVertex[1].size() ; ++ t) { Point3d ptIntermed = vEdgeVertex[1][t] ; @@ -3743,7 +3744,7 @@ Tree::AddVertex( int nId, const PNTMATRIX& vEdgeVertex, const PNTMATRIX& vEdgeVe ++ c ; } } - // edge 2 + // edge 2 else if ( ptToAdd.x >= ptBL.x && ptToAdd.x <= ptTR.x && ptToAdd.y == ptBL.y && abs( vDir.x) > 1 - EPS_SMALL) { for ( int t = nVertToSkip == 0 ? 0 : 1 ; t < (int)vEdgeVertex[2].size() ; ++ t) { Point3d ptIntermed = vEdgeVertex[2][t] ; @@ -3764,7 +3765,7 @@ Tree::AddVertex( int nId, const PNTMATRIX& vEdgeVertex, const PNTMATRIX& vEdgeVe ++ c ; } } - // edge 3 + // edge 3 else if ( ptToAdd.y >= ptBL.y && ptToAdd.y <= ptTR.y && ptToAdd.x == ptTR.x && abs( vDir.y) > 1 - EPS_SMALL) { for ( int t = nVertToSkip == 1 ? 0 : 1 ; t < (int)vEdgeVertex[3].size() ; ++ t) { Point3d ptIntermed = vEdgeVertex[3][t] ; @@ -3785,8 +3786,8 @@ Tree::AddVertex( int nId, const PNTMATRIX& vEdgeVertex, const PNTMATRIX& vEdgeVe ++ c ; } } - // sono allineato con un lato, ma NON sono su un lato - // aggiungo e basta + // sono allineato con un lato, ma NON sono su un lato + // aggiungo e basta else { plTrimmedPoly.AddUPoint( c, ptToAdd) ; if( bForTriangulation) { @@ -3796,7 +3797,7 @@ Tree::AddVertex( int nId, const PNTMATRIX& vEdgeVertex, const PNTMATRIX& vEdgeVe ++ c ; } } - // non su un edge, quindi aggiungo e basta + // non su un edge, quindi aggiungo e basta else { plTrimmedPoly.AddUPoint( c, ptToAdd) ; if( bForTriangulation) { @@ -3816,15 +3817,15 @@ bool Tree::SetRightEdgeIn( int nId) { Cell& cCell = m_mTree[nId] ; - // categorizzo la cella in base a quanta parte del lato destro è contenuta all'interno delle curve di trim - // RightEdgeIn -> 0 non contenuto ; 1 contenuto ; 2 in parte contenuto + // categorizzo la cella in base a quanta parte del lato destro è contenuta all'interno delle curve di trim + // RightEdgeIn -> 0 non contenuto ; 1 contenuto ; 2 in parte contenuto int nPass = (int) cCell.m_vInters.size() ; if ( nPass == 0) { cCell.m_nRightEdgeIn = -1 ; return true ; } bool bDone = false ; - // se ho solo loop interni devo controllare se il più esterno è CCW ( lato destro esterno) o CW ( lato destro interno) + // se ho solo loop interni devo controllare se il più esterno è CCW ( lato destro esterno) o CW ( lato destro interno) if ( cCell.m_nFlag == 2) { bool bAllContained = true ; bool bContained = false ; @@ -3893,9 +3894,9 @@ Tree::SetRightEdgeIn( int nId) if ( cCell.m_vInters[k].nIn != -1) { // trovo il loop che ha l'ingresso o l'uscita più a destra if ( CheckIfBefore( cCell.m_vInters[k].nIn, cCell.m_vInters[k].vpt[0], nEdgeUp, ptUp) || - CheckIfBefore( cCell.m_vInters[k].nOut, cCell.m_vInters[k].vpt.back(), nEdgeUp, ptUp) || - CheckIfBefore( nEdgeDown, ptDown, cCell.m_vInters[k].nIn, cCell.m_vInters[k].vpt[0]) || - CheckIfBefore( nEdgeDown, ptDown, cCell.m_vInters[k].nOut, cCell.m_vInters[k].vpt.back())) { + CheckIfBefore( cCell.m_vInters[k].nOut, cCell.m_vInters[k].vpt.back(), nEdgeUp, ptUp) || + CheckIfBefore( nEdgeDown, ptDown, cCell.m_vInters[k].nIn, cCell.m_vInters[k].vpt[0]) || + CheckIfBefore( nEdgeDown, ptDown, cCell.m_vInters[k].nOut, cCell.m_vInters[k].vpt.back())) { nLoop = k ; if ( CheckIfBefore( cCell.m_vInters[k])) { ptUp = cCell.m_vInters[k].vpt[0] ; @@ -3996,14 +3997,14 @@ Tree::CategorizeCell( int nId) Point3d ptIntersOut = m_mTree[nNeigh].m_vInters[r].vpt.back() ; Point3d ptIntersIn = m_mTree[nNeigh].m_vInters[r].vpt[0] ; if ( (m_mTree[nNeigh].m_vInters[r].nOut == 0 || m_mTree[nNeigh].m_vInters[r].nOut == 7) && - ( CheckIfBefore( 2, ptBr, ptIntersOut) || AreSamePointApprox( ptBr, ptIntersOut))) { + ( CheckIfBefore( 2, ptBr, ptIntersOut) || AreSamePointApprox( ptBr, ptIntersOut))) { if (ptIntersOut.x < ptLeftMostInters.x) { ptLeftMostInters = ptIntersOut ; bFound = true ; } } if ( (m_mTree[nNeigh].m_vInters[r].nIn == 0 || m_mTree[nNeigh].m_vInters[r].nIn == 7) && - ( CheckIfBefore( 2, ptBr, ptIntersIn) || AreSamePointApprox( ptBr, ptIntersIn))) { + ( CheckIfBefore( 2, ptBr, ptIntersIn) || AreSamePointApprox( ptBr, ptIntersIn))) { if (ptIntersIn.x < ptLeftMostInters.x) { ptLeftMostInters = ptIntersIn ; bFound = false ; @@ -4050,7 +4051,7 @@ Tree::CategorizeCell( int nId) } } } - // se non ho vicini bottom devo per forza guardare il vicino a sinistra + // se non ho vicini bottom devo per forza guardare il vicino a sinistra else { Point3d ptInters = m_mTree[vNeigh[0]].GetTopRight() ; int nEdge = 3 ; @@ -4214,7 +4215,7 @@ Tree::GetLeaves( vector& vLeaves) const Cell cToAdd = m_mTree.at( k) ; vLeaves.push_back( cToAdd) ; } - + return true ; } @@ -4270,7 +4271,7 @@ Tree::GetEdges3D( vector& mCCEdges, POLYLINEVECTOR& vPolygons GetRootNeigh( 2, vEdges[2]) ; vEdges.emplace_back() ; GetRootNeigh( 3, vEdges[3]) ; - + // scorro sui gruppi di polyline che rappresentano i poligoni delle celle lungo un lato for ( int i = 0 ; i < int( vEdges.size()) ; ++i) { mCCEdges.emplace_back() ;