From 25e2a903c77139e8b7304d0d5dcc09caa19231eb Mon Sep 17 00:00:00 2001 From: Riccardo Elitropi Date: Fri, 19 Jun 2026 08:53:09 +0200 Subject: [PATCH] EgtGeomKernel : - in CalcPocketing aggiunto parametro bOpenOutRaw. --- CalcPocketing.cpp | 87 +++++++++++++++++++++++++---------------------- 1 file changed, 47 insertions(+), 40 deletions(-) diff --git a/CalcPocketing.cpp b/CalcPocketing.cpp index a5fb0ca..1500680 100644 --- a/CalcPocketing.cpp +++ b/CalcPocketing.cpp @@ -68,6 +68,7 @@ struct PocketParams { bool bAvoidOpt = false ; // flag per evitare casi ottimizzati bool bConventionalMilling = true ; // flag per Conventional Milling Vs Climb Milling per svuotature a curva singola bool bAllowZigZagOneWayBorders = false ; // flag per abilitare le curve di bordo per ZigZag/OneWay + bool bOpenOutRaw = false ; // flag per disabilitare controllo per ingresso per regione limite Point3d ptStart = P_INVALID ; // punto d'inizio Point3d ptEnd = P_INVALID ; // punto di fine SurfFlatRegion SfrLimit ; // superficie limite per estensione lati aperti @@ -1078,48 +1079,48 @@ GetExtendPathLen( const PocketParams& PockParam) { double dDistToolCenterWithMaterial = PockParam.dOpenEdgeRad - PockParam.dRad - PockParam.dRadialOffset ; double dOutDist = Clamp( PockParam.dRad - dDistToolCenterWithMaterial, 0., PockParam.dRad) ; - return dOutDist + PockParam.dOpenMinSafe ; + return ( dOutDist + PockParam.dOpenMinSafe) ; } //---------------------------------------------------------------------------- static bool -ExtendPath( ICurveComposite* pCompo, const ISurfFlatRegion* pSfr, const PocketParams& PockParams, - const Vector3d& vtFirstOut, bool bEndOrStart, double dExtension, bool& bOkExtended) +ExtendPath( ICurveComposite* pCompo, const ISurfFlatRegion* pSfr, const PocketParams& PockParams, const Vector3d& vtFirstOut, + bool bEndOrStart, double dExtension, bool& bOkExtended) { /* Estensione della curva pCompo con un segmento lineare. bEndOrStart: definisce se la curva va estesa all'inizio o alla fine - vtFirstOut: prima direzione su cui tentare l'entrata, se questa non andasse bene - ruoto progressivamente di 90° - La curva viene estesa di un tratto lineare in direzione vtRotOut per una lunghezza - pari a Rad + OffsR + OpenMinSafe. + vtFirstOut: prima direzione su cui tentare l'entrata, se questa non andasse bene ruoto progressivamente di 45° + La curva viene estesa di un tratto lineare in direzione vtRotOut per una lunghezza pari a Rad + OffsR + OpenMinSafe. */ // controllo dei parametri - if ( pCompo == nullptr || ! pCompo->IsValid() || - pSfr == nullptr || ! pSfr->IsValid()) + if ( pCompo == nullptr || ! pCompo->IsValid() || pSfr == nullptr || ! pSfr->IsValid()) return false ; bOkExtended = false ; // recupero il punto iniziale/finale della curva con versore tangente Point3d pt ; - Vector3d vtTan ; if ( bEndOrStart) { - if ( ! pCompo->GetEndPoint( pt) || ! pCompo->GetEndDir( vtTan)) + if ( ! pCompo->GetEndPoint( pt)) return false ; } else { - if ( ! pCompo->GetStartPoint( pt) || ! pCompo->GetStartDir( vtTan)) + if ( ! pCompo->GetStartPoint( pt)) return false ; - vtTan.Invert() ; } // angoli di rotazione ( potrebbero servirne altri) const double ANG_45 = ANG_RIGHT / 2. ; const array vAngles{ 0., ANG_RIGHT, 3 * ANG_RIGHT, ANG_45, 3 * ANG_45, 5 * ANG_45, 7 * ANG_45} ; + // -->! NB. Nel punto di caduta dell'utensile la distanza deve comprendere dOpenMinSafe per entrambe le regioni + // NB. Durante il movimento del tratto lineare che collega il punto di caduta con il punto sulla curva corrente la dOpenMinSafe + // NON DEVE essere considerata, in quanto mi avvicino alla superficie da svuotare. La distanza deve essere sempre il raggio + // utensile dalla limite, senza considerare la pSfr !<-- + // ruoto il versore di uscita cercando un'entrata valida - double dMinDist = 0. ; + double dMinDist = PockParams.dRad - 10. * EPS_SMALL ; for ( int i = 0 ; i < ssize( vAngles) ; ++ i) { // ruoto il versore d'uscita Vector3d vtRotOut = GetRotate( vtFirstOut, Z_AX, - vAngles[i]) ; @@ -1129,12 +1130,17 @@ ExtendPath( ICurveComposite* pCompo, const ISurfFlatRegion* pSfr, const PocketPa bool bInside = true ; bool bOkOut = true ; if ( PockParams.SfrLimit.IsValid()) { - bOkOut = ( IsPointInsideSurfFr( ptFall, &PockParams.SfrLimit, dMinDist - 10. * EPS_SMALL, bInside) && ! bInside) ; + bOkOut = ( PockParams.bOpenOutRaw || + ( IsPointInsideSurfFr( ptFall, &PockParams.SfrLimit, dMinDist + PockParams.dOpenMinSafe, bInside) && ! bInside)) ; + // testo anche il punto medio per sicurezza di movimento lungo il tragitto (sempre per la limite) if ( bOkOut) - bOkOut = ( IsPointInsideSurfFr( Media( ptFall, pt), &PockParams.SfrLimit, dMinDist - 10. * EPS_SMALL, bInside) && ! bInside) ; + bOkOut = ( PockParams.bOpenOutRaw || + ( IsPointInsideSurfFr( Media( ptFall, pt), &PockParams.SfrLimit, dMinDist, bInside) && ! bInside)) ; } + // se fuori dalla limite, testo la superficie di svuotatura if ( bOkOut) - bOkOut = ( IsPointInsideSurfFr( ptFall, pSfr, dMinDist, bInside) && ! bInside) ; + bOkOut = ( PockParams.bOpenOutRaw || + ( IsPointInsideSurfFr( ptFall, pSfr, dMinDist + PockParams.dOpenMinSafe, bInside) && ! bInside)) ; if ( bOkOut) { // aggiungo al ritorno l'uscita pCompo->AddLine( ptFall, bEndOrStart) ; @@ -1854,8 +1860,7 @@ ChainCompoCurves( ICRVCOMPOPOVECTOR& vCrvCompo) //---------------------------------------------------------------------------- static bool -ChangePtStartForSinglePocketCurve( ICurveComposite* pCrvCompo, const PocketParams& PockParams, - const Point3d& ptRef, bool bInvertOpenCrv) +ChangePtStartForSinglePocketCurve( ICurveComposite* pCrvCompo, const PocketParams& PockParams, const Point3d& ptRef, bool bInvertOpenCrv) { // controllo dei parametri if ( pCrvCompo == nullptr || ! pCrvCompo->IsValid()) @@ -1899,8 +1904,7 @@ ChangePtStartForSinglePocketCurve( ICurveComposite* pCrvCompo, const PocketParam //---------------------------------------------------------------------------- static bool -AdvanceExtendCurves( ICRVCOMPOPOVECTOR& vCrvCompo, const ISurfFlatRegion* pSfr, - const PocketParams& PockParams, bool bInvertOpenCrv) +AdvanceExtendCurves( ICRVCOMPOPOVECTOR& vCrvCompo, const ISurfFlatRegion* pSfr, const PocketParams& PockParams, bool bInvertOpenCrv) { // se non ho curve, allora non faccio nulla if ( vCrvCompo.empty()) @@ -1921,11 +1925,15 @@ AdvanceExtendCurves( ICRVCOMPOPOVECTOR& vCrvCompo, const ISurfFlatRegion* pSfr, return true ; /* - L'estensione della curva permettendo un'entrata da fuori è valida se il - nuovo punto di Inizio ( ptFall) : + L'estensione della curva permettendo un'entrata da fuori è valida se il nuovo punto di Inizio (ptFall) : - E' al di fuori della superficie Limite ( di almeno Rad + OffsR) - E' al di fuori della superifice di svuotatura ( di almeno dRad + OffsR) */ + /* + - Se la curva è aperta, allora posso estendere l'ingresso e (se inversione ammessa) l'uscita + - Se la curva è chiusa, allora l'ingresso potrebbe avvenire in un qualsiasi punto di essa. Per ora ci limitiamo + a campionarla ad intervalli di 1/4 della sua lunghezza e a cercare la prima entrata valida a partire da questi punti + */ // scorro ogni singola curva composita const int MAX_ITER = 4 ; @@ -1969,8 +1977,8 @@ AdvanceExtendCurves( ICRVCOMPOPOVECTOR& vCrvCompo, const ISurfFlatRegion* pSfr, } //---------------------------------------------------------------------------- static bool -GetPocketCurvesByClosedEdges( const ISurfFlatRegion* pSfrChunk, const PocketParams& PockParams, - ICRVCOMPOPOVECTOR& vCrvCompoRes, bool& bAllRemoved) +GetPocketCurvesByClosedEdges( const ISurfFlatRegion* pSfrChunk, const PocketParams& PockParams, ICRVCOMPOPOVECTOR& vCrvCompoRes, + bool& bAllRemoved) { // controllo parametri if ( pSfrChunk == nullptr || ! pSfrChunk->IsValid()) @@ -2013,7 +2021,7 @@ GetPocketCurvesByClosedEdges( const ISurfFlatRegion* pSfrChunk, const PocketPara } } // CASO PARTICOLARE : Tunnel ( 2 tratti open e due tratto chiusi) -> non uso le curve singole - if ( int( vpCrvs.size() == 4)) + if ( ssize( vpCrvs) == 4) return true ; // controllo se il loop Esterno è uniforme ( quindi tutto chiuso o tutto aperto) bool bExtAllClose = false ; @@ -2115,11 +2123,11 @@ GetPocketCurvesByClosedEdges( const ISurfFlatRegion* pSfrChunk, const PocketPara if ( IsNull( pSfrNotRemoved) || ! pSfrNotRemoved->IsValid()) return false ; double dOffs = PockParams.dRad + PockParams.dRadialOffset + 50. * EPS_SMALL ; - double dTol = 25. * EPS_SMALL ; + const double NORMAL_TOL = 25. * EPS_SMALL ; for ( int i = 0 ; i < ssize( vCrvCompoResTmp) ; ++ i) { PtrOwner pSfrRemoved( GetSurfFlatRegionFromFatCurve( CloneCurveComposite( vCrvCompoResTmp[i]), dOffs, false, false)) ; if ( ! IsNull( pSfrRemoved) && pSfrRemoved->IsValid()) { - if ( AreOppositeVectorEpsilon( pSfrRemoved->GetNormVersor(), pSfrNotRemoved->GetNormVersor(), dTol)) + if ( AreOppositeVectorEpsilon( pSfrRemoved->GetNormVersor(), pSfrNotRemoved->GetNormVersor(), NORMAL_TOL)) pSfrRemoved->Invert() ; pSfrNotRemoved->Subtract( *pSfrRemoved) ; } @@ -2128,7 +2136,7 @@ GetPocketCurvesByClosedEdges( const ISurfFlatRegion* pSfrChunk, const PocketPara if ( vpCrvs[i]->GetTempProp( 0) == TEMP_PROP_CLOSE_EDGE) { PtrOwner pSfrRemoved( GetSurfFlatRegionFromFatCurve( CloneCurveComposite( vpCrvs[i]), dOffs, false, false)) ; if ( ! IsNull( pSfrRemoved) && pSfrRemoved->IsValid()) { - if ( AreOppositeVectorEpsilon( pSfrRemoved->GetNormVersor(), pSfrNotRemoved->GetNormVersor(), dTol)) + if ( AreOppositeVectorEpsilon( pSfrRemoved->GetNormVersor(), pSfrNotRemoved->GetNormVersor(), NORMAL_TOL)) pSfrRemoved->Invert() ; pSfrNotRemoved->Subtract( *pSfrRemoved) ; } @@ -2150,7 +2158,8 @@ GetPocketCurvesByClosedEdges( const ISurfFlatRegion* pSfrChunk, const PocketPara if ( IsNull( pSfrLimit) || ! pSfrLimit->IsValid()) return false ; // effettuo un Offset della regione, tutto ciò che dista più del raggio utensile non la rovina - pSfrLimit->Offset( PockParams.dRad + PockParams.dRadialOffset - dTol, ICurve::OFF_FILLET) ; // c'è un offset radiale, quindi tengo tolleranza alta + const double SURF_OFFS_TOL = 25. * EPS_SMALL ; + pSfrLimit->Offset( PockParams.dRad + PockParams.dRadialOffset - SURF_OFFS_TOL, ICurve::OFF_FILLET) ; // c'è un offset radiale, quindi tengo tolleranza alta ICRVCOMPOPOVECTOR vCrvCompoResTmpSplitted ; for ( int i = 0 ; i < ssize( vCrvCompoResTmp) ; ++ i) { CRVCVECTOR ccClass ; @@ -3867,8 +3876,7 @@ CalcTrapezoidSpiral( ICurveComposite* pCrvPocket, const Frame3d& frTrap, double //---------------------------------------------------------------------------- static bool -AdjustTrapeziodLeadIn( ICurveComposite* pCrvRes, const PocketParams& PockParam, - const ISurfFlatRegion* pSfrChunk) +AdjustTrapeziodLeadIn( ICurveComposite* pCrvRes, const PocketParams& PockParam, const ISurfFlatRegion* pSfrChunk) { // recupero la TempProp int nTmpProp = pCrvRes->GetTempProp( 0) ; @@ -3917,8 +3925,7 @@ AdjustTrapeziodLeadIn( ICurveComposite* pCrvRes, const PocketParams& PockParam, //---------------------------------------------------------------------------- static bool -GetZigZagOptimizedCurves( const ISurfFlatRegion* pSfrChunk, const PocketParams& PockParam, - ICurveComposite* pCrvRes) +GetZigZagOptimizedCurves( const ISurfFlatRegion* pSfrChunk, const PocketParams& PockParam, ICurveComposite* pCrvRes) { // controllo dei parametri if ( pSfrChunk == nullptr || ! pSfrChunk->IsValid()) @@ -9937,11 +9944,10 @@ CalcSpiralPocketing( const ISurfFlatRegion* pSfr, int nType, const PocketParams& return ( CalcPocketing( pSfr, PockParams.dRad, PockParams.dRadialOffset, PockParams.dSideStep, PockParams.dAngle, PockParams.dOpenMinSafe, nType, PockParams.bSmooth, PockParams.bCalcUnclearedRegs, PockParams.bInvert, PockParams.bAvoidOpt, - PockParams.bConventionalMilling, PockParams.bAllowZigZagOneWayBorders, PockParams.bCalcFeed, PockParams.ptStart, - pSfrLimit, PockParams.bAvoidOpt, PockParams.dMaxOptSize, - PockParams.nLiType, PockParams.dLiTang, PockParams.dLiElev, PockParams.nLoType, PockParams.dLoTang, - PockParams.bPolishing, PockParams.dEpicyclesRad, PockParams.dEpicyclesDist, PockParams.bToolCompensation, - vCrvCompoRes)) ; + PockParams.bConventionalMilling, PockParams.bAllowZigZagOneWayBorders, PockParams.bOpenOutRaw, PockParams.bCalcFeed, + PockParams.ptStart, pSfrLimit, PockParams.bAvoidOpt, PockParams.dMaxOptSize, PockParams.nLiType, PockParams.dLiTang, + PockParams.dLiElev, PockParams.nLoType, PockParams.dLoTang, PockParams.bPolishing, PockParams.dEpicyclesRad, + PockParams.dEpicyclesDist, PockParams.bToolCompensation, vCrvCompoRes)) ; } //---------------------------------------------------------------------------- @@ -10295,7 +10301,7 @@ AddContours( const ISurfFlatRegion* pSfrOrig, PocketParams& PockParams, ICRVCOMP bool CalcPocketing( const ISurfFlatRegion* pSfr, double dRad, double dRadOffs, double dStep, double dAngle, double dOpenMinSafe, int nType, bool bSmooth, bool bCalcUnclReg, bool bInvert, bool bAvoidOpt, - bool bConventionalMilling, bool bAllowZigZagOneWayBorders, bool bCalcFeed, const Point3d& ptEndPrec, + bool bConventionalMilling, bool bAllowZigZagOneWayBorders, bool bOpenOutRaw, bool bCalcFeed, const Point3d& ptEndPrec, const ISurfFlatRegion* pSfrLimit, bool bAllOffs, double dMaxOptSize, int nLiType, double dLiTang, double dLiElev, int nLoType, double dLoTang, bool bPolishing, double dEpicyclesRad, double dEpicyclesDist, bool bContour, ICRVCOMPOPOVECTOR& vCrvCompoRes) @@ -10326,6 +10332,7 @@ CalcPocketing( const ISurfFlatRegion* pSfr, double dRad, double dRadOffs, double myParams.bCalcFeed = bCalcFeed ; myParams.bConventionalMilling = bConventionalMilling ; myParams.bAllowZigZagOneWayBorders = bAllowZigZagOneWayBorders ; + myParams.bOpenOutRaw = bOpenOutRaw ; myParams.bOptOffsets = ( ! bAllOffs) ; myParams.dMaxOptSize = dMaxOptSize ; myParams.nLiType = nLiType ;