Straight.h

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

#include "mg/EReal.h"
#include "mg/Position.h"
#include "mg/Unit_vector.h"
#include "mg/Curve.h"

// MGStraight.h
// Definition of MGStraight class

class MGBox;
class MGInterval;
class MGVector;
class MGTransf;
class MGCCisect;
class MGCSisect;
class MGRLBRep;
class MGEllipse;
class MGLBRep;
class MGSurfCurve;
class MGBSumCurve;
class MGCompositeCurve;
class MGTrimmedCurve;
class MGKnotVector;
class MGPlane;
class MGSurface;
class MGCCisect_list;
class MGPosition_list;
class MGIfstream;
class MGOfstream;

class MG_DLL_DECLR MGStraight: public MGCurve{
public:

MG_DLL_DECLR friend MGStraight operator+ (const MGVector& v, const MGStraight& sl);
MG_DLL_DECLR friend MGStraight operator* (double scale, const MGStraight&);

    
MGStraight();

MGStraight(const MGStraight& sl);

explicit MGStraight (
    const MGEReal& endparam,    
    const MGEReal& sparam,      
    const MGVector& direction,  
    const MGPosition& Origin    
);
explicit MGStraight(
    double endparam,            
    double sparam,              
    const MGVector& direction,  
    const MGPosition& Origin    
);

MGStraight(
    MGSTRAIGHT_TYPE type,   
    const MGVector& vec,                
    const MGPosition & = mgORIGIN       
);

MGStraight(
    const MGPosition& end,      
    const MGPosition& start     
);

MGStraight(
    const MGPosition& endP,     
    const MGPosition& startP,   
    const double endT,          
    const double startT = 0.0   
);

MGStraight(
    const MGUnit_vector& v, 
    double d,               
    const MGPosition& p= mgORIGIN
);
    
explicit MGStraight(
    const MGPosition& P1,   
    const MGPosition& P2,   
    const MGVector& N
);

explicit MGStraight(
    const MGVector& v0, //a vector whose end is uv.
    const MGVector& v1, //a vector whose start is uv.
    const MGPosition& uv//origin of sl.
);


MGStraight(
    int dim,                
    const MGStraight& linne2,
    int start1=0,           
    int start2=0            
);
~MGStraight();


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

MGStraight operator+ (const MGVector& vec)const;
MGStraight operator- (const MGVector& vec)const;
MGStraight operator* (double scale)const;
MGStraight operator* (const MGMatrix&)const;
MGStraight operator* (const MGTransf&)const;

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

bool operator==(const MGStraight& sl2)const;
bool operator==(const MGGel& gel2)const;
bool operator<(const MGStraight& gel2)const;
bool operator<(const MGGel& gel2)const;


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

int bdim()const{return 2;};

MGBox box_limitted(const MGInterval& l)const;

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

void change_range(
    double t1,      
    double t2       
);

MGStraight& coordinate_exchange(int i, int j);

MGStraight* clone()const;

double closest(const MGPosition& point) const;

MGPosition closest(const MGCurve& curve2) const;

void convert_to_Bezier(MGLBRep& bezier)const;

MGCurve* copy_as_nurbs()const;

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

double curvature( double ) const{return 0.;};

double curvilinear_integral(double t1, double t2)const;

#ifdef __sgi
    double curvilinear_integral()const
    {return MGCurve::curvilinear_integral();}
#endif

MGUnit_vector direction(double)const{return m_direction;};

const MGVector& direction()const{return m_direction;};

double direction_len()const{return m_direction.len();};

double distance( const MGPosition& = mgORIGIN )const;

double distance( const MGStraight& )const;

void drawWire(
    mgVBO& vbo,
    double span_length, 
    int line_density=1
)const;

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

const MGEReal& end()const{ return m_endparam;};

double end_param()const{return param_e();};

MGPosition end_point()const;

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

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

MGVector eval_deriv(double t)const;

MGPosition eval_position(double t)const;

MGPosition eval_position_unlimitted(double t)const;

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

bool finite()const{return m_sparam.finite() && m_endparam.finite();};

long identify_type()const;

bool infinite_above()const{return m_endparam.plus_infinite();};

bool infinite_below()const{return m_sparam.minus_infinite();};

bool in_range(double t)const;

int intersect_dnum() const{return 2;}

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

bool is_startpoint_parameter(double t)const;

bool is_endpoint_parameter(double t)const;

bool is_linear(MGStraight& straight)const;

bool is_planar(MGPlane& plane)const;

MGCCisect_list isect(const MGCurve&)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 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;
MGCSisect_list isect(const MGFace& f)const;

double knot(int i) const;

const MGKnotVector& knot_vector() const;
MGKnotVector& knot_vector();

double length(double t1, double t2) const;

double length() const;

double length_param(double t, double len) const;

MGStraight& limit(const MGInterval& );

MGStraight& limit(const MGBox& box);

MGPosition nearest_to_origin() const;

void negate();

double negate_param(double t)const;

MGPvector<MGCurve> offset(
    double ofs_value,                       
    const MGVector& norm_vector = mgNULL_VEC
)const;

bool on(
    const MGPosition&,  
    double&             
)const;

bool on(
    const MGPlane&      
)const;

int order() const{return 2;};

double param (
    const MGPosition &
) const;

double param_e() const{return m_endparam.value();};

double param_error() const;

double param_normalize(double t) const;

MGInterval param_range() const;

double param_s() const{return m_sparam.value();};
    
MGStraight* part(
    double t1, 
    double t2, 
    int multiple=0  
) const;

double perp_param(
    const MGPosition &      
) const;

int perp_point(
    const MGPosition &,     
    double& d1,             
    const double* d2=NULL   
) 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 MGSurfCurve& crv2)const;
MGPosition_list perps(const MGBSumCurve& crv2)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;

