diff --git a/Milling.cpp b/Milling.cpp index c98520b..4ccca19 100644 --- a/Milling.cpp +++ b/Milling.cpp @@ -3050,52 +3050,32 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool Point3d ptPe ; CalcLeadOutEnd( ptEnd, vtEnd, vtTool, dElev, false, pCompo, ptPe) ; Vector3d vtCe = CalcCorrDir( pCompo, pCompo->GetCurveCount()) ; - // verifico se attacco e uscita sopra il grezzo - bool bAboveStartEnd = false ; - bool bOutStartEnd = false ; - if ( m_bAboveHead) { - if ( ! m_bTiltingTab) { - bAboveStartEnd = GetPointAboveRaw( ptPs, vtTool) && GetPointAboveRaw( ptPe, vtTool) ; - bOutStartEnd = bAboveStartEnd ; - } - else { - Vector3d vtCm = Media( vtCs, vtCe) ; - if ( ! vtCm.Normalize()) - vtCm = vtCs ; - bOutStartEnd = GetPointOutOfRaw( ptPs, vtTool, vtCs, dElev, dSafeZ) && - GetPointOutOfRaw( ptPe, vtTool, vtCe, dElev, dSafeZ) && - GetPointOutOfRaw( Media( ptPs, ptPe), vtTool, vtCm, dElev, dSafeZ) ; - } - } - // verifico se collegamento diretto tra inizio e uscita sicuri è fuori dal grezzo - bool bSafeDirLinkStartEnd = false ; - if ( bAboveStartEnd) - bSafeDirLinkStartEnd = true ; - else if ( m_bAboveHead) { - // inizio con sua elevazione e sicurezza - double dStElev ; - if ( ! GetElevation( m_nPhase, ptStart, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev)) - dStElev = dElev ; - Point3d ptPsr = ptPs + ( dStElev + dSafeZ) * vtTool ; - // fine con sua elevazione e sicurezza - double dEndElev ; - if ( ! GetElevation( m_nPhase, ptEnd, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev)) - dEndElev = dElev ; - Point3d ptPer = ptPe + ( dEndElev + dSafeZ) * vtTool ; + // verifico se attacco e uscita entrambi sopra o sotto il grezzo + bool bAhAboveStartEnd = false ; + bool bUhBelowStartEnd = false ; + if ( m_bAboveHead) + bAhAboveStartEnd = GetPointAboveRaw( ptPs, vtTool) && GetPointAboveRaw( ptPe, vtTool) ; + else + bUhBelowStartEnd = GetPointBelowRaw( ptPs, vtTool) && GetPointBelowRaw( ptPe, vtTool) ; + // verifico se collegamento diretto tra inizio e uscita è fuori dal grezzo + bool bSafeDirLinkStartEnd = ( bAhAboveStartEnd || bUhBelowStartEnd) ; + if ( ! bSafeDirLinkStartEnd) { // verifica dei punti intermedi - bSafeDirLinkStartEnd = true ; - int nStep = Clamp( int( Dist( ptPsr, ptPer) / m_TParams.m_dDiam), 4, 16) ; + bool bIsOut = true ; + int nStep = Clamp( int( Dist( ptPs, ptPe) / m_TParams.m_dDiam), 4, 16) ; for ( int i = 1 ; i < nStep ; ++ i) { double dCoeff = double( i) / nStep ; - Point3d ptPm = Media( ptPsr, ptPer, dCoeff) ; + Point3d ptPm = Media( ptPs, ptPe, dCoeff) ; Vector3d vtCm = Media( vtCs, vtCe, dCoeff) ; if ( ! vtCm.Normalize()) vtCm = vtCs ; - if ( ! GetPointOutOfRaw( ptPm, vtTool, vtCm, dElev, dSafeZ)) { - bSafeDirLinkStartEnd = false ; + if ( ! GetSimplePointOutOfRaw( ptPm, vtTool, vtCm)) { + bIsOut = false ; break ; } } + if ( bIsOut) + bSafeDirLinkStartEnd = true ; } // determino numero e affondamento degli step @@ -3163,7 +3143,7 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, vtAppr, dStElev, dSafeZ) ; // aggiungo approccio per frese normali e frese che non lavorano di testa con attacco opportuno oppure fuori if ( ( m_TParams.m_nType & TF_MILL) != 0 && - ( m_TParams.m_nType != TT_MILL_NOTIP || LeadInRawIsOk() || m_bStartOutRaw || bOutStart)) { + ( m_TParams.m_nType != TT_MILL_NOTIP || LeadInRawIsOk() || m_bStartOutRaw || ! bSafeDirLinkStartEnd)) { // 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) || @@ -3173,12 +3153,12 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool } double dNewStElev ; if ( GetElevation( m_nPhase, ptP1, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev)) { - if ( bAboveStartEnd) + if ( bAhAboveStartEnd || bUhBelowStartEnd) dStElev = min( dStElev, dNewStElev) ; else dStElev = max( dStElev, dNewStElev) ; } - if ( bOutStartEnd && m_bTiltingTab) + if ( bSafeDirLinkStartEnd && m_bTiltingTab) dStElev = min( dStElev, j * dStep) ; // 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(), @@ -3193,7 +3173,7 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool } // approccio standard al punto iniziale if ( j == 1 || bMidRetract) { - if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dExtrAppr, bOutStart, bAboveStartEnd)) { + if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dExtrAppr, bOutStart, bAhAboveStartEnd || bUhBelowStartEnd)) { m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ; return false ; } @@ -3214,15 +3194,21 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool bool bGeomAboveStart = GetPointAboveRaw( ptP1, vtTool) ; // verifico se sono sotto double dSawStartElev = 0 ; - bool bUnderStart = false ; + bool bAhUnderStart = false ; + bool bUhAboveStart = false ; bool bSideStart = false ; if ( ! bGeomAboveStart) { - bUnderStart = m_bAboveHead && GetAhPointUnderRaw( ptP1, vtTool, m_TParams.m_dTDiam / 2, - GetRadiusForStartEndElevation( false), - m_TParams.m_dLen, true, dSafeZ, vtAppr, dSawStartElev) ; + bAhUnderStart = m_bAboveHead && GetAhPointUnderRaw( ptP1, vtTool, m_TParams.m_dTDiam / 2, + GetRadiusForStartEndElevation( false), + m_TParams.m_dLen, true, dSafeZ, vtAppr, dSawStartElev) ; + } + else { + bUhAboveStart = ! m_bAboveHead && GetUhPointAboveRaw( 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) - if ( ! bUnderStart) { + if ( ! bAhUnderStart && ! bUhAboveStart) { Point3d ptTest = ptP1 - MIN_SAFEDIST * vtTool ; Vector3d vtAppr1 = FromNearestHorizontalOrtho( vtTool, vtDir1) ; Vector3d vtAppr2 = vtDir1 ; @@ -3249,7 +3235,7 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool bSideStart = true ; } } - if ( ! bGeomAboveStart && ! bUnderStart && ! bSideStart && bOk) { + if ( ! bGeomAboveStart && ! bAhUnderStart && ! bUhAboveStart && ! bSideStart && bOk) { m_pMchMgr->SetLastError( 2314, "Error in Milling : LeadIn must be out of rawpart") ; bOk = false ; } @@ -3347,7 +3333,7 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool bool bOutEnd = GetPointOutOfRaw( ptP1, vtTool, vtRetr, dEndElev, dSafeZ) ; // aggiungo retrazione per frese normali e frese che non lavorano di testa già fuori if ( ( m_TParams.m_nType & TF_MILL) != 0 && - ( m_TParams.m_nType != TT_MILL_NOTIP || m_bEndOutRaw || bOutEnd)) { + ( m_TParams.m_nType != TT_MILL_NOTIP || m_bEndOutRaw || ! bSafeDirLinkStartEnd)) { // 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) || @@ -3357,12 +3343,12 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool } double dNewEndElev ; if ( GetElevation( m_nPhase, ptP1, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev)) { - if ( bAboveStartEnd) + if ( bAhAboveStartEnd || bUhBelowStartEnd) dEndElev = min( dEndElev, dNewEndElev) ; else if ( dNewEndElev > EPS_SMALL) dEndElev = max( dEndElev, dNewEndElev) ; } - if ( bOutStartEnd && m_bTiltingTab) + if ( bSafeDirLinkStartEnd && m_bTiltingTab) dEndElev = min( dEndElev, j * dStep) ; // 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(), @@ -3371,7 +3357,7 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool 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, dExtrAppr, bAboveStartEnd)) { + if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dExtrAppr, bAhAboveStartEnd || bUhBelowStartEnd)) { m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ; return false ; } @@ -3383,14 +3369,20 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool bool bGeomAboveEnd = GetPointAboveRaw( ptP1, vtTool) ; // verifico se sono sotto double dSawEndElev = 0 ; - bool bUnderEnd = false ; + bool bAhUnderEnd = false ; + bool bUhAboveEnd = false ; bool bSideEnd = false ; if ( ! bGeomAboveEnd) { - bUnderEnd = m_bAboveHead && GetAhPointUnderRaw( ptP1, vtTool, m_TParams.m_dTDiam / 2, - GetRadiusForStartEndElevation( false), - m_TParams.m_dLen, true, dSafeZ, vtRetr, dSawEndElev) ; + bAhUnderEnd = m_bAboveHead && GetAhPointUnderRaw( ptP1, vtTool, m_TParams.m_dTDiam / 2, + GetRadiusForStartEndElevation( false), + m_TParams.m_dLen, true, dSafeZ, vtRetr, dSawEndElev) ; } - if ( ! bUnderEnd) { + else { + bUhAboveEnd = ! m_bAboveHead && GetUhPointAboveRaw( ptP1, vtTool, m_TParams.m_dTDiam / 2, + GetRadiusForStartEndElevation( false), + m_TParams.m_dLen, true, dSafeZ, vtRetr, dSawEndElev) ; + } + if ( ! bAhUnderEnd && ! bUhAboveEnd) { Point3d ptTest = ptP1 - MIN_SAFEDIST * ( m_bAboveHead ? Z_AX : -Z_AX) ; Vector3d vtRetr1 = FromNearestHorizontalOrtho( vtTool, vtDir1) ; Vector3d vtRetr2 = vtDir1 ; @@ -3417,7 +3409,7 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool bSideEnd = true ; } } - if ( ! bGeomAboveEnd && ! bUnderEnd && ! bSideEnd && bOk) { + if ( ! bGeomAboveEnd && ! bAhUnderEnd && ! bUhAboveEnd && ! bSideEnd && bOk) { m_pMchMgr->SetLastError( 2324, "Error in Milling : LeadOut must be out of rawpart") ; bOk = false ; } @@ -4356,28 +4348,46 @@ Milling::AddSawBladeSideApproach( const Point3d& ptP, const Vector3d& vtAppr, co SetFlag( 1) ; // 1a -> punto fuori inizio Point3d ptP1a = ptP + vtAppr * ( dSawStElev + max( dAppr, dSafeZ)) ; + bool bFirst = true ; // se necessario ulteriore approccio - if ( ! m_bTiltingTab && vtAppr.z < LIM_DOWN_APPRZ) { + if ( ! m_bTiltingTab) { Vector3d vtMove = Vector3d( vtTool.x, vtTool.y, 0) ; if ( vtMove.Normalize()) { - Point3d ptP1e = ptP1a + vtMove * ( dStElev + dSafeZ) ; - if ( AddRapidStart( ptP1e) == GDB_ID_NULL) - return false ; - SetFlag( 0) ; - if ( AddRapidMove( ptP1a) == GDB_ID_NULL) - return false ; - } - else { - if ( AddRapidStart( ptP1a) == GDB_ID_NULL) - return false ; + if ( m_bAboveHead && vtAppr.z < LIM_DOWN_APPRZ) { + double dSawStartElev ; + if ( GetAhPointUnderRaw( ptP1a, vtTool, m_TParams.m_dTDiam / 2, + GetRadiusForStartEndElevation( false), + m_TParams.m_dLen, true, dSafeZ, vtMove, dSawStartElev)) { + Point3d ptP1e = ptP1a + vtMove * ( dSawStartElev + dSafeZ) ; + if ( AddRapidStart( ptP1e) == GDB_ID_NULL) + return false ; + bFirst = false ; + } + } + else if ( ! m_bAboveHead && vtAppr.z > -LIM_DOWN_APPRZ) { + double dSawStartElev ; + if ( GetUhPointAboveRaw( ptP1a, vtTool, m_TParams.m_dTDiam / 2, + GetRadiusForStartEndElevation( false), + m_TParams.m_dLen, true, dSafeZ, vtMove, dSawStartElev)) { + Point3d ptP1e = ptP1a + vtMove * ( dSawStartElev + dSafeZ) ; + if ( AddRapidStart( ptP1e) == GDB_ID_NULL) + return false ; + bFirst = false ; + } + } } } - // caso standard - else { + // punto fuori inizio + if ( bFirst) { if ( AddRapidStart( ptP1a) == GDB_ID_NULL) return false ; + SetFlag( 0) ; + } + else { + SetFlag( 0) ; + if ( AddRapidMove( ptP1a) == GDB_ID_NULL) + return false ; } - SetFlag( 0) ; // 1b -> punto appena sopra inizio (se necessario) if ( dSafeZ > dAppr + 10 * EPS_SMALL && dSawStElev + dAppr > 10 * EPS_SMALL) { Point3d ptP1b = ptP + vtAppr * ( dSawStElev + dAppr) ; @@ -4516,18 +4526,29 @@ Milling::AddSawBladeSideRetract( const Point3d& ptP, const Vector3d& vtRetr, con } // se necessaria ulteriore uscita - if ( ! m_bTiltingTab && vtRetr.z < LIM_DOWN_APPRZ) { + if ( ! m_bTiltingTab) { Vector3d vtMove = Vector3d( vtTool.x, vtTool.y, 0) ; if ( vtMove.Normalize()) { - double dSawEndElev ; - if ( ! m_bAboveHead || - ! GetAhPointUnderRaw( ptP4, vtTool, m_TParams.m_dTDiam / 2, - GetRadiusForStartEndElevation( false), - m_TParams.m_dLen, true, dSafeZ, vtMove, dSawEndElev)) - dSawEndElev = dEndElev ; - Point3d ptP4b = ptP4 + vtMove * ( dSawEndElev + dSafeZ) ; - if ( AddRapidMove( ptP4b) == GDB_ID_NULL) - return false ; + if ( m_bAboveHead && vtRetr.z < LIM_DOWN_APPRZ) { + double dSawEndElev ; + if ( GetAhPointUnderRaw( ptP4, vtTool, m_TParams.m_dTDiam / 2, + GetRadiusForStartEndElevation( false), + m_TParams.m_dLen, true, dSafeZ, vtMove, dSawEndElev)) { + Point3d ptP4b = ptP4 + vtMove * ( dSawEndElev + dSafeZ) ; + if ( AddRapidMove( ptP4b) == GDB_ID_NULL) + return false ; + } + } + else if ( ! m_bAboveHead && vtRetr.z > -LIM_DOWN_APPRZ) { + double dSawEndElev ; + if ( GetUhPointAboveRaw( ptP4, vtTool, m_TParams.m_dTDiam / 2, + GetRadiusForStartEndElevation( false), + m_TParams.m_dLen, true, dSafeZ, vtMove, dSawEndElev)) { + Point3d ptP4b = ptP4 + vtMove * ( dSawEndElev + dSafeZ) ; + if ( AddRapidMove( ptP4b) == GDB_ID_NULL) + return false ; + } + } } } @@ -6143,13 +6164,40 @@ Milling::GetRadiusForStartEndElevation( bool bExtra) const return ( 0.5 * m_TParams.m_dTDiam + dDeltaRad) ; } +//---------------------------------------------------------------------------- +bool +Milling::GetSimplePointOutOfRaw( const Point3d& ptP, const Vector3d& vtTool, const Vector3d& vtCorr) const +{ + // per frese che lavorano di testa + if ( m_TParams.m_nType == TT_MILL_STD) { + // eseguo verifica in direzione utensile + double dToolRad = m_TParams.m_dTDiam / 2 ; + double dToolDeltaLen = m_TParams.m_dTLen - m_TParams.m_dLen ; + double dTemp ; + if ( ! GetElevation( m_nPhase, ptP - ( dToolDeltaLen + MIN_SAFEDIST) * vtTool, vtTool, dToolRad + MIN_SAFEDIST, vtTool, dTemp)) + return false ; + return ( dTemp < 10 * EPS_SMALL) ; + } + // per frese che lavorano solo di fianco e per lame + else { + // eseguo verifica in direzione correzione + double dToolRad = m_TParams.m_dTDiam / 2 ; + double dToolThick = ( m_TParams.m_nType == TT_MILL_NOTIP ? m_TParams.m_dMaxMat : m_TParams.m_dThick) ; + double dToolDeltaLen = m_TParams.m_dTLen - m_TParams.m_dLen ; + double dTemp ; + if ( ! GetElevation( m_nPhase, ptP - ( dToolDeltaLen + MIN_SAFEDIST) * vtTool, vtTool, dToolRad + MIN_SAFEDIST, dToolThick, vtCorr, dTemp)) + return false ; + return ( dTemp < 10 * EPS_SMALL) ; + } +} + //---------------------------------------------------------------------------- bool Milling::GetPointOutOfRaw( const Point3d& ptP, const Vector3d& vtTool, const Vector3d& vtCorr, double dElev, double dSafeZ) const { // per frese normali if ( m_TParams.m_nType == TT_MILL_STD) { - // determino se l'inizio dell'attacco è fuori dal grezzo (considero movimento fresa lungo il suo asse) + // determino se la posizione è fuori dal grezzo (considero movimento fresa lungo il suo asse) double dTemp ; if ( ! GetElevation( m_nPhase, ptP, vtTool, m_TParams.m_dTDiam / 2, vtTool, dTemp)) return false ; @@ -6157,19 +6205,21 @@ Milling::GetPointOutOfRaw( const Point3d& ptP, const Vector3d& vtTool, const Vec } // per lame e frese che non lavorano di testa else { - // determino se l'inizio dell'attacco è fuori dal grezzo (considero movimento utensile in +/- Z) + // determino se la posizione è fuori dal grezzo (considero movimento utensile in +/- Z) double dTemp ; Vector3d vtMove = ( m_bAboveHead ? Z_AX : -Z_AX) ; Vector3d vtSafe = vtCorr ; vtSafe.z = 0 ; vtSafe.Normalize() ; Point3d ptQ = ptP - ( vtSafe + vtMove) * max( 0.2 * dSafeZ, MIN_SAFEDIST) ; + double dToolRad = m_TParams.m_dDiam / 2 ; + double dToolLen = ( ( m_TParams.m_nType & TF_SAWBLADE) != 0 ? m_TParams.m_dThick : m_TParams.m_dMaxMat) ; bool bOut = true ; - if ( ! GetElevation( m_nPhase, ptQ, vtTool, m_TParams.m_dDiam / 2, m_TParams.m_dThick, vtMove, dTemp) || dTemp > 10 * EPS_SMALL) { + if ( ! GetElevation( m_nPhase, ptQ, vtTool, dToolRad, dToolLen, vtMove, dTemp) || dTemp > 10 * EPS_SMALL) { bOut = false ; if ( ! m_bTiltingTab) return false ; } - Point3d ptR = ptP + vtTool * m_TParams.m_dThick ; - if ( ! GetElevation( m_nPhase, ptR, vtTool, m_TParams.m_dDiam / 2, m_TParams.m_dThick, vtMove, dTemp) || dTemp > 10 * EPS_SMALL) { + Point3d ptR = ptP + vtTool * dToolLen ; + if ( ! GetElevation( m_nPhase, ptR, vtTool, dToolRad, dToolLen, vtMove, dTemp) || dTemp > 10 * EPS_SMALL) { bOut = false ; if ( ! m_bTiltingTab) return false ; @@ -6177,9 +6227,9 @@ Milling::GetPointOutOfRaw( const Point3d& ptP, const Vector3d& vtTool, const Vec // 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, m_TParams.m_dDiam / 2, m_TParams.m_dThick, vtMove, dTemp) || dTemp > 10 * EPS_SMALL) + if ( ! GetElevation( m_nPhase, ptQ, vtTool, dToolRad, dToolLen, vtMove, dTemp) || dTemp > 10 * EPS_SMALL) return false ; - if ( ! GetElevation( m_nPhase, ptR, vtTool, m_TParams.m_dDiam / 2, m_TParams.m_dThick, vtMove, dTemp) || dTemp > 10 * EPS_SMALL) + if ( ! GetElevation( m_nPhase, ptR, vtTool, dToolRad, dToolLen, vtMove, dTemp) || dTemp > 10 * EPS_SMALL) return false ; } return true ; @@ -6191,7 +6241,7 @@ bool Milling::GetPointAboveRaw( const Point3d& ptP, const Vector3d& vtTool) const { // derivo punti più bassi dell'utensile - Vector3d vtDown = - FromUprightOrtho( vtTool) ; + Vector3d vtDown = -FromUprightOrtho( vtTool) ; Point3d ptP1 = ptP + vtDown * 0.5 * m_TParams.m_dTDiam ; Point3d ptP2 = ptP1 + vtTool * ((( m_TParams.m_nType & TF_SAWBLADE) == 0) ? m_TParams.m_dLen : m_TParams.m_dThick) ; // determino la posizione dei punti rispetto al grezzo @@ -6214,6 +6264,34 @@ Milling::GetPointAboveRaw( const Point3d& ptP, const Vector3d& vtTool) const return true ; } +//---------------------------------------------------------------------------- +bool +Milling::GetPointBelowRaw( const Point3d& ptP, const Vector3d& vtTool) const +{ + // derivo punti più alti dell'utensile + Vector3d vtUp = FromUprightOrtho( vtTool) ; + Point3d ptP1 = ptP + vtUp * 0.5 * m_TParams.m_dTDiam ; + Point3d ptP2 = ptP1 + vtTool * ((( m_TParams.m_nType & TF_SAWBLADE) == 0) ? m_TParams.m_dLen : m_TParams.m_dThick) ; + // determino la posizione dei punti 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) ; + if ( ! b3Raw.IsEmpty()) { + if ( ptP1.z > b3Raw.GetMin().z - 10 * EPS_SMALL || + ptP2.z > b3Raw.GetMin().z - 10 * EPS_SMALL) + return false ; + } + } + nRawId = m_pMchMgr->GetNextRawPart( nRawId) ; + } + return true ; +} + //---------------------------------------------------------------------------- bool Milling::CalcAndSetCorrAuxDir( const ICurveComposite* pCompo, double dU, bool bInvertSide) diff --git a/Milling.h b/Milling.h index c54aac7..11895a7 100644 --- a/Milling.h +++ b/Milling.h @@ -123,8 +123,10 @@ 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 GetSimplePointOutOfRaw( const Point3d& ptP, const Vector3d& vtTool, const Vector3d& vtCorr) const ; bool GetPointOutOfRaw( const Point3d& ptP, const Vector3d& vtTool, const Vector3d& vtCorr, double dElev, double dSafeZ) const ; bool GetPointAboveRaw( const Point3d& ptP, const Vector3d& vtTool) const ; + bool GetPointBelowRaw( const Point3d& ptP, const Vector3d& vtTool) const ; bool CalcAndSetCorrAuxDir( const ICurveComposite* pCompo, double dU, bool bInvertSide = false) ; Vector3d CalcCorrDir( const ICurveComposite* pCompo, double dU, bool bInvertSide = false) ; bool CalcOffset( ICurveComposite* pCompo, double dSignOffs) ;