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

EgtMachKernel :

Browse Source 
- aggiunta gestione tabs a standard milling.
This commit is contained in:
Dario Sassi
2020-06-02 23:13:29 +00:00
parent 910a5fcb2c
commit 083082aab3
2 changed files with 369 additions and 19 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Milling.cpp
+361 -15
View File
@@ -1,13 +1,14 @@
//----------------------------------------------------------------------------
// EgalTech 2015-2016
// EgalTech 2015-2020
//----------------------------------------------------------------------------
// File : Milling.cpp Data : 11.08.16 Versione : 1.6t2
// File : Milling.cpp Data : 02.06.20 Versione : 2.2f1
// Contenuto : Implementazione gestione fresature.
//
//
//
// Modifiche : 07.06.15 DS Creazione modulo.
// 11.08.16 DS Miglioria gestione PV per più loop.
// 02.06.20 DS Aggiunta gestione Tabs.
//
//----------------------------------------------------------------------------
@@ -30,6 +31,7 @@
#include "/EgtDev/Include/EGkExtText.h"
#include "/EgtDev/Include/EGkUserObjFactory.h"
#include "/EgtDev/Include/EGnStringKeyVal.h"
#include "/EgtDev/Include/EgtNumUtils.h"
#include "/EgtDev/Include/EgtPointerOwner.h"
using namespace std ;
@@ -107,6 +109,7 @@ Milling::Clone( void) const
pMill->m_bAboveHead = m_bAboveHead ;
pMill->m_bAggrBottom = m_bAggrBottom ;
pMill->m_dCurrOscillLen = m_dCurrOscillLen ;
pMill->m_dCurrTabsLen = m_dCurrTabsLen ;
}
catch( ...) {
delete pMill ;
@@ -229,6 +232,7 @@ Milling::Milling( void)
m_bAboveHead = true ;
m_bAggrBottom = false ;
m_dCurrOscillLen = 0 ;
m_dCurrTabsLen = 0 ;
}
//----------------------------------------------------------------------------
@@ -1553,11 +1557,16 @@ Milling::ProcessPath( int nPathId, int nPvId, int nClId)
if ( ! pCompo->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL, false))
return false ;
// flag di oscillazione del percorso corrente
bool bPathOscEnable = m_Params.m_bOscEnable ;
// flags per tabs e oscillazione del percorso corrente (se entrambi, solo tabs)
bool bPathTabsEnable = m_Params.m_bLeaveTab ;
bool bPathOscEnable = ( ! bPathTabsEnable && m_Params.m_bOscEnable) ;
// se utensile lama, disabilito eventuale oscillazione
// se utensile lama, disabilito eventuali tbas o oscillazione
if ( ( m_TParams.m_nType & TF_SAWBLADE) != 0) {
if ( bPathTabsEnable) {
bPathTabsEnable = false ;
m_pMchMgr->SetWarning( 2359, "Warning in Milling : tabs incompatible with saw blade") ;
}
if ( bPathOscEnable) {
bPathOscEnable = false ;
m_pMchMgr->SetWarning( 2359, "Warning in Milling : oscillation incompatible with saw blade") ;
@@ -1778,19 +1787,19 @@ Milling::ProcessPath( int nPathId, int nPvId, int nClId)
// se altrimenti una sola passata
else if ( dOkStep < EPS_SMALL || dOkStep > dElev) {
m_bStepOn = false ;
if ( ! AddStandardMilling( pCompo, vtTool, dDepth, dElev, bSplitArcs, bPathOscEnable))
if ( ! AddStandardMilling( pCompo, vtTool, dDepth, dElev, bSplitArcs, bPathTabsEnable, bPathOscEnable))
return false ;
}
// se altrimenti passate a zig-zag
else if ( m_Params.m_nStepType == MILL_ST_ZIGZAG) {
m_bStepOn = true ;
if ( ! AddZigZagMilling( pCompo, vtTool, dDepth, dElev, dOkStep, bSplitArcs, bPathOscEnable))
if ( ! AddZigZagMilling( pCompo, vtTool, dDepth, dElev, dOkStep, bSplitArcs, bPathTabsEnable, bPathOscEnable))
return false ;
}
// se altrimenti passate a one-way
else if ( m_Params.m_nStepType == MILL_ST_ONEWAY) {
m_bStepOn = true ;
if ( ! AddOneWayMilling( pCompo, vtTool, dDepth, dElev, dOkStep, bSplitArcs, bPathOscEnable))
if ( ! AddOneWayMilling( pCompo, vtTool, dDepth, dElev, dOkStep, bSplitArcs, bPathTabsEnable, bPathOscEnable))
return false ;
}
// se altrimenti passate a spirale
@@ -1803,7 +1812,7 @@ Milling::ProcessPath( int nPathId, int nPvId, int nClId)
pCompo->Invert() ;
m_dAddedOverlap = 0 ;
}
if ( ! AddSpiralMilling( pCompo, vtTool, dDepth, dElev, dOkStep, bSplitArcs, bPathOscEnable))
if ( ! AddSpiralMilling( pCompo, vtTool, dDepth, dElev, dOkStep, bSplitArcs, bPathTabsEnable, bPathOscEnable))
return false ;
}
@@ -2046,7 +2055,7 @@ Milling::GenerateMillingPv( int nPathId, const ICurveComposite* pCompo)
//----------------------------------------------------------------------------
bool
Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTool,
double dDepth, double dElev, bool bSplitArcs, bool bPathOscEnable)
double dDepth, double dElev, bool bSplitArcs, bool bPathTabsEnable, bool bPathOscEnable)
{
// recupero distanze di sicurezza
double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ;
@@ -2054,12 +2063,17 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
// lunghezza di approccio/retrazione
double dAppr = m_Params.m_dStartPos ;
// in caso di tabs ne aggiusto i parametri secondo il percorso
double dTabsRampLen, dTabsBottomLen, dTabsTopLen ;
AdjustTabsParams( pCompo, bPathTabsEnable, dTabsRampLen, dTabsBottomLen, dTabsTopLen) ;
// in caso di oscillazione ne aggiusto i parametri secondo il percorso
double dOscRampLen, dOscFlatLen ;
AdjustOscillParams( pCompo, bPathOscEnable, dOscRampLen, dOscFlatLen) ;
// ciclo sulle curve elementari
bool bClosed = pCompo->IsClosed() ;
m_dCurrTabsLen = dTabsRampLen + 0.5 * dTabsBottomLen ;
m_dCurrOscillLen = 2 * dOscRampLen + 1.5 * dOscFlatLen ;
int nMaxInd = pCompo->GetCurveCount() - 1 ;
for ( int i = 0 ; i <= nMaxInd ; ++ i) {
@@ -2137,7 +2151,11 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
if ( pCurve->GetType() == CRV_LINE) {
ICurveLine* pLine = GetCurveLine( pCurve) ;
SetFeed( GetFeed()) ;
if ( bPathOscEnable) {
if ( bPathTabsEnable) {
if ( ! AddTabsLine( pLine, vtTool, dTabsRampLen, dTabsBottomLen, dTabsTopLen))
return false ;
}
else if ( bPathOscEnable) {
if ( ! AddOscillLine( pLine, vtTool, dOscRampLen, dOscFlatLen))
return false ;
}
@@ -2150,7 +2168,11 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
else if ( pCurve->GetType() == CRV_ARC) {
ICurveArc* pArc = GetCurveArc( pCurve) ;
SetFeed( GetFeed()) ;
if ( bPathOscEnable) {
if ( bPathTabsEnable) {
if ( ! AddTabsArc( pArc, vtTool, dTabsRampLen, dTabsBottomLen, dTabsTopLen))
return false ;
}
else if ( bPathOscEnable) {
if ( ! AddOscillArc( pArc, vtTool, dOscRampLen, dOscFlatLen))
return false ;
}
@@ -2207,7 +2229,7 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
//----------------------------------------------------------------------------
bool
Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool,
double dDepth, double dElev, double dOkStep, bool bSplitArcs, bool bPathOscEnable)
double dDepth, double dElev, double dOkStep, bool bSplitArcs, bool bPathTabsEnable, bool bPathOscEnable)
{
// recupero distanze di sicurezza
double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ;
@@ -2411,7 +2433,7 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
//----------------------------------------------------------------------------
bool
Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool,
double dDepth, double dElev, double dOkStep, bool bSplitArcs, bool bPathOscEnable)
double dDepth, double dElev, double dOkStep, bool bSplitArcs, bool bPathTabsEnable, bool bPathOscEnable)
{
// recupero distanze di sicurezza
double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ;
@@ -2625,7 +2647,7 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
//----------------------------------------------------------------------------
bool
Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool,
double dDepth, double dElev, double dOkStep, bool bSplitArcs, bool bPathOscEnable)
double dDepth, double dElev, double dOkStep, bool bSplitArcs, bool bPathTabsEnable, bool bPathOscEnable)
{
// recupero distanze di sicurezza
double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ;
@@ -4096,6 +4118,330 @@ Milling::AddOscillArc( const ICurveArc* pArc, const Vector3d& vtTool, double dRa
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::AdjustTabsParams( const ICurve* pCrv, bool& bPathTabsEnable, double& dTabsRampLen, double& dTabsBottomLen, double& dTabsTopLen)
{
// se c'è oscillazione cerco di aggiustare le lunghezze dei Bottom per finire con la stessa quota di partenza
double dTabAngle = Clamp( abs( m_Params.m_dTabAngle), 15., 75.) ;
dTabsRampLen = min( abs( m_Params.m_dTabHeight) / tan( dTabAngle * DEGTORAD), abs( m_Params.m_dTabLen) / 2 - OSC_MIN_LEN) ;
dTabsTopLen = abs( m_Params.m_dTabLen) - 2 * dTabsRampLen ;
dTabsBottomLen = abs( m_Params.m_dTabDist) - abs( m_Params.m_dTabLen) ;
if ( bPathTabsEnable) {
// lunghezza del percorso
double dLen ; pCrv->GetLength( dLen) ; dLen -= m_dAddedOverlap ;
// se percorso più corto di due tabs, disabilito
if ( dLen < 2 * dTabsRampLen + 2 * dTabsTopLen)
bPathTabsEnable = false ;
else {
int nTabs = max( static_cast<int>( dLen / ( 2 * dTabsRampLen + dTabsTopLen + dTabsBottomLen)), 1) ;
dTabsBottomLen = ( dLen - nTabs * ( 2 * dTabsRampLen + dTabsTopLen)) / nTabs ;
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::AddTabsLine( const ICurveLine* pLine, const Vector3d& vtTool, double dTabsRampLen, double dTabsBottomLen, double dTabsTopLen)
{
// lunghezze dei tratti di oscillazione
dTabsRampLen = max( dTabsRampLen, OSC_MIN_LEN) ;
dTabsBottomLen = max( dTabsBottomLen, OSC_MIN_LEN) ;
dTabsTopLen = max( dTabsTopLen, OSC_MIN_LEN) ;
double vLenRef[4] = { dTabsRampLen,
dTabsRampLen + dTabsBottomLen,
dTabsRampLen + dTabsBottomLen + dTabsRampLen,
dTabsRampLen + dTabsBottomLen + dTabsRampLen + dTabsTopLen} ;
// lunghezza della linea
double dLen ; pLine->GetLength( dLen) ;
// lunghezza corrente sulla linea
double dCurrLen = 0 ;
// emissione oscillazioni
while ( dCurrLen < dLen - EPS_ZERO) {
// lunghezza rimanente
double dNextLen = dLen - dCurrLen ;
// se inizio è sul primo tratto (rampa discendente)
if ( m_dCurrTabsLen < vLenRef[0] - 10 * EPS_SMALL) {
// se fine linea è entro il tratto
if ( m_dCurrTabsLen + dNextLen < vLenRef[0] - 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrTabsLen += dNextLen ;
Point3d ptP3 = pLine->GetEnd() ;
ptP3 += vtTool * ( abs( m_Params.m_dTabHeight) * ( vLenRef[0] - m_dCurrTabsLen) / ( vLenRef[0] - 0)) ;
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
}
// se fine linea è alla fine del tratto
else if ( m_dCurrTabsLen + dNextLen < vLenRef[0] + 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrTabsLen = vLenRef[0] ;
Point3d ptP3 = pLine->GetEnd() ;
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
}
// altrimenti fine linea è oltre
else {
dCurrLen += vLenRef[0] - m_dCurrTabsLen ;
m_dCurrTabsLen = vLenRef[0] ;
double dU ; pLine->GetParamAtLength( dCurrLen, dU) ;
Point3d ptP3 ; pLine->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ;
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
}
}
// se inizio è sul secondo tratto (parte piatta in basso)
else if ( m_dCurrTabsLen < vLenRef[1] - 10 * EPS_SMALL) {
// se fine linea è entro il tratto
if ( m_dCurrTabsLen + dNextLen < vLenRef[1] - 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrTabsLen += dNextLen ;
Point3d ptP3 = pLine->GetEnd() ;
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
}
// se fine linea è alla fine del tratto
else if ( m_dCurrTabsLen + dNextLen < vLenRef[1] + 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrTabsLen = vLenRef[1] ;
Point3d ptP3 = pLine->GetEnd() ;
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
}
// altrimenti fine linea è oltre
else {
dCurrLen += vLenRef[1] - m_dCurrTabsLen ;
m_dCurrTabsLen = vLenRef[1] ;
double dU ; pLine->GetParamAtLength( dCurrLen, dU) ;
Point3d ptP3 ; pLine->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ;
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
}
}
// se inizio è sul terzo tratto (rampa ascendente)
else if ( m_dCurrTabsLen < vLenRef[2] - 10 * EPS_SMALL) {
// se fine linea è entro il tratto
if ( m_dCurrTabsLen + dNextLen < vLenRef[2] - 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrTabsLen += dNextLen ;
Point3d ptP3 = pLine->GetEnd() ;
ptP3 += vtTool * ( abs( m_Params.m_dTabHeight) * ( m_dCurrTabsLen - vLenRef[1]) / ( vLenRef[2] - vLenRef[1])) ;
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
}
// se fine linea è alla fine del tratto
else if ( m_dCurrTabsLen + dNextLen < vLenRef[2] + 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrTabsLen = vLenRef[2] ;
Point3d ptP3 = pLine->GetEnd() ;
ptP3 += vtTool * abs( m_Params.m_dTabHeight) ;
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
}
// altrimenti fine linea è oltre
else {
dCurrLen += vLenRef[2] - m_dCurrTabsLen ;
m_dCurrTabsLen = vLenRef[2] ;
double dU ; pLine->GetParamAtLength( dCurrLen, dU) ;
Point3d ptP3 ; pLine->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ;
ptP3 += vtTool * abs( m_Params.m_dTabHeight) ;
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
}
}
// altrimenti è sul quarto tratto (parte piatta in alto)
else {
// se fine linea è entro il tratto
if ( m_dCurrTabsLen + dNextLen < vLenRef[3] - 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrTabsLen += dNextLen ;
Point3d ptP3 = pLine->GetEnd() ;
ptP3 += vtTool * abs( m_Params.m_dTabHeight) ;
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
}
// se fine linea è alla fine del tratto
else if ( m_dCurrTabsLen + dNextLen < vLenRef[3] + 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrTabsLen = 0 ;
Point3d ptP3 = pLine->GetEnd() ;
ptP3 += vtTool * abs( m_Params.m_dTabHeight) ;
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
}
// altrimenti fine linea è oltre
else {
dCurrLen += vLenRef[3] - m_dCurrTabsLen ;
m_dCurrTabsLen = 0 ;
double dU ; pLine->GetParamAtLength( dCurrLen, dU) ;
Point3d ptP3 ; pLine->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ;
ptP3 += vtTool * abs( m_Params.m_dTabHeight) ;
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
}
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::AddTabsArc( const ICurveArc* pArc, const Vector3d& vtTool, double dTabsRampLen, double dTabsBottomLen, double dTabsTopLen)
{
// lunghezze dei tratti di oscillazione
dTabsRampLen = max( dTabsRampLen, OSC_MIN_LEN) ;
dTabsBottomLen = max( dTabsBottomLen, OSC_MIN_LEN) ;
dTabsTopLen = max( dTabsTopLen, OSC_MIN_LEN) ;
double vLenRef[4] = { dTabsRampLen,
dTabsRampLen + dTabsBottomLen,
dTabsRampLen + dTabsBottomLen + dTabsRampLen,
dTabsRampLen + dTabsBottomLen + dTabsRampLen + dTabsTopLen} ;
// parametria dell'arco
Point3d ptCen = pArc->GetCenter() ;
double dAngCen = pArc->GetAngCenter() ;
Vector3d vtN = pArc->GetNormVersor() ;
double dLen ; pArc->GetLength( dLen) ;
// lunghezza corrente sull'arco
double dCurrLen = 0 ;
// emissione oscillazioni
while ( dCurrLen < dLen - EPS_ZERO) {
// lunghezza rimanente
double dNextLen = dLen - dCurrLen ;
// se inizio è sul primo tratto (rampa discendente)
if ( m_dCurrTabsLen < vLenRef[0] - 10 * EPS_SMALL) {
// se fine linea è entro il tratto
if ( m_dCurrTabsLen + dNextLen < vLenRef[0] - 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrTabsLen += dNextLen ;
Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
ptP3 += vtTool * ( abs( m_Params.m_dTabHeight) * ( vLenRef[0] - m_dCurrTabsLen) / ( vLenRef[0] - 0)) ;
double dCurrAngCen = dAngCen * dNextLen / dLen ;
if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
return false ;
}
// se fine linea è alla fine del tratto
else if ( m_dCurrTabsLen + dNextLen < vLenRef[0] + 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrTabsLen = vLenRef[0] ;
Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
double dCurrAngCen = dAngCen * dNextLen / dLen ;
if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
return false ;
}
// altrimenti fine linea è oltre
else {
dCurrLen += vLenRef[0] - m_dCurrTabsLen ;
m_dCurrTabsLen = vLenRef[0] ;
double dU ; pArc->GetParamAtLength( dCurrLen, dU) ;
Point3d ptP3 ; pArc->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ;
double dCurrAngCen = dAngCen * ( dNextLen + dCurrLen - dLen) / dLen ;
if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
return false ;
}
}
// se inizio è sul secondo tratto (parte piatta in basso)
else if ( m_dCurrTabsLen < vLenRef[1] - 10 * EPS_SMALL) {
// se fine linea è entro il tratto
if ( m_dCurrTabsLen + dNextLen < vLenRef[1] - 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrTabsLen += dNextLen ;
Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
double dCurrAngCen = dAngCen * dNextLen / dLen ;
if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
return false ;
}
// se fine linea è alla fine del tratto
else if ( m_dCurrTabsLen + dNextLen < vLenRef[1] + 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrTabsLen = vLenRef[1] ;
Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
double dCurrAngCen = dAngCen * dNextLen / dLen ;
if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
return false ;
}
// altrimenti fine linea è oltre
else {
dCurrLen += vLenRef[1] - m_dCurrTabsLen ;
m_dCurrTabsLen = vLenRef[1] ;
double dU ; pArc->GetParamAtLength( dCurrLen, dU) ;
Point3d ptP3 ; pArc->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ;
double dCurrAngCen = dAngCen * ( dNextLen + dCurrLen - dLen) / dLen ;
if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
return false ;
}
}
// se inizio è sul terzo tratto (rampa ascendente)
else if ( m_dCurrTabsLen < vLenRef[2] - 10 * EPS_SMALL) {
// se fine linea è entro il tratto
if ( m_dCurrTabsLen + dNextLen < vLenRef[2] - 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrTabsLen += dNextLen ;
Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
ptP3 += vtTool * ( abs( m_Params.m_dTabHeight) * ( m_dCurrTabsLen - vLenRef[1]) / ( vLenRef[2] - vLenRef[1])) ;
double dCurrAngCen = dAngCen * dNextLen / dLen ;
if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
return false ;
}
// se fine linea è alla fine del tratto
else if ( m_dCurrTabsLen + dNextLen < vLenRef[2] + 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrTabsLen = vLenRef[2] ;
Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
ptP3 += vtTool * abs( m_Params.m_dTabHeight) ;
double dCurrAngCen = dAngCen * dNextLen / dLen ;
if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
return false ;
}
// altrimenti fine linea è oltre
else {
dCurrLen += vLenRef[2] - m_dCurrTabsLen ;
m_dCurrTabsLen = vLenRef[2] ;
double dU ; pArc->GetParamAtLength( dCurrLen, dU) ;
Point3d ptP3 ; pArc->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ;
ptP3 += vtTool * abs( m_Params.m_dTabHeight) ;
double dCurrAngCen = dAngCen * ( dNextLen + dCurrLen - dLen) / dLen ;
if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
return false ;
}
}
// altrimenti è sul quarto tratto (parte piatta in alto)
else {
// se fine linea è entro il tratto
if ( m_dCurrTabsLen + dNextLen < vLenRef[3] - 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrTabsLen += dNextLen ;
Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
ptP3 += vtTool * abs( m_Params.m_dTabHeight) ;
double dCurrAngCen = dAngCen * dNextLen / dLen ;
if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
return false ;
}
// se fine linea è alla fine del tratto
else if ( m_dCurrTabsLen + dNextLen < vLenRef[3] + 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrTabsLen = 0 ;
Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
ptP3 += vtTool * abs( m_Params.m_dTabHeight) ;
double dCurrAngCen = dAngCen * dNextLen / dLen ;
if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
return false ;
}
// altrimenti fine linea è oltre
else {
dCurrLen += vLenRef[3] - m_dCurrTabsLen ;
m_dCurrTabsLen = 0 ;
double dU ; pArc->GetParamAtLength( dCurrLen, dU) ;
Point3d ptP3 ; pArc->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ;
ptP3 += vtTool * abs( m_Params.m_dTabHeight) ;
double dCurrAngCen = dAngCen * ( dNextLen + dCurrLen - dLen) / dLen ;
if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
return false ;
}
}
}
return true ;
}
//----------------------------------------------------------------------------
double
Milling::GetRadiusForStartEndElevation( void) const
Milling.h
+8 -4
View File
@@ -79,13 +79,13 @@ class Milling : public Machining
bool VerifyPathFromBottom( const ICurveComposite* pCompo, const Vector3d& vtTool) ;
bool GenerateMillingPv( int nPathId, const ICurveComposite* pCompo) ;
bool AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTool,
double dDepth, double dElev, bool bSplitArcs, bool bPathOscEnable) ;
double dDepth, double dElev, bool bSplitArcs, bool bPathTabsEnable, bool bPathOscEnable) ;
bool AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool,
double dDepth, double dElev, double dOkStep, bool bSplitArcs, bool bPathOscEnable) ;
double dDepth, double dElev, double dOkStep, bool bSplitArcs, bool bPathTabsEnable, bool bPathOscEnable) ;
bool AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool,
double dDepth, double dElev, double dOkStep, bool bSplitArcs, bool bPathOscEnable) ;
double dDepth, double dElev, double dOkStep, bool bSplitArcs, bool bPathTabsEnable, bool bPathOscEnable) ;
bool AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool,
double dDepth, double dElev, double dOkStep, bool bSplitArcs, bool bPathOscEnable) ;
double dDepth, double dElev, double dOkStep, bool bSplitArcs, bool bPathTabsEnable, bool bPathOscEnable) ;
bool AddSawZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool,
double dDepth, double dElev, double dOkStep, bool bSplitArcs) ;
bool AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ,
@@ -102,6 +102,9 @@ class Milling : public Machining
bool AdjustOscillParams( const ICurve* pCrv, bool& bPathOscEnable, double& dRampLen, double& dFlatLen) ;
bool AddOscillLine( const ICurveLine* pLine, const Vector3d& vtTool, double dRampLen, double dFlatLen) ;
bool AddOscillArc( const ICurveArc* pArc, const Vector3d& vtTool, double dRampLen, double dFlatLen) ;
bool AdjustTabsParams( const ICurve* pCrv, bool& bPathTabsEnable, double& dTabsRampLen, double& dTabsBottomLen, double& dTabsTopLen) ;
bool AddTabsLine( const ICurveLine* pLine, const Vector3d& vtTool, double dTabsRampLen, double dTabsBottomLen, double dTabsTopLen) ;
bool AddTabsArc( const ICurveArc* pArc, const Vector3d& vtTool, double dTabsRampLen, double dTabsBottomLen, double dTabsTopLen) ;
double GetRadiusForStartEndElevation( void) const ;
bool GetPointOutOfRaw( const Point3d& ptP, const Vector3d& vtTool, double dElev) const ;
bool GetPointAboveRaw( const Point3d& ptP, const Vector3d& vtTool) const ;
@@ -148,4 +151,5 @@ class Milling : public Machining
Vector3d m_vtAggrBottom ; // vettore direzione ausiliaria aggregato da sotto
AggrBottom m_AggrBottom ; // dati eventuale aggregato da sotto
double m_dCurrOscillLen ; // lunghezza corrente lungo il percorso per l'oscillazione
double m_dCurrTabsLen ; // lunghezza corrente lungo il percorso per tabs
} ;