double range(double) const;

//Return two straight line's relationship.
//Whe two are parallel, MGPSREL_PARALLEL or MGPSREL_COIN will be returned.
//MGPSREL_PARALLEL takes place when no overlapping part exists, and 
//MGPSREL_COIN when some parts overlaps.
//MGPSREL_ISECT when they have an intersection.
//MGPSREL_VIRTUAL_ISECT when there is an intersection at extended part of the lines.
//MGPSREL_TORSION when the two do not lie on a same plane.
MGPSRELATION relation(
    const MGStraight& sl2,
    MGCCisect& ip
) const;
    
MGPSRELATION relation(
    const MGPlane &,    
    MGCSisect &     
) const;

const MGPosition& root_point() const{return m_root_point;};

int sdim() const;

MGStraight& set_straight(
    MGSTRAIGHT_TYPE type,   
    const MGVector& vec,                
    const MGPosition & = mgORIGIN           
);

const MGVector& sl_direction()const{return m_direction;}

const MGEReal& start() const{ return m_sparam;};

MGPosition start_point() const;

MGSTRAIGHT_TYPE straight_type() const;

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

MGCURVE_TYPE type() const{return MGCURVE_STRAIGHT;};

MGCurve& unlimit();

MGCurve& unlimit_end();

MGCurve& unlimit_start();

//Update the root point of this straight.
void update_root(const MGPosition& rootP);

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

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

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

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:


    MGPosition      m_root_point;
    MGVector        m_direction;
    MGEReal         m_sparam;   
    MGEReal         m_endparam; 
    mutable MGKnotVector* m_knotV;

MGBox* compute_box() const;

MGPosition closestSL(const MGStraight& straight2)const;

bool isect2D(const MGStraight& l2, double& t,double& s) const;

MGCCisect_list isect_withC1LB(const MGLBRep& curve2)const;

MGCCisect_list isect_with_noCompoSC(const MGSurfCurve& curve2)const;

MGPosition_list relation_parallel(const MGStraight& line2) const;

void save_length_zero();

//Compute two straight lines relationship of parallel or coincidence.
//Parallelness of the two is assumed.
//Obtain the relationship when two lines coinside.
//ip of a intersection or nearest point will be returned.
//When this and s do not coincide, MGPSREL_PARALLEL will be returned as
//the function's return value.
MGPSRELATION relation_coincide(const MGStraight& s, MGCCisect& ip)const;

//relation_coincide when this is MGSTRAIGHT_SEGMENTt.
MGPSRELATION relation_coincide1(
    const MGStraight& sl2,
    MGCCisect& ip
)const;

friend class MGCylinder;

};
 // end of GEO group
#endif