CompositeCurve.h

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

#include <deque>
#include "mg/Interval.h"
#include "mg/Position_list.h"
#include "mg/Straight.h"
#include "mg/RLBRep.h"
#include "mg/Ellipse.h"
#include "mg/LBRep.h"
#include "mg/SurfCurve.h"
#include "mg/BSumCurve.h"

class MGPlane;
class MGIgesDirectoryEntry;
class MGSurfCurve;
class MGStraight;
class MGCompositeCurve;
class mgVBO;


class MG_DLL_DECLR MGCompositeCurve:public MGCurve{

public:
typedef std::deque<MGCurve*> container_type;
typedef container_type::iterator iterator;
typedef container_type::const_iterator const_iterator;
typedef container_type::reverse_iterator reverse_iterator;
typedef container_type::const_reverse_iterator const_reverse_iterator;

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


MGCompositeCurve(){;};              

explicit MGCompositeCurve(MGCurve* crv);

MGCompositeCurve(const MGCompositeCurve&);

~MGCompositeCurve();


MGCompositeCurve& operator=(const MGGel& gel2);
MGCompositeCurve& operator=(const MGCompositeCurve& original);

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

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

bool is_same_curve(const MGCurve& curve2)const;
bool operator==(const MGCompositeCurve& gel2)const;
bool operator==(const MGGel& gel2)const;
bool operator==(const MGTrimmedCurve& gel2)const;
bool operator<(const MGCompositeCurve& 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;

const_iterator begin()const{return m_composite.begin();};
iterator begin(){return m_composite.begin();};

MGBox box_limitted(
    const MGInterval& 
) const;

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

void change_range(
    double t0,  
    double t1   
);

double closest(const MGPosition& point) const;

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

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

MGInterval connect(MGCurve* add_curve);
MGInterval connect_to_end(MGCurve* add_curve);
MGInterval connect_to_start(MGCurve* add_curve);

MGCompositeCurve& coordinate_exchange(int i, int j);

MGCompositeCurve* clone() const;

MGCurve* copy_as_nurbs() const;

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

const MGCurve& curve(int i)const{return *(m_composite[i]);};
MGCurve& curve(int i){return *(m_composite[i]);};

double curvilinear_integral(double t1, double t2) const;

double curvilinear_integral() const;

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

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

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

const_iterator end()const{return m_composite.end();};
iterator end(){return m_composite.end();};

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

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

int find(double t, bool right_continuous=true) const;

long identify_type() const;

bool is_planar(MGPlane& plane)const;

MGCCisect_list isect(const MGCurve& crv2) 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;
MGCCisect_list isect(const MGTrimmedCurve& curve2)const;
MGCCisect_list isect(const MGCompositeCurve& 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) const;

const MGKnotVector& knot_vector() const;

double length(double t1, double t2) const;
double length()const{return MGCurve::length();}

MGCompositeCurve& limit(const MGInterval& rng);

void negate();

double negate_param(double t)const;

int number_of_curves()const{return int(m_composite.size());};

//****Offset of CompositeCurve is CompositeCurve of the offsets of each
//member curves********

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

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

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

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

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

int order() const;

double param_e() const;

double param_normalize(double t) const;

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

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

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

MGPosition_list perps(const MGCurve& crv2)const{return perps_1by1(crv2);};
MGPosition_list perps(const MGStraight& crv2)const{return perps_1by1(crv2);};
MGPosition_list perps(const MGRLBRep& crv2)const{return perps_1by1(crv2);};
MGPosition_list perps(const MGEllipse& crv2)const{return perps_1by1(crv2);};
MGPosition_list perps(const MGLBRep& crv2)const{return perps_1by1(crv2);};
MGPosition_list perps(const MGSurfCurve& crv2)const;
MGPosition_list perps(const MGBSumCurve& crv2)const{return perps_1by1(crv2);};

MGCParam_list perps(
    const MGPosition& P     
) const;

void polygonize(
    double error,   
    MGLBRep& lb2    
)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;

size_t project_onto_surface(
    const MGFSurface& srf,
    MGPvector<MGCurve>& vec_crv_uv, 
    MGPvector<MGCurve>& vec_crv,
    const MGVector& vec
)const;

MGCurve* release_back();

MGCurve* release_front();

void remove_knot();

int sdim() const;

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

MGCURVE_TYPE type() const{return MGCURVE_COMPOSITE;};

MGCurve& unlimit();

MGCurve& unlimit_end();

MGCurve& unlimit_start();

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

int out_to_IGES(
    MGIgesOfstream& igesfile,
    int SubordinateEntitySwitch=0
)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 "CompositeCurve";};

private:

    container_type m_composite; 

MGBox* compute_box() const;

int intersect_dnum() const;

MGCCisect_list isect_1by1(const MGCurve& crv2) const;

MGCSisect_list isect_1by1(const MGSurface& surf) const;

MGPosition_list perps_1by1(
    const MGCurve& crv2     
)const;

friend class MGHHisect;

};
 // end of GEO group
#endif