From dea96ccbcc6c1756bfcc6c0c4b19e2640e868968 Mon Sep 17 00:00:00 2001 From: Dario Sassi Date: Sat, 29 Jun 2024 18:45:19 +0200 Subject: [PATCH] EgtGeomKernel : - miglioramenti a calcolo silhouette con CollisionAvoid compresa parallelizzazione - piccole migliorie a CollisionAvoid - migliorie e correzioni a CalcPocketing. --- CAvSilhouetteSurfTm.cpp | 198 ++++++++++++++++++++++++++++++++-------- CAvSilhouetteSurfTm.h | 1 + CAvToolSurfTm.cpp | 10 +- CAvToolSurfTm.h | 10 +- CalcPocketing.cpp | 53 +++++------ 5 files changed, 193 insertions(+), 79 deletions(-) diff --git a/CAvSilhouetteSurfTm.cpp b/CAvSilhouetteSurfTm.cpp index 7c685ba..1160abb 100644 --- a/CAvSilhouetteSurfTm.cpp +++ b/CAvSilhouetteSurfTm.cpp @@ -16,6 +16,8 @@ #include "GeoConst.h" #include "/EgtDev/Include/EGkChainCurves.h" #include "/EgtDev/Include/EGkOffsetCurve.h" +#include +#include using namespace std ; @@ -43,7 +45,7 @@ CalcPoint( const Point3d& ptS, const Point3d& ptE, double dLevel, double dDist = max( abs( ptS.x - ptE.x), abs( ptS.y - ptE.y)) ; // Ricerca con metodo di bisezione (si arresta quando il medio รจ allineato agli estremi) - const int MAX_ITER = 8 ; + const int MAX_ITER = 10 ; int nCount = 0 ; Point3d ptP1 = ptS ; Point3d ptP2 = ptE ; @@ -53,10 +55,10 @@ CalcPoint( const Point3d& ptS, const Point3d& ptE, double dLevel, ptMid.z = 0 ; Point3d ptTest = GetToGlob( ptMid + cavTstm.GetToolHeight() * Z_AX, frGrid) ; double dMove ; - const_cast( &cavTstm)->TestPosition( ptTest, frGrid.VersZ(), frGrid.VersZ(), dMove) ; + cavTstm.TestPosition( ptTest, frGrid.VersZ(), frGrid.VersZ(), dMove) ; ptMid.z = dMove ; // se sta sulla linea che unisce gli estremi, basta interpolazione lineare - if ( abs( ptMid.z - ( ptP1.z + ptP2.z) / 2) < 0.004 * dDist) + if ( abs( ptMid.z - ( ptP1.z + ptP2.z) / 2) < EPS_SMALL / 2) return Media( ptP1, ptP2, ( ptP1.z - dLevel) / ( ptP1.z - ptP2.z)) ; // altrimenti nuova suddivisione della parte con estremi da parte opposta rispetto al livello bool b1On = ( ptP1.z > dLevel) ; @@ -74,9 +76,7 @@ CalcPoint( const Point3d& ptS, const Point3d& ptE, double dLevel, //---------------------------------------------------------------------------- static int -ProcessSquare( int nFlag, const Point3d ptP[4], double dLevel, - const ICAvToolSurfTm& cavTstm, const Frame3d &frGrid, - Point3d& ptL1s, Point3d& ptL1e, Point3d& ptL2s, Point3d& ptL2e) +ProcessSquare( int nFlag, int& nI1s, int& nI1e, int& nI2s, int& nI2e) { static int LineTable[16][5] = { { 0, -1, -1, -1, -1}, { 1, 0, 3, -1, -1}, @@ -102,22 +102,16 @@ ProcessSquare( int nFlag, const Point3d ptP[4], double dLevel, return 0 ; // una linea else if ( LineTable[nFlag][0] == 1) { - int nI1s = LineTable[nFlag][1] ; - int nI1e = LineTable[nFlag][2] ; - ptL1s = CalcPoint( ptP[nI1s], ptP[( nI1s + 1) % 4], dLevel, cavTstm, frGrid) ; - ptL1e = CalcPoint( ptP[nI1e], ptP[( nI1e + 1) % 4], dLevel, cavTstm, frGrid) ; - return ( AreSamePointApprox( ptL1s, ptL1e) ? 0 : 1) ; + nI1s = LineTable[nFlag][1] ; + nI1e = LineTable[nFlag][2] ; + return 1 ; } // due linee else if ( LineTable[nFlag][0] == 2) { - int nI1s = LineTable[nFlag][1] ; - int nI1e = LineTable[nFlag][2] ; - ptL1s = CalcPoint( ptP[nI1s], ptP[( nI1s + 1) % 4], dLevel, cavTstm, frGrid) ; - ptL1e = CalcPoint( ptP[nI1e], ptP[( nI1e + 1) % 4], dLevel, cavTstm, frGrid) ; - int nI2s = LineTable[nFlag][3] ; - int nI2e = LineTable[nFlag][4] ; - ptL2s = CalcPoint( ptP[nI2s], ptP[( nI2s + 1) % 4], dLevel, cavTstm, frGrid) ; - ptL2e = CalcPoint( ptP[nI2e], ptP[( nI2e + 1) % 4], dLevel, cavTstm, frGrid) ; + nI1s = LineTable[nFlag][1] ; + nI1e = LineTable[nFlag][2] ; + nI2s = LineTable[nFlag][3] ; + nI2e = LineTable[nFlag][4] ; return 2 ; } return -1 ; @@ -125,15 +119,125 @@ ProcessSquare( int nFlag, const Point3d ptP[4], double dLevel, //---------------------------------------------------------------------------- static bool -MarchingSquares( const DBLVECTOR& vdGrid, int nStepX, int nStepY, double dStep, double dLevel, - const ICAvToolSurfTm& cavTstm, const Frame3d &frGrid, POLYLINEVECTOR& vPL) +TestSubEdges( unordered_map& umEdgePnt, const INTVECTOR& vEdgeInd, int nFirst, int nLast, + const DBLVECTOR& vdGrid, int nStepX, double dStep, + double dLevel, const ICAvToolSurfTm& cavTstm, const Frame3d &frGrid) { + for ( int k = nFirst ; k <= nLast ; ++ k) { + // recupero i differenti indici + int nKey = vEdgeInd[k] ; + int nInd = nKey / 2 ; + bool bOnX = ( ( nKey % 2) == 0) ; + int j = nInd / ( nStepX + 1) ; + int i = nInd % ( nStepX + 1) ; + // determino i punti estremi dell'edge + Point3d ptS{ i * dStep, j * dStep, vdGrid[nInd]} ; + Point3d ptE{ ptS.x + ( bOnX ? dStep : 0), ptS.y + ( bOnX ? 0 : dStep), vdGrid[nInd + ( bOnX ? 1 : nStepX + 1)]} ; + // calcolo il punto + Point3d ptQ = CalcPoint( ptS, ptE, dLevel, cavTstm, frGrid) ; + umEdgePnt[ nKey] = ptQ ; + } + return true ; +} + +//---------------------------------------------------------------------------- +static bool +MarchingSquares( const DBLVECTOR& vdGrid, int nStepX, int nStepY, double dStep, double dRad, + double dLevel, const ICAvToolSurfTm& cavTstm, const Frame3d &frGrid, POLYLINEVECTOR& vPL) +{ + // Analizzo gli edge da cui passano le curve cercate + unordered_map umEdgePnt( 4 * ( nStepX + nStepY)) ; + INTVECTOR vEdgeInd ; + vEdgeInd.reserve( 4 * ( nStepX + nStepY)) ; + for ( int j = 0 ; j < nStepY ; ++ j) { + for ( int i = 0 ; i < nStepX ; ++ i) { + // indici dei vertici nella griglia + int nInd0 = i + j * ( nStepX + 1) ; + int nInd1 = ( i + 1) + j * ( nStepX + 1) ; + int nInd2 = ( i + 1) + ( j + 1) * ( nStepX + 1) ; + int nInd3 = i + ( j + 1) * ( nStepX + 1) ; + // flag del quadrato + bool bUp0 = ( vdGrid[nInd0] > dLevel) ; + bool bUp1 = ( vdGrid[nInd1] > dLevel) ; + bool bUp2 = ( vdGrid[nInd2] > dLevel) ; + bool bUp3 = ( vdGrid[nInd3] > dLevel) ; + // se tutti uguali, passo al successivo + if ( bUp0 == bUp1 && bUp0 == bUp2 && bUp0 == bUp3) + continue ; + // verifico quali calcolare + if ( bUp0 != bUp1) { + int nKey = 2 * nInd0 ; + if ( umEdgePnt.find( nKey) == umEdgePnt.end()) { + umEdgePnt[ nKey] = P_INVALID ; + vEdgeInd.emplace_back( nKey) ; + } + } + if ( bUp3 != bUp2) { + int nKey = 2 * nInd3 ; + if ( umEdgePnt.find( nKey) == umEdgePnt.end()) { + umEdgePnt[ nKey] = P_INVALID ; + vEdgeInd.emplace_back( nKey) ; + } + } + if ( bUp0 != bUp3) { + int nKey = 2 * nInd0 + 1 ; + if ( umEdgePnt.find( nKey) == umEdgePnt.end()) { + umEdgePnt[ nKey] = P_INVALID ; + vEdgeInd.emplace_back( nKey) ; + } + } + if ( bUp1 != bUp2) { + int nKey = 2 * nInd1 + 1 ; + if ( umEdgePnt.find( nKey) == umEdgePnt.end()) { + umEdgePnt[ nKey] = P_INVALID ; + vEdgeInd.emplace_back( nKey) ; + } + } + } + } + // Numero di edge da valutare + int nEdgeCnt = int( vEdgeInd.size()) ; + // Recupero il numero massimo di thread concorrenti + int nThreadMax = thread::hardware_concurrency() ; + bool bOk = true ; + // Se un solo thread o pochi punti + if ( nThreadMax <= 1 || nEdgeCnt < 50) { + TestSubEdges( umEdgePnt, vEdgeInd, 0, nEdgeCnt - 1, vdGrid, nStepX, dStep, dLevel, cavTstm, frGrid) ; + } + // altrimenti + else { + const int MAX_PARTS = 32 ; + INTINTVECTOR vFstLst( MAX_PARTS) ; + // calcolo le parti del vettore + int nPartCnt = min( nThreadMax, MAX_PARTS) ; + int nPartDim = nEdgeCnt / nPartCnt + 1 ; + for ( int i = 0 ; i < nPartCnt ; ++ i) { + vFstLst[i].first = i * nPartDim ; + vFstLst[i].second = min( ( i + 1) * nPartDim, nEdgeCnt) - 1 ; + } + // processo le parti + future vRes[MAX_PARTS] ; + for ( int i = 0 ; i < nPartCnt ; ++ i) + vRes[i] = async( launch::async, &TestSubEdges, ref( umEdgePnt), cref( vEdgeInd), vFstLst[i].first, vFstLst[i].second, + cref( vdGrid), nStepX, dStep, dLevel, cref( cavTstm), cref( frGrid)) ; + // attendo i risultati + int nFin = 0 ; + while ( nFin < nPartCnt) { + for ( int i = 0 ; i < nPartCnt ; ++ i) { + if ( vRes[i].valid() && vRes[i].wait_for( chrono::nanoseconds{ 1}) == future_status::ready) { + bOk = vRes[i].get() && bOk ; + ++ nFin ; + } + } + } + } + // Predispongo il concatenamento BIPNTVECTOR vBiPnt ; vBiPnt.reserve( 2 * ( nStepX + nStepY)) ; ChainCurves chainC ; chainC.Init( false, EPS_SMALL, 2 * ( nStepX + nStepY)) ; - // Ciclo sui quadrati della griglia + // Ciclo sui quadrati da analizzare for ( int j = 0 ; j < nStepY ; ++ j) { for ( int i = 0 ; i < nStepX ; ++ i) { // indici dei vertici nella griglia @@ -146,25 +250,31 @@ MarchingSquares( const DBLVECTOR& vdGrid, int nStepX, int nStepY, double dStep, ( vdGrid[nInd1] > dLevel ? 2 : 0) + ( vdGrid[nInd2] > dLevel ? 4 : 0) + ( vdGrid[nInd3] > dLevel ? 8 : 0) ; - // punti di vertice del quadrato - Point3d ptP[4] = { { i * dStep, j * dStep, vdGrid[nInd0]}, - { ( i + 1) * dStep, j * dStep, vdGrid[nInd1]}, - { ( i + 1) * dStep, ( j + 1) * dStep, vdGrid[nInd2]}, - { i * dStep, ( j + 1) * dStep, vdGrid[nInd3]}} ; + // se quadrato con vertici tutti dello stesso tipo, passo al successivo + if ( nFlag == 0 || nFlag == 15) + continue ; + // chiavi + int vKey[4] = { 2 * nInd0, 2 * nInd1 + 1, 2 * nInd3, 2 * nInd0 + 1} ; // calcolo segmenti da inserire - Point3d ptL1s, ptL1e, ptL2s, ptL2e ; - int nSegCnt = ProcessSquare( nFlag, ptP, dLevel, cavTstm, frGrid, ptL1s, ptL1e, ptL2s, ptL2e) ; + int nI1s, nI1e, nI2s, nI2e ; + int nSegCnt = ProcessSquare( nFlag, nI1s, nI1e, nI2s, nI2e) ; if ( nSegCnt == -1) return false ; else if ( nSegCnt == 1) { + Point3d ptL1s = umEdgePnt.find( vKey[nI1s])->second ; + Point3d ptL1e = umEdgePnt.find( vKey[nI1e])->second ; vBiPnt.emplace_back( ptL1s, ptL1e) ; Vector3d vtDir1 = ptL1e - ptL1s ; vtDir1.Normalize() ; chainC.AddCurve( int( vBiPnt.size()), ptL1s, vtDir1, ptL1e, vtDir1) ; } else if ( nSegCnt == 2) { + Point3d ptL1s = umEdgePnt.find( vKey[nI1s])->second ; + Point3d ptL1e = umEdgePnt.find( vKey[nI1e])->second ; vBiPnt.emplace_back( ptL1s, ptL1e) ; Vector3d vtDir1 = ptL1e - ptL1s ; vtDir1.Normalize() ; chainC.AddCurve( int( vBiPnt.size()), ptL1s, vtDir1, ptL1e, vtDir1) ; + Point3d ptL2s = umEdgePnt.find( vKey[nI2s])->second ; + Point3d ptL2e = umEdgePnt.find( vKey[nI2e])->second ; vBiPnt.emplace_back( ptL2s, ptL2e) ; Vector3d vtDir2 = ptL2e - ptL2s ; vtDir2.Normalize() ; chainC.AddCurve( int( vBiPnt.size()), ptL2s, vtDir2, ptL2e, vtDir2) ; @@ -186,6 +296,10 @@ MarchingSquares( const DBLVECTOR& vdGrid, int nStepX, int nStepY, double dStep, crvCompo.Close() ; // elimino le parti allineate crvCompo.MergeCurves( 10 * EPS_SMALL, ANG_TOL_STD_DEG) ; + // salto i contorni orari con area inferiore al doppio del quadrato + double dCmpArea ; + if ( ! crvCompo.GetAreaXY( dCmpArea) || ( dCmpArea < 0 && abs( dCmpArea) < 2 * dStep * dStep)) + continue ; // per test mettere a 1 #if 0 vPL.emplace_back( PolyLine()) ; @@ -193,7 +307,7 @@ MarchingSquares( const DBLVECTOR& vdGrid, int nStepX, int nStepY, double dStep, #else // eseguo offset a sinistra pari allo step OffsetCurve offsCompo ; - offsCompo.Make( &crvCompo, -( dStep - 10 * EPS_SMALL), ICurve::OFF_CHAMFER) ; + offsCompo.Make( &crvCompo, -( dRad - 2 * EPS_SMALL), ICurve::OFF_CHAMFER) ; PtrOwner pCrvOffset( offsCompo.GetLongerCurve()) ; if ( ! IsNull( pCrvOffset)) { vPL.emplace_back( PolyLine()) ; @@ -256,8 +370,9 @@ CAvSilhouetteSurfTm( const ISurfTriMesh& Stm, const Plane3d& plPlane, double dTo } // esecuzione della verifica + double dRad = SQRT1_2 * dTol ; CAvToolSurfTm cavTstm ; - cavTstm.SetStdTool( dDimZ, dTol, 0) ; + cavTstm.SetStdTool( dDimZ, dRad, 0) ; cavTstm.SetSurfTm( Stm) ; if ( ! cavTstm.TestSeries( vPntM, frGrid.VersZ(), frGrid.VersZ(), -1)) return false ; @@ -273,7 +388,7 @@ CAvSilhouetteSurfTm( const ISurfTriMesh& Stm, const Plane3d& plPlane, double dTo // calcolo della silhouette con il metodo MarchingSquares double dLevel = dLevelOffs ; - if ( ! MarchingSquares( vdGrid, nStepX, nStepY, dTol, dLevel, cavTstm, frGrid, vPL)) + if ( ! MarchingSquares( vdGrid, nStepX, nStepY, dTol, dRad, dLevel, cavTstm, frGrid, vPL)) return false ; // riporto nella corretta posizione le curve trovate for ( auto& PL : vPL) @@ -283,6 +398,8 @@ CAvSilhouetteSurfTm( const ISurfTriMesh& Stm, const Plane3d& plPlane, double dTo } +//---------------------------------------------------------------------------- +// Silhouette rispetto ad una direzione e sopra diverse quote di una superficie TriMesh //---------------------------------------------------------------------------- ICAvParSilhouettesSurfTm* CreateCAvParSilhouettesSurfTm( void) @@ -290,11 +407,9 @@ CreateCAvParSilhouettesSurfTm( void) return static_cast ( new(nothrow) CAvParSilhouettesSurfTm) ; } -//---------------------------------------------------------------------------- -// Silhouette rispetto ad una direzione e sopra diverse quote di una superficie TriMesh //---------------------------------------------------------------------------- CAvParSilhouettesSurfTm::CAvParSilhouettesSurfTm( void) - : m_dTol( 100 * EPS_SMALL), m_nStepX( 0), m_nStepY( 0), m_dLevelOffs( 0), m_bGridOk( false) + : m_dTol( 100 * EPS_SMALL), m_nStepX( 0), m_nStepY( 0), m_dRad( m_dTol), m_dLevelOffs( 0), m_bGridOk( false) { } @@ -305,6 +420,7 @@ CAvParSilhouettesSurfTm::SetData( const CISURFTMPVECTOR& vpStm, const Frame3d& f m_vpStm = vpStm ; m_frGrid = frPlanes ; m_dTol = max( dTol, 100 * EPS_SMALL) ; + m_dRad = SQRT1_2 * m_dTol ; m_nStepX = 0 ; m_nStepY = 0 ; m_dDimZ = 0 ; @@ -317,7 +433,7 @@ CAvParSilhouettesSurfTm::SetData( const CISURFTMPVECTOR& vpStm, const Frame3d& f bool CAvParSilhouettesSurfTm::Prepare( void) { - // ingombro delle superfici nel riferimento dei piani + // ingombro delle superfici nel riferimento dei piani BBox3d b3All ; Frame3d frInv = GetInvert( m_frGrid) ; for ( auto pStm : m_vpStm) { @@ -348,7 +464,7 @@ CAvParSilhouettesSurfTm::Prepare( void) } // esecuzione della verifica - if ( ! m_cavTstm.SetStdTool( m_dDimZ, m_dTol, 0)) + if ( ! m_cavTstm.SetStdTool( m_dDimZ, m_dRad, 0)) return false ; if ( m_vpStm.empty() || ! m_cavTstm.SetSurfTm( *( m_vpStm[0]))) return false ; @@ -384,10 +500,14 @@ CAvParSilhouettesSurfTm::GetSilhouette( double dLevel, POLYLINEVECTOR& vPL) // calcolo della silhouette con il metodo MarchingSquares dLevel += m_dLevelOffs ; - if ( ! MarchingSquares( m_vdGrid, m_nStepX, m_nStepY, m_dTol, dLevel, m_cavTstm, m_frGrid, vPL)) + double dCalcLevel = max( dLevel, 0.) ; + if ( ! MarchingSquares( m_vdGrid, m_nStepX, m_nStepY, m_dTol, m_dRad, dCalcLevel, m_cavTstm, m_frGrid, vPL)) return false ; // riporto nella corretta posizione le curve trovate - for ( auto& PL : vPL) + for ( auto& PL : vPL) { + if ( dLevel < dCalcLevel - EPS_SMALL) + PL.Translate( Vector3d{ 0, 0, dLevel - dCalcLevel}) ; PL.ToGlob( m_frGrid) ; + } return true ; } diff --git a/CAvSilhouetteSurfTm.h b/CAvSilhouetteSurfTm.h index 7a79076..3f4649e 100644 --- a/CAvSilhouetteSurfTm.h +++ b/CAvSilhouetteSurfTm.h @@ -36,6 +36,7 @@ class CAvParSilhouettesSurfTm : public ICAvParSilhouettesSurfTm double m_dTol ; int m_nStepX ; int m_nStepY ; + double m_dRad ; double m_dDimZ ; double m_dLevelOffs ; bool m_bGridOk ; diff --git a/CAvToolSurfTm.cpp b/CAvToolSurfTm.cpp index f4a56f0..0fcd4c2 100644 --- a/CAvToolSurfTm.cpp +++ b/CAvToolSurfTm.cpp @@ -121,7 +121,7 @@ CAvToolSurfTm::SetGenTool( const ICurveComposite* pToolOutline) //---------------------------------------------------------------------------- bool -CAvToolSurfTm::TestPosition( const Point3d& ptT, const Vector3d& vtDir, const Vector3d& vtMove, double& dTotDist) +CAvToolSurfTm::TestPosition( const Point3d& ptT, const Vector3d& vtDir, const Vector3d& vtMove, double& dTotDist) const { // Se utensile non definito, errore if ( m_Tool.GetType() == Tool::UNDEF) @@ -387,7 +387,7 @@ CAvToolSurfTm::TestSubPath( int nId, PNTULIST& lPntM, const Vector3d& vtDir, dou //---------------------------------------------------------------------------- bool CAvToolSurfTm::MyTestMidPointHG( PNTULIST& lPntM, const PNTULIST::iterator& itPntMPrev, const PNTULIST::iterator& itPntMCurr, - const Point3d& ptPrev, const Point3d& ptCurr, const Vector3d& vtDir, double dLinTol, int nLev) + const Point3d& ptPrev, const Point3d& ptCurr, const Vector3d& vtDir, double dLinTol, int nLev) const { // se superato limite di ricursione, esco const int MAX_LEV = 10 ; @@ -419,7 +419,7 @@ CAvToolSurfTm::MyTestMidPointHG( PNTULIST& lPntM, const PNTULIST::iterator& itPn //---------------------------------------------------------------------------- double -CAvToolSurfTm::MyTestPosition( Point3d& ptT, const Vector3d& vtDir, const Vector3d& vtMove) +CAvToolSurfTm::MyTestPosition( Point3d& ptT, const Vector3d& vtDir, const Vector3d& vtMove) const { double dTotDist = 0 ; for ( auto pStm : m_vSTM) { @@ -441,7 +441,7 @@ CAvToolSurfTm::MyTestPosition( Point3d& ptT, const Vector3d& vtDir, const Vector //---------------------------------------------------------------------------- double -CAvToolSurfTm::MyTestPositionHG( Point3d& ptT, const Vector3d& vtDir) +CAvToolSurfTm::MyTestPositionHG( Point3d& ptT, const Vector3d& vtDir) const { // calcolo box utensile nel riferimento di movimento BBox3d b3Tool ; @@ -520,7 +520,7 @@ CAvToolSurfTm::PrepareHashGrid( void) //---------------------------------------------------------------------------- int -CAvToolSurfTm::GetSurfInd( int nT) +CAvToolSurfTm::GetSurfInd( int nT) const { // verifico la presenza di almeno un intervallo if ( m_vBaseInd.size() < 2) diff --git a/CAvToolSurfTm.h b/CAvToolSurfTm.h index f13ff92..37201e9 100644 --- a/CAvToolSurfTm.h +++ b/CAvToolSurfTm.h @@ -36,7 +36,7 @@ class CAvToolSurfTm : public ICAvToolSurfTm { return m_Tool.GetHeigth() ; } const ICurveComposite& GetToolOutline( bool bApprox = false) const override { return ( bApprox ? m_Tool.GetApproxOutline() : m_Tool.GetOutline()) ;} - bool TestPosition( const Point3d& ptT, const Vector3d& vtDir, const Vector3d& vtMove, double& dTotDist) override ; + bool TestPosition( const Point3d& ptT, const Vector3d& vtDir, const Vector3d& vtMove, double& dTotDist) const override ; bool TestSeries( PNTUVECTOR& vPntM, const Vector3d& vtDir, const Vector3d& vtMove, double dProgCoeff = 1) override ; bool TestPath( PNTULIST& lPntM, const Vector3d& vtDir, const Vector3d& vtMove, double dLinTol, double dProgCoeff = 1) override ; @@ -47,12 +47,12 @@ class CAvToolSurfTm : public ICAvToolSurfTm private : bool TestSubSeries( int nId, PNTUVECTOR& vPntM, const Vector3d& vtDir, int nFirst, int nLast, double dProgCoeff) ; bool TestSubPath( int nId, PNTULIST& lPntM, const Vector3d& vtDir, double dLinTol, double dProgCoeff) ; - double MyTestPosition( Point3d& ptT, const Vector3d& vtDir, const Vector3d& vtMove) ; - double MyTestPositionHG( Point3d& ptT, const Vector3d& vtDir) ; + double MyTestPosition( Point3d& ptT, const Vector3d& vtDir, const Vector3d& vtMove) const ; + double MyTestPositionHG( Point3d& ptT, const Vector3d& vtDir) const ; bool MyTestMidPointHG( PNTULIST& lPntM, const PNTULIST::iterator& itPntMPrev, const PNTULIST::iterator& itPntMCurr, - const Point3d& ptPrev, const Point3d& ptCurr, const Vector3d& vtDir, double dLinTol, int nLev) ; + const Point3d& ptPrev, const Point3d& ptCurr, const Vector3d& vtDir, double dLinTol, int nLev) const ; bool PrepareHashGrid( void) ; - int GetSurfInd( int nT) ; + int GetSurfInd( int nT) const ; private : typedef std::vector CSURFTMPVECTOR ; // vettore di puntatori a const SurfTriMesh diff --git a/CalcPocketing.cpp b/CalcPocketing.cpp index 2f9c12d..3800841 100644 --- a/CalcPocketing.cpp +++ b/CalcPocketing.cpp @@ -592,7 +592,7 @@ ExistOpenEdges( ISurfFlatRegion* pSfr, const PocketParams& PockParam, bool& bExi //---------------------------------------------------- static bool ComputeTrapezoidSpiralLeadInLeadOut( ICurveComposite* pCompo, const Vector3d& vtMainDir, bool bLeadIn, - PocketParams PockParams, bool& bIsOutsideRaw) + const PocketParams& PockParams, bool& bIsOutsideRaw) { // inizializzazione come interno al grezzo bIsOutsideRaw = false ; @@ -648,7 +648,7 @@ ComputeTrapezoidSpiralLeadInLeadOut( ICurveComposite* pCompo, const Vector3d& vt //---------------------------------------------------- static bool -AdjustTrapezoidSpiralForLeadInLeadOut( ICurveComposite* pCompo, PocketParams PockParams) +AdjustTrapezoidSpiralForLeadInLeadOut( ICurveComposite* pCompo, const PocketParams& PockParams) { // recupero la direzione principale della svuotatura Vector3d vtMainDir ; @@ -675,8 +675,6 @@ AdjustTrapezoidSpiralForLeadInLeadOut( ICurveComposite* pCompo, PocketParams Poc return true ; } - - //---------------------------------------------------------------------------- static bool ExtendPathOnOpenEdge( ICurveComposite* pCrvPath, const PocketParams& PockParams, const Vector3d& vtN, @@ -1668,7 +1666,7 @@ SetSpecialPtStartForOpenEdges( const ICurveComposite* pCrvOrig, const Frame3d& f //---------------------------------------------------------------------------- static bool -AssignOpenCloseTmpPropToFirstOffsCurve( ICurveComposite* pCrv, const PocketParams PockParams, +AssignOpenCloseTmpPropToFirstOffsCurve( ICurveComposite* pCrv, const PocketParams& PockParams, ICRVCOMPOPOVECTOR& vCrvLoops, INTVECTOR& vIndex, bool& bSomeOpen) { // controllo dei parametri @@ -1742,7 +1740,7 @@ AssignOpenCloseTmpPropToFirstOffsCurve( ICurveComposite* pCrv, const PocketParam static bool SetPtStartForPath( ICurveComposite* pCrvOffsAct, const PocketParams& PockParams, const ISurfFlatRegion* pSrfToWork, const Point3d& ptEndPrec, const Frame3d& frPocket, Point3d& ptStart, - Vector3d& vtMidOut, bool& bMidOut, int nOffs, ICurveComposite* pCrvOrig) + Vector3d& vtMidOut, bool& bMidOut, int nOffs, const ICurveComposite* pCrvOrig) { // ============================= INFO ============================================================== // pCrvOffsAct -> Curva di Offset su cui cercare ptStart, vtMidOut, bMidOpen @@ -1909,7 +1907,7 @@ SetAdvancedPtStartForPath( ICRVCOMPOPOVECTOR& vCrvOffsAct, const PocketParams& P // cambio il suo punto d'inizio dell'Offset attuale if ( SetPtStartForPath( vCrvOffsAct[i], PockParams, pSrfToWork, ptEndPrec, frPocket, ptStart, vtMidOut, bMidOut, nOffs, - ( int( vCrvOrigChunkLoops.size()) < i) ? vCrvOrigChunkLoops[i]->Clone() : nullptr)) + ( int( vCrvOrigChunkLoops.size()) < i ? Get( vCrvOrigChunkLoops[i]) : nullptr))) vCrvOffsAct[i]->GetStartPoint( ptStart) ; else return false ; @@ -3767,9 +3765,9 @@ ModifyBiArc( ICurve* pBiArcLink, double dToll, ICurveComposite* pNewBiArc) //------------------------------------------------------------------------------ static bool -CalcBoundedSmootedLink( const Point3d& ptStart, const Vector3d& vtStart, const Point3d& ptEnd, - const Vector3d& vtEnd, double dParMeet, const ICRVCOMPOPOVECTOR& vOffIslands, - const PocketParams& PockParams, ICurveComposite* pCrvLink) +CalcBoundedSmoothedLink( const Point3d& ptStart, const Vector3d& vtStart, const Point3d& ptEnd, + const Vector3d& vtEnd, double dParMeet, const ICRVCOMPOPOVECTOR& vOffIslands, + const PocketParams& PockParams, ICurveComposite* pCrvLink) { // se senza smusso, ritorno tratto lineare if ( ! PockParams.bSmooth) @@ -3943,7 +3941,7 @@ CutCurveToConnect( ICurveComposite* pCrvS, ICurveComposite* pCrvE, const ICRVCOM // calcolo il BiArco PtrOwner ptBiArc( CreateBasicCurveComposite()) ; - if ( ! CalcBoundedSmootedLink( ptSE, vS, ptES, vE, 0.5, vFirstOffset, PockParams, ptBiArc) || + if ( ! CalcBoundedSmoothedLink( ptSE, vS, ptES, vE, 0.5, vFirstOffset, PockParams, ptBiArc) || ptBiArc->GetCurveCount() == 0) return false ; @@ -4309,7 +4307,7 @@ RemoveExtraPartByMedialAxis( const ISurfFlatRegion* pChunkToCut, ICRVCOMPOPOVECT if ( IsNull( pCrvLink)) return false ; - if ( ! CalcBoundedSmootedLink( ptS, vtS, ptE, vtE, 0.5, vOffsFirstCurve, PockParams, pCrvLink)) + if ( ! CalcBoundedSmoothedLink( ptS, vtS, ptE, vtE, 0.5, vOffsFirstCurve, PockParams, pCrvLink)) if ( ! CalcBoundedLink( ptS, ptE, vOffsFirstCurve, pCrvLink)) return false ; @@ -4318,8 +4316,8 @@ RemoveExtraPartByMedialAxis( const ISurfFlatRegion* pChunkToCut, ICRVCOMPOPOVECT } if ( ! AreSamePointEpsilon( ptEOriginal, ptSOriginal, EPS_SMALL) && - ! CalcBoundedSmootedLink( ptEOriginal, vtEOriginal, ptSOriginal, vtSOriginal, 0.5, vOffsFirstCurve, - PockParams, pCrvCoBackLink) && + ! CalcBoundedSmoothedLink( ptEOriginal, vtEOriginal, ptSOriginal, vtSOriginal, 0.5, vOffsFirstCurve, + PockParams, pCrvCoBackLink) && ! CalcBoundedLink( ptEOriginal, ptSOriginal, vOffsFirstCurve, pCrvCoBackLink)) return false ; @@ -4352,8 +4350,8 @@ RemoveExtraPartByMedialAxis( const ISurfFlatRegion* pChunkToCut, ICRVCOMPOPOVECT if ( IsNull( pCrvPath1)) return false ; - if ( ! CalcBoundedSmootedLink( ptClosestOnPath, vtTanCpt, vPtCentroid[i], vtTanCpt, 0, - vOffsFirstCurve, PockParams, pCrvPath1) && + if ( ! CalcBoundedSmoothedLink( ptClosestOnPath, vtTanCpt, vPtCentroid[i], vtTanCpt, 0, + vOffsFirstCurve, PockParams, pCrvPath1) && ! CalcBoundedLink( ptClosestOnPath, vPtCentroid[i], vOffsFirstCurve, pCrvPath1)) return false ; @@ -4619,7 +4617,7 @@ GetNewCurvetWithCentroid( const ICurveComposite* pCrvH1, const ICurveComposite* } // creo la circonferenza - if ( ! CalcBoundedSmootedLink( ptS, vtTanS, ptE, vtTanE, 0, VFirstOff, PockParams, pPath1)) + if ( ! CalcBoundedSmoothedLink( ptS, vtTanS, ptE, vtTanE, 0, VFirstOff, PockParams, pPath1)) return false ; Vector3d vtS_cir ; pPath1->GetStartDir( vtS_cir) ; Vector3d vtS_CrvH1 ; pCrvH1->GetEndDir( vtS_CrvH1) ; @@ -4664,8 +4662,8 @@ GetNewCurvetWithCentroid( const ICurveComposite* pCrvH1, const ICurveComposite* } // creo i due Biarchi - if ( ! CalcBoundedSmootedLink( ptS, vtTanS, ptE, vtTanS, 0.5, VFirstOff, PockParams, pPath1) || - ! CalcBoundedSmootedLink( ptE, vtTanS, ptS, vtTanS, 0.5, VFirstOff, PockParams, pPath2)) + if ( ! CalcBoundedSmoothedLink( ptS, vtTanS, ptE, vtTanS, 0.5, VFirstOff, PockParams, pPath1) || + ! CalcBoundedSmoothedLink( ptE, vtTanS, ptS, vtTanS, 0.5, VFirstOff, PockParams, pPath2)) return false ; // creo la nuova curva con il doppio Biarco @@ -4817,10 +4815,10 @@ GetNewCurvetWithPath( const ICurveComposite* pCrvH1, const ICurveComposite* pCrv } // creo i due Biarchi - if ( ! CalcBoundedSmootedLink( ptS, vtTanS, ptE, vtTanE, 0.5, VFirstOff, PockParams, pPath1)) + if ( ! CalcBoundedSmoothedLink( ptS, vtTanS, ptE, vtTanE, 0.5, VFirstOff, PockParams, pPath1)) if ( ! CalcBoundedLink( ptS, ptE, VFirstOff, pPath1)) return false ; - if ( ! CalcBoundedSmootedLink( ptH, vtH, ptS, vtTanS, 0.5, VFirstOff, PockParams, pPath2)) + if ( ! CalcBoundedSmoothedLink( ptH, vtH, ptS, vtTanS, 0.5, VFirstOff, PockParams, pPath2)) if ( ! CalcBoundedLink( ptH, ptS, VFirstOff, pPath2)) return false ; @@ -4850,7 +4848,7 @@ GetNewCurvetWithPath( const ICurveComposite* pCrvH1, const ICurveComposite* pCrv pCrvToAdd->GetStartPoint( ptHE) ; pCrvToAdd->GetStartDir( vtHE) ; PtrOwner pCrvBiArcHelper( CreateCurveComposite()) ; - if ( ! CalcBoundedSmootedLink( ptHS, vtHS, ptHE, vtHE, 0.5, VFirstOff, PockParams, pCrvBiArcHelper)) + if ( ! CalcBoundedSmoothedLink( ptHS, vtHS, ptHE, vtHE, 0.5, VFirstOff, PockParams, pCrvBiArcHelper)) if ( ! CalcBoundedLink( ptHS, ptHE, VFirstOff, pCrvBiArcHelper)) return false ; @@ -4870,7 +4868,7 @@ GetNewCurvetWithPath( const ICurveComposite* pCrvH1, const ICurveComposite* pCrv pCrvH2->GetStartPoint( ptHE) ; pCrvH2->GetStartDir( vtHE) ; PtrOwner pCrvBiArcHelper( CreateCurveComposite()) ; - if ( ! CalcBoundedSmootedLink( ptHS, vtHS, ptHE, vtHE, 0.5, VFirstOff, PockParams, pCrvBiArcHelper)) + if ( ! CalcBoundedSmoothedLink( ptHS, vtHS, ptHE, vtHE, 0.5, VFirstOff, PockParams, pCrvBiArcHelper)) if ( ! CalcBoundedLink( ptHS, ptHE, VFirstOff, pCrvBiArcHelper) ) return false ; @@ -5258,7 +5256,7 @@ CreateSpiralPocketingPath( ICRVCOMPOPOVECTOR& vOffs, ICURVEPOVECTOR& vLinks, con if ( ! vOffs[i]->GetStartDir( vtS) || ! vOffs[i+1]->GetStartDir( vtE)) return false ; // creo il bi-arco tra esse - if ( CalcBoundedSmootedLink( ptS, vtS, ptStartNext, vtE, 0.5, vOffsFirstCurve, PockParams, pCrvLink)) + if ( CalcBoundedSmoothedLink( ptS, vtS, ptStartNext, vtE, 0.5, vOffsFirstCurve, PockParams, pCrvLink)) vLinks[i + 1].Set( pCrvLink) ; // aggiorno il collegamento else return false ; @@ -5285,9 +5283,7 @@ CreateSpiralPocketingPath( ICRVCOMPOPOVECTOR& vOffs, ICURVEPOVECTOR& vLinks, con // aggiorno il collegamento vLinks[i+1].Set( Release( pCrvLink)) ; - } - } return true ; @@ -5418,7 +5414,7 @@ CalcSpiral( const ISurfFlatRegion* pSrfPock, const PocketParams& PockParams, int bool bIsCircle = false ; if ( ! OptimizedSpiralCirle( pCrvBorder, 50 * EPS_SMALL, dRad, ptCen, bIsCircle)) return false ; - if ( bIsCircle) { + if ( bIsCircle && dRad - dOffs > 10 * EPS_SMALL) { double dIntRad = 0 ; if ( nReg == 0) { bool bOk = CalcCircleSpiral( ptCen, vtN, dRad - dOffs, dIntRad, PockParams, pMCrv, pRCrv) ; @@ -5459,7 +5455,6 @@ CalcSpiral( const ISurfFlatRegion* pSrfPock, const PocketParams& PockParams, int else return true ; } - } // porto la superficie nel frame corrente @@ -6202,9 +6197,7 @@ AddSpiralIn( const ISurfFlatRegion* pSrfPock, const ISurfFlatRegion* pSfrOrig, // inserisco le curve nel vettore vCrvCompoRes.emplace_back( Release( pMCrv)) ; ++ nReg ; // incremento il numero di regione progressiva - } - } return true ;