From 3851bdcecb9f141bed56cb53c662992b8527d893 Mon Sep 17 00:00:00 2001 From: DarioS Date: Thu, 8 Jun 2023 08:17:54 +0200 Subject: [PATCH] EgtMachKernel 2.5f1 : - in svuotature modificata gestione lati aperti, ora vengono lavorati con affondo laterali pari al passo di lato. --- EgtMachKernel.rc | Bin 11774 -> 11774 bytes Pocketing.cpp | 99 +++++++++++++++++++++++++++-------------------- Pocketing.h | 12 +++--- 3 files changed, 63 insertions(+), 48 deletions(-) diff --git a/EgtMachKernel.rc b/EgtMachKernel.rc index a683cea58ef91fdc734591995610349dd386a01a..d0ff0ecbac70789dd0f202a692b37a2dba0885d7 100644 GIT binary patch delta 121 zcmewt{V#gMH#Sx?1|0^&&A-{KnVHiV3@1O7)ZLuM)x!c8zsNNCgkT;*P6$a3MUMyL R=2g-z%(yjz6ex#q0RV5MCZGTS delta 121 zcmewt{V#gMH#SyN1|0^|&A-{KnVC}=Oea5-)ZLuM)x!c8zsNNCgkT;*P6$a3MUMyL R=2g-z%(yjz6ex#q0RVNACb$3q diff --git a/Pocketing.cpp b/Pocketing.cpp index 3f76a8d..3499e53 100644 --- a/Pocketing.cpp +++ b/Pocketing.cpp @@ -1994,7 +1994,8 @@ Pocketing::AddZigZag( const ICurveComposite* pCompo, const Vector3d& vtTool, con // verifico se si tratta di caso ottimizzato bool bOptimizedZigZag = false ; bool bOutRawLeadIn = false ; - if ( ! OptimizedZigZag( nPathId, vtTool, dDepth, dSafeZ, frPocket, bOptimizedZigZag, vpCrvs)) + double dOptZigZagOffs ; + if ( ! OptimizedZigZag( nPathId, vtTool, dDepth, dSafeZ, frPocket, bOptimizedZigZag, vpCrvs, dOptZigZagOffs)) return false ; if ( bOptimizedZigZag && ! vpCrvs.empty()) { nOffsCrvNbr = 1 ; @@ -2003,15 +2004,15 @@ Pocketing::AddZigZag( const ICurveComposite* pCompo, const Vector3d& vtTool, con vpCrvs[0]->GetStartPoint( ptStart) ; Vector3d vtDir ; vpCrvs[0]->GetStartDir( vtDir) ; - ptStart += -vtDir * ( m_TParams.m_dDiam / 2 + dSafeZ) ; + ptStart += -vtDir * ( m_TParams.m_dDiam / 2 - dOptZigZagOffs + dSafeZ) ; ptStart.ToGlob( frPocket) ; - ptStart += - vtTool * dDepth ; + ptStart += -vtTool * dDepth ; double dTestElev ; if ( ! GetElevation( m_nPhase, ptStart, vtTool, m_TParams.m_dDiam / 2, vtTool, dTestElev) || dTestElev < EPS_SMALL) bOutRawLeadIn = true ; // sistemo attacco (per essere completamente fuori dal grezzo) if ( bOutRawLeadIn || m_bOpenOutRaw) - vpCrvs[0]->ExtendStartByLen( m_TParams.m_dDiam / 2 + dSafeZ) ; + vpCrvs[0]->ExtendStartByLen( m_TParams.m_dDiam / 2 - dOptZigZagOffs + dSafeZ) ; } // se non ottimizzato e utensile che non lavora di testa poichè ingresso non fuori dal pezzo, errore @@ -2565,7 +2566,7 @@ Pocketing::CalcZigZag( const ICurveComposite* pOffs, //---------------------------------------------------------- bool Pocketing::OptimizedZigZag( int nPathId, const Vector3d& vtTool, double dDepth, double dSafeZ, - Frame3d& frPocket, bool& bOptimizedZigZag, ICRVCOMPOPOVECTOR& vpCrvs) + Frame3d& frPocket, bool& bOptimizedZigZag, ICRVCOMPOPOVECTOR& vpCrvs, double& dOffs) { // recupero la curva originale che delimita la svuotatura int nCrvId = m_pGeomDB->GetFirstInGroup( nPathId) ; @@ -2593,19 +2594,19 @@ Pocketing::OptimizedZigZag( int nPathId, const Vector3d& vtTool, double dDepth, // modifico pCrvPocket per poterla passare a CalcZigZag bool bTwoOpposite ; - Vector3d vtDir ; + Vector3d vtDir ; switch ( nClosedSides) { case 0 : - ZigZagOptimizedNoClosedEdges( pCrvPocket, bOptimizedZigZag, vtDir) ; + ZigZagOptimizedNoClosedEdges( pCrvPocket, bOptimizedZigZag, vtDir, dOffs) ; break ; case 1 : - ZigZagOptimizedOneClosedEdge( pCrvPocket, vnInfoClosed[0], bOptimizedZigZag, vtDir) ; + ZigZagOptimizedOneClosedEdge( pCrvPocket, vnInfoClosed[0], bOptimizedZigZag, vtDir, dOffs) ; break ; case 2 : - ZigZagOptimizedTwoClosedEdges( pCrvPocket, vnInfoClosed, bOptimizedZigZag, bTwoOpposite, vtDir) ; + ZigZagOptimizedTwoClosedEdges( pCrvPocket, vnInfoClosed, bOptimizedZigZag, bTwoOpposite, vtDir, dOffs) ; break ; case 3 : - ZigZagOptimizedThreeClosedEdges( pCrvPocket, vnInfoClosed, bOptimizedZigZag, bTwoOpposite, vtDir) ; + ZigZagOptimizedThreeClosedEdges( pCrvPocket, vnInfoClosed, bOptimizedZigZag, bTwoOpposite, vtDir, dOffs) ; break ; default : bOptimizedZigZag = false ; @@ -2641,20 +2642,20 @@ Pocketing::OptimizedZigZag( int nPathId, const Vector3d& vtTool, double dDepth, vpCrvs[0]->GetStartPoint( ptStart) ; Vector3d vtDir ; vpCrvs[0]->GetStartDir( vtDir) ; - Point3d ptTest = ptStart + ( -vtDir) * ( m_TParams.m_dDiam / 2 + dSafeZ) ; + Point3d ptTest = ptStart + ( -vtDir) * ( m_TParams.m_dDiam / 2 - dOffs + 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, vtTool, dTestElev) && dTestElev > EPS_SMALL) { + if ( GetElevation( m_nPhase, ptTest, vtTool, m_TParams.m_dDiam / 2 - dOffs, 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 + dSafeZ) ; + Point3d ptTestO = ptStart + vtDirO * ( m_TParams.m_dDiam / 2 - dOffs + 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, vtTool, dTestElevO) || dTestElevO < EPS_SMALL) { + if ( ! GetElevation( m_nPhase, ptTestO, vtTool, m_TParams.m_dDiam / 2 - dOffs, vtTool, dTestElevO) || dTestElevO < EPS_SMALL) { Point3d ptNewStart = ptStart + vtDirO ; vpCrvs[0]->AddLine( ptNewStart, false) ; } @@ -2679,15 +2680,15 @@ Pocketing::OptimizedZigZag( int nPathId, const Vector3d& vtTool, double dDepth, } // estendo la fine del percorso - if ( ! ( nClosedSides == 3 && bTwoOpposite)) - vpCrvs[0]->ExtendEndByLen( m_TParams.m_dDiam / 4) ; + if ( ! ( nClosedSides == 3 && bTwoOpposite)) + vpCrvs[0]->ExtendEndByLen( max( m_TParams.m_dDiam / 4 - dOffs, 0.)) ; return true ; } //------------------------------------------------------------------ bool -Pocketing::ZigZagOptimizedNoClosedEdges( ICurveComposite* pCrvPocket, bool& bOptimizedZigZag, Vector3d& vtDir) +Pocketing::ZigZagOptimizedNoClosedEdges( ICurveComposite* pCrvPocket, bool& bOptimizedZigZag, Vector3d& vtDir, double& dOffs) { // individuo il segmento di retta più lungo int nMax = -1 ; @@ -2707,7 +2708,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, {})) + if ( ! ZigZagOptimizedComputeOffset( pCrvPocket, vtDir, 0, {}, dOffs)) return true ; bOptimizedZigZag = true ; @@ -2716,7 +2717,7 @@ Pocketing::ZigZagOptimizedNoClosedEdges( ICurveComposite* pCrvPocket, bool& bOpt //------------------------------------------------------------------ bool -Pocketing::ZigZagOptimizedOneClosedEdge( ICurveComposite* pCrvPocket, int nClosedId, bool& bOptimizedZigZag, Vector3d& vtDir) +Pocketing::ZigZagOptimizedOneClosedEdge( ICurveComposite* pCrvPocket, int nClosedId, bool& bOptimizedZigZag, Vector3d& vtDir, double& dOffs) { // verifico che il lato chiuso sia una linea PtrOwner pCrv( CloneCurveLine( pCrvPocket->GetCurve( nClosedId))) ; @@ -2725,7 +2726,7 @@ Pocketing::ZigZagOptimizedOneClosedEdge( ICurveComposite* pCrvPocket, int nClose // aggiorno pCrvPocket con eventuale offset per regioni residue pCrv->GetStartDir( vtDir) ; - if ( ! ZigZagOptimizedComputeOffset( pCrvPocket, vtDir, 1, {nClosedId})) + if ( ! ZigZagOptimizedComputeOffset( pCrvPocket, vtDir, 1, {nClosedId}, dOffs)) return true ; // setto il vettore estrusione per eseguire correttamente offset @@ -2748,7 +2749,7 @@ Pocketing::ZigZagOptimizedOneClosedEdge( ICurveComposite* pCrvPocket, int nClose //------------------------------------------------------------------ bool Pocketing::ZigZagOptimizedTwoClosedEdges( ICurveComposite* pCrvPocket, const INTVECTOR& vnClosedIds, bool& bOptimizedZigZag, - bool& bOpposite, Vector3d& vtDir) + bool& bOpposite, Vector3d& vtDir, double& dOffs) { // verifico che i lati chiusi siano linee PtrOwner pCrv1( CloneCurveLine( pCrvPocket->GetCurve( vnClosedIds[0]))) ; @@ -2798,18 +2799,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)) + if ( ! ZigZagOptimizedComputeOffset( pCrvPocket, vtDir, bOpposite ? 2 : 1, vnClosedIds, dOffs)) return true ; - double dOffs = m_TParams.m_dDiam / 2 + GetOffsR() - 10 * EPS_SMALL ; - pCrv1->SimpleOffset( -dOffs) ; + double dMyOffs = m_TParams.m_dDiam / 2 + GetOffsR() - 10 * EPS_SMALL ; + pCrv1->SimpleOffset( -dMyOffs) ; pCrv1->ExtendStartByLen( 300) ; pCrv1->ExtendEndByLen( 300) ; if ( ! CutCurveWithLine( pCrvPocket, pCrv1)) return false ; // sarà la prima curva del percorso - pCrv2->SimpleOffset( -dOffs) ; + pCrv2->SimpleOffset( -dMyOffs) ; pCrv2->ExtendStartByLen( 300) ; pCrv2->ExtendEndByLen( 300) ; if ( ! CutCurveWithLine( pCrvPocket, pCrv2)) @@ -2822,7 +2823,7 @@ Pocketing::ZigZagOptimizedTwoClosedEdges( ICurveComposite* pCrvPocket, const INT //------------------------------------------------------------------ bool Pocketing::ZigZagOptimizedThreeClosedEdges( ICurveComposite* pCrvPocket, const INTVECTOR& vnClosedIds, bool& bOptimizedZigZag, - bool& bOpposite, Vector3d& vtDir) + bool& bOpposite, Vector3d& vtDir, double& dOffs) { // verifico che i lati chiusi siano linee PtrOwner pCrv1( CloneCurveLine( pCrvPocket->GetCurve( vnClosedIds[0]))) ; @@ -2859,7 +2860,7 @@ 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 ( dLen2 > dLen1 && dLen2 > dLen3) { if ( dLen1 > 1.5 * m_TParams.m_dDiam || dLen3 > 1.5 * m_TParams.m_dDiam) return true ; pCrv2->GetStartDir( vtDir) ; @@ -2873,7 +2874,7 @@ Pocketing::ZigZagOptimizedThreeClosedEdges( ICurveComposite* pCrvPocket, const I } // aggiorno pCrvPocket con eventuale offset per regioni residue - if ( ! ZigZagOptimizedComputeOffset( pCrvPocket, vtDir, 1, vnClosedIds)) + if ( ! ZigZagOptimizedComputeOffset( pCrvPocket, vtDir, 1, vnClosedIds, dOffs)) return true ; // setto il vettore estrusione per eseguire correttamente offset @@ -2883,21 +2884,21 @@ Pocketing::ZigZagOptimizedThreeClosedEdges( ICurveComposite* pCrvPocket, const I pCrv2->SetExtrusion( vtExtr) ; pCrv3->SetExtrusion( vtExtr) ; - double dOffs = m_TParams.m_dDiam / 2 + GetOffsR() - 10 * EPS_SMALL ; - pCrv1->SimpleOffset( -dOffs) ; + double dMyOffs = m_TParams.m_dDiam / 2 + GetOffsR() - 10 * EPS_SMALL ; + pCrv1->SimpleOffset( -dMyOffs) ; pCrv1->ExtendStartByLen( 300) ; pCrv1->ExtendEndByLen( 300) ; if ( ! CutCurveWithLine( pCrvPocket, pCrv1)) return false ; - pCrv3->SimpleOffset( -dOffs) ; + pCrv3->SimpleOffset( -dMyOffs) ; pCrv3->ExtendStartByLen( 300) ; pCrv3->ExtendEndByLen( 300) ; if ( ! CutCurveWithLine( pCrvPocket, pCrv3)) return false ; // sarà la prima curva del percorso - pCrv2->SimpleOffset( -dOffs) ; + pCrv2->SimpleOffset( -dMyOffs) ; pCrv2->ExtendStartByLen( 300) ; pCrv2->ExtendEndByLen( 300) ; if ( ! CutCurveWithLine( pCrvPocket, pCrv2)) @@ -2910,7 +2911,7 @@ Pocketing::ZigZagOptimizedThreeClosedEdges( ICurveComposite* pCrvPocket, const I //------------------------------------------------------------------ bool Pocketing::ZigZagOptimizedComputeOffset( ICurveComposite* pCrvPocket, const Vector3d& vtMainDir, int nOffsettedEdgesOnY, - const INTVECTOR& vnClosedIds) + const INTVECTOR& vnClosedIds, double& dOffs) { // calcolo il side step che verrà utilizzato in CalcZigZag Frame3d frLoc ; @@ -2937,7 +2938,7 @@ Pocketing::ZigZagOptimizedThreeClosedEdges( ICurveComposite* pCrvPocket, const I } // verifico se resteranno aree residue e calcolo eventuale offset per pCrvPocket - double dOffs = 0 ; + dOffs = 0 ; for ( int i = 0 ; i < pCrvPocket->GetCurveCount() ; i ++) { double dOffsTmp = 0 ; @@ -2972,7 +2973,11 @@ Pocketing::ZigZagOptimizedThreeClosedEdges( ICurveComposite* pCrvPocket, const I 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 ; @@ -3842,7 +3847,10 @@ Pocketing::CalcSpiral( const ICurveComposite* pCompo, int nReg, bool bSplitArcs, vtDir.Normalize() ; Vector3d vtOrtho = OrthoCompo( vtOtherDir, vtDir) ; double dPocketSize = vtOrtho.Len() ; - if ( dPocketSize < m_TParams.m_dDiam + EPS_SMALL) { + double dMaxOptSize ; + FromString( ExtractInfo( m_Params.m_sUserNotes, "MaxOptSize="), dMaxOptSize) ; + if ( dPocketSize < m_TParams.m_dDiam + EPS_SMALL && + ( ! FromString( ExtractInfo( m_Params.m_sUserNotes, "MaxOptSize="), dMaxOptSize) || dPocketSize < dMaxOptSize)) { if ( nReg == 0) { CalcTrapezoidSpiral( pCrvPocket, vtDir, dPocketSize, pMCrv, pRCrv, bOptimizedTrap) ; if ( bOptimizedTrap) @@ -4564,8 +4572,9 @@ 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) { - pCompo->AddPoint( ptP2) ; + bStartPnt = pCompo->AddPoint( ptP2) ; } else { Vector3d vtDir ; @@ -4573,11 +4582,14 @@ Pocketing::AdjustTrapezoidSpiralForAngles( ICurveComposite* pMCrv, const ICurveC if ( bStart) vtDir.Invert() ; Point3d ptP2N = ptP2 - m_TParams.m_dDiam / 2 * abs( vtDir.x / vtDir.y) * vtDir ; - pCompo->AddPoint( ptP2N) ; + if ( ptP2N.y < dYCoord) + bStartPnt = pCompo->AddPoint( ptP2N) ; + } + if ( bStartPnt) { + Point3d ptCrv ; + pMCrv->GetStartPoint( ptCrv) ; + pCompo->AddLine( ptCrv) ; } - Point3d ptCrv ; - pMCrv->GetStartPoint( ptCrv) ; - pCompo->AddLine( ptCrv) ; } // setto temp prop per ricordare che è curva aggiuntiva per pulire angoli @@ -5541,7 +5553,10 @@ Pocketing::AdjustContourWithOpenEdges( ICurveComposite* pCompo) // sposto l'inizio a metà del tratto più lungo AdjustContourStart( pCompo) ; // raggio di riferimento per offset - double dRad = 0.5 * m_TParams.m_dDiam + GetOffsR() ; + double dOutEdge = 0.5 * m_TParams.m_dDiam ; + if ( m_Params.m_nSubType == POCKET_SUB_SPIRALIN || m_Params.m_nSubType == POCKET_SUB_ZIGZAG) + dOutEdge = max( dOutEdge, m_TParams.m_dDiam - m_Params.m_dSideStep) ; + double dRad = dOutEdge + GetOffsR() ; // estraggo parti con proprietà uniforme in un vettore ICURVEPOVECTOR vpCrvs ; int nCurrTempProp ; diff --git a/Pocketing.h b/Pocketing.h index a096a30..db36135 100644 --- a/Pocketing.h +++ b/Pocketing.h @@ -79,15 +79,15 @@ class Pocketing : public Machining 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) ; - bool ZigZagOptimizedNoClosedEdges( ICurveComposite* pCrvPocket, bool& bOptimizedZigZag, Vector3d& vtDir) ; - bool ZigZagOptimizedOneClosedEdge( ICurveComposite* pCrvPocket, int nClosedId, bool& bOptimizedZigZag, Vector3d& vtDir) ; + 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) ; + bool& bOpposite, Vector3d& vtDir, double& dOffs) ; bool ZigZagOptimizedThreeClosedEdges( ICurveComposite* pCrvPocket, const INTVECTOR& vnClosedIds, bool& bOptimizedZigZag, - bool& bOpposite, Vector3d& vtDir) ; + bool& bOpposite, Vector3d& vtDir, double& dOffs) ; bool ZigZagOptimizedComputeOffset( ICurveComposite* pCrvPocket, const Vector3d& vtMainDir, int nOffsettedEdgesOnY, - const INTVECTOR& vnClosedIds) ; + const INTVECTOR& vnClosedIds, double& dOffs) ; bool CutCurveWithLine( ICurveComposite* pCrvA, const ICurveLine* pCrvB) ; bool AddOneWay( const ICurveComposite* pCompo, const Vector3d& vtTool, const Vector3d& vtExtr, double dDepth, double dElev, double dOkStep, bool bSplitArcs) ;