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

EgtMachKernel :

Browse Source 
- migliorie su approcci eretrazioni di fresature con lame.
This commit is contained in:
DarioS
2022-04-22 08:53:59 +02:00
parent 6bb714e581
commit dc0b055480
3 changed files with 78 additions and 48 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Milling.cpp
+66 -42
View File
@@ -2244,13 +2244,10 @@ 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
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) ;
Vector3d vtAppr( vtTool.x, vtTool.y, 0) ;
if ( ! vtAppr.Normalize())
vtAppr = FromNearestHorizontalOrtho( vtTool, ptP1 - ptStart) ;
bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, vtAppr, dElev, dSafeZ) ;
// determino se l'inizio dell'attacco è sopra il grezzo
bool bGeomAboveStart = GetPointAboveRaw( ptP1, vtTool) ;
bool bAboveStart = ( m_bAboveHead && bGeomAboveStart) ;
@@ -2291,15 +2288,34 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
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) ;
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) {
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 ;
Point3d ptTest = ptP1 - MIN_SAFEDIST * ( m_bAboveHead ? Z_AX : -Z_AX) ;
Vector3d vtAppr1 = FromNearestHorizontalOrtho( vtTool, ptP1 - ptStart) ;
Vector3d vtAppr2 = ptP1 - ptStart ;
if ( ! vtAppr2.Normalize())
vtAppr2 = CalcCorrDir( pCompo, i) ;
double dSawStartElev1, dSawStartElev2 ;
GetElevation( m_nPhase, ptTest, vtTool, 0.5 * m_TParams.m_dDiam, vtAppr1, dSawStartElev1) ;
GetElevation( m_nPhase, ptTest, vtTool, 0.5 * m_TParams.m_dDiam, vtAppr2, dSawStartElev2) ;
if ( dSawStartElev1 > EPS_SMALL && dSawStartElev2 > EPS_SMALL) {
bool bFirst = ( dSawStartElev1 < dSawStartElev2) ;
vtAppr = ( bFirst ? vtAppr1 : vtAppr2) ;
dSawStartElev = ( bFirst ? dSawStartElev1 : dSawStartElev2) ;
bSideStart = true ;
}
else if ( dSawStartElev1 > EPS_SMALL) {
vtAppr = vtAppr1 ;
dSawStartElev = dSawStartElev1 ;
bSideStart = true ;
}
else if ( dSawStartElev2 > EPS_SMALL) {
vtAppr = vtAppr2 ;
dSawStartElev = dSawStartElev2 ;
bSideStart = true ;
}
}
if ( ! bGeomAboveStart && ! bUnderStart && ! bSideStart && bOk) {
@@ -2307,7 +2323,7 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
bOk = false ;
}
// aggiungo opportuno approccio
if ( ! AddSawBladeSideApproach( ptP1, vtCorr, dSafeZ, dSawStartElev, dAppr)) {
if ( ! AddSawBladeSideApproach( ptP1, vtAppr, dSafeZ, dSawStartElev, dAppr)) {
m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ;
return false ;
}
@@ -2409,13 +2425,10 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
// per lame quando è necessario
else {
// verifico di uscire in aria
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) ;
Vector3d vtRetr( vtTool.x, vtTool.y, 0) ;
if ( ! vtRetr.Normalize())
vtRetr = FromNearestHorizontalOrtho( vtTool, ptP1 - ptEnd) ;
bool bOutEnd = GetPointOutOfRaw( ptP1, vtTool, vtRetr, dElev, dSafeZ) ;
if ( ! bOutEnd) {
// verifico se sono sopra
bool bGeomAboveEnd = GetPointAboveRaw( ptP1, vtTool) ;
@@ -2425,14 +2438,32 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
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) ;
GetRadiusForStartEndElevation( false), m_TParams.m_dLen, true, dSafeZ, vtRetr, 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 ;
Point3d ptTest = ptP1 - MIN_SAFEDIST * ( m_bAboveHead ? Z_AX : -Z_AX) ;
Vector3d vtRetr1 = FromNearestHorizontalOrtho( vtTool, ptP1 - ptEnd) ;
Vector3d vtRetr2 = ptP1 - ptEnd ;
if ( ! vtRetr2.Normalize())
vtRetr2 = CalcCorrDir( pCompo, i + 1) ;
double dSawEndElev1, dSawEndElev2 ;
GetElevation( m_nPhase, ptTest, vtTool, 0.5 * m_TParams.m_dDiam, vtRetr1, dSawEndElev1) ;
GetElevation( m_nPhase, ptTest, vtTool, 0.5 * m_TParams.m_dDiam, vtRetr2, dSawEndElev2) ;
if ( dSawEndElev1 > EPS_SMALL && dSawEndElev2 > EPS_SMALL) {
bool bFirst = ( dSawEndElev1 < dSawEndElev2) ;
vtRetr = ( bFirst ? vtRetr1 : vtRetr2) ;
dSawEndElev = ( bFirst ? dSawEndElev1 : dSawEndElev2) ;
bSideEnd = true ;
}
else if ( dSawEndElev1 > EPS_SMALL) {
vtRetr = vtRetr1 ;
dSawEndElev = dSawEndElev1 ;
bSideEnd = true ;
}
else if ( dSawEndElev2 > EPS_SMALL) {
vtRetr = vtRetr2 ;
dSawEndElev = dSawEndElev2 ;
bSideEnd = true ;
}
}
if ( ! bGeomAboveEnd && ! bUnderEnd && ! bSideEnd && bOk) {
@@ -2440,12 +2471,11 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
bOk = false ;
}
// aggiungo opportuna retrazione
if ( ! AddSawBladeSideRetract( ptP1, vtCorr, dSafeZ, dSawEndElev, dAppr)) {
if ( ! AddSawBladeSideRetract( ptP1, vtRetr, dSafeZ, dSawEndElev, dAppr)) {
m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ;
return false ;
}
}
}
}
}
@@ -3605,13 +3635,10 @@ Milling::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ,
//----------------------------------------------------------------------------
bool
Milling::AddSawBladeSideApproach( const Point3d& ptP, const Vector3d& vtCorr, double dSafeZ, double dStElev, double dAppr)
Milling::AddSawBladeSideApproach( const Point3d& ptP, const Vector3d& vtAppr, double dSafeZ, double dStElev, double dAppr)
{
SetFlag( 1) ;
// 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() ;
// per approccio orizzontale vtAppr deve essere già stato sistemato dal chiamante
// 1 -> punto fuori inizio
Point3d ptP1 = ptP + vtAppr * ( dStElev + max( dAppr, dSafeZ)) ;
if ( AddRapidStart( ptP1) == GDB_ID_NULL)
@@ -3728,31 +3755,28 @@ Milling::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ,
//----------------------------------------------------------------------------
bool
Milling::AddSawBladeSideRetract( const Point3d& ptP, const Vector3d& vtCorr, double dSafeZ, double dEndElev, double dAppr)
Milling::AddSawBladeSideRetract( const Point3d& ptP, const Vector3d& vtRetr, double dSafeZ, double dEndElev, double dAppr)
{
// 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() ;
// per retrazione orizzontale vtAppr deve essere già stato sistemato dal chiamante
// se sopra uscita c'è spazio per sicurezza o approccio
if ( dEndElev + max( dSafeZ, dAppr) > 10 * EPS_SMALL) {
if ( dSafeZ < dAppr + 10 * EPS_SMALL) {
// 4 -> movimento di risalita sopra il punto finale
SetFeed( GetEndFeed()) ;
Point3d ptP4 = ptP + vtAppr * ( dEndElev + dAppr) ;
Point3d ptP4 = ptP + vtRetr * ( dEndElev + dAppr) ;
if ( AddLinearMove( ptP4) == GDB_ID_NULL)
return false ;
}
else {
// 4a -> movimento di risalita appena sopra il punto finale
Point3d ptP4a = ptP + vtAppr * ( dEndElev + dAppr) ;
Point3d ptP4a = ptP + vtRetr * ( dEndElev + dAppr) ;
if ( dEndElev + dAppr > EPS_SMALL) {
SetFeed( GetEndFeed()) ;
if ( AddLinearMove( ptP4a) == GDB_ID_NULL)
return false ;
}
// 4b -> movimento di risalita sopra il punto finale
Point3d ptP4b = ptP4a + vtAppr * ( dSafeZ - dAppr) ;
Point3d ptP4b = ptP4a + vtRetr * ( dSafeZ - dAppr) ;
if ( AddRapidMove( ptP4b) == GDB_ID_NULL)
return false ;
}
Milling.h
+2 -2
View File
@@ -98,11 +98,11 @@ class Milling : public Machining
double dDepth, double dElev, double dOkStep, bool bSplitArcs) ;
bool AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ,
double dElev, double dAppr, bool bOutStart, bool bAboveStart) ;
bool AddSawBladeSideApproach( const Point3d& ptP, const Vector3d& vtCorr, double dSafeZ, double dStElev, double dAppr) ;
bool AddSawBladeSideApproach( const Point3d& ptP, const Vector3d& vtAppr, double dSafeZ, double dStElev, double dAppr) ;
bool AddDirectApproach( const Point3d& ptP) ;
bool AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ,
double dElev, double dAppr, bool bAboveEnd) ;
bool AddSawBladeSideRetract( const Point3d& ptP, const Vector3d& vtCorr, double dSafeZ, double dEndElev, double dAppr) ;
bool AddSawBladeSideRetract( const Point3d& ptP, const Vector3d& vtRetr, double dSafeZ, double dEndElev, double dAppr) ;
bool CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtN,
double dStElev, bool bInvert, const ICurveComposite* pCompo, Point3d& ptP1) const ;
bool AddLeadIn( const Point3d& ptP1, const Point3d& ptStart, const Vector3d& vtStart,
Operation.cpp
+10 -4
View File
@@ -168,7 +168,7 @@ Operation::GetElevation( int nPhase, const Point3d& ptP,
// verifico che il grezzo compaia nella fase
if ( m_pMchMgr->VerifyRawPartPhase( nRawId, nPhase)) {
// intersezione del raggio dal punto alla trimesh del grezzo
const double RAY_LEN = 10000 ;
const double RAY_LEN = 100000 ;
int nStmId = m_pGeomDB->GetFirstNameInGroup( nRawId, MACH_RAW_SOLID) ;
ISurfTriMesh* pStm = GetSurfTriMesh( m_pGeomDB->GetGeoObj( nStmId)) ;
if ( pStm != nullptr) {
@@ -197,9 +197,15 @@ Operation::GetElevation( int nPhase, const Point3d& ptP,
else if ( Info.dCosDN > - COS_ORTO_ANG_ZERO) {
dElev = min( dElev, Info.dU) ;
}
// se altrimenti è la prima, distante ed entra, salto tutto
else if ( i == 0 && Info.dU > MAX_DIST_RAW && Info.dCosDN < - COS_ORTO_ANG_ZERO)
break ;
// se altrimenti è la prima ed entra
else if ( i == 0 && Info.dCosDN < - COS_ORTO_ANG_ZERO) {
// se una sola o distante salto tutto
if ( vInfo.size() == 1 || Info.dU > ( dElev > INFINITO - 1 ? 0 : dElev) + MAX_DIST_RAW)
break ;
// altrimenti reset
else
dElev = INFINITO ;
}
}
}
}