From 1ad96ce8ca0aa3f23c5a6fa94acea9516211d7e8 Mon Sep 17 00:00:00 2001 From: Daniele Bariletti Date: Mon, 15 Dec 2025 15:08:53 +0100 Subject: [PATCH] EgtGeomKernel : - tentativo di miglioramento delle ruled nei punti di mismatch. --- SurfBezier.cpp | 258 ++++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 244 insertions(+), 14 deletions(-) diff --git a/SurfBezier.cpp b/SurfBezier.cpp index 6dbbe3f..e0ce050 100644 --- a/SurfBezier.cpp +++ b/SurfBezier.cpp @@ -44,6 +44,13 @@ #define EIGEN_NO_IO #include "/EgtDev/Extern/Eigen/Dense" +#define DEBUG + + +#ifdef DEBUG +#include "/EgtDev/Include/EGkGeoObjSave.h" +#endif + using namespace std ; //---------------------------------------------------------------------------- @@ -5034,8 +5041,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 @@ -5044,7 +5051,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 ; } @@ -5128,7 +5142,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 ; @@ -5153,6 +5167,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 ; @@ -5177,23 +5194,200 @@ 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 - ++c ; - ++j ; - vPairs.emplace_back( c + nSplit0, j + nSplit1) ; - dLastParamMatch1 = c ; - ptLastPointMatch1 = vPnt0[c] ; - dLastParamMatch0 = j ; - ptLastPointMatch0 = vPnt1[j] ; + ///////////OLD VRESION + //++c ; + //++j ; + //vPairs.emplace_back( c + nSplit0, j + nSplit1) ; + //dLastParamMatch1 = c ; + //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()) ; @@ -5280,6 +5474,28 @@ SurfBezier::CreateByTwoCurves( const ICurve* pCurve0, const ICurve* pCurve1, int ++ nAddedSpan ; } +#ifdef DEBUG + //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 ) { @@ -5901,5 +6117,19 @@ SurfBezier::CreateByIsoParamSet( const ICurve* pCurve0, const ICurve* pCurve1, c ++ nAddedSpan ; } + #ifdef DEBUG + //debug + vector vGeo ; + ICURVEPOVECTOR vCrv2 ; + GetAllPatchesIsocurves( false, vCrv2) ; + for( int i = 0 ; i < ssize( vCrv2) ; ++i) { + vGeo.push_back( vCrv2[i]->Clone()) ; + } + vector vCol( ssize( vCrv2)) ; + fill( vCol.begin(), vCol.end(), Color( 255,0,128)) ; + SaveGeoObj( vGeo, vCol, "D:/Temp/bezier/ruled/isoCurves.nge") ; + //debug + #endif + return true ; } \ No newline at end of file