Egalware/EgtGeomKernel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
7c85ea2d43092ebb01a22e80f5de8ef026e431f6
EgtGeomKernel/SurfBezier.h
T
Daniele Bariletti e7d25b2d0e EgtGeomKernel : 
- correzioni e migliorie a regolarize dei bordi per trimming.
2026-04-21 15:04:24 +02:00

265 lines
17 KiB
C++
Raw Blame History

//----------------------------------------------------------------------------
// EgalTech 2020-2020
//----------------------------------------------------------------------------
// File : SurfBezier.h Data : 22.03.20 Versione : 2.2c3
// Contenuto : Dichiarazione della classe Superficie Bezier.
//
//
//
// Modifiche : 22.03.20 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------
#pragma once
#include "ObjGraphicsMgr.h"
#include "DllMain.h"
#include "GeoObjRW.h"
#include "CurveComposite.h"
#include "SurfTriMesh.h"
#include "SurfFlatRegion.h"
#include "/EgtDev/Include/EGkSurfBezier.h"
#include "/EgtDev/Include/EGkIntersLineTria.h"
#include "/EgtDev/Include/EGkGeoCollection.h"
//----------------------------------------------------------------------------
class SurfBezier : public ISurfBezier, public IGeoObjRW
{
public : // IGeoObj
~SurfBezier( void) override ;
SurfBezier* Clone( void) const override ;
GeoObjType GetType( void) const override ;
bool IsValid( void) const override
{ return ( m_nStatus == OK) ; }
const std::string& GetTitle( void) const override ;
bool Dump( std::string& sOut, bool bMM = true, const char* szNewLine = "\n") const override ;
bool GetLocalBBox( BBox3d& b3Loc, int nFlag = BBF_STANDARD) const override ;
bool GetBBox( const Frame3d& frRef, BBox3d& b3Ref, int nFlag = BBF_STANDARD) const override ;
bool Translate( const Vector3d& vtMove) override ;
bool Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dAngDeg) override
{ double dAngRad = dAngDeg * DEGTORAD ;
return Rotate( ptAx, vtAx, cos( dAngRad), sin( dAngRad)) ; }
bool Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAng, double dSinAng) override ;
bool Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, double dCoeffZ) override ;
bool Mirror( const Point3d& ptOn, const Vector3d& vtNorm) override ;
bool Shear( const Point3d& ptOn, const Vector3d& vtNorm, const Vector3d& vtDir, double dCoeff) override ;
bool ToGlob( const Frame3d& frRef) override ;
bool ToLoc( const Frame3d& frRef) override ;
bool LocToLoc( const Frame3d& frOri, const Frame3d& frDest) override ;
void SetObjGraphics( IObjGraphics* pOGr) override
{ m_OGrMgr.SetObjGraphics( pOGr) ; }
IObjGraphics* GetObjGraphics( void) override
{ return m_OGrMgr.GetObjGraphics() ; }
const IObjGraphics* GetObjGraphics( void) const override
{ return m_OGrMgr.GetObjGraphics() ; }
void SetTempProp( int nProp, int nPropInd) override
{ if ( nPropInd >= 0 && nPropInd < 2)
m_nTempProp[nPropInd] = nProp ; }
int GetTempProp( int nPropInd) const override
{ return (( nPropInd >= 0 && nPropInd < 2) ? m_nTempProp[nPropInd] : 0) ; }
void SetTempParam( double dParam, int nParamInd = 0) override
{ if ( nParamInd >= 0 && nParamInd < 2)
m_dTempParam[nParamInd] = dParam ; }
double GetTempParam( int nParamInd = 0) const override
{ return (( nParamInd >= 0 && nParamInd < 2) ? m_dTempParam[nParamInd] : 0.0) ; }
public : // ISurf
bool IsSimple( void) const override
{ return true ; }
bool IsClosed( void) const override ;
bool GetArea( double& dArea) const override ;
bool GetVolume( double& dVolume) const override
{ if ( &dVolume == nullptr)
return false ;
if ( m_pSTM == nullptr)
GetAuxSurf() ;
dVolume = 0 ;
if ( m_pSTM != nullptr)
m_pSTM->GetVolume( dVolume) ;
return true ; }
bool GetCentroid( Point3d& ptCen) const override ;
bool Invert( void) override ;
public : // ISurfBezier
bool CopyFrom( const IGeoObj* pGObjSrc) override ;
bool Init( int nDegU, int nDegV, int nSpanU, int nSpanV, bool bIsRational) override ;
bool SetControlPoint( int nIndU, int nIndV, const Point3d& ptCtrl) override
{ return SetControlPoint( GetInd( nIndU, nIndV), ptCtrl) ; }
bool SetControlPoint( int nInd, const Point3d& ptCtrl) override ;
bool SetControlPoint( int nIndU, int nIndV, const Point3d& ptCtrl, double dW) override
{ return SetControlPoint( GetInd( nIndU, nIndV), ptCtrl, dW) ; }
bool SetControlPoint( int nInd, const Point3d& ptCtrl, double dW) override ;
bool SetTrimRegion( ISurfFlatRegion& sfrTrimReg, bool bIntersectOrSubtract = true) override ;
SurfFlatRegion* GetTrimRegion( void) const override ;
bool GetInfo( int& nDegU, int& nDegV, int& nSpanU, int& nSpanV, bool& bIsRat, bool& bTrimmed) const override ;
const Point3d& GetControlPoint( int nIndU, int nIndV, bool* pbOk) const override
{ return GetControlPoint( GetInd( nIndU, nIndV), pbOk) ; }
const Point3d& GetControlPoint( int nInd, bool* pbOk) const override ;
double GetControlWeight( int nIndU, int nIndV, bool* pbOk) const override
{ return GetControlWeight( GetInd( nIndU, nIndV), pbOk) ; }
double GetControlWeight( int nInd, bool* pbOk) const override ;
bool IsAPoint( void) const override ;
bool GetPoint( double dU, double dV, Side nUs, Side nVs, Point3d& ptPos) const override ;
bool GetPointD1D2( double dU, double dV, Side nUs, Side nVs,
Point3d& ptPos,
Vector3d* pvtDerU = nullptr, Vector3d* pvtDerV = nullptr,
Vector3d* pvtDerUU = nullptr, Vector3d* pvtDerVV = nullptr, Vector3d* pvtDerUV = nullptr) const override ;
bool GetPointNrmD1D2( double dU, double dV, Side nUs, Side nVs,
Point3d& ptPos, Vector3d& vtN,
Vector3d* pvtDerU = nullptr, Vector3d* pvtDerV = nullptr,
Vector3d* pvtDerUU = nullptr, Vector3d* pvtDerVV = nullptr, Vector3d* pvtDerUV = nullptr) const override ;
CurveComposite* GetCurveOnU( double dV) const override ;
CurveComposite* GetCurveOnV( double dU) const override ;
CurveComposite* GetLoop( int nLoop) const override ; // nLoop 0-based (1°esterno, successivi interni)
bool GetControlCurveOnU( int nIndV, PolyLine& plCtrlU) const override ;
bool GetControlCurveOnV( int nIndU, PolyLine& plCtrlV) const override ;
const SurfTriMesh* GetAuxSurf( void) const override ;
const SurfTriMesh* GetAuxSurfRefined( void) const override ;
SurfTriMesh* GetApproxSurf( double dTol, double dSideMin = 10 * EPS_SMALL, bool bUpdateEdges = false) const override ;
// funzione per ottenere la suddivisione dello spazio parametrico nelle celle utilizzate per la triangolazione.
bool GetLeaves( std::vector<std::tuple<int, Point3d, Point3d>>& vLeaves, bool bRefined = false) const override ;
bool GetTriangles2D( std::vector<std::tuple<int,Point3d, Point3d, Point3d>>& vTria2D) const override ;
// funzioni che servono per ricavare l'immagine nel parametrico di un punto appartenente alla trimesh ausiliaria della superficie di Bezier
bool UnprojectPointFromStm( int nT, const Point3d& ptI, Point3d& ptSP, int nIL = IntLineTriaType::ILTT_IN) const override ;
bool UnprojectPointFromStm( int nT, const Point3d& ptI, Point3d& ptSP, int nIL, const Point3d& ptIPrev, bool* bTroughEdge = nullptr) const override ;
// restituisce il corrispettivo parametrico di un punto qualunque della trimesh associata alla superficie
// ptIPrev è un punto addizionale che precede o segue il punto pt3D nel caso in cui il punto faccia parte di una curva 3d sulla superficie
// pPlCut è il piano di taglio su cui dovrebbe giacere il punto raffinato
bool UnprojectPoint( const Point3d& pt3D, Point3d& ptParam, const Point3d& ptIPrev = P_INVALID, bool* bTroughEdge = nullptr, const Plane3d* plCut = nullptr) const override ;
// pPlCut è il piano di taglio su cui giace la curva
bool UnprojectCurveFromStm( const ICurveComposite* pCC, ICRVCOMPOPVECTOR& vpCC, const Plane3d* pPlCut) const override ;
// funzione per tagliare una superficie di bezier con un piano ( cancello la parte dal lato positivo della normale del piano).
// bSaveOnEq indica se tenere i triangoli (della trimesh associata) che sono sul piano
bool Cut( const Plane3d& plPlane, bool bSaveOnEq = false) override ;
// funzioni per incrementare le coordinate restando dentro lo spazio parametrico
bool IncreaseUV( double& dU, double dx, bool bUOrV, double* dUVCopy = nullptr, bool bModifyOrig = true) const override ;
bool IncreaseUV( Point3d& ptUV, Vector3d vtH , Point3d* ptUVCopy, bool bModifyOrig) const override ;
// funzione che restituisce gli edge della superficie o in forma di linea spezzata o in forma di curva di Bezier
// restituisce un vettore con i loop della superficie ( più di uno solo se è trimmata con un parametrico con buchi o più di un chunk)
bool GetLoops( ICRVCOMPOPOVECTOR& vCC, bool bLineOrBezier) const override ;
// restituisce il singolo edge della superficie non trimmata
ICurveComposite* GetSingleEdge3D( bool bLineOrBezier, int nEdge) 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) override ;
bool CreateByScrewing( const ICurve* pCurve, const Point3d& ptAx, const Vector3d& vtAx, double dAngRotDeg, double dMove) override ;
bool CreateByPointCurve( const Point3d& pt, const ICurve* pCurve) override ;
bool CreateByTwoCurves( const ICurve* pCurve1, const ICurve* pCurve2, int nType) override ;
bool CreateBySetOfCurves( const ICURVEPOVECTOR& vCrvBez, bool bReduceToDeg3) override ;
PNTVECTOR GetAllControlPoints( void) const override ;
bool GetAllPatchesIsocurves( bool bUorV, ICURVEPOVECTOR& vCrv) const ;
bool CreateByIsoParamSet( const ICurve* pCurve0, const ICurve* pCurve1, const BIPNTVECTOR& vCrv) ;
bool RemoveCollapsedSpans( void) override ;
bool SwapParameters( void) ;
bool LimitSurfToTrimmedRegion( void) override ;
bool CreateSmoothRuledByTwoCurves( const ICurve* pCurve0, const ICurve* pCurve1, double dSampleLen) override ;
bool CreateSmoothRuledByTwoCurves( const ICurve* pCurve0, const ICurve* pCurve1, double dSampleLen, BIPNTVECTOR& vSyncLines) override ;
public : // IGeoObjRW
int GetNgeId( void) const override ;
bool Save( NgeWriter& ngeOut) const override ;
bool PreSave( GdbGeo& Wrapper) const override { return true ; }
bool PostSave( GdbGeo& Wrapper) const override { return true ; }
bool Load( NgeReader& ngeIn) override ;
bool PostLoad( GdbGeo& Wrapper) override { return true ; }
public :
SurfBezier( void) ;
SurfBezier( const SurfBezier& sbSrc) : m_pSTM( nullptr), m_pSTMRefined( nullptr), m_pTrimReg(nullptr)
{ if ( ! CopyFrom( sbSrc))
LOG_ERROR( GetEGkLogger(), "SurfBezier : copy constructor error") }
SurfBezier& operator =( const SurfBezier& sbSrc)
{ if ( ! CopyFrom( sbSrc))
LOG_ERROR( GetEGkLogger(), "SurfBezier : copy error")
return *this ; }
private :
enum Status { ERR = 0, OK = 1, TO_VERIFY = 2} ;
enum ParDir { ON_U = 1, ON_V = 2} ;
static const int MAXDEG = 21 ;
private :
bool CopyFrom( const SurfBezier& sbSrc) ;
bool Validate( void) ;
int GetInd( int nIndU, int nIndV) const
{ return ( nIndV * ( m_nDegU * m_nSpanU + 1) + nIndU) ; }
int GetIndU( int nInd) const
{ return ( nInd % ( m_nDegU * m_nSpanU + 1)) ; }
int GetIndV( int nInd) const
{ return ( nInd / ( m_nDegU * m_nSpanU + 1)) ; }
int GetDim( void) const
{ return ( m_nDegU * m_nSpanU + 1) * ( m_nDegV * m_nSpanV + 1) ; }
int GetLocInd( int nIndU, int nIndV) const
{ return ( nIndV * ( m_nDegU + 1) + nIndU) ; }
int GetLocIndU( int nInd) const
{ return ( nInd % ( m_nDegU + 1)) ; }
int GetLocIndV( int nInd) const
{ return ( nInd / ( m_nDegU + 1)) ; }
int GetLocDim( void) const
{ return ( m_nDegU + 1) * ( m_nDegV + 1) ; }
void ResetAuxSurf( void) const ;
void ResetTrimRegion( void) ;
int GetSteps( int nDeg, int nSpan, double dLen, int nQuality) const ;
bool GetCurveOnU( double dV, int nStep, PolyLine& plCrvU) const ;
bool GetCurveOnV( double dU, int nStep, PolyLine& plCrvV) const ;
double GetCurveOnUApproxLen( double dV) const ;
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 ;
// funzione che calcola se gli edge sono collassati in poli
bool CalcPoles( void) const ;
bool FindMatchByParam( const PolyLine& pl0, const PolyLine& pl1, INTVECTOR& vMatch, int& nLong) const ;
bool ReorderPntVector( const POLYLINEVECTOR& vPL, bool bTriangulatedIn3D, const PNTVECTOR& vPnt, const POLYLINEVECTOR& vPLToOrd, PNTVECTOR& vPntOrd) const ;
bool ReorderPntEnhancedVector( const POLYLINEVECTOR& vPL, bool bTriangulatedIn3D, const PNTVECTOR& vPnt, const POLYLINEVECTOR& vPLToOrd, PNTVECTOR& vPntOrd) const ;
bool GetBernstein( double dU, int nDegU, DBLVECTOR& vBernU) const ;
private :
ObjGraphicsMgr m_OGrMgr ; // gestore grafica dell'oggetto
mutable SurfTriMesh* m_pSTM ; // superficie trimesh ausiliaria per la visualizzazione
mutable SurfTriMesh* m_pSTMRefined ; // superficie trimesh ausiliaria raffinata per i calcoli
Status m_nStatus ; // stato
int m_nDegU ; // grado in U
int m_nDegV ; // grado in V
int m_nSpanU ; // numero di pezze in U
int m_nSpanV ; // numero di pezze in V
bool m_bRat ; // flag di razionale/polinomiale
bool m_bTrimmed ; // flag per presenza regione di trim
mutable bool m_bClosedU ; // flag che indica se la superficie è chiusa lungo il parametro U ( gli edge a V=0 e V=1 coincidono)
mutable bool m_bClosedV ; // flag che indica se la superficie è chiusa lungo il parametro V ( gli edge a U=0 e U=1 coincidono)
mutable BOOLVECTOR m_vbPole ; // vettore di flag che indicano se i lati sono collassati in dei poli
PNTVECTOR m_vPtCtrl ; // vettore dei punti di controllo
DBLVECTOR m_vWeCtrl ; // vettore dei pesi di controllo
SurfFlatRegion* m_pTrimReg ; // eventuale regione di trim
int m_nTempProp[2] ; // vettore proprietà temporanee
double m_dTempParam[2] ; // vettore parametri temporanei
mutable std::vector<ICRVCOMPOPOVECTOR> m_mCCEdge ; // vettore dei vettori che contengono le curve compo degli edge della superficie nello spazio 3D
mutable ICRVCOMPOPOVECTOR m_vCCLoop ; // vettore dei loop della superficie trimmata
mutable int m_nIsPlanar ; // enum che indica se la superficie è piana ( -1, non è stato calcolato)
mutable DBLVECTOR m_vBernU ;
mutable PNTVECTOR m_ptTemp ;
mutable DBLVECTOR m_vBernV ;
mutable PNTVECTOR m_ptTempW ;
mutable DBLVECTOR m_dTempW ;
mutable PNTVECTOR m_vPtWCtrlLoc ;
mutable DBLVECTOR m_vWeCtrlLoc ;
} ;
//-----------------------------------------------------------------------------
inline SurfBezier* CreateBasicSurfBezier( void)
{ return ( static_cast<SurfBezier*>( CreateGeoObj( SRF_BEZIER))) ; }
inline SurfBezier* CloneBasicSurfBezier( const IGeoObj* pGObj)
{ if ( pGObj == nullptr || pGObj->GetType() != SRF_BEZIER)
return nullptr ;
return ( static_cast<SurfBezier*>( pGObj->Clone())) ; }
inline const SurfBezier* GetBasicSurfBezier( const IGeoObj* pGObj)
{ if ( pGObj == nullptr || pGObj->GetType() != SRF_BEZIER)
return nullptr ;
return ( static_cast<const SurfBezier*>( pGObj)) ; }
inline SurfBezier* GetBasicSurfBezier( IGeoObj* pGObj)
{ if ( pGObj == nullptr || pGObj->GetType() != SRF_BEZIER)
return nullptr ;
return ( static_cast<SurfBezier*>( pGObj)) ; }
Reference in New Issue View Git Blame Copy Permalink