From 0fd0b12445c8c71807e91d6e732a528d6fcc7a97 Mon Sep 17 00:00:00 2001 From: Riccardo Elitropi Date: Tue, 18 Jul 2023 13:33:39 +0200 Subject: [PATCH] EgtMachKernel : - modifiche lati aperti e Offset sulle curve omogenee. --- Pocketing.cpp | 317 ++++++++++++++++++++++++++++++++++++++------------ Pocketing.h | 4 +- 2 files changed, 245 insertions(+), 76 deletions(-) diff --git a/Pocketing.cpp b/Pocketing.cpp index db3a63c..6d92b8b 100644 --- a/Pocketing.cpp +++ b/Pocketing.cpp @@ -9332,7 +9332,7 @@ Pocketing::CalcDistanceFromRawSurface( int nPhase, const Point3d& ptP, const Vec //---------------------------------------------------------------------------- bool Pocketing::GetParamsAtEachStep( ISURFFRPOVECTOR& vSrfSliced, vector& 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 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 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 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 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 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 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 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 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 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 pCrv_j_Offs( pCrv_uOpen_Offs->CopyParamRange( ccClass[j].dParS, ccClass[j].dParE)) ; - PtrOwner 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 pCrv_Bef( CloneCurveComposite( pCrvCompo_Clone_Trasl)) ; + // tratto successivo + PtrOwner pCrv_Aft( CloneCurveComposite( pCrvCompo_Clone_Trasl)) ; + // tratto corrente da mettere come chiuso + PtrOwner pCrv_curr_Close( CreateCurveComposite()) ; + // nuova curva... + PtrOwner 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 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 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 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 pCrv( pCrvCompo->CopyParamRange( nParStart, i)) ; + if ( IsNull( pCrv)) + return false ; + pCrv->SetTempProp( nCurrTempProp) ; + PtrOwner 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 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 ; } \ No newline at end of file diff --git a/Pocketing.h b/Pocketing.h index 0fcb94d..2766591 100644 --- a/Pocketing.h +++ b/Pocketing.h @@ -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& 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) ;