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

EgtMachKernel :

Browse Source 
- migliorie codice proiezione con grezzo.
This commit is contained in:
Riccardo Elitropi
2023-06-27 13:43:26 +02:00
parent ccac200e41
commit e04805a99a
2 changed files with 238 additions and 161 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Pocketing.cpp
+237 -160
View File
@@ -9372,12 +9372,14 @@ Pocketing::AdaptSfrWithRaw( ISurfFlatRegion* pSrf, Vector3d vtTrasl, ICRVCOMPOPO
return false ;
if ( pSrf->GetChunkCount() == 0 || ! pSrf->IsValid())
return true ;
int b = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrf->Clone()) ;
m_pGeomDB->SetMaterial( b, BROWN) ;
//int b = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrf->Clone()) ;
//m_pGeomDB->SetMaterial( b, BROWN) ;
}
// 2) PROIEZIONE CON GREZZO
if ( m_bProjectRaw) {
if ( ! ProjectRaw( pSrf, vtTrasl, pStmRaw))
// recupero la Trimesh di partenza
if ( ! ProjectRaw( pSrf, vtTrasl, pStmRaw, nProp0))
return false ;
if ( pSrf->GetChunkCount() == 0 || ! pSrf->IsValid())
return true ;
@@ -9631,9 +9633,6 @@ Pocketing::IntersSurfWithRaw( ISurfFlatRegion* pSfrPock, const ISurfTriMesh* pSt
//m_pGeomDB->SetMaterial( L, LIME) ;
SrfChunkDef.AddCurve( Release( pCrv_proj)) ; // aggiungo le curve proiettate
}
PtrOwner<ISurfFlatRegion> pSrfByCurves( SrfChunkDef.GetSurf()) ;
@@ -10280,31 +10279,60 @@ Pocketing::GetProjStmBoxOnSfr( const ISurfFlatRegion* pSfr, const ISurfTriMesh*
return false ;
// recupero il box globale del grezzo
BBox3d b3Raw ;
if( ! pStmRaw->GetBBox( GLOB_FRM, b3Raw) || b3Raw.IsEmpty())
return false ;
//BBox3d b3Raw ;
//if ( ! pStmRaw->GetBBox( GLOB_FRM, b3Raw) || b3Raw.IsEmpty())
// return false ;
// creo la trimesh del box globale del grezzo e la taglio con il piano
PtrOwner<ISurfTriMesh> pStmRawBox( GetSurfTriMeshBox( b3Raw.GetDimX(), b3Raw.GetDimY(), b3Raw.GetDimZ())) ;
if ( IsNull( pStmRawBox) || ! pStmRawBox->IsValid())
PtrOwner<ISurfTriMesh> pSrfRaw_clone( CloneSurfTriMesh( pStmRaw)) ;
if ( IsNull( pSrfRaw_clone))
return false ;
pStmRawBox->Translate( b3Raw.GetMin() - ORIG) ; // è creata con ptMin nell'origine ( alla funzione passo le dimensioni)
if ( ! pStmRawBox->Cut( plProj, true))
//PtrOwner<ISurfTriMesh> pStmRawClone( GetSurfTriMeshBox( b3Raw.GetDimX(), b3Raw.GetDimY(), b3Raw.GetDimZ())) ;
//if ( IsNull( pStmRawBox) || ! pStmRawBox->IsValid())
// return false ;
//pStmRawBox->Translate( b3Raw.GetMin() - ORIG) ; // è creata con ptMin nell'origine ( alla funzione passo le dimensioni)
if ( ! pSrfRaw_clone->Cut( plProj, true))
return false ;
if ( ! pStmRawBox->IsValid() || pStmRawBox->GetTriangleCount() == 0) {
if ( ! pSrfRaw_clone->IsValid() || pSrfRaw_clone->GetTriangleCount() == 0) {
pSfrRawBoxProj->Clear() ;
return true ;
}
// recupero solo la parte di TriMesh contente la superificie da svuotare
PtrOwner<ISurfTriMesh> pStr_real( CreateSurfTriMesh()) ;
for ( int p = 0 ; p < pSrfRaw_clone->GetPartCount() ; ++ p) {
PtrOwner<ISurfTriMesh> pStm_raw_part( pSrfRaw_clone->ClonePart( p)) ;
POLYLINEVECTOR vPl ;
pStm_raw_part->GetLoops( vPl) ;
for ( int l = 0 ; l < ( int)vPl.size() ; ++ l) {
PtrOwner<ICurveComposite> pCompo( CreateCurveComposite()) ;
pCompo->FromPolyLine( vPl[l]) ;
PtrOwner<ISurfFlatRegion> pSfr_H( CreateSurfFlatRegion()) ;
pSfr_H->AddExtLoop( Release( pCompo)) ;
if ( ! AreSameVectorApprox( pSfr_H->GetNormVersor(), pSfrPock->GetNormVersor()))
pSfr_H->Invert() ;
for ( int c = 0 ; c < pSfrPock->GetChunkCount() ; ++ c) {
if ( pSfr_H->GetChunkSimpleClassification( 0, *pSfrPock, c) != CCREGC_OUT) {
if ( pStr_real->GetTriangleCount() != 0)
pStr_real->Add( *Release( pStm_raw_part)) ;
else
pStr_real.Set( Release( pStm_raw_part)) ;
l = ( int)vPl.size() ;
break ;
}
}
}
}
// creo una Regione piana a partire da tutte le curve
PtrOwner<ISurfFlatRegion> pSfrProj( CreateSurfFlatRegion()) ;
if( IsNull( pSfrProj))
return false ;
// proietto ora le curve, delle facce della superificie ottenuta, sul piano della svuotatura
for ( int f = 0 ; f < pStmRawBox->GetFacetCount() ; ++ f) {
for ( int f = 0 ; f < pStr_real->GetFacetCount() ; ++ f) {
POLYLINEVECTOR vPL ;
pStmRawBox->GetFacetLoops( f, vPL) ;
pStr_real->GetFacetLoops( f, vPL) ;
PtrOwner<ICurveComposite> pCrvBorder( CreateCurveComposite()) ;
if ( IsNull( pCrvBorder) || ! pCrvBorder->FromPolyLine( vPL[0])) // le facce del box sono semplici
return false ;
@@ -10332,7 +10360,7 @@ Pocketing::GetProjStmBoxOnSfr( const ISurfFlatRegion* pSfr, const ISurfTriMesh*
//----------------------------------------------------------------------------
bool
Pocketing::ProjectRaw( ISurfFlatRegion* pSrf, const Vector3d& vtTrasl,
const ISurfTriMesh* pStmRaw)
const ISurfTriMesh* pStmRaw, int nId)
{
// controllo dei paramtri
if ( pSrf == nullptr || ! pSrf->IsValid() || pSrf->GetChunkCount() == 0 ||
@@ -10390,8 +10418,8 @@ Pocketing::ProjectRaw( ISurfFlatRegion* pSrf, const Vector3d& vtTrasl,
pSrf->ToLoc( frLoc) ;
pSrfOnPlPlus->ToLoc( frLoc) ;
//int G = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrfOnPlPlus->Clone()) ;
//m_pGeomDB->SetMaterial( G, GREEN) ;
int G = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrfOnPlPlus->Clone()) ;
m_pGeomDB->SetMaterial( G, GREEN) ;
// creo la superificie finale da restituire
SurfFlatRegionByContours pSrfAfterProj ;
@@ -10417,10 +10445,10 @@ Pocketing::ProjectRaw( ISurfFlatRegion* pSrf, const Vector3d& vtTrasl,
// derivando da una trimesh, semplifico le curve ( specialmente per circonferenze)
pCrvExtProj->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL, true, true) ;
pCrvExtSfr->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL, true, true) ;
//int b = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvExtProj->Clone()) ;
//m_pGeomDB->SetMaterial( b, BLACK) ;
//int l = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvExtSfr->Clone()) ;
//m_pGeomDB->SetMaterial( l, LIME) ;
int b = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvExtProj->Clone()) ;
m_pGeomDB->SetMaterial( b, BLACK) ;
int l = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvExtSfr->Clone()) ;
m_pGeomDB->SetMaterial( l, LIME) ;
// parametri
Vector3d vtS ; Vector3d vtE ;
@@ -10444,6 +10472,7 @@ Pocketing::ProjectRaw( ISurfFlatRegion* pSrf, const Vector3d& vtTrasl,
pCrvExtSfr->ChangeStartPoint( u) ;
}
}
// se la curva ha tutti lati aperti, allora la imposto uguale alla proiezione del grezzo ed esco
if ( ! bCEFound) {
pCrvExtSfr->Clear() ;
@@ -10455,172 +10484,220 @@ Pocketing::ProjectRaw( ISurfFlatRegion* pSrf, const Vector3d& vtTrasl,
pCrvExtSfr->SetCurveTempProp( i, 1) ;
pCrvExtSfr->SetExtrusion( vtExtr) ;
pCrvExtSfr->SetThickness( dthick) ;
PtrOwner<ISurfFlatRegion> pSrf_h( CreateSurfFlatRegion()) ;
for ( int cc = 0 ; cc < pSrf->GetChunkCount() ; ++ cc) {
if ( cc != c)
pSrf_h->Add( *pSrf->CloneChunk( cc)) ;
else
pSrf_h->AddExtLoop( Release( pCrvExtSfr)) ;
}
pSrf->Clear() ;
pSrf->CopyFrom( pSrf_h) ;
pSrf->Translate( - vtTrasl) ;
return true ;
pCrvExtSfr->ToLoc( frLoc) ;
pSrfAfterProj.AddCurve( Release( pCrvExtSfr)) ;
//PtrOwner<ISurfFlatRegion> pSrf_h( CreateSurfFlatRegion()) ;
//for ( int cc = 0 ; cc < pSrf->GetChunkCount() ; ++ cc) {
// if ( cc != c)
// pSrf_h->Add( *pSrf->CloneChunk( cc)) ;
// else
// pSrf_h->AddExtLoop( Release( pCrvExtSfr)) ;
//}
// la proiezione con il grezzo potrebbe essere troppo grande
//pSrf->Clear() ;
//pSrfF->CopyFrom( pSrf_h) ;
//pSrf->Translate( - vtTrasl) ;
//return true ;
}
else {
//int O = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvExtProj->Clone()) ;
//m_pGeomDB->SetMaterial( O, ORANGE) ;
//int R = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvExtSfr->Clone()) ;
//m_pGeomDB->SetMaterial( R, RED) ;
//int O = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvExtProj->Clone()) ;
//m_pGeomDB->SetMaterial( O, ORANGE) ;
// paramtri dU iniziali e finali del tratto di curva compreso tra le due rette
double dUS = EPS_SMALL ;
double dUE = EPS_SMALL ;
//int R = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvExtSfr->Clone()) ;
//m_pGeomDB->SetMaterial( R, RED) ;
// scorro tutte le curve del contorno, cercando di raccordare linearmente i tratti aperti
// con il bordo della proiezione ( in modo da estendere la superficie da svuotare
bool bIsLastOpen = false ;
for ( int c = 0 ; c < pCrvExtSfr->GetCurveCount() || bIsLastOpen ; ++c) {
// recupero la curva c-esima
PtrOwner<ICurve> pCrv( pCrvExtSfr->GetCurve( bIsLastOpen ? 0 : c)->Clone()) ;
if ( IsNull( pCrv))
return false ;
// controllo se fa overlap con il bordo della proiezione e/o con il bordo di un isola aperta
int nStat1 = 0 ;
if ( ! CheckSimpleOverlap( pCrv, pCrvExtProj, nStat1, 5 * EPS_SMALL))
return false ;
// se lato aperto e non sulla curva esterna di proiezione...
if ( pCrv->GetTempProp() == 1 && nStat1 == 0) {
// paramtri dU iniziali e finali del tratto di curva compreso tra le due rette
double dUS = EPS_SMALL ;
double dUE = EPS_SMALL ;
++ nCont ;
if ( nCont == 1) { // ... e primo lato aperto trovato
// scorro tutte le curve del contorno, cercando di raccordare linearmente i tratti aperti
// con il bordo della proiezione ( in modo da estendere la superficie da svuotare
bool bIsLastOpen = false ;
for ( int c = 0 ; c < pCrvExtSfr->GetCurveCount() || bIsLastOpen ; ++c) {
// recupero la curva c-esima
PtrOwner<ICurve> pCrv( pCrvExtSfr->GetCurve( bIsLastOpen ? 0 : c)->Clone()) ;
if ( IsNull( pCrv))
return false ;
// controllo se fa overlap con il bordo della proiezione e/o con il bordo di un isola aperta
int nStat1 = 0 ;
if ( ! CheckSimpleOverlap( pCrv, pCrvExtProj, nStat1, 5 * EPS_SMALL))
return false ;
// se lato aperto e non sulla curva esterna di proiezione...
if ( pCrv->GetTempProp() == 1 && nStat1 == 0) {
++ nCont ;
if ( nCont == 1) { // ... e primo lato aperto trovato
// creo la retta iniziale di raccordo
pCrvLS->Set( ptS, ptS + vtS * 10000) ;
//int CC = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvLS->Clone()) ;
//m_pGeomDB->SetMaterial( CC, AQUA) ;
// creo la retta iniziale di raccordo
pCrvLS->Set( ptS, ptS + vtS * 10000) ;
int CC = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvLS->Clone()) ;
m_pGeomDB->SetMaterial( CC, AQUA) ;
// imposto il parametro inziale sulla curva
pCrvExtSfr->GetParamAtPoint( ptS, dUS) ;
// imposto il parametro inziale sulla curva
pCrvExtSfr->GetParamAtPoint( ptS, dUS) ;
// la spezzo alla prima intersezione con il grezzo
CRVCVECTOR ccClass ;
if ( pSrfOnPlPlus->GetCurveClassification( *pCrvLS, EPS_SMALL, ccClass) &&
( ccClass[0].nClass == CRVC_IN || ccClass[0].nClass == CRVC_ON_P || ccClass[0].nClass == CRVC_ON_M)) {
pCrvLS.Set( GetCurveLine( pCrvLS->CopyParamRange( 0, ccClass[0].dParE))) ;
pCrvLS->SetTempProp( ccClass[0].nClass == CRVC_IN ? 0 : 1) ;
// la spezzo alla prima intersezione con il grezzo
CRVCVECTOR ccClass ;
if ( pSrfOnPlPlus->GetCurveClassification( *pCrvLS, EPS_SMALL, ccClass) &&
( ccClass[0].nClass == CRVC_IN || ccClass[0].nClass == CRVC_ON_P || ccClass[0].nClass == CRVC_ON_M)) {
pCrvLS.Set( GetCurveLine( pCrvLS->CopyParamRange( 0, ccClass[0].dParE))) ;
pCrvLS->SetTempProp( ccClass[0].nClass == CRVC_IN ? 0 : 1) ;
}
else if (( int) ccClass.size() == 0) // retta iniziale degenere ad un punto
nStat = 1 ;
else { // esco ...
pSrf->ToGlob( frLoc) ;
pSrf->Translate( -vtTrasl) ;
return true ;
}
// nel caso in cui la retta tocca la curva della svuotatura n volte...
IntersCurveCurve intCCOpt( *pCrvLS, *pCrvExtSfr) ;
if ( intCCOpt.GetCurveClassification( 0, EPS_SMALL, ccClass) && ( int)ccClass.size() > 1) {
// salto questa proiezione, proviene da isole aperte
pSrf->ToGlob( frLoc) ;
pSrf->Translate( -vtTrasl) ;
return true ;
}
// se ultima curva ...
if ( c == pCrvExtSfr->GetCurveCount() - 1)
bIsLastOpen = true ;
}
else if (( int) ccClass.size() == 0) // retta iniziale degenere ad un punto
nStat = 1 ;
else { // esco ...
pSrf->ToGlob( frLoc) ;
pSrf->Translate( -vtTrasl) ;
return true ;
}
// nel caso in cui la retta tocca la curva della svuotatura n volte...
IntersCurveCurve intCCOpt( *pCrvLS, *pCrvExtSfr) ;
if ( intCCOpt.GetCurveClassification( 0, EPS_SMALL, ccClass) && ( int)ccClass.size() > 1) {
// salto questa proiezione, proviene da isole aperte
pSrf->ToGlob( frLoc) ;
pSrf->Translate( -vtTrasl) ;
return true ;
}
// se ultima curva ...
if ( c == pCrvExtSfr->GetCurveCount() - 1)
bIsLastOpen = true ;
}
}
else {
// se è un chiuso dopo n lati aperti non sulla proiezione...
if ( nCont > 0) {
else {
// se è un chiuso dopo n lati aperti non sulla proiezione...
if ( nCont > 0) {
pCrv->GetStartDir( vtE) ; vtE = -vtE ;
pCrv->GetStartPoint( ptE) ;
pCrv->GetStartDir( vtE) ; vtE = -vtE ;
pCrv->GetStartPoint( ptE) ;
// setto la retta finale di raccordo
pCrvLE->Set( ptE, ptE + vtE * 10000) ;
//int BB = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvLE->Clone()) ;
//m_pGeomDB->SetMaterial( BB, BLUE) ;
// setto la retta finale di raccordo
pCrvLE->Set( ptE, ptE + vtE * 10000) ;
int BB = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvLE->Clone()) ;
m_pGeomDB->SetMaterial( BB, BLUE) ;
// imposto il parametro finale sulla curva
pCrvExtSfr->GetParamAtPoint( ptE, dUE) ;
// imposto il parametro finale sulla curva
pCrvExtSfr->GetParamAtPoint( ptE, dUE) ;
// controllo se il tratto di curva esterno alla superificie da svuotare
PtrOwner<ICurveComposite> pCrvToCheck( GetCurveComposite( pCrvExtSfr->CopyParamRange( dUS, dUE))) ;
if ( ! IsNull( pCrvToCheck) && pCrvToCheck->IsValid()) {
CRVCVECTOR ccClass_c ;
if ( pSrf->GetCurveClassification( *pCrvToCheck, EPS_SMALL, ccClass_c)) {
bool bIsPartOut = false ;
for ( int _c = 0 ; _c < ( int)ccClass_c.size() && ! bIsPartOut ; ++ _c) {
if ( ccClass_c[_c].nClass == CRVC_OUT)
bIsPartOut = true ;
}
// se la curva trovata non è esterna alla superificie ( caso in cui il grezzo sia interno alla
// curva di svuotatura, allora non allargo la sua proiezione al suo box)
if ( ! bIsPartOut) {
nCont = 0 ;
continue ;
// controllo se il tratto di curva esterno alla superificie da svuotare
PtrOwner<ICurveComposite> pCrvToCheck( GetCurveComposite( pCrvExtSfr->CopyParamRange( dUS, dUE))) ;
if ( ! IsNull( pCrvToCheck) && pCrvToCheck->IsValid()) {
CRVCVECTOR ccClass_c ;
if ( pSrf->GetCurveClassification( *pCrvToCheck, EPS_SMALL, ccClass_c)) {
bool bIsPartOut = false ;
for ( int _c = 0 ; _c < ( int)ccClass_c.size() && ! bIsPartOut ; ++ _c) {
if ( ccClass_c[_c].nClass == CRVC_OUT)
bIsPartOut = true ;
}
// se la curva trovata non è esterna alla superificie ( caso in cui il grezzo sia interno alla
// curva di svuotatura, allora non allargo la sua proiezione al suo box)
if ( ! bIsPartOut) {
nCont = 0 ;
continue ;
}
}
}
}
// la spezzo alla prima intersezione con il grezzo
CRVCVECTOR ccClass ;
if ( pSrfOnPlPlus->GetCurveClassification( *pCrvLE, EPS_SMALL, ccClass) &&
( ccClass[0].nClass == CRVC_IN || ccClass[0].nClass == CRVC_ON_P || ccClass[0].nClass == CRVC_ON_M)) {
pCrvLE.Set( GetCurveLine( pCrvLE->CopyParamRange( 0, ccClass[0].dParE))) ;
pCrvLE->SetTempProp( ccClass[0].nClass == CRVC_IN ? 0 : 1) ;
}
else if (( int) ccClass.size() == 0) // retta finale degenere ad un punto
nStat = nStat == 1 ? 3 : 2 ;
else { // esco...
pSrf->ToGlob( frLoc) ;
pSrf->Translate( -vtTrasl) ;
return true ; // migliorare
}
// la spezzo alla prima intersezione con il grezzo
CRVCVECTOR ccClass ;
if ( pSrfOnPlPlus->GetCurveClassification( *pCrvLE, EPS_SMALL, ccClass) &&
( ccClass[0].nClass == CRVC_IN || ccClass[0].nClass == CRVC_ON_P || ccClass[0].nClass == CRVC_ON_M)) {
pCrvLE.Set( GetCurveLine( pCrvLE->CopyParamRange( 0, ccClass[0].dParE))) ;
pCrvLE->SetTempProp( ccClass[0].nClass == CRVC_IN ? 0 : 1) ;
}
else if (( int) ccClass.size() == 0) // retta finale degenere ad un punto
nStat = nStat == 1 ? 3 : 2 ;
else { // esco...
pSrf->ToGlob( frLoc) ;
pSrf->Translate( -vtTrasl) ;
return true ; // migliorare
}
// nel caso in cui la retta tocca la curva della svuotatura n volte...
IntersCurveCurve intCCOpt( *pCrvLE, *pCrvExtSfr) ;
if ( intCCOpt.GetCurveClassification( 0, EPS_SMALL, ccClass) && ( int)ccClass.size() > 1) {
// salto questa proiezione, proviene da isole aperte
pSrf->ToGlob( frLoc) ;
pSrf->Translate( -vtTrasl) ;
return true ;
}
// nel caso in cui la retta tocca la curva della svuotatura n volte...
IntersCurveCurve intCCOpt( *pCrvLE, *pCrvExtSfr) ;
if ( intCCOpt.GetCurveClassification( 0, EPS_SMALL, ccClass) && ( int)ccClass.size() > 1) {
// salto questa proiezione, proviene da isole aperte
pSrf->ToGlob( frLoc) ;
pSrf->Translate( -vtTrasl) ;
return true ;
}
int nCrv = pCrvExtSfr->GetCurveCount() ; // memorizzo il numero di curve attuali
PNTVECTOR vPtTan{ ptS, ptE} ;
if ( ! AjustCurveForProjRawOnFace( pCrvLS, pCrvLE, pCrvExtProj, pCrvExtSfr, nStat, vPtTan, pSrfOnPlPlus))
return false ;
c += pCrvExtSfr->GetCurveCount() - nCrv - 1 ; // aumento numero delle curve
nStat = 0 ; // ritorno al caso base per nStat
int nCrv = pCrvExtSfr->GetCurveCount() ; // memorizzo il numero di curve attuali
PNTVECTOR vPtTan{ ptS, ptE} ;
if ( ! AjustCurveForProjRawOnFace( pCrvLS, pCrvLE, pCrvExtProj, pCrvExtSfr, nStat, vPtTan, pSrfOnPlPlus))
return false ;
c += pCrvExtSfr->GetCurveCount() - nCrv - 1 ; // aumento numero delle curve
nStat = 0 ; // ritorno al caso base per nStat
}
nCont = 0 ;
pCrv->GetEndDir( vtS) ;
pCrv->GetEndPoint( ptS) ;
if ( bIsLastOpen)
bIsLastOpen = false ;
}
nCont = 0 ;
pCrv->GetEndDir( vtS) ;
pCrv->GetEndPoint( ptS) ;
if ( bIsLastOpen)
bIsLastOpen = false ;
}
}
// aggiungo la nuova curva esterna ricavata e le isole
pCrvExtSfr->SetExtrusion( vtExtr) ;
pCrvExtSfr->SetThickness( dthick) ;
pSrfAfterProj.AddCurve( Release( pCrvExtSfr)) ;
for ( int i = 0 ; i < ( int)vCrvIsl.size() ; ++ i) {
vCrvIsl[i]->SetExtrusion( vtExtr) ;
vCrvIsl[i]->SetThickness( dthick) ;
pSrfAfterProj.AddCurve( Release( vCrvIsl[i])) ;
// aggiungo la nuova curva esterna ricavata e le isole
pCrvExtSfr->SetExtrusion( vtExtr) ;
pCrvExtSfr->SetThickness( dthick) ;
pSrfAfterProj.AddCurve( Release( pCrvExtSfr)) ;
for ( int i = 0 ; i < ( int)vCrvIsl.size() ; ++ i) {
vCrvIsl[i]->SetExtrusion( vtExtr) ;
vCrvIsl[i]->SetThickness( dthick) ;
pSrfAfterProj.AddCurve( Release( vCrvIsl[i])) ;
}
}
}
// Superificie finale
PtrOwner<ISurfFlatRegion> pSrfF( CreateSurfFlatRegion()) ;
pSrfF.Set( pSrfAfterProj.GetSurf()) ;
// ritorno la nuova superificie
pSrf->Clear() ;
PtrOwner<ISurfFlatRegion> pSrfF( pSrfAfterProj.GetSurf()) ;
// se la superificie da svuotare viene da una Trimesh, taglio quest'ultima con la Trimesh Originale
if ( m_pGeomDB->GetGeoType( nId) == SRF_TRIMESH) {
ICRVCOMPOPOVECTOR vCrvAll ;
for ( int c = 0 ; c < ( int)pSrfF->GetChunkCount() ; ++ c)
vCrvAll.emplace_back( GetCurveComposite( pSrfF->GetLoop( c, 0))) ;
for ( int c = 0 ; c < ( int)pSrfF->GetChunkCount() ; ++ c)
for ( int l = 1 ; l < ( int)pSrfF->GetLoopCount( c) ; ++ l)
vCrvAll.emplace_back( GetCurveComposite( pSrfF->GetLoop( c, l))) ;
PtrOwner<ISurfTriMesh> pStm_orig( CloneSurfTriMesh( m_pGeomDB->GetGeoObj( nId))) ;
Frame3d frLoc1 ; m_pGeomDB->GetGlobFrame( nId, frLoc1) ;
pStm_orig->LocToLoc( frLoc1, frLoc) ;
PtrOwner<ISurfTriMesh> pSrfF_tm( CloneSurfTriMesh( pSrfF->GetAuxSurf())) ;
SurfFlatRegionByContours pSrf_HH ;
if ( pSrfF_tm->CutWithOtherSurf( *pStm_orig, false, true)) {
// estraggo tutti i loops
POLYLINEVECTOR vPl ;
pSrfF_tm->GetLoops( vPl) ;
for ( int ll = 0 ; ll < ( int)vPl.size() ; ++ ll) {
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
pCrvCompo->FromPolyLine( vPl[ll]) ;
for ( int u = 0 ; u < pCrvCompo->GetCurveCount() ; ++ u) {
for ( int j = 0 ; j < ( int)vCrvAll.size() ; ++ j) {
int nStat = -1 ;
pCrvCompo->SetCurveTempProp( u, 0, 0) ;
if ( SetTmpPropByOverlap( pCrvCompo, u, vCrvAll[j], nStat) && nStat == 1)
break ;
}
}
pSrf_HH.AddCurve( Release( pCrvCompo)) ;
}
pSrfF.Set( pSrf_HH.GetSurf()) ;
}
}
pSrf->CopyFrom( pSrfF) ;
pSrf->ToGlob( frLoc) ;
Pocketing.h
+1 -1
View File
@@ -98,7 +98,7 @@ class Pocketing : public Machining
bool IntersSurfWithRaw( ISurfFlatRegion* pSfr, const ISurfTriMesh* pStm, const Vector3d& vtTrasl,
bool& bIsChanged, double dAreaToll = 500 * EPS_SMALL, bool bInVsOut = true,
bool bRemoveSmallRawParts = false) ;
bool ProjectRaw( ISurfFlatRegion* pSrf, const Vector3d& vtTrals, const ISurfTriMesh* pSrfProjRaw) ;
bool ProjectRaw( ISurfFlatRegion* pSrf, const Vector3d& vtTrals, const ISurfTriMesh* pSrfProjRaw, int nId) ;
bool AdjustAngleForProjectedFace( const ISurfFlatRegion* pSrfFaceT, ICurveComposite* pCrvEdgeBorder, double dAngle) ;
bool SetOpenOrCloseEdge( ISurfFlatRegion* pSrfTP, const ISurfFlatRegion* pSrfO) ;
bool GetProjStmBoxOnSfr( const ISurfFlatRegion* pSfr, const ISurfTriMesh* pStmRaw, ISurfFlatRegion* pSfrRawBoxProj) ;