RSBRep.h

/********************************************************************/
/* Copyright (c) 2015 DG Technologies Inc. and Yuzi Mizuno          */
/* All rights reserved.                                             */
/********************************************************************/
#ifndef _MGRSBRep_HH_
#define _MGRSBRep_HH_

#include "mg/Position.h"
#include "mg/SBRep.h"

// MGRSBRep.h
//

// Forward Declaration
class  MGSPointSeq;
class  MGKnotArray;
class  MGMatrix;
class  MGTransf;
class  MGStraight;
class  MGRLBRep;
class  MGPlane;
class  MGCSisect_list;
class  MGSSisect_list;
class  MGIfstream;
class  MGOfstream;

class MG_DLL_DECLR MGRSBRep: public MGSurface {

public:

MG_DLL_DECLR friend MGRSBRep operator* (double scale, const MGRSBRep& sb);


MGRSBRep():MGSurface(){;};

MGRSBRep(
    const MGSPointSeq& bcoef,   
    const MGKnotVector& tu,     
    const MGKnotVector& tv,     
    int homogeneous=1   
);

MGRSBRep(
    const MGSPointSeq& bcoef,   
    const MGSPointSeq& weights, 
    const MGKnotVector& tu,     
    const MGKnotVector& tv      
);

MGRSBRep(
    const MGRLBRep& rlb,    
    const MGStraight& sl,   
    double angle            
);

MGRSBRep(
    const MGRLBRep& rlbrep,     
    const MGUnit_vector& uvec,  
    double start_dist,          
    double end_dist         
);

//**** 1. Approximation Constructor ****

MGRSBRep(
    const MGRSBRep& old,
    const MGKnotVector& ut, 
    const MGKnotVector& vt, 
    int &error  
);

//**** 2.Conversion Constructor.****

explicit MGRSBRep(
    const MGSBRep& brep,
    int homogeneous=0   
);

MGRSBRep(
    const MGRSBRep& old,        
    const MGKnotArray& uknots,  
    const MGKnotArray& vknots   
);

/*
MGRSBRep(
    const MGRSBRep& brep1,  ///B-Rep 1.
    int which1,             ///which perimeter of brep1.
    int continuity,         ///continuity. Must >=0.
    const MGRSBRep& brep2,  ///B-Rep 2.
    int which2,             ///which perimeter of brep2.
    int opposite            /// Input if parameter direction of which2
);
*/

MGRSBRep(
    const MGBox& uvrange,   
    const MGRSBRep& old,    
    int multiple=0 
);

MGRSBRep(
    int dim,                
    const MGRSBRep& sbrep,  
    int start1=0,       
    int start2=0        
);

MGRSBRep(
    const std::vector<const MGRLBRep*>& vecPtrRibRLBReps,
    bool direction_adjustment=true//=true, curves[.] direction are adjusted to line
                                //to the same direction.
);




MGRSBRep& operator=(const MGGel& gel2);
MGRSBRep& operator=(const MGRSBRep& gel2);

MGRSBRep operator+ (const MGVector& ) const;

MGRSBRep operator- (const MGVector& ) const;

MGRSBRep operator* (double) const;

MGRSBRep operator* (const MGMatrix& ) const;

MGRSBRep operator* (const MGTransf& ) const;

MGRSBRep& operator+=(const MGVector& v);
MGRSBRep& operator-=(const MGVector& v);
MGRSBRep& operator*=(double scale);
MGRSBRep& operator*=(const MGMatrix& mat);
MGRSBRep& operator*=(const MGTransf& tr);

bool operator==(const MGRSBRep& gel2)const;
bool operator==(const MGGel& gel2)const;
bool operator<(const MGRSBRep& gel2)const;
bool operator<(const MGGel& gel2)const;
bool operator!=(const MGGel& gel2)const{return !(gel2==(*this));};
bool operator!=(const MGRSBRep& gel2)const{return !(gel2==(*this));};
bool operator==(const MGSBRep& sb)const;




int bdim_u() const{return m_surface.bdim_u();}

int bdim_v() const{return m_surface.bdim_v();}
    
MGBox box_limitted(const MGBox& bx) const;

MGRSBRep& change_dimension(
    int sdim,   
    int start1=0,
    int start2=0 
);

MGRSBRep& change_range(
    int is_u,       
    double t1,      
    double t2       
);

double& coef(int i, int j, int k)
{   assert(i<bdim_u() && j<bdim_v() && k<=sdim());
    return m_surface.coef(i,j,k);}

double coef(int i, int j, int k)const{return m_surface.coef(i,j,k);}

MGVector coef(int i, int j) const{return m_surface.coef(i,j);}

const double* coef_data(int i=0, int j=0, int k=0) const
{return m_surface.coef_data(i,j,k);}

/*
int continuity(     /// Reuturn value is the continuity.
    const MGRSBRep& brep2,  /// Input second RSBRep
    int& which1,    /// Outputs which perimeter(which1) of this is
    int& which2,    /// connected to which(which2) of brep2.
    int& opposite,  /// Outputs if parameter direction of which2
    double& ratio   /// Ratio of 1st derivatives of the two surfaces will
) const;
*/

MGRSBRep* clone() const;

MGRSBRep* copy_change_dimension(
    int sdim,           
    int start1=0,       
    int start2=0        
)const;

void display_control_polygon(mgSysGL& sgl)const;

int divide_multi_knot(
    MGPvector<MGSurface>& srfl      
) const;

MGVector eval(
    double u,
    double v,
    int ndu=0,  
    int ndv=0   
) const;

MGVector eval(
    const MGPosition& uv
    , int ndu=0         
    , int ndv=0         
) const;

void eval_all(
    double u,       
    double v,       
    MGPosition& f,          
    MGVector&   fu,         
    MGVector&   fv,         
    MGVector&   fuv,        
    MGVector&   fuu,        
    MGVector&   fvv         
) const;

void eval_all(
    double u,       
    double v,       
    int ndu,    
    int ndv,    
    double* deriv   
) const;

MGSurface& exchange_uv(){m_surface.exchange_uv(); return *this;};

MGRSBRep& extend(
    int perimeter,  
    double param,   
    double length,  
    double dk=0.  
);

const MGSBRep& homogeneous() const {return m_surface;};

long identify_type() const;

bool in_range(double u, double v) const{return m_surface.in_range(u,v);};
bool in_range(const MGPosition& uv) const{return m_surface.in_range(uv);};

MGCSisect_list isect(const MGCurve& curve)const;
MGCSisect_list isect(const MGStraight& sl)const{return isectSl(sl);};
MGCSisect_list isect(const MGRLBRep& curve)const;
MGCSisect_list isect(const MGEllipse& curve)const;
MGCSisect_list isect(const MGLBRep& curve)const;
MGCSisect_list isect(const MGSurfCurve& curve)const;
MGCSisect_list isect(const MGBSumCurve& curve)const;

MGSSisect_list isect(const MGSurface& srf2)const;
MGSSisect_list isect(const MGPlane& srf2)const;
MGSSisect_list isect(const MGSphere& srf2)const;
MGSSisect_list isect(const MGCylinder& srf2)const;
MGSSisect_list isect(const MGSBRep& srf2)const;
MGSSisect_list isect(const MGRSBRep& srf2)const;
MGSSisect_list isect(const MGBSumSurf& srf2)const;

double& knot_u(int i){return m_surface.knot_u(i);}

double knot_u(int i) const{return m_surface.knot_u(i);}

double& knot_v(int i){return m_surface.knot_v(i);}

double knot_v(int i) const{return m_surface.knot_v(i);}

const double* knot_data_u() const{return m_surface.knot_data_u();}

const double* knot_data_v() const{return m_surface.knot_data_v();}

const MGKnotVector& knot_vector_u() const
{return m_surface.knot_vector_u();}
MGKnotVector& knot_vector_u(){return m_surface.knot_vector_u();}

const MGKnotVector& knot_vector_v() const
{return m_surface.knot_vector_v();}
MGKnotVector& knot_vector_v(){return m_surface.knot_vector_v();}

bool less_than(
    int i,  
    const MGPosition& uv1,
    const MGPosition& uv2
)const{return m_surface.less_than(i,uv1,uv2);};

MGRSBRep& limit(const MGBox& uvrange){m_surface.limit(uvrange); return *this;}

void negate(            
    int is_u        
){m_surface.negate(is_u);}

MGPosition negate_param(const MGPosition& uv, int is_u=1)const
{ return m_surface.negate_param(uv,is_u);}

MGSPointSeq non_homogeneous_bcoef() const;

int non_rational() const;

int order_u() const{return m_surface.knot_vector_u().order();}

int order_v() const{return m_surface.knot_vector_v().order();}

MGPosition param_e() const{return m_surface.param_e();}
double param_e_u() const{return m_surface.param_e_u();}
double param_e_v() const{return m_surface.param_e_v();}

MGCurve* parameter_curve(
    int is_u            
    , double x          
) const;

MGRLBRep parameter_line(
    int is_u            
    , double x          
) const;

MGBox param_range() const;

MGPosition param_s() const{return m_surface.param_s();}
double param_s_u() const{return m_surface.param_s_u();}
double param_s_v() const{return m_surface.param_s_v();}

MGRSBRep* part(
    const MGBox& bx,
    int multiple=0  
)const;

MGRLBRep perimeter(int i) const;

int perimeter_num() const{return 4;};

int planar(
    MGPlane& plane,     
    double& deviation   
) const;

int planar(
    const MGBox& uvbox,
    double tol, 
    int* divideU=0
)const;

MGPosition range(const MGPosition& uv)const{return m_surface.range(uv);}

std::auto_ptr<MGSurface> rebuild(
    int how_rebuild=1,
    int parameter_normalization=2,
    double tol=-1., 
    int* order=0
)const;

int reduce(
    int is_u,   
    int ndec    
){return m_surface.reduce(is_u,ndec);}

MGRSBRep& refine(
    const MGKnotVector& uknot,  
    const MGKnotVector& vknot   
){m_surface.refine(uknot,vknot); return *this;}

void remove_knot();

int sdim() const{return m_surface.sdim()-1;}

void shrink_to_knot(
    const MGBox& uvbx,
    int multiple=0  
){m_surface.shrink_to_knot(uvbx,multiple);};

const MGSPointSeq& surface_bcoef() const{return m_surface.surface_bcoef();} 

MGSPointSeq& surface_bcoef(){return m_surface.surface_bcoef();}


MGSURFACE_TYPE type() const{return MGSURFACE_RSPLINE;}

MGSurface& unlimit(){return *this;};

public:

int out_to_IGES(
    MGIgesOfstream& igesfile,
    int SubordinateEntitySwitch=0
)const;

std::ostream& out(std::ostream&) const;

std::string whoami()const{return "RSBRep";};

protected:

MGCSisect_list isectSl(
    const MGStraight& sl,
    const MGBox& uvbox=mgNULL_BOX 
)const;

void ReadMembers(MGIfstream& buf);
    
void WriteMembers(MGOfstream& buf) const;

private:

