From d8f72d02f7abda5dbf97d7dac5d7376a6eda0d9b Mon Sep 17 00:00:00 2001 From: SaraP Date: Wed, 16 Mar 2022 09:26:21 +0100 Subject: [PATCH] EgtMachKernel 2.4c1 : - in svuotatura a spirale ottimizzata per trapezoidi aggiunta rimozione di materiale residuo negli angoli. --- EgtMachKernel.rc | Bin 11774 -> 11774 bytes Pocketing.cpp | 358 ++++++++++++++++++++++++++++++++++++++--------- Pocketing.h | 6 +- 3 files changed, 293 insertions(+), 71 deletions(-) diff --git a/EgtMachKernel.rc b/EgtMachKernel.rc index 9881ec52bd59197682ec24c5c90550ab3244a4ed..f9e3306fb08ee5cf20dfedfd14e09e04a41f167f 100644 GIT binary patch delta 265 zcmewt{V#gMI%aiGhCGIJh8%`ehGHOAV9;O)W+-7u1ma8}FBB-731Uz7R&U)L$1;P7 z)tEtt!Ep0$Hfv_)WCp{@4<&Usr*ZYLz{M{zO+F!*hmaFOl0(ts!MJ&qv delta 260 zcmewt{V#gMI%aKGhCGIJh8%`WhGK>c1_cHUhESkLCPN8BDnkm89}HwAf_cT0IklxX ze_&=}W;J5aVX)ZzUhX2(p?RB diff --git a/Pocketing.cpp b/Pocketing.cpp index 40c6c0a..c3f09c5 100644 --- a/Pocketing.cpp +++ b/Pocketing.cpp @@ -3720,7 +3720,7 @@ Pocketing::CalcSpiral( const ICurveComposite* pCompo, int nReg, bool bSplitArcs, Point3d pt ; Vector3d vtB1, vtL1, vtB2 ; - if ( false && pCrvPocket->IsATrapezoid( 100 * EPS_SMALL, pt, vtB1, vtL1, vtB2)) { + if ( pCrvPocket->IsATrapezoid( 100 * EPS_SMALL, pt, vtB1, vtL1, vtB2)) { Vector3d vtDir( vtB1), vtOtherDir( vtL1) ; // se parallelogramma scelgo come base i lati lunghi Vector3d vtL2( -vtB1 + vtL1 + vtB2) ; @@ -3732,8 +3732,11 @@ Pocketing::CalcSpiral( const ICurveComposite* pCompo, int nReg, bool bSplitArcs, Vector3d vtOrtho = OrthoCompo( vtOtherDir, vtDir) ; double dPocketSize = vtOrtho.Len() ; if ( dPocketSize < m_TParams.m_dDiam + EPS_SMALL) { - if ( nReg == 0) - return CalcTrapezoidSpiral( pCrvPocket, vtDir, dPocketSize, pMCrv, pRCrv, bOptimizedTrap) ; + if ( nReg == 0) { + CalcTrapezoidSpiral( pCrvPocket, vtDir, dPocketSize, pMCrv, pRCrv, bOptimizedTrap) ; + if ( bOptimizedTrap) + return true ; + } else return true ; } @@ -4097,7 +4100,7 @@ Pocketing::CalcCircleSpiral( const Point3d& ptCen, const Vector3d& vtN, double d bool Pocketing::CalcTrapezoidSpiral( ICurveComposite * pCrvPocket, const Vector3d& vtDir, double dPocketSize, ICurveComposite * pMCrv, ICurveComposite * pRCrv, bool& bOptimizedTrap) -{ +{ Vector3d vtExtr ; pCrvPocket->GetExtrusion( vtExtr) ; // eventuale approssimazione della curva con polyline per ottenere la stessa curva calcolata in ICurveComposite::IsATrapezoid if ( pCrvPocket->GetCurveCount() > 4) { @@ -4122,40 +4125,58 @@ Pocketing::CalcTrapezoidSpiral( ICurveComposite * pCrvPocket, const Vector3d& vt return false ; pCrvPocket->ToLoc( frLoc) ; - int nProp0 = 0, nProp1 = 0, nProp3 = 0 ; - pCrvPocket->GetCurveTempProp( 0, nProp0) ; - pCrvPocket->GetCurveTempProp( 1, nProp1) ; - pCrvPocket->GetCurveTempProp( 3, nProp3) ; + INTVECTOR vnProp( 4, 0) ; + for ( int i = 0 ; i < 4 ; i++) + pCrvPocket->GetCurveTempProp( i, vnProp[i]) ; + // verifico le dimensioni della svuotatura - if ( ! nProp0 && abs( dPocketSize - m_TParams.m_dDiam) > EPS_SMALL) + if ( ! vnProp[0] && abs( dPocketSize - m_TParams.m_dDiam) > EPS_SMALL) return false ; + if ( ! vnProp[1] && ! vnProp[3]) { + double dLen0 = 0, dLen2 = 0 ; + pCrvPocket->GetCurve( 0)->GetLength( dLen0) ; + pCrvPocket->GetCurve( 2)->GetLength( dLen2) ; + if ( dLen0 < m_TParams.m_dDiam + EPS_SMALL || dLen2 < m_TParams.m_dDiam + EPS_SMALL) + return false ; + } // calcolo percorso di svuotatura double dYCoord = dPocketSize - 0.5 * m_TParams.m_dDiam ; - if ( nProp0) - dYCoord -= GetOffsR() ; + if ( vnProp[0]) + dYCoord -= GetOffsR() ; + if ( vnProp[0] && vnProp[2]) + dYCoord = 0.5 * dPocketSize ; // se entrambi i lati paralleli sono aperti mi posiziono a metà della svuotatura + double dXCoordStart, dXCoordEnd ; - if ( ! CalcTrapezoidSpiralXCoord( pCrvPocket, true, dYCoord, dXCoordStart)) + if ( ! CalcTrapezoidSpiralXCoord( pCrvPocket, true, dYCoord, dXCoordStart, dPocketSize)) return false ; - if ( ! CalcTrapezoidSpiralXCoord( pCrvPocket, false, dYCoord, dXCoordEnd)) + if ( ! CalcTrapezoidSpiralXCoord( pCrvPocket, false, dYCoord, dXCoordEnd, dPocketSize)) return false ; - Point3d ptStart( dXCoordStart, dYCoord) ; + if ( dXCoordStart > dXCoordEnd) + return false ; + Point3d ptStart( dXCoordStart, dYCoord) ; Point3d ptEnd( dXCoordEnd, dYCoord) ; - PtrOwner pLine( CreateCurveLine()) ; - if ( IsNull( pLine)) - return false ; - pLine->Set( ptStart, ptEnd) ; + pMCrv->AddPoint( ptStart) ; + pMCrv->AddLine( ptEnd) ; + + // aggiustamenti al percorso per rimuovere materiale residuo negli angoli + if ( vnProp[0]) { + if ( ! vnProp[3]) + AdjustTrapezoidSpiralForAngles( pMCrv, pCrvPocket, true) ; + if ( ! vnProp[1]) + AdjustTrapezoidSpiralForAngles( pMCrv, pCrvPocket, false) ; + } - pMCrv->AddCurve( Release( pLine)) ; pMCrv->ToGlob( frLoc) ; + if ( ! m_Params.m_bInvert) { pMCrv->Invert() ; // inverto le proprietà in modo che nProp3 sia sempre legata al punto iniziale e nProp1 a quello finale - swap( nProp1, nProp3) ; + swap( vnProp[1], vnProp[3]) ; } // segno i lati aperti come temp prop della curva - int nOpenEdges = nProp0 + nProp1 * 2 + nProp3 * 8 ; + int nOpenEdges = vnProp[0] + vnProp[1] * 2 + vnProp[3] * 8 ; pMCrv->SetTempProp( nOpenEdges, 0) ; pMCrv->SetExtrusion( vtExtr) ; @@ -4200,7 +4221,7 @@ Pocketing::CalcTrapezoidSpiralLocalFrame( ICurveComposite * pCrvPocket, const Ve //------------------------------------------------------ bool -Pocketing::CalcTrapezoidSpiralXCoord( const ICurveComposite * pCrvPocket, bool bStart, double dYCoord, double& dXCoord) +Pocketing::CalcTrapezoidSpiralXCoord( const ICurveComposite * pCrvPocket, bool bStart, double dYCoord, double& dXCoord, double dPocketSize) { int nCrvId = bStart ? 3 : 1 ; int nProp ; @@ -4221,16 +4242,21 @@ Pocketing::CalcTrapezoidSpiralXCoord( const ICurveComposite * pCrvPocket, bool b double dVal ; Vector3d vtRef ; pCrvPocket->GetCurve( nCrvId)->GetStartDir( vtRef) ; - double dCosAlpha = vtRef * X_AX ; - - if ( dRad * dCosAlpha < dYCoord) { + double dCosAlpha = vtRef * X_AX ; + + if ( dRad * dCosAlpha < dYCoord && dYCoord < dPocketSize + dRad * dCosAlpha) { double dSinAlpha = ( vtRef ^ X_AX).Len() ; if ( abs( dSinAlpha) < EPS_SMALL) return false ; dVal = 1 / dSinAlpha * ( dRad - dYCoord * dCosAlpha) ; } - else - dVal = sqrt( dRad * dRad - dYCoord * dYCoord) ; + else if ( dYCoord < dRad * dCosAlpha) + dVal = sqrt( dRad * dRad - dYCoord * dYCoord) ; + else { + double dLen ; + pCrvPocket->GetCurve( nCrvId)->GetLength( dLen) ; + dVal = - dLen * dCosAlpha + sqrt( dRad * dRad - dYCoord * dYCoord) ; + } Point3d ptRef ; if ( bStart) { @@ -4245,17 +4271,163 @@ Pocketing::CalcTrapezoidSpiralXCoord( const ICurveComposite * pCrvPocket, bool b return true ; } + +//---------------------------------------------------- +bool +Pocketing::AdjustTrapezoidSpiralForAngles( ICurveComposite * pMCrv, const ICurveComposite * pCrvPocket, bool bStart) +{ + PtrOwner pCompo( CreateCurveComposite()) ; + if ( ! bStart) + pMCrv->Invert() ; + + Point3d ptTmp ; + pMCrv->GetStartPoint( ptTmp) ; + double dYCoord = ptTmp.y ; // quota verticale del percorso di svuotatura + pCrvPocket->GetCurve( 2)->GetStartPoint( ptTmp) ; + double dPocketSize = ptTmp.y ; + + int nCrvId = bStart ? 3 : 1 ; + PtrOwner pLine( GetCurveLine( pCrvPocket->GetCurve( nCrvId)->Clone())) ; + pLine->SimpleOffset( - 0.5 * m_TParams.m_dDiam - GetOffsR()) ; + + Point3d ptP1, ptP2 ; + pLine->GetStartPoint( ptP1) ; + pLine->GetEndPoint( ptP2) ; + if ( ! bStart) + swap( ptP1, ptP2) ; + + int nProp2 ; + // lato opposto a quello di riferimento aperto + if ( pCrvPocket->GetCurveTempProp( 2, nProp2) && nProp2) { + + // caso 1 : pLine ha un estremo sopra e uno sotto il percorso di svuotatura pMCrv + if ( ptP2.y < dYCoord && dYCoord < ptP1.y) { + + // creo tratto da ptP2 a ptP1 + pCompo->AddPoint( ptP2) ; + pCompo->AddLine( ptP1) ; + + // trovo il punto di pMCrv da cui ripartire per non lasciare aree residue + pLine->SimpleOffset( - 0.5 * m_TParams.m_dDiam) ; + pLine->ExtendStartByLen( EPS_SMALL) ; + pLine->ExtendEndByLen( EPS_SMALL) ; + IntersCurveCurve intCC( *pLine, *pCrvPocket) ; + if ( intCC.GetIntersCount() == 0) + return false ; + IntCrvCrvInfo aInfo ; + intCC.GetIntCrvCrvInfo( 0, aInfo) ; + double dDeltaX = sqrt( m_TParams.m_dDiam * m_TParams.m_dDiam / 4 - dYCoord * dYCoord) ; + if ( ! bStart) + dDeltaX *= -1 ; + Point3d ptCrv( aInfo.IciA[0].ptI.x + dDeltaX, dYCoord) ; + + double dPar = 0 ; + if ( ! pMCrv->GetParamAtPoint( ptCrv, dPar)) { + dPar = 0.5 ; + pMCrv->GetPointD1D2( dPar, ICurve::FROM_MINUS, ptCrv) ; + } + pMCrv->TrimStartAtParam( dPar) ; + + if ( ptP1.y > dPocketSize) { + // se ptP1 è esterno alla svuotatura scambio i punti in modo da usare ptP2 per il biarco ( così da non farlo fuoriuscire troppo) + swap( ptP1, ptP2) ; + pCompo->Invert() ; + } + + // creo biarco fra ptP1 e ptCrv + Vector3d vtDir ; + pCompo->GetStartDir( vtDir) ; + double dAng ; + vtDir.GetAngleXY( X_AX, dAng) ; + PtrOwner pBiArc( GetBiArc( ptP1, - dAng, ptCrv, bStart ? 0 : 180, 0.8)) ; + + bool bUseBiArc = false ; + if ( ! IsNull( pBiArc)) { + // verifico che con il biarco non si oltrepassi il lato obliquo chiuso della svuotatura + IntersCurveCurve intCC2( *pBiArc, *pCompo) ; + if ( intCC2.GetIntersCount() == 1) + bUseBiArc = true ; + } + if ( bUseBiArc) + pCompo->AddCurve( Release( pBiArc)) ; + else { + double dParLine = ( dYCoord - ptP2.y) / ( ptP1.y - ptP2.y) ; + Point3d ptOnLine = Media( ptP2, ptP1, dParLine) ; + pCompo->AddLine( ptOnLine) ; + pCompo->AddLine( ptCrv) ; + } + } + + // caso 2 : pLine è completamente sopra/sotto la linea di svuotatura + else { + // se è sopra modifiche per ricondurmi al caso in cui è sotto + if ( ptP2.y > dYCoord) { + pLine->Invert() ; + swap( ptP1, ptP2) ; + } + + // trovo l'intersezione fra il prolungamento della linea e pMCrv + if ( bStart) + pLine->ExtendStartByLen( 1000) ; + else + pLine->ExtendEndByLen( 1000) ; + IntersCurveCurve intCC ( *pLine, *pMCrv) ; + IntCrvCrvInfo aInfo ; + intCC.GetIntCrvCrvInfo( 0, aInfo) ; + Point3d ptInt ; + ptInt = aInfo.IciA[0].ptI ; + double dPar = 0 ; + pMCrv->GetParamAtPoint( ptInt, dPar) ; + pMCrv->TrimStartAtParam( dPar) ; + + pCompo->AddPoint( ptP2) ; + pCompo->AddLine( ptInt) ; + } + } + + // se il lato opposto a quello di riferimento è chiuso ha senso aggiungere solo se il punto è sotto la linea di svuotatura + else { + if ( ptP2.y < dYCoord) { + pCompo->AddPoint( ptP2) ; + Point3d ptCrv ; + pMCrv->GetStartPoint( ptCrv) ; + pCompo->AddLine( ptCrv) ; + } + } + + // setto temp prop per ricordare che è curva aggiuntiva per pulire angoli + for ( int i = 0 ; i < pCompo->GetCurveCount() ; i++) + pCompo->SetCurveTempProp( i, 1) ; + + pMCrv->AddCurve( Release( pCompo), false) ; + if ( ! bStart) + pMCrv->Invert() ; // ripristino la direzione originaria + + return true ; +} + //---------------------------------------------------- bool Pocketing::AdjustTrapezoidSpiralForLeadInLeadOut( ICurveComposite * pCompo, ICurveComposite * pRCrv, const Vector3d& vtTool, double dDepth, int& nOutsideRaw) -{ - // start point +{ + // recupero la direzione principale della svuotatura + Vector3d vtMainDir ; + for ( int i = 0 ; i < pCompo->GetCurveCount() ; i++) { + int nProp ; + if ( pCompo->GetCurveTempProp( i, nProp) && nProp == 0) { + // se non è lato aggiuntivo per la pulitura angoli recupero la sua direzione + pCompo->GetCurve( i)->GetStartDir( vtMainDir) ; + break ; + } + } + + // start point bool bStartOutside = false ; - ComputeTrapezoidSpiralLeadInLeadOut( pCompo, true, vtTool, dDepth, bStartOutside) ; + ComputeTrapezoidSpiralLeadInLeadOut( pCompo, vtMainDir, true, vtTool, dDepth, bStartOutside) ; // end point bool bEndOutside = false ; - ComputeTrapezoidSpiralLeadInLeadOut( pCompo, false, vtTool, dDepth, bEndOutside) ; + ComputeTrapezoidSpiralLeadInLeadOut( pCompo, vtMainDir, false, vtTool, dDepth, bEndOutside) ; // eventuale inversione della curva per partire sempre dall'esterno del grezzo if ( bEndOutside && ! bStartOutside) @@ -4264,17 +4436,13 @@ Pocketing::AdjustTrapezoidSpiralForLeadInLeadOut( ICurveComposite * pCompo, ICur nOutsideRaw = 0 ; if ( bStartOutside && bEndOutside) nOutsideRaw = 2 ; - else if ( bStartOutside || bEndOutside ) { + else if ( bStartOutside || bEndOutside) { nOutsideRaw = 1 ; // calcolo percorso di ritorno pRCrv->Clear() ; - Point3d ptS, ptE ; - pCompo->GetStartPoint( ptS) ; - pCompo->GetEndPoint( ptE) ; - PtrOwner pRLine( CreateCurveLine()) ; - pRLine->Set( ptE, ptS) ; - pRCrv->AddCurve( Release( pRLine)) ; + pRCrv->AddCurve( pCompo->Clone()) ; + pRCrv->Invert() ; } return true ; @@ -4282,9 +4450,11 @@ Pocketing::AdjustTrapezoidSpiralForLeadInLeadOut( ICurveComposite * pCompo, ICur //---------------------------------------------------- bool -Pocketing::ComputeTrapezoidSpiralLeadInLeadOut( ICurveComposite * pCompo, bool bLeadIn, const Vector3d& vtTool, double dDepth, bool& bIsOutsideRaw) +Pocketing::ComputeTrapezoidSpiralLeadInLeadOut( ICurveComposite * pCompo, const Vector3d& vtMainDir, bool bLeadIn, const Vector3d& vtTool, double dDepth, bool& bIsOutsideRaw) { - Vector3d vtDir ; + bIsOutsideRaw = false ; + Vector3d vtExtr ; pCompo->GetExtrusion( vtExtr) ; + Vector3d vtDir ; Point3d pt ; if ( bLeadIn) { pCompo->GetStartPoint( pt) ; @@ -4299,48 +4469,77 @@ Pocketing::ComputeTrapezoidSpiralLeadInLeadOut( ICurveComposite * pCompo, bool b int nPropOpen = pCompo->GetTempProp( 0) ; bool bEdgeOpen = ( nPropOpen & ( bLeadIn ? 8 : 2)) > 0 ; bool bBaseOpen = ( nPropOpen & 1) > 0 ; + + // recupero info per capire se sto considerando un lato aggiuntivo per pulire angoli + int nIdCrv = bLeadIn ? 0 : pCompo->GetCurveCount() - 1 ; + int nExtraEdge ; + pCompo->GetCurveTempProp( nIdCrv, nExtraEdge) ; double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ; - if ( bEdgeOpen) { - // se lato inclinato è apert tento con prolungamento della curva lungo vtDir - Point3d ptTest ; - if ( bLeadIn) - ptTest = pt - vtDir * ( 0.5 * m_TParams.m_dDiam + dSafeZ) ; - else - ptTest = pt + vtDir * ( 0.5 * m_TParams.m_dDiam + dSafeZ) ; - ptTest += - vtTool * dDepth ; + // tento con allungamento se lato inclinato è aperto oppure se sto considerando un lato aggiuntivo per pulire angoli + if ( bEdgeOpen || nExtraEdge == 1) { + + Vector3d vtDirP = bLeadIn ? -vtDir : vtDir ; - double dTestElev ; - // se fuori dal grezzo - if ( ! GetElevation( m_nPhase, ptTest, vtTool, 0.5 * m_TParams.m_dDiam, vtTool, dTestElev) || dTestElev < EPS_SMALL) { - if ( bLeadIn) - pCompo->ExtendStartByLen( 0.5 * m_TParams.m_dDiam + dSafeZ) ; - else - pCompo->ExtendEndByLen( 0.5 * m_TParams.m_dDiam + dSafeZ) ; - bIsOutsideRaw = true ; - } - } - - if ( bBaseOpen && ! bIsOutsideRaw) { - // se base è aperta provo a ruotare di 90 gradi - Vector3d vtDirO = vtDir ; - Vector3d vtExtr ; pCompo->GetExtrusion( vtExtr) ; - vtDirO.Rotate( vtExtr, ( m_Params.m_bInvert ? -90 : 90)) ; + // recupero la distanza dal bordo del grezzo lungo la direzione di allungamento double dDist ; - GetDistanceFromRawSide( m_nPhase, pt, vtDirO, dDist) ; + if ( ! CalcDistanceFromRawSurface( m_nPhase, pt, vtDirP, dDist)) + return false ; + + // calcolo eventuali fattori correttivi + double dCorr = 1 ; + double dDistRef = dDist ; + Vector3d vtDirO = vtMainDir ; + vtDirO.Rotate( vtExtr, 90) ; + if ( vtDirO * vtDirP < EPS_SMALL) + vtDirO.Rotate( vtExtr, 180) ; + if ( ! AreSameOrOppositeVectorApprox( vtDir, vtDirO) && ! AreOrthoApprox( vtDir, vtDirO) && abs( dDist) > EPS_SMALL) { + double dDistMin = 0 ; + CalcDistanceFromRawSurface( m_nPhase, pt, vtDirO, dDistMin) ; + if ( abs( dDistMin) < abs( dDist)) { + dDistRef = dDistMin ; + dCorr = dDist / dDistMin ; + } + } + + // se vicino al bordo del grezzo + if ( dDistRef < 0.5 * m_TParams.m_dDiam + EPS_SMALL) { + Point3d ptTest = pt + vtDirP * ( dDist + ( 0.5 * m_TParams.m_dDiam + dSafeZ) * dCorr) ; + ptTest += - vtTool * dDepth ; + double dTestElev ; + // se è fuori dal grezzo + if ( ! GetElevation( m_nPhase, ptTest, vtTool, 0.5 * m_TParams.m_dDiam, vtTool, dTestElev) || dTestElev < EPS_SMALL) { + Point3d ptNewStart = pt + vtDirP * ( dDist + ( 0.5 * m_TParams.m_dDiam + dSafeZ) * dCorr) ; + pCompo->AddLine( ptNewStart, ! bLeadIn) ; + bIsOutsideRaw = true ; + } + } + } + + // tento con attacco ruotato di 90° se non sto considerando un tratto aggiuntivo per pulire angoli + if ( bBaseOpen && ! bIsOutsideRaw && nExtraEdge == 0) { + + Vector3d vtDirO = vtDir ; + vtDirO.Rotate( vtExtr, ( m_Params.m_bInvert ? -90 : 90)) ; + // calcolo distanza dal bordo del grezzo lungo vtDirO + double dDist ; + if ( ! CalcDistanceFromRawSurface( m_nPhase, pt, vtDirO, dDist)) + return false ; + + // se vicino al bordo del grezzo if ( dDist < 0.5 * m_TParams.m_dDiam + EPS_SMALL) { Point3d ptTestO = pt + vtDirO * ( dDist + 0.5 * m_TParams.m_dDiam + dSafeZ) ; ptTestO += - vtTool * dDepth ; double dTestElevO ; // se è fuori dal grezzo uso inizio ruotato if ( ! GetElevation( m_nPhase, ptTestO, vtTool, 0.5 * m_TParams.m_dDiam, vtTool, dTestElevO) || dTestElevO < EPS_SMALL) { - Point3d ptNewStart = pt + vtDirO * ( dDist + 0.5 * m_TParams.m_dDiam + dSafeZ) ; - pCompo->AddLine( ptNewStart, ! bLeadIn) ; - bIsOutsideRaw = true ; + Point3d ptNewStart = pt + vtDirO * ( dDist + 0.5 * m_TParams.m_dDiam + dSafeZ) ; + pCompo->AddLine( ptNewStart, ! bLeadIn) ; + bIsOutsideRaw = true ; } } - } + } return true ; } @@ -5221,3 +5420,24 @@ Pocketing::VerifyLeadInZigZag( const ICurveComposite* pCompo, const Point3d& ptP return false ; return ( dMinDistPa > 0.5 * m_TParams.m_dDiam - 10 * EPS_SMALL && dMinDistPb > 0.5 * m_TParams.m_dDiam - 10 * EPS_SMALL) ; } + +//---------------------------------------------------------------------------- +bool +Pocketing::CalcDistanceFromRawSurface( int nPhase, const Point3d& ptP, const Vector3d& vtDir, double& dDist) +{ + if ( ! GetElevation( nPhase, ptP, vtDir, dDist)) + return false ; + + // se punto esterno al grezzo + if ( abs( dDist) < EPS_SMALL) { + double dDist1, dDist2 ; + if ( ! GetElevation( nPhase, ptP, -vtDir, dDist1)) + return false ; + if ( ! GetElevation( nPhase, ptP - vtDir * ( dDist1), vtDir, dDist2)) + return false ; + if ( abs( dDist2) > EPS_SMALL && abs( dDist1) > EPS_SMALL) + dDist = dDist2 - dDist1 ; + } + + return true ; +} \ No newline at end of file diff --git a/Pocketing.h b/Pocketing.h index 2263737..3ee767b 100644 --- a/Pocketing.h +++ b/Pocketing.h @@ -104,10 +104,11 @@ class Pocketing : public Machining bool CalcTrapezoidSpiral( ICurveComposite * pCrvPocket, const Vector3d& vtDir, double dPocketSize, ICurveComposite * pMCrv, ICurveComposite * pRCrv, bool& bOptimizedTrap) ; bool CalcTrapezoidSpiralLocalFrame( ICurveComposite * pCrvPocket, const Vector3d& vtDir, Frame3d& frLoc) ; - bool CalcTrapezoidSpiralXCoord( const ICurveComposite * pCrvPocket, bool bStart, double dYCoord, double& dXCoord) ; + bool CalcTrapezoidSpiralXCoord( const ICurveComposite * pCrvPocket, bool bStart, double dYCoord, double& dXCoord, double dPocketSize) ; + bool AdjustTrapezoidSpiralForAngles( ICurveComposite * pMCrv, const ICurveComposite * pCrvPocket, bool bStart) ; bool AdjustTrapezoidSpiralForLeadInLeadOut( ICurveComposite * pCompo, ICurveComposite * pRCrv, const Vector3d& vtTool, double dDepth, int& nOutsideRaw) ; - bool ComputeTrapezoidSpiralLeadInLeadOut( ICurveComposite * pCompo, bool bLeadIn, const Vector3d& vtTool, double dDepth, bool& bIsOutsideRaw) ; + bool ComputeTrapezoidSpiralLeadInLeadOut( ICurveComposite * pCompo, const Vector3d& vtMainDir, bool bLeadIn, const Vector3d& vtTool, double dDepth, bool& bIsOutsideRaw) ; bool ComputePolishingPath( ICurveComposite* pMCrv, ICurveComposite* pRCrv, bool bSplitArcs) ; bool AddEpicycles( ICurveComposite * pCompo, ICurveComposite * pCrv, ICurveComposite * pCrvBound = nullptr) ; bool AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ, @@ -131,6 +132,7 @@ class Pocketing : public Machining bool AdjustContourStart( ICurveComposite* pCompo) ; bool VerifyLeadInHelix( const ICurveComposite* pCompo, const Point3d& ptCen, double dRad) const ; bool VerifyLeadInZigZag( const ICurveComposite* pCompo, const Point3d& ptPa, const Point3d& ptPb) const ; + bool CalcDistanceFromRawSurface( int nPhase, const Point3d& ptP, const Vector3d& vtDir, double& dDist) ; private : double GetSpeed( void) const