FSurface.h

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

#include <deque>
#include "mg/Default.h"
#include "mg/Unit_vector.h"
#include "mg/Position_list.h"
#include "mg/Pvector.h"
#include "mgGL/VBO.h"

class MGCompositeCurve;
class MGHHisect_vector;
class MGSSisect_list;
class MGCSisect_list;
class MGObject;
class MGCurve;
class MGFace;
class MGShell;
class MGDrawParam;
class mgSysGL;
class mgVBO;
class mgTL2Triangles;

class MG_DLL_DECLR MGFSurface{

friend class MGFace;
friend class MGSurface;
friend class MGCurve;
friend class MGCompositeCurve;
friend class MGTrimmedCurve;
friend class MGStraight;
friend class MGLBRep;
friend class MGSurfCurve;

public:

MGFSurface(){;}

MGFSurface(const MGFSurface& fsurf){;};

virtual ~MGFSurface(){;};


bool operator<(const MGFSurface& f2)const;
bool operator>(const MGFSurface& f2)const{return f2<(*this);};


virtual void arrow(double u,double v, MGPosition data[10])const=0;
virtual void arrow(const MGPosition& uv, MGPosition data[10])const=0;

const MGBox& get_box() const;

virtual const MGBox box_param2()const=0;

virtual MGFSurface* clone_fsurface()const=0;

virtual MGFace* clone_as_face()const=0;

virtual MGPosition closest(
    const MGPosition& point
)const=0;

virtual MGPosition closest_on_boundary(
    const MGStraight& sl
)const=0;

void display_arrowsFS(
    mgSysGL& sgl
    ,int udiv=4
    , int vdiv=4
)const;

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

//Draw 3D curve in world coordinates.
//The object is converted to curve(s) and is drawn.
void drawWireFS_to_highlight(
    mgVBO& vbo,
    double span_length, 
    int line_density    
)const;

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

virtual MGVector eval(
    const MGPosition& uv,
    int ndu=0,
    int ndv=0
)const=0;

void eval_discrete_deviation(
    const MGFSurface& face2,
    std::vector<MGPosition>& uvuvs,
    int npoint=20,      
    double tolerance=0.1
)const;

MGPvector<MGCurve> get_all_boundaries(void)const;

virtual MGFace* get_face_pointer()=0;
virtual const MGFace* get_face_pointer()const=0;

virtual int get_number_of_boundaries()const=0;

virtual MGSurface* get_surface_pointer()=0;
virtual const MGSurface* get_surface_pointer()const=0;

virtual bool has_commonFS(const MGObject& obj2) const=0;

bool hasInnerBoundaryLoop()const{ return number_of_inner_boundaries()>0;};

virtual bool hasLoop(const MGBox& uvbox)const{return false;};

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

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

virtual bool in_range(double u, double v)const=0;
virtual bool in_range(const MGPosition& uv) const=0;

int in_range_with_on(double u, double v)const{return in_range_with_on(MGPosition(u,v));};
virtual int in_range_with_on(const MGPosition& uv)const=0;

virtual MGHHisect_vector isect(const MGShell& shell2) const=0;
virtual MGSSisect_list isect(const MGFSurface& fsurf) const=0;
virtual MGSSisect_list isect(const MGFace& fsurf) const=0;
virtual MGSSisect_list isect(const MGSurface& fsurf) const=0;
virtual MGCSisect_list isect(const MGCurve& curv) const=0;

void intersect12Boundary(
    const MGFSurface& face2,        
    MGPosition_list& uvuv_list  
)const;

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

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

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

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

virtual int isect_guess(
    const MGStraight& sl,   
    const MGPosition& uvi,  
    double ti,          
    MGPosition& uv,     
    double& t           
)const{return isect_guess_straight(sl,ti,uvi,t,uv);};

virtual int isect_guess(
    const MGCompositeCurve& crv,    
    const MGPosition& uvi,  
    double ti,          
    MGPosition& uv,     
    double& t           
)const{return isect_guess_composite(crv,uvi,ti,uv,t);};

virtual int isect_guess_composite(
    const MGCompositeCurve& crv,    
    const MGPosition& uvi,  
    double ti,          
    MGPosition& uv,     
    double& t           
)const;

virtual int isect_guess_straight(
    const MGStraight& sl,   
    double ti,          
    const MGPosition& uvi,  
    double& t,          
    MGPosition& uv      
)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 MGFace* make_face()=0;

virtual void negateFS()=0;

virtual MGVector normal(const MGPosition& uv) const=0;

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

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

virtual const MGObject* object_pointer()const=0;
virtual MGObject* object_pointer()=0;

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

virtual bool on(
    const MGPosition& P,
    MGPosition& uv  
)const=0;

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

virtual std::ostream& outFS(std::ostream& ostrm) const=0;


virtual MGPvector<MGCurve> outer_boundary()const=0;

virtual MGPvector<MGCurve> outer_boundary_param()const=0;

virtual MGPosition param(const MGPosition& P)const=0;

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

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

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

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

virtual MGPosition param_mid()const;

virtual MGBox param_range() const=0;

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

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

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

virtual MGPosition_list perps(const MGPosition& P) const=0;

virtual int perp_one(
    const MGPosition& P, 
    MGPosition& uv      
)const;

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

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

virtual int get_proj_divnum(const MGCurve& crv)const=0;

virtual MGPosition range(const MGPosition& uv)const=0;

//Obtain main parameter lines of the FSurface without boundaries.
//inner_skeleton includes only inner parameter lines without boundaries.
//density indicates how many inner parameter lines are necessary
//for both u and v directions.
MGPvector<MGCurve> inner_skeleton(int density)const;

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

virtual MGPvector<MGCurve> skeleton_at_knots()const;

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


void split(
    const std::vector<const MGCurve*>& splitters,   //splitter world curves.
    const MGVector&  dir,   //splitter projection direction.
                            //If dir.is_null(), normal projection will be performed.
    MGPvector<MGFace>& faces//Result splitted face(s) will be appended.
            //If no splitting was performed, no faces will be appended.
)const;

void split(
    const MGPvector<MGCurve>& splitters,//splitter (u,v) curves.
    MGPvector<MGFace>& faces//Result splitted face(s) will be appended.
            //If no splitting was performed, no faces will be appended.
)const;

void extract(
    const std::vector<const MGCurve*>& trimmers,    
    const MGVector&  dir,   
    const MGPosition& uv,   
    std::auto_ptr<MGFace>& eface
)const;

void shadeFS(
    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=0;

void trim(
    const std::vector<const MGCurve*>& trimmers,    
    const MGVector&  dir,   
    const MGPosition& uv,   
    MGPvector<MGFace>& faces
)const;

virtual MGUnit_vector unit_normal(const MGPosition& uv) const=0;

virtual MGUnit_vector unit_normal(double u,double v) const=0;

protected:

virtual int coef_sdim() const=0;

virtual int isect_area_length() const=0;

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

int isect_direction_with_direction(
    double u,   
    double v,   
    const MGVector& tangent,
    double& du,             
    double& dv      
)const;

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

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

double isect_dt_coef(int n) const;

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;

int isect_start(
    const MGPosition& uvuv_startIn, 
    MGPosition_list& uvuv_list, 
    const MGFSurface& sf2,  
    MGSSisect& ssi,         
    MGPosition_list::iterator& uvuv_id,
    int& m1 
)const;

int isect_start_boundary(
    const MGFSurface& sf2,  
    const MGPosition& uvuv_pre, 
    int kdt,        
    double du,
    double dv,
    int lid1,       
    MGPosition& uvuv_now
)const;

double isect_start_dif(
    const MGNDDArray& tau,  
    const MGLBRep& line,    
    const MGFSurface& sf2   
)const;

int isect_start_incr(
    const MGFSurface& sf2,  
    const MGPosition& uvuv_pre, 
    int kdt,        
    double du,
    double dv,
    int lid1,   
    MGPosition& uvuv_now
)const;

int isect_startPt(
    const MGPosition& uvuv_startIn, 
    MGPosition_list& uvuv_list, 
    const MGFSurface& sf2,  
    double acuRatio,
    MGBPointSeq& point,     
    MGPosition_list::iterator& uvuv_id,
    int& m1 
)const;

int isect_startPlane(
    const MGPosition& uvuvS,
    MGPosition_list& uvuv_list,
    const MGPlane& pl,  
    MGSSisect& ssi,     
    MGPosition_list::iterator& uvuv_id
)const;

int isect_startPlanePt(
    const MGPosition& uvuv_startIn, 
    MGPosition_list& uvuv_list, 
    const MGPlane& pl2, 
    double acuRatio,
    MGBPointSeq& point,     
    MGPosition_list::iterator& uvuv_id
)const;

MGSSisect_list isect_with_surf(
    MGPosition_list& uvuv_list,
    const MGFSurface& srf2  
)const;

MGSSisect_list isect_with_plane(
    MGPosition_list& uvuv_list,
    const MGPlane& pl,  
    const MGFSurface& fsrf2 
)const;

//Obtain the projected curve of a curve onto the surface.
//The direction of the projection is along the vector vec if the vec is not
//NULL, and normal to the surface if the vec is NULL.
//Output of 'project' is two kind of curves:
//one is general world coordinate curves('vec_crv'), and the other is (u,v) curves of
//the parameter space of the surfaces(vec_crv_uv).
//vec_crv_uv.size() is equal to vec_crv.size(). Let the size be n, then
// (vec_crv_uv[i], vec_crv[i]) is one pair for 0<=i<n.
//戻り値：
//      投影曲線の数:       投影曲線が求まった
//      0:          投影曲線が求まらなかった
//      -1:         内部処理エラー
//      -2:         収束処理エラー（収束しなかった）
int projectbyApproximateAsLBRep(
    const MGCurve& crv,
    MGPvector<MGCurve>& vec_crv_uv, 
        //Projected curve(surface parameter (u,v) representation) will be appended.
    MGPvector<MGCurve>& vec_crv,
        //Projected curve(world coordinate(x,y,z) representation) will be appended.
    const MGVector& vec
)const;

//Obtain the projected curve of a curve onto the surface.
//The direction of the projection is along the vector vec if the vec is not
//NULL, and normal to the surface if the vec is NULL.
//Output of 'project' is two kind of curves:
//one is general world coordinate curves('vec_crv'), and the other is (u,v) curves of
//the parameter space of the surfaces(vec_crv_uv).
//vec_crv_uv.size() is equal to vec_crv.size(). Let the size be n, then
// (vec_crv_uv[i], vec_crv[i]) is one pair for 0<=i<n.
//戻り値：
//      投影曲線の数:       投影曲線が求まった
//      0:          投影曲線が求まらなかった
//      -1:         内部処理エラー
//      -2:         収束処理エラー（収束しなかった）
int projectbyRemovKnots(
    const MGCurve& crv,
    MGPvector<MGCurve>& vec_crv_uv, 
        //Projected curve(surface parameter (u,v) representation) will be appended.
    MGPvector<MGCurve>& vec_crv,
        //Projected curve(world coordinate(x,y,z) representation) will be appended.
    const MGVector& vec
)const;

int projVector(
    const MGCurve& crv,
    MGPvector<MGCurve>& vec_crv_uv,
    MGPvector<MGCurve>& vec_crv,
    const MGVector& vec
) const;

int projNormal(
    const MGCurve& crv,
    MGPvector<MGCurve>& vec_crv_uv,
    MGPvector<MGCurve>& vec_crv
)const;

private:

virtual bool in_range_face(const MGPosition& uv)const{return true;};

bool uvuvE_is_a_midpoint(
    const MGFSurface& f2,
    int m1,     
    const MGSSisect& ssi, 
    const MGPosition& uvuvE
)const;

void projNormalProc(
    const MGCurve& crv, 
    MGPvector<MGLBRep>& crv_xyzuv_vector
)const;

int projVectorProc(
    const MGCurve& crv,
    MGPvector<MGLBRep>& vec_crv,    
    const MGVector& vec
) const;

};

typedef std::pair<const MGBox*,int> mgBCPair;
//Private class to sort boxes by their distances from a position.
class MG_DLL_DECLR MGBox2PositionCompare{
public:
    MGBox2PositionCompare(const MGPosition& P):m_position(P){;};
    bool operator()(const MGBox* b1, const MGBox* b2)const;
    bool operator()(const mgBCPair& b1, const mgBCPair& b2)const;
    const MGPosition& m_position;
};
 // end of MGObjectRelated group
#endif