From e04a05831eb46573a6ccf449a92a03f9d6338e2b Mon Sep 17 00:00:00 2001 From: Riccardo Elitropi Date: Fri, 23 Jun 2023 08:38:57 +0200 Subject: [PATCH] Revert "Merge commit '994658da167a7ac3f607f4b535a65febe8f308d1' into svuotature" This reverts commit e96f467b56d93494eda59ae5a97a47e33a9a59b1, reversing changes made to ec1ee961bed04d91ffd30331f51c59ebda799318. --- EgtMachKernel.rc | Bin 11774 -> 11774 bytes Milling.cpp | 119 ++++++++++++++++++----------------------------- Milling.h | 5 +- Operation.cpp | 4 +- Pocketing.cpp | 110 ++++++++++++++----------------------------- Pocketing.h | 18 ------- Simulator.cpp | 92 ++++++++++++++---------------------- 7 files changed, 118 insertions(+), 230 deletions(-) diff --git a/EgtMachKernel.rc b/EgtMachKernel.rc index 96f6b682b3d1b49b58b6514fcc1579b513c4e375..a683cea58ef91fdc734591995610349dd386a01a 100644 GIT binary patch delta 121 zcmewt{V#gMH#SyN1|0^|&A-{KnVC}=Oea5-)ZLuM)x!c8zsNNCgkT;*P6$a3MUMyL R=2g-z%(yjz6ex#q0RVNACb$3q delta 121 zcmewt{V#gMH#Sx?1|0^Y&A-{KnVHiVj3z&n)ZLuM)x!c8zsNNCgkT;*P6$a3MUMyL R=2g-z%(yjz6ex#q0RVBQCa3@a diff --git a/Milling.cpp b/Milling.cpp index 41e7ef7..a03406a 100644 --- a/Milling.cpp +++ b/Milling.cpp @@ -45,7 +45,6 @@ using namespace std ; const double OSC_MIN_LEN = 0.1 ; const double ELEV_MAX_OFFS = 25.0 ; const double MIN_SAFEDIST = 5.0 ; -const double LIM_DOWN_APPRZ = - 0.5 ; //------------------------------ Errors -------------------------------------- // 2301 = "Error in Milling : UpdateToolData failed" @@ -2377,12 +2376,8 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo Point3d ptTest = ptP1 - MIN_SAFEDIST * ( m_bAboveHead ? Z_AX : -Z_AX) ; Vector3d vtAppr1 = FromNearestHorizontalOrtho( vtTool, ptP1 - ptStart) ; Vector3d vtAppr2 = ptP1 - ptStart ; - if ( ! vtAppr2.Normalize()) { - if ( ( m_TParams.m_nType & TF_MILL) != 0) - vtAppr2 = -vtStart ; - else - vtAppr2 = CalcCorrDir( pCompo, i) ; - } + if ( ! vtAppr2.Normalize()) + vtAppr2 = CalcCorrDir( pCompo, i) ; double dThick = ( m_TParams.m_nType == TT_MILL_NOTIP ? m_TParams.m_dMaxMat : m_TParams.m_dThick) ; double dSawStartElev1 = -1, dSawStartElev2 = -1 ; GetElevation( m_nPhase, ptTest, vtTool, 0.5 * m_TParams.m_dDiam, dThick, vtAppr1, dSawStartElev1) ; @@ -2409,7 +2404,7 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo bOk = false ; } // aggiungo opportuno approccio - if ( ! AddSawBladeSideApproach( ptP1, vtAppr, vtTool, dSafeZ, dSawStartElev, dStElev, dAppr)) { + if ( ! AddSawBladeSideApproach( ptP1, vtAppr, dSafeZ, dSawStartElev, dAppr)) { m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ; return false ; } @@ -2546,12 +2541,8 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo Point3d ptTest = ptP1 - MIN_SAFEDIST * ( m_bAboveHead ? Z_AX : -Z_AX) ; Vector3d vtRetr1 = FromNearestHorizontalOrtho( vtTool, ptP1 - ptEnd) ; Vector3d vtRetr2 = ptP1 - ptEnd ; - if ( ! vtRetr2.Normalize()) { - if ( ( m_TParams.m_nType & TF_MILL) != 0) - vtRetr2 = vtEnd ; - else - vtRetr2 = CalcCorrDir( pCompo, i + 1) ; - } + if ( ! vtRetr2.Normalize()) + vtRetr2 = CalcCorrDir( pCompo, i + 1) ; double dThick = ( m_TParams.m_nType == TT_MILL_NOTIP ? m_TParams.m_dMaxMat : m_TParams.m_dThick) ; double dSawEndElev1, dSawEndElev2 ; GetElevation( m_nPhase, ptTest, vtTool, 0.5 * m_TParams.m_dDiam, dThick, vtRetr1, dSawEndElev1) ; @@ -2578,7 +2569,7 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo bOk = false ; } // aggiungo opportuna retrazione - if ( ! AddSawBladeSideRetract( ptP1, vtRetr, vtTool, dSafeZ, dSawEndElev, dEndElev, dAppr)) { + if ( ! AddSawBladeSideRetract( ptP1, vtRetr, vtTool, dSafeZ, dSawEndElev, dAppr)) { m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ; return false ; } @@ -2759,7 +2750,7 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool bOk = false ; } // aggiungo opportuno approccio - if ( ! AddSawBladeSideApproach( ptP1, vtAppr, vtTool, dSafeZ, dSawStartElev, dStElev, dAppr)) { + if ( ! AddSawBladeSideApproach( ptP1, vtAppr, dSafeZ, dSawStartElev, dAppr)) { m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ; return false ; } @@ -2924,7 +2915,7 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool bOk = false ; } // aggiungo opportuna retrazione - if ( ! AddSawBladeSideRetract( ptP1, vtRetr, vtTool, dSafeZ, dSawEndElev, dEndElev, dAppr)) { + if ( ! AddSawBladeSideRetract( ptP1, vtRetr, vtTool, dSafeZ, dSawEndElev, dAppr)) { m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ; return false ; } @@ -3220,7 +3211,7 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool bOk = false ; } // aggiungo opportuno approccio - if ( ! AddSawBladeSideApproach( ptP1, vtAppr, vtTool, dSafeZ, dSawStartElev, dStElev, dAppr)) { + if ( ! AddSawBladeSideApproach( ptP1, vtAppr, dSafeZ, dSawStartElev, dAppr)) { m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ; return false ; } @@ -3386,7 +3377,7 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool bOk = false ; } // aggiungo opportuna retrazione - if ( ! AddSawBladeSideRetract( ptP1, vtRetr, vtTool, dSafeZ, dSawEndElev, dEndElev, dAppr)) { + if ( ! AddSawBladeSideRetract( ptP1, vtRetr, vtTool, dSafeZ, dSawEndElev, dAppr)) { m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ; return false ; } @@ -4084,42 +4075,16 @@ Milling::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, //---------------------------------------------------------------------------- bool -Milling::AddSawBladeSideApproach( const Point3d& ptP, const Vector3d& vtAppr, const Vector3d& vtTool, - double dSafeZ, double dSawStElev, double dStElev, double dAppr) +Milling::AddSawBladeSideApproach( const Point3d& ptP, const Vector3d& vtAppr, double dSafeZ, double dStElev, double dAppr) { - // per approccio orizzontale vtAppr deve essere già stato sistemato dal chiamante SetFlag( 1) ; - // 1a -> punto fuori inizio - Point3d ptP1a = ptP + vtAppr * ( dSawStElev + max( dAppr, dSafeZ)) ; - // se necessario ulteriore approccio - if ( ! m_bTiltingTab && vtAppr.z < LIM_DOWN_APPRZ) { - Vector3d vtMove = Vector3d( vtTool.x, vtTool.y, 0) ; - if ( vtMove.Normalize()) { - Point3d ptP1e = ptP1a + vtMove * ( dStElev + dSafeZ) ; - if ( AddRapidStart( ptP1e) == GDB_ID_NULL) - return false ; - SetFlag( 0) ; - if ( AddRapidMove( ptP1a) == GDB_ID_NULL) - return false ; - } - else { - if ( AddRapidStart( ptP1a) == GDB_ID_NULL) - return false ; - } - } - // caso standard - else { - if ( AddRapidStart( ptP1a) == GDB_ID_NULL) - return false ; - } - SetFlag( 0) ; - // 1b -> punto appena sopra inizio (se necessario) - if ( dSafeZ > dAppr + 10 * EPS_SMALL && dSawStElev + dAppr > 10 * EPS_SMALL) { - Point3d ptP1b = ptP + vtAppr * ( dSawStElev + dAppr) ; - if ( AddRapidMove( ptP1b) == GDB_ID_NULL) - return false ; - } + // per approccio orizzontale vtAppr deve essere già stato sistemato dal chiamante + // 1 -> punto fuori inizio + Point3d ptP1 = ptP + vtAppr * ( dStElev + max( dAppr, dSafeZ)) ; + if ( AddRapidStart( ptP1) == GDB_ID_NULL) + return false ; // affondo al punto iniziale in feed + SetFlag( 0) ; SetFeed( GetStartFeed()) ; if ( AddLinearMove( ptP) == GDB_ID_NULL) return false ; @@ -4232,29 +4197,37 @@ Milling::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, //---------------------------------------------------------------------------- bool Milling::AddSawBladeSideRetract( const Point3d& ptP, const Vector3d& vtRetr, const Vector3d& vtTool, - double dSafeZ, double dSawEndElev, double dEndElev, double dAppr) + double dSafeZ, double dEndElev, double dAppr) { // per retrazione orizzontale vtAppr deve essere già stato sistemato dal chiamante - Point3d ptP4 = ptP ; - // se sopra uscita c'è spazio per approccio - if ( dSawEndElev + dAppr > 10 * EPS_SMALL) { - SetFeed( GetEndFeed()) ; - ptP4 = ptP + vtRetr * ( dSawEndElev + dAppr) ; - if ( AddLinearMove( ptP4) == GDB_ID_NULL) - return false ; - } - // se sopra uscita c'è spazio per sicurezza - if ( dSafeZ - dAppr > 10 * EPS_SMALL) { - ptP4 += vtRetr * ( dSafeZ - dAppr) ; - if ( AddRapidMove( ptP4) == GDB_ID_NULL) - return false ; - } - - // se necessaria ulteriore uscita - if ( ! m_bTiltingTab && vtRetr.z < LIM_DOWN_APPRZ) { - Vector3d vtMove = Vector3d( vtTool.x, vtTool.y, 0) ; - if ( vtMove.Normalize()) { - Point3d ptP4b = ptP4 + vtMove * ( dEndElev + dSafeZ) ; + // se sopra uscita c'è spazio per sicurezza o approccio + if ( dEndElev + max( dSafeZ, dAppr) > 10 * EPS_SMALL) { + if ( dSafeZ < dAppr + 10 * EPS_SMALL) { + // 4 -> movimento di risalita sopra il punto finale + SetFeed( GetEndFeed()) ; + Point3d ptP4 = ptP + vtRetr * ( dEndElev + dAppr) ; + if ( AddLinearMove( ptP4) == GDB_ID_NULL) + return false ; + } + else { + // 4a -> movimento di risalita appena sopra il punto finale + Point3d ptP4a = ptP + vtRetr * ( dEndElev + dAppr) ; + if ( dEndElev + dAppr > EPS_SMALL) { + SetFeed( GetEndFeed()) ; + if ( AddLinearMove( ptP4a) == GDB_ID_NULL) + return false ; + } + // 4b -> movimento di risalita sopra il punto finale + Vector3d vtMove = vtRetr ; + double dMove = dSafeZ - dAppr ; + if ( ! m_bTiltingTab && vtRetr.z < sin( -ANG_RIGHT / 2)) { + vtMove = Vector3d( vtTool.x, vtTool.y, 0) ; + if ( vtMove.Normalize()) + dMove = dSafeZ ; + else + vtMove = vtRetr ; + } + Point3d ptP4b = ptP4a + vtMove * dMove ; if ( AddRapidMove( ptP4b) == GDB_ID_NULL) return false ; } diff --git a/Milling.h b/Milling.h index 86b36a3..686c233 100644 --- a/Milling.h +++ b/Milling.h @@ -98,13 +98,12 @@ class Milling : public Machining double dDepth, double dElev, double dOkStep, bool bSplitArcs) ; bool AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ, double dElev, double dAppr, bool bOutStart, bool bAboveStart) ; - bool AddSawBladeSideApproach( const Point3d& ptP, const Vector3d& vtAppr, const Vector3d& vtTool, - double dSafeZ, double dSawStElev, double dStElev, double dAppr) ; + bool AddSawBladeSideApproach( const Point3d& ptP, const Vector3d& vtAppr, double dSafeZ, double dStElev, double dAppr) ; bool AddDirectApproach( const Point3d& ptP) ; bool AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ, double dElev, double dAppr, bool bAboveEnd) ; bool AddSawBladeSideRetract( const Point3d& ptP, const Vector3d& vtRetr, const Vector3d& vtTool, - double dSafeZ, double dSawEndElev, double dEndElev, double dAppr) ; + double dSafeZ, double dEndElev, double dAppr) ; bool CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtTool, double dStElev, bool bInvert, const ICurveComposite* pCompo, Point3d& ptP1) const ; bool AddLeadIn( const Point3d& ptP1, const Point3d& ptStart, const Vector3d& vtStart, diff --git a/Operation.cpp b/Operation.cpp index 497d0b8..bad0fc1 100644 --- a/Operation.cpp +++ b/Operation.cpp @@ -1837,7 +1837,7 @@ Operation::SetBlockedRotAxis( const string& sBlockedAxis) const for ( int i = 0 ; i < nRotAxes && ! bFound ; ++ i) { string sAxToken ; if ( m_pMchMgr->GetCurrMachine()->GetCurrAxisToken( i + nLinAxes, sAxToken) && - sKey == Trim( sAxToken, " \t\r\n=")) { + sKey == Trim( sAxToken)) { string sAxis ; m_pMchMgr->GetCurrMachine()->GetCurrAxisName( i + nLinAxes, sAxis) ; m_pMchMgr->SetRotAxisBlock( sAxis, dVal) ; @@ -1915,7 +1915,7 @@ Operation::CalculateAxesValues( const string& sHint, bool bRotContOnNext, bool b for ( int i = 0 ; i < nRotAxes ; ++ i) { string sAxToken ; if ( m_pMchMgr->GetCurrMachine()->GetCurrAxisToken( nLinAxes + i, sAxToken) && - szKey == Trim( sAxToken, " \t\r\n=")) { + szKey == Trim( sAxToken)) { double dVal ; if ( FromString( szVal, dVal)) { double dOffset = 0 ; diff --git a/Pocketing.cpp b/Pocketing.cpp index a0470cf..c6980bd 100644 --- a/Pocketing.cpp +++ b/Pocketing.cpp @@ -3480,20 +3480,20 @@ Pocketing::OptimizedZigZag( ISurfFlatRegion* pSrf, const Vector3d& vtTool, doubl vpCrvs[0]->GetStartPoint( ptStart) ; Vector3d vtDir ; vpCrvs[0]->GetStartDir( vtDir) ; - Point3d ptTest = ptStart + ( -vtDir) * ( m_TParams.m_dDiam / 2 - dOffs + dSafeZ) ; + Point3d ptTest = ptStart + ( - vtDir) * ( m_TParams.m_dDiam / 2 + dSafeZ) ; ptTest.ToGlob( frPocket) ; ptTest += - vtTool * dDepth ; double dTestElev ; - // se � nel grezzo provo a ruotare di 90 gradi - if ( GetElevation( m_nPhase, ptTest, vtTool, m_TParams.m_dDiam / 2 - dOffs, vtTool, dTestElev) && dTestElev > EPS_SMALL) { + // se è nel grezzo provo a ruotare di 90 gradi + if ( GetElevation( m_nPhase, ptTest, vtTool, m_TParams.m_dDiam / 2, vtTool, dTestElev) && dTestElev > EPS_SMALL) { Vector3d vtDirO = vtDir ; vtDirO.Rotate( Z_AX, ( m_Params.m_bInvert ? -90 : 90)) ; - Point3d ptTestO = ptStart + vtDirO * ( m_TParams.m_dDiam / 2 - dOffs + dSafeZ) ; + Point3d ptTestO = ptStart + vtDirO * ( m_TParams.m_dDiam / 2 + dSafeZ) ; ptTestO.ToGlob( frPocket) ; ptTestO += - vtTool * dDepth ; double dTestElevO ; - // se � fuori dal grezzo uso inizio ruotato - if ( ! GetElevation( m_nPhase, ptTestO, vtTool, m_TParams.m_dDiam / 2 - dOffs, vtTool, dTestElevO) || dTestElevO < EPS_SMALL) { + // se è fuori dal grezzo uso inizio ruotato + if ( ! GetElevation( m_nPhase, ptTestO, vtTool, m_TParams.m_dDiam / 2, vtTool, dTestElevO) || dTestElevO < EPS_SMALL) { Point3d ptNewStart = ptStart + vtDirO ; vpCrvs[0]->AddLine( ptNewStart, false) ; } @@ -3519,14 +3519,14 @@ Pocketing::OptimizedZigZag( ISurfFlatRegion* pSrf, const Vector3d& vtTool, doubl // estendo la fine del percorso if ( ! ( nClosedSides == 3 && bTwoOpposite)) - vpCrvs[0]->ExtendEndByLen( max( m_TParams.m_dDiam / 4 - dOffs, 0.)) ; + vpCrvs[0]->ExtendEndByLen( m_TParams.m_dDiam / 4) ; return true ; } //------------------------------------------------------------------ bool -Pocketing::ZigZagOptimizedNoClosedEdges( ICurveComposite* pCrvPocket, bool& bOptimizedZigZag, Vector3d& vtDir, double& dOffs) +Pocketing::ZigZagOptimizedNoClosedEdges( ICurveComposite* pCrvPocket, bool& bOptimizedZigZag, Vector3d& vtDir) { // individuo il segmento di retta più lungo int nMax = -1 ; @@ -3546,7 +3546,7 @@ Pocketing::ZigZagOptimizedNoClosedEdges( ICurveComposite* pCrvPocket, bool& bOpt pCrvPocket->GetCurve( nMax)->GetStartDir( vtDir) ; // aggiorno pCrvPocket con eventuale offset per regioni residue - if ( ! ZigZagOptimizedComputeOffset( pCrvPocket, vtDir, 0, {}, dOffs)) + if ( ! ZigZagOptimizedComputeOffset( pCrvPocket, vtDir, 0, {})) return true ; bOptimizedZigZag = true ; @@ -3555,7 +3555,7 @@ Pocketing::ZigZagOptimizedNoClosedEdges( ICurveComposite* pCrvPocket, bool& bOpt //------------------------------------------------------------------ bool -Pocketing::ZigZagOptimizedOneClosedEdge( ICurveComposite* pCrvPocket, int nClosedId, bool& bOptimizedZigZag, Vector3d& vtDir, double& dOffs) +Pocketing::ZigZagOptimizedOneClosedEdge( ICurveComposite* pCrvPocket, int nClosedId, bool& bOptimizedZigZag, Vector3d& vtDir) { // verifico che il lato chiuso sia una linea PtrOwner pCrv( CloneCurveLine( pCrvPocket->GetCurve( nClosedId))) ; @@ -3564,7 +3564,7 @@ Pocketing::ZigZagOptimizedOneClosedEdge( ICurveComposite* pCrvPocket, int nClose // aggiorno pCrvPocket con eventuale offset per regioni residue pCrv->GetStartDir( vtDir) ; - if ( ! ZigZagOptimizedComputeOffset( pCrvPocket, vtDir, 1, {nClosedId}, dOffs)) + if ( ! ZigZagOptimizedComputeOffset( pCrvPocket, vtDir, 1, {nClosedId})) return true ; // setto il vettore estrusione per eseguire correttamente offset @@ -3587,7 +3587,7 @@ Pocketing::ZigZagOptimizedOneClosedEdge( ICurveComposite* pCrvPocket, int nClose //------------------------------------------------------------------ bool Pocketing::ZigZagOptimizedTwoClosedEdges( ICurveComposite* pCrvPocket, const INTVECTOR& vnClosedIds, bool& bOptimizedZigZag, - bool& bOpposite, Vector3d& vtDir, double& dOffs) + bool& bOpposite, Vector3d& vtDir) { // verifico che i lati chiusi siano linee PtrOwner pCrv1( CloneCurveLine( pCrvPocket->GetCurve( vnClosedIds[0]))) ; @@ -3638,18 +3638,18 @@ Pocketing::ZigZagOptimizedTwoClosedEdges( ICurveComposite* pCrvPocket, const INT pCrv2->GetStartDir( vtDir) ; // aggiorno pCrvPocket con eventuale offset per regioni residue - if ( ! ZigZagOptimizedComputeOffset( pCrvPocket, vtDir, bOpposite ? 2 : 1, vnClosedIds, dOffs)) + if ( ! ZigZagOptimizedComputeOffset( pCrvPocket, vtDir, bOpposite ? 2 : 1, vnClosedIds)) return true ; - double dMyOffs = m_TParams.m_dDiam / 2 + GetOffsR() - 10 * EPS_SMALL ; - pCrv1->SimpleOffset( -dMyOffs) ; + double dOffs = m_TParams.m_dDiam / 2 + GetOffsR() - 10 * EPS_SMALL ; + pCrv1->SimpleOffset( -dOffs) ; pCrv1->ExtendStartByLen( 300) ; pCrv1->ExtendEndByLen( 300) ; if ( ! CutCurveWithLine( pCrvPocket, pCrv1)) return false ; - // sar� la prima curva del percorso - pCrv2->SimpleOffset( -dMyOffs) ; + // sarà la prima curva del percorso + pCrv2->SimpleOffset( -dOffs) ; pCrv2->ExtendStartByLen( 300) ; pCrv2->ExtendEndByLen( 300) ; if ( ! CutCurveWithLine( pCrvPocket, pCrv2)) @@ -3662,7 +3662,7 @@ Pocketing::ZigZagOptimizedTwoClosedEdges( ICurveComposite* pCrvPocket, const INT //------------------------------------------------------------------ bool Pocketing::ZigZagOptimizedThreeClosedEdges( ICurveComposite* pCrvPocket, const INTVECTOR& vnClosedIds, bool& bOptimizedZigZag, - bool& bOpposite, Vector3d& vtDir, double& dOffs) + bool& bOpposite, Vector3d& vtDir) { // verifico che i lati chiusi siano linee @@ -3700,8 +3700,9 @@ Pocketing::ZigZagOptimizedThreeClosedEdges( ICurveComposite* pCrvPocket, const I double dLen1 ; pCrv1->GetLength( dLen1) ; double dLen2 ; pCrv2->GetLength( dLen2) ; double dLen3 ; pCrv3->GetLength( dLen3) ; - if ( dLen2 > dLen1 && dLen2 > dLen3) { - if ( dLen1 > 1.5 * m_TParams.m_dDiam || dLen3 > 1.5 * m_TParams.m_dDiam) + + if ( dLen2 > dLen1 && dLen2 > dLen3) { + if ( dLen1 > /*1.5 **/ m_TParams.m_dDiam / 2 + 5 * EPS_SMALL || dLen3 > /*1.5 **/ m_TParams.m_dDiam / 2 + 5 * EPS_SMALL) return true ; pCrv2->GetStartDir( vtDir) ; bOpposite = false ; @@ -3715,7 +3716,7 @@ Pocketing::ZigZagOptimizedThreeClosedEdges( ICurveComposite* pCrvPocket, const I // aggiorno pCrvPocket con eventuale offset per regioni residue - if ( ! ZigZagOptimizedComputeOffset( pCrvPocket, vtDir, 1, vnClosedIds, dOffs)) + if ( ! ZigZagOptimizedComputeOffset( pCrvPocket, vtDir, 1, vnClosedIds)) return true ; // setto il vettore estrusione per eseguire correttamente offset @@ -3725,21 +3726,21 @@ Pocketing::ZigZagOptimizedThreeClosedEdges( ICurveComposite* pCrvPocket, const I pCrv2->SetExtrusion( vtExtr) ; pCrv3->SetExtrusion( vtExtr) ; - double dMyOffs = m_TParams.m_dDiam / 2 + GetOffsR() - 10 * EPS_SMALL ; - pCrv1->SimpleOffset( -dMyOffs) ; + double dOffs = m_TParams.m_dDiam / 2 + GetOffsR() - 10 * EPS_SMALL ; + pCrv1->SimpleOffset( - dOffs) ; pCrv1->ExtendStartByLen( 300) ; pCrv1->ExtendEndByLen( 300) ; if ( ! CutCurveWithLine( pCrvPocket, pCrv1)) return false ; - pCrv3->SimpleOffset( -dMyOffs) ; + pCrv3->SimpleOffset( -dOffs) ; pCrv3->ExtendStartByLen( 300) ; pCrv3->ExtendEndByLen( 300) ; if ( ! CutCurveWithLine( pCrvPocket, pCrv3)) return false ; - // sar� la prima curva del percorso - pCrv2->SimpleOffset( -dMyOffs) ; + // sarà la prima curva del percorso + pCrv2->SimpleOffset( -dOffs) ; pCrv2->ExtendStartByLen( 300) ; pCrv2->ExtendEndByLen( 300) ; if ( ! CutCurveWithLine( pCrvPocket, pCrv2)) @@ -3752,54 +3753,15 @@ Pocketing::ZigZagOptimizedThreeClosedEdges( ICurveComposite* pCrvPocket, const I //------------------------------------------------------------------ bool Pocketing::ZigZagOptimizedComputeOffset( ICurveComposite* pCrvPocket, const Vector3d& vtMainDir, int nOffsettedEdgesOnY, - const INTVECTOR& vnClosedIds, double& dOffs) + const INTVECTOR& vnClosedIds) { // ricavo l'estrusione Vector3d vtExtr ; pCrvPocket->GetExtrusion( vtExtr) ; // ricavo la Thickness double dThick ; pCrvPocket->GetThickness( dThick) ; - // verifico se resteranno aree residue e calcolo eventuale offset per pCrvPocket - dOffs = 0 ; - for ( int i = 0 ; i < pCrvPocket->GetCurveCount() ; i ++) { + double dOffs = m_TParams.m_dDiam / 2 + 5 * EPS_SMALL; - double dOffsTmp = 0 ; - double dVal = 0 ; - - if ( pCrvPocket->GetCurve(i)->GetType() == CRV_LINE) { - Vector3d vtDir ; - if ( ! pCrvPocket->GetCurve( i)->GetStartDir( vtDir)) - return false ; - - int nProp ; - pCrvPocket->GetCurveTempProp( i, nProp, 1) ; - double dLen ; - pCrvPocket->GetCurve( i)->GetLength( dLen) ; - - if ( nProp == 1 && dLen > 1000 * EPS_SMALL) { - // gestione speciale se vicino al lato closed - double dCosAlpha = vtMainDir * vtDir ; - if ( abs( dCosAlpha) > EPS_SMALL && abs( dCosAlpha) < 1 - EPS_SMALL) - dOffsTmp = abs( 0.5 * m_TParams.m_dDiam * dCosAlpha) ; - } - else { - double dSinAlpha = ( vtMainDir ^ vtDir).Len() ; - if ( abs( dSinAlpha) > EPS_SMALL) - dVal = ( dYSideStep - 0.5 * m_TParams.m_dDiam) / dSinAlpha - 0.5 * m_TParams.m_dDiam ; - if ( dVal > EPS_SMALL) { - double dCosAlpha = vtMainDir * vtDir ; - dOffsTmp = abs( ( dYSideStep - 0.5 * m_TParams.m_dDiam) * dCosAlpha) ; - } - } - } - if ( dOffsTmp > dOffs) - dOffs = dOffsTmp ; - } - - // aggiusto offset - double dMinOffs = max( 0., 0.5 * m_TParams.m_dDiam - m_Params.m_dSideStep) ; - dOffs = max( dOffs, dMinOffs) ; - if ( dOffs > EPS_SMALL) { // calcolo offset OffsetCurve OffsCrv ; @@ -7701,9 +7663,8 @@ Pocketing::AdjustTrapezoidSpiralForAngles( ICurveComposite* pMCrv, const ICurveC // se il lato opposto a quello di riferimento � chiuso bisogna distinguere i casi else { - bool bStartPnt = false ; if ( ptP2.y < dYCoord) { - bStartPnt = pCompo->AddPoint( ptP2) ; + pCompo->AddPoint( ptP2) ; } else { Vector3d vtDir ; @@ -7711,14 +7672,11 @@ Pocketing::AdjustTrapezoidSpiralForAngles( ICurveComposite* pMCrv, const ICurveC if ( bStart) vtDir.Invert() ; Point3d ptP2N = ptP2 - m_TParams.m_dDiam / 2 * abs( vtDir.x / vtDir.y) * vtDir ; - if ( ptP2N.y < dYCoord) - bStartPnt = pCompo->AddPoint( ptP2N) ; - } - if ( bStartPnt) { - Point3d ptCrv ; - pMCrv->GetStartPoint( ptCrv) ; - pCompo->AddLine( ptCrv) ; + pCompo->AddPoint( ptP2N) ; } + Point3d ptCrv ; + pMCrv->GetStartPoint( ptCrv) ; + pCompo->AddLine( ptCrv) ; } // setto temp prop per ricordare che è curva aggiuntiva per pulire angoli diff --git a/Pocketing.h b/Pocketing.h index bbf83a9..33756af 100644 --- a/Pocketing.h +++ b/Pocketing.h @@ -76,7 +76,6 @@ class Pocketing : public Machining bool Chain( int nGrpDestId) ; bool ProcessPath( int nPathId, int nPvId, int nClId) ; bool CalcRegionElevation( const ICurveComposite* pCompo, const Vector3d& vtTool, double dDepth, double dRad, double& dElev) const ; -<<<<<<< HEAD bool VerifyPathFromBottom( const ISurfFlatRegion* pSrf, const Vector3d& vtTool) ; bool GeneratePocketingPv( int nPathId, const ISurfFlatRegion* pSrfPock) ; @@ -146,23 +145,6 @@ class Pocketing : public Machining bool ZigZagOptimizedComputeOffset( ICurveComposite* pCrvPocket, const Vector3d& vtMainDir, int nOffsettedEdgesOnY, const INTVECTOR& vnClosedIds) ; bool AssignContourToPath( const ICRVCOMPOPOVECTOR& vpCrvs, const Frame3d frPocket, const ISurfFlatRegion* pSrfOffs, ICRVCOMPOPOVECTOR& vAllCrv) ; -======= - bool VerifyPathFromBottom( const ICurveComposite* pCompo, const Vector3d& vtTool) ; - bool GeneratePocketingPv( int nPathId, const ICurveComposite* pCompo) ; - bool AddZigZag( const ICurveComposite* pCompo, const Vector3d& vtTool, const Vector3d& vtExtr, - double dDepth, double dElev, double dOkStep, bool bSplitArcs, int nPathId) ; - bool CalcZigZag( const ICurveComposite* pOffs, ICRVCOMPOPOVECTOR& vpCrvs) ; - bool OptimizedZigZag( int nPathId, const Vector3d& vtTool, double dDepth, double dSafeZ, - Frame3d& frPocket, bool& bOptimizedZigZag, ICRVCOMPOPOVECTOR& vpCrvs, double& dOffs) ; - bool ZigZagOptimizedNoClosedEdges( ICurveComposite* pCrvPocket, bool& bOptimizedZigZag, Vector3d& vtDir, double& dOffs) ; - bool ZigZagOptimizedOneClosedEdge( ICurveComposite* pCrvPocket, int nClosedId, bool& bOptimizedZigZag, Vector3d& vtDir, double& dOffs) ; - bool ZigZagOptimizedTwoClosedEdges( ICurveComposite* pCrvPocket, const INTVECTOR& vnClosedIds, bool& bOptimizedZigZag, - bool& bOpposite, Vector3d& vtDir, double& dOffs) ; - bool ZigZagOptimizedThreeClosedEdges( ICurveComposite* pCrvPocket, const INTVECTOR& vnClosedIds, bool& bOptimizedZigZag, - bool& bOpposite, Vector3d& vtDir, double& dOffs) ; - bool ZigZagOptimizedComputeOffset( ICurveComposite* pCrvPocket, const Vector3d& vtMainDir, int nOffsettedEdgesOnY, - const INTVECTOR& vnClosedIds, double& dOffs) ; ->>>>>>> 994658da167a7ac3f607f4b535a65febe8f308d1 bool CutCurveWithLine( ICurveComposite* pCrvA, const ICurveLine* pCrvB) ; // =================================================================== diff --git a/Simulator.cpp b/Simulator.cpp index 63ced76..dc8c7f8 100644 --- a/Simulator.cpp +++ b/Simulator.cpp @@ -25,11 +25,9 @@ #include "/EgtDev/Include/EGkCDeCylClosedSurfTm.h" #include "/EgtDev/Include/EGkCDeSpheClosedSurfTm.h" #include "/EgtDev/Include/EGkCDeConeFrustumClosedSurfTm.h" -#include "/EgtDev/Include/EGkCDeClosedSurfTmClosedSurfTm.h" #include "/EgtDev/Include/EGkVolZmap.h" #include "/EgtDev/Include/EGkGeoVector3d.h" #include "/EgtDev/Include/EGkStringUtils3d.h" -#include "/EgtDev/Include/EGkSurfLocal.h" #include "/EgtDev/Include/EXeCmdLogOff.h" #include "/EgtDev/Include/EXeConst.h" #include "/EgtDev/Include/EMkToolConst.h" @@ -1355,62 +1353,44 @@ Simulator::ExecCollisionCheck( int& nCdInd, int& nObjInd, int nMoveType) // se utensile attivo su grezzo in lavoro e non è rapido, salto if ( bIsTool && bIsRaw && nMoveType != 0) continue ; + // se riferimento non trovato, si salta + const IGeoFrame3d* pGeoFrame = GetGeoFrame3d( m_pGeomDB->GetGeoObj( m_CollObj[j].nFrameId)) ; + if ( pGeoFrame == nullptr) + continue ; // esecuzione controlli di collisione bool bOk = true ; - // oggetti che richiedono frame associato (Box, Cylinder, Sphere, Cone) - if ( m_CollObj[j].nType != MCH_SIM_COB_POLY) { - // se riferimento non trovato, si salta - const IGeoFrame3d* pGeoFrame = GetGeoFrame3d( m_pGeomDB->GetGeoObj( m_CollObj[j].nFrameId)) ; - if ( pGeoFrame == nullptr) - continue ; - Frame3d frObj = pGeoFrame->GetFrame() ; - if ( ! m_CollObj[j].vtMove.IsSmall()) - frObj.Translate( m_CollObj[j].vtMove.x * frObj.VersX() + - m_CollObj[j].vtMove.y * frObj.VersY() + - m_CollObj[j].vtMove.z * frObj.VersZ()) ; - Frame3d frParent ; m_pGeomDB->GetGlobFrame( m_CollObj[j].nFrameId, frParent) ; - frObj.LocToLoc( frParent, frCd) ; - // controlli di collisione - if ( m_CollObj[j].nType == MCH_SIM_COB_BOX) { - Vector3d vtDiag( m_CollObj[j].dPar1, m_CollObj[j].dPar2, m_CollObj[j].dPar3) ; - if ( pVZM != nullptr) - bOk = pVZM->AvoidBox( frObj, vtDiag, m_dSafeDist) ; - else - bOk = ! CDeBoxClosedSurfTm( frObj, vtDiag, m_dSafeDist, *pSTM) ; - } - else if ( m_CollObj[j].nType == MCH_SIM_COB_CYL) { - if ( pVZM != nullptr) - bOk = pVZM->AvoidCylinder( frObj, m_CollObj[j].dPar1, m_CollObj[j].dPar2, m_dSafeDist) ; - else - bOk = ! CDeCylClosedSurfTm( frObj, m_CollObj[j].dPar1, m_CollObj[j].dPar2, m_dSafeDist, *pSTM) ; - } - else if ( m_CollObj[j].nType == MCH_SIM_COB_SPHE) { - if ( pVZM != nullptr) - bOk = pVZM->AvoidSphere( frObj.Orig(), m_CollObj[j].dPar1, m_dSafeDist) ; - else - bOk = ! CDeSpheClosedSurfTm( frObj.Orig(), m_CollObj[j].dPar1, m_dSafeDist, *pSTM) ; - } - else if ( m_CollObj[j].nType == MCH_SIM_COB_CONE) { - if ( pVZM != nullptr) - bOk = pVZM->AvoidConeFrustum( frObj, m_CollObj[j].dPar1, m_CollObj[j].dPar2, m_CollObj[j].dPar3, m_dSafeDist) ; - else - bOk = ! CDeConeFrustumClosedSurfTm( frObj, m_CollObj[j].dPar1, m_CollObj[j].dPar2, m_CollObj[j].dPar3, m_dSafeDist, *pSTM) ; - } - } - // altrimenti poliedro - else { - SurfLocal SurfLoc( m_pGeomDB, m_CollObj[j].nFrameId, frCd) ; - const ISurfTriMesh* pStmLoc = GetSurfTriMesh( SurfLoc) ; - if ( pStmLoc != nullptr) { - if ( pVZM != nullptr) - bOk = pVZM->AvoidSurfTm( *pStmLoc, m_dSafeDist) ; - else - bOk = ! CDeClosedSurfTmClosedSurfTm( *pStmLoc, *pSTM, m_dSafeDist) ; - } + Frame3d frObj = pGeoFrame->GetFrame() ; + if ( ! m_CollObj[j].vtMove.IsSmall()) + frObj.Translate( m_CollObj[j].vtMove.x * frObj.VersX() + + m_CollObj[j].vtMove.y * frObj.VersY() + + m_CollObj[j].vtMove.z * frObj.VersZ()) ; + Frame3d frParent ; m_pGeomDB->GetGlobFrame( m_CollObj[j].nFrameId, frParent) ; + frObj.LocToLoc( frParent, frCd) ; + if ( m_CollObj[j].nType == MCH_SIM_COB_BOX) { + Vector3d vtDiag( m_CollObj[j].dPar1, m_CollObj[j].dPar2, m_CollObj[j].dPar3) ; + if ( pVZM != nullptr) + bOk = pVZM->AvoidBox( frObj, vtDiag, m_dSafeDist) ; else - bOk = false ; + bOk = ! CDeBoxClosedSurfTm( frObj, vtDiag, m_dSafeDist, *pSTM) ; + } + else if ( m_CollObj[j].nType == MCH_SIM_COB_CYL) { + if ( pVZM != nullptr) + bOk = pVZM->AvoidCylinder( frObj, m_CollObj[j].dPar1, m_CollObj[j].dPar2, m_dSafeDist) ; + else + bOk = ! CDeCylClosedSurfTm( frObj, m_CollObj[j].dPar1, m_CollObj[j].dPar2, m_dSafeDist, *pSTM) ; + } + else if ( m_CollObj[j].nType == MCH_SIM_COB_SPHE) { + if ( pVZM != nullptr) + bOk = pVZM->AvoidSphere( frObj.Orig(), m_CollObj[j].dPar1, m_dSafeDist) ; + else + bOk = ! CDeSpheClosedSurfTm( frObj.Orig(), m_CollObj[j].dPar1, m_dSafeDist, *pSTM) ; + } + else if ( m_CollObj[j].nType == MCH_SIM_COB_CONE) { + if ( pVZM != nullptr) + bOk = pVZM->AvoidConeFrustum( frObj, m_CollObj[j].dPar1, m_CollObj[j].dPar2, m_CollObj[j].dPar3, m_dSafeDist) ; + else + bOk = ! CDeConeFrustumClosedSurfTm( frObj, m_CollObj[j].dPar1, m_CollObj[j].dPar2, m_CollObj[j].dPar3, m_dSafeDist, *pSTM) ; } - // se trovata collisione if ( ! bOk) { nCdInd = i ; nObjInd = j ; @@ -1993,10 +1973,6 @@ Simulator::AddCollisionObj( int nInd, bool bToolOn, int nFrameId, int nType, con if ( ( dPar1 < EPS_SMALL && dPar2 < EPS_SMALL) || dPar3 < EPS_SMALL) return false ; break ; - case MCH_SIM_COB_POLY : - if ( ! ExeSurfIsClosed( nFrameId)) - return false ; - break ; default : return false ; }