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

EgtGeomKernel :

Browse Source 
- aggiunte le funzioni per creare SurfBez da estrusione e da FlatContour.
This commit is contained in:
Daniele Bariletti
2024-05-09 15:13:25 +02:00
parent d6567e94c4
commit 5f56152a8b
5 changed files with 1374 additions and 75 deletions
Download Patch File Download Diff File Expand all files Collapse all files
EgtGeomKernel.vcxproj
+1
View File
@@ -323,6 +323,7 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
<ClCompile Include="Quaternion.cpp" />
<ClCompile Include="RotationMinimizingFrame.cpp" />
<ClCompile Include="RotationXplaneFrame.cpp" />
<ClCompile Include="SbzFromCurves.cpp" />
<ClCompile Include="SbzStandard.cpp" />
<ClCompile Include="Voronoi.cpp" />
<ClInclude Include="..\Include\EGkCDeClosedSurfTmClosedSurfTm.h" />
EgtGeomKernel.vcxproj.filters
+3
View File
@@ -540,6 +540,9 @@
<ClCompile Include="ProjectCurveSurfBez.cpp">
<Filter>File di origine\GeoProject</Filter>
</ClCompile>
<ClCompile Include="SbzFromCurves.cpp">
<Filter>File di origine\GeoCreate</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="stdafx.h">
SbzFromCurves.cpp
+1145
View File
File diff suppressed because it is too large Load Diff
SurfBezier.cpp
+221 -75
View File
@@ -1784,8 +1784,8 @@ SurfBezier::UnprojectCurveFromStm( const ICurveComposite* pCC, ICRVCOMPOPVECTOR&
Vector3d vtDir = pt2D - pt2DPrev ;
vtDir.Normalize() ;
// se mi accorgo che sto per tracciare un taglio lungo un bordo posso semplicmente evitarlo
if ( (1 - abs(vtDir.x) < EPS_SMALL && (pt2D.y < EPS_SMALL || m_nSpanV * SBZ_TREG_COEFF - pt2D.y < 1)) || // parallelo agli edge 0 e 2 e su uno di questi
(1 - abs(vtDir.y) < EPS_SMALL && (pt2D.x < EPS_SMALL || m_nSpanU * SBZ_TREG_COEFF - pt2D.x < 1))) { // parallello agli edge 1 e 3 e su uno di questi
if ( (1 - abs(vtDir.x) < SQ_EPS_SMALL && (pt2D.y < 1 || m_nSpanV * SBZ_TREG_COEFF - pt2D.y < 1)) || // parallelo agli edge 0 e 2 e su uno di questi
(1 - abs(vtDir.y) < SQ_EPS_SMALL && (pt2D.x < 1 || m_nSpanU * SBZ_TREG_COEFF - pt2D.x < 1))) { // parallello agli edge 1 e 3 e su uno di questi
++ nRejected ;
continue ;
}
@@ -1794,6 +1794,7 @@ SurfBezier::UnprojectCurveFromStm( const ICurveComposite* pCC, ICRVCOMPOPVECTOR&
dParamH = m_nSpanV * SBZ_TREG_COEFF ;
dParamL = m_nSpanU * SBZ_TREG_COEFF ;
// sia questo punto che il precedente sono su un edge, ma il segmento che li unisce non è parallelo ad un edge
// ( i punti per periodicità hanno coordinate diverse anche se dovrebbero averle uguali, quindi il segmento attraversa tutto lo spazio parametrico, anche se in realtà è lungo il bordo di chiusura)
// potrei star tracciando un taglio sul bordo di chiusura
// controllo se sto tracciando una linea che unisce due lati di chiusura, allora in realtà sdtarei tracciando un taglio sull'edge e quindi posso non tracciarlo
if ( (abs( vtDir.x) > abs( vtDir.y) && Dist( pt2D, pt2DPrev) > dParamL * 0.5) ||
@@ -1882,76 +1883,13 @@ struct hash<TRINT> {
};
//----------------------------------------------------------------------------
bool
SurfBezier::Cut( const Plane3d& plPlane, bool bSaveOnEq)
ISurfFlatRegion*
SurfBezier::CreateTrimRegionFromCuts( ICRVCOMPOPOVECTOR& vpCCOpen, ICRVCOMPOPOVECTOR& vpCCClosed) const
{
// faccio l'intersezione della trimesh ausiliaria con il piano posso ottenere: punti, curve 3d e triangoli( coplanari al piano di taglio)
// i punti li escludo
// le curve 3d le trasformo in curve 2d e le aggiungo alle curve di trim
// accorpo eventuali triangoli adiacenti ed estraggo i loop delle regioni ottenute; questi vengono poi portati in 2d e aggiunti alle curve di trim
// se necessario calcolo i poli
if ( m_vbPole.empty())
CalcPoles() ;
PNTVECTOR vPnt ;
BIPNTVECTOR vBPnt ;
TRIA3DVECTOR vTria ;
IntersPlaneSurfTm( plPlane, *GetAuxSurf(), vPnt, vBPnt, vTria) ;
// concateno le curve 3d
ChainCurves chainC ;
double dToler = EPS_SMALL ;
chainC.Init( false, dToler, int( vBPnt.size())) ;
for ( int i = 0 ; i < int( vBPnt.size()) ; ++ i) {
Vector3d vtDir = vBPnt[i].second - vBPnt[i].first ;
vtDir.Normalize() ;
if ( ! chainC.AddCurve( i + 1, vBPnt[i].first, vtDir, vBPnt[i].second, vtDir))
return false ;
}
// GESTIONE DELLE CURVE OTTENUTE DALL'INTERSEZIONE
// recupero i percorsi concatenati
Point3d ptNear = ( vBPnt.empty() ? ORIG : vBPnt[0].first) ;
INTVECTOR vId ;
// separo tra loop chiusi, interni allo spazio parametrico e loop passanti che tagliano lo spazio intersecando i bordi
ICRVCOMPOPOVECTOR vpCCOpen ;
ICRVCOMPOPOVECTOR vpCCClosed ;
while ( chainC.GetChainFromNear( ptNear, false, vId)) {
// creo una curva composita
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
if ( IsNull( pCrvCompo))
return false ;
// recupero gli estremi dei segmenti, creo le linee e le inserisco nella composita
bool bAdded = true ;
for ( int i = 0 ; i < int( vId.size()) ; ++ i) {
// creo un segmento di retta
ICurveLine* pLine( CreateCurveLine()) ;
if ( pLine == nullptr)
return false ;
// recupero gli estremi (non vanno mai invertiti per opzione di concatenamento)
int nInd = abs( vId[i]) - 1 ;
Point3d ptStart = ( bAdded ? vBPnt[nInd].first : ptNear) ;
Point3d ptEnd = vBPnt[nInd].second ;
// provo ad accodarlo alla composita
bAdded = ( Dist( ptStart, ptEnd) > dToler / 2 &&
pLine->Set( ptStart, ptEnd)) ;
bAdded = bAdded && pCrvCompo->AddCurve( pLine, true, dToler) ;
ptNear = ( bAdded ? ptEnd : ptStart) ;
}
if ( ! AddCurveCompoToCuts( pCrvCompo, vpCCOpen, vpCCClosed, EPS_SMALL, &plPlane))
return false ;
}
//comincio a creare la superficie aggiungendo i tagli aperti ai bordi attualmente esistenti
SurfFlatRegionByContours sfrContour ;
if ( int(vpCCOpen.size()) != 0 ) {
// qui devo aggiungere tutto del codice nuovo per ricostruire in altro modo il nuovo bordo della superficie
// recupero la regione attuale
PtrOwner<ISurfFlatRegion> pNewTrim( CreateBasicSurfFlatRegion()) ;
if ( m_bTrimmed)
pNewTrim.Set( GetTrimRegion()->Clone()) ;
@@ -2114,7 +2052,7 @@ SurfBezier::Cut( const Plane3d& plPlane, bool bSaveOnEq)
}
}
}
// devo trovare fino a che punto seguire il loop che ho trovato come prosecuzione del taglio corrente
// devo quindi trovare la prossima intersezione con un taglio
int nInters = -1 ;
@@ -2180,6 +2118,78 @@ SurfBezier::Cut( const Plane3d& plPlane, bool bSaveOnEq)
}
}
// aggiungo i loop chiusi
for ( int i = 0 ; i < int( vpCCClosed.size()); ++i )
sfrContour.AddCurve( Release( vpCCClosed[i])) ;
PtrOwner<ISurfFlatRegion> pSfrTrimReg( sfrContour.GetSurf()) ;
return Release( pSfrTrimReg) ;
}
//----------------------------------------------------------------------------
bool
SurfBezier::Cut( const Plane3d& plPlane, bool bSaveOnEq)
{
// faccio l'intersezione della trimesh ausiliaria con il piano posso ottenere: punti, curve 3d e triangoli( coplanari al piano di taglio)
// i punti li escludo
// le curve 3d le trasformo in curve 2d e le aggiungo alle curve di trim
// accorpo eventuali triangoli adiacenti ed estraggo i loop delle regioni ottenute; questi vengono poi portati in 2d e aggiunti alle curve di trim
// se necessario calcolo i poli
if ( m_vbPole.empty())
CalcPoles() ;
PNTVECTOR vPnt ;
BIPNTVECTOR vBPnt ;
TRIA3DVECTOR vTria ;
IntersPlaneSurfTm( plPlane, *GetAuxSurf(), vPnt, vBPnt, vTria) ;
// concateno le curve 3d
ChainCurves chainC ;
double dToler = EPS_SMALL ;
chainC.Init( false, dToler, int( vBPnt.size())) ;
for ( int i = 0 ; i < int( vBPnt.size()) ; ++ i) {
Vector3d vtDir = vBPnt[i].second - vBPnt[i].first ;
vtDir.Normalize() ;
if ( ! chainC.AddCurve( i + 1, vBPnt[i].first, vtDir, vBPnt[i].second, vtDir))
return false ;
}
// GESTIONE DELLE CURVE OTTENUTE DALL'INTERSEZIONE
// recupero i percorsi concatenati
Point3d ptNear = ( vBPnt.empty() ? ORIG : vBPnt[0].first) ;
INTVECTOR vId ;
// separo tra loop chiusi, interni allo spazio parametrico e loop passanti che tagliano lo spazio intersecando i bordi
ICRVCOMPOPOVECTOR vpCCOpen ;
ICRVCOMPOPOVECTOR vpCCClosed ;
while ( chainC.GetChainFromNear( ptNear, false, vId)) {
// creo una curva composita
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
if ( IsNull( pCrvCompo))
return false ;
// recupero gli estremi dei segmenti, creo le linee e le inserisco nella composita
bool bAdded = true ;
for ( int i = 0 ; i < int( vId.size()) ; ++ i) {
// creo un segmento di retta
ICurveLine* pLine( CreateCurveLine()) ;
if ( pLine == nullptr)
return false ;
// recupero gli estremi (non vanno mai invertiti per opzione di concatenamento)
int nInd = abs( vId[i]) - 1 ;
Point3d ptStart = ( bAdded ? vBPnt[nInd].first : ptNear) ;
Point3d ptEnd = vBPnt[nInd].second ;
// provo ad accodarlo alla composita
bAdded = ( Dist( ptStart, ptEnd) > dToler / 2 &&
pLine->Set( ptStart, ptEnd)) ;
bAdded = bAdded && pCrvCompo->AddCurve( pLine, true, dToler) ;
ptNear = ( bAdded ? ptEnd : ptStart) ;
}
if ( ! AddCurveCompoToCuts( pCrvCompo, vpCCOpen, vpCCClosed, EPS_SMALL, &plPlane))
return false ;
}
//GESTIONE DEI TRIANGOLI RISULTANTI DALL'INTERSEZIONE
StmFromTriangleSoup StmFts ;
if ( ! StmFts.Start())
@@ -2197,16 +2207,15 @@ SurfBezier::Cut( const Plane3d& plPlane, bool bSaveOnEq)
pNewStm->GetLoops( vPLTria) ;
}
// aggiungo i loop chiusi
for ( int i = 0 ; i < int( vpCCClosed.size()); ++i )
sfrContour.AddCurve( Release( vpCCClosed[i])) ;
// aggiungo loop derivati dai triangoli
for ( int i = 0 ; i < int( vPLTria.size()); ++i ) {
PtrOwner<ICurveComposite> pCC( CreateCurveComposite()) ;
pCC->FromPolyLine( vPLTria[i]) ;
sfrContour.AddCurve( Release( pCC)) ;
vpCCClosed.emplace_back() ;
vpCCClosed.back()->FromPolyLine( vPLTria[i]) ;
}
PtrOwner<ISurfFlatRegion> pSFR( sfrContour.GetSurf()) ;
// ora posso chiamare la costruzione dello spazio parametrico trimmato
PtrOwner<ISurfFlatRegion> pSFR( CreateTrimRegionFromCuts( vpCCOpen, vpCCClosed)) ;
if ( IsNull( pSFR) || ! pSFR->IsValid())
return false ;
@@ -2723,6 +2732,8 @@ SurfBezier::UnprojectPoint( const Point3d& pt3D, Point3d& ptParam, const Point3d
bool
SurfBezier::CalcPoles( void)
{
if ( m_vbPole.size() != 0)
return true ;
// la funzione identifica se degli edge della superficie non trimmata sono in realtà dei poli
for ( int i = 0 ; i < 4 ; ++i)
m_vbPole.emplace_back( true) ;
@@ -3247,3 +3258,138 @@ SurfBezier::IsPlanar( void) const
// nel dubbio restituisco false
return false ;
}
//----------------------------------------------------------------------------
bool
SurfBezier::CreateByFlatContour( const PolyLine& PL)
{
Plane3d plPlane ;
double dArea = 0 ;
if ( ! PL.IsClosedAndFlat( plPlane, dArea, EPS_SMALL))
return false ;
// creo una superficie piana grande come il box della curva nel suo piano e poi la trimmo
Frame3d frPlane ;
Point3d ptStart ; PL.GetFirstPoint( ptStart) ;
frPlane.Set( ptStart, plPlane.GetVersN()) ;
// recupero il box
BBox3d bboxContour ;
PL.GetLocalBBox( bboxContour) ;
// inizializzo la superficie come una bezier di primo grado formata da una sola patch
int nDegU = 1, nDegV = 1, nSpanU = 1, nSpanV = 1 ;
bool bRat = false ;
Init( nDegU, nDegV, nSpanU, nSpanV, bRat) ;
// i punti di controllo sono i quattro vertici della bbox ( che è piana)
Point3d ptBL = bboxContour.GetMin() ;
Point3d ptTR = bboxContour.GetMax() ;
SetControlPoint( 0, ptBL) ;
SetControlPoint( 1, Point3d( ptTR.x, ptBL.y)) ;
SetControlPoint( 2, Point3d( ptBL.x, ptTR.y)) ;
SetControlPoint( 3, ptTR) ;
// calcolo il corrispondente parametrico del contorno
PtrOwner<ICurveComposite> pCCContour( CreateCurveComposite()) ;
if ( IsNull( pCCContour))
return false ;
pCCContour->FromPolyLine( PL) ;
// calcolo gli eventuali poli, necessari per poter chiamare le funzioni di unproject
CalcPoles() ;
ICRVCOMPOPOVECTOR vCCOpen ;
ICRVCOMPOPOVECTOR vCCClosed ;
AddCurveCompoToCuts( pCCContour, vCCOpen, vCCClosed) ;
// creo la regione di trim dai loop di trim
PtrOwner<ISurfFlatRegion> pSfrTrim( CreateTrimRegionFromCuts( vCCOpen, vCCClosed)) ;
if ( IsNull( pSfrTrim) || ! pSfrTrim->IsValid())
return false ;
SetTrimRegion( *pSfrTrim) ;
if ( plPlane.GetVersN().z < EPS_SMALL)
Invert() ;
return true ;
}
//----------------------------------------------------------------------------
bool
SurfBezier::CreateByRegion( const POLYLINEVECTOR& vPL)
{
return false ;
}
//----------------------------------------------------------------------------
bool
SurfBezier::CreateByExtrusion( const ICurve* pCrv, const Vector3d& vtExtr, bool bDeg3orDeg2)
{
if ( pCrv == nullptr)
return false ;
// verifico che la curva passata sia una bezier semplice o una composita di bezier
if ( pCrv->GetType() != CRV_COMPO && pCrv->GetType() != CRV_BEZIER)
return false ;
// se composita verifico che curve siano con lo stesso grado e uniformi come tipo
PtrOwner<ICurveComposite> pCC( CreateCurveComposite()) ;
pCC->AddCurve( pCrv->Clone()) ;
bool bRat = false ;
int nDegU = 1 ;
for ( int i = 0 ; i < pCC->GetCurveCount() ; ++i) {
if ( pCC->GetCurve( i)->GetType() != CRV_BEZIER)
return false ;
const ICurveBezier* pCrvBez = static_cast<const ICurveBezier*>( pCC->GetCurve( i)) ;
if ( i == 0 ) {
bRat = pCrvBez->IsRational() ;
nDegU = pCrvBez->GetDegree() ;
}
else {
if ( pCrvBez->GetDegree() != nDegU || pCrvBez->IsRational() != bRat)
return false ;
}
}
// riempio la matrice dei punti di controllo
// parto dalla curva che sto estrudendo e mi alzo progressivamente seguendo il vettore vtExtr
int nDegV = bDeg3orDeg2 ? 3 : 2 ;
int nSpanU = pCC->GetCurveCount() ;
int nSpanV = 1 ;
Init(nDegU, nDegV, nSpanU, nSpanV, bRat) ;
for ( int k = 0 ; k < nSpanU ; ++k) {
const ICurveBezier* pCrvBezier = static_cast<const ICurveBezier*>( pCC->GetCurve( k)) ;
for ( int i = 0 ; i < nDegU + 1 ; ++i) {
if ( k != 0 && i == 0)
continue ;
Point3d ptCtrl = pCrvBezier->GetControlPoint( i) ;
int nInd = k * nDegU + i ;
if ( bRat) {
double dW = pCrvBezier->GetControlWeight( i) ;
SetControlPoint( nInd, ptCtrl, dW) ;
}
else
SetControlPoint( nInd, ptCtrl) ;
}
}
Vector3d vtStep = vtExtr / nDegV ;
// calcolo il vettore di progressione del singolo step per passare dalla curva di partenza alla curva finale
for ( int j = 1 ; j < nDegV + 1 ; ++j) {
for ( int k = 0 ; k < nSpanU ; ++k) {
for ( int i = 0 ; i < nDegU + 1 ; ++i) {
int nIndPrev = ( j - 1) * ( nDegU * nSpanU + 1) + ( k * nDegU + i) ;
Point3d ptCtrl = GetControlPoint( nIndPrev, nullptr) ;
ptCtrl += vtStep ;
int nInd = j * ( nDegU * nSpanU + 1) + k * nDegU + i ;
if ( bRat) {
double dW = GetControlWeight( i, nullptr) ;
SetControlPoint( nInd, ptCtrl, dW) ;
}
else
SetControlPoint( nInd, ptCtrl) ;
}
}
}
// aggiorno lo stato
m_nStatus = OK ;
return true ;
}
SurfBezier.h
+4
View File
@@ -137,6 +137,9 @@ class SurfBezier : public ISurfBezier, public IGeoObjRW
// se la superficie è trimmata restituisce i loop dello spazio parametrico in forma di linee spezzate
bool GetLoops( ICRVCOMPOPOVECTOR& vCC, bool bLineOrBezier, int nEdge = -1) const override ;
bool IsPlanar( void) const override ;
bool CreateByFlatContour( const PolyLine& PL) override ;
bool CreateByRegion( const POLYLINEVECTOR& vPL) override ;
bool CreateByExtrusion( const ICurve* pCurve, const Vector3d& vtExtr, bool bDeg3OrDeg2 = false) override ;
public : // IGeoObjRW
int GetNgeId( void) const override ;
@@ -189,6 +192,7 @@ class SurfBezier : public ISurfBezier, public IGeoObjRW
double GetCurveOnVApproxLen( double dU) const ;
// funzione che proietta nello spazio parametrico un trim derivante da un taglio con un piano, categorizzandolo come aperto o chiuso ( nel parametrico)
bool AddCurveCompoToCuts( ICurveComposite* pCrvCompo, ICRVCOMPOPOVECTOR& vpCCOpen, ICRVCOMPOPOVECTOR& vpCCClosed, double dToler = EPS_SMALL, const Plane3d* pPlCut = nullptr) const ;
ISurfFlatRegion* CreateTrimRegionFromCuts( ICRVCOMPOPOVECTOR& vpCCOpen, ICRVCOMPOPOVECTOR& vpCCClosed) const ;
// restituisce il singolo edge della superficie non trimmata
ICurveComposite* GetSingleEdge3D( bool bLineOrBezier, int nEdge) const ;
bool UpdateEdgesFromTree( Tree& tr) const ;