LBRep.h

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

#include "mg/MGCL.h"
#include "mg/Vector.h"
#include "mg/KnotVector.h"
#include "mg/BPointSeq.h"
#include "mg/Curve.h"

// MGLBRep.h
// Forward Declaration
class  MGInterval;
class  MGNDDArray;
class  MGPosition;
class  MGOscuCircle;
class  MGKnotArray;
class  MGCParam_list;
class  MGPosition_list;
class  MGLBRepEndC;
class  MGRLBRep;
class  MGPPRep;
class  MGSBRepTP;
class  MGIfstream;
class  MGOfstream;

// Defines Line B-Representation.

class MG_DLL_DECLR MGLBRep: public MGCurve{

public:

MG_DLL_DECLR friend MGLBRep operator+ (const MGVector& v, const MGLBRep& lb);

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

MG_DLL_DECLR friend MGPvector<MGLBRep> rebuild_knot(
    const std::vector<const MGCurve*>& brepl,
    int order = 0,  
    MGLBRep**   tp=0    
);

MG_DLL_DECLR friend MGPvector<MGLBRep> rebuild_knot(
    const MGPvector<MGCurve>& brepl,    
    int order = 0,  
    MGLBRep**   tp=0    
);              

MG_DLL_DECLR friend void remove_knot_curves(
    MGPvector<MGLBRep>& brepList,   
    MGLBRep**       tp=0,   
    double tp_length=0.
);


MGLBRep():MGCurve(),m_line_bcoef(),m_knot_vector(){;}

MGLBRep(int bdim,   
        int order,  
        int sdim    
):MGCurve(),m_line_bcoef(bdim,sdim),m_knot_vector(order, bdim){;}

MGLBRep(
    const MGKnotVector& t,  
    const MGBPointSeq& bcoef
);

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

explicit MGLBRep(
    const MGBPointSeq& points,  
    int order=4,        
    bool circular=false 
);

MGLBRep(
    const MGNDDArray& tau,      
    const MGBPointSeq& points,  
    int order=4,                
    double ratio=-1.            
);

MGLBRep(
    const MGNDDArray& tau,      
    const MGBPointSeq& points,  
    const MGKnotVector& t       
);

MGLBRep(
    const MGLBRepEndC& begin,   
    const MGLBRepEndC& end,     
    const MGNDDArray& tau,      
    const MGBPointSeq& value    
);

MGLBRep(
    int order,              
    const MGLBRepEndC& begin,   
    const MGLBRepEndC& end,     
    const MGNDDArray& tau,      
    const MGBPointSeq& value    
);

MGLBRep(
    const MGLBRepEndC& begin,   
    const MGLBRepEndC& end,     
    const MGNDDArray& tau,      
    const MGBPointSeq& value,   
    const MGKnotVector& t       
);

MGLBRep(
    const MGLBRepEndC& begin,   
    const MGLBRepEndC& end,     
    const MGBPointSeq& points,  
    const int* point_kind,      
    const MGOscuCircle& circle  
);

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

explicit MGLBRep(
    const MGCurve& crv, 
    int order=0,
    int parameter_normalization=0,
    bool neglectMulti=false
);

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

MGLBRep(
    const MGCurve& old_curve,   
    const MGKnotVector& t   
);

MGLBRep(
    int coordinate1,    
    const MGLBRep& brep1,   
    int coordinate2,    
    const MGLBRep& brep2    
);

MGLBRep(
    const MGNDDArray& tau,      
    const MGBPointSeq& points,  
    const double* weight,       
    const MGKnotVector& t       
);

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

MGLBRep(const MGPPRep& pprep);

MGLBRep(
    const MGPPRep& pprep,   
    const MGKnotVector t    
);

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

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

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

MGLBRep(
    int id1,
    int id2,
    const MGLBRep& old_brep 
);

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

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

//Destructor
//  ~MGLBRep(); ///We can use default destructor.

//Virtual Destructor
~MGLBRep(){;};


//Assignment.
//MGLBRep& operator= (const MGLBRep& lb2);//We can use default assignment.

MGLBRep& operator=(const MGGel& gel2);

MGLBRep& operator=(const MGLBRep& el2);

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

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

bool operator==(const MGLBRep& gel2)const;
bool operator==(const MGGel& gel2)const;
bool operator<(const MGLBRep& gel2)const;
bool operator<(const MGGel& gel2)const;
bool operator==(const MGRLBRep& 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_bcoef.length();}

MGBox box_limitted(const MGInterval& l) const;

const MGBox& box_unlimit() const;

void buildSRSmoothedLB_of_FreeEnd(
    const MGNDDArray& tau,  
    const MGBPointSeq& y,   
    const double* dy,
    double deviation,
    bool dev_is_sum=false
);

void buildSRSmoothedLB_of_1stDeriv(
    const MGLBRepEndC& begin,
    const MGLBRepEndC& end, 
    const MGNDDArray& tau,  
    const MGBPointSeq& y,   
    const double* dy,
    double deviation,
    bool dev_is_sum=false
);

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

void change_range(
    double t1,  
    double t2   
);

MGLBRep& change_order(
    int order   
);

MGLBRep& change_order_by_approximation(
    int ordr    
);

double& coef(int i, int j){return m_line_bcoef(i,j);}

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

MGVector coef(int i) const{return m_line_bcoef(i);}

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

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

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

MGLBRep& coordinate_exchange(int j1, int j2);

virtual MGLBRep* clone()const;

void convert_to_Bezier(MGLBRep& bezier)const;

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

MGLBRep* copy_as_LBRep() const;

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

MGCurve* copy_limitted(const MGInterval& prange) const;

double curvilinear_integral(double t1, double t2) const;
#ifdef __sgi
    double curvilinear_integral()const
    {return curvilinear_integral(param_s(), param_e());}
#endif

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

void display_control_polygon(mgSysGL& sgl)const;


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

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

void eval_all(
    double,     
    MGPosition&,
    MGVector&,  
    MGVector&   
)const;

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

void eval_line(
    MGENDCOND begin,        
    MGENDCOND end,          
    const MGNDDArray& tau,  
    MGBPointSeq& value      
)const;

void eval_line(
    const MGNDDArray& tau,  
    MGBPointSeq& value      
)const{eval_line(MGENDC_NO,MGENDC_NO,tau,value);};

MGLBRep& extend(
    int start,      
    double length,  
    double dk     
);

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

MGLBRep& extend_with_parameter(
    double tau, 
    double dk   
);

bool get_control_points(
    MGBPointSeq& cpoints    
)const;

long identify_type() const;

const MGLBRep* is_Bezier(int ordr=0)const;

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

bool is_planar(MGPlane& plane)const;

MGCCisect_list isect(const MGCurve& curve2) const;
MGCCisect_list isect(const MGStraight& curve2)const;
MGCCisect_list isect(const MGRLBRep& curve2)const;
MGCCisect_list isect(const MGEllipse& curve2)const;
MGCCisect_list isect(const MGLBRep& 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;

double& knot(int i){return m_knot_vector(i);};

double knot(int i) const{return m_knot_vector(i);};

const double* knot_data() const{return m_knot_vector.data();};
double* knot_data(){return m_knot_vector.data();};

const MGKnotVector& knot_vector() const{return m_knot_vector;};

MGKnotVector& knot_vector(){return m_knot_vector;};

//Update this by limiting the parameter range of the curve.
virtual MGLBRep& limit(const MGInterval& i1);

const MGBPointSeq& line_bcoef() const{return m_line_bcoef;};

MGBPointSeq& line_bcoef(){
    update_mark();
    return m_line_bcoef;
};

MGLBRep& move(
    int move_kind,          
    double move_point_param,
    const MGPosition& to_point, 
    const double fix_point[2]
);

virtual void negate();

double negate_param(double t)const;

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

double param_e() const;

double param_s() const;

double param_normalize(double t) const;

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

MGCParam_list perps(
    const MGPosition& point 
)const;

MGPosition_list perps(const MGCurve& crv2)const;
MGPosition_list perps(const MGStraight& crv2)const;
MGPosition_list perps(const MGRLBRep& crv2)const;
MGPosition_list perps(const MGEllipse& crv2)const;
MGPosition_list perps(const MGLBRep& crv2)const;
MGPosition_list perps(const MGSurfCurve& crv2)const;
MGPosition_list perps(const MGBSumCurve& crv2)const;

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

int project(
    const MGFSurface& surf, //given surface.
    MGPvector<MGCurve>& vec_crv_uv, //uv projection curve will be appended.
    MGPvector<MGCurve>& vec_crv,    //3d projection curve will be appended.
    const MGVector& vec //projection vector.
                        //if vec = NULL then calculate perpendicular project.
)const;
int project(
    const MGPlane& plane,   //given surface.
    MGPvector<MGCurve>& vec_crv_uv, //uv projection curve will be appended.
    MGPvector<MGCurve>& vec_crv,    //3d projection curve will be appended.
    const MGVector& vec //projection vector.
                        //if vec = NULL then calculate perpendicular project.
)const;

int reduce(
    int ndec    
);

MGLBRep& refine(                
        const MGKnotVector& t   
);

void remove_knot(){remove_knot(0,0);};

void remove_knot(int j, int snum);

int remove_knot_one(
    double line0,   
    int nKnot,  
    double& totalTol,
    int& num_knot,
    int sid=0,  
    int snum=0  
);

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

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

MGCURVE_TYPE type() const{return MGCURVE_SPLINE;};

void updatePolarCoordinates2Ordinary();

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

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

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


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

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

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

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;

private:

MGLBRep(const MGRLBRep& rlb, const MGNDDArray& tau);

MGPosition closest_mix(
    int coordinate1,    
    int coordinate2,    
    double tau,             
    const MGPosition& P,    
    const MGPosition& F     
)const;

MGBox* compute_box() const;

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

int intersect_dnum()const;

MGCCisect_list isect_by_split_to_C1(const MGCurve& crv2)const;

MGCCisect_list C1isect(const MGCurve& crv2) const;
MGCCisect_list C1isect(const MGStraight& crv2) const;

MGPosition_list C1perps(const MGCurve& crv2)const;

MGCCisect_list isect_order2(const MGCurve& crv2) const;
MGCSisect_list isect_order2(const MGSurface& crv2) const;

MGCCisect_list isect_with_noCompoSC(const MGSurfCurve& curve2)const;

MGCCisect_list isect_withC1LB(const MGLBRep& crv2)const;

MGCSisect_list isect_by_split_to_C1(const MGSurface& surf)const;

MGPosition_list perps_by_split_to_C1(const MGCurve& crv2)const;

MGPosition_list perps_withC1LB(
   const MGLBRep& lbC1
)const;

MGPosition_list perps_with_noCompoSC(const MGSurfCurve& curve2)const;

MGPosition_list perps_order2(const MGCurve& crv)const;

MGPosition_list perps_1span(const MGLBRep& lb2)const;

private:
    MGKnotVector m_knot_vector; 
    MGBPointSeq  m_line_bcoef;  

friend class MGCurve;
friend class MGStraight;
friend class MGRLBRep;

};
 // end of GEO group
#endif