RLBRep.h

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

#include "mg/LBRep.h"

// MGRLBRep.h
//

// Forward Declaration
class  MGPosition;
class  MGKnotArray;
class  MGCParam_list;
class  MGPosition_list;
class  MGIfstream;
class  MGOfstream;


class MG_DLL_DECLR MGRLBRep: public MGCurve {

public:
MG_DLL_DECLR friend MGRLBRep operator+ (const MGVector& v, const MGRLBRep& lb);
MG_DLL_DECLR friend MGRLBRep operator* (double scale, const MGRLBRep&);


MGRLBRep():MGCurve(){;}

MGRLBRep(
    const MGKnotVector& t,      
    const MGBPointSeq& bcoef,   
    int homogeneous=1
);

MGRLBRep(
    const MGKnotVector& t,  
    const MGBPointSeq& bcoef,
    const std::vector<double>& weights
);

explicit MGRLBRep(const MGEllipse& ellipse);

MGRLBRep(
    const MGPosition& P0,
    const MGVector& T0, 
    const MGPosition& P,
    const MGPosition& P2,
    const MGVector& T2  
);

MGRLBRep(
    const MGRLBRep& old_brep,
    const MGKnotVector& t   
);


MGRLBRep(
const MGLBRep& brep,
int homogeneous=0   
);

MGRLBRep(
    const MGRLBRep& old_brep,   
    const MGKnotArray& knots    
);

MGRLBRep(
    const MGRLBRep& brep1,  
    int continuity,         
    int which,  
    const MGRLBRep& brep2   
);

MGRLBRep(
    double t1, 
    double t2, 
    const MGRLBRep& old_brep,
    int multiple=0 
);

MGRLBRep(
    int dim,            
    const MGRLBRep& lbrep,
    int start1=0,       
    int start2=0        
);

MGRLBRep(
    double a, double b,
    double angle1, double angle2
);




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

MGRLBRep operator+ (const MGVector& ) const;
MGRLBRep operator- (const MGVector& ) const;
MGRLBRep operator* (double) const;
MGRLBRep operator* (const MGMatrix& ) const;
MGRLBRep operator* (const MGTransf& ) const;

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

bool operator==(const MGRLBRep& gel2)const;
bool operator==(const MGGel& gel2)const;
bool operator<(const MGRLBRep& gel2)const;
bool operator<(const MGGel& gel2)const;
bool operator==(const MGLBRep& gel2)const;


void approximate_as_LBRep(
    MGLBRep& lb,    
    int ordr=0,     
    int parameter_normalization=0,
    bool neglectMulti=false
)const;

int bdim() const{return m_line.bdim();}
    
MGBox box_limitted(const MGInterval& l) const;

MGBox box_unlimit() const;

void change_range(
    double t1,          
    double t2           
){
    m_line.change_range(t1,t2);
    update_mark();
};

MGRLBRep& change_dimension(
    int dim,            
    int start1=0,       
    int start2=0        
);

MGRLBRep& change_order(
int order       
){m_line.change_order(order); return *this;};

double& coef(int i, int j){update_mark(); return m_line.coef(i,j);};        

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

MGVector coef(int i) const{return m_line.coef(i);};

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

void connect(
    int continuity, 
    int which,      
    const MGRLBRep& brep2   
);

int continuity(
    const MGRLBRep& brep2,
    int& which, 
    double& ratio 
) const;

MGRLBRep& coordinate_exchange(int i, int j);

MGRLBRep* clone() const;

MGCurve* copy_as_nurbs() const{return clone();};

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

MGCurve* copy_limitted(const MGInterval& prange) const;

int divide_multi(
    MGPvector<MGCurve>& crv_list,   
    int multiplicity=-1 
) const;

void display_control_polygon(mgSysGL& sgl)const;

void draw_2D(
    void (*moveto)(int, int),
    void (*lineto)(int, int),
    const double wind[4],   
    int ynum            
)const;

void draw_2D(
    void (*moveto)(float, float),
    void (*lineto)(float, float),
    const double wind[4],   
    int ynum            
)const;

void draw_2D(
    void (*moveto)(double, double),
    void (*lineto)(double, double),
    const double wind[4],   
    int ynum            
)const;

void draw_1D(
    void (*moveto)(int, int),
    void (*lineto)(int, int),
    int coordinate,     
    bool t_is_x,        
    const double wind[4],
    int ynum        
)const;

void draw_1D(
    void (*moveto)(float, float),
    void (*lineto)(float, float),
    int coordinate,     
    bool t_is_x,            
    const double wind[4],   
    int ynum        
)const;

void draw_1D(
    void (*moveto)(double, double),
    void (*lineto)(double, double),
    int coordinate,     
    bool t_is_x,            
    const double wind[4],   
    int ynum    
)const;

void drawSE(
    mgVBO& vbo,
    double span_length, 
    double t0,          
    double t1           
)const;

MGVector eval(
    double t,       
    int nderiv=0,
    int left=0      
) const;

void eval_all(
    double tau,         
    MGPosition& P,      
    MGVector& V1,       
    MGVector& V2        
) const;

void eval_all(
    double tau,     
    int nderiv, 
    double* deriv,  
    int left=0      
) const;

void extend(
    double length,  
    bool start=false
);

MGRLBRep& extend(
    int start,          
    double length,      
    double dk=0.         
);

MGRLBRep& extend_with_parameter(
    double tau, 
    double dk   
);

bool get_control_points(
    MGBPointSeq& cpoints    
)const;

const MGLBRep& homogeneous() const {return m_line;}
MGLBRep& homogeneous(){update_mark();return m_line;}

long identify_type() const;

int intersect_dnum() const;

bool is_coplanar(const MGCurve& curve2, MGPlane& plane)const;

bool is_planar(MGPlane& plane)const;

MGCCisect_list isect(const MGCurve&) const;
MGCCisect_list isect(const MGStraight& curve2)const;
MGCCisect_list isect(const MGSurfCurve& curve2)const;
MGCCisect_list isect(const MGBSumCurve& curve2)const;


MGCSisect_list isect(const MGSurface& surf) const;
MGCSisect_list isect(const MGPlane& surf) const;
MGCSisect_list isect(const MGSphere& surf)const;
MGCSisect_list isect(const MGCylinder& surf)const;
MGCSisect_list isect(const MGSBRep& surf)const;
MGCSisect_list isect(const MGRSBRep& surf)const;
MGCSisect_list isect(const MGBSumSurf& surf)const;

MGCParam_list isect_2D(
    const MGStraight& sl,
    int coordinate=0    
) const;    

MGCParam_list isect_3D(
    const MGPlane& pl,  
    int coordinate=0    
) const;    

double& knot(int i){return m_line.knot(i);}         

double knot(int i) const{return m_line.knot(i);}

const double* knot_data() const{return m_line.knot_data();}     

const MGKnotVector& knot_vector() const{return m_line.knot_vector();}

MGKnotVector& knot_vector(){return m_line.knot_vector();}   

MGRLBRep& limit(const MGInterval& itvl);

const MGBPointSeq& line_bcoef() const{return m_line.line_bcoef();};

MGBPointSeq& line_bcoef(){update_mark(); return m_line.line_bcoef();};

void negate(){m_line.negate();};

double negate_param(double t)const{return m_line.negate_param(t);};

MGBPointSeq non_homogeneous_bcoef() const;

int non_rational() const;

int order() const{return m_line.order();}

double param_e() const{return m_line.param_e();};

double param_normalize(double t) const{return m_line.param_normalize(t);}

double param_s() const{return m_line.param_s();};

MGRLBRep* part(
    double t1,
    double t2,
    int multiple=0  
) const;

MGPosition_list perps(const MGCurve& crv2)const;
MGPosition_list perps(const MGStraight& crv2)const;

int planar(
    MGPlane& plane  
    , MGStraight& line      
    , MGPosition& point     
)const;

int reduce(
    int ndec            
){
    update_mark();
    return m_line.reduce(ndec);
};

MGRLBRep& refine(
        const MGKnotVector& t   
){
    m_line.refine(t);
    update_mark();
    return *this;
};

std::auto_ptr<MGRLBRep> rebuild_with_new_knot_configuration(
    double error,   //Error alowed to rebuild. If error<=0., MGTolerance::line_zero()
                    //will be employed.
    int parameter_normalization
        //Indicates how the parameter normalization be done:
        //=0: no parameter normalization.
        //=1: normalize to range=(0., 1.);
        //=2: normalize to make the average length of the 1st derivative 
        //    is as equal to 1. as possible.
)const;

void remove_knot();

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

MGSurface* sweep(
    const MGUnit_vector& uvec,          
    double start_dist,                  
    double end_dist             
) const;

MGCURVE_TYPE type() const{return MGCURVE_RSPLINE;}

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

MGCurve& unlimit_end(){return *this;};

MGCurve& unlimit_start(){return *this;};


public:

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

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

protected:

MGCParam_list intersect_1D(                     
    double f,           
    int coordinate=0    
)const; 

std::auto_ptr<MGCurve> oneD(
    const double g[4]           
) const;

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

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

private:


    MGLBRep  m_line;            

MGBox* compute_box()const;

void drawgl(
    mgVBO& vbo,
    double dl,      
    double tstart, double tend  
)const;

MGCParam_list isect_nD(                     
    const MGVector& N,      
    int dimension,      
    int coordinate      
) const;

void draw_all2D(
    int kfunc,      
    int (*moveto)(...), int (*lineto)(...),
    const double wind[4], 
    int ynum    
)const;

void draw_all1D(
    int coordinate, 
    bool t_is_x,    
    int kfunc,      
    int (*moveto)(...), int (*lineto)(...),
    const double wind[4], 
    int ynum    
)const;

MGRLBRep& split_conic(int i);


};

MG_DLL_DECLR int MGRLBRep_ellipse_weight
    (const MGPosition& P0, const MGVector& T0,
     const MGPosition& P,
     const MGPosition& P2, const MGVector& T2,
     MGPosition& P1, double& w1
);
 // end of GEO group
#endif