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

EgtMachKernel 1.8e5 :

Browse Source 
- gestione da parametri lavorazione di angoli iniziali suggeriti e asse rotante bloccato
- in fresatura, svuotatura, incisione e lav. generica aggiunta possibilità di invertire direzione utensile
- in fresatura aggiunto parametro per tipo lavorazione faccia (perpendicolare, parallela, ...)
- differenziata distanza sicurezza standard da distanza sicurezza per rinvio da sotto
- migliorati approcci e retrazioni con rinvio da sotto
- migliorata segnalazione errori.
This commit is contained in:
Dario Sassi
2017-05-31 14:18:11 +00:00
parent c9ab1c76ed
commit 6c7a60b60a
48 changed files with 1214 additions and 234 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Milling.cpp
+246 -64
View File
@@ -47,6 +47,9 @@ using namespace std ;
// 2312 = "Error in Milling : LeadIn must be out of rawpart"
// 2313 = "Error in Milling : Chaining failed"
// 2314 = "Error in Milling : Tool MaxMaterial too small (xx)"
// 2315 = "Error in Milling : axes values not calculable"
// 2316 = "Error in Milling : link movements not calculable"
// 2317 = "Error in Milling : post apply not calculable"
//----------------------------------------------------------------------------
USEROBJ_REGISTER( "EMkMilling", Milling) ;
@@ -216,6 +219,9 @@ Milling::SetParam( int nType, bool bVal)
case MPA_LEAVETAB :
m_Params.m_bLeaveTab = bVal ;
return true ;
case MPA_TOOLINVERT :
m_Params.m_bToolInvert = bVal ;
return true ;
}
return false ;
}
@@ -250,6 +256,11 @@ Milling::SetParam( int nType, int nVal)
return false ;
m_Params.m_nSolCh = nVal ;
return true ;
case MPA_FACEUSE :
if ( ! m_Params.VerifyFaceUse( nVal))
return false ;
m_Params.m_nFaceUse = nVal ;
return true ;
}
return false ;
}
@@ -371,6 +382,12 @@ Milling::SetParam( int nType, const string& sVal)
case MPA_USERNOTES :
m_Params.m_sUserNotes = sVal ;
break ;
case MPA_INITANGS :
m_Params.m_sInitAngs = sVal ;
break ;
case MPA_BLOCKEDAXIS :
m_Params.m_sBlockedAxis = sVal ;
break ;
default :
return false ;
}
@@ -535,18 +552,36 @@ Milling::Apply( bool bRecalc)
return true ;
}
// imposto eventuale asse bloccato da lavorazione
if ( ! m_Params.m_sBlockedAxis.empty()) {
string sAxis, sVal ;
Split( m_Params.m_sBlockedAxis, "=", true, sAxis, sVal) ;
double dVal = 0 ;
FromString( sVal, dVal) ;
m_pMchMgr->ClearRotAxisBlock() ;
m_pMchMgr->SetRotAxisBlock( sAxis, dVal) ;
}
// calcolo gli assi macchina
string sHint = ExtractHint( m_Params.m_sUserNotes) ;
if ( ! CalculateAxesValues( sHint))
if ( ! m_Params.m_sInitAngs.empty())
sHint = m_Params.m_sInitAngs ;
if ( ! CalculateAxesValues( sHint)) {
m_pMchMgr->SetLastError( 2315, "Error in Milling : axes values not calculable") ;
return false ;
}
// gestione movimenti all'inizio di ogni singolo percorso di lavorazione e alla fine della lavorazione
if ( ! AdjustStartEndMovements())
if ( ! AdjustStartEndMovements()) {
m_pMchMgr->SetLastError( 2316, "Error in Milling : link movements not calculable") ;
return false ;
}
// esecuzione eventuali personalizzazioni
if ( ! PostApply())
if ( ! PostApply()) {
m_pMchMgr->SetLastError( 2317, "Error in Milling : post apply not calculable") ;
return false ;
}
return true ;
}
@@ -562,6 +597,9 @@ Milling::GetParam( int nType, bool& bVal) const
case MPA_LEAVETAB :
bVal = m_Params.m_bLeaveTab ;
return true ;
case MPA_TOOLINVERT :
bVal = m_Params.m_bToolInvert ;
return true ;
}
bVal = false ;
return false ;
@@ -590,6 +628,9 @@ Milling::GetParam( int nType, int& nVal) const
case MPA_SCC :
nVal = m_Params.m_nSolCh ;
return true ;
case MPA_FACEUSE :
nVal = m_Params.m_nFaceUse ;
return true ;
}
nVal = 0 ;
return false ;
@@ -691,6 +732,12 @@ Milling::GetParam( int nType, string& sVal) const
case MPA_USERNOTES :
sVal = m_Params.m_sUserNotes ;
return true ;
case MPA_INITANGS :
sVal = m_Params.m_sInitAngs ;
return true ;
case MPA_BLOCKEDAXIS :
sVal = m_Params.m_sBlockedAxis ;
return true ;
}
sVal = "" ;
return false ;
@@ -882,25 +929,24 @@ Milling::GetCurve( SelData Id)
bool
Milling::AdjustCurveFromSurf( ICurveComposite* pCrvCompo)
{
// tipo di utilizzo contorno superficie
enum { SURF_CONT = 0, SURF_TOP = 1, SURF_BOTTOM = 2} ;
int nSurf ;
// se fresa, lo recupero dalle note utente
if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
string sSurf = ExtractSurf( m_Params.m_sUserNotes) ;
if ( sSurf == "C")
nSurf = SURF_CONT ;
else if ( sSurf == "T")
nSurf = SURF_TOP ;
else
nSurf = SURF_BOTTOM ;
}
// altrimenti lama, sempre bottom
// tipo posizione utensile
enum { TOOL_PARAL = 1, TOOL_ORTHO = 2, TOOL_ORTUP = 3} ;
int nToolDir ;
if ( ( m_Params.m_nFaceUse & 64) != 0)
nToolDir = TOOL_ORTUP ;
else if ( ( m_Params.m_nFaceUse & 32) != 0)
nToolDir = TOOL_ORTHO ;
else
nSurf = SURF_BOTTOM ;
nToolDir = TOOL_PARAL ;
// tipo di utilizzo contorno faccia
enum { FACE_DOWN = 1, FACE_TOP = 2, FACE_FRONT = 3, FACE_BACK = 4, FACE_LEFT = 5, FACE_RIGHT = 6, FACE_CONT = 7} ;
int nFace = ( m_Params.m_nFaceUse & 31) ;
// copia della curva originale
PtrOwner<ICurveComposite> pCopy( pCrvCompo->Clone()) ;
// se richiesto contorno
if ( nSurf == SURF_CONT) {
if ( nFace == FACE_CONT) {
// cerco l'estremo più alto e lo imposto come inizio
double dU = 0 ;
double dUmax = 0 ;
@@ -921,16 +967,44 @@ Milling::AdjustCurveFromSurf( ICurveComposite* pCrvCompo)
// ingombro
BBox3d b3Box ;
pCrvCompo->GetLocalBBox( b3Box) ;
double dZmin = b3Box.GetMin().z ;
double dZmax = b3Box.GetMax().z ;
double dZtol = min( ( dZmax - dZmin) / 4., 20.) ;
// elimino le linee troppo sopra il minimo dall'inizio e poi dalla fine
double dMin = b3Box.GetMin().z ;
double dMax = b3Box.GetMax().z ;
if ( nFace == FACE_FRONT || nFace == FACE_BACK) {
dMin = b3Box.GetMin().y ;
dMax = b3Box.GetMax().y ;
}
else if ( nFace == FACE_RIGHT || nFace == FACE_LEFT) {
dMin = b3Box.GetMin().x ;
dMax = b3Box.GetMax().x ;
}
double dTol = min( ( dMax - dMin) / 4., 20.) ;
// cerco il punto medio delle curve più vicino all'estremo desiderato
double dRef = dMin ;
if ( nFace == FACE_DOWN || nFace == FACE_FRONT || nFace == FACE_LEFT)
dRef = dMax ;
const ICurve* pCrv = pCrvCompo->GetFirstCurve() ;
while ( pCrv != nullptr) {
Point3d ptMid ; pCrv->GetMidPoint( ptMid) ;
Vector3d vtDir ; pCrv->GetMidDir( vtDir) ;
if ( ( nSurf == SURF_BOTTOM && ptMid.z > dZmin + dZtol) ||
( nSurf == SURF_TOP && ptMid.z < dZmax - dZtol)) {
switch ( nFace) {
case FACE_DOWN : dRef = min( dRef, ptMid.z) ; break ;
case FACE_TOP : dRef = max( dRef, ptMid.z) ; break ;
case FACE_FRONT : dRef = min( dRef, ptMid.y) ; break ;
case FACE_BACK : dRef = max( dRef, ptMid.y) ; break ;
case FACE_LEFT : dRef = min( dRef, ptMid.x) ; break ;
case FACE_RIGHT : dRef = max( dRef, ptMid.x) ; break ;
}
pCrv = pCrvCompo->GetNextCurve() ;
}
// elimino le linee troppo discoste dal riferimento dall'inizio e poi dalla fine
pCrv = pCrvCompo->GetFirstCurve() ;
while ( pCrv != nullptr) {
Point3d ptMid ; pCrv->GetMidPoint( ptMid) ;
if ( ( nFace == FACE_DOWN && ptMid.z > dRef + dTol) ||
( nFace == FACE_TOP && ptMid.z < dRef - dTol) ||
( nFace == FACE_FRONT && ptMid.y > dRef + dTol) ||
( nFace == FACE_BACK && ptMid.y < dRef - dTol) ||
( nFace == FACE_LEFT && ptMid.x > dRef + dTol) ||
( nFace == FACE_RIGHT && ptMid.x < dRef - dTol)) {
ICurve* pErase = pCrvCompo->RemoveFirstOrLastCurve( false) ;
delete( pErase) ;
pCrv = pCrvCompo->GetFirstCurve() ;
@@ -941,9 +1015,12 @@ Milling::AdjustCurveFromSurf( ICurveComposite* pCrvCompo)
pCrv = pCrvCompo->GetLastCurve() ;
while ( pCrv != nullptr) {
Point3d ptMid ; pCrv->GetMidPoint( ptMid) ;
Vector3d vtDir ; pCrv->GetMidDir( vtDir) ;
if ( ( nSurf == SURF_BOTTOM && ptMid.z > dZmin + dZtol) ||
( nSurf == SURF_TOP && ptMid.z < dZmax - dZtol)) {
if ( ( nFace == FACE_DOWN && ptMid.z > dRef + dTol) ||
( nFace == FACE_TOP && ptMid.z < dRef - dTol) ||
( nFace == FACE_FRONT && ptMid.y > dRef + dTol) ||
( nFace == FACE_BACK && ptMid.y < dRef - dTol) ||
( nFace == FACE_LEFT && ptMid.x > dRef + dTol) ||
( nFace == FACE_RIGHT && ptMid.x < dRef - dTol)) {
ICurve* pErase = pCrvCompo->RemoveFirstOrLastCurve( true) ;
delete( pErase) ;
pCrv = pCrvCompo->GetLastCurve() ;
@@ -951,14 +1028,64 @@ Milling::AdjustCurveFromSurf( ICurveComposite* pCrvCompo)
else
break ;
}
// verifico il versore estrusione
}
// determino il versore estrusione (utensile)
if ( nToolDir == TOOL_ORTHO)
pCrvCompo->SetThickness( 0) ;
else if ( nToolDir == TOOL_ORTUP) {
Vector3d vtN ;
pCrvCompo->GetExtrusion( vtN) ;
if ( vtN.z < - sin( 2 * DEGTORAD)) {
pCrvCompo->Invert() ;
// pCrvCompo->Invert() ;
pCrvCompo->Translate( vtN * m_TParams.m_dThick) ;
pCrvCompo->SetExtrusion( - vtN) ;
}
pCrvCompo->SetThickness( 0) ;
}
else { // nToolDir == TOOL_PARAL
// sistemo versore
Vector3d vtN ;
pCrvCompo->GetExtrusion( vtN) ;
Point3d ptStart, ptEnd ;
pCrvCompo->GetStartPoint( ptStart) ;
pCrvCompo->GetEndPoint( ptEnd) ;
Vector3d vtT = ptEnd - ptStart ;
Vector3d vtExtr = vtN ^ vtT ;
if ( ! vtExtr.Normalize())
return false ;
pCrvCompo->SetExtrusion( vtExtr) ;
// elimino eventuali parti iniziali e/o finali dirette circa come il versore
const double MAX_ALL_COS = cos( 25 * DEGTORAD) ;
const ICurve* pCrv = pCrvCompo->GetFirstCurve() ;
while ( pCrv != nullptr) {
Vector3d vtDir ; pCrv->GetStartDir( vtDir) ;
if ( abs( vtDir * vtExtr) > MAX_ALL_COS) {
ICurve* pErase = pCrvCompo->RemoveFirstOrLastCurve( false) ;
delete( pErase) ;
pCrv = pCrvCompo->GetFirstCurve() ;
}
else
break ;
}
pCrv = pCrvCompo->GetLastCurve() ;
while ( pCrv != nullptr) {
Vector3d vtDir ; pCrv->GetStartDir( vtDir) ;
if ( abs( vtDir * vtExtr) > MAX_ALL_COS) {
ICurve* pErase = pCrvCompo->RemoveFirstOrLastCurve( true) ;
delete( pErase) ;
pCrv = pCrvCompo->GetLastCurve() ;
}
else
break ;
}
// determino lo spessore misurato lungo la direzione
if ( ! IsNull( pCopy)) {
Frame3d frOcs ; frOcs.Set( ORIG, vtExtr) ;
Frame3d frExtr ; frExtr.ToLoc( frOcs) ;
BBox3d b3Extr ; pCopy->GetBBox( frExtr, b3Extr) ;
if ( ! b3Extr.IsEmpty())
pCrvCompo->SetThickness( b3Extr.GetMax().z - b3Extr.GetMin().z) ;
}
}
return true ;
}
@@ -968,8 +1095,6 @@ bool
Milling::Chain( int nGrpDestId)
{
// vettore puntatori alle curve
typedef PtrOwner<ICurve> POWNCURVE ;
typedef std::vector<POWNCURVE> POCRVVECTOR ;
POCRVVECTOR vpCrvs ;
vpCrvs.reserve( m_vId.size()) ;
// recupero tutte le curve e le porto in globale
@@ -1117,6 +1242,14 @@ Milling::ProcessPath( int nPathId, int nPvId, int nClId)
double dThick ;
pCompo->GetThickness( dThick) ;
// eventuale inversione direzione utensile
if ( m_Params.m_bToolInvert) {
vtExtr.Invert() ;
pCompo->SetExtrusion( vtExtr) ;
dThick = - dThick ;
pCompo->SetThickness( dThick) ;
}
// eventuali allungamenti/accorciamenti per percorso aperto o chiuso senza sovrapposizione
if ( ! pCompo->IsClosed() || m_Params.m_dOverlap < EPS_SMALL) {
// verifico che il percorso sia abbastanza lungo
@@ -1574,8 +1707,9 @@ bool
Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTool, const Vector3d& vtExtr,
double dDepth, double dElev, bool bSplitArcs)
{
// recupero distanza di sicurezza
// recupero distanze di sicurezza
double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ;
double dSafeAggrBottZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeAggrBottZ() ;
// lunghezza di approccio/retrazione
double dAppr = m_Params.m_dStartPos ;
@@ -1608,6 +1742,8 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
return false ;
// determino se l'inizio dell'attacco è fuori dal grezzo
bool bOutStart = GetPointOutOfRaw( ptP1, vtTool) ;
// determino se l'inizio dell'attacco è sopra il grezzo
bool bAboveStart = GetPointAboveRaw( ptP1) ;
// aggiungo approccio per frese normali con spazio sopra attacco
if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
// correggo elevazione iniziale con punto inizio attacco
@@ -1618,7 +1754,7 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
dStElev = - LIO_ELEV_TOL ;
}
// approccio al punto iniziale
if ( ! AddApproach( ptP1, vtTool, dSafeZ, dStElev, dAppr, bOutStart))
if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dAppr, bOutStart, bAboveStart))
return false ;
}
// altrimenti, approccio per lame o diretto
@@ -1681,8 +1817,10 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
// correggo elevazione finale con punto fine uscita
dEndElev -= ( ptP1 - ptEnd) * vtExtr ;
// determino se la fine dell'uscita è sopra il grezzo
bool bAboveEnd = GetPointAboveRaw( ptP1) ;
// aggiungo retrazione
if ( ! AddRetract( ptP1, vtTool, dSafeZ, dEndElev, dAppr))
if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bAboveEnd))
return false ;
}
// per lame non è necessario
@@ -1696,8 +1834,9 @@ bool
Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool, const Vector3d& vtExtr,
double dDepth, double dElev, double dOkStep, bool bSplitArcs)
{
// recupero distanza di sicurezza
// recupero distanze di sicurezza
double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ;
double dSafeAggrBottZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeAggrBottZ() ;
// lunghezza di approccio/retrazione
double dAppr = m_Params.m_dStartPos ;
@@ -1745,12 +1884,14 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
return false ;
// determino se l'inizio dell'attacco è fuori dal grezzo
bool bOutStart = GetPointOutOfRaw( ptP1, vtTool) ;
// determino se l'inizio dell'attacco è sopra il grezzo
bool bAboveStart = GetPointAboveRaw( ptP1) ;
// se primo step aggiungo approccio per frese normali
if ( j == 1 && ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
// correggo elevazione iniziale con punto inizio attacco
dStElev -= ( ptP1 - ptStart) * vtExtr ;
// approccio al punto iniziale
if ( ! AddApproach( ptP1, vtTool, dSafeZ, dStElev, dAppr, bOutStart))
if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dAppr, bOutStart, bAboveStart))
return false ;
}
// altrimenti, affondo al punto iniziale
@@ -1832,8 +1973,10 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
if ( j == nStep && ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
// correggo elevazione finale con punto fine uscita
dEndElev -= ( ptP1 - ptEnd) * vtExtr ;
// determino se la fine dell'uscita è sopra il grezzo
bool bAboveEnd = GetPointAboveRaw( ptP1) ;
// aggiungo retrazione
if ( ! AddRetract( ptP1, vtTool, dSafeZ, dEndElev, dAppr))
if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bAboveEnd))
return false ;
}
// per lame non è necessario
@@ -1848,8 +1991,9 @@ bool
Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool, const Vector3d& vtExtr,
double dDepth, double dElev, double dOkStep, bool bSplitArcs)
{
// recupero distanza di sicurezza
// recupero distanze di sicurezza
double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ;
double dSafeAggrBottZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeAggrBottZ() ;
// lunghezza di approccio/retrazione
double dAppr = m_Params.m_dStartPos ;
@@ -1897,6 +2041,8 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
return false ;
// determino se l'inizio dell'attacco è fuori dal grezzo
bool bOutStart = GetPointOutOfRaw( ptP1, vtTool) ;
// determino se l'inizio dell'attacco è sopra il grezzo
bool bAboveStart = GetPointAboveRaw( ptP1) ;
// aggiungo approccio per frese normali
if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
// correggo elevazione iniziale con punto inizio attacco
@@ -1907,7 +2053,7 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
dStElev = ( j - 1) * dStep ;
}
// approccio al punto iniziale
if ( ! AddApproach( ptP1, vtTool, dSafeZ, dStElev, dAppr, bOutStart))
if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dAppr, bOutStart, bAboveStart))
return false ;
}
// altrimenti, approccio per lame
@@ -1974,8 +2120,10 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
// correggo elevazione finale con punto fine uscita
dEndElev -= ( ptP1 - ptEnd) * vtExtr ;
// determino se la fine dell'uscita è sopra il grezzo
bool bAboveEnd = GetPointAboveRaw( ptP1) ;
// aggiungo retrazione
if ( ! AddRetract( ptP1, vtTool, dSafeZ, dEndElev, dAppr))
if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bAboveEnd))
return false ;
}
// per lame non è necessario
@@ -1990,8 +2138,9 @@ bool
Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool, const Vector3d& vtExtr,
double dDepth, double dElev, double dOkStep, bool bSplitArcs)
{
// recupero distanza di sicurezza
// recupero distanze di sicurezza
double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ;
double dSafeAggrBottZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeAggrBottZ() ;
// lunghezza di approccio/retrazione
double dAppr = m_Params.m_dStartPos ;
// se attacco ad inseguimento (per ora nullo), parto sopra di elevazione in attacco
@@ -2041,12 +2190,14 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
return false ;
// determino se l'inizio dell'attacco è fuori dal grezzo
bool bOutStart = GetPointOutOfRaw( ptP1, vtTool) ;
// determino se l'inizio dell'attacco è sopra il grezzo
bool bAboveStart = GetPointAboveRaw( ptP1) ;
// aggiungo approccio per frese normali
if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
// correggo elevazione iniziale con punto inizio attacco
dStElev -= ( ptP1 - ptStart) * vtExtr ;
// approccio al punto iniziale
if ( ! AddApproach( ptP1, vtTool, dSafeZ, dStElev, dAppr, bOutStart))
if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dAppr, bOutStart, bAboveStart))
return false ;
}
// altrimenti, affondo al punto iniziale per lame
@@ -2113,8 +2264,10 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
// correggo elevazione finale con punto fine uscita
dEndElev -= ( ptP1 - ptEnd) * vtExtr ;
// determino se la fine dell'uscita è sopra il grezzo
bool bAboveEnd = GetPointAboveRaw( ptP1) ;
// aggiungo retrazione
if ( ! AddRetract( ptP1, vtTool, dSafeZ, dEndElev, dAppr))
if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bAboveEnd))
return false ;
}
// per lame non è necessario
@@ -2167,8 +2320,10 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
dStElev -= ( ptP1 - ptStart) * vtExtr ;
// determino se l'inizio dell'attacco è fuori dal grezzo
bool bOutStart = GetPointOutOfRaw( ptP1, vtTool) ;
// determino se l'inizio dell'attacco è sopra il grezzo
bool bAboveStart = GetPointAboveRaw( ptP1) ;
// approccio al punto iniziale
if ( ! AddApproach( ptP1, vtTool, dSafeZ, dStElev, dAppr, bOutStart))
if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dAppr, bOutStart, bAboveStart))
return false ;
}
// altrimenti, affondo per lame
@@ -2229,8 +2384,10 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
// correggo elevazione finale con punto fine uscita
dEndElev -= ( ptP1 - ptEnd) * vtExtr ;
// determino se la fine dell'uscita è sopra il grezzo
bool bAboveEnd = GetPointAboveRaw( ptP1) ;
// aggiungo retrazione
if ( ! AddRetract( ptP1, vtTool, dSafeZ, dEndElev, dAppr))
if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bAboveEnd))
return false ;
}
// per lame non è necessario
@@ -2243,7 +2400,8 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
//----------------------------------------------------------------------------
bool
Milling::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr, bool bOutStart)
Milling::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ,
double dElev, double dAppr, bool bOutStart, bool bAboveStart)
{
SetFlag( 1) ;
// se con aggregato da sotto
@@ -2254,14 +2412,14 @@ Milling::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ,
m_pGeomDB->GetInfo( m_pMchMgr->GetHeadId( m_TParams.m_sHead), "AGB_ENCH", dAgbEncH) ;
m_pGeomDB->GetInfo( m_pMchMgr->GetHeadId( m_TParams.m_sHead), "AGB_ENCV", dAgbEncV) ;
// aggiuntivo in Z
double dAggZ = max( dElev + max( dSafeZ, dAppr), 0.) ;
double dAggZ = max( dElev + max( dSafeAggrBottZ, dAppr), 0.) ;
// distanza dal bordo del pezzo
double dDistBottom ;
if ( ! GetDistanceFromRawSide( m_nPhase, ptP, m_vtAux, dDistBottom))
dDistBottom = 0 ;
// pre-approccio
Point3d ptP0 = ptP - Z_AX * dAggZ + m_vtAux * ( dDistBottom + dAgbEncH + dAppr) ;
Point3d ptP00 = ptP0 + Z_AX * ( dAgbEncV + m_TParams.m_dLen + dAggZ) ;
Point3d ptP0 = ptP - Z_AX * dAggZ + m_vtAux * ( dDistBottom + dAgbEncH + dSafeZ) ;
Point3d ptP00 = ptP0 + Z_AX * ( dAgbEncV + m_TParams.m_dLen + dAggZ - dElev) ;
Vector3d vtAux = m_vtAux ;
vtAux.Rotate( Z_AX, 90) ;
SetAuxDir( vtAux) ;
@@ -2273,10 +2431,11 @@ Milling::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ,
if ( AddRapidMove( ptP0, MCH_CL_AGB_IN) == GDB_ID_NULL)
return false ;
}
// se sopra attacco c'è spazio per sicurezza o approccio
if ( dElev + max( dSafeZ, dAppr) > 10 * EPS_SMALL) {
// se non sono già sopra il pezzo e sopra attacco c'è spazio per sicurezza o approccio
double dSafeDist = ( m_bAggrBottom ? dSafeAggrBottZ : dSafeZ) ;
if ( ! bAboveStart && dElev + max( dSafeDist, dAppr) > 10 * EPS_SMALL) {
// se distanza di sicurezza minore di distanza di inizio
if ( dSafeZ < dAppr + 10 * EPS_SMALL) {
if ( dSafeDist < dAppr + 10 * EPS_SMALL) {
// 1 -> punto sopra inizio
Point3d ptP1 = ptP + vtTool * ( dElev + dAppr) ;
if ( ( ! m_bAggrBottom && AddRapidStart( ptP1) == GDB_ID_NULL) ||
@@ -2286,7 +2445,7 @@ Milling::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ,
else {
// 1a -> punto sopra inizio
Point3d ptP1b = ptP + vtTool * ( dElev + dAppr) ;
Point3d ptP1a = ptP1b + vtTool * ( dSafeZ - dAppr) ;
Point3d ptP1a = ptP1b + vtTool * ( dSafeDist - dAppr) ;
if ( ( ! m_bAggrBottom && AddRapidStart( ptP1a) == GDB_ID_NULL) ||
( m_bAggrBottom && AddRapidMove( ptP1a) == GDB_ID_NULL))
return false ;
@@ -2315,11 +2474,13 @@ Milling::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ,
//----------------------------------------------------------------------------
bool
Milling::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr)
Milling::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ,
double dElev, double dAppr, bool bAboveEnd)
{
// se sopra uscita c'è spazio per sicurezza o approccio
if ( dElev + max( dSafeZ, dAppr) > 10 * EPS_SMALL) {
if ( dSafeZ < dAppr + 10 * EPS_SMALL) {
// se non sono già sopra il pezzo e sopra uscita c'è spazio per sicurezza o approccio
double dSafeDist = ( m_bAggrBottom ? dSafeAggrBottZ : dSafeZ) ;
if ( ! bAboveEnd && dElev + max( dSafeDist, dAppr) > 10 * EPS_SMALL) {
if ( dSafeDist < dAppr + 10 * EPS_SMALL) {
// 4 -> movimento di risalita sopra il punto finale
SetFeed( GetEndFeed()) ;
Point3d ptP4 = ptP + vtTool * ( dElev + dAppr) ;
@@ -2335,7 +2496,7 @@ Milling::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ,
return false ;
}
// 4b -> movimento di risalita sopra il punto finale
Point3d ptP4b = ptP4a + vtTool * ( dSafeZ - dAppr) ;
Point3d ptP4b = ptP4a + vtTool * ( dSafeDist - dAppr) ;
if ( AddRapidMove( ptP4b) == GDB_ID_NULL)
return false ;
}
@@ -2348,14 +2509,14 @@ Milling::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ,
m_pGeomDB->GetInfo( m_pMchMgr->GetHeadId( m_TParams.m_sHead), "AGB_ENCH", dAgbEncH) ;
m_pGeomDB->GetInfo( m_pMchMgr->GetHeadId( m_TParams.m_sHead), "AGB_ENCV", dAgbEncV) ;
// aggiuntivo in Z
double dAggZ = max( dElev + max( dSafeZ, dAppr), 0.) ;
double dAggZ = max( dElev + max( dSafeAggrBottZ, dAppr), 0.) ;
// distanza dal bordo del pezzo
double dDistBottom ;
if ( ! GetDistanceFromRawSide( m_nPhase, ptP, m_vtAux, dDistBottom))
dDistBottom = 0 ;
// post-retract
Point3d ptP0 = ptP - Z_AX * dAggZ + m_vtAux * ( dDistBottom + dAgbEncH + dAppr) ;
Point3d ptP00 = ptP0 + Z_AX * ( dAgbEncV + m_TParams.m_dLen + dAggZ) ;
Point3d ptP0 = ptP - Z_AX * dAggZ + m_vtAux * ( dDistBottom + dAgbEncH + dSafeZ) ;
Point3d ptP00 = ptP0 + Z_AX * ( dAgbEncV + m_TParams.m_dLen + dAggZ - dElev) ;
if ( AddRapidMove( ptP0, MCH_CL_AGB_OUT) == GDB_ID_NULL)
return false ;
Vector3d vtAux = m_vtAux ;
@@ -2713,7 +2874,7 @@ double
Milling::GetRadiusForStartEndElevation( void)
{
const double DELTA_ELEV_RAD = 20.0 ;
double dDeltaRad = DELTA_ELEV_RAD + max( m_Params.m_dStartAddLen, m_Params.m_dEndAddLen) ;
double dDeltaRad = DELTA_ELEV_RAD + max( max( m_Params.m_dStartAddLen, m_Params.m_dEndAddLen), 0.0) ;
return ( 0.5 * m_TParams.m_dTDiam + dDeltaRad) ;
}
@@ -2727,3 +2888,24 @@ Milling::GetPointOutOfRaw( const Point3d& ptP, const Vector3d& vtTool)
return false ;
return ( dTemp < 10 * EPS_SMALL) ;
}
//----------------------------------------------------------------------------
bool
Milling::GetPointAboveRaw( const Point3d& ptP)
{
// determino la posizione del punto 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() && ptP.z < b3Raw.GetMax().z - 10 * EPS_SMALL)
return false ;
}
nRawId = m_pMchMgr->GetNextRawPart( nRawId) ;
}
return true ;
}