SurfCurve.h

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

#include "mg/Default.h"
#include "mg/Curve.h"
#include "mg/Surface.h"
#include "mg/TrimmedCurve.h"

//
//Define MGSurfCurve Class.

class MGInterval;
class MGBox;
class MGVector;
class MGUnit_vector;
class MGPosition;
class MGPosition_list;
class MGTransf;
class MGCParam_list;
class MGStraight;
class MGEllipse;
class MGRLBRep;
class MGRSBRep;
class MGCCisect_list;
class MGCSisect_list;
class MGIfstream;
class MGOfstream;

class MG_DLL_DECLR MGSurfCurve:public MGCurve{

public:

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


MGSurfCurve():MGCurve(),m_surface(0){;};

MGSurfCurve(const MGSurfCurve& sc);

MGSurfCurve(
    const MGSurface& srf, 
    const MGCurve& crv  
); 

MGSurfCurve(
    const MGFSurface& srf, 
    const MGCurve& crv  
); 


public:

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

bool operator==(const MGSurfCurve& gel2)const;
bool operator==(const MGGel& gel2)const;
bool operator<(const MGSurfCurve& 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;

const MGCompositeCurve* base_composite()const;

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

const MGSurface* base_surface() const {return m_surface;};

int bdim() const    {return m_curve.bdim();}

MGBox box_limitted(
    const MGInterval & 
) const;

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

void change_range(
    double t1,      
    double t2   
){  assert(false);}

MGSurfCurve* clone() const;

MGCurve* copy_as_nurbs() const;

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

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

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

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

long identify_type() const;

bool in_range(double t) const;

int intersect_dnum() 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) const;
    
const MGKnotVector& knot_vector() const{return m_curve.knot_vector();}

MGSurfCurve& limit(const MGInterval& );

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

double param_e() const;

double param_normalize(double t) const;

MGInterval param_range() const;

double param_s() const;

MGSurfCurve* part(
    double t1,
    double t2,
    int multiple=0  
) 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 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 ;

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

MGCurve& unlimit();

MGCurve& unlimit_end();

MGCurve& unlimit_start();

MGCURVE_TYPE type() const;

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

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

protected:

std::auto_ptr<MGCurve> oneD(
    const double g[4]   
)const{assert(false); std::auto_ptr<MGCurve> tmpPtr; return tmpPtr;}

void ReadMembers(MGIfstream& buf);

void WriteMembers(MGOfstream& buf) const;

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

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

private:


    const MGSurface* m_surface;
    MGTrimmedCurve m_curve;

MGBox* compute_box() const;


MGSurfCurve& coordinate_exchange(int i, int j);

MGCCisect_list isect_noCompo(const MGCurve& curve2)const;

MGCCisect_list isect_noCompo(const MGStraight& curve2)const;

MGCCisect_list isect_noCompo(const MGSurfCurve& curve2)const;

MGCSisect_list isect_noCompo(const MGSurface& surf)const;

MGCSisect_list isect_noCompo(const MGPlane& surf)const;

void isect_of_each(
    const MGCurve& curve2,  
    MGCCisect_list& list    
)const;

void isect_of_each(
    const MGSurface& surf,  
    MGCSisect_list& list    
)const;

void negate();

double negate_param(double t)const;
MGPosition negate_param(const MGPosition& t)const;

MGPosition_list perps_noCompo(const MGCurve& curve2)const;

void perps_of_each(
    const MGCurve& curve2,  
    MGPosition_list& list   
)const;

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

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

friend class MGLBRep;
friend class MGStraight;
friend class MGPlane;
};
 // end of GEO group
#endif