Face.h

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

#include <vector>
#include "mg/Default.h"
#include "mg/drawParam.h"
#include "mg/BPointSeq.h"
#include "mg/Unit_vector.h"
#include "mg/Position.h"
#include "mg/Curve.h"
#include "mg/Surface.h"
#include "mg/FSurface.h"
#include "mg/Pvector.h"

#include "topo/Cell.h"
#include "topo/LEPoint.h"
#include "topo/FOuterCurve.h"

class MGSSisect_list;
class MGCSisect_list;
class MGPosition_list;
class MGLBRep;
class MGCellNB;
class MGLoop;
class MGLEPoint;
class MGShell;
class MGFSurface;
class MGHHisect_vector;

//
//Define MGFace Class.

typedef std::vector<const MGLBRep*> SHLL_COM_EDGES;//Used for tessellatiion(shade).
            //Represents  n polylines of n edges of a loop.
            //SHLL_COM_EDGES[j] is j-th edge's polyline of a loop.
            //Generally a face has multiple SHLL_COM_EDGES.


class MG_DLL_DECLR MGFace: public MGCell, public MGFSurface{

public:

MG_DLL_DECLR friend MGFace operator* (double s, const MGFace& face);


MGFace():MGCell(){;}

MGFace(const MGFace& face);

MGFace(const MGFace& face, bool copy_boundary, bool no_binder=false);

MGFace(
    MGSurface* geo,
    std::vector<MGBoundary*>& boundaries,
    MGCell* binder
);

MGFace(const MGSurface& surf)
:MGCell(surf),m_box_param(surf.param_range())
{;}

MGFace(const MGFSurface& surf);

MGFace(MGSurface* surf)
:MGCell(surf),m_box_param(surf->param_range())
{;}

MGFace(const MGSurface& surf,
    const std::vector<MGBoundary*>& boundaries);
MGFace(MGSurface* surf,
    const std::vector<MGBoundary*>& boundaries);


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

MGFace operator+ (const MGVector& v) const;

MGFace operator- (const MGVector& v) const;

MGFace operator* (double s) const;

MGFace operator* (const MGMatrix& mat) const;

MGFace operator* (const MGTransf& tr) const;

MGFace operator/ (double s) const{return (*this)*(1./s);};

bool operator<(const MGFace& gel2)const{return is_less_than(gel2);};
bool operator<(const MGGel& gel2)const;

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

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

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


void add_boundary(MGLoop* nloop);

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

int append_boundary(MGBoundary* bound);

MGFace* binder_face() const;

MGPvector<MGCurve> face_boundaries()const;

const MGBox& box_param() const;

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

std::auto_ptr<MGLoop> build_loop(
    const MGCurve& crv  
)const;

MGFace* clone() const;
MGFace* clone_without_boundaries() const;

MGFSurface* clone_fsurface()const{return clone();};

MGFace* clone_as_face()const{return clone();};

MGFace* clone_binder(const MGCellBase& f) const;

MGPosition closest(const MGPosition& point) const;
    
MGPosition closest_on_boundary(const MGStraight& sl) const;

void display_arrows(mgSysGL& sgl)const;
void display_control_polygon(mgSysGL& sgl)const;

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

void draw3DVertex(mgVBO& vbo)const;

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 equal_direction(
    const MGPvector<MGCurve>& wcurves,
    const MGPvector<MGCurve>& pcurves,
    int i
)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;

void extract_loops(std::vector<const MGLoop*>& loops)const;

void extract_sub_face(
    const MGPvector<MGLoop>& networks,
    const MGPosition& uv,
    std::auto_ptr<MGFace>& face
)const;

MGFace* face(){return this;};
const MGFace* face()const{return this;};

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

std::vector<const MGLoop*> get_inner_boundary_loops(const MGBox& uvbox) const;

//bool displayList_is_made(MGCL::VIEWMODE vmode)const;

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

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

int get_number_of_boundaries()const{return number_of_boundaries();};

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

bool hasLoop(const MGBox& uvbox)const;

bool hasInactiveLoop()const;

bool hasOuterBoundaryLoop()const;

bool hasPerimeterBoundaryLoop() const;

MGPvector<MGCurve> inner_boundary(int i)const;

MGPvector<MGCurve> inner_boundary_param(int i)const;

long identify_type()const;

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

int in_range_with_on(const MGPosition& uv)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;

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

double knot_u(int i) const{return surface()->knot_u(i);};

double knot_v(int i) const{return surface()->knot_v(i);};

const MGKnotVector& knot_vector_u()const{return surface()->knot_vector_u();};
MGKnotVector& knot_vector_u(){return surface()->knot_vector_u();};

const MGKnotVector& knot_vector_v()const{return surface()->knot_vector_v();};
MGKnotVector& knot_vector_v(){return surface()->knot_vector_v();};

MGLoop* loop(int i);
MGLoop* loop(iterator i);
const MGLoop* loop(int i)const;
const MGLoop* loop(const_iterator i)const;

MGCellNB* make_binder() const;

MGFace* make_face(){return this;};

void make_outer_boundary();

int manifold_dimension() const{return 2;};

const MGFace* member_partner_face(int i)const;

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

MGVector normal(const MGPosition& uv) const
{   return surface()->normal(uv.ref(0), uv.ref(1));};

MGVector normal(double u,double v) const
{   return surface()->normal(u, v);};

bool no_outer_boundaries()const;

int number_of_inner_boundaries()const
{   int dummy; return number_of_inner_boundaries(dummy);}

int number_of_inner_boundaries(int& i)const;

int number_of_loops()const;

int number_of_perimeter_boundaries()const;

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

MGFace offset(double distance, int& error)const;

int offset(double distance, MGPvector<MGFace>& vecOfsFace)const;

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

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

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

MGPvector<MGCurve> outer_boundary()const;

MGPvector<MGCurve> outer_boundary_param()const;

MGPosition param(const MGPosition& P)const;

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

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

double param_e_u()const;
double param_e_v()const;

double param_s_u()const;
double param_s_v()const;

MGShell* parent_shell();
const MGShell* parent_shell()const;

MGPvector<MGCurve> PBloop_curves() const;

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

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

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

MGPosition_list perps(const MGPosition& P) const;

MGPosition pick_closest(const MGStraight& sl)const;

MGPosition range(const MGPosition& uv) const;

std::auto_ptr<MGFace> rebuild(
    int how_rebuild=1,
    int parameter_normalization=2,
    double tol=-1.,
    int* order=0, 
    double* range=0
)const;

void remove_inactive_loops();

void rotateBoundary(const MGMatrix& mat);

void scalePolar(
    double angleBase,   
    double angle1,      
    double angle2
);

void shrink_base_surface_to_knot(
    int multiple=0  
);

void sort_boundaries();

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

void split(
    const MGPvector<MGLoop>& networks,
    MGPvector<MGFace>& faces
)const;

MGSurface* surface();
const MGSurface* surface() const;

int trim_projection(
    const MGCurve& crv,     
    const MGVector& direction=mgNULL_VEC
);

int trim(
    const MGCurve& pcrv 
);

int trim(const MGLoop& new_loop_in);

void trim(
    const MGPvector<MGLoop>& networks,
    const MGPosition& uv,
    MGPvector<MGFace>& faces
)const;

MGUnit_vector unit_normal(const MGPosition& uv) const
{   return surface()->unit_normal(uv.ref(0), uv.ref(1));};

MGUnit_vector unit_normal(double u,double v) const
{   return surface()->unit_normal(u, v);};

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

protected:

void WriteMembers(MGOfstream& buf) const;

void ReadMembers(MGIfstream& buf);

private:

