TrimmedCurve.h

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

#include <vector>
#include "mg/Default.h"
#include "mg/Pvector.h"
#include "mg/Interval.h"
#include "mg/Box.h"
#include "mg/Position.h"
#include "mg/Position_list.h"
#include "mg/LBRep.h"
#include "mg/RLBRep.h"
#include "mg/Ellipse.h"
#include "mg/Straight.h"
#include "mg/BSumCurve.h"

//Define MGTrimmedCurve Class.

class MGInterval;
class MGBox;
class MGVector;
class MGUnit_vector;
class MGPosition;
class MGTransf;
class MGCParam_list;
class MGStraight;
class MGEllipse;
class MGCompositeCurve;
class MGKnotVector;
class MGLBRep;
class MGRLBRep;
class MGSurface;
class MGCCisect_list;
class MGCSisect_list;
class MGIfstream;
class MGOfstream;

class MG_DLL_DECLR MGTrimmedCurve:public MGCurve{

public:

MG_DLL_DECLR friend MGTrimmedCurve operator+ (const MGVector& v, const MGTrimmedCurve& cv2);
MG_DLL_DECLR friend MGTrimmedCurve operator* (double scale, const MGTrimmedCurve& cv2);


MGTrimmedCurve();
MGTrimmedCurve(const MGTrimmedCurve& tc);
MGTrimmedCurve(const MGCurve& crv, const MGInterval range);

MGTrimmedCurve(const MGCurve& crv, double t1, double t2);

~MGTrimmedCurve();


MGTrimmedCurve& operator=(const MGGel& gel2);
MGTrimmedCurve& operator=(const MGTrimmedCurve& el2);

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

MGBox box_limitted(
    const MGInterval& 
) const;

MGTrimmedCurve& change_dimension(
    int dim,        
    int start1,     
    int start2  
){
    assert(false);//This cannot be used.
    return *this;
}
void change_range(
    double t1,  
    double t2   
){
    assert(false);//The use is prohibitted.
}

MGCurve* clone() const;

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

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

MGCurve* copy_as_nurbs() const;

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

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

const MGCurve* base_curve() const {return m_curve;};

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 drawSE(
    mgVBO& vbo,
    double span_length, 
    double t0,          
    double t1           
)const;

MGVector eval(
    double t,           
    int nderiv=0,   
    int left=0          
)const{return m_curve->eval(t,nderiv,left);};

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

long identify_type() const;

bool in_range(double t) const{return m_range>>t;}

int intersect_dnum() const;

bool is_planar(MGPlane& plane)const;

bool is_same_range()const{return m_sameRange;};

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;
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;

#ifdef __sgi
    double length() const{return length(param_s(), param_e());}
#endif

double length_param( double t, double len) const;

MGTrimmedCurve& limit(const MGInterval& );

double negate_param(double t)const{return m_curve->negate_param(t);};

int order() const{return m_curve->order();}

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

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

double param_e() const;

double param_normalize(double t) const;

MGInterval param_range() const{return m_range;}

double param_s() const;
    
MGCurve* part(
    double t1,
    double t2,
    int multiple=0  
) const;
    
MGCParam_list perps(
    const MGPosition& P     
)const;

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

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 t) const;

int sdim() const{return m_curve->sdim();};

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

MGCURVE_TYPE type() const{return MGCURVE_TRIMMED;}

MGCurve& unlimit();

MGCurve& unlimit_end();

MGCurve& unlimit_start();

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

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:

    const MGCurve* m_curve; 
    mutable bool m_sameRange;
    MGInterval     m_range; 
    mutable MGKnotVector* m_knotV;

MGBox* compute_box()const;


MGTrimmedCurve& coordinate_exchange(int i, int j);

MGCCisect_list isect_in_range(const MGCurve& curve2)const;

MGCCisect_list isect_withC1LB(const MGLBRep& curve2)const;

MGCSisect_list isect_in_range(const MGSurface& surf)const;

void narrow_into_range(
    const MGCurve& curve2,
    std::vector<double>& vecComSpan
)const;

void negate();

MGPosition_list perps_in_range(
    const MGCurve& crv2     
)const;

void remove_knot();

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

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

friend class MGSurfCurve;
friend class MGLBRep;

};
 // end of GEO group
#endif