From b577dfe86b93985f6533390a1f912980356fd2f1 Mon Sep 17 00:00:00 2001 From: Riccardo Elitropi Date: Tue, 7 Apr 2026 14:49:34 +0200 Subject: [PATCH] EgtMachKernel : - modifica nomi gruppi Paths per Sgrossature e PocketingNT sotto al gruppo CL. In Sgrossature e Finiture migliorati i controlli sulla semplificazione delle curve mediante frame Locale. --- PocketingNT.cpp | 10 +++---- SurfFinishing.cpp | 60 ++++++++++++++++++++++------------------ SurfFinishing.h | 2 +- SurfRoughing.cpp | 70 +++++++++++++++++++++++++++++------------------ SurfRoughing.h | 2 +- 5 files changed, 85 insertions(+), 59 deletions(-) diff --git a/PocketingNT.cpp b/PocketingNT.cpp index 994eaaf..ca499f4 100644 --- a/PocketingNT.cpp +++ b/PocketingNT.cpp @@ -1938,7 +1938,7 @@ PocketingNT::Chain( int nGrpDestId) } // scorro le regioni piane ricavate dalle curve - int nGroupName = -1 ; + int nGroupName = 0 ; PtrOwner pSfrCurr( SfrByC.GetSurf()) ; while ( ! IsNull( pSfrCurr) && pSfrCurr->IsValid()) { // per ogni Chunk @@ -1982,7 +1982,7 @@ PocketingNT::Chain( int nGrpDestId) PtrOwner pCrvLoop( CreateCurveComposite()) ; if ( IsNull( pCrvLoop) || ! pCrvLoop.Set( ConvertCurveToComposite( pSfrChunk->GetLoop( 0, nL))) || - ! pCrvLoop->IsValid()) + ! pCrvLoop->IsValid()) return false ; // se loop esterno, aggiungo la superfifice al gruppo con le relative informazioni if ( nL == 0) { @@ -2165,7 +2165,7 @@ ISurfFlatRegion* PocketingNT::GetSfrByStmIntersection( const IntersParPlanesSurfTm& IPPStm, double dDist, double dSmallOffs) { // interseco la superficie alla quota corrente - PNTVECTOR vPnt ; + PNTVECTOR vPnt ; BIPNTVECTOR vBpt ; TRIA3DVECTOR vTria ; if ( ! IPPStm.GetInters( dDist, vPnt, vBpt, vTria)) @@ -2855,8 +2855,8 @@ PocketingNT::ChooseCloseOrOpenEdge( ISurfFlatRegion* pSfr, const ISurfTriMesh* p return false ; // recupero i NUM_POINTS punti bool bIsOnStm = true ; - for ( int p = 0 ; p < NUM_POINTS + 1 && bIsOnStm ; ++ p) { - double dPar = ( 1. / ( 1. * NUM_POINTS)) * p ; + for ( int nP = 0 ; nP < NUM_POINTS + 1 && bIsOnStm ; ++ nP) { + double dPar = ( 1. / ( 1. * NUM_POINTS)) * nP ; Point3d ptPar ; if ( ! pCrv->GetPointD1D2( dPar, ICurve::FROM_PLUS, ptPar)) return false ; diff --git a/SurfFinishing.cpp b/SurfFinishing.cpp index fa54e5b..11062b3 100644 --- a/SurfFinishing.cpp +++ b/SurfFinishing.cpp @@ -2093,7 +2093,7 @@ SurfFinishing::ProcessSfr( int nPathId, int nPvId, int nClId) //---------------------------------------------------------------------------- bool -SurfFinishing::SimplifyCurve( ICurveComposite* pCompo, double dMergeLinTol, double dMergeAndTolDeg, +SurfFinishing::SimplifyCurve( ICurveComposite* pCompo, const Frame3d& frLocXY, double dMergeLinTol, double dMergeAndTolDeg, double dSmallDefLinTol, double dSmallDefAngTolDeg, double dArcApproxLinTol, double dArcApproxAngTolDeg) const { @@ -2101,35 +2101,38 @@ SurfFinishing::SimplifyCurve( ICurveComposite* pCompo, double dMergeLinTol, doub if ( pCompo == nullptr || ! pCompo->IsValid()) return false ; - // ricavo il punto iniziale e finale - Point3d ptStart ; pCompo->GetStartPoint( ptStart) ; - Point3d ptEnd ; pCompo->GetEndPoint( ptEnd) ; - - // eseguo le modifiche su una copia della curva originale - PtrOwner pCompoCL( CloneCurveComposite( pCompo)) ; - if ( IsNull( pCompoCL)) + // eseguo le modifiche su una copia della curva originale in locale al frame XY + PtrOwner pCompoLoc( CloneCurveComposite( pCompo)) ; + if ( IsNull( pCompoLoc)) return false ; + pCompoLoc->ToLoc( frLocXY) ; + + // ricavo il punto iniziale e finale + Point3d ptStart ; pCompoLoc->GetStartPoint( ptStart) ; + Point3d ptEnd ; pCompoLoc->GetEndPoint( ptEnd) ; // merge per uniformità - bool bOk = pCompoCL->MergeCurves( dMergeLinTol, dMergeAndTolDeg, false) ; + bool bOk = pCompoLoc->MergeCurves( dMergeLinTol, dMergeAndTolDeg, false) ; // rimozione Spikes o Curve Z - bOk = bOk && pCompoCL->RemoveSmallDefects( dSmallDefLinTol, dSmallDefAngTolDeg, true) ; + bOk = bOk && pCompoLoc->RemoveSmallDefects( dSmallDefLinTol, dSmallDefAngTolDeg, true) ; // interpolazione mediante linee ed archi PolyArc PA ; - bOk = bOk && pCompoCL->ApproxWithArcsEx( dArcApproxLinTol, dArcApproxAngTolDeg, LIN_FEA_STD, PA) && - pCompoCL->Clear() && pCompoCL->FromPolyArc( PA) ; + bOk = bOk && pCompoLoc->ApproxWithArcsEx( dArcApproxLinTol, dArcApproxAngTolDeg, LIN_FEA_STD, PA) && + pCompoLoc->Clear() && pCompoLoc->FromPolyArc( PA) ; // controllo aggiuntivo sui punti iniziali e finali che siano gli stessi Point3d ptNewStart, ptNewEnd ; - bOk = bOk && pCompoCL->GetStartPoint( ptNewStart) && pCompoCL->GetEndPoint( ptNewEnd) && + bOk = bOk && pCompoLoc->GetStartPoint( ptNewStart) && pCompoLoc->GetEndPoint( ptNewEnd) && AreSamePointApprox( ptNewStart, ptStart) && AreSamePointApprox( ptNewEnd, ptEnd) ; // controllo che non si siano create auto-intersezioni - SelfIntersCurve SIC( *pCompoCL) ; + SelfIntersCurve SIC( *pCompoLoc) ; bOk = bOk && ( SIC.GetCrossIntersCount() == 0) ; // se tutto bene, sostiuisco la curva originale con la modificata - if ( bOk) - pCompo->CopyFrom( pCompoCL) ; + if ( bOk) { + pCompoLoc->ToGlob( frLocXY) ; + pCompo->CopyFrom( pCompoLoc) ; + } return true ; } @@ -2502,6 +2505,11 @@ SurfFinishing::CalcZConstSilCrv( ICAvParSilhouettesSurfTm* pCavParSilh, const SU if ( pSfrClass == nullptr || ! pSfrClass->IsValid()) return false ; + // definisco un frame implicito rispetto alla superficie di classificazione + Frame3d frLocXY ; + Point3d ptC ; pSfrClass->GetCentroid( ptC) ; + frLocXY.Set( ptC, pSfrClass->GetNormVersor()) ; + // NB. Essendo una finitura a Z costante, devo controllare che i piani di finitura non facciano // overlap con facce delle TriMesh selezionate con normale simile a vtTool set setZAmbiguos ; @@ -2530,32 +2538,32 @@ SurfFinishing::CalcZConstSilCrv( ICAvParSilhouettesSurfTm* pCavParSilh, const SU if ( ! pCavParSilh->GetSilhouette( dZLoc, vPL)) return false ; // classifico le PolyLine in base alla regione - POLYLINEVECTOR vPL_InsideSfr ; + POLYLINEVECTOR vPLInsideSfr ; for ( auto& PL : vPL) { // porto la PolyLine a contatto con la regione PL.Translate( - dZLoc * pSfrClass->GetNormVersor()) ; // converto in curva composita - PtrOwner pCrv_PL( CreateCurveComposite()) ; - if ( IsNull( pCrv_PL) || ! pCrv_PL->FromPolyLine( PL)) + PtrOwner pCrvPL( CreateCurveComposite()) ; + if ( IsNull( pCrvPL) || ! pCrvPL->FromPolyLine( PL)) return false ; // classifico la curva con la superficie CRVCVECTOR ccClass ; - if ( ! pSfrClass->GetCurveClassification( *pCrv_PL, EPS_SMALL, ccClass)) + if ( ! pSfrClass->GetCurveClassification( *pCrvPL, EPS_SMALL, ccClass)) return false ; // tengo tutti i tratti non esterni alla superficie for ( int i = 0 ; i < int( ccClass.size()) ; ++ i) { if ( ccClass[i].nClass != CRVC_OUT) { - PtrOwner pCrvCompoPartIn( ConvertCurveToComposite( pCrv_PL->CopyParamRange( ccClass[i].dParS, ccClass[i].dParE))) ; + PtrOwner pCrvCompoPartIn( ConvertCurveToComposite( pCrvPL->CopyParamRange( ccClass[i].dParS, ccClass[i].dParE))) ; if ( ! IsNull( pCrvCompoPartIn) && pCrvCompoPartIn->IsValid()) { - vPL_InsideSfr.emplace_back( PolyLine()) ; + vPLInsideSfr.emplace_back( PolyLine()) ; // riporto la curva alla quota giusta pCrvCompoPartIn->Translate( dZLoc * pSfrClass->GetNormVersor()) ; - pCrvCompoPartIn->ApproxWithLines( 0, 0, ICurve::APL_SPECIAL, vPL_InsideSfr.back()) ; + pCrvCompoPartIn->ApproxWithLines( 0, 0, ICurve::APL_SPECIAL, vPLInsideSfr.back()) ; } } } } - swap( vPL, vPL_InsideSfr) ; + swap( vPL, vPLInsideSfr) ; for ( auto& PL : vPL) { // recupero la curva dalla silhouette PtrOwner pSilCrv( CreateCurveComposite()) ; @@ -2574,7 +2582,7 @@ SurfFinishing::CalcZConstSilCrv( ICAvParSilhouettesSurfTm* pCavParSilh, const SU pTempCrv->MergeCurves( SILH_ARC_TOL / 2., ANG_TOL_STD_DEG)) pSilCrv.Set( pTempCrv) ; } - SimplifyCurve( pSilCrv) ; + SimplifyCurve( pSilCrv, frLocXY) ; vCrvCompo.back().emplace_back( Release( pSilCrv)) ; } // controllo validità delle curve @@ -5807,7 +5815,7 @@ SurfFinishing::CalcOptimalZConstCurves( const ISurfFlatRegion* pSfrLoc, const SU PtrOwner pNewCrvCompo( CreateCurveComposite()) ; if ( IsNull( pNewCrvCompo) || ! pNewCrvCompo->FromPolyLine( PL)) continue ; - SimplifyCurve( pNewCrvCompo) ; + SimplifyCurve( pNewCrvCompo, frSfr) ; vvCrvCompo[i].emplace_back( Release( pNewCrvCompo)) ; // memorizzo come primo TempParam la distanza della superficie ( per coerenza) vvCrvCompo[i].back()->SetTempParam( dSfrDist, 0) ; diff --git a/SurfFinishing.h b/SurfFinishing.h index 377dbc0..cf21044 100644 --- a/SurfFinishing.h +++ b/SurfFinishing.h @@ -115,7 +115,7 @@ class SurfFinishing : public Machining double dDepth, ISurfFlatRegion* pSfrCnt) ; bool ProcessCrvCompo( int nPathId, int nPvId, int nClId) ; bool ProcessSfr( int nPathId, int nPvId, int nClId) ; - bool SimplifyCurve( ICurveComposite* pCompo, + bool SimplifyCurve( ICurveComposite* pCompo, const Frame3d& frLocXY, double dMergeLinTol = 200. * EPS_SMALL, double dMergeAndTolDeg = 200. * EPS_ANG_SMALL, double dSmallDefLinTol = 150. * EPS_SMALL, double dSmallDefAngTolDeg = 2. * ANG_TOL_STD_DEG, double dArcApproxLinTol = 50. * EPS_SMALL, double dArcApproxAngTolDeg = ANG_TOL_STD_DEG) const ; diff --git a/SurfRoughing.cpp b/SurfRoughing.cpp index b16bbf1..d261184 100644 --- a/SurfRoughing.cpp +++ b/SurfRoughing.cpp @@ -1236,7 +1236,7 @@ SurfRoughing::Chain( int nGrpDestId) } // scorro le regioni piane ricavate dalle curve - int nGroupName = -1 ; + int nGroupName = 0 ; PtrOwner pSfrCurr( SfrByC.GetSurf()) ; while ( ! IsNull( pSfrCurr) && pSfrCurr->IsValid()) { // la normale del Chunk deve essere coerente con l'estrusione ricavata @@ -4281,52 +4281,60 @@ SurfRoughing::ResetCurveAllTempProp( ICurve* pCurve) const //---------------------------------------------------------------------------- bool -SurfRoughing::SimplifyCurve( ICurveComposite* pCompo, const ICRVCOMPOPOVECTOR& vCrvCheck) const +SurfRoughing::SimplifyCurve( ICurveComposite* pCompo, const ICRVCOMPOPOVECTOR& vCrvCheck, const Frame3d& frLocXY) const { // controllo dei parametri if ( pCompo == nullptr || ! pCompo->IsValid()) return false ; - // ricavo il punto iniziale e finale - Point3d ptStart ; pCompo->GetStartPoint( ptStart) ; - Point3d ptEnd ; pCompo->GetEndPoint( ptEnd) ; - - // eseguo le modifiche su una copia della curva originale - PtrOwner pCompoCL( CloneCurveComposite( pCompo)) ; - if ( IsNull( pCompoCL)) + // eseguo le modifiche su una copia della curva originale in locale al frameXY + PtrOwner pCompoLoc( CloneCurveComposite( pCompo)) ; + if ( IsNull( pCompoLoc)) return false ; + pCompoLoc->ToLoc( frLocXY) ; + + // ricavo il punto iniziale e finale + Point3d ptStart ; pCompoLoc->GetStartPoint( ptStart) ; + Point3d ptEnd ; pCompoLoc->GetEndPoint( ptEnd) ; // merge per uniformità - bool bOk = pCompoCL->MergeCurves( 200 * EPS_SMALL, 200 * EPS_ANG_SMALL, false) ; + bool bOk = pCompoLoc->MergeCurves( 200. * EPS_SMALL, 200. * EPS_ANG_SMALL, false) ; // rimozione Spikes o Curve Z - bOk = bOk && pCompoCL->RemoveSmallDefects( 150 * EPS_SMALL, 2 * ANG_TOL_STD_DEG, true) ; + bOk = bOk && pCompoLoc->RemoveSmallDefects( 150. * EPS_SMALL, 2. * ANG_TOL_STD_DEG, true) ; // interpolazione mediante linee ed archi PolyArc PA ; - bOk = bOk && pCompoCL->ApproxWithArcsEx( 50 * EPS_SMALL, ANG_TOL_STD_DEG, LIN_FEA_STD, PA) && - pCompoCL->Clear() && pCompoCL->FromPolyArc( PA) ; + bOk = bOk && pCompoLoc->ApproxWithArcsEx( 50. * EPS_SMALL, ANG_TOL_STD_DEG, LIN_FEA_STD, PA) && + pCompoLoc->Clear() && pCompoLoc->FromPolyArc( PA) ; // controllo aggiuntivo sui punti iniziali e finali che siano gli stessi Point3d ptNewStart, ptNewEnd ; - bOk = bOk && pCompoCL->GetStartPoint( ptNewStart) && pCompoCL->GetEndPoint( ptNewEnd) && + bOk = bOk && pCompoLoc->GetStartPoint( ptNewStart) && pCompoLoc->GetEndPoint( ptNewEnd) && AreSamePointApprox( ptNewStart, ptStart) && AreSamePointApprox( ptNewEnd, ptEnd) ; // controllo che non si siano create auto-intersezioni - SelfIntersCurve SIC( *pCompoCL) ; + SelfIntersCurve SIC( *pCompoLoc) ; bOk = bOk && ( SIC.GetCrossIntersCount() == 0) ; // controllo che non si siano create intersezioni con le altre curve in punti interni - for ( int i = 0 ; i < int( vCrvCheck.size()) && bOk ; ++ i) { - IntersCurveCurve ICC( *vCrvCheck[i], *pCompoCL) ; - for ( int j = 0 ; j < int( ICC.GetIntersCount()) && bOk ; ++ j) { - IntCrvCrvInfo aInfo ; - bOk = bOk && ICC.GetIntCrvCrvInfo( j, aInfo) ; - bOk = bOk && ( AreSamePointApprox( ptStart, aInfo.IciA[0].ptI) || - AreSamePointApprox( ptEnd, aInfo.IciA[0].ptI)) ; + for ( int i = 0 ; i < ssize( vCrvCheck) && bOk ; ++ i) { + PtrOwner pCrvCheckLocXY( CloneCurveComposite( vCrvCheck[i])) ; + bOk = bOk && ( ! IsNull( pCrvCheckLocXY)) && pCrvCheckLocXY->IsValid() ; + if ( bOk) { + pCrvCheckLocXY->ToLoc( frLocXY) ; + IntersCurveCurve ICC( *pCrvCheckLocXY, *pCompoLoc) ; + for ( int j = 0 ; j < ICC.GetIntersCount() && bOk ; ++ j) { + IntCrvCrvInfo aInfo ; + bOk = ICC.GetIntCrvCrvInfo( j, aInfo) ; + bOk = bOk && ( AreSamePointApprox( ptStart, aInfo.IciA[0].ptI) || + AreSamePointApprox( ptEnd, aInfo.IciA[0].ptI)) ; + } } } // se tutto bene, sostiuisco la curva originale con la modificata - if ( bOk) - pCompo->CopyFrom( pCompoCL) ; + if ( bOk) { + pCompoLoc->ToGlob( frLocXY) ; + pCompo->CopyFrom( pCompoLoc) ; + } return true ; } @@ -4345,12 +4353,17 @@ SurfRoughing::SimplyfySfr( ISurfFlatRegion* pSfr) const return false ; ICRVCOMPOPOVECTOR vCrvEmpty ; + // recupero il frame localeXY della regione piana + Frame3d frLoc ; + Point3d ptC ; pSfr->GetCentroid( ptC) ; + frLoc.Set( ptC, pSfr->GetNormVersor()) ; + // scorro tutti i loops di tutte le parti for ( int nC = 0 ; nC < pSfr->GetChunkCount() ; ++ nC) { for ( int nL = 0 ; nL < pSfr->GetLoopCount( nC) ; ++ nL) { // recupero la curva di Loop e la semplifico PtrOwner pCompoLoop( ConvertCurveToComposite( pSfr->GetLoop( nC, nL))) ; - if ( IsNull( pCompoLoop) || ! SimplifyCurve( pCompoLoop, vCrvEmpty)) + if ( IsNull( pCompoLoop) || ! SimplifyCurve( pCompoLoop, vCrvEmpty, frLoc)) return false ; // inserisco le curve nella nuova regione (il primo loop di ogni parte è esterno) if ( nL == 0) { @@ -4458,6 +4471,11 @@ SurfRoughing::CloseOpenEdgesUnderTolerance( ISurfFlatRegion* pSfr, double dToler if ( IsNull( pSfrRegular)) return false ; + // recupero il frame locale XY della superficie + Frame3d frLoc ; + Point3d ptC ; pSfr->GetCentroid( ptC) ; + frLoc.Set( ptC, pSfr->GetNormVersor()) ; + // scorro tutti i chunk della superficie for ( int nC = 0 ; nC < pSfr->GetChunkCount() ; ++ nC) { // creo una superficie di test @@ -4488,7 +4506,7 @@ SurfRoughing::CloseOpenEdgesUnderTolerance( ISurfFlatRegion* pSfr, double dToler // se tratto aperto e non coincidente con tutta la curva if ( vpCrvs[i]->GetTempProp( 0) == TEMP_PROP_OPEN_EDGE && int( vpCrvs.size()) != 1) { // semplifico il loop per avere curve più uniformi - SimplifyCurve( vpCrvs[i], vCrvClose) ; + SimplifyCurve( vpCrvs[i], vCrvClose, frLoc) ; // riporto le proprietà vpCrvs[i]->SetTempProp( TEMP_PROP_OPEN_EDGE) ; for ( int j = 0 ; j < vpCrvs[i]->GetCurveCount() ; ++ j) diff --git a/SurfRoughing.h b/SurfRoughing.h index 887593c..2906f22 100644 --- a/SurfRoughing.h +++ b/SurfRoughing.h @@ -222,7 +222,7 @@ class SurfRoughing : public Machining bool CloseOpenEdgesUnderTolerance( ISurfFlatRegion* pSfr, double dToler) ; bool ModifySurfForOpenCloseEdges( ISurfFlatRegion* pSfr, const Vector3d& vtTool, const ICurveComposite* pCrvCompo) const ; bool ChooseCloseOrOpenEdge( ISurfFlatRegion* pSfr, const ISurfFlatRegion* pSfrRef) const ; - bool SimplifyCurve( ICurveComposite* pCompo, const ICRVCOMPOPOVECTOR& vCrvCheck) const ; + bool SimplifyCurve( ICurveComposite* pCompo, const ICRVCOMPOPOVECTOR& vCrvCheck, const Frame3d& frLocXY) const ; bool SimplyfySfr( ISurfFlatRegion* pSfr) const ; bool CheckSafetyLinearLink( const Point3d& ptCurr, const Point3d& ptDest, const ISurfFlatRegion* pSfrCheck, const Vector3d& vtTool, bool& bSafe) const ;