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

EgtMachKernel :

Browse Source 
- modifiche lati aperti e proiezioni.
This commit is contained in:
Riccardo Elitropi
2023-07-06 13:13:41 +02:00
parent 648ca06815
commit 3fa4e64cc2
2 changed files with 176 additions and 63 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Pocketing.cpp
+175 -62
View File
@@ -5078,7 +5078,7 @@ Pocketing::CalcSpiral( const ISurfFlatRegion* pSrfPock, int& nReg, Point3d& ptSt
// caso spirale
PtrOwner<ICurveComposite> pCrvBorder( GetCurveComposite( pSrfPock->GetLoop( 0, 0))) ;
Point3d ptCen ; Vector3d vtN ; double dRad ; bool bCCW ;
m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvBorder->Clone()) ;
//m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvBorder->Clone()) ;
if ( pCrvBorder->IsACircle( 100 * EPS_SMALL, ptCen, vtN, dRad, bCCW)) {
double dIntRad = 0 ;
if ( m_Params.m_nSubType == POCKET_SUB_SPIRALOUT && GetLeadInType() == POCKET_LI_HELIX) {
@@ -8634,8 +8634,59 @@ Pocketing::AdjustContourWithOpenEdges( ICurveComposite* pCompo, ICRVCOMPOPOVECTO
return false ;
}
int nCrv_offs = OffsCrv.GetCurveCount() ;
if ( nCrv_offs == 0)
continue ;
if ( nCrv_offs == 0) {
// determino la curva ad amo
Point3d ptEnd ; vpCrvs[i-1]->GetEndPoint( ptEnd) ;
Vector3d vtTg ; vpCrvs[i-1]->GetEndDir( vtTg) ;
Vector3d vtOrt = vtTg ; vtOrt.Rotate( vtExtr, 0, -1) ;
Point3d ptArc = ptEnd + ( 1.05 * dTool_Diam + 2 * dOffR ) * vtOrt ;
//Point3d ptLine = ptArc - 5 * dDiam * vtTg ;
PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
if ( IsNull( pCrvArc))
return false ;
pCrvArc->SetExtrusion( vtExtr) ;
pCrvArc->Set2PVN( ptEnd, ptArc, vtTg, vtExtr) ;
PtrOwner<ICurveComposite> pJCrv( CreateCurveComposite()) ;
if ( IsNull( pJCrv))
return false ;
pJCrv->AddCurve( Release( pCrvArc)) ;
// determino la curva ad amo
vpCrvs[i+1]->GetStartDir( vtTg) ;
vtOrt = vtTg ; vtOrt.Rotate( vtExtr, 0, -1) ;
ptArc = ptStart + ( 1.05 * dTool_Diam + 2 * dOffR ) * vtOrt ;
Point3d ptLine = ptArc + 5 * ( 1.05 * dTool_Diam + 2 * dOffR ) * vtTg ;
PtrOwner<ICurveComposite> pJCrv1( CreateCurveComposite()) ;
if ( IsNull( pJCrv1))
return false ;
pJCrv1->SetExtrusion( vtExtr) ;
pJCrv1->AddPoint( ptLine) ;
pJCrv1->AddLine( ptArc) ;
pJCrv1->AddArcTg( ptStart) ;
pJCrv->ToLoc( frPocket) ;
pJCrv1->ToLoc( frPocket) ;
IntersCurveCurve intCC( *pJCrv, *pJCrv1) ;
pJCrv->ToGlob( frPocket) ;
pJCrv1->ToGlob( frPocket) ;
IntCrvCrvInfo aInfo ;
if ( intCC.GetIntersCount() > 0) {
if ( intCC.GetIntCrvCrvInfo( 0, aInfo)) {
PtrOwner<ICurveComposite> pCrvFinal( CreateCurveComposite()) ;
PtrOwner<ICurve> PJ_Cut( pJCrv->CopyParamRange( 0, aInfo.IciA[0].dU)) ;
PtrOwner<ICurve> PJ1_Cut( pJCrv1->CopyParamRange( 0, aInfo.IciB[0].dU)) ;
PJ1_Cut->Invert() ;
pCrvFinal->AddCurve( Release( PJ_Cut)) ;
pCrvFinal->AddCurve( Release( PJ1_Cut)) ;
for ( int u = 0 ; u < pCrvFinal->GetCurveCount() ; ++ u)
pCrvFinal->SetCurveTempProp( u, 0, 0) ;
vpCrvs[i].Set( Release( pCrvFinal)) ;
vpCrvs[i]->SetTempProp( 0) ;
}
}
else
continue ;
}
PtrOwner<ICurve> pCrvlonger( OffsCrv.GetLongerCurve()) ;
//int W = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvlonger->Clone()) ;
//m_pGeomDB->SetMaterial( W, WHITE) ;
@@ -8691,7 +8742,7 @@ Pocketing::AdjustContourWithOpenEdges( ICurveComposite* pCompo, ICRVCOMPOPOVECTO
Point3d ptS ; pCompo->GetEndPoint( ptS) ;
Point3d ptE ; vpCrvs[i+1]->GetStartPoint( ptE) ;
PtrOwner<ICurveComposite> pCrvNew( CreateCurveComposite()) ;
if ( ! bInVsOut && AdjustPathOutsideRawForOpenEdges( pCompo_clone, vCrvIsl, pHHHH, ptS, ptE, dRad, dDiam,
if ( ! bInVsOut && AdjustPathOutsideRawForOpenEdges( pCompo_clone, vCrvIsl, pHHHH, ptS, ptE, dRad, dDiam,
pCrvNew, vtTrasl, pStmRaw, bInVsOut)) {
vpCrvs[i].Set( Release( pCrvNew)) ;
vpCrvs[i]->GetStartPoint( ptStart) ;
@@ -9385,7 +9436,7 @@ Pocketing::AdaptSfrWithRaw( ISurfFlatRegion* pSrf, Vector3d vtTrasl, const doubl
if ( ! ModifySurfByOpenEdge( pSrf, vCrvOEFlags, vtTrasl, pStmRaw))
return false ;
for ( int c = 0 ; c < pSrf->GetChunkCount() ; ++ c) {
/*for ( int c = 0 ; c < pSrf->GetChunkCount() ; ++ c) {
for ( int l = 0 ; l < pSrf->GetLoopCount( c) ; ++ l) {
const ICurveComposite* pCrvCompo( GetCurveComposite( pSrf->GetLoop( c, l))) ;
for ( int u = 0 ; u < pCrvCompo->GetCurveCount() ; ++ u) {
@@ -9394,7 +9445,7 @@ Pocketing::AdaptSfrWithRaw( ISurfFlatRegion* pSrf, Vector3d vtTrasl, const doubl
m_pGeomDB->SetMaterial( aaa, nProp0 == 0 ? BLUE : RED) ;
}
}
}
}*/
//PtrOwner<ISurfFlatRegion> pSrf_toDraw( CloneSurfFlatRegion( pSrf)) ;
//pSrf_toDraw->Translate( vtTrasl) ;
@@ -10306,8 +10357,6 @@ Pocketing::GetProjStmBoxOnSfr( const ISurfFlatRegion* pSfr, const ISurfTriMesh*
PtrOwner<ISurfTriMesh> pSrfRaw_clone( CloneSurfTriMesh( pStmRaw)) ;
if ( IsNull( pSrfRaw_clone))
return false ;
//if ( ! pSrfRaw_clone->Cut( plProj, true))
// return false ;
if ( ! pSrfRaw_clone->CutWithOtherSurf( *pSrf_ForCuttingRaw, true, true))
return false ;
if ( ! pSrfRaw_clone->IsValid() || pSrfRaw_clone->GetTriangleCount() == 0) {
@@ -10343,16 +10392,25 @@ Pocketing::GetProjStmBoxOnSfr( const ISurfFlatRegion* pSfr, const ISurfTriMesh*
}
// creo una Regione piana a partire da tutte le curve ( superificie che restituisco)
PtrOwner<ISurfFlatRegion> pSfrProj( CreateSurfFlatRegion()) ;
if ( IsNull( pSfrProj))
return false ;
SurfFlatRegionByContours pSrf_H_Final ;
//pSrf_H_Final.AddCurve( GetCurveComposite( pSfr->GetLoop( 0,0))) ;
//PtrOwner<ISurfFlatRegion> pSfrProj( CloneSurfFlatRegion( pSfr)) ;
//if ( IsNull( pSfrProj) || ! pSfrProj->IsValid())
// return false ;
//int g = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pStr_real->Clone()) ;
//m_pGeomDB->SetMaterial( g, GREEN) ;
// creo un vettore con le curve esterne
// in posizione 0 metto la curva esterna della superificie da svuoatre originale
// nelle posizioni successive inserisco le curve esterne dei chunk creati ( aperti per definizione)
ICRVCOMPOPOVECTOR vCrvExtProj ;
vCrvExtProj.emplace_back( GetCurveComposite( pSfr->GetLoop( 0, 0))) ;
// Proietto ora le curve, delle facce della superificie ottenuta, sul piano della svuotatura
for ( int f = 0 ; f < pStr_real->GetFacetCount() ; ++ f) {
// controllo se la faccia è quasi percpendicolare, nel caso la salto
// controllo se la faccia è quasi perpendicolare, nel caso la salto
Vector3d vtN_check ; pStr_real->GetFacetNormal( f, vtN_check) ;
if ( abs( vtN_check * vtNorm) < EPS_ZERO)
continue ;
@@ -10371,10 +10429,9 @@ Pocketing::GetProjStmBoxOnSfr( const ISurfFlatRegion* pSfr, const ISurfTriMesh*
Plane3d plCheck ;
if ( ! pCrvProjFacef->IsClosed() || ! pCrvProjFacef->GetArea( plCheck, dArea) || dArea <= EPS_SMALL)
continue ;
// aggiungo questa curva solo se :
bool bNeedProj = false ;
// 1) cerco se ho dei tratti sulla curva di proiezione che fanno overlap con il bordo della superificie da svuoatare
// 1) cerco se ho dei tratti sulla curva di proiezione che fanno overlap con il bordo della superificie da svuotare
for ( int cc_ = 0 ; cc_ < pSfr->GetChunkCount() && !bNeedProj ; ++ cc_) {
// recupero il bordo esterno
PtrOwner<ICurveComposite> pCrvEB_Ccc_( GetCurveComposite( pSfr->GetLoop( cc_, 0))) ;
@@ -10410,7 +10467,7 @@ Pocketing::GetProjStmBoxOnSfr( const ISurfFlatRegion* pSfr, const ISurfTriMesh*
if ( ! bNeedProj)
continue ;
// 2) ha almeno una sottocurva sovrapposta ad un lato aperto della superfcicie originale
// 2) ha almeno una sottocurva sovrapposta ad un lato aperto della superificie originale
CRVCVECTOR ccClass ;
if ( pSfrPock->GetCurveClassification( *pCrvProjFacef, EPS_SMALL, ccClass)) {
for ( int j = 0 ; j < ( int)ccClass.size() && bNeedProj ; ++ j) {
@@ -10421,30 +10478,40 @@ Pocketing::GetProjStmBoxOnSfr( const ISurfFlatRegion* pSfr, const ISurfTriMesh*
if ( ! bNeedProj)
continue ;
// 3) setto tutte le sottocurve aperte ( sono proiezioni...)
PtrOwner<ICurveComposite> pCrvCompo_ProjFacef( CreateCurveComposite()) ;
if ( IsNull( pCrvCompo_ProjFacef))
return false ;
pCrvCompo_ProjFacef->AddCurve( Release( pCrvProjFacef)) ;
for ( int uu = 0 ; uu < pCrvCompo_ProjFacef->GetCurveCount() ; ++ uu)
pCrvCompo_ProjFacef->SetCurveTempProp( uu, 1, 0) ;
if ( l == 0)
pSfr_ff->AddExtLoop( pCrvProjFacef->Clone()) ;
else
pSfr_ff->AddIntLoop( pCrvProjFacef->Clone()) ;
//if ( IsNull( pSfr_ff) || ! pSfr_ff->IsValid()) {
//int r = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvProjFacef->Clone()) ;
//m_pGeomDB->SetMaterial( r, RED) ;
//}
if ( l == 0) // se primo allora loop esterno...
pSfr_ff->AddExtLoop( pCrvCompo_ProjFacef->Clone()) ;
else // ... altrimenti loop interno
pSfr_ff->AddIntLoop( pCrvCompo_ProjFacef->Clone()) ;
// inserisco nel vettore la curva trovata
vCrvExtProj.emplace_back( Release( pCrvCompo_ProjFacef)) ;
}
if ( IsNull( pSfr_ff) || ! pSfr_ff->IsValid())
continue ;
if ( AreOppositeVectorApprox( pSfr_ff->GetNormVersor(), vtNorm))
pSfr_ff->Invert() ;
if ( ! pSfrProj->IsValid() || pSfrProj->GetChunkCount() == 0)
pSfrProj.Set( Release( pSfr_ff)) ;
else
pSfrProj->Add( *Release( pSfr_ff)) ;
//pSfrProj->Add( *Release( pSfr_ff)) ;
pSrf_H_Final.AddCurve( pSfr_ff->GetLoop( 0, 0)) ;
}
// Recupero la regione e controllo la validità
//pSfrProj.Set( pSrf_Help.GetSurf()) ;
for ( int o = 0 ; o < ( int)vCrvExtProj.size() ; ++ o) {
int g = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, vCrvExtProj[o]->Clone()) ;
m_pGeomDB->SetMaterial( g, BLACK) ;
}
// controllo la validità della regione
PtrOwner<ISurfFlatRegion> pSfrProj( CloneSurfFlatRegion( pSfr)) ;
pSfrProj->Add( *pSrf_H_Final.GetSurf()) ;
if ( IsNull( pSfrProj) || ! pSfrProj->IsValid())
return true ;
@@ -10453,19 +10520,72 @@ Pocketing::GetProjStmBoxOnSfr( const ISurfFlatRegion* pSfr, const ISurfTriMesh*
if ( AreOppositeVectorApprox( vtN_check, vtNorm))
pSfrProj->Invert() ;
// estendo la regione iniziale mediante i lati aperti
// -----------------------------------------------------------------------------------------
PtrOwner<ICurveComposite> pCrvExt( GetCurveComposite( pSfr->GetLoop( 0, 0))) ;
if ( IsNull( pCrvExt) || ! pCrvExt->IsValid())
return false ;
ICRVCOMPOPOVECTOR vCrvNull ;
// allargo la copia della superificie iniziale estendendola presso i lati aperti
// ( semplice AdjustContourWithOpenEdges, senza grezzo e senza regione di incidenza, verrà tutto fatto in seguito)
if ( AdjustContourWithOpenEdges( pCrvExt, vCrvNull, m_dMaxLenRawProj, 0.0, 0.0, V_NULL, nullptr, true)) {
PtrOwner<ISurfFlatRegion> pSrfWithOEModified( CreateSurfFlatRegion()) ;
if ( IsNull( pSrfWithOEModified))
return false ;
pSrfWithOEModified->AddExtLoop( Release( pCrvExt)) ; // la modifico con la curva appena restituita ( allargata dai lati aperti)
if ( pSrfWithOEModified->IsValid()) { // se la superificie ottenuta è valida...
// ... la clono...
PtrOwner<ISurfFlatRegion> pSfrProj_Clone( CloneSurfFlatRegion( pSfrProj)) ;
if ( IsNull( pSfrProj_Clone) || ! pSfrProj_Clone->IsValid())
return false ;
// controllo che le normali siano compatibili
if ( AreOppositeVectorApprox( pSfrProj_Clone->GetNormVersor(), pSrfWithOEModified->GetNormVersor()))
pSfrProj_Clone->Invert() ;
int ga = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrProj_Clone->Clone()) ;
m_pGeomDB->SetMaterial( ga, RED) ;
int gaa = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrfWithOEModified->Clone()) ;
m_pGeomDB->SetMaterial( gaa, PURPLE) ;
// ... e Interseco la superificie di proiezione con questa nuova superificie
if ( pSfrProj_Clone->Intersect( *pSrfWithOEModified) && ! IsNull( pSfrProj_Clone) && pSfrProj_Clone->IsValid()) {
int g = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrProj_Clone->Clone()) ;
m_pGeomDB->SetMaterial( g, GREEN) ;
// Recupero le TmpProp e creo la nuova superificie mediante questo loop esterno
PtrOwner<ICurve> pCrv_NewExt( pSfrProj_Clone->GetLoop( 0, 0)) ;
if ( IsNull( pCrv_NewExt) || ! pCrv_NewExt->IsValid())
return false ;
PtrOwner<ICurveComposite> pCrvCompo_NewExt( CreateCurveComposite()) ; // trasformo in composita
if ( IsNull( pCrvCompo_NewExt))
return false ;
pCrvCompo_NewExt->AddCurve( Release( pCrv_NewExt)) ;
if ( pCrvCompo_NewExt->IsValid()) {
// imposto le proprietà temporanee delle curve
for ( int u = 0 ; u < pCrvCompo_NewExt->GetCurveCount() ; ++ u) {
bool bFound = false ;
for ( int i = 0 ; i < ( int)vCrvExtProj.size() && !bFound ; ++ i) {
int nStat = -1 ;
if ( SetTmpPropByOverlap( pCrvCompo_NewExt, u, vCrvExtProj[i], nStat, 100 * EPS_SMALL) && nStat == 1)
bFound = true ;
}
if ( ! bFound)
pCrvCompo_NewExt->SetCurveTempProp( u, 0, 0) ; // chiusa per sicurezza
}
// creo la superificie finale
PtrOwner<ISurfFlatRegion> pSrfProj_Final( CreateSurfFlatRegion()) ;
if ( IsNull( pSrfProj_Final))
return false ;
pSrfProj_Final->AddExtLoop( Release( pCrvCompo_NewExt)) ;
if ( pSrfProj_Final->IsValid()) {
if ( AreOppositeVectorApprox( pSrfProj_Final->GetNormVersor(), pSfr->GetNormVersor()))
pSrfProj_Final->Invert() ;
}
pSfrRawBoxProj->Clear() ;
pSfrRawBoxProj->CopyFrom( pSrfProj_Final) ;
return pSfrRawBoxProj->IsValid() ;
}
}
}
}
// la proiezione che serve è solamente l'intersezione tra la proiezione del grezzo ricavato e la supericie allargata
// dai lati aperti
// restituisco la FlatRegion della proiezione del grezzo
pSfrRawBoxProj->Clear() ;
pSfrRawBoxProj->CopyFrom( pSfrProj) ;
//int g = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrRawBoxProj->Clone()) ;
//m_pGeomDB->SetMaterial( g, GREEN) ;
return pSfrRawBoxProj->IsValid() && pSfrRawBoxProj->GetChunkCount() > 0 ;
return false ;
}
@@ -10543,27 +10663,20 @@ Pocketing::ProjectRaw( ISurfFlatRegion* pSrf, const Vector3d& vtTrasl,
if ( IsNull( pSrfOnPlPlus) || ! pSrfOnPlPlus->IsValid() || pSrfOnPlPlus->GetChunkCount() == 0)
continue ;
int aaa = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrfOnPlPlus->Clone()) ;
m_pGeomDB->SetMaterial( aaa, RED) ;
int aaag = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrf_clone_ChunkC->Clone()) ;
m_pGeomDB->SetMaterial( aaag, GREEN) ;
if ( ! pSrf_clone_ChunkC->Add( *Release( pSrfOnPlPlus)))
continue ;
int aaab = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrf_clone_ChunkC->Clone()) ;
m_pGeomDB->SetMaterial( aaab, ORANGE) ;
// recupero la curva esterna
PtrOwner<ICurveComposite> pNewCrvExt( GetCurveComposite( pSrf_clone_ChunkC->GetLoop( 0, 0))) ;
int nStat = - 1 ;
for ( int u = 0 ; u < pNewCrvExt->GetCurveCount() ; ++ u) {
int nStat = -1 ;
if ( SetTmpPropByOverlap( pNewCrvExt, u, pCrvExt_Loop, nStat, 5 * EPS_SMALL) &&
( nStat == 0 || nStat == 2))
pNewCrvExt->SetCurveTempProp( u, 1, 0) ;
//int aaa = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrfOnPlPlus->Clone()) ;
//m_pGeomDB->SetMaterial( aaa, RED) ;
for ( int cc = 0 ; cc < pSrfOnPlPlus->GetChunkCount() ; ++ cc) {
for ( int ll = 0 ; ll < pSrfOnPlPlus->GetLoopCount( cc) ; ++ ll) {
const ICurveComposite* pCrvCompo( GetCurveComposite( pSrfOnPlPlus->GetLoop( cc, ll))) ;
for ( int uu = 0 ; uu < pCrvCompo->GetCurveCount() ; ++ uu) {
int nProp0 ; pCrvCompo->GetCurveTempProp( uu, nProp0, 0) ;
int aaak = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvCompo->GetCurve( uu)->Clone()) ;
m_pGeomDB->SetMaterial( aaak, nProp0 == 0 ? AQUA :ORANGE) ;
}
}
}
// recupero la curva esterna
PtrOwner<ICurveComposite> pNewCrvExt( GetCurveComposite( pSrfOnPlPlus->GetLoop( 0, 0))) ;
// recupero la nuova superificie con la curva esterna modificata e le isole originali
pSrf_Help.AddCurve( Release( pNewCrvExt)) ;
for ( int i = 0 ; i < ( int)vCrvIsl.size() ; ++ i)
Pocketing.h
+1 -1
View File
@@ -320,7 +320,7 @@ class Pocketing : public Machining
double m_dOpenMinSafe ; // minima distanza di sicurezza di attacco su lato aperto
bool m_bIntersRaw = true ; // flag per intersezione con grezzo
bool m_bProjectRaw = true ; // flag di proiezione del grezzo
double m_dMaxLenRawProj = 40 ; // lunghezza massima per contatto di proiezione
double m_dMaxLenRawProj = 20 ; // 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
bool m_bAssignFeed = true ; // flag per controllo della Feed