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

EgtMachKernel 2.2f5 :

Browse Source 
- prime modifiche a Tabs di fresature per renderli adattativi.
This commit is contained in:
Dario Sassi
2020-06-11 07:05:38 +00:00
parent f64370e2df
commit dda2eeafbe
3 changed files with 135 additions and 71 deletions
Download Patch File Download Diff File Expand all files Collapse all files
EgtMachKernel.rc
BIN
View File
Binary file not shown.
Milling.cpp
+124 -68
View File
@@ -29,6 +29,7 @@
#include "/EgtDev/Include/EGkSfrCreate.h"
#include "/EgtDev/Include/EGkSurfTriMesh.h"
#include "/EgtDev/Include/EGkExtText.h"
#include "/EgtDev/Include/EGkIntervals.h"
#include "/EgtDev/Include/EGkUserObjFactory.h"
#include "/EgtDev/Include/EGnStringKeyVal.h"
#include "/EgtDev/Include/EgtNumUtils.h"
@@ -2120,8 +2121,10 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
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) ;
TabData tdTabs ;
AdjustTabsParams( pCompo, bPathTabsEnable, tdTabs) ;
DBLVECTOR vdTabs ;
CalcTabsPositions( pCompo, bPathTabsEnable, tdTabs, vdTabs) ;
// in caso di oscillazione ne aggiusto i parametri secondo il percorso
double dOscRampLen, dOscFlatLen ;
@@ -2129,7 +2132,7 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
// ciclo sulle curve elementari
bool bClosed = pCompo->IsClosed() ;
m_dCurrTabsLen = dTabsRampLen + 0.5 * dTabsBottomLen ;
m_dCurrTabsLen = 0 ;
m_dCurrOscillLen = 2 * dOscRampLen + 1.5 * dOscFlatLen ;
int nMaxInd = pCompo->GetCurveCount() - 1 ;
for ( int i = 0 ; i <= nMaxInd ; ++ i) {
@@ -2208,7 +2211,7 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
ICurveLine* pLine = GetCurveLine( pCurve) ;
SetFeed( GetFeed()) ;
if ( bPathTabsEnable) {
if ( ! AddTabsLine( pLine, vtTool, dTabsRampLen, dTabsBottomLen, dTabsTopLen))
if ( ! AddTabsLine( pLine, vtTool, vdTabs, tdTabs))
return false ;
}
else if ( bPathOscEnable) {
@@ -2225,7 +2228,7 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
ICurveArc* pArc = GetCurveArc( pCurve) ;
SetFeed( GetFeed()) ;
if ( bPathTabsEnable) {
if ( ! AddTabsArc( pArc, vtTool, dTabsRampLen, dTabsBottomLen, dTabsTopLen))
if ( ! AddTabsArc( pArc, vtTool, vdTabs, tdTabs))
return false ;
}
else if ( bPathOscEnable) {
@@ -4178,66 +4181,111 @@ Milling::AddOscillArc( const ICurveArc* pArc, const Vector3d& vtTool, double dRa
//----------------------------------------------------------------------------
bool
Milling::AdjustTabsParams( const ICurve* pCrv, bool& bPathTabsEnable, double& dTabsRampLen, double& dTabsBottomLen, double& dTabsTopLen)
Milling::AdjustTabsParams( const ICurve* pCrv, bool& bPathTabsEnable, TabData& tdTabs)
{
// se ci sono i tab cerco di aggiustare le lunghezze dei Bottom per finire con la stessa quota di partenza
double dTabLen = m_Params.m_dTabLen + m_TParams.m_dDiam ;
double dTabAngle = Clamp( abs( m_Params.m_dTabAngle), 15., 75.) ;
dTabsRampLen = min( abs( m_Params.m_dTabHeight) / tan( dTabAngle * DEGTORAD), abs( dTabLen) / 2 - OSC_MIN_LEN) ;
dTabsTopLen = abs( dTabLen) - 2 * dTabsRampLen ;
dTabsBottomLen = abs( m_Params.m_dTabDist) - abs( dTabLen) ;
tdTabs.m_dRampLen = min( abs( m_Params.m_dTabHeight) / tan( dTabAngle * DEGTORAD), abs( dTabLen) / 2 - OSC_MIN_LEN) ;
tdTabs.m_dTopLen = abs( dTabLen) - 2 * tdTabs.m_dRampLen ;
tdTabs.m_dBottomLen = abs( m_Params.m_dTabDist) - abs( dTabLen) ;
if ( bPathTabsEnable) {
// lunghezza del percorso
double dLen ; pCrv->GetLength( dLen) ; dLen -= m_dAddedOverlap ;
// se percorso non permette nemmeno un tab disabilito
if ( dLen < ( 2 * dTabsRampLen + 2 * dTabsTopLen)) {
if ( dLen < ( 2 * tdTabs.m_dRampLen + 2 * tdTabs.m_dTopLen)) {
bPathTabsEnable = false ;
m_pMchMgr->SetWarning( 2363, "Warning in Milling : tabs impossible") ;
}
else {
// calcolo numero di tabs e distanza
int nTabs = max( static_cast<int>( dLen / ( 2 * dTabsRampLen + dTabsBottomLen + dTabsTopLen)), 1) ;
int nTabs = max( static_cast<int>( dLen / ( 2 * tdTabs.m_dRampLen + tdTabs.m_dBottomLen + tdTabs.m_dTopLen)), 1) ;
nTabs = min( nTabs, m_Params.m_nTabMax) ;
if ( nTabs < m_Params.m_nTabMin) {
if ( dLen > ( 2 * dTabsRampLen + 2 * dTabsTopLen) * m_Params.m_nTabMin)
if ( dLen > ( 2 * tdTabs.m_dRampLen + 2 * tdTabs.m_dTopLen) * m_Params.m_nTabMin)
nTabs = m_Params.m_nTabMin ;
else
m_pMchMgr->SetWarning( 2364, "Warning in Milling : tabs number less than minimum") ;
}
dTabsBottomLen = ( dLen - nTabs * ( 2 * dTabsRampLen + dTabsTopLen)) / nTabs ;
tdTabs.m_dBottomLen = ( dLen - nTabs * ( 2 * tdTabs.m_dRampLen + tdTabs.m_dTopLen)) / nTabs ;
}
}
// verifico che le lughezze non siano inferiori al minimo
tdTabs.m_dRampLen = max( tdTabs.m_dRampLen, OSC_MIN_LEN) ;
tdTabs.m_dBottomLen = max( tdTabs.m_dBottomLen, OSC_MIN_LEN) ;
tdTabs.m_dTopLen = max( tdTabs.m_dTopLen, OSC_MIN_LEN) ;
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::AddTabsLine( const ICurveLine* pLine, const Vector3d& vtTool, double dTabsRampLen, double dTabsBottomLen, double dTabsTopLen)
Milling::CalcTabsPositions( const ICurveComposite* pCompo, bool bPathTabsEnable, const TabData& tdTabs, DBLVECTOR& vdTabs)
{
// reset posizioni Tabs
vdTabs.clear() ;
// se Tabs non abilitati, esco
if ( ! bPathTabsEnable)
return true ;
// lunghezza del percorso
double dLen ; pCompo->GetLength( dLen) ; dLen -= m_dAddedOverlap ;
// determinazione intervalli validi
Intervals ivTabs ;
// inizializzo intervallo valido
ivTabs.Set( 0, dLen) ;
// elimino parti (test)
if ( dLen > 300) {
ivTabs.Subtract( 0, 100) ;
ivTabs.Subtract( dLen - 100, dLen) ;
}
else {
ivTabs.Subtract( 0.4 * dLen, 0.6 * dLen) ;
}
// determino posizioni di inizio dei Tabs
double dNextTab = 0.5 * tdTabs.m_dBottomLen ;
double dCurrLen = 0 ;
while ( dCurrLen + dNextTab < dLen) {
vdTabs.emplace_back( dCurrLen + dNextTab) ;
dCurrLen += dNextTab + tdTabs.m_dRampLen + tdTabs.m_dTopLen + tdTabs.m_dRampLen ;
dNextTab = tdTabs.m_dBottomLen ;
}
if ( ! vdTabs.empty())
vdTabs.emplace_back( dLen + m_dAddedOverlap + 100.) ;
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::AddTabsLine( const ICurveLine* pLine, const Vector3d& vtTool, const DBLVECTOR& vdTabs, const TabData& tdTabs)
{
// 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} ;
double vLen[4] = { 0,
tdTabs.m_dRampLen,
tdTabs.m_dRampLen + tdTabs.m_dTopLen,
tdTabs.m_dRampLen + tdTabs.m_dTopLen + tdTabs.m_dRampLen} ;
// lunghezza della linea
double dLen ; pLine->GetLength( dLen) ;
// lunghezza corrente sulla linea
double dCurrLen = 0 ;
// indice corrente di posizione
int nI = 0 ;
// emissione oscillazioni
while ( dCurrLen < dLen - EPS_ZERO) {
while ( dCurrLen < dLen - EPS_ZERO && nI < int( vdTabs.size())) {
// lunghezze di riferimento dei tratti di oscillazione
double vLenRef[4] = { vdTabs[nI] + vLen[0], vdTabs[nI] + vLen[1], vdTabs[nI] + vLen[2], vdTabs[nI] + vLen[3]} ;
// lunghezza rimanente
double dNextLen = dLen - dCurrLen ;
// se inizio è sul primo tratto (rampa discendente)
// se inizio è sul primo tratto (parte piatta in basso)
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 ;
}
@@ -4259,13 +4307,14 @@ Milling::AddTabsLine( const ICurveLine* pLine, const Vector3d& vtTool, double dT
return false ;
}
}
// se inizio è sul secondo tratto (parte piatta in basso)
// se inizio è sul secondo tratto (rampa ascendente)
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() ;
ptP3 += vtTool * ( abs( m_Params.m_dTabHeight) * ( m_dCurrTabsLen - vLenRef[0]) / ( vLenRef[1] - vLenRef[0])) ;
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
}
@@ -4274,6 +4323,7 @@ Milling::AddTabsLine( const ICurveLine* pLine, const Vector3d& vtTool, double dT
dCurrLen = dLen ;
m_dCurrTabsLen = vLenRef[1] ;
Point3d ptP3 = pLine->GetEnd() ;
ptP3 += vtTool * abs( m_Params.m_dTabHeight) ;
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
}
@@ -4283,18 +4333,19 @@ Milling::AddTabsLine( const ICurveLine* pLine, const Vector3d& vtTool, double dT
m_dCurrTabsLen = vLenRef[1] ;
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 ;
}
}
// se inizio è sul terzo tratto (rampa ascendente)
// se inizio è sul terzo tratto (parte piatta in alto)
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])) ;
ptP3 += vtTool * abs( m_Params.m_dTabHeight) ;
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
}
@@ -4318,77 +4369,78 @@ Milling::AddTabsLine( const ICurveLine* pLine, const Vector3d& vtTool, double dT
return false ;
}
}
// altrimenti è sul quarto tratto (parte piatta in alto)
else {
// altrimenti è sul quarto tratto (rampa discendente)
else if ( m_dCurrTabsLen < vLenRef[3] - 10 * EPS_SMALL) {
// 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) ;
ptP3 += vtTool * ( abs( m_Params.m_dTabHeight) * ( vLenRef[3] - m_dCurrTabsLen) / ( vLenRef[3] - vLenRef[2])) ;
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 ;
m_dCurrTabsLen = vLenRef[3] ;
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 ;
m_dCurrTabsLen = vLenRef[3] ;
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 passo all'intervallo successivo
else
++ nI ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::AddTabsArc( const ICurveArc* pArc, const Vector3d& vtTool, double dTabsRampLen, double dTabsBottomLen, double dTabsTopLen)
Milling::AddTabsArc( const ICurveArc* pArc, const Vector3d& vtTool, const DBLVECTOR& vdTabs, const TabData& tdTabs)
{
// 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
double vLen[4] = { 0,
tdTabs.m_dRampLen,
tdTabs.m_dRampLen + tdTabs.m_dTopLen,
tdTabs.m_dRampLen + tdTabs.m_dTopLen + tdTabs.m_dRampLen} ;
// parametri 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 ;
// indice corrente di posizione
int nI = 0 ;
// emissione oscillazioni
while ( dCurrLen < dLen - EPS_ZERO) {
while ( dCurrLen < dLen - EPS_ZERO && nI < int( vdTabs.size())) {
// lunghezze di riferimento dei tratti di oscillazione
double vLenRef[4] = { vdTabs[nI] + vLen[0], vdTabs[nI] + vLen[1], vdTabs[nI] + vLen[2], vdTabs[nI] + vLen[3]} ;
// lunghezza rimanente
double dNextLen = dLen - dCurrLen ;
// se inizio è sul primo tratto (rampa discendente)
// se inizio è sul primo tratto (parte piatta in basso)
if ( m_dCurrTabsLen < vLenRef[0] - 10 * EPS_SMALL) {
// se fine linea è entro il tratto
// se fine arco è 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
// se fine arco è alla fine del tratto
else if ( m_dCurrTabsLen + dNextLen < vLenRef[0] + 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrTabsLen = vLenRef[0] ;
@@ -4397,7 +4449,7 @@ Milling::AddTabsArc( const ICurveArc* pArc, const Vector3d& vtTool, double dTabs
if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
return false ;
}
// altrimenti fine linea è oltre
// altrimenti fine arco è oltre
else {
dCurrLen += vLenRef[0] - m_dCurrTabsLen ;
m_dCurrTabsLen = vLenRef[0] ;
@@ -4408,50 +4460,53 @@ Milling::AddTabsArc( const ICurveArc* pArc, const Vector3d& vtTool, double dTabs
return false ;
}
}
// se inizio è sul secondo tratto (parte piatta in basso)
// se inizio è sul secondo tratto (rampa ascendente)
else if ( m_dCurrTabsLen < vLenRef[1] - 10 * EPS_SMALL) {
// se fine linea è entro il tratto
// se fine arco è entro il tratto
if ( m_dCurrTabsLen + dNextLen < vLenRef[1] - 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrTabsLen += dNextLen ;
Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
ptP3 += vtTool * ( abs( m_Params.m_dTabHeight) * ( m_dCurrTabsLen - vLenRef[0]) / ( vLenRef[1] - vLenRef[0])) ;
double dCurrAngCen = dAngCen * dNextLen / dLen ;
if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
return false ;
}
// se fine linea è alla fine del tratto
// se fine arco è 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) ;
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
// altrimenti fine arco è 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) ;
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 ;
}
}
// se inizio è sul terzo tratto (rampa ascendente)
// se inizio è sul terzo tratto (parte piatta in alto)
else if ( m_dCurrTabsLen < vLenRef[2] - 10 * EPS_SMALL) {
// se fine linea è entro il tratto
// se fine arco è 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])) ;
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
// se fine arco è alla fine del tratto
else if ( m_dCurrTabsLen + dNextLen < vLenRef[2] + 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrTabsLen = vLenRef[2] ;
@@ -4461,7 +4516,7 @@ Milling::AddTabsArc( const ICurveArc* pArc, const Vector3d& vtTool, double dTabs
if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
return false ;
}
// altrimenti fine linea è oltre
// altrimenti fine arco è oltre
else {
dCurrLen += vLenRef[2] - m_dCurrTabsLen ;
m_dCurrTabsLen = vLenRef[2] ;
@@ -4473,40 +4528,41 @@ Milling::AddTabsArc( const ICurveArc* pArc, const Vector3d& vtTool, double dTabs
return false ;
}
}
// altrimenti è sul quarto tratto (parte piatta in alto)
else {
// se fine linea è entro il tratto
// altrimenti è sul quarto tratto (rampa discendente)
else if ( m_dCurrTabsLen < vLenRef[3] - 10 * EPS_SMALL) {
// se fine arco è 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) ;
ptP3 += vtTool * ( abs( m_Params.m_dTabHeight) * ( vLenRef[3] - m_dCurrTabsLen) / ( vLenRef[3] - vLenRef[2])) ;
double dCurrAngCen = dAngCen * dNextLen / dLen ;
if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
return false ;
}
// se fine linea è alla fine del tratto
// se fine arco è alla fine del tratto
else if ( m_dCurrTabsLen + dNextLen < vLenRef[3] + 10 * EPS_SMALL) {
dCurrLen = dLen ;
m_dCurrTabsLen = 0 ;
m_dCurrTabsLen = vLenRef[3] ;
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
// altrimenti fine arco è oltre
else {
dCurrLen += vLenRef[3] - m_dCurrTabsLen ;
m_dCurrTabsLen = 0 ;
m_dCurrTabsLen = vLenRef[3] ;
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 passo all'intervallo successivo
else
++ nI ;
}
return true ;
}
Milling.h
+11 -3
View File
@@ -69,6 +69,13 @@ class Milling : public Machining
public :
Milling( void) ;
private :
struct TabData {
double m_dBottomLen ;
double m_dRampLen ;
double m_dTopLen ;
} ;
private :
bool VerifyGeometry( SelData Id, int& nSubs, int& nType) ;
bool GetCurves( SelData Id, ICURVEPLIST& lstPC) ;
@@ -102,9 +109,10 @@ 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) ;
bool AdjustTabsParams( const ICurve* pCrv, bool& bPathTabsEnable, TabData& tdTabs) ;
bool CalcTabsPositions( const ICurveComposite* pCompo, bool bPathTabsEnable, const TabData& tdTabs, DBLVECTOR& vdTabs) ;
bool AddTabsLine( const ICurveLine* pLine, const Vector3d& vtTool, const DBLVECTOR& vdTabs, const TabData& tdTabs) ;
bool AddTabsArc( const ICurveArc* pArc, const Vector3d& vtTool, const DBLVECTOR& vdTabs, const TabData& tdTabs) ;
double GetRadiusForStartEndElevation( void) const ;
bool GetPointOutOfRaw( const Point3d& ptP, const Vector3d& vtTool, double dElev) const ;
bool GetPointAboveRaw( const Point3d& ptP, const Vector3d& vtTool) const ;