Egalware/EgtMachKernel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

EgtMachKernel :

Browse Source 
- primo Test LeadIn/Out con VRONI.
This commit is contained in:
Riccardo Elitropi
2024-01-08 13:23:43 +01:00
parent ee9a446cc0
commit 0cbf148bb6
1 changed files with 141 additions and 187 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Pocketing.cpp
+141 -187
View File
@@ -5877,7 +5877,7 @@ Pocketing::AddSpiralIn( ISURFFRPOVECTOR& vSfr, const vector<ICRVCOMPOPOVECTOR>&
// 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<ICRVCOMPOPOVECTOR>&
}
}
// 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<ICurve> 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<ICRVCOMPOPOVECTOR>&
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<ICurveComposite> pRCrv( CreateCurveComposite()) ;
if ( IsNull( pRCrv))
return false ;
// se percorso già calcolato, allora uso questo
if ( vRCrv[i]->IsValid()) {
// copio la curva di ritorno
PtrOwner<ICurveComposite> 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<ICRVCOMPOPOVECTOR>&
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<ICurveComposite> 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<Voronoi> 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<ISurfFlatRegion> 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