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

EgtMachKernel :

Browse Source 
- modifiche lati aperti e Offset sulle curve omogenee.
This commit is contained in:
Riccardo Elitropi
2023-07-18 13:33:39 +02:00
parent 2a3a9fefe3
commit 0fd0b12445
2 changed files with 245 additions and 76 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Pocketing.cpp
+242 -75
View File
@@ -9332,7 +9332,7 @@ Pocketing::CalcDistanceFromRawSurface( int nPhase, const Point3d& ptP, const Vec
//----------------------------------------------------------------------------
bool
Pocketing::GetParamsAtEachStep( ISURFFRPOVECTOR& vSrfSliced, vector<ICRVCOMPOPOVECTOR>& vCrvOEWithFlags,
BOOLVECTOR vbChangedPrec, const ISurfFlatRegion* pSrfChunk, const int& nStep, const Vector3d vtTool, const double& dElev,
BOOLVECTOR& vbChangedPrec, const ISurfFlatRegion* pSrfChunk, const int& nStep, const Vector3d vtTool, const double& dElev,
const double& dDepth, const double& dStep)
{
for ( int j = 1 ; j <= nStep ; ++ j) {
@@ -9497,7 +9497,6 @@ Pocketing::AdjustFakeOpenEdges( ICurveComposite* pCrvCompo, const ISurfFlatRegio
if ( pStmRaw == nullptr) // se non c'è grezzo...
return true ;
//m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvCompo->Clone()) ;
//m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrOrig->Clone()) ;
//m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pStmRaw->Clone()) ;
@@ -9622,87 +9621,173 @@ Pocketing::AdjustFakeOpenEdges( ICurveComposite* pCrvCompo, const ISurfFlatRegio
pSrfOrig_clone->Translate( vtTrasl) ;
int oooo = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrfOrig_clone->Clone()) ;
m_pGeomDB->SetMaterial( oooo, Color( 0.0, 0.0, 0.0, 0.3)) ;
// controllo le curve della composita
m_pGeomDB->SetMaterial( oooo, Color( 0.0, 0.0, 0.0, 0.3)) ;
// ho cambiato un lato aperto in chiuso ?
bool bLoopL_isChanged = false ;
for ( int u = 0 ; u < pCrvCompo_Clone_Trasl->GetCurveCount() ; ++ u) {
PtrOwner<ICurve> pCrv_u( pCrvCompo_Clone_Trasl->GetCurve( u)->Clone()) ;
if ( IsNull( pCrv_u) || ! pCrv_u->IsValid())
do {
// creo i tratti di curva omogonei ( tratti uniformi chiusi o aperti)
ICURVEPOVECTOR vCrvOpen ; ICURVEPOVECTOR vCrvClose ;
if ( ! GetHomogeneousParts( pCrvCompo_Clone_Trasl, vCrvOpen, vCrvClose, true))
return false ;
// ricavo la temp prop
int nTmpProp = pCrv_u->GetTempProp( 0) ;
if ( nTmpProp == 1) {
// se si tratta di un lato aperto...
// 1) clono il lato
PtrOwner<ICurve> pCrv_uOpen_clone( pCrv_u->Clone()) ;
if ( IsNull( pCrv_uOpen_clone) || ! pCrv_uOpen_clone->IsValid())
// scorro tutti i tratti aperti
for ( int t = 0 ; t < ( int)vCrvOpen.size() && !bLoopL_isChanged ; ++ t) {
// 1) ricavo il tratto aperto t-esimo
PtrOwner<ICurveComposite> pCrvCompo_t_Open( CreateCurveComposite()) ;
if ( IsNull( pCrvCompo_t_Open))
return false ;
pCrv_uOpen_clone->SetExtrusion( vtExtr) ;
// 2) effettuo l'Offset
pCrvCompo_t_Open->AddCurve( vCrvOpen[t]->Clone()) ;
// 2) Ricavo il paramtro iniziale e finale sulla curva originale
Point3d ptS ;
double dU_jump ;
pCrvCompo_t_Open->GetStartPoint( ptS) ;
pCrvCompo_Clone_Trasl->GetParamAtPoint( ptS, dU_jump) ;
// 3) effettuo l'Offset
pCrvCompo_t_Open->SetExtrusion( vtExtr) ;
OffsetCurve OffsCrv ;
if ( ! OffsCrv.Make( pCrv_uOpen_clone, m_dDiam_Prec > 0 ? 0.5 * m_dDiam_Prec + m_dOffsetR_Prec :
0.5 * m_TParams.m_dDiam + GetOffsR(), ICurve::OFF_FILLET) || OffsCrv.GetCurveCount() == 0)
return false ;
// 3) ricavo la curva di Offset
PtrOwner<ICurve> pCrv_uOpen_Offs( OffsCrv.GetLongerCurve()) ;
if ( IsNull( pCrv_uOpen_Offs) || ! pCrv_uOpen_Offs->IsValid())
if ( ! OffsCrv.Make( pCrvCompo_t_Open, m_dDiam_Prec > 0 ? 0.5 * m_dDiam_Prec + m_dOffsetR_Prec :
0.5 * m_TParams.m_dDiam + GetOffsR(), ICurve::OFF_FILLET))
return false ;
// -> se Offset non preduce nessuna curva, allora passo al tratto successivo
int nCrv_offs = OffsCrv.GetCurveCount() ;
if ( nCrv_offs == 0)
continue ;
PtrOwner<ICurve> pCrvlonger( OffsCrv.GetLongerCurve()) ;
// -> per ogni curva di Offset
while ( ! IsNull( pCrvlonger) && ! bLoopL_isChanged) {
if ( ! pCrvlonger->IsClosed()) { // salto le curve "chiuse"
// 4) classifico la curva di offset ricavata con la supericie originale
// NB. Tutti tratti di curva che sono esterni alla superificie originale e che si trovano all'interno della
// superificie di proeizione del grezzo lo rovineranno al di fuori della superficie originale, quindi
// vanno impostati come chiusi
PtrOwner<ICurveComposite> pCrv_tOpen_Offs( CloneCurveComposite( pCrvlonger)) ;
if ( IsNull( pCrv_tOpen_Offs) || ! pCrv_tOpen_Offs->IsValid())
return false ;
int YE = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrv_tOpen_Offs->Clone()) ;
m_pGeomDB->SetMaterial( YE, YELLOW) ;
CRVCVECTOR ccClass ;
if ( pSrfOrig_clone->GetCurveClassification( *pCrv_tOpen_Offs, 10 * EPS_SMALL, ccClass)) { // NERA
for ( int j = 0 ; j < ( int)ccClass.size() && ! bLoopL_isChanged ; ++ j) {
// 5) scorro tutti i tratti di curva della classificazione
PtrOwner<ICurveComposite> pCrv_j_Offs( CloneCurveComposite( pCrv_tOpen_Offs)) ;
pCrv_j_Offs->TrimStartEndAtParam( ccClass[j].dParS, ccClass[j].dParE) ;
// 6) se tratto di curva esterno alla superificie originale....
if ( ccClass[j].nClass == CRVC_OUT) {
CRVCVECTOR ccClass1 ;
// ... lo classifico con la proeizione del grezzo
if ( pSrf_Proj->GetCurveClassification( *pCrv_j_Offs, EPS_SMALL, ccClass1)) { // VERDE
for ( int jj = 0 ; jj < ( int)ccClass1.size() && ! bLoopL_isChanged ; ++ jj) {
if ( ccClass1[jj].nClass == CRVC_IN) {
// 7) se trovo una parte interna alla proeizione, allora devo ricavare la parte di curva
// originaria ( della pCrvCompo_t_Open) relativa a quersto tratto e impostarla come aperta
// ... ricavo il tratto di curva
int nRealDUS = ( int)floor( ccClass1[jj].dParS) ;
int nRealDUE = min( pCrv_j_Offs->GetCurveCount() - 1, ( int)floor( ccClass1[jj].dParE)) ;
if ( ceil( ccClass1[jj].dParS) - ccClass1[jj].dParS < 50 * EPS_SMALL)
nRealDUS = ( int)ceil( ccClass1[jj].dParS) ;
if ( abs( ccClass1[jj].dParE - ceil( ccClass1[jj].dParE)) < 50 * EPS_SMALL)
nRealDUE = min( pCrv_j_Offs->GetCurveCount() - 1, ( int)ceil( ccClass1[jj].dParE)) ;
int nCrvStart ; pCrv_j_Offs->GetCurveTempProp( nRealDUS, nCrvStart, 0) ;
int nCrvEnd ; pCrv_j_Offs->GetCurveTempProp( nRealDUE, nCrvEnd, 0) ;
double dUStart = dU_jump ;
double dUEnd = dU_jump ;
// TOGLIEREEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE---
PtrOwner<ICurve> hhhhhh( pCrv_uOpen_Offs->Clone()) ;
int aaa = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, hhhhhh->Clone()) ;
m_pGeomDB->SetMaterial( aaa, YELLOW) ;
// -------------------------------------------------------------------------------------------------
if (( int)( ceil( ccClass1[jj].dParE) + 0.5) == pCrv_j_Offs->GetCurveCount())
nCrvEnd += 1 ;
PtrOwner<ICurve> CIAO( pCrv_j_Offs->CopyParamRange( ccClass1[jj].dParS, ccClass1[jj].dParE)) ;
int YEs = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, CIAO->Clone()) ;
m_pGeomDB->SetMaterial( YEs, Color( 0.95, 0.0, 0.63, 1.0)) ;
// 4) classifico la curva di offset ricavata con la supericie originale
// NB. Tutti tratti di curva che sono esterni alla superificie originale e che si trovano all'interno della
// superificie di proeizione del grezzo lo rovineranno al di fuori della superficie originale, quindi
// vanno impostati come chiusi
CRVCVECTOR ccClass ;
if ( pSrfOrig_clone->GetCurveClassification( *pCrv_uOpen_Offs, 10 * EPS_SMALL, ccClass)) {
for ( int j = 0 ; j < ( int)ccClass.size() ; ++ j) {
// 5) scorro tutti i tratti di curva della classificazione
// NB. I parametri sulla curva di Offset e sulla curva originale sono in proporizione ( la curva
// è singola, quindi non ci sono raccordi). Posso quindi sfruttare i parametri della classificazione
// della curva Offsettata e utilizzarli per spezzare in sottocurve la curva originaria
PtrOwner<ICurve> pCrv_j_Offs( pCrv_uOpen_Offs->CopyParamRange( ccClass[j].dParS, ccClass[j].dParE)) ;
PtrOwner<ICurve> pCrv_uj( pCrv_u->CopyParamRange( ccClass[j].dParS, ccClass[j].dParE)) ;
if ( IsNull( pCrv_j_Offs) || ! pCrv_j_Offs->IsValid() || IsNull( pCrv_uj) || ! pCrv_uj->IsValid())
continue ;
if ( ccClass[j].nClass == CRVC_OUT) {
CRVCVECTOR ccClass1 ;
bool bSetClose = false ;
if ( pSrf_Proj->GetCurveClassification( *pCrv_j_Offs, EPS_SMALL, ccClass1)) {
for ( int jj = 0 ; jj < ( int)ccClass1.size() && !bSetClose ; ++ jj) {
if ( ccClass1[jj].nClass == CRVC_IN) {
bLoopL_isChanged = true ;
bSetClose = true ;
//int ff = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrv_uj->Clone()) ;
//m_pGeomDB->SetMaterial( ff, Color( 0.95, 0.0, 0.63)) ;
// se il tratto pericoloso ha entrambi gli estremi riferiti a due curva aperte note
if ( nCrvStart != 0 && nCrvEnd != 0) {
dUStart += nCrvStart - 1 + ( ccClass1[jj].dParS - ( int)ccClass1[jj].dParS) ;
dUEnd += nCrvEnd - 1 + ( ccClass1[jj].dParE - ( int)ccClass1[jj].dParE) ;
}
// se il tratto pericoloso l'ultimo estremo su un raccordo
else if ( nCrvStart != 0 && nCrvEnd == 0) {
dUStart += nCrvStart - 1 + ( ccClass1[jj].dParS - (int)ccClass1[jj].dParS) ;
int nCrvToAsk = ( int)( min( 0.0, ccClass1[jj].dParE - 1)) ;
int nCrvEndReal ; pCrv_j_Offs->GetCurveTempProp( nCrvToAsk, nCrvEndReal, 0) ;
dUEnd += nCrvEndReal + 0.05 ; // 5% del diam se curva abbastanza lunga
}
// se il tratto pericoloso ha il primo estremo su un raccordo
else if ( nCrvStart == 0 && nCrvEnd != 0) {
// ricavo la curva predente
int nCrvToAsk = ( int)( min( 0.0, ccClass1[jj].dParS - 1)) ;
int nCrvStartReal ; pCrv_j_Offs->GetCurveTempProp( nCrvToAsk, nCrvStartReal, 0) ;
dUStart += nCrvStartReal - 0.05 ; // 5% del diam se curva abbastanza lunga
dUEnd += nCrvEnd - 1 + ( ccClass1[jj].dParE - ( int)ccClass1[jj].dParE) ;
}
// se il tratto pericoloso ha tutti e due gli estremi su raccordi
else {
int nCrvToAskStart = ( int)( min( 0.0, ccClass[jj].dParS - 1)) ;
int nCrvStartReal ; pCrv_j_Offs->GetCurveTempProp( nCrvToAskStart, nCrvStartReal, 0) ;
dUStart += nCrvStartReal - 0.05 ; // 5% del diam se curva abbastanza lunga
int nCrvToAskEnd = ( int)( min( 0.0, ccClass[jj].dParE - 1)) ;
int nCrvEndReal ; pCrv_j_Offs->GetCurveTempProp( nCrvToAskEnd, nCrvEndReal, 0) ;
dUEnd += nCrvEndReal + 0.05 ; // 5% del diam se curva abbastanza lunga
}
// tratto precente
PtrOwner<ICurveComposite> pCrv_Bef( CloneCurveComposite( pCrvCompo_Clone_Trasl)) ;
// tratto successivo
PtrOwner<ICurveComposite> pCrv_Aft( CloneCurveComposite( pCrvCompo_Clone_Trasl)) ;
// tratto corrente da mettere come chiuso
PtrOwner<ICurveComposite> pCrv_curr_Close( CreateCurveComposite()) ;
// nuova curva...
PtrOwner<ICurveComposite> pCrv_New( CreateCurveComposite()) ;
if ( IsNull( pCrv_Bef) || ! pCrv_Bef->IsValid() ||
IsNull( pCrv_Aft) || ! pCrv_Aft->IsValid() ||
IsNull( pCrv_curr_Close) ||
IsNull( pCrv_New))
return false ;
// ricomposizione con tagli per non perdere le proprietà appena impostate
pCrv_Bef->TrimEndAtParam( dUStart) ;
pCrv_Aft->TrimStartAtParam( dUEnd) ;
if ( ! IsNull( pCrv_Bef) && pCrv_Bef->IsValid())
pCrv_New->AddCurve( Release( pCrv_Bef)) ;
pCrv_curr_Close->AddCurve( pCrvCompo_t_Open->CopyParamRange( dUStart, dUEnd)) ;
for ( int uu = 0 ; uu < pCrv_curr_Close->GetCurveCount() ; ++ uu) {
pCrv_curr_Close->SetCurveTempProp( uu, 0, 0) ; // chiusa
pCrv_curr_Close->SetCurveTempProp( uu, -99, 1) ; // chiusa
}
if ( ! IsNull( pCrv_curr_Close) && pCrv_curr_Close->IsValid()) {
int YEss = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrv_curr_Close->Clone()) ;
m_pGeomDB->SetMaterial( YEss, GREEN) ;
pCrv_New->AddCurve( Release( pCrv_curr_Close)) ;
}
else
// se la nuova curva chiusa è piccola, la ignoro...
continue ;
if ( ! IsNull( pCrv_Aft) && pCrv_Aft->IsValid())
pCrv_New->AddCurve( Release( pCrv_Aft)) ;
// controllo validità della curva, altrimenti non modifico nulla ed esco ( Avrò un chiuso)
if ( ! IsNull( pCrv_New) && pCrv_New->IsValid() && pCrv_New->IsClosed()) {
pCrvCompo_Clone_Trasl.Set( Release( pCrv_New)) ;
bLoopL_isChanged = true ;
}
}
}
}
}
}
pCrv_uj->SetTempProp( !bSetClose, 0) ;
pCrv_uj->SetTempProp( bSetClose ? -99 : 0, 1) ;
}
pCrvCompo_Final->AddCurve( pCrv_uj->Clone()) ;
} // chiusura ciclo for sui tratti di classificazione...
}
pCrvlonger.Set( OffsCrv.GetLongerCurve()) ;
}
else // se classificazione errata -> lascio la curva invariata
pCrvCompo_Final->AddCurve( pCrv_u->Clone()) ;
}
else // se curva chiusa, la aggiungo
pCrvCompo_Final->AddCurve( pCrv_u->Clone()) ;
//m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvCompo_Final->Clone()) ;
}
} while ( bLoopL_isChanged) ;
// se ci sono stati cambiamenti nella curva ...
if ( ! bLoopL_isChanged)
return true ;
//if ( ! bLoopL_isChanged)
// return true ;
// altrimenti sotituisco la curva originale, traslo e miglioro...
if ( pCrvCompo_Final != nullptr && pCrvCompo_Final->IsValid() && pCrvCompo_Final->IsClosed()) {
pCrvCompo_Final->Translate( - vtTrasl) ;
@@ -10594,7 +10679,7 @@ Pocketing::GetProjStmOnSfr( const ISurfFlatRegion* pSfr, const ISurfTriMesh* pSt
pStmRaw == nullptr || ! pStmRaw->IsValid() || pStmRaw->GetTriangleCount() == 0)
return false ;
// ---------- CREAZIONE DI UN VETTORE CONTENENTI TUTTI I TRATTI APERTI APERTE --------------------
// ---------- CREAZIONE DI UN VETTORE CONTENENTI TUTTI I TRATTI APERTI --------------------
ICRVCOMPOPOVECTOR vCrvOpen ;
ICRVCOMPOPOVECTOR vCrvNULL ;
PtrOwner<ICurveComposite> pCrvCompo( GetCurveComposite( pSfr->GetLoop( 0, 0))) ;
@@ -11468,7 +11553,7 @@ Pocketing::GetParamForPtStartOnEdge( const ICurve* pCrvCheck, const ICurveCompos
while ( nDen < dMaxInt + EPS_SMALL) { // EPS_SMALL per comprendere l'uguaglianza
for ( int i = 1 ; i < nDen ; ++i) {
if ( int( i % nDen) == 0)
continue ;
@@ -11742,7 +11827,7 @@ Pocketing::SetTmpPropByOverlap( ICurveComposite* pCrv_, int nInd, const ICurveCo
pCrvOri->GetParamAtPoint( ptS, dUS, dToll) ;
pCrvOri->GetParamAtPoint( ptE, dUE, dToll) ;
// controllare questa funzione, con 50 funziona la C, ma non la passata con il tool a 75 !
// controllare questa funzione
int nRealDUS = ( int)floor( dUS) ;
int nRealDUE = ( int)ceil( dUE) ;
if ( ceil( dUS) - dUS < EPS_SMALL)
@@ -12988,8 +13073,8 @@ Pocketing::GetSfrByStm( const ISurfTriMesh* pStm, ISurfFlatRegion* pSfr, const P
PolyLine PL = vPl[i] ;
PtrOwner<ICurveComposite> pCrv( CreateCurveComposite()) ;
pCrv->FromPolyLine( PL) ;
int yy = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrv->Clone()) ;
m_pGeomDB->SetMaterial( yy, GREEN) ;
//int yy = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrv->Clone()) ;
//m_pGeomDB->SetMaterial( yy, GREEN) ;
// essendo una curva derivante da un'intersezione di Trimesh ho una composita derivante da una polyLine,
// devo recuperare gli archi
PolyArc PA ;
@@ -13000,8 +13085,8 @@ Pocketing::GetSfrByStm( const ISurfTriMesh* pStm, ISurfFlatRegion* pSfr, const P
pCrv->ToGlob( frPock) ;
pCrv->SetExtrusion( vtExtr) ;
pCrv->SetThickness( dThick) ;
int yyy = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrv->Clone()) ;
m_pGeomDB->SetMaterial( yyy, BLACK) ;
//int yyy = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrv->Clone()) ;
//m_pGeomDB->SetMaterial( yyy, BLACK) ;
// la converto in una semplice cruva per proiettarla su piano della svuotatura
// dato che le curve sono prese da una trimesh, le proietto sul piano per sicurezza e per evitare approssimazioni
double dS, dE ;
@@ -13010,8 +13095,8 @@ Pocketing::GetSfrByStm( const ISurfTriMesh* pStm, ISurfFlatRegion* pSfr, const P
if ( IsNull( pCrv_c) || ! pCrv_c->IsValid())
return false ;
PtrOwner<ICurve> pCrv_proj( ProjectCurveOnPlane( *pCrv_c, plPock)) ;
int y = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrv_proj->Clone()) ;
m_pGeomDB->SetMaterial( y, YELLOW) ;
//int y = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrv_proj->Clone()) ;
//m_pGeomDB->SetMaterial( y, YELLOW) ;
SrfChunkDef.AddCurve( Release( pCrv_proj)) ; // aggiungo le curve proiettate
}
// recupero la FlatRegion
@@ -13022,4 +13107,86 @@ Pocketing::GetSfrByStm( const ISurfTriMesh* pStm, ISurfFlatRegion* pSfr, const P
pSfr->Clear() ;
pSfr->CopyFrom( pSrfByCurves) ;
return pSfr != nullptr && pSfr->IsValid() ;
}
//----------------------------------------------------------------------------
bool
Pocketing::GetHomogeneousParts( ICurveComposite* pCrvCompo, ICURVEPOVECTOR& vCrvOpen, ICURVEPOVECTOR& vCrvClose,
bool bCallAdjust)
{
// controllo dei parametri
vCrvClose.clear() ;
vCrvClose.clear() ;
if ( pCrvCompo == nullptr || ! pCrvCompo->IsValid() || pCrvCompo->GetCurveCount() == 0) // se curva non valida
return true ;
// controllo se la curva ha solo tratti aperti o tratti chiusi ---------------------
int nFirstTmpProp = -1 ;
int nCheckTmpProp = -1 ;
bool bIsHomogenous = true ;
for ( int u = 0 ; u < pCrvCompo->GetCurveCount() && bIsHomogenous ; ++ u) {
pCrvCompo->GetCurveTempProp( u, nCheckTmpProp, 0) ;
if ( u == 0)
nFirstTmpProp = nCheckTmpProp ;
else
if ( nFirstTmpProp != nCheckTmpProp)
bIsHomogenous = false ;
}
if ( bIsHomogenous) {
if ( nFirstTmpProp == 0)
vCrvClose.emplace_back( pCrvCompo->Clone()) ;
else if ( nFirstTmpProp == 1)
vCrvOpen.emplace_back( pCrvCompo->Clone()) ;
else
return false ;
return true ;
}
// ---------------------------------------------------------------------------------
// la curva ha sia tratti aperti che tratti chiusi, quindi sposto l'inizio a metà del tratto più lungo ( se richisto)...
if ( bCallAdjust) {
ICRVCOMPOPOVECTOR vCrvNULL ;
AdjustContourStart( pCrvCompo, vCrvNULL) ;
}
ICURVEPOVECTOR vCrvClose_tmp ;
// estraggo parti con proprietà uniforme in un vettore
int nCurrTempProp ;
int nParStart = 0 ;
for ( int i = 0 ; i < pCrvCompo->GetCurveCount() ; ++ i) {
int nTempProp ;
pCrvCompo->GetCurveTempProp( i, nTempProp) ;
if ( i == 0) {
nCurrTempProp = nTempProp ;
nParStart = i ;
}
else if ( nCurrTempProp != nTempProp) {
PtrOwner<ICurve> pCrv( pCrvCompo->CopyParamRange( nParStart, i)) ;
if ( IsNull( pCrv))
return false ;
pCrv->SetTempProp( nCurrTempProp) ;
PtrOwner<ICurveComposite> pCrvSameTmpProp( CreateCurveComposite()) ;
pCrvSameTmpProp->AddCurve( Release( pCrv)) ;
pCrvSameTmpProp->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL) ;
if ( nCurrTempProp == 1)
vCrvOpen.emplace_back( Release( pCrvSameTmpProp)) ; // se aperta
if ( nCurrTempProp == 0)
vCrvClose_tmp.emplace_back( Release( pCrvSameTmpProp)) ; // se chiusa
nCurrTempProp = nTempProp ;
nParStart = i ;
}
}
// unisco il primo e l'ultimo tratto chiuso, avendo cambiato l'inizio e la fine
if ( vCrvClose.size() > 0) {
PtrOwner<ICurveComposite> pCrvCompoFirstLast( CreateCurveComposite()) ;
if ( IsNull( pCrvCompoFirstLast))
return false ;
pCrvCompoFirstLast->AddCurve( vCrvClose.back()->Clone()) ;
pCrvCompoFirstLast->AddCurve( vCrvClose.front()->Clone()) ;
vCrvClose.front().Set( Release( pCrvCompoFirstLast)) ;
vCrvClose.pop_back() ;
}
return true ;
}
Pocketing.h
+3 -1
View File
@@ -88,6 +88,8 @@ class Pocketing : public Machining
// ===================================================================
// =========================== GREZZO e GEOMETRIE ====================
bool GetHomogeneousParts( ICurveComposite* pCrvCompo, ICURVEPOVECTOR& vCrvOpen, ICURVEPOVECTOR& vCrvClose,
bool bCallAdjust = false) ;
bool GetSfrByStm( const ISurfTriMesh* pStm, ISurfFlatRegion* pSfr, const Plane3d plPock, const Vector3d& vtExtr,
const double dThick, double dToll = 5 * EPS_SMALL) ;
bool ProjectEdgesOnSelFace( const ISurfFlatRegion* pSfrFacet, const ISurfTriMesh* pStmEdge, INTVECTOR& vBannedId ,
@@ -95,7 +97,7 @@ class Pocketing : public Machining
bool GetSurfByAdj( const ISurfTriMesh* pSrfOri, INTVECTOR& vBannedId, int idCurrFace) ;
bool GetNewBorderByProjectionOfFaces( ISurfFlatRegion* pSrfpCompo, ICurveComposite* pCrvProj, const Point3d ptStart) ;
bool GetParamsAtEachStep( ISURFFRPOVECTOR& vSrfSliced, std::vector<ICRVCOMPOPOVECTOR>& vCrvOEWithFlags,
BOOLVECTOR vbChangedPrec, const ISurfFlatRegion* pSrfChunk, const int& nStep, const Vector3d vtTool, const double& dElev,
BOOLVECTOR& vbChangedPrec, const ISurfFlatRegion* pSrfChunk, const int& nStep, const Vector3d vtTool, const double& dElev,
const double& dDepth, const double& dStep) ;
bool AdaptSfrWithRaw( ISurfFlatRegion* pSrf, Vector3d vtTrasl, const double& dRawSecLen,
ICRVCOMPOPOVECTOR& vCrvOEFlags, bool& bChanged, double dAreaToll = 500 * EPS_SMALL) ;