From ac85a09ff27051f8e2124d19f82e2dccd30ec7d1 Mon Sep 17 00:00:00 2001 From: Riccardo Elitropi Date: Tue, 10 Oct 2023 11:04:59 +0200 Subject: [PATCH] EgtMachKernel : - migliorie per entrate. --- Pocketing.cpp | 104 ++++++++++++++++++++++++++++++++++++-------------- Pocketing.h | 2 +- 2 files changed, 76 insertions(+), 30 deletions(-) diff --git a/Pocketing.cpp b/Pocketing.cpp index 8365867..b174ec3 100644 --- a/Pocketing.cpp +++ b/Pocketing.cpp @@ -2258,6 +2258,12 @@ Pocketing::AddZigZag( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c nStep, vtTool, dElev, dDepth, dStep)) return false ; + // parametri per lavorazioni precedenti + VCT3DVECTOR vVtMidOutPrec ; + BOOLVECTOR vbMidOutPrec ; + PNTVECTOR vPtStartPrec ; + ICRVCOMPOPOVECTOR vAllCrvPrec ; + // ciclo su tutti gli step for( int j = 1 ; j <= nStep ; ++j) { @@ -2617,12 +2623,36 @@ Pocketing::AddZigZag( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c for ( int u = 0 ; u < ( int)vAllCrv.size() ; ++u) { // per ogni curva di bordo... - bool bOutTmp = false ; + if ( vbChangedPrec[j-1] || j == 1) { + // se la superficie è cambiata, allora ricalcolo i parametri + bool bOutTmp = false ; - if ( ! SetBetterPtStartForSubChunks( vAllCrv[u], pSrfChunkFinal, - vPtStart[u], vVtMidOut[u], bOutTmp, dOffs)) - return false ; - vbMidOut[u] = bOutTmp ; // vector::reference da Bit a Bool + if ( ! SetBetterPtStartForSubChunks( vAllCrv[u], pSrfChunkFinal, + vPtStart[u], vVtMidOut[u], bOutTmp, dOffs)) + return false ; + vbMidOut[u] = bOutTmp ; // vector::reference da Bit a Bool + + vPtStartPrec.clear() ; + vVtMidOutPrec.clear() ; + vAllCrvPrec.clear() ; + vbMidOutPrec.clear() ; + // memorizzo per lavorazioni successive + for ( int k = 0 ; k < int( vPtStart.size()) ; ++ k) { + vPtStartPrec.push_back( vPtStart[k]) ; + vVtMidOutPrec.push_back( vVtMidOut[k]) ; + vAllCrvPrec.emplace_back( vAllCrv[k]->Clone()) ; + vbMidOutPrec.push_back( vbMidOut[k]) ; + } + } + else { + // se la superficie attuale è uguale alla precedente, lascio i paramentri inviariati + for ( int k = 0 ; k < int( vPtStartPrec.size()) ; ++ k) { + vPtStart[k] = vPtStartPrec[k] ; + vVtMidOut[k] = vVtMidOutPrec[k] ; + vAllCrv[k].Set( vAllCrvPrec[k]->Clone()) ; + vbMidOut[k] = vbMidOutPrec[k] ; + } + } // riporto i valori nel sistema di riferimento corretto vPtStart[u].ToGlob( bOptimizedZigZag ? frPocketOriByOpt : frPocket) ; @@ -2705,9 +2735,6 @@ Pocketing::AddZigZag( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c Vector3d vtStart ; pCurve->GetStartPoint( ptStart) ; pCurve->GetStartDir( vtStart) ; - Point3d ptForElev = ptStart ; - if ( vbMidOut[u] || vbForcedOutStart[u]) - pCurve->GetEndPoint( ptForElev) ; // se primo step, approccio e affondo //if ( true || j == 1 || vbChangedPrec[j-1] || vSrfSliced[j-2]->GetChunkCount() > 1) { // determino inizio attacco @@ -4613,19 +4640,18 @@ Pocketing::AddSpiralIn( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, if ( IsNull( pSrfChunk)) return false ; - // modifico le superifici in base alla geometria del grezzo - // RECUPERO DEL GREZZO -> INTERSEZIONE CON GREZZO -> PROIEZIONE CON GREZZO -> MODIFICA DEI LATI APERTI - + // modifico le superifici in base alla geometria del grezzo e alla geometria dell'entità selezionata ISURFFRPOVECTOR vSrfSliced( nStep) ; vector vCrvOEWithFlags( nStep) ; BOOLVECTOR vbChangedPrec( nStep, false) ; VCT3DVECTOR vVtTrasl( nStep, V_NULL) ; - // modifico le superifici in base alla geometria del grezzo if ( ! GetParamsAtEachStep( vSrfSliced, vCrvOEWithFlags, vbChangedPrec, vVtTrasl, pSrfChunk, nStep, vtTool, dElev, dDepth, dStep)) return false ; - Point3d ptP1 ; // per LeadIn + Point3d ptP1, ptStartPrec ; // per LeadIn attuale e precedente + Vector3d vtMidOutPrec ; // vettore direzione di uscite precedente + bool bMidOutPrec ; // flag per entrata da fuori dal grezzo precedente // ciclo su tutti gli step for ( int j = 1 ; j <= nStep ; ++ j) { @@ -4712,7 +4738,9 @@ Pocketing::AddSpiralIn( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, int nRegTot = nReg ; // calcolo il percorso di svuotatura - if ( ! CalcSpiral( pSrfChunkFinal, nRegTot, ptStart, vtMidOut, bMidOut, bSplitArcs, pMCrv, pRCrv, vCrvOEWithFlags[j-1][nInd], bOptimizedTrap)) + if ( ! CalcSpiral( pSrfChunkFinal, nRegTot, ptStart, vtMidOut, bMidOut, bSplitArcs, pMCrv, pRCrv, + vCrvOEWithFlags[j-1][nInd], j == 1 ? true : vbChangedPrec[j-1] , ptStartPrec, + bOptimizedTrap)) return false ; // se terminate le regioni, esco @@ -4729,13 +4757,26 @@ Pocketing::AddSpiralIn( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, return false ; } } - + // controlli per entrate da fuori al grezzo bool bOutStart = bMidOut ; if ( bOutStart && ! bOptimizedTrap) { + if ( j != 1 && ! vbChangedPrec[j-1]) { + vtMidOut = vtMidOutPrec ; + bMidOut = bMidOutPrec ; + ptStart = ptStartPrec ; + } // calcolo il punto fuori per il LeadIn Point3d ptOut = ptStart + vtMidOut * ( 0.5 * m_TParams.m_dDiam + dSafeZ) ; + // memorizzo nel caso lo step successivo presenti la stessa geometria + ptStartPrec = ptStart ; + vtMidOutPrec = vtMidOut ; + bMidOutPrec = bMidOut ; ptOut.Translate( vVtTrasl[j-1]) ; // lo traslo allo step corrente + + //IGeoPoint3d* ptSSS( CreateGeoPoint3d()) ; ptSSS->Set( ptOut) ; + //m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, ptSSS) ; + double dStElev ; // controllo l'elevazione bOutStart = ( ! GetElevation( m_nPhase, ptOut, vtTool, 0.5 * m_TParams.m_dDiam, vtTool, dStElev) || dStElev < EPS_SMALL) ; @@ -4906,7 +4947,7 @@ Pocketing::AddSpiralIn( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, if ( IsNull( pRet)) return false ; // aggiungo affondamento - pRet->Translate( -vtTool * ( dDepth - dElev + j * dStep)) ; + pRet->Translate( vVtTrasl[j-1]) ; // se attacco a scivolo, accorcio della lunghezza dell'attacco if ( GetLeadInType() == POCKET_LI_GLIDE) { double dLen ; pRet->GetLength( dLen) ; @@ -4989,7 +5030,7 @@ Pocketing::AddSpiralOut( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool nStep, vtTool, dElev, dDepth, dStep)) return false ; - Point3d ptP1 ; + Point3d ptP1, ptStartPrec ; // per LeadIn attuale e precedente // ciclo su tutti gli step for ( int j = 1 ; j <= nStep ; ++ j) { @@ -5067,7 +5108,8 @@ Pocketing::AddSpiralOut( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool bool bMidOut ; int nRegToT = nReg ; - if ( ! CalcSpiral( pSrfChunkFinal, nRegToT, ptStart, vtMidOut, bMidOut, bSplitArcs, pMCrv, pRCrv, vCrvOEWithFlags[j-1][nInd], bOptimizedTrap)) + if ( ! CalcSpiral( pSrfChunkFinal, nRegToT, ptStart, vtMidOut, bMidOut, bSplitArcs, pMCrv, pRCrv, + vCrvOEWithFlags[j-1][nInd], vbChangedPrec[j-1], ptStartPrec, bOptimizedTrap)) return false ; // se terminate le regioni, esco @@ -5268,7 +5310,7 @@ Pocketing::AddSpiralOut( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool bool Pocketing::CalcSpiral( const ISurfFlatRegion* pSrfPock, int& nReg, Point3d& ptStart, Vector3d& vtMidOut , bool& bMidOut, bool bSplitArcs,ICurveComposite* pMCrv, ICurveComposite* pRCrv, ICurveComposite* pCrvOEWithFlags, - bool& bOptimizedTrap) + bool bChangedPrec, Point3d& ptStartPrec, bool& bOptimizedTrap) { // inizializzo i risultati @@ -5433,7 +5475,7 @@ Pocketing::CalcSpiral( const ISurfFlatRegion* pSrfPock, int& nReg, Point3d& ptSt if (( int)vOffs.size() == 0) return true ; - // cambio il punto iniziale della prima Curva di Offset + // cambio il punto iniziale della prima Curva di Offset ( se la superficie precedente non è cambiata) Point3d ptNewStart ; double dOffR ; if (( int)vOffs.size() > 1) @@ -5441,10 +5483,20 @@ Pocketing::CalcSpiral( const ISurfFlatRegion* pSrfPock, int& nReg, Point3d& ptSt else dOffR = dOffs ; - if ( SetBetterPtStartForSubChunks( vOffs[0], pSrfToWork, ptStart, vtMidOut, bMidOut, dOffR)) + if ( bChangedPrec) { + if ( SetBetterPtStartForSubChunks( vOffs[0], pSrfToWork, ptStart, vtMidOut, bMidOut, dOffR)) + vOffs[0]->GetStartPoint( ptNewStart) ; + else + return false ; + } + else { + double dULastStart ; + Point3d ptStartPrec_Loc = ptStartPrec ; + ptStartPrec_Loc.ToLoc( frPocket) ; + vOffs[0]->GetParamAtPoint( ptStartPrec_Loc, dULastStart, 100 * EPS_SMALL) ; + vOffs[0]->ChangeStartPoint( dULastStart) ; vOffs[0]->GetStartPoint( ptNewStart) ; - else - return false ; + } // se richiesta inversione for ( int i = 0 ; i < ( int)vOffs.size() && m_Params.m_bInvert ; ++ i) @@ -9866,7 +9918,6 @@ Pocketing::GetParamsAtEachStep( ISURFFRPOVECTOR& vSrfSliced, vectorClone()) ; // la superificie potrebbe non essere valida ( ad esempio se già svuotata tutta con un Tool in precedenza...) if ( ! IsNull( vSrfSliced[j-1])) { @@ -9968,8 +10019,6 @@ Pocketing::CalcExtraSteps( const ISurfFlatRegion* pSfrAct, const ISurfTriMesh* p return false ; if ( ! pStmORIG_c->IsValid()) continue ; - //int G = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pStmORIG_c->Clone()) ; - //m_pGeomDB->SetMaterial( G, GRAY) ; // 4) Cerco se ci sono delle facce che presentano una normale parallela al versore di svuotatura vector vdDists ; @@ -9978,9 +10027,6 @@ Pocketing::CalcExtraSteps( const ISurfFlatRegion* pSfrAct, const ISurfTriMesh* p if ( ! AreSameVectorApprox( vtN_Check, vtN)) continue ; - //int Y = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pStmORIG_c->CloneFacet( f)) ; - //m_pGeomDB->SetMaterial( Y, YELLOW) ; - // 5) se faccia trovata, allora calcolo la distanza tra il piano far e la faccia Point3d ptC_f ; pStmORIG_c->GetFacetCenter( f, ptC_f, vtN) ; double dCurrDist = abs( DistPointPlane( ptC_f, plFar)) ; diff --git a/Pocketing.h b/Pocketing.h index 2149ff7..c82adf8 100644 --- a/Pocketing.h +++ b/Pocketing.h @@ -207,7 +207,7 @@ class Pocketing : public Machining double dElev, double dOkStep, bool bSplitArcs) ; bool CalcSpiral( const ISurfFlatRegion* pSrfPock, int& nReg, Point3d& ptStart, Vector3d& vtMidOut , bool& bMidOut, bool bSplitArcs,ICurveComposite* pMCrv, ICurveComposite* pRCrv, ICurveComposite* pCrvOEWithFlags, - bool& bOptimizedTrap) ; + bool vbChangedPrec, Point3d& ptStartPrec, bool& bOptimizedTrap) ; bool CheckIfOffsetIsNecessary( const ICurveComposite* pCrvOffs, const double dOffs, const int nIter, const int nOffsCount, const Vector3d& vtN, bool& bInsert) ; bool GetUnclearedRegion( ICRVCOMPOPOVECTOR& vFirstOffs, ICRVCOMPOPOVECTOR& vCrvs, ICURVEPOVECTOR& vLinks,