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

EgtMachKernel 2.2d1 :

Browse Source 
- in fresatura corretti e modificati attacchi a zigzag e a spirale specie per percorsi aperti
- in fresatura corretto step di spirale su percorso aperto
- in fresatura con lama aggiunti altri controlli su movimenti assiali
- in taglio con lama ammesse anche superfici regione
- in mortasatura (taglio con sega a catena) corretto calcolo elevazione su inizio e fine con attacco da sotto.
This commit is contained in:
Dario Sassi
2020-04-08 21:11:12 +00:00
parent 0243faef74
commit 0971bba37d
6 changed files with 238 additions and 74 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Milling.cpp
+124 -43
View File
@@ -1061,8 +1061,8 @@ Milling::VerifyGeometry( SelData Id, int& nSubs, int& nType)
return true ;
}
// se altrimenti ammesse superfici trimesh ed è tale
else if ( ( nType == GEO_NONE || nType == SRF_TRIMESH) && pGObj->GetType() == SRF_TRIMESH) {
nType = SRF_TRIMESH ;
else if ( ( nType == GEO_NONE || nType == GEO_SURF) && pGObj->GetType() == SRF_TRIMESH) {
nType = GEO_SURF ;
const ISurfTriMesh* pSurf = ::GetSurfTriMesh( pGObj) ;
if ( pSurf == nullptr)
return false ;
@@ -1083,8 +1083,8 @@ Milling::VerifyGeometry( SelData Id, int& nSubs, int& nType)
return true ;
}
// se altrimenti ammesse regioni ed è tale
else if ( ( nType == GEO_NONE || nType == SRF_FLATRGN) && pGObj->GetType() == SRF_FLATRGN) {
nType = SRF_FLATRGN ;
else if ( ( nType == GEO_NONE || nType == GEO_SURF) && pGObj->GetType() == SRF_FLATRGN) {
nType = GEO_SURF ;
const ISurfFlatRegion* pReg = ::GetSurfFlatRegion( pGObj) ;
if ( pReg == nullptr)
return false ;
@@ -1179,7 +1179,7 @@ Milling::GetCurves( SelData Id, ICURVEPLIST& lstPC)
// ritorno
return true ;
}
// se altrimenti superficie
// se altrimenti superficie trimesh
else if ( pGObj->GetType() == SRF_TRIMESH) {
// recupero la trimesh
const ISurfTriMesh* pSurf = ::GetSurfTriMesh( pGObj) ;
@@ -1759,6 +1759,16 @@ Milling::ProcessPath( int nPathId, int nPvId, int nClId)
SetPathId( nPxId) ;
SetToolDir( vtTool) ;
// Controlli per lama (non deve fare movimenti assiali nel pezzo)
if ( ( m_TParams.m_nType & TF_SAWBLADE) != 0) {
// Non ammesse passate a spirale
if ( m_Params.m_nStepType == MILL_ST_SPIRAL)
m_Params.m_nStepType = MILL_ST_ZIGZAG ;
// Non ammessa elevazione in attacco e uscita
m_Params.m_dLiElev = 0 ;
m_Params.m_dLoElev = 0 ;
}
// Se lama con elevazione e step di fianco
if ( ( m_TParams.m_nType & TF_SAWBLADE) != 0 && dSideElev > 10 * EPS_SMALL && dOkStep > EPS_SMALL) {
m_bStepOn = true ;
@@ -2267,6 +2277,11 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
dStElev -= ( ptP1 - ptStart) * vtTool ;
// determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
bool bUnderStart = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, GetRadiusForStartEndElevation(), m_TParams.m_dLen, dStElev) ;
// se attacco a zigzag o a spirale, l'elevazione va nell'attacco
if ( IsLeadInHelixOrZigzag()) {
ptP1 += vtTool * ( dStElev + LIO_ELEV_TOL) ;
dStElev = - LIO_ELEV_TOL ;
}
// approccio al punto iniziale
if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dAppr, bOutStart, bAboveStart)) {
m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ;
@@ -2293,6 +2308,11 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
return false ;
}
}
// se attacco a zigzag o a spirale, non affondo
else if ( IsLeadInHelixOrZigzag()) {
ptP1 += vtTool * ( dStElev + LIO_ELEV_TOL) ;
dStElev = - LIO_ELEV_TOL ;
}
// altrimenti, affondo in feed opportuna
else {
bool bStartFeed = ( bOutStart || m_TParams.m_nType == TT_MILL_NOTIP || m_TParams.m_nType == TT_MILL_POLISHING) ;
@@ -2355,12 +2375,14 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
}
else
dEndElev = - LIO_ELEV_TOL ;
// aggiungo uscita
Point3d ptP1 ;
SetFeed( GetEndFeed()) ;
if ( ! AddLeadOut( ptEnd, vtEnd, vtTool, dEndElev, bInvert, pCompo, bSplitArcs, ptP1)) {
m_pMchMgr->SetLastError( 2311, "Error in Milling : LeadOut not computable") ;
return false ;
// se non c'è attacco a zigzag o a spirale oppure ultimo step, aggiungo uscita
Point3d ptP1 = ptEnd ;
if ( ! IsLeadInHelixOrZigzag() || j == nStep) {
SetFeed( GetEndFeed()) ;
if ( ! AddLeadOut( ptEnd, vtEnd, vtTool, dEndElev, bInvert, pCompo, bSplitArcs, ptP1)) {
m_pMchMgr->SetLastError( 2311, "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) {
@@ -2619,15 +2641,17 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
double dOscRampLen, dOscFlatLen ;
AdjustOscillParams( pCompo, bPathOscEnable, dOscRampLen, dOscFlatLen) ;
// imposto flag di percorso chiuso
bool bClosed = pCompo->IsClosed() ;
// determino numero e affondamento degli step
int nStep = max( 1, static_cast<int>( ceil( ( dElev + dStart) / dOkStep))) ;
int nStep = max( 1, static_cast<int>( ceil( ( dElev + dStart) / ( bClosed ? dOkStep : dOkStep / 2)))) ;
if ( m_TParams.m_nType == TT_MILL_POLISHING)
nStep = max( 1, nStep - 1) ;
double dStep = ( dElev + dStart) / nStep ;
// determino dati del percorso
double dTotLen ; pCompo->GetLength( dTotLen) ;
bool bClosed = pCompo->IsClosed() ;
int nMaxInd = pCompo->GetCurveCount() - 1 ;
// se chiuso -> sempre in avanti
@@ -3336,9 +3360,9 @@ Milling::GetLeadInType( void) const
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_bStepOn && 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_bStepOn && 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_bStepOn && m_Params.m_nStepType == MILL_ST_SPIRAL)
return MILL_LI_NONE ;
@@ -3360,17 +3384,20 @@ Milling::CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtStart, const
double dElev = min( m_Params.m_dLiElev, dStElev + LIO_ELEV_TOL) ;
// se step invertito
if ( bInvert) {
switch ( m_Params.m_nLeadOutType) {
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 ;
case MILL_LO_AS_LI : /* resta inalterato */ ; break ;
default : nType = MILL_LI_NONE ; break ;
}
if ( m_Params.m_nLeadOutType != MILL_LO_AS_LI) {
dTang = m_Params.m_dLoTang ;
dPerp = m_Params.m_dLoPerp ;
dElev = min( m_Params.m_dLoElev, dStElev + LIO_ELEV_TOL) ;
// va aggiustato se non zigzag o spirale
if ( nType != MILL_LI_ZIGZAG && nType != MILL_LI_HELIX) {
switch ( m_Params.m_nLeadOutType) {
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 ;
case MILL_LO_AS_LI : /* resta inalterato */ ; break ;
default : nType = MILL_LI_NONE ; break ;
}
if ( m_Params.m_nLeadOutType != MILL_LO_AS_LI) {
dTang = m_Params.m_dLoTang ;
dPerp = m_Params.m_dLoPerp ;
dElev = min( m_Params.m_dLoElev, dStElev + LIO_ELEV_TOL) ;
}
}
}
// senso di rotazione da dir tg a dir esterna
@@ -3433,15 +3460,18 @@ Milling::AddLeadIn( const Point3d& ptP1, const Point3d& ptStart, const Vector3d&
double dTang = m_Params.m_dLiTang ;
// se step invertito
if ( bInvert) {
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 ;
case MILL_LO_AS_LI : /* resta inalterato */ ; break ;
default : nType = MILL_LI_NONE ; break ;
// va aggiustato se non zigzag o spirale
if ( nType != MILL_LI_ZIGZAG && nType != MILL_LI_HELIX) {
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 ;
case MILL_LO_AS_LI : /* resta inalterato */ ; break ;
default : nType = MILL_LI_NONE ; break ;
}
if ( m_Params.m_nLeadOutType != MILL_LO_AS_LI)
dTang = m_Params.m_dLoTang ;
}
if ( m_Params.m_nLeadOutType != MILL_LO_AS_LI)
dTang = m_Params.m_dLoTang ;
}
// verifico di poter fare l'ingresso a inseguimento
if ( nType == MILL_LI_GLIDE && ! pCompo->IsClosed() && m_dAddedOverlap < EPS_SMALL)
@@ -3522,22 +3552,73 @@ Milling::AddLeadIn( const Point3d& ptP1, const Point3d& ptStart, const Vector3d&
}
case MILL_LI_ZIGZAG :
{
// recupero la parte richiesta della curva
PtrOwner<ICurveComposite> pCrv ;
if ( ! bInvert) {
double dU ;
if ( pCompo->GetParamAtLength( dTang, dU)) {
double dParS, dParE ;
pCompo->GetDomain( dParS, dParE) ;
if ( ! pCrv.Set( CreateCurveComposite()) || ! pCrv->AddCurve( pCompo->CopyParamRange( dParS, dU)))
return false ;
}
else {
if ( ! pCrv.Set( pCompo->Clone()))
return false ;
}
}
else {
double dLen, dU ;
if ( pCompo->GetLength( dLen) && pCompo->GetParamAtLength( dLen - dTang, dU)) {
double dParS, dParE ;
pCompo->GetDomain( dParS, dParE) ;
if ( ! pCrv.Set( CreateCurveComposite()) || ! pCrv->AddCurve( pCompo->CopyParamRange( dU, dParE)))
return false ;
}
else {
if ( ! pCrv.Set( pCompo->Clone()))
return false ;
}
pCrv->Invert() ;
}
pCrv->SetExtrusion( vtN) ;
// la porto alla giusta quota
Point3d ptIni ; pCrv->GetStartPoint( ptIni) ;
Vector3d vtMove = ptStart - ptIni ;
pCrv->Translate( vtMove) ;
// eventuale spezzatura
if ( bSplitArcs && ! ApproxWithLines( pCrv))
return false ;
// la ripeto a zigzag
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)
// calcolo quote per pendenza
double dNini = ( ptP1 - ORIG) * vtN - ( i - 1) * dStep ;
double dNmid = dNini - 0.5 * dStep ;
double dNfin = dNmid - 0.5 * dStep ;
// copio per zig
PtrOwner<ICurveComposite> pCopy1( pCrv->Clone()) ;
// assegno la corretta pendenza
AdjustCurveSlope( pCopy1, dNini, dNmid) ;
// emetto
if ( AddCurveMove( pCopy1) == GDB_ID_NULL)
return false ;
if ( AddLinearMove( ptPb - vtN * ( i - 0.25) * dStep, MCH_CL_LEADIN) == GDB_ID_NULL)
// copio per zag
PtrOwner<ICurveComposite> pCopy2( pCrv->Clone()) ;
pCopy2->Invert() ;
// assegno la corretta pendenza
AdjustCurveSlope( pCopy2, dNmid, dNfin) ;
// emetto
if ( AddCurveMove( pCopy2) == GDB_ID_NULL)
return false ;
}
return ( AddLinearMove( ptStart, MCH_CL_LEADIN) != GDB_ID_NULL) ;
return true ;
}
case MILL_LI_HELIX :
{
bool bAtLeft = ( m_Params.m_nWorkSide != MILL_WS_RIGHT) ;
bool bAtLeft = ( bInvert != ( m_Params.m_nWorkSide != MILL_WS_RIGHT)) ;
// vettore dal punto al centro elica
Vector3d vtCen = vtStart ;
vtCen.Rotate( vtN, 0, ( bAtLeft ? 1 : - 1)) ;
@@ -3595,8 +3676,8 @@ Milling::AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d
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 ;
case MILL_LI_ZIGZAG : nType = MILL_LO_LINEAR ; break ;
case MILL_LI_HELIX : nType = MILL_LO_TANGENT ; break ;
case MILL_LI_ZIGZAG : nType = MILL_LO_NONE ; break ;
case MILL_LI_HELIX : nType = MILL_LO_NONE ; break ;
default : nType = MILL_LO_NONE ; break ;
}
dTang = m_Params.m_dLiTang ;