SBRep.h

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

#include <assert.h>
#include "mg/MGCL.h"
#include "mg/Vector.h"
#include "mg/SPointSeq.h"
#include "mg/KnotVector.h"
#include "mg/Surface.h"
#include "mg/CSisect_list.h"
#include "mg/SSisect_list.h"

// MGSBRep.h
//
// Forward Declaration
class  MGBox;
class  MGNDDArray;
class  MGPosition;
class  MGBPointSeq;
class  MGKnotArray;
class  MGMatrix;
class  MGTransf;
class  MGLBRep;
class  MGSBRepEndC;
class  MGSBRepTP;
class  MGSBRepVecTP;
class  MGStraight;
class  MGEllipse;
class  MGPlane;
class  MGIfstream;
class  MGOfstream;

class MG_DLL_DECLR MGSBRep: public MGSurface {

public:

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

MG_DLL_DECLR friend void build_SBRep_1direction(
    MGSBRepEndC& endc,          
    const MGNDDArray& utaui,    
    const MGNDDArray& vtaui,    
    const MGSPointSeq& value,   
    const MGKnotVector& tu, 
    const MGKnotVector& tv, 
    MGSBRep& brep,          
    int &error          
);


MGSBRep();

MGSBRep(
    const MGSPointSeq& vertex,  
    const MGKnotVector& tu,     
    const MGKnotVector& tv  
);

//**** 1. Interpolation Constructor ****

explicit MGSBRep(
    const MGSPointSeq& points,
    int orderu=4,       
    int orderv=4        
);

MGSBRep(
    const MGNDDArray& utau,     
    const MGNDDArray& vtau,     
    const MGSPointSeq& points,  
    const MGKnotVector& tu,     
    const MGKnotVector& tv      
);

MGSBRep(                
    const MGSBRepTP& tp,        
    const MGNDDArray& utau,     
    const MGNDDArray& vtau,     
    const MGVector   uvec[4],   
    const MGVector   vvec[4],   
    const MGSPointSeq& points   
);

MGSBRep(                
    MGSBRepEndC& endc,      
    const MGNDDArray& utaui,
    const MGNDDArray& vtaui,
    const MGSPointSeq& value
);

MGSBRep(                
    MGSBRepEndC& endc,      
    int orderu,
    int orderv,
    const MGNDDArray& utaui,    
    const MGNDDArray& vtaui,    
    const MGSPointSeq& value    
);

MGSBRep(
    MGSBRepEndC& endc,          
    const MGNDDArray& utaui,    
    const MGNDDArray& vtaui,    
    const MGSPointSeq& value,   
    const MGKnotVector& tu, 
    const MGKnotVector& tv  
);

MGSBRep(
    const MGLBRep& lbrep,       
    const MGUnit_vector& uvec,  
    double start_dist,          
    double end_dist         
);

MGSBRep(
    const MGNDDArray& utau, 
    const MGNDDArray& vtau, 
    const MGSPointSeq& value,   
    int orderu=4,
    int orderv=4
);

MGSBRep(
    const MGStraight& st,       
    const MGUnit_vector& uvec,  
    double start_dist,          
    double end_dist         
);

MGSBRep(
    const MGNDDArray& tau,
    const std::vector<MGLBRep*>& lines,
    const MGLBRep* deriS,
    const MGLBRep* deriE
);

//**** 2. Approximation Constructor ****

MGSBRep(
    const MGSBRep& old_brep,
    const MGKnotVector& ut, 
    const MGKnotVector& vt, 
    int &error  

);

MGSBRep(                
    const MGNDDArray& utau, 
    const MGNDDArray& vtau, 
    const MGSPointSeq& points,  
    const MGKnotVector& tu, 
    const MGKnotVector& tv, 
    const MGSPointSeq& weight   
);

MGSBRep(                
    const MGNDDArray& utau, 
    const MGNDDArray& vtau, 
    const MGSPointSeq& points,  
    const MGSPointSeq& dp,  
    double deviation        
);

MGSBRep(
    const MGCurve*  edge_crvl[4],
    const MGCurve&  blendCrvU,  
    const MGCurve&  blendCrvV,  
    const MGSBRepTP&tp,         
    int& error      
);

MGSBRep(
    MGPvector<MGLBRep>& edges,  
    int&            error   ,   
    const MGCurve*  blendCrvU=0,
    const MGCurve*  blendCrvV=0 
);

MGSBRep(
    const MGCurve*  edge_crvl[4],
    const MGSBRepTP&tp,         
    int& error,                 
    const double* alpha=0       
);

MGSBRep(
    bool along_u,   
    const MGPvector<MGLBRep>& perimeters
);

//**** 3.Conversion Constructor.****

MGSBRep(
    const MGSBRep& old_brep,    
    const MGKnotArray& uknots,  
    const MGKnotArray& vknots   
);

MGSBRep(
    const MGSBRep& brep1,   
    int which1,             
    int continuity,         
    const MGSBRep& brep2,   
    int which2,             
    int opposite            
);

MGSBRep(
    const MGBox& uvrange,       
    const MGSBRep& old_brep,    
    int multiple=0
);

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

MGSBRep(
    const MGPlane& plane,
    const MGBox& prange 
);

//  MGSBRep(const MGSBRep&);  ///Copy constructor.
//  We can use default copy constructor.

MGSBRep(const std::vector<const MGCurve*>& curves,bool direction_adjustment=true);
MGSBRep(const MGPvector<MGCurve>& curves,bool direction_adjustment=true);



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

MGSBRep operator+ ( const MGVector & ) const;

MGSBRep operator- ( const MGVector & ) const;

MGSBRep operator* (double) const;

MGSBRep operator* ( const MGMatrix& ) const;

MGSBRep operator*( const MGTransf & ) const;

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

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




int bdim_u() const{return m_surface_bcoef.length_u();}

int bdim_v() const{return m_surface_bcoef.length_v();}

MGBox box_limitted(const MGBox& uvrange) const;

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

MGSBRep& 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());
    update_mark();
    return m_surface_bcoef(i,j,k);
}       

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

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

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