    mutable MGBox m_box_param;

MGFace* clone(MGCellMap& cmap)const;

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

int coef_sdim() const{return surface()->coef_sdim();};

void compute_box() const;

void compute_box_param() const;

void copy_binder(const MGFace& faceOriginal);

int get_proj_divnum(const MGCurve& crv)const;

void set_box_as_null()const;

int inside_inner_boundary(const MGPosition& uv, int& id)const;

int inside_outer_boundary(
    const MGPosition& uv
)const;

MGSSisect_list intersect(const MGFSurface& face2)const;

MGPosition_list intersectInner(
    const MGFace& f2        
) const;

MGPosition_list intersectInner(
    const MGSurface& sf2        
) const;

int isect_area_length() const{return surface()->isect_area_length();};

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

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

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

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

int isect_lpcurves(
    const MGFSurface& face2,        
    const MGLoop& lp,               
    MGPosition_list& uvuv_list, 
    int id1         
)const;

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

MGSSisect_list isectEP(
    MGPosition_list& uvuv_list, 
    const MGFSurface& fsrf2     
) const;

std::vector<double> isect1D_with_boundaries(
    double x,                           
    int kcod                    
)const;

MGGeometry* make_binder_extent() const;

void make_extent() const;

std::vector<MGFOuterCurve> outer_curve() const;

std::vector<MGInterval> perimeter_param_range(int i) const;

MGPosition range_check_inner_boundary(const MGPosition& uv) const;

void remove_outside_param(MGPosition_list& uvs)const;

void shade(
    mgVBO& vbo,
    const MGDrawParam& para,
    std::vector<SHLL_COM_EDGES>* polylines,
    mgVBO::ELEMENT_TARGET target=mgVBO::SHADING
)const;

void sl_edge_append(
    MGLoop*& lp,            
    int id,             
    const MGPosition& uv2,  
    const MGPosition& uv1,  
    double err_sqr      
);

void getTrimCrv(
    double uerror, double verror,
    const MGBox& box,   
    MGPvector<MGCurve>& vecCrv  
) const;

friend class MGShell;
friend class MGSurface;

};


union MG_DLL_DECLR mgEdgeP{const MGEdge* pointer; double doubleV;};


MG_DLL_DECLR MGPosition MGClosest_to_curves(
    const MGPosition& uv,               
    const MGPvector<MGCurve>& curves    
);
 // end of TOPO group
#endif