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

EgtMachKernel :

Browse Source 
- si conservano le info delle uscite delle teste al caricamento della macchina
- al caricamento di un utensile su una uscita di una testa si caricano anche tutti gli utensili previsti dall'attrezzaggio sulle altre uscite della stessa testa
- aggiunta gestione attacchi a elica e zigzag nelle contornature
- migliorato controllo collisioni e gestione risalite conseguenti.
This commit is contained in:
Dario Sassi
2017-04-04 07:39:43 +00:00
parent d10c193039
commit 493ff4b9e4
10 changed files with 336 additions and 264 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Milling.cpp
+213 -215
View File
@@ -1124,6 +1124,9 @@ Milling::ProcessPath( int nPathId, int nPvId, int nClId)
LOG_INFO( GetEMkLogger(), "Warning in Milling : skipped Path too small") ;
return true ;
}
// se una sola entità circonferenza completa, la divido in due per poterla allungare
if ( pCompo->GetCurveCount() == 1 && pCompo->IsClosed())
pCompo->AddJoint( 0.5) ;
// eventuali allungamenti
if ( m_Params.m_dStartAddLen > EPS_SMALL) {
if ( ! pCompo->ExtendStartByLen( m_Params.m_dStartAddLen))
@@ -1177,7 +1180,6 @@ Milling::ProcessPath( int nPathId, int nPvId, int nClId)
}
// eventuale sovrapposizione per percorso chiuso
bool bOverlapOn = false ;
if ( pCompo->IsClosed()) {
if ( m_Params.m_dOverlap > EPS_SMALL) {
double dParS, dParE ;
@@ -1186,7 +1188,6 @@ Milling::ProcessPath( int nPathId, int nPvId, int nClId)
PtrOwner<ICurve> pCrv( pCompo->CopyParamRange( dParS, dParE)) ;
if ( ! IsNull( pCrv)) {
pCompo->AddCurve( Release( pCrv)) ;
bOverlapOn = true ;
}
}
}
@@ -1348,6 +1349,7 @@ Milling::ProcessPath( int nPathId, int nPvId, int nClId)
// Se una sola passata
if ( dOkStep < EPS_SMALL || dElev <= dOkStep) {
// eseguo lavorazione
if ( ! AddStandardMilling( pCompo, vtTool, vtExtr, dDepth, dElev, bSplitArcs))
return false ;
}
@@ -1363,13 +1365,6 @@ Milling::ProcessPath( int nPathId, int nPvId, int nClId)
}
// se altrimenti passate a spirale
else if ( m_Params.m_nStepType == MILL_ST_SPIRAL) {
// elimino eventuale overlap prima aggiunto
if ( bOverlapOn) {
double dLen ;
if ( pCompo->GetLength( dLen))
pCompo->TrimEndAtLen( dLen - m_Params.m_dOverlap) ;
}
// eseguo
if ( ! AddSpiralMilling( pCompo, vtTool, vtExtr, dDepth, dElev, dOkStep, bSplitArcs))
return false ;
}
@@ -1600,19 +1595,25 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
pCurve->GetStartPoint( ptStart) ;
Vector3d vtStart ;
pCurve->GetStartDir( vtStart) ;
// determino elevazione su inizio percorso di lavoro
double dStElev ;
if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), dStElev))
dStElev = dElev ;
// determino inizio attacco
Point3d ptP1 ;
if ( ! CalcLeadInStart( ptStart, vtStart, vtExtr, false, ptP1))
if ( ! CalcLeadInStart( ptStart, vtStart, vtExtr, dStElev, false, ptP1))
return false ;
// determino se l'inizio dell'attacco è fuori dal grezzo
bool bOutStart = GetPointOutOfRaw( ptP1, vtTool) ;
// aggiungo approccio per frese normali con spazio sopra attacco
if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
// determino elevazione su inizio percorso di lavoro
double dStElev ;
if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), dStElev))
dStElev = dElev ;
// correggo elevazione iniziale con punto inizio attacco
dStElev -= ( ptP1 - ptStart) * vtExtr ;
// se attacco a zigzag o a spirale o a scivolo, l'elevazione va nell'attacco
if ( IsLeadInHelixZigzagGlide()) {
ptP1 += vtExtr * dStElev ;
dStElev = 0 ;
}
// approccio al punto iniziale
if ( ! AddApproach( ptP1, vtTool, dSafeZ, dStElev, dAppr, bOutStart))
return false ;
@@ -1662,18 +1663,20 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
pCurve->GetEndPoint( ptEnd) ;
Vector3d vtEnd ;
pCurve->GetEndDir( vtEnd) ;
// elevazione sul punto finale
double dEndElev ;
if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), dEndElev))
dEndElev = dElev ;
// aggiungo uscita
Point3d ptP1 ;
SetFeed( GetStartFeed()) ;
if ( ! AddLeadOut( ptEnd, vtEnd, vtExtr, false, bSplitArcs, ptP1)) {
if ( ! AddLeadOut( ptEnd, vtEnd, vtExtr, dEndElev, false, bSplitArcs, ptP1)) {
m_pMchMgr->SetLastError( 2310, "Error in Milling : LeadOut not computable") ;
return false ;
}
// aggiungo retrazione per frese normali
if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
double dEndElev ;
if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), dEndElev))
dEndElev = dElev ;
// correggo elevazione finale con punto fine uscita
dEndElev -= ( ptP1 - ptEnd) * vtExtr ;
// aggiungo retrazione
if ( ! AddRetract( ptP1, vtTool, dSafeZ, dEndElev, dAppr))
@@ -1704,10 +1707,10 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
// ciclo sugli step
for ( int j = 1 ; j <= nStep ; ++ j) {
// flag direzione (prima passata indice 1)
bool bInvert = ( ( j % 2) == 0) ;
// ciclo sulle curve elementari
for ( int i = 0 ; i <= nMaxInd ; ++ i) {
// flag direzione (prima passata indice 1)
bool bInvert = ( ( j % 2) == 0) ;
// curva corrente
const ICurve* pCrvC = pCompo->GetCurve( ( bInvert ? nMaxInd - i : i)) ;
// copio la curva
@@ -1725,18 +1728,23 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
pCurve->GetStartPoint( ptStart) ;
Vector3d vtStart ;
pCurve->GetStartDir( vtStart) ;
// determino inizio attacco
// determino elevazione su inizio attacco
double dStElev ;
if ( j == 1) {
if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), dStElev))
dStElev = dElev ;
}
else
dStElev = dStep - LIO_ELEV_TOL - 10 * EPS_SMALL ;
// determino inizio attacco
Point3d ptP1 ;
if ( ! CalcLeadInStart( ptStart, vtStart, vtExtr, bInvert, ptP1))
if ( ! CalcLeadInStart( ptStart, vtStart, vtExtr, dStElev, bInvert, ptP1))
return false ;
// determino se l'inizio dell'attacco è fuori dal grezzo
bool bOutStart = GetPointOutOfRaw( ptP1, vtTool) ;
// se primo step aggiungo approccio per frese normali
if ( j == 1 && ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
// determino elevazione su inizio attacco
double dStElev ;
if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), dStElev))
dStElev = dElev ;
// correggo elevazione iniziale con punto inizio attacco
dStElev -= ( ptP1 - ptStart) * vtExtr ;
// approccio al punto iniziale
if ( ! AddApproach( ptP1, vtTool, dSafeZ, dStElev, dAppr, bOutStart))
@@ -1802,18 +1810,25 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
pCurve->GetEndPoint( ptEnd) ;
Vector3d vtEnd ;
pCurve->GetEndDir( vtEnd) ;
// elevazione sul punto finale
double dEndElev ;
if ( j == nStep) {
if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), dEndElev))
dEndElev = dElev ;
}
else
dEndElev = - LIO_ELEV_TOL ;
// aggiungo uscita
Point3d ptP1 ;
SetFeed( GetStartFeed()) ;
if ( ! AddLeadOut( ptEnd, vtEnd, vtExtr, bInvert, bSplitArcs, ptP1)) {
if ( ! AddLeadOut( ptEnd, vtEnd, vtExtr, dEndElev, bInvert, bSplitArcs, ptP1)) {
m_pMchMgr->SetLastError( 2310, "Error in Milling : LeadOut not computable") ;
return false ;
}
// se ultimo step aggiungo retrazione per frese normali
if ( j == nStep && ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
double dEndElev ;
if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), dEndElev))
dEndElev = dElev ;
// correggo elevazione finale con punto fine uscita
dEndElev -= ( ptP1 - ptEnd) * vtExtr ;
// aggiungo retrazione
if ( ! AddRetract( ptP1, vtTool, dSafeZ, dEndElev, dAppr))
return false ;
@@ -1842,6 +1857,9 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
bool bClosed = pCompo->IsClosed() ;
int nMaxInd = pCompo->GetCurveCount() - 1 ;
// percorso speciale : chiuso e con attacco a spirale o zigzag
bool bSpecial = bClosed && ( GetLeadInType() == MILL_LI_HELIX || GetLeadInType() == MILL_LI_ZIGZAG) ;
// ciclo sugli step
for ( int j = 1 ; j <= nStep ; ++ j) {
// ciclo sulle curve elementari
@@ -1861,34 +1879,48 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
pCurve->GetStartPoint( ptStart) ;
Vector3d vtStart ;
pCurve->GetStartDir( vtStart) ;
// determino inizio attacco
// punto inizio attacco
Point3d ptP1 ;
if ( ! CalcLeadInStart( ptStart, vtStart, vtExtr, false, ptP1))
return false ;
// determino se l'inizio dell'attacco è fuori dal grezzo
bool bOutStart = GetPointOutOfRaw( ptP1, vtTool) ;
// aggiungo approccio per frese normali
if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
// se speciale e step intermedio
if ( bSpecial && j > 1) {
ptP1 = ptStart + dStep * vtExtr ;
}
// altrimenti
else {
// determino elevazione su inizio attacco
double dStElev ;
if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), dStElev))
dStElev = dElev ;
dStElev -= ( ptP1 - ptStart) * vtExtr ;
// approccio al punto iniziale
if ( ! AddApproach( ptP1, vtTool, dSafeZ, dStElev, dAppr, bOutStart))
return false ;
}
// altrimenti, approccio per lame
else {
// verifico di entrare in aria
if ( ! bOutStart) {
m_pMchMgr->SetLastError( 2312, "Error in Milling : LeadIn must be out of rawpart") ;
// determino inizio attacco
if ( ! CalcLeadInStart( ptStart, vtStart, vtExtr, dStElev, false, ptP1))
return false ;
// determino se l'inizio dell'attacco è fuori dal grezzo
bool bOutStart = GetPointOutOfRaw( ptP1, vtTool) ;
// aggiungo approccio per frese normali
if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
// correggo elevazione iniziale con punto inizio attacco
dStElev -= ( ptP1 - ptStart) * vtExtr ;
// se attacco a zigzag o a spirale o a scivolo, l'elevazione va nell'attacco
if ( IsLeadInHelixZigzagGlide()) {
ptP1 += vtExtr * ( dStElev - ( j - 1) * dStep) ;
dStElev = ( j - 1) * dStep ;
}
// approccio al punto iniziale
if ( ! AddApproach( ptP1, vtTool, dSafeZ, dStElev, dAppr, bOutStart))
return false ;
}
// altrimenti, approccio per lame
else {
// verifico di entrare in aria
if ( ! bOutStart) {
m_pMchMgr->SetLastError( 2312, "Error in Milling : LeadIn must be out of rawpart") ;
return false ;
}
// affondo al punto iniziale
SetFlag( 0) ;
if ( AddRapidStart( ptP1) == GDB_ID_NULL)
return false ;
}
// affondo al punto iniziale
SetFlag( 0) ;
if ( AddRapidStart( ptP1) == GDB_ID_NULL)
return false ;
}
// aggiungo attacco
SetFeed( GetStartFeed()) ;
@@ -1918,23 +1950,29 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
}
// se ultima entità, uscita e retrazione
if ( i == nMaxInd) {
// se speciale e step intermedio salto uscita e retrazione
if ( bSpecial && j != nStep)
continue ;
// dati fine entità
Point3d ptEnd ;
pCurve->GetEndPoint( ptEnd) ;
Vector3d vtEnd ;
pCurve->GetEndDir( vtEnd) ;
// elevazione sul punto finale
double dEndElev ;
if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), dEndElev))
dEndElev = dElev ;
// aggiungo uscita
Point3d ptP1 ;
SetFeed( GetStartFeed()) ;
if ( ! AddLeadOut( ptEnd, vtEnd, vtExtr, false, bSplitArcs, ptP1)) {
if ( ! AddLeadOut( ptEnd, vtEnd, vtExtr, dEndElev, false, bSplitArcs, ptP1)) {
m_pMchMgr->SetLastError( 2310, "Error in Milling : LeadOut not computable") ;
return false ;
}
// aggiungo retrazione per frese normali
if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
double dEndElev ;
if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), dEndElev))
dEndElev = dElev ;
// correggo elevazione finale con punto fine uscita
dEndElev -= ( ptP1 - ptEnd) * vtExtr ;
// aggiungo retrazione
if ( ! AddRetract( ptP1, vtTool, dSafeZ, dEndElev, dAppr))
return false ;
@@ -1992,18 +2030,19 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
ptStart -= vtStaDepth ;
Vector3d vtStart ;
pCrvC->GetStartDir( vtStart) ;
// determino elevazione su inizio attacco
double dStElev ;
if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), dStElev))
dStElev = 0 ;
// determino inizio attacco
Point3d ptP1 ;
if ( ! CalcLeadInStart( ptStart, vtStart, vtExtr, false, ptP1))
if ( ! CalcLeadInStart( ptStart, vtStart, vtExtr, dStElev, false, ptP1))
return false ;
// determino se l'inizio dell'attacco è fuori dal grezzo
bool bOutStart = GetPointOutOfRaw( ptP1, vtTool) ;
// aggiungo approccio per frese normali
if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
// determino elevazione su inizio attacco
double dStElev ;
if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), dStElev))
dStElev = 0 ;
// correggo elevazione iniziale con punto inizio attacco
dStElev -= ( ptP1 - ptStart) * vtExtr ;
// approccio al punto iniziale
if ( ! AddApproach( ptP1, vtTool, dSafeZ, dStElev, dAppr, bOutStart))
@@ -2058,18 +2097,21 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
ptEnd -= vtEndDepth ;
Vector3d vtEnd ;
pCrvC->GetEndDir( vtEnd) ;
// elevazione sul punto finale
double dEndElev ;
if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), dEndElev))
dEndElev = dElev ;
// aggiungo uscita
Point3d ptP1 ;
SetFeed( GetStartFeed()) ;
if ( ! AddLeadOut( ptEnd, vtEnd, vtExtr, false, bSplitArcs, ptP1)) {
if ( ! AddLeadOut( ptEnd, vtEnd, vtExtr, dEndElev, false, bSplitArcs, ptP1)) {
m_pMchMgr->SetLastError( 2310, "Error in Milling : LeadOut not computable") ;
return false ;
}
// aggiungo retrazione per frese normali
if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
double dEndElev ;
if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), dEndElev))
dEndElev = dElev ;
// correggo elevazione finale con punto fine uscita
dEndElev -= ( ptP1 - ptEnd) * vtExtr ;
// aggiungo retrazione
if ( ! AddRetract( ptP1, vtTool, dSafeZ, dEndElev, dAppr))
return false ;
@@ -2110,16 +2152,17 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
ptStart -= vtStaDepth ;
Vector3d vtStart ;
pCurve->GetStartDir( vtStart) ;
// determino elevazione su inizio attacco
double dStElev ;
if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), dStElev))
dStElev = dElev ;
// determino inizio attacco
Point3d ptP1 ;
if ( ! CalcLeadInStart( ptStart, vtStart, vtExtr, bInvert, ptP1))
if ( ! CalcLeadInStart( ptStart, vtStart, vtExtr, dStElev, bInvert, ptP1))
return false ;
// aggiungo approccio per frese normali
if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
// determino elevazione su inizio attacco
double dStElev ;
if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), dStElev))
dStElev = dElev ;
// correggo elevazione iniziale con punto inizio attacco
dStElev -= ( ptP1 - ptStart) * vtExtr ;
// determino se l'inizio dell'attacco è fuori dal grezzo
bool bOutStart = GetPointOutOfRaw( ptP1, vtTool) ;
@@ -2170,18 +2213,21 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
ptEnd -= vtEndDepth ;
Vector3d vtEnd ;
pCurve->GetEndDir( vtEnd) ;
// elevazione sul punto finale
double dEndElev ;
if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), dEndElev))
dEndElev = dElev ;
// aggiungo uscita
Point3d ptP1 ;
SetFeed( GetStartFeed()) ;
if ( ! AddLeadOut( ptEnd, vtEnd, vtExtr, bInvert, bSplitArcs, ptP1)) {
if ( ! AddLeadOut( ptEnd, vtEnd, vtExtr, dEndElev, bInvert, bSplitArcs, ptP1)) {
m_pMchMgr->SetLastError( 2310, "Error in Milling : LeadOut not computable") ;
return false ;
}
// aggiungo retrazione per frese normali
if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
double dEndElev ;
if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), dEndElev))
dEndElev = dElev ;
// correggo elevazione finale con punto fine uscita
dEndElev -= ( ptP1 - ptEnd) * vtExtr ;
// aggiungo retrazione
if ( ! AddRetract( ptP1, vtTool, dSafeZ, dEndElev, dAppr))
return false ;
@@ -2320,16 +2366,38 @@ Milling::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ,
return true ;
}
//----------------------------------------------------------------------------
int
Milling::GetLeadInType( void) const
{
if ( abs( m_Params.m_dLiTang) < min( 0.1 * m_TParams.m_dDiam, 0.1) &&
abs( m_Params.m_dLiPerp) < min( 0.1 * m_TParams.m_dDiam, 0.1))
return MILL_LI_NONE ;
if ( ( m_Params.m_nLeadInType == MILL_LI_HELIX || m_Params.m_nLeadInType == MILL_LI_ZIGZAG) &&
( m_Params.m_dLiTang < min( 0.1 * m_TParams.m_dDiam, 1.0) || m_Params.m_dLiElev < 10 * EPS_SMALL))
return MILL_LI_NONE ;
if ( ( m_Params.m_nLeadInType == MILL_LI_HELIX || m_Params.m_nLeadInType == MILL_LI_ZIGZAG ||
m_Params.m_nLeadInType == MILL_LI_GLIDE) && m_Params.m_nStepType == MILL_ST_ZIGZAG)
return MILL_LI_NONE ;
if ( ( m_Params.m_nLeadInType == MILL_LI_HELIX || m_Params.m_nLeadInType == MILL_LI_ZIGZAG ||
m_Params.m_nLeadInType == MILL_LI_GLIDE) && m_Params.m_nStepType == MILL_ST_SPIRAL)
return MILL_LI_NONE ;
if ( ( m_Params.m_nLeadInType == MILL_LI_HELIX || m_Params.m_nLeadInType == MILL_LI_ZIGZAG) &&
( m_TParams.m_nType & TF_SAWBLADE) != 0)
return MILL_LI_LINEAR ;
return m_Params.m_nLeadInType ;
}
//----------------------------------------------------------------------------
bool
Milling::CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtN, bool bInvert,
Point3d& ptP1)
Milling::CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtN,
double dStElev, bool bInvert, Point3d& ptP1)
{
// Assegno tipo e parametri
int nType = m_Params.m_nLeadInType ;
int nType = GetLeadInType() ;
double dTang = m_Params.m_dLiTang ;
double dPerp = m_Params.m_dLiPerp ;
double dElev = m_Params.m_dLiElev ;
double dElev = min( m_Params.m_dLiElev, dStElev + LIO_ELEV_TOL) ;
// se step invertito
if ( bInvert) {
switch ( m_Params.m_nLeadOutType) {
@@ -2342,14 +2410,14 @@ Milling::CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtStart, const
if ( m_Params.m_nLeadOutType != MILL_LO_AS_LI) {
dTang = m_Params.m_dLoTang ;
dPerp = m_Params.m_dLoPerp ;
dElev = m_Params.m_dLoElev ;
dElev = min( m_Params.m_dLoElev, dStElev + LIO_ELEV_TOL) ;
}
}
// senso di rotazione da dir tg a dir esterna
bool bCcwRot = (( ! bInvert && m_Params.m_nWorkSide == MILL_WS_LEFT) ||
( bInvert && m_Params.m_nWorkSide != MILL_WS_LEFT)) ;
// !!! provvisorio : GLIDE, ZIGZAG e HELIX -> NONE !!!
if ( nType == MILL_LI_GLIDE || nType == MILL_LI_ZIGZAG || nType == MILL_LI_HELIX)
// !!! provvisorio : GLIDE -> NONE !!!
if ( nType == MILL_LI_GLIDE)
nType = MILL_LI_NONE ;
// Calcolo punto iniziale
switch ( nType) {
@@ -2367,11 +2435,11 @@ Milling::CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtStart, const
// !!! DA FARE !!!
return false ;
case MILL_LI_ZIGZAG :
// !!! DA FARE !!!
return false ;
ptP1 = ptStart ;
return true ;
case MILL_LI_HELIX :
// !!! DA FARE !!!
return false ;
ptP1 = ptStart ;
return true ;
default :
return false ;
}
@@ -2383,10 +2451,10 @@ Milling::AddLeadIn( const Point3d& ptP1, const Point3d& ptStart, const Vector3d&
const Vector3d& vtN, bool bInvert, bool bSplitArcs)
{
// Assegno il tipo
int nType = m_Params.m_nLeadInType ;
int nType = GetLeadInType() ;
// se step invertito
if ( bInvert) {
switch ( m_Params.m_nLeadOutType) {
switch ( GetLeadOutType()) {
case MILL_LO_LINEAR : nType = MILL_LI_LINEAR ; break ;
case MILL_LO_TANGENT : nType = MILL_LI_TANGENT ; break ;
case MILL_LO_GLIDE : nType = MILL_LI_GLIDE ; break ;
@@ -2394,18 +2462,8 @@ Milling::AddLeadIn( const Point3d& ptP1, const Point3d& ptStart, const Vector3d&
default : nType = MILL_LI_NONE ; break ;
}
}
// se archi da spezzare
if ( bSplitArcs) {
if ( nType == MILL_LI_TANGENT)
nType = MILL_LI_LINEAR ;
if ( nType == MILL_LI_HELIX)
nType = MILL_LI_ZIGZAG ;
}
// se parametri tg e perp entrambi nulli, allora nessun attacco
if ( (( ptStart - ptP1) ^ vtN).IsSmall())
nType = MILL_LI_NONE ;
// !!! provvisorio : GLIDE, ZIGZAG e HELIX -> NONE !!!
if ( nType == MILL_LI_GLIDE || nType == MILL_LI_ZIGZAG || nType == MILL_LI_HELIX)
// !!! provvisorio : GLIDE -> NONE !!!
if ( nType == MILL_LI_GLIDE)
nType = MILL_LI_NONE ;
// Eseguo a seconda del tipo
switch ( nType) {
@@ -2419,82 +2477,81 @@ Milling::AddLeadIn( const Point3d& ptP1, const Point3d& ptStart, const Vector3d&
if ( IsNull( pCrv))
return false ;
pCrv->Invert() ;
if ( pCrv->GetType() == CRV_LINE) {
ICurveLine* pLine = GetCurveLine( pCrv) ;
Point3d ptP3 = pLine->GetEnd() ;
return ( AddLinearMove( ptP3, MCH_CL_LEADIN) != GDB_ID_NULL) ;
}
else if ( pCrv->GetType() == CRV_ARC) {
ICurveArc* pArc = GetCurveArc( pCrv) ;
Point3d ptCen = pArc->GetCenter() ;
double dAngCen = pArc->GetAngCenter() ;
Vector3d vtN = pArc->GetNormVersor() ;
Point3d ptP3 ;
pArc->GetEndPoint( ptP3) ;
// se angolo al centro minore del limite, un solo arco
const double MAX_ANG_CEN = 150 + EPS_ANG_SMALL ;
if ( abs( dAngCen) < MAX_ANG_CEN) {
if ( AddArcMove( ptP3, ptCen, dAngCen, vtN, MCH_CL_LEADIN) == GDB_ID_NULL)
return false ;
}
// altrimenti due archi
else if ( abs( dAngCen) < 2 * MAX_ANG_CEN){
Point3d ptMid ;
pArc->GetMidPoint( ptMid) ;
// prima metà arco
if ( AddArcMove( ptMid, ptCen, dAngCen / 2, vtN, MCH_CL_LEADIN) == GDB_ID_NULL)
return false ;
// seconda metà arco
if ( AddArcMove( ptP3, ptCen, dAngCen / 2, vtN, MCH_CL_LEADIN) == GDB_ID_NULL)
return false ;
}
// oppure tre archi
else {
Point3d ptTmp ;
// primo terzo
pArc->GetPointD1D2( 1. / 3, ICurve::FROM_MINUS, ptTmp) ;
if ( AddArcMove( ptTmp, ptCen, dAngCen / 3, vtN, MCH_CL_LEADIN) == GDB_ID_NULL)
return false ;
// secondo terzo
ptCen.z = ptTmp.z ;
pArc->GetPointD1D2( 2. / 3, ICurve::FROM_MINUS, ptTmp) ;
if ( AddArcMove( ptTmp, ptCen, dAngCen / 3, vtN, MCH_CL_LEADIN) == GDB_ID_NULL)
return false ;
// ultimo terzo
ptCen.z = ptTmp.z ;
if ( AddArcMove( ptP3, ptCen, dAngCen / 3, vtN, MCH_CL_LEADIN) == GDB_ID_NULL)
return false ;
}
return true ;
}
return ( AddCurveMove( pCrv, MCH_CL_LEADIN) != GDB_ID_NULL) ;
}
case MILL_LI_GLIDE :
// !!! DA FARE !!!
return false ;
case MILL_LI_ZIGZAG :
// !!! DA FARE !!!
return false ;
{
double dDeltaN = ( ptStart - ptP1) * vtN ;
int nStep = int( ceil( - dDeltaN / ( m_Params.m_dLiElev + 10 * EPS_SMALL))) ;
double dStep = - dDeltaN / nStep ;
Point3d ptPa = ptP1 + vtStart * 0.5 * min( m_Params.m_dLiTang, m_TParams.m_dDiam) ;
Point3d ptPb = ptP1 - vtStart * 0.5 * min( m_Params.m_dLiTang, m_TParams.m_dDiam) ;
for ( int i = 1 ; i <= nStep ; ++ i) {
if ( AddLinearMove( ptPa - vtN * ( i - 0.75) * dStep, MCH_CL_LEADIN) == GDB_ID_NULL)
return false ;
if ( AddLinearMove( ptPb - vtN * ( i - 0.25) * dStep, MCH_CL_LEADIN) == GDB_ID_NULL)
return false ;
}
return ( AddLinearMove( ptStart, MCH_CL_LEADIN) != GDB_ID_NULL) ;
}
case MILL_LI_HELIX :
// !!! DA FARE !!!
return false ;
{
bool bAtLeft = ( m_Params.m_nWorkSide != MILL_WS_RIGHT) ;
// vettore dal punto al centro elica
Vector3d vtCen = vtStart ;
vtCen.Rotate( vtN, ( bAtLeft ? ANG_RIGHT : - ANG_RIGHT)) ;
// dati dell'elica
double dRad = 0.5 * min( m_Params.m_dLiTang, m_TParams.m_dDiam) ;
Point3d ptCen = ptP1 + vtCen * dRad ;
double dDeltaN = ( ptStart - ptP1) * vtN ;
double dAngCen = ceil( - dDeltaN / ( m_Params.m_dLiElev + 10 * EPS_SMALL)) * ( bAtLeft ? ANG_FULL : - ANG_FULL) ;
// creo l'elica
PtrOwner<ICurveArc> pArc( CreateCurveArc()) ;
if ( IsNull( pArc) || ! pArc->Set( ptCen, vtN, dRad, - vtCen, dAngCen, dDeltaN))
return false ;
// eventuale spezzatura
if ( bSplitArcs) {
PtrOwner<ICurveComposite> pCompo( CreateCurveComposite()) ;
if ( IsNull( pCompo) || ! pCompo->AddCurve( Release( pArc)) || ! ApproxWithLines( pCompo))
return false ;
return ( AddCurveMove( pCompo, MCH_CL_LEADIN) != GDB_ID_NULL) ;
}
else {
// emetto l'elica
return ( AddCurveMove( pArc, MCH_CL_LEADIN) != GDB_ID_NULL) ;
}
}
default :
return false ;
}
}
//----------------------------------------------------------------------------
int
Milling::GetLeadOutType( void) const
{
if ( abs( m_Params.m_dLoTang) < min( 0.1 * m_TParams.m_dDiam, 0.1) &&
abs( m_Params.m_dLoPerp) < min( 0.1 * m_TParams.m_dDiam, 0.1))
return MILL_LO_NONE ;
return m_Params.m_nLeadOutType ;
}
//----------------------------------------------------------------------------
bool
Milling::AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d& vtN,
bool bInvert, bool bSplitArcs, Point3d& ptP1)
double dEndElev, bool bInvert, bool bSplitArcs, Point3d& ptP1)
{
// assegno i parametri
int nType = m_Params.m_nLeadOutType ;
int nType = GetLeadOutType() ;
double dTang = m_Params.m_dLoTang ;
double dPerp = m_Params.m_dLoPerp ;
double dElev = m_Params.m_dLoElev ;
double dElev = min( m_Params.m_dLoElev, dEndElev + LIO_ELEV_TOL) ;
// se uscita come ingresso o step invertito
if ( nType == MILL_LO_AS_LI || bInvert) {
switch ( m_Params.m_nLeadInType) {
switch ( GetLeadInType()) {
case MILL_LI_LINEAR : nType = MILL_LO_LINEAR ; break ;
case MILL_LI_TANGENT : nType = MILL_LO_TANGENT ; break ;
case MILL_LI_GLIDE : nType = MILL_LO_GLIDE ; break ;
@@ -2504,15 +2561,8 @@ Milling::AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d
}
dTang = m_Params.m_dLiTang ;
dPerp = m_Params.m_dLiPerp ;
dElev = m_Params.m_dLiElev ;
dElev = min( m_Params.m_dLiElev, dEndElev + LIO_ELEV_TOL) ;
}
if ( bSplitArcs) {
if ( nType == MILL_LO_TANGENT)
nType = MILL_LO_LINEAR ;
}
// se parametri nulli, allora nessuna uscita
if ( abs( dTang) < EPS_SMALL && abs( dPerp) < EPS_SMALL )
nType = MILL_LO_NONE ;
// senso di rotazione da dir tg a dir esterna
bool bCcwRot = (( ! bInvert && m_Params.m_nWorkSide == MILL_WS_LEFT) ||
( bInvert && m_Params.m_nWorkSide != MILL_WS_LEFT)) ;
@@ -2526,8 +2576,6 @@ Milling::AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d
return true ;
case MILL_LO_LINEAR :
{
if ( dTang < 10 * EPS_SMALL && abs( dPerp) < EPS_SMALL)
return false ;
Vector3d vtPerp = vtEnd ;
vtPerp.Rotate( vtN, ( bCcwRot ? 90 : - 90)) ;
ptP1 = ptEnd + vtEnd * dTang + vtPerp * dPerp + vtN * dElev ;
@@ -2536,8 +2584,6 @@ Milling::AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d
case MILL_LO_TANGENT :
{
// calcolo punto finale dell'uscita
if ( dTang < 10 * EPS_SMALL && abs( dPerp) < EPS_SMALL)
return false ;
Vector3d vtPerp = vtEnd ;
vtPerp.Rotate( vtN, ( bCcwRot ? 90 : - 90)) ;
ptP1 = ptEnd + vtEnd * dTang + vtPerp * dPerp + vtN * dElev ;
@@ -2545,55 +2591,7 @@ Milling::AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d
PtrOwner<ICurve> pCrv( GetArc2PVN( ptEnd, ptP1, vtEnd, vtN)) ;
if ( IsNull( pCrv))
return false ;
if ( pCrv->GetType() == CRV_LINE) {
ICurveLine* pLine = GetCurveLine( pCrv) ;
Point3d ptP3 = pLine->GetEnd() ;
return ( AddLinearMove( ptP3, MCH_CL_LEADOUT) != GDB_ID_NULL) ;
}
else if ( pCrv->GetType() == CRV_ARC) {
ICurveArc* pArc = GetCurveArc( pCrv) ;
Point3d ptCen = pArc->GetCenter() ;
double dAngCen = pArc->GetAngCenter() ;
Vector3d vtN = pArc->GetNormVersor() ;
Point3d ptP3 ;
pArc->GetEndPoint( ptP3) ;
// se angolo al centro minore del limite, un solo arco
const double MAX_ANG_CEN = 150 + EPS_ANG_SMALL ;
if ( abs( dAngCen) < MAX_ANG_CEN) {
if ( AddArcMove( ptP3, ptCen, dAngCen, vtN, MCH_CL_LEADOUT) == GDB_ID_NULL)
return false ;
}
// altrimenti due archi
else if ( abs( dAngCen) < 2 * MAX_ANG_CEN){
Point3d ptMid ;
pArc->GetMidPoint( ptMid) ;
// prima metà arco
if ( AddArcMove( ptMid, ptCen, dAngCen / 2, vtN, MCH_CL_LEADOUT) == GDB_ID_NULL)
return false ;
// seconda metà arco
ptCen.z = ptMid.z ;
if ( AddArcMove( ptP3, ptCen, dAngCen / 2, vtN, MCH_CL_LEADOUT) == GDB_ID_NULL)
return false ;
}
// oppure tre archi
else {
Point3d ptTmp ;
// primo terzo
pArc->GetPointD1D2( 1. / 3, ICurve::FROM_MINUS, ptTmp) ;
if ( AddArcMove( ptTmp, ptCen, dAngCen / 3, vtN, MCH_CL_LEADOUT) == GDB_ID_NULL)
return false ;
// secondo terzo
ptCen.z = ptTmp.z ;
pArc->GetPointD1D2( 2. / 3, ICurve::FROM_MINUS, ptTmp) ;
if ( AddArcMove( ptTmp, ptCen, dAngCen / 3, vtN, MCH_CL_LEADOUT) == GDB_ID_NULL)
return false ;
// ultimo terzo
ptCen.z = ptTmp.z ;
if ( AddArcMove( ptP3, ptCen, dAngCen / 3, vtN, MCH_CL_LEADOUT) == GDB_ID_NULL)
return false ;
}
return true ;
}
return ( AddCurveMove( pCrv, MCH_CL_LEADOUT) != GDB_ID_NULL) ;
}
case MILL_LO_GLIDE :
// !!! DA FARE !!!