diff --git a/MachMgrMachines.cpp b/MachMgrMachines.cpp index cb87327..c0adbcb 100644 --- a/MachMgrMachines.cpp +++ b/MachMgrMachines.cpp @@ -258,7 +258,7 @@ MachMgr::GetDeltaSafeZ( const string& sHead) const { if ( m_pGeomDB == nullptr) return 0 ; - // Leggo da testa Info ZASAFEDELTA + // Leggo da testa Info ZSAFEDELTA double dDeltaSafeZ = 0 ; m_pGeomDB->GetInfo( GetHeadId( sHead), MCH_ZSAFEDELTA, dDeltaSafeZ) ; return dDeltaSafeZ ; diff --git a/Milling.cpp b/Milling.cpp index 6bbe060..9ace1a5 100644 --- a/Milling.cpp +++ b/Milling.cpp @@ -2233,7 +2233,7 @@ 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) ; + bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, 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 @@ -2246,7 +2246,7 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo else dStElev -= ( ptP1 - ptStart) * vtTool ; // determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione - bool bUnderStart = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, GetRadiusForStartEndElevation(), m_TParams.m_dLen, dStElev) ; + bool bUnderStart = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dStElev) ; // se attacco a zigzag o a spirale, l'elevazione va nell'attacco if ( IsLeadInHelixOrZigzag()) { ptP1 += vtTool * ( dStElev + LIO_ELEV_TOL) ; @@ -2263,13 +2263,14 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo // verifico di entrare in aria if ( ! bOutStart) { // verifico se sono sotto - bool bUnderStart = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, GetRadiusForStartEndElevation( false), m_TParams.m_dLen, dStElev) ; + double dSawStartElev = 0 ; + bool bUnderStart = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, GetRadiusForStartEndElevation( false), m_TParams.m_dLen, true, dSafeZ, dSawStartElev) ; if ( ! bUnderStart) { m_pMchMgr->SetLastError( 2314, "Error in Milling : LeadIn must be out of rawpart") ; return false ; } // aggiungo opportuno approccio - if ( ! AddSawBladeSideApproach( ptP1, vtTool, dSafeZ, dStElev, dAppr)) { + if ( ! AddSawBladeSideApproach( ptP1, vtTool, dSafeZ, dSawStartElev, dAppr)) { m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ; return false ; } @@ -2356,7 +2357,7 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo else dEndElev -= ( ptP1 - ptEnd) * vtTool ; // determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione - bool bUnderEnd = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, GetRadiusForStartEndElevation(), m_TParams.m_dLen, dEndElev) ; + bool bUnderEnd = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dEndElev) ; // aggiungo retrazione if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bAboveEnd)) { m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ; @@ -2366,9 +2367,10 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo // per lame quando è necessario else { // verifico se sono sotto - bool bUnderEnd = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, GetRadiusForStartEndElevation( false), m_TParams.m_dLen, dEndElev) ; + double dSawEndElev = 0 ; + bool bUnderEnd = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, GetRadiusForStartEndElevation( false), m_TParams.m_dLen, true, dSafeZ, dSawEndElev) ; // se necessario, aggiungo opportuna retrazione - if ( bUnderEnd && ! AddSawBladeSideRetract( ptP1, vtTool, dSafeZ, dEndElev, dAppr)) { + if ( bUnderEnd && ! AddSawBladeSideRetract( ptP1, vtTool, dSafeZ, dSawEndElev, dAppr)) { m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ; return false ; } @@ -2454,7 +2456,7 @@ 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) ; + bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, 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 @@ -2467,7 +2469,7 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool else dStElev -= ( ptP1 - ptStart) * vtTool ; // determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione - bool bUnderStart = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, GetRadiusForStartEndElevation(), m_TParams.m_dLen, dStElev) ; + bool bUnderStart = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dStElev) ; // se attacco a zigzag o a spirale, l'elevazione va nell'attacco if ( IsLeadInHelixOrZigzag()) { ptP1 += vtTool * ( dStElev + LIO_ELEV_TOL) ; @@ -2593,7 +2595,7 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool else dEndElev -= ( ptP1 - ptEnd) * vtTool ; // determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione - bool bUnderEnd = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, GetRadiusForStartEndElevation(), m_TParams.m_dLen, dEndElev) ; + bool bUnderEnd = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dEndElev) ; // aggiungo retrazione if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bAboveEnd)) { m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ; @@ -2703,7 +2705,7 @@ 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) ; + bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, 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-) @@ -2712,7 +2714,7 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool else dStElev -= ( ptP1 - ptStart) * vtTool ; // determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione - bool bUnderStart = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, GetRadiusForStartEndElevation(), m_TParams.m_dLen, dStElev) ; + bool bUnderStart = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dStElev) ; // se attacco a zigzag o a spirale, l'elevazione va nell'attacco if ( IsLeadInHelixOrZigzag()) { ptP1 += vtTool * ( dStElev - ( j - 1) * dStep) ; @@ -2822,7 +2824,7 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool else dEndElev -= ( ptP1 - ptEnd) * vtTool ; // determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione - bool bUnderEnd = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, GetRadiusForStartEndElevation(), m_TParams.m_dLen, dEndElev) ; + bool bUnderEnd = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dEndElev) ; // aggiungo retrazione if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bAboveStartEnd)) { m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ; @@ -2902,7 +2904,7 @@ 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) ; + bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, 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 @@ -2915,7 +2917,7 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool else dStElev -= ( ptP1 - ptStart) * vtTool ; // determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione - bool bUnderStart = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, GetRadiusForStartEndElevation(), m_TParams.m_dLen, dStElev) ; + bool bUnderStart = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, 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") ; @@ -3013,7 +3015,7 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool else dEndElev -= ( ptP1 - ptEnd) * vtTool ; // determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione - bool bUnderEnd = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, GetRadiusForStartEndElevation(), m_TParams.m_dLen, dEndElev) ; + bool bUnderEnd = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dEndElev) ; // aggiungo retrazione if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bAboveEnd)) { m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ; @@ -3077,11 +3079,11 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool else dStElev -= ( ptP1 - ptStart) * vtTool ; // determino se l'inizio dell'attacco è fuori dal grezzo - bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, dElev) ; + bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, 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, GetRadiusForStartEndElevation(), m_TParams.m_dLen, dStElev) ; + bool bUnderStart = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, 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") ; @@ -3174,7 +3176,7 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool else dEndElev -= ( ptP1 - ptEnd) * vtTool ; // determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione - bool bUnderEnd = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, GetRadiusForStartEndElevation(), m_TParams.m_dLen, dEndElev) ; + bool bUnderEnd = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dEndElev) ; // aggiungo retrazione if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bAboveEnd)) { m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ; @@ -3283,7 +3285,7 @@ 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) ; + bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, 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 @@ -3473,34 +3475,18 @@ bool Milling::AddSawBladeSideApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dStElev, double dAppr) { SetFlag( 1) ; - // approccio per lame su teste da sopra che attaccano da sotto -> movimento in orizzontale fino all'esterno del grezzo + // 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 ; vtAppr.Normalize() ; - // se distanza di sicurezza minore di distanza di inizio - if ( dSafeZ < dAppr + 10 * EPS_SMALL) { - // 1 -> punto sopra inizio - Point3d ptP1 = ptP + vtAppr * ( dStElev + dAppr) ; - if ( AddRapidStart( ptP1) == GDB_ID_NULL) - return false ; - } - else { - // 1a -> punto sopra inizio - Point3d ptP1b = ptP + vtAppr * ( dStElev + dAppr) ; - Point3d ptP1a = ptP1b + vtAppr * ( dSafeZ - dAppr) ; - if ( AddRapidStart( ptP1a) == GDB_ID_NULL) - return false ; - // 1b -> punto appena sopra inizio - if ( ( dStElev + dAppr) > EPS_SMALL) { - SetFlag( 0) ; - if ( AddRapidMove( ptP1b) == GDB_ID_NULL) - return false ; - } - } + // 1 -> punto fuori inizio + Point3d ptP1 = ptP + vtAppr * ( dStElev + max( dAppr, dSafeZ)) ; + if ( AddRapidStart( ptP1) == GDB_ID_NULL) + return false ; // affondo al punto iniziale SetFlag( 0) ; SetFeed( GetStartFeed()) ; - if ( AddLinearMove( ptP) == GDB_ID_NULL) + if ( AddRapidMove( ptP) == GDB_ID_NULL) return false ; return true ; @@ -4992,7 +4978,7 @@ Milling::GetRadiusForStartEndElevation( bool bExtra) const //---------------------------------------------------------------------------- bool -Milling::GetPointOutOfRaw( const Point3d& ptP, const Vector3d& vtTool, double dElev) const +Milling::GetPointOutOfRaw( const Point3d& ptP, const Vector3d& vtTool, double dElev, double dSafeZ) const { // per frese normali if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) { @@ -5007,9 +4993,12 @@ 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) ; - if ( ! GetElevation( m_nPhase, ptP, vtTool, 0.5 * m_TParams.m_dDiam, vtMove, dTemp) || dTemp > 10 * EPS_SMALL) + Vector3d vtSafe = vtTool ; vtSafe.z = 0 ; vtSafe.Normalize() ; + Point3d ptQ = ptP - vtSafe * 0.8 * dSafeZ ; + if ( ! GetElevation( m_nPhase, ptQ, vtTool, 0.5 * m_TParams.m_dDiam, vtMove, dTemp) || dTemp > 10 * EPS_SMALL) return false ; - if ( ! GetElevation( m_nPhase, ptP + vtTool * m_TParams.m_dThick, vtTool, 0.5 * m_TParams.m_dDiam, vtMove, dTemp) || dTemp > 10 * EPS_SMALL) + Point3d ptR = ptP + vtTool * m_TParams.m_dThick ; + if ( ! GetElevation( m_nPhase, ptR, vtTool, 0.5 * m_TParams.m_dDiam, vtMove, dTemp) || dTemp > 10 * EPS_SMALL) return false ; return true ; } diff --git a/Milling.h b/Milling.h index b9338db..051d5de 100644 --- a/Milling.h +++ b/Milling.h @@ -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) const ; + bool GetPointOutOfRaw( const Point3d& ptP, const Vector3d& vtTool, 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 2c01c8a..9a7c7f6 100644 --- a/Mortising.cpp +++ b/Mortising.cpp @@ -1483,20 +1483,20 @@ Mortising::GenerateMortisingCl( const ICurveComposite* pCompo, const Vector3d& v double dDelta = dElev - dDepth ; // determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione + double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() + m_pMchMgr->GetDeltaSafeZ( m_TParams.m_sHead) ; double dStartElev = 0 ; Point3d ptLi = ptStart + vtTool * dDelta ; - bool bUnderStart = GetPointUnderRaw( ptLi, vtTool, GetRadiusForStartEndElevation(), m_TParams.m_dLen, dStartElev) ; + bool bUnderStart = GetPointUnderRaw( ptLi, vtTool, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dStartElev) ; // 1 -> punto approccio SetFlag( 1) ; - double dAppr = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() + m_pMchMgr->GetDeltaSafeZ( m_TParams.m_sHead) ; - Point3d ptP1 = ptStart + vtTool * ( dDelta + dStartElev + dAppr) ; + Point3d ptP1 = ptStart + vtTool * ( dDelta + dStartElev + dSafeZ) ; if ( AddRapidStart( ptP1) == GDB_ID_NULL) return false ; SetFlag( 0) ; // 2 -> punto fuori (se diverso dal precedente) - if ( m_Params.m_dStartPos < dAppr) { + if ( m_Params.m_dStartPos < dSafeZ) { Point3d ptP2 = ptStart + vtTool * ( dDelta + m_Params.m_dStartPos) ; if ( AddRapidMove( ptP2) == GDB_ID_NULL) return false ; @@ -1566,12 +1566,12 @@ Mortising::GenerateMortisingCl( const ICurveComposite* pCompo, const Vector3d& v // 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, GetRadiusForStartEndElevation(), m_TParams.m_dLen, dEndElev) ; + bool bUnderEnd = GetPointUnderRaw( ptLo, vtTool, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dEndElev) ; // 6 -> ritorno all'approccio SetFeed( GetEndFeed()) ; SetFlag( 104) ; // risalita sopra la fine - Point3d ptP6 = ptLast + vtTool * ( dDelta + dEndElev + dAppr) ; + Point3d ptP6 = ptLast + vtTool * ( dDelta + dEndElev + dSafeZ) ; if ( AddLinearMove( ptP6) == GDB_ID_NULL) return false ; diff --git a/Operation.cpp b/Operation.cpp index 70c478f..a2ab045 100644 --- a/Operation.cpp +++ b/Operation.cpp @@ -343,7 +343,7 @@ Operation::GetElevation( int nPhase, const Point3d& ptP, const Vector3d& vtTool, //---------------------------------------------------------------------------- bool -Operation::GetPointUnderRaw( const Point3d& ptP, const Vector3d& vtTool, double dToolRadForElev, double dToolLen, double& dElev) const +Operation::GetPointUnderRaw( const Point3d& ptP, const Vector3d& vtTool, double dToolRadForElev, double dToolLen, bool bIsSaw, double dSafeZ, double& dElev) const { // punto a metà lunghezza utensile Point3d ptQ = ptP + vtTool * dToolLen / 2 ; @@ -357,7 +357,7 @@ Operation::GetPointUnderRaw( const Point3d& ptP, const Vector3d& vtTool, double b3Tool.Expand( dExpandX, dExpandY, dExpandZ) ; // direzione di fuga per l'elevazione Vector3d vtDir = vtTool ; - if ( vtDir.z < - EPS_SMALL) + if ( bIsSaw || vtDir.z < - EPS_SMALL) vtDir.z = 0 ; vtDir.Normalize() ; // determino la posizione del punto rispetto al grezzo @@ -369,6 +369,7 @@ Operation::GetPointUnderRaw( const Point3d& ptP, const Vector3d& vtTool, double int nStmId = m_pGeomDB->GetFirstNameInGroup( nRawId, MACH_RAW_SOLID) ; BBox3d b3Raw ; m_pGeomDB->GetGlobalBBox( nStmId, b3Raw) ; + b3Raw.Expand( dSafeZ - 10 * EPS_SMALL) ; if ( ! b3Raw.IsEmpty() && b3Raw.OverlapsXY( b3Tool) && ptP.z < b3Raw.GetMin().z - 10 * EPS_SMALL) { double dRawCentZ = ( b3Raw.GetMin().z + b3Raw.GetMax().z) / 2 ; double dRawDimZ = b3Raw.GetMax().z - b3Raw.GetMin().z ; @@ -378,7 +379,7 @@ Operation::GetPointUnderRaw( const Point3d& ptP, const Vector3d& vtTool, double double dNewElev ; if ( GetElevation( m_nPhase, ptTest - 10 * EPS_SMALL * vtTool, vtTool, dToolRadForElev, vtDir, dNewElev)) dElev = max( dElev, dNewElev) ; - // se direzione di fuga quasi orizzontale (30 deg) e ingombro utensile rilevante rispetto ad altezza grezzo + // 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) { // determino elevazione del punto rispetto al grezzo a metà altezza più metà ingombro utensile ptTest = Point3d( ptP.x, ptP.y, dRawCentZ + dToolDimZ / 2) ; diff --git a/Operation.h b/Operation.h index 4c41b23..f18a28d 100644 --- a/Operation.h +++ b/Operation.h @@ -74,7 +74,7 @@ class Operation : public IUserObj 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 dToolRadForElev, double dToolLen, double& dElev) const ; + bool GetPointUnderRaw( const Point3d& ptP, const Vector3d& vtTool, double dToolRadForElev, double dToolLen, bool bIsSaw, double dSafeZ, 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 4270bc6..5458822 100644 --- a/Pocketing.cpp +++ b/Pocketing.cpp @@ -2797,7 +2797,7 @@ Pocketing::AddSpiralIn( const ICurveComposite* pCompo, const Vector3d& vtTool, c if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev)) dStElev = dElev ; dStElev -= ( ptP1 - ptStart) * vtExtr ; - bool bUnderStart = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, GetRadiusForStartEndElevation(), m_TParams.m_dLen, dStElev) ; + bool bUnderStart = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dStElev) ; // se attacco a zigzag o a spirale o a scivolo, l'elevazione va nell'attacco if ( GetLeadInType() == POCKET_LI_ZIGZAG || GetLeadInType() == POCKET_LI_HELIX || @@ -3745,7 +3745,8 @@ Pocketing::AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtN, vtN, GetRadiusForStartEndElevation(), vtN, dEndElev)) dElev = dEndElev ; // correzione per punto sotto il grezzo con testa normale da sopra - bool bUnderEnd = m_bAboveHead && ! m_bAggrBottom && GetPointUnderRaw( ptP1, vtN, GetRadiusForStartEndElevation(), m_TParams.m_dLen, dElev) ; + double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ; + bool bUnderEnd = m_bAboveHead && ! m_bAggrBottom && GetPointUnderRaw( ptP1, vtN, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dElev) ; return true ; } case POCKET_LO_GLIDE : @@ -3779,7 +3780,8 @@ Pocketing::AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtN, vtN, GetRadiusForStartEndElevation(), vtN, dEndElev)) dElev = dEndElev ; // correzione per punto sotto il grezzo con testa normale da sopra - bool bUnderEnd = m_bAboveHead && ! m_bAggrBottom && GetPointUnderRaw( ptP1, vtN, GetRadiusForStartEndElevation(), m_TParams.m_dLen, dElev) ; + double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ; + bool bUnderEnd = m_bAboveHead && ! m_bAggrBottom && GetPointUnderRaw( ptP1, vtN, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dElev) ; return true ; } default :