Egalware/EgtGeomKernel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

EgtGeomKernel :

Browse Source 
- in CalcPocketing modifiche stilistiche.
This commit is contained in:
Riccardo Elitropi
2026-06-09 15:22:55 +02:00
parent 1c49379ee1
commit 7c85ea2d43
1 changed files with 90 additions and 101 deletions
Download Patch File Download Diff File Expand all files Collapse all files
CalcPocketing.cpp
+90 -101
View File
@@ -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<ISurfFlatRegion> 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<ICurveComposite> 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<ICurveComposite> 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<ICurveComposite> 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<ICurve> 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<ISurfFlatRegion> 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<ISurfFlatRegion> 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<ICurveComposite> pCrvIntLoop( ConvertCurveToComposite( pSfrInc->GetLoop( 0, l))) ;
PtrOwner<ICurveComposite> 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<ICurveComposite> 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<ICurveComposite> pCrvCompo_final( CreateCurveComposite()) ;
if ( IsNull( pCrvCompo_final))
PtrOwner<ICurveComposite> 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<ISurfFlatRegion> 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<ICurveComposite> 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<ICurveComposite> 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<ISurfFlatRegion> 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<ICurveComposite> 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) ;