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

EgtMachKernel:

Browse Source 
- modifiche proiezioni con scalatura.
This commit is contained in:
Riccardo Elitropi
2023-08-21 13:32:56 +02:00
parent 98aac3154c
commit 01d3e7baa9
2 changed files with 129 additions and 232 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Pocketing.cpp
+128 -232
View File
@@ -9480,6 +9480,7 @@ Pocketing::GetParamsAtEachStep( ISURFFRPOVECTOR& vSrfSliced, vector<ICRVCOMPOPOV
// se la geometria selezionata è una Trimesh, allora controllo se ci sono delle facce da proiettare
if ( ! ProjectEdgesOfSelectedStm( pSrfChunk_c, pStmORIG, pSfrExtended))
return false ;
}
// ======================================================================================
@@ -9741,69 +9742,10 @@ Pocketing::GetAdaptedSfrByTrimesh( const ISurfFlatRegion* pSrfExtended, const IS
//int g = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pStmORIG_forCut->Clone()) ;
//m_pGeomDB->SetMaterial( g, GRAY) ;
// 6) Proeitto tutte le facce ottenute sul piano di proeizione
for ( int f = 0 ; f < pStmORIG_forCut->GetFacetCount() ; ++ f) {
// 7) Estrazione del bordo della faccia -> Curva composita
POLYLINEVECTOR vPL ;
pStmORIG_forCut->GetFacetLoops( f, vPL) ;
SurfFlatRegionByContours SfrByC_Tmp ;
// 8) Creazione del Loop i-esimo della faccia f
for ( int i = 0 ; i < ( int)vPL.size() ; ++ i) {
PtrOwner<ICurveComposite> pCrvCompoLoop( CreateCurveComposite()) ;
if ( IsNull( pCrvCompoLoop))
return false ;
pCrvCompoLoop->FromPolyLine( vPL[i]) ;
pCrvCompoLoop->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL) ;
// NB. essendo una curva derivante da un contorno di Trimesh ho una composita derivante da una polyLine,
// devo recuperare gli archi e approssimarli
PolyArc PA ;
Frame3d frPock ; frPock.Set( ptC, vtN) ;
if ( ! frPock.IsValid())
return false ;
pCrvCompoLoop->ToLoc( frPock) ;
pCrvCompoLoop->ApproxWithArcsEx( 0.5 , ANG_TOL_STD_DEG, LIN_FEA_STD, PA) ;
pCrvCompoLoop->Clear() ;
pCrvCompoLoop->FromPolyArc( PA) ;
pCrvCompoLoop->ToGlob( frPock) ;
pCrvCompoLoop->SetExtrusion( vtExtr) ;
pCrvCompoLoop->SetThickness( dThick) ;
// 6) Proeizione della TriMesh tagliata sul piano di svuotatura
if ( ! ProjectStmOnPlane( pStmORIG_forCut, plProj, pSfrProjUP))
return false ;
//int o = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvCompoLoop->Clone()) ;
//m_pGeomDB->SetMaterial( o, ORANGE) ;
// 8) Proeizione della curva sul piano di proeizione
PtrOwner<ICurve> pCrvProj( ProjectCurveOnPlane( *pCrvCompoLoop, plProj)) ;
//int g = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvProj->Clone()) ;
//m_pGeomDB->SetMaterial( g, GREEN) ;
if ( ! IsNull( pCrvProj) && pCrvProj->IsValid()) {
// 9) aggiorno il vettore delle curve ( queste curve devono essere tutte chiuse...)
PtrOwner<ICurveComposite> pCrvCompoForTmpProps( ConvertCurveToComposite( pCrvProj->Clone())) ;
if ( ! IsNull( pCrvCompoForTmpProps) && pCrvCompoForTmpProps->IsValid()) {
for ( int u = 0 ; u < pCrvCompoForTmpProps->GetCurveCount() ; ++ u)
pCrvCompoForTmpProps->SetCurveTempProp( u, 0, 0) ; // tutte chiuse...
SfrByC_Tmp.AddCurve( pCrvCompoForTmpProps->Clone()) ;
vAllCrv.emplace_back( Release( pCrvCompoForTmpProps)) ;
}
}
}
// 10) creazione della FlatRegion dalla proiezione
PtrOwner<ISurfFlatRegion> pSfrTmp( SfrByC_Tmp.GetSurf()) ;
if ( ! IsNull( pSfrTmp) && pSfrTmp->IsValid()) {
if ( AreOppositeVectorApprox( pSfrTmp->GetNormVersor(), pSfrORIG->GetNormVersor()))
pSfrTmp->Invert() ;
//int l = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrTmp->Clone()) ;
//m_pGeomDB->SetMaterial( l, LIME) ;
if ( ! pSfrProjUP->IsValid() || pSfrProjUP->GetChunkCount() == 0)
pSfrProjUP.Set( Release( pSfrTmp)) ;
else
pSfrProjUP->Add( *pSfrTmp) ;
}
}
}
else
return false ;
@@ -9811,36 +9753,6 @@ Pocketing::GetAdaptedSfrByTrimesh( const ISurfFlatRegion* pSrfExtended, const IS
else
return false ;
/*int p = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrProjUP->Clone()) ;
m_pGeomDB->SetMaterial( p, PURPLE) ;*/
// 11) dato che pSfrProjUP è attenuta dall'unione di molte superifici proiettate, meglio sistemare i bordi ( specialmente gli archi)
/*if ( pSfrProjUP->IsValid()) {
SurfFlatRegionByContours SrfByC_ProjUP ;
for ( int c = 0 ; c < pSfrProjUP->GetChunkCount() ; ++ c) {
for ( int l = 0 ; l < pSfrProjUP->GetLoopCount( c) ; ++ l) {
PtrOwner<ICurveComposite> pCrvLoop( ConvertCurveToComposite( pSfrProjUP->GetLoop( c, l))) ;
if ( IsNull( pCrvLoop) || ! pCrvLoop->IsValid())
return false ;
PolyArc PA ;
pCrvLoop->ApproxWithArcsEx( 0.5, ANG_TOL_STD_DEG, LIN_FEA_STD, PA) ;
pCrvLoop->Clear() ;
pCrvLoop->FromPolyArc( PA) ;
SrfByC_ProjUP.AddCurve( Release( pCrvLoop)) ;
}
}
PtrOwner<ISurfFlatRegion> pSfrProjUP_Cute( CreateSurfFlatRegion()) ;
if ( IsNull( pSfrProjUP_Cute))
return false ;
pSfrProjUP_Cute.Set( SrfByC_ProjUP.GetSurf()) ;
if ( ! IsNull( pSfrProjUP_Cute) && pSfrProjUP_Cute->IsValid()) {
pSfrProjUP->Clear() ;
pSfrProjUP->CopyFrom( pSfrProjUP_Cute) ;
if ( ! pSfrProjUP->IsValid())
return false ;
}
}*/
//int r = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrProjUP->Clone()) ;
//m_pGeomDB->SetMaterial( r, RED) ;
@@ -9909,6 +9821,105 @@ Pocketing::GetAdaptedSfrByTrimesh( const ISurfFlatRegion* pSrfExtended, const IS
}
//----------------------------------------------------------------------------
bool
Pocketing::ProjectStmOnPlane( const ISurfTriMesh* pStmAbove, const Plane3d plPock, ISurfFlatRegion* pSfrProj)
{
// controllo parametri
if ( pStmAbove == nullptr || ! pStmAbove->IsValid() || pStmAbove->GetTriangleCount() == 0)
return true ;
if ( ! plPock.IsValid())
return false ;
pSfrProj->Clear() ;
// 1) creo il sistema di riferimento ( inerente al piano di svuotatura)
Point3d ptORIG = plPock.GetPoint() ;
Vector3d vtN = -plPock.GetVersN() ;
Frame3d frPlane ; frPlane.Set( ptORIG, vtN) ;
if ( ! frPlane.IsValid())
return false ;
// 2) creo una copia della superficie nel nuovo sistema di riferimento
PtrOwner<ISurfTriMesh> pStmRef( CloneSurfTriMesh( pStmAbove)) ;
if ( IsNull( pStmRef) || ! pStmRef->IsValid())
return false ;
// 3) scalo la superficie rispetto al sistema di riferimento ( mettendo a 0 la conponente vtN)
if ( ! pStmRef->Scale( frPlane, 1., 1., 0.))
return false ;
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)
return true ; // la proeizione sparisce
// 5) NB. A seconda di come sono orientate le facce, posso avere i Triangoli con normali vtN o -vtN...
// rendo le normali dei triangoli coerenti
StmFromTriangleSoup TriaSoupUp ; TriaSoupUp.Start() ;
StmFromTriangleSoup TriaSoupDown ; TriaSoupDown.Start() ;
for ( int t = 0 ; t < pStmRef->GetTriangleCount() ; ++ t) {
Triangle3d Tria ; pStmRef->GetTriangle( t, Tria) ;
if ( AreOppositeVectorApprox( Tria.GetN(), vtN))
TriaSoupDown.AddTriangle( Tria) ;
else
TriaSoupUp.AddTriangle( Tria) ;
}
TriaSoupUp.End() ;
TriaSoupDown.End() ;
PtrOwner<ISurfTriMesh> pStmUp( TriaSoupUp.GetSurf()) ; // superificie con i Triangoli Up
PtrOwner<ISurfTriMesh> pStmDown( TriaSoupDown.GetSurf()) ; // superificie con i Triangoli Down
// 5.1) Controllo ausiliario... ( per possibili approssimazioni con triangoli particolari)
if ( ! IsNull( pStmUp) && pStmUp->IsValid() && pStmUp->GetTriangleCount() == 0 &&
! IsNull( pStmDown) && pStmDown->IsValid() && pStmDown->GetTriangleCount() == 0)
return true ;
//pStmUp->Repair() ; pStmDown->Repair() ;
//int r = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pStmUp->Clone()) ;
//int o = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pStmDown->Clone()) ;
//m_pGeomDB->SetMaterial( r, RED) ;
//m_pGeomDB->SetMaterial( o, ORANGE) ;
//m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrProj->Clone()) ;
// 6) Essendo due Trimesh piane e sullo stesso piano, converto in FlatRegion prima di unirle
PtrOwner<ISurfFlatRegion> pSfrUp( CreateSurfFlatRegion()) ;
PtrOwner<ISurfFlatRegion> pSfrUp1( CreateSurfFlatRegion()) ;
if ( IsNull( pSfrUp) || IsNull( pSfrUp1))
return false ;
if ( ! IsNull( pStmUp) && pStmUp->IsValid() && pStmUp->GetTriangleCount() > 0) {
if ( ! GetSfrByStm( pStmUp, pSfrUp, plPock, V_NULL, 0., 0.))
return false ;
}
if ( ! IsNull( pStmDown) && pStmDown->IsValid() && pStmDown->GetTriangleCount() > 0) {
if ( ! pStmDown->Invert() ||
! GetSfrByStm( pStmDown, pSfrUp1, plPock, V_NULL, 0., 0.))
return false ;
}
// 7) Controllo validità e creo la FlatRegion da restituire
if ( ! IsNull( pSfrUp) && pSfrUp->IsValid()) // se Up valida, allora inizio a sostituire
pSfrProj->CopyFrom( pSfrUp) ;
if ( ! IsNull( pSfrUp1) && pSfrUp1->IsValid()) { // se Down valida...
if ( pSfrProj != nullptr && pSfrProj->IsValid()) { // e Up valida -> aggiungo
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 ;
}
//----------------------------------------------------------------------------
bool
Pocketing::CloseCurvesOnProjectionSurface( ICurveComposite* pCrvCompo, const ISurfFlatRegion* pSrfProjDanger)
@@ -11485,7 +11496,7 @@ Pocketing::GetProjStmOnSfr( const ISurfFlatRegion* pSfr, const ISurfTriMesh* pSt
pSrfRaw_clone->Cut( plNear, true) ;
if ( pSrfRaw_clone->IsValid())
pSrfRaw_clone->Cut( plFar, true) ;
// se step > 1 -> chiudo la superificie dalla parte del piano di far
// chiudo la superificie dalla parte del piano di far
if ( ! IsNull( pSrfRaw_clone) && pSrfRaw_clone->IsValid()) {
POLYLINEVECTOR vPL ;
pSrfRaw_clone->GetLoops( vPL) ;
@@ -11504,7 +11515,7 @@ Pocketing::GetProjStmOnSfr( const ISurfFlatRegion* pSfr, const ISurfTriMesh* pSt
PtrOwner<ISurfTriMesh> pStm_SideAtFar( CreateSurfTriMesh()) ;
if ( pStm_SideAtFar->CreateByFlatContour( vPL[p])) {
Vector3d vtN ;
if ( pStm_SideAtFar->GetFacetNormal( 0, vtN) && AreOppositeVectorApprox( vtN, plNear.GetVersN()))
if ( pStm_SideAtFar->GetFacetNormal( 0, vtN) && AreOppositeVectorApprox( vtN, -plNear.GetVersN()))
pStm_SideAtFar->Invert() ;
}
pSrfRaw_clone->DoSewing( *pStm_SideAtFar) ;
@@ -11558,110 +11569,6 @@ Pocketing::GetProjStmOnSfr( const ISurfFlatRegion* pSfr, const ISurfTriMesh* pSt
// quindi in posizione 0 ho una curva con i lati aperti/chiusi già settati
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 perpendicolare, nel caso la salto
Vector3d vtN_check ; pStr_real->GetFacetNormal( f, vtN_check) ;
if ( abs( vtN_check * vtNorm) < EPS_ZERO)
continue ;
POLYLINEVECTOR vPL ;
pStr_real->GetFacetLoops( f, vPL) ;
// per ogni Loop l della faccia f
for ( int l = 0 ; l < ( int) vPL.size() ; ++ l) {
PtrOwner<ICurveComposite> pCrvBorder( CreateCurveComposite()) ;
if ( IsNull( pCrvBorder) || ! pCrvBorder->FromPolyLine( vPL[l]))
return false ;
PtrOwner<ICurve> pCrvProjFacef( ProjectCurveOnPlane( *pCrvBorder, plProj)) ;
if ( IsNull( pCrvProjFacef) || ! pCrvProjFacef->IsValid())
return false ;
// controllo validità della curva ( che sia chiusa e non degenere)
double dArea = EPS_SMALL ;
Plane3d plCheck ;
if ( ! pCrvProjFacef->IsClosed() ||
! pCrvProjFacef->GetArea( plCheck, dArea) ||
dArea <= 5 * EPS_SMALL)
continue ;
// creo la curva composita associata
PtrOwner<ICurveComposite> pCrvBorderProj_f( CreateCurveComposite()) ;
pCrvBorderProj_f->AddCurve( Release( pCrvProjFacef)) ;
// 1) controllo se una sottocurva della curva composita del bordo è sufficientemente vicina ad una curva aperta
// della curva originale di bordo della superificie esterna
bool bNeedProj = false ;
for ( int i = 0 ; i < pCrvBorderProj_f->GetCurveCount() && !bNeedProj; ++ i) {
const ICurve* pCrv_i = pCrvBorderProj_f->GetCurve( i) ;
if ( pCrv_i == nullptr)
return false ;
for ( int j = 0 ; j < ( int)vCrvOpen.size() && !bNeedProj ; ++ j) {
int nStat = -1 ;
const double nMAX = 10.0 ;
for ( int i = 0 ; i <= nMAX && !bNeedProj ; ++i) {
double dPar = i / nMAX ;
Point3d ptC ; pCrv_i->GetPointD1D2( dPar, ICurve::FROM_PLUS, ptC) ;
if ( vCrvOpen[j]->IsPointOn( ptC, 150 * EPS_SMALL))
bNeedProj = true ;
}
}
}
if ( ! bNeedProj) {
// 2) controllo se un tratto aperto è sufficientemente vicino ad una sottocurva della curva composita del bordo
// della proiezione
for ( int j = 0 ; j < ( int)vCrvOpen.size() && !bNeedProj ; ++ j) {
for ( int u = 0 ; u < ( int)vCrvOpen[j]->GetCurveCount() && !bNeedProj ; ++ u) {
const ICurve* pCrv_j_u = vCrvOpen[j]->GetCurve( u) ;
if ( pCrv_j_u == nullptr)
return false ;
int nStat = -1 ;
if ( CheckSimpleOverlap( pCrv_j_u, pCrvBorderProj_f, nStat, 150 * EPS_SMALL) && nStat == 1)
bNeedProj = true ;
}
}
}
if ( ! bNeedProj) {
// 3) controllo se la questa curva contiene o interseca un lato aperto
// 3.1) creo una flat region ausiliaria per determinare il verso corretto della curva proeittata
PtrOwner<ISurfFlatRegion> pSrf_HelpProjPart( CreateSurfFlatRegion()) ;
if ( IsNull( pSrf_HelpProjPart))
return false ;
pSrf_HelpProjPart->AddExtLoop( pCrvBorderProj_f->Clone()) ;
if ( AreOppositeVectorApprox( pSrf_HelpProjPart->GetNormVersor(), pSrfOrig->GetNormVersor()))
pSrf_HelpProjPart->Invert() ;
// 3.2) ricavo la curva di bordo della regione ( lascio le isole invariate) <- possibile miglioria (?)
PtrOwner<ICurveComposite> pCrvBorder_Check( ConvertCurveToComposite( pSfrPock->GetLoop( 0, 0))) ;
if ( IsNull( pCrvBorder_Check) || ! pCrvBorder_Check->IsValid())
return false ;
// 3.3) classificazione
CRVCVECTOR ccClass_H ;
if ( pSrf_HelpProjPart->GetCurveClassification( *pCrvBorder_Check, EPS_SMALL, ccClass_H)) {
for ( int j = 0 ; j < ( int)ccClass_H.size() && !bNeedProj ; ++ j) {
if ( ccClass_H[j].nClass == CRVC_IN) {
// se tratto j di curva interno, controllo se c'è un sotto-tratto jj aperto
PtrOwner<ICurveComposite> pCrvCompo_forOpens(
ConvertCurveToComposite( pCrvBorder_Check->CopyParamRange( ccClass_H[j].dParS, ccClass_H[j].dParE))) ;
if ( ! IsNull( pCrvCompo_forOpens) && pCrvCompo_forOpens->IsValid()) {
// scorro le sottocurve del tratto j
for ( int u = 0 ; u < pCrvCompo_forOpens->GetCurveCount() && !bNeedProj ; ++ u) {
int nTmpProp0 = 0 ;
if ( pCrvCompo_forOpens->GetCurveTempProp( u, nTmpProp0, 0) && nTmpProp0 == 1)
bNeedProj = true ;
}
}
}
}
}
}
if ( ! bNeedProj) // se non devo proiettare passo alla prossima
continue ;
// 3) Setto tutte le sottocurve aperte
for ( int uu = 0 ; uu < pCrvBorderProj_f->GetCurveCount() ; ++ uu)
pCrvBorderProj_f->SetCurveTempProp( uu, 1, 0) ;
// inserisco nel vettore delle curve di bordo
vCrvExtProj.emplace_back( Release( pCrvBorderProj_f)) ; // <---- dall'indice 1 in poi ho solo curve aperte e
// sono le curve di bordo delle proeizioni
}
}
// Clono la superificie di partenza ( per sicurezza lascio invariata quella passata alla funzione)
PtrOwner<ISurfFlatRegion> pSrf_Clone( CloneSurfFlatRegion( pSfr)) ;
if ( IsNull( pSrf_Clone) || ! pSrf_Clone->IsValid())
@@ -11672,45 +11579,31 @@ Pocketing::GetProjStmOnSfr( const ISurfFlatRegion* pSfr, const ISurfTriMesh* pSt
if ( IsNull( pSrf_Proj_Ext))
return false ;
// ---------------- CREAZIONE DELLA VERA A PROPRIA REGIONE DI INCIDENZA, COME SOMMA DELLE
// ----------------------------- SINGOLE FLATREGIONS DI PROIEZIONE -----------------------------
for ( int i = 1 ; i < ( int)vCrvExtProj.size() ; ++ i) {
CRVCVECTOR ccClass ;
if ( pSrf_Clone->GetCurveClassification( *vCrvExtProj[i], 150 * EPS_SMALL, ccClass)) {
bool bAdd = false ;
for ( int j = 0 ; j < ( int)ccClass.size() && !bAdd ; ++ j)
bAdd = ccClass[j].nClass == CRVC_OUT || ccClass[j].nClass == CRVC_ON_M || ccClass[j].nClass == CRVC_ON_P ;
if ( bAdd) {
PtrOwner<ISurfFlatRegion> pSrf_H( CreateSurfFlatRegion()) ;
if ( IsNull( pSrf_H))
return false ;
pSrf_H->AddExtLoop( vCrvExtProj[i]->Clone()) ;
// inverto se le normali risultano opposte
if ( pSrf_H->IsValid()) {
if ( AreOppositeVectorApprox( pSrf_H->GetNormVersor() , pSrf_Clone->GetNormVersor()))
pSrf_H->Invert() ;
}
if ( pSrf_Proj_Ext->GetChunkCount() == 0)
pSrf_Proj_Ext.Set( Release( pSrf_H)) ;
else {
PtrOwner<ISurfFlatRegion> pSrf_Check( CloneSurfFlatRegion( pSrf_Proj_Ext)) ;
if ( IsNull( pSrf_Check))
return false ;
if ( ! pSrf_Proj_Ext->Add( *pSrf_H) || ! pSrf_Proj_Ext->IsValid())
pSrf_Proj_Ext.Set( Release( pSrf_Proj_Ext)) ;
}
}
}
}
//m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pStr_real->Clone()) ;
if ( ! ProjectStmOnPlane( pStr_real, plProj, pSrf_Proj_Ext))
return false ;
if ( IsNull( pSrf_Proj_Ext) || ! pSrf_Proj_Ext->IsValid())
return true ;
// creo la vera e propria regione di proiezione, sommando la proiezione esterna con la superifcie originale da svuotare
for ( int c = 0 ; c < pSrf_Proj_Ext->GetChunkCount() ; ++ c) {
for ( int l = 0 ; l < pSrf_Proj_Ext->GetLoopCount( c) ; ++ l) {
PtrOwner<ICurveComposite> pCrvCompoLoop( ConvertCurveToComposite( pSrf_Proj_Ext->GetLoop( c, l))) ;
if ( IsNull( pCrvCompoLoop) || ! pCrvCompoLoop->IsValid())
return false ;
for ( int u = 0 ; u < pCrvCompoLoop->GetCurveCount() ; ++ u)
pCrvCompoLoop->SetCurveTempProp( u, 1, 0) ;
vCrvExtProj.emplace_back( Release( pCrvCompoLoop)) ;
}
}
// creo la vera e propria regione di proiezione, sommando la proiezione esterna con la superficie originale
// da svuotare
PtrOwner<ISurfFlatRegion> pSrf_Proj( CloneSurfFlatRegion( pSrf_Proj_Ext)) ;
if ( IsNull( pSrf_Proj) || ! pSrf_Proj->IsValid())
return false ;
pSrf_Proj->Add( *pSfr) ;
pSrf_Proj->Add( *pSfr) ;
//pSrf_Proj->Add( *pSfr) ;
// controllo i loop della superificie creata ------------------------
SurfFlatRegionByContours SrfByC ;
@@ -13835,8 +13728,8 @@ Pocketing::GetDynamicClearedRegion( ISurfFlatRegion* pSrfPrec, const ICurveCompo
//----------------------------------------------------------------------------
bool
Pocketing::GetSfrByStm( const ISurfTriMesh* pStm, ISurfFlatRegion* pSfr, const Plane3d plPock, const Vector3d& vtExtr,
const double dThick, double dToll)
Pocketing::GetSfrByStm( const ISurfTriMesh* pStm, ISurfFlatRegion* pSfr, const Plane3d plPock,
const Vector3d& vtExtr, const double dThick, double dToll)
{
// controllo validità dei parametri
if ( pStm == nullptr || ! pStm->IsValid() ||
@@ -13878,6 +13771,9 @@ 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 ;
//m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrv_c->Clone()) ;
PtrOwner<ICurve> pCrv_proj( ProjectCurveOnPlane( *pCrv_c, plPock)) ;
SrfChunkDef.AddCurve( Release( pCrv_proj)) ; // aggiungo le curve proiettate
}
Pocketing.h
+1
View File
@@ -102,6 +102,7 @@ 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 ProjectStmOnPlane( const ISurfTriMesh* pStmAbove, const Plane3d plPock, ISurfFlatRegion* pSfrProj) ;
bool AdaptSfrWithRaw( ISurfFlatRegion* pSrf, Vector3d vtTrasl, ISurfTriMesh* pStmRaw, const double& dRawSecLen,
ICRVCOMPOPOVECTOR& vCrvOEFlags, bool& bChanged, int nStep, double dStep,
double dAreaToll = 500 * EPS_SMALL) ;