Ellipse.h

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

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

// MGEllipse.h
// header for class MGEllipse
//

class MGInterval;
class MGMatrix;
class MGTransf;
class MGCCisect_list;
class MGPosition_list;
class MGLBRep;
class MGStraight;
class MGIfstream;
class MGOfstream;
class MGKnotVector;
class MGIgesDirectoryEntry;


class MG_DLL_DECLR MGEllipse : public MGCurve {

public:

MG_DLL_DECLR friend MGEllipse operator+ (const MGVector& v, const MGEllipse& e);
MG_DLL_DECLR friend MGEllipse operator* (double scale, const MGEllipse& el);


MGEllipse();

MGEllipse(const MGEllipse& el, bool to_radian=false);

MGEllipse (int sdim     
    , const MGEllipse& ellip
    , int start1=0      
    , int start2=0      
);

MGEllipse (
    const MGPosition& center,   
    const MGVector& major_axis, 
    const MGVector& minor_axis, 
    const MGInterval& prange    
);

MGEllipse (
    const MGPosition& center,   
    double r,                   
    const MGVector& normal=mgZ_UVEC 
);

MGEllipse (
    const MGPosition& center    
    , const MGPosition& spoint  
    , double d= mgDBLPAI        
    , const MGVector& v=mgZ_UVEC
);

MGEllipse(
    const MGPlane&    plane, 
    const MGPosition& corner1, 
    MGPosition&       corner2
);

MGEllipse(
  double r,     
  const MGPosition& start,
  const MGPosition& end,
  const MGVector& N,
  bool whole_circle=false       
);

MGEllipse(
  double r,     
  const MGPosition& start,
  const MGPosition& end,
  const MGPosition& reference,
  bool whole_circle=false       
 );

MGEllipse (
    const MGPosition &P     
    , const MGVector & V1   
    , const MGVector & V2   
    , double d              
);

MGEllipse (
    const MGPosition& start,    
    const MGPosition& through,  
    const MGPosition& end,      
    bool whole_circle=false     
);

MGEllipse(
    const MGPosition& center,   
    const MGPosition& start,    
    const MGPosition& end,      
    const MGVector& N,          
    bool whole_circle=false     
);

MGEllipse(
    const MGPosition& start,
    const MGPosition& end,
    const MGVector& dir_s,
    bool whole_circle=false 
);

MGEllipse (
    const MGCurve& crv1,            
    const MGCurve& crv2,            
    const MGUnit_vector& normal,    
    double dRadius,                 
    double& t1,                     
    double& t2,                     
    int& rc                         
);

MGEllipse (
    const MGCurve&          crv1,   
    const MGCurve&          crv2,   
    const MGUnit_vector&    normal, 
    double                  t1,     
    double&                 t2,     
    int&                    rc  
);

MGEllipse (
    const MGCurve&          crv1,   
    const MGCurve&          crv2,   
    const MGCurve&          crv3,   
    const MGUnit_vector&    normal, 
    double&                 t1,     
    double&                 t2,     
    double&                 t3,     
    int&                    rc  
);

MGEllipse (
    const MGCurve&          crv,    
    const MGPosition&       pos,    
    const MGUnit_vector&    normal, 
    double                  dRadius,
    double&                 dParam, 
    int&                    rc  
);

MGEllipse (
    const MGCurve& crv,     
    const MGPosition& P2,   
    const MGUnit_vector& normal,
    double t                
);

MGEllipse(
    const MGIgesDirectoryEntry& de  
);

~MGEllipse();


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

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

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

bool operator==(const MGEllipse& gel2)const;
bool operator==(const MGGel& gel2)const;
bool operator<(const MGEllipse& gel2)const;
bool operator<(const MGGel& gel2)const;


int bdim() const {return 2;};

MGBox box_limitted( const MGInterval&) const;

MGPosition center()const{return m_center;};

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

void change_param_to_radian();

void change_range(
    double t1,  
    double t2   
);  

bool circle() const {return m_circle!=0;};

MGEllipse* clone() const;

MGCurve* copy_as_nurbs() const;

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

MGEllipse& coordinate_exchange(int i, int j);

bool create_ellipse(
    const MGPosition& F0,
    const MGPosition& F1,
    const MGPosition& P
    );

double curvilinear_integral(double t1, double t2) const; 

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

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

MGELLIPSE_TYPE ellipse_type()const;

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

MGVector eval_deriv ( double ) const;

void eval_all (
    double d,   
    MGPosition& p,  
    MGVector& v1,   
    MGVector& v2    
) const;

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

MGVector eval_in_degree(
        double degree,  
        int nderiv=0    
) const;

MGPosition eval_position(double t)const{
    t=range(t);
    return eval_in_radian2(gp_to_radian(t));
};

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

double gp_to_radian(double t)const{
    if(param_range_is_in_radian())
        return t;
    return m_prange[0]+(t-m_gprange[0])*m_gprange[2];
}

long identify_type() const;

bool in_RelativeRange_of_radian(double t) const;

int intersect_dnum() const;

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

bool is_linear(MGStraight& straight)const;

bool is_planar(MGPlane& plane)const;

bool is_whole_ellipse()const;

double knot(int i) const;

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

MGEllipse& limit(const MGInterval& );

void negate();

double negate_param(double t)const;

MGCurve& unlimit();

MGCurve& unlimit_end();

MGCurve& unlimit_start();

double length(double t1, double t2) const;

double length() const;

double length_param(double t, double len) const;

const MGVector& major_axis() const {return m_m;};

double major_len() const {return m_m.len();};

const MGVector& minor_axis() const {return m_n;};

double minor_len() const {return m_n.len();};

const MGUnit_vector& normal() const {return m_normal;};

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

int order() const{return 2;};

double param_e() const{
    if(m_gprange) return m_gprange[1];
    else return m_prange[1];
};

double param_normalize(double t) const;

double param_s() const{
    if(m_gprange) return m_gprange[0];
    else return m_prange[0];
};

bool param_range_is_in_radian()const{return m_gprange==0;};

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

int perp_point (
    const MGPosition &p,
    double& d,          
    const double*g=NULL 
) const;            
    
MGCParam_list perps(
    const MGPosition &  
) const;

MGPosition_list perps(const MGCurve& crv2)const;
MGPosition_list perps(const MGStraight& crv2)const;

double radian_to_gp(double angle)const{
    if(!m_gprange) return angle;
    return m_gprange[0]+(angle-m_prange[0])/m_gprange[2];
}

double radius()const{return m_r;};

int sdim() const ;

void set_arc(
    const MGPosition& start,
    const MGPosition& end,
    const MGVector& dir_s
);

MGSurface* sweep(
    const MGUnit_vector& uvec,  
    double start_dist,          
    double end_dist         
) const;    
MGCURVE_TYPE type() const {return MGCURVE_ELLIPSE;};


std::ostream& out(std::ostream& ostrm) 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 "Ellipse";};

private:

    MGPosition  m_center;   
    MGUnit_vector m_normal; 
    MGVector    m_m;        
    MGVector    m_n;        
    double      m_r;    
    double  m_prange[2];
    int m_circle;   
    double* m_gprange;  
    mutable MGKnotVector* m_knotV;

int axis() const;

MGBox* compute_box() const;         

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

void copy_ellipse_data(const MGEllipse& ellipse2);

bool in_radian_range(double angle) const;

int isect2d(
    const MGPosition& sp,   
    const MGVector& dir,    
    double t[2],    
    double angle[2],    
    int& tangen         
) const;

int perp2d(double p,        
    double q,           
    double theta[4] 
) const;

double param_length(double p1, double p2) const;

double RelativeRange_in_radian(double angle) const;

void set_param(
    double a0,  
    double a1
);

void set_normal_r_c();

friend class MGCylinder;
friend class MGSphere;

};
 // end of GEO group
#endif