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

EgtMachKernel :

Browse Source 
- a lavorazione WaterJetting aggiunti parametri necessari.
This commit is contained in:
Dario Sassi
2019-10-21 10:59:44 +00:00
parent 222db2563a
commit 40aa1de2de
4 changed files with 390 additions and 44 deletions
Download Patch File Download Diff File Expand all files Collapse all files
WaterJetting.cpp
+168 -35
View File
@@ -248,6 +248,16 @@ WaterJetting::SetParam( int nType, bool bVal)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_bInvert = bVal ;
return true ;
case MPA_PROBING :
if ( bVal != m_Params.m_bProbing)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_bProbing = bVal ;
return true ;
case MPA_LIHOLE :
if ( bVal != m_Params.m_bLiHole)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_bLiHole = bVal ;
return true ;
}
return false ;
}
@@ -264,6 +274,27 @@ WaterJetting::SetParam( int nType, int nVal)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_nWorkSide = nVal ;
return true ;
case MPA_EXTCORNERTYPE :
if ( ! m_Params.VerifyExtCornerType( nVal))
return false ;
if ( nVal != m_Params.m_nExtCornerType)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_nExtCornerType = nVal ;
break ;
case MPA_INTCORNERTYPE :
if ( ! m_Params.VerifyIntCornerType( nVal))
return false ;
if ( nVal != m_Params.m_nIntCornerType)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_nIntCornerType = nVal ;
break ;
case MPA_CORNERSLOWPERC :
if ( ! m_Params.VerifyCornerSlowPerc( nVal))
return false ;
if ( nVal != m_Params.m_nCornerSlowPerc)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_nCornerSlowPerc = nVal ;
break ;
case MPA_LEADINTYPE :
if ( ! m_Params.VerifyLeadInType( nVal))
return false ;
@@ -278,6 +309,16 @@ WaterJetting::SetParam( int nType, int nVal)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_nLeadOutType = nVal ;
return true ;
case MPA_LPTURNS :
if ( nVal != m_Params.m_nLpTurns)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_nLpTurns = nVal ;
break ;
case MPA_HPTURNS :
if ( nVal != m_Params.m_nHpTurns)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_nHpTurns = nVal ;
break ;
case MPA_SCC :
if ( ! m_Params.VerifySolCh( nVal))
return false ;
@@ -336,6 +377,13 @@ WaterJetting::SetParam( int nType, double dVal)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dSideAngle = dVal ;
return true ;
case MPA_FORWARDANGLE :
if ( ! m_Params.VerifyForwardAngle( dVal))
return false ;
if ( ! AreSameAngValue( dVal, m_Params.m_dForwardAngle))
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dForwardAngle = dVal ;
return true ;
case MPA_STARTADDLEN :
if ( abs( dVal - m_Params.m_dStartAddLen) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
@@ -346,6 +394,21 @@ WaterJetting::SetParam( int nType, double dVal)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dEndAddLen = dVal ;
return true ;
case MPA_PROBINGMINDIST :
if ( abs( dVal - m_Params.m_dProbingMinDist) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dProbingMinDist = dVal ;
return true ;
case MPA_PROBINGMAXDIST :
if ( abs( dVal - m_Params.m_dProbingMaxDist) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dProbingMaxDist = dVal ;
return true ;
case MPA_CORNERSLOWLEN :
if ( abs( dVal - m_Params.m_dCornerSlowLen) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dCornerSlowLen = dVal ;
return true ;
case MPA_LITANG :
if ( abs( dVal - m_Params.m_dLiTang) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
@@ -698,6 +761,12 @@ WaterJetting::GetParam( int nType, bool& bVal) const
case MPA_INVERT :
bVal = m_Params.m_bInvert ;
return true ;
case MPA_PROBING :
bVal = m_Params.m_bProbing ;
return true ;
case MPA_LIHOLE :
bVal = m_Params.m_bLiHole ;
return true ;
}
bVal = false ;
return false ;
@@ -714,12 +783,27 @@ WaterJetting::GetParam( int nType, int& nVal) const
case MPA_WORKSIDE :
nVal = m_Params.m_nWorkSide ;
return true ;
case MPA_EXTCORNERTYPE :
nVal = m_Params.m_nExtCornerType ;
return true ;
case MPA_INTCORNERTYPE :
nVal = m_Params.m_nIntCornerType ;
return true ;
case MPA_CORNERSLOWPERC :
nVal = m_Params.m_nCornerSlowPerc ;
return true ;
case MPA_LEADINTYPE :
nVal = m_Params.m_nLeadInType ;
return true ;
case MPA_LEADOUTTYPE :
nVal = m_Params.m_nLeadOutType ;
return true ;
case MPA_LPTURNS :
nVal = m_Params.m_nLpTurns ;
return true ;
case MPA_HPTURNS :
nVal = m_Params.m_nHpTurns ;
return true ;
case MPA_SCC :
nVal = m_Params.m_nSolCh ;
return true ;
@@ -751,12 +835,24 @@ WaterJetting::GetParam( int nType, double& dVal) const
case MPA_SIDEANGLE :
dVal = m_Params.m_dSideAngle ;
return true ;
case MPA_FORWARDANGLE :
dVal = m_Params.m_dForwardAngle ;
return true ;
case MPA_STARTADDLEN :
dVal = m_Params.m_dStartAddLen ;
return true ;
case MPA_ENDADDLEN :
dVal = m_Params.m_dEndAddLen ;
return true ;
case MPA_PROBINGMINDIST :
dVal = m_Params.m_dProbingMinDist ;
return true ;
case MPA_PROBINGMAXDIST :
dVal = m_Params.m_dProbingMaxDist ;
return true ;
case MPA_CORNERSLOWLEN :
dVal = m_Params.m_dCornerSlowLen ;
return true ;
case MPA_LITANG :
dVal = m_Params.m_dLiTang ;
return true ;
@@ -1373,6 +1469,10 @@ WaterJetting::ProcessPath( int nPathId, int nPvId, int nClId)
// verifiche sull'ampiezza dell'angolo al centro degli eventuali archi
VerifyArcs( pCompo) ;
// se abilitato probing, verifico lunghezza entità ed eventualmente le divido
if ( m_Params.m_bProbing)
VerifyMaxLenCurves( pCompo, m_Params.m_dProbingMaxDist) ;
// calcolo l'elevazione massima
double dElev = 0 ;
@@ -1697,10 +1797,8 @@ WaterJetting::AddLoopsPreview( const ICurveComposite* pCompo, ISurfFlatRegion* p
Vector3d vtStart ; pCrvC->GetStartDir( vtStart) ;
// angolo tra le direzioni
double dAng ; vtEnd.GetAngleXY( vtStart, dAng) ;
// se deviazione esterna superiore a 30deg, si aggiunge l'anello
const double ANG_CORNER = 30 ;
if ( ( dAng > ANG_CORNER && m_Params.m_nWorkSide == WJET_WS_RIGHT) ||
( dAng < -ANG_CORNER && m_Params.m_nWorkSide == WJET_WS_LEFT)) {
// se previsto e angolo esterno, si aggiunge l'anello
if ( m_Params.m_nExtCornerType == WJET_EC_LOOP && IsExternalAngle( dAng)) {
// curva dell'anello
PtrOwner<ICurveComposite> pCompo( CreateCurveComposite()) ;
if ( IsNull( pCompo))
@@ -1749,6 +1847,9 @@ bool
WaterJetting::AddStandardWj( const ICurveComposite* pCompo, const Vector3d& vtTool,
double dRbDist, double dElev, bool bSplitArcs)
{
// numero punti di accelerazione/decelerazione
const int ACC_PNT_NUM = 3 ;
// recupero distanze di sicurezza
double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ;
@@ -1799,12 +1900,10 @@ WaterJetting::AddStandardWj( const ICurveComposite* pCompo, const Vector3d& vtTo
// direzione iniziale corrente
Vector3d vtStart ; pCrvC->GetStartDir( vtStart) ;
// angolo tra le direzioni
double dAng ; vtEnd.GetAngleXY( vtStart, dAng) ;
// Valore limite angolo per corner
const double ANG_CORNER = 30 ;
// Se angolo esterno con precedente (deviazione esterna superiore a 30deg), aggiungo anello
if ( ( dAng > ANG_CORNER && m_Params.m_nWorkSide == WJET_WS_RIGHT) ||
( dAng < -ANG_CORNER && m_Params.m_nWorkSide == WJET_WS_LEFT)) {
double dAng ;
vtEnd.GetAngleXY( vtStart, dAng) ;
// Se richiesto loop e angolo esterno con precedente
if ( m_Params.m_nExtCornerType == WJET_EC_LOOP && IsExternalAngle( dAng)) {
// lunghezza tratti lineari e loro punti estremi
double dTgLen = 0.5 * m_TParams.m_dDiam * tan( 0.5 * dAng * DEGTORAD) ;
Point3d ptP ; pCrvC->GetStartPoint( ptP) ;
@@ -1829,19 +1928,16 @@ WaterJetting::AddStandardWj( const ICurveComposite* pCompo, const Vector3d& vtTo
if ( AddLinearMove( ptP) == GDB_ID_NULL)
return false ;
}
// se altrimenti angolo interno con precedente (deviazione interna inferiore a -30deg), aggiungo accelerazione
else if ( ( dAng <- ANG_CORNER && m_Params.m_nWorkSide == WJET_WS_RIGHT) ||
( dAng > ANG_CORNER && m_Params.m_nWorkSide == WJET_WS_LEFT)) {
// lunghezza max di accelerazione
const double ACC_MAX_LEN = 10 ;
// se altrimenti richiesto rallentamento esterno o interno e angolo dello stesso tipo, eseguo accelerazione
else if ( ( m_Params.m_nExtCornerType == WJET_EC_SLOW && IsExternalAngle( dAng)) ||
( m_Params.m_nIntCornerType == WJET_IC_SLOW && IsInternalAngle( dAng))) {
// lunghezza entità
double dLen ; pCrvC->GetLength( dLen) ;
double dAccLen = min( ACC_MAX_LEN, dLen / 2) ;
// lunghezza di accelerazione
double dAccLen = min( m_Params.m_dCornerSlowLen, dLen / 2) ;
// Feed minima
const double COEFF_MIN_FEED = 0.5 ;
double dMinFeed = COEFF_MIN_FEED * GetFeed() ;
double dMinFeed = m_Params.m_nCornerSlowPerc / 100. * GetFeed() ;
// ciclo sui punti di accelerazione
const int ACC_PNT_NUM = 3 ;
for ( int j = 1 ; j <= ACC_PNT_NUM ; ++ j) {
double dCoeff = j / double( ACC_PNT_NUM) ;
double dU ; pCrvC->GetParamAtLength( dCoeff * dAccLen, dU) ;
@@ -1854,12 +1950,11 @@ WaterJetting::AddStandardWj( const ICurveComposite* pCompo, const Vector3d& vtTo
}
}
// se non è l'ultima entità, verifico se dopo c'è un angolo interno
const double MIN_PROBE_DIST = 90 ;
double dNextFeed = GetFeed() ;
if ( i < nMaxInd) {
// controlli per indice del punto di arrivo
Point3d ptP3 ; pCrvC->GetEndPoint( ptP3) ;
if ( SqDistXY( ptP3, m_ptLastProbe) >= MIN_PROBE_DIST * MIN_PROBE_DIST)
if ( SqDistXY( ptP3, m_ptLastProbe) >= m_Params.m_dProbingMinDist * m_Params.m_dProbingMinDist)
SetIndex( i + 1 - nIdxSkip) ;
// Recupero versore estrusione
Vector3d vtN ; pCompo->GetExtrusion( vtN) ;
@@ -1870,21 +1965,16 @@ WaterJetting::AddStandardWj( const ICurveComposite* pCompo, const Vector3d& vtTo
Vector3d vtStart ; pCrvN->GetStartDir( vtStart) ;
// angolo tra le direzioni
double dAng ; vtEnd.GetAngleXY( vtStart, dAng) ;
// Valore limite angolo per corner
const double ANG_CORNER = 30 ;
// se altrimenti angolo interno con successivo (deviazione interna inferiore a -30deg), aggiungo accelerazione
if ( ( dAng <- ANG_CORNER && m_Params.m_nWorkSide == WJET_WS_RIGHT) ||
( dAng > ANG_CORNER && m_Params.m_nWorkSide == WJET_WS_LEFT)) {
// lunghezza max di decelerazione
const double ACC_MAX_LEN = 10 ;
// se altrimenti richiesto rallentamento esterno o interno e angolo dello stesso tipo, aggiungo decelerazione
if ( ( m_Params.m_nExtCornerType == WJET_EC_SLOW && IsExternalAngle( dAng)) ||
( m_Params.m_nIntCornerType == WJET_IC_SLOW && IsInternalAngle( dAng))) {
// lunghezza entità
double dLen ; pCrvC->GetLength( dLen) ;
double dAccLen = min( ACC_MAX_LEN, dLen / 2) ;
// lunghezza di accelerazione
double dAccLen = min( m_Params.m_dCornerSlowLen, dLen / 2) ;
// Feed minima
const double COEFF_MIN_FEED = 0.5 ;
double dMinFeed = COEFF_MIN_FEED * GetFeed() ;
double dMinFeed = m_Params.m_nCornerSlowPerc / 100. * GetFeed() ;
// ciclo sui punti di decelerazione
const int ACC_PNT_NUM = 3 ;
for ( int j = 0 ; j < ACC_PNT_NUM ; ++ j) {
double dCoeff = j / double( ACC_PNT_NUM) ;
double dU ; pCrvC->GetParamAtLength( dLen - ( 1 - dCoeff) * dAccLen, dU) ;
@@ -1905,7 +1995,7 @@ WaterJetting::AddStandardWj( const ICurveComposite* pCompo, const Vector3d& vtTo
Point3d ptP3 = pLine->GetEnd() ;
SetFeed( dNextFeed) ;
// controlli per indice del punto di arrivo
if ( SqDistXY( ptP3, m_ptLastProbe) >= MIN_PROBE_DIST * MIN_PROBE_DIST) {
if ( SqDistXY( ptP3, m_ptLastProbe) >= m_Params.m_dProbingMinDist * m_Params.m_dProbingMinDist) {
SetIndex( i + 1 - nIdxSkip) ;
m_ptLastProbe = ptP3 ;
}
@@ -1922,7 +2012,7 @@ WaterJetting::AddStandardWj( const ICurveComposite* pCompo, const Vector3d& vtTo
Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
SetFeed( dNextFeed) ;
// controlli per indice del punto di arrivo
if ( SqDistXY( ptP3, m_ptLastProbe) >= MIN_PROBE_DIST * MIN_PROBE_DIST) {
if ( SqDistXY( ptP3, m_ptLastProbe) >= m_Params.m_dProbingMinDist * m_Params.m_dProbingMinDist) {
SetIndex( i + 1 - nIdxSkip) ;
m_ptLastProbe = ptP3 ;
}
@@ -1953,7 +2043,6 @@ WaterJetting::AddStandardWj( const ICurveComposite* pCompo, const Vector3d& vtTo
return true ;
}
//----------------------------------------------------------------------------
class LeadIOStatus
{
@@ -2386,3 +2475,47 @@ WaterJetting::CalcOffset( ICurveComposite* pCompo, double dSignOffs)
}
return bOk ;
}
//----------------------------------------------------------------------------
// Valore limite angolo per corner
const double ANG_CORNER = 30 ;
//----------------------------------------------------------------------------
bool
WaterJetting::IsExternalAngle( double dAng)
{
return ( ( dAng > ANG_CORNER && m_Params.m_nWorkSide == WJET_WS_RIGHT) ||
( dAng < -ANG_CORNER && m_Params.m_nWorkSide == WJET_WS_LEFT)) ;
}
//----------------------------------------------------------------------------
bool
WaterJetting::IsInternalAngle( double dAng)
{
return ( ( dAng <- ANG_CORNER && m_Params.m_nWorkSide == WJET_WS_RIGHT) ||
( dAng > ANG_CORNER && m_Params.m_nWorkSide == WJET_WS_LEFT)) ;
}
//----------------------------------------------------------------------------
bool
WaterJetting::VerifyMaxLenCurves( ICurveComposite* pCompo, double dMaxLen)
{
// verifiche sulla lunghezza delle curve
int nMaxInd = pCompo->GetCurveCount() - 1 ;
for ( int i = 0 ; i <= nMaxInd ; ) {
// se lunghezza oltre il limite, la divido a metà
const ICurve* pCrv = GetCurve( pCompo->GetCurve( i)) ;
double dLen ;
if ( pCrv != nullptr && pCrv->GetLength( dLen) && dLen > dMaxLen) {
int nParts = int( ceil( dLen / dMaxLen)) ;
for ( int j = 0 ; j < nParts - 1 ; ++ j) {
double dCoeff = 1. / ( nParts - j) ;
pCompo->AddJoint( i + j + dCoeff) ;
++ nMaxInd ;
}
}
else
++ i ;
}
return true ;
}