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

EgtMachKernel :

Browse Source 
- Prime idee per ottimizzazioni.
This commit is contained in:
Riccardo Elitropi
2023-11-02 17:57:28 +01:00
parent 072b47590e
commit 4ed4445d09
2 changed files with 181 additions and 172 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Pocketing.cpp
+178 -169
View File
@@ -1851,7 +1851,9 @@ Pocketing::ProcessPath( int nAuxId, int nPvId, int nClId)
//----------------------------------------------------------------------------
bool
Pocketing::DetectOpenEdgeInsideRaw ( ISurfFlatRegion* pSfr, const ISurfTriMesh* pStmRaw ) {
Pocketing::DetectOpenEdgeInsideRaw ( ISurfFlatRegion* pSfr, const ISurfTriMesh* pStmRaw) {
return true ;
// controllo dei parametri
if ( pSfr == nullptr || ! pSfr->IsValid() || pSfr->GetChunkCount() == 0 ||
@@ -5383,6 +5385,11 @@ Pocketing::CalcSpiral( const ISurfFlatRegion* pSrfPock, int& nReg, Point3d& ptSt
if ( IsNull( pSrfToWork) || pSrfToWork->GetChunkCount() == 0)
return false;
// porto il Chunk c-esimo nel sistema di riferimento locale (assieme al punto inziale)
Vector3d vtExtr = pSrfToWork->GetNormVersor() ;
Point3d ptCen ; pSrfToWork->GetCentroid( ptCen) ;
Frame3d frPocket ; frPocket.Set( ptCen, vtExtr) ;
// controllo se ho isole per i casi ottimizzati
bool bHasIsland = pSrfPock->GetLoopCount( 0) > 1 ;
@@ -5424,6 +5431,25 @@ Pocketing::CalcSpiral( const ISurfFlatRegion* pSrfPock, int& nReg, Point3d& ptSt
// caso trapezoide
Point3d pt ; Vector3d vtB1, vtL1, vtB2 ;
PtrOwner<ICurveComposite> pCrvTrap( CreateCurveComposite()) ;
if ( IsNull( pCrvTrap))
return false ;
Vector3d vtDir ; double dPocketSize ;
pCrvBorder->ToLoc( frPocket) ;
if ( ! GetTrapezoidFromShape( pCrvBorder, m_dDiam_Prec > 0 ? m_dDiam_Prec : m_TParams.m_dDiam, pCrvTrap,
vtDir, dPocketSize))
return false ;
pCrvTrap->ToGlob( frPocket) ;
if ( pCrvTrap->IsValid()) {
for ( int u = 0 ; u < pCrvTrap->GetCurveCount() ; ++ u) {
const ICurve* pCrv = pCrvTrap->GetCurve( u) ;
int a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrv->Clone()) ;
m_pGeomDB->SetMaterial( a, pCrv->GetTempProp( 0) == 0 ? BLUE : RED) ;
}
}
return false ;
//if ( pCrvOEWithFlags->IsATrapezoid( 100 * EPS_SMALL, pt, vtB1, vtL1, vtB2)) {
// Vector3d vtDir( vtB1), vtOtherDir( vtL1) ;
// // se parallelogramma scelgo come base i lati lunghi
@@ -5458,10 +5484,7 @@ Pocketing::CalcSpiral( const ISurfFlatRegion* pSrfPock, int& nReg, Point3d& ptSt
//}
}
// porto il Chunk c-esimo nel sistema di riferimento locale (assieme al punto inziale)
Vector3d vtExtr = pSrfToWork->GetNormVersor() ;
Point3d ptCen ; pSrfToWork->GetCentroid( ptCen) ;
Frame3d frPocket ; frPocket.Set( ptCen, vtExtr) ;
// porto la superficie nel frame della svuotatura
pSrfToWork->ToLoc( frPocket) ;
// ciclo di offset verso l'interno
@@ -14787,6 +14810,7 @@ Pocketing::GetTrapezoidFromShape( const ICurveComposite* pCrvCompo, double dDiam
// controllo parametri
if ( pCrvCompo == nullptr || ! pCrvCompo->IsValid())
return false ;
pCrvTrap->Clear() ; // resterà vuota se il caso non è ottimizzato
// controllo il numero di lati chiusi e salvo i loro indici
int nClosedSide = 0 ;
@@ -14799,17 +14823,32 @@ Pocketing::GetTrapezoidFromShape( const ICurveComposite* pCrvCompo, double dDiam
}
}
const double TOLL = 5 * EPS_SMALL ;
m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvCompo->Clone()) ;
OffsetCurve OffsCrv ;
if ( ! OffsCrv.Make( pCrvCompo, - 0.5 * dDiam * 1.05 + TOLL, ICurve::OFF_CHAMFER)) {
m_pMchMgr->SetLastError( 2412, "Error in Pocketing : Offset not computable") ;
return false ;
}
if ( OffsCrv.GetCurveCount() > 1) // i chiusi sono troppo vicini => non può essere ottimizzato
return true ;
PtrOwner<ICurveComposite> pCrvCompo_COffs( ConvertCurveToComposite( OffsCrv.GetLongerCurve())) ;
if ( IsNull( pCrvCompo_COffs))
return false ;
int y = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvCompo_COffs->Clone()) ;
m_pGeomDB->SetMaterial( y, PURPLE) ;
// se tutti lati aperti
if ( nClosedSide == 0) {
// ricavo il box minimo della curva aperta ( passo dalla polyLine)
PolyLine PL ;
if ( ! pCrvCompo->ApproxWithLines( 10 * EPS_SMALL, ANG_TOL_STD_DEG, ICurve::APL_STD, PL))
PolyLine PL ; Point3d ptCen ; double dWidth ;
if ( ! pCrvCompo_COffs->ApproxWithLines( 10 * EPS_SMALL, ANG_TOL_STD_DEG, ICurve::APL_STD, PL) ||
! PL.GetMinAreaRectangleXY( ptCen, vtDir, dWidth, dPocketSize))
return false ;
Point3d ptCen ; double dWidth, dHeight ;
if ( ! PL.GetMinAreaRectangleXY( ptCen, vtDir, dWidth, dPocketSize))
return false ;
// controllo dimY ( dHeight)
if ( dPocketSize > 2 * dDiam - 50 * EPS_SMALL)
// controllo dimY ( dHeight), se troppo estesa, non è un caso ottimizzato
if ( dPocketSize > dDiam + 50 * EPS_SMALL)
return true ;
// inverto il frame attuale
Frame3d frRect ; frRect.Set( ptCen, Z_AX, vtDir) ;
@@ -14822,18 +14861,17 @@ Pocketing::GetTrapezoidFromShape( const ICurveComposite* pCrvCompo, double dDiam
pCrvTrap->AddLine( Point3d( - 0.5 * dWidth, 0.5 * dPocketSize, 0)) ;
pCrvTrap->Close() ;
pCrvTrap->ToGlob( frRect) ;
// imposto tutte le curve come aperte
// imposto tutte le 4 curve come aperte
for ( int u = 0 ; u < pCrvTrap->GetCurveCount() ; ++ u)
pCrvTrap->SetCurveTempProp( u, 1, 0) ;
}
// se un lato aperto
else if ( nClosedSide == 1) {
// prendo la curva
// prendo l'unica curva chiusa
const ICurve* pCrvCurr = pCrvCompo->GetCurve( vIndClosedSides[0]) ;
if ( pCrvCurr == nullptr)
return false ;
// controllo se lineare
// controllo se lineare ( altrimenti non è ottimizzato)
if ( pCrvCurr->GetType() != CRV_LINE)
return true ;
// prendo la direzione del tratto lineare
@@ -14845,53 +14883,51 @@ Pocketing::GetTrapezoidFromShape( const ICurveComposite* pCrvCompo, double dDiam
frCurr.Set( ptStart, Z_AX, vtDir) ;
if ( ! frCurr.IsValid())
return false ;
// porto la curva compo ( clonandola) nel frame
PtrOwner<ICurveComposite> pCrvCompo_c( CloneCurveComposite( pCrvCompo)) ;
// porto la curva Compo ( clonandola) nel frame
PtrOwner<ICurveComposite> pCrvCompo_c( CloneCurveComposite( pCrvCompo_COffs)) ;
if ( IsNull( pCrvCompo_c))
return false ;
pCrvCompo_c->ToLoc( frCurr) ;
// ricavo il box complessivo in questo frame
BBox3d BBox ;
pCrvCompo_c->GetLocalBBox( BBox) ;
// controllo dimY
if ( BBox.GetDimY() > 1.5 * dDiam + 50 * EPS_SMALL ||
! ( abs( BBox.GetMin().y) > EPS_SMALL && abs( BBox.GetMax().y) > EPS_SMALL))
// controllo dimY ( se troppo grande o lato chiuso non sul bordo del box => caso non ottimizzato)
if ( BBox.GetDimY() > dDiam + 50 * EPS_SMALL || BBox.GetMin().y < - TOLL - EPS_SMALL)
return true ;
// creo il rettangolo del Box
pCrvTrap->AddPoint( BBox.GetMin()) ;
pCrvTrap->AddLine( BBox.GetMin() + BBox.GetDimX() * X_AX) ;
Point3d ptNewMin = BBox.GetMin() ;
ptNewMin.y = 0. ;
pCrvTrap->AddPoint( ptNewMin) ;
pCrvTrap->AddLine( ptNewMin + BBox.GetDimX() * X_AX) ;
pCrvTrap->AddLine( BBox.GetMax()) ;
pCrvTrap->AddLine( BBox.GetMin() + BBox.GetDimY() * Y_AX) ;
pCrvTrap->AddLine( BBox.GetMax() - BBox.GetDimX() * X_AX) ;
pCrvTrap->Close() ;
// porto in globale
pCrvTrap->ToGlob( frCurr) ;
// imposto tutte le curve come aperte tranne la prima
// imposto tutte le curve come aperte tranne la prima ( estendo il solo lato chiuso come base del Box)
for ( int u = 0 ; u < pCrvTrap->GetCurveCount() ; ++ u)
pCrvTrap->SetCurveTempProp( u, u == 0 ? 0 : 1, 0) ;
// memorizzo la dimensione Y
dPocketSize = BBox.GetDimY() ;
}
else {
// riordino gli indici in base alla lunghezza delle curva
sort( vIndClosedSides.begin(), vIndClosedSides.end(), ([pCrvCompo] ( int nInd_a, int nInd_b) {
double dLen_a, dLen_b ;
pCrvCompo->GetCurve( nInd_a)->GetLength( dLen_a) ;
pCrvCompo->GetCurve( nInd_b)->GetLength( dLen_b) ;
return dLen_b > dLen_a ;
})) ;
// cerco la base :
// lato lineare, box nella sua direzione con DimY < 1.5 dDiam, box dei restanti chiusi con dimY < dDiam
// il lato lineare deve essere un lato del box
bool bBaseFound = false ;
int nBase = -1 ;
int nSecondBase = -1 ;
BBox3d BBox ;
Frame3d frCurr ;
for ( int i = 0 ; i < int( vIndClosedSides.size()) && !bBaseFound ; ++ i) {
nBase = i ;
// cerco la base
// Def di base :
// lato lineare chiuso, box nella sua direzione con DimY < 1.5 dDiam, box dei restanti chiusi ( almeno 1)
// con dimY < dDiam e lato lineare come lato del box ( è possibile trovare una seconda base, come altro lato chiuso
// parallelo alla base principale con distanza da essa circa il dDiam)
bool bBaseFound = false ; // flag per individuare base principale
int nBase = -1 ; // indice base principale
int nSecondBase = -1 ; // indice base secondaria ( resta -1 se non esiste )
BBox3d BBox ; Frame3d frCurr ; // Box e Frame per base principale
// scorro i chiusi alla ricerca di una possibile base principale
for ( int i = 0 ; i < int( vIndClosedSides.size()) && ! bBaseFound ; ++ i) {
nBase = i ; // aggiorno l'indice
// prendo la curva
const ICurve* pCrvCurr = pCrvCompo->GetCurve( vIndClosedSides[i]) ;
if ( pCrvCurr == nullptr)
return false ;
// controllo se lineare
// controllo se lineare, altrimenti passo alla successiva
if ( pCrvCurr->GetType() != CRV_LINE)
continue ;
// prendo la direzione del tratto lineare
@@ -14902,61 +14938,50 @@ Pocketing::GetTrapezoidFromShape( const ICurveComposite* pCrvCompo, double dDiam
frCurr.Set( ptStart, Z_AX, vtDir) ;
if ( ! frCurr.IsValid())
return false ;
// porto la curva compo ( clonandola) nel frame
// porto la curva Compo ( clonandola) nel frame
PtrOwner<ICurveComposite> pCrvCompo_c( CloneCurveComposite( pCrvCompo)) ;
if ( IsNull( pCrvCompo_c))
return false ;
pCrvCompo_c->ToLoc( frCurr) ;
pCrvCompo_c->GetLocalBBox( BBox) ;
// controllo dimY
if ( BBox.GetDimY() > 1.5 * dDiam + 50 * EPS_SMALL ||
! ( abs( BBox.GetMin().y) > EPS_SMALL && abs( BBox.GetMax().y) > EPS_SMALL))
PtrOwner<ICurveComposite> pCrvCompo_COffs_frCurr( CloneCurveComposite( pCrvCompo_COffs)) ;
pCrvCompo_COffs_frCurr->ToLoc( frCurr) ;
pCrvCompo_COffs_frCurr->GetLocalBBox( BBox) ;
// controllo dimY ( se troppo grande o base principale non sul bordo del box => cerco un'altra base ammissibile)
if ( BBox.GetDimY() > dDiam + 50 * EPS_SMALL || BBox.GetMin().y < - TOLL - EPS_SMALL)
continue ;
// Box dei chiusi...
bool bOk = true ;
for ( int j = 0 ; j < int( vIndClosedSides.size()) ; ++ j) {
if ( i == j)
bBaseFound = true ;
// cerco la base secondaria ( se esiste)
// scorro le altre curve lineari chiuse
for ( int u = 0 ; u < int( vIndClosedSides.size()) && nSecondBase == -1 ; ++ u) {
if ( vIndClosedSides[u] == nBase || pCrvCompo_c->GetCurve( vIndClosedSides[u])->GetType() != CRV_LINE)
continue ;
// prendo la curva
const ICurve* pCrvOther = pCrvCompo_c->GetCurve( vIndClosedSides[j]) ;
if ( pCrvOther == nullptr)
return false ;
// calcolo il box
BBox3d BBoxOther ;
pCrvOther->GetLocalBBox( BBoxOther) ;
// controllo dimY
if ( BBox.GetDimY() > dDiam + 50 * EPS_SMALL) {
bOk = false ;
break ;
// recupero la direzione del tratto
Vector3d vtCurr_dir ; pCrvCompo_c->GetCurve( vIndClosedSides[u])->GetStartDir( vtCurr_dir) ;
// direzioni parallele ma opposte
if ( AreOppositeVectorApprox( vtCurr_dir, X_AX)) {
// se le direzioni sono compatibili, controllo che la distanza sia ammissibile,
// altrimenti non ho nè base secondaria nè primaria ( se non entro mai in questo controllo, allora
// ho solo la base principale)
Point3d ptS0, ptS1 ;
pCrvCurr->GetStartPoint( ptS0) ;
pCrvCompo_c->GetCurve( vIndClosedSides[u])->GetStartPoint( ptS1) ;
if ( abs( ptS1.y - dDiam) < 50 * EPS_SMALL)
nSecondBase = vIndClosedSides[u] ;
}
}
if ( bOk) {
// cerco se ho una seconda base lineare chiusa parallela alla prima e distante circa il diametro
for ( int u = 0 ; u < int( vIndClosedSides.size()) ; ++ u) {
if ( vIndClosedSides[u] == nBase || pCrvCompo_c->GetCurve( vIndClosedSides[u])->GetType() != CRV_LINE)
continue ;
Vector3d vtCurr_dir ; pCrvCompo_c->GetCurve( vIndClosedSides[u])->GetStartDir( vtCurr_dir) ;
if ( AreOppositeVectorApprox( vtCurr_dir, X_AX)) {
Point3d ptS0, ptS1 ;
pCrvCurr->GetStartPoint( ptS0) ;
pCrvCompo_c->GetCurve( vIndClosedSides[u])->GetStartPoint( ptS1) ;
if ( abs( ptS1.y - ptS0.y - dDiam) > 50 * EPS_SMALL)
bOk = false ;
else
nSecondBase = vIndClosedSides[u] ;
}
}
}
bBaseFound = bOk ;
} // ?
if ( ! bBaseFound || nBase < 0)
return true ; // non è un caso ottimizzato
}
// se non ho trovato una base principale => non è ottimizzato
if ( ! bBaseFound)
return true ;
// imposto la dimensione della svuotatura come la DimY dell'ultimo box trovato ( quindi secondo la base principale)
dPocketSize = BBox.GetDimY() ;
// se ho due basi
// se ho la base secondaria
if ( nSecondBase > -1) {
// le parti tra le due basi devono essere tutte omogenee ( o tutte aperte o tutte chiuse)
// pCrvTest0 sarà la parte destra, pCrvTest1 la parte sinistra
Point3d ptSB0, ptSB1 ;
PtrOwner<ICurveComposite> pCrvTest0( CloneCurveComposite( pCrvCompo)) ;
PtrOwner<ICurveComposite> pCrvTest1( CloneCurveComposite( pCrvCompo)) ;
@@ -14969,64 +14994,59 @@ Pocketing::GetTrapezoidFromShape( const ICurveComposite* pCrvCompo, double dDiam
pCrvTest1->GetParamAtPoint( ptSB0, dUTrim1) ;
pCrvTest0->TrimStartEndAtParam( 1, dUTrim0) ;
pCrvTest1->TrimStartEndAtParam( 1, dUTrim1) ;
pCrvTest0->ToLoc( frCurr) ;
pCrvTest1->ToLoc( frCurr) ;
// controllo che la parte destra si uniforme per le TmpProp
for ( int u = 0 ; u < pCrvTest0->GetCurveCount() - 1 ; ++ u) {
int nPropAct, nPropSucc ;
if ( pCrvTest0->GetCurveTempProp( u, nPropAct, 0) &&
pCrvTest0->GetCurveTempProp( u + 1, nPropSucc, 0) &&
nPropAct != nPropSucc)
return true ;
return true ; // se TmpProp diverse => non è un caso ottimizzato
}
// controllo che la parte sinistra sia uniforme per le TmpProp
for ( int u = 0 ; u < pCrvTest1->GetCurveCount() - 1 ; ++ u) {
int nPropAct, nPropSucc ;
if ( pCrvTest1->GetCurveTempProp( u, nPropAct, 0) &&
pCrvTest1->GetCurveTempProp( u + 1, nPropSucc, 0) &&
nPropAct != nPropSucc)
return true ;
return true ; // se TmpProp diverse => non è un caso ottimizzato
}
// creo le due curve di base
// creo la base principale e secondaria
PtrOwner<ICurve> pCrvBase0( pCrvCompo->GetCurve( nBase)->Clone()) ;
PtrOwner<ICurve> pCrvBase1( pCrvCompo->GetCurve( nSecondBase)->Clone()) ;
// le porto nel sistema di riferimento corrente
pCrvBase0->ToLoc( frCurr) ;
pCrvBase1->ToLoc( frCurr) ;
// ricavo i nuovi estremi
Point3d ptEB0, ptEB1 ;
pCrvBase0->GetStartPoint( ptSB0) ;
pCrvBase0->GetEndPoint( ptEB0) ;
pCrvBase1->GetStartPoint( ptSB1) ;
pCrvBase1->GetEndPoint( ptEB1) ;
// controllo se lato destro o sinistro sono due semicirconferenze chiuse
bool bIsRightClosedArc = false ;
if ( pCrvTest0->GetCurveCount() == 1 && pCrvTest0->GetCurve( 0)->GetType() == CRV_ARC &&
pCrvTest0->GetCurve( 0)->GetTempProp( 0) == 0 &&
abs( (( ICurveArc*) pCrvTest0->GetCurve( 0))->GetAngCenter() - 180) < 50 * EPS_SMALL)
bIsRightClosedArc = true ;
bool bIsLeftClosedArc = false ;
if ( pCrvTest1->GetCurveCount() == 1 && pCrvTest1->GetCurve( 0)->GetType() == CRV_ARC &&
pCrvTest1->GetCurve( 0)->GetTempProp( 0) == 0 &&
abs( (( ICurveArc*) pCrvTest1->GetCurve( 0))->GetAngCenter() - 180) < 50 * EPS_SMALL)
bIsLeftClosedArc = true ;
// creo la linea a metà del box in direzione X_AX
PtrOwner<ICurveLine> pMidLine( CreateCurveLine()) ;
if ( IsNull( pMidLine) ||
! pMidLine->SetPVL( BBox.GetMin() + Y_AX * dDiam * 0.5, X_AX, 1.) ||
! pMidLine->IsValid())
return false ;
// se lato destro aperto
// se lato destro aperto ( estendo il punto finale della base principale e il punto iniziale
// della base secondaria fino al lato destro del box)
Point3d ptNewMin = BBox.GetMin() ;
ptNewMin.y = 0. ;
bool bCopyRight = false ;
if ( pCrvTest0->GetCurve( 0)->GetTempProp( 0) == 1 || bIsRightClosedArc) {
ptEB0 = BBox.GetMin() + X_AX * BBox.GetDimX() ;
ptSB1 = BBox.GetMax() ;
if ( pCrvTest0->GetCurve( 0)->GetTempProp( 0) == 1) {
ptEB0 = ptNewMin + X_AX * BBox.GetDimX() ;
ptSB1 = ptEB0 + dDiam * Y_AX ;
}
// se lato destro chiuso
else
bCopyRight = true ;
// se lato sinistro aperto
// se lato sinistro aperto ( estendo il punto finale della base secondaria e il punto iniziale
// della base primaria dino al lato sinistro del box)
bool bCopyLeft = false ;
if ( pCrvTest1->GetCurve( 0)->GetTempProp( 0) == 1 || bIsLeftClosedArc) {
ptSB0 = BBox.GetMin() ;
ptEB1 = BBox.GetMax() - X_AX * BBox.GetDimX() ;
if ( pCrvTest1->GetCurve( 0)->GetTempProp( 0) == 1) {
ptSB0 = ptNewMin ;
ptEB1 = ptNewMin + dDiam * Y_AX ;
}
// se lato sinistro chiuso
else
bCopyLeft = true ;
// creo la curva da restituire
pCrvTrap->AddPoint( ptSB0) ;
pCrvTrap->AddLine( ptEB0) ;
@@ -15034,74 +15054,63 @@ Pocketing::GetTrapezoidFromShape( const ICurveComposite* pCrvCompo, double dDiam
pCrvTrap->AddCurve( Release( pCrvTest0)) ;
else {
pCrvTrap->AddLine( ptSB1) ;
pCrvTrap->SetCurveTempProp( pCrvTrap->GetCurveCount() - 1, bIsRightClosedArc ? 0 : 1, 0) ; // aperta
pCrvTrap->SetCurveTempProp( pCrvTrap->GetCurveCount() - 1, 1, 0) ; // aperta
}
pCrvTrap->AddLine( ptEB1) ;
if ( bCopyLeft)
pCrvTrap->AddCurve( Release( pCrvTest1)) ;
else {
pCrvTrap->Close() ;
pCrvTrap->SetCurveTempProp( pCrvTrap->GetCurveCount() - 1, bIsLeftClosedArc ? 0 : 1, 0) ; // aperta
pCrvTrap->SetCurveTempProp( pCrvTrap->GetCurveCount() - 1, 1, 0) ; // aperta
}
pCrvTrap->ToGlob( frCurr) ;
}
else {
// devo avere un solo lato chiuso ( la base), oppure tre lati chiusi di cui il box deve avere DimY curva il diam
if ( nClosedSide != 1 && nClosedSide != 3)
// se non ho una base secondaria, i lati chiusi devono essere 3 e consecutivi
else if ( nClosedSide == 3) {
// prendo i 3 lati chiusi
const ICurve* pCrv0 = pCrvCompo->GetCurve( vIndClosedSides[0]) ;
const ICurve* pCrv1 = pCrvCompo->GetCurve( vIndClosedSides[1]) ;
const ICurve* pCrv2 = pCrvCompo->GetCurve( vIndClosedSides[2]) ;
if ( pCrv0 == nullptr || pCrv1 == nullptr || pCrv2 == nullptr)
return false ;
// prendo i punti iniziali e finali
Point3d ptStart0 ; pCrv0->GetStartPoint( ptStart0) ;
Point3d ptEnd0 ; pCrv0->GetEndPoint( ptEnd0) ;
Point3d ptStart1 ; pCrv1->GetStartPoint( ptStart1) ;
Point3d ptEnd1 ; pCrv1->GetEndPoint( ptEnd1) ;
Point3d ptStart2 ; pCrv2->GetStartPoint( ptStart2) ;
Point3d ptEnd2 ; pCrv2->GetEndPoint( ptEnd2) ;
// controllo che siano consecutivi e cambio l'ordine se necessario
if ( AreSamePointApprox( ptEnd0, ptStart1) && AreSamePointApprox( ptEnd1, ptStart2))
;
else if ( AreSamePointApprox( ptEnd1, ptStart2) && AreSamePointApprox( ptEnd2, ptStart0)) {
swap( vIndClosedSides[0], vIndClosedSides[1]) ;
swap( vIndClosedSides[1], vIndClosedSides[2]) ;
}
else if ( AreSamePointApprox( ptEnd2, ptStart0) && AreSamePointApprox( ptEnd0, ptStart1)) {
swap( vIndClosedSides[0], vIndClosedSides[2]) ;
swap( vIndClosedSides[2], vIndClosedSides[1]) ;
}
else // se non consecutivi ? ( per ora esco)
return true ;
if ( nClosedSide == 3) {
// prendo i 3 lati chiusi
const ICurve* pCrv0 = pCrvCompo->GetCurve( vIndClosedSides[0]) ;
const ICurve* pCrv1 = pCrvCompo->GetCurve( vIndClosedSides[1]) ;
const ICurve* pCrv2 = pCrvCompo->GetCurve( vIndClosedSides[2]) ;
if ( pCrv0 == nullptr || pCrv1 == nullptr || pCrv2 == nullptr)
return false ;
// prendo i punti iniziali e finali
Point3d ptStart0 ; pCrv0->GetStartPoint( ptStart0) ;
Point3d ptEnd0 ; pCrv0->GetEndPoint( ptEnd0) ;
Point3d ptStart1 ; pCrv1->GetStartPoint( ptStart1) ;
Point3d ptEnd1 ; pCrv1->GetEndPoint( ptEnd1) ;
Point3d ptStart2 ; pCrv2->GetStartPoint( ptStart2) ;
Point3d ptEnd2 ; pCrv2->GetEndPoint( ptEnd2) ;
// controllo che siano consecutivi
if ( AreSamePointApprox( ptEnd0, ptStart1) && AreSamePointApprox( ptEnd1, ptStart2))
;
else if ( AreSamePointApprox( ptEnd1, ptStart2) && AreSamePointApprox( ptEnd2, ptStart0)) {
swap( vIndClosedSides[0], vIndClosedSides[1]) ;
swap( vIndClosedSides[1], vIndClosedSides[2]) ;
}
else if ( AreSamePointApprox( ptEnd2, ptStart0) && AreSamePointApprox( ptEnd0, ptStart1)) {
swap( vIndClosedSides[0], vIndClosedSides[2]) ;
swap( vIndClosedSides[2], vIndClosedSides[1]) ;
}
else // se non consecutivi ? ( per ora esco)
return true ;
// controllo per sicurezza
if ( vIndClosedSides[1] != nBase)
return true ;
// controllo per sicurezza
if ( vIndClosedSides[1] != nBase)
return true ;
// controllo le distanze che siano effettivamente il dDiam
PtrOwner<ICurveComposite> pCrvCompo_c( CloneCurveComposite( pCrvCompo)) ;
if ( IsNull( pCrvCompo_c))
return false ;
pCrvCompo_c->ToLoc( frCurr) ;
Point3d ptS0 ; pCrvCompo_c->GetCurve( vIndClosedSides[0])->GetStartPoint( ptS0) ;
Point3d ptS1 ; pCrvCompo_c->GetCurve( vIndClosedSides[1])->GetStartPoint( ptS1) ; // sempre zero (!)
Point3d ptE2 ; pCrvCompo_c->GetCurve( vIndClosedSides[2])->GetEndPoint( ptE2) ;
if ( ptS0.y - ptS1.y > dDiam + 50 * EPS_SMALL ||
ptE2.y - ptS1.y > dDiam + 50 * EPS_SMALL)
return true ;
// creo la curva
pCrvTrap->AddPoint( ptS0) ;
pCrvTrap->AddCurve( pCrvCompo->GetCurve( vIndClosedSides[0])->Clone()) ;
pCrvTrap->AddCurve( pCrvCompo->GetCurve( vIndClosedSides[1])->Clone()) ;
pCrvTrap->AddCurve( pCrvCompo->GetCurve( vIndClosedSides[2])->Clone()) ;
pCrvTrap->Close() ;
pCrvTrap->SetCurveTempProp( pCrvTrap->GetCurveCount() - 1, 1, 0) ;
}
// creo la curva
Point3d ptS0 ; pCrvCompo->GetCurve( vIndClosedSides[0])->GetStartPoint( ptS0) ;
pCrvTrap->AddPoint( ptS0) ;
pCrvTrap->AddCurve( pCrvCompo->GetCurve( vIndClosedSides[0])->Clone()) ;
pCrvTrap->AddCurve( pCrvCompo->GetCurve( vIndClosedSides[1])->Clone()) ;
pCrvTrap->AddCurve( pCrvCompo->GetCurve( vIndClosedSides[2])->Clone()) ;
pCrvTrap->Close() ;
pCrvTrap->SetCurveTempProp( pCrvTrap->GetCurveCount() - 1, 1, 0) ;
}
else // ho più di 3 lati chiusi => non è ottimizzato
;
}
return true ;
Pocketing.h
+3 -3
View File
@@ -91,8 +91,8 @@ class Pocketing : public Machining
Vector3d& vtMidOut, bool& bMidOut) ;
bool GetOptCrvIndex( const std::vector<ICRVCOMPOPOVECTOR>& vCrvOEWithFlags, int nStep, ISurfFlatRegion* pSrfChunkFinal,
int& nIndex) ;
bool GetTrapezoidFromShape( const ICurveComposite* pCrvCompo, double dDiam, ICurveComposite* pCrvTrap, Vector3d& vtDir,
double& dPocketSize) ;
bool GetTrapezoidFromShape( const ICurveComposite* pCrvCompo, double dDiam, ICurveComposite* pCrvTrap,
Vector3d& vtDir,double& dPocketSize) ;
// ===================================================================
// =========================== GREZZO e GEOMETRIE ====================
@@ -362,7 +362,7 @@ class Pocketing : public Machining
AggrBottom m_AggrBottom ; // dati eventuale aggregato da sotto
bool m_bOpenOutRaw ; // flag forzatura lati aperti sempre fuori dal grezzo
double m_dOpenMinSafe ; // minima distanza di sicurezza di attacco su lato aperto
bool m_bIntersRaw = true ; // flag per intersezione con grezzo
bool m_bIntersRaw = false ; // flag per intersezione con grezzo
bool m_bProjectRaw = false ; // flag di proiezione del grezzo
bool m_bHasShape = true ; // flag per presenza di geometria voluta
PtrOwner<ISurfTriMesh> m_pStmShape ; // puntatore alla superficie TriMesh da seguire