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

EgtMachKernel :

Browse Source 
- modifiche a fresature per approcci/retrazioni con frese che non lavorano di testa.
This commit is contained in:
Dario Sassi
2024-03-26 13:32:13 +01:00
parent 7fbce2b593
commit 0d0f195d8b
2 changed files with 169 additions and 89 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Milling.cpp
+167 -89
View File
@@ -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)
Milling.h
+2
View File
@@ -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) ;