From 7c85ea2d43092ebb01a22e80f5de8ef026e431f6 Mon Sep 17 00:00:00 2001 From: Riccardo Elitropi Date: Tue, 9 Jun 2026 15:22:55 +0200 Subject: [PATCH] EgtGeomKernel : - in CalcPocketing modifiche stilistiche. --- CalcPocketing.cpp | 191 ++++++++++++++++++++++------------------------ 1 file changed, 90 insertions(+), 101 deletions(-) diff --git a/CalcPocketing.cpp b/CalcPocketing.cpp index 3db077d..1605ea7 100644 --- a/CalcPocketing.cpp +++ b/CalcPocketing.cpp @@ -1290,24 +1290,22 @@ CreateSurfFrIncidence( const ICurveComposite* pCrv, const PocketParams& PockPara //---------------------------------------------------------------------------- static bool -AdjustOpenEdge( const ICurveComposite* pCrvCompo, const ICRVCOMPOPOVECTOR& vCrvIsland, - const double dParS, const double dParE, const Vector3d& vtTanS, - const Vector3d& vtTanE, const double dRad, const double dDiamJ, - const PocketParams& PockParams, ICurveComposite* pCrvBorder) +AdjustOpenEdge( const ICurveComposite* pCrvCompo, const ICRVCOMPOPOVECTOR& vCrvIsland, const double dParS, const double dParE, + const Vector3d& vtTanS, const Vector3d& vtTanE, const double dRad, const double dDiamJ, const PocketParams& PockParams, + ICurveComposite* pCrvBorder) { - /* parametri : + /* --- Parametri : pCrvCompo -> curva originaria di bordo - vCrvIsland -> vettore delle isole all'interno di pCrvCompo + vCrvIsland -> vettore delle isole chiuse all'interno di pCrvCompo dParS -> parametro sulla pCrvCompo per l'inizio del tratto aperto dParE -> parametro sulla pCrvCompo per la fine del tratto aperto - vtTanS -> vettore di tangenza finale tratto chiuso precedente - vtTanE -> vettore di tangenza iniziale ( invertito ) del tratto chiuso successivo + vtTanS -> vettore di tangenza iniziale tratto chiuso precedente + vtTanE -> vettore di tangenza finale (invertito) del tratto chiuso successivo dRad -> raggio di Offset per la regione di incidenza - dDiamJ -> ampiezza delle curve a fagiolo per estendere la regione di incidenza - pCrvRes -> curva da restituire ( inizialmente è il tratto aperto sulla pCrvCompo ; - questa curva sarà l'estensione del lato aperto, adattandosi alla geometria - dei chiusi ( non posso vedere solo i chiusi adiacenti all'aperto, devo considerare TUTTI i chiusi - della pCrvCompo + dDiamJ -> ampiezza delle curve "a fagiolo" per estendere la regione di incidenza + pCrvRes -> curva da restituire (inizialmente è il tratto aperto sulla pCrvCompo). Questa curva sarà l'estensione del lato aperto, + adattandosi alla geometria dei chiusi (non posso vedere solo i chiusi adiacenti all'aperto, devo considerare TUTTI i chiusi + della pCrvCompo e delle isole al suo interno) */ // controllo la validità dei parametri @@ -1315,28 +1313,28 @@ AdjustOpenEdge( const ICurveComposite* pCrvCompo, const ICRVCOMPOPOVECTOR& vCrvI pCrvBorder == nullptr || ! pCrvBorder->IsValid() || pCrvBorder->GetCurveCount() == 0) return false ; - // definisco la regione di incidenza ( leggermente più grande ) + // definisco la regione di incidenza (leggermente più grande) PtrOwner pSfrInc( CreateSurfFlatRegion()) ; if ( IsNull( pSfrInc)) return false ; if ( ! CreateSurfFrIncidence( pCrvBorder, PockParams, dRad + 75. * EPS_SMALL, pSfrInc)) { - pSfrInc.Set( GetSurfFlatRegionFromFatCurve( CloneCurveComposite( pCrvBorder), dRad + 75 * EPS_SMALL, false, false)) ; + pSfrInc.Set( GetSurfFlatRegionFromFatCurve( CloneCurveComposite( pCrvBorder), dRad + 75. * EPS_SMALL, false, false)) ; if ( IsNull( pSfrInc) || ! pSfrInc->IsValid()) return false ; } // creo un vettore con tutte le curve che potrebbero cadere, in parte, nella regione di incidenza ICRVCOMPOPOVECTOR vCrvToCheck ; - for ( int i = 0 ; i < int( vCrvIsland.size()) ; ++ i) - vCrvToCheck.emplace_back( vCrvIsland[i]->Clone()) ; // aggiungo le isole + for ( int i = 0 ; i < ssize( vCrvIsland) ; ++ i) + vCrvToCheck.emplace_back( CloneCurveComposite( vCrvIsland[i])) ; // se la curva originale non è tutta Aperta -> devo aggiungere anche essa nelle curve da controllare - bool bIsAllOpen = abs( abs( dParE - dParS) - pCrvCompo->GetCurveCount()) < EPS_SMALL ; + bool bIsAllOpen = ( abs( abs( dParE - dParS) - pCrvCompo->GetCurveCount()) < EPS_SMALL) ; if ( ! bIsAllOpen) { // recupero il tratto di curva prima e dopo dell'aperto corrente PtrOwner pCompoOther( ConvertCurveToComposite( pCrvCompo->CopyParamRange( dParE, dParS))) ; if ( IsNull( pCompoOther) || ! pCompoOther->IsValid()) return false ; - vCrvToCheck.emplace_back( Release( pCompoOther)) ; // aggiungo il bordo + vCrvToCheck.emplace_back( Release( pCompoOther)) ; } // controllo se la curva è un'isola ( normale del piano -Z_AX) @@ -1346,28 +1344,28 @@ AdjustOpenEdge( const ICurveComposite* pCrvCompo, const ICRVCOMPOPOVECTOR& vCrvI return false ; bIsIsland = AreSameVectorEpsilon( plCheck.GetVersN(), - Z_AX, 10. * EPS_SMALL) ; - // scorro il vettore creato... - for ( int i = 0 ; i < int( vCrvToCheck.size()) ; ++ i) { - // 1) recupero la curva corrente - PtrOwner pCrvCurr( vCrvToCheck[i]->Clone()) ; + // scorro il vettore di curve chiuse da verificare + for ( int i = 0 ; i < ssize( vCrvToCheck) ; ++ i) { + // recupero la curva corrente + PtrOwner pCrvCurr( CloneCurveComposite( vCrvToCheck[i])) ; if ( IsNull( pCrvCurr) || ! pCrvCurr->IsValid()) return false ; - // 2) ricavo i tratti con proprietà uniformi ( Aperti/Chiusi ) + // ricavo i tratti con proprietà uniformi (Aperti/Chiusi) ICRVCOMPOPOVECTOR vpCrvs ; if ( ! GetHomogeneousParts( pCrvCurr, PockParams, vpCrvs)) return false ; - // 3) considero solo i tratti chiusi - for ( int nU = 0 ; nU < int( vpCrvs.size()) ; ++ nU) { + // considero solo i tratti chiusi + for ( int nU = 0 ; nU < ssize( vpCrvs) ; ++ nU) { if ( vpCrvs[nU]->GetTempProp() == TEMP_PROP_OPEN_EDGE) continue ; - // 4) effettuo l'Offset della curva di metà dDiamJ + // effettuo l'Offset della curva di metà dDiamJ OffsetCurve OffsCrv ; if ( ! OffsCrv.Make( vpCrvs[nU], - dDiamJ / 2. - 20. * EPS_SMALL, PockParams.nOffsType)) return false ; - // 5) scorro tutte le curve di Offset che si sono formate, prendendo sempre la più lunga tra le rimanenti + // scorro tutte le curve di Offset che si sono formate, prendendo sempre la più lunga tra le rimanenti PtrOwner pOffLongestCrv( OffsCrv.GetLongerCurve()) ; while ( ! IsNull( pOffLongestCrv)) { - // 6) creo la regione di incidenza di tale curva ( "Curva a fagiolo") + // creo la regione di incidenza di tale curva ("Curva a fagiolo") bool bSquareEnds = ( PockParams.nOffsType == ICurve::OFF_CHAMFER) ; bool bSquareMids = ( PockParams.nOffsType == ICurve::OFF_CHAMFER) ; PtrOwner pSfrBean( GetSurfFlatRegionFromFatCurve( Release( pOffLongestCrv), dDiamJ / 2., bSquareEnds, bSquareMids)) ; @@ -1376,7 +1374,7 @@ AdjustOpenEdge( const ICurveComposite* pCrvCompo, const ICRVCOMPOPOVECTOR& vCrvI // inverto se necessario if ( AreOppositeVectorApprox( pSfrBean->GetNormVersor(), pSfrInc->GetNormVersor())) pSfrBean->Invert() ; - // 7) se la "Regione a fagiolo" non influenza la regione di incidenza, la transcuro + // se la "Regione a fagiolo" non influenza la regione di incidenza, la transcuro bool bDiscard = false ; if ( ! bIsIsland) { // se tratto un loop esterno @@ -1384,21 +1382,19 @@ AdjustOpenEdge( const ICurveComposite* pCrvCompo, const ICRVCOMPOPOVECTOR& vCrvI if ( IsNull( pSfrBean_test) || ! pSfrBean_test->IsValid()) return false ; pSfrBean_test->Intersect( *pSfrInc) ; - bDiscard = ( IsNull( pSfrBean_test) || - ! pSfrBean_test->IsValid() || - pSfrBean_test->GetChunkCount() == 0) ; + bDiscard = ( IsNull( pSfrBean_test) || ! pSfrBean_test->IsValid() || pSfrBean_test->GetChunkCount() == 0) ; } else if ( bIsAllOpen && bIsIsland) { // se isola aperta - for ( int cI = 0 ; cI < pSfrInc->GetChunkCount() && ! bDiscard ; ++ cI) { - for ( int cB = 0 ; cB < pSfrBean->GetChunkCount() && ! bDiscard ; ++ cB) { - if ( pSfrInc->GetChunkSimpleClassification( cI, *pSfrBean, cB) == REGC_IN1) { - for ( int l = 1 ; l < pSfrBean->GetLoopCount( cB) ; ++ l) { + for ( int nC = 0 ; nC < pSfrInc->GetChunkCount() && ! bDiscard ; ++ nC) { + for ( int nB = 0 ; nB < pSfrBean->GetChunkCount() && ! bDiscard ; ++ nB) { + if ( pSfrInc->GetChunkSimpleClassification( nC, *pSfrBean, nB) == REGC_IN1) { + for ( int nL = 1 ; nL < pSfrBean->GetLoopCount( nB) ; ++ nL) { PtrOwner pSfrTmp( CreateSurfFlatRegion()) ; - if ( IsNull( pSfrTmp) || ! pSfrTmp->AddExtLoop( pSfrBean->GetLoop( cB, l)) || + if ( IsNull( pSfrTmp) || ! pSfrTmp->AddExtLoop( pSfrBean->GetLoop( nB, nL)) || ! pSfrTmp->Invert()) return false ; - bDiscard = ( pSfrInc->GetChunkSimpleClassification( cI, *pSfrTmp, 0) == REGC_IN1) ; + bDiscard = ( pSfrInc->GetChunkSimpleClassification( nC, *pSfrTmp, 0) == REGC_IN1) ; } } } @@ -1500,9 +1496,9 @@ AdjustOpenEdge( const ICurveComposite* pCrvCompo, const ICRVCOMPOPOVECTOR& vCrvI // pulisco la curva originale pCrvBorder->Clear() ; if ( bIsIsland) { // se isola inserisco il loop interno corretto della regione - for ( int l = 1 ; l < pSfrInc->GetLoopCount( 0) ; ++ l) { + for ( int nL = 1 ; nL < pSfrInc->GetLoopCount( 0) ; ++ nL) { // recupero il Loop - PtrOwner pCrvIntLoop( ConvertCurveToComposite( pSfrInc->GetLoop( 0, l))) ; + PtrOwner pCrvIntLoop( ConvertCurveToComposite( pSfrInc->GetLoop( 0, nL))) ; if ( IsNull( pCrvIntLoop) || ! pCrvIntLoop->IsValid()) return false ; // controllo che sia interno alla curva di bordo corrente ( l'isola aperta) @@ -1516,8 +1512,8 @@ AdjustOpenEdge( const ICurveComposite* pCrvCompo, const ICRVCOMPOPOVECTOR& vCrvI if ( IsNull( pCrvNewBorder) || ! pCrvNewBorder->IsValid()) return false ; // imposto la curva come tutta aperta ( gira come girava già l'isola) - for ( int u = 0 ; u < pCrvNewBorder->GetCurveCount() ; ++ u) - pCrvNewBorder->SetCurveTempProp( u, TEMP_PROP_OPEN_EDGE, 0) ; + for ( int nU = 0 ; nU < pCrvNewBorder->GetCurveCount() ; ++ nU) + pCrvNewBorder->SetCurveTempProp( nU, TEMP_PROP_OPEN_EDGE, 0) ; break ; } } @@ -1556,7 +1552,7 @@ AdjustOpenEdge( const ICurveComposite* pCrvCompo, const ICRVCOMPOPOVECTOR& vCrvI if ( ! pCrvNewBorder->GetParamAtPoint( ptMinDist, dUTmp)) return false ; if ( dUTmp < EPS_SMALL) - dUTmp = pCrvNewBorder->GetCurveCount() - 5 * EPS_SMALL ; + dUTmp = pCrvNewBorder->GetCurveCount() - 5. * EPS_SMALL ; // copio la curva tra questi due parametri PtrOwner pCrvTmp( ConvertCurveToComposite( pCrvNewBorder->CopyParamRange( 0., dUTmp))) ; if ( IsNull( pCrvTmp) || ! pCrvTmp->IsValid()) @@ -1583,7 +1579,7 @@ AdjustContourWithOpenEdges( ICurveComposite* pCrvCompo, ICRVCOMPOPOVECTOR& vCrvI return false ; // recupero i parametri di lavorazione correnti - double dDiam = PockParams.dRad * 2 ; + double dDiam = 2. * PockParams.dRad ; double dOffR = PockParams.dRadialOffset ; double dStep = PockParams.dSideStep ; @@ -1610,71 +1606,66 @@ AdjustContourWithOpenEdges( ICurveComposite* pCrvCompo, ICRVCOMPOPOVECTOR& vCrvI // salvo il raggio trovato PockParams.dOpenEdgeRad = dRad ; - // ricavo i tratti omogenei + // ricavo i tratti omogenei. Il primo tratto è la prima metà del tratto aperto più lungo ( se esiste ) ICRVCOMPOPOVECTOR vpCrvs ; if ( ! GetHomogeneousParts( pCrvCompo, PockParams, vpCrvs)) return false ; - // NB. Il primo tratto è la prima metà del tratto aperto più lungo ( se esiste ) // Offset esterno per CurveJ - double dDiamJ = 1.05 * ( dDiam) + 2 * dOffR ; + double dDiamJ = 1.05 * ( dDiam) + 2. * dOffR ; if ( abs( PockParams.dMaxOpenEdgeRad) > 0) - dDiamJ = 100 * EPS_SMALL ; + dDiamJ = 100. * EPS_SMALL ; else if ( PockParams.nType == POCKET_CONFORMAL_ZIGZAG || PockParams.nType == POCKET_CONFORMAL_ONEWAY) dDiamJ = 1.05 * ( PockParams.dRad + dRad) + dOffR ; // NB. 1.05 serve per eccedere leggermente, in modo che il contro-offset della prima curva di svuotatura presenti // dei piccoli archi tra i chiusi e gli aperti ( in modo da svuotare bene lungo il chiuso) // curva finale da restituire - PtrOwner pCrvCompo_final( CreateCurveComposite()) ; - if ( IsNull( pCrvCompo_final)) + PtrOwner pCompoFinal( CreateCurveComposite()) ; + if ( IsNull( pCompoFinal)) return false ; // parametro iniziale del tratto corrente, sulla curva originale double dParS = 0. ; // scorro tutti i tratti omogenei nel vettore - for ( int i = 0 ; i < int( vpCrvs.size()) ; ++ i) { + for ( int i = 0 ; i < ssize( vpCrvs) ; ++ i) { // recupero la proprietà della curva composita int nCurrTmpProp = vpCrvs[i]->GetTempProp() ; // aggiorno i parametri del lato aperto corrente sulla curva originale double dParE = dParS + 1. * vpCrvs[i]->GetCurveCount() ; // se aperta if ( nCurrTmpProp == TEMP_PROP_OPEN_EDGE) { - // controllo che sia almeno lungo quanto il diametro utensile - double dLen = 0. ; - vpCrvs[i]->GetLength( dLen) ; // ricavo la tangenze dei lati chiusi agli estremi di questa curva - Vector3d vtTanS = V_INVALID ; - Vector3d vtTanE = V_INVALID ; + Vector3d vtTanS = V_INVALID ; // tangente finale del chiuso precedente + Vector3d vtTanE = V_INVALID ; // tangente iniziale del chiuso successivo if ( i != 0) { - if ( ! vpCrvs[i-1]->GetEndDir( vtTanS) || // tangente finale del chiuso precedente - ! vpCrvs[( i + 1) % int( vpCrvs.size())]->GetStartDir( vtTanE)) // tangente iniziale del chiuso successivo... + if ( ! vpCrvs[i-1]->GetEndDir( vtTanS) || ! vpCrvs[( i + 1) % int( vpCrvs.size())]->GetStartDir( vtTanE)) return false ; - vtTanE.Invert() ; // invertita + vtTanE.Invert() ; } if ( ! AdjustOpenEdge( pCrvCompo, vCrvIsl, dParS, dParE, vtTanS, vtTanE, dRad, dDiamJ, PockParams, vpCrvs[i])) return false ; } // assegno le proprietà di lato Aperto/Chiuso per la curva corrente - for ( int u = 0 ; u < vpCrvs[i]->GetCurveCount() ; ++ u) - vpCrvs[i]->SetCurveTempProp( u, nCurrTmpProp, TEMP_PROP_CLOSE_EDGE) ; + for ( int nU = 0 ; nU < vpCrvs[i]->GetCurveCount() ; ++ nU) + vpCrvs[i]->SetCurveTempProp( nU, nCurrTmpProp, TEMP_PROP_CLOSE_EDGE) ; // aggiungo la curva ricavata ( se chiusa -> la copio, se aperta -> copio l'estesa) - if ( ! pCrvCompo_final->AddCurve( vpCrvs[i]->Clone())) { + if ( ! pCompoFinal->AddCurve( vpCrvs[i]->Clone())) { // per sicurezza, se gli estremi non coincidono, creo un piccolo raccordo lineare Point3d ptH ; vpCrvs[i]->GetStartPoint( ptH) ; - if ( ! pCrvCompo_final->AddLine( ptH) || - ! pCrvCompo_final->SetCurveTempProp( pCrvCompo_final->GetCurveCount() - 1, 1, 0) || - ! pCrvCompo_final->AddCurve( vpCrvs[i]->Clone())) + if ( ! pCompoFinal->AddLine( ptH) || + ! pCompoFinal->SetCurveTempProp( pCompoFinal->GetCurveCount() - 1, TEMP_PROP_OPEN_EDGE, 0) || + ! pCompoFinal->AddCurve( vpCrvs[i]->Clone())) return false ; } // aggiorno dParS = dParE ; } // non dovrebbe esserci un gap, ma meglio prevenire problemi - pCrvCompo_final->Close() ; + pCompoFinal->Close() ; // sostituisco pCrvCompo->Clear() ; - pCrvCompo->CopyFrom( pCrvCompo_final) ; + pCrvCompo->CopyFrom( pCompoFinal) ; return true ; } @@ -2168,7 +2159,7 @@ ModifySurfByOpenEdges( ISurfFlatRegion* pSfr, PocketParams& PockParams) { // controllo parametri : if ( pSfr == nullptr || ! pSfr->IsValid()) - return true ; // <- se superficie non valida, allora non ho niente da impostare sui suoi lati + return true ; // se lati tutti chiusi, allora non devo fare nulla if ( PockParams.bAllClosed) @@ -2178,18 +2169,18 @@ ModifySurfByOpenEdges( ISurfFlatRegion* pSfr, PocketParams& PockParams) // I lati aperti vanno estesi seguendo lo geometria dei lati chiusi adiacenti e tenendo conto delle isole chiuse // vicine ad essi - // creo la superficie da restituire... ( questa superficie sarà estesa presso i lati aperti) + // creo la superficie da restituire ( questa superficie sarà estesa presso i lati aperti) PtrOwner pSrfFinal( CreateSurfFlatRegion()) ; if ( IsNull( pSrfFinal)) return false ; - // per ogni Chunck della superificie ottenuta... + // per ogni Chunck della superificie ottenuta for ( int nC = 0 ; nC < pSfr->GetChunkCount() ; ++ nC) { // flag per indicare se il Chunk è stato modificato mediante estensione degli aperti bool bIsChunkModified = true ; - // ricavo il Loop esterno ( External Loop) + // ricavo il Loop esterno (External Loop) PtrOwner pCrvEL( ConvertCurveToComposite( pSfr->GetLoop( nC, 0))) ; if ( IsNull( pCrvEL) || ! pCrvEL->IsValid()) return false ; @@ -2203,13 +2194,13 @@ ModifySurfByOpenEdges( ISurfFlatRegion* pSfr, PocketParams& PockParams) vCrvIsl.emplace_back( Release( pCrvIL)) ; } - // se la curva esterna presenta dei lati aperti -> devo modificarla + // se la curva esterna presenta dei lati aperti, allora necessita di estensione bool bSomeOpen = false ; int nProp0 = TEMP_PROP_INVALID ; - for ( int u = 0 ; u < pCrvEL->GetCurveCount() && ! bSomeOpen ; ++ u) - bSomeOpen = ( pCrvEL->GetCurveTempProp( u, nProp0, 0) && nProp0 == TEMP_PROP_OPEN_EDGE) ; + for ( int nU = 0 ; nU < pCrvEL->GetCurveCount() && ! bSomeOpen ; ++ nU) + bSomeOpen = ( pCrvEL->GetCurveTempProp( nU, nProp0, 0) && nProp0 == TEMP_PROP_OPEN_EDGE) ; if ( bSomeOpen) { - // allorargo il Loop esterno presso i lati aperti + // allarargo il Loop esterno presso i lati aperti if ( ! AdjustContourWithOpenEdges( pCrvEL, vCrvIsl, PockParams)) return false ; bIsChunkModified = true ; @@ -2218,8 +2209,8 @@ ModifySurfByOpenEdges( ISurfFlatRegion* pSfr, PocketParams& PockParams) // controllo i bordi delle isole ottenute // NB. L'isola può essere tutta aperta o tutta chiusa ( se non uniforme, la forzo chiusa) // [ La definizione di isola con proprietà non uniformi non è definita ] - ICRVCOMPOPOVECTOR vCrvToTIsland ; // isole che considero valide - for ( int nI = 0 ; nI < int( vCrvIsl.size()) ; ++ nI) { + ICRVCOMPOPOVECTOR vCompoIsland ; // isole che considero valide + for ( int nI = 0 ; nI < ssize( vCrvIsl) ; ++ nI) { // controllo uniformità int nCurrTmpProp = TEMP_PROP_INVALID ; int nPrecTmpProp = TEMP_PROP_INVALID ; @@ -2227,12 +2218,12 @@ ModifySurfByOpenEdges( ISurfFlatRegion* pSfr, PocketParams& PockParams) PtrOwner pCrvIsl( CloneCurveComposite( vCrvIsl[nI])) ; if ( IsNull( pCrvIsl) || ! pCrvIsl->IsValid()) return false ; - for ( int nU = 0 ; nU < pCrvIsl->GetCurveCount() && ! bIsMixed ; ++ nU) { + for ( int nU = 0 ; nU < pCrvIsl->GetCurveCount() && ! bIsMixed ; ++ nU) { pCrvIsl->GetCurveTempProp( nU, nCurrTmpProp, 0) ; bIsMixed = ( nU != 0 && nCurrTmpProp != nPrecTmpProp) ; nPrecTmpProp = nCurrTmpProp ; } - // se proprità non uniformi -> tutta chiusa + // se proprità non uniformi, allora tutta chiusa if ( bIsMixed) { for ( int nU = 0 ; nU < pCrvIsl->GetCurveCount() ; ++ nU) pCrvIsl->SetTempProp( nU, TEMP_PROP_CLOSE_EDGE) ; @@ -2245,52 +2236,50 @@ ModifySurfByOpenEdges( ISurfFlatRegion* pSfr, PocketParams& PockParams) double dMaxOffs ; CalcCurveLimitOffset( *pCrvIsl, dMaxOffs) ; // se l'isola è trascurabile passo alla successiva - if ( dMaxOffs < 2 * PockParams.dRad + 2 * PockParams.dRadialOffset) + if ( dMaxOffs < 2. * PockParams.dRad + 2. * PockParams.dRadialOffset) continue ; - // altrimenti la restringo + // altrimenti effettuo estensione ICRVCOMPOPOVECTOR vCrvOther ; - vCrvOther.emplace_back( pCrvEL->Clone()) ; - for ( int nII = 0 ; nII < int( vCrvIsl.size()) ; ++ nII) { - if ( nII != nI) - vCrvOther.emplace_back( vCrvIsl[nII]->Clone()) ; + vCrvOther.emplace_back( CloneCurveComposite( pCrvEL)) ; + for ( int nOther = 0 ; nOther < ssize( vCrvIsl) ; ++ nOther) { + if ( nOther != nI) + vCrvOther.emplace_back( vCrvIsl[nOther]->Clone()) ; } if ( ! AdjustContourWithOpenEdges( pCrvIsl, vCrvOther, PockParams)) return false ; bIsChunkModified = true ; } // conservo l'isola ( estesa o meno) - vCrvToTIsland.emplace_back( pCrvIsl->Clone()) ; // <-- valida + vCompoIsland.emplace_back( CloneCurveComposite( pCrvIsl)) ; } // se c'è stata almeno una modifica di lato aperto al Chunk ( nC-esimo), devo ricreare il Chunk // con i nuovi loop ricavati ( Chunk dopo Chunk creo la superficie finale) if ( bIsChunkModified) { - /* - l'estensione degli aperti, può unire il loop esterno con il loop delle sue isole. - Creo una nuova regione dai nuovi contorni ottenuti - */ + // L'estensione degli aperti, può unire il loop esterno con il loop delle sue isole. + // Creo una nuova regione dai nuovi contorni ottenuti SurfFlatRegionByContours SfrBC ; // loop Esterno - pCrvEL->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL, true, true) ; + pCrvEL->MergeCurves( 10. * EPS_SMALL, 10. * EPS_ANG_SMALL, true, true) ; SfrBC.AddCurve( Release( pCrvEL)) ; // isole non trascurate - for ( int nI = 0 ; nI < int( vCrvToTIsland.size()) ; ++ nI) { - vCrvToTIsland[nI]->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL, true, true) ; - SfrBC.AddCurve( Release( vCrvToTIsland[nI])) ; + for ( int nI = 0 ; nI < ssize( vCompoIsland) ; ++ nI) { + vCompoIsland[nI]->MergeCurves( 10. * EPS_SMALL, 10. * EPS_ANG_SMALL, true, true) ; + SfrBC.AddCurve( Release( vCompoIsland[nI])) ; } - // ricavo il nuovo Chunk nC-esimo esteso presso i lati aperti + // ricavo il nuovo Chunk corrente esteso presso i lati aperti PtrOwner pNewChunk( SfrBC.GetSurf()) ; if ( IsNull( pNewChunk) || ! pNewChunk->IsValid()) return false ; - // aggiungo il Chunk nC-esimo alla superficie finale + // aggiungo il Chunk corrente alla superficie finale if ( pSrfFinal->GetChunkCount() == 0) pSrfFinal.Set( pNewChunk) ; else if ( ! pSrfFinal->Add( *pNewChunk)) return false ; } - // se il Chunk c-esimo non è mai stato modificato + // se il Chunk corrente non è mai stato modificato else { - // aggiungo il Chunk alla superficie finale + // lo aggiungo semplicemente if ( pSrfFinal->GetChunkCount() == 0) pSrfFinal.Set( pSfr->CloneChunk( nC)) ; else if ( ! pSrfFinal->Add( *pSfr->CloneChunk( nC))) @@ -2311,12 +2300,12 @@ ModifySurfByOpenEdges( ISurfFlatRegion* pSfr, PocketParams& PockParams) PtrOwner pCrvIsl( ConvertCurveToComposite( pSrfFinal->GetLoop( nC, nL))) ; if ( IsNull( pCrvIsl) || ! pCrvIsl->IsValid()) return false ; - for ( int nU = 0 ; nU < pCrvIsl->GetCurveCount() && ! bIsMixed ; ++ nU) { + for ( int nU = 0 ; nU < pCrvIsl->GetCurveCount() && ! bIsMixed ; ++ nU) { pCrvIsl->GetCurveTempProp( nU, nCurrTmpProp, 0) ; bIsMixed = ( nU != 0 && nCurrTmpProp != nPrecTmpProp) ; nPrecTmpProp = nCurrTmpProp ; } - // se proprità non uniformi -> tutta chiusa + // se proprità non uniformi, tutta chiusa if ( bIsMixed) { for ( int nU = 0 ; nU < pCrvIsl->GetCurveCount() ; ++ nU) pSrfFinal->SetCurveTempProp( nC, nL, nU, TEMP_PROP_CLOSE_EDGE) ;