Sphere.h

/********************************************************************/
/* Copyright (c) 2015 DG Technologies Inc. and Yuzi Mizuno          */
/* All rights reserved.                                             */
/********************************************************************/
#ifndef _MGSphere_HH_
#define _MGSphere_HH_
#include "mg/Position.h"
#include "mg/Unit_vector.h"
#include "mg/CSisect_list.h"
#include "mg/Surface.h"
#include "mg/Ellipse.h"
#include "mg/Straight.h"

// MGSphere.h
// Header for class MGSphere

class MGTransf;
class MGStraight;
class MGSBRep;
class MGIfstream;
class MGOfstream;
class MGIgesOfstream;

class MG_DLL_DECLR MGSphere :public MGSurface{

public:

MG_DLL_DECLR friend MGSphere operator+ (const MGVector& v, const MGSphere& cyl);

MG_DLL_DECLR friend MGSphere operator* (double scale, const MGSphere& cyl);


MGSphere(void);

//Copy constructor.
//MGSphere(const MGSphere& cyl);

MGSphere(
    const MGPosition& cntr, 
    double radius       
);

MGSphere(
    const MGPosition& cntr, 
    double radius,          
    const MGUnit_vector& B, 
    const MGVector& M 
);

MGSphere(
    int dim,                
    const MGSphere& cyl,    
    int start1=0,       
    int start2=0        
);

MGSphere(
    const MGEllipse& ellipse    
);

MGSphere(
    const MGEllipse& ellipse,   
    MGInterval urange   
);



MGSphere& operator=(const MGGel& gel2);
MGSphere& operator=(const MGSphere& gel2);

MGSphere operator+ (const MGVector& ) const;

MGSphere operator- (const MGVector& ) const;

MGSphere operator* (double) const;

MGSphere operator* (const MGMatrix& ) const;

MGSphere operator* (const MGTransf& ) const;

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

bool operator==(const MGSphere& gel2)const;
bool operator==(const MGGel& gel2)const;
bool operator<(const MGSphere& gel2)const;
bool operator<(const MGGel& gel2)const;
bool operator!=(const MGGel& gel2)const{return !(gel2==(*this));};
bool operator!=(const MGSphere& gel2)const{return !(gel2==(*this));};

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

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


MGBox box_limitted(
    const MGBox& uvrange    
) const;

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

MGSphere& change_range(
    int is_u,       
    double t1,      
    double t2       
);

MGPosition closest(const MGPosition& point) const;

MGPosition closest_on_perimeter(const MGPosition& point)const;

MGSphere* clone() const;

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

bool degenerate_at_v0()const;

bool degenerate_at_v1()const;

double distance(const MGPosition& point) const;

const MGEllipse& ellipseu() const{return m_ellipseu;};
const MGEllipse& ellipsev() const{return m_ellipsev;};
MGEllipse& ellipseu(){return m_ellipseu;};
MGEllipse& ellipsev(){return m_ellipsev;};

MGVector eval(
    double u,   
    double v        
    , int ndu=0         
    , int ndv=0         
) const;

MGVector eval(
    const MGPosition& uv
    , int ndu=0         
    , int ndv=0         
)const{return eval(uv.ref(0),uv.ref(1),ndu,ndv);}

MGSurface& exchange_uv();

MGSphere& extend(
    int perimeter,  
    double param,   
    double length,  
    double dk=0.  
);

long identify_type() const;

bool in_range(double u, double v) const;

int intersect_dnum_u() const{ return m_ellipseu.intersect_dnum();};
int intersect_dnum_v() const{ return m_ellipsev.intersect_dnum();};

MGCSisect_list isect(const MGCurve& curve)const;
MGCSisect_list isect(const MGStraight& line)const{ return isectSl(line);};
MGCSisect_list isect(const MGRLBRep& curve)const;
MGCSisect_list isect(const MGEllipse& curve)const;
MGCSisect_list isect(const MGLBRep& curve)const;
MGCSisect_list isect(const MGSurfCurve& curve)const;
MGCSisect_list isect(const MGBSumCurve& curve)const;

MGSSisect_list isect(const MGSurface& srf2)const;
MGSSisect_list isect(const MGPlane& srf2)const;
MGSSisect_list isect(const MGSphere& srf2)const;
MGSSisect_list isect(const MGCylinder& srf2)const;
MGSSisect_list isect(const MGSBRep& srf2)const;
MGSSisect_list isect(const MGRSBRep& srf2)const;
MGSSisect_list isect(const MGBSumSurf& srf2)const;

double knot_u(int i)const{return m_ellipseu.knot(i);};
double knot_v(int j)const{return m_ellipsev.knot(j);};

const MGKnotVector& knot_vector_u() const{return m_ellipseu.knot_vector();};
MGKnotVector& knot_vector_u(){return m_ellipseu.knot_vector();};

const MGKnotVector& knot_vector_v() const{return m_ellipsev.knot_vector();};
MGKnotVector& knot_vector_v(){return m_ellipsev.knot_vector();};

const MGVector& M()const{return m_ellipseu.major_axis();};
const MGVector& N()const{return m_ellipseu.minor_axis();};
const MGVector& B()const{return m_ellipsev.minor_axis();};
const MGPosition& C()const{return m_ellipsev.m_center;};

void negate(int is_u);

MGPosition negate_param(const MGPosition& uv, int is_u=1)const;

std::auto_ptr<MGSurface> offset_c1(
    double ofs_value,   
    int& error  
)const;

bool on(
    const MGPosition& point,
    MGPosition& puv         
)const;

bool outgoing()const;

double param_error() const;

double param_e_u()const{return m_ellipseu.param_e();};
double param_e_v()const{return m_ellipsev.param_e();};

MGBox param_range()const;

double param_s_u()const{return m_ellipseu.param_s();};
double param_s_v()const{return m_ellipsev.param_s();};

