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

Merge commit '2a2b0e5d7eb846e93cf590d8d91d0a5e17317797'

Browse Source
This commit is contained in:
Dario Sassi
2024-10-02 17:40:11 +02:00
parent 93598217a4 2a2b0e5d7e
commit edd3f623c7
2 changed files with 145 additions and 178 deletions
Download Patch File Download Diff File Expand all files Collapse all files
SurfRoughing.cpp
+132 -168
View File
@@ -35,14 +35,12 @@
#include "/EgtDev/Include/EGkStringUtils3d.h"
#include "/EgtDev/Include/EGkUserObjFactory.h"
#include "/EgtDev/Include/EGnStringKeyVal.h"
#include "/EgtDev/Include/EgtPointerOwner.h"
#include "/EgtDev/Include/EGkDistPointCurve.h"
#include "/EgtDev/Include/EGkDistPointSurfFr.h"
#include "/EgtDev/Include/EGkCurveAux.h"
#include "/EgtDev/Include/EGkDistPointSurfTm.h"
#include "/EgtDev/Include/EGkIntersPlaneSurfTm.h"
#include "/EgtDev/Include/EGkStmFromCurves.h"
#include "/EgtDev/Include/EXeExecutor.h"
// per far dimenticare macro di WinUser.h
#undef GetClassName
@@ -80,6 +78,7 @@ using namespace std ;
// 3029 = "Error in SurfRoughing : Error in Classifying border"
// 3029 = "Error in SurfRoughing : Simplify Chunks for SubSteps failed"
// 3030 = "Error in SurfRoughing : Conformal ZigZag not valid at step (xx)"
// 3131 = "Error in SurfRoughing : LeadIn with Mill NoTip in material"
// 3051 = "Warning in SurfRoughing : Skipped entity (xx)"
// 3052 = "Warning in SurfRoughing : No machinable path"
// 3053 = "Warning in SurfRoughing : Tool name changed (xx)"
@@ -1244,8 +1243,19 @@ SurfRoughing::ProcessPath( int nPathId, int nTempId, int nPvId, int nClId)
}
// inizializzo la classe di intersezione tra grezzo e piani paralleli ( quelli di lavoro)
// traslo leggermente il grezzo per gestire il primo e l'ultimo Step
pStmRaw->Translate( - vtTool * 5 * EPS_SMALL) ;
IntersParPlanesSurfTm IPPStm( fr_pCompo, *pStmRaw) ;
// costruisco una superficie di estrusione della curva (devo determinare parte della regione limite)
Vector3d vtLimitExtr = - vtTool * 1.5 * max( b3Raw.GetDimX(), max( b3Raw.GetDimY(), b3Raw.GetDimZ())) ;
PtrOwner<ISurfTriMesh> pStmLimit( GetStmOutSideCompo( pCompo, pStmRaw, vtLimitExtr)) ;
if ( IsNull( pStmLimit))
return false ;
// inizializzo la classe di intersezione tra la superficie trimesh limite e piani paralleli ( quelli di lavoro)
IntersParPlanesSurfTm IPPStm1( fr_pCompo, *pStmLimit) ;
// inizializzo la classe di calcolo delle silhouette nei piani come sopra
SURFLOCALVECTOR vSurfL ; vSurfL.reserve( vSurfId.size()) ;
CISURFTMPVECTOR vpStm ; vpStm.reserve( vSurfId.size()) ;
@@ -1381,6 +1391,18 @@ SurfRoughing::ProcessPath( int nPathId, int nTempId, int nPvId, int nClId)
else
continue ; // step fuori dal grezzo, passo al successivo
/* ***************** Regione piana esterna a pCompo ****************** */
PtrOwner<ISurfFlatRegion> pSfrOutCompo( CreateSurfFlatRegion()) ;
if ( IsNull( pSfrOutCompo))
return false ;
if ( pStmLimit->IsValid() && pStmLimit->GetTriangleCount() > 0) {
pSfrOutCompo.Set( GetSfrByStmIntersection( IPPStm1, it->dDepth + GetOffsL(), 0)) ;
if ( IsNull( pSfrRaw)) {
m_pMchMgr->SetLastError( 3027, "Error in SurfRoughing : Slicing Raw failed") ;
return false ;
}
}
/* *************************** Silhouette **************************** */
// determino la regione da non lavorare e la sottraggo
POLYLINEVECTOR vPL ;
@@ -1388,7 +1410,6 @@ SurfRoughing::ProcessPath( int nPathId, int nTempId, int nPvId, int nClId)
m_pMchMgr->SetLastError( 3024, "Error in SurfRoughing : region not computable") ;
return false ;
}
// creo la regione piana dalle PolyLine ricavate dalla Silhouette
SurfFlatRegionByContours SfrMaker ;
for ( auto& PL : vPL) {
@@ -1481,12 +1502,6 @@ SurfRoughing::ProcessPath( int nPathId, int nTempId, int nPvId, int nClId)
it->pSfrRemoved = nullptr ;
continue ;
}
// estendo la superficie di riferimento considerando le sottocurve chiuse della
// curva di sgrossatura
if ( ! ModifySurfRefForOpenCloseEdges( pSfrOpenClose, pCompoPocket)) {
m_pMchMgr->SetLastError( 3026, "Error in SurfRoughing : Detecting open edges failed") ;
return false ;
}
}
// determino i lati aperti ( mediante vicinanza dei tratti di curva al volume progressivo non svuotato)
@@ -1526,10 +1541,21 @@ SurfRoughing::ProcessPath( int nPathId, int nTempId, int nPvId, int nClId)
m_pGeomDB->SetMaterial( nNew_SfrPock_Id, GREEN) ;
m_pGeomDB->SetName( nNew_SfrPock_Id, KEY_SURF_POCK + ToString( nPocket)) ;
// nel gruppo temporaneo salvo anche la Shilouette ( per superficie Limite)
// nel gruppo temporaneo salvo anche la superficie Limite)
int nNew_SfrLimit_Id = GDB_ID_NULL ;
PtrOwner<ISurfFlatRegion> pSfrLimit( CreateSurfFlatRegion()) ;
if ( IsNull( pSfrLimit))
return false ;
if ( ! IsNull( pSfrOutCompo) && pSfrOutCompo->IsValid())
pSfrLimit.Set( pSfrOutCompo) ;
if ( ! IsNull( pSfrSil) && pSfrSil->IsValid()) {
nNew_SfrLimit_Id = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nTempId, Release( pSfrSil)) ;
if ( ! IsNull( pSfrLimit) && pSfrLimit->IsValid())
pSfrLimit->Add( *pSfrSil) ;
else
pSfrLimit.Set( pSfrSil) ;
}
if ( ! IsNull( pSfrLimit) && pSfrLimit->IsValid()) {
nNew_SfrLimit_Id = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nTempId, Release( pSfrLimit)) ;
if ( nNew_SfrLimit_Id == GDB_ID_NULL) {
m_pMchMgr->SetLastError( 3024, "Error in SurfRoughing : region not computable") ;
return false ;
@@ -1614,6 +1640,62 @@ SurfRoughing::GetRaw( void) const
return ( ( pStmRaw->IsValid() && pStmRaw->GetTriangleCount() > 0) ? Release( pStmRaw) : nullptr) ;
}
//----------------------------------------------------------------------------
ISurfTriMesh*
SurfRoughing::GetStmOutSideCompo( ICurveComposite* pCompo, const ISurfTriMesh* pStmRaw, const Vector3d& vtExtr) const
{
// controllo dei parametri
if ( pCompo == nullptr || ! pCompo->IsValid() ||
pStmRaw == nullptr || ! pStmRaw->IsValid())
return nullptr ;
// recupero la PolyLine dalla curva
PolyLine PL ;
pCompo->ApproxWithLines( 10 * EPS_SMALL, 15, ICurve::APL_STD, PL) ;
// determino la superficie di estrusione
PtrOwner<ISurfTriMesh> pStmExtr( CreateSurfTriMesh()) ;
bool bOk = ( ! IsNull( pStmExtr)) ;
bOk = bOk && pStmExtr->AdjustTopology() ;
bOk = bOk && pStmExtr->CreateByExtrusion( PL, vtExtr) ;
bOk = bOk && ( pStmExtr->IsValid() && pStmExtr->GetTriangleCount() > 0) ;
if ( ! bOk)
return nullptr ;
// aggiungo i caps
PtrOwner<ISurfTriMesh> pStmCap0( CreateSurfTriMesh()) ;
bOk = ( ! IsNull( pStmCap0)) ;
bOk = bOk && pStmCap0->CreateByFlatContour( PL) ;
bOk = bOk && ( pStmCap0->IsValid() && pStmCap0->GetTriangleCount() > 0) ;
if ( ! bOk)
return nullptr ;
Vector3d vtN ; pStmCap0->GetFacetNormal( 0, vtN) ;
Vector3d vtN_ref = vtExtr ; vtN_ref.Normalize() ;
if ( AreOppositeVectorApprox( vtN, vtN_ref))
pStmCap0->Invert() ;
PtrOwner<ISurfTriMesh> pStmCap1( CloneSurfTriMesh( pStmCap0)) ;
bOk = ( ! IsNull( pStmCap1) && pStmCap1->IsValid() && pStmCap1->GetTriangleCount() > 0) ;
bOk = bOk && ( pStmCap1->Translate( vtExtr) && pStmCap1->Invert()) ;
bOk = bOk && pStmExtr->DoSewing( *pStmCap0) ;
bOk = bOk && pStmExtr->DoSewing( *pStmCap1) ;
if ( ! bOk)
return nullptr ;
// la superficie deeve definire un volume
double dVol = 0. ; pStmExtr->GetVolume( dVol) ;
if ( dVol < EPS_ZERO)
pStmExtr->Invert() ;
// sottraggo al grezzo la regione di estrusione
PtrOwner<ISurfTriMesh> pStmLimit( CloneSurfTriMesh( pStmRaw)) ;
bOk = ! IsNull( pStmLimit) ;
bOk = bOk && pStmLimit->IsValid() ;
bOk = bOk && pStmLimit->Subtract( *pStmExtr) ;
if ( ! bOk)
return nullptr ;
return Release( pStmLimit) ;
}
//----------------------------------------------------------------------------
ISurfFlatRegion*
SurfRoughing::GetSfrByStmIntersection( const IntersParPlanesSurfTm& IPPStm, double dDist, double dSmallOffs) const
@@ -1746,14 +1828,14 @@ SurfRoughing::GetActiveSurfaces( INTVECTOR& vSurfId) const
//----------------------------------------------------------------------------
bool
SurfRoughing::CalcPaths( const INTINTVECTOR& vPocket, const ICRVCOMPOPOVECTOR& vCrvPocketCompo,
STEPINFOVECTOR& vStepInfo) const
STEPINFOSRVECTOR& vStepInfo) const
{
/*
funzione per calcolo dei percorsi di Pockets e delle loro proprietà
*/
// inizializzo vettore dei percorsi
vStepInfo.clear() ; vStepInfo.resize( int( vPocket.size())) ;
vStepInfo.resize( vPocket.size()) ;
// punto finale di riferimento per il percorso attuale ( serve per trovare il punto iniziale
// del percorso successivo)
@@ -1857,15 +1939,11 @@ SurfRoughing::CalcPaths( const INTINTVECTOR& vPocket, const ICRVCOMPOPOVECTOR& v
vStepInfo[nInd].vPaths[i].bOutStart = ( vCrvPaths[i]->GetCurveCount() > 0 &&
vCrvPaths[i]->GetFirstCurve()->GetTempProp( 0) == TEMP_PROP_OUT_START) ;
// controllo se il punto di ingresso è valido
bool bValidOutLeadIn = true ;
if ( vStepInfo[nInd].vPaths[i].bOutStart) {
if ( ! VerifyLeadInLeadOut( vCrvPaths[i]->GetFirstCurve(), vStepInfo[nInd].pCompo, bValidOutLeadIn))
// se utensile che non lavora di testa e ingresso non fuori dal pezzo, errore
if ( m_TParams.m_nType == TT_MILL_NOTIP && ! vStepInfo[nInd].vPaths[i].bOutStart) {
if ( ! LeadInRawIsOk()) {
m_pMchMgr->SetLastError( 2431, "Error in SurfRoughing : LeadIn with Mill NoTip in material") ;
return false ;
if ( ! bValidOutLeadIn) {
// se non valido, rimuovo il primo tratto
vStepInfo[nInd].vPaths[i].bOutStart = false ;
vCrvPaths[i]->RemoveFirstOrLastCurve( false) ;
}
}
@@ -1873,16 +1951,6 @@ SurfRoughing::CalcPaths( const INTINTVECTOR& vPocket, const ICRVCOMPOPOVECTOR& v
bool bOutEnd = ( vCrvPaths[i]->GetCurveCount() > 0 &&
vCrvPaths[i]->GetLastCurve()->GetTempProp( 0) == TEMP_PROP_OUT_START) ;
// controllo se il punto d'uscita va limitata
bool bValidOutLeadOut = true ;
if ( bOutEnd) {
if ( ! VerifyLeadInLeadOut( vCrvPaths[i]->GetLastCurve(), vStepInfo[nInd].pCompo, bValidOutLeadOut))
return false ;
// se non valido, rimuovo l'ultimo tratto
if ( ! bValidOutLeadOut)
vCrvPaths[i]->RemoveFirstOrLastCurve( true) ;
}
// controllo se il percorso è formato da una singola curva seguente il lato chiuso
vStepInfo[nInd].vPaths[i].bSingleCrv = ( vCrvPaths[i]->GetCurveCount() > 0 &&
vCrvPaths[i]->GetTempProp( 0) == TEMP_PROP_SINGLE_CURVE) ;
@@ -1941,7 +2009,7 @@ SurfRoughing::AddPocket( const INTINTVECTOR& vPocket, const Vector3d& vtTool, co
return true ;
// calcolo i percorsi di svuotatura per ogni Step/SubStep
STEPINFOVECTOR vStepInfo ;
STEPINFOSRVECTOR vStepInfo ;
if ( ! CalcPaths( vPocket, vCrvPocketCompo, vStepInfo))
return false ;
@@ -1958,12 +2026,12 @@ SurfRoughing::AddPocket( const INTINTVECTOR& vPocket, const Vector3d& vtTool, co
for ( int i = 0 ; i < int( vStepInfo.size()) ; ++ i) {
// riferimento alle informazioni relative allo step i-esimo
StepInfo& currStep = vStepInfo[i] ;
StepInfoSR& currStep = vStepInfo[i] ;
// scorro i percorsi calcolati per il piano di pocketing i-esimo
for ( int j = 0 ; j < int( currStep.vPaths.size()) ; ++ j) {
// riferimento alle informazioni relative al percorso j-esimo del piano di pocketing i-esimo
PathInfo& currPath = currStep.vPaths[j] ;
PathInfoSR& currPath = currStep.vPaths[j] ;
// ciclo sulle curve elementari del percorso attuale
int nMaxInd = currPath.pCrvPath->GetCurveCount() - 1 ;
for ( int k = 0 ; k <= nMaxInd ; ++ k) {
@@ -2721,11 +2789,14 @@ SurfRoughing::CloseOpenEdgesUnderTolerance( ISurfFlatRegion* pSfr, double dToler
//----------------------------------------------------------------------------
bool
SurfRoughing::ModifySurfRefForOpenCloseEdges( ISurfFlatRegion* pSfrRef, const ICurveComposite* pCrvCompo) const
SurfRoughing::ModifySurfForOpenCloseEdges( ISurfFlatRegion* pSfr, const Vector3d& vtTool,
const ICurveComposite* pCrvCompo) const
{
// controllo dei parametri
if ( pSfrRef == nullptr || pCrvCompo == nullptr || ! pCrvCompo->IsValid())
if ( pSfr == nullptr || pCrvCompo == nullptr || ! pCrvCompo->IsValid())
return false ;
if ( ! pSfr->IsValid())
return true ;
/*
NB. Questa funzione è richiamata per i sub steps.
@@ -2738,15 +2809,17 @@ SurfRoughing::ModifySurfRefForOpenCloseEdges( ISurfFlatRegion* pSfrRef, const IC
ICRVCOMPOPOVECTOR vpCrvs ;
if ( ! GetHomogeneousParts( pCrvCompo, vpCrvs))
return false ;
// scorro tutti i tratti chiusi e li aggiungo alla pSfrDanger
// scorro tutti i tratti chiusi e li aggiungo alla superficie da non rovinare
for ( int i = 0 ; i < int( vpCrvs.size()) ; ++ i) {
if ( vpCrvs[i]->GetTempProp( 0) == TEMP_PROP_CLOSE_EDGE) {
vpCrvs[i]->SetExtrusion( vtTool) ;
PtrOwner<ISurfFlatRegion> pSfrFat( GetSurfFlatRegionFromFatCurve( vpCrvs[i]->Clone(), m_TParams.m_dDiam / 2, false, false)) ;
if ( ! IsNull( pSfrFat) && pSfrFat->IsValid()) {
if ( ! pSfrRef->IsValid())
pSfrRef->CopyFrom( pSfrFat) ;
else
pSfrRef->Add( *pSfrFat) ;
if ( pSfr->IsValid()) {
pSfr->Subtract( *pSfrFat) ;
if ( ! pSfr->IsValid())
return true ;
}
}
}
}
@@ -2781,13 +2854,13 @@ SurfRoughing::ChooseCloseOrOpenEdge( ISurfFlatRegion* pSfr, const ISurfFlatRegio
} ;
vector<SurfRef_Info> vSfrRef_info ;
// assegno le info dei Loop della superficie di riferimento
for ( int c = 0 ; c < pSfrRef_Offs->GetChunkCount() ; ++ c) {
for ( int l = 0 ; l < pSfrRef_Offs->GetLoopCount( c) ; ++ l) {
for ( int nC = 0 ; nC < pSfrRef_Offs->GetChunkCount() ; ++ nC) {
for ( int nL = 0 ; nL < pSfrRef_Offs->GetLoopCount( nC) ; ++ nL) {
SurfRef_Info mySurfRef_Info ;
mySurfRef_Info.bIsExternal = ( l == 0) ;
mySurfRef_Info.bIsExternal = ( nL == 0) ;
if ( mySurfRef_Info.bIsExternal)
mySurfRef_Info.nInternalLoops = pSfrRef_Offs->GetLoopCount( c) - 1 ;
PtrOwner<ICurve> pCrv( pSfrRef_Offs->GetLoop( c, l)) ;
mySurfRef_Info.nInternalLoops = pSfrRef_Offs->GetLoopCount( nC) - 1 ;
PtrOwner<ICurve> pCrv( pSfrRef_Offs->GetLoop( nC, nL)) ;
pCrv->ApproxWithLines( 10 * EPS_SMALL, 15, ICurve::APL_STD, mySurfRef_Info.PL_Loop) ;
if ( ! mySurfRef_Info.bIsExternal)
mySurfRef_Info.PL_Loop.Invert() ;
@@ -2810,24 +2883,24 @@ SurfRoughing::ChooseCloseOrOpenEdge( ISurfFlatRegion* pSfr, const ISurfFlatRegio
const int NUM_POINTS = 4 ;
// scorro tutti i loop
for ( int c = 0 ; c < pSfr->GetChunkCount() ; ++ c) {
for ( int l = 0 ; l < pSfr->GetLoopCount( c) ; ++ l) {
for ( int nC = 0 ; nC < pSfr->GetChunkCount() ; ++ nC) {
for ( int nL = 0 ; nL < pSfr->GetLoopCount( nC) ; ++ nL) {
// recupero la curva composita del Loop
PtrOwner<ICurveComposite> pCrvCompoLoop( ConvertCurveToComposite( pSfr->GetLoop( c, l))) ;
PtrOwner<ICurveComposite> pCrvCompoLoop( ConvertCurveToComposite( pSfr->GetLoop( nC, nL))) ;
if ( IsNull( pCrvCompoLoop) || ! pCrvCompoLoop->IsValid())
return false ;
// scorro ogni sua sottocurva
for ( int u = 0 ; u < pCrvCompoLoop->GetCurveCount() ; ++ u) {
for ( int nU = 0 ; nU < pCrvCompoLoop->GetCurveCount() ; ++ nU) {
// metto a 1 la TmpProp della sottocurva corrente della superficie
pSfr->SetCurveTempProp( c, l, u, TEMP_PROP_OPEN_EDGE, 0) ;
pSfr->SetCurveTempProp( nC, nL, nU, TEMP_PROP_OPEN_EDGE, 0) ;
// recupero la sottocurva
const ICurve* pCrv = pCrvCompoLoop->GetCurve( u) ;
const ICurve* pCrv = pCrvCompoLoop->GetCurve( nU) ;
if ( pCrv == nullptr)
return false ;
// recupero i NUM_POINTS punti
bool bIsOut = true ;
for ( int p = 0 ; p < NUM_POINTS + 1 ; ++ p) {
double dPar = ( 1. / ( 1. * NUM_POINTS)) * p ;
for ( int nP = 0 ; nP < NUM_POINTS + 1 ; ++ nP) {
double dPar = ( 1. / ( 1. * NUM_POINTS)) * nP ;
Point3d ptPar ;
if ( ! pCrv->GetPointD1D2( dPar, ICurve::FROM_PLUS, ptPar))
return false ;
@@ -2855,7 +2928,7 @@ SurfRoughing::ChooseCloseOrOpenEdge( ISurfFlatRegion* pSfr, const ISurfFlatRegio
}
}
if ( ! bIsOut) {
pSfr->SetCurveTempProp( c, l, u, TEMP_PROP_CLOSE_EDGE, 0) ;
pSfr->SetCurveTempProp( nC, nL, nU, TEMP_PROP_CLOSE_EDGE, 0) ;
break ;
}
}
@@ -2929,62 +3002,6 @@ SurfRoughing::GetRadiusForStartEndElevation( void) const
return ( 0.5 * m_TParams.m_dTDiam + dDeltaRad) ;
}
//----------------------------------------------------------------------------
bool
SurfRoughing::AdjustPathForLeadInLeadOut( ICurveComposite* pCrvCompo, int nSubType, const ICurveComposite* pCrvPocket,
bool& bOutStart, bool& bSingleCrv, bool& bOptTrap, bool& bIsZigZagOneWayBorder) const
{
// controllo dei parametri
if ( pCrvCompo == nullptr || ! pCrvCompo->IsValid())
return false ;
// controllo se il percorso ha un ingresso presso un lato aperto
bOutStart = ( pCrvCompo->GetCurveCount() > 0 &&
pCrvCompo->GetFirstCurve()->GetTempProp( 0) == TEMP_PROP_OUT_START) ;
// controllo se il punto di ingresso è valido
bool bValidOutLeadIn = true ;
if ( bOutStart) {
if ( ! VerifyLeadInLeadOut( pCrvCompo->GetFirstCurve(), pCrvPocket, bValidOutLeadIn))
return false ;
if ( ! bValidOutLeadIn) {
// se non valido, rimuovo il primo tratto
bOutStart = false ;
pCrvCompo->RemoveFirstOrLastCurve( false) ;
}
}
// controllo se il percorso ha un'uscita presso un lato aperto
bool bOutEnd = ( pCrvCompo->GetCurveCount() > 0 &&
pCrvCompo->GetLastCurve()->GetTempProp( 0) == TEMP_PROP_OUT_START) ;
// controllo se il punto d'uscita va limitata
bool bValidOutLeadOut = true ;
if ( bOutEnd) {
if ( ! VerifyLeadInLeadOut( pCrvCompo->GetLastCurve(), pCrvPocket, bValidOutLeadOut))
return false ;
// se non valido, rimuovo l'ultimo tratto
if ( ! bValidOutLeadOut)
pCrvCompo->RemoveFirstOrLastCurve( true) ;
}
// controllo se il percorso è formato da una singola curva seguente il lato chiuso
bSingleCrv = ( pCrvCompo->GetCurveCount() > 0 &&
pCrvCompo->GetTempProp( 0) == TEMP_PROP_SINGLE_CURVE) ;
// controllo se caso ottimizzato a trapezio
bOptTrap = ( pCrvCompo->GetCurveCount() > 0 &&
pCrvCompo->GetTempProp( 0) == TEMP_PROP_OPT_TRAPEZOID) ;
// controllo se è un percorso a ZigZag/OneWay ( non curva di bordo)
bIsZigZagOneWayBorder = ( pCrvCompo->GetCurveCount() > 0 &&
( nSubType == SURFROU_SUB_ONEWAY || nSubType == SURFROU_SUB_ZIGZAG) &&
pCrvCompo->GetTempProp( 0) == TEMP_PROP_BORDER_CURVE) ;
return true ;
}
//----------------------------------------------------------------------------
bool
SurfRoughing::CheckSafetyLinearLink( const Point3d& ptCurr, const ISurfFlatRegion* pSfrLimit, const Vector3d& vtTool,
@@ -3000,6 +3017,10 @@ SurfRoughing::CheckSafetyLinearLink( const Point3d& ptCurr, const ISurfFlatRegio
if ( ! plProj.Set( ptCurr, vtTool))
return false ;
Point3d ptDestProj = ProjectPointOnPlane( ptDest, plProj) ;
if ( AreSamePointApprox( ptDestProj, ptCurr)) {
bSafe = true ;
return true ;
}
// controllo se la retta che collega ptCurr a ptDesProj è interna o esterna alla regione limite
// devo prima creare un frame Locale XY
@@ -3114,63 +3135,6 @@ SurfRoughing::GetHomogeneousParts( const ICurveComposite* pCrvCompo, ICRVCOMPOPO
}
//----------------------------------------------------------------------------
bool
SurfRoughing::VerifyLeadInLeadOut( const ICurve* pCrv, const ICurveComposite* pCrvPock, bool& bValidLeadIn) const
{
/*
Verifica se il segmento di LeadIn per entrate da fuori sia valido
*/
// controllo dei parametri
if ( pCrv == nullptr || ! pCrv->IsValid() ||
pCrvPock == nullptr || ! pCrvPock->IsValid())
return false ;
// recupero i tratti chiusi della curva di pocketing
ICRVCOMPOPOVECTOR vpCrvs ;
if ( ! GetHomogeneousParts( pCrvPock, vpCrvs))
return false ;
// porto tutto nel piano XY ( la Fat curve di una Linea è ambigua)
Frame3d frLoc ;
Point3d ptFrLoc ; pCrvPock->GetStartPoint( ptFrLoc) ;
double dArea ;
Plane3d plPlane ;
pCrvPock->GetArea( plPlane, dArea) ;
Vector3d vtFrLoc = plPlane.GetVersN() ;
if ( ! frLoc.Set( ptFrLoc, vtFrLoc))
return false ;
// porto la curva in locale
PtrOwner<ICurve> pCrvLoc( pCrv->Clone()) ;
if ( IsNull( pCrvLoc) || ! pCrvLoc->IsValid() || ! pCrvLoc->ToLoc( frLoc))
return false ;
// calcolo la Fat Curve del tratto lineare e la porto in globale
PtrOwner<ISurfFlatRegion> pSfrFat( GetSurfFlatRegionFromFatCurve( pCrvLoc->Clone(), m_TParams.m_dDiam / 2 - 50 * EPS_SMALL, false, false)) ;
if ( IsNull( pSfrFat) || ! pSfrFat->IsValid())
return false ;
bValidLeadIn = true ;
for ( int i = 0 ; i < int( vpCrvs.size()) && bValidLeadIn ; ++ i) {
// se tratto chiuso...
if ( vpCrvs[i]->GetTempProp( 0) == 0) {
// porto nel frame locale
vpCrvs[i]->ToLoc( frLoc) ;
// controllo se interseca la fat curve
CRVCVECTOR ccClass ;
if ( pSfrFat->GetCurveClassification( *vpCrvs[i], EPS_SMALL, ccClass))
bValidLeadIn = ( int( ccClass.size()) == 1 && ccClass[0].nClass == CRVC_OUT) ;
else
bValidLeadIn = false ;
}
}
return true ;
}
//----------------------------------------------------------------------------
// Debug Functions
//----------------------------------------------------------------------------
SurfRoughing.h
+13 -10
View File
@@ -26,7 +26,7 @@
class ICAvToolSurfTm ;
// struttura informazioni sui singoli percorsi
struct PathInfo {
struct PathInfoSR {
bool bOutStart ; // flag per entrata da fuori
bool bSingleCrv ; // se percorso formato da una curva singola ( in generale per SubSteps)
bool bOptTrap ; // flag per casi ottimizzati a trapezio ( per Spiral)
@@ -35,10 +35,10 @@ struct PathInfo {
PtrOwner<ICurveComposite> pCvrRet ; // curva di ritorno per LeadIn/Out a guida
} ;
// tipo percorso
typedef std::vector<PathInfo> PATHINFOVECTOR ;
typedef std::vector<PathInfoSR> PATHINFOSRVECTOR ;
// struttura informazioni per Step/SubSteps complessivi
struct StepInfo {
struct StepInfoSR {
double dDepth ; // profondità dello step attuale
double dRelativeDepth ; // profondità relativa allo step al di sopra
double dZlocCoeffFeed ; // coeffiziente riduzione Feed lungo Zloc
@@ -48,10 +48,10 @@ struct StepInfo {
PtrOwner<ISurfFlatRegion> pSfrPock ; // regione piana di svuotatura
PtrOwner<ISurfFlatRegion> pSfrLimit ; // regione piana da non svuotare
PtrOwner<ICurveComposite> pCompo ; // curva selezionata per sgrossatura
PATHINFOVECTOR vPaths ; // percorsi di Pocketing
PATHINFOSRVECTOR vPaths ; // percorsi di Pocketing
} ;
// tipo step
typedef std::vector<StepInfo> STEPINFOVECTOR ;
typedef std::vector<StepInfoSR> STEPINFOSRVECTOR ;
//----------------------------------------------------------------------------
class SurfRoughing : public Machining
@@ -104,7 +104,7 @@ class SurfRoughing : public Machining
bool GetCurves( SelData Id, ICURVEPLIST& lstPC) ;
bool Chain( int nGrpDestId) ;
bool ProcessPath( int nPathId, int nTempId, int nPvId, int nClId) ;
bool CalcPaths( const INTINTVECTOR& vPocket, const ICRVCOMPOPOVECTOR& vCrvPocketCompo, STEPINFOVECTOR& vStepInfo) const ;
bool CalcPaths( const INTINTVECTOR& vPocket, const ICRVCOMPOPOVECTOR& vCrvPocketCompo, STEPINFOSRVECTOR& vStepInfo) const ;
bool AddPocket( const INTINTVECTOR& vPocket, const Vector3d& vtTool, const ICRVCOMPOPOVECTOR& vCrvPocketCompo,
double dElev, double dStep, double dSubStep, bool bSplitArcs) ;
bool AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr) ;
@@ -112,24 +112,22 @@ class SurfRoughing : public Machining
bool AddLinkRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr) ;
bool AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr) ;
bool CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtTool, const ICurveComposite* pCrvPath, Point3d& ptP1) const ;
bool VerifyLeadInLeadOut( const ICurve* pCrv, const ICurveComposite* pCrvPock, bool& bSkip) const ;
bool AddLeadIn( const Point3d& ptP1, const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtN,
const ISurfFlatRegion* pSfr, const ICurveComposite* pRCrv, bool bAtLeft, bool bSplitArcs,
bool bNoneForced, bool bSkipControl) ;
bool AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d& vtN,
const ICurveComposite* pRCrv, bool bSplitArcs, bool bNoneForced, Point3d& ptP1) ;
ISurfTriMesh* GetRaw( void) const ;
ISurfTriMesh* GetStmOutSideCompo( ICurveComposite* pCompo, const ISurfTriMesh* pStmRaw, const Vector3d& vtExtr) const ;
ISurfFlatRegion* GetSfrByStmIntersection( const IntersParPlanesSurfTm& IPPStm, double dDist, double dSmallOffs = 0) const ;
bool GetActiveSurfaces( INTVECTOR& vSurfId) const ;
double GetRightFeed( const Vector3d& vtMove, const Vector3d& vtTool) const ;
double GetRadiusForStartEndElevation( void) const ;
bool AdjustPathForLeadInLeadOut( ICurveComposite* pCrvCompo, int nSubType, const ICurveComposite* pCrvPocket, bool& bOutStart,
bool& bSingleCrv, bool& bOptTrap, bool& bIsZigZagOneWayBorder) const ;
bool AssignOpenEdgesForPocketCrvCompo( ICurveComposite* pCrvCompo, const ISurfFlatRegion* pSfr) const ;
bool ResetCurveAllTempProp( ICurve* pCurve) const ;
bool RemoveChunksUnderTolerance( ISurfFlatRegion* pSfr) const ;
bool CloseOpenEdgesUnderTolerance( ISurfFlatRegion* pSfr, double dToler) ;
bool ModifySurfRefForOpenCloseEdges( ISurfFlatRegion* pSfrRef, const ICurveComposite* pCrvCompo) const ;
bool ModifySurfForOpenCloseEdges( ISurfFlatRegion* pSfr, const Vector3d& vtTool, const ICurveComposite* pCrvCompo) const ;
bool ChooseCloseOrOpenEdge( ISurfFlatRegion* pSfr, const ISurfFlatRegion* pSfrRef) const ;
bool SimplifyCurve( ICurveComposite* pCompo) const ;
bool SimplyfySfr( ISurfFlatRegion* pSfr) const ;
@@ -165,6 +163,11 @@ class SurfRoughing : public Machining
if ( m_Params.m_nLeadInType != SURFROU_LI_GLIDE && m_Params.m_dLiElev < 10 * EPS_SMALL)
return SURFROU_LI_NONE ;
return m_Params.m_nLeadInType ; }
bool LeadInRawIsOk( void) const
{ if ( m_TParams.m_nType != TT_MILL_NOTIP)
return true ;
return (( GetLeadInType() == SURFROU_LI_ZIGZAG || GetLeadInType() == SURFROU_LI_HELIX) &&
m_Params.m_dLiTang >= 0.9 * m_TParams.m_dDiam && m_Params.m_dLiElev <= 2) ; }
int GetLeadOutType( void) const
{ if ( m_Params.m_dLoTang < std::min( 0.1 * m_TParams.m_dDiam, 1.0))
return SURFROU_LO_NONE ;