From dc0b055480f052ae8b464e8903e90c9da1eb9401 Mon Sep 17 00:00:00 2001 From: DarioS Date: Fri, 22 Apr 2022 08:53:59 +0200 Subject: [PATCH] EgtMachKernel : - migliorie su approcci eretrazioni di fresature con lame. --- Milling.cpp | 108 ++++++++++++++++++++++++++++++-------------------- Milling.h | 4 +- Operation.cpp | 14 +++++-- 3 files changed, 78 insertions(+), 48 deletions(-) diff --git a/Milling.cpp b/Milling.cpp index 5611d60..3df5088 100644 --- a/Milling.cpp +++ b/Milling.cpp @@ -2244,13 +2244,10 @@ 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 - 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) ; + Vector3d vtAppr( vtTool.x, vtTool.y, 0) ; + if ( ! vtAppr.Normalize()) + vtAppr = FromNearestHorizontalOrtho( vtTool, ptP1 - ptStart) ; + bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, vtAppr, dElev, dSafeZ) ; // determino se l'inizio dell'attacco è sopra il grezzo bool bGeomAboveStart = GetPointAboveRaw( ptP1, vtTool) ; bool bAboveStart = ( m_bAboveHead && bGeomAboveStart) ; @@ -2291,15 +2288,34 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo 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) ; + GetRadiusForStartEndElevation( false), m_TParams.m_dLen, true, dSafeZ, vtAppr, dSawStartElev) ; } + // se non sono sotto, verifico se posso allontanarmi nel piano lama (meglio se in orizzontale) 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 ; + Point3d ptTest = ptP1 - MIN_SAFEDIST * ( m_bAboveHead ? Z_AX : -Z_AX) ; + Vector3d vtAppr1 = FromNearestHorizontalOrtho( vtTool, ptP1 - ptStart) ; + Vector3d vtAppr2 = ptP1 - ptStart ; + if ( ! vtAppr2.Normalize()) + vtAppr2 = CalcCorrDir( pCompo, i) ; + double dSawStartElev1, dSawStartElev2 ; + GetElevation( m_nPhase, ptTest, vtTool, 0.5 * m_TParams.m_dDiam, vtAppr1, dSawStartElev1) ; + GetElevation( m_nPhase, ptTest, vtTool, 0.5 * m_TParams.m_dDiam, vtAppr2, dSawStartElev2) ; + if ( dSawStartElev1 > EPS_SMALL && dSawStartElev2 > EPS_SMALL) { + bool bFirst = ( dSawStartElev1 < dSawStartElev2) ; + vtAppr = ( bFirst ? vtAppr1 : vtAppr2) ; + dSawStartElev = ( bFirst ? dSawStartElev1 : dSawStartElev2) ; + bSideStart = true ; + } + else if ( dSawStartElev1 > EPS_SMALL) { + vtAppr = vtAppr1 ; + dSawStartElev = dSawStartElev1 ; + bSideStart = true ; + } + else if ( dSawStartElev2 > EPS_SMALL) { + vtAppr = vtAppr2 ; + dSawStartElev = dSawStartElev2 ; + bSideStart = true ; } } if ( ! bGeomAboveStart && ! bUnderStart && ! bSideStart && bOk) { @@ -2307,7 +2323,7 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo bOk = false ; } // aggiungo opportuno approccio - if ( ! AddSawBladeSideApproach( ptP1, vtCorr, dSafeZ, dSawStartElev, dAppr)) { + if ( ! AddSawBladeSideApproach( ptP1, vtAppr, dSafeZ, dSawStartElev, dAppr)) { m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ; return false ; } @@ -2409,13 +2425,10 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo // per lame quando è necessario else { // verifico di uscire in aria - 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) ; + Vector3d vtRetr( vtTool.x, vtTool.y, 0) ; + if ( ! vtRetr.Normalize()) + vtRetr = FromNearestHorizontalOrtho( vtTool, ptP1 - ptEnd) ; + bool bOutEnd = GetPointOutOfRaw( ptP1, vtTool, vtRetr, dElev, dSafeZ) ; if ( ! bOutEnd) { // verifico se sono sopra bool bGeomAboveEnd = GetPointAboveRaw( ptP1, vtTool) ; @@ -2425,14 +2438,32 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo 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) ; + GetRadiusForStartEndElevation( false), m_TParams.m_dLen, true, dSafeZ, vtRetr, 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 ; + Point3d ptTest = ptP1 - MIN_SAFEDIST * ( m_bAboveHead ? Z_AX : -Z_AX) ; + Vector3d vtRetr1 = FromNearestHorizontalOrtho( vtTool, ptP1 - ptEnd) ; + Vector3d vtRetr2 = ptP1 - ptEnd ; + if ( ! vtRetr2.Normalize()) + vtRetr2 = CalcCorrDir( pCompo, i + 1) ; + double dSawEndElev1, dSawEndElev2 ; + GetElevation( m_nPhase, ptTest, vtTool, 0.5 * m_TParams.m_dDiam, vtRetr1, dSawEndElev1) ; + GetElevation( m_nPhase, ptTest, vtTool, 0.5 * m_TParams.m_dDiam, vtRetr2, dSawEndElev2) ; + if ( dSawEndElev1 > EPS_SMALL && dSawEndElev2 > EPS_SMALL) { + bool bFirst = ( dSawEndElev1 < dSawEndElev2) ; + vtRetr = ( bFirst ? vtRetr1 : vtRetr2) ; + dSawEndElev = ( bFirst ? dSawEndElev1 : dSawEndElev2) ; + bSideEnd = true ; + } + else if ( dSawEndElev1 > EPS_SMALL) { + vtRetr = vtRetr1 ; + dSawEndElev = dSawEndElev1 ; + bSideEnd = true ; + } + else if ( dSawEndElev2 > EPS_SMALL) { + vtRetr = vtRetr2 ; + dSawEndElev = dSawEndElev2 ; + bSideEnd = true ; } } if ( ! bGeomAboveEnd && ! bUnderEnd && ! bSideEnd && bOk) { @@ -2440,12 +2471,11 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo bOk = false ; } // aggiungo opportuna retrazione - if ( ! AddSawBladeSideRetract( ptP1, vtCorr, dSafeZ, dSawEndElev, dAppr)) { + if ( ! AddSawBladeSideRetract( ptP1, vtRetr, dSafeZ, dSawEndElev, dAppr)) { m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ; return false ; } } - } } } @@ -3605,13 +3635,10 @@ Milling::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, //---------------------------------------------------------------------------- bool -Milling::AddSawBladeSideApproach( const Point3d& ptP, const Vector3d& vtCorr, double dSafeZ, double dStElev, double dAppr) +Milling::AddSawBladeSideApproach( const Point3d& ptP, const Vector3d& vtAppr, double dSafeZ, double dStElev, double dAppr) { SetFlag( 1) ; - // 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() ; + // per approccio orizzontale vtAppr deve essere già stato sistemato dal chiamante // 1 -> punto fuori inizio Point3d ptP1 = ptP + vtAppr * ( dStElev + max( dAppr, dSafeZ)) ; if ( AddRapidStart( ptP1) == GDB_ID_NULL) @@ -3728,31 +3755,28 @@ Milling::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, //---------------------------------------------------------------------------- bool -Milling::AddSawBladeSideRetract( const Point3d& ptP, const Vector3d& vtCorr, double dSafeZ, double dEndElev, double dAppr) +Milling::AddSawBladeSideRetract( const Point3d& ptP, const Vector3d& vtRetr, double dSafeZ, double dEndElev, double dAppr) { - // 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() ; + // per retrazione orizzontale vtAppr deve essere già stato sistemato dal chiamante // se sopra uscita c'è spazio per sicurezza o approccio if ( dEndElev + max( dSafeZ, dAppr) > 10 * EPS_SMALL) { if ( dSafeZ < dAppr + 10 * EPS_SMALL) { // 4 -> movimento di risalita sopra il punto finale SetFeed( GetEndFeed()) ; - Point3d ptP4 = ptP + vtAppr * ( dEndElev + dAppr) ; + Point3d ptP4 = ptP + vtRetr * ( dEndElev + dAppr) ; if ( AddLinearMove( ptP4) == GDB_ID_NULL) return false ; } else { // 4a -> movimento di risalita appena sopra il punto finale - Point3d ptP4a = ptP + vtAppr * ( dEndElev + dAppr) ; + Point3d ptP4a = ptP + vtRetr * ( dEndElev + dAppr) ; if ( dEndElev + dAppr > EPS_SMALL) { SetFeed( GetEndFeed()) ; if ( AddLinearMove( ptP4a) == GDB_ID_NULL) return false ; } // 4b -> movimento di risalita sopra il punto finale - Point3d ptP4b = ptP4a + vtAppr * ( dSafeZ - dAppr) ; + Point3d ptP4b = ptP4a + vtRetr * ( dSafeZ - dAppr) ; if ( AddRapidMove( ptP4b) == GDB_ID_NULL) return false ; } diff --git a/Milling.h b/Milling.h index e438382..57b83c8 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& vtCorr, double dSafeZ, double dStElev, double dAppr) ; + bool AddSawBladeSideApproach( const Point3d& ptP, const Vector3d& vtAppr, 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& vtCorr, double dSafeZ, double dEndElev, double dAppr) ; + bool AddSawBladeSideRetract( const Point3d& ptP, const Vector3d& vtRetr, 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, diff --git a/Operation.cpp b/Operation.cpp index 138aa4b..adf2097 100644 --- a/Operation.cpp +++ b/Operation.cpp @@ -168,7 +168,7 @@ Operation::GetElevation( int nPhase, const Point3d& ptP, // verifico che il grezzo compaia nella fase if ( m_pMchMgr->VerifyRawPartPhase( nRawId, nPhase)) { // intersezione del raggio dal punto alla trimesh del grezzo - const double RAY_LEN = 10000 ; + const double RAY_LEN = 100000 ; int nStmId = m_pGeomDB->GetFirstNameInGroup( nRawId, MACH_RAW_SOLID) ; ISurfTriMesh* pStm = GetSurfTriMesh( m_pGeomDB->GetGeoObj( nStmId)) ; if ( pStm != nullptr) { @@ -197,9 +197,15 @@ Operation::GetElevation( int nPhase, const Point3d& ptP, else if ( Info.dCosDN > - COS_ORTO_ANG_ZERO) { dElev = min( dElev, Info.dU) ; } - // se altrimenti è la prima, distante ed entra, salto tutto - else if ( i == 0 && Info.dU > MAX_DIST_RAW && Info.dCosDN < - COS_ORTO_ANG_ZERO) - break ; + // se altrimenti è la prima ed entra + else if ( i == 0 && Info.dCosDN < - COS_ORTO_ANG_ZERO) { + // se una sola o distante salto tutto + if ( vInfo.size() == 1 || Info.dU > ( dElev > INFINITO - 1 ? 0 : dElev) + MAX_DIST_RAW) + break ; + // altrimenti reset + else + dElev = INFINITO ; + } } } }