From d3922eb897491bbc58b171e6c7d8b57a315f50cd Mon Sep 17 00:00:00 2001 From: DarioS Date: Sun, 20 Mar 2022 18:51:56 +0100 Subject: [PATCH] EgtMachKernel : - migliorata gestione approcci e retrazioni in fresature con lame. --- Milling.cpp | 139 +++++++++++++++++++++++++++++++++++--------------- Milling.h | 6 +-- Mortising.cpp | 4 +- Operation.cpp | 20 ++++---- Operation.h | 2 +- Pocketing.cpp | 16 +++--- 6 files changed, 121 insertions(+), 66 deletions(-) diff --git a/Milling.cpp b/Milling.cpp index 9f9104c..b2e5d2c 100644 --- a/Milling.cpp +++ b/Milling.cpp @@ -1,7 +1,7 @@ //---------------------------------------------------------------------------- -// EgalTech 2015-2020 +// EgalTech 2015-2022 //---------------------------------------------------------------------------- -// File : Milling.cpp Data : 02.06.20 Versione : 2.2f1 +// File : Milling.cpp Data : 16.03.22 Versione : 2.4c1 // Contenuto : Implementazione gestione fresature. // // @@ -9,6 +9,7 @@ // Modifiche : 07.06.15 DS Creazione modulo. // 11.08.16 DS Miglioria gestione PV per più loop. // 02.06.20 DS Aggiunta gestione Tabs. +// 16.03.22 DS Migliorata sicurezza lame sopra. // //---------------------------------------------------------------------------- @@ -42,6 +43,7 @@ using namespace std ; //------------------------------ Constants ------------------------------------ const double OSC_MIN_LEN = 0.1 ; const double ELEV_MAX_OFFS = 25.0 ; +const double MIN_SAFEDIST = 5.0 ; //------------------------------ Errors -------------------------------------- // 2301 = "Error in Milling : UpdateToolData failed" @@ -2178,6 +2180,18 @@ Milling::GenerateMillingPv( int nPathId, const ICurveComposite* pCompo) return true ; } +//---------------------------------------------------------------------------- +static bool +VerifyEscapeDir( const Vector3d& vtCorr, const Vector3d& vtTool, bool bAboveHead) +{ + if ( bAboveHead && AreSameVectorApprox( vtCorr, -Z_AX)) + return false ; + if ( ! bAboveHead && AreSameVectorApprox( vtCorr, Z_AX)) + return false ; + Vector3d vtEsc( vtCorr.x, vtCorr.y, 0) ; + return ( vtEsc.Normalize() && vtEsc * vtTool > -0.5) ; +} + //---------------------------------------------------------------------------- bool Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTool, @@ -2230,7 +2244,13 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, dStElev, false, pCompo, ptP1)) return false ; // determino se l'inizio dell'attacco è fuori dal grezzo - bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, dElev, dSafeZ) ; + Vector3d vtCorr = ptP1 - ptStart ; + if ( ! vtCorr.Normalize() || ! VerifyEscapeDir( vtCorr, vtTool, m_bAboveHead)) { + vtCorr = CalcCorrDir( pCompo, i) ; + if ( ! vtCorr.Normalize() || ! VerifyEscapeDir( vtCorr, vtTool, m_bAboveHead)) + vtCorr = vtTool ; + } + bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, vtCorr, dElev, dSafeZ) ; // determino se l'inizio dell'attacco è sopra il grezzo bool bGeomAboveStart = GetPointAboveRaw( ptP1, vtTool) ; bool bAboveStart = ( m_bAboveHead && bGeomAboveStart) ; @@ -2249,7 +2269,7 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo dStElev = min( dStElev, dNewStElev) ; // determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione bool bUnderStart = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, 0, - GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dStElev) ; + GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ; // se attacco a zigzag o a spirale, l'elevazione va nell'attacco if ( IsLeadInHelixOrZigzag()) { ptP1 += vtTool * ( dStElev + LIO_ELEV_TOL) ; @@ -2267,14 +2287,27 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo if ( ! bOutStart) { // verifico se sono sotto double dSawStartElev = 0 ; - bool bUnderStart = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, m_TParams.m_dTDiam / 2, - GetRadiusForStartEndElevation( false), m_TParams.m_dLen, true, dSafeZ, dSawStartElev) ; - if ( ! bGeomAboveStart && ! bUnderStart && bOk) { + bool bUnderStart = false ; + bool bSideStart = false ; + if ( ! bGeomAboveStart) { + bUnderStart = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, m_TParams.m_dTDiam / 2, + GetRadiusForStartEndElevation( false), m_TParams.m_dLen, true, dSafeZ, vtCorr, dSawStartElev) ; + + } + if ( ! bUnderStart) { + Vector3d vtMove( vtCorr.x, vtCorr.y, 0) ; + if ( vtMove.Normalize()) { + Point3d ptTest = ptP1 - MIN_SAFEDIST * ( m_bAboveHead ? Z_AX : -Z_AX) ; + if ( GetElevation( m_nPhase, ptTest, vtTool, 0.5 * m_TParams.m_dDiam, vtMove, dSawStartElev) && dSawStartElev < EPS_SMALL) + bSideStart = true ; + } + } + if ( ! bGeomAboveStart && ! bUnderStart && ! bSideStart && bOk) { m_pMchMgr->SetLastError( 2314, "Error in Milling : LeadIn must be out of rawpart") ; bOk = false ; } // aggiungo opportuno approccio - if ( ! AddSawBladeSideApproach( ptP1, vtTool, dSafeZ, dSawStartElev, dAppr)) { + if ( ! AddSawBladeSideApproach( ptP1, vtCorr, dSafeZ, dSawStartElev, dAppr)) { m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ; return false ; } @@ -2294,7 +2327,7 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo } } // imposto versore correzione e ausiliario sul punto di arrivo - CalcAndSetCorrAuxDir( pCompo, i+1) ; + CalcAndSetCorrAuxDir( pCompo, i + 1) ; // elaborazioni sulla curva corrente if ( pCurve->GetType() == CRV_LINE) { ICurveLine* pLine = GetCurveLine( pCurve) ; @@ -2366,7 +2399,7 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo dEndElev = min( dEndElev, dNewEndElev) ; // determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione bool bUnderEnd = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, 0, - GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dEndElev) ; + GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dEndElev) ; // aggiungo retrazione if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bAboveEnd)) { m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ; @@ -2376,20 +2409,38 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo // per lame quando è necessario else { // verifico di uscire in aria - bool bOutEnd = GetPointOutOfRaw( ptP1, vtTool, dElev, dSafeZ) ; + Vector3d vtCorr = ptP1 - ptEnd ; + if ( ! vtCorr.Normalize() || ! VerifyEscapeDir( vtCorr, vtTool, m_bAboveHead)) { + vtCorr = CalcCorrDir( pCompo, i + 1) ; + if ( ! vtCorr.Normalize() || ! VerifyEscapeDir( vtCorr, vtTool, m_bAboveHead)) + vtCorr = vtTool ; + } + bool bOutEnd = GetPointOutOfRaw( ptP1, vtTool, vtCorr, dElev, dSafeZ) ; if ( ! bOutEnd) { // verifico se sono sopra bool bGeomAboveEnd = GetPointAboveRaw( ptP1, vtTool) ; // verifico se sono sotto double dSawEndElev = 0 ; - bool bUnderEnd = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, m_TParams.m_dTDiam / 2, - GetRadiusForStartEndElevation( false), m_TParams.m_dLen, true, dSafeZ, dSawEndElev) ; - if ( ! bGeomAboveEnd && ! bUnderEnd && bOk) { + bool bUnderEnd = false ; + bool bSideEnd = false ; + if ( ! bGeomAboveEnd) { + bUnderEnd = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, m_TParams.m_dTDiam / 2, + GetRadiusForStartEndElevation( false), m_TParams.m_dLen, true, dSafeZ, vtCorr, dSawEndElev) ; + } + if ( ! bUnderEnd) { + Vector3d vtMove( vtCorr.x, vtCorr.y, 0) ; + if ( vtMove.Normalize()) { + Point3d ptTest = ptP1 - MIN_SAFEDIST * ( m_bAboveHead ? Z_AX : -Z_AX) ; + if ( GetElevation( m_nPhase, ptTest, vtTool, 0.5 * m_TParams.m_dDiam, vtMove, dSawEndElev) && dSawEndElev < EPS_SMALL) + bSideEnd = true ; + } + } + if ( ! bGeomAboveEnd && ! bUnderEnd && ! bSideEnd && bOk) { m_pMchMgr->SetLastError( 2324, "Error in Milling : LeadOut must be out of rawpart") ; bOk = false ; } // aggiungo opportuna retrazione - if ( ! AddSawBladeSideRetract( ptP1, vtTool, dSafeZ, dSawEndElev, dAppr)) { + if ( ! AddSawBladeSideRetract( ptP1, vtCorr, dSafeZ, dSawEndElev, dAppr)) { m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ; return false ; } @@ -2477,7 +2528,8 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, dStElev, bInvert, pCompo, ptP1)) return false ; // determino se l'inizio dell'attacco è fuori dal grezzo - bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, dElev, dSafeZ) ; + Vector3d vtCorr = CalcCorrDir( pCompo, ( bInvert ? nMaxInd - i + 1 : i)) ; + bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, vtCorr, dElev, dSafeZ) ; // determino se l'inizio dell'attacco è sopra il grezzo bool bAboveStart = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ; // imposto versore correzione e ausiliario sul punto di partenza @@ -2495,7 +2547,7 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool dStElev = min( dStElev, dNewStElev) ; // determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione bool bUnderStart = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, 0, - GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dStElev) ; + GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ; // se attacco a zigzag o a spirale, l'elevazione va nell'attacco if ( IsLeadInHelixOrZigzag()) { ptP1 += vtTool * ( dStElev + LIO_ELEV_TOL) ; @@ -2626,7 +2678,7 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool dEndElev = min( dEndElev, dNewEndElev) ; // determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione bool bUnderEnd = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, 0, - GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dEndElev) ; + GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dEndElev) ; // aggiungo retrazione if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bAboveEnd)) { m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ; @@ -2738,7 +2790,8 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, dStElev, false, pCompo, ptP1)) return false ; // determino se l'inizio dell'attacco è fuori dal grezzo - bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, dElev, dSafeZ) ; + Vector3d vtCorr = CalcCorrDir( pCompo, i) ; + bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, vtCorr, dElev, dSafeZ) ; // aggiungo approccio per frese normali if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) { // correggo elevazione iniziale per punto inizio attacco (se testa da sopra senza aggregato approccio mai Z-) @@ -2757,7 +2810,7 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool } // determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione bool bUnderStart = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, 0, - GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dStElev) ; + GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ; // se attacco a zigzag o a spirale, l'elevazione va nell'attacco if ( IsLeadInHelixOrZigzag()) { ptP1 += vtTool * ( dStElev - ( j - 1) * dStep) ; @@ -2879,7 +2932,7 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool } // determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione bool bUnderEnd = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, 0, - GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dEndElev) ; + GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dEndElev) ; // aggiungo retrazione if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bAboveStartEnd)) { m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ; @@ -2959,7 +3012,8 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, dStElev, false, pCompo, ptP1)) return false ; // determino se l'inizio dell'attacco è fuori dal grezzo - bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, dElev, dSafeZ) ; + Vector3d vtCorr = CalcCorrDir( pCompo, i) ; + bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, vtCorr, dElev, dSafeZ) ; // determino se l'inizio dell'attacco è sopra il grezzo bool bAboveStart = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ; // imposto versore correzione e ausiliario sul punto di partenza @@ -2977,7 +3031,7 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool dStElev = min( dStElev, dNewStElev) ; // determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione bool bUnderStart = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, 0, - GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dStElev) ; + GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ; // approccio al punto iniziale if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dAppr, bOutStart, bAboveStart)) { m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ; @@ -3080,7 +3134,7 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool dEndElev = min( dEndElev, dNewEndElev) ; // determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione bool bUnderEnd = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, 0, - GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dEndElev) ; + GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dEndElev) ; // aggiungo retrazione if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bAboveEnd)) { m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ; @@ -3148,12 +3202,13 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev) && dNewStElev > EPS_SMALL) dStElev = min( dStElev, dNewStElev) ; // determino se l'inizio dell'attacco è fuori dal grezzo - bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, dElev, dSafeZ) ; + Vector3d vtCorr = CalcCorrDir( pCompo, ( bInvert ? nMaxInd - i + 1 : i)) ; + bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, vtCorr, dElev, dSafeZ) ; // determino se l'inizio dell'attacco è sopra il grezzo bool bAboveStart = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ; // determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione bool bUnderStart = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, 0, - GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dStElev) ; + GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ; // approccio al punto iniziale if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dAppr, bOutStart, bAboveStart)) { m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ; @@ -3251,7 +3306,7 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool dEndElev = min( dEndElev, dNewEndElev) ; // determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione bool bUnderEnd = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, 0, - GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dEndElev) ; + GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dEndElev) ; // aggiungo retrazione if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bAboveEnd)) { m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ; @@ -3360,7 +3415,8 @@ Milling::AddSawZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtT if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, dStElev, bInvert, pCompo, ptP1)) return false ; // determino se l'inizio dell'attacco è fuori dal grezzo - bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, dElev, dSafeZ) ; + Vector3d vtCorr = CalcCorrDir( pCompo, ( bInvert ? nMaxInd - i + 1 : i)) ; + bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, vtCorr, dElev, dSafeZ) ; // determino se l'inizio dell'attacco è sopra il grezzo bool bAboveStart = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ; // imposto versore correzione e ausiliario sul punto di partenza @@ -3549,21 +3605,21 @@ Milling::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, //---------------------------------------------------------------------------- bool -Milling::AddSawBladeSideApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dStElev, double dAppr) +Milling::AddSawBladeSideApproach( const Point3d& ptP, const Vector3d& vtCorr, double dSafeZ, double dStElev, double dAppr) { SetFlag( 1) ; - // approccio per lame su teste da sopra che attaccano da sotto -> movimento in verticale fino all'esterno del grezzo - Vector3d vtAppr = vtTool ; - vtAppr.z = 0 ; + // approccio per lame su teste da sopra che attaccano da sotto o da sopra troppo vicine -> movimento in verticale fino all'esterno del grezzo + Vector3d vtAppr = vtCorr ; + vtAppr.z = max( vtAppr.z, 0.) ; vtAppr.Normalize() ; // 1 -> punto fuori inizio Point3d ptP1 = ptP + vtAppr * ( dStElev + max( dAppr, dSafeZ)) ; if ( AddRapidStart( ptP1) == GDB_ID_NULL) return false ; - // affondo al punto iniziale + // affondo al punto iniziale in feed SetFlag( 0) ; SetFeed( GetStartFeed()) ; - if ( AddRapidMove( ptP) == GDB_ID_NULL) + if ( AddLinearMove( ptP) == GDB_ID_NULL) return false ; return true ; @@ -3672,11 +3728,11 @@ Milling::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, //---------------------------------------------------------------------------- bool -Milling::AddSawBladeSideRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dEndElev, double dAppr) +Milling::AddSawBladeSideRetract( const Point3d& ptP, const Vector3d& vtCorr, double dSafeZ, double dEndElev, double dAppr) { - // retrazione per lame su teste da sopra che attaccano da sotto -> movimento in orizzontale fino all'esterno del grezzo - Vector3d vtAppr = vtTool ; - vtAppr.z = 0 ; + // retrazione per lame su teste da sopra che attaccano da sotto o da sopra troppo vicine -> movimento in orizzontale fino all'esterno del grezzo + Vector3d vtAppr = vtCorr ; + vtAppr.z = max( vtAppr.z, 0.) ; vtAppr.Normalize() ; // se sopra uscita c'è spazio per sicurezza o approccio if ( dEndElev + max( dSafeZ, dAppr) > 10 * EPS_SMALL) { @@ -5093,7 +5149,7 @@ Milling::GetRadiusForStartEndElevation( bool bExtra) const //---------------------------------------------------------------------------- bool -Milling::GetPointOutOfRaw( const Point3d& ptP, const Vector3d& vtTool, double dElev, double dSafeZ) const +Milling::GetPointOutOfRaw( const Point3d& ptP, const Vector3d& vtTool, const Vector3d& vtCorr, double dElev, double dSafeZ) const { // per frese normali if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) { @@ -5108,9 +5164,8 @@ Milling::GetPointOutOfRaw( const Point3d& ptP, const Vector3d& vtTool, double dE // determino se l'inizio dell'attacco è fuori dal grezzo (considero movimento lama in +/- Z) double dTemp ; Vector3d vtMove = ( m_bAboveHead ? Z_AX : -Z_AX) ; - Vector3d vtSafe = vtTool ; vtSafe.z = 0 ; vtSafe.Normalize() ; - const double MIN_SAFEDIST = 5.0 ; - Point3d ptQ = ptP - vtSafe * max( 0.2 * dSafeZ, MIN_SAFEDIST) ; + Vector3d vtSafe = vtCorr ; vtSafe.z = 0 ; vtSafe.Normalize() ; + Point3d ptQ = ptP - ( vtSafe + vtMove) * max( 0.2 * dSafeZ, MIN_SAFEDIST) ; if ( ! GetElevation( m_nPhase, ptQ, vtTool, 0.5 * m_TParams.m_dDiam, vtMove, dTemp) || dTemp > 10 * EPS_SMALL) return false ; Point3d ptR = ptP + vtTool * m_TParams.m_dThick ; diff --git a/Milling.h b/Milling.h index 051d5de..e438382 100644 --- a/Milling.h +++ b/Milling.h @@ -98,11 +98,11 @@ class Milling : public Machining double dDepth, double dElev, double dOkStep, bool bSplitArcs) ; bool AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ, double dElev, double dAppr, bool bOutStart, bool bAboveStart) ; - bool AddSawBladeSideApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dStElev, double dAppr) ; + bool AddSawBladeSideApproach( const Point3d& ptP, const Vector3d& vtCorr, double dSafeZ, double dStElev, double dAppr) ; bool AddDirectApproach( const Point3d& ptP) ; bool AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ, double dElev, double dAppr, bool bAboveEnd) ; - bool AddSawBladeSideRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dEndElev, double dAppr) ; + bool AddSawBladeSideRetract( const Point3d& ptP, const Vector3d& vtCorr, double dSafeZ, double dEndElev, double dAppr) ; bool CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtN, double dStElev, bool bInvert, const ICurveComposite* pCompo, Point3d& ptP1) const ; bool AddLeadIn( const Point3d& ptP1, const Point3d& ptStart, const Vector3d& vtStart, @@ -117,7 +117,7 @@ class Milling : public Machining bool AddTabsLine( const ICurveLine* pLine, const Vector3d& vtTool, const DBLVECTOR& vdTabs, const TabData& tdTabs) ; bool AddTabsArc( const ICurveArc* pArc, const Vector3d& vtTool, const DBLVECTOR& vdTabs, const TabData& tdTabs) ; double GetRadiusForStartEndElevation( bool bExtra = true) const ; - bool GetPointOutOfRaw( const Point3d& ptP, const Vector3d& vtTool, double dElev, double dSafeZ) const ; + bool GetPointOutOfRaw( const Point3d& ptP, const Vector3d& vtTool, const Vector3d& vtCorr, double dElev, double dSafeZ) const ; bool GetPointAboveRaw( const Point3d& ptP, const Vector3d& vtTool) const ; bool CalcAndSetCorrAuxDir( const ICurveComposite* pCompo, double dU) ; Vector3d CalcCorrDir( const ICurveComposite* pCompo, double dU) ; diff --git a/Mortising.cpp b/Mortising.cpp index 1b231a8..05924dd 100644 --- a/Mortising.cpp +++ b/Mortising.cpp @@ -1480,7 +1480,7 @@ Mortising::GenerateMortisingCl( const ICurveComposite* pCompo, const Vector3d& v double dStartElev = 0 ; Point3d ptLi = ptStart + vtTool * dDelta ; bool bUnderStart = GetPointUnderRaw( ptLi, vtTool, 0, - GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dStartElev) ; + GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dStartElev) ; // altrimenti ridetermino elevazione su inizio percorso di lavoro if ( ! bUnderStart) GetElevation( m_nPhase, ptLi, vtTool, GetRadiusForStartEndElevation(), vtTool, dStartElev) ; @@ -1564,7 +1564,7 @@ Mortising::GenerateMortisingCl( const ICurveComposite* pCompo, const Vector3d& v double dEndElev = 0 ; Point3d ptLo = ptLast + vtTool * dDelta ; bool bUnderEnd = GetPointUnderRaw( ptLo, vtTool, 0, - GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dEndElev) ; + GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dEndElev) ; // altrimenti ridetermino elevazione su fine percorso di lavoro if ( ! bUnderEnd) GetElevation( m_nPhase, ptLo, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev) ; diff --git a/Operation.cpp b/Operation.cpp index 54a485e..138aa4b 100644 --- a/Operation.cpp +++ b/Operation.cpp @@ -324,7 +324,7 @@ Operation::GetElevation( int nPhase, const Point3d& ptP, const Vector3d& vtTool, return false ; // considero più direzioni sulla circonferenza const int MIN_STEP = 8 ; - const double LEN_STEP = 50 ; + const double LEN_STEP = 25 ; int nStep = max( int( ( 2 * PIGRECO * dRad) / LEN_STEP), MIN_STEP) ; Vector3d vtRad = FromUprightOrtho( vtTool) * dRad ; for ( int i = 0 ; i < nStep ; ++ i) { @@ -344,7 +344,7 @@ Operation::GetElevation( int nPhase, const Point3d& ptP, const Vector3d& vtTool, //---------------------------------------------------------------------------- bool Operation::GetPointUnderRaw( const Point3d& ptP, const Vector3d& vtTool, double dToolRad, double dToolRadForElev, - double dToolLen, bool bIsSaw, double dSafeZ, double& dElev) const + double dToolLen, bool bIsSaw, double dSafeZ, const Vector3d& vtDir, double& dElev) const { // punto a metà lunghezza utensile Point3d ptQ = ptP + vtTool * dToolLen / 2 ; @@ -359,10 +359,10 @@ Operation::GetPointUnderRaw( const Point3d& ptP, const Vector3d& vtTool, double // extra ingombro reale in Z double dExtraZ = sqrt( 1 - vtTool.z * vtTool.z) * dToolRad ; // direzione di fuga per l'elevazione - Vector3d vtDir = vtTool ; - if ( bIsSaw || vtDir.z < - EPS_SMALL) - vtDir.z = 0 ; - vtDir.Normalize() ; + Vector3d vtMyDir = vtDir ; + if ( bIsSaw || vtMyDir.z < - EPS_SMALL) + vtMyDir.z = 0 ; + vtMyDir.Normalize() ; // determino la posizione del punto rispetto al grezzo // ciclo sui grezzi int nRawId = m_pMchMgr->GetFirstRawPart() ; @@ -380,17 +380,17 @@ Operation::GetPointUnderRaw( const Point3d& ptP, const Vector3d& vtTool, double // determino elevazione del punto rispetto al grezzo a metà altezza Point3d ptTest( ptP.x, ptP.y, dRawCentZ) ; double dNewElev ; - if ( GetElevation( m_nPhase, ptTest - 10 * EPS_SMALL * vtTool, vtTool, dToolRadForElev, vtDir, dNewElev)) + if ( GetElevation( m_nPhase, ptTest - 10 * EPS_SMALL * vtTool, vtTool, dToolRadForElev, vtMyDir, dNewElev)) dElev = max( dElev, dNewElev) ; // se direzione di fuga quasi orizzontale (max 30 deg) e ingombro utensile rilevante rispetto ad altezza grezzo - if ( vtDir.z < 0.5 && dToolDimZ > dRawDimZ / 2) { + if ( vtMyDir.z < 0.5 && dToolDimZ > dRawDimZ / 2) { // determino elevazione del punto rispetto al grezzo a metà altezza più metà ingombro utensile ptTest = Point3d( ptP.x, ptP.y, dRawCentZ + dToolDimZ / 2) ; - if ( GetElevation( m_nPhase, ptTest - 10 * EPS_SMALL * vtTool, vtTool, dToolRadForElev, vtDir, dNewElev)) + if ( GetElevation( m_nPhase, ptTest - 10 * EPS_SMALL * vtTool, vtTool, dToolRadForElev, vtMyDir, dNewElev)) dElev = max( dElev, dNewElev) ; // determino elevazione del punto rispetto al grezzo a metà altezza meno metà ingombro utensile ptTest = Point3d( ptP.x, ptP.y, dRawCentZ - dToolDimZ / 2) ; - if ( GetElevation( m_nPhase, ptTest - 10 * EPS_SMALL * vtTool, vtTool, dToolRadForElev, vtDir, dNewElev)) + if ( GetElevation( m_nPhase, ptTest - 10 * EPS_SMALL * vtTool, vtTool, dToolRadForElev, vtMyDir, dNewElev)) dElev = max( dElev, dNewElev) ; } return true ; diff --git a/Operation.h b/Operation.h index 5a827b2..8b2455f 100644 --- a/Operation.h +++ b/Operation.h @@ -75,7 +75,7 @@ class Operation : public IUserObj bool GetElevation( int nPhase, const Point3d& ptP, const Vector3d& vtTool, double dRad, const Vector3d& vtDir, double& dElev) const ; bool GetPointUnderRaw( const Point3d& ptP, const Vector3d& vtTool, double dToolRad, double dToolRadForElev, - double dToolLen, bool bIsSaw, double dSafeZ, double& dElev) const ; + double dToolLen, bool bIsSaw, double dSafeZ, const Vector3d& vtDir, double& dElev) const ; bool GetDistanceFromRawSide( int nPhase, const Point3d& ptP, const Vector3d& vtDir, double& dDist) const ; bool GetMinDistanceFromRawSide( int nPhase, const Point3d& ptP, double dExpand, double& dDist, Vector3d& vtDir) const ; bool GetDistanceFromRawBottom( int nPhase, int nPathId, double dToler, double& dRbDist) const diff --git a/Pocketing.cpp b/Pocketing.cpp index c3f09c5..a69b56b 100644 --- a/Pocketing.cpp +++ b/Pocketing.cpp @@ -2068,7 +2068,7 @@ Pocketing::AddZigZag( const ICurveComposite* pCompo, const Vector3d& vtTool, con GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev) ; dStElev = max( dStElev, j * dStep) ; bool bUnderRaw = m_bAboveHead && ! m_bAggrBottom && - GetPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dStElev) ; + GetPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ; if ( bUnderRaw) dStElev = max( dStElev, j * dStep) ; dStElev -= ( ptP1 - ptStart) * vtExtr ; @@ -2217,7 +2217,7 @@ Pocketing::AddZigZag( const ICurveComposite* pCompo, const Vector3d& vtTool, con if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev)) dStElev = dStep ; bool bUnderRaw = m_bAboveHead && ! m_bAggrBottom && - GetPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dStElev) ; + GetPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ; if ( bUnderRaw) dStElev = max( dStElev, dStep) ; dStElev -= ( ptP1 - ptStart) * vtExtr ; @@ -3013,7 +3013,7 @@ Pocketing::AddOneWay( const ICurveComposite* pCompo, const Vector3d& vtTool, con if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev)) dStElev = dStep ; bool bUnderRaw = m_bAboveHead && ! m_bAggrBottom && - GetPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dStElev) ; + GetPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ; if ( bUnderRaw) dStElev = max( dStElev, dStep) ; dStElev -= ( ptP1 - ptStart) * vtExtr ; @@ -3167,7 +3167,7 @@ Pocketing::AddOneWay( const ICurveComposite* pCompo, const Vector3d& vtTool, con if ( ! GetElevation( m_nPhase, ptS - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev)) dStElev = j * dStep ; bool bUnderRaw = m_bAboveHead && ! m_bAggrBottom && - GetPointUnderRaw( ptP, vtTool, 0, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dStElev) ; + GetPointUnderRaw( ptP, vtTool, 0, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ; if ( bUnderRaw) dStElev = max( dStElev, j * dStep) ; dStElev -= ( ptP - ptS) * vtExtr ; @@ -3353,7 +3353,7 @@ Pocketing::AddSpiralIn( const ICurveComposite* pCompo, const Vector3d& vtTool, c if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev)) dStElev = dStep ; bool bUnderRaw = m_bAboveHead && ! m_bAggrBottom && - GetPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dStElev) ; + GetPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ; if ( bUnderRaw || ( bOutStart && ! m_bAboveHead)) dStElev = max( dStElev, dStep) ; dStElev -= ( ptP1 - ptStart) * vtExtr ; @@ -3577,7 +3577,7 @@ Pocketing::AddSpiralOut( const ICurveComposite* pCompo, const Vector3d& vtTool, if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev)) dStElev = dStep ; bool bUnderRaw = m_bAboveHead && ! m_bAggrBottom && - GetPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dStElev) ; + GetPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ; if ( bUnderRaw) dStElev = max( dStElev, dStep) ; dStElev -= ( ptP1 - ptStart) * vtExtr ; @@ -5092,7 +5092,7 @@ Pocketing::AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector // correzione per punto sotto il grezzo con testa normale da sopra double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ; bool bUnderEnd = m_bAboveHead && ! m_bAggrBottom && GetPointUnderRaw( ptP1, vtN, 0, - GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dElev) ; + GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtN, dElev) ; return true ; } case POCKET_LO_GLIDE : @@ -5128,7 +5128,7 @@ Pocketing::AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector // correzione per punto sotto il grezzo con testa normale da sopra double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ; bool bUnderEnd = m_bAboveHead && ! m_bAggrBottom && GetPointUnderRaw( ptP1, vtN, 0, - GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dElev) ; + GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtN, dElev) ; return true ; } default :