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

EgtMachKernel :

Browse Source 
- migliorie approssimazione sulle curve
- casi ottimizzati ZigZag con isole.
This commit is contained in:
Riccardo Elitropi
2023-09-07 13:08:34 +02:00
parent 7dcf367d48
commit 09cddcf9ac
2 changed files with 254 additions and 103 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Pocketing.cpp
+250 -101
View File
@@ -1365,6 +1365,11 @@ Pocketing::ResetCurveAllTempProp( ICurve* pCurve)
bool
Pocketing::Chain( int nGrpDestId)
{
// controllo quanti elementi ho nel vettore degli indici selezionati
int nSelId = ( int)m_vId.size() ;
if ( nSelId > 1 && ! CheckSelectedId())
return false ;
// vettore puntatori alle curve
ICURVEPOVECTOR vpCrvs ;
vpCrvs.reserve( m_vId.size()) ;
@@ -2053,6 +2058,31 @@ Pocketing::GeneratePocketingPv( int nPathId, const ISurfFlatRegion* pSrfPock)
return true ;
}
//----------------------------------------------------------------------------
bool
Pocketing::CheckSelectedId( ) {
// se non ho almeno due Id selezionati, allora esco
if (( int)m_vId.size() <= 1)
return true ;
// Controllo Tra gli Id Selezionati se ho una Trimesh
// NB. Il primo Id selezionato ( o i primi Id selezionati nel caso di curve) rapprensentano la geometria che
// voglio svuotare; cerco, se presente, una TriMesh dopo l'indice 0
for ( int i = 1 ; i < ( int)m_vId.size() ; ++ i) {
int nCurrId = m_vId[i].nId ;
// recupero l'oggetto geometrico associato a tale Id
const IGeoObj* pGObj = m_pGeomDB->GetGeoObj( nCurrId) ;
if ( pGObj == nullptr)
return false ;
// se tale oggetto esiste ed è una TriMesh, allora rappresenta il risultato della svuotatura voluto
if ( pGObj->GetType() == SRF_TRIMESH)
return DetectShape( nCurrId, GLOB_FRM) ;
}
return true ;
}
//----------------------------------------------------------------------------
static double
GetCurveRadius( const ICurve* pCrv)
@@ -2179,8 +2209,10 @@ Pocketing::AddZigZag( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c
bool bOptimizedZigZag = false ;
bool bOutRawLeadIn = false ;
ICRVCOMPOPOVECTOR vpCrvs ; // vettore con i paths a ZigZag per il Chunk (c)-esimo allo step (j)-esimo
ICRVCOMPOPOVECTOR vCrvIslMergeBorders ; // vettore delle possibili isole mergiate per il Chunk (c)-esimo allo step (j)-esimo
double dOptZigZagOffs ;
if ( ! OptimizedZigZag( pSrfChunkFinal, vtTool, dDepth, dSafeZ, frPocket, vCrvOEWithFlags[j-1][nInd], bOptimizedZigZag, vpCrvs, dOptZigZagOffs))
if ( ! OptimizedZigZag( pSrfChunkFinal, vtTool, dDepth, dSafeZ, frPocket, vCrvOEWithFlags[j-1][nInd],
bOptimizedZigZag, vpCrvs, vCrvIslMergeBorders, dOptZigZagOffs))
return false ;
if ( bOptimizedZigZag && ! vpCrvs.empty()) {
// se sono in un caso ottimizzato ...
@@ -2450,15 +2482,17 @@ Pocketing::AddZigZag( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c
// Una volta percorse le curve di ZigZag devo aggiungere le curve per il bordo
// creo un vettore con tutti i loop formati, aggiustando i loro punti iniziali e portandoli nel frame della svuotatura
// NB. se sono in un caso ottimizzato uso solo i loop interni
// NB. se sono in un caso ottimizzato uso solo i loop interni ( se non rivatai mergiati)
ICRVCOMPOPOVECTOR vAllCrv ;
for ( int l = bOptimizedZigZag ? 1 : 0 ; l < pSrfForCrv->GetLoopCount( cfc) ; ++ l)
vAllCrv.emplace_back( GetCurveComposite( pSrfForCrv->GetLoop( cfc, l))) ;
vAllCrv.emplace_back( ConvertCurveToComposite( pSrfForCrv->GetLoop( cfc, l))) ;
for ( int u = 0 ; u < ( int)vCrvIslMergeBorders.size() ; ++ u)
vAllCrv.emplace_back( ConvertCurveToComposite( vCrvIslMergeBorders[u]->Clone())) ;
// Sistemo i punti iniziali per i nuovi Chunks ------------------------------------------
VCT3DVECTOR vVtMidOut(( int) vAllCrv.size(), V_NULL) ;
BOOLVECTOR vbMidOut(( int) vAllCrv.size(), false) ;
PNTVECTOR vPtStart(( int) vAllCrv.size(), Point3d( 0,0,0)) ;
PNTVECTOR vPtStart(( int) vAllCrv.size(), Point3d( 0, 0, 0)) ;
BOOLVECTOR vbForcedOutStart(( int) vAllCrv.size(), false) ;
// se sono in un caso ottimizzato e non ho isole non ho bisogno di fare nulla...
@@ -2470,7 +2504,7 @@ Pocketing::AddZigZag( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c
bool bOutTmp = false ;
if ( ! SetBetterPtStartForSubChunks( vAllCrv[u], pSrfChunkFinal,
vPtStart[u], vVtMidOut[u], bOutTmp, dOffs))
vPtStart[u], vVtMidOut[u], bOutTmp, dOffs))
return false ;
vbMidOut[u] = bOutTmp ; // vector<bool>::reference da Bit a Bool
@@ -3233,8 +3267,8 @@ Pocketing::CalcZigZagLink( ICurveComposite* pCrv1, ICurveComposite* pCrv2, ICurv
//----------------------------------------------------------
bool
Pocketing::OptimizedZigZag( ISurfFlatRegion* pSrf, const Vector3d& vtTool, double dDepth, double dSafeZ,
Frame3d& frPocket, ICurveComposite* pCrvOrig, bool& bOptimizedZigZag, ICRVCOMPOPOVECTOR& vpCrvs,
double& dOffs)
Frame3d& frPocket, ICurveComposite* pCrvOrig, bool& bOptimizedZigZag,
ICRVCOMPOPOVECTOR& vpCrvs, ICRVCOMPOPOVECTOR& vCrvIslMergeBorders, double& dOffs)
{
// clono la superficie (chunk c-esimo dell'originale)
PtrOwner<ISurfFlatRegion> pSrfPocket( CloneSurfFlatRegion( pSrf)) ;
@@ -3298,10 +3332,12 @@ Pocketing::OptimizedZigZag( ISurfFlatRegion* pSrf, const Vector3d& vtTool, doubl
break ;
}
// se non sono in un caso ottimizzato, allora esco
if ( ! bOptimizedZigZag)
return true ;
if ( vtDir.IsZero())
// frame per direzione più lunga per la svuotatura a ZigZag
if ( vtDir.IsZero())
pCrvPocket->GetStartDir( vtDir) ;
double dAng ;
vtDir.GetAngleXY( X_AX, dAng) ;
@@ -3320,6 +3356,7 @@ Pocketing::OptimizedZigZag( ISurfFlatRegion* pSrf, const Vector3d& vtTool, doubl
ICRVCOMPOPOVECTOR vFirstOffsets ;
vFirstOffsets.emplace_back( Release( pCrvPocket)) ; // la curva esterna modificata
// parametri per Offset
double dTRad = m_TParams.m_dDiam / 2 ;
double dMyOffs = dTRad + GetOffsR() ;
double dExtra = (( m_TParams.m_nType != TT_MILL_POLISHING) ? min( 0.1 * m_TParams.m_dDiam, 2.0) : 0) ;
@@ -3328,47 +3365,182 @@ Pocketing::OptimizedZigZag( ISurfFlatRegion* pSrf, const Vector3d& vtTool, doubl
if ( IsNull( pSrfPocketClone))
return false ;
// Offsetto la superficie per ricavare informazioni su eventuali isole e sulle loro possibili unioni
if ( ! pSrfPocketClone->Offset( - dMyOffs - dExtra, ICurve::OFF_FILLET)) { // le isole interne vanno Offsettate
m_pMchMgr->SetLastError( 2412, "Error in Pocketing : Offset not computable") ;
return false ;
}
// NB. Se il numero di Loop interni ora è cambiato, vuol dire che le isole si sono unite tra loro o con il bordo
// -> conto il numero di Loop interni prima e dopo l'Offset
int nLoopBef = 0 ;
for ( int c = 0 ; c < pSrfPocket->GetChunkCount() ; ++ c)
for ( int l = 1 ; l < pSrfPocket->GetLoopCount( c) ; ++ l)
++ nLoopBef ;
int nLoopAft = 0 ;
for ( int c = 0 ; c < pSrfPocketClone->GetChunkCount() ; ++ c)
for ( int l = 1 ; l < pSrfPocketClone->GetLoopCount( c) ; ++ l)
++ nLoopAft ;
// vettore delle curve da tenere in considerazione...
ICRVCOMPOPOVECTOR vCrvAllLoops ;
double dMaxArea = -INFINITO; int nIndex = -1; int p = 0 ; // p è il # di loop totali
double dMaxArea = -INFINITO ; int nIndex = -1 ; int p = 0 ; // p è il # di loop totali
for ( int cu = 0 ; cu < pSrfPocketClone->GetChunkCount() ; ++ cu) {
for ( int l = 0 ; l < pSrfPocketClone->GetLoopCount( cu) ; ++ l) {
// inserisco i loops portandoli nel nuovo sistema di riferimento
PtrOwner<ICurveComposite> pCrvLoop( GetCurveComposite( pSrfPocketClone->GetLoop( cu, l))) ;
if ( IsNull( pCrvLoop))
return false ;
pCrvLoop->ToGlob( frameH) ;
pCrvLoop->ToLoc( frPocket) ;
// superificie generata dalle isole
PtrOwner<ISurfFlatRegion> pSrfIslandsOff1( CreateSurfFlatRegion()) ;
PtrOwner<ISurfFlatRegion> pSrfIslandsOff2( CreateSurfFlatRegion()) ;
if ( IsNull( pSrfIslandsOff1) || IsNull( pSrfIslandsOff2))
return false ;
double dArea ; pCrvLoop->GetAreaXY( dArea) ;
if ( dArea > dMaxArea) {
dMaxArea = dArea ;
nIndex = p ;
// Se il numero di Loop è rimasto uguale allora tengo le curve così come sono...
if ( nLoopAft == nLoopBef) {
for ( int cu = 0 ; cu < pSrfPocketClone->GetChunkCount() ; ++ cu) {
for ( int l = 0 ; l < pSrfPocketClone->GetLoopCount( cu) ; ++ l) {
// inserisco i loops portandoli nel nuovo sistema di riferimento
PtrOwner<ICurveComposite> pCrvLoop( GetCurveComposite( pSrfPocketClone->GetLoop( cu, l))) ;
if ( IsNull( pCrvLoop))
return false ;
pCrvLoop->ToGlob( frameH) ;
pCrvLoop->ToLoc( frPocket) ;
double dArea ; pCrvLoop->GetAreaXY( dArea) ;
if ( dArea > dMaxArea) {
dMaxArea = dArea ;
nIndex = p ;
}
vCrvAllLoops.emplace_back( Release( pCrvLoop)) ;
p++ ;
}
vCrvAllLoops.emplace_back( Release( pCrvLoop)) ;
p++ ;
}
}
// se il numero di curve è cambiato, allora creo una superficie da tutte le isole
else {
ICRVCOMPOPOVECTOR vCrvOff1Islands ;
for ( int cu = 0 ; cu < pSrfPocket->GetChunkCount() ; ++ cu) {
for ( int l = 1 ; l < pSrfPocket->GetLoopCount( cu) ; ++ l) {
PtrOwner<ICurveComposite> pCrvIslLoop( ConvertCurveToComposite( pSrfPocket->GetLoop( cu, l))) ;
if ( IsNull( pCrvIslLoop) || ! pCrvIslLoop->IsValid())
return false ;
pCrvIslLoop->ToGlob( frameH) ;
pCrvIslLoop->ToLoc( frPocket) ;
// Offset 1 dell'isola ------------
OffsetCurve OffCrv1 ;
if ( ! OffCrv1.Make( pCrvIslLoop, - dMyOffs, ICurve::OFF_FILLET)) {
m_pMchMgr->SetLastError( 2412, "Error in Pocketing : Offset not computable") ;
return false ;
}
PtrOwner<ICurve> pCrvlonger1( OffCrv1.GetLongerCurve()) ;
while ( ! IsNull( pCrvlonger1)) {
if ( pCrvlonger1->IsClosed()) {
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
pCrvCompo->AddCurve( Release( pCrvlonger1)) ;
PtrOwner<ISurfFlatRegion> pSrfIsland_i( CreateSurfFlatRegion()) ;
if ( IsNull( pSrfIsland_i))
return false ;
pSrfIsland_i->AddExtLoop( Release( pCrvCompo)) ;
if ( pSrfIsland_i->IsValid()) {
if ( AreOppositeVectorApprox( pSrfIsland_i->GetNormVersor(), vtTool))
pSrfIsland_i->Invert() ;
}
if ( ! pSrfIslandsOff1->IsValid() || pSrfIslandsOff1->GetChunkCount() == 0)
pSrfIslandsOff1.Set( Release( pSrfIsland_i)) ;
else
pSrfIslandsOff1->Add( *pSrfIsland_i) ;
}
pCrvlonger1.Set( OffCrv1.GetLongerCurve()) ;
}
// Offset 2 dell'isola --------------
OffsetCurve OffCrv2 ;
if ( ! OffCrv2.Make( pCrvIslLoop, - dMyOffs - dExtra, ICurve::OFF_FILLET)) {
m_pMchMgr->SetLastError( 2412, "Error in Pocketing : Offset not computable") ;
return false ;
}
// le curve chiuse che ottengo le aggiungo al vettore delle curve di bordo
PtrOwner<ICurve> pCrvlonger2( OffCrv2.GetLongerCurve()) ;
while ( ! IsNull( pCrvlonger2)) {
if ( pCrvlonger2->IsClosed()) {
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
pCrvCompo->AddCurve( Release( pCrvlonger2)) ;
PtrOwner<ISurfFlatRegion> pSrfIsland_i( CreateSurfFlatRegion()) ;
if ( IsNull( pSrfIsland_i))
return false ;
pSrfIsland_i->AddExtLoop( Release( pCrvCompo)) ;
if ( pSrfIsland_i->IsValid()) {
if ( AreOppositeVectorApprox( pSrfIsland_i->GetNormVersor(), vtTool))
pSrfIsland_i->Invert() ;
}
if ( ! pSrfIslandsOff2->IsValid() || pSrfIslandsOff2->GetChunkCount() == 0)
pSrfIslandsOff2.Set( Release( pSrfIsland_i)) ;
else
pSrfIslandsOff2->Add( *pSrfIsland_i) ;
}
pCrvlonger2.Set( OffCrv2.GetLongerCurve()) ;
}
}
}
// aggiungo tutti i Loop al vettore delle curve utili
for ( int c = 0 ; c < pSrfIslandsOff2->GetChunkCount() ; ++ c)
for ( int l = 0 ; l < pSrfIslandsOff2->GetLoopCount( c) ; ++ l)
vCrvAllLoops.emplace_back( ConvertCurveToComposite( pSrfIslandsOff2->GetLoop( c, l))) ;
}
// vettore contentente il bordo esterno opportunamente allargato e le curve utili ( isole)
for ( int i = 0 ; i < int( vCrvAllLoops.size()) ; ++ i) {
if ( i != nIndex) {
vFirstOffsets.emplace_back( vCrvAllLoops[i]->Clone()) ;
}
}
// creo la superficie da svuotare ottimizzata
SurfFlatRegionByContours pSrfMod ;
for ( int i = 0 ; i < int( vFirstOffsets.size()) ; ++ i)
pSrfMod.AddCurve( vFirstOffsets[i]->Clone()) ;
PtrOwner<ISurfFlatRegion> pSrfZigZag( pSrfMod.GetSurf()) ;
PtrOwner<ISurfFlatRegion> pSrfZigZag( CreateSurfFlatRegion()) ;
if ( IsNull( pSrfZigZag))
return false ;
if (( int)vFirstOffsets.size() > 0) {
pSrfZigZag->AddExtLoop( *vFirstOffsets[0]) ;
if ( pSrfZigZag->IsValid()) {
if ( AreOppositeVectorApprox( vtExtr, pSrfZigZag->GetNormVersor()))
pSrfZigZag->Invert() ;
// sottraggo le isole ( se presenti)
if ( pSrfIslandsOff2->IsValid() || pSrfIslandsOff2->GetChunkCount() > 0) {
if ( AreOppositeVectorApprox( pSrfZigZag->GetNormVersor(), pSrfIslandsOff2->GetNormVersor()))
pSrfIslandsOff2->Invert() ;
m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrfZigZag->Clone()) ;
m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrfIslandsOff2->Clone()) ;
if ( ! pSrfZigZag->Subtract( *pSrfIslandsOff2))
return false ;
m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrfZigZag->Clone()) ;
// aggiungo le curve della superficie delle isole alle curve da percorrere ( se necessario)
if ( nLoopAft != nLoopBef) {
if ( AreSameVectorApprox( pSrfZigZag->GetNormVersor(), pSrfIslandsOff2->GetNormVersor()))
pSrfIslandsOff2->Invert() ;
pSrfIslandsOff1->Invert() ;
pSrfIslandsOff1->ToGlob( frameH) ;
pSrfIslandsOff1->ToLoc( frPocket) ;
for ( int c = 0 ; c < pSrfIslandsOff1->GetChunkCount() ; ++ c)
for ( int l = 0 ; l < pSrfIslandsOff1->GetLoopCount( c) ; ++ l)
vCrvIslMergeBorders.emplace_back( ConvertCurveToComposite( pSrfIslandsOff1->GetLoop( c, l))) ;
}
}
else {
// creo la superficie da svuotare ottimizzata
SurfFlatRegionByContours pSrfMod ;
for ( int i = 0 ; i < int( vFirstOffsets.size()) ; ++ i)
pSrfMod.AddCurve( vFirstOffsets[i]->Clone()) ;
pSrfZigZag.Set( pSrfMod.GetSurf()) ;
if ( IsNull( pSrfZigZag) || ! pSrfZigZag->IsValid())
return false ;
if ( AreOppositeVectorApprox( vtExtr, pSrfZigZag->GetNormVersor()))
pSrfZigZag->Invert() ;
}
}
}
else
return false ;
if ( AreOppositeVectorApprox( vtExtr, pSrfZigZag->GetNormVersor()))
pSrfZigZag->Invert() ;
@@ -4541,8 +4713,9 @@ Pocketing::AddSpiralIn( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool,
bool bUhAboveRaw = ! m_bAboveHead &&
GetUhPointAboveRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ;
if ( bAhUnderRaw || bUhAboveRaw )
dStElev = max( dStElev, dCurrAffondamento) ;
//if ( bAhUnderRaw || bUhAboveRaw )
//dStElev = max( dStElev, dCurrAffondamento) ;
dStElev = max( dStElev, j * dStep) ;
dStElev -= ( ptP1 - ptStart) * vtExtr ;
// se attacco a zigzag o a spirale o a scivolo, l'elevazione va nell'attacco
if ( GetLeadInType() == POCKET_LI_ZIGZAG ||
@@ -4556,7 +4729,7 @@ Pocketing::AddSpiralIn( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool,
m_pMchMgr->SetLastError( 2414, "Error in Pocketing : Approach not computable") ;
return false ;
}
dStElev = max( dStElev, dCurrAffondamento) ;
dStElev = max( dStElev, j * dStep) ;
// aggiungo attacco
SetFeed( GetStartFeed()) ;
if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtExtr, pSrfLeanInOut, pRCrv, !m_Params.m_bInvert, bSplitArcs, bOutStart || bForcedOutStart)) {
@@ -9491,18 +9664,7 @@ Pocketing::GetParamsAtEachStep( ISURFFRPOVECTOR& vSrfSliced, vector<ICRVCOMPOPOV
return false ;
// ======================================================================================
// =========================== RECUPERO EVENTUALE SHAPE =================================
PtrOwner<ISurfTriMesh> pStmShape( CreateSurfTriMesh()) ;
pStmShape->AdjustTopology() ;
if ( m_bHasShape) {
if ( ! DetectShape( nProp0, pStmShape, GLOB_FRM))
return false ;
int r = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pStmShape->Clone()) ;
m_pGeomDB->SetMaterial( r, Color( 1.0, 0.0, 0.0, 0.5)) ;
}
// ======================================================================================
// ======================== AD OGNI STEP ADATTO LA SUPERIFICIE ==========================
// ADATTAMENTO A TRIMESH ( se necessario) o SHAPE, INTERSEZIONE, PROIEZIONE
// ED ESTENSIONE PRESSO LATI APERTI
@@ -9529,7 +9691,7 @@ Pocketing::GetParamsAtEachStep( ISURFFRPOVECTOR& vSrfSliced, vector<ICRVCOMPOPOV
}
// adatto la superficie dello step corrente con la geometria del grezzo
if ( AdaptSfrWithRaw( pSrfToPock, vtTrasl, pStmRaw, vCrvOEF, bChanged, j, dStep, 500 * EPS_SMALL, pStmShape)) {
if ( AdaptSfrWithRaw( pSrfToPock, vtTrasl, pStmRaw, vCrvOEF, bChanged, j, dStep, 500 * EPS_SMALL, m_pStmShape)) {
vSrfSliced[j-1].Set( pSrfToPock->Clone()) ;
// la superificie potrebbe non essere valida ( ad esempio se già svuotata tutta con un Tool in precedenza...)
@@ -9560,42 +9722,37 @@ Pocketing::GetParamsAtEachStep( ISURFFRPOVECTOR& vSrfSliced, vector<ICRVCOMPOPOV
// --------------------------------------------------------------------------
bool
Pocketing::DetectShape( int nId, ISurfTriMesh* pSrfTMShape, Frame3d frPocket)
Pocketing::DetectShape( int nId, Frame3d frPocket)
{
// controllo dei parametri
if ( ! frPocket.IsValid())
return false ;
// recupero il gruppo della lavorazione
int nProcessingId = m_pGeomDB->GetParentId( nId) ;
if ( nProcessingId != GDB_ID_NULL) {
int nPartId = m_pGeomDB->GetParentId( nProcessingId) ;
if ( nPartId != GDB_ID_NULL) {
int nIdIter = m_pGeomDB->GetFirstNameInGroup( nPartId, "Proc" ) ;
if ( nIdIter != GDB_ID_NULL) {
int nIdShape = m_pGeomDB->GetFirstInGroup( nIdIter) ;
if ( nIdShape != GDB_ID_NULL) {
const IGeoObj* pGObj = m_pGeomDB->GetGeoObj( nIdShape) ;
Frame3d frRawPart ;
m_pGeomDB->GetGlobFrame( nIdIter, frRawPart) ;
if ( pGObj == nullptr)
return false ;
if ( pGObj->GetType() == SRF_TRIMESH) {
PtrOwner<ISurfTriMesh> pSrfRawPart( CloneSurfTriMesh( pGObj)) ;
if ( IsNull( pSrfRawPart))
return false ;
pSrfRawPart->LocToLoc( frRawPart, frPocket) ;
pSrfTMShape->CopyFrom( pSrfRawPart) ;
// se shape presente ma non valida, errore
if ( pSrfTMShape == nullptr || ! pSrfTMShape->IsValid() || pSrfTMShape->GetTriangleCount() == 0)
return false ;
}
}
}
}
}
// recupero l'oggetto geometrico
const IGeoObj* pGObj = m_pGeomDB->GetGeoObj( nId) ;
if ( pGObj == nullptr)
return false ;
// se l'oggetto geometrico non è una trimesh, allora errore
if ( pGObj->GetType() != SRF_TRIMESH)
return false ;
return true ;
// recupero il Frame in cui si trova
Frame3d frRawPart ;
m_pGeomDB->GetGlobFrame( nId, frRawPart) ;
// recupero la TriMesh ( shape) associata all'oggetto geometrico
PtrOwner<ISurfTriMesh> pSrfRawPart( CloneSurfTriMesh( pGObj)) ;
if ( IsNull( pSrfRawPart))
return false ;
// porto la TriMesh ( shape) dal suo frame al frame richiesto
pSrfRawPart->LocToLoc( frRawPart, frPocket) ;
// assegno la TriMesh ( shape) al parametro della funzione e controllo la sua validità
m_pStmShape.Set( Release( pSrfRawPart)) ;
return m_pStmShape != nullptr && m_pStmShape->IsValid() && m_pStmShape->GetTriangleCount() > 0 ;
}
@@ -9999,7 +10156,7 @@ Pocketing::ProjectStmOnPlane( const ISurfTriMesh* pStmAbove, const Plane3d plPoc
for ( int t = 0 ; t < pStmRef->GetTriangleCount() ; ++ t) {
Vector3d vtNTria ;
if ( pStmRef->GetFacetNormal( pStmRef->GetFacetFromTria( t), vtNTria) &&
vtNTria * vtN > 10 * EPS_ANG_SMALL) {
vtNTria * vtN > EPS_SMALL) {
Triangle3d Tria ; pStmRef->GetTriangle( t, Tria) ;
TriaSoupEasy.AddTriangle( Tria) ;
}
@@ -10012,13 +10169,9 @@ Pocketing::ProjectStmOnPlane( const ISurfTriMesh* pStmAbove, const Plane3d plPoc
// 3) scalo la superficie rispetto al sistema di riferimento ( mettendo a 0 la componente vtN)
pStmRef->ToLoc( frPlane) ;
//int G = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pStmRef->Clone()) ;
//m_pGeomDB->SetMaterial( G, GREEN) ;
if ( ! pStmRef->Scale( GLOB_FRM, 1., 1., 0.))
return false ;
pStmRef->ToGlob( frPlane) ;
//int p = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pStmRef->Clone()) ;
//m_pGeomDB->SetMaterial( p, PURPLE) ;
// 4) controllo la validità della superficie ottenuta
if ( IsNull( pStmRef) || ! pStmRef->IsValid() || pStmRef->GetTriangleCount() == 0)
@@ -10068,24 +10221,13 @@ Pocketing::ProjectStmOnPlane( const ISurfTriMesh* pStmAbove, const Plane3d plPoc
pSfrProj->CopyFrom( pSfrUp) ;
if ( ! IsNull( pSfrUp1) && pSfrUp1->IsValid()) { // se Down valida...
if ( pSfrProj != nullptr && pSfrProj->IsValid()) { // e Up valida -> aggiungo
if ( ! pSfrProj->Add( *pSfrUp1)) {
int a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrProj->Clone()) ;
m_pGeomDB->SetMaterial( a, ORANGE) ;
int v = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrUp1->Clone()) ;
m_pGeomDB->SetMaterial( v, PURPLE) ;
if ( ! pSfrProj->Add( *pSfrUp1))
return false ;
}
}
else // se Up non valida -> copio
pSfrProj->CopyFrom( pSfrUp1) ;
}
//int r = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrUp->Clone()) ;
//int o = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrUp1->Clone()) ;
//m_pGeomDB->SetMaterial( r, RED) ;
//m_pGeomDB->SetMaterial( o, ORANGE) ;
//m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrProj->Clone()) ;
return pSfrProj != nullptr && pSfrProj->IsValid() && pSfrProj->GetChunkCount() != 0 ;
}
@@ -10293,15 +10435,15 @@ Pocketing::SubtractFinalShape( ISurfFlatRegion* pSfrCurr, const Vector3d& vtTras
if ( IsNull( pSfrCurr_c) || ! pSfrCurr_c->IsValid())
return false ;
int W = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrCurr_c->Clone()) ;
m_pGeomDB->SetMaterial( W, WHITE) ;
int F = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrShape_c->Clone()) ;
m_pGeomDB->SetMaterial( F, BLACK) ;
//int W = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrCurr_c->Clone()) ;
//m_pGeomDB->SetMaterial( W, WHITE) ;
//int F = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrShape_c->Clone()) ;
//m_pGeomDB->SetMaterial( F, BLACK) ;
if ( ! pSfrCurr_c->Subtract( *pSfrShape_c))
return false ;
int G = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrCurr_c->Clone()) ;
m_pGeomDB->SetMaterial( G, GRAY) ;
//int G = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrCurr_c->Clone()) ;
//m_pGeomDB->SetMaterial( G, GRAY) ;
// ricalcolo le TmpProp
SurfFlatRegionByContours sfrBC ;
@@ -14036,6 +14178,9 @@ Pocketing::GetSfrByStm( const ISurfTriMesh* pStm, ISurfFlatRegion* pSfr, const P
// essendo una curva derivante da un'intersezione di Trimesh ho una composita derivante da una polyLine,
// devo recuperare gli archi
PolyArc PA ;
pCrv->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL) ;
//int b = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrv->Clone()) ;
//m_pGeomDB->SetMaterial( b, BLUE) ;
pCrv->ToLoc( frPock) ;
pCrv->ApproxWithArcsEx( 500 * EPS_SMALL, ANG_TOL_STD_DEG, LIN_FEA_STD, PA) ; // 5 * EPS_SMALL
pCrv->Clear() ;
@@ -14050,8 +14195,10 @@ Pocketing::GetSfrByStm( const ISurfTriMesh* pStm, ISurfFlatRegion* pSfr, const P
PtrOwner<ICurve> pCrv_c( pCrv->CopyParamRange( dS, dE)) ;
if ( IsNull( pCrv_c) || ! pCrv_c->IsValid())
return false ;
//int p = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrv->Clone()) ;
//m_pGeomDB->SetMaterial( p, PURPLE) ;
// se la curva è "stretta" la trascuro, rende sono difficili i conti senza dare valore aggiunto
// se la curva è "stretta" la trascuro, rende solo difficili i conti senza dare valore aggiunto
PtrOwner<ICurve> pCrv_proj( ProjectCurveOnPlane( *pCrv_c, plPock)) ;
double dAreaCheck = EPS_SMALL ; Plane3d plCheck ;
if ( ! IsNull( pCrv_proj) &&
@@ -14062,6 +14209,8 @@ Pocketing::GetSfrByStm( const ISurfTriMesh* pStm, ISurfFlatRegion* pSfr, const P
}
//int g = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrv_c->Clone()) ;
//m_pGeomDB->SetMaterial( g, GREEN) ;
SrfChunkDef.AddCurve( Release( pCrv_proj)) ; // aggiungo le curve proiettate
}
@@ -14088,9 +14237,9 @@ Pocketing::GetSfrByStm( const ISurfTriMesh* pStm, ISurfFlatRegion* pSfr, const P
}
}
// pSrfByCurves.Set( SFRFINAL.GetSurf()) ;
// if ( IsNull( pSrfByCurves) || pSrfByCurves->GetChunkCount() == 0) // controllo ancora validità della FlatRegion
// return true ; // non ho ricavato nulla, la TriMesh è troppo sottile o piccola
pSrfByCurves.Set( SFRFINAL.GetSurf()) ;
if ( IsNull( pSrfByCurves) || pSrfByCurves->GetChunkCount() == 0) // controllo ancora validità della FlatRegion
return true ; // non ho ricavato nulla, la TriMesh è troppo sottile o piccola
// restituisco la FlatRegion
pSfr->Clear() ;
Pocketing.h
+4 -2
View File
@@ -79,6 +79,8 @@ class Pocketing : public Machining
bool CalcRegionElevation( const ICurveComposite* pCompo, const Vector3d& vtTool, double dDepth, double dRad, double& dElev) const ;
bool VerifyPathFromBottom( const ISurfFlatRegion* pSrf, const Vector3d& vtTool) ;
bool GeneratePocketingPv( int nPathId, const ISurfFlatRegion* pSrfPock) ;
bool CheckSelectedId( void) ;
bool DetectShape( int nId, Frame3d frPocket) ;
// =========================== MIGLIORIE GENERALI ====================
bool ModifyCurveToSmoothed( ICurveComposite* pCrvOffset, double dRightPer, double dleftPer) ;
@@ -103,7 +105,6 @@ class Pocketing : public Machining
const double& dDepth, const double& dStep) ;
bool GetAdaptedSfrByTrimesh( const ISurfFlatRegion* pSfrExtended, const ISurfFlatRegion* pSfrORIG,
const ISurfTriMesh* pStmORIG, const Vector3d& vtTrasl, ISurfFlatRegion* pNewSrfPock) ;
bool DetectShape( int nId, ISurfTriMesh* pSrfTMShape, Frame3d frPocket) ;
bool ProjectStmOnPlane( const ISurfTriMesh* pStmAbove, const Plane3d plPock, ISurfFlatRegion* pSfrProj) ;
bool CalcExtraSteps( const ISurfFlatRegion* pSfrAct, const ISurfTriMesh* pStmORIG,
const Vector3d vtTool, const double& dElev, const double& dDepth, const int& nStep,
@@ -173,7 +174,7 @@ class Pocketing : public Machining
bool CalcZigZagLink( ICurveComposite* pCrv1, ICurveComposite* pCrv2, ICurveComposite* pCrvLink) ;
bool OptimizedZigZag( ISurfFlatRegion* pSrf, const Vector3d & vtTool, double dDepth, double dSafeZ,
Frame3d& frPocket, ICurveComposite* pCrvOrig, bool& bOptimizedZigZag,
ICRVCOMPOPOVECTOR& vpCrvs, double& dOffs) ;
ICRVCOMPOPOVECTOR& vpCrvs, ICRVCOMPOPOVECTOR& vCrvIslMergeBorders, double& dOffs) ;
bool ZigZagOptimizedNoClosedEdges( ICurveComposite* pCrvPocket, bool& bOptimizedZigZag, Vector3d& vtDir, double& dOffs) ;
bool ZigZagOptimizedOneClosedEdge( ICurveComposite* pCrvPocket, int nClosedId, bool& bOptimizedZigZag,
Vector3d& vtDir, double& dOffs) ;
@@ -354,6 +355,7 @@ class Pocketing : public Machining
bool m_bIntersRaw = true ; // flag per intersezione con grezzo
bool m_bProjectRaw = true ; // flag di proiezione del grezzo
bool m_bHasShape = true ; // flag per presenza di geometria voluta
PtrOwner<ISurfTriMesh> m_pStmShape ; // puntatore alla superficie TriMesh da seguire
double m_dMaxLenRawProj = 200 ; // lunghezza massima per contatto di proiezione
bool m_bOptOffset = true ; // flag per ottimizzazione numero di Offset necessari
bool m_bOptOffsetCM = false ; // flag per ottimizzazione numero di Offset necessari con centroidi e medial Axis