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

EgtMachKernel :

Browse Source 
- ulteriori migliorie nel calcolo dell'elevazione.
This commit is contained in:
Dario Sassi
2023-12-07 11:00:26 +01:00
parent 368721dcaa
commit d49f198720
2 changed files with 99 additions and 246 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Milling.cpp
+93 -154
View File
@@ -2080,69 +2080,30 @@ bool
Milling::CalcPathElevation( const ICurveComposite* pCompo, const Vector3d& vtTool, double dDepth, double dRad,
double& dElev) const
{
// default
dElev = 0 ;
int nMaxInd = pCompo->GetCurveCount() - 1 ;
for ( int i = 0 ; i <= nMaxInd ; ++ i) {
// curva corrente
const ICurve* pCrvC = pCompo->GetCurve( i) ;
// calcolo elevazione
double dCurrElev ;
Point3d ptStart, ptMid, ptEnd ;
pCrvC->GetStartPoint( ptStart) ;
pCrvC->GetMidPoint( ptMid) ;
pCrvC->GetEndPoint( ptEnd) ;
Vector3d vtStartPerp, vtMidPerp, vtEndPerp, vtTg ;
pCrvC->GetStartDir( vtTg) ;
vtStartPerp = vtTg ^ vtTool ;
vtStartPerp.Normalize() ;
vtStartPerp *= dRad ;
pCrvC->GetMidDir( vtTg) ;
vtMidPerp = vtTg ^ vtTool ;
vtMidPerp.Normalize() ;
vtMidPerp *= dRad ;
pCrvC->GetEndDir( vtTg) ;
vtEndPerp = vtTg ^ vtTool ;
vtEndPerp.Normalize() ;
vtEndPerp *= dRad ;
Vector3d vtDepth = vtTool * dDepth ;
// linea centro utensile
if ( GetElevation( m_nPhase, ptStart - vtDepth, ptMid - vtDepth, ptEnd - vtDepth, vtTool, dCurrElev)) {
if ( dCurrElev > dElev)
dElev = dCurrElev ;
}
else {
m_pMchMgr->SetLastError( 2306, "Error in Milling : Entity GetElevation") ;
// controllo il raggio utensile
double const MIN_RAD = 5 ;
dRad = max( dRad, MIN_RAD) ;
// approssimo la curva con una polilinea
PolyLine PL ;
if ( ! pCompo->ApproxWithLines( LIN_TOL_STD, ANG_TOL_MAX_DEG, ICurve::APL_SPECIAL, PL))
return false ;
double const MIN_STEP = 5 ;
double const MAX_STEP = 500 ;
double dStep = Clamp( dRad, MIN_STEP, MAX_STEP) ;
PL.AdjustForMaxSegmentLen( dStep) ;
// calcolo l'elevazione
Point3d ptP ;
bool bFound = PL.GetFirstPoint( ptP) ;
while ( bFound) {
double dPtElev ;
if ( ! GetElevation( m_nPhase, ptP - vtTool * dDepth, vtTool, dRad, vtTool, dPtElev))
return false ;
}
// step laterali
int nStep = Clamp( int( dRad / ELEV_MAX_OFFS + 0.1), 0, 4) + 1 ;
// da una parte
for ( int j = 1 ; j <= nStep ; ++ j) {
double dCoeff = j / double( nStep) ;
if ( GetElevation( m_nPhase, ptStart + dCoeff * vtStartPerp - vtDepth, ptMid + dCoeff * vtMidPerp - vtDepth,
ptEnd + dCoeff * vtEndPerp - vtDepth, vtTool, dCurrElev)) {
if ( dCurrElev > dElev)
dElev = dCurrElev ;
}
else {
m_pMchMgr->SetLastError( 2306, "Error in Milling : Entity GetElevation") ;
return false ;
}
}
// dall'altra parte
for ( int j = 1 ; j <= nStep ; ++ j) {
double dCoeff = j / double( nStep) ;
if ( GetElevation( m_nPhase, ptStart - dCoeff * vtStartPerp - vtDepth, ptMid - dCoeff * vtMidPerp - vtDepth,
ptEnd - dCoeff * vtEndPerp - vtDepth, vtTool, dCurrElev)) {
if ( dCurrElev > dElev)
dElev = dCurrElev ;
}
else {
m_pMchMgr->SetLastError( 2306, "Error in Milling : Entity GetElevation") ;
return false ;
}
}
dElev = max( dElev, dPtElev) ;
bFound = PL.GetNextPoint( ptP) ;
}
return true ;
}
@@ -2394,28 +2355,24 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
Point3d ptTest = ptP1 - MIN_SAFEDIST * ( m_bAboveHead ? Z_AX : -Z_AX) ;
Vector3d vtAppr1 = FromNearestHorizontalOrtho( vtTool, ptP1 - ptStart) ;
Vector3d vtAppr2 = ptP1 - ptStart ;
if ( ! vtAppr2.Normalize()) {
if ( ( m_TParams.m_nType & TF_MILL) != 0)
vtAppr2 = -vtStart ;
else
vtAppr2 = CalcCorrDir( pCompo, i) ;
}
if ( ! vtAppr2.Normalize())
vtAppr2 = ( m_TParams.m_nType == TT_MILL_NOTIP ? -vtStart : CalcCorrDir( pCompo, i)) ;
double dThick = ( m_TParams.m_nType == TT_MILL_NOTIP ? m_TParams.m_dMaxMat : m_TParams.m_dThick) ;
double dSawStartElev1 = -1, dSawStartElev2 = -1 ;
GetElevation( m_nPhase, ptTest, vtTool, 0.5 * m_TParams.m_dDiam, dThick, vtAppr1, dSawStartElev1) ;
GetElevation( m_nPhase, ptTest, vtTool, 0.5 * m_TParams.m_dDiam, dThick, vtAppr2, dSawStartElev2) ;
if ( dSawStartElev1 > -EPS_SMALL && dSawStartElev2 > -EPS_SMALL) {
double dSawStartElev1, dSawStartElev2 ;
bool bOk1 = GetElevation( m_nPhase, ptTest, vtTool, m_TParams.m_dDiam / 2, dThick, vtAppr1, dSawStartElev1) ;
bool bOk2 = GetElevation( m_nPhase, ptTest, vtTool, m_TParams.m_dDiam / 2, dThick, vtAppr2, dSawStartElev2) ;
if ( bOk1 && bOk2) {
bool bFirst = ( dSawStartElev1 < dSawStartElev2) ;
vtAppr = ( bFirst ? vtAppr1 : vtAppr2) ;
dSawStartElev = ( bFirst ? dSawStartElev1 : dSawStartElev2) ;
bSideStart = true ;
}
else if ( dSawStartElev1 > -EPS_SMALL) {
else if ( bOk1) {
vtAppr = vtAppr1 ;
dSawStartElev = dSawStartElev1 ;
bSideStart = true ;
}
else if ( dSawStartElev2 > -EPS_SMALL) {
else if ( bOk2) {
vtAppr = vtAppr2 ;
dSawStartElev = dSawStartElev2 ;
bSideStart = true ;
@@ -2562,28 +2519,24 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
Point3d ptTest = ptP1 - MIN_SAFEDIST * ( m_bAboveHead ? Z_AX : -Z_AX) ;
Vector3d vtRetr1 = FromNearestHorizontalOrtho( vtTool, ptP1 - ptEnd) ;
Vector3d vtRetr2 = ptP1 - ptEnd ;
if ( ! vtRetr2.Normalize()) {
if ( ( m_TParams.m_nType & TF_MILL) != 0)
vtRetr2 = vtEnd ;
else
vtRetr2 = CalcCorrDir( pCompo, i + 1) ;
}
if ( ! vtRetr2.Normalize())
vtRetr2 = ( m_TParams.m_nType == TT_MILL_NOTIP ? vtEnd : CalcCorrDir( pCompo, i + 1)) ;
double dThick = ( m_TParams.m_nType == TT_MILL_NOTIP ? m_TParams.m_dMaxMat : m_TParams.m_dThick) ;
double dSawEndElev1, dSawEndElev2 ;
GetElevation( m_nPhase, ptTest, vtTool, 0.5 * m_TParams.m_dDiam, dThick, vtRetr1, dSawEndElev1) ;
GetElevation( m_nPhase, ptTest, vtTool, 0.5 * m_TParams.m_dDiam, dThick, vtRetr2, dSawEndElev2) ;
if ( dSawEndElev1 > -EPS_SMALL && dSawEndElev2 > -EPS_SMALL) {
bool bOk1 = GetElevation( m_nPhase, ptTest, vtTool, m_TParams.m_dDiam / 2, dThick, vtRetr1, dSawEndElev1) ;
bool bOk2 = GetElevation( m_nPhase, ptTest, vtTool, m_TParams.m_dDiam / 2, dThick, vtRetr2, dSawEndElev2) ;
if ( bOk1 && bOk2) {
bool bFirst = ( dSawEndElev1 < dSawEndElev2) ;
vtRetr = ( bFirst ? vtRetr1 : vtRetr2) ;
dSawEndElev = ( bFirst ? dSawEndElev1 : dSawEndElev2) ;
bSideEnd = true ;
}
else if ( dSawEndElev1 > -EPS_SMALL) {
else if ( bOk1) {
vtRetr = vtRetr1 ;
dSawEndElev = dSawEndElev1 ;
bSideEnd = true ;
}
else if ( dSawEndElev2 > -EPS_SMALL) {
else if ( bOk2) {
vtRetr = vtRetr2 ;
dSawEndElev = dSawEndElev2 ;
bSideEnd = true ;
@@ -2672,7 +2625,7 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
pCurve->GetStartDir( vtStart) ;
// 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, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
dStElev = dStep ;
// determino inizio attacco
Point3d ptP1 ;
@@ -2709,10 +2662,8 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
vtEscape.Normalize() ;
}
double dNewStElev ;
if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev)) {
if ( bAboveStart || dNewStElev > EPS_SMALL)
dStElev = min( dStElev, dNewStElev) ;
}
if ( GetElevation( m_nPhase, ptP1, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev))
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) ;
@@ -2750,23 +2701,23 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
Vector3d vtAppr1 = FromNearestHorizontalOrtho( vtTool, ptP1 - ptStart) ;
Vector3d vtAppr2 = ptP1 - ptStart ;
if ( ! vtAppr2.Normalize())
vtAppr2 = CalcCorrDir( pCompo, i) ;
vtAppr2 = ( m_TParams.m_nType == TT_MILL_NOTIP ? -vtStart : CalcCorrDir( pCompo, i)) ;
double dThick = ( m_TParams.m_nType == TT_MILL_NOTIP ? m_TParams.m_dMaxMat : m_TParams.m_dThick) ;
double dSawStartElev1 = -1, dSawStartElev2 = -1 ;
GetElevation( m_nPhase, ptTest, vtTool, 0.5 * m_TParams.m_dDiam, dThick, vtAppr1, dSawStartElev1) ;
GetElevation( m_nPhase, ptTest, vtTool, 0.5 * m_TParams.m_dDiam, dThick, vtAppr2, dSawStartElev2) ;
if ( dSawStartElev1 > -EPS_SMALL && dSawStartElev2 > -EPS_SMALL) {
double dSawStartElev1, dSawStartElev2 ;
bool bOk1 = GetElevation( m_nPhase, ptTest, vtTool, m_TParams.m_dDiam / 2, dThick, vtAppr1, dSawStartElev1) ;
bool bOk2 = GetElevation( m_nPhase, ptTest, vtTool, m_TParams.m_dDiam / 2, dThick, vtAppr2, dSawStartElev2) ;
if ( bOk1 && bOk2) {
bool bFirst = ( dSawStartElev1 < dSawStartElev2) ;
vtAppr = ( bFirst ? vtAppr1 : vtAppr2) ;
dSawStartElev = ( bFirst ? dSawStartElev1 : dSawStartElev2) ;
bSideStart = true ;
}
else if ( dSawStartElev1 > -EPS_SMALL) {
else if ( bOk1) {
vtAppr = vtAppr1 ;
dSawStartElev = dSawStartElev1 ;
bSideStart = true ;
}
else if ( dSawStartElev2 > -EPS_SMALL) {
else if ( bOk2) {
vtAppr = vtAppr2 ;
dSawStartElev = dSawStartElev2 ;
bSideStart = true ;
@@ -2879,7 +2830,7 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
pCurve->GetEndDir( vtEnd) ;
// elevazione sul punto finale
double dEndElev ;
if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
if ( ! GetElevation( m_nPhase, ptEnd, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
dEndElev = dElev ;
// se non c'è attacco a zigzag o a spirale oppure ultimo step, aggiungo uscita
Point3d ptP1 = ptEnd ;
@@ -2917,23 +2868,23 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
Vector3d vtRetr1 = FromNearestHorizontalOrtho( vtTool, ptP1 - ptEnd) ;
Vector3d vtRetr2 = ptP1 - ptEnd ;
if ( ! vtRetr2.Normalize())
vtRetr2 = CalcCorrDir( pCompo, i + 1) ;
vtRetr2 = ( m_TParams.m_nType == TT_MILL_NOTIP ? vtEnd : CalcCorrDir( pCompo, i + 1)) ;
double dThick = ( m_TParams.m_nType == TT_MILL_NOTIP ? m_TParams.m_dMaxMat : m_TParams.m_dThick) ;
double dSawEndElev1, dSawEndElev2 ;
GetElevation( m_nPhase, ptTest, vtTool, 0.5 * m_TParams.m_dDiam, dThick, vtRetr1, dSawEndElev1) ;
GetElevation( m_nPhase, ptTest, vtTool, 0.5 * m_TParams.m_dDiam, dThick, vtRetr2, dSawEndElev2) ;
if ( dSawEndElev1 > -EPS_SMALL && dSawEndElev2 > -EPS_SMALL) {
bool bOk1 = GetElevation( m_nPhase, ptTest, vtTool, m_TParams.m_dDiam / 2, dThick, vtRetr1, dSawEndElev1) ;
bool bOk2 = GetElevation( m_nPhase, ptTest, vtTool, m_TParams.m_dDiam / 2, dThick, vtRetr2, dSawEndElev2) ;
if ( bOk1 && bOk2) {
bool bFirst = ( dSawEndElev1 < dSawEndElev2) ;
vtRetr = ( bFirst ? vtRetr1 : vtRetr2) ;
dSawEndElev = ( bFirst ? dSawEndElev1 : dSawEndElev2) ;
bSideEnd = true ;
}
else if ( dSawEndElev1 > -EPS_SMALL) {
else if ( bOk1) {
vtRetr = vtRetr1 ;
dSawEndElev = dSawEndElev1 ;
bSideEnd = true ;
}
else if ( dSawEndElev2 > -EPS_SMALL) {
else if ( bOk2) {
vtRetr = vtRetr2 ;
dSawEndElev = dSawEndElev2 ;
bSideEnd = true ;
@@ -2971,10 +2922,8 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
vtEscape.Normalize() ;
}
double dNewEndElev ;
if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev)) {
if ( bAboveEnd || dNewEndElev > EPS_SMALL)
dEndElev = min( dEndElev, dNewEndElev) ;
}
if ( GetElevation( m_nPhase, ptP1, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev))
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) ;
@@ -3079,12 +3028,12 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
else if ( m_bAboveHead) {
// inizio con sua elevazione e sicurezza
double dStElev ;
if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, 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 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
if ( ! GetElevation( m_nPhase, ptEnd, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
dEndElev = dElev ;
Point3d ptPer = ptPe + ( dEndElev + dSafeZ) * vtTool ;
// verifica dei punti intermedi
@@ -3150,7 +3099,7 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
else {
// 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, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
dStElev = dElev ;
if ( ! bSafeDirLinkStartEnd)
dStElev = max( dStElev, j * dStep) ;
@@ -3166,7 +3115,6 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
if ( ( m_TParams.m_nType & TF_MILL) != 0 &&
( m_TParams.m_nType != TT_MILL_NOTIP || LeadInRawIsOk() || m_bStartOutRaw || bOutStart)) {
// 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) ||
( ! m_bAboveHead && vtTool.z > EPS_SMALL)) {
@@ -3174,10 +3122,10 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
vtEscape.Normalize() ;
}
double dNewStElev ;
if ( GetElevation( m_nPhase, ptP1m, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev)) {
if ( GetElevation( m_nPhase, ptP1, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev)) {
if ( bAboveStartEnd)
dStElev = min( dStElev, dNewStElev) ;
else if ( dNewStElev > EPS_SMALL)
else
dStElev = max( dStElev, dNewStElev) ;
}
if ( bOutStartEnd && m_bTiltingTab)
@@ -3229,23 +3177,23 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
Vector3d vtAppr1 = FromNearestHorizontalOrtho( vtTool, ptP1 - ptStart) ;
Vector3d vtAppr2 = ptP1 - ptStart ;
if ( ! vtAppr2.Normalize())
vtAppr2 = CalcCorrDir( pCompo, i) ;
vtAppr2 = ( m_TParams.m_nType == TT_MILL_NOTIP ? -vtStart : CalcCorrDir( pCompo, i)) ;
double dThick = ( m_TParams.m_nType == TT_MILL_NOTIP ? m_TParams.m_dMaxMat : m_TParams.m_dThick) ;
double dSawStartElev1 = -1, dSawStartElev2 = -1 ;
GetElevation( m_nPhase, ptTest, vtTool, 0.5 * m_TParams.m_dDiam, dThick + 2 * MIN_SAFEDIST, vtAppr1, dSawStartElev1) ;
GetElevation( m_nPhase, ptTest, vtTool, 0.5 * m_TParams.m_dDiam, dThick + 2 * MIN_SAFEDIST, vtAppr2, dSawStartElev2) ;
if ( dSawStartElev1 > -EPS_SMALL && dSawStartElev2 > -EPS_SMALL) {
double dSawStartElev1 = 0, dSawStartElev2 = 0 ;
bool bOk1 = GetElevation( m_nPhase, ptTest, vtTool, m_TParams.m_dDiam / 2, dThick, vtAppr1, dSawStartElev1) ;
bool bOk2 = GetElevation( m_nPhase, ptTest, vtTool, m_TParams.m_dDiam / 2, dThick, vtAppr2, dSawStartElev2) ;
if ( bOk1 && bOk2) {
bool bFirst = ( dSawStartElev1 < dSawStartElev2) ;
vtAppr = ( bFirst ? vtAppr1 : vtAppr2) ;
dSawStartElev = ( bFirst ? dSawStartElev1 : dSawStartElev2) ;
bSideStart = true ;
}
else if ( dSawStartElev1 > -EPS_SMALL) {
else if ( bOk1) {
vtAppr = vtAppr1 ;
dSawStartElev = dSawStartElev1 ;
bSideStart = true ;
}
else if ( dSawStartElev2 > -EPS_SMALL) {
else if ( bOk2) {
vtAppr = vtAppr2 ;
dSawStartElev = dSawStartElev2 ;
bSideStart = true ;
@@ -3328,7 +3276,7 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
pCurve->GetEndDir( vtEnd) ;
// elevazione sul punto finale
double dEndElev ;
if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
if ( ! GetElevation( m_nPhase, ptEnd, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
dEndElev = dElev ;
if ( ! bSafeDirLinkStartEnd)
dEndElev = max( dEndElev, j * dStep) ;
@@ -3350,7 +3298,6 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
if ( ( m_TParams.m_nType & TF_MILL) != 0 &&
( m_TParams.m_nType != TT_MILL_NOTIP || m_bEndOutRaw || bOutEnd)) {
// 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) ||
( ! m_bAboveHead && vtTool.z > EPS_SMALL)) {
@@ -3358,7 +3305,7 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
vtEscape.Normalize() ;
}
double dNewEndElev ;
if ( GetElevation( m_nPhase, ptP1m, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev)) {
if ( GetElevation( m_nPhase, ptP1, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev)) {
if ( bAboveStartEnd)
dEndElev = min( dEndElev, dNewEndElev) ;
else if ( dNewEndElev > EPS_SMALL)
@@ -3400,20 +3347,20 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
vtRetr2 = CalcCorrDir( pCompo, i + 1) ;
double dThick = ( m_TParams.m_nType == TT_MILL_NOTIP ? m_TParams.m_dMaxMat : m_TParams.m_dThick) ;
double dSawEndElev1, dSawEndElev2 ;
GetElevation( m_nPhase, ptTest, vtTool, 0.5 * m_TParams.m_dDiam, dThick, vtRetr1, dSawEndElev1) ;
GetElevation( m_nPhase, ptTest, vtTool, 0.5 * m_TParams.m_dDiam, dThick, vtRetr2, dSawEndElev2) ;
if ( dSawEndElev1 > -EPS_SMALL && dSawEndElev2 > -EPS_SMALL) {
bool bOk1 = GetElevation( m_nPhase, ptTest, vtTool, m_TParams.m_dDiam / 2, dThick, vtRetr1, dSawEndElev1) ;
bool bOk2 = GetElevation( m_nPhase, ptTest, vtTool, m_TParams.m_dDiam / 2, dThick, vtRetr2, dSawEndElev2) ;
if ( bOk1 && bOk2) {
bool bFirst = ( dSawEndElev1 < dSawEndElev2) ;
vtRetr = ( bFirst ? vtRetr1 : vtRetr2) ;
dSawEndElev = ( bFirst ? dSawEndElev1 : dSawEndElev2) ;
bSideEnd = true ;
}
else if ( dSawEndElev1 > -EPS_SMALL) {
else if ( bOk1) {
vtRetr = vtRetr1 ;
dSawEndElev = dSawEndElev1 ;
bSideEnd = true ;
}
else if ( dSawEndElev2 > -EPS_SMALL) {
else if ( bOk2) {
vtRetr = vtRetr2 ;
dSawEndElev = dSawEndElev2 ;
bSideEnd = true ;
@@ -3495,7 +3442,7 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
pCrvC->GetStartDir( vtStart) ;
// 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, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
dStElev = 0 ;
dStElev -= dStart ;
// determino inizio attacco
@@ -3519,10 +3466,8 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
vtEscape.Normalize() ;
}
double dNewStElev ;
if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev)) {
if ( bAboveStart || dNewStElev > EPS_SMALL)
dStElev = min( dStElev, dNewStElev) ;
}
if ( GetElevation( m_nPhase, ptP1, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev))
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) ;
@@ -3607,7 +3552,7 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
pCrvC->GetEndDir( vtEnd) ;
// elevazione sul punto finale
double dEndElev ;
if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
if ( ! GetElevation( m_nPhase, ptEnd, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
dEndElev = dElev ;
// aggiungo uscita
Point3d ptP1 ;
@@ -3628,10 +3573,8 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
vtEscape.Normalize() ;
}
double dNewEndElev ;
if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev)) {
if ( bAboveEnd || dNewEndElev > EPS_SMALL)
dEndElev = min( dEndElev, dNewEndElev) ;
}
if ( GetElevation( m_nPhase, ptP1, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev))
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) ;
@@ -3684,7 +3627,7 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
pCurve->GetStartDir( vtStart) ;
// 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, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
dStElev = dElev ;
dStElev -= dStart ;
// determino inizio attacco
@@ -3708,10 +3651,8 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
vtEscape.Normalize() ;
}
double dNewStElev ;
if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev)) {
if ( bAboveStart || dNewStElev > EPS_SMALL)
dStElev = min( dStElev, dNewStElev) ;
}
if ( GetElevation( m_nPhase, ptP1, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev))
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) ;
@@ -3791,7 +3732,7 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
pCurve->GetEndDir( vtEnd) ;
// elevazione sul punto finale
double dEndElev ;
if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
if ( ! GetElevation( m_nPhase, ptEnd, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
dEndElev = dElev ;
// aggiungo uscita
Point3d ptP1 ;
@@ -3812,10 +3753,8 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
vtEscape.Normalize() ;
}
double dNewEndElev ;
if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev)) {
if ( bAboveEnd || dNewEndElev > EPS_SMALL)
dEndElev = min( dEndElev, dNewEndElev) ;
}
if ( GetElevation( m_nPhase, ptP1, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev))
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) ;
@@ -3920,7 +3859,7 @@ Milling::AddSawZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtT
// determino elevazione su inizio attacco
double dStElev ;
if ( j == 1) {
if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
if ( ! GetElevation( m_nPhase, ptStart, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
dStElev = dElev ;
}
else
@@ -3997,7 +3936,7 @@ Milling::AddSawZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtT
// elevazione sul punto finale
double dEndElev ;
if ( j == nStep) {
if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
if ( ! GetElevation( m_nPhase, ptEnd, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
dEndElev = dElev ;
}
else
@@ -5810,7 +5749,7 @@ Milling::GetPointOutOfRaw( const Point3d& ptP, const Vector3d& vtTool, const Vec
if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
// determino se l'inizio dell'attacco è fuori dal grezzo (considero movimento fresa lungo il suo asse)
double dTemp ;
if ( ! GetElevation( m_nPhase, ptP, vtTool, 0.5 * m_TParams.m_dDiam, vtTool, dTemp))
if ( ! GetElevation( m_nPhase, ptP, vtTool, m_TParams.m_dDiam / 2, vtTool, dTemp))
return false ;
return ( dTemp < 10 * EPS_SMALL || dTemp > dElev + 10 * EPS_SMALL) ;
}
@@ -5822,13 +5761,13 @@ Milling::GetPointOutOfRaw( const Point3d& ptP, const Vector3d& vtTool, const Vec
Vector3d vtSafe = vtCorr ; vtSafe.z = 0 ; vtSafe.Normalize() ;
Point3d ptQ = ptP - ( vtSafe + vtMove) * max( 0.2 * dSafeZ, MIN_SAFEDIST) ;
bool bOut = true ;
if ( ! GetElevation( m_nPhase, ptQ, vtTool, 0.5 * m_TParams.m_dDiam, m_TParams.m_dThick, vtMove, dTemp) || dTemp > 10 * EPS_SMALL) {
if ( ! GetElevation( m_nPhase, ptQ, vtTool, m_TParams.m_dDiam / 2, m_TParams.m_dThick, 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, 0.5 * m_TParams.m_dDiam, m_TParams.m_dThick, vtMove, dTemp) || dTemp > 10 * EPS_SMALL) {
if ( ! GetElevation( m_nPhase, ptR, vtTool, m_TParams.m_dDiam / 2, m_TParams.m_dThick, vtMove, dTemp) || dTemp > 10 * EPS_SMALL) {
bOut = false ;
if ( ! m_bTiltingTab)
return false ;
@@ -5836,9 +5775,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, 0.5 * m_TParams.m_dDiam, m_TParams.m_dThick, vtMove, dTemp) || dTemp > 10 * EPS_SMALL)
if ( ! GetElevation( m_nPhase, ptQ, vtTool, m_TParams.m_dDiam / 2, m_TParams.m_dThick, vtMove, dTemp) || dTemp > 10 * EPS_SMALL)
return false ;
if ( ! GetElevation( m_nPhase, ptR, vtTool, 0.5 * m_TParams.m_dDiam, m_TParams.m_dThick, vtMove, dTemp) || dTemp > 10 * EPS_SMALL)
if ( ! GetElevation( m_nPhase, ptR, vtTool, m_TParams.m_dDiam / 2, m_TParams.m_dThick, vtMove, dTemp) || dTemp > 10 * EPS_SMALL)
return false ;
}
return true ;
Operation.cpp
+6 -92
View File
@@ -378,90 +378,6 @@ Operation::GetElevation( int nPhase, const Point3d& ptP1, const Point3d& ptP2, c
return true ;
}
#if 0
//----------------------------------------------------------------------------
bool
Operation::GetElevation( int nPhase, const Point3d& ptP, const Vector3d& vtTool, double dRad,
const Vector3d& vtDir, double& dElev) const
{
if ( m_pMchMgr == nullptr || m_pGeomDB == nullptr)
return false ;
// vettore grezzi interessati
INTVECTOR vRawStmId ;
// considero il punto centrale
if ( ! GetElevation( nPhase, ptP, vtDir, dElev, vRawStmId))
return false ;
// 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) {
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( EPS_ZERO) ;
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::GetElevation( int nPhase, const Point3d& ptP, const Vector3d& vtTool, double dRad, double dLen,
const Vector3d& vtDir, double& dElev) const
{
if ( m_pMchMgr == nullptr || m_pGeomDB == nullptr)
return false ;
// sopra e sotto
double dElev1, dElev2 ;
if ( ! GetElevation( nPhase, ptP, vtTool, dRad, vtDir, dElev1))
return false ;
if ( ! GetElevation( nPhase, ptP + dLen * vtTool, vtTool, dRad, vtDir, dElev2))
return false ;
dElev = max( dElev1, dElev2) ;
return true ;
}
#else
//----------------------------------------------------------------------------
bool
Operation::GetElevation( int nPhase, const Point3d& ptP, const Vector3d& vtTool, double dRad,
@@ -562,8 +478,6 @@ Operation::GetElevation( int nPhase, const Point3d& ptP, const Vector3d& vtTool,
return true ;
}
#endif
//----------------------------------------------------------------------------
bool
Operation::GetAhPointUnderRaw( const Point3d& ptP, const Vector3d& vtTool, double dToolRad, double dToolRadForElev,
@@ -603,17 +517,17 @@ Operation::GetAhPointUnderRaw( const Point3d& ptP, const Vector3d& vtTool, doubl
// 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))
if ( GetElevation( m_nPhase, ptTest, 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))
if ( GetElevation( m_nPhase, ptTest, 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))
if ( GetElevation( m_nPhase, ptTest, vtTool, dToolRadForElev, vtMyDir, dNewElev))
dElev = max( dElev, dNewElev) ;
}
return true ;
@@ -663,17 +577,17 @@ Operation::GetUhPointAboveRaw( const Point3d& ptP, const Vector3d& vtTool, doubl
// 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))
if ( GetElevation( m_nPhase, ptTest, 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))
if ( GetElevation( m_nPhase, ptTest, 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))
if ( GetElevation( m_nPhase, ptTest, vtTool, dToolRadForElev, vtMyDir, dNewElev))
dElev = max( dElev, dNewElev) ;
}
return true ;