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

EgtMachKernel :

Browse Source 
- aggiunta gestione oggetti per verifica collisioni nei link tra lavorazioni anche nelle tavole
- in fresatura standard migliorati approcci e retrazioni per frese che non lavorano di testa
- in simulazione migliorata gestione comandi ausiliari di start in Disposizioni senza movimenti.
This commit is contained in:
Dario Sassi
2024-03-19 18:11:50 +01:00
parent 74b2874f56
commit 7fbce2b593
10 changed files with 149 additions and 54 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Milling.cpp
+56 -38
View File
@@ -2267,6 +2267,8 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
// lunghezza di approccio/retrazione
double dAppr = m_Params.m_dStartPos ;
double dExtrAppr = dAppr + max( 0.0, m_TParams.m_dTLen - m_TParams.m_dLen) ;
// delta da punto lavoro a punto tip
Vector3d vtWkTip = vtTool * ( m_TParams.m_dLen - m_TParams.m_dTLen) ;
// in caso di tabs ne aggiusto i parametri secondo il percorso
TabData tdTabs ;
@@ -2302,7 +2304,7 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
pCurve->GetStartDir( vtStart) ;
// determino elevazione su inizio percorso di lavoro
double dStElev ;
if ( ! GetElevation( m_nPhase, ptStart, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
if ( ! GetElevation( m_nPhase, ptStart + vtWkTip, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
dStElev = dElev ;
// determino inizio attacco
Point3d ptP1 ;
@@ -2314,9 +2316,9 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
Vector3d vtAppr( vtTool.x, vtTool.y, 0) ;
if ( ! vtAppr.Normalize())
vtAppr = FromNearestHorizontalOrtho( vtTool, vtDir1) ;
bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, vtAppr, dStElev, dSafeZ) ;
bool bOutStart = GetPointOutOfRaw( ptP1 + vtWkTip, vtTool, vtAppr, dStElev, dSafeZ) ;
// determino se l'inizio dell'attacco è sopra il grezzo
bool bGeomAboveStart = GetPointAboveRaw( ptP1, vtTool) ;
bool bGeomAboveStart = GetPointAboveRaw( ptP1 + vtWkTip, vtTool) ;
bool bAboveStart = false ;
if ( m_bAboveHead) {
if ( ! m_bTiltingTab)
@@ -2330,7 +2332,7 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
CalcAndSetCorrAuxDir( pCompo, i) ;
// 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)) {
// 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) ||
@@ -2339,13 +2341,13 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
vtEscape.Normalize() ;
}
double dNewStElev ;
if ( GetElevation( m_nPhase, ptP1, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev))
if ( GetElevation( m_nPhase, ptP1 + vtWkTip, 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(),
bool bAhUnderStart = m_bAboveHead && GetAhPointUnderRaw( ptP1 + vtWkTip, vtTool, 0, GetRadiusForStartEndElevation(),
m_TParams.m_dLen, false, dSafeZ, vtEscape, dStElev) ;
// se testa sotto, determino se l'inizio dell'attacco è esattamente sopra il grezzo, nel qual caso ricalcolo l'elevazione
bool bUhAboveStart = ! m_bAboveHead && GetUhPointAboveRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
bool bUhAboveStart = ! m_bAboveHead && GetUhPointAboveRaw( ptP1 + vtWkTip, vtTool, 0, GetRadiusForStartEndElevation(),
m_TParams.m_dLen, false, dSafeZ, vtEscape, dStElev) ;
// se attacco a zigzag o a spirale, l'elevazione va nell'attacco
if ( IsLeadInHelixOrZigzag()) {
@@ -2364,15 +2366,21 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
if ( ! bOutStart) {
// 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 + vtWkTip, vtTool, m_TParams.m_dTDiam / 2,
GetRadiusForStartEndElevation( false),
m_TParams.m_dLen, true, dSafeZ, vtAppr, dSawStartElev) ;
}
else {
bUhAboveStart = ! m_bAboveHead && GetUhPointAboveRaw( ptP1 + vtWkTip, 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 * ( m_bAboveHead ? Z_AX : -Z_AX) - DELTA_ELEV_RAD * vtTool ;
Point3d ptTestU = ptTest + m_TParams.m_dDiam * ( m_bAboveHead ? Z_AX : -Z_AX) ;
Vector3d vtAppr1 = FromNearestHorizontalOrtho( vtTool, vtDir1) ;
@@ -2381,9 +2389,9 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
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) + 2 * DELTA_ELEV_RAD ;
double dSawStartElev1, dSawStartElev2 ;
bool bOk1 = GetElevation( m_nPhase, ptTest, ptTestU, vtTool, GetRadiusForStartEndElevation(), dThick, vtAppr1, dSawStartElev1) ;
bool bOk1 = GetElevation( m_nPhase, ptTest + vtWkTip, ptTestU + vtWkTip, vtTool, GetRadiusForStartEndElevation(), dThick, vtAppr1, dSawStartElev1) ;
bool bOk2 = ! AreSameVectorApprox( vtAppr2, vtAppr1) &&
GetElevation( m_nPhase, ptTest, ptTestU, vtTool, GetRadiusForStartEndElevation(), dThick, vtAppr2, dSawStartElev2) ;
GetElevation( m_nPhase, ptTest + vtWkTip, ptTestU + vtWkTip, vtTool, GetRadiusForStartEndElevation(), dThick, vtAppr2, dSawStartElev2) ;
if ( bOk1 && bOk2) {
bool bFirst = ( dSawStartElev1 < 1.3 * dSawStartElev2) ;
vtAppr = ( bFirst ? vtAppr1 : vtAppr2) ;
@@ -2401,7 +2409,7 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
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 ;
}
@@ -2474,7 +2482,7 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
pCurve->GetEndDir( vtEnd) ;
// elevazione sul punto finale
double dEndElev ;
if ( ! GetElevation( m_nPhase, ptEnd, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
if ( ! GetElevation( m_nPhase, ptEnd + vtWkTip, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
dEndElev = dElev ;
// aggiungo uscita
Point3d ptP1 ;
@@ -2488,18 +2496,18 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
Vector3d vtRetr( vtTool.x, vtTool.y, 0) ;
if ( ! vtRetr.Normalize())
vtRetr = FromNearestHorizontalOrtho( vtTool, vtDir1) ;
bool bOutEnd = GetPointOutOfRaw( ptP1, vtTool, vtRetr, dEndElev, dSafeZ) ;
bool bOutEnd = GetPointOutOfRaw( ptP1 + vtWkTip, 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)) {
// determino se la fine dell'uscita è sopra il grezzo
bool bAboveEnd = false ;
if ( m_bAboveHead) {
if ( ! m_bTiltingTab)
bAboveEnd = GetPointAboveRaw( ptP1, vtTool) ;
bAboveEnd = GetPointAboveRaw( ptP1 + vtWkTip, vtTool) ;
else {
Vector3d vtCorr = CalcCorrDir( pCompo, nMaxInd + 1) ;
if ( GetPointOutOfRaw( ptP1, vtTool, vtCorr, dEndElev, dSafeZ))
if ( GetPointOutOfRaw( ptP1 + vtWkTip, vtTool, vtCorr, dEndElev, dSafeZ))
dEndElev = min( dEndElev, dElev) ;
}
}
@@ -2511,13 +2519,13 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
vtEscape.Normalize() ;
}
double dNewEndElev ;
if ( GetElevation( m_nPhase, ptP1, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev))
if ( GetElevation( m_nPhase, ptP1 + vtWkTip, 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(),
bool bAhUnderEnd = m_bAboveHead && GetAhPointUnderRaw( ptP1 + vtWkTip, vtTool, 0, GetRadiusForStartEndElevation(),
m_TParams.m_dLen, false, dSafeZ, vtEscape, dEndElev) ;
// se testa sotto, determino se l'inizio dell'uscita è esattamente sopra il grezzo, nel qual caso ricalcolo l'elevazione
bool bUhAboveEnd = ! m_bAboveHead && GetUhPointAboveRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
bool bUhAboveEnd = ! m_bAboveHead && GetUhPointAboveRaw( ptP1 + vtWkTip, vtTool, 0, GetRadiusForStartEndElevation(),
m_TParams.m_dLen, false, dSafeZ, vtEscape, dEndElev) ;
// aggiungo retrazione
if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dExtrAppr, bAboveEnd)) {
@@ -2529,17 +2537,23 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
else {
if ( ! bOutEnd) {
// verifico se sono sopra
bool bGeomAboveEnd = GetPointAboveRaw( ptP1, vtTool) ;
bool bGeomAboveEnd = GetPointAboveRaw( ptP1 + vtWkTip, 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( true),
m_TParams.m_dLen, true, dSafeZ, vtRetr, dSawEndElev) ;
bAhUnderEnd = m_bAboveHead && GetAhPointUnderRaw( ptP1 + vtWkTip, vtTool, m_TParams.m_dTDiam / 2,
GetRadiusForStartEndElevation( true),
m_TParams.m_dLen, true, dSafeZ, vtRetr, dSawEndElev) ;
}
if ( ! bUnderEnd) {
else {
bUhAboveEnd = ! m_bAboveHead && GetUhPointAboveRaw( ptP1 + vtWkTip, vtTool, m_TParams.m_dTDiam / 2,
GetRadiusForStartEndElevation( true),
m_TParams.m_dLen, true, dSafeZ, vtRetr, dSawEndElev) ;
}
if ( ! bAhUnderEnd && ! bUhAboveEnd) {
Point3d ptTest = ptP1 - MIN_SAFEDIST * ( m_bAboveHead ? Z_AX : -Z_AX) - DELTA_ELEV_RAD * vtTool ;
Point3d ptTestU = ptTest + m_TParams.m_dDiam * ( m_bAboveHead ? Z_AX : -Z_AX) ;
Vector3d vtRetr1 = FromNearestHorizontalOrtho( vtTool, vtDir1) ;
@@ -2548,9 +2562,9 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
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) + 2 * DELTA_ELEV_RAD ;
double dSawEndElev1, dSawEndElev2 ;
bool bOk1 = GetElevation( m_nPhase, ptTest, ptTestU, vtTool, GetRadiusForStartEndElevation(), dThick, vtRetr1, dSawEndElev1) ;
bool bOk1 = GetElevation( m_nPhase, ptTest + vtWkTip, ptTestU + vtWkTip, vtTool, GetRadiusForStartEndElevation(), dThick, vtRetr1, dSawEndElev1) ;
bool bOk2 = ! AreSameVectorApprox( vtRetr2, vtRetr1) &&
GetElevation( m_nPhase, ptTest, ptTestU, vtTool, GetRadiusForStartEndElevation(), dThick, vtRetr2, dSawEndElev2) ;
GetElevation( m_nPhase, ptTest + vtWkTip, ptTestU + vtWkTip, vtTool, GetRadiusForStartEndElevation(), dThick, vtRetr2, dSawEndElev2) ;
if ( bOk1 && bOk2) {
bool bFirst = ( dSawEndElev1 < 1.3 * dSawEndElev2) ;
vtRetr = ( bFirst ? vtRetr1 : vtRetr2) ;
@@ -2568,7 +2582,7 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
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 ;
}
@@ -5121,12 +5135,16 @@ Milling::AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d
Vector3d vtRot = OrthoCompo( vtTool, vtEnd) ;
vtPerp.Rotate( vtRot, 0, ( bCcwRot ? 1 : - 1)) ;
ptP1 = ptEnd + vtEnd * dTang + vtPerp * dPerp + vtTool * dElev ;
vtDir1 = ptP1 - ptEnd ;
if ( ! vtDir1.Normalize())
return false ;
// inserisco uscita
PtrOwner<ICurve> pCrv( GetArc2PVN( ptEnd, ptP1, vtEnd, vtTool)) ;
if ( IsNull( pCrv))
return false ;
// assegno direzione finale dell'uscita
if ( ! pCrv->GetEndDir( vtDir1))
Vector3d vtDirF ;
if ( ! pCrv->GetEndDir( vtDirF))
return false ;
bool bOk = true ;
// eventuale spezzatura
@@ -5141,7 +5159,7 @@ Milling::AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d
}
// eventuale movimento ortogonale (estensione di inserimento compensazione raggio utensile)
if ( m_Params.m_dLoCompLen > 10 * EPS_SMALL) {
vtDir1 = OrthoCompo( vtDir1, vtTool) ;
vtDir1 = OrthoCompo( vtDirF, vtTool) ;
bOk = bOk && vtDir1.Normalize() ;
vtDir1.Rotate( vtRot, 0, ( bCcwRot ? 1 : - 1)) ;
ptP1 += vtDir1 * m_Params.m_dLoCompLen ;
@@ -6130,16 +6148,16 @@ 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 & TF_SAWBLADE) == 0) {
if ( m_TParams.m_nType == TT_MILL_STD) {
// determino se l'inizio dell'attacco è fuori dal grezzo (considero movimento fresa lungo il suo asse)
double dTemp ;
if ( ! GetElevation( m_nPhase, ptP, vtTool, m_TParams.m_dDiam / 2, vtTool, dTemp))
if ( ! GetElevation( m_nPhase, ptP, vtTool, m_TParams.m_dTDiam / 2, vtTool, dTemp))
return false ;
return ( dTemp < 10 * EPS_SMALL || dTemp > dElev + 10 * EPS_SMALL) ;
}
// per lame
// per lame e frese che non lavorano di testa
else {
// determino se l'inizio dell'attacco è fuori dal grezzo (considero movimento lama in +/- Z)
// determino se l'inizio dell'attacco è 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() ;