Surface.h

/********************************************************************/
/* Copyright (c) 2015 DG Technologies Inc. and Yuzi Mizuno          */
/* All rights reserved.                                             */
/********************************************************************/
#ifndef _MGSurface_HH_
#define _MGSurface_HH_
#include <memory>
#include <vector>
#include "mg/Default.h"
#include "mg/Geometry.h"
#include "mg/Position_list.h"
#include "mg/SSisect_list.h"
#include "mg/FSurface.h"
#include "mg/Pvector.h"

// MGSurface.h

class MGDrawParam;
class MGBPointSeq;
class MGPosition;
class MGVector;
class MGTransf;
class MGUnit_vector;
class MGCurve;
class MGEllipse;
class MGStraight;
class MGCompositeCurve;
class MGSurfCurve;
class MGLBRep;
class MGSPointSeq;
class MGCSisect_list;
class MGPlane;
class MGSBRep;
class MGSSisect;
class MGSSisect_list;
class MGPosition_list;
class MGIfstream;
class MGOfstream;
class MGRLBRep;
class MGCParam_list;
class MGNDDArray;
class MGFace;
class MGShell;
class MGHHisect_vector;
class mgTL2Triangles;


class MG_DLL_DECLR MGSurface: public MGGeometry, public MGFSurface{

public:


MGSurface(void);

MGSurface(const MGSurface& srf):MGGeometry(srf){;};

virtual ~MGSurface();


virtual MGSurface& operator=(const MGSurface& gel2){MGGeometry::operator=(gel2);return *this;};

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

virtual bool operator==(const MGGel& gel2)const=0;
virtual bool operator<(const MGGel& gel2)const=0;



std::auto_ptr<MGSBRep> approximate_as_SBRep(
    int parameter_normalization=2,
    double tol=-1., 
    int* order=0
)const;

double average_chord_length(
    int is_u,
    const double para[3],   
    const MGNDDArray& tau   
)const;


void arrow(double u,double v, MGPosition data[10])const;
void arrow(const MGPosition& uv, MGPosition data[10])const{
    arrow(uv[0],uv[1],data);
}

void arrow(const MGBox& box, double u,double v, MGPosition data[10])const;

virtual int bdim_u() const {return 1;}

virtual int bdim_v() const {return 1;}


virtual MGBox box_limitted(
    const MGBox& uvrange    
) const=0;

MGBox box_param() const;

const MGBox box_param2() const{return box_param();};

virtual MGPosition center() const;

virtual MGPosition center_param() const;

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

virtual MGSurface& change_range(
    int is_u,               
    double t1,              
    double t2               
)=0;



virtual int coef_sdim() const{return sdim();};

virtual MGFSurface* clone_fsurface()const{return copy_surface();};


MGFace* clone_as_face()const;

virtual MGPosition closest(const MGPosition& point) const;



virtual MGPosition closest_on_perimeter(const MGPosition& point)const;
virtual MGPosition closest_on_perimeter(const MGStraight& sl)const;


virtual MGPosition closest_on_boundary(const MGStraight& sl) const{
    return closest_on_perimeter(sl);
}



virtual MGSurface* clone() const=0;



void compute_sample_point(
    double u0,
    double u1,
    double v0,
    double v1,
    MGPosition Pn[9],   
    MGPosition& center, 
    MGUnit_vector& normal,
    MGVector* Nn_in=0       
)const;



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



void curvatures(
    const MGPosition& uv, double value[4], MGUnit_vector& N) const;
void curvatures(
    double u, double v, double value[4], MGUnit_vector& N) const;

MGUnit_vector direction(const MGPosition& param) const;



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



virtual MGSurface* copy_surface() const {return clone();}

virtual void display_arrows(mgSysGL& sgl)const;

virtual int divide_multi_knot(
    MGPvector<MGSurface>& srfl      
)const;



int equal_direction(
    const MGCurve& param_curve, 
    const MGCurve& world_curve  
)const;

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

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



virtual void MGSurface::eval_spoint(
    const MGNDDArray&   utau,   
    const MGNDDArray&   vtau,   
    MGSPointSeq&        spoint  
)const;


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


virtual void eval_all(
    const MGPosition& uv,   
    MGPosition& f,          
    MGVector&   fu,         
    MGVector&   fv,         
    MGVector&   fuv,        
    MGVector&   fuu,        
    MGVector&   fvv         
    )const;

double eval_gap(
    const MGCurve& curve, 
    int            iperi, 
    MGPosition&    uv     
)const;


double eval_gap(
    const MGCurve* curve[4], 
    MGPosition&    uv       
)const;

MGVector evaluate(
const MGPosition& t,
const int* nderiv   
)const;

virtual MGSurface& exchange_uv()=0;


virtual MGSurface& extend(
    int perimeter,  
    double param,   
    double length,  
    double dk=0.  
){return *this;};

const MGFSurface* fsurface()const{return this;};
MGFSurface* fsurface(){return this;};


void fundamentals(
    const MGPosition&uv,    
    double Q[6],            
    MGUnit_vector& UN       
)const;
void fundamentals(
    double u,   
    double v,   
    double Q[6],            
    MGUnit_vector& N        
)const;


void get_approximate_plane(
    double u0   
    ,double u1, 
    double v0,
    double v1,
    MGPlane& plane,     
    double* width=0,    
    double* height=0    
)const;

MGFace* get_face_pointer(){return (MGFace*)0;};
const MGFace* get_face_pointer()const{return (const MGFace*)0;};


int getPerimeterCommon(
    const MGCurve& crv,
    std::vector<double> pspan[2],
    int peri_num[2] 
)const;


MGSurface* get_surface_pointer(){return this;};
const MGSurface* get_surface_pointer()const{return this;};

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


MGCurve* get_parameterCurve(const MGCurve& wcrv)const;

void get_new_surface_knots(
    int parameter_normalization,
        //Indicates how the parameter normalization be done:
        //=0: no surface parameter normalization.
        //=1: normalize to u_range=(0., 1.), and v_range=(0.,1.);
        //=2: normalize to make the average length of the 1st derivative along u and v 
        //    of the base surface is as equal to 1. as possible.
    MGKnotVector& uknots,//normalized MGKnotVector will be returned.
    MGKnotVector& vknots,
    double* Oldparameter=0//Old parameterization will be returned. [.]=(us, ue, vs,ve).
)const;



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


bool on_a_perimeter2(
    int is_u,   
    double& x,  
    int& perim_num
)const;

virtual bool has_commonFS(const MGObject& obj2) const{return has_common(obj2);};

virtual void shade(
    mgVBO& vbo,
    const MGDrawParam& para,
    mgVBO::ELEMENT_TARGET target=mgVBO::SHADING
)const;

virtual void triangulate(
    const MGDrawParam& para,
    MGCL::TL_DATA_KIND dkind,
    std::vector<mgTL2Triangles>& trisVec
)const;


bool test_and_get_approximate_plane(
    double u0,
    double u1,
    double v0,
    double v1,
    double surface_tol, 
    double angle,       
    MGPlane& plane,     
    double& width,  
    double& height  
)const;

virtual long identify_type()const=0;

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


int in_range_with_on(const MGPosition& uv)const;


bool is_flat_and_small(
    const MGBox& bx,//Paramete range of the surface.
    double surftol, //Input the maximum deviation allowed from a plane.
    double melen2,  //square of maximum edge length allowed of the surface edge.
    bool& direction//true: u-direction is more non flat or longer.
                // false: v-direction is more non flat or longer.
)const;


virtual MGPvector<MGCurve> inner_boundary(int i)const;


virtual MGPvector<MGCurve> inner_boundary_param(int i)const;


MGCSisect_list intersect(const MGCurve& curve) const;

MGCSisect_list intersect(const MGEllipse& el) const;


MGisects intersection(const MGObject& obj2)const;
MGisects intersection(const MGCurve& obj2)const;
MGisects intersection(const MGFSurface& obj2)const;
MGisects intersection(const MGSurface& obj2)const;
MGisects intersection(const MGFace& obj2)const;
MGisects intersection(const MGShell& obj2)const;


virtual MGSSisect_list isect(const MGSurface& srf2)const=0;
virtual MGSSisect_list isect(const MGPlane& srf2)const=0;
virtual MGSSisect_list isect(const MGSphere& srf2)const=0;
virtual MGSSisect_list isect(const MGCylinder& srf2)const=0;
virtual MGSSisect_list isect(const MGSBRep& srf2)const=0;
virtual MGSSisect_list isect(const MGRSBRep& srf2)const=0;
virtual MGSSisect_list isect(const MGBSumSurf& srf2)const=0;
MGSSisect_list isect(const MGFace& f) const;
MGSSisect_list isect(const MGFSurface& fsurf) const;
MGHHisect_vector isect(const MGShell& shl) const;


virtual MGCSisect_list isect(const MGCurve& curve) const=0;

virtual int isect_order() const=0;

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

virtual int isect_boundary(
    const MGFSurface& face2,
    MGPosition_list& uvuvs,
    int id1=0
)const{return isect_outcurves(face2,uvuvs,id1);};

virtual int isect_incurves(
    const MGFSurface& face2,
    int iid,    
    MGPosition_list& uvuv_list, 
    int id1         
)const{return 0;};

int isect_outcurves(
    const MGFSurface& face2,
    MGPosition_list& uvuv_list, 
    int id1         
)const;

virtual double knot_u(int i) const{return 0.0;}

virtual double knot_v(int i) const{return 0.0;}

virtual const MGKnotVector& knot_vector_u() const=0;
virtual MGKnotVector& knot_vector_u()=0;

virtual const MGKnotVector& knot_vector_v() const=0;
virtual MGKnotVector& knot_vector_v()=0;



virtual bool less_than(
    int i,  
    const MGPosition& uv1,
    const MGPosition& uv2
)const;

MGFace* make_face();

int manifold_dimension() const{return 2;};



virtual void negate(){ exchange_uv();};
virtual void negateFS(){negate();};

virtual void negate(
    int is_u    
)=0;


void negate_transform(MGGeometry& boundary)const;

virtual MGVector normal(double u, double v) const;

virtual MGVector normal(const MGPosition& uv) const;

virtual const MGObject* object_pointer()const{return object();};
virtual MGObject* object_pointer(){return object();};



virtual MGPvector<MGSurface> offset(
    double ofs_value,   
    int& error          
)const;



int offset_fs(
    double distance,
    MGPvector<MGFSurface>& vecOfsFSurface
)const;


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


virtual bool on(
    const MGPosition& P, 
    MGPosition&          
)const;



virtual bool on_the_perimeter(
    int perim_num,  
    double u,   
    double v    
)const;
    

virtual bool on_perimeter(
    const MGCurve& uvcurve, 
    int& perim_num
)const;

virtual int order_u() const{return 1;}  

virtual int order_v() const{return 1;}  

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

std::ostream& outFS(std::ostream& ostrm) const{return out(ostrm);};


virtual MGPvector<MGCurve> outer_boundary()const;


virtual MGPvector<MGCurve> outer_boundary_param()const;


virtual MGPosition param(
    const MGPosition &  
)const;


double param_of_pcurve(
    double tw,          
    const MGCurve& wcurve,
    const MGCurve& pcurve,
    const double* guess=0
)const;



MGPosition parameter(
    const MGPosition& P 
)const;


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


MGPvector<MGCurve> parameter_curves(
    int is_u,       
    double x    
)const;

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

virtual double param_e_u() const=0;
virtual double param_e_v() const=0;


MGPosition param_mid()const{return center_param();};

virtual MGBox param_range() const;

MGBox parameter_range() const;

virtual double param_s_u() const=0;
virtual double param_s_v() const=0;

virtual double param_span() const;


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


virtual MGCurve* perimeter_curve(int i) const;

virtual int perimeter_num() const=0;

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


virtual int perp_guess(
const MGPosition& uv0,
const MGPosition& uv1,
const MGPosition& P,        
const MGPosition& uvguess,  
MGPosition& uv              
)const;


bool perp_guess(
    const MGPosition& P,        
    const MGPosition& uvguess,  
    MGPosition& uv              
)const;


virtual int perp_guess(
const MGPosition& uv0,
const MGPosition& uv1,
const MGCurve& curve,
double t0,
double t1,
const MGPosition& tuvg,
MGPosition& tuv 
)const;

virtual int perp_guess(
const MGPosition& uv0,
const MGPosition& uv1,
const MGCompositeCurve& crv,
double t0,
double t1,
const MGPosition& tuvg, 
MGPosition& tuv 
)const;


virtual bool perp_guess(
    const MGCurve& curve,   
    const MGPosition& uvguess,  
    double tguess,  
    MGPosition& uv, 
    double& t       
)const;


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

virtual MGPosition_list perps(
    const MGPosition& P             
)const;


MGPosition pick_closest(const MGStraight& sl)const;


virtual MGPosition range(const MGPosition&) const;


virtual void remove_knot();


virtual MGSurface& rotate_self(
    const MGVector& vec,
    double angle,
    const MGPosition& origin=mgORIGIN
);

virtual int sdim() const=0;


virtual void shrink_to_knot(
    const MGBox& uvbx,
    int multiple=0  
){;};

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


const MGSurface* surf()const{return this;};
MGSurface* surf(){return this;};


virtual MGSURFACE_TYPE type() const=0;

MGUnit_vector unit_normal(const MGPosition& uv) const;

MGUnit_vector unit_normal(double u,double v) const;

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

protected:

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

MGSSisect_list intersect(const MGSurface& srf2) const;

MGSSisect_list intersectPl(const MGPlane& srf2) const;

MGPosition_list intersectInner(
    const MGSurface& sf2        
)const;

virtual int intersect_dnum_u() const=0;
virtual int intersect_dnum_v() const=0;

virtual int isect_area_length() const{return (bdim_u()+bdim_v())*2;};

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

int isect_div_id_max()const;

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

virtual void isect_inner_dt(
    int n,      
    const MGPosition& uvnow,
    double& du, 
    double& dv, 
    int& kdt,   
    double acuRatio=1.  
)const{MGFSurface::isect_inner_dt(n,uvnow,du,dv,kdt,acuRatio);};

virtual MGCSisect_list isect_withC1LB(const MGLBRep& lb)const;

virtual MGCSisect_list isect_with_noCompoSC(const MGSurfCurve& scrv)const;

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

virtual MGSBRep* surf1D(const MGPlane& pl)const=0;

virtual void ReadMembers(MGIfstream& buf);

virtual void WriteMembers(MGOfstream& buf) const;

private:

virtual MGBox* compute_box() const=0;

int get_proj_divnum(const MGCurve& crv)const;

int perp_guess_general(
    const MGPosition& uv0,
    const MGPosition& uv1,
    const MGCurve& curve,
    double t0, double t1,
    const MGPosition& tuvg,
    MGPosition& tuv 
) const;

void offset_calc_knot_vec(
    MGKnotVector& knot_vec_u,           
    MGKnotVector& knot_vec_v,           
    MGNDDArray& data_point_u,           
    MGNDDArray& data_point_v    
) const;

int offset_check_curva(
    double ofs_value
)const; 

int offset_check_curva_one(
    double ofs_value    
)const;

virtual int offset_div_num() const;

int offset_div_num_one(
    const MGBox& param_range) const;

//Get nearest (u,v) that is not degenerated point.
//That is, nearest point |fu*fv|>MGTolerance::mach_zero().
void nearest_non_degenerated(double& u,double& v) const;

friend class MGStraight;
friend class MGLBRep;
friend class MGSurfCurve;
friend class MGSBRep;
friend class MGPlane;
friend class MGCylinder;
friend class MGFSurface;
friend class MGFace;
friend class MGBSumSurf;

MG_DLL_DECLR friend int isect_start_tan(
    const MGFSurface& sf1,
    const MGFSurface& sf2,
    const MGLBRep& lineb,
    MGVector* Tse[2]    
);

MG_DLL_DECLR friend void isect_start_adjustSE(
    int ngtan,  
    MGNDDArray& tau,    
    MGBPointSeq& point, 
    MGLBRep& lineb, 
    MGVector* tan[2]
);

};

