Cylinder.h

/********************************************************************/
/* Copyright (c) 2015 DG Technologies Inc. and Yuzi Mizuno          */
/* All rights reserved.                                             */
/********************************************************************/
#ifndef _MGCylinder_HH_
#define _MGCylinder_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"

// MGCylinder.h
// Header for class MGCylinder

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


class MG_DLL_DECLR MGCylinder :public MGSurface{

public:

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


MGCylinder(void);

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

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

MGCylinder(
    const MGPosition& bottom,   
    const MGVector axis,
    double radius,      
    bool outgoing=true  
);

MGCylinder(
    const MGEllipse& ellipse,   
    const MGStraight& axis      
);



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

MGCylinder operator+ (const MGVector& ) const;

MGCylinder operator- (const MGVector& ) const;

MGCylinder operator* (double) const;

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

MGCylinder operator* (const MGMatrix& ) const;

MGCylinder operator* (const MGTransf& ) const;

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

bool operator==(const MGCylinder& gel2)const;
bool operator==(const MGGel& gel2)const;
bool operator<(const MGCylinder& gel2)const;
bool operator<(const MGGel& gel2)const;
bool operator!=(const MGGel& gel2)const{return !(gel2==(*this));};
bool operator!=(const MGCylinder& 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;

MGPosition center() const;

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

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

MGPosition closest(const MGPosition& point) const;

MGCylinder* clone()const;

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

double distance(const MGPosition& point) const;

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

void eval_all(
    double u,
    double v,
    MGPosition& f,          
    MGVector&   fu,         
    MGVector&   fv,         
    MGVector&   fuv,        
    MGVector&   fuu,        
    MGVector&   fvv         
) const;

void eval_all(
    const MGPosition& uv,   
    MGPosition& f,          
    MGVector&   fu,         
    MGVector&   fv,         
    MGVector&   fuv,        
    MGVector&   fuu,        
    MGVector&   fvv         
) const{ eval_all(uv(0),uv(1),f,fu,fv,fuv,fuu,fvv);}

MGSurface& exchange_uv();

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

long identify_type() const;

bool in_range(double u, double v) const;
bool in_range(const MGPosition& uv) const{return in_range(uv[0], uv[1]);};

int intersect_dnum_u() const{ return m_ellipse.intersect_dnum();};
int intersect_dnum_v() const{ return m_axis.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_ellipse.knot(i);};
double knot_v(int j)const{return m_axis.knot(j);};

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

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

void negate(
    int is_u    
);

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

const MGEllipse& ellipse() const{return m_ellipse;};

const MGStraight& axis() const{return m_axis;};

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

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

bool on_a_perimeter(
    double& u,  
    double& v,  
    int& perim_num  
)const;

double param_error() const;

double param_e_u() const{return m_ellipse.param_e();};
double param_e_v() const{return m_axis.param_e();};

MGBox param_range() const;

double param_s_u() const{return m_ellipse.param_s();};
double param_s_v() const{return m_axis.param_s();};

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

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

MGPosition range(const MGPosition& uv) const;

int sdim() const;

MGSURFACE_TYPE type() const{return MGSURFACE_CYLINDER;}

protected:

bool flat(
    const MGBox& uvbox,
    double tol,     
    int& direction, 
    MGPosition& P,  
    MGUnit_vector& N
)const;

bool flat_tess(
    double u0,  
    double u1,  
    double v0,  
    double v1,  
    double tol,     
    bool& direction,
    double max_edge_len
)const;

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

int vrange(const MGPosition& P, double& v)const;

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

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

private:

    MGEllipse   m_ellipse;  
    MGStraight  m_axis;     
    bool m_ortho;

MGPosition axis_point(double v)const;

MGBox* compute_box() const;

int isect_area_length() const{return 10;};

int isect_direction(
    const MGFSurface& sf2,  
    int m1,     
    MGPosition& uvuvS,
    double& du, 
    double& dv, 
    double acuRatio=1.  
)const;

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;

void isect_inner_dt(
    int n,              
    const MGPosition& uvnow,
    double& du, double& dv, 
    int& kdt,   
    double acuRatio=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;};

};
 // end of GEO group
#endif