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

EgtMachKernel :

Browse Source 
- LeadIn/Out VORONOI e Dijkstra per casi ottimizzati a Spirale.
- migliorie sui percotrsi di ritorno.
This commit is contained in:
Riccardo Elitropi
2024-01-10 18:28:17 +01:00
parent d684f6fb82
commit 8ae1d4cdc2
1 changed files with 177 additions and 93 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Pocketing.cpp
+177 -93
View File
@@ -2308,6 +2308,24 @@ Pocketing::ProcessPath( int nPathId, int nPvId, int nClId)
for ( int s = 0 ; s < int( vSrfSliced.size()) ; ++ s)
vSrfSliced[s]->ToGlob( frElevation) ;
for ( int s = 0 ; s < int( vSrfSliced.size()) ; ++ s) {
PtrOwner<ISurfFlatRegion> pSrf_toDraw( CloneSurfFlatRegion( vSrfSliced[s])) ;
int a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrf_toDraw->Clone()) ;
m_pGeomDB->SetMaterial( a, Color( 0.0, 0.0, 1.0, 0.45)) ;
for ( int c = 0 ; c < pSrf_toDraw->GetChunkCount() ; ++ c) {
for ( int l = 0 ; l < pSrf_toDraw->GetLoopCount( c) ; ++ l) {
PtrOwner<ICurveComposite> pCrvCompo( GetCurveComposite( pSrf_toDraw->GetLoop( c, l))) ;
for ( int u = 0 ; u < pCrvCompo->GetCurveCount() ; ++ u) {
int nProp0 ; pCrvCompo->GetCurveTempProp( u, nProp0, 0) ;
int nProp1 ; pCrvCompo->GetCurveTempProp( u, nProp1, 1) ;
int aaa = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvCompo->GetCurve( u)->Clone()) ;
m_pGeomDB->SetMaterial( aaa, nProp0 == 0 ? BLUE : RED) ;
}
}
}
}
// riporto le curve per i casi ottimizzati nel frame globale
for ( int u = 0 ; u < int( vCrvOEWithFlags.size()) ; ++ u)
for ( int uu = 0 ; uu < int( vCrvOEWithFlags[u].size()) ; ++ uu)
@@ -5721,21 +5739,32 @@ Pocketing::AddSpiralIn( ISURFFRPOVECTOR& vSfr, const vector<ICRVCOMPOPOVECTOR>&
int nStep = int( vSfr.size()) ;
// determino lo step classico ( senza considerare gli step extra)
double dStep = dElev / nStep ;
// Dati Spiral dello step precedente ( j-1)
Point3d ptP1, ptStartPrec ; // per LeadIn attuale e precedente
BOOLVECTOR vbMidOutPrec ; // flags per effettiva entrata precedente da fuori dal grezzo
ICRVCOMPOPOVECTOR vMCrv_step_prec ; // vettore delle curve dei percorsi di svuotatura dello step precedente
ICRVCOMPOPOVECTOR vRCrv_step_prec ; // vettore delle curve dei percorsi di ritorno dello step precedente
ICRVCOMPOPOVECTOR vMCrv_step_prec_tot ; // vettore delle curve dei percorsi di svuotatura dello step precedente con entrata
ICRVCOMPOPOVECTOR vRCrv_step_prec_tot ; // vettore delle curve dei percorsi di ritorno dello step precedente con uscita
vector<Vector3d> vvtMidOutPrec ; // vettore dei versori delle direzioni di uscita dello step precedente
INTVECTOR vnRegTot_prec ; // vettore dei numeri delle regioni formate dal primo Offset nello step precedente
BOOLVECTOR vbOptTrap_prec ; // flags per caso ottimizzato svuotratura dello step precedente
// LeadIn/leadout
Point3d ptP1 ;
struct SpiralData {
BOOLVECTOR vbMidOut ; // flags per effettiva entrata precedente da fuori dal grezzo
ICRVCOMPOPOVECTOR vMCrv ; // vettore delle curve dei percorsi di svuotatura dello step precedente
ICRVCOMPOPOVECTOR vRCrv ; // vettore delle curve dei percorsi di ritorno dello step precedente
vector<Vector3d> vvtMidOut ; // vettore dei versori delle direzioni di uscita dello step precedente
INTVECTOR vnRegTot ; // vettore dei numeri delle regioni formate dal primo Offset nello step precedente
BOOLVECTOR vbOptTrap ;
} ;
SpiralData SDStepPrec ; // informazioni Spiral attuali
int nOffs_act = 0 ; // Shift indice dei vettori causato da nReg
// scorro il vettore delle FlatRegion ( calcolate per ogni step j-esimo)
for ( int j = 1 ; j <= nStep ; ++ j) {
SpiralData SDStepCurr ; // informazioni Spiral attuali
if ( ! vbChangedPrec[j-1]) {
for ( int i = 0 ; i < int( SDStepPrec.vMCrv.size()) ; ++ i)
SDStepCurr.vMCrv.emplace_back( SDStepPrec.vMCrv[i]->Clone()) ;
SDStepCurr.vbMidOut = SDStepPrec.vbMidOut ;
SDStepCurr.vnRegTot = SDStepPrec.vnRegTot ;
SDStepCurr.vvtMidOut = SDStepPrec.vvtMidOut ;
SDStepCurr.vbOptTrap = SDStepPrec.vbOptTrap ;
}
// se superficie non valida, passo alla prossima
if ( IsNull( vSfr[j-1]) || ! vSfr[j-1]->IsValid())
continue ;
@@ -5745,18 +5774,6 @@ Pocketing::AddSpiralIn( ISURFFRPOVECTOR& vSfr, const vector<ICRVCOMPOPOVECTOR>&
if ( IsNull( pSrfLeanInOut))
return false ;
// se lo step attuale è cambiato rispetto al precedente...
if ( vbChangedPrec[j-1]) {
// Flush info step precedente
vMCrv_step_prec.clear() ;
vRCrv_step_prec.clear() ;
vnRegTot_prec.clear() ;
vbMidOutPrec.clear() ;
vvtMidOutPrec.clear() ;
vbOptTrap_prec.clear() ;
nOffs_act = 0 ;
}
// creo le entità per lo step corrente
ICRVCOMPOPOVECTOR vMCrv, vRCrv ;
BOOLVECTOR vbOut ;
@@ -5797,15 +5814,14 @@ Pocketing::AddSpiralIn( ISURFFRPOVECTOR& vSfr, const vector<ICRVCOMPOPOVECTOR>&
// NB. se la superficie è rimasta la stessa, utilizzo pMCrv e pRCrv dello step precedente
// ( non c'è bisogno di ricalcolare tutti i percorsi)
if ( ! vbChangedPrec[j-1] && j != 1) {
if ( nOffs_act > int( vMCrv_step_prec.size()) - 1)
if ( nOffs_act > int( SDStepPrec.vMCrv.size()) - 1)
break ;
pMCrv.Set( vMCrv_step_prec[nOffs_act]->Clone()) ;
pRCrv.Set( vRCrv_step_prec[nOffs_act]->Clone()) ;
nRegTot = vnRegTot_prec[nOffs_act] ;
bMidOut = vbMidOutPrec[nOffs_act] ;
vMCrv_step_prec[nOffs_act]->GetStartPoint( ptStart) ;
vtMidOut = vvtMidOutPrec[nOffs_act] ;
bOptimizedTrap = vbOptTrap_prec[nOffs_act] ;
pMCrv.Set( SDStepPrec.vMCrv[nOffs_act]->Clone()) ;
pRCrv.Set( SDStepPrec.vRCrv[nOffs_act]->Clone()) ;
nRegTot = SDStepPrec.vnRegTot[nOffs_act] ;
bMidOut = SDStepPrec.vbMidOut[nOffs_act] ;
vtMidOut = SDStepPrec.vvtMidOut[nOffs_act] ;
bOptimizedTrap = SDStepPrec.vbOptTrap[nOffs_act] ;
}
else {
// se lucidatura con epicicli
@@ -5845,16 +5861,16 @@ Pocketing::AddSpiralIn( ISURFFRPOVECTOR& vSfr, const vector<ICRVCOMPOPOVECTOR>&
}
// memorizzo le curve create e modificate per lo step successivo
vMCrv_step_prec.emplace_back( pMCrv->Clone()) ;
vRCrv_step_prec.emplace_back( pRCrv->Clone()) ;
SDStepCurr.vMCrv.emplace_back( pMCrv->Clone()) ;
SDStepCurr.vRCrv.emplace_back( pRCrv->Clone()) ;
// memorizzo i Flag per le entrate
vbMidOutPrec.push_back( bMidOut) ;
SDStepCurr.vbMidOut.push_back( bMidOut) ;
// memorizzo il numero delle regioni create dal primo Offset
vnRegTot_prec.push_back( nRegTot) ;
SDStepCurr.vnRegTot.push_back( nRegTot) ;
// memorizzo il versore di uscita calcolato
vvtMidOutPrec.push_back( vtMidOut) ;
SDStepCurr.vvtMidOut.push_back( vtMidOut) ;
// memorizzo caso ottimizzato
vbOptTrap_prec.push_back( bOptimizedTrap) ;
SDStepCurr.vbOptTrap.push_back( bOptimizedTrap) ;
}
// controlli per entrate da fuori al grezzo
@@ -5886,6 +5902,8 @@ Pocketing::AddSpiralIn( ISURFFRPOVECTOR& vSfr, const vector<ICRVCOMPOPOVECTOR>&
if ( bOptimizedTrap) {
AdjustTrapezoidSpiralForLeadInLeadOut( pMCrv, pRCrv, vtTool, dDepth, nOutsideRaw) ;
bOutStart = ( nOutsideRaw > 0) ;
// aggiorno la curva per eventuali inversioni
SDStepCurr.vMCrv.back().Set( pMCrv->Clone()) ;
}
// verifico se l'ingresso è da considerare fuori dal grezzo anche se dentro
@@ -5902,9 +5920,30 @@ Pocketing::AddSpiralIn( ISURFFRPOVECTOR& vSfr, const vector<ICRVCOMPOPOVECTOR>&
// se sono nel caso ottimizzato per Trapezi e ho attacco e uscita entrambi dentro/fuori dal grezzo,
// ad ogni step pari inverto la direzione della curva solamente se ho un solo chunk e la superificie successiva
// non è cambiata
if ( bOptimizedTrap && nOutsideRaw != 1 && j > 1 && vSfr[j-2]->GetChunkCount() == 1 && ! vbChangedPrec[j-1]
&& ( j % 2 == 0))
pMCrv->Invert() ;
if (( j > 1 && vSfr[j-1]->GetChunkCount() == 1 && int( SDStepPrec.vMCrv.size()) == 1 &&
bOptimizedTrap && SDStepPrec.vbOptTrap[0])) {
Point3d ptA, ptB, ptC ;
pMCrv->GetStartPoint( ptA) ;
SDStepPrec.vMCrv[0]->GetStartPoint( ptB) ;
SDStepPrec.vMCrv[0]->GetEndPoint( ptC) ;
ptA.Translate( vVtTrasl[j-2] - vVtTrasl[j-1]) ;
bool bOpposite = ( Dist( ptA, ptB) > Dist( ptA, ptC) + EPS_SMALL) ;
switch ( nOutsideRaw) {
case 0 :
case 2 :
if ( ! bOpposite) {
pMCrv->Invert() ;
SDStepCurr.vMCrv[0]->Invert() ;
}
break ;
case 1 :
if ( bOpposite) {
pMCrv->Invert() ;
SDStepCurr.vMCrv[0]->Invert() ;
}
break ;
}
}
++ nReg ; // incremento del numero di regioni trovate
++ nOffs_act ; // shift indice
@@ -5982,38 +6021,15 @@ Pocketing::AddSpiralIn( ISURFFRPOVECTOR& vSfr, const vector<ICRVCOMPOPOVECTOR>&
// per il percorso attuale
else {
PtrOwner<ICurveComposite> pRCrv( CreateCurveComposite()) ;
if ( IsNull( pRCrv))
// 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, vSfr[j-2], pRCrv)) {
m_pMchMgr->SetLastError( 2413, "Error in Pocketing : Toolpath not computable") ;
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)) ;
}
// ... 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, 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()) ;
@@ -6077,9 +6093,15 @@ Pocketing::AddSpiralIn( ISURFFRPOVECTOR& vSfr, const vector<ICRVCOMPOPOVECTOR>&
}
}
// aggiorno i dati Spiral
vMCrv_step_prec_tot.swap( vMCrv) ;
vRCrv_step_prec_tot.swap( vRCrv) ;
// aggiorno i dati Spiral se regioni cambiate tra step
SDStepPrec.vMCrv.clear() ;
for ( int i = 0 ; i < int( SDStepCurr.vMCrv.size()) ; ++ i)
SDStepPrec.vMCrv.emplace_back( Release( SDStepCurr.vMCrv[i])) ;
SDStepPrec.vbMidOut = SDStepCurr.vbMidOut ;
SDStepPrec.vnRegTot = SDStepCurr.vnRegTot ;
SDStepPrec.vvtMidOut = SDStepCurr.vvtMidOut ;
SDStepPrec.vbOptTrap = SDStepCurr.vbOptTrap ;
}
return true ;
@@ -6144,9 +6166,17 @@ Pocketing::CalcLinkOnStep( const Point3d& ptS, const Point3d& ptE, const ISurfFl
pCrvStepLink->IsValid() &&
pCrvStepLink->ToGlob( frCurr) ;
// se invece esistono intersezioni devo prendere in considerazione i tratti esterni alla regione
// su di essi calcolo l'elevazione considerata sopra la segmento
// originaria, l'elevazione è calcolata sui tratti esterni ad essa
double dMAxElev = 0. ;
ccClass.clear() ;
PtrOwner<ISurfFlatRegion> pSfrCurr( CloneSurfFlatRegion( pSfr)) ;
if ( IsNull( pSfrCurr) || ! pSfrCurr->IsValid() ||
! pSfrCurr->ToLoc( frCurr) ||
! pSfrCurr->GetCurveClassification( *pSeg, EPS_SMALL, ccClass))
return false ;
for ( int i = 0 ; i < int( ccClass.size()) ; ++ i) {
if ( ccClass[i].nClass == CRVC_IN)
continue ;
@@ -6169,7 +6199,7 @@ Pocketing::CalcLinkOnStep( const Point3d& ptS, const Point3d& ptE, const ISurfFl
pCrvStepLink->AddLine( ptEProj + SAFE_Z_RET * Z_AX) &&
pCrvStepLink->IsValid() &&
pCrvStepLink->ToGlob( frCurr) ;
// in questo caso creo un percorso con i Bisettori seguendo VRONI
ICURVEPOVECTOR vCrvBisectors ;
Voronoi* pVRONI( pSfr->GetVoronoiObject()) ;
@@ -6177,7 +6207,7 @@ Pocketing::CalcLinkOnStep( const Point3d& ptS, const Point3d& ptE, const ISurfFl
! pVRONI->CalcMedialAxis( vCrvBisectors, Voronoi::WMAT_LEFT) ||
vCrvBisectors.empty())
return false ;
// porto i bisettori nel riferimento
for ( int i = 0 ; i < ( int)vCrvBisectors.size() ; ++ i)
vCrvBisectors[i]->ToLoc( frCurr) ;
@@ -6192,11 +6222,43 @@ Pocketing::CalcLinkOnStep( const Point3d& ptS, const Point3d& ptE, const ISurfFl
if ( IsNull( pCrvPath) ||
! ChooseBestBisectorPath( vCompoBisChain, ORIG, ptEProj, pCrvPath))
return false ;
// controllo che la curva si effettivamente distante dal percorso, altrimenti scarico
bool bSkip = false ;
for ( int j = 1 ; j < int( pCrvPath->GetCurveCount()) -1 && ! bSkip ; ++ j)
// controllo che la curva si effettivamente valida e distante dal percorso, altrimenti scarico
bool bSkip = ! pCrvPath->IsValid() || pCrvPath->GetCurveCount() == 0 ;
for ( int j = 0 ; j < int( pCrvPath->GetCurveCount()) && ! bSkip ; ++ j)
bSkip = pCrvPath->GetCurve( j)->GetTempParam( 0) < m_TParams.m_dDiam * 0.5 ||
pCrvPath->GetCurve( j)->GetTempParam( 1) < m_TParams.m_dDiam * 0.5 ;
if ( ! bSkip) {
// calcolo i tratti lineari di raccordo tra il percorso trovato e i punti iniziali e finali effettivi
Point3d ptS_path, ptE_path ;
if ( ! pCrvPath->GetStartPoint( ptS_path) || ! pCrvPath->GetEndPoint( ptE_path))
return false ;
CRVCVECTOR ccClass_line ;
if ( ! AreSamePointEpsilon( ptS_path, ORIG, 5 * EPS_SMALL)) {
PtrOwner<ICurveLine> pLineToStart( CreateCurveLine()) ;
if ( IsNull( pLineToStart) ||
! pLineToStart->Set( ORIG, ptS_path) ||
! pSfrSafe->GetCurveClassification( *pLineToStart, EPS_SMALL, ccClass_line))
return false ;
bSkip = ! ( int( ccClass_line.size()) == 1 && ccClass_line[0].nClass == CRVC_IN) ;
}
if ( ! bSkip) {
ccClass_line.clear() ;
if ( ! AreSamePointEpsilon( ptE_path, ptEProj, 5 * EPS_SMALL)) {
PtrOwner<ICurveLine> pLineToEnd( CreateCurveLine()) ;
if ( IsNull( pLineToEnd) ||
! pLineToEnd->Set( ptEProj, ptE_path) ||
! pSfrSafe->GetCurveClassification( *pLineToEnd, EPS_SMALL, ccClass_line))
return false ;
bSkip = ! ( int( ccClass_line.size()) == 1 && ccClass_line[0].nClass == CRVC_IN) ;
}
}
}
// se la curva non è valida, non sufficientemente lontana dal bordo della regione Safe o i raccordi
// lineari rovinano il grezzo, scarico
if ( bSkip)
return pCrvStepLink->AddPoint( ORIG) &&
pCrvStepLink->AddLine( ORIG + ( SAFE_Z_RET + dMAxElev) * Z_AX) &&
@@ -6204,16 +6266,16 @@ Pocketing::CalcLinkOnStep( const Point3d& ptS, const Point3d& ptE, const ISurfFl
( dMAxElev - SAFE_Z_RET > 0 ? pCrvStepLink->AddLine( ptEProj + SAFE_Z_RET * Z_AX) : true) &&
pCrvStepLink->IsValid() &&
pCrvStepLink->ToGlob( frCurr) ;
// aggiungo un tratto lineare per avere il percorso completo
pCrvPath->AddLine( ORIG, false) ;
pCrvPath->AddLine( ptEProj, true) ;
// calcolo la sua lunghezza
double dCurrLen ;
if ( ! pCrvPath->GetLength( dCurrLen))
return false ;
// merge delle curve e smusso il miglior percorso trovato
pCrvPath->MergeCurves( 100 * EPS_SMALL, 100 * EPS_ANG_SMALL) ;
// approssimo con PolyArc
@@ -6224,7 +6286,7 @@ Pocketing::CalcLinkOnStep( const Point3d& ptS, const Point3d& ptE, const ISurfFl
pCrvPath->FromPolyArc( PA) ;
ModifyCurveToSmoothed( pCrvPath, m_TParams.m_dDiam / 16, m_TParams.m_dDiam / 16,
false) ;
// valuto se invece è più conveniente scaricare ( quindi alzandomi di dMaxElev)
// la lunghezza del tratto in salita e in discesa è dMaxElev
// la lunghezza del tratto orizzontale è data dalla distanza tra ORIG e ptEProj
@@ -6236,7 +6298,7 @@ Pocketing::CalcLinkOnStep( const Point3d& ptS, const Point3d& ptE, const ISurfFl
pCrvStepLink->AddCurve( Release( pCrvPath)) &&
pCrvStepLink->IsValid() &&
pCrvStepLink->ToGlob( frCurr) ;
// privilegio lo scarico
return pCrvStepLink->AddPoint( ORIG) &&
pCrvStepLink->AddLine( ORIG + ( SAFE_Z_RET + dMAxElev) * Z_AX) &&
@@ -6244,7 +6306,6 @@ Pocketing::CalcLinkOnStep( const Point3d& ptS, const Point3d& ptE, const ISurfFl
( dMAxElev - SAFE_Z_RET > 0 ? pCrvStepLink->AddLine( ptEProj + SAFE_Z_RET * Z_AX) : true) &&
pCrvStepLink->IsValid() &&
pCrvStepLink->ToGlob( frCurr) ;
}
//----------------------------------------------------------------------------
@@ -6466,8 +6527,19 @@ Pocketing::ChooseBestBisectorPath( ICRVCOMPOPOVECTOR& vCrvCompo, const Point3d&
( Links[i].nIndNodA == nIndPrecNode && Links[i].nIndNodB == nIndCurrNode)) {
if ( ! pCrvPath->AddCurve( vCrvCompo[i]->Clone())) {
vCrvCompo[i]->Invert() ;
if ( ! pCrvPath->AddCurve( vCrvCompo[i]->Clone()))
if ( ! pCrvPath->AddCurve( vCrvCompo[i]->Clone())) {
m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvPath->Clone()) ;
m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, vCrvCompo[i]->Clone()) ;
return false ;
}
}
// NB. Se la curva è la prima, il punto iniziale deve essere ptBisE !
if ( nIndCurrNode == nDestInd) {
Point3d ptSPath ;
if ( ! pCrvPath->GetStartPoint( ptSPath))
return false ;
if ( ! AreSamePointEpsilon( ptSPath, ptBisE, 5 * EPS_SMALL))
pCrvPath->Invert() ;
}
break ;
}
@@ -6478,12 +6550,17 @@ Pocketing::ChooseBestBisectorPath( ICRVCOMPOPOVECTOR& vCrvCompo, const Point3d&
// controllo se il percorso trovato è ammissibile e che il punto iniziale e finale che coincidano
// a quelli ricavati
Point3d ptSCheck, ptECheck ;
return pCrvPath->IsValid() &&
pCrvPath->Invert() &&
pCrvPath->GetStartPoint( ptSCheck) &&
AreSamePointEpsilon( ptBisS, ptSCheck, 5 * EPS_SMALL) &&
pCrvPath->GetEndPoint( ptECheck) &&
AreSamePointEpsilon( ptBisE, ptECheck, 5 * EPS_SMALL) ;
bool bIsValid = pCrvPath->IsValid() &&
pCrvPath->Invert() &&
pCrvPath->GetStartPoint( ptSCheck) &&
AreSamePointEpsilon( ptBisS, ptSCheck, 5 * EPS_SMALL) &&
pCrvPath->GetEndPoint( ptECheck) &&
AreSamePointEpsilon( ptBisE, ptECheck, 5 * EPS_SMALL) ;
// se non valida, potrebbe effettivamente non esistere un percorso
if ( ! bIsValid)
pCrvPath->Clear() ;
return true ;
}
//----------------------------------------------------------------------------
@@ -11241,6 +11318,13 @@ Pocketing::GetTrapezoidFromShape( const ICurveComposite* pCrvCompo, ICurveCompos
return true ;
}
// la curva a trapezio deve evere 4 lati
if ( pCrvTrap->GetCurveCount() != 4) {
pCrvTrap->Clear() ;
return true ;
}
// se parametro MaxOptSize non compatibile => non è ottimizzato
double dMaxOptSize ;
FromString( ExtractInfo( m_Params.m_sUserNotes, "MaxOptSize="), dMaxOptSize) ;
@@ -11707,7 +11791,7 @@ Pocketing::CalcTrapezoidSpiral( ICurveComposite* pCrvPocket, const Frame3d& frTr
INTVECTOR vnProp( 4, 0) ;
if ( pCrvPocket->GetCurveCount() == 4) {
for ( int i = 0 ; i < 4 ; i++)
pCrvPocket->GetCurveTempProp( i, vnProp[i]) ;
pCrvPocket->GetCurveTempProp( i, vnProp[i]) ;
}
else {
vnProp[1] = pCrvPocket->GetCurve( 1)->GetTempProp() ;