Plane.h

/********************************************************************/
/* Copyright (c) 2015 DG Technologies Inc. and Yuzi Mizuno          */
/* All rights reserved.                                             */
/********************************************************************/
#ifndef _MGPlane_HH_
#define _MGPlane_HH_
#include "mg/drawParam.h"
#include "mg/Position.h"
#include "mg/Unit_vector.h"
#include "mg/Surface.h"
#include "mgGL/VBO.h"

// MGPlane.h
// Header for class MGPlane
class MGBPointSeq;
class MGCCisect;
class MGCSisect;
class MGTransf;
class MGStraight;
class MGSBRep;
class MGIfstream;
class MGOfstream;
class MGFace;

class MG_DLL_DECLR MGPlane :public MGSurface{

public:

MG_DLL_DECLR friend MGPlane operator+ (const MGVector& v, const MGPlane& pl);
MG_DLL_DECLR friend MGPlane operator* (double scale, const MGPlane& pl);


MGPlane(void);

MGPlane(const MGPlane& pl);

MGPlane(
    int dim,            
    const MGPlane& plane,
    int start1=0,       
    int start2=0        
); 

MGPlane(
    const double g[4],  
    const double* root_point=0
);

MGPlane(
    const MGUnit_vector& normal,
    double d            
);

MGPlane(
    const MGUnit_vector& normal,
    const MGPosition& p
);

MGPlane(
    const MGStraight& st,
    const MGPosition& point
);

MGPlane(
    const MGVector& uderiv,
    const MGVector& vderiv,
    const MGPosition &origin
);

MGPlane(
    const MGPlane& plane1,
    const MGPlane& plane2,
    double t    
);

MGPlane(
    const MGPosition& P1,
    const MGPosition& P2,
    const MGPosition& P3
);

~MGPlane();


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

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

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

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

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


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


void abcd(double g[4]) const;

MGBox box_limitted(
    const MGBox& uvrange    
) const;

virtual MGPosition center() const{return m_root_point;};

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

MGPlane& change_range(
    int is_u,               
    double t1,              
    double t2               
){return *this;};

void change_root_point(
    const MGPosition& new_point
);


MGPosition closest(const MGPosition& point) const;

MGPlane* clone() const;

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

void display_arrows(mgSysGL& sgl)const;

double distance() const{return m_d;};

double distance(const MGPosition& point) const;

virtual void drawWire(
    mgVBO& vbo,
    double span_length, 
    int line_density=1  
)const{drawWirePlane(vbo,span_length,line_density,mgVBO::WIRE);};

void drawWirePlane(
    mgVBO& vbo,
    double span_length, 
    int line_density=1, 
    mgVBO::ELEMENT_TARGET target=mgVBO::WIRE
)const;

virtual void shade(
    mgVBO& vbo,
    const MGDrawParam& para,
    mgVBO::ELEMENT_TARGET target=mgVBO::SHADING
)const{drawWirePlane(vbo,para.span_length_wire(),1,target);};

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;

MGSurface& exchange_uv();

long identify_type() const;

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

int intersect_dnum_u() const{ return 2;};
int intersect_dnum_v() const{ return 2;};

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

int isect_startHPL(
    const MGPosition& uvuv_startIn, 
    MGPosition_list& uvuv_list, 
    const MGSurface& sf2,   
    MGSSisect& ssi,         
    MGPosition_list::iterator& uvuv_id
) const;

double knot_u(int)const ;
double knot_v(int)const ;

const MGKnotVector& knot_vector_u() const;
MGKnotVector& knot_vector_u();

const MGKnotVector& knot_vector_v() const;
MGKnotVector& knot_vector_v();

virtual void make_display_list(
    MGCL::VIEWMODE vmode=MGCL::DONTCARE
)const;

void negate(
    int is_u
);

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

MGVector normal(double u, double v) const{return m_normal;}
MGVector normal(const MGPosition& uv) const{return m_normal;}
const MGUnit_vector& normal() const{return m_normal;}

void normalize();

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

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

bool on(const MGStraight&) const;

bool on_a_perimeter(
    double& u,
    double& v,
    int& perim_num  
)const{return false;};

bool on_the_perimeter(
    int perim_num,  
    double u,   
    double v    
)const{return false;};

MGPosition param(
    const MGPosition&   
) const;

double param_error() const;
double param_error_u() const;
double param_error_v() const;

virtual double param_e_u() const{return mgInfiniteVal;}
virtual double param_e_v() const{return mgInfiniteVal;}

virtual MGBox param_range() const;

virtual double param_s_u() const{return -mgInfiniteVal;}
virtual double param_s_v() const{return -mgInfiniteVal;}

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

MGSurface* part(
    const MGBox& uvbox,
    int multiple=0  
)const;

virtual MGCurve* perimeter_curve(int i) const{return 0;};

virtual int perimeter_num() const{return 0;};

virtual MGPosition perimeter_uv(int i,double t) const;

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

MGPosition_list perps(
    const MGPosition& P 
) const;

int planar(
    MGPlane& plane, 
    double& deviation   
) const;

int planar(
    const MGBox& uvbox,
    double tol, 
    int* divideU=0
)const;

int project(
    const MGStraight& sl,   
    MGPvector<MGCurve>& vec_crv_uv, 
    MGPvector<MGCurve>& vec_crv,    
    const MGVector& vec= mgNULL_VEC 
)const;

int project(
    const MGCurve& crv,             
    MGPvector<MGCurve>& vec_crv,    
    const MGVector& vec = mgNULL_VEC
) const;

MGPosition range(const MGPosition& uv) const{return uv;}

MGPSRELATION relation(
    const MGPlane&, 
    MGStraight&     
) const;

MGPSRELATION relation(
    const MGStraight&,  
    MGCSisect&          
) const;

const MGPosition& root_point() const{return m_root_point;}

int sdim() const;

virtual MGPvector<MGCurve> skeleton(int density=1)const;

MGPvector<MGCurve> skeleton_at_knots()const;

void split(
    double param,
    bool is_u,  
    MGPvector<MGFSurface>& surfaces
)const;

virtual MGSURFACE_TYPE type() const{return MGSURFACE_PLANE;}

const MGVector& u_deriv() const{return m_uderiv;}

const MGVector& v_deriv() const{return m_vderiv;}

MGPosition uv(const MGPosition& p) const;

MGVector uv(const MGVector& v) const;

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

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

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

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

protected:
    MGPosition  m_root_point;   
    MGVector    m_uderiv;   
    MGVector    m_vderiv;   

private:

    MGUnit_vector   m_normal;   
    double      m_d;
    mutable MGKnotVector* m_uknotV;
    mutable MGKnotVector* m_vknotV;

virtual MGBox* compute_box() const;

void MGPlane::get_uv_display_vector(
    MGVector& u,
    MGVector& v
)const;

int isect_area_length() const{return 10;};

int isect_guess(
    const MGCurve& crv,     
    const MGPosition& uvi,  
    double ti,          
    MGPosition& uv,     
    double& t           
)const;

int isect_guess_straight(
    const MGStraight& sl,   
    double ti,          
    const MGPosition& uvi,  
    double& t,          
    MGPosition& uvout       
) 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;}

MGCSisect_list isect_withC1LB(const MGLBRep& lb)const;

MGCSisect_list isect_with_noCompoSC(const MGSurfCurve& curve2)const;

int offset_div_num() const;

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

};
 // end of GEO group
#endif