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

EgtGeomKernel :

Browse Source 
- in CalcPocketing aggiunto parametro bOpenOutRaw.
This commit is contained in:
Riccardo Elitropi
2026-06-19 08:53:09 +02:00
parent 8e18211735
commit 25e2a903c7
1 changed files with 47 additions and 40 deletions
Download Patch File Download Diff File Expand all files Collapse all files
CalcPocketing.cpp
+47 -40
View File
@@ -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<ISurfFlatRegion> 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<ISurfFlatRegion> 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 ;