diff --git a/Pocketing.cpp b/Pocketing.cpp index c99a279..fce132b 100644 --- a/Pocketing.cpp +++ b/Pocketing.cpp @@ -5877,7 +5877,7 @@ Pocketing::AddSpiralIn( ISURFFRPOVECTOR& vSfr, const vector& // aggiungo un tratto lineare all'inizio del percorso di svuotatura pMCrv->AddLine( ptOut, false) ; // aggiungo un tratto lineare alla fine del percorso di svuotatura - pRCrv->AddLine( ptOut, true) ; + //pRCrv->AddLine( ptOut, true) ; } } @@ -5917,59 +5917,32 @@ Pocketing::AddSpiralIn( ISURFFRPOVECTOR& vSfr, const vector& } } - // 3 punti critici per entrate ed uscite - Point3d ptS, ptE ; - - // per ogni entità trovata... - int nSpiralEntity = int( vMCrv.size()) ; - for ( int e = 0 ; e < nSpiralEntity ; ++ e) { - // se non sono al primo step, regolo l'uscita all'ultima entità dello step precedente - if ( j != 1) { - // DEVO AVERE PTE PRECEDNETE E PTS ATTUALE - // CALCOLO LA QUOTA CORRETTA - // uscita e retrazione entità precedente - // dati fine entità - Point3d ptEnd ; vMCrv[e]->GetEndPoint( ptEnd) ; - Vector3d vtEnd ; vMCrv[e]->GetEndDir( vtEnd) ; - // aggiungo uscita - Point3d ptP1 ; - double dEndElev = dElev ; - SetFeed( GetEndFeed()) ; - if ( ! AddLeadOut( ptEnd, vtEnd, vtExtr, vRCrv[e], bSplitArcs, false, ptP1, dEndElev, true)) { - m_pMchMgr->SetLastError( 2416, "Error in Pocketing : LeadOut not computable") ; - return false ; - } - // aggiungo retrazione - if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr)) { - m_pMchMgr->SetLastError( 2417, "Error in Pocketing : Retract not computable") ; - return false ; - } - } - - + // per ogni percorso trovato + for ( int i = 0 ; i < int( vMCrv.size()) ; ++ i) { // recupero l'indice massimo delle sottocurve - int nMaxInd = vMCrv[e]->GetCurveCount() - 1 ; - int nMaxRInd = vRCrv[e]->GetCurveCount() - 1 ; - + int nMaxInd = vMCrv[i]->GetCurveCount() - 1 ; // ciclo sulle curve elementari - for ( int i = 0 ; i <= nMaxInd ; ++ i) { + for ( int u = 0 ; u <= nMaxInd ; ++ u) { // curva corrente - const ICurve* pCrvC = vMCrv[e]->GetCurve( i) ; + const ICurve* pCrvC = vMCrv[i]->GetCurve( u) ; // copio la curva PtrOwner pCurve( pCrvC->Clone()) ; if ( IsNull( pCurve)) return false ; - // se prima entità - if ( i == 0) { - // dati inizio entità - Point3d ptStart ; - pCurve->GetStartPoint( ptStart) ; - Vector3d vtStart ; - pCurve->GetStartDir( vtStart) ; - // se prima etità in assoluto - if ( e == 0 && j == 1) { - // LeadIn - if ( ! CalcLeadInStart( ptStart, vtStart, vtExtr, vRCrv[e], ptP1)) { + + int b = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCurve->Clone()) ; + m_pGeomDB->SetMaterial( b, RED) ; + + // se prima curva del percorso + if ( u == 0) { + // ricavo il punto inziale + Point3d ptStart ; pCurve->GetStartPoint( ptStart) ; + // vettore tangente iniziale + Vector3d vtStart ; pCurve->GetStartDir( vtStart) ; + // se primo Step e primo percorso, allora semplice LeadIn... + if ( j == 1 && i == 0) { + // inizio leadIn + if ( ! CalcLeadInStart( ptStart, vtStart, vtExtr, vRCrv[i], ptP1)) { m_pMchMgr->SetLastError( 2415, "Error in Pocketing : LeadIn not computable") ; return false ; } @@ -5994,72 +5967,77 @@ Pocketing::AddSpiralIn( ISURFFRPOVECTOR& vSfr, const vector& dStElev = -LIO_ELEV_TOL ; } // approccio al punto iniziale - if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dAppr, vbOut[e])) { + if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dAppr, vbOut[i])) { m_pMchMgr->SetLastError( 2414, "Error in Pocketing : Approach not computable") ; return false ; } // aggiungo attacco SetFeed( GetStartFeed()) ; - if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtExtr, pSrfLeanInOut, vRCrv[e], !m_Params.m_bInvert, bSplitArcs, vbOut[e])) { + if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtExtr, pSrfLeanInOut, vRCrv[i], !m_Params.m_bInvert, bSplitArcs, vbOut[i])) { m_pMchMgr->SetLastError( 2415, "Error in Pocketing : LeadIn not computable") ; return false ; } } - // se devo scendere nella stessa posizione... solo collegaento - else if ( vbChangedPrec[j-1] && vSfr[j-2]->GetChunkCount() == 1 && vnRegTot[e] == 1) { - SetFeed( GetStartFeed()) ; - GetCurrPos( ptP1) ; - if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtExtr, pSrfLeanInOut, vRCrv[e], !m_Params.m_bInvert, bSplitArcs, vbOut[e])) { - m_pMchMgr->SetLastError( 2418, "Error in Pocketing : Link not computable") ; - return false ; - } - } + // ... se devo aggiungere l'uscita del percorso precedente e calcolare l'entrata + // per il percorso attuale else { - // Ricalcolo il punto di attacco sopra al PtStart ( modificato in precedenza dal PtOut) quando : - // 1) sono nel primo Step o ... - // 2) la superificie è diversa da quello dello step precedente o ... - // 3) il numero di chunk allo step precedente è maggiore di 1 o ... - // 4) dal primo offset del chunk cc-esimo ottengo più regioni - - if ( ! CalcLeadInStart( ptStart, vtStart, vtExtr, vRCrv[e], ptP1)) { - m_pMchMgr->SetLastError( 2415, "Error in Pocketing : LeadIn not computable") ; + PtrOwner pRCrv( CreateCurveComposite()) ; + if ( IsNull( pRCrv)) return false ; + // se percorso già calcolato, allora uso questo + if ( vRCrv[i]->IsValid()) { + // copio la curva di ritorno + PtrOwner pRet( vRCrv[i]->Clone()) ; + if ( IsNull( pRet)) + return false ; + // se attacco a scivolo, accorcio della lunghezza dell'attacco + if ( GetLeadInType() == POCKET_LI_GLIDE) { + double dLen ; pRet->GetLength( dLen) ; + if ( dLen > m_Params.m_dLiTang + 10 * EPS_SMALL) { + if ( ! pRet->TrimEndAtLen( dLen - m_Params.m_dLiTang)) + pRet->Clear() ; + } + else + pRet->Clear() ; + } + pRCrv.Set( Release( pRet)) ; } - - // determino elevazione su inizio attacco ( se non trovata, l'elevazione è nStep) - double dStElev ; - if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev)) - dStElev = dStep ; - bool bAhUnderRaw = m_bAboveHead && ! m_bAggrBottom && ! m_bTiltingTab && - GetAhPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), - m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ; - bool bUhAboveRaw = ! m_bAboveHead && - GetUhPointAboveRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(), - m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ; - if ( bAhUnderRaw || bUhAboveRaw || m_bTiltingTab) - dStElev = max( dStElev, dStep) ; - dStElev -= ( ptP1 - ptStart) * vtExtr ; - // se attacco a zigzag o a spirale o a scivolo, l'elevazione va nell'attacco - if ( GetLeadInType() == POCKET_LI_ZIGZAG || - GetLeadInType() == POCKET_LI_HELIX || - GetLeadInType() == POCKET_LI_GLIDE) { - ptP1 += vtExtr * ( dStElev + LIO_ELEV_TOL) ; - dStElev = -LIO_ELEV_TOL ; + // ... se devo calcolarlo + else { + // ricavo il punto in cui sono + Point3d ptCurr ; GetCurrPos( ptCurr) ; + // ricavo il punto che devo raggiungere + Point3d ptDest ; vMCrv[i]->GetStartPoint( ptDest) ; + // calcolo il percorso di ritorno del percorso attuale + if ( IsNull( pRCrv) || + ! CalcLinkOnStep( ptCurr, ptDest, dSafeZ, vSfr[j-2], pRCrv)) { + m_pMchMgr->SetLastError( 2413, "Error in Pocketing : Toolpath not computable") ; + return false ; + } } + // emetto + int b = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pRCrv->Clone()) ; + m_pGeomDB->SetMaterial( b, BLUE) ; + SetFeed( GetEndFeed()) ; + if ( pRCrv->GetCurveCount() > 0 && AddCurveMove( pRCrv) == GDB_ID_NULL) + return false ; + // ricavo la posizione attuale + Point3d ptAbove ; GetCurrPos( ptAbove) ; + double dStElev = Dist( ptAbove, ptStart) ; // approccio al punto iniziale - if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dAppr, vbOut[e])) { - m_pMchMgr->SetLastError( 2414, "Error in Pocketing : Approach not computable") ; - return false ; - } + //if ( ! AddApproach( ptAbove, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dAppr, vbOut[i])) { + // m_pMchMgr->SetLastError( 2414, "Error in Pocketing : Approach not computable") ; + // return false ; + //} // aggiungo attacco SetFeed( GetStartFeed()) ; - if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtExtr, pSrfLeanInOut, vRCrv[e], !m_Params.m_bInvert, bSplitArcs, vbOut[e])) { + if ( ! AddLeadIn( ptAbove, ptStart, vtStart, vtExtr, pSrfLeanInOut, vRCrv[i], !m_Params.m_bInvert, bSplitArcs, vbOut[i])) { m_pMchMgr->SetLastError( 2415, "Error in Pocketing : LeadIn not computable") ; return false ; } } - } + // elaborazioni sulla curva corrente if ( pCurve->GetType() == CRV_LINE) { ICurveLine* pLine = GetCurveLine( pCurve) ; @@ -6079,64 +6057,31 @@ Pocketing::AddSpiralIn( ISURFFRPOVECTOR& vSfr, const vector& if ( AddArcMove( ptP3, ptCen, dAngCen, vtN) == GDB_ID_NULL) return false ; } - // se ultima entità -> passo al chunk cc successivo o allo step sotto - if ( i == nMaxInd) { - // Uscita ... - if ( j < nStep && vSfr[j-1]->GetChunkCount() == 1 && ! vbChangedPrec[j] && vnRegTot[e] == 1) { - // Effettuo l'uscita quando : - // 1) non sono nello step intermedio e ... - // 2) il numero di Chunk allo step attuale è 1 e ... - // 3) la superificie non è cambiata dalla precedente e ... - // 4) dal primo offset del chunk cc-esimo non si sono create altre regioni da svuotare - // se necessario ritorno all'inizio - if ( nMaxRInd >= 0) { - // copio la curva di ritorno - PtrOwner pRet( vRCrv[e]->Clone()) ; - if ( IsNull( pRet)) - return false ; - // aggiungo affondamento - //pRet->Translate( vVtTrasl[j-1]) ; - // se attacco a scivolo, accorcio della lunghezza dell'attacco - if ( GetLeadInType() == POCKET_LI_GLIDE) { - double dLen ; pRet->GetLength( dLen) ; - if ( dLen > m_Params.m_dLiTang + 10 * EPS_SMALL) { - if ( ! pRet->TrimEndAtLen( dLen - m_Params.m_dLiTang)) - pRet->Clear() ; - } - else - pRet->Clear() ; - } - // emetto - SetFeed( GetFeed()) ; - if ( pRet->GetCurveCount() > 0 && AddCurveMove( pRet) == GDB_ID_NULL) - return false ; - } + // se ultima entità dell'ultimo percorso + if ( u == nMaxInd && j == int( vSfr.size()) && i == int( vMCrv.size()) - 1) { + // dati fine entità + Point3d ptEnd ; + pCurve->GetEndPoint( ptEnd) ; + Vector3d vtEnd ; + pCurve->GetEndDir( vtEnd) ; + // aggiungo uscita, LeadOut + Point3d ptP1 ; + double dEndElev = dElev ; + SetFeed( GetEndFeed()) ; + if ( ! AddLeadOut( ptEnd, vtEnd, vtExtr, vRCrv[i], bSplitArcs, false, ptP1, dEndElev, true)) { + m_pMchMgr->SetLastError( 2416, "Error in Pocketing : LeadOut not computable") ; + return false ; } - // atrimenti ultimo step, uscita e retrazione - else { - // dati fine entità - Point3d ptEnd ; - pCurve->GetEndPoint( ptEnd) ; - Vector3d vtEnd ; - pCurve->GetEndDir( vtEnd) ; - // aggiungo uscita - Point3d ptP1 ; - double dEndElev = dElev ; - SetFeed( GetEndFeed()) ; - if ( ! AddLeadOut( ptEnd, vtEnd, vtExtr, vRCrv[e], bSplitArcs, false, ptP1, dEndElev, true)) { - m_pMchMgr->SetLastError( 2416, "Error in Pocketing : LeadOut not computable") ; - return false ; - } - // aggiungo retrazione - if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr)) { - m_pMchMgr->SetLastError( 2417, "Error in Pocketing : Retract not computable") ; - return false ; - } + // aggiungo retrazione + if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr)) { + m_pMchMgr->SetLastError( 2417, "Error in Pocketing : Retract not computable") ; + return false ; } } } } + // aggiorno i dati Spiral vMCrv_step_prec_tot.swap( vMCrv) ; vRCrv_step_prec_tot.swap( vRCrv) ; @@ -6236,8 +6181,8 @@ Pocketing::CalcLinkOnStep( const Point3d& ptS, const Point3d& ptE, const double& // in questo caso creo un percorso con i Bisettori seguendo VRONI ICURVEPOVECTOR vCrvBisectors ; - PtrOwner pVRONI( pSfr->GetVoronoiObject()) ; - if ( IsNull( pVRONI) || + Voronoi* pVRONI( pSfr->GetVoronoiObject()) ; + if ( pVRONI == nullptr || ! pVRONI->CalcMedialAxis( vCrvBisectors, Voronoi::WMAT_LEFT) || vCrvBisectors.empty()) return false ; @@ -6279,49 +6224,47 @@ Pocketing::CalcLinkOnStep( const Point3d& ptS, const Point3d& ptE, const double& if ( ! vCompoBisChain[i]->IsPointOn( ptCheck, 10 * EPS_SMALL)) continue ; // Spezzo nei punti più vicini a - // ORIG ( ptS) e ptEProj raccordo linearmente l'inizio e la fine a tali punti ( se necessario) + // ORIG ( ptS) e ptEProj e raccordo linearmente l'inizio e la fine a tali punti ( se necessario) // NB. Non è esclusa la possibilità che ORIG ( ptS) e ptEProj siano già sul bisettore double dUS = 0, dUE = vCompoBisChain[i]->GetCurveCount() ; - if ( ! vCompoBisChain[i]->GetParamAtPoint( ORIG, dUS) || - ( dUS > 10 * EPS_SMALL && ! vCompoBisChain[i]->TrimStartAtParam( dUS)) || - ! vCompoBisChain[i]->GetParamAtPoint( ptEProj, dUE) || - ( dUE < vCompoBisChain[i]->GetCurveCount() - 10 * EPS_SMALL && - ! vCompoBisChain[i]->TrimEndAtParam( dUE))) + // cerco il punto più vicino al bosettore + Point3d ptBisS, ptBisE ; + int nFlag ; + if ( ! DistPointCurve( ORIG, *vCompoBisChain[i]).GetMinDistPoint( EPS_SMALL, ptBisS, nFlag) || + ! DistPointCurve( ptEProj, *vCompoBisChain[i]).GetMinDistPoint( EPS_SMALL, ptBisE, nFlag)) return false ; - // collego il percorso valido trovato all'ORIG ( ptS) e al ptEProj + if ( ! vCompoBisChain[i]->GetParamAtPoint( ptBisS, dUS, 10 * EPS_SMALL) || + ! vCompoBisChain[i]->GetParamAtPoint( ptBisE, dUE, 10 * EPS_SMALL)) + return false ; + if ( dUS > dUE) // potrebbe succedere... + swap( dUS, dUE) ; + if ( ! vCompoBisChain[i]->TrimStartEndAtParam( dUS, dUE)) + return false ; + + // controllo che tutte curve non estremanti del percorso siano sufficientemente distanti + // dai bordi della pSfrSafe + bool bSkip = false ; + for ( int j = 1 ; j < int( vCompoBisChain[i]->GetCurveCount()) -1 && ! bSkip ; ++ j) + bSkip = vCompoBisChain[i]->GetCurve( j)->GetTempParam( 0) < m_TParams.m_dDiam * 0.5 || + vCompoBisChain[i]->GetCurve( j)->GetTempParam( 1) < m_TParams.m_dDiam * 0.5 ; + + m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, vCompoBisChain[i]->Clone()) ; vCompoBisChain[i]->AddLine( ORIG, false) ; vCompoBisChain[i]->AddLine( ptEProj, true) ; + m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, vCompoBisChain[i]->Clone()) ; - // creo la FatCurve da qeusto percorso - PtrOwner pSfrTool( GetSurfFlatRegionFromFatCurve( vCompoBisChain[i]->Clone(), - 0.5 * m_TParams.m_dDiam, false, false)) ; - if ( IsNull( pSfrTool) || ! pSfrTool->IsValid()) + // calcolo l'elevazione sopra all'ultimo tratto lineare + Point3d ptCS ; vCompoBisChain[i]->GetLastCurve()->GetStartPoint( ptCS) ; + Point3d ptCE ; vCompoBisChain[i]->GetLastCurve()->GetEndPoint( ptCE) ; + double dElevCheck = 0. ; + if ( ! GetElevation( m_nPhase, ptCS, ptCE, pSfr->GetNormVersor(), m_TParams.m_dDiam * 0.5, m_TParams.m_dLen, + pSfr->GetNormVersor(), dElevCheck)) return false ; - if ( AreOppositeVectorApprox( pSfrTool->GetNormVersor(), Z_AX)) - pSfrTool->Invert() ; - - // controllo se è interamente contenuta nella regione Safe, altrimenti non considero il percorso - bool bIsInside = false ; - for ( int c = 0 ; c < pSfrSafe->GetChunkCount() && ! bIsInside ; ++ c) - bIsInside = pSfrTool->GetChunkSimpleClassification( 0, *pSfrTool, c) == REGC_IN1 ; - if ( ! bIsInside) + // se non nulla, allora non considero valido il percorso + if ( dElevCheck > EPS_SMALL) continue ; - /* - double dUS = 0, dUE = vCompoBisChain[i]->GetCurveCount() ; - if ( ! vCompoBisChain[i]->GetParamAtPoint( ORIG, dUS)) - return false ; - if ( dUS > 10 * EPS_SMALL && ! vCompoBisChain[i]->TrimStartAtParam( dUS)) - return false ; - if ( ! vCompoBisChain[i]->GetParamAtPoint( ptEProj, dUE)) - return false ; - if ( dUE < vCompoBisChain[i]->GetCurveCount() - 10 * EPS_SMALL && - ! vCompoBisChain[i]->TrimEndAtParam( dUE)) - return false ; - */ - - // calcolo la sua lunghezza double dCurrLen ; if ( ! vCompoBisChain[i]->GetLength( dCurrLen)) @@ -6332,7 +6275,7 @@ Pocketing::CalcLinkOnStep( const Point3d& ptS, const Point3d& ptE, const double& nIndBestPath = i ; } } - // se non ho trovato un percorso valido, privilegio lo scarico ed esco + // se non ho trovato un percorso valido , privilegio lo scarico ed esco if ( nIndBestPath < 0) return pCrvStepLink->AddPoint( ORIG) && pCrvStepLink->AddLine( ORIG + ( dSafeZ + dMAxElev) * Z_AX) && @@ -6872,17 +6815,18 @@ Pocketing::CalcSpiral( const ISurfFlatRegion* pSrfPock, int& nReg, Point3d& ptSt // smusso le curve di offset ( ad eccezione della prima) ICRVCOMPOPOVECTOR vOffsClosedCurves( vOffs.size()) ; // vettore con tutte le curve di Offset Chiuse + double dSmoothPar = m_TParams.m_dDiam / 16 ; for ( int i = 0 ; i < int( vOffs.size()) ; ++i ) { if ( i != 0) - ModifyCurveToSmoothed( vOffs[i], m_TParams.m_dDiam / 16, m_TParams.m_dDiam / 16, false) ; + ModifyCurveToSmoothed( vOffs[i], dSmoothPar, dSmoothPar, false) ; vOffs[i]->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL, true, true) ; vOffsClosedCurves[i].Set( vOffs[i]->Clone()) ; } for ( int i = 0 ; i < int( vOffsFirstCurve.size()) ; ++ i) { if ( i != 0) - ModifyCurveToSmoothed( vOffsFirstCurve[i], m_TParams.m_dDiam / 16, m_TParams.m_dDiam / 16, false) ; + ModifyCurveToSmoothed( vOffsFirstCurve[i], dSmoothPar, dSmoothPar, false) ; vOffsFirstCurve[i]->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL) ; } @@ -8443,6 +8387,18 @@ Pocketing::CalcBoundedSmootedLink( const Point3d& ptStart, const Vector3d& vtSta if ( IsNull( pBiArcLink)) return CalcBoundedLink( ptStart, ptEnd, vOffIslands, pCrvLink) ; + // controllo la distanza tra i due punti ( utilizzo raccordo lineare se grande) + if ( SqDist( ptStart, ptEnd) > 3 * ( 4 * GetSideStep() + m_TParams.m_dDiam * m_TParams.m_dDiam)) { + Point3d ptS_shift = ptStart + ( m_TParams.m_dDiam / 6) * vtStart ; + Point3d ptE_shift = ptEnd - ( m_TParams.m_dDiam / 6) * vtEnd ; + if ( ! CalcBoundedLink( ptS_shift, ptE_shift, vOffIslands, pCrvLink)) + return false ; + pCrvLink->AddLine( ptStart, false) ; + pCrvLink->AddLine( ptEnd, true) ; + ModifyCurveToSmoothed( pCrvLink, m_TParams.m_dDiam / 16, m_TParams.m_dDiam / 16, false) ; + return true ; + } + // se BiArco troppo grande allora lo modifico double dLenBiArc ; pBiArcLink->GetLength( dLenBiArc) ; @@ -9875,7 +9831,7 @@ Pocketing::AdjustContourStart( ICurveComposite* pCompo, const ICRVCOMPOPOVECTOR& for ( int i = 0 ; i < pCompo->GetCurveCount() ; ++ i) { int nProp_i ; - // se la curva i-esima non è già stata considerata ed è aperta... + // se la curva i-esima non è già stata considerata ed è chiusa... if ( find( vIndUsed.begin(), vIndUsed.end(), i) == vIndUsed.end() && pCompo->GetCurveTempProp( i, nProp_i, 0) && nProp_i == 0) { @@ -10233,7 +10189,7 @@ Pocketing::GetParamForPtStartOnEdge( const ICurve* pCrvCheck, const ICurveCompos if ( ! pCompo->GetExtrusion( vtExtr)) vtExtr = Z_AX ; // ricavo il centroide o il punto iniziale della curva composita - Point3d ptCen ; + Point3d ptCen ; if ( ! pCompo->GetCentroid( ptCen)) if ( ! pCompo->GetStartPoint( ptCen)) return false ; @@ -10262,8 +10218,6 @@ Pocketing::GetParamForPtStartOnEdge( const ICurve* pCrvCheck, const ICurveCompos } double dDiv = dSubArc < 0 ? dDiam : dSubArc ; double dMaxInt = floor( dLen / dDiv) ; - //if ( dMaxInt < EPS_SMALL) - // return false ; int nDen = 2 ; // intervalli in cui suddivido la curva dMaxInt = max( 2.0, dMaxInt) ; // così se entra una volta controllo sempre dParT = 0.5 @@ -10297,7 +10251,7 @@ Pocketing::GetParamForPtStartOnEdge( const ICurve* pCrvCheck, const ICurveCompos // di convergenza tra più chunks... vtPerpIn.Normalize() ; vtPerpIn.Rotate( Z_AX, 0, 1) ; // cos( pi/2) = 0, sin( pi/2) = 1 - vtPerpIn *= (( m_TParams.m_dDiam + GetOffsR() + 50 * EPS_SMALL)) ; + vtPerpIn *= (( 0.5 * m_TParams.m_dDiam + GetOffsR() - 50 * EPS_SMALL)) ; ptTest = ptTest + vtPerpIn ; // creo una circonferenza ( ombra del tool ) centrata su ptTest