From 222db2563a0f54db5b09a31e1ab5ab1d8fa33dde Mon Sep 17 00:00:00 2001 From: Dario Sassi Date: Mon, 21 Oct 2019 05:52:22 +0000 Subject: [PATCH] EgtMachKernel 2.1j5 : - in lavorazione WaterJetting aggiunti rallentamenti su angoli interni - in lavorazione WaterJetting eliminati parametri inutili. --- EgtMachKernel.rc | Bin 11782 -> 11782 bytes WaterJetting.cpp | 462 +++++++++++++------------------------------ WaterJetting.h | 23 +-- WaterJettingData.cpp | 117 ++--------- WaterJettingData.h | 20 +- 5 files changed, 168 insertions(+), 454 deletions(-) diff --git a/EgtMachKernel.rc b/EgtMachKernel.rc index c2469ba560a0265aa9f8ad014a1db3ef0e9d9bb0..46271b26e2afc72fb90fa2d72799309c686a0866 100644 GIT binary patch delta 97 zcmZpRX^YwLhmFy6^ItYwW=7M=j>5W|vxM9jH?QON0rG*u7nvrX5iEd9O=7{OSQ@Kh Hr8(RHQiUK= delta 97 zcmZpRX^YwLhmFx>^ItYwW=50Aj>5W|vxM9jH?QON0rG*u7nvrX5iEd9O=7{OSQ@Kh Hr8(RHQ1Kv2 diff --git a/WaterJetting.cpp b/WaterJetting.cpp index fc9cca7..db0d98d 100644 --- a/WaterJetting.cpp +++ b/WaterJetting.cpp @@ -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 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 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 pCrv( GetArc2PVN( ptEnd, ptP1, vtEnd, vtN)) ; if ( IsNull( pCrv)) diff --git a/WaterJetting.h b/WaterJetting.h index c154946..86360cd 100644 --- a/WaterJetting.h +++ b/WaterJetting.h @@ -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 ; diff --git a/WaterJettingData.cpp b/WaterJettingData.cpp index 38cbddf..8852fe8 100644 --- a/WaterJettingData.cpp +++ b/WaterJettingData.cpp @@ -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 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 ; diff --git a/WaterJettingData.h b/WaterJettingData.h index 953ae4a..3cf56ae 100644 --- a/WaterJettingData.h +++ b/WaterJettingData.h @@ -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 ;