diff --git a/Milling.cpp b/Milling.cpp index ea6577b..61a9c34 100644 --- a/Milling.cpp +++ b/Milling.cpp @@ -83,8 +83,15 @@ Milling::Clone( void) const pMill->m_nPhase = m_nPhase ; pMill->m_Params = m_Params ; pMill->m_TParams = m_TParams ; + pMill->m_dTHoldLen = m_dTHoldLen ; + pMill->m_dTHoldDiam = m_dTHoldDiam ; pMill->m_nStatus = m_nStatus ; pMill->m_nMills = m_nMills ; + pMill->m_bStepOn = m_bStepOn ; + pMill->m_nHeadSolCh = m_nHeadSolCh ; + pMill->m_bTiltingTab = m_bTiltingTab ; + pMill->m_bAboveHead = m_bAboveHead ; + pMill->m_bAggrBottom = m_bAggrBottom ; } catch( ...) { delete pMill ; @@ -202,6 +209,8 @@ Milling::Milling( void) m_nMills = 0 ; m_bStepOn = false ; m_nHeadSolCh = MCH_SCC_NONE ; + m_bTiltingTab = false ; + m_bAboveHead = true ; m_bAggrBottom = false ; } @@ -1397,16 +1406,18 @@ Milling::ProcessPath( int nPathId, int nPvId, int nClId) if ( m_Params.m_bInvert) pCompo->Invert() ; - // recupero estrusione e spessore - Vector3d vtExtr ; - pCompo->GetExtrusion( vtExtr) ; + // recupero direzione utensile da estrusione e spessore + Vector3d vtTool ; + pCompo->GetExtrusion( vtTool) ; + if ( vtTool.IsSmall()) + vtTool = Z_AX ; double dThick ; pCompo->GetThickness( dThick) ; // eventuale inversione direzione utensile if ( m_Params.m_bToolInvert) { - vtExtr.Invert() ; - pCompo->SetExtrusion( vtExtr) ; + vtTool.Invert() ; + pCompo->SetExtrusion( vtTool) ; dThick = - dThick ; pCompo->SetThickness( dThick) ; } @@ -1417,7 +1428,7 @@ Milling::ProcessPath( int nPathId, int nPvId, int nClId) pCompo->GetStartDir( vtStart) ; pCompo->GetEndDir( vtEnd) ; if ( ! AreSameVectorApprox( vtStart, vtEnd)) { - bool bAngCCW = ( ( vtEnd ^ vtStart) * vtExtr > 0.0) ; + bool bAngCCW = ( ( vtEnd ^ vtStart) * vtTool > 0.0) ; if ( m_Params.m_nWorkSide == MILL_WS_CENTER || ( m_Params.m_nWorkSide == MILL_WS_RIGHT && ! bAngCCW) || ( m_Params.m_nWorkSide == MILL_WS_LEFT && bAngCCW)) @@ -1505,7 +1516,7 @@ Milling::ProcessPath( int nPathId, int nPvId, int nClId) // recupero distanza da fondo dei grezzi interessati dal percorso double dRbDist = 0 ; - if ( AreSameVectorApprox( vtExtr, Z_AX)) { + if ( AreSameVectorApprox( vtTool, Z_AX)) { if ( ! GetDistanceFromRawBottom( m_nPhase, nCopyId, m_TParams.m_dTDiam, dRbDist)) return false ; } @@ -1532,8 +1543,8 @@ Milling::ProcessPath( int nPathId, int nPvId, int nClId) // eventuale approssimazione con segmenti di retta int nSplitArcs = m_pMchMgr->GetCurrMachiningsMgr()->GetSplitArcs() ; bool bSplitArcs = ( nSplitArcs == SPLAR_ALWAYS || - ( nSplitArcs == SPLAR_NO_XY_PLANE && ! vtExtr.IsZplus()) || - ( nSplitArcs == SPLAR_GEN_PLANE && vtExtr.IsGeneric())) ; + ( nSplitArcs == SPLAR_NO_XY_PLANE && ! vtTool.IsZplus()) || + ( nSplitArcs == SPLAR_GEN_PLANE && vtTool.IsGeneric())) ; if ( bSplitArcs && ! ApproxWithLines( pCompo)) { m_pMchMgr->SetLastError( 2313, "Error in Milling : Linear Approx not computable") ; return false ; @@ -1542,15 +1553,10 @@ Milling::ProcessPath( int nPathId, int nPvId, int nClId) // verifiche sull'ampiezza dell'angolo al centro degli eventuali archi VerifyArcs( pCompo) ; - // calcolo il versore fresa - Vector3d vtTool = Z_AX ; - if ( ! vtExtr.IsSmall()) - vtTool = vtExtr ; - // calcolo l'elevazione massima double dElev ; if ( CalcPathElevation( pCompo, vtTool, dDepth, 0.5 * m_TParams.m_dDiam, dElev)) { - if ( dElev < EPS_SMALL && AreSameVectorApprox( vtExtr, Z_AX)) { + 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) ; @@ -1648,6 +1654,13 @@ Milling::ProcessPath( int nPathId, int nPvId, int nClId) } } + // verifico se tavola basculante + bool bTiltTab = false ; + m_bTiltingTab = ( m_pMchMgr->GetCurrMachine()->GetCurrTableIsTilting( bTiltTab) && bTiltTab) ; + + // verifico se testa da sopra (Z+) + m_bAboveHead = m_pMchMgr->GetHeadAbove( m_TParams.m_sHead) ; + // verifiche per fresatura dal basso m_bAggrBottom = false ; if ( ! VerifyPathFromBottom( pCompo, vtTool)) @@ -1690,25 +1703,25 @@ Milling::ProcessPath( int nPathId, int nPvId, int nClId) // Se lama con elevazione e step di fianco if ( ( m_TParams.m_nType & TF_SAWBLADE) != 0 && dSideElev > 10 * EPS_SMALL && dOkStep > EPS_SMALL) { m_bStepOn = true ; - if ( ! AddSawZigZagMilling( pCompo, vtTool, vtExtr, dDepth, dSideElev, dOkStep, bSplitArcs)) + if ( ! AddSawZigZagMilling( pCompo, vtTool, dDepth, dSideElev, dOkStep, bSplitArcs)) return false ; } // se altrimenti una sola passata else if ( dOkStep < EPS_SMALL || dOkStep > dElev) { m_bStepOn = false ; - if ( ! AddStandardMilling( pCompo, vtTool, vtExtr, dDepth, dElev, bSplitArcs)) + if ( ! AddStandardMilling( pCompo, vtTool, dDepth, dElev, bSplitArcs)) return false ; } // se altrimenti passate a zig-zag else if ( m_Params.m_nStepType == MILL_ST_ZIGZAG) { m_bStepOn = true ; - if ( ! AddZigZagMilling( pCompo, vtTool, vtExtr, dDepth, dElev, dOkStep, bSplitArcs)) + if ( ! AddZigZagMilling( pCompo, vtTool, dDepth, dElev, dOkStep, bSplitArcs)) return false ; } // se altrimenti passate a one-way else if ( m_Params.m_nStepType == MILL_ST_ONEWAY) { m_bStepOn = true ; - if ( ! AddOneWayMilling( pCompo, vtTool, vtExtr, dDepth, dElev, dOkStep, bSplitArcs)) + if ( ! AddOneWayMilling( pCompo, vtTool, dDepth, dElev, dOkStep, bSplitArcs)) return false ; } // se altrimenti passate a spirale @@ -1719,7 +1732,7 @@ Milling::ProcessPath( int nPathId, int nPvId, int nClId) pCompo->TrimStartAtLen( dAddedOverlap) ; pCompo->Invert() ; } - if ( ! AddSpiralMilling( pCompo, vtTool, vtExtr, dDepth, dElev, dOkStep, bSplitArcs)) + if ( ! AddSpiralMilling( pCompo, vtTool, dDepth, dElev, dOkStep, bSplitArcs)) return false ; } @@ -1853,8 +1866,7 @@ Milling::VerifyPathFromBottom( const ICurveComposite* pCompo, const Vector3d& vt if ( vtTool.z > - 0.5) return true ; // se c'è tavola basculante, esco - bool bTabTilting = false ; - if ( m_pMchMgr->GetCurrMachine()->GetCurrTableIsTilting( bTabTilting) && bTabTilting) + if ( m_bTiltingTab) return true ; // recupero dati di eventuale rinvio da sotto if ( ! GetAggrBottomData( m_TParams.m_sHead, m_AggrBottom) || m_AggrBottom.nType == 0) { @@ -1961,7 +1973,7 @@ Milling::GenerateMillingPv( int nPathId, const ICurveComposite* pCompo) //---------------------------------------------------------------------------- bool -Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTool, const Vector3d& vtExtr, +Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTool, double dDepth, double dElev, bool bSplitArcs) { // recupero distanze di sicurezza @@ -1995,21 +2007,24 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo dStElev = dElev ; // determino inizio attacco Point3d ptP1 ; - if ( ! CalcLeadInStart( ptStart, vtStart, vtExtr, dStElev, false, pCompo, ptP1)) + if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, dStElev, false, pCompo, ptP1)) return false ; // determino se l'inizio dell'attacco è fuori dal grezzo bool bOutStart = GetPointOutOfRaw( ptP1, vtTool) ; // determino se l'inizio dell'attacco è sopra il grezzo - bool bAboveStart = m_pMchMgr->GetHeadAbove( m_TParams.m_sHead) && GetPointAboveRaw( ptP1) ; + bool bAboveStart = m_bAboveHead && GetPointAboveRaw( ptP1) ; // imposto versore correzione e ausiliario sul punto di partenza CalcAndSetCorrAuxDir( pCompo, i) ; // aggiungo approccio per frese normali if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) { - // correggo elevazione iniziale con punto inizio attacco - dStElev -= ( ptP1 - ptStart) * vtExtr ; + // correggo elevazione iniziale per punto inizio attacco (se testa da sopra senza aggregato approccio mai Z-) + if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL) + dStElev -= ScalarXY( (ptP1 - ptStart), vtTool) ; + else + dStElev -= ( ptP1 - ptStart) * vtTool ; // se attacco a zigzag o a spirale, l'elevazione va nell'attacco if ( IsLeadInHelixOrZigzag()) { - ptP1 += vtExtr * ( dStElev + LIO_ELEV_TOL) ; + ptP1 += vtTool * ( dStElev + LIO_ELEV_TOL) ; dStElev = - LIO_ELEV_TOL ; } // approccio al punto iniziale @@ -2032,7 +2047,7 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo } // aggiungo attacco SetFeed( GetStartFeed()) ; - if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtExtr, false, pCompo, bSplitArcs)) { + if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, false, pCompo, bSplitArcs)) { m_pMchMgr->SetLastError( 2310, "Error in Milling : LeadIn not computable") ; return false ; } @@ -2071,16 +2086,19 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo // aggiungo uscita Point3d ptP1 ; SetFeed( GetEndFeed()) ; - if ( ! AddLeadOut( ptEnd, vtEnd, vtExtr, dEndElev, false, pCompo, bSplitArcs, ptP1)) { + if ( ! AddLeadOut( ptEnd, vtEnd, vtTool, dEndElev, false, pCompo, bSplitArcs, ptP1)) { m_pMchMgr->SetLastError( 2311, "Error in Milling : LeadOut not computable") ; return false ; } // aggiungo retrazione per frese normali if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) { - // correggo elevazione finale con punto fine uscita - dEndElev -= ( ptP1 - ptEnd) * vtExtr ; + // correggo elevazione finale per punto fine uscita (se testa da sopra senza aggregato approccio mai Z-) + if ( m_bAboveHead && ! m_bAggrBottom && 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 = m_pMchMgr->GetHeadAbove( m_TParams.m_sHead) && GetPointAboveRaw( ptP1) ; + bool bAboveEnd = m_bAboveHead && GetPointAboveRaw( ptP1) ; // aggiungo retrazione if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bAboveEnd)) { m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ; @@ -2095,7 +2113,7 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo //---------------------------------------------------------------------------- bool -Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool, const Vector3d& vtExtr, +Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool, double dDepth, double dElev, double dOkStep, bool bSplitArcs) { // recupero distanze di sicurezza @@ -2144,18 +2162,21 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool dStElev = dStep - LIO_ELEV_TOL - 10 * EPS_SMALL ; // determino inizio attacco Point3d ptP1 ; - if ( ! CalcLeadInStart( ptStart, vtStart, vtExtr, dStElev, bInvert, pCompo, ptP1)) + if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, dStElev, bInvert, pCompo, ptP1)) return false ; // determino se l'inizio dell'attacco è fuori dal grezzo bool bOutStart = GetPointOutOfRaw( ptP1, vtTool) ; // determino se l'inizio dell'attacco è sopra il grezzo - bool bAboveStart = m_pMchMgr->GetHeadAbove( m_TParams.m_sHead) && GetPointAboveRaw( ptP1) ; + bool bAboveStart = m_bAboveHead && GetPointAboveRaw( ptP1) ; // imposto versore correzione e ausiliario sul punto di partenza CalcAndSetCorrAuxDir( pCompo, ( bInvert ? nMaxInd - i + 1 : i)) ; // se primo step aggiungo approccio per frese normali if ( j == 1 && ( m_TParams.m_nType & TF_SAWBLADE) == 0) { - // correggo elevazione iniziale con punto inizio attacco - dStElev -= ( ptP1 - ptStart) * vtExtr ; + // correggo elevazione iniziale per punto inizio attacco (se testa da sopra senza aggregato approccio mai Z-) + if ( m_bAboveHead && ! m_bAggrBottom && 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)) { m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ; @@ -2191,7 +2212,7 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool } // aggiungo attacco SetFeed( GetStartFeed()) ; - if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtExtr, bInvert, pCompo, bSplitArcs)) { + if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, bInvert, pCompo, bSplitArcs)) { m_pMchMgr->SetLastError( 2310, "Error in Milling : LeadIn not computable") ; return false ; } @@ -2235,16 +2256,19 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool // aggiungo uscita Point3d ptP1 ; SetFeed( GetEndFeed()) ; - if ( ! AddLeadOut( ptEnd, vtEnd, vtExtr, dEndElev, bInvert, pCompo, bSplitArcs, ptP1)) { + if ( ! AddLeadOut( ptEnd, vtEnd, vtTool, dEndElev, bInvert, pCompo, bSplitArcs, ptP1)) { m_pMchMgr->SetLastError( 2311, "Error in Milling : LeadOut not computable") ; return false ; } // se ultimo step aggiungo retrazione per frese normali if ( j == nStep && ( m_TParams.m_nType & TF_SAWBLADE) == 0) { - // correggo elevazione finale con punto fine uscita - dEndElev -= ( ptP1 - ptEnd) * vtExtr ; + // correggo elevazione finale per punto fine uscita (se testa da sopra senza aggregato approccio mai Z-) + if ( m_bAboveHead && ! m_bAggrBottom && 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 = m_pMchMgr->GetHeadAbove( m_TParams.m_sHead) && GetPointAboveRaw( ptP1) ; + bool bAboveEnd = m_bAboveHead && GetPointAboveRaw( ptP1) ; // aggiungo retrazione if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bAboveEnd)) { m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ; @@ -2260,7 +2284,7 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool //---------------------------------------------------------------------------- bool -Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool, const Vector3d& vtExtr, +Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool, double dDepth, double dElev, double dOkStep, bool bSplitArcs) { // recupero distanze di sicurezza @@ -2298,7 +2322,7 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool Point3d ptEnd ; pCompo->GetEndPoint( ptEnd) ; ptEnd -= vtTool * dDepth ; - bool bAboveStartEnd = m_pMchMgr->GetHeadAbove( m_TParams.m_sHead) && GetPointAboveRaw( ptStart) && GetPointAboveRaw( ptEnd) ; + bool bAboveStartEnd = m_bAboveHead && GetPointAboveRaw( ptStart) && GetPointAboveRaw( ptEnd) ; // determino numero e affondamento degli step int nStep = max( 1, static_cast( ceil( dElev / dOkStep))) ; @@ -2330,7 +2354,7 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool Point3d ptP1 ; // se speciale e step intermedio if ( bSpecial && j > 1) { - ptP1 = ptStart + dStep * vtExtr ; + ptP1 = ptStart + dStep * vtTool ; } // altrimenti else { @@ -2339,17 +2363,20 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev)) dStElev = dElev ; // determino inizio attacco - if ( ! CalcLeadInStart( ptStart, vtStart, vtExtr, dStElev, false, pCompo, ptP1)) + if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, dStElev, false, pCompo, ptP1)) return false ; // determino se l'inizio dell'attacco è fuori dal grezzo bool bOutStart = GetPointOutOfRaw( ptP1, vtTool) ; // aggiungo approccio per frese normali if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) { - // correggo elevazione iniziale con punto inizio attacco - dStElev -= ( ptP1 - ptStart) * vtExtr ; + // correggo elevazione iniziale per punto inizio attacco (se testa da sopra senza aggregato approccio mai Z-) + if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL) + dStElev -= ScalarXY( (ptP1 - ptStart), vtTool) ; + else + dStElev -= ( ptP1 - ptStart) * vtTool ; // se attacco a zigzag o a spirale, l'elevazione va nell'attacco if ( IsLeadInHelixOrZigzag()) { - ptP1 += vtExtr * ( dStElev - ( j - 1) * dStep) ; + ptP1 += vtTool * ( dStElev - ( j - 1) * dStep) ; dStElev = ( j - 1) * dStep ; } // approccio standard al punto iniziale @@ -2382,7 +2409,7 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool } // aggiungo attacco SetFeed( GetStartFeed()) ; - if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtExtr, false, pCompo, bSplitArcs)) { + if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, false, pCompo, bSplitArcs)) { m_pMchMgr->SetLastError( 2310, "Error in Milling : LeadIn not computable") ; return false ; } @@ -2425,14 +2452,17 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool // aggiungo uscita Point3d ptP1 ; SetFeed( GetEndFeed()) ; - if ( ! AddLeadOut( ptEnd, vtEnd, vtExtr, dEndElev, false, pCompo, bSplitArcs, ptP1)) { + if ( ! AddLeadOut( ptEnd, vtEnd, vtTool, dEndElev, false, pCompo, bSplitArcs, ptP1)) { m_pMchMgr->SetLastError( 2311, "Error in Milling : LeadOut not computable") ; return false ; } // aggiungo retrazione per frese normali (esclusi step intermedi senza retrazione) if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0 && ( j == nStep || bMidRetract)) { - // correggo elevazione finale con punto fine uscita - dEndElev -= ( ptP1 - ptEnd) * vtExtr ; + // correggo elevazione finale per punto fine uscita (se testa da sopra senza aggregato approccio mai Z-) + if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL) + dEndElev -= ScalarXY( (ptP1 - ptEnd), vtTool) ; + else + dEndElev -= ( ptP1 - ptEnd) * vtTool ; // aggiungo retrazione if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bAboveStartEnd)) { m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ; @@ -2448,7 +2478,7 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool //---------------------------------------------------------------------------- bool -Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool, const Vector3d& vtExtr, +Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool, double dDepth, double dElev, double dOkStep, bool bSplitArcs) { // recupero distanze di sicurezza @@ -2500,18 +2530,21 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool dStElev -= dStart ; // determino inizio attacco Point3d ptP1 ; - if ( ! CalcLeadInStart( ptStart, vtStart, vtExtr, dStElev, false, pCompo, ptP1)) + if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, dStElev, false, pCompo, ptP1)) return false ; // determino se l'inizio dell'attacco è fuori dal grezzo bool bOutStart = GetPointOutOfRaw( ptP1, vtTool) ; // determino se l'inizio dell'attacco è sopra il grezzo - bool bAboveStart = m_pMchMgr->GetHeadAbove( m_TParams.m_sHead) && GetPointAboveRaw( ptP1) ; + bool bAboveStart = m_bAboveHead && GetPointAboveRaw( ptP1) ; // imposto versore correzione e ausiliario sul punto di partenza CalcAndSetCorrAuxDir( pCompo, i) ; // aggiungo approccio per frese normali if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) { - // correggo elevazione iniziale con punto inizio attacco - dStElev -= ( ptP1 - ptStart) * vtExtr ; + // correggo elevazione iniziale per punto inizio attacco (se testa da sopra senza aggregato approccio mai Z-) + if ( m_bAboveHead && ! m_bAggrBottom && 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)) { m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ; @@ -2532,7 +2565,7 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool } // aggiungo attacco SetFeed( GetStartFeed()) ; - if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtExtr, false, pCompo, bSplitArcs)) { + if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, false, pCompo, bSplitArcs)) { m_pMchMgr->SetLastError( 2310, "Error in Milling : LeadIn not computable") ; return false ; } @@ -2576,16 +2609,19 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool // aggiungo uscita Point3d ptP1 ; SetFeed( GetEndFeed()) ; - if ( ! AddLeadOut( ptEnd, vtEnd, vtExtr, dEndElev, false, pCompo, bSplitArcs, ptP1)) { + if ( ! AddLeadOut( ptEnd, vtEnd, vtTool, dEndElev, false, pCompo, bSplitArcs, ptP1)) { m_pMchMgr->SetLastError( 2311, "Error in Milling : LeadOut not computable") ; return false ; } // aggiungo retrazione per frese normali if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) { - // correggo elevazione finale con punto fine uscita - dEndElev -= ( ptP1 - ptEnd) * vtExtr ; + // correggo elevazione finale per punto fine uscita (se testa da sopra senza aggregato approccio mai Z-) + if ( m_bAboveHead && ! m_bAggrBottom && 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 = m_pMchMgr->GetHeadAbove( m_TParams.m_sHead) && GetPointAboveRaw( ptP1) ; + bool bAboveEnd = m_bAboveHead && GetPointAboveRaw( ptP1) ; // aggiungo retrazione if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bAboveEnd)) { m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ; @@ -2635,18 +2671,21 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool dStElev -= dStart ; // determino inizio attacco Point3d ptP1 ; - if ( ! CalcLeadInStart( ptStart, vtStart, vtExtr, dStElev, bInvert, pCompo, ptP1)) + if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, dStElev, bInvert, pCompo, ptP1)) return false ; // imposto versore correzione e ausiliario sul punto di partenza CalcAndSetCorrAuxDir( pCompo, ( bInvert ? nMaxInd - i + 1 : i)) ; // aggiungo approccio per frese normali if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) { - // correggo elevazione iniziale con punto inizio attacco - dStElev -= ( ptP1 - ptStart) * vtExtr ; + // correggo elevazione iniziale per punto inizio attacco (se testa da sopra senza aggregato approccio mai Z-) + if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL) + dStElev -= ScalarXY( (ptP1 - ptStart), vtTool) ; + else + dStElev -= ( ptP1 - ptStart) * vtTool ; // determino se l'inizio dell'attacco è fuori dal grezzo bool bOutStart = GetPointOutOfRaw( ptP1, vtTool) ; // determino se l'inizio dell'attacco è sopra il grezzo - bool bAboveStart = m_pMchMgr->GetHeadAbove( m_TParams.m_sHead) && GetPointAboveRaw( ptP1) ; + bool bAboveStart = m_bAboveHead && GetPointAboveRaw( ptP1) ; // approccio al punto iniziale if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dAppr, bOutStart, bAboveStart)) { m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ; @@ -2661,7 +2700,7 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool } // aggiungo attacco SetFeed( GetStartFeed()) ; - if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtExtr, bInvert, pCompo, bSplitArcs)) { + if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, bInvert, pCompo, bSplitArcs)) { m_pMchMgr->SetLastError( 2310, "Error in Milling : LeadIn not computable") ; return false ; } @@ -2705,16 +2744,19 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool // aggiungo uscita Point3d ptP1 ; SetFeed( GetEndFeed()) ; - if ( ! AddLeadOut( ptEnd, vtEnd, vtExtr, dEndElev, bInvert, pCompo, bSplitArcs, ptP1)) { + if ( ! AddLeadOut( ptEnd, vtEnd, vtTool, dEndElev, bInvert, pCompo, bSplitArcs, ptP1)) { m_pMchMgr->SetLastError( 2311, "Error in Milling : LeadOut not computable") ; return false ; } // aggiungo retrazione per frese normali if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) { - // correggo elevazione finale con punto fine uscita - dEndElev -= ( ptP1 - ptEnd) * vtExtr ; + // correggo elevazione finale per punto fine uscita (se testa da sopra senza aggregato approccio mai Z-) + if ( m_bAboveHead && ! m_bAggrBottom && 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 = m_pMchMgr->GetHeadAbove( m_TParams.m_sHead) && GetPointAboveRaw( ptP1) ; + bool bAboveEnd = m_bAboveHead && GetPointAboveRaw( ptP1) ; // aggiungo retrazione if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bAboveEnd)) { m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ; @@ -2754,7 +2796,7 @@ class LeadIOStatus //---------------------------------------------------------------------------- bool -Milling::AddSawZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool, const Vector3d& vtExtr, +Milling::AddSawZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool, double dDepth, double dElev, double dOkStep, bool bSplitArcs) { // recupero distanze di sicurezza @@ -2820,12 +2862,12 @@ Milling::AddSawZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtT dStElev = dStep - LIO_ELEV_TOL - 10 * EPS_SMALL ; // determino inizio attacco Point3d ptP1 ; - if ( ! CalcLeadInStart( ptStart, vtStart, vtExtr, dStElev, bInvert, pCompo, ptP1)) + if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, dStElev, bInvert, pCompo, ptP1)) return false ; // determino se l'inizio dell'attacco è fuori dal grezzo bool bOutStart = GetPointOutOfRaw( ptP1, vtTool) ; // determino se l'inizio dell'attacco è sopra il grezzo - bool bAboveStart = m_pMchMgr->GetHeadAbove( m_TParams.m_sHead) && GetPointAboveRaw( ptP1) ; + bool bAboveStart = m_bAboveHead && GetPointAboveRaw( ptP1) ; // imposto versore correzione e ausiliario sul punto di partenza CalcAndSetCorrAuxDir( pCompo, ( bInvert ? nMaxInd - i + 1 : i)) ; // se primo step @@ -2849,7 +2891,7 @@ Milling::AddSawZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtT // aggiungo attacco bool bTang = (( ! bInvert && m_Params.m_dLiTang > EPS_SMALL) || ( bInvert && m_Params.m_dLoTang > EPS_SMALL)) ; SetFeed( bTang ? GetStartFeed() : GetTipFeed()) ; - if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtExtr, bInvert, pCompo, bSplitArcs)) { + if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, bInvert, pCompo, bSplitArcs)) { m_pMchMgr->SetLastError( 2310, "Error in Milling : LeadIn not computable") ; return false ; } @@ -2896,7 +2938,7 @@ Milling::AddSawZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtT // aggiungo uscita Point3d ptP1 ; SetFeed( GetEndFeed()) ; - if ( ! AddLeadOut( ptEnd, vtEnd, vtExtr, dEndElev, bInvert, pCompo, bSplitArcs, ptP1)) { + if ( ! AddLeadOut( ptEnd, vtEnd, vtTool, dEndElev, bInvert, pCompo, bSplitArcs, ptP1)) { m_pMchMgr->SetLastError( 2311, "Error in Milling : LeadOut not computable") ; return false ; } @@ -2944,22 +2986,28 @@ Milling::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, SetFlag( 0) ; } } + // se testa da sopra senza aggregato da sotto, approccio mai da Z negativo + Vector3d vtAppr = vtTool ; + if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL) { + vtAppr.z = 0 ; + vtAppr.Normalize() ; + } // se non sono già sopra il pezzo e sopra attacco c'è spazio per sicurezza o approccio double dSafeDist = ( m_bAggrBottom ? dSafeAggrBottZ : dSafeZ) ; - double dElevZ = vtTool.z * dElev ; + double dElevZ = vtAppr.z * dElev ; 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) ; + Point3d ptP1 = ptP + vtAppr * ( dElev + dAppr) ; if ( ( ! m_bAggrBottom && AddRapidStart( ptP1) == GDB_ID_NULL) || ( m_bAggrBottom && AddRapidMove( ptP1) == GDB_ID_NULL)) return false ; } else { // 1a -> punto sopra inizio - Point3d ptP1b = ptP + vtTool * ( dElev + dAppr) ; - Point3d ptP1a = ptP1b + vtTool * ( dSafeDist - dAppr) ; + Point3d ptP1b = ptP + vtAppr * ( dElev + dAppr) ; + Point3d ptP1a = ptP1b + vtAppr * ( dSafeDist - dAppr) ; if ( ( ! m_bAggrBottom && AddRapidStart( ptP1a) == GDB_ID_NULL) || ( m_bAggrBottom && AddRapidMove( ptP1a) == GDB_ID_NULL)) return false ; @@ -3016,27 +3064,33 @@ bool Milling::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ, double dElev, double dAppr, bool bAboveEnd) { + // se testa da sopra senza aggregato da sotto, approccio mai da Z negativo + Vector3d vtAppr = vtTool ; + if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL) { + vtAppr.z = 0 ; + vtAppr.Normalize() ; + } // se non sono già sopra il pezzo e sopra uscita c'è spazio per sicurezza o approccio double dSafeDist = ( m_bAggrBottom ? dSafeAggrBottZ : dSafeZ) ; - double dElevZ = vtTool.z * dElev ; + double dElevZ = vtAppr.z * dElev ; 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) ; + Point3d ptP4 = ptP + vtAppr * ( 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) ; + Point3d ptP4a = ptP + vtAppr * ( 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) ; + Point3d ptP4b = ptP4a + vtAppr * ( dSafeDist - dAppr) ; if ( AddRapidMove( ptP4b) == GDB_ID_NULL) return false ; } diff --git a/Milling.h b/Milling.h index 005241d..e08c7af 100644 --- a/Milling.h +++ b/Milling.h @@ -76,15 +76,15 @@ class Milling : public Machining bool CalcPathElevation( const ICurveComposite* pCompo, const Vector3d& vtTool, double dDepth, double dRad, double& dElev) ; bool VerifyPathFromBottom( const ICurveComposite* pCompo, const Vector3d& vtTool) ; bool GenerateMillingPv( int nPathId, const ICurveComposite* pCompo) ; - bool AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTool, const Vector3d& vtExtr, + bool AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTool, double dDepth, double dElev, bool bSplitArcs) ; - bool AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool, const Vector3d& vtExtr, + bool AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool, double dDepth, double dElev, double dOkStep, bool bSplitArcs) ; - bool AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool, const Vector3d& vtExtr, + bool AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool, double dDepth, double dElev, double dOkStep, bool bSplitArcs) ; - bool AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool, const Vector3d& vtExtr, + bool AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool, double dDepth, double dElev, double dOkStep, bool bSplitArcs) ; - bool AddSawZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool, const Vector3d& vtExtr, + bool AddSawZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool, 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) ; @@ -136,6 +136,8 @@ class Milling : public Machining int m_nMills ; // numero di percorsi di lavoro generati bool m_bStepOn ; // flag per indicare che effettivamente si lavora a step int m_nHeadSolCh ; // criterio scelta soluzione impostato nella testa + bool m_bTiltingTab ; // flag utilizzo tavola basculante + bool m_bAboveHead ; // flag utilizzo testa da sopra bool m_bAggrBottom ; // flag utilizzo di aggregato da sotto Vector3d m_vtAggrBottom ; // vettore direzione ausiliaria aggregato da sotto AggrBottom m_AggrBottom ; // dati eventuale aggregato da sotto