diff --git a/SurfBezier.cpp b/SurfBezier.cpp index 7b6cd02..138a4d8 100644 --- a/SurfBezier.cpp +++ b/SurfBezier.cpp @@ -46,7 +46,9 @@ #define SAVEFAILEDTRIANGULATION 0 #define SAVEISO 0 -#if SAVEFAILEDTRIANGULATION || SAVEISO +#define SAVERULEDISO 1 +#define SAVERULEDGUIDEDISO 1 +#if SAVEFAILEDTRIANGULATION || SAVEISO || SAVERULEDISO || SAVERULEDGUIDEDISO #include "/EgtDev/Include/EGkGeoObjSave.h" #endif @@ -5058,8 +5060,8 @@ SurfBezier::CreateByTwoCurves( const ICurve* pCurve0, const ICurve* pCurve1, int bool bAdvance0 = dParam0 < j + 1 + EPS_SMALL ; bool bAdvance1 = dParam1 < c + 1 + EPS_SMALL ; // controllo se ho un match biunivoco - bool bPerfectMatch = dParam0 - int( dParam0) < EPS_SMALL && int( dParam0) == j + 1 && - dParam1 - int( dParam1) < EPS_SMALL && int( dParam1) == c + 1 ; + bool bPerfectMatch = abs( dParam0 - round( dParam0)) < EPS_SMALL && round( dParam0) == j + 1 && + abs( dParam1 - round( dParam1)) < EPS_SMALL && round( dParam1) == c + 1 ; int nSplit1 = vdSplit1.size() ; int nSplit0 = vdSplit0.size() ; // se con una polyline sono arrivato alla fine non posso più avanzare @@ -5068,7 +5070,14 @@ SurfBezier::CreateByTwoCurves( const ICurve* pCurve0, const ICurve* pCurve1, int if ( j == vMatch1.size()) bAdvance1 = false ; // se trovo che ho uno spigolo allora procedo con la gestione spigoli - if ( vEdgeSplit0[c+1] || vEdgeSplit1[j+1]) { + if( vEdgeSplit0[c+1] && vEdgeSplit1[j+1]) { + // se ho uno spigolo su entrambe le curve forzo l'accoppiamento + bAdvance0 = true ; + bPerfectMatch = true ; + dParam0 = round( dParam0) ; + dParam1 = round( dParam1) ; + } + else if ( (vEdgeSplit0[c+1] && ! bAdvance1) || (vEdgeSplit1[j+1] && ! bAdvance0)) { bAdvance0 = false ; bAdvance1 = false ; } @@ -5152,7 +5161,7 @@ SurfBezier::CreateByTwoCurves( const ICurve* pCurve0, const ICurve* pCurve1, int bool bEdgeFoundOnSecond = false ; if ( vEdgeSplit0[c+1] && vEdgeSplit1[j+1]) { // questo caso non è previsto !!!!! e non mi aspetto che avvenga - LOG_DBG_ERR( GetEGkLogger(), "RLT_B_MINDIST_PLUS: a not handled mismatch was found") ; + LOG_DBG_ERR( GetEGkLogger(), "RLT_B_MINDIST_PLUS: a not handled mismatch was found, type 0") ; } if ( vEdgeSplit0[c+1]) { ++c ; @@ -5177,6 +5186,9 @@ SurfBezier::CreateByTwoCurves( const ICurve* pCurve0, const ICurve* pCurve1, int dLastParamMatch0 = j - 1 ; ptLastPointMatch0 = vPnt1[j] ; } + else { + LOG_DBG_ERR( GetEGkLogger(), "RLT_B_MINDIST_PLUS: a not handled mismatch was found, type 1") ; + } } else if ( vEdgeSplit1[j+1]) { ++c ; @@ -5201,10 +5213,12 @@ SurfBezier::CreateByTwoCurves( const ICurve* pCurve0, const ICurve* pCurve1, int dLastParamMatch1 = c - 1 ; ptLastPointMatch1 = vPnt0[c] ; } + else { + LOG_DBG_ERR( GetEGkLogger(), "RLT_B_MINDIST_PLUS: a not handled mismatch was found, type 2") ; + } } else { - // potrei avere un mismatch, senza però avere degli spigoli.. - // gestisco comunque con un'accoppiamento + /////////OLD VRESION ++c ; ++j ; vPairs.emplace_back( c + nSplit0, j + nSplit1) ; @@ -5212,12 +5226,187 @@ SurfBezier::CreateByTwoCurves( const ICurve* pCurve0, const ICurve* pCurve1, int ptLastPointMatch1 = vPnt0[c] ; dLastParamMatch0 = j ; ptLastPointMatch0 = vPnt1[j] ; + + + + ////// potrei avere un mismatch, senza però avere degli spigoli.. + + // // identifico la zona in cui ho il mismatch e parametrizzo localmente + + // //conto quanti punti ho nel mezzo + // int c_temp = c, j_temp = j ; + // bAdvance0 = true ; + // bAdvance1 = true ; + // int nParam0, nParam1 ; + // while( bAdvance0) { + // dParam0 = vMatch0[c_temp].second ; + // nParam0 = int( round( dParam0)) ; + // dParam1 = vMatch1[nParam0].second ; + // nParam1 = int( round( dParam1)) ; + // if( abs( nParam1 - c_temp) <= 2) + // bAdvance0 = false ; + // else + // ++ c_temp ; + // } + // while( bAdvance1) { + // dParam1 = vMatch1[j_temp].second ; + // nParam1 = int( round( dParam1)) ; + // dParam0 = vMatch0[nParam1].second ; + // nParam0 = int( round( dParam0)) ; + // if( abs( nParam0 - j_temp) <= 2) + // bAdvance1 = false ; + // else + // ++ j_temp ; + // } + // // se non sono avanzato, allora mi basta accoppiare i due punti in questione + // if( c_temp == c || j_temp == j) { + // ++c ; + // ++j ; + // vPairs.emplace_back( c + nSplit0, j + nSplit1) ; + // dLastParamMatch1 = c ; + // ptLastPointMatch1 = vPnt0[c] ; + // dLastParamMatch0 = j ; + // ptLastPointMatch0 = vPnt1[j] ; + // } + // // se sono dovuto avanzare per trovare delle coppie che tornano a matchare allora ho effettivamente trovato una zona di mismatch + // else { + // // determino quale delle due coppie è il confine effettivo con la zona di mismatch e quale sarà la prima dopo il mismamtch + // dParam0 = vMatch0[c_temp].second ; + // dParam1 = vMatch1[j_temp].second ; + // bool bIntParam0 = false ; + // bool bIntParam1 = false ; + // if ( abs( dParam0 - round( dParam0)) < EPS_SMALL) { + // dParam0 = round( dParam0) ; + // bIntParam0 = true ; + // } + // if ( abs( dParam1 - round( dParam1)) < EPS_SMALL) { + // dParam1 = round( dParam1) ; + // bIntParam1 = true ; + // } + // bAdvance0 = dParam0 < j_temp + 1 + EPS_SMALL ; + // bAdvance1 = dParam1 < c_temp + 1 + EPS_SMALL ; + // PtrOwner pCC0 ; + // PtrOwner pCC1 ; + // int nPointsBetween0 = 0 ; + // int nPointsBetween1 = 0 ; + // if( bAdvance0 && bAdvance1) { + // pCC0.Set( CrvU0.CopyParamRange( dLastParamMatch1, c_temp + 1)) ; + // pCC1.Set( CrvU1.CopyParamRange( dLastParamMatch0, j_temp + 1)) ; + // nPointsBetween0 = c_temp - c ; + // nPointsBetween1 = j_temp - j ; + // } + // else if( bAdvance0){ + // pCC0.Set( CrvU0.CopyParamRange( dLastParamMatch1, c_temp + 1)) ; + // pCC1.Set( CrvU1.CopyParamRange( dLastParamMatch0, dParam0)) ; + // nPointsBetween0 = c_temp - c ; + // nPointsBetween1 = int( dParam0) - ( j + 1) ; + // if ( bIntParam0) + // nPointsBetween1 -= 1 ; + // } + // else if( bAdvance1){ + // pCC0.Set( CrvU0.CopyParamRange( dLastParamMatch1, dParam1)) ; + // pCC1.Set( CrvU1.CopyParamRange( dLastParamMatch0, j_temp + 1)) ; + // nPointsBetween0 = int( dParam1) - ( c + 1) ; + // nPointsBetween1 = j_temp - j ; + // if ( bIntParam1) + // nPointsBetween0 -= 1 ; + // } + // + // double dLen0 ; pCC0->GetLength( dLen0) ; + // double dLen1 ; pCC1->GetLength( dLen1) ; + // DBLVECTOR vdParamPos0 ; vdParamPos0.reserve( nPointsBetween0) ; + // DBLVECTOR vdParamPos1 ; vdParamPos1.reserve( nPointsBetween1) ; + // for ( int k = 0 ; k <= nPointsBetween0 ; ++k) { + // double dLen = 0 ; pCC0->GetLengthAtParam( k, dLen) ; + // vdParamPos0.push_back( dLen / dLen0) ; + // } + // vdParamPos0.push_back( 1) ; + // for ( int k = 0 ; k <= nPointsBetween1 ; ++k) { + // double dLen = 0 ; pCC1->GetLengthAtParam( k, dLen) ; + // vdParamPos1.push_back( dLen / dLen1) ; + // } + // vdParamPos1.push_back( 1) ; + + // bool bSplitToAdd = true ; + // int c0 = 1, c1 = 1 ; + // //debug + // int nCBerfore = c ; + // int nJBefore = j ; + // //debug + // while ( bSplitToAdd) { + // if ( c0 > ssize( vdParamPos0) - 1 && c1 > ssize( vdParamPos1) - 1) { + // LOG_DBG_ERR( GetEGkLogger(), "Surf Bez Ruled Guided: error 1 while reparametrizing some section") ; + // return false ; + // } + // // se ho una corrispondenza tra punti ( e non sono alla fine del tratto) allora non aggiungo split + // if ( abs( vdParamPos0[c0] - vdParamPos1[c1]) < EPS_PARAM && vdParamPos0[c0] < 1) { + // ++c0 ; + // ++c1 ; + // ++c ; + // ++j ; + // vPairs.emplace_back( c + nSplit0, j + nSplit1) ; + // } + // // se non ho corrispondenza allora aggiungo uno split sulla curva a cui manca il punto corrispondente + // else if ( vdParamPos0[c0] < vdParamPos1[c1]) { + // double dPar ; CrvU1.GetParamAtLength( dLen1 * vdParamPos0[c0], dPar) ; + // if ( abs( dPar - round( dPar)) > EPS_SMALL) { + // vdSplit1.push_back( dPar + dLastParamMatch0) ; + // nSplit1 = vdSplit1.size() ; + // } + // else if ( dPar = round( dPar) ; dPar > j){ + // ++ j ; + // } + // ++c ; + // vPairs.emplace_back( c + nSplit0, j + nSplit1) ; + // ++c0 ; + // } + // else if ( vdParamPos0[c0] > vdParamPos1[c1]) { + // double dPar ; CrvU0.GetParamAtLength( dLen0 * vdParamPos1[c1], dPar) ; + // // se lo split non è in prossimità di una joint già esistente allora lo aggiungo + // if ( abs( dPar - round( dPar)) > EPS_SMALL) { + // vdSplit0.push_back( dPar + dLastParamMatch1) ; + // nSplit0 = vdSplit0.size() ; + // } + // else if ( dPar = round( dPar) ; dPar > c){ + // ++ c ; + // } + // ++j ; + // vPairs.emplace_back( c + nSplit0, j + nSplit1) ; + // ++c1 ; + // } + // else { + // LOG_DBG_ERR( GetEGkLogger(), "Surf Bez Ruled Guided: error 2 while reparametrizing some section") ; + // return false ; + // } + // bSplitToAdd = ! ( c0 == ssize( vdParamPos0) - 1 && c1 == ssize( vdParamPos1) - 1) ; + // } + // // aggiorno i dati dell'ultima aggiunta + // if( bAdvance0 && ! bAdvance1) { + // ptLastPointMatch0 = vMatch0[c_temp].first ; + // dLastParamMatch0 = vMatch0[c_temp].second ; + // ptLastPointMatch1 = vPnt0[c_temp] ; + // dLastParamMatch0 = c_temp ; + // } + // else if( ! bAdvance0 && bAdvance1) { + // ptLastPointMatch0 = vPnt1[j_temp] ; + // dLastParamMatch0 = j_temp ; + // ptLastPointMatch1 = vMatch1[j_temp].first ; + // dLastParamMatch0 = vMatch1[j_temp].second ; + // } + // else { + // ptLastPointMatch0 = vPnt1[j_temp] ; + // dLastParamMatch0 = j_temp ; + // ptLastPointMatch1 = vPnt0[c_temp] ; + // dLastParamMatch0 = c_temp ; + // } + // vPairs.emplace_back( c + nSplit0, j + nSplit1) ; + // } } } bAdvance = ! (c >= int(vMatch0.size()) - 1 && j >= int(vMatch1.size()) - 1) ; } - // applico effettivamente gli split e aggiungo gli elementi ai vettori vbRep + // applico effettivamente gli split int nUnit = 0 ; if ( ! vdSplit1.empty()) nUnit = int( vdSplit1.back()) ; @@ -5304,6 +5493,28 @@ SurfBezier::CreateByTwoCurves( const ICurve* pCurve0, const ICurve* pCurve1, int ++ nAddedSpan ; } +#if SAVERULEDISO + //debug + vector vGeo ; + ICURVEPOVECTOR vCrv ; + GetAllPatchesIsocurves( false, vCrv) ; + for( int i = 0 ; i < ssize( vCrv) ; ++i) { + vGeo.push_back( vCrv[i]->Clone()) ; + } + vector vCol( ssize( vCrv)) ; + fill( vCol.begin(), vCol.end(), Color( 255,0,128)) ; + SaveGeoObj( vGeo, vCol, "D:/Temp/bezier/ruled/isoCurves.nge") ; + //debug + + vGeo.clear() ; + vGeo.push_back( CrvU0.Clone()) ; + vGeo.push_back( CrvU1.Clone()) ; + vCol.clear() ; + vCol.push_back(Color(0,64,128)) ; + vCol.push_back(Color(128,64,0)) ; + SaveGeoObj( vGeo, vCol, "D:/Temp/bezier/ruled/NewCurves.nge") ; +#endif + return bOk ; } else if ( RLT_B_LENPAR ) { @@ -5672,6 +5883,8 @@ SurfBezier::CreateByIsoParamSet( const ICurve* pCurve0, const ICurve* pCurve1, c //controllo che siano entrambe chiuse o entrambe aperte if( pCurve0->IsClosed() ^ pCurve1->IsClosed()) return false ; + + bool bClosed = pCurve0->IsClosed() ; // converto in bezier la curva iniziale CurveComposite CrvU0 ; CrvU0.AddCurve( CurveToBezierCurve(pCurve0)) ; @@ -5709,12 +5922,26 @@ SurfBezier::CreateByIsoParamSet( const ICurve* pCurve0, const ICurve* pCurve1, c double dLenPrev0 = 0 ,dLenPrev1 = 0 ; // costruisco il vettore delle nuove curve isoparamtriche per la nuova superficie + bool bFirstAdded = false ; + int nSpanU0 = CrvU0.GetCurveCount() ; + int nSpanU1 = CrvU1.GetCurveCount() ; ISOPARVECT vIso ; for ( int i = 0 ; i < ssize( vCrv) ; ++i) { Point3d ptU0 = vCrv[i].first ; Point3d ptU1 = vCrv[i].second ; double dParam0 ; CrvU0.GetParamAtPoint( ptU0, dParam0) ; double dParam1 ; CrvU1.GetParamAtPoint( ptU1, dParam1) ; + if( bClosed && (dParam0 < EPS_SMALL || nSpanU0 - dParam0 < EPS_SMALL) && (dParam1 < EPS_SMALL || nSpanU1 - dParam1 < EPS_SMALL)) { + if( ! bFirstAdded) { + dParam0 = 0 ; + dParam1 = 0 ; + bFirstAdded = true ; + } + else { + dParam0 = nSpanU0 ; + dParam1 = nSpanU1 ; + } + } vIso.emplace_back( i, dParam0, dParam1) ; } @@ -5735,7 +5962,7 @@ SurfBezier::CreateByIsoParamSet( const ICurve* pCurve0, const ICurve* pCurve1, c dLastParam0 = 0 ; dLastParam1 = 0 ; - if( vIso[0].dParam0 > 0 || vIso[0].dParam1 > 1) + if( vIso[0].dParam0 > 0 || vIso[0].dParam1 > 0) vPairs.emplace_back( 0, 0) ; for ( int i = 0 ; i < ssize( vIso) ; ++i) { const BIPOINT& pCrv = vCrv[vIso[i].nCrv] ; @@ -5893,8 +6120,8 @@ SurfBezier::CreateByIsoParamSet( const ICurve* pCurve0, const ICurve* pCurve1, c CrvU0.AddJoint( dSplit) ; } - int nSpanU0 = CrvU0.GetCurveCount() ; - int nSpanU1 = CrvU1.GetCurveCount() ; + nSpanU0 = CrvU0.GetCurveCount() ; + nSpanU1 = CrvU1.GetCurveCount() ; // aggiungo l'ultima coppia vPairs.emplace_back( nSpanU0, nSpanU1) ; @@ -5951,6 +6178,28 @@ SurfBezier::CreateByIsoParamSet( const ICurve* pCurve0, const ICurve* pCurve1, c ++ nAddedSpan ; } + #if SAVERULEDGUIDEDISO + //debug + vector vGeo ; + ICURVEPOVECTOR vCrvIso ; + GetAllPatchesIsocurves( false, vCrvIso) ; + for( int i = 0 ; i < ssize( vCrvIso) ; ++i) { + vGeo.push_back( vCrvIso[i]->Clone()) ; + } + vector vCol( ssize( vCrvIso)) ; + fill( vCol.begin(), vCol.end(), Color( 255,0,128)) ; + SaveGeoObj( vGeo, vCol, "D:/Temp/bezier/ruled/isoCurves.nge") ; + //debug + + vGeo.clear() ; + vGeo.push_back( CrvU0.Clone()) ; + vGeo.push_back( CrvU1.Clone()) ; + vCol.clear() ; + vCol.push_back(Color(0,64,128)) ; + vCol.push_back(Color(128,64,0)) ; + SaveGeoObj( vGeo, vCol, "D:/Temp/bezier/ruled/NewCurves.nge") ; +#endif + return true ; }