From 4ed4445d09be3fd2cec030701cccb6cd1fc8c359 Mon Sep 17 00:00:00 2001 From: Riccardo Elitropi Date: Thu, 2 Nov 2023 17:57:28 +0100 Subject: [PATCH] EgtMachKernel : - Prime idee per ottimizzazioni. --- Pocketing.cpp | 347 ++++++++++++++++++++++++++------------------------ Pocketing.h | 6 +- 2 files changed, 181 insertions(+), 172 deletions(-) diff --git a/Pocketing.cpp b/Pocketing.cpp index 1c9fb18..4ce188d 100644 --- a/Pocketing.cpp +++ b/Pocketing.cpp @@ -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 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 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 pCrvCompo_c( CloneCurveComposite( pCrvCompo)) ; + // porto la curva Compo ( clonandola) nel frame + PtrOwner 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 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 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 pCrvTest0( CloneCurveComposite( pCrvCompo)) ; PtrOwner 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 pCrvBase0( pCrvCompo->GetCurve( nBase)->Clone()) ; PtrOwner 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 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 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 ; diff --git a/Pocketing.h b/Pocketing.h index 5001c87..277b882 100644 --- a/Pocketing.h +++ b/Pocketing.h @@ -91,8 +91,8 @@ class Pocketing : public Machining Vector3d& vtMidOut, bool& bMidOut) ; bool GetOptCrvIndex( const std::vector& 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 m_pStmShape ; // puntatore alla superficie TriMesh da seguire