    MGSBRep m_surface;      

int coef_sdim() const{return m_surface.sdim();};

MGBox* compute_box() const;

/*
int continuity(     /// Reuturn value is the continuity.
    const MGRSBRep& brep2,  /// Input second RSBRep
    int is_u1,      /// Input if u-direction of this.
    int is_u2,      /// Input if u-direction of brep2.
    int opposite,   /// Input if parameter direction of which2 is equal or not.
    int& which1,    /// Outputs which perimeter(which1) of this is
    int& which2,    /// connected to which(which2) of brep2.
    double& ratio   /// Ratio of 1st derivatives of the two surfaces will
) const;
*/

int intersect_dnum_u() const;
int intersect_dnum_v() const;

MGCurve* isect_incr_pline(
    const MGPosition& uv,
    int kdt,            
    double du, double dv,
    double& u,          
    double& v,          
    int incr=1      
) const;

int isect_order() const;

MGSBRep* surf1D(
    const MGPlane& pl
)const;

int divide_multi_knot_u(
    MGPvector<MGRSBRep>& srfl) const;      

int divide_multi_knot_v(
    MGPvector<MGSurface>& srfl) const;      

};

namespace MGCL{
    
extern MG_DLL_DECLR void Binominal(int m, double* bc);

};
 // end of GEO group
#endif