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

EgtMachKernel 2.1j5 :

Browse Source 
- in lavorazione WaterJetting aggiunti rallentamenti su angoli interni
- in lavorazione WaterJetting eliminati parametri inutili.
This commit is contained in:
Dario Sassi
2019-10-21 05:52:22 +00:00
parent cd28dbd9c9
commit 222db2563a
5 changed files with 168 additions and 454 deletions
Download Patch File Download Diff File Expand all files Collapse all files
EgtMachKernel.rc
BIN
View File
Binary file not shown.
WaterJetting.cpp
+140 -322
View File
@@ -310,20 +310,6 @@ WaterJetting::SetParam( int nType, double dVal)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dFeed = dVal ;
return true ;
case MPA_STARTFEED :
if ( abs( m_TParams.m_dStartFeed - dVal) < EPS_MACH_LEN_PAR)
dVal = 0 ;
if ( abs( dVal - m_Params.m_dStartFeed) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dStartFeed = dVal ;
return true ;
case MPA_ENDFEED :
if ( abs( m_TParams.m_dEndFeed - dVal) < EPS_MACH_LEN_PAR)
dVal = 0 ;
if ( abs( dVal - m_Params.m_dEndFeed) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dEndFeed = dVal ;
return true ;
case MPA_TIPFEED :
if ( abs( m_TParams.m_dTipFeed - dVal) < EPS_MACH_LEN_PAR)
dVal = 0 ;
@@ -338,24 +324,6 @@ WaterJetting::SetParam( int nType, double dVal)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dOffsR = dVal ;
return true ;
case MPA_OFFSL :
if ( abs( m_TParams.m_dOffsL - dVal) < EPS_MACH_LEN_PAR)
dVal = UNKNOWN_PAR ;
if ( abs( dVal - m_Params.m_dOffsL) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dOffsL = dVal ;
return true ;
case MPA_DEPTH : {
string sVal = ToString( dVal) ;
if ( sVal != m_Params.m_sDepth)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_sDepth = sVal ;
} return true ;
case MPA_STARTPOS :
if ( abs( dVal - m_Params.m_dStartPos) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dStartPos = dVal ;
return true ;
case MPA_OVERL :
if ( abs( dVal - m_Params.m_dOverlap) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
@@ -388,15 +356,10 @@ WaterJetting::SetParam( int nType, double dVal)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dLiPerp = dVal ;
return true ;
case MPA_LIELEV :
if ( abs( dVal - m_Params.m_dLiElev) > EPS_MACH_LEN_PAR)
case MPA_LIHOLERAD :
if ( abs( dVal - m_Params.m_dLiHoleRad) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dLiElev = dVal ;
return true ;
case MPA_LICOMPLEN :
if ( abs( dVal - m_Params.m_dLiCompLen) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dLiCompLen = dVal ;
m_Params.m_dLiHoleRad = dVal ;
return true ;
case MPA_LOTANG :
if ( abs( dVal - m_Params.m_dLoTang) > EPS_MACH_LEN_PAR)
@@ -408,16 +371,6 @@ WaterJetting::SetParam( int nType, double dVal)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dLoPerp = dVal ;
return true ;
case MPA_LOELEV :
if ( abs( dVal - m_Params.m_dLoElev) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dLoElev = dVal ;
return true ;
case MPA_LOCOMPLEN :
if ( abs( dVal - m_Params.m_dLoCompLen) > EPS_MACH_LEN_PAR)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_dLoCompLen = dVal ;
return true ;
}
return false ;
}
@@ -437,11 +390,6 @@ WaterJetting::SetParam( int nType, const string& sVal)
m_Params.m_ToolUuid = pTdata->m_Uuid ;
m_TParams = *pTdata ;
} return true ;
case MPA_DEPTH_STR :
if ( sVal != m_Params.m_sDepth)
m_nStatus |= MCH_ST_PARAM_MODIF ;
m_Params.m_sDepth = sVal ;
return true ;
case MPA_SYSNOTES :
if ( sVal != m_Params.m_sSysNotes)
m_nStatus |= MCH_ST_PARAM_MODIF ;
@@ -791,24 +739,12 @@ WaterJetting::GetParam( int nType, double& dVal) const
case MPA_FEED :
dVal = GetFeed() ;
return true ;
case MPA_STARTFEED :
dVal = GetStartFeed() ;
return true ;
case MPA_ENDFEED :
dVal = GetEndFeed() ;
return true ;
case MPA_TIPFEED :
dVal = GetTipFeed() ;
return true ;
case MPA_OFFSR :
dVal = GetOffsR() ;
return true ;
case MPA_OFFSL :
dVal = GetOffsL() ;
return true ;
case MPA_STARTPOS :
dVal = m_Params.m_dStartPos ;
return true ;
case MPA_OVERL :
dVal = m_Params.m_dOverlap ;
return true ;
@@ -827,21 +763,18 @@ WaterJetting::GetParam( int nType, double& dVal) const
case MPA_LIPERP :
dVal = m_Params.m_dLiPerp ;
return true ;
case MPA_LIELEV :
dVal = m_Params.m_dLiElev ;
return true ;
case MPA_LICOMPLEN :
dVal = m_Params.m_dLiCompLen ;
return true ;
case MPA_LIHOLERAD :
dVal = m_Params.m_dLiHoleRad ;
return true ;
case MPA_LOTANG :
dVal = m_Params.m_dLoTang ;
return true ;
case MPA_LOPERP :
dVal = m_Params.m_dLoPerp ;
return true ;
case MPA_LOELEV :
dVal = m_Params.m_dLoElev ;
return true ;
case MPA_LOCOMPLEN :
dVal = m_Params.m_dLoCompLen ;
return true ;
@@ -861,9 +794,6 @@ WaterJetting::GetParam( int nType, string& sVal) const
case MPA_TOOL :
sVal = m_Params.m_sToolName ;
return true ;
case MPA_DEPTH_STR :
sVal = m_Params.m_sDepth ;
return true ;
case MPA_TUUID :
sVal = ToString( m_Params.m_ToolUuid) ;
return true ;
@@ -1301,15 +1231,13 @@ WaterJetting::ProcessPath( int nPathId, int nPvId, int nClId)
if ( m_Params.m_bInvert)
pCompo->Invert() ;
// recupero direzione utensile da estrusione e spessore
// recupero direzione utensile da estrusione
Vector3d vtTool ;
pCompo->GetExtrusion( vtTool) ;
if ( ! ( vtTool - Z_AX).IsSmall()) {
m_pMchMgr->SetLastError( 3221, "Error in WaterJetting : Path plane different from XY") ;
return false ;
}
double dThick ;
pCompo->GetThickness( dThick) ;
// se percorso chiuso con lavorazione all'interno, porto la partenza a metà del lato più lungo
if ( pCompo->IsClosed()) {
@@ -1414,27 +1342,19 @@ WaterJetting::ProcessPath( int nPathId, int nPvId, int nClId)
return false ;
}
// recupero distanza da fondo dei grezzi interessati dal percorso
double dRbDist = 0 ;
if ( AreSameVectorApprox( vtTool, Z_AX)) {
if ( ! GetDistanceFromRawBottom( m_nPhase, nCopyId, m_TParams.m_dTDiam, dRbDist))
return false ;
// appiattisco il percorso sulla superficie superiore del grezzo
double dZref = b3Raw.GetMax().z ;
double dUs, dUe ; pCompo->GetDomain( dUs, dUe) ;
for ( int nU = int( dUs) ; nU < dUe + EPS_ZERO ; ++nU) {
Point3d ptP ;
if ( pCompo->GetPointD1D2( nU, ICurve::FROM_MINUS, ptP)) {
ptP.z = dZref ;
pCompo->ModifyJoint( nU, ptP) ;
}
}
// valuto l'espressione dell'affondamento
ExeLuaSetGlobNumVar( "TH", abs( dThick)) ;
ExeLuaSetGlobNumVar( "RB", dRbDist) ;
double dDepth ;
string sMyDepth = m_Params.m_sDepth ;
if ( ! ExeLuaEvalNumExpr( ToUpper( sMyDepth), &dDepth)) {
m_pMchMgr->SetLastError( 3204, "Error in WaterJetting : Depth not computable") ;
return false ;
}
// se spessore positivo, lo sottraggo dal risultato
if ( dThick > 0)
dDepth -= dThick ;
// sottraggo eventuale offset longitudinale
dDepth -= GetOffsL() ;
// recupero distanza da fondo dei grezzi interessati dal percorso
double dRbDist = ( b3Raw.GetMax() - b3Raw.GetMin()).z ;
// recupero nome del path
string sPathName ;
@@ -1454,20 +1374,7 @@ WaterJetting::ProcessPath( int nPathId, int nPvId, int nClId)
VerifyArcs( pCompo) ;
// calcolo l'elevazione massima
double dElev ;
if ( CalcPathElevation( pCompo, vtTool, dDepth, 0.5 * m_TParams.m_dDiam, dElev)) {
if ( dElev < EPS_SMALL && AreSameVectorApprox( vtTool, Z_AX)) {
BBox3d b3Crv ;
pCompo->GetLocalBBox( b3Crv) ;
dElev = max( 0., b3Raw.GetMax().z - b3Crv.GetMin().z + min( 0., dThick) + dDepth) ;
}
}
else
return false ;
// eventuale imposizione massima elevazione da note utente
double dMaxElev ;
if ( FromString( ExtractInfo( m_Params.m_sUserNotes, "MaxElev="), dMaxElev) && dElev > dMaxElev)
dElev = dMaxElev ;
double dElev = 0 ;
// verifico che il massimo materiale dell'utensile sia sensato
const double MIN_MAXMAT = 1.0 ;
@@ -1520,7 +1427,7 @@ WaterJetting::ProcessPath( int nPathId, int nPvId, int nClId)
SetPathId( nPxId) ;
// Inserisco la lavorazione
if ( ! AddStandardWj( pCompo, vtTool, dDepth, dElev, bSplitArcs))
if ( ! AddStandardWj( pCompo, vtTool, dRbDist, dElev, bSplitArcs))
return false ;
}
@@ -1680,7 +1587,7 @@ WaterJetting::AddLeadInPreview( const ICurveComposite* pCompo, ISurfFlatRegion*
Vector3d vtN ; pCompo->GetExtrusion( vtN) ;
// Calcolo punto iniziale dell'attacco
Point3d ptP1 ;
if ( ! CalcLeadInStart( ptStart, vtStart, vtN, 0, false, pCompo, ptP1))
if ( ! CalcLeadInStart( ptStart, vtStart, vtN, pCompo, ptP1))
return false ;
// calcolo la curva di attacco
PtrOwner<ICurve> pCrv ;
@@ -1840,69 +1747,49 @@ WaterJetting::AddLoopsPreview( const ICurveComposite* pCompo, ISurfFlatRegion* p
//----------------------------------------------------------------------------
bool
WaterJetting::AddStandardWj( const ICurveComposite* pCompo, const Vector3d& vtTool,
double dDepth, double dElev, bool bSplitArcs)
double dRbDist, double dElev, bool bSplitArcs)
{
// recupero distanze di sicurezza
double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ;
double dSafeAggrBottZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeAggrBottZ() ;
// lunghezza di approccio/retrazione
double dAppr = m_Params.m_dStartPos ;
// ciclo sulle curve elementari
int nIdxSkip = 0 ;
int nMaxInd = pCompo->GetCurveCount() - 1 ;
for ( int i = 0 ; i <= nMaxInd ; ++ i) {
// curva corrente
const ICurve* pCrvC = pCompo->GetCurve( i) ;
// copio la curva
// copio la curva (è già alla giusta quota)
PtrOwner<ICurve> pCurve( pCrvC->Clone()) ;
if ( IsNull( pCurve))
return false ;
// aggiungo affondamento
pCurve->Translate( - vtTool * dDepth) ;
// se prima entità, approccio e affondo
if ( i == 0) {
// imposto indice dei punti precedenti la partenza
SetIndex( -1) ;
SetIndex( -1 - nIdxSkip) ;
// dati inizio entità
Point3d ptStart ;
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(), vtTool, dStElev))
dStElev = dElev ;
Point3d ptStart ; pCurve->GetStartPoint( ptStart) ;
Vector3d vtStart ; pCurve->GetStartDir( vtStart) ;
// determino inizio attacco
Point3d ptP1 ;
if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, dStElev, false, pCompo, ptP1))
if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, pCompo, ptP1))
return false ;
// determino se l'inizio dell'attacco è fuori dal grezzo
bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, dElev) ;
// determino se l'inizio dell'attacco è sopra il grezzo
bool bAboveStart = GetPointAboveRaw( ptP1) ;
// imposto versore correzione e ausiliario sul punto di partenza
CalcAndSetToolCorrAuxDir( pCompo, i) ;
// aggiungo approccio
// correggo elevazione iniziale per punto inizio attacco (se testa da sopra senza aggregato approccio mai Z-)
if ( vtTool.z < - EPS_SMALL)
dStElev -= ScalarXY( (ptP1 - ptStart), vtTool) ;
else
dStElev -= ( ptP1 - ptStart) * vtTool ;
// approccio al punto iniziale
if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dAppr, bOutStart, bAboveStart)) {
// aggiungo approccio al punto iniziale
if ( ! AddApproach( ptP1, vtTool, dSafeZ)) {
m_pMchMgr->SetLastError( 3207, "Error in WaterJetting : Approach not computable") ;
return false ;
}
// aggiungo attacco
SetFeed( GetStartFeed()) ;
SetIndex( 0) ;
if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, false, pCompo, bSplitArcs)) {
SetFeed( GetFeed()) ;
SetIndex( 0 - nIdxSkip) ;
if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, bSplitArcs)) {
m_pMchMgr->SetLastError( 3208, "Error in WaterJetting : LeadIn not computable") ;
return false ;
}
m_ptLastProbe = ptStart ;
}
// altrimenti verifico se forma un angolo esterno con l'entità precedente
// altrimenti verifico con l'entità precedente
else {
// Recupero versore estrusione
Vector3d vtN ; pCompo->GetExtrusion( vtN) ;
@@ -1913,8 +1800,9 @@ WaterJetting::AddStandardWj( const ICurveComposite* pCompo, const Vector3d& vtTo
Vector3d vtStart ; pCrvC->GetStartDir( vtStart) ;
// angolo tra le direzioni
double dAng ; vtEnd.GetAngleXY( vtStart, dAng) ;
// se deviazione esterna superiore a 30deg, aggiungo anello
// 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)) {
// lunghezza tratti lineari e loro punti estremi
@@ -1941,20 +1829,88 @@ 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 ;
// lunghezza entità
double dLen ; pCrvC->GetLength( dLen) ;
double dAccLen = min( ACC_MAX_LEN, dLen / 2) ;
// Feed minima
const double COEFF_MIN_FEED = 0.5 ;
double dMinFeed = COEFF_MIN_FEED * 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) ;
Point3d ptP ; pCrvC->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP) ;
CalcAndSetToolCorrAuxDir( pCompo, i + dU) ;
SetFeed( ( 1 - dCoeff) * dMinFeed + dCoeff * GetFeed()) ;
if ( AddLinearMove( ptP) == GDB_ID_NULL)
return false ;
}
}
}
// 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)
SetIndex( i + 1 - nIdxSkip) ;
// Recupero versore estrusione
Vector3d vtN ; pCompo->GetExtrusion( vtN) ;
// direzione finale corrente
Vector3d vtEnd ; pCrvC->GetEndDir( vtEnd) ;
// direzione iniziale successiva
const ICurve* pCrvN = pCompo->GetCurve( i + 1) ;
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 ;
// lunghezza entità
double dLen ; pCrvC->GetLength( dLen) ;
double dAccLen = min( ACC_MAX_LEN, dLen / 2) ;
// Feed minima
const double COEFF_MIN_FEED = 0.5 ;
double dMinFeed = COEFF_MIN_FEED * 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) ;
Point3d ptP ; pCrvC->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP) ;
CalcAndSetToolCorrAuxDir( pCompo, i + dU) ;
SetFeed( ( 1 - dCoeff) * GetFeed() + dCoeff * dMinFeed) ;
if ( AddLinearMove( ptP) == GDB_ID_NULL)
return false ;
}
dNextFeed = dMinFeed ;
}
}
// imposto versore correzione e ausiliario del punto di arrivo
CalcAndSetToolCorrAuxDir( pCompo, i+1) ;
CalcAndSetToolCorrAuxDir( pCompo, i + 1) ;
// elaborazioni sulla curva corrente
const double MIN_PROBE_DIST = 90 ;
if ( pCurve->GetType() == CRV_LINE) {
ICurveLine* pLine = GetCurveLine( pCurve) ;
Point3d ptP3 = pLine->GetEnd() ;
SetFeed( GetFeed()) ;
SetFeed( dNextFeed) ;
// controlli per indice del punto di arrivo
if ( SqDistXY( ptP3, m_ptLastProbe) >= MIN_PROBE_DIST * MIN_PROBE_DIST) {
SetIndex( i + 1) ;
SetIndex( i + 1 - nIdxSkip) ;
m_ptLastProbe = ptP3 ;
}
else
++ nIdxSkip ;
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
}
@@ -1964,42 +1920,31 @@ WaterJetting::AddStandardWj( const ICurveComposite* pCompo, const Vector3d& vtTo
double dAngCen = pArc->GetAngCenter() ;
Vector3d vtN = pArc->GetNormVersor() ;
Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
SetFeed( GetFeed()) ;
SetFeed( dNextFeed) ;
// controlli per indice del punto di arrivo
if ( SqDistXY( ptP3, m_ptLastProbe) >= MIN_PROBE_DIST * MIN_PROBE_DIST) {
SetIndex( i + 1) ;
SetIndex( i + 1 - nIdxSkip) ;
m_ptLastProbe = ptP3 ;
}
else
++ nIdxSkip ;
if ( AddArcMove( ptP3, ptCen, dAngCen, vtN) == GDB_ID_NULL)
return false ;
}
// se ultima entità, uscita e retrazione
if ( i == nMaxInd) {
// 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(), vtTool, dEndElev))
dEndElev = dElev ;
Point3d ptEnd ; pCurve->GetEndPoint( ptEnd) ;
Vector3d vtEnd ; pCurve->GetEndDir( vtEnd) ;
// aggiungo uscita
Point3d ptP1 ;
SetFeed( GetEndFeed()) ;
if ( ! AddLeadOut( ptEnd, vtEnd, vtTool, dEndElev, false, pCompo, bSplitArcs, ptP1)) {
SetFeed( GetFeed()) ;
if ( ! AddLeadOut( ptEnd, vtEnd, vtTool, bSplitArcs, ptP1)) {
m_pMchMgr->SetLastError( 3209, "Error in WaterJetting : LeadOut not computable") ;
return false ;
}
// correggo elevazione finale per punto fine uscita (se testa da sopra senza aggregato approccio mai Z-)
if ( vtTool.z < - EPS_SMALL)
dEndElev -= ScalarXY( (ptP1 - ptEnd), vtTool) ;
else
dEndElev -= ( ptP1 - ptEnd) * vtTool ;
// determino se la fine dell'uscita è sopra il grezzo
bool bAboveEnd = GetPointAboveRaw( ptP1) ;
// aggiungo retrazione
if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bAboveEnd)) {
if ( ! AddRetract( ptP1, vtTool, dSafeZ)) {
m_pMchMgr->SetLastError( 3210, "Error in WaterJetting : Retract not computable") ;
return false ;
}
@@ -2034,125 +1979,28 @@ class LeadIOStatus
//----------------------------------------------------------------------------
bool
WaterJetting::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ,
double dElev, double dAppr, bool bOutStart, bool bAboveStart)
WaterJetting::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ)
{
SetFlag( 1) ;
// se non sono già sopra il pezzo e sopra attacco c'è spazio per sicurezza o approccio
double dSafeDist = dSafeZ ;
if ( ! bAboveStart && dElev + max( dSafeDist, dAppr) > 10 * EPS_SMALL) {
// se distanza di sicurezza minore di distanza di inizio
if ( dSafeDist < dAppr + 10 * EPS_SMALL) {
// 1 -> punto sopra inizio
Point3d ptP1 = ptP + vtTool * ( dElev + dAppr) ;
if ( AddRapidStart( ptP1) == GDB_ID_NULL)
return false ;
}
else {
// 1a -> punto sopra inizio
Point3d ptP1b = ptP + vtTool * ( dElev + dAppr) ;
Point3d ptP1a = ptP1b + vtTool * ( dSafeDist - dAppr) ;
if ( AddRapidStart( ptP1a) == GDB_ID_NULL)
return false ;
// 1b -> punto appena sopra inizio
if ( ( dElev + dAppr) > EPS_SMALL) {
SetFlag( 0) ;
if ( AddRapidMove( ptP1b) == GDB_ID_NULL)
return false ;
}
}
// affondo al punto iniziale
SetFlag( 0) ;
SetFeed( bOutStart ? GetStartFeed() : GetTipFeed()) ;
if ( AddLinearMove( ptP) == GDB_ID_NULL)
return false ;
}
// sono sopra il pezzo ma non abbastanza
else if ( bAboveStart && ( dElev + dAppr) > 10 * EPS_SMALL) {
// 1b -> punto appena sopra inizio (in Z globale)
Point3d ptP1b = ptP + Z_AX * ( dElev + dAppr) ;
if ( AddRapidStart( ptP1b) == GDB_ID_NULL)
return false ;
// affondo al punto iniziale
SetFlag( 0) ;
SetFeed( bOutStart ? GetStartFeed() : GetTipFeed()) ;
if ( AddLinearMove( ptP) == GDB_ID_NULL)
return false ;
}
// altrimenti
else {
// affondo diretto al punto iniziale
if ( AddRapidStart( ptP) == GDB_ID_NULL)
return false ;
SetFlag( 0) ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
WaterJetting::AddDirectApproach( const Point3d& ptP)
{
SetFlag( 1) ;
// affondo diretto al punto iniziale
// 1 -> punto sopra inizio
Point3d ptP1 = ptP + vtTool * dSafeZ ;
if ( AddRapidStart( ptP1) == GDB_ID_NULL)
return false ;
// affondo al punto iniziale
SetFlag( 0) ;
if ( AddRapidMove( ptP) == GDB_ID_NULL)
return false ;
SetFlag( 0) ;
return true ;
}
//----------------------------------------------------------------------------
bool
WaterJetting::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ,
double dElev, double dAppr, bool bAboveEnd)
WaterJetting::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ)
{
// se non sono già sopra il pezzo e sopra uscita c'è spazio per sicurezza o approccio
double dSafeDist = dSafeZ ;
if ( ! bAboveEnd && dElev + max( dSafeDist, dAppr) > 10 * EPS_SMALL) {
if ( dSafeDist < dAppr + 10 * EPS_SMALL) {
// 4 -> movimento di risalita sopra il punto finale
SetFeed( GetEndFeed()) ;
Point3d ptP4 = ptP + vtTool * ( dElev + dAppr) ;
if ( AddLinearMove( ptP4) == GDB_ID_NULL)
return false ;
}
else {
// 4a -> movimento di risalita appena sopra il punto finale
Point3d ptP4a = ptP + vtTool * ( dElev + dAppr) ;
if ( dElev + dAppr > EPS_SMALL) {
SetFeed( GetEndFeed()) ;
if ( AddLinearMove( ptP4a) == GDB_ID_NULL)
return false ;
}
// 4b -> movimento di risalita sopra il punto finale
Point3d ptP4b = ptP4a + vtTool * ( dSafeDist - dAppr) ;
if ( AddRapidMove( ptP4b) == GDB_ID_NULL)
return false ;
}
}
// sono sopra il pezzo ma non abbastanza
else if ( bAboveEnd && ( dElev + dAppr) > 10 * EPS_SMALL) {
if ( dSafeDist < dAppr + 10 * EPS_SMALL) {
// 4 -> movimento di risalita sopra il punto finale
SetFeed( GetEndFeed()) ;
Point3d ptP4 = ptP + Z_AX * ( dElev + dAppr) ;
if ( AddLinearMove( ptP4) == GDB_ID_NULL)
return false ;
}
else {
// 4a -> movimento di risalita appena sopra il punto finale
Point3d ptP4a = ptP + Z_AX * ( dElev + dAppr) ;
if ( dElev + dAppr > EPS_SMALL) {
SetFeed( GetEndFeed()) ;
if ( AddLinearMove( ptP4a) == GDB_ID_NULL)
return false ;
}
// 4b -> movimento di risalita sopra il punto finale
Point3d ptP4b = ptP4a + Z_AX * ( dSafeDist - dAppr) ;
if ( AddRapidMove( ptP4b) == GDB_ID_NULL)
return false ;
}
}
// Risalgo in rapido alla quota di sicurezza
Point3d ptP4 = ptP + vtTool * dSafeZ ;
if ( AddRapidMove( ptP4) == GDB_ID_NULL)
return false ;
return true ;
}
@@ -2169,30 +2017,14 @@ WaterJetting::GetLeadInType( void) const
//----------------------------------------------------------------------------
bool
WaterJetting::CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtN,
double dStElev, bool bInvert, const ICurveComposite* pCompo, Point3d& ptP1) const
const ICurveComposite* pCompo, Point3d& ptP1) const
{
// Assegno tipo e parametri
int nType = GetLeadInType() ;
double dTang = m_Params.m_dLiTang ;
double dPerp = m_Params.m_dLiPerp ;
double dElev = min( m_Params.m_dLiElev, dStElev + LIO_ELEV_TOL) ;
// se step invertito
if ( bInvert) {
switch ( m_Params.m_nLeadOutType) {
case WJET_LO_LINEAR : nType = WJET_LI_LINEAR ; break ;
case WJET_LO_TANGENT : nType = WJET_LI_TANGENT ; break ;
case WJET_LO_AS_LI : /* resta inalterato */ ; break ;
default : nType = WJET_LI_NONE ; break ;
}
if ( m_Params.m_nLeadOutType != WJET_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
bool bCcwRot = (( ! bInvert && m_Params.m_nWorkSide == WJET_WS_LEFT) ||
( bInvert && m_Params.m_nWorkSide != WJET_WS_LEFT)) ;
bool bCcwRot = ( m_Params.m_nWorkSide == WJET_WS_LEFT) ;
// Calcolo punto iniziale
switch ( nType) {
case WJET_LI_NONE :
@@ -2202,7 +2034,7 @@ WaterJetting::CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtStart,
case WJET_LI_TANGENT : {
Vector3d vtPerp = vtStart ;
vtPerp.Rotate( vtN, 0, ( bCcwRot ? 1 : - 1)) ;
ptP1 = ptStart - vtStart * dTang + vtPerp * dPerp + vtN * dElev ;
ptP1 = ptStart - vtStart * dTang + vtPerp * dPerp ;
return true ;
}
default :
@@ -2213,22 +2045,11 @@ WaterJetting::CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtStart,
//----------------------------------------------------------------------------
bool
WaterJetting::AddLeadIn( const Point3d& ptP1, const Point3d& ptStart, const Vector3d& vtStart,
const Vector3d& vtN, bool bInvert, const ICurveComposite* pCompo, bool bSplitArcs)
const Vector3d& vtN, bool bSplitArcs)
{
// Assegno il tipo
int nType = GetLeadInType() ;
double dTang = m_Params.m_dLiTang ;
// se step invertito
if ( bInvert) {
switch ( GetLeadOutType()) {
case WJET_LO_LINEAR : nType = WJET_LI_LINEAR ; break ;
case WJET_LO_TANGENT : nType = WJET_LI_TANGENT ; break ;
case WJET_LO_AS_LI : /* resta inalterato */ ; break ;
default : nType = WJET_LI_NONE ; break ;
}
if ( m_Params.m_nLeadOutType != WJET_LO_AS_LI)
dTang = m_Params.m_dLoTang ;
}
// Eseguo a seconda del tipo
switch ( nType) {
case WJET_LI_NONE :
@@ -2270,16 +2091,15 @@ WaterJetting::GetLeadOutType( void) const
//----------------------------------------------------------------------------
bool
WaterJetting::AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d& vtN, double dEndElev,
bool bInvert, const ICurveComposite* pCompo, bool bSplitArcs, Point3d& ptP1)
WaterJetting::AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d& vtN,
bool bSplitArcs, Point3d& ptP1)
{
// assegno i parametri
int nType = GetLeadOutType() ;
double dTang = m_Params.m_dLoTang ;
double dPerp = m_Params.m_dLoPerp ;
double dElev = min( m_Params.m_dLoElev, dEndElev + LIO_ELEV_TOL) ;
// se uscita come ingresso o step invertito
if ( nType == WJET_LO_AS_LI || bInvert) {
// se uscita come ingresso
if ( nType == WJET_LO_AS_LI) {
int nLiType = GetLeadInType() ;
switch ( nLiType) {
case WJET_LI_LINEAR : nType = WJET_LO_LINEAR ; break ;
@@ -2288,11 +2108,9 @@ WaterJetting::AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vec
}
dTang = m_Params.m_dLiTang ;
dPerp = m_Params.m_dLiPerp ;
dElev = min( m_Params.m_dLiElev, dEndElev + LIO_ELEV_TOL) ;
}
// senso di rotazione da dir tg a dir esterna
bool bCcwRot = (( ! bInvert && m_Params.m_nWorkSide == WJET_WS_LEFT) ||
( bInvert && m_Params.m_nWorkSide != WJET_WS_LEFT)) ;
bool bCcwRot = ( m_Params.m_nWorkSide == WJET_WS_LEFT) ;
// eseguo a seconda del tipo
switch ( nType) {
case WJET_LO_NONE :
@@ -2302,7 +2120,7 @@ WaterJetting::AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vec
{
Vector3d vtPerp = vtEnd ;
vtPerp.Rotate( vtN, 0, ( bCcwRot ? 1 : - 1)) ;
ptP1 = ptEnd + vtEnd * dTang + vtPerp * dPerp + vtN * dElev ;
ptP1 = ptEnd + vtEnd * dTang + vtPerp * dPerp ;
return ( AddLinearMove( ptP1, MCH_CL_LEADOUT) != GDB_ID_NULL) ;
}
case WJET_LO_TANGENT :
@@ -2310,7 +2128,7 @@ WaterJetting::AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vec
// calcolo punto finale dell'uscita
Vector3d vtPerp = vtEnd ;
vtPerp.Rotate( vtN, 0, ( bCcwRot ? 1 : - 1)) ;
ptP1 = ptEnd + vtEnd * dTang + vtPerp * dPerp + vtN * dElev ;
ptP1 = ptEnd + vtEnd * dTang + vtPerp * dPerp ;
// inserisco uscita
PtrOwner<ICurve> pCrv( GetArc2PVN( ptEnd, ptP1, vtEnd, vtN)) ;
if ( IsNull( pCrv))
WaterJetting.h
+7 -16
View File
@@ -80,18 +80,15 @@ class WaterJetting : public Machining
bool AddLeadOutPreview( const ICurveComposite* pCompo, ISurfFlatRegion* pSPV) ;
bool AddLoopsPreview( const ICurveComposite* pCompo, ISurfFlatRegion* pSPV) ;
bool AddStandardWj( const ICurveComposite* pCompo, const Vector3d& vtTool,
double dDepth, double dElev, bool bSplitArcs) ;
bool AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ,
double dElev, double dAppr, bool bOutStart, bool bAboveStart) ;
bool AddDirectApproach( const Point3d& ptP) ;
bool AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ,
double dElev, double dAppr, bool bAboveEnd) ;
double dRbDist, double dElev, bool bSplitArcs) ;
bool AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ) ;
bool AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ) ;
bool CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtN,
double dStElev, bool bInvert, const ICurveComposite* pCompo, Point3d& ptP1) const ;
const ICurveComposite* pCompo, Point3d& ptP1) const ;
bool AddLeadIn( const Point3d& ptP1, const Point3d& ptStart, const Vector3d& vtStart,
const Vector3d& vtN, bool bInvert, const ICurveComposite* pCompo, bool bSplitArcs) ;
bool AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d& vtN, double dEndElev,
bool bInvert, const ICurveComposite* pCompo, bool bSplitArcs, Point3d& ptP1) ;
const Vector3d& vtN, bool bSplitArcs) ;
bool AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d& vtN,
bool bSplitArcs, Point3d& ptP1) ;
double GetRadiusForStartEndElevation( void) const ;
bool GetPointOutOfRaw( const Point3d& ptP, const Vector3d& vtTool, double dElev) const ;
bool GetPointAboveRaw( const Point3d& ptP) const ;
@@ -105,14 +102,8 @@ class WaterJetting : public Machining
{ return ( IsNullAngValue( m_Params.m_dSpeed) ? m_TParams.m_dSpeed : m_Params.m_dSpeed) ; }
double GetFeed() const
{ return ( IsNullLenValue( m_Params.m_dFeed) ? m_TParams.m_dFeed : m_Params.m_dFeed) ; }
double GetStartFeed() const
{ return ( IsNullLenValue( m_Params.m_dStartFeed) ? m_TParams.m_dStartFeed : m_Params.m_dStartFeed) ; }
double GetEndFeed() const
{ return ( IsNullLenValue( m_Params.m_dEndFeed) ? m_TParams.m_dEndFeed : m_Params.m_dEndFeed) ; }
double GetTipFeed() const
{ return ( IsNullLenValue( m_Params.m_dTipFeed) ? m_TParams.m_dTipFeed : m_Params.m_dTipFeed) ; }
double GetOffsL() const
{ return ( IsUnknownValue( m_Params.m_dOffsL) ? m_TParams.m_dOffsL : m_Params.m_dOffsL) ; }
double GetOffsR() const
{ return ( IsUnknownValue( m_Params.m_dOffsR) ? m_TParams.m_dOffsR : m_Params.m_dOffsR) ; }
int GetLeadInType( void) const ;
WaterJettingData.cpp
+14 -103
View File
@@ -28,30 +28,24 @@ using namespace std ;
enum nWaterJetting {
KEY_AB = 0,
KEY_AI,
KEY_DH,
KEY_EAL,
KEY_F,
KEY_FE,
KEY_FS,
KEY_FT,
KEY_INV,
KEY_LICL,
KEY_LIEL,
KEY_LIHR,
KEY_LIPR,
KEY_LITG,
KEY_LITY,
KEY_LOCL,
KEY_LOEL,
KEY_LOPR,
KEY_LOTG,
KEY_LOTY,
KEY_NAME,
KEY_NNS,
KEY_NNU,
KEY_OL,
KEY_OR,
KEY_OVL,
KEY_PS,
KEY_S,
KEY_SA,
KEY_SAL,
@@ -65,30 +59,24 @@ enum nWaterJetting {
static const std::array<std::string,KEY_ZZZ> sWaterJettingKey = {
"AB",
"AI",
"DH",
"EAL",
"F",
"FE",
"FS",
"FT",
"INV",
"LICL",
"LIEL",
"LIHR",
"LIPR",
"LITG",
"LITY",
"LOCL",
"LOEL",
"LOPR",
"LOTG",
"LOTY",
"NAME",
"NNS",
"NNU",
"OL",
"OR",
"OVL",
"PS",
"S",
"SA",
"SAL",
@@ -138,15 +126,10 @@ WaterJettingData::CopyFrom( const MachiningData* pMdata)
m_nSolCh = pSdata->m_nSolCh ;
m_dSpeed = pSdata->m_dSpeed ;
m_dFeed = pSdata->m_dFeed ;
m_dEndFeed = pSdata->m_dEndFeed ;
m_dStartFeed = pSdata->m_dStartFeed ;
m_dTipFeed = pSdata->m_dTipFeed ;
m_dOffsL = pSdata->m_dOffsL ;
m_dOffsR = pSdata->m_dOffsR ;
m_bInvert = pSdata->m_bInvert ;
m_nWorkSide = pSdata->m_nWorkSide ;
m_sDepth = pSdata->m_sDepth ;
m_dStartPos = pSdata->m_dStartPos ;
m_dOverlap = pSdata->m_dOverlap ;
m_dSideAngle = pSdata->m_dSideAngle ;
m_dStartAddLen = pSdata->m_dStartAddLen ;
@@ -154,12 +137,11 @@ WaterJettingData::CopyFrom( const MachiningData* pMdata)
m_nLeadInType = pSdata->m_nLeadInType ;
m_dLiTang = pSdata->m_dLiTang ;
m_dLiPerp = pSdata->m_dLiPerp ;
m_dLiElev = pSdata->m_dLiElev ;
m_dLiCompLen = pSdata->m_dLiCompLen ;
m_dLiHoleRad = pSdata->m_dLiHoleRad ;
m_nLeadOutType = pSdata->m_nLeadOutType ;
m_dLoTang = pSdata->m_dLoTang ;
m_dLoPerp = pSdata->m_dLoPerp ;
m_dLoElev = pSdata->m_dLoElev ;
m_dLoCompLen = pSdata->m_dLoCompLen ;
m_sSysNotes = pSdata->m_sSysNotes ;
m_sUserNotes = pSdata->m_sUserNotes ;
@@ -187,15 +169,10 @@ WaterJettingData::SameAs( const MachiningData* pMdata) const
m_nSolCh == pSdata->m_nSolCh &&
abs( m_dSpeed - pSdata->m_dSpeed) < EPS_MACH_ANG_PAR &&
abs( m_dFeed - pSdata->m_dFeed) < EPS_MACH_LEN_PAR &&
abs( m_dEndFeed - pSdata->m_dEndFeed) < EPS_MACH_LEN_PAR &&
abs( m_dStartFeed - pSdata->m_dStartFeed) < EPS_MACH_LEN_PAR &&
abs( m_dTipFeed - pSdata->m_dTipFeed) < EPS_MACH_LEN_PAR &&
abs( m_dOffsL - pSdata->m_dOffsL) < EPS_MACH_LEN_PAR &&
abs( m_dOffsR - pSdata->m_dOffsR) < EPS_MACH_LEN_PAR &&
m_bInvert == pSdata->m_bInvert &&
m_nWorkSide == pSdata->m_nWorkSide &&
m_sDepth == pSdata->m_sDepth &&
abs( m_dStartPos - pSdata->m_dStartPos) < EPS_MACH_LEN_PAR &&
abs( m_dOverlap - pSdata->m_dOverlap) < EPS_MACH_LEN_PAR &&
abs( m_dSideAngle - pSdata->m_dSideAngle) < EPS_MACH_ANG_PAR &&
abs( m_dStartAddLen - pSdata->m_dStartAddLen) < EPS_MACH_LEN_PAR &&
@@ -203,12 +180,11 @@ WaterJettingData::SameAs( const MachiningData* pMdata) const
m_nLeadInType == pSdata->m_nLeadInType &&
abs( m_dLiTang - pSdata->m_dLiTang) < EPS_MACH_LEN_PAR &&
abs( m_dLiPerp - pSdata->m_dLiPerp) < EPS_MACH_LEN_PAR &&
abs( m_dLiElev - pSdata->m_dLiElev) < EPS_MACH_LEN_PAR &&
abs( m_dLiCompLen - pSdata->m_dLiCompLen) < EPS_MACH_LEN_PAR &&
abs( m_dLiHoleRad - pSdata->m_dLiHoleRad) < EPS_MACH_LEN_PAR &&
m_nLeadOutType == pSdata->m_nLeadOutType &&
abs( m_dLoTang - pSdata->m_dLoTang) < EPS_MACH_LEN_PAR &&
abs( m_dLoPerp - pSdata->m_dLoPerp) < EPS_MACH_LEN_PAR &&
abs( m_dLoElev - pSdata->m_dLoElev) < EPS_MACH_LEN_PAR &&
abs( m_dLoCompLen - pSdata->m_dLoCompLen) < EPS_MACH_LEN_PAR &&
m_sSysNotes == pSdata->m_sSysNotes &&
m_sUserNotes == pSdata->m_sUserNotes) ;
@@ -256,23 +232,12 @@ WaterJettingData::FromString( const string& sString, int& nKey)
case KEY_AI :
m_sInitAngs = sVal ;
break ;
case KEY_DH :
m_sDepth = sVal ;
if ( m_sDepth.empty())
m_sDepth = "0" ;
break ;
case KEY_EAL :
bOk = ::FromString( sVal, m_dEndAddLen) ;
break ;
case KEY_F :
bOk = ::FromString( sVal, m_dFeed) ;
break ;
case KEY_FE :
bOk = ::FromString( sVal, m_dEndFeed) ;
break ;
case KEY_FS :
bOk = ::FromString( sVal, m_dStartFeed) ;
break ;
case KEY_FT :
bOk = ::FromString( sVal, m_dTipFeed) ;
break ;
@@ -282,8 +247,8 @@ WaterJettingData::FromString( const string& sString, int& nKey)
case KEY_LICL :
bOk = ::FromString( sVal, m_dLiCompLen) ;
break ;
case KEY_LIEL :
bOk = ::FromString( sVal, m_dLiElev) ;
case KEY_LIHR :
bOk = ::FromString( sVal, m_dLiHoleRad) ;
break ;
case KEY_LIPR :
bOk = ::FromString( sVal, m_dLiPerp) ;
@@ -297,9 +262,6 @@ WaterJettingData::FromString( const string& sString, int& nKey)
case KEY_LOCL :
bOk = ::FromString( sVal, m_dLoCompLen) ;
break ;
case KEY_LOEL :
bOk = ::FromString( sVal, m_dLoElev) ;
break ;
case KEY_LOPR :
bOk = ::FromString( sVal, m_dLoPerp) ;
break ;
@@ -319,18 +281,12 @@ WaterJettingData::FromString( const string& sString, int& nKey)
case KEY_NNU :
m_sUserNotes = sVal ;
break ;
case KEY_OL :
bOk = ::FromString( sVal, m_dOffsL) ;
break ;
case KEY_OR :
bOk = ::FromString( sVal, m_dOffsR) ;
break ;
case KEY_OVL :
bOk = ::FromString( sVal, m_dOverlap) ;
break ;
case KEY_PS :
bOk = ::FromString( sVal, m_dStartPos) ;
break ;
case KEY_S :
bOk = ::FromString( sVal, m_dSpeed) ;
break ;
@@ -369,30 +325,24 @@ WaterJettingData::ToString( int nInd) const
switch ( nInd) {
case KEY_AB : return ( sWaterJettingKey[KEY_AB] + "=" + m_sBlockedAxis) ;
case KEY_AI : return ( sWaterJettingKey[KEY_AI] + "=" + m_sInitAngs) ;
case KEY_DH : return ( sWaterJettingKey[KEY_DH] + "=" + m_sDepth) ;
case KEY_EAL : return ( sWaterJettingKey[KEY_EAL] + "=" + ::ToString( m_dEndAddLen)) ;
case KEY_F : return ( sWaterJettingKey[KEY_F] + "=" + ::ToString( m_dFeed)) ;
case KEY_FE : return ( sWaterJettingKey[KEY_FE] + "=" + ::ToString( m_dEndFeed)) ;
case KEY_FS : return ( sWaterJettingKey[KEY_FS] + "=" + ::ToString( m_dStartFeed)) ;
case KEY_FT : return ( sWaterJettingKey[KEY_FT] + "=" + ::ToString( m_dTipFeed)) ;
case KEY_INV : return ( sWaterJettingKey[KEY_INV] + "=" + ::ToString( m_bInvert)) ;
case KEY_LICL : return ( sWaterJettingKey[KEY_LICL] + "=" + ::ToString( m_dLiCompLen)) ;
case KEY_LIEL : return ( sWaterJettingKey[KEY_LIEL] + "=" + ::ToString( m_dLiElev)) ;
case KEY_LIHR : return ( sWaterJettingKey[KEY_LIHR] + "=" + ::ToString( m_dLiHoleRad)) ;
case KEY_LIPR : return ( sWaterJettingKey[KEY_LIPR] + "=" + ::ToString( m_dLiPerp)) ;
case KEY_LITG : return ( sWaterJettingKey[KEY_LITG] + "=" + ::ToString( m_dLiTang)) ;
case KEY_LITY : return ( sWaterJettingKey[KEY_LITY] + "=" + ::ToString( m_nLeadInType)) ;
case KEY_LOCL : return ( sWaterJettingKey[KEY_LOCL] + "=" + ::ToString( m_dLoCompLen)) ;
case KEY_LOEL : return ( sWaterJettingKey[KEY_LOEL] + "=" + ::ToString( m_dLoElev)) ;
case KEY_LOPR : return ( sWaterJettingKey[KEY_LOPR] + "=" + ::ToString( m_dLoPerp)) ;
case KEY_LOTG : return ( sWaterJettingKey[KEY_LOTG] + "=" + ::ToString( m_dLoTang)) ;
case KEY_LOTY : return ( sWaterJettingKey[KEY_LOTY] + "=" + ::ToString( m_nLeadOutType)) ;
case KEY_NAME : return ( sWaterJettingKey[KEY_NAME] + "=" + m_sName) ;
case KEY_NNS : return ( sWaterJettingKey[KEY_NNS] + "=" + m_sSysNotes) ;
case KEY_NNU : return ( sWaterJettingKey[KEY_NNU] + "=" + m_sUserNotes) ;
case KEY_OL : return ( sWaterJettingKey[KEY_OL] + "=" + ::ToString( m_dOffsL)) ;
case KEY_OR : return ( sWaterJettingKey[KEY_OR] + "=" + ::ToString( m_dOffsR)) ;
case KEY_OVL : return ( sWaterJettingKey[KEY_OVL] + "=" + ::ToString( m_dOverlap)) ;
case KEY_PS : return ( sWaterJettingKey[KEY_PS] + "=" + ::ToString( m_dStartPos)) ;
case KEY_S : return ( sWaterJettingKey[KEY_S] + "=" + ::ToString( m_dSpeed)) ;
case KEY_SA : return ( sWaterJettingKey[KEY_SA] + "=" + ::ToString( m_dSideAngle)) ;
case KEY_SAL : return ( sWaterJettingKey[KEY_SAL] + "=" + ::ToString( m_dStartAddLen)) ;
@@ -446,7 +396,7 @@ WaterJettingData::VerifyLeadOutType( int nVal) const
bool
WaterJettingData::VerifySideAngle( double dVal) const
{
const double MAX_SIDE_ANG = 75.0 + EPS_ANG_SMALL ;
const double MAX_SIDE_ANG = 60.0 + EPS_ANG_SMALL ;
const double AUTO_SIDE_ANG = 99 ;
return ( ( dVal > - MAX_SIDE_ANG && dVal < MAX_SIDE_ANG) || abs( dVal - AUTO_SIDE_ANG) < EPS_ANG_SMALL) ;
}
@@ -527,30 +477,15 @@ WaterJettingData::SetParam( int nType, double dVal)
case MPA_FEED :
m_dFeed = dVal ;
return true ;
case MPA_STARTFEED :
m_dStartFeed = dVal ;
return true ;
case MPA_ENDFEED :
m_dEndFeed = dVal ;
return true ;
case MPA_TIPFEED :
m_dTipFeed = dVal ;
return true ;
case MPA_OFFSL :
m_dOffsL = dVal ;
return true ;
case MPA_OFFSR :
m_dOffsR = dVal ;
return true ;
case MPA_DEPTH :
m_sDepth = ::ToString( dVal) ;
return true ;
case MPA_OVERL :
m_dOverlap = dVal ;
return true ;
case MPA_STARTPOS :
m_dStartPos = dVal ;
return true ;
case MPA_SIDEANGLE :
if ( ! VerifySideAngle( dVal))
return false ;
@@ -568,21 +503,18 @@ WaterJettingData::SetParam( int nType, double dVal)
case MPA_LIPERP :
m_dLiPerp = dVal ;
return true ;
case MPA_LIELEV :
m_dLiElev = dVal ;
return true ;
case MPA_LICOMPLEN :
m_dLiCompLen = dVal ;
return true ;
case MPA_LIHOLERAD :
m_dLiHoleRad = dVal ;
return true ;
case MPA_LOTANG :
m_dLoTang = dVal ;
return true ;
case MPA_LOPERP :
m_dLoPerp = dVal ;
return true ;
case MPA_LOELEV :
m_dLoElev = dVal ;
return true ;
case MPA_LOCOMPLEN :
m_dLoCompLen = dVal ;
return true ;
@@ -601,9 +533,6 @@ WaterJettingData::SetParam( int nType, const string& sVal)
case MPA_TOOL :
m_sToolName = sVal ;
return true ;
case MPA_DEPTH_STR :
m_sDepth = sVal ;
return true ;
case MPA_TUUID :
return ::FromString( sVal, m_ToolUuid) ;
case MPA_UUID :
@@ -682,27 +611,15 @@ WaterJettingData::GetParam( int nType, double& dVal) const
case MPA_FEED :
dVal = m_dFeed ;
return true ;
case MPA_STARTFEED :
dVal = m_dStartFeed ;
return true ;
case MPA_ENDFEED :
dVal = m_dEndFeed ;
return true ;
case MPA_TIPFEED :
dVal = m_dTipFeed ;
return true ;
case MPA_OFFSL :
dVal = m_dOffsL ;
return true ;
case MPA_OFFSR :
dVal = m_dOffsR ;
return true ;
case MPA_OVERL :
dVal = m_dOverlap ;
return true ;
case MPA_STARTPOS :
dVal = m_dStartPos ;
return true ;
case MPA_SIDEANGLE :
dVal = m_dSideAngle ;
return true ;
@@ -718,21 +635,18 @@ WaterJettingData::GetParam( int nType, double& dVal) const
case MPA_LIPERP :
dVal = m_dLiPerp ;
return true ;
case MPA_LIELEV :
dVal = m_dLiElev ;
return true ;
case MPA_LICOMPLEN :
dVal = m_dLiCompLen ;
return true ;
case MPA_LIHOLERAD :
dVal = m_dLiHoleRad ;
return true ;
case MPA_LOTANG :
dVal = m_dLoTang ;
return true ;
case MPA_LOPERP :
dVal = m_dLoPerp ;
return true ;
case MPA_LOELEV :
dVal = m_dLoElev ;
return true ;
case MPA_LOCOMPLEN :
dVal = m_dLoCompLen ;
return true ;
@@ -752,9 +666,6 @@ WaterJettingData::GetParam( int nType, string& sVal) const
case MPA_TOOL :
sVal = m_sToolName ;
return true ;
case MPA_DEPTH_STR :
sVal = m_sDepth ;
return true ;
case MPA_TUUID :
sVal = ::ToString( m_ToolUuid) ;
return true ;
WaterJettingData.h
+7 -13
View File
@@ -23,17 +23,12 @@ struct WaterJettingData : public MachiningData
std::string m_sInitAngs ; // angoli iniziali suggeriti (Nome1=val1,Nome2=val2)
std::string m_sBlockedAxis ; // eventuale asse rotante bloccato (Nome=val)
int m_nSolCh ; // criterio scelta soluzione (quando possibili molteplici)
double m_dSpeed ; // velocità di rotazione (+ se CCW, - se CW) ( se 0 da utensile)
double m_dSpeed ; // velocità afflusso abrasivo ( se 0 da utensile)
double m_dFeed ; // velocità di lavorazione normale ( se 0 da utensile)
double m_dStartFeed ; // velocità di lavorazione iniziale ( se 0 da utensile)
double m_dEndFeed ; // velocità di lavorazione finale ( se 0 da utensile)
double m_dTipFeed ; // velocità di lavorazione di testa ( se 0 da utensile)
double m_dOffsR ; // offset radiale ( se UNKNOWN_PAR da utensile)
double m_dOffsL ; // offset longitudinale ( se UNKNOWN_PAR da utensile)
bool m_bInvert ; // flag di inversione direzione lavorazione
int m_nWorkSide ; // lato di lavoro (destra, sinistra, centro)
std::string m_sDepth ; // affondamento (espressione numerica)
double m_dStartPos ; // quota di inizio lavorazione (sempre >= 0)
double m_dOverlap ; // lunghezza di sovrapposizione se percorso chiuso
double m_dSideAngle ; // angolo di sbandamento (0-60deg)
double m_dStartAddLen ; // lunghezza da aggiungere/togliere all'inizio
@@ -41,24 +36,23 @@ struct WaterJettingData : public MachiningData
int m_nLeadInType ; // tipo di attacco (nessuno, lineare, tangente, inseguimento)
double m_dLiTang ; // distanza tangente da inizio attacco
double m_dLiPerp ; // distanza perpendicolare da inizio attacco
double m_dLiElev ; // elevazione da inizio attacco
double m_dLiCompLen ; // lunghezza del tratto di inserimento correttore raggio utensile
double m_dLiHoleRad ; // raggio foro attacco (se 0 non c'è foro)
int m_nLeadOutType ; // tipo di uscita (come attacco, nessuno, lineare, tangente, inseguimento)
double m_dLoTang ; // distanza tangente verso fine uscita
double m_dLoPerp ; // distanza perpendicolare verso fine uscita
double m_dLoElev ; // elevazione verso fine uscita
double m_dLoCompLen ; // lunghezza del tratto di disinserimento correttore raggio utensile
std::string m_sSysNotes ; // note interne
std::string m_sUserNotes ; // note dell'utente
WaterJettingData( void)
: m_ToolUuid(), m_nSolCh( 0), m_dSpeed( 0), m_dFeed( 0), m_dStartFeed( 0), m_dEndFeed( 0), m_dTipFeed( 0),
m_dOffsR( UNKNOWN_PAR), m_dOffsL( UNKNOWN_PAR),
: m_ToolUuid(), m_nSolCh( 0), m_dSpeed( 0), m_dFeed( 0), m_dTipFeed( 0),
m_dOffsR( UNKNOWN_PAR),
m_bInvert( false), m_nWorkSide( 0),
m_dStartPos( 0), m_dOverlap( 0), m_dSideAngle( 0),
m_dOverlap( 0), m_dSideAngle( 0),
m_dStartAddLen( 0), m_dEndAddLen( 0),
m_nLeadInType( 0), m_dLiTang( 0), m_dLiPerp( 0), m_dLiElev( 0), m_dLiCompLen( 0),
m_nLeadOutType( 0), m_dLoTang( 0), m_dLoPerp( 0), m_dLoElev( 0), m_dLoCompLen( 0) {}
m_nLeadInType( 0), m_dLiTang( 0), m_dLiPerp( 0), m_dLiCompLen( 0), m_dLiHoleRad( 0),
m_nLeadOutType( 0), m_dLoTang( 0), m_dLoPerp( 0), m_dLoCompLen( 0) {}
WaterJettingData* Clone( void) const override ;
bool CopyFrom( const MachiningData* pMdata) override ;
bool SameAs(const MachiningData* pMdata) const override ;