From e3121ff553223cd9eca539c29f1d11f2b7b6fa8c Mon Sep 17 00:00:00 2001 From: DarioS Date: Fri, 17 Feb 2023 12:08:10 +0100 Subject: [PATCH] EgtMachKernel 2.5b3 : - modifiche quote approccio e retrazione --- Drilling.cpp | 3 +- Drilling.h | 1 + EgtMachKernel.rc | Bin 11774 -> 11774 bytes Machine.h | 2 +- MachineCalc.cpp | 13 ++- Milling.cpp | 218 +++++++++++++++++++++++++++++----------------- Milling.h | 1 + Mortising.cpp | 8 +- Operation.cpp | 147 +++++++++++++++++++++++++++---- Operation.h | 10 ++- Pocketing.cpp | 123 +++++++++++++++++--------- Pocketing.h | 7 +- SurfFinishing.cpp | 5 +- 13 files changed, 389 insertions(+), 149 deletions(-) diff --git a/Drilling.cpp b/Drilling.cpp index efe5bdc..101790c 100644 --- a/Drilling.cpp +++ b/Drilling.cpp @@ -95,6 +95,7 @@ Drilling::Clone( void) const pDri->m_nStatus = m_nStatus ; pDri->m_nDrillings = m_nDrillings ; pDri->m_bTiltingTab = m_bTiltingTab ; + pDri->m_vtTiltingAx = m_vtTiltingAx ; pDri->m_bAboveHead = m_bAboveHead ; pDri->m_bAggrBottom = m_bAggrBottom ; } @@ -1042,7 +1043,7 @@ Drilling::GenerateHoleCl( int nInd, const SelData& nCircId, const string& sPName } // verifico se tavola basculante bool bTiltTab = false ; - m_bTiltingTab = ( m_pMchMgr->GetCurrMachine()->GetCurrTableIsTilting( bTiltTab) && bTiltTab) ; + m_bTiltingTab = ( m_pMchMgr->GetCurrMachine()->GetCurrTableIsTilting( bTiltTab, m_vtTiltingAx) && bTiltTab) ; // verifico se testa da sopra (Z+) m_bAboveHead = m_pMchMgr->GetHeadAbove( m_TParams.m_sHead) ; // verifiche per foro verso il basso diff --git a/Drilling.h b/Drilling.h index 299e8aa..41287b0 100644 --- a/Drilling.h +++ b/Drilling.h @@ -100,6 +100,7 @@ class Drilling : public Machining int m_nStatus ; // stato di aggiornamento della lavorazione int m_nDrillings ; // numero di fori generati bool m_bTiltingTab ; // flag utilizzo tavola basculante + Vector3d m_vtTiltingAx ; // versore direzione eventuale asse basculante bool m_bAboveHead ; // flag utilizzo testa da sopra bool m_bAggrBottom ; // flag di utilizzo dell'aggregato da sotto Vector3d m_vtAggrBottom ; // vettore direzione ausiliaria aggregato da sotto diff --git a/EgtMachKernel.rc b/EgtMachKernel.rc index de5c6ee74fe8ec97205fe0b2cf754a69f13a1254..119ee14ab9e4de8213f679ea4654d09c07d5a6d7 100644 GIT binary patch delta 97 zcmewt{V#gMFE&Qw&A-`fnHh~IKa|wnoW?bQ1uSxrY4Qod0+^@}R1`^_2jk{d(jGv4 NK<#LXK~l;gTmUD-Bai?9 delta 97 zcmewt{V#gMFE&P_&A-`fnHh~HKa|wnoW?bQ1uSxrY4Qod0+^@}R1`^_2jk{d(jGv4 NK<#LXK~l;gTmU8!BZvS1 diff --git a/Machine.h b/Machine.h index 1560eb0..116cbba 100644 --- a/Machine.h +++ b/Machine.h @@ -95,7 +95,7 @@ class Machine bool GetCurrTableRef1( Point3d& ptRef1) const ; bool GetCurrTableArea1( BBox3d& b3Area1) const ; bool GetCurrTableDeltaRef1( Vector3d& vtDelta1) const ; - bool GetCurrTableIsTilting( bool& bTilting) const ; + bool GetCurrTableIsTilting( bool& bTilting, Vector3d& vtTiltingAx) const ; bool SetCurrTool( const std::string& sTool, const std::string& sHead, int nExit) ; bool ResetCurrTool( void) ; int GetCurrTool( void) const ; diff --git a/MachineCalc.cpp b/MachineCalc.cpp index 775007d..13369ce 100644 --- a/MachineCalc.cpp +++ b/MachineCalc.cpp @@ -167,17 +167,23 @@ Machine::GetCurrTableDeltaRef1( Vector3d& vtDelta1) const //---------------------------------------------------------------------------- bool -Machine::GetCurrTableIsTilting( bool& bTilting) const +Machine::GetCurrTableIsTilting( bool& bTilting, Vector3d& vtTiltingAx) const { // default bTilting = false ; + vtTiltingAx = V_NULL ; // verifico esistenza tavola if ( m_nCalcTabId == GDB_ID_NULL) return false ; // verifico se presente flag che lo forza come tale - bool bTiltingLike ; - if ( m_pGeomDB->GetInfo( m_nCalcTabId, MCH_TILTINGLIKE, bTiltingLike) && bTiltingLike) { + int nTiltingLike ; + if ( m_pGeomDB->GetInfo( m_nCalcTabId, MCH_TILTINGLIKE, nTiltingLike) && nTiltingLike != 0) { bTilting = true ; + switch ( abs( nTiltingLike)) { + default : vtTiltingAx = X_AX ; break ; + case 2 : vtTiltingAx = Y_AX ; break ; + case 3 : vtTiltingAx = Z_AX ; break ; + } return true ; } // recupero gli eventuali assi rotanti della tavola @@ -192,6 +198,7 @@ Machine::GetCurrTableIsTilting( bool& bTilting) const // verifico se asse rotante orizzontale if ( pAx->GetType() == MCH_AT_ROTARY && abs( pAx->GetDir().z) < EPS_SMALL) { bTilting = true ; + vtTiltingAx = pAx->GetDir() ; return true ; } // risalgo lungo la catena diff --git a/Milling.cpp b/Milling.cpp index 76171a3..a218840 100644 --- a/Milling.cpp +++ b/Milling.cpp @@ -119,6 +119,7 @@ Milling::Clone( void) const pMill->m_dAddedOverlap = m_dAddedOverlap ; pMill->m_nHeadSolCh = m_nHeadSolCh ; pMill->m_bTiltingTab = m_bTiltingTab ; + pMill->m_vtTiltingAx = m_vtTiltingAx ; pMill->m_bAboveHead = m_bAboveHead ; pMill->m_bAggrBottom = m_bAggrBottom ; pMill->m_dCurrOscillLen = m_dCurrOscillLen ; @@ -1867,7 +1868,7 @@ Milling::ProcessPath( int nPathId, int nPvId, int nClId) // verifico se tavola basculante bool bTiltTab = false ; - m_bTiltingTab = ( m_pMchMgr->GetCurrMachine()->GetCurrTableIsTilting( bTiltTab) && bTiltTab) ; + m_bTiltingTab = ( m_pMchMgr->GetCurrMachine()->GetCurrTableIsTilting( bTiltTab, m_vtTiltingAx) && bTiltTab) ; // verifico se testa da sopra (Z+) m_bAboveHead = m_pMchMgr->GetHeadAbove( m_TParams.m_sHead) ; @@ -2297,16 +2298,22 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) { // correggo elevazione iniziale per punto inizio attacco (se testa da sopra senza aggregato approccio mai Z-) Vector3d vtEscape = vtTool ; - if ( m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && vtTool.z < - EPS_SMALL) { + if ( ( m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && vtTool.z < -EPS_SMALL) || + ( ! m_bAboveHead && vtTool.z > EPS_SMALL)) { vtEscape.z = 0 ; vtEscape.Normalize() ; } double dNewStElev ; - 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 è 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, vtTool, dStElev) ; + if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev)) { + if ( bAboveStart || dNewStElev > EPS_SMALL) + dStElev = min( dStElev, dNewStElev) ; + } + // se testa sopra, determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione + bool bAhUnderStart = m_bAboveHead && GetAhPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), + m_TParams.m_dLen, false, dSafeZ, vtEscape, dStElev) ; + // se testa sotto, determino se l'inizio dell'attacco è esattamente sopra il grezzo, nel qual caso ricalcolo l'elevazione + bool bUhAboveStart = ! m_bAboveHead && GetUhPointAboveRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), + m_TParams.m_dLen, false, dSafeZ, vtEscape, dStElev) ; // se attacco a zigzag o a spirale, l'elevazione va nell'attacco if ( IsLeadInHelixOrZigzag()) { ptP1 += vtTool * ( dStElev + LIO_ELEV_TOL) ; @@ -2327,8 +2334,9 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo 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, vtAppr, dSawStartElev) ; + bUnderStart = m_bAboveHead && GetAhPointUnderRaw( ptP1, vtTool, m_TParams.m_dTDiam / 2, + 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) @@ -2454,16 +2462,22 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo } // correggo elevazione finale per punto fine uscita (se testa da sopra senza aggregato approccio mai Z-) Vector3d vtEscape = vtTool ; - if ( m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && vtTool.z < - EPS_SMALL) { + if ( ( m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && vtTool.z < -EPS_SMALL) || + ( ! m_bAboveHead && vtTool.z > EPS_SMALL)) { vtEscape.z = 0 ; vtEscape.Normalize() ; } double dNewEndElev ; - if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev) && dNewEndElev > EPS_SMALL) - 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, vtTool, dEndElev) ; + if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev)) { + if ( bAboveEnd || dNewEndElev > EPS_SMALL) + dEndElev = min( dEndElev, dNewEndElev) ; + } + // se testa sopra, determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione + bool bAhUnderEnd = m_bAboveHead && GetAhPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), + m_TParams.m_dLen, false, dSafeZ, vtEscape, dEndElev) ; + // se testa sotto, determino se l'inizio dell'uscita è esattamente sopra il grezzo, nel qual caso ricalcolo l'elevazione + bool bUhAboveEnd = ! m_bAboveHead && GetUhPointAboveRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), + m_TParams.m_dLen, false, dSafeZ, vtEscape, dEndElev) ; // aggiungo retrazione if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bAboveEnd)) { m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ; @@ -2485,8 +2499,9 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo 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, vtRetr, dSawEndElev) ; + bUnderEnd = m_bAboveHead && GetAhPointUnderRaw( ptP1, vtTool, m_TParams.m_dTDiam / 2, + GetRadiusForStartEndElevation( false), + m_TParams.m_dLen, true, dSafeZ, vtRetr, dSawEndElev) ; } if ( ! bUnderEnd) { Point3d ptTest = ptP1 - MIN_SAFEDIST * ( m_bAboveHead ? Z_AX : -Z_AX) ; @@ -2623,16 +2638,22 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool if ( k == 1 && ( m_TParams.m_nType & TF_SAWBLADE) == 0) { // correggo elevazione iniziale per punto inizio attacco (se testa da sopra senza aggregato approccio mai Z-) Vector3d vtEscape = vtTool ; - if ( m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && vtTool.z < - EPS_SMALL) { + if ( ( m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && vtTool.z < -EPS_SMALL) || + ( ! m_bAboveHead && vtTool.z > EPS_SMALL)) { vtEscape.z = 0 ; vtEscape.Normalize() ; } double dNewStElev ; - 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 è 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, vtTool, dStElev) ; + if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev)) { + if ( bAboveStart || dNewStElev > EPS_SMALL) + dStElev = min( dStElev, dNewStElev) ; + } + // se testa sopra determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione + bool bAhUnderStart = m_bAboveHead && GetAhPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), + m_TParams.m_dLen, false, dSafeZ, vtEscape, dStElev) ; + // se testa sotto determino se l'inizio dell'attacco è esattamente sopra il grezzo, nel qual caso ricalcolo l'elevazione + bool bUhAboveStart = ! m_bAboveHead && GetUhPointAboveRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), + m_TParams.m_dLen, false, dSafeZ, vtEscape, dStElev) ; // se attacco a zigzag o a spirale, l'elevazione va nell'attacco if ( IsLeadInHelixOrZigzag()) { ptP1 += vtTool * ( dStElev + LIO_ELEV_TOL) ; @@ -2762,16 +2783,22 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool } // correggo elevazione finale per punto fine uscita (se testa da sopra senza aggregato approccio mai Z-) Vector3d vtEscape = vtTool ; - if ( m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && vtTool.z < - EPS_SMALL) { + if ( ( m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && vtTool.z < -EPS_SMALL) || + ( ! m_bAboveHead && vtTool.z > EPS_SMALL)) { vtEscape.z = 0 ; vtEscape.Normalize() ; } double dNewEndElev ; - if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev) && dNewEndElev > EPS_SMALL) - 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, vtTool, dEndElev) ; + if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev)) { + if ( bAboveEnd || dNewEndElev > EPS_SMALL) + dEndElev = min( dEndElev, dNewEndElev) ; + } + // se testa sopra, determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione + bool bAhUnderEnd = m_bAboveHead && GetAhPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), + m_TParams.m_dLen, false, dSafeZ, vtEscape, dEndElev) ; + // se testa sotto, determino se l'inizio dell'uscita è esattamente sopra il grezzo, nel qual caso ricalcolo l'elevazione + bool bUhAboveEnd = ! m_bAboveHead && GetUhPointAboveRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), + m_TParams.m_dLen, false, dSafeZ, vtEscape, dEndElev) ; // aggiungo retrazione if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bAboveEnd)) { m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ; @@ -2943,20 +2970,24 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool // correggo elevazione iniziale per punto inizio attacco (se testa da sopra senza aggregato approccio mai Z-) Point3d ptP1m = ptP1 - 10 * EPS_SMALL * vtTool ; Vector3d vtEscape = vtTool ; - if ( m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && vtTool.z < - EPS_SMALL) { + if ( ( m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && vtTool.z < -EPS_SMALL) || + ( ! m_bAboveHead && vtTool.z > EPS_SMALL)) { vtEscape.z = 0 ; vtEscape.Normalize() ; } double dNewStElev ; - if ( GetElevation( m_nPhase, ptP1m, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev) && dNewStElev > EPS_SMALL) { + if ( GetElevation( m_nPhase, ptP1m, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev)) { if ( bAboveStartEnd) dStElev = min( dStElev, dNewStElev) ; - else + else if ( dNewStElev > EPS_SMALL) dStElev = max( 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, vtTool, dStElev) ; + // se testa sopra, determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione + bool bAhUnderStart = m_bAboveHead && GetAhPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), + m_TParams.m_dLen, false, dSafeZ, vtEscape, dStElev) ; + // se testa sotto, determino se l'inizio dell'attacco è esattamente sopra il grezzo, nel qual caso ricalcolo l'elevazione + bool bUhAboveStart = ! m_bAboveHead && GetUhPointAboveRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), + m_TParams.m_dLen, false, dSafeZ, vtEscape, dStElev) ; // se attacco a zigzag o a spirale, l'elevazione va nell'attacco if ( IsLeadInHelixOrZigzag()) { ptP1 += vtTool * ( dStElev - ( j - 1) * dStep) ; @@ -3065,20 +3096,24 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool // correggo elevazione finale per punto fine uscita (se testa da sopra senza aggregato approccio mai Z-) Point3d ptP1m = ptP1 - 10 * EPS_SMALL * vtTool ; Vector3d vtEscape = vtTool ; - if ( m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && vtTool.z < - EPS_SMALL) { + if ( ( m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && vtTool.z < -EPS_SMALL) || + ( ! m_bAboveHead && vtTool.z > EPS_SMALL)) { vtEscape.z = 0 ; vtEscape.Normalize() ; } double dNewEndElev ; - if ( GetElevation( m_nPhase, ptP1m, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev) && dNewEndElev > EPS_SMALL) { - if ( bAboveStartEnd) + if ( GetElevation( m_nPhase, ptP1m, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev)) { + if ( bAboveStartEnd ) dEndElev = min( dEndElev, dNewEndElev) ; - else + else if ( dNewEndElev > EPS_SMALL) dEndElev = max( 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, vtTool, dEndElev) ; + // se testa sopra, determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione + bool bAhUnderEnd = m_bAboveHead && GetAhPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), + m_TParams.m_dLen, false, dSafeZ, vtEscape, dEndElev) ; + // se testa sotto, determino se l'inizio dell'uscita è esattamente sopra il grezzo, nel qual caso ricalcolo l'elevazione + bool bUhAboveEnd = ! m_bAboveHead && GetUhPointAboveRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), + m_TParams.m_dLen, false, dSafeZ, vtEscape, dEndElev) ; // aggiungo retrazione if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bAboveStartEnd)) { m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ; @@ -3168,16 +3203,22 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) { // correggo elevazione iniziale per punto inizio attacco (se testa da sopra senza aggregato approccio mai Z-) Vector3d vtEscape = vtTool ; - if ( m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && vtTool.z < - EPS_SMALL) { + if ( ( m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && vtTool.z < -EPS_SMALL) || + ( ! m_bAboveHead && vtTool.z > EPS_SMALL)) { vtEscape.z = 0 ; vtEscape.Normalize() ; } double dNewStElev ; - 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 è 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, vtTool, dStElev) ; + if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev)) { + if ( bAboveStart || dNewStElev > EPS_SMALL) + dStElev = min( dStElev, dNewStElev) ; + } + // se testa sopra, determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione + bool bAhUnderStart = m_bAboveHead && GetAhPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), + m_TParams.m_dLen, false, dSafeZ, vtEscape, dStElev) ; + // se testa sotto, determino se l'inizio dell'attacco è esattamente sopra il grezzo, nel qual caso ricalcolo l'elevazione + bool bUhAboveStart = ! m_bAboveHead && GetUhPointAboveRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), + m_TParams.m_dLen, false, dSafeZ, vtEscape, 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") ; @@ -3271,16 +3312,22 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool bool bAboveEnd = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ; // correggo elevazione finale per punto fine uscita (se testa da sopra senza aggregato approccio mai Z-) Vector3d vtEscape = vtTool ; - if ( m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && vtTool.z < - EPS_SMALL) { + if ( ( m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && vtTool.z < -EPS_SMALL) || + ( ! m_bAboveHead && vtTool.z > EPS_SMALL)) { vtEscape.z = 0 ; vtEscape.Normalize() ; } double dNewEndElev ; - if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev) && dNewEndElev > EPS_SMALL) - 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, vtTool, dEndElev) ; + if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev)) { + if ( bAboveEnd || dNewEndElev > EPS_SMALL) + dEndElev = min( dEndElev, dNewEndElev) ; + } + // se testa sopra, determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione + bool bAhUnderEnd = m_bAboveHead && GetAhPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), + m_TParams.m_dLen, false, dSafeZ, vtEscape, dEndElev) ; + // se testa sotto, determino se l'inizio dell'uscita è esattamente sopra il grezzo, nel qual caso ricalcolo l'elevazione + bool bUhAboveEnd = ! m_bAboveHead && GetUhPointAboveRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), + m_TParams.m_dLen, false, dSafeZ, vtEscape, dEndElev) ; // aggiungo retrazione if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bAboveEnd)) { m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ; @@ -3334,27 +3381,33 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool Point3d ptP1 ; if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, dStElev, bInvert, pCompo, ptP1)) return false ; + // determino se l'inizio dell'attacco è fuori dal grezzo + 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 CalcAndSetCorrAuxDir( pCompo, ( bInvert ? nMaxInd - i + 1 : i)) ; // 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-) Vector3d vtEscape = vtTool ; - if ( m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && vtTool.z < - EPS_SMALL) { + if ( ( m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && vtTool.z < -EPS_SMALL) || + ( ! m_bAboveHead && vtTool.z > EPS_SMALL)) { vtEscape.z = 0 ; vtEscape.Normalize() ; } double dNewStElev ; - 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 - 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, vtTool, dStElev) ; + if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev)) { + if ( bAboveStart || dNewStElev > EPS_SMALL) + dStElev = min( dStElev, dNewStElev) ; + } + // se testa sopra, determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione + bool bAhUnderStart = m_bAboveHead && GetAhPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), + m_TParams.m_dLen, false, dSafeZ, vtEscape, dStElev) ; + // se testa sotto, determino se l'inizio dell'attacco è esattamente sopra il grezzo, nel qual caso ricalcolo l'elevazione + bool bUhAboveStart = ! m_bAboveHead && GetUhPointAboveRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), + m_TParams.m_dLen, false, dSafeZ, vtEscape, 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") ; @@ -3443,16 +3496,22 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool bool bAboveEnd = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ; // correggo elevazione finale per punto fine uscita (se testa da sopra senza aggregato approccio mai Z-) Vector3d vtEscape = vtTool ; - if ( m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && vtTool.z < - EPS_SMALL) { + if ( ( m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && vtTool.z < -EPS_SMALL) || + ( ! m_bAboveHead && vtTool.z > EPS_SMALL)) { vtEscape.z = 0 ; vtEscape.Normalize() ; } double dNewEndElev ; - if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev) && dNewEndElev > EPS_SMALL) - 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, vtTool, dEndElev) ; + if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev)) { + if ( bAboveEnd || dNewEndElev > EPS_SMALL) + dEndElev = min( dEndElev, dNewEndElev) ; + } + // se testa sopra, determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione + bool bAhUnderEnd = m_bAboveHead && GetAhPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), + m_TParams.m_dLen, false, dSafeZ, vtEscape, dEndElev) ; + // se testa sotto, determino se l'inizio dell'uscita è esattamente sopra il grezzo, nel qual caso ricalcolo l'elevazione + bool bUhAboveEnd = ! m_bAboveHead && GetUhPointAboveRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), + m_TParams.m_dLen, false, dSafeZ, vtEscape, dEndElev) ; // aggiungo retrazione if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bAboveEnd)) { m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ; @@ -3686,16 +3745,18 @@ Milling::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, SetFlag( 0) ; } } - // se testa da sopra senza aggregato da sotto, approccio mai da Z negativo + // se testa da sopra senza aggregato da sotto e non con tavola basculante, approccio mai da Z negativo + // oppure testa da sotto, approccio mai da Z positivo Vector3d vtAppr = vtTool ; - if ( m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && vtTool.z < - EPS_SMALL) { + if ( ( m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && vtTool.z < - EPS_SMALL) || + ( ! m_bAboveHead && vtTool.z > EPS_SMALL)) { vtAppr.z = 0 ; vtAppr.Normalize() ; } // se non sono già sopra il pezzo e sopra attacco c'è spazio per sicurezza o approccio double dSafeDist = ( m_bAggrBottom ? dSafeAggrBottZ : dSafeZ) ; double dElevZ = vtAppr.z * dElev ; - if ( ( ! bAboveStart || m_bTiltingTab) && ! bBottomStart && dElev + max( dSafeDist, dAppr) > 10 * EPS_SMALL) { + if ( ! bAboveStart && ! bBottomStart && dElev + max( dSafeDist, dAppr) > 10 * EPS_SMALL) { // se distanza di sicurezza minore di distanza di inizio if ( dSafeDist < dAppr + 10 * EPS_SMALL) { // 1 -> punto sopra inizio @@ -3787,7 +3848,8 @@ Milling::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, { // se testa da sopra senza aggregato da sotto, retrazione mai da Z negativo Vector3d vtAppr = vtTool ; - if ( m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && vtTool.z < - EPS_SMALL) { + if ( ( m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && vtTool.z < - EPS_SMALL) || + ( ! m_bAboveHead && vtTool.z > EPS_SMALL)) { vtAppr.z = 0 ; vtAppr.Normalize() ; } @@ -3803,7 +3865,7 @@ Milling::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, // se non sono già sopra il pezzo e sopra uscita c'è spazio per sicurezza o approccio double dSafeDist = ( m_bAggrBottom ? dSafeAggrBottZ : dSafeZ) ; double dElevZ = vtAppr.z * dElev ; - if ( ( ! bAboveEnd || m_bTiltingTab) && ! bBottomOutStart && dElev + max( dSafeDist, dAppr) > 10 * EPS_SMALL) { + if ( ! bAboveEnd && ! bBottomOutStart && dElev + max( dSafeDist, dAppr) > 10 * EPS_SMALL) { if ( dSafeDist < dAppr + 10 * EPS_SMALL) { // 4 -> movimento di risalita sopra il punto finale SetFeed( GetEndFeed()) ; @@ -5396,7 +5458,7 @@ Milling::GetRadiusForStartEndElevation( bool bExtra) const if ( ! bExtra) return ( 0.5 * m_TParams.m_dTDiam) ; // aumentato - const double DELTA_ELEV_RAD = 2.0 ; + const double DELTA_ELEV_RAD = 4.0 ; double dDeltaRad = min( DELTA_ELEV_RAD, 0.5 * m_TParams.m_dTDiam) ; return ( 0.5 * m_TParams.m_dTDiam + dDeltaRad) ; } @@ -5432,7 +5494,7 @@ Milling::GetPointOutOfRaw( const Point3d& ptP, const Vector3d& vtTool, const Vec if ( ! m_bTiltingTab) return false ; } - // se tavola rotante (o asse basculante) e non esterno, provo in direzione utensile + // se tavola basculante (o asse ralla) e non esterno, provo in direzione utensile if ( m_bTiltingTab && ! bOut) { vtMove = vtTool ; if ( ! GetElevation( m_nPhase, ptQ, vtTool, 0.5 * m_TParams.m_dDiam, vtMove, dTemp) || dTemp > 10 * EPS_SMALL) diff --git a/Milling.h b/Milling.h index 4448ff8..9b2f6ee 100644 --- a/Milling.h +++ b/Milling.h @@ -160,6 +160,7 @@ class Milling : public Machining double m_dAddedOverlap ; // overlap effettivamente aggiunto a percorso chiuso int m_nHeadSolCh ; // criterio scelta soluzione impostato nella testa bool m_bTiltingTab ; // flag utilizzo tavola basculante + Vector3d m_vtTiltingAx ; // versore direzione eventuale asse basculante bool m_bAboveHead ; // flag utilizzo testa da sopra bool m_bAggrBottom ; // flag utilizzo di aggregato da sotto Vector3d m_vtAggrBottom ; // vettore direzione ausiliaria aggregato da sotto diff --git a/Mortising.cpp b/Mortising.cpp index 0d2904b..bc96a37 100644 --- a/Mortising.cpp +++ b/Mortising.cpp @@ -1537,8 +1537,8 @@ Mortising::GenerateOnePlungeCl( const Point3d& ptStart, const Point3d& ptEnd, co double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() + m_pMchMgr->GetDeltaSafeZ( m_TParams.m_sHead) ; double dStartElev = 0 ; Point3d ptLi = ( nPlunge != MORTISE_PLUNGE_END ? ptStart : ptEnd) + vtTool * dDelta ; - bool bUnderStart = GetPointUnderRaw( ptLi, vtTool, 0, - GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dStartElev) ; + bool bUnderStart = GetAhPointUnderRaw( ptLi, vtTool, 0, + 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) ; @@ -1643,8 +1643,8 @@ Mortising::GenerateOnePlungeCl( const Point3d& ptStart, const Point3d& ptEnd, co // determino se la fine dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione double dEndElev = 0 ; Point3d ptLo = ptLast + vtTool * dDelta ; - bool bUnderEnd = GetPointUnderRaw( ptLo, vtTool, 0, - GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dEndElev) ; + bool bUnderEnd = GetAhPointUnderRaw( ptLo, vtTool, 0, + 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 3100b77..177edff 100644 --- a/Operation.cpp +++ b/Operation.cpp @@ -170,13 +170,32 @@ Operation::GetElevation( int nPhase, const Point3d& ptP, const Vector3d& vtDir, double& dElev) const { Vector3d vtNorm ; - return GetElevation( nPhase, ptP, vtDir, dElev, vtNorm) ; + INTVECTOR vRawStmId ; + return GetElevation( nPhase, ptP, vtDir, dElev, vtNorm, vRawStmId) ; } //---------------------------------------------------------------------------- bool Operation::GetElevation( int nPhase, const Point3d& ptP, const Vector3d& vtDir, double& dElev, Vector3d& vtNorm) const +{ + INTVECTOR vRawStmId ; + return GetElevation( nPhase, ptP, vtDir, dElev, vtNorm, vRawStmId) ; +} + +//---------------------------------------------------------------------------- +bool +Operation::GetElevation( int nPhase, const Point3d& ptP, + const Vector3d& vtDir, double& dElev, INTVECTOR& vRawStmId) const +{ + Vector3d vtNorm ; + return GetElevation( nPhase, ptP, vtDir, dElev, vtNorm, vRawStmId) ; +} + +//---------------------------------------------------------------------------- +bool +Operation::GetElevation( int nPhase, const Point3d& ptP, + const Vector3d& vtDir, double& dElev, Vector3d& vtNorm, INTVECTOR& vRawStmId) const { if ( m_pMchMgr == nullptr || m_pGeomDB == nullptr) return false ; @@ -240,11 +259,13 @@ Operation::GetElevation( int nPhase, const Point3d& ptP, } } } - // se c'è triangolo di intersezione, ne recupero la normale + // se c'è triangolo di intersezione, ne recupero la normale e salvo Id del grezzo if ( nTria != SVT_NULL) { Triangle3d Tria ; if ( pStm->GetTriangle( nTria, Tria)) vtNorm = Tria.GetN() ; + if ( find( vRawStmId.begin(), vRawStmId.end(), nStmId) == vRawStmId.end()) + vRawStmId.emplace_back( nStmId) ; } } } @@ -363,32 +384,66 @@ Operation::GetElevation( int nPhase, const Point3d& ptP, const Vector3d& vtTool, { if ( m_pMchMgr == nullptr || m_pGeomDB == nullptr) return false ; + // vettore grezzi interessati + INTVECTOR vRawStmId ; // considero il punto centrale - if ( ! GetElevation( nPhase, ptP, vtDir, dElev)) + if ( ! GetElevation( nPhase, ptP, vtDir, dElev, vRawStmId)) return false ; - // considero più direzioni sulla circonferenza - const int MIN_STEP = 8 ; - const double LEN_STEP = 25 ; - int nStep = max( int( ( 2 * PIGRECO * dRad) / LEN_STEP), MIN_STEP) ; + // considero più posizioni sulla circonferenza + const int MIN_STEP = 9 ; + const int MAX_STEP = 127 ; + const double LEN_STEP = 12.5 ; + int nStep = Clamp( 2 * int( ( PIGRECO * dRad) / LEN_STEP) + 1, MIN_STEP, MAX_STEP) ; Vector3d vtRad = FromUprightOrtho( vtTool) * dRad ; for ( int i = 0 ; i < nStep ; ++ i) { - // esploro 4 posizioni sulle direzioni - for ( int j = 1 ; j <= 8 ; j *= 2) { - double dElevT = 0 ; - if ( ! GetElevation( nPhase, ptP + vtRad / j, vtDir, dElevT)) - return false ; - dElev = max( dElev, dElevT) ; - } + double dElevT = 0 ; + if ( ! GetElevation( nPhase, ptP + vtRad, vtDir, dElevT, vRawStmId)) + return false ; + dElev = max( dElev, dElevT) ; // passo alla direzione successiva vtRad.Rotate( vtTool, ANG_FULL / nStep) ; } + // considero i vertici che cadono entro il cilindro positivo spazzato dal fondo utensile + for ( auto nRawStmId : vRawStmId) { + // recupero la superficie + const ISurfTriMesh* pStm = GetSurfTriMesh( m_pGeomDB->GetGeoObj( nRawStmId)) ; + if ( pStm != nullptr) { + // recupero il riferimento della trimesh + Frame3d frStm ; + m_pGeomDB->GetGlobFrame( nRawStmId, frStm) ; + // ciclo sui vertici + Point3d ptV ; + int nV = pStm->GetFirstVertex( ptV) ; + while ( nV != SVT_NULL) { + ptV.ToGlob( frStm) ; + double dDist = ( ptV - ptP) * vtDir ; + if ( dDist > EPS_ZERO) { + if ( AreSameOrOppositeVectorApprox( vtTool, vtDir)) { + Vector3d vtOrtho = OrthoCompo( ptV - ptP, vtDir) ; + if ( vtOrtho.SqLen() < dRad * dRad + EPS_ZERO) + dElev = max( dElev, dDist) ; + } + else { + Vector3d vtOrtho = OrthoCompo( ptV - ptP, vtDir) ; + Vector3d vtMajAx = vtTool ^ vtDir ; vtMajAx.Normalize() ; + Vector3d vtMajOrt = ParallCompo( vtOrtho, vtMajAx) ; + Vector3d vtMinOrt = ( vtOrtho - vtMajOrt) / abs( vtTool * vtDir) ; + if ( vtMajOrt.SqLen() + vtMinOrt.SqLen() < dRad * dRad + EPS_ZERO) + dElev = max( dElev, dDist) ; + } + } + nV = pStm->GetNextVertex( nV, ptV) ; + } + } + } + return true ; } //---------------------------------------------------------------------------- bool -Operation::GetPointUnderRaw( const Point3d& ptP, const Vector3d& vtTool, double dToolRad, double dToolRadForElev, - double dToolLen, bool bIsSaw, double dSafeZ, const Vector3d& vtDir, double& dElev) const +Operation::GetAhPointUnderRaw( const Point3d& ptP, const Vector3d& vtTool, double dToolRad, double dToolRadForElev, + double dToolLen, bool bIsSaw, double dSafeZ, const Vector3d& vtDir, double& dElev) const { // punto a metà lunghezza utensile Point3d ptQ = ptP + vtTool * dToolLen / 2 ; @@ -445,6 +500,66 @@ Operation::GetPointUnderRaw( const Point3d& ptP, const Vector3d& vtTool, double return false ; } +//---------------------------------------------------------------------------- +bool +Operation::GetUhPointAboveRaw( const Point3d& ptP, const Vector3d& vtTool, double dToolRad, double dToolRadForElev, + double dToolLen, bool bIsSaw, double dSafeZ, const Vector3d& vtDir, double& dElev) const +{ + // punto a metà lunghezza utensile + Point3d ptQ = ptP + vtTool * dToolLen / 2 ; + // box di ingombro dell'utensile + BBox3d b3Tool ; + b3Tool.Set( ptP) ; + b3Tool.Add( ptQ) ; + double dExpandX = sqrt( 1 - vtTool.x * vtTool.x) * dToolRadForElev ; + double dExpandY = sqrt( 1 - vtTool.y * vtTool.y) * dToolRadForElev ; + double dExpandZ = sqrt( 1 - vtTool.z * vtTool.z) * dToolRadForElev ; + b3Tool.Expand( dExpandX, dExpandY, dExpandZ) ; + // extra ingombro reale in Z + double dExtraZ = sqrt( 1 - vtTool.z * vtTool.z) * dToolRad ; + // direzione di fuga per l'elevazione + 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() ; + while ( nRawId != GDB_ID_NULL) { + // se il grezzo compare nella fase + if ( m_pMchMgr->VerifyRawPartPhase( nRawId, m_nPhase)) { + int nStmId = m_pGeomDB->GetFirstNameInGroup( nRawId, MACH_RAW_SOLID) ; + BBox3d b3Raw ; + m_pGeomDB->GetGlobalBBox( nStmId, b3Raw) ; + b3Raw.Expand( 0.5 * dSafeZ, 0.5 * dSafeZ, 0) ; + if ( ! b3Raw.IsEmpty() && b3Raw.OverlapsXY( b3Tool) && ptP.z - dExtraZ > b3Raw.GetMax().z + 10 * EPS_SMALL) { + double dRawCentZ = ( b3Raw.GetMin().z + b3Raw.GetMax().z) / 2 ; + double dRawDimZ = b3Raw.GetMax().z - b3Raw.GetMin().z ; + double dToolDimZ = b3Tool.GetMax().z - b3Tool.GetMin().z ; + // 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, vtMyDir, dNewElev)) + dElev = max( dElev, dNewElev) ; + // se direzione di fuga quasi orizzontale (max 30 deg) e ingombro utensile rilevante rispetto ad altezza grezzo + 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, 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, vtMyDir, dNewElev)) + dElev = max( dElev, dNewElev) ; + } + return true ; + } + } + nRawId = m_pMchMgr->GetNextRawPart( nRawId) ; + } + return false ; +} + //---------------------------------------------------------------------------- bool Operation::GetDistanceFromRawSide( int nPhase, const Point3d& ptP, const Vector3d& vtDir, double& dDist) const diff --git a/Operation.h b/Operation.h index b6e9142..a841f84 100644 --- a/Operation.h +++ b/Operation.h @@ -71,14 +71,20 @@ class Operation : public IUserObj const Vector3d& vtDir, double& dElev) const ; bool GetElevation( int nPhase, const Point3d& ptP, const Vector3d& vtDir, double& dElev, Vector3d& vtNorm) const ; + bool GetElevation( int nPhase, const Point3d& ptP, + const Vector3d& vtDir, double& dElev, INTVECTOR& vRawStmId) const ; + bool GetElevation( int nPhase, const Point3d& ptP, + const Vector3d& vtDir, double& dElev, Vector3d& vtNorm, INTVECTOR& vRawStmId) const ; bool GetElevation( int nPhase, const Point3d& ptP1, const Point3d& ptP2, const Vector3d& vtDir, double& dElev) const ; bool GetElevation( int nPhase, const Point3d& ptP1, const Point3d& ptP2, const Point3d& ptP3, const Vector3d& vtDir, double& dElev) const ; 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, const Vector3d& vtDir, double& dElev) const ; + bool GetAhPointUnderRaw( const Point3d& ptP, const Vector3d& vtTool, double dToolRad, double dToolRadForElev, + double dToolLen, bool bIsSaw, double dSafeZ, const Vector3d& vtDir, double& dElev) const ; + bool GetUhPointAboveRaw( const Point3d& ptP, const Vector3d& vtTool, double dToolRad, double dToolRadForElev, + 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 ; diff --git a/Pocketing.cpp b/Pocketing.cpp index d1d14a0..53b8c13 100644 --- a/Pocketing.cpp +++ b/Pocketing.cpp @@ -116,6 +116,7 @@ Pocketing::Clone( void) const pPock->m_nStatus = m_nStatus ; pPock->m_nPockets = m_nPockets ; pPock->m_bTiltingTab = m_bTiltingTab ; + pPock->m_vtTiltingAx = m_vtTiltingAx ; pPock->m_bAboveHead = m_bAboveHead ; pPock->m_bAggrBottom = m_bAggrBottom ; pPock->m_bOpenOutRaw = m_bOpenOutRaw ; @@ -1614,7 +1615,7 @@ Pocketing::ProcessPath( int nPathId, int nPvId, int nClId) // verifico se tavola basculante bool bTiltTab = false ; - m_bTiltingTab = ( m_pMchMgr->GetCurrMachine()->GetCurrTableIsTilting( bTiltTab) && bTiltTab) ; + m_bTiltingTab = ( m_pMchMgr->GetCurrMachine()->GetCurrTableIsTilting( bTiltTab, m_vtTiltingAx) && bTiltTab) ; // verifico se testa da sopra (Z+) m_bAboveHead = m_pMchMgr->GetHeadAbove( m_TParams.m_sHead) ; @@ -1747,7 +1748,6 @@ Pocketing::CalcRegionElevation( const ICurveComposite* pCompo, const Vector3d& v int nYStep = max( int( ceil( ( dDimY - 20 * EPS_SMALL) / STEP)), 2) ; double dYStep = ( nYStep > 0 ? ( dDimY - 20 * EPS_SMALL) / nYStep : 0) ; // calcolo le linee di svuotatura - int nCount = 0 ; for ( int i = 1 ; i < nYStep ; ++ i) { // definisco la linea PtrOwner pLine( CreateCurveLine()) ; @@ -2091,9 +2091,13 @@ Pocketing::AddZigZag( const ICurveComposite* pCompo, const Vector3d& vtTool, con double dStElev ; GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev) ; dStElev = max( dStElev, j * dStep) ; - bool bUnderRaw = m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && - GetPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ; - if ( bUnderRaw) + bool bAhUnderRaw = m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && + GetAhPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), + m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ; + bool bUhAboveRaw = ! m_bAboveHead && + GetUhPointAboveRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), + m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ; + if ( bAhUnderRaw || bUhAboveRaw) dStElev = max( dStElev, j * dStep) ; dStElev -= ( ptP1 - ptStart) * vtExtr ; // se ottimizzata e attacco nel grezzo @@ -2157,11 +2161,10 @@ Pocketing::AddZigZag( const ICurveComposite* pCompo, const Vector3d& vtTool, con double dEndElev = dElev ; Point3d ptP1 ; SetFeed( GetEndFeed()) ; - if ( ! AddLeadOut( ptEnd, vtEnd, vtExtr, nullptr, bSplitArcs, ptP1, dEndElev, true)) { + if ( ! AddLeadOut( ptEnd, vtEnd, vtExtr, nullptr, bSplitArcs, true, ptP1, dEndElev)) { m_pMchMgr->SetLastError( 2416, "Error in Pocketing : LeadOut not computable") ; return false ; } - dEndElev = max( dEndElev, j * dStep) ; // se lucidatura o caso ottimizzato e ultimo percorso di ultimo step, aggiungo retrazione if ( ( m_TParams.m_nType == TT_MILL_POLISHING || bOptimizedZigZag) && k == nPath - 1 && j == nStep) { if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr)) { @@ -2239,11 +2242,16 @@ Pocketing::AddZigZag( const ICurveComposite* pCompo, const Vector3d& vtTool, con return false ; // determino elevazione su inizio attacco double dStElev ; - if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev)) + if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, + GetRadiusForStartEndElevation(), vtTool, dStElev)) dStElev = dStep ; - bool bUnderRaw = m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && - GetPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ; - if ( bUnderRaw) + bool bAhUnderRaw = m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && + GetAhPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), + m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ; + bool bUhAboveRaw = ! m_bAboveHead && + GetUhPointAboveRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), + m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ; + if ( bAhUnderRaw || bUhAboveRaw) dStElev = max( dStElev, dStep) ; dStElev -= ( ptP1 - ptStart) * vtExtr ; // se attacco a zigzag o a spirale o a scivolo, l'elevazione va nell'attacco @@ -2306,7 +2314,7 @@ Pocketing::AddZigZag( const ICurveComposite* pCompo, const Vector3d& vtTool, con // aggiungo uscita double dEndElev = dElev ; SetFeed( GetEndFeed()) ; - if ( ! AddLeadOut( ptEnd, vtEnd, vtExtr, nullptr, bSplitArcs, ptP1, dEndElev)) { + if ( ! AddLeadOut( ptEnd, vtEnd, vtExtr, nullptr, bSplitArcs, false, ptP1, dEndElev)) { m_pMchMgr->SetLastError( 2416, "Error in Pocketing : LeadOut not computable") ; return false ; } @@ -3071,9 +3079,13 @@ Pocketing::AddOneWay( const ICurveComposite* pCompo, const Vector3d& vtTool, con double dStElev ; if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev)) dStElev = dStep ; - bool bUnderRaw = m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && - GetPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ; - if ( bUnderRaw) + bool bAhUnderRaw = m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && + GetAhPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), + m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ; + bool bUhAboveRaw = ! m_bAboveHead && + GetUhPointAboveRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), + m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ; + if ( bAhUnderRaw || bUhAboveRaw) dStElev = max( dStElev, dStep) ; dStElev -= ( ptP1 - ptStart) * vtExtr ; // se attacco a zigzag o a spirale o a scivolo, l'elevazione va nell'attacco @@ -3137,7 +3149,7 @@ Pocketing::AddOneWay( const ICurveComposite* pCompo, const Vector3d& vtTool, con Point3d ptP1 ; double dEndElev = dElev ; SetFeed( GetEndFeed()) ; - if ( ! AddLeadOut( ptEnd, vtEnd, vtExtr, nullptr, bSplitArcs, ptP1, dEndElev)) { + if ( ! AddLeadOut( ptEnd, vtEnd, vtExtr, nullptr, bSplitArcs, false, ptP1, dEndElev)) { m_pMchMgr->SetLastError( 2416, "Error in Pocketing : LeadOut not computable") ; return false ; } @@ -3225,9 +3237,13 @@ Pocketing::AddOneWay( const ICurveComposite* pCompo, const Vector3d& vtTool, con double dStElev ; if ( ! GetElevation( m_nPhase, ptS - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev)) dStElev = j * dStep ; - bool bUnderRaw = m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && - GetPointUnderRaw( ptP, vtTool, 0, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ; - if ( bUnderRaw) + bool bAhUnderRaw = m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && + GetAhPointUnderRaw( ptP, vtTool, 0, GetRadiusForStartEndElevation(), + m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ; + bool bUhAboveRaw = ! m_bAboveHead && + GetUhPointAboveRaw( ptP, vtTool, 0, GetRadiusForStartEndElevation(), + m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ; + if ( bAhUnderRaw || bUhAboveRaw) dStElev = max( dStElev, j * dStep) ; dStElev -= ( ptP - ptS) * vtExtr ; // sempre approccio di collegamento @@ -3253,7 +3269,7 @@ Pocketing::AddOneWay( const ICurveComposite* pCompo, const Vector3d& vtTool, con Point3d ptQ ; double dEndElev = dElev ; SetFeed( GetEndFeed()) ; - if ( ! AddLeadOut( ptE, frPocket.VersX(), vtExtr, nullptr, bSplitArcs, ptQ, dEndElev, true)) { + if ( ! AddLeadOut( ptE, frPocket.VersX(), vtExtr, nullptr, bSplitArcs, true, ptQ, dEndElev)) { m_pMchMgr->SetLastError( 2416, "Error in Pocketing : LeadOut not computable") ; return false ; } @@ -3413,9 +3429,13 @@ Pocketing::AddSpiralIn( const ICurveComposite* pCompo, const Vector3d& vtTool, c double dStElev ; if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev)) dStElev = dStep ; - bool bUnderRaw = m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && - GetPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ; - if ( bUnderRaw || ( bOutStart && ! m_bAboveHead)) + bool bAhUnderRaw = m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && + GetAhPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), + m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ; + bool bUhAboveRaw = ! m_bAboveHead && + GetUhPointAboveRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), + m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ; + if ( bAhUnderRaw || bUhAboveRaw) dStElev = max( dStElev, dStep) ; dStElev -= ( ptP1 - ptStart) * vtExtr ; // se attacco a zigzag o a spirale o a scivolo, l'elevazione va nell'attacco @@ -3503,12 +3523,10 @@ Pocketing::AddSpiralIn( const ICurveComposite* pCompo, const Vector3d& vtTool, c Point3d ptP1 ; double dEndElev = dElev ; SetFeed( GetEndFeed()) ; - if ( ! AddLeadOut( ptEnd, vtEnd, vtExtr, pRCrv, bSplitArcs, ptP1, dEndElev)) { + if ( ! AddLeadOut( ptEnd, vtEnd, vtExtr, pRCrv, bSplitArcs, false, ptP1, dEndElev)) { m_pMchMgr->SetLastError( 2416, "Error in Pocketing : LeadOut not computable") ; return false ; } - if ( ! m_bAboveHead) - dEndElev = max( dEndElev, j * dStep) ; // aggiungo retrazione if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr)) { m_pMchMgr->SetLastError( 2417, "Error in Pocketing : Retract not computable") ; @@ -3639,9 +3657,13 @@ Pocketing::AddSpiralOut( const ICurveComposite* pCompo, const Vector3d& vtTool, double dStElev ; if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev)) dStElev = dStep ; - bool bUnderRaw = m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && - GetPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ; - if ( bUnderRaw || ( bOutStart && ! m_bAboveHead)) + bool bAhUnderRaw = m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && + GetAhPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), + m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ; + bool bUhAboveRaw = ! m_bAboveHead && + GetUhPointAboveRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), + m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ; + if ( bAhUnderRaw || bUhAboveRaw) dStElev = max( dStElev, dStep) ; dStElev -= ( ptP1 - ptStart) * vtExtr ; // se attacco a zigzag o a spirale o a scivolo, l'elevazione va nell'attacco @@ -3729,12 +3751,10 @@ Pocketing::AddSpiralOut( const ICurveComposite* pCompo, const Vector3d& vtTool, Point3d ptQ ; double dEndElev = dElev ; SetFeed( GetEndFeed()) ; - if ( ! AddLeadOut( ptEnd, vtEnd, vtExtr, pRCrv, bSplitArcs, ptQ, dEndElev)) { + if ( ! AddLeadOut( ptEnd, vtEnd, vtExtr, pRCrv, bSplitArcs, false, ptQ, dEndElev)) { m_pMchMgr->SetLastError( 2416, "Error in Pocketing : LeadOut not computable") ; return false ; } - if ( ! m_bAboveHead) - dEndElev = max( dEndElev, j * dStep) ; // aggiungo retrazione if ( ! AddRetract( ptQ, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr)) { m_pMchMgr->SetLastError( 2417, "Error in Pocketing : Retract not computable") ; @@ -5137,8 +5157,6 @@ Pocketing::CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtStart, con int nType = GetLeadInType() ; if ( nType == POCKET_LI_GLIDE && ( pRCrv == nullptr || pRCrv->GetCurveCount() == 0)) nType = POCKET_LI_NONE ; - // senso di rotazione da dir tg a dir esterna - bool bCcwRot = true ; // Calcolo punto iniziale switch ( nType) { case POCKET_LI_NONE : @@ -5280,7 +5298,18 @@ Pocketing::AddLeadIn( const Point3d& ptP1, const Point3d& ptStart, const Vector3 //---------------------------------------------------------------------------- bool Pocketing::AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d& vtN, - const ICurveComposite* pRCrv, bool bSplitArcs, Point3d& ptP1, double& dElev, bool bNoneForced) + const ICurveComposite* pRCrv, bool bSplitArcs, bool bNoneForced, + Point3d& ptP1, double& dElev) +{ + bool bOppositeHome ; + return AddLeadOut( ptEnd, vtEnd, vtN, pRCrv, bSplitArcs, bNoneForced, ptP1, dElev, bOppositeHome) ; +} + +//---------------------------------------------------------------------------- +bool +Pocketing::AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d& vtN, + const ICurveComposite* pRCrv, bool bSplitArcs, bool bNoneForced, + Point3d& ptP1, double& dElev, bool& bOppositeHome) { // assegno i parametri int nType = GetLeadOutType() ; @@ -5299,8 +5328,13 @@ Pocketing::AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector dElev = dEndElev ; // correzione per punto sotto il grezzo con testa normale da sopra double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ; - bool bUnderEnd = m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && - GetPointUnderRaw( ptP1, vtN, 0, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtN, dElev) ; + bool bAhUnderRaw = m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && + GetAhPointUnderRaw( ptP1, vtN, 0, GetRadiusForStartEndElevation(), + m_TParams.m_dLen, false, dSafeZ, vtN, dElev) ; + bool bUhAboveRaw = ! m_bAboveHead && + GetUhPointAboveRaw( ptP1, vtN, 0, GetRadiusForStartEndElevation(), + m_TParams.m_dLen, false, dSafeZ, vtN, dElev) ; + bOppositeHome = ( bAhUnderRaw || bUhAboveRaw) ; return true ; } case POCKET_LO_GLIDE : @@ -5335,11 +5369,17 @@ Pocketing::AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector dElev = dEndElev ; // correzione per punto sotto il grezzo con testa normale da sopra double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ; - bool bUnderEnd = m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && - GetPointUnderRaw( ptP1, vtN, 0, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtN, dElev) ; + bool bAhUnderRaw = m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && + GetAhPointUnderRaw( ptP1, vtN, 0, GetRadiusForStartEndElevation(), + m_TParams.m_dLen, false, dSafeZ, vtN, dElev) ; + bool bUhAboveRaw = ! m_bAboveHead && + GetUhPointAboveRaw( ptP1, vtN, 0, GetRadiusForStartEndElevation(), + m_TParams.m_dLen, false, dSafeZ, vtN, dElev) ; + bOppositeHome = ( bAhUnderRaw || bUhAboveRaw) ; return true ; } default : + bOppositeHome = false ; return false ; } @@ -5349,8 +5389,9 @@ Pocketing::AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector double Pocketing::GetRadiusForStartEndElevation( void) const { - const double DELTA_ELEV_RAD = 20.0 ; - return ( 0.5 * m_TParams.m_dTDiam + min( 0.25 * m_TParams.m_dTDiam, DELTA_ELEV_RAD)) ; + const double DELTA_ELEV_RAD = 4.0 ; + double dDeltaRad = min( DELTA_ELEV_RAD, 0.5 * m_TParams.m_dTDiam) ; + return ( 0.5 * m_TParams.m_dTDiam + dDeltaRad) ; } //---------------------------------------------------------------------------- diff --git a/Pocketing.h b/Pocketing.h index 7afb60c..bdfa5d5 100644 --- a/Pocketing.h +++ b/Pocketing.h @@ -129,7 +129,11 @@ class Pocketing : public Machining const ICurveComposite* pCompo, const ICurveComposite* pRCrv, bool bAtLeft, bool bSplitArcs, bool bNoneForced = false, bool bSkipControl = false) ; bool AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d& vtN, - const ICurveComposite* pRCrv, bool bSplitArcs, Point3d& ptP1, double& dElev, bool bNoneForced = false) ; + const ICurveComposite* pRCrv, bool bSplitArcs, bool bNoneForced, + Point3d& ptP1, double& dElev) ; + bool AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d& vtN, + const ICurveComposite* pRCrv, bool bSplitArcs, bool bNoneForced, + Point3d& ptP1, double& dElev, bool& bOppositeHome) ; double GetRadiusForStartEndElevation( void) const ; bool GetMidOfLongestOpenSide( const ICurveComposite* pCompo, Point3d& ptMid, Vector3d& vtMidOut) ; bool AdjustContourWithOpenEdges( ICurveComposite* pCompo) ; @@ -182,6 +186,7 @@ class Pocketing : public Machining int m_nStatus ; // stato di aggiornamento della lavorazione int m_nPockets ; // numero di percorsi di svuotatura generati bool m_bTiltingTab ; // flag utilizzo tavola basculante + Vector3d m_vtTiltingAx ; // versore direzione eventuale asse basculante bool m_bAboveHead ; // flag utilizzo testa da sopra bool m_bAggrBottom ; // flag di utilizzo dell'aggregato da sotto Vector3d m_vtAggrBottom ; // vettore direzione ausiliaria aggregato da sotto diff --git a/SurfFinishing.cpp b/SurfFinishing.cpp index 1a06026..cd15632 100644 --- a/SurfFinishing.cpp +++ b/SurfFinishing.cpp @@ -2083,6 +2083,7 @@ SurfFinishing::GetRightFeed( const Vector3d& vtMove, const Vector3d& vtTool) con double SurfFinishing::GetRadiusForStartEndElevation( void) const { - const double DELTA_ELEV_RAD = 20.0 ; - return ( 0.5 * m_TParams.m_dTDiam + DELTA_ELEV_RAD) ; + const double DELTA_ELEV_RAD = 4.0 ; + double dDeltaRad = min( DELTA_ELEV_RAD, 0.5 * m_TParams.m_dTDiam) ; + return ( 0.5 * m_TParams.m_dTDiam + dDeltaRad) ; }