From b18c309344fd16ebd1ae69d5410b0592722094e5 Mon Sep 17 00:00:00 2001 From: DarioS Date: Wed, 25 Aug 2021 15:06:01 +0200 Subject: [PATCH] EgtMachKernel 2.3h2 : - correzioni a Milling per lavorazioni con fresa inclinata rispetto ad un percorso piano. --- Disposition.cpp | 2 +- EgtMachKernel.rc | Bin 11774 -> 11774 bytes MachineLua.cpp | 6 +- Milling.cpp | 160 +++++++++++++++++++++++++++++++---------------- 4 files changed, 110 insertions(+), 58 deletions(-) diff --git a/Disposition.cpp b/Disposition.cpp index 4bc010d..77c415a 100644 --- a/Disposition.cpp +++ b/Disposition.cpp @@ -306,7 +306,7 @@ Disposition::Load( const STRVECTOR& vString, int nBaseGdbId) //---------------------------------------------------------------------------- //---------------------------------------------------------------------------- Disposition::Disposition( void) - : m_bTabOk( false), m_nExit( 0), m_nStatus( MCH_ST_TO_VERIFY), m_nShifts( 0), m_bSomeByHand( false), m_dAreaOffset({{0,0,0,0}}) + : m_bTabOk( false), m_dAreaOffset({{0,0,0,0}}), m_nExit( 0), m_nStatus( MCH_ST_TO_VERIFY), m_nShifts( 0), m_bSomeByHand( false) { } diff --git a/EgtMachKernel.rc b/EgtMachKernel.rc index 2743a0a83fb9fd5d03209923a53783bfe485f545..5ca33c8975edd401dd83397881491aae1c24a251 100644 GIT binary patch delta 97 zcmewt{V#gMFE&P_&A-`fnHh~HKa|wnoW?bQ1uSxrY4Qod0+^@}R1`^_2jk{d(jGv4 NK<#LXK~l;gTmU8!BZvS1 delta 97 zcmewt{V#gMFE&QQ&A-`fnHdcyKa|wnoW?bQ1uSxrY4Qod0+^@}R1`^_2jk{d(jGv4 NK<#LXK~l;gTmU3rBY*$^ diff --git a/MachineLua.cpp b/MachineLua.cpp index 6c2351f..e8808f1 100644 --- a/MachineLua.cpp +++ b/MachineLua.cpp @@ -589,7 +589,7 @@ Machine::LuaEmtStdHead( lua_State* L) double dRot1W = 1 ; LuaGetTabFieldParam( L, 1, FLD_ROT1W, dRot1W) ; // lettura eventuale campo 'Rot2Stroke' dalla tabella - STROKE Rot2Stroke{ -INFINITO, INFINITO} ; + STROKE Rot2Stroke{{ -INFINITO, INFINITO}} ; LuaGetTabFieldParam( L, 1, FLD_ROT2STROKE, Rot2Stroke.v) ; // lettura eventuale campo 'SolCh' dalla tabella int nSolCh = MCH_SCC_NONE ; @@ -667,7 +667,7 @@ Machine::LuaEmtMultiHead( lua_State* L) double dRot1W = 1 ; LuaGetTabFieldParam( L, 1, FLD_ROT1W, dRot1W) ; // lettura eventuale campo 'Rot2Stroke' dalla tabella - STROKE Rot2Stroke{ -INFINITO, INFINITO} ; + STROKE Rot2Stroke{{ -INFINITO, INFINITO}} ; LuaGetTabFieldParam( L, 1, FLD_ROT2STROKE, Rot2Stroke.v) ; // lettura eventuale campo 'SolCh' dalla tabella int nSolCh = MCH_SCC_NONE ; @@ -734,7 +734,7 @@ Machine::LuaEmtSpecialHead( lua_State* L) double dRot1W = 1 ; LuaGetTabFieldParam( L, 1, FLD_ROT1W, dRot1W) ; // lettura eventuale campo 'Rot2Stroke' dalla tabella - STROKE Rot2Stroke{ -INFINITO, INFINITO} ; + STROKE Rot2Stroke{{ -INFINITO, INFINITO}} ; LuaGetTabFieldParam( L, 1, FLD_ROT2STROKE, Rot2Stroke.v) ; // lettura eventuale campo 'SolCh' dalla tabella int nSolCh = MCH_SCC_NONE ; diff --git a/Milling.cpp b/Milling.cpp index 8eca4a1..5c6a213 100644 --- a/Milling.cpp +++ b/Milling.cpp @@ -2243,10 +2243,14 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo // aggiungo approccio per frese normali if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) { // 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 ; + Vector3d vtEscape = vtTool ; + if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL) { + vtEscape.z = 0 ; + vtEscape.Normalize() ; + } + double dNewStElev ; + if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev) && dNewStElev > EPS_SMALL) + dStElev = min( dStElev, dNewStElev) ; // determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione bool bUnderStart = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dStElev) ; @@ -2356,10 +2360,14 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo // determino se la fine dell'uscita è sopra il grezzo bool bAboveEnd = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ; // 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 ; + Vector3d vtEscape = vtTool ; + if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL) { + vtEscape.z = 0 ; + vtEscape.Normalize() ; + } + double dNewEndElev ; + if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev) && dNewEndElev > EPS_SMALL) + dEndElev = min( dEndElev, dNewEndElev) ; // determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione bool bUnderEnd = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dEndElev) ; @@ -2462,7 +2470,7 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool double dStElev ; if ( j == 1) { if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev)) - dStElev = dElev ; + dStElev = dStep ; } else dStElev = dStep - LIO_ELEV_TOL - 10 * EPS_SMALL ; @@ -2479,10 +2487,14 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool // se primo step aggiungo approccio per frese normali if ( j == 1 && ( m_TParams.m_nType & TF_SAWBLADE) == 0) { // 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 ; + Vector3d vtEscape = vtTool ; + if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL) { + vtEscape.z = 0 ; + vtEscape.Normalize() ; + } + double dNewStElev ; + if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev) && dNewStElev > EPS_SMALL) + dStElev = min( dStElev, dNewStElev) ; // determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione bool bUnderStart = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dStElev) ; @@ -2606,10 +2618,14 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool // determino se la fine dell'uscita è sopra il grezzo bool bAboveEnd = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ; // 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 ; + Vector3d vtEscape = vtTool ; + if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL) { + vtEscape.z = 0 ; + vtEscape.Normalize() ; + } + double dNewEndElev ; + if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev) && dNewEndElev > EPS_SMALL) + dEndElev = min( dEndElev, dNewEndElev) ; // determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione bool bUnderEnd = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dEndElev) ; @@ -2718,6 +2734,8 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool double dStElev ; if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev)) dStElev = dElev ; + if ( ! bAboveStartEnd) + dStElev = max( dStElev, j * dStep) ; // determino inizio attacco if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, dStElev, false, pCompo, ptP1)) return false ; @@ -2726,10 +2744,14 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool // aggiungo approccio per frese normali if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) { // 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 ; + Vector3d vtEscape = vtTool ; + if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL) { + vtEscape.z = 0 ; + vtEscape.Normalize() ; + } + double dNewStElev ; + if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev) && dNewStElev > EPS_SMALL) + dStElev = min( dStElev, dNewStElev) ; // determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione bool bUnderStart = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dStElev) ; @@ -2827,6 +2849,8 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool double dEndElev ; if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev)) dEndElev = dElev ; + if ( ! bAboveStartEnd) + dEndElev = max( dEndElev, j * dStep) ; // aggiungo uscita Point3d ptP1 ; SetFeed( GetEndFeed()) ; @@ -2837,10 +2861,14 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool // aggiungo retrazione per frese normali (esclusi step intermedi senza retrazione) if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0 && ( j == nStep || bMidRetract)) { // 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 ; + Vector3d vtEscape = vtTool ; + if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL) { + vtEscape.z = 0 ; + vtEscape.Normalize() ; + } + double dNewEndElev ; + if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev) && dNewEndElev > EPS_SMALL) + dEndElev = min( dEndElev, dNewEndElev) ; // determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione bool bUnderEnd = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dEndElev) ; @@ -2931,10 +2959,14 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool // aggiungo approccio per frese normali if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) { // 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 ; + Vector3d vtEscape = vtTool ; + if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL) { + vtEscape.z = 0 ; + vtEscape.Normalize() ; + } + double dNewStElev ; + if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev) && dNewStElev > EPS_SMALL) + dStElev = min( dStElev, dNewStElev) ; // determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione bool bUnderStart = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dStElev) ; @@ -3030,10 +3062,14 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool // determino se la fine dell'uscita è sopra il grezzo bool bAboveEnd = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ; // 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 ; + Vector3d vtEscape = vtTool ; + if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL) { + vtEscape.z = 0 ; + vtEscape.Normalize() ; + } + double dNewEndElev ; + if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev) && dNewEndElev > EPS_SMALL) + dEndElev = min( dEndElev, dNewEndElev) ; // determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione bool bUnderEnd = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dEndElev) ; @@ -3095,10 +3131,14 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool // aggiungo approccio per frese normali if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) { // 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 ; + Vector3d vtEscape = vtTool ; + if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL) { + vtEscape.z = 0 ; + vtEscape.Normalize() ; + } + double dNewStElev ; + if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev) && dNewStElev > EPS_SMALL) + dStElev = min( dStElev, dNewStElev) ; // determino se l'inizio dell'attacco è fuori dal grezzo bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, dElev, dSafeZ) ; // determino se l'inizio dell'attacco è sopra il grezzo @@ -3193,10 +3233,14 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool // determino se la fine dell'uscita è sopra il grezzo bool bAboveEnd = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ; // 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 ; + Vector3d vtEscape = vtTool ; + if ( m_bAboveHead && ! m_bAggrBottom && vtTool.z < - EPS_SMALL) { + vtEscape.z = 0 ; + vtEscape.Normalize() ; + } + double dNewEndElev ; + if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev) && dNewEndElev > EPS_SMALL) + dEndElev = min( dEndElev, dNewEndElev) ; // determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione bool bUnderEnd = m_bAboveHead && GetPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, dEndElev) ; @@ -3717,7 +3761,8 @@ Milling::CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtStart, const case MILL_LI_LINEAR : case MILL_LI_TANGENT : { Vector3d vtPerp = vtStart ; - vtPerp.Rotate( vtN, 0, ( bCcwRot ? 1 : - 1)) ; + Vector3d vtRot = vtN - vtN * vtStart * vtStart ; + vtPerp.Rotate( vtRot, 0, ( bCcwRot ? 1 : - 1)) ; ptP1 = ptStart - vtStart * dTang + vtPerp * dPerp + vtN * dElev ; return true ; } @@ -4005,7 +4050,8 @@ Milling::AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d case MILL_LO_LINEAR : { Vector3d vtPerp = vtEnd ; - vtPerp.Rotate( vtN, 0, ( bCcwRot ? 1 : - 1)) ; + Vector3d vtRot = vtN - vtN * vtEnd * vtEnd ; + vtPerp.Rotate( vtRot, 0, ( bCcwRot ? 1 : - 1)) ; ptP1 = ptEnd + vtEnd * dTang + vtPerp * dPerp + vtN * dElev ; return ( AddLinearMove( ptP1, MCH_CL_LEADOUT) != GDB_ID_NULL) ; } @@ -4013,7 +4059,8 @@ Milling::AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d { // calcolo punto finale dell'uscita Vector3d vtPerp = vtEnd ; - vtPerp.Rotate( vtN, 0, ( bCcwRot ? 1 : - 1)) ; + Vector3d vtRot = vtN - vtN * vtEnd * vtEnd ; + vtPerp.Rotate( vtRot, 0, ( bCcwRot ? 1 : - 1)) ; ptP1 = ptEnd + vtEnd * dTang + vtPerp * dPerp + vtN * dElev ; // inserisco uscita PtrOwner pCrv( GetArc2PVN( ptEnd, ptP1, vtEnd, vtN)) ; @@ -5001,8 +5048,8 @@ Milling::GetRadiusForStartEndElevation( bool bExtra) const if ( ! bExtra) return ( 0.5 * m_TParams.m_dTDiam) ; // aumentato - const double DELTA_ELEV_RAD = 20.0 ; - double dDeltaRad = DELTA_ELEV_RAD + max( max( m_Params.m_dStartAddLen, m_Params.m_dEndAddLen), 0.0) ; + const double DELTA_ELEV_RAD = 2.0 ; + double dDeltaRad = min( DELTA_ELEV_RAD, 0.5 * m_TParams.m_dTDiam) ; return ( 0.5 * m_TParams.m_dTDiam + dDeltaRad) ; } @@ -5167,22 +5214,27 @@ Milling::CalcOffset( ICurveComposite* pCompo, double dSignOffs) } if ( m_Params.m_bLeaveTab || m_Params.m_bOscEnable) nFlag |= ICurve::OFF_MEDIA_INTDZ ; - // eseguo offset semplice - if ( pCompo->SimpleOffset( dSignOffs, nFlag)) - return true ; - // se curva piatta, provo con offset avanzato - bool bOk = false ; + // determino se curva piatta e recupero suo vettore estrusione Plane3d plPlane ; - if ( pCompo->IsFlat( plPlane, true, 100 * EPS_SMALL)) { + bool bIsFlat = pCompo->IsFlat( plPlane, false, 10 * EPS_SMALL) ; + Vector3d vtExtr ; pCompo->GetExtrusion( vtExtr) ; + // se curva piatta con estrusione non perpendicolare forzo offset avanzato + bool bAdvOffs = ( bIsFlat && abs( vtExtr * plPlane.GetVersN()) < cos( 0.1 * DEGTORAD)) ; + // eseguo offset semplice + if ( ! bAdvOffs && pCompo->SimpleOffset( dSignOffs, nFlag)) + return true ; + // eseguo offset avanzato + if ( bIsFlat) { OffsetCurve OffsCrv ; if ( OffsCrv.Make( pCompo, dSignOffs, nFlag)) { ICurve* pOffs = OffsCrv.GetLongerCurve() ; if ( pOffs != nullptr) { pCompo->Clear() ; pCompo->AddCurve( pOffs) ; - bOk = true ; + pCompo->ArcsBezierCurvesToArcsPerpExtr( LIN_TOL_MID, ANG_TOL_STD_DEG) ; + return true ; } } } - return bOk ; + return false ; }