Curve.h

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

#include <vector>
#include <memory>
#include "mg/MGCL.h"
#include "mg/Default.h"
#include "mg/Position.h"
#include "mg/Geometry.h"
#include "mg/FSurface.h"
#include "mg/Pvector.h"
#include "mg/KnotVector.h"
#include "mg/CCisect_list.h"
#include "mg/CSisect_list.h"

//
//Define MGCurve Class.

class MGInterval;
class MGBox;
class MGVector;
class MGUnit_vector;
class MGPosition_list;
class MGTransf;
class MGCParam_list;
class MGPoint;
class MGStraight;
class MGEllipse;
class MGLBRep;
class MGRLBRep;
class MGSurfCurve;
class MGBSumCurve;
class MGTrimmedCurve;
class MGCompositeCurve;
class MGSurface;
class MGPlane;
class MGSphere;
class MGCylinder;
class MGSBRep;
class MGRSBRep;
class MGBSumSurf;
class MGCCisect_list;
class MGCSisect_list;
class MGIfstream;
class MGOfstream;
class MGFace;
class MGShell;
class MGCFisect_vector;
class MGPPRep;
class MGCommonON;
class mgVBO;
class MG_DLL_DECLR MGCurve:public MGGeometry{

public:


MGCurve();

MGCurve(const MGCurve& curve);

virtual ~MGCurve();



virtual MGCurve& operator=(const MGCurve& gel2){MGGeometry::operator=(gel2);return *this;};


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

virtual bool operator==(const MGCompositeCurve& crv)const;
virtual bool operator==(const MGTrimmedCurve& crv)const;
virtual bool operator==(const MGGel& gel2)const=0;
virtual bool operator<(const MGGel& gel2)const=0;



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


void arrow(double t,MGPosition data[4])const;

virtual int bdim() const=0;


virtual MGBox box_limitted(
    const MGInterval& 
) const = 0;

virtual int calc_div_num(
    const MGInterval& interval)
const{return this->offset_div_num(interval);};

virtual MGPosition center() const;

virtual MGPosition center_param() const;

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


virtual void change_range(
    double t1,  
    double t2   
)=0;


virtual MGCurve* clone()const=0;

virtual double closest(const MGPosition& point) const;

virtual double closest2D(const MGPosition& point) const;


virtual MGPosition closest(const MGCurve& curve2) const;


bool cn_continuity(int n)const;


virtual int common(
    const MGCurve& curve2,
    std::vector<double>& vecComSpan,
    MGCCisect_list& isect
) const;


virtual int common(
    const MGCurve& curve2,
    std::vector<double>& vecComSpan
) const;


virtual MGCurve& coordinate_exchange(int i, int j)=0;


virtual MGCurve* copy_as_nurbs() const=0;


virtual void convert_to_Bezier(MGLBRep& bezier)const;


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


virtual MGCurve* copy_limitted(const MGInterval& prange) const;


virtual double curvature( double ) const;

MGCurve* curve(){return this;};
const MGCurve* curve()const{return this;};


virtual double curvilinear_integral(double t1, double t2) const;
virtual double curvilinear_integral() const{
    return curvilinear_integral(param_s(), param_e());
};

virtual double deriv_length()const;

MGUnit_vector direction(const MGPosition& param) const;


virtual MGUnit_vector direction(double) const;

virtual void display_arrows(mgSysGL& sgl)const;
virtual void display_break_points(mgSysGL& sgl)const;
virtual void display_curvatures(
    mgSysGL& sgl,
    double  scale,  
    int     density,
    bool    use_radius
)const;


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

int divide_number() const{return offset_div_num(param_range());};

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

virtual void drawWire(
    mgVBO& vbo,
    double span_length, 
    int line_density=1  
)const{drawSE(vbo,span_length,param_s(),param_e());};

virtual MGPosition end_point() const;


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


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


virtual MGVector eval_deriv(double) const;


void eval_discrete_deviation(
    const MGCurve& curve2,
    std::vector<MGPosition>& sts,
    int npoint=20,      
    double tolerance=0.1
)const;

virtual void eval_line(
    const MGNDDArray& tau,  
    MGBPointSeq& value      
)const;


virtual MGPosition eval_position(double) const;

MGVector evaluate(
    const MGPosition& t,    
    const int* nderiv=0 
) const;


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

virtual void Frenet_frame2(
    double t,           
    MGVector& V2,
    MGVector& T,
    MGVector& N,
    MGVector& B 
)const;

virtual void Frenet_frame(
    double t,           
    MGUnit_vector& T,   
    MGUnit_vector& N,   
    MGUnit_vector& B,   
    double& curvature,  
    double& torsion     
)const;


double get_average_tangent_length()const;


virtual bool get_control_points(
    MGBPointSeq& cpoints    
)const{return false;};

void getParamsC0Continuity(std::vector<double>& param)const;


bool has_same_direction_at(
    double s,
    const MGCurve& curve2,
    double t
)const;

virtual long identify_type() const=0;

virtual bool in_range(double t) const;

bool in_range(const MGPosition& t) const;


MGCCisect_list intersect_brute_force(const MGCurve&) const;


virtual MGCCisect_list intersect(const MGCurve&) const;


MGisects intersection(const MGObject& obj2)const;
MGisects intersection(const MGCurve& obj2)const;
MGisects intersection(const MGFSurface& obj2)const;
MGisects intersection(const MGSurface& obj2)const;
MGisects intersection(const MGFace& obj2)const;
MGisects intersection(const MGShell& obj2)const;

virtual int intersect_dnum()const=0;

MGCSisect_list intersect_with_plane(const MGPlane& surf)const;

virtual MGCCisect_list isect(const MGCurve& curve2)const=0;
virtual MGCCisect_list isect(const MGStraight& curve2)const=0;
virtual MGCCisect_list isect(const MGRLBRep& curve2)const;
virtual MGCCisect_list isect(const MGEllipse& curve2)const;
virtual MGCCisect_list isect(const MGLBRep& curve2)const;
virtual MGCCisect_list isect(const MGSurfCurve& curve2)const=0;
virtual MGCCisect_list isect(const MGBSumCurve& curve2)const;
MGCCisect_list isect(const MGTrimmedCurve& curve2)const;
MGCCisect_list isect(const MGCompositeCurve& curve2)const;

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

MGCSisect_list isect(const MGFSurface& fs)const{return fs.isect(*this);};
virtual MGCSisect_list isect(const MGFace&)const;

MGCFisect_vector isect(const MGShell& shl) const;


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


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


bool is_closed()const{return start_point()==end_point();};

bool is_closedWithError(double err)const;


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

virtual bool is_startpoint_parameter(double t)const;

virtual bool is_endpoint_parameter(double t)const;


bool is_perpendicular(const MGPosition& P, double t)const;


virtual bool is_linear(MGStraight& straight)const;


virtual bool is_planar(MGPlane& plane)const;

virtual double knot(int i) const=0;
    
virtual const MGKnotVector& knot_vector() const=0;

MGKnotVector& knot_vector();


virtual double length(double t1, double t2) const;


virtual double length() const {return length(param_s(), param_e());}


virtual double length_param( double t, double len) const;


virtual MGCurve& limit(const MGInterval& rng) = 0;
MGCurve& limit(double t0, double t1);

int manifold_dimension() const{ return 1;};

virtual void negate() = 0;

virtual double negate_param(double t)const= 0;

void negate_transform(MGGeometry& boundary)const;


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


virtual MGPvector<MGCurve> offset(
    const MGLBRep& ofs_value_lb,                
    const MGVector& norm_vector = mgNULL_VEC    
) const;


virtual MGLBRep offset_c2(
    double ofs_value,                           
    const MGVector& norm_vector = mgNULL_VEC    
) const;


virtual MGLBRep offset_c2(
    const MGLBRep& ofs_value_lb,                
    const MGVector& norm_vector = mgNULL_VEC    
) const;

virtual int offset_div_num(
    const MGInterval& interval  
)const;


virtual bool on(
    const MGPosition& point,
    double& t   
) const;


bool on(
    const MGPosition& P,
    MGPosition& t       
) const;

virtual int order() const=0;


virtual double param(
    const MGPosition &  
) const;

virtual double param_e() const=0;

virtual double param_error() const;

virtual double param_normalize(double t) const=0;

virtual MGInterval param_range() const;

double param_round_into_range(double t)const;

MGBox parameter_range() const;

virtual double param_s() const=0;

double param_se(double t) const;

virtual double param_span() const{return param_e()-param_s();};


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


virtual int perp_guess(
    double t0,  
    double t1,  
    const MGPosition& P,    
    double tg,              
    double& t               
) const;


virtual int perp_guess(
    double s0,  
    double s1,  
    const MGCurve& curve2,  
    double t0,  
    double t1,  
    double sg,  
    double tg,  
    MGPosition& st  
) const;


virtual int perp_point(
    const MGPosition& p,    
    double& t,              
    const double* g=0       
) const;


MGPosition_list perpendiculars(
    const MGCurve& crv      
) const;


virtual MGCParam_list perps(
    const MGPosition& P     
) const;


virtual MGPosition_list perps(const MGCurve& crv2)const=0;
virtual MGPosition_list perps(const MGStraight& crv2)const=0;
virtual MGPosition_list perps(const MGRLBRep& crv2)const;
virtual MGPosition_list perps(const MGEllipse& crv2)const;
virtual MGPosition_list perps(const MGLBRep& crv2)const;
virtual MGPosition_list perps(const MGSurfCurve& crv2)const;
virtual MGPosition_list perps(const MGBSumCurve& crv2)const;
MGPosition_list perps(const MGCompositeCurve& crv2)const;
MGPosition_list perps(const MGTrimmedCurve& crv2)const;


virtual MGPosition pick_closest(const MGStraight& sl)const;


virtual void polygonize(
    double error,   
    MGLBRep& lb2    
)const;



//曲線を面に面直またはベクトル投影して曲線リストを求める。
//戻り値：
virtual 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;


virtual double range(double t) const;


MGPosition range(const MGPosition& t) const;

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


virtual void remove_knot();


virtual MGCurve& rotate_self(
    const MGVector& v,          
    double,                     
    const MGPosition & = mgORIGIN   
);


std::auto_ptr<MGLBRep> scalePolar(
    double angleBase,
    double angle1,  
    double angle2   
)const;

virtual int sdim() const =0 ;

virtual MGPosition start_point() const;


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


virtual int tangent_guess(
    double t0,
    double t1,
    const MGPosition& P,    
    double tg,              
    double& t               
)const;


void trim_end(double t);


void trim_start(double t);


void trim_start_and_end(double ts, double te);

virtual MGCURVE_TYPE type() const =0;

virtual MGCurve& unlimit() =0;


virtual MGCurve& unlimit_end() =0;


virtual MGCurve& unlimit_start() =0;


virtual std::auto_ptr<MGLBRep> PolarCoordinatesLBRep()const;

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

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

protected:


virtual void ReadMembers(MGIfstream& buf);


virtual void WriteMembers(MGOfstream& buf) const;


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


void approximate_as_LBRep2(
    MGLBRep& lb,        
    int order,      
    int is,
    int ie,
    bool neglectMulti=false
)const;

virtual void data_points_for_approximate_as_LBRep2(
    int is,
    int ie,
    MGKnotVector& t,
    MGNDDArray& tau,
    bool neglectMulti=false
)const;

void extrapolated_pp(
    double tau,     
    double dk,     
    MGPPRep& pp   
)const;

virtual MGCCisect_list isect_withC1LB(const MGLBRep& curve2)const;

virtual MGCCisect_list isect_with_noCompoSC(const MGSurfCurve& curve2)const;


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


virtual MGPosition_list perps_withC1LB(
   const MGLBRep& lbC1
)const;


virtual MGPosition_list perps_with_noCompoSC(const MGSurfCurve& curve2)const;


MGPosition_list perpsSl(
    const MGStraight& sl    
)const;

virtual void update_mark(){ MGGeometry::update_mark();}

private:

int common_one_span(
    const MGCurve& curve2,
    MGCommonON SEon[2],
    MGCommonON &sparam, 
    double span,    
    double comSpan[4]
)const;

void common_boundary(
    const MGCurve& curve2,
    const MGCommonON& onparam,
    const MGCommonON& offparam,
    double& param1, double& param2
)const;

virtual MGBox* compute_box() const=0;

int offset_norm_proc(
    const MGLBRep& ofs_value_lb,        
    const MGVector& norm_vector,        
    MGPvector<MGCurve>& ofs_crvl    
)const;

int offset_proc(
    const MGLBRep& ofs_value_lb,    
    MGPvector<MGCurve>& ofs_crvl    
)const;

int offset_norm_c2_proc(
    const MGLBRep& ofs_value_lb,    
    const MGVector& norm_vector,    
    MGLBRep& ofs_brep       
)const;

int offset_c2_proc(
    const MGLBRep& ofs_value_lb,    
    MGLBRep& ofs_brep,              
    MGUnit_vector& preN,            
    int& freverse           
)const;

int divide_multi_ofs(
    const MGLBRep& ofs_value_lb,        
    MGPvector<MGCurve>& brep_list       
)const;


MGKnotVector offset_make_knotvector(const MGLBRep& ofs_value_lb)const;

friend class MGFace;
friend class MGFSurface;
friend class MGSurface;
friend class MGLBRep;
friend class MGTrimmedCurve;
friend class MGSurfCurve;
friend class MGCompositeCurve;
friend class MGBSumCurve;

};

class MGCurveLengthDrive{
    const MGCurve* m_curve;
public:
    MGCurveLengthDrive(const MGCurve* curve):m_curve(curve){;};

    double operator()(double t) const;
};

class MGCurveLenParamDrive {
    const MGCurve* m_curve;
    double m_len, m_ts;
public:
    MGCurveLenParamDrive(const MGCurve* curve, double len, double ts)
        :m_curve(curve), m_len(len), m_ts(ts){;};
    double operator()(double t)const;
};

namespace MGCL{

extern double Curvature(
        const MGVector& v1,     
        const MGVector& v2  
);

extern double Torsion(
        const MGVector& v1,     
        const MGVector& v2,     
        const MGVector& v3  
);
    
void one_arrow(
    const MGPosition& root, 
    const MGVector& vecx,   
    const MGUnit_vector& vecy,
    MGPosition& head,       
    MGPosition& headtail1,  
    MGPosition& headtail2   
);

MG_DLL_DECLR MGRLBRep* convert_to_rational(const MGCurve& curve);

}
 // end of GEO group
#endif