diff --git a/CAvSilhouetteSurfTm.cpp b/CAvSilhouetteSurfTm.cpp index e69965d..7c685ba 100644 --- a/CAvSilhouetteSurfTm.cpp +++ b/CAvSilhouetteSurfTm.cpp @@ -12,9 +12,8 @@ //---------------------------------------------------------------------------- #include "stdafx.h" -#include "CAvToolSurfTm.h" +#include "CAvSilhouetteSurfTm.h" #include "GeoConst.h" -#include "/EgtDev/Include/EGkCAvSilhouetteSurfTm.h" #include "/EgtDev/Include/EGkChainCurves.h" #include "/EgtDev/Include/EGkOffsetCurve.h" @@ -37,14 +36,46 @@ using namespace std ; //---------------------------------------------------------------------------- static Point3d -CalcPoint( const Point3d& ptS, const Point3d& ptE, double dLevel) +CalcPoint( const Point3d& ptS, const Point3d& ptE, double dLevel, + const ICAvToolSurfTm& cavTstm, const Frame3d &frGrid) { - return Media( ptS, ptE, ( ptS.z - dLevel) / ( ptS.z - ptE.z)) ; + // Distanza tra gli estremi iniziali + 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 ; + int nCount = 0 ; + Point3d ptP1 = ptS ; + Point3d ptP2 = ptE ; + Point3d ptMid = Media( ptP1, ptP2) ; + while ( nCount < MAX_ITER) { + // verifica del punto medio + ptMid.z = 0 ; + Point3d ptTest = GetToGlob( ptMid + cavTstm.GetToolHeight() * Z_AX, frGrid) ; + double dMove ; + const_cast( &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) + 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) ; + bool bMidOn = ( ptMid.z > dLevel) ; + if ( b1On != bMidOn) + ptP2 = ptMid ; + else + ptP1 = ptMid ; + ptMid = Media( ptP1, ptP2) ; + ++ nCount ; + } + ptMid.z = dLevel ; + return ptMid ; } //---------------------------------------------------------------------------- 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) { static int LineTable[16][5] = { { 0, -1, -1, -1, -1}, @@ -73,20 +104,20 @@ ProcessSquare( int nFlag, const Point3d ptP[4], double dLevel, 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) ; - ptL1e = CalcPoint( ptP[nI1e], ptP[( nI1e + 1) % 4], dLevel) ; + 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) ; } // 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) ; - ptL1e = CalcPoint( ptP[nI1e], ptP[( nI1e + 1) % 4], dLevel) ; + 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) ; - ptL2e = CalcPoint( ptP[nI2e], ptP[( nI2e + 1) % 4], dLevel) ; + ptL2s = CalcPoint( ptP[nI2s], ptP[( nI2s + 1) % 4], dLevel, cavTstm, frGrid) ; + ptL2e = CalcPoint( ptP[nI2e], ptP[( nI2e + 1) % 4], dLevel, cavTstm, frGrid) ; return 2 ; } return -1 ; @@ -94,7 +125,8 @@ ProcessSquare( int nFlag, const Point3d ptP[4], double dLevel, //---------------------------------------------------------------------------- static bool -MarchingSquares( const DBLVECTOR& vdGrid, int nStepX, int nStepY, double dStep, double dLevel, POLYLINEVECTOR& vPL) +MarchingSquares( const DBLVECTOR& vdGrid, int nStepX, int nStepY, double dStep, double dLevel, + const ICAvToolSurfTm& cavTstm, const Frame3d &frGrid, POLYLINEVECTOR& vPL) { // Predispongo il concatenamento BIPNTVECTOR vBiPnt ; @@ -121,7 +153,7 @@ MarchingSquares( const DBLVECTOR& vdGrid, int nStepX, int nStepY, double dStep, { i * dStep, ( j + 1) * dStep, vdGrid[nInd3]}} ; // calcolo segmenti da inserire Point3d ptL1s, ptL1e, ptL2s, ptL2e ; - int nSegCnt = ProcessSquare( nFlag, ptP, dLevel, ptL1s, ptL1e, ptL2s, ptL2e) ; + int nSegCnt = ProcessSquare( nFlag, ptP, dLevel, cavTstm, frGrid, ptL1s, ptL1e, ptL2s, ptL2e) ; if ( nSegCnt == -1) return false ; else if ( nSegCnt == 1) { @@ -159,13 +191,13 @@ MarchingSquares( const DBLVECTOR& vdGrid, int nStepX, int nStepY, double dStep, vPL.emplace_back( PolyLine()) ; crvCompo.ApproxWithLines( 0, 0, ICurve::APL_SPECIAL, vPL.back()) ; #else - // eseguo offset a sinistra pari a metà step + // eseguo offset a sinistra pari allo step OffsetCurve offsCompo ; - offsCompo.Make( &crvCompo, -0.5 * dStep, ICurve::OFF_CHAMFER) ; + offsCompo.Make( &crvCompo, -( dStep - 10 * EPS_SMALL), ICurve::OFF_CHAMFER) ; PtrOwner pCrvOffset( offsCompo.GetLongerCurve()) ; if ( ! IsNull( pCrvOffset)) { vPL.emplace_back( PolyLine()) ; - pCrvOffset->ApproxWithLines( 0.1 * dStep, ANG_TOL_APPROX_DEG, ICurve::APL_STD, vPL.back()) ; + pCrvOffset->ApproxWithLines( 10 * EPS_SMALL, ANG_TOL_STD_DEG, ICurve::APL_STD, vPL.back()) ; } #endif } @@ -173,6 +205,7 @@ MarchingSquares( const DBLVECTOR& vdGrid, int nStepX, int nStepY, double dStep, return true ; } + //---------------------------------------------------------------------------- // Silhouette rispetto ad una direzione e sopra una quota di una superficie TriMesh // ( dTol è il passo della griglia di campionamento e il raggio del cilindro di prova) @@ -194,32 +227,30 @@ CAvSilhouetteSurfTm( const ISurfTriMesh& Stm, const Plane3d& plPlane, double dTo vPL.clear() ; // sistema di riferimento nel piano - Frame3d frPlane ; - if ( ! frPlane.Set( plPlane.GetPoint(), plPlane.GetVersN())) + Frame3d frGrid ; + if ( ! frGrid.Set( plPlane.GetPoint(), plPlane.GetVersN())) return false ; // bounding box della superficie nel riferimento del piano BBox3d b3Surf ; - if ( ! Stm.GetBBox( GetInvert( frPlane), b3Surf, BBF_STANDARD)) + if ( ! Stm.GetBBox( GetInvert( frGrid), b3Surf, BBF_STANDARD)) return false ; // calcolo dati della griglia const double EXTRA_XY = 1.5 * dTol ; - const double EXTRA_Z = 10 ; + const double EXTRA_Z = 10 * dTol ; b3Surf.Expand( EXTRA_XY, EXTRA_XY, EXTRA_Z) ; - Point3d ptOrig = GetToGlob( b3Surf.GetMin(), frPlane) ; - Vector3d vtAxX = frPlane.VersX() ; - Vector3d vtAxY = frPlane.VersY() ; - Vector3d vtAxZ = frPlane.VersZ() ; int nStepX = int( ceil( b3Surf.GetDimX() / dTol)) ; int nStepY = int( ceil( b3Surf.GetDimY() / dTol)) ; + frGrid.ChangeOrig( GetToGlob( b3Surf.GetMin(), frGrid)) ; double dDimZ = b3Surf.GetDimZ() ; + double dLevelOffs = - b3Surf.GetMin().z ; // calcolo dei punti della griglia (sul top del cilindro) PNTUVECTOR vPntM( ( nStepX + 1) * ( nStepY + 1)) ; for ( int j = 0 ; j <= nStepY ; ++ j) { for ( int i = 0 ; i <= nStepX ; ++ i) { int nInd = i + j * ( nStepX + 1) ; - Point3d ptP = ptOrig + i * dTol * vtAxX + j * dTol * vtAxY + dDimZ * vtAxZ ; + Point3d ptP = GetToGlob( Point3d( i * dTol, j * dTol, dDimZ), frGrid) ; vPntM[nInd] = { ptP, 0.} ; } } @@ -228,46 +259,58 @@ CAvSilhouetteSurfTm( const ISurfTriMesh& Stm, const Plane3d& plPlane, double dTo CAvToolSurfTm cavTstm ; cavTstm.SetStdTool( dDimZ, dTol, 0) ; cavTstm.SetSurfTm( Stm) ; - if ( ! cavTstm.TestSeries( vPntM, vtAxZ, vtAxZ, -1)) + if ( ! cavTstm.TestSeries( vPntM, frGrid.VersZ(), frGrid.VersZ(), -1)) return false ; - // riporto i punti sul tip del cilindro - for ( auto& PntU : vPntM) - PntU.first -= dDimZ * vtAxZ ; - // griglia degli spostamenti DBLVECTOR vdGrid( ( nStepX + 1) * ( nStepY + 1)) ; for ( int j = 0 ; j <= nStepY ; ++ j) { for ( int i = 0 ; i <= nStepX ; ++ i) { int nInd = i + j * ( nStepX + 1) ; - vdGrid[nInd] = -vPntM[nInd].second ; + vdGrid[nInd] = vPntM[nInd].second ; } } // calcolo della silhouette con il metodo MarchingSquares - double dLevel = -b3Surf.GetMin().z ; - if ( ! MarchingSquares( vdGrid, nStepX, nStepY, dTol, dLevel, vPL)) + double dLevel = dLevelOffs ; + if ( ! MarchingSquares( vdGrid, nStepX, nStepY, dTol, dLevel, cavTstm, frGrid, vPL)) return false ; // riporto nella corretta posizione le curve trovate - for ( auto& PL : vPL) { - PL.Translate( b3Surf.GetMin() - ORIG) ; - PL.ToGlob( frPlane) ; - } + for ( auto& PL : vPL) + PL.ToGlob( frGrid) ; return true ; } + +//---------------------------------------------------------------------------- +ICAvParSilhouettesSurfTm* +CreateCAvParSilhouettesSurfTm( void) +{ + return static_cast ( new(nothrow) CAvParSilhouettesSurfTm) ; +} + //---------------------------------------------------------------------------- // Silhouette rispetto ad una direzione e sopra diverse quote di una superficie TriMesh //---------------------------------------------------------------------------- -CAvParSilhouettesSurfTm::CAvParSilhouettesSurfTm( const CISURFTMPVECTOR& vpStm, const Frame3d& frPlanes, double dTol) +CAvParSilhouettesSurfTm::CAvParSilhouettesSurfTm( void) + : m_dTol( 100 * EPS_SMALL), m_nStepX( 0), m_nStepY( 0), m_dLevelOffs( 0), m_bGridOk( false) +{ +} + +//---------------------------------------------------------------------------- +bool +CAvParSilhouettesSurfTm::SetData( const CISURFTMPVECTOR& vpStm, const Frame3d& frPlanes, double dTol) { m_vpStm = vpStm ; - m_frPlanes = frPlanes ; + m_frGrid = frPlanes ; m_dTol = max( dTol, 100 * EPS_SMALL) ; m_nStepX = 0 ; m_nStepY = 0 ; + m_dDimZ = 0 ; + m_dLevelOffs = 0 ; m_bGridOk = false ; + return true ; } //---------------------------------------------------------------------------- @@ -276,7 +319,7 @@ CAvParSilhouettesSurfTm::Prepare( void) { // ingombro delle superfici nel riferimento dei piani BBox3d b3All ; - Frame3d frInv = GetInvert( m_frPlanes) ; + Frame3d frInv = GetInvert( m_frGrid) ; for ( auto pStm : m_vpStm) { BBox3d b3Surf ; if ( ! pStm->GetBBox( frInv, b3Surf, BBF_STANDARD)) @@ -286,49 +329,41 @@ CAvParSilhouettesSurfTm::Prepare( void) // calcolo dati della griglia const double EXTRA_XY = 1.5 * m_dTol ; - const double EXTRA_Z = 10 ; + const double EXTRA_Z = 10 * m_dTol ; b3All.Expand( EXTRA_XY, EXTRA_XY, EXTRA_Z) ; - Point3d ptOrig = GetToGlob( b3All.GetMin(), m_frPlanes) ; - Vector3d vtAxX = m_frPlanes.VersX() ; - Vector3d vtAxY = m_frPlanes.VersY() ; - Vector3d vtAxZ = m_frPlanes.VersZ() ; m_nStepX = int( ceil( b3All.GetDimX() / m_dTol)) ; m_nStepY = int( ceil( b3All.GetDimY() / m_dTol)) ; - m_vtMove = b3All.GetMin() - ORIG ; - double dDimZ = b3All.GetDimZ() ; + m_frGrid.ChangeOrig( GetToGlob( b3All.GetMin(), m_frGrid)) ; + m_dDimZ = b3All.GetDimZ() ; + m_dLevelOffs = - b3All.GetMin().z ; // calcolo dei punti della griglia (sul top del cilindro) PNTUVECTOR vPntM( ( m_nStepX + 1) * ( m_nStepY + 1)) ; for ( int j = 0 ; j <= m_nStepY ; ++ j) { for ( int i = 0 ; i <= m_nStepX ; ++ i) { int nInd = i + j * ( m_nStepX + 1) ; - Point3d ptP = ptOrig + i * m_dTol * vtAxX + j * m_dTol * vtAxY + dDimZ * vtAxZ ; + Point3d ptP = GetToGlob( Point3d( i * m_dTol, j * m_dTol, m_dDimZ), m_frGrid) ; vPntM[nInd] = { ptP, 0.} ; } } // esecuzione della verifica - CAvToolSurfTm cavTstm ; - if ( ! cavTstm.SetStdTool( dDimZ, m_dTol, 0)) + if ( ! m_cavTstm.SetStdTool( m_dDimZ, m_dTol, 0)) return false ; - if ( m_vpStm.empty() || ! cavTstm.SetSurfTm( *( m_vpStm[0]))) + if ( m_vpStm.empty() || ! m_cavTstm.SetSurfTm( *( m_vpStm[0]))) return false ; for ( int k = 1 ; k < int( m_vpStm.size()) ; ++ k) - cavTstm.AddSurfTm( *( m_vpStm[k])) ; - if ( ! cavTstm.TestSeries( vPntM, vtAxZ, vtAxZ, -1)) + m_cavTstm.AddSurfTm( *( m_vpStm[k])) ; + if ( ! m_cavTstm.TestSeries( vPntM, m_frGrid.VersZ(), m_frGrid.VersZ(), -1)) return false ; - // riporto i punti sul tip del cilindro - for ( auto& PntU : vPntM) - PntU.first -= dDimZ * vtAxZ ; - // griglia degli spostamenti m_vdGrid.clear() ; m_vdGrid.resize( ( m_nStepX + 1) * ( m_nStepY + 1)) ; for ( int j = 0 ; j <= m_nStepY ; ++ j) { for ( int i = 0 ; i <= m_nStepX ; ++ i) { int nInd = i + j * ( m_nStepX + 1) ; - m_vdGrid[nInd] = -vPntM[nInd].second ; + m_vdGrid[nInd] = vPntM[nInd].second ; } } @@ -348,13 +383,11 @@ CAvParSilhouettesSurfTm::GetSilhouette( double dLevel, POLYLINEVECTOR& vPL) m_bGridOk = true ; // calcolo della silhouette con il metodo MarchingSquares - dLevel -= m_vtMove.z ; - if ( ! MarchingSquares( m_vdGrid, m_nStepX, m_nStepY, m_dTol, dLevel, vPL)) + dLevel += m_dLevelOffs ; + if ( ! MarchingSquares( m_vdGrid, m_nStepX, m_nStepY, m_dTol, dLevel, m_cavTstm, m_frGrid, vPL)) return false ; // riporto nella corretta posizione le curve trovate - for ( auto& PL : vPL) { - PL.Translate( m_vtMove) ; - PL.ToGlob( m_frPlanes) ; - } + for ( auto& PL : vPL) + PL.ToGlob( m_frGrid) ; return true ; } diff --git a/CAvSilhouetteSurfTm.h b/CAvSilhouetteSurfTm.h index b280f07..7a79076 100644 --- a/CAvSilhouetteSurfTm.h +++ b/CAvSilhouetteSurfTm.h @@ -1,7 +1,7 @@ //---------------------------------------------------------------------------- // EgalTech 2024-2024 //---------------------------------------------------------------------------- -// File : CAvSilhouetteSurfTm.h Data : 10.06.24 Versione : 2.6f2 +// File : CAvSilhouetteSurfTm.h Data : 16.06.24 Versione : 2.6f2 // Contenuto : Dichiarazione della classe calcolo multi-silhouette. // // @@ -20,16 +20,24 @@ class CAvParSilhouettesSurfTm : public ICAvParSilhouettesSurfTm { public : - bool SetSurfTm( const ISurfTriMesh& Stm) override ; - bool AddSurfTm( const ISurfTriMesh& Stm) override ; - bool Calculate( const Frame3d& frPlanes, double dTol) override ; + bool SetData( const CISURFTMPVECTOR& vpStm, const Frame3d& frPlanes, double dTol) override ; bool GetSilhouette( double dLevel, POLYLINEVECTOR& vPL) override ; public : CAvParSilhouettesSurfTm( void) ; private : - bool m_bOk ; - const Frame3d m_frPlanes ; - CAvToolSurfTm m_cavTstm ; + bool Prepare( void) ; + + private : + CISURFTMPVECTOR m_vpStm ; + CAvToolSurfTm m_cavTstm ; + Frame3d m_frGrid ; + double m_dTol ; + int m_nStepX ; + int m_nStepY ; + double m_dDimZ ; + double m_dLevelOffs ; + bool m_bGridOk ; + DBLVECTOR m_vdGrid ; } ; \ No newline at end of file diff --git a/CAvToolSurfTm.cpp b/CAvToolSurfTm.cpp index 6a07cd3..f4a56f0 100644 --- a/CAvToolSurfTm.cpp +++ b/CAvToolSurfTm.cpp @@ -37,10 +37,29 @@ CreateCAvToolSurfTm( void) // CAvToolSurfTm //---------------------------------------------------------------------------- CAvToolSurfTm::CAvToolSurfTm( void) - : m_Tool( false) + : m_frMove( false), m_Tool( false) { } +//---------------------------------------------------------------------------- +bool +CAvToolSurfTm::Clear( void) +{ + // pulisco la lista dei puntatori a Stm + m_vSTM.clear() ; + // pulisco e inizializzo la prima posizione della lista delle basi per gli indici dei triangoli + m_vBaseInd.clear() ; + m_vBaseInd.emplace_back( 0) ; + // pulisco HashGrid 2d + m_HGrids.Clear() ; + // reset utensile + m_Tool.Clear() ; + // reset riferimento + m_frMove.Reset() ; + + return true ; +} + //---------------------------------------------------------------------------- bool CAvToolSurfTm::SetSurfTm( const ISurfTriMesh& Stm) @@ -50,6 +69,9 @@ CAvToolSurfTm::SetSurfTm( const ISurfTriMesh& Stm) // pulisco e inizializzo la prima posizione della lista delle basi per gli indici dei triangoli m_vBaseInd.clear() ; m_vBaseInd.emplace_back( 0) ; + // pulisco HashGrid 2d + m_HGrids.Clear() ; + // non tocco l'utensile // aggiungo la superficie return AddSurfTm( Stm) ; } @@ -107,14 +129,25 @@ CAvToolSurfTm::TestPosition( const Point3d& ptT, const Vector3d& vtDir, const Ve // Se direzioni non definite, errore if ( vtDir.IsSmall() || vtMove.IsSmall()) return false ; - // Imposto il riferimento di movimento - if ( ! AreSameOrOppositeVectorApprox( vtDir, vtMove)) - m_frMove.Set( ORIG, vtMove, vtDir) ; - else - m_frMove.Set( ORIG, vtMove) ; - // Eseguo controllo + // Se riferimento di movimento già presente + if ( m_frMove.IsValid()) { + // Calcolo nuovo riferimento di movimento + Frame3d frMove ; + if ( ! AreSameOrOppositeVectorApprox( vtDir, vtMove)) + frMove.Set( ORIG, vtMove, vtDir) ; + else + frMove.Set( ORIG, vtMove) ; + // Se riferimenti di movimento uguali, sfrutto HashGrid 2d + if ( AreSameFrame( frMove, m_frMove)) { + // Eseguo controllo + Point3d ptCurr = ptT ; + dTotDist = MyTestPositionHG( ptCurr, vtDir) ; + return ( dTotDist > - EPS_SMALL) ; + } + } + // Altrimenti eseguo controllo diretto Point3d ptCurr = ptT ; - dTotDist = MyTestPosition( ptCurr, vtDir) ; + dTotDist = MyTestPosition( ptCurr, vtDir, vtMove) ; return ( dTotDist > - EPS_SMALL) ; } @@ -186,8 +219,6 @@ CAvToolSurfTm::TestSeries( PNTUVECTOR& vPntM, const Vector3d& vtDir, const Vecto } ProcessEvents( int( 100 * dProgCoeff), 0) ; } - // pulisco HashGrid 2d - m_HGrids.Clear() ; return bOk ; } @@ -202,7 +233,7 @@ CAvToolSurfTm::TestSubSeries( int nId, PNTUVECTOR& vPntM, const Vector3d& vtDir, for ( int i = nFirst ; i <= nLast ; ++ i) { // verifico il punto double dMove = MyTestPositionHG( vPntM[i].first, vtDir) ; - vPntM[i].second = - dMove ; + vPntM[i].second = dMove ; if ( dMove < - EPS_SMALL) return false ; ++ m_nCurrPnt ; @@ -305,8 +336,6 @@ CAvToolSurfTm::TestPath( PNTULIST& lPntM, const Vector3d& vtDir, const Vector3d& } ProcessEvents( int( 100 * dProgCoeff), 0) ; } - // pulisco HashGrid 2d - m_HGrids.Clear() ; return bOk ; } @@ -325,7 +354,7 @@ CAvToolSurfTm::TestSubPath( int nId, PNTULIST& lPntM, const Vector3d& vtDir, dou // verifico il punto ptCurr = itPntMCurr->first ; double dMove = MyTestPositionHG( itPntMCurr->first, vtDir) ; - itPntMCurr->second = - dMove ; + itPntMCurr->second = dMove ; if ( dMove < - EPS_SMALL) return false ; // se esiste il punto precedente e richiesto devo verificare il medio @@ -377,7 +406,7 @@ CAvToolSurfTm::MyTestMidPointHG( PNTULIST& lPntM, const PNTULIST::iterator& itPn if ( abs(( Media( itPntMPrev->first, itPntMCurr->first, 0.5) - ptNewMid) * m_frMove.VersZ()) > 0.5 * dLinTol || SqDist( itPntMPrev->first, itPntMCurr->first) > dMaxSqDist) { // aggiungo - lPntM.emplace( itPntMCurr, ptNewMid, - dMidMove) ; + lPntM.emplace( itPntMCurr, ptNewMid, dMidMove) ; auto itPntMMid = itPntMCurr ; -- itPntMMid ; // verifico intervallo precedente @@ -390,7 +419,7 @@ CAvToolSurfTm::MyTestMidPointHG( PNTULIST& lPntM, const PNTULIST::iterator& itPn //---------------------------------------------------------------------------- double -CAvToolSurfTm::MyTestPosition( Point3d& ptT, const Vector3d& vtDir) +CAvToolSurfTm::MyTestPosition( Point3d& ptT, const Vector3d& vtDir, const Vector3d& vtMove) { double dTotDist = 0 ; for ( auto pStm : m_vSTM) { @@ -398,12 +427,12 @@ CAvToolSurfTm::MyTestPosition( Point3d& ptT, const Vector3d& vtDir) for ( int nTria = pStm->GetFirstTriangle( Tria) ; nTria != SVT_NULL ; nTria = pStm->GetNextTriangle( nTria, Tria)) { - double dDist = CAvToolTriangle( m_Tool, ptT, vtDir, Tria, m_frMove.VersZ()) ; + double dDist = CAvToolTriangle( m_Tool, ptT, vtDir, Tria, vtMove) ; if ( dDist < - EPS_SMALL) return -1 ; if ( dDist > EPS_SMALL) { dTotDist += dDist ; - ptT += dDist * m_frMove.VersZ() ; + ptT += dDist * vtMove ; } } } diff --git a/CAvToolSurfTm.h b/CAvToolSurfTm.h index c618651..f13ff92 100644 --- a/CAvToolSurfTm.h +++ b/CAvToolSurfTm.h @@ -42,11 +42,12 @@ class CAvToolSurfTm : public ICAvToolSurfTm public : CAvToolSurfTm( void) ; + bool Clear( void) ; 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) ; + double MyTestPosition( Point3d& ptT, const Vector3d& vtDir, const Vector3d& vtMove) ; double MyTestPositionHG( Point3d& ptT, const Vector3d& vtDir) ; 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) ; diff --git a/CalcPocketing.cpp b/CalcPocketing.cpp index 76369e6..78469a9 100644 --- a/CalcPocketing.cpp +++ b/CalcPocketing.cpp @@ -1669,10 +1669,10 @@ SetSpecialPtStartForOpenEdges( const ICurveComposite* pCrvOrig, const Frame3d& f // se il punto trovato è a cavallo tra due curve... if ( abs( dU_check - floor( dU_check)) < EPS_PARAM || abs( dU_check - ceil( dU_check)) < EPS_PARAM) { - const ICurve* pCrvA = pCrvCompo->GetCurve( floor( dU_check)) ; + const ICurve* pCrvA = pCrvCompo->GetCurve( int( floor( dU_check))) ; if ( pCrvA == nullptr) return false ; - const ICurve* pCrvB = pCrvCompo->GetCurve( ceil( dU_check)) ; + const ICurve* pCrvB = pCrvCompo->GetCurve( int( ceil( dU_check))) ; if ( pCrvB == nullptr) return false ; if ( pCrvA->GetTempProp( 0) == 0 || pCrvB->GetTempProp( 0) == 1) @@ -1680,7 +1680,7 @@ SetSpecialPtStartForOpenEdges( const ICurveComposite* pCrvOrig, const Frame3d& f } // se invece tocca una sola curva, controllo che sia aperta else { - const ICurve* pCrvA = pCrvCompo->GetCurve( floor( dU_check)) ; + const ICurve* pCrvA = pCrvCompo->GetCurve( int( floor( dU_check))) ; if ( pCrvA == nullptr) return false ; if ( pCrvA->GetTempProp( 0) == 0) diff --git a/EgtGeomKernel.vcxproj b/EgtGeomKernel.vcxproj index 9d9ea9c..a1768f8 100644 --- a/EgtGeomKernel.vcxproj +++ b/EgtGeomKernel.vcxproj @@ -341,6 +341,7 @@ copy $(TargetPath) \EgtProg\Dll64 + diff --git a/EgtGeomKernel.vcxproj.filters b/EgtGeomKernel.vcxproj.filters index ba80006..d88555b 100644 --- a/EgtGeomKernel.vcxproj.filters +++ b/EgtGeomKernel.vcxproj.filters @@ -1217,6 +1217,9 @@ File di intestazione\Include + + File di intestazione +