namespace MGCL{

MG_DLL_DECLR std::auto_ptr<MGSurface> createSurfaceFromRibs(
    const MGPvector<MGCurve>& curves,   
    bool direction_adjustment=true  
);
MG_DLL_DECLR std::auto_ptr<MGSurface> createSurfaceFromRibs(
    const std::vector<const MGCurve*>& curves,
    bool direction_adjustment=true
);

MG_DLL_DECLR std::auto_ptr<MGSurface> create_ruled_surface(
    const MGCurve& cross1,    
    const MGCurve& cross2,     
    bool direction_adjustment=true
);



MG_DLL_DECLR std::auto_ptr<MGRSBRep> create_revolved_surface(
    const MGCurve& curve,     
    const MGStraight& axis,   
    double angle = mgDBLPAI   
);



int SurfCurve_equal_direction(
    const MGCurve& pline,   
    const MGCurve& world_curve  
);


double get_length(
    MGPosition Pn[9],   //9 sample points.
                    //Pn[.]={(umin, vmin), (umid, vmin), (umax,vmin),
                    //       (umin, vmid), (umid, vmid), (umax,vmid),
                    //       (umin, vmax), (umid, vmax), (umax,vmax),
    bool& direction //which direction was longer is returned.
                    //True: when u direction is longer than v direction.
);

}
 // end of GEO group
#endif