EgtGeomKernel/SurfBezier.h

//----------------------------------------------------------------------------
//  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/EGkGeoCollection.h"

using namespace std ;
class Tree ;

//----------------------------------------------------------------------------
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
               { return false ; }
      bool GetArea( double& dArea) const override ;
      bool GetVolume( double& dVolume) const override
               { if ( &dVolume == nullptr)
                    return false ;
                 dVolume = 0 ;
                 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 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 ;
      SurfTriMesh* GetApproxSurf( double dTol, double dSideMin = 100 * EPS_SMALL) 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) 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
      // a nIL si può passare 5 come valore di default
      bool UnprojectPointFromStm( int nT, const Point3d& ptI, Point3d& ptSP, int nIL = 5) 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, 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
      // 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 ;

   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)
                  { 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 ;
      // restituisce il singolo edge della superficie non trimmata
      ICurveComposite* GetSingleEdge3D( bool bLineOrBezier, int nEdge) const ;
      bool UpdateEdgesFromTree( Tree& tr) const ;
      // funzione che calcola se gli edge sono collassati in poli
      bool CalcPoles( void) ;

   private :
      ObjGraphicsMgr  m_OGrMgr ;        // gestore grafica dell'oggetto
      mutable SurfTriMesh* m_pSTM ;     // superficie trimesh ausiliaria
      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
      mutable bool    m_bClosedV ;      // flag che indica se la superficie è chiusa lungo il parametro V
      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 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
} ;

//-----------------------------------------------------------------------------
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)) ; }