    MGCurve* parameter_curve(
    int is_u                
    , double x              
)const;

MGSphere* part(
    const MGBox& bx,
    int multiple=0  
)const;

MGCurve* perimeter_curve(int i)const;

int perimeter_num()const{return 4;};

int perp_point(
    const MGPosition& P,
    MGPosition& uv,     
    const MGPosition* uvguess=NULL  
)const;

MGPosition_list perps(
    const MGPosition& P             
)const;

double radius()const{return m_ellipseu.radius();};

MGPosition range(const MGPosition& uv) const;

int sdim() const;

bool sphere() const{return m_ellipseu.circle();};

const MGPosition& sphere_center()const{return m_ellipsev.m_center;};

MGSURFACE_TYPE type() const{return MGSURFACE_SPHERE;}

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

protected:

MGCSisect_list isectSl(
    const MGStraight& sl,
    const MGBox& uvbox=mgNULL_BOX 
)const;

void ReadMembers(MGIfstream& buf);
    
void WriteMembers(MGOfstream& buf) const;

private:

    MGEllipse  m_ellipseu;
    MGEllipse  m_ellipsev;

void box_driver(MGBox& bx)const;

void box_uconst(MGBox& bx, double u)const;

void box_vconst(MGBox& bx, double v)const;

MGBox* compute_box() const;

int isect_area_length() const{return 10;};

void isect_dt(
    double u, double v, double& du, double& dv,
    double acuRatio=1.  
) const;

MGCurve* isect_incr_pline(
    const MGPosition& uv,   
    int kdt,                
    double du, double dv,
    double& u,              
    double& v,              
    int incr=1      
) const;

int isect_order() const{return 4;}

MGSSisect_list intersectPl(const MGPlane& pl) const;

int offset_div_num() const{return 1;};

MGSBRep* surf1D(const MGPlane& plane)const{assert(false);return 0;};

void compute_uv(const MGPosition& P, double&u, double&v)const;

};
 // end of GEO group
#endif