int continuity(
    const MGSBRep& brep2,   
    int& which1,    
    int& which2,    
    int& opposite,  
    double& ratio   
) const;

MGSBRep* clone() const;

MGSBRep* 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();

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

long identify_type() const;

bool in_range(double u, double v) const;
bool in_range(const MGPosition& uv) const;

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_uknot(i);}

double knot_u(int i) const{return m_uknot(i);}

double& knot_v(int i){return m_vknot(i);}           

double knot_v(int i) const{return m_vknot(i);}

const double* knot_data_u() const{return m_uknot.data();}

const double* knot_data_v() const{return m_vknot.data();}

const MGKnotVector& knot_vector_u() const{return m_uknot;}
MGKnotVector& knot_vector_u(){return m_uknot;};

const MGKnotVector& knot_vector_v() const{return m_vknot;}
MGKnotVector& knot_vector_v(){return m_vknot;};

bool less_than(
    int i,  
    const MGPosition& uv1,
    const MGPosition& uv2
) const;

MGSBRep& limit(const MGBox& uvrange);

MGSBRep& move(
    int move_kind_u,    
    int move_kind_v,    
    const MGPosition& move_point_param, 
    const MGPosition& to_point, 
    const MGPosition fix_point[2]
);

void negate(            
    int is_u    
);

MGPosition negate_param(const MGPosition& uv, int is_u=1)const;

int order_u() const{return m_uknot.order();}

int order_v() const{return m_vknot.order();}

MGPosition param_e() const;
double param_e_u() const;
double param_e_v() const;

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

MGLBRep parameter_line(
    int is_u            
    , double x          
    , int nderiv=0  
)const;

//MGBox param_range() const; Uses MGSurface::param_range()

MGPosition param_s() const;
double param_s_u() const;
double param_s_v() const;

MGSBRep* part(
    const MGBox& uvbx,
    int multiple=0  
)const;

MGLBRep 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;

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

int reduce(
    int is_u,       
    int ndec        
);

MGSBRep& refine(
    const MGKnotVector& uknot,  
    const MGKnotVector& vknot   
);

void remove_knot();

int remove_knot_one(
    double line0,       
    int id, 
    double& tol,
    bool u_knot=true    
);

int sdim() const{return m_surface_bcoef.sdim();}

void shrink_to_knot(
    const MGBox& uvbx,
    int multiple=0  
);

const MGSPointSeq& surface_bcoef() const{return m_surface_bcoef;}

MGSPointSeq& surface_bcoef(){update_mark(); return m_surface_bcoef;}


MGSURFACE_TYPE type() const{return MGSURFACE_SPLINE;}

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

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

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

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

protected:

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

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

private:

    MGKnotVector m_uknot;           
    MGKnotVector m_vknot;           
    MGSPointSeq  m_surface_bcoef;   

MGBox* compute_box() const;

void compute_knot(
    const MGSPointSeq& points,
    int orderu,         
    int orderv,         
    MGNDDArray& utau,   
    MGNDDArray& vtau    
);

int continuity(
    const MGSBRep& brep2,   
    int is_u1,      
    int is_u2,      
    int opposite,   
    int& which1,    
    int& which2,    
    double& ratio   
)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=0          
) const;

void isect_incr_pline2(
    const MGPosition& uv,
    int kdt,            
    double du, double dv,
    double& u,          
    double& v,          
    int incr,       
    MGLBRep& pline      
) const;

int isect_sub_interval(
    int kdt,    
    double u, double v, 
    double du, double dv,
    int& index,         
    int incr            
)const;

int isect_order() const;

int remove_knot_u();

int remove_knot_u_one(
    double line0,       
    int id,         
    double& totalTol,   
    int& num_knot   
);

MGSBRep* surf1D(const MGPlane& pl)const;

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

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

friend class MGSurface;
friend class MGRSBRep;

};

int MG_DLL_DECLR construct_perimeters(
    const MGPvector<MGCurve>& peris,
    MGPvector<MGLBRep>& perimeters2
);

extern MG_DLL_DECLR void bool_sum(
    const MGCurve*  edge_crvl[4],   
    const MGSBRepTP& tp,            
    int& error, 
    MGSBRep& surf
);

extern MG_DLL_DECLR void bool_sum(
    const MGCurve*  edge_crvl[4],   
    MGSBRepVecTP& vectp,            
    int& error, 
    MGSBRep& surf
);
 // end of GEO group
#endif