Egalware/EgtMachKernel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

EgtMachKernel :

Browse Source 
- migliorata gestione approcci e retrazioni in fresature con lame.
This commit is contained in:
DarioS
2022-03-20 18:51:56 +01:00
parent d8f72d02f7
commit d3922eb897
6 changed files with 121 additions and 66 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Milling.cpp
+97 -42
View File
@@ -1,7 +1,7 @@
//----------------------------------------------------------------------------
// EgalTech 2015-2020
// EgalTech 2015-2022
//----------------------------------------------------------------------------
// File : Milling.cpp Data : 02.06.20 Versione : 2.2f1
// File : Milling.cpp Data : 16.03.22 Versione : 2.4c1
// Contenuto : Implementazione gestione fresature.
//
//
@@ -9,6 +9,7 @@
// Modifiche : 07.06.15 DS Creazione modulo.
// 11.08.16 DS Miglioria gestione PV per più loop.
// 02.06.20 DS Aggiunta gestione Tabs.
// 16.03.22 DS Migliorata sicurezza lame sopra.
//
//----------------------------------------------------------------------------
@@ -42,6 +43,7 @@ using namespace std ;
//------------------------------ Constants ------------------------------------
const double OSC_MIN_LEN = 0.1 ;
const double ELEV_MAX_OFFS = 25.0 ;
const double MIN_SAFEDIST = 5.0 ;
//------------------------------ Errors --------------------------------------
// 2301 = "Error in Milling : UpdateToolData failed"
@@ -2178,6 +2180,18 @@ Milling::GenerateMillingPv( int nPathId, const ICurveComposite* pCompo)
return true ;
}
//----------------------------------------------------------------------------
static bool
VerifyEscapeDir( const Vector3d& vtCorr, const Vector3d& vtTool, bool bAboveHead)
{
if ( bAboveHead && AreSameVectorApprox( vtCorr, -Z_AX))
return false ;
if ( ! bAboveHead && AreSameVectorApprox( vtCorr, Z_AX))
return false ;
Vector3d vtEsc( vtCorr.x, vtCorr.y, 0) ;
return ( vtEsc.Normalize() && vtEsc * vtTool > -0.5) ;
}
//----------------------------------------------------------------------------
bool
Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTool,
@@ -2230,7 +2244,13 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, dStElev, false, pCompo, ptP1))
return false ;
// determino se l'inizio dell'attacco è fuori dal grezzo
bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, dElev, dSafeZ) ;
Vector3d vtCorr = ptP1 - ptStart ;
if ( ! vtCorr.Normalize() || ! VerifyEscapeDir( vtCorr, vtTool, m_bAboveHead)) {
vtCorr = CalcCorrDir( pCompo, i) ;
if ( ! vtCorr.Normalize() || ! VerifyEscapeDir( vtCorr, vtTool, m_bAboveHead))
vtCorr = vtTool ;
}
bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, vtCorr, dElev, dSafeZ) ;
// determino se l'inizio dell'attacco è sopra il grezzo
bool bGeomAboveStart = GetPointAboveRaw( ptP1, vtTool) ;
bool bAboveStart = ( m_bAboveHead && bGeomAboveStart) ;
@@ -2249,7 +2269,7 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
dStElev = min( dStElev, dNewStElev) ;
// determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
bool bUnderStart = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, 0,
GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dStElev) ;
GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ;
// se attacco a zigzag o a spirale, l'elevazione va nell'attacco
if ( IsLeadInHelixOrZigzag()) {
ptP1 += vtTool * ( dStElev + LIO_ELEV_TOL) ;
@@ -2267,14 +2287,27 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
if ( ! bOutStart) {
// verifico se sono sotto
double dSawStartElev = 0 ;
bool bUnderStart = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, m_TParams.m_dTDiam / 2,
GetRadiusForStartEndElevation( false), m_TParams.m_dLen, true, dSafeZ, dSawStartElev) ;
if ( ! bGeomAboveStart && ! bUnderStart && bOk) {
bool bUnderStart = false ;
bool bSideStart = false ;
if ( ! bGeomAboveStart) {
bUnderStart = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, m_TParams.m_dTDiam / 2,
GetRadiusForStartEndElevation( false), m_TParams.m_dLen, true, dSafeZ, vtCorr, dSawStartElev) ;
}
if ( ! bUnderStart) {
Vector3d vtMove( vtCorr.x, vtCorr.y, 0) ;
if ( vtMove.Normalize()) {
Point3d ptTest = ptP1 - MIN_SAFEDIST * ( m_bAboveHead ? Z_AX : -Z_AX) ;
if ( GetElevation( m_nPhase, ptTest, vtTool, 0.5 * m_TParams.m_dDiam, vtMove, dSawStartElev) && dSawStartElev < EPS_SMALL)
bSideStart = true ;
}
}
if ( ! bGeomAboveStart && ! bUnderStart && ! bSideStart && bOk) {
m_pMchMgr->SetLastError( 2314, "Error in Milling : LeadIn must be out of rawpart") ;
bOk = false ;
}
// aggiungo opportuno approccio
if ( ! AddSawBladeSideApproach( ptP1, vtTool, dSafeZ, dSawStartElev, dAppr)) {
if ( ! AddSawBladeSideApproach( ptP1, vtCorr, dSafeZ, dSawStartElev, dAppr)) {
m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ;
return false ;
}
@@ -2294,7 +2327,7 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
}
}
// imposto versore correzione e ausiliario sul punto di arrivo
CalcAndSetCorrAuxDir( pCompo, i+1) ;
CalcAndSetCorrAuxDir( pCompo, i + 1) ;
// elaborazioni sulla curva corrente
if ( pCurve->GetType() == CRV_LINE) {
ICurveLine* pLine = GetCurveLine( pCurve) ;
@@ -2366,7 +2399,7 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
dEndElev = min( dEndElev, dNewEndElev) ;
// determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
bool bUnderEnd = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, 0,
GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dEndElev) ;
GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dEndElev) ;
// aggiungo retrazione
if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bAboveEnd)) {
m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ;
@@ -2376,20 +2409,38 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
// per lame quando è necessario
else {
// verifico di uscire in aria
bool bOutEnd = GetPointOutOfRaw( ptP1, vtTool, dElev, dSafeZ) ;
Vector3d vtCorr = ptP1 - ptEnd ;
if ( ! vtCorr.Normalize() || ! VerifyEscapeDir( vtCorr, vtTool, m_bAboveHead)) {
vtCorr = CalcCorrDir( pCompo, i + 1) ;
if ( ! vtCorr.Normalize() || ! VerifyEscapeDir( vtCorr, vtTool, m_bAboveHead))
vtCorr = vtTool ;
}
bool bOutEnd = GetPointOutOfRaw( ptP1, vtTool, vtCorr, dElev, dSafeZ) ;
if ( ! bOutEnd) {
// verifico se sono sopra
bool bGeomAboveEnd = GetPointAboveRaw( ptP1, vtTool) ;
// verifico se sono sotto
double dSawEndElev = 0 ;
bool bUnderEnd = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, m_TParams.m_dTDiam / 2,
GetRadiusForStartEndElevation( false), m_TParams.m_dLen, true, dSafeZ, dSawEndElev) ;
if ( ! bGeomAboveEnd && ! bUnderEnd && bOk) {
bool bUnderEnd = false ;
bool bSideEnd = false ;
if ( ! bGeomAboveEnd) {
bUnderEnd = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, m_TParams.m_dTDiam / 2,
GetRadiusForStartEndElevation( false), m_TParams.m_dLen, true, dSafeZ, vtCorr, dSawEndElev) ;
}
if ( ! bUnderEnd) {
Vector3d vtMove( vtCorr.x, vtCorr.y, 0) ;
if ( vtMove.Normalize()) {
Point3d ptTest = ptP1 - MIN_SAFEDIST * ( m_bAboveHead ? Z_AX : -Z_AX) ;
if ( GetElevation( m_nPhase, ptTest, vtTool, 0.5 * m_TParams.m_dDiam, vtMove, dSawEndElev) && dSawEndElev < EPS_SMALL)
bSideEnd = true ;
}
}
if ( ! bGeomAboveEnd && ! bUnderEnd && ! bSideEnd && bOk) {
m_pMchMgr->SetLastError( 2324, "Error in Milling : LeadOut must be out of rawpart") ;
bOk = false ;
}
// aggiungo opportuna retrazione
if ( ! AddSawBladeSideRetract( ptP1, vtTool, dSafeZ, dSawEndElev, dAppr)) {
if ( ! AddSawBladeSideRetract( ptP1, vtCorr, dSafeZ, dSawEndElev, dAppr)) {
m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ;
return false ;
}
@@ -2477,7 +2528,8 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, dStElev, bInvert, pCompo, ptP1))
return false ;
// determino se l'inizio dell'attacco è fuori dal grezzo
bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, dElev, dSafeZ) ;
Vector3d vtCorr = CalcCorrDir( pCompo, ( bInvert ? nMaxInd - i + 1 : i)) ;
bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, vtCorr, dElev, dSafeZ) ;
// determino se l'inizio dell'attacco è sopra il grezzo
bool bAboveStart = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ;
// imposto versore correzione e ausiliario sul punto di partenza
@@ -2495,7 +2547,7 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
dStElev = min( dStElev, dNewStElev) ;
// determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
bool bUnderStart = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, 0,
GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dStElev) ;
GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ;
// se attacco a zigzag o a spirale, l'elevazione va nell'attacco
if ( IsLeadInHelixOrZigzag()) {
ptP1 += vtTool * ( dStElev + LIO_ELEV_TOL) ;
@@ -2626,7 +2678,7 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
dEndElev = min( dEndElev, dNewEndElev) ;
// determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
bool bUnderEnd = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, 0,
GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dEndElev) ;
GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dEndElev) ;
// aggiungo retrazione
if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bAboveEnd)) {
m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ;
@@ -2738,7 +2790,8 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, dStElev, false, pCompo, ptP1))
return false ;
// determino se l'inizio dell'attacco è fuori dal grezzo
bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, dElev, dSafeZ) ;
Vector3d vtCorr = CalcCorrDir( pCompo, i) ;
bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, vtCorr, dElev, dSafeZ) ;
// aggiungo approccio per frese normali
if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
// correggo elevazione iniziale per punto inizio attacco (se testa da sopra senza aggregato approccio mai Z-)
@@ -2757,7 +2810,7 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
}
// determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
bool bUnderStart = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, 0,
GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dStElev) ;
GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ;
// se attacco a zigzag o a spirale, l'elevazione va nell'attacco
if ( IsLeadInHelixOrZigzag()) {
ptP1 += vtTool * ( dStElev - ( j - 1) * dStep) ;
@@ -2879,7 +2932,7 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
}
// determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
bool bUnderEnd = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, 0,
GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dEndElev) ;
GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dEndElev) ;
// aggiungo retrazione
if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bAboveStartEnd)) {
m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ;
@@ -2959,7 +3012,8 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, dStElev, false, pCompo, ptP1))
return false ;
// determino se l'inizio dell'attacco è fuori dal grezzo
bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, dElev, dSafeZ) ;
Vector3d vtCorr = CalcCorrDir( pCompo, i) ;
bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, vtCorr, dElev, dSafeZ) ;
// determino se l'inizio dell'attacco è sopra il grezzo
bool bAboveStart = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ;
// imposto versore correzione e ausiliario sul punto di partenza
@@ -2977,7 +3031,7 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
dStElev = min( dStElev, dNewStElev) ;
// determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
bool bUnderStart = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, 0,
GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dStElev) ;
GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ;
// approccio al punto iniziale
if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dAppr, bOutStart, bAboveStart)) {
m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ;
@@ -3080,7 +3134,7 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
dEndElev = min( dEndElev, dNewEndElev) ;
// determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
bool bUnderEnd = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, 0,
GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dEndElev) ;
GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dEndElev) ;
// aggiungo retrazione
if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bAboveEnd)) {
m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ;
@@ -3148,12 +3202,13 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev) && dNewStElev > EPS_SMALL)
dStElev = min( dStElev, dNewStElev) ;
// determino se l'inizio dell'attacco è fuori dal grezzo
bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, dElev, dSafeZ) ;
Vector3d vtCorr = CalcCorrDir( pCompo, ( bInvert ? nMaxInd - i + 1 : i)) ;
bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, vtCorr, dElev, dSafeZ) ;
// determino se l'inizio dell'attacco è sopra il grezzo
bool bAboveStart = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ;
// determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
bool bUnderStart = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, 0,
GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dStElev) ;
GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ;
// approccio al punto iniziale
if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dAppr, bOutStart, bAboveStart)) {
m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ;
@@ -3251,7 +3306,7 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
dEndElev = min( dEndElev, dNewEndElev) ;
// determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
bool bUnderEnd = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, 0,
GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dEndElev) ;
GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dEndElev) ;
// aggiungo retrazione
if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bAboveEnd)) {
m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ;
@@ -3360,7 +3415,8 @@ Milling::AddSawZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtT
if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, dStElev, bInvert, pCompo, ptP1))
return false ;
// determino se l'inizio dell'attacco è fuori dal grezzo
bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, dElev, dSafeZ) ;
Vector3d vtCorr = CalcCorrDir( pCompo, ( bInvert ? nMaxInd - i + 1 : i)) ;
bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, vtCorr, dElev, dSafeZ) ;
// determino se l'inizio dell'attacco è sopra il grezzo
bool bAboveStart = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ;
// imposto versore correzione e ausiliario sul punto di partenza
@@ -3549,21 +3605,21 @@ Milling::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ,
//----------------------------------------------------------------------------
bool
Milling::AddSawBladeSideApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dStElev, double dAppr)
Milling::AddSawBladeSideApproach( const Point3d& ptP, const Vector3d& vtCorr, double dSafeZ, double dStElev, double dAppr)
{
SetFlag( 1) ;
// approccio per lame su teste da sopra che attaccano da sotto -> movimento in verticale fino all'esterno del grezzo
Vector3d vtAppr = vtTool ;
vtAppr.z = 0 ;
// approccio per lame su teste da sopra che attaccano da sotto o da sopra troppo vicine -> movimento in verticale fino all'esterno del grezzo
Vector3d vtAppr = vtCorr ;
vtAppr.z = max( vtAppr.z, 0.) ;
vtAppr.Normalize() ;
// 1 -> punto fuori inizio
Point3d ptP1 = ptP + vtAppr * ( dStElev + max( dAppr, dSafeZ)) ;
if ( AddRapidStart( ptP1) == GDB_ID_NULL)
return false ;
// affondo al punto iniziale
// affondo al punto iniziale in feed
SetFlag( 0) ;
SetFeed( GetStartFeed()) ;
if ( AddRapidMove( ptP) == GDB_ID_NULL)
if ( AddLinearMove( ptP) == GDB_ID_NULL)
return false ;
return true ;
@@ -3672,11 +3728,11 @@ Milling::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ,
//----------------------------------------------------------------------------
bool
Milling::AddSawBladeSideRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dEndElev, double dAppr)
Milling::AddSawBladeSideRetract( const Point3d& ptP, const Vector3d& vtCorr, double dSafeZ, double dEndElev, double dAppr)
{
// retrazione per lame su teste da sopra che attaccano da sotto -> movimento in orizzontale fino all'esterno del grezzo
Vector3d vtAppr = vtTool ;
vtAppr.z = 0 ;
// retrazione per lame su teste da sopra che attaccano da sotto o da sopra troppo vicine -> movimento in orizzontale fino all'esterno del grezzo
Vector3d vtAppr = vtCorr ;
vtAppr.z = max( vtAppr.z, 0.) ;
vtAppr.Normalize() ;
// se sopra uscita c'è spazio per sicurezza o approccio
if ( dEndElev + max( dSafeZ, dAppr) > 10 * EPS_SMALL) {
@@ -5093,7 +5149,7 @@ Milling::GetRadiusForStartEndElevation( bool bExtra) const
//----------------------------------------------------------------------------
bool
Milling::GetPointOutOfRaw( const Point3d& ptP, const Vector3d& vtTool, double dElev, double dSafeZ) const
Milling::GetPointOutOfRaw( const Point3d& ptP, const Vector3d& vtTool, const Vector3d& vtCorr, double dElev, double dSafeZ) const
{
// per frese normali
if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
@@ -5108,9 +5164,8 @@ Milling::GetPointOutOfRaw( const Point3d& ptP, const Vector3d& vtTool, double dE
// determino se l'inizio dell'attacco è fuori dal grezzo (considero movimento lama in +/- Z)
double dTemp ;
Vector3d vtMove = ( m_bAboveHead ? Z_AX : -Z_AX) ;
Vector3d vtSafe = vtTool ; vtSafe.z = 0 ; vtSafe.Normalize() ;
const double MIN_SAFEDIST = 5.0 ;
Point3d ptQ = ptP - vtSafe * max( 0.2 * dSafeZ, MIN_SAFEDIST) ;
Vector3d vtSafe = vtCorr ; vtSafe.z = 0 ; vtSafe.Normalize() ;
Point3d ptQ = ptP - ( vtSafe + vtMove) * max( 0.2 * dSafeZ, MIN_SAFEDIST) ;
if ( ! GetElevation( m_nPhase, ptQ, vtTool, 0.5 * m_TParams.m_dDiam, vtMove, dTemp) || dTemp > 10 * EPS_SMALL)
return false ;
Point3d ptR = ptP + vtTool * m_TParams.m_